@navios/di 0.3.0 → 0.4.0

package/lib/index.js

@@ -33,18 +33,18 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
 };
 
 // src/enums/injectable-scope.enum.mts
-var InjectableScope = /* @__PURE__ */ ((InjectableScope4) => {
-  InjectableScope4["Singleton"] = "Singleton";
-  InjectableScope4["Transient"] = "Transient";
-  InjectableScope4["Request"] = "Request";
-  return InjectableScope4;
+var InjectableScope = /* @__PURE__ */ ((InjectableScope5) => {
+  InjectableScope5["Singleton"] = "Singleton";
+  InjectableScope5["Transient"] = "Transient";
+  InjectableScope5["Request"] = "Request";
+  return InjectableScope5;
 })(InjectableScope || {});
 
 // src/enums/injectable-type.enum.mts
-var InjectableType = /* @__PURE__ */ ((InjectableType4) => {
-  InjectableType4["Class"] = "Class";
-  InjectableType4["Factory"] = "Factory";
-  return InjectableType4;
+var InjectableType = /* @__PURE__ */ ((InjectableType5) => {
+  InjectableType5["Class"] = "Class";
+  InjectableType5["Factory"] = "Factory";
+  return InjectableType5;
 })(InjectableType || {});
 
 // src/injection-token.mts
@@ -439,6 +439,132 @@ function createDeferred() {
   return new Deferred();
 }
 
+// src/service-locator-instance-holder.mts
+var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus3) => {
+  ServiceLocatorInstanceHolderStatus3["Created"] = "created";
+  ServiceLocatorInstanceHolderStatus3["Creating"] = "creating";
+  ServiceLocatorInstanceHolderStatus3["Destroying"] = "destroying";
+  ServiceLocatorInstanceHolderStatus3["Error"] = "error";
+  return ServiceLocatorInstanceHolderStatus3;
+})(ServiceLocatorInstanceHolderStatus || {});
+
+// src/base-instance-holder-manager.mts
+var BaseInstanceHolderManager = class {
+  constructor(logger = null) {
+    this.logger = logger;
+    this._holders = /* @__PURE__ */ new Map();
+  }
+  _holders;
+  /**
+   * Protected getter for accessing the holders map from subclasses.
+   */
+  get holders() {
+    return this._holders;
+  }
+  /**
+   * 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) {
+    return this._holders.delete(name);
+  }
+  /**
+   * 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) {
+    return new Map(
+      [...this._holders].filter(([key, value]) => predicate(value, key))
+    );
+  }
+  /**
+   * Clears all holders from this manager.
+   */
+  clear() {
+    this._holders.clear();
+  }
+  /**
+   * Gets the number of holders currently managed.
+   */
+  size() {
+    return this._holders.size;
+  }
+  /**
+   * 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
+   * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
+   * @returns A tuple containing the deferred promise and the holder
+   */
+  createCreatingHolder(name, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
+    const deferred = createDeferred();
+    const holder = {
+      status: "creating" /* Creating */,
+      name,
+      instance: null,
+      creationPromise: deferred.promise,
+      destroyPromise: null,
+      type,
+      scope,
+      deps,
+      destroyListeners: [],
+      createdAt: Date.now(),
+      ttl
+    };
+    return [deferred, holder];
+  }
+  /**
+   * 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
+   * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
+   * @returns The created holder
+   */
+  createCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
+    const holder = {
+      status: "created" /* Created */,
+      name,
+      instance,
+      creationPromise: null,
+      destroyPromise: null,
+      type,
+      scope,
+      deps,
+      destroyListeners: [],
+      createdAt: Date.now(),
+      ttl
+    };
+    return holder;
+  }
+  /**
+   * Gets all holder names currently managed.
+   */
+  getAllNames() {
+    return Array.from(this._holders.keys());
+  }
+  /**
+   * Gets all holders currently managed.
+   */
+  getAllHolders() {
+    return Array.from(this._holders.values());
+  }
+  /**
+   * Checks if this manager has any holders.
+   */
+  isEmpty() {
+    return this._holders.size === 0;
+  }
+};
+
 // src/event-emitter.mts
 var _EventEmitter_decorators, _init;
 _EventEmitter_decorators = [Injectable({ scope: "Transient" /* Transient */ })];
@@ -620,8 +746,9 @@ var ServiceInstantiator = class {
 };
 
 // src/request-context-holder.mts
-var DefaultRequestContextHolder = class {
+var DefaultRequestContextHolder = class extends BaseInstanceHolderManager {
   constructor(requestId, priority = 100, initialMetadata) {
+    super(null);
     this.requestId = requestId;
     this.priority = priority;
     if (initialMetadata) {
@@ -630,26 +757,53 @@ var DefaultRequestContextHolder = class {
       });
     }
   }
-  instances = /* @__PURE__ */ new Map();
-  holders = /* @__PURE__ */ new Map();
   metadata = /* @__PURE__ */ new Map();
   createdAt = Date.now();
-  addInstance(instanceName, instance, holder) {
-    this.instances.set(instanceName, instance);
-    this.holders.set(instanceName, holder);
+  /**
+   * Public getter for holders to maintain interface compatibility.
+   */
+  get holders() {
+    return this._holders;
   }
-  getInstance(instanceName) {
-    return this.instances.get(instanceName);
+  /**
+   * Gets a holder by name. For RequestContextHolder, this is a simple lookup.
+   */
+  get(name) {
+    return this._holders.get(name);
   }
-  getHolder(instanceName) {
-    return this.holders.get(instanceName);
+  /**
+   * Sets a holder by name.
+   */
+  set(name, holder) {
+    this._holders.set(name, holder);
   }
-  hasInstance(instanceName) {
-    return this.instances.has(instanceName);
+  /**
+   * Checks if a holder exists by name.
+   */
+  has(name) {
+    return this._holders.has(name);
+  }
+  addInstance(instanceName, instance, holder) {
+    if (instanceName instanceof InjectionToken) {
+      const name = instanceName.toString();
+      const createdHolder = this.createCreatedHolder(
+        name,
+        instance,
+        "Class" /* Class */,
+        "Singleton" /* Singleton */,
+        /* @__PURE__ */ new Set(),
+        Infinity
+      );
+      this._holders.set(name, createdHolder);
+    } else {
+      if (!holder) {
+        throw new Error("Holder is required when adding an instance by name");
+      }
+      this._holders.set(instanceName, holder);
+    }
   }
   clear() {
-    this.instances.clear();
-    this.holders.clear();
+    super.clear();
     this.metadata.clear();
   }
   getMetadata(key) {
@@ -714,23 +868,13 @@ var ServiceLocatorEventBus = class {
   }
 };
 
-// src/service-locator-instance-holder.mts
-var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus2) => {
-  ServiceLocatorInstanceHolderStatus2["Created"] = "created";
-  ServiceLocatorInstanceHolderStatus2["Creating"] = "creating";
-  ServiceLocatorInstanceHolderStatus2["Destroying"] = "destroying";
-  ServiceLocatorInstanceHolderStatus2["Error"] = "error";
-  return ServiceLocatorInstanceHolderStatus2;
-})(ServiceLocatorInstanceHolderStatus || {});
-
 // src/service-locator-manager.mts
-var ServiceLocatorManager = class {
+var ServiceLocatorManager = class extends BaseInstanceHolderManager {
   constructor(logger = null) {
-    this.logger = logger;
+    super(logger);
   }
-  instancesHolders = /* @__PURE__ */ new Map();
   get(name) {
-    const holder = this.instancesHolders.get(name);
+    const holder = this._holders.get(name);
     if (holder) {
       if (holder.ttl !== Infinity) {
         const now = Date.now();
@@ -760,7 +904,7 @@ var ServiceLocatorManager = class {
     }
   }
   set(name, holder) {
-    this.instancesHolders.set(name, holder);
+    this._holders.set(name, holder);
   }
   has(name) {
     const [error, holder] = this.get(name);
@@ -774,43 +918,8 @@ var ServiceLocatorManager = class {
     }
     return [void 0, !!holder];
   }
-  delete(name) {
-    return this.instancesHolders.delete(name);
-  }
-  filter(predicate) {
-    return new Map(
-      [...this.instancesHolders].filter(
-        ([key, value]) => predicate(value, key)
-      )
-    );
-  }
-  /**
-   * 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
-   * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
-   * @returns A tuple containing the deferred promise and the holder
-   */
-  createCreatingHolder(name, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
-    const deferred = createDeferred();
-    const holder = {
-      status: "creating" /* Creating */,
-      name,
-      instance: null,
-      creationPromise: deferred.promise,
-      destroyPromise: null,
-      type,
-      scope,
-      deps,
-      destroyListeners: [],
-      createdAt: Date.now(),
-      ttl
-    };
-    return [deferred, holder];
-  }
+  // delete and filter methods are inherited from BaseInstanceHolderManager
+  // createCreatingHolder method is inherited from BaseInstanceHolderManager
   /**
    * Creates a new holder with Created status and an actual instance.
    * This is useful for creating holders that already have their instance ready.
@@ -823,20 +932,15 @@ var ServiceLocatorManager = class {
    * @returns The created holder
    */
   storeCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
-    const holder = {
-      status: "created" /* Created */,
+    const holder = this.createCreatedHolder(
       name,
       instance,
-      creationPromise: null,
-      destroyPromise: null,
       type,
       scope,
       deps,
-      destroyListeners: [],
-      createdAt: Date.now(),
       ttl
-    };
-    this.instancesHolders.set(name, holder);
+    );
+    this._holders.set(name, holder);
     return holder;
   }
 };
@@ -881,9 +985,7 @@ var ServiceLocator = class {
       return [err];
     }
     const { instanceName, validatedArgs, actualToken, realToken } = data;
-    if (onPrepare) {
-      onPrepare({ instanceName, actualToken, validatedArgs });
-    }
+    onPrepare?.({ instanceName, actualToken, validatedArgs });
     const [error, holder] = await this.retrieveOrCreateInstanceByInstanceName(
       instanceName,
       realToken,
@@ -908,7 +1010,7 @@ var ServiceLocator = class {
     }
     const instanceName = this.generateInstanceName(actualToken, validatedArgs);
     if (this.currentRequestContext) {
-      const requestHolder = this.currentRequestContext.getHolder(instanceName);
+      const requestHolder = this.currentRequestContext.get(instanceName);
       if (requestHolder) {
         return requestHolder.instance;
       }
@@ -921,63 +1023,80 @@ var ServiceLocator = class {
   }
   invalidate(service, round = 1) {
     this.logger?.log(
-      `[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`
+      `[ServiceLocator] Starting invalidation process for ${service}`
     );
     const toInvalidate = this.manager.filter(
       (holder) => holder.name === service || holder.deps.has(service)
     );
     const promises = [];
     for (const [key, holder] of toInvalidate.entries()) {
-      if (holder.status === "destroying" /* Destroying */) {
-        this.logger?.trace(
-          `[ServiceLocator]#invalidate(): ${key} is already being destroyed`
-        );
-        promises.push(holder.destroyPromise);
-        continue;
-      }
-      if (holder.status === "creating" /* Creating */) {
+      promises.push(this.invalidateHolder(key, holder, round));
+    }
+    return Promise.all(promises);
+  }
+  /**
+   * Invalidates a single holder based on its current status.
+   */
+  async invalidateHolder(key, holder, round) {
+    switch (holder.status) {
+      case "destroying" /* Destroying */:
+        this.logger?.trace(`[ServiceLocator] ${key} is already being destroyed`);
+        await holder.destroyPromise;
+        break;
+      case "creating" /* Creating */:
         this.logger?.trace(
-          `[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`
+          `[ServiceLocator] ${key} is being created, waiting...`
         );
-        promises.push(
-          holder.creationPromise?.then(() => {
-            if (round > 3) {
-              this.logger?.error(
-                `[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`
-              );
-              return;
-            }
-            return this.invalidate(key, round + 1);
-          })
-        );
-        continue;
-      }
-      holder.status = "destroying" /* Destroying */;
-      this.logger?.log(
-        `[ServiceLocator]#invalidate(): Invalidating ${key} and notifying listeners`
-      );
-      holder.destroyPromise = Promise.all(
-        holder.destroyListeners.map((listener) => listener())
-      ).then(async () => {
-        this.manager.delete(key);
-        await this.emitInstanceEvent(key, "destroy");
-      });
-      promises.push(holder.destroyPromise);
+        await holder.creationPromise;
+        if (round > 3) {
+          this.logger?.error(
+            `[ServiceLocator] ${key} creation triggered too many invalidation rounds`
+          );
+          return;
+        }
+        await this.invalidate(key, round + 1);
+        break;
+      default:
+        await this.destroyHolder(key, holder);
+        break;
     }
-    return Promise.all(promises);
+  }
+  /**
+   * Destroys a holder and cleans up its resources.
+   */
+  async destroyHolder(key, holder) {
+    holder.status = "destroying" /* Destroying */;
+    this.logger?.log(
+      `[ServiceLocator] Invalidating ${key} and notifying listeners`
+    );
+    holder.destroyPromise = Promise.all(
+      holder.destroyListeners.map((listener) => listener())
+    ).then(async () => {
+      this.manager.delete(key);
+      await this.emitInstanceEvent(key, "destroy");
+    });
+    await holder.destroyPromise;
   }
   async ready() {
-    return Promise.all(
-      Array.from(this.manager.filter(() => true)).map(([, holder]) => {
-        if (holder.status === "creating" /* Creating */) {
-          return holder.creationPromise?.then(() => null);
-        }
-        if (holder.status === "destroying" /* Destroying */) {
-          return holder.destroyPromise.then(() => null);
-        }
-        return Promise.resolve(null);
-      })
-    ).then(() => null);
+    const holders = Array.from(this.manager.filter(() => true)).map(
+      ([, holder]) => holder
+    );
+    await Promise.all(
+      holders.map((holder) => this.waitForHolderToSettle(holder))
+    );
+  }
+  /**
+   * Waits for a holder to settle (either created, destroyed, or error state).
+   */
+  async waitForHolderToSettle(holder) {
+    switch (holder.status) {
+      case "creating" /* Creating */:
+        await holder.creationPromise;
+        break;
+      case "destroying" /* Destroying */:
+        await holder.destroyPromise;
+        break;
+    }
   }
   // ============================================================================
   // REQUEST CONTEXT MANAGEMENT
@@ -1109,86 +1228,106 @@ var ServiceLocator = class {
    * Gets an instance by its instance name, handling all the logic after instance name creation.
    */
   async retrieveOrCreateInstanceByInstanceName(instanceName, realToken, realArgs) {
-    if (this.registry.has(realToken)) {
-      const record = this.registry.get(realToken);
-      if (record.scope === "Request" /* Request */) {
-        if (!this.currentRequestContext) {
-          this.logger?.log(
-            `[ServiceLocator]#retrieveOrCreateInstanceByInstanceName() No current request context available for request-scoped service ${instanceName}`
-          );
-          return [new UnknownError("InstanceNotFound" /* InstanceNotFound */)];
-        }
-        const requestHolder = this.currentRequestContext.getHolder(instanceName);
-        if (requestHolder) {
-          if (requestHolder.status === "creating" /* Creating */) {
-            await requestHolder.creationPromise;
-            return this.retrieveOrCreateInstanceByInstanceName(
-              instanceName,
-              realToken,
-              realArgs
-            );
-          } else if (requestHolder.status === "destroying" /* Destroying */) {
-            return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
-          }
-          return [void 0, requestHolder];
-        }
-      }
+    const existingHolder = await this.tryGetExistingInstance(
+      instanceName,
+      realToken
+    );
+    if (existingHolder) {
+      return existingHolder;
+    }
+    const result = await this.createNewInstance(
+      instanceName,
+      realToken,
+      realArgs
+    );
+    if (result[0]) {
+      return [result[0]];
     }
+    const [, holder] = result;
+    return this.waitForInstanceReady(holder);
+  }
+  /**
+   * Attempts to retrieve an existing instance, handling request-scoped and singleton instances.
+   * Returns null if no instance exists and a new one should be created.
+   */
+  async tryGetExistingInstance(instanceName, realToken) {
+    const requestResult = await this.tryGetRequestScopedInstance(
+      instanceName,
+      realToken
+    );
+    if (requestResult) {
+      return requestResult;
+    }
+    return this.tryGetSingletonInstance(instanceName);
+  }
+  /**
+   * Attempts to get a request-scoped instance if applicable.
+   */
+  async tryGetRequestScopedInstance(instanceName, realToken) {
+    if (!this.registry.has(realToken)) {
+      return null;
+    }
+    const record = this.registry.get(realToken);
+    if (record.scope !== "Request" /* Request */) {
+      return null;
+    }
+    if (!this.currentRequestContext) {
+      this.logger?.log(
+        `[ServiceLocator] No current request context available for request-scoped service ${instanceName}`
+      );
+      return [new UnknownError("InstanceNotFound" /* InstanceNotFound */)];
+    }
+    const requestHolder = this.currentRequestContext.get(instanceName);
+    if (!requestHolder) {
+      return null;
+    }
+    return this.waitForInstanceReady(requestHolder);
+  }
+  /**
+   * Attempts to get a singleton instance from the manager.
+   */
+  async tryGetSingletonInstance(instanceName) {
     const [error, holder] = this.manager.get(instanceName);
     if (!error) {
-      if (holder.status === "creating" /* Creating */) {
-        await holder.creationPromise;
-        return this.retrieveOrCreateInstanceByInstanceName(
-          instanceName,
-          realToken,
-          realArgs
-        );
-      } else if (holder.status === "destroying" /* Destroying */) {
-        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
-      }
-      return [void 0, holder];
+      return this.waitForInstanceReady(holder);
     }
     switch (error.code) {
       case "InstanceDestroying" /* InstanceDestroying */:
         this.logger?.log(
-          `[ServiceLocator]#retrieveOrCreateInstanceByInstanceName() TTL expired for ${holder?.name}`
+          `[ServiceLocator] Instance ${instanceName} is being destroyed, waiting...`
         );
         await holder?.destroyPromise;
-        return this.retrieveOrCreateInstanceByInstanceName(
-          instanceName,
-          realToken,
-          realArgs
-        );
+        return this.tryGetSingletonInstance(instanceName);
       case "InstanceExpired" /* InstanceExpired */:
         this.logger?.log(
-          `[ServiceLocator]#retrieveOrCreateInstanceByInstanceName() TTL expired for ${holder?.name}`
+          `[ServiceLocator] Instance ${instanceName} expired, invalidating...`
         );
         await this.invalidate(instanceName);
-        return this.retrieveOrCreateInstanceByInstanceName(
-          instanceName,
-          realToken,
-          realArgs
-        );
+        return this.tryGetSingletonInstance(instanceName);
       case "InstanceNotFound" /* InstanceNotFound */:
-        break;
+        return null;
+      // Instance doesn't exist, should create new one
       default:
         return [error];
     }
-    const result = await this.createNewInstance(
-      instanceName,
-      realToken,
-      realArgs
-    );
-    if (result[0]) {
-      return [result[0]];
-    }
-    if (result[1].status === "creating" /* Creating */) {
-      await result[1].creationPromise;
-    }
-    if (result[1].status === "error" /* Error */) {
-      return [result[1].instance];
+  }
+  /**
+   * Waits for an instance holder to be ready and returns the appropriate result.
+   */
+  async waitForInstanceReady(holder) {
+    switch (holder.status) {
+      case "creating" /* Creating */:
+        await holder.creationPromise;
+        return this.waitForInstanceReady(holder);
+      case "destroying" /* Destroying */:
+        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
+      case "error" /* Error */:
+        return [holder.instance];
+      case "created" /* Created */:
+        return [void 0, holder];
+      default:
+        return [new UnknownError("InstanceNotFound" /* InstanceNotFound */)];
     }
-    return [void 0, result[1]];
   }
   /**
    * Emits events to listeners for instance lifecycle events.
@@ -1236,65 +1375,137 @@ var ServiceLocator = class {
       Infinity
     );
     this.serviceInstantiator.instantiateService(ctx, record, args).then(async ([error, instance]) => {
-      holder.destroyListeners = ctx.getDestroyListeners();
-      holder.creationPromise = null;
-      if (error) {
-        this.logger?.error(
-          `[ServiceLocator]#instantiateServiceFromRegistry(): Error creating instance for ${instanceName}`,
-          error
-        );
-        holder.status = "error" /* Error */;
-        holder.instance = error;
-        if (scope === "Singleton" /* Singleton */) {
-          setTimeout(() => this.invalidate(instanceName), 10);
-        }
-        deferred.reject(error);
-      } else {
-        holder.instance = instance;
-        holder.status = "created" /* Created */;
-        if (ctx.deps.size > 0) {
-          ctx.deps.forEach((dependency) => {
-            holder.destroyListeners.push(
-              this.eventBus.on(
-                dependency,
-                "destroy",
-                () => this.invalidate(instanceName)
-              )
-            );
-          });
-        }
-        await this.emitInstanceEvent(instanceName);
-        deferred.resolve([void 0, instance]);
-      }
-    }).catch((error) => {
-      this.logger?.error(
-        `[ServiceLocator]#instantiateServiceFromRegistry(): Unexpected error creating instance for ${instanceName}`,
+      await this.handleInstantiationResult(
+        instanceName,
+        holder,
+        ctx,
+        deferred,
+        scope,
+        error,
+        instance
+      );
+    }).catch(async (error) => {
+      await this.handleInstantiationError(
+        instanceName,
+        holder,
+        deferred,
+        scope,
         error
       );
-      holder.status = "error" /* Error */;
-      holder.instance = error;
-      holder.creationPromise = null;
-      if (scope === "Singleton" /* Singleton */) {
-        setTimeout(() => this.invalidate(instanceName), 10);
-      }
-      deferred.reject(error);
     });
-    if (scope === "Singleton" /* Singleton */) {
-      this.logger?.debug(
-        `[ServiceLocator]#instantiateServiceFromRegistry(): Setting instance for ${instanceName}`
-      );
-      this.manager.set(instanceName, holder);
-    } else if (scope === "Request" /* Request */ && this.currentRequestContext) {
-      this.logger?.debug(
-        `[ServiceLocator]#instantiateServiceFromRegistry(): Setting request-scoped instance for ${instanceName}`
+    this.storeInstanceByScope(scope, instanceName, holder);
+    return [void 0, holder];
+  }
+  /**
+   * Handles the result of service instantiation.
+   */
+  async handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance) {
+    holder.destroyListeners = ctx.getDestroyListeners();
+    holder.creationPromise = null;
+    if (error) {
+      await this.handleInstantiationError(
+        instanceName,
+        holder,
+        deferred,
+        scope,
+        error
       );
-      this.currentRequestContext.addInstance(
+    } else {
+      await this.handleInstantiationSuccess(
         instanceName,
-        holder.instance,
-        holder
+        holder,
+        ctx,
+        deferred,
+        instance
       );
     }
-    return [void 0, holder];
+  }
+  /**
+   * Handles successful service instantiation.
+   */
+  async handleInstantiationSuccess(instanceName, holder, ctx, deferred, instance) {
+    holder.instance = instance;
+    holder.status = "created" /* Created */;
+    if (ctx.deps.size > 0) {
+      ctx.deps.forEach((dependency) => {
+        holder.destroyListeners.push(
+          this.eventBus.on(
+            dependency,
+            "destroy",
+            () => this.invalidate(instanceName)
+          )
+        );
+      });
+    }
+    await this.emitInstanceEvent(instanceName);
+    deferred.resolve([void 0, instance]);
+  }
+  /**
+   * Handles service instantiation errors.
+   */
+  async handleInstantiationError(instanceName, holder, deferred, scope, error) {
+    this.logger?.error(
+      `[ServiceLocator] Error creating instance for ${instanceName}`,
+      error
+    );
+    holder.status = "error" /* Error */;
+    holder.instance = error;
+    holder.creationPromise = null;
+    if (scope === "Singleton" /* Singleton */) {
+      setTimeout(() => this.invalidate(instanceName), 10);
+    }
+    deferred.reject(error);
+  }
+  /**
+   * Stores an instance holder based on its scope.
+   */
+  storeInstanceByScope(scope, instanceName, holder) {
+    switch (scope) {
+      case "Singleton" /* Singleton */:
+        this.logger?.debug(
+          `[ServiceLocator] Setting singleton instance for ${instanceName}`
+        );
+        this.manager.set(instanceName, holder);
+        break;
+      case "Request" /* Request */:
+        if (this.currentRequestContext) {
+          this.logger?.debug(
+            `[ServiceLocator] Setting request-scoped instance for ${instanceName}`
+          );
+          this.currentRequestContext.addInstance(
+            instanceName,
+            holder.instance,
+            holder
+          );
+        }
+        break;
+    }
+  }
+  /**
+   * Tries to get a pre-prepared instance from request contexts.
+   */
+  tryGetPrePreparedInstance(instanceName, contextHolder, deps) {
+    if (contextHolder && contextHolder.priority > 0) {
+      const prePreparedInstance = contextHolder.get(instanceName)?.instance;
+      if (prePreparedInstance !== void 0) {
+        this.logger?.debug(
+          `[ServiceLocator] Using pre-prepared instance ${instanceName} from request context ${contextHolder.requestId}`
+        );
+        deps.add(instanceName);
+        return prePreparedInstance;
+      }
+    }
+    if (this.currentRequestContext && this.currentRequestContext !== contextHolder) {
+      const prePreparedInstance = this.currentRequestContext.get(instanceName)?.instance;
+      if (prePreparedInstance !== void 0) {
+        this.logger?.debug(
+          `[ServiceLocator] Using pre-prepared instance ${instanceName} from current request context ${this.currentRequestContext.requestId}`
+        );
+        deps.add(instanceName);
+        return prePreparedInstance;
+      }
+    }
+    return void 0;
   }
   /**
    * Creates a factory context for dependency injection during service instantiation.
@@ -1313,33 +1524,20 @@ var ServiceLocator = class {
     return {
       // @ts-expect-error This is correct type
       async inject(token, args) {
-        if (contextHolder && contextHolder.priority > 0) {
-          const instanceName = self.generateInstanceName(token, args);
-          const prePreparedInstance = contextHolder.getInstance(instanceName);
-          if (prePreparedInstance !== void 0) {
-            self.logger?.debug(
-              `[ServiceLocator] Using pre-prepared instance ${instanceName} from request context ${contextHolder.requestId}`
-            );
-            deps.add(instanceName);
-            return prePreparedInstance;
-          }
-        }
-        if (self.currentRequestContext && self.currentRequestContext !== contextHolder) {
-          const instanceName = self.generateInstanceName(token, args);
-          const prePreparedInstance = self.currentRequestContext.getInstance(instanceName);
-          if (prePreparedInstance !== void 0) {
-            self.logger?.debug(
-              `[ServiceLocator] Using pre-prepared instance ${instanceName} from current request context ${self.currentRequestContext.requestId}`
-            );
-            deps.add(instanceName);
-            return prePreparedInstance;
-          }
+        const instanceName = self.generateInstanceName(token, args);
+        const prePreparedInstance = self.tryGetPrePreparedInstance(
+          instanceName,
+          contextHolder,
+          deps
+        );
+        if (prePreparedInstance !== void 0) {
+          return prePreparedInstance;
         }
         const [error, instance] = await self.getInstance(
           token,
           args,
-          ({ instanceName }) => {
-            deps.add(instanceName);
+          ({ instanceName: instanceName2 }) => {
+            deps.add(instanceName2);
           }
         );
         if (error) {
@@ -1357,16 +1555,23 @@ var ServiceLocator = class {
    * Generates a unique instance name based on token and arguments.
    */
   generateInstanceName(token, args) {
-    const formattedArgs = args ? ":" + Object.entries(args ?? {}).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => {
-      if (typeof value === "function") {
-        return `${key}=fn_${value.name}(${value.length})`;
-      }
-      if (typeof value === "symbol") {
-        return `${key}=${value.toString()}`;
-      }
-      return `${key}=${JSON.stringify(value).slice(0, 40)}`;
-    }).join(",").replaceAll(/"/g, "").replaceAll(/:/g, "=") : "";
-    return `${token.toString()}${formattedArgs}`;
+    if (!args) {
+      return token.toString();
+    }
+    const formattedArgs = Object.entries(args).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}=${this.formatArgValue(value)}`).join(",");
+    return `${token.toString()}:${formattedArgs.replaceAll(/"/g, "").replaceAll(/:/g, "=")}`;
+  }
+  /**
+   * Formats a single argument value for instance name generation.
+   */
+  formatArgValue(value) {
+    if (typeof value === "function") {
+      return `fn_${value.name}(${value.length})`;
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    return JSON.stringify(value).slice(0, 40);
   }
 };
 
@@ -1457,6 +1662,7 @@ _Container = __decorateElement(_init2, 0, "Container", _Container_decorators, _C
 __runInitializers(_init2, 1, _Container);
 var Container = _Container;
 
+exports.BaseInstanceHolderManager = BaseInstanceHolderManager;
 exports.BoundInjectionToken = BoundInjectionToken;
 exports.Container = Container;
 exports.DefaultRequestContextHolder = DefaultRequestContextHolder;