@navios/di 0.4.1 → 0.5.0

package/lib/index.js

@@ -181,6 +181,7 @@ function Factory({
 function Injectable({
   scope = "Singleton" /* Singleton */,
   token,
+  schema,
   registry = globalRegistry
 } = {}) {
   return (target, context) => {
@@ -189,79 +190,73 @@ function Injectable({
         "[ServiceLocator] @Injectable decorator can only be used on classes."
       );
     }
-    let injectableToken = token ?? InjectionToken.create(target);
+    if (schema && token) {
+      throw new Error(
+        "[ServiceLocator] @Injectable decorator cannot have both a token and a schema"
+      );
+    }
+    let injectableToken = token ?? InjectionToken.create(target, schema);
     registry.set(injectableToken, scope, target, "Class" /* Class */);
     target[InjectableTokenMeta] = injectableToken;
     return target;
   };
 }
 
-// src/errors/errors.enum.mts
-var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
-  ErrorsEnum2["InstanceExpired"] = "InstanceExpired";
-  ErrorsEnum2["InstanceNotFound"] = "InstanceNotFound";
-  ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
-  ErrorsEnum2["UnknownError"] = "UnknownError";
-  ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
-  ErrorsEnum2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
-  return ErrorsEnum2;
-})(ErrorsEnum || {});
-
-// src/errors/factory-not-found.mts
-var FactoryNotFound = class extends Error {
-  constructor(name) {
-    super(`Factory ${name} not found`);
-    this.name = name;
-  }
-  code = "FactoryNotFound" /* FactoryNotFound */;
-};
-
-// src/errors/factory-token-not-resolved.mts
-var FactoryTokenNotResolved = class extends Error {
-  code = "FactoryTokenNotResolved" /* FactoryTokenNotResolved */;
-  constructor(name) {
-    super(`Factory token not resolved: ${name.toString()}`);
+// src/errors/di-error.mts
+var DIErrorCode = /* @__PURE__ */ ((DIErrorCode2) => {
+  DIErrorCode2["FactoryNotFound"] = "FactoryNotFound";
+  DIErrorCode2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
+  DIErrorCode2["InstanceNotFound"] = "InstanceNotFound";
+  DIErrorCode2["InstanceDestroying"] = "InstanceDestroying";
+  DIErrorCode2["UnknownError"] = "UnknownError";
+  return DIErrorCode2;
+})(DIErrorCode || {});
+var DIError = class _DIError extends Error {
+  code;
+  context;
+  constructor(code, message, context) {
+    super(message);
+    this.name = "DIError";
+    this.code = code;
+    this.context = context;
+  }
+  // Static factory methods for common error types
+  static factoryNotFound(name) {
+    return new _DIError(
+      "FactoryNotFound" /* FactoryNotFound */,
+      `Factory ${name} not found`,
+      { name }
+    );
   }
-};
-
-// src/errors/instance-destroying.mts
-var InstanceDestroying = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} destroying`);
-    this.name = name;
+  static factoryTokenNotResolved(token) {
+    return new _DIError(
+      "FactoryTokenNotResolved" /* FactoryTokenNotResolved */,
+      `Factory token not resolved: ${token?.toString() ?? "unknown"}`,
+      { token }
+    );
   }
-  code = "InstanceDestroying" /* InstanceDestroying */;
-};
-
-// src/errors/instance-expired.mts
-var InstanceExpired = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} expired`);
-    this.name = name;
+  static instanceNotFound(name) {
+    return new _DIError(
+      "InstanceNotFound" /* InstanceNotFound */,
+      `Instance ${name} not found`,
+      { name }
+    );
   }
-  code = "InstanceExpired" /* InstanceExpired */;
-};
-
-// src/errors/instance-not-found.mts
-var InstanceNotFound = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} not found`);
-    this.name = name;
+  static instanceDestroying(name) {
+    return new _DIError(
+      "InstanceDestroying" /* InstanceDestroying */,
+      `Instance ${name} destroying`,
+      { name }
+    );
   }
-  code = "InstanceNotFound" /* InstanceNotFound */;
-};
-
-// src/errors/unknown-error.mts
-var UnknownError = class extends Error {
-  code = "UnknownError" /* UnknownError */;
-  parent;
-  constructor(message) {
+  static unknown(message, context) {
     if (message instanceof Error) {
-      super(message.message);
-      this.parent = message;
-      return;
+      return new _DIError("UnknownError" /* UnknownError */, message.message, {
+        ...context,
+        parent: message
+      });
     }
-    super(message);
+    return new _DIError("UnknownError" /* UnknownError */, message, context);
   }
 };
 
@@ -283,29 +278,58 @@ function getInjectors() {
   }
   let promiseCollector = null;
   let injectState = null;
-  function asyncInject2(token, args) {
+  function getRequest(token, args) {
     if (!injectState) {
       throw new Error(
-        "[Injector] Trying to access inject outside of a injectable context"
+        "[Injector] Trying to make a request outside of a injectable context"
       );
     }
     if (injectState.isFrozen) {
       const idx = injectState.currentIndex++;
-      const request = injectState.requests[idx];
-      if (request.token !== token) {
+      const request2 = injectState.requests[idx];
+      if (request2.token !== token) {
         throw new Error(
-          `[Injector] Wrong token order. Expected ${request.token.toString()} but got ${token.toString()}`
+          `[Injector] Wrong token order. Expected ${request2.token.toString()} but got ${token.toString()}`
         );
       }
-      return request.promise;
-    }
-    const promise = getFactoryContext().inject(token, args);
-    injectState.requests.push({
-      token,
-      promise
+      return request2;
+    }
+    let result = null;
+    let error = null;
+    const promise = getFactoryContext().inject(token, args).then((r) => {
+      result = r;
+      return r;
+    }).catch((e) => {
+      error = e;
     });
+    const request = {
+      token,
+      promise,
+      get result() {
+        return result;
+      },
+      get error() {
+        return error;
+      }
+    };
+    injectState.requests.push(request);
     injectState.currentIndex++;
-    return promise;
+    return request;
+  }
+  function asyncInject2(token, args) {
+    if (!injectState) {
+      throw new Error(
+        "[Injector] Trying to access inject outside of a injectable context"
+      );
+    }
+    const realToken = token[InjectableTokenMeta] ?? token;
+    const request = getRequest(realToken, args);
+    return request.promise.then((result) => {
+      if (request.error) {
+        throw request.error;
+      }
+      return result;
+    });
   }
   function wrapSyncInit2(cb) {
     return (previousState) => {
@@ -335,23 +359,31 @@ function getInjectors() {
   }
   function inject2(token, args) {
     const realToken = token[InjectableTokenMeta] ?? token;
+    if (!injectState) {
+      throw new Error(
+        "[Injector] Trying to access inject outside of a injectable context"
+      );
+    }
     const instance = getFactoryContext().locator.getSyncInstance(
       realToken,
       args
     );
     if (!instance) {
+      const request = getRequest(realToken, args);
+      if (request.error) {
+        throw request.error;
+      } else if (request.result) {
+        return request.result;
+      }
       if (promiseCollector) {
-        const promise = getFactoryContext().inject(realToken, args);
-        promiseCollector(promise);
-      } else {
-        throw new Error(`[Injector] Cannot initiate ${realToken.toString()}`);
+        promiseCollector(request.promise);
       }
       return new Proxy(
         {},
         {
           get() {
             throw new Error(
-              `[Injector] Trying to access ${realToken.toString()} before it's initialized, please use asyncInject() instead of inject() or do not use the value outside of class methods`
+              `[Injector] Trying to access ${realToken.toString()} before it's initialized, please move the code to a onServiceInit method`
             );
           }
         }
@@ -359,9 +391,17 @@ function getInjectors() {
     }
     return instance;
   }
+  function optional2(token, args) {
+    try {
+      return inject2(token, args);
+    } catch {
+      return null;
+    }
+  }
   const injectors = {
     asyncInject: asyncInject2,
     inject: inject2,
+    optional: optional2,
     wrapSyncInit: wrapSyncInit2,
     provideFactoryContext: provideFactoryContext2
   };
@@ -379,73 +419,13 @@ function getInjectableToken(target) {
   return token;
 }
 
-// src/utils/defer.mts
-var Deferred = class {
-  promise;
-  _resolve;
-  _reject;
-  _isResolved = false;
-  _isRejected = false;
-  constructor() {
-    this.promise = new Promise((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
-    });
-  }
-  /**
-   * Resolves the deferred promise with the given value.
-   * @param value The value to resolve with
-   * @throws Error if the promise has already been resolved or rejected
-   */
-  resolve(value) {
-    if (this._isResolved || this._isRejected) {
-      throw new Error("Deferred promise has already been resolved or rejected");
-    }
-    this._isResolved = true;
-    this._resolve(value);
-  }
-  /**
-   * Rejects the deferred promise with the given reason.
-   * @param reason The reason for rejection
-   * @throws Error if the promise has already been resolved or rejected
-   */
-  reject(reason) {
-    if (this._isResolved || this._isRejected) {
-      throw new Error("Deferred promise has already been resolved or rejected");
-    }
-    this._isRejected = true;
-    this._reject(reason);
-  }
-  /**
-   * Returns true if the promise has been resolved.
-   */
-  get isResolved() {
-    return this._isResolved;
-  }
-  /**
-   * Returns true if the promise has been rejected.
-   */
-  get isRejected() {
-    return this._isRejected;
-  }
-  /**
-   * Returns true if the promise has been settled (resolved or rejected).
-   */
-  get isSettled() {
-    return this._isResolved || this._isRejected;
-  }
-};
-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;
+var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus2) => {
+  ServiceLocatorInstanceHolderStatus2["Created"] = "created";
+  ServiceLocatorInstanceHolderStatus2["Creating"] = "creating";
+  ServiceLocatorInstanceHolderStatus2["Destroying"] = "destroying";
+  ServiceLocatorInstanceHolderStatus2["Error"] = "error";
+  return ServiceLocatorInstanceHolderStatus2;
 })(ServiceLocatorInstanceHolderStatus || {});
 
 // src/base-instance-holder-manager.mts
@@ -498,11 +478,10 @@ var BaseInstanceHolderManager = class {
    * @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();
+  createCreatingHolder(name, type, scope, deps = /* @__PURE__ */ new Set()) {
+    const deferred = Promise.withResolvers();
     const holder = {
       status: "creating" /* Creating */,
       name,
@@ -513,8 +492,7 @@ var BaseInstanceHolderManager = class {
       scope,
       deps,
       destroyListeners: [],
-      createdAt: Date.now(),
-      ttl
+      createdAt: Date.now()
     };
     return [deferred, holder];
   }
@@ -526,10 +504,9 @@ var BaseInstanceHolderManager = class {
    * @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) {
+  createCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set()) {
     const holder = {
       status: "created" /* Created */,
       name,
@@ -540,8 +517,7 @@ var BaseInstanceHolderManager = class {
       scope,
       deps,
       destroyListeners: [],
-      createdAt: Date.now(),
-      ttl
+      createdAt: Date.now()
     };
     return holder;
   }
@@ -614,6 +590,7 @@ __runInitializers(_init, 1, exports.EventEmitter);
 var defaultInjectors = getInjectors();
 var asyncInject = defaultInjectors.asyncInject;
 var inject = defaultInjectors.inject;
+var optional = defaultInjectors.optional;
 var wrapSyncInit = defaultInjectors.wrapSyncInit;
 var provideFactoryContext = defaultInjectors.provideFactoryContext;
 
@@ -745,362 +722,425 @@ var ServiceInstantiator = class {
   }
 };
 
-// src/request-context-holder.mts
-var DefaultRequestContextHolder = class extends BaseInstanceHolderManager {
-  constructor(requestId, priority = 100, initialMetadata) {
-    super(null);
-    this.requestId = requestId;
-    this.priority = priority;
-    if (initialMetadata) {
-      Object.entries(initialMetadata).forEach(([key, value]) => {
-        this.metadata.set(key, value);
-      });
+// src/instance-resolver.mts
+var InstanceResolver = class {
+  constructor(registry, manager, serviceInstantiator, tokenProcessor, logger = null, serviceLocator) {
+    this.registry = registry;
+    this.manager = manager;
+    this.serviceInstantiator = serviceInstantiator;
+    this.tokenProcessor = tokenProcessor;
+    this.logger = logger;
+    this.serviceLocator = serviceLocator;
+  }
+  /**
+   * Resolves an instance for the given token and arguments.
+   */
+  async resolveInstance(token, args, requestContext) {
+    const [err, data] = await this.resolveTokenAndPrepareInstanceName(
+      token,
+      args
+    );
+    if (err) {
+      return [err];
+    }
+    const {
+      instanceName,
+      validatedArgs,
+      realToken
+    } = data;
+    const [error, holder] = await this.retrieveOrCreateInstanceByInstanceName(
+      instanceName,
+      realToken,
+      validatedArgs,
+      requestContext
+    );
+    if (error) {
+      return [error];
     }
+    return [void 0, holder.instance];
   }
-  metadata = /* @__PURE__ */ new Map();
-  createdAt = Date.now();
   /**
-   * Public getter for holders to maintain interface compatibility.
+   * Gets a synchronous instance (for sync operations).
    */
-  get holders() {
-    return this._holders;
+  getSyncInstance(token, args, currentRequestContext) {
+    const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
+    if (err) {
+      return null;
+    }
+    const instanceName = this.tokenProcessor.generateInstanceName(
+      actualToken,
+      validatedArgs
+    );
+    if (currentRequestContext) {
+      const requestHolder = currentRequestContext.get(instanceName);
+      if (requestHolder) {
+        return requestHolder.instance;
+      }
+    }
+    const [error, holder] = this.manager.get(instanceName);
+    if (error) {
+      return null;
+    }
+    return holder.instance;
   }
   /**
-   * Gets a holder by name. For RequestContextHolder, this is a simple lookup.
+   * Internal method to resolve token args and create instance name.
+   * Handles factory token resolution and validation.
    */
-  get(name) {
-    return this._holders.get(name);
+  async resolveTokenAndPrepareInstanceName(token, args) {
+    const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
+    if (err instanceof DIError && err.code === "UnknownError" /* UnknownError */) {
+      return [err];
+    } else if (err instanceof DIError && err.code === "FactoryTokenNotResolved" /* FactoryTokenNotResolved */ && actualToken instanceof FactoryInjectionToken) {
+      this.logger?.log(
+        `[InstanceResolver]#resolveTokenAndPrepareInstanceName() Factory token not resolved, resolving it`
+      );
+      await actualToken.resolve(this.createFactoryContext());
+      return this.resolveTokenAndPrepareInstanceName(token);
+    }
+    const instanceName = this.tokenProcessor.generateInstanceName(
+      actualToken,
+      validatedArgs
+    );
+    const realToken = actualToken instanceof BoundInjectionToken || actualToken instanceof FactoryInjectionToken ? actualToken.token : actualToken;
+    return [void 0, { instanceName, validatedArgs, actualToken, realToken }];
   }
   /**
-   * Sets a holder by name.
+   * Gets an instance by its instance name, handling all the logic after instance name creation.
    */
-  set(name, holder) {
-    this._holders.set(name, holder);
+  async retrieveOrCreateInstanceByInstanceName(instanceName, realToken, realArgs, requestContext) {
+    const existingHolder = await this.tryGetExistingInstance(
+      instanceName,
+      realToken,
+      requestContext
+    );
+    if (existingHolder) {
+      return existingHolder;
+    }
+    const result = await this.createNewInstance(
+      instanceName,
+      realToken,
+      realArgs,
+      requestContext
+    );
+    if (result[0]) {
+      return [result[0]];
+    }
+    const [, holder] = result;
+    return this.waitForInstanceReady(holder);
   }
   /**
-   * Checks if a holder exists by name.
+   * 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.
    */
-  has(name) {
-    return this._holders.has(name);
+  async tryGetExistingInstance(instanceName, realToken, requestContext) {
+    const requestResult = await this.tryGetRequestScopedInstance(
+      instanceName,
+      realToken,
+      requestContext
+    );
+    if (requestResult) {
+      return requestResult;
+    }
+    return this.tryGetSingletonInstance(instanceName);
   }
-  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
+  /**
+   * Attempts to get a request-scoped instance if applicable.
+   */
+  async tryGetRequestScopedInstance(instanceName, realToken, requestContext) {
+    if (!this.registry.has(realToken)) {
+      return null;
+    }
+    const record = this.registry.get(realToken);
+    if (record.scope !== "Request" /* Request */) {
+      return null;
+    }
+    if (!requestContext) {
+      this.logger?.log(
+        `[InstanceResolver] No current request context available for request-scoped service ${instanceName}`
       );
-      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);
+      return [
+        DIError.unknown(
+          `No current request context available for request-scoped service ${instanceName}`
+        )
+      ];
     }
+    const requestHolder = requestContext.get(instanceName);
+    if (!requestHolder) {
+      return null;
+    }
+    return this.waitForInstanceReady(requestHolder);
   }
-  clear() {
-    super.clear();
-    this.metadata.clear();
-  }
-  getMetadata(key) {
-    return this.metadata.get(key);
-  }
-  setMetadata(key, value) {
-    this.metadata.set(key, value);
-  }
-};
-function createRequestContextHolder(requestId, priority = 100, initialMetadata) {
-  return new DefaultRequestContextHolder(requestId, priority, initialMetadata);
-}
-
-// src/service-locator-event-bus.mts
-var ServiceLocatorEventBus = class {
-  constructor(logger = null) {
-    this.logger = logger;
-  }
-  listeners = /* @__PURE__ */ new Map();
-  on(ns, event, listener) {
-    this.logger?.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
-    if (!this.listeners.has(ns)) {
-      this.listeners.set(ns, /* @__PURE__ */ new Map());
+  /**
+   * Attempts to get a singleton instance from the manager.
+   */
+  async tryGetSingletonInstance(instanceName) {
+    const [error, holder] = this.manager.get(instanceName);
+    if (!error) {
+      return this.waitForInstanceReady(holder);
     }
-    const nsEvents = this.listeners.get(ns);
-    if (!nsEvents.has(event)) {
-      nsEvents.set(event, /* @__PURE__ */ new Set());
+    switch (error.code) {
+      case "InstanceDestroying" /* InstanceDestroying */:
+        this.logger?.log(
+          `[InstanceResolver] Instance ${instanceName} is being destroyed, waiting...`
+        );
+        await holder?.destroyPromise;
+        return this.tryGetSingletonInstance(instanceName);
+      case "InstanceNotFound" /* InstanceNotFound */:
+        return null;
+      // Instance doesn't exist, should create new one
+      default:
+        return [error];
     }
-    nsEvents.get(event).add(listener);
-    return () => {
-      nsEvents.get(event).delete(listener);
-      if (nsEvents.get(event)?.size === 0) {
-        nsEvents.delete(event);
-      }
-      if (nsEvents.size === 0) {
-        this.listeners.delete(ns);
-      }
-    };
-  }
-  async emit(key, event) {
-    if (!this.listeners.has(key)) {
-      return;
-    }
-    const events = this.listeners.get(key);
-    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
-    const res = await Promise.allSettled(
-      [...events.get(event) ?? []].map((listener) => listener(event))
-    ).then((results) => {
-      const res2 = results.filter((result) => result.status === "rejected").map((result) => {
-        this.logger?.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
-          result.reason
-        );
-        return result;
-      });
-      if (res2.length > 0) {
-        return Promise.reject(res2);
-      }
-      return results;
-    });
-    return res;
   }
-};
-
-// src/service-locator-manager.mts
-var ServiceLocatorManager = class extends BaseInstanceHolderManager {
-  constructor(logger = null) {
-    super(logger);
-  }
-  get(name) {
-    const holder = this._holders.get(name);
-    if (holder) {
-      if (holder.ttl !== Infinity) {
-        const now = Date.now();
-        if (now - holder.createdAt > holder.ttl) {
-          this.logger?.log(
-            `[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`
-          );
-          return [new InstanceExpired(holder.name), holder];
-        }
-      } else if (holder.status === "destroying" /* Destroying */) {
-        this.logger?.log(
-          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`
-        );
-        return [new InstanceDestroying(holder.name), holder];
-      } else if (holder.status === "error" /* Error */) {
-        this.logger?.log(
-          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is in error state`
-        );
-        return [holder.instance, holder];
-      }
-      return [void 0, holder];
-    } else {
-      this.logger?.log(
-        `[ServiceLocatorManager]#getInstanceHolder() Instance ${name} not found`
-      );
-      return [new InstanceNotFound(name)];
-    }
-  }
-  set(name, holder) {
-    this._holders.set(name, holder);
-  }
-  has(name) {
-    const [error, holder] = this.get(name);
-    if (!error) {
-      return [void 0, true];
-    }
-    if (["InstanceExpired" /* InstanceExpired */, "InstanceDestroying" /* InstanceDestroying */].includes(
-      error.code
-    )) {
-      return [error];
+  /**
+   * 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 [DIError.instanceDestroying(holder.name)];
+      case "error" /* Error */:
+        return [holder.instance];
+      case "created" /* Created */:
+        return [void 0, holder];
+      default:
+        return [DIError.instanceNotFound("unknown")];
     }
-    return [void 0, !!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.
-   * @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
+   * Creates a new instance for the given token and arguments.
    */
-  storeCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
-    const holder = this.createCreatedHolder(
-      name,
-      instance,
-      type,
-      scope,
-      deps,
-      ttl
+  async createNewInstance(instanceName, realToken, args, requestContext) {
+    this.logger?.log(
+      `[InstanceResolver]#createNewInstance() Creating instance for ${instanceName}`
     );
-    this._holders.set(name, holder);
-    return holder;
-  }
-};
-
-// src/service-locator.mts
-var ServiceLocator = class {
-  constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
-    this.registry = registry;
-    this.logger = logger;
-    this.injectors = injectors;
-    this.eventBus = new ServiceLocatorEventBus(logger);
-    this.manager = new ServiceLocatorManager(logger);
-    this.serviceInstantiator = new ServiceInstantiator(injectors);
-  }
-  eventBus;
-  manager;
-  serviceInstantiator;
-  requestContexts = /* @__PURE__ */ new Map();
-  currentRequestContext = null;
-  // ============================================================================
-  // PUBLIC METHODS
-  // ============================================================================
-  getEventBus() {
-    return this.eventBus;
-  }
-  getManager() {
-    return this.manager;
-  }
-  getInstanceIdentifier(token, args) {
-    const [err, { actualToken, validatedArgs }] = this.validateAndResolveTokenArgs(token, args);
-    if (err) {
-      throw err;
+    if (this.registry.has(realToken)) {
+      return this.instantiateServiceFromRegistry(
+        instanceName,
+        realToken,
+        args,
+        requestContext
+      );
+    } else {
+      return [DIError.factoryNotFound(realToken.name.toString())];
     }
-    return this.generateInstanceName(actualToken, validatedArgs);
   }
-  async getInstance(token, args, onPrepare) {
-    const [err, data] = await this.resolveTokenAndPrepareInstanceName(
-      token,
-      args
+  /**
+   * Instantiates a service from the registry using the service instantiator.
+   */
+  instantiateServiceFromRegistry(instanceName, token, args, requestContext) {
+    this.logger?.log(
+      `[InstanceResolver]#instantiateServiceFromRegistry(): Creating instance for ${instanceName} from abstract factory`
     );
-    if (err) {
-      return [err];
-    }
-    const { instanceName, validatedArgs, actualToken, realToken } = data;
-    onPrepare?.({ instanceName, actualToken, validatedArgs });
-    const [error, holder] = await this.retrieveOrCreateInstanceByInstanceName(
+    const ctx = this.createFactoryContext();
+    let record = this.registry.get(token);
+    let { scope, type } = record;
+    const [deferred, holder] = this.manager.createCreatingHolder(
       instanceName,
-      realToken,
-      validatedArgs
+      type,
+      scope,
+      ctx.deps
     );
-    if (error) {
-      return [error];
-    }
-    return [void 0, holder.instance];
+    this.serviceInstantiator.instantiateService(ctx, record, args).then(async ([error, instance]) => {
+      await this.handleInstantiationResult(
+        instanceName,
+        holder,
+        ctx,
+        deferred,
+        scope,
+        error,
+        instance,
+        requestContext
+      );
+    }).catch(async (error) => {
+      await this.handleInstantiationError(
+        instanceName,
+        holder,
+        deferred,
+        scope,
+        error
+      );
+    });
+    this.storeInstanceByScope(scope, instanceName, holder, requestContext);
+    return [void 0, holder];
   }
-  async getOrThrowInstance(token, args) {
-    const [error, instance] = await this.getInstance(token, args);
+  /**
+   * Handles the result of service instantiation.
+   */
+  async handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance, _requestContext) {
+    holder.destroyListeners = ctx.getDestroyListeners();
+    holder.creationPromise = null;
     if (error) {
-      throw error;
+      await this.handleInstantiationError(
+        instanceName,
+        holder,
+        deferred,
+        scope,
+        error
+      );
+    } else {
+      await this.handleInstantiationSuccess(
+        instanceName,
+        holder,
+        ctx,
+        deferred,
+        instance
+      );
     }
-    return instance;
   }
-  getSyncInstance(token, args) {
-    const [err, { actualToken, validatedArgs }] = this.validateAndResolveTokenArgs(token, args);
-    if (err) {
-      return null;
-    }
-    const instanceName = this.generateInstanceName(actualToken, validatedArgs);
-    if (this.currentRequestContext) {
-      const requestHolder = this.currentRequestContext.get(instanceName);
-      if (requestHolder) {
-        return requestHolder.instance;
-      }
-    }
-    const [error, holder] = this.manager.get(instanceName);
-    if (error) {
-      return null;
+  /**
+   * 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.serviceLocator.getEventBus().on(dependency, "destroy", () => {
+            this.logger?.log(
+              `[InstanceResolver] Dependency ${dependency} destroyed, invalidating ${instanceName}`
+            );
+            this.serviceLocator.getServiceInvalidator().invalidate(instanceName);
+          })
+        );
+      });
     }
-    return holder.instance;
-  }
-  invalidate(service, round = 1) {
     this.logger?.log(
-      `[ServiceLocator] Starting invalidation process for ${service}`
+      `[InstanceResolver] Instance ${instanceName} created successfully`
     );
-    const toInvalidate = this.manager.filter(
-      (holder) => holder.name === service || holder.deps.has(service)
+    deferred.resolve([void 0, instance]);
+  }
+  /**
+   * Handles service instantiation errors.
+   */
+  async handleInstantiationError(instanceName, holder, deferred, scope, error) {
+    this.logger?.error(
+      `[InstanceResolver] Error creating instance for ${instanceName}`,
+      error
     );
-    const promises = [];
-    for (const [key, holder] of toInvalidate.entries()) {
-      promises.push(this.invalidateHolder(key, holder, round));
+    holder.status = "error" /* Error */;
+    holder.instance = error;
+    holder.creationPromise = null;
+    if (scope === "Singleton" /* Singleton */) {
+      this.logger?.log(
+        `[InstanceResolver] Singleton ${instanceName} failed, will be invalidated`
+      );
+      this.serviceLocator.getServiceInvalidator().invalidate(instanceName);
     }
-    return Promise.all(promises);
+    deferred.reject(error);
   }
   /**
-   * Invalidates a single holder based on its current status.
+   * Stores an instance holder based on its scope.
    */
-  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] ${key} is being created, waiting...`
+  storeInstanceByScope(scope, instanceName, holder, requestContext) {
+    switch (scope) {
+      case "Singleton" /* Singleton */:
+        this.logger?.debug(
+          `[InstanceResolver] Setting singleton instance for ${instanceName}`
         );
-        await holder.creationPromise;
-        if (round > 3) {
-          this.logger?.error(
-            `[ServiceLocator] ${key} creation triggered too many invalidation rounds`
+        this.manager.set(instanceName, holder);
+        break;
+      case "Request" /* Request */:
+        if (requestContext) {
+          this.logger?.debug(
+            `[InstanceResolver] Setting request-scoped instance for ${instanceName}`
           );
-          return;
+          requestContext.addInstance(instanceName, holder.instance, holder);
         }
-        await this.invalidate(key, round + 1);
-        break;
-      default:
-        await this.destroyHolder(key, holder);
         break;
     }
   }
   /**
-   * Destroys a holder and cleans up its resources.
+   * Creates a factory context for dependency injection during service instantiation.
    */
-  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;
+  createFactoryContext() {
+    return this.tokenProcessor.createFactoryContext(this.serviceLocator);
   }
-  async ready() {
-    const holders = Array.from(this.manager.filter(() => true)).map(
-      ([, holder]) => holder
-    );
-    await Promise.all(
-      holders.map((holder) => this.waitForHolderToSettle(holder))
-    );
+};
+
+// src/request-context-holder.mts
+var DefaultRequestContextHolder = class extends BaseInstanceHolderManager {
+  constructor(requestId, priority = 100, initialMetadata) {
+    super(null);
+    this.requestId = requestId;
+    this.priority = priority;
+    if (initialMetadata) {
+      Object.entries(initialMetadata).forEach(([key, value]) => {
+        this.metadata.set(key, value);
+      });
+    }
   }
+  metadata = /* @__PURE__ */ new Map();
+  createdAt = Date.now();
   /**
-   * Waits for a holder to settle (either created, destroyed, or error state).
+   * Public getter for holders to maintain interface compatibility.
    */
-  async waitForHolderToSettle(holder) {
-    switch (holder.status) {
-      case "creating" /* Creating */:
-        await holder.creationPromise;
-        break;
-      case "destroying" /* Destroying */:
-        await holder.destroyPromise;
-        break;
+  get holders() {
+    return this._holders;
+  }
+  /**
+   * Gets a holder by name. For RequestContextHolder, this is a simple lookup.
+   */
+  get(name) {
+    return this._holders.get(name);
+  }
+  /**
+   * Sets a holder by name.
+   */
+  set(name, holder) {
+    this._holders.set(name, holder);
+  }
+  /**
+   * 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()
+      );
+      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);
     }
   }
-  // ============================================================================
-  // REQUEST CONTEXT MANAGEMENT
-  // ============================================================================
+  clear() {
+    super.clear();
+    this.metadata.clear();
+  }
+  getMetadata(key) {
+    return this.metadata.get(key);
+  }
+  setMetadata(key, value) {
+    this.metadata.set(key, value);
+  }
+};
+function createRequestContextHolder(requestId, priority = 100, initialMetadata) {
+  return new DefaultRequestContextHolder(requestId, priority, initialMetadata);
+}
+
+// src/request-context-manager.mts
+var RequestContextManager = class {
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  requestContexts = /* @__PURE__ */ new Map();
+  currentRequestContext = null;
   /**
    * Begins a new request context with the given parameters.
    * @param requestId Unique identifier for this request
@@ -1111,7 +1151,7 @@ var ServiceLocator = class {
   beginRequest(requestId, metadata, priority = 100) {
     if (this.requestContexts.has(requestId)) {
       throw new Error(
-        `[ServiceLocator] Request context ${requestId} already exists`
+        `[RequestContextManager] Request context ${requestId} already exists`
       );
     }
     const contextHolder = new DefaultRequestContextHolder(
@@ -1121,7 +1161,9 @@ var ServiceLocator = class {
     );
     this.requestContexts.set(requestId, contextHolder);
     this.currentRequestContext = contextHolder;
-    this.logger?.log(`[ServiceLocator] Started request context: ${requestId}`);
+    this.logger?.log(
+      `[RequestContextManager] Started request context: ${requestId}`
+    );
     return contextHolder;
   }
   /**
@@ -1132,11 +1174,13 @@ var ServiceLocator = class {
     const contextHolder = this.requestContexts.get(requestId);
     if (!contextHolder) {
       this.logger?.warn(
-        `[ServiceLocator] Request context ${requestId} not found`
+        `[RequestContextManager] Request context ${requestId} not found`
       );
       return;
     }
-    this.logger?.log(`[ServiceLocator] Ending request context: ${requestId}`);
+    this.logger?.log(
+      `[RequestContextManager] Ending request context: ${requestId}`
+    );
     const cleanupPromises = [];
     for (const [, holder] of contextHolder.holders) {
       if (holder.destroyListeners.length > 0) {
@@ -1151,7 +1195,9 @@ var ServiceLocator = class {
     if (this.currentRequestContext === contextHolder) {
       this.currentRequestContext = Array.from(this.requestContexts.values()).at(-1) ?? null;
     }
-    this.logger?.log(`[ServiceLocator] Request context ${requestId} ended`);
+    this.logger?.log(
+      `[RequestContextManager] Request context ${requestId} ended`
+    );
   }
   /**
    * Gets the current request context.
@@ -1167,354 +1213,521 @@ var ServiceLocator = class {
   setCurrentRequestContext(requestId) {
     const contextHolder = this.requestContexts.get(requestId);
     if (!contextHolder) {
-      throw new Error(`[ServiceLocator] Request context ${requestId} not found`);
+      throw new Error(
+        `[RequestContextManager] Request context ${requestId} not found`
+      );
     }
     this.currentRequestContext = contextHolder;
   }
-  // ============================================================================
-  // PRIVATE METHODS
-  // ============================================================================
   /**
-   * Validates and resolves token arguments, handling factory token resolution and validation.
+   * Gets all request contexts.
+   * @returns Map of request contexts
    */
-  validateAndResolveTokenArgs(token, args) {
-    let actualToken = token;
-    if (typeof token === "function") {
-      actualToken = getInjectableToken(token);
+  getRequestContexts() {
+    return this.requestContexts;
+  }
+  /**
+   * Clears all request contexts.
+   */
+  async clearAllRequestContexts() {
+    const requestIds = Array.from(this.requestContexts.keys());
+    if (requestIds.length === 0) {
+      this.logger?.log("[RequestContextManager] No request contexts to clear");
+      return;
     }
-    let realArgs = args;
-    if (actualToken instanceof BoundInjectionToken) {
-      realArgs = actualToken.value;
-    } else if (actualToken instanceof FactoryInjectionToken) {
-      if (actualToken.resolved) {
-        realArgs = actualToken.value;
-      } else {
-        return [new FactoryTokenNotResolved(token.name), { actualToken }];
+    this.logger?.log(
+      `[RequestContextManager] Clearing ${requestIds.length} request contexts: ${requestIds.join(", ")}`
+    );
+    for (const requestId of requestIds) {
+      try {
+        await this.endRequest(requestId);
+      } catch (error) {
+        this.logger?.error(
+          `[RequestContextManager] Error clearing request context ${requestId}:`,
+          error
+        );
       }
     }
-    if (!actualToken.schema) {
-      return [void 0, { actualToken, validatedArgs: realArgs }];
+  }
+};
+
+// src/service-invalidator.mts
+var ServiceInvalidator = class {
+  constructor(manager, requestContextManager, eventBus, logger = null) {
+    this.manager = manager;
+    this.requestContextManager = requestContextManager;
+    this.eventBus = eventBus;
+    this.logger = logger;
+  }
+  /**
+   * Invalidates a service and all its dependencies.
+   */
+  invalidate(service, round = 1) {
+    this.logger?.log(
+      `[ServiceInvalidator] Starting invalidation process for ${service}`
+    );
+    const [, toInvalidate] = this.manager.get(service);
+    const promises = [];
+    if (toInvalidate) {
+      promises.push(this.invalidateHolder(service, toInvalidate, round));
     }
-    const validatedArgs = actualToken.schema?.safeParse(realArgs);
-    if (validatedArgs && !validatedArgs.success) {
-      this.logger?.error(
-        `[ServiceLocator]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`,
-        validatedArgs.error
-      );
-      return [new UnknownError(validatedArgs.error), { actualToken }];
+    const requestContexts = this.requestContextManager.getRequestContexts();
+    for (const [requestId, requestContext] of requestContexts.entries()) {
+      const holder = requestContext.get(service);
+      if (holder) {
+        this.logger?.log(
+          `[ServiceInvalidator] Invalidating request-scoped instance ${service} in request ${requestId}`
+        );
+        promises.push(
+          this.invalidateRequestHolder(requestId, service, holder, round)
+        );
+      }
     }
-    return [void 0, { actualToken, validatedArgs: validatedArgs?.data }];
+    return Promise.all(promises);
   }
   /**
-   * Internal method to resolve token args and create instance name.
-   * Handles factory token resolution and validation.
+   * 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.
    */
-  async resolveTokenAndPrepareInstanceName(token, args) {
-    const [err, { actualToken, validatedArgs }] = this.validateAndResolveTokenArgs(token, args);
-    if (err instanceof UnknownError) {
-      return [err];
-    } else if (err instanceof FactoryTokenNotResolved && actualToken instanceof FactoryInjectionToken) {
+  async clearAll(options = {}) {
+    const {
+      clearRequestContexts = true,
+      maxRounds = 10,
+      waitForSettlement = true
+    } = options;
+    this.logger?.log(
+      "[ServiceInvalidator] Starting graceful clearing of all services"
+    );
+    if (waitForSettlement) {
       this.logger?.log(
-        `[ServiceLocator]#resolveTokenAndPrepareInstanceName() Factory token not resolved, resolving it`
+        "[ServiceInvalidator] Waiting for all services to settle..."
       );
-      await actualToken.resolve(this.createFactoryContext());
-      return this.resolveTokenAndPrepareInstanceName(token);
+      await this.ready();
     }
-    const instanceName = this.generateInstanceName(actualToken, validatedArgs);
-    const realToken = actualToken instanceof BoundInjectionToken || actualToken instanceof FactoryInjectionToken ? actualToken.token : actualToken;
-    return [void 0, { instanceName, validatedArgs, actualToken, realToken }];
+    const allServiceNames = this.getAllServiceNames();
+    if (allServiceNames.length === 0) {
+      this.logger?.log("[ServiceInvalidator] No singleton services to clear");
+    } else {
+      this.logger?.log(
+        `[ServiceInvalidator] Found ${allServiceNames.length} services to clear: ${allServiceNames.join(", ")}`
+      );
+      await this.clearServicesWithDependencyAwareness(
+        allServiceNames,
+        maxRounds
+      );
+    }
+    if (clearRequestContexts) {
+      await this.requestContextManager.clearAllRequestContexts();
+    }
+    this.logger?.log("[ServiceInvalidator] Graceful clearing completed");
   }
   /**
-   * Gets an instance by its instance name, handling all the logic after instance name creation.
+   * Waits for all services to settle (either created, destroyed, or error state).
    */
-  async retrieveOrCreateInstanceByInstanceName(instanceName, realToken, realArgs) {
-    const existingHolder = await this.tryGetExistingInstance(
-      instanceName,
-      realToken
+  async ready() {
+    const holders = Array.from(this.manager.filter(() => true)).map(
+      ([, holder]) => holder
     );
-    if (existingHolder) {
-      return existingHolder;
-    }
-    const result = await this.createNewInstance(
-      instanceName,
-      realToken,
-      realArgs
+    await Promise.all(
+      holders.map((holder) => this.waitForHolderToSettle(holder))
     );
-    if (result[0]) {
-      return [result[0]];
+  }
+  /**
+   * Invalidates a single holder based on its current status.
+   */
+  async invalidateHolder(key, holder, round) {
+    await this.invalidateHolderByStatus(holder, round, {
+      context: key,
+      isRequestScoped: false,
+      onCreationError: () => this.logger?.error(
+        `[ServiceInvalidator] ${key} creation triggered too many invalidation rounds`
+      ),
+      onRecursiveInvalidate: () => this.invalidate(key, round + 1),
+      onDestroy: () => this.destroyHolder(key, holder)
+    });
+  }
+  /**
+   * Invalidates a request-scoped holder based on its current status.
+   */
+  async invalidateRequestHolder(requestId, instanceName, holder, round) {
+    await this.invalidateHolderByStatus(holder, round, {
+      context: `Request-scoped ${instanceName} in ${requestId}`,
+      isRequestScoped: true,
+      onCreationError: () => this.logger?.error(
+        `[ServiceInvalidator] Request-scoped ${instanceName} in ${requestId} creation triggered too many invalidation rounds`
+      ),
+      onRecursiveInvalidate: () => this.invalidateRequestHolder(
+        requestId,
+        instanceName,
+        holder,
+        round + 1
+      ),
+      onDestroy: () => this.destroyRequestHolder(requestId, instanceName, holder)
+    });
+  }
+  /**
+   * Common invalidation logic for holders based on their status.
+   */
+  async invalidateHolderByStatus(holder, round, options) {
+    switch (holder.status) {
+      case "destroying" /* Destroying */:
+        await holder.destroyPromise;
+        break;
+      case "creating" /* Creating */:
+        await holder.creationPromise;
+        if (round > 3) {
+          options.onCreationError();
+          return;
+        }
+        await options.onRecursiveInvalidate();
+        break;
+      default:
+        await options.onDestroy();
+        break;
     }
-    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.
+   * Destroys a holder and cleans up its resources.
+   */
+  async destroyHolder(key, holder) {
+    await this.destroyHolderWithCleanup(holder, {
+      context: key,
+      logMessage: `[ServiceInvalidator] Invalidating ${key} and notifying listeners`,
+      cleanup: () => this.manager.delete(key),
+      eventName: key
+    });
+  }
+  /**
+   * Destroys a request-scoped holder and cleans up its resources.
+   */
+  async destroyRequestHolder(requestId, instanceName, holder) {
+    await this.destroyHolderWithCleanup(holder, {
+      context: `Request-scoped ${instanceName} in ${requestId}`,
+      logMessage: `[ServiceInvalidator] Invalidating request-scoped ${instanceName} in ${requestId} and notifying listeners`,
+      cleanup: () => {
+        const requestContext = this.requestContextManager.getRequestContexts().get(requestId);
+        if (requestContext) {
+          requestContext.delete(instanceName);
+        }
+      },
+      eventName: instanceName
+    });
+  }
+  /**
+   * Common destroy logic for holders with customizable cleanup.
+   */
+  async destroyHolderWithCleanup(holder, options) {
+    holder.status = "destroying" /* Destroying */;
+    this.logger?.log(options.logMessage);
+    holder.destroyPromise = Promise.all(
+      holder.destroyListeners.map((listener) => listener())
+    ).then(async () => {
+      holder.destroyListeners = [];
+      holder.deps.clear();
+      options.cleanup();
+      await this.emitInstanceEvent(options.eventName, "destroy");
+    });
+    await holder.destroyPromise;
+  }
+  /**
+   * Waits for a holder to settle (either created, destroyed, or error state).
    */
-  async tryGetExistingInstance(instanceName, realToken) {
-    const requestResult = await this.tryGetRequestScopedInstance(
-      instanceName,
-      realToken
-    );
-    if (requestResult) {
-      return requestResult;
+  async waitForHolderToSettle(holder) {
+    switch (holder.status) {
+      case "creating" /* Creating */:
+        await holder.creationPromise;
+        break;
+      case "destroying" /* Destroying */:
+        await holder.destroyPromise;
+        break;
     }
-    return this.tryGetSingletonInstance(instanceName);
   }
   /**
-   * Attempts to get a request-scoped instance if applicable.
+   * Clears services with dependency awareness, ensuring proper cleanup order.
+   * Services with no dependencies are cleared first, then services that depend on them.
    */
-  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) {
+  async clearServicesWithDependencyAwareness(serviceNames, maxRounds) {
+    const clearedServices = /* @__PURE__ */ new Set();
+    let round = 1;
+    while (clearedServices.size < serviceNames.length && round <= maxRounds) {
       this.logger?.log(
-        `[ServiceLocator] No current request context available for request-scoped service ${instanceName}`
+        `[ServiceInvalidator] Clearing round ${round}/${maxRounds}, ${clearedServices.size}/${serviceNames.length} services cleared`
+      );
+      const servicesToClearThisRound = this.findServicesReadyForClearing(
+        serviceNames,
+        clearedServices
+      );
+      if (servicesToClearThisRound.length === 0) {
+        const remainingServices = serviceNames.filter(
+          (name) => !clearedServices.has(name)
+        );
+        if (remainingServices.length > 0) {
+          this.logger?.warn(
+            `[ServiceInvalidator] No services ready for clearing, forcing cleanup of remaining: ${remainingServices.join(", ")}`
+          );
+          await this.forceClearServices(remainingServices);
+          remainingServices.forEach((name) => clearedServices.add(name));
+        }
+        break;
+      }
+      const clearPromises = servicesToClearThisRound.map(
+        async (serviceName) => {
+          try {
+            await this.invalidate(serviceName, round);
+            clearedServices.add(serviceName);
+            this.logger?.log(
+              `[ServiceInvalidator] Successfully cleared service: ${serviceName}`
+            );
+          } catch (error) {
+            this.logger?.error(
+              `[ServiceInvalidator] Error clearing service ${serviceName}:`,
+              error
+            );
+            clearedServices.add(serviceName);
+          }
+        }
       );
-      return [new UnknownError("InstanceNotFound" /* InstanceNotFound */)];
+      await Promise.all(clearPromises);
+      round++;
     }
-    const requestHolder = this.currentRequestContext.get(instanceName);
-    if (!requestHolder) {
-      return null;
+    if (clearedServices.size < serviceNames.length) {
+      this.logger?.warn(
+        `[ServiceInvalidator] Clearing completed after ${maxRounds} rounds, but ${serviceNames.length - clearedServices.size} services may not have been properly cleared`
+      );
     }
-    return this.waitForInstanceReady(requestHolder);
   }
   /**
-   * Attempts to get a singleton instance from the manager.
+   * Finds services that are ready to be cleared in the current round.
+   * A service is ready if all its dependencies have already been cleared.
    */
-  async tryGetSingletonInstance(instanceName) {
-    const [error, holder] = this.manager.get(instanceName);
-    if (!error) {
-      return this.waitForInstanceReady(holder);
-    }
-    switch (error.code) {
-      case "InstanceDestroying" /* InstanceDestroying */:
-        this.logger?.log(
-          `[ServiceLocator] Instance ${instanceName} is being destroyed, waiting...`
-        );
-        await holder?.destroyPromise;
-        return this.tryGetSingletonInstance(instanceName);
-      case "InstanceExpired" /* InstanceExpired */:
-        this.logger?.log(
-          `[ServiceLocator] Instance ${instanceName} expired, invalidating...`
+  findServicesReadyForClearing(allServiceNames, clearedServices) {
+    return allServiceNames.filter((serviceName) => {
+      if (clearedServices.has(serviceName)) {
+        return false;
+      }
+      const [error, holder] = this.manager.get(serviceName);
+      if (error) {
+        return true;
+      }
+      const hasUnclearedDependencies = Array.from(holder.deps).some(
+        (dep) => !clearedServices.has(dep)
+      );
+      return !hasUnclearedDependencies;
+    });
+  }
+  /**
+   * Force clears services that couldn't be cleared through normal dependency resolution.
+   * This handles edge cases like circular dependencies.
+   */
+  async forceClearServices(serviceNames) {
+    const promises = serviceNames.map(async (serviceName) => {
+      try {
+        const [error, holder] = this.manager.get(serviceName);
+        if (!error && holder) {
+          await this.destroyHolder(serviceName, holder);
+        }
+      } catch (error) {
+        this.logger?.error(
+          `[ServiceInvalidator] Error force clearing service ${serviceName}:`,
+          error
         );
-        await this.invalidate(instanceName);
-        return this.tryGetSingletonInstance(instanceName);
-      case "InstanceNotFound" /* InstanceNotFound */:
-        return null;
-      // Instance doesn't exist, should create new one
-      default:
-        return [error];
-    }
+      }
+    });
+    await Promise.all(promises);
   }
   /**
-   * Waits for an instance holder to be ready and returns the appropriate result.
+   * Gets all service names currently managed by the ServiceLocator.
    */
-  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 */)];
-    }
+  getAllServiceNames() {
+    return this.manager.getAllNames();
   }
   /**
    * Emits events to listeners for instance lifecycle events.
    */
   emitInstanceEvent(name, event = "create") {
     this.logger?.log(
-      `[ServiceLocator]#emitInstanceEvent() Notifying listeners for ${name} with event ${event}`
+      `[ServiceInvalidator]#emitInstanceEvent() Notifying listeners for ${name} with event ${event}`
     );
     return this.eventBus.emit(name, event);
   }
-  /**
-   * Creates a new instance for the given token and arguments.
-   */
-  async createNewInstance(instanceName, realToken, args) {
-    this.logger?.log(
-      `[ServiceLocator]#createNewInstance() Creating instance for ${instanceName}`
-    );
-    if (this.registry.has(realToken)) {
-      return this.instantiateServiceFromRegistry(
-        instanceName,
-        realToken,
-        args
-      );
-    } else {
-      return [new FactoryNotFound(realToken.name.toString())];
+};
+
+// src/service-locator-event-bus.mts
+var ServiceLocatorEventBus = class {
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  listeners = /* @__PURE__ */ new Map();
+  on(ns, event, listener) {
+    this.logger?.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
+    if (!this.listeners.has(ns)) {
+      this.listeners.set(ns, /* @__PURE__ */ new Map());
+    }
+    const nsEvents = this.listeners.get(ns);
+    if (!nsEvents.has(event)) {
+      nsEvents.set(event, /* @__PURE__ */ new Set());
     }
+    nsEvents.get(event).add(listener);
+    return () => {
+      nsEvents.get(event).delete(listener);
+      if (nsEvents.get(event)?.size === 0) {
+        nsEvents.delete(event);
+      }
+      if (nsEvents.size === 0) {
+        this.listeners.delete(ns);
+      }
+    };
   }
-  /**
-   * Instantiates a service from the registry using the service instantiator.
-   */
-  instantiateServiceFromRegistry(instanceName, token, args) {
-    this.logger?.log(
-      `[ServiceLocator]#instantiateServiceFromRegistry(): Creating instance for ${instanceName} from abstract factory`
-    );
-    const ctx = this.createFactoryContext(
-      this.currentRequestContext || void 0
-    );
-    let record = this.registry.get(token);
-    let { scope, type } = record;
-    const [deferred, holder] = this.manager.createCreatingHolder(
-      instanceName,
-      type,
-      scope,
-      ctx.deps,
-      Infinity
-    );
-    this.serviceInstantiator.instantiateService(ctx, record, args).then(async ([error, instance]) => {
-      await this.handleInstantiationResult(
-        instanceName,
-        holder,
-        ctx,
-        deferred,
-        scope,
-        error,
-        instance
-      );
-    }).catch(async (error) => {
-      await this.handleInstantiationError(
-        instanceName,
-        holder,
-        deferred,
-        scope,
-        error
-      );
+  async emit(key, event) {
+    if (!this.listeners.has(key)) {
+      return;
+    }
+    const events = this.listeners.get(key);
+    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
+    const res = await Promise.allSettled(
+      [...events.get(event) ?? []].map((listener) => listener(event))
+    ).then((results) => {
+      const res2 = results.filter((result) => result.status === "rejected").map((result) => {
+        this.logger?.warn(
+          `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
+          result.reason
+        );
+        return result;
+      });
+      if (res2.length > 0) {
+        return Promise.reject(res2);
+      }
+      return results;
     });
-    this.storeInstanceByScope(scope, instanceName, holder);
-    return [void 0, holder];
+    return res;
   }
-  /**
-   * 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
-      );
+};
+
+// src/service-locator-manager.mts
+var ServiceLocatorManager = class extends BaseInstanceHolderManager {
+  constructor(logger = null) {
+    super(logger);
+  }
+  get(name) {
+    const holder = this._holders.get(name);
+    if (holder) {
+      if (holder.status === "destroying" /* Destroying */) {
+        this.logger?.log(
+          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`
+        );
+        return [DIError.instanceDestroying(holder.name), holder];
+      } else if (holder.status === "error" /* Error */) {
+        this.logger?.log(
+          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is in error state`
+        );
+        return [holder.instance, holder];
+      }
+      return [void 0, holder];
     } else {
-      await this.handleInstantiationSuccess(
-        instanceName,
-        holder,
-        ctx,
-        deferred,
-        instance
+      this.logger?.log(
+        `[ServiceLocatorManager]#getInstanceHolder() Instance ${name} not found`
       );
+      return [DIError.instanceNotFound(name)];
     }
   }
+  set(name, holder) {
+    this._holders.set(name, holder);
+  }
+  has(name) {
+    const [error, holder] = this.get(name);
+    if (!error) {
+      return [void 0, true];
+    }
+    if (error.code === "InstanceDestroying" /* InstanceDestroying */) {
+      return [error];
+    }
+    return [void 0, !!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.
+   * @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(name, instance, type, scope, deps = /* @__PURE__ */ new Set()) {
+    const holder = this.createCreatedHolder(name, instance, type, scope, deps);
+    this._holders.set(name, holder);
+    return holder;
+  }
+};
+
+// src/token-processor.mts
+var TokenProcessor = class {
+  constructor(logger = null) {
+    this.logger = logger;
+  }
   /**
-   * Handles successful service instantiation.
+   * Validates and resolves token arguments, handling factory token resolution and validation.
    */
-  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)
-          )
-        );
-      });
+  validateAndResolveTokenArgs(token, args) {
+    let actualToken = token;
+    if (typeof token === "function") {
+      actualToken = getInjectableToken(token);
     }
-    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);
+    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 }];
+      }
     }
-    deferred.reject(error);
+    if (!actualToken.schema) {
+      return [void 0, { actualToken, validatedArgs: realArgs }];
+    }
+    const validatedArgs = actualToken.schema?.safeParse(realArgs);
+    if (validatedArgs && !validatedArgs.success) {
+      this.logger?.error(
+        `[TokenProcessor]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`,
+        validatedArgs.error
+      );
+      return [DIError.unknown(validatedArgs.error), { actualToken }];
+    }
+    return [void 0, { actualToken, validatedArgs: validatedArgs?.data }];
   }
   /**
-   * Stores an instance holder based on its scope.
+   * Generates a unique instance name based on token and arguments.
    */
-  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;
+  generateInstanceName(token, args) {
+    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, "=")}`;
   }
   /**
-   * Tries to get a pre-prepared instance from request contexts.
+   * Formats a single argument value for instance name generation.
    */
-  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;
-      }
+  formatArgValue(value) {
+    if (typeof value === "function") {
+      return `fn_${value.name}(${value.length})`;
     }
-    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;
-      }
+    if (typeof value === "symbol") {
+      return value.toString();
     }
-    return void 0;
+    return JSON.stringify(value).slice(0, 40);
   }
   /**
    * Creates a factory context for dependency injection during service instantiation.
-   * @param contextHolder Optional request context holder for priority-based resolution
+   * @param serviceLocator Reference to the service locator for dependency resolution
    */
-  createFactoryContext(contextHolder) {
+  createFactoryContext(serviceLocator) {
     const destroyListeners = /* @__PURE__ */ new Set();
     const deps = /* @__PURE__ */ new Set();
-    const self = this;
     function addDestroyListener(listener) {
       destroyListeners.add(listener);
     }
@@ -1524,20 +1737,11 @@ var ServiceLocator = class {
     return {
       // @ts-expect-error This is correct type
       async inject(token, args) {
-        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(
+        const [error, instance] = await serviceLocator.getInstance(
           token,
           args,
-          ({ instanceName: instanceName2 }) => {
-            deps.add(instanceName2);
+          ({ instanceName }) => {
+            deps.add(instanceName);
           }
         );
         if (error) {
@@ -1547,31 +1751,204 @@ var ServiceLocator = class {
       },
       addDestroyListener,
       getDestroyListeners,
-      locator: self,
+      locator: serviceLocator,
       deps
     };
   }
   /**
-   * Generates a unique instance name based on token and arguments.
+   * Tries to get a pre-prepared instance from request contexts.
    */
-  generateInstanceName(token, args) {
-    if (!args) {
-      return token.toString();
+  tryGetPrePreparedInstance(instanceName, contextHolder, deps, currentRequestContext) {
+    if (contextHolder && contextHolder.priority > 0) {
+      const prePreparedInstance = contextHolder.get(instanceName)?.instance;
+      if (prePreparedInstance !== void 0) {
+        this.logger?.debug(
+          `[TokenProcessor] Using pre-prepared instance ${instanceName} from request context ${contextHolder.requestId}`
+        );
+        deps.add(instanceName);
+        return prePreparedInstance;
+      }
     }
-    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, "=")}`;
+    if (currentRequestContext && currentRequestContext !== contextHolder) {
+      const prePreparedInstance = currentRequestContext.get(instanceName)?.instance;
+      if (prePreparedInstance !== void 0) {
+        this.logger?.debug(
+          `[TokenProcessor] Using pre-prepared instance ${instanceName} from current request context ${currentRequestContext.requestId}`
+        );
+        deps.add(instanceName);
+        return prePreparedInstance;
+      }
+    }
+    return void 0;
   }
-  /**
-   * Formats a single argument value for instance name generation.
-   */
-  formatArgValue(value) {
-    if (typeof value === "function") {
-      return `fn_${value.name}(${value.length})`;
+};
+
+// src/service-locator.mts
+var ServiceLocator = class {
+  constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
+    this.registry = registry;
+    this.logger = logger;
+    this.injectors = injectors;
+    this.eventBus = new ServiceLocatorEventBus(logger);
+    this.manager = new ServiceLocatorManager(logger);
+    this.serviceInstantiator = new ServiceInstantiator(injectors);
+    this.tokenProcessor = new TokenProcessor(logger);
+    this.requestContextManager = new RequestContextManager(logger);
+    this.serviceInvalidator = new ServiceInvalidator(
+      this.manager,
+      this.requestContextManager,
+      this.eventBus,
+      logger
+    );
+    this.instanceResolver = new InstanceResolver(
+      this.registry,
+      this.manager,
+      this.serviceInstantiator,
+      this.tokenProcessor,
+      logger,
+      this
+    );
+  }
+  eventBus;
+  manager;
+  serviceInstantiator;
+  tokenProcessor;
+  requestContextManager;
+  serviceInvalidator;
+  instanceResolver;
+  // ============================================================================
+  // PUBLIC METHODS
+  // ============================================================================
+  getEventBus() {
+    return this.eventBus;
+  }
+  getManager() {
+    return this.manager;
+  }
+  getRequestContexts() {
+    return this.requestContextManager.getRequestContexts();
+  }
+  getRequestContextManager() {
+    return this.requestContextManager;
+  }
+  getServiceInvalidator() {
+    return this.serviceInvalidator;
+  }
+  getInstanceIdentifier(token, args) {
+    const [err, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
+    if (err) {
+      throw err;
     }
-    if (typeof value === "symbol") {
-      return value.toString();
+    return this.tokenProcessor.generateInstanceName(actualToken, validatedArgs);
+  }
+  async getInstance(token, args, onPrepare) {
+    const [err, data] = await this.instanceResolver.resolveInstance(
+      token,
+      args,
+      this.requestContextManager.getCurrentRequestContext() || void 0
+    );
+    if (err) {
+      return [err];
     }
-    return JSON.stringify(value).slice(0, 40);
+    if (onPrepare) {
+      const instanceName = this.getInstanceIdentifier(token, args);
+      const [tokenErr, { actualToken, validatedArgs }] = this.tokenProcessor.validateAndResolveTokenArgs(token, args);
+      if (!tokenErr) {
+        onPrepare({ instanceName, actualToken, validatedArgs });
+      }
+    }
+    return [void 0, data];
+  }
+  async getOrThrowInstance(token, args) {
+    const [error, instance] = await this.getInstance(token, args);
+    if (error) {
+      throw error;
+    }
+    return instance;
+  }
+  getSyncInstance(token, args) {
+    return this.instanceResolver.getSyncInstance(
+      token,
+      args,
+      this.requestContextManager.getCurrentRequestContext()
+    );
+  }
+  invalidate(service, round = 1) {
+    return this.serviceInvalidator.invalidate(service, round);
+  }
+  /**
+   * 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
+   */
+  async clearAll(options = {}) {
+    return this.serviceInvalidator.clearAll(options);
+  }
+  // ============================================================================
+  // REQUEST CONTEXT MANAGEMENT
+  // ============================================================================
+  /**
+   * Begins a new request context with the given parameters.
+   * @param requestId Unique identifier for this request
+   * @param metadata Optional metadata for the request
+   * @param priority Priority for resolution (higher = more priority)
+   * @returns The created request context holder
+   */
+  beginRequest(requestId, metadata, priority = 100) {
+    return this.requestContextManager.beginRequest(
+      requestId,
+      metadata,
+      priority
+    );
+  }
+  /**
+   * Ends a request context and cleans up all associated instances.
+   * @param requestId The request ID to end
+   */
+  async endRequest(requestId) {
+    return this.requestContextManager.endRequest(requestId);
+  }
+  /**
+   * Gets the current request context.
+   * @returns The current request context holder or null
+   */
+  getCurrentRequestContext() {
+    return this.requestContextManager.getCurrentRequestContext();
+  }
+  /**
+   * Sets the current request context.
+   * @param requestId The request ID to set as current
+   */
+  setCurrentRequestContext(requestId) {
+    return this.requestContextManager.setCurrentRequestContext(requestId);
+  }
+  /**
+   * Waits for all services to settle (either created, destroyed, or error state).
+   */
+  async ready() {
+    return this.serviceInvalidator.ready();
+  }
+  /**
+   * Helper method for TokenProcessor to access pre-prepared instances.
+   * This is needed for the factory context creation.
+   */
+  tryGetPrePreparedInstance(instanceName, contextHolder, deps) {
+    return this.tokenProcessor.tryGetPrePreparedInstance(
+      instanceName,
+      contextHolder,
+      deps,
+      this.requestContextManager.getCurrentRequestContext()
+    );
+  }
+  /**
+   * Helper method for InstanceResolver to generate instance names.
+   * This is needed for the factory context creation.
+   */
+  generateInstanceName(token, args) {
+    return this.tokenProcessor.generateInstanceName(token, args);
   }
 };
 
@@ -1579,11 +1956,14 @@ var ServiceLocator = class {
 var _Container_decorators, _init2;
 _Container_decorators = [Injectable()];
 var _Container = class _Container {
-  serviceLocator;
   constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
+    this.registry = registry;
+    this.logger = logger;
+    this.injectors = injectors;
     this.serviceLocator = new ServiceLocator(registry, logger, injectors);
     this.registerSelf();
   }
+  serviceLocator;
   registerSelf() {
     const token = getInjectableToken(_Container);
     const instanceName = this.serviceLocator.getInstanceIdentifier(token);
@@ -1607,15 +1987,54 @@ var _Container = class _Container {
    * Invalidates a service and its dependencies
    */
   async invalidate(service) {
-    const holderMap = this.serviceLocator.getManager().filter((holder2) => holder2.instance === service);
-    if (holderMap.size === 0) {
-      return;
-    }
-    const holder = holderMap.values().next().value;
+    const holder = this.getHolderByInstance(service);
     if (holder) {
       await this.serviceLocator.invalidate(holder.name);
+    } else {
+      const requestHolder = this.getRequestHolderByInstance(service);
+      if (requestHolder) {
+        await this.serviceLocator.invalidate(requestHolder.name);
+      }
+    }
+  }
+  /**
+   * Gets a service holder by instance (reverse lookup)
+   */
+  getHolderByInstance(instance) {
+    const holderMap = Array.from(
+      this.serviceLocator.getManager().filter((holder) => holder.instance === instance).values()
+    );
+    return holderMap.length > 0 ? holderMap[0] : null;
+  }
+  getRequestHolderByInstance(instance) {
+    const requestContexts = this.serviceLocator.getRequestContextManager().getRequestContexts();
+    if (requestContexts) {
+      for (const requestContext of requestContexts.values()) {
+        for (const holder of requestContext.holders.values()) {
+          if (holder.instance === instance) {
+            return holder;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Checks if a service is registered in the container
+   */
+  isRegistered(token) {
+    try {
+      return this.serviceLocator.getInstanceIdentifier(token) !== null;
+    } catch {
+      return false;
     }
   }
+  /**
+   * Disposes the container and cleans up all resources
+   */
+  async dispose() {
+    await this.serviceLocator.clearAll();
+  }
   /**
    * Waits for all pending operations to complete
    */
@@ -1656,6 +2075,13 @@ var _Container = class _Container {
   setCurrentRequestContext(requestId) {
     this.serviceLocator.setCurrentRequestContext(requestId);
   }
+  /**
+   * Clears all instances and bindings from the container.
+   * This is useful for testing or resetting the container state.
+   */
+  clear() {
+    return this.serviceLocator.clearAll();
+  }
 };
 _init2 = __decoratorStart();
 _Container = __decorateElement(_init2, 0, "Container", _Container_decorators, _Container);
@@ -1665,36 +2091,36 @@ var Container = _Container;
 exports.BaseInstanceHolderManager = BaseInstanceHolderManager;
 exports.BoundInjectionToken = BoundInjectionToken;
 exports.Container = Container;
+exports.DIError = DIError;
+exports.DIErrorCode = DIErrorCode;
 exports.DefaultRequestContextHolder = DefaultRequestContextHolder;
-exports.Deferred = Deferred;
-exports.ErrorsEnum = ErrorsEnum;
+exports.ErrorsEnum = DIErrorCode;
 exports.Factory = Factory;
 exports.FactoryInjectionToken = FactoryInjectionToken;
-exports.FactoryNotFound = FactoryNotFound;
-exports.FactoryTokenNotResolved = FactoryTokenNotResolved;
+exports.FactoryNotFound = DIError;
+exports.FactoryTokenNotResolved = DIError;
 exports.Injectable = Injectable;
 exports.InjectableScope = InjectableScope;
 exports.InjectableTokenMeta = InjectableTokenMeta;
 exports.InjectableType = InjectableType;
 exports.InjectionToken = InjectionToken;
-exports.InstanceDestroying = InstanceDestroying;
-exports.InstanceExpired = InstanceExpired;
-exports.InstanceNotFound = InstanceNotFound;
+exports.InstanceDestroying = DIError;
+exports.InstanceNotFound = DIError;
 exports.Registry = Registry;
 exports.ServiceInstantiator = ServiceInstantiator;
 exports.ServiceLocator = ServiceLocator;
 exports.ServiceLocatorEventBus = ServiceLocatorEventBus;
 exports.ServiceLocatorInstanceHolderStatus = ServiceLocatorInstanceHolderStatus;
 exports.ServiceLocatorManager = ServiceLocatorManager;
-exports.UnknownError = UnknownError;
+exports.UnknownError = DIError;
 exports.asyncInject = asyncInject;
-exports.createDeferred = createDeferred;
 exports.createRequestContextHolder = createRequestContextHolder;
 exports.defaultInjectors = defaultInjectors;
 exports.getInjectableToken = getInjectableToken;
 exports.getInjectors = getInjectors;
 exports.globalRegistry = globalRegistry;
 exports.inject = inject;
+exports.optional = optional;
 exports.provideFactoryContext = provideFactoryContext;
 exports.wrapSyncInit = wrapSyncInit;
 //# sourceMappingURL=index.js.map