@navios/di 0.5.1 → 0.6.1

package/lib/index.js

@@ -1,2127 +0,0 @@
-'use strict';
-
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decoratorStart = (base) => [, , , __create(null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var it, done, ctx, k = flags & 7, p = false;
-  var j = 0;
-  var extraInitializers = array[j] || (array[j] = []);
-  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
-  __name(target, name);
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    it = (0, decorators[i])(target, ctx), done._ = 1;
-    __expectFn(it) && (target = it);
-  }
-  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-
-// src/enums/injectable-scope.enum.mts
-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__ */ ((InjectableType5) => {
-  InjectableType5["Class"] = "Class";
-  InjectableType5["Factory"] = "Factory";
-  return InjectableType5;
-})(InjectableType || {});
-
-// src/injection-token.mts
-var InjectionToken = class _InjectionToken {
-  constructor(name, schema) {
-    this.name = name;
-    this.schema = schema;
-  }
-  id = globalThis.crypto.randomUUID();
-  formattedName = null;
-  static create(name, schema) {
-    return new _InjectionToken(name, schema);
-  }
-  static bound(token, value) {
-    return new BoundInjectionToken(token, value);
-  }
-  static factory(token, factory) {
-    return new FactoryInjectionToken(token, factory);
-  }
-  static refineType(token) {
-    return token;
-  }
-  toString() {
-    if (this.formattedName) {
-      return this.formattedName;
-    }
-    const { name } = this;
-    if (typeof name === "function") {
-      const className = name.name;
-      this.formattedName = `${className}(${this.id})`;
-    } else if (typeof name === "symbol") {
-      this.formattedName = `${name.toString()}(${this.id})`;
-    } else {
-      this.formattedName = `${name}(${this.id})`;
-    }
-    return this.formattedName;
-  }
-};
-var BoundInjectionToken = class {
-  constructor(token, value) {
-    this.token = token;
-    this.value = value;
-    this.name = token.name;
-    this.id = token.id;
-    this.schema = token.schema;
-  }
-  id;
-  name;
-  schema;
-  toString() {
-    return this.token.toString();
-  }
-};
-var FactoryInjectionToken = class {
-  constructor(token, factory) {
-    this.token = token;
-    this.factory = factory;
-    this.name = token.name;
-    this.id = token.id;
-    this.schema = token.schema;
-  }
-  value;
-  resolved = false;
-  id;
-  name;
-  schema;
-  async resolve(ctx) {
-    if (!this.value) {
-      this.value = await this.factory(ctx);
-      this.resolved = true;
-    }
-    return this.value;
-  }
-  toString() {
-    return this.token.toString();
-  }
-};
-
-// src/registry.mts
-var Registry = class {
-  constructor(parent) {
-    this.parent = parent;
-  }
-  factories = /* @__PURE__ */ new Map();
-  has(token) {
-    if (this.factories.has(token.id)) {
-      return true;
-    }
-    if (this.parent) {
-      return this.parent.has(token);
-    }
-    return false;
-  }
-  get(token) {
-    const factory = this.factories.get(token.id);
-    if (!factory) {
-      if (this.parent) {
-        return this.parent.get(token);
-      }
-      throw new Error(`[Registry] No factory found for ${token.toString()}`);
-    }
-    return factory;
-  }
-  set(token, scope, target, type) {
-    this.factories.set(token.id, { scope, originalToken: token, target, type });
-  }
-  delete(token) {
-    this.factories.delete(token.id);
-  }
-};
-var globalRegistry = new Registry();
-
-// src/symbols/injectable-token.mts
-var InjectableTokenMeta = /* @__PURE__ */ Symbol.for("InjectableTokenMeta");
-
-// src/decorators/factory.decorator.mts
-function Factory({
-  scope = "Singleton" /* Singleton */,
-  token,
-  registry = globalRegistry
-} = {}) {
-  return (target, context) => {
-    if (context && context.kind !== "class" || target instanceof Function && !context) {
-      throw new Error(
-        "[ServiceLocator] @Factory decorator can only be used on classes."
-      );
-    }
-    let injectableToken = token ?? InjectionToken.create(target);
-    registry.set(injectableToken, scope, target, "Factory" /* Factory */);
-    target[InjectableTokenMeta] = injectableToken;
-    return target;
-  };
-}
-function Injectable({
-  scope = "Singleton" /* Singleton */,
-  token,
-  schema,
-  registry = globalRegistry
-} = {}) {
-  return (target, context) => {
-    if (context && context.kind !== "class" || target instanceof Function && !context) {
-      throw new Error(
-        "[ServiceLocator] @Injectable decorator can only be used on classes."
-      );
-    }
-    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/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 }
-    );
-  }
-  static factoryTokenNotResolved(token) {
-    return new _DIError(
-      "FactoryTokenNotResolved" /* FactoryTokenNotResolved */,
-      `Factory token not resolved: ${token?.toString() ?? "unknown"}`,
-      { token }
-    );
-  }
-  static instanceNotFound(name) {
-    return new _DIError(
-      "InstanceNotFound" /* InstanceNotFound */,
-      `Instance ${name} not found`,
-      { name }
-    );
-  }
-  static instanceDestroying(name) {
-    return new _DIError(
-      "InstanceDestroying" /* InstanceDestroying */,
-      `Instance ${name} destroying`,
-      { name }
-    );
-  }
-  static unknown(message, context) {
-    if (message instanceof Error) {
-      return new _DIError("UnknownError" /* UnknownError */, message.message, {
-        ...context,
-        parent: message
-      });
-    }
-    return new _DIError("UnknownError" /* UnknownError */, message, context);
-  }
-};
-
-// src/utils/get-injectors.mts
-function getInjectors() {
-  let currentFactoryContext = null;
-  function provideFactoryContext2(context) {
-    const original = currentFactoryContext;
-    currentFactoryContext = context;
-    return original;
-  }
-  function getFactoryContext() {
-    if (!currentFactoryContext) {
-      throw new Error(
-        "[Injector] Trying to access injection context outside of a injectable context"
-      );
-    }
-    return currentFactoryContext;
-  }
-  let promiseCollector = null;
-  let injectState = null;
-  function getRequest(token, args) {
-    if (!injectState) {
-      throw new Error(
-        "[Injector] Trying to make a request outside of a injectable context"
-      );
-    }
-    if (injectState.isFrozen) {
-      const idx = injectState.currentIndex++;
-      const request2 = injectState.requests[idx];
-      if (request2.token !== token) {
-        throw new Error(
-          `[Injector] Wrong token order. Expected ${request2.token.toString()} but got ${token.toString()}`
-        );
-      }
-      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 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) => {
-      const promises = [];
-      const originalPromiseCollector = promiseCollector;
-      const originalInjectState = injectState;
-      injectState = previousState ? {
-        ...previousState,
-        currentIndex: 0
-      } : {
-        currentIndex: 0,
-        isFrozen: false,
-        requests: []
-      };
-      promiseCollector = (promise) => {
-        promises.push(promise);
-      };
-      const result = cb();
-      promiseCollector = originalPromiseCollector;
-      const newInjectState = {
-        ...injectState,
-        isFrozen: true
-      };
-      injectState = originalInjectState;
-      return [result, promises, newInjectState];
-    };
-  }
-  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) {
-        promiseCollector(request.promise);
-      }
-      return new Proxy(
-        {},
-        {
-          get() {
-            throw new Error(
-              `[Injector] Trying to access ${realToken.toString()} before it's initialized, please move the code to a onServiceInit method`
-            );
-          }
-        }
-      );
-    }
-    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
-  };
-  return injectors;
-}
-
-// src/utils/get-injectable-token.mts
-function getInjectableToken(target) {
-  const token = target[InjectableTokenMeta];
-  if (!token) {
-    throw new Error(
-      `[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`
-    );
-  }
-  return token;
-}
-
-// 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/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
-   * @returns A tuple containing the deferred promise and the holder
-   */
-  createCreatingHolder(name, type, scope, deps = /* @__PURE__ */ new Set()) {
-    const deferred = Promise.withResolvers();
-    const holder = {
-      status: "creating" /* Creating */,
-      name,
-      instance: null,
-      creationPromise: deferred.promise,
-      destroyPromise: null,
-      type,
-      scope,
-      deps,
-      destroyListeners: [],
-      createdAt: Date.now()
-    };
-    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
-   * @returns The created holder
-   */
-  createCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set()) {
-    const holder = {
-      status: "created" /* Created */,
-      name,
-      instance,
-      creationPromise: null,
-      destroyPromise: null,
-      type,
-      scope,
-      deps,
-      destroyListeners: [],
-      createdAt: Date.now()
-    };
-    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 */ })];
-exports.EventEmitter = class EventEmitter {
-  listeners = /* @__PURE__ */ new Map();
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(event).add(listener);
-    return () => {
-      this.off(event, listener);
-    };
-  }
-  off(event, listener) {
-    if (!this.listeners.has(event)) {
-      return;
-    }
-    this.listeners.get(event).delete(listener);
-    if (this.listeners.get(event).size === 0) {
-      this.listeners.delete(event);
-    }
-  }
-  once(event, listener) {
-    const off = this.on(event, (...args) => {
-      off();
-      listener(...args);
-    });
-    return off;
-  }
-  async emit(event, ...args) {
-    if (!this.listeners.has(event)) {
-      return;
-    }
-    return Promise.all(
-      Array.from(this.listeners.get(event)).map(
-        (listener) => listener(...args)
-      )
-    );
-  }
-};
-_init = __decoratorStart();
-exports.EventEmitter = __decorateElement(_init, 0, "EventEmitter", _EventEmitter_decorators, exports.EventEmitter);
-__runInitializers(_init, 1, exports.EventEmitter);
-
-// src/injector.mts
-var defaultInjectors = getInjectors();
-var asyncInject = defaultInjectors.asyncInject;
-var inject = defaultInjectors.inject;
-var optional = defaultInjectors.optional;
-var wrapSyncInit = defaultInjectors.wrapSyncInit;
-var provideFactoryContext = defaultInjectors.provideFactoryContext;
-
-// src/service-instantiator.mts
-var ServiceInstantiator = class {
-  constructor(injectors) {
-    this.injectors = injectors;
-  }
-  /**
-   * Instantiates a service based on its registry record.
-   * @param ctx The factory context for dependency injection
-   * @param record The factory record from the registry
-   * @param args Optional arguments for the service
-   * @returns Promise resolving to [undefined, instance] or [error]
-   */
-  async instantiateService(ctx, record, args = void 0) {
-    try {
-      switch (record.type) {
-        case "Class" /* Class */:
-          return this.instantiateClass(ctx, record, args);
-        case "Factory" /* Factory */:
-          return this.instantiateFactory(ctx, record, args);
-        default:
-          throw new Error(
-            `[ServiceInstantiator] Unknown service type: ${record.type}`
-          );
-      }
-    } catch (error) {
-      return [error instanceof Error ? error : new Error(String(error))];
-    }
-  }
-  /**
-   * Instantiates a class-based service (Injectable decorator).
-   * @param ctx The factory context for dependency injection
-   * @param record The factory record from the registry
-   * @param args Optional arguments for the service constructor
-   * @returns Promise resolving to [undefined, instance] or [error]
-   */
-  async instantiateClass(ctx, record, args) {
-    try {
-      const tryLoad = this.injectors.wrapSyncInit(() => {
-        const original = this.injectors.provideFactoryContext(ctx);
-        let result = new record.target(...args ? [args] : []);
-        this.injectors.provideFactoryContext(original);
-        return result;
-      });
-      let [instance, promises, injectState] = tryLoad();
-      if (promises.length > 0) {
-        const results = await Promise.allSettled(promises);
-        if (results.some((result) => result.status === "rejected")) {
-          throw new Error(
-            `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`
-          );
-        }
-        const newRes = tryLoad(injectState);
-        instance = newRes[0];
-        promises = newRes[1];
-      }
-      if (promises.length > 0) {
-        console.error(`[ServiceInstantiator] ${record.target.name} has problem with it's definition.
-
-       One or more of the dependencies are registered as a InjectableScope.Instance and are used with inject.
-
-       Please use inject asyncInject of inject to load those dependencies.`);
-        throw new Error(
-          `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`
-        );
-      }
-      if ("onServiceInit" in instance) {
-        await instance.onServiceInit();
-      }
-      if ("onServiceDestroy" in instance) {
-        ctx.addDestroyListener(async () => {
-          await instance.onServiceDestroy();
-        });
-      }
-      return [void 0, instance];
-    } catch (error) {
-      return [error instanceof Error ? error : new Error(String(error))];
-    }
-  }
-  /**
-   * Instantiates a factory-based service (Factory decorator).
-   * @param ctx The factory context for dependency injection
-   * @param record The factory record from the registry
-   * @param args Optional arguments for the factory
-   * @returns Promise resolving to [undefined, instance] or [error]
-   */
-  async instantiateFactory(ctx, record, args) {
-    try {
-      const tryLoad = this.injectors.wrapSyncInit(() => {
-        const original = this.injectors.provideFactoryContext(ctx);
-        let result = new record.target();
-        this.injectors.provideFactoryContext(original);
-        return result;
-      });
-      let [builder, promises, injectState] = tryLoad();
-      if (promises.length > 0) {
-        const results = await Promise.allSettled(promises);
-        if (results.some((result) => result.status === "rejected")) {
-          throw new Error(
-            `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`
-          );
-        }
-        const newRes = tryLoad(injectState);
-        builder = newRes[0];
-        promises = newRes[1];
-      }
-      if (promises.length > 0) {
-        console.error(`[ServiceInstantiator] ${record.target.name} has problem with it's definition.
-
-       One or more of the dependencies are registered as a InjectableScope.Instance and are used with inject.
-
-       Please use asyncInject instead of inject to load those dependencies.`);
-        throw new Error(
-          `[ServiceInstantiator] Service ${record.target.name} cannot be instantiated.`
-        );
-      }
-      if (typeof builder.create !== "function") {
-        throw new Error(
-          `[ServiceInstantiator] Factory ${record.target.name} does not implement the create method.`
-        );
-      }
-      const instance = await builder.create(ctx, args);
-      return [void 0, instance];
-    } catch (error) {
-      return [error instanceof Error ? error : new Error(String(error))];
-    }
-  }
-};
-
-// 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];
-  }
-  /**
-   * Gets a synchronous instance (for sync operations).
-   */
-  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;
-  }
-  /**
-   * Internal method to resolve token args and create instance name.
-   * Handles factory token resolution and validation.
-   */
-  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 }];
-  }
-  /**
-   * Gets an instance by its instance name, handling all the logic after instance name creation.
-   */
-  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);
-  }
-  /**
-   * 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, requestContext) {
-    const requestResult = await this.tryGetRequestScopedInstance(
-      instanceName,
-      realToken,
-      requestContext
-    );
-    if (requestResult) {
-      return requestResult;
-    }
-    return this.tryGetSingletonInstance(instanceName);
-  }
-  /**
-   * 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}`
-      );
-      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);
-  }
-  /**
-   * 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);
-    }
-    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];
-    }
-  }
-  /**
-   * 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")];
-    }
-  }
-  /**
-   * Creates a new instance for the given token and arguments.
-   */
-  async createNewInstance(instanceName, realToken, args, requestContext) {
-    this.logger?.log(
-      `[InstanceResolver]#createNewInstance() Creating instance for ${instanceName}`
-    );
-    if (this.registry.has(realToken)) {
-      return this.instantiateServiceFromRegistry(
-        instanceName,
-        realToken,
-        args,
-        requestContext
-      );
-    } else {
-      return [DIError.factoryNotFound(realToken.name.toString())];
-    }
-  }
-  /**
-   * 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`
-    );
-    const ctx = this.createFactoryContext();
-    let record = this.registry.get(token);
-    let { scope, type } = record;
-    const [deferred, holder] = this.manager.createCreatingHolder(
-      instanceName,
-      type,
-      scope,
-      ctx.deps
-    );
-    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];
-  }
-  /**
-   * 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) {
-      await this.handleInstantiationError(
-        instanceName,
-        holder,
-        deferred,
-        scope,
-        error
-      );
-    } else {
-      await this.handleInstantiationSuccess(
-        instanceName,
-        holder,
-        ctx,
-        deferred,
-        instance
-      );
-    }
-  }
-  /**
-   * 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);
-          })
-        );
-      });
-    }
-    this.logger?.log(
-      `[InstanceResolver] Instance ${instanceName} created successfully`
-    );
-    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
-    );
-    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);
-    }
-    deferred.reject(error);
-  }
-  /**
-   * Stores an instance holder based on its scope.
-   */
-  storeInstanceByScope(scope, instanceName, holder, requestContext) {
-    switch (scope) {
-      case "Singleton" /* Singleton */:
-        this.logger?.debug(
-          `[InstanceResolver] Setting singleton instance for ${instanceName}`
-        );
-        this.manager.set(instanceName, holder);
-        break;
-      case "Request" /* Request */:
-        if (requestContext) {
-          this.logger?.debug(
-            `[InstanceResolver] Setting request-scoped instance for ${instanceName}`
-          );
-          requestContext.addInstance(instanceName, holder.instance, holder);
-        }
-        break;
-    }
-  }
-  /**
-   * Creates a factory context for dependency injection during service instantiation.
-   */
-  createFactoryContext() {
-    return this.tokenProcessor.createFactoryContext(this.serviceLocator);
-  }
-};
-
-// 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();
-  /**
-   * Public getter for holders to maintain interface compatibility.
-   */
-  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);
-    }
-  }
-  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
-   * @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) {
-    if (this.requestContexts.has(requestId)) {
-      throw new Error(
-        `[RequestContextManager] Request context ${requestId} already exists`
-      );
-    }
-    const contextHolder = new DefaultRequestContextHolder(
-      requestId,
-      priority,
-      metadata
-    );
-    this.requestContexts.set(requestId, contextHolder);
-    this.currentRequestContext = contextHolder;
-    this.logger?.log(
-      `[RequestContextManager] Started request context: ${requestId}`
-    );
-    return contextHolder;
-  }
-  /**
-   * Ends a request context and cleans up all associated instances.
-   * @param requestId The request ID to end
-   */
-  async endRequest(requestId) {
-    const contextHolder = this.requestContexts.get(requestId);
-    if (!contextHolder) {
-      this.logger?.warn(
-        `[RequestContextManager] Request context ${requestId} not found`
-      );
-      return;
-    }
-    this.logger?.log(
-      `[RequestContextManager] Ending request context: ${requestId}`
-    );
-    const cleanupPromises = [];
-    for (const [, holder] of contextHolder.holders) {
-      if (holder.destroyListeners.length > 0) {
-        cleanupPromises.push(
-          Promise.all(holder.destroyListeners.map((listener) => listener()))
-        );
-      }
-    }
-    await Promise.all(cleanupPromises);
-    contextHolder.clear();
-    this.requestContexts.delete(requestId);
-    if (this.currentRequestContext === contextHolder) {
-      this.currentRequestContext = Array.from(this.requestContexts.values()).at(-1) ?? null;
-    }
-    this.logger?.log(
-      `[RequestContextManager] Request context ${requestId} ended`
-    );
-  }
-  /**
-   * Gets the current request context.
-   * @returns The current request context holder or null
-   */
-  getCurrentRequestContext() {
-    return this.currentRequestContext;
-  }
-  /**
-   * Sets the current request context.
-   * @param requestId The request ID to set as current
-   */
-  setCurrentRequestContext(requestId) {
-    const contextHolder = this.requestContexts.get(requestId);
-    if (!contextHolder) {
-      throw new Error(
-        `[RequestContextManager] Request context ${requestId} not found`
-      );
-    }
-    this.currentRequestContext = contextHolder;
-  }
-  /**
-   * Gets all request contexts.
-   * @returns Map of request contexts
-   */
-  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;
-    }
-    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
-        );
-      }
-    }
-  }
-};
-
-// 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 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 Promise.all(promises);
-  }
-  /**
-   * 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 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(
-        "[ServiceInvalidator] Waiting for all services to settle..."
-      );
-      await this.ready();
-    }
-    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");
-  }
-  /**
-   * Waits for all services to settle (either created, destroyed, or error state).
-   */
-  async ready() {
-    const holders = Array.from(this.manager.filter(() => true)).map(
-      ([, holder]) => holder
-    );
-    await Promise.all(
-      holders.map((holder) => this.waitForHolderToSettle(holder))
-    );
-  }
-  /**
-   * 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;
-    }
-  }
-  /**
-   * 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 waitForHolderToSettle(holder) {
-    switch (holder.status) {
-      case "creating" /* Creating */:
-        await holder.creationPromise;
-        break;
-      case "destroying" /* Destroying */:
-        await holder.destroyPromise;
-        break;
-    }
-  }
-  /**
-   * Clears services with dependency awareness, ensuring proper cleanup order.
-   * Services with no dependencies are cleared first, then services that depend on them.
-   */
-  async clearServicesWithDependencyAwareness(serviceNames, maxRounds) {
-    const clearedServices = /* @__PURE__ */ new Set();
-    let round = 1;
-    while (clearedServices.size < serviceNames.length && round <= maxRounds) {
-      this.logger?.log(
-        `[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);
-          }
-        }
-      );
-      await Promise.all(clearPromises);
-      round++;
-    }
-    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`
-      );
-    }
-  }
-  /**
-   * Finds services that are ready to be cleared in the current round.
-   * A service is ready if all its dependencies have already been cleared.
-   */
-  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 Promise.all(promises);
-  }
-  /**
-   * Gets all service names currently managed by the ServiceLocator.
-   */
-  getAllServiceNames() {
-    return this.manager.getAllNames();
-  }
-  /**
-   * Emits events to listeners for instance lifecycle events.
-   */
-  emitInstanceEvent(name, event = "create") {
-    this.logger?.log(
-      `[ServiceInvalidator]#emitInstanceEvent() Notifying listeners for ${name} with event ${event}`
-    );
-    return this.eventBus.emit(name, event);
-  }
-};
-
-// 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);
-      }
-    };
-  }
-  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.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 {
-      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;
-  }
-  /**
-   * Validates and resolves token arguments, handling factory token resolution and validation.
-   */
-  validateAndResolveTokenArgs(token, args) {
-    let actualToken = token;
-    if (typeof token === "function") {
-      actualToken = getInjectableToken(token);
-    }
-    let realArgs = args;
-    if (actualToken instanceof BoundInjectionToken) {
-      realArgs = actualToken.value;
-    } else if (actualToken instanceof FactoryInjectionToken) {
-      if (actualToken.resolved) {
-        realArgs = actualToken.value;
-      } else {
-        return [DIError.factoryTokenNotResolved(token.name), { actualToken }];
-      }
-    }
-    if (!actualToken.schema) {
-      return [void 0, { actualToken, validatedArgs: realArgs }];
-    }
-    const validatedArgs = actualToken.schema?.safeParse(realArgs);
-    if (validatedArgs && !validatedArgs.success) {
-      this.logger?.error(
-        `[TokenProcessor]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`,
-        validatedArgs.error
-      );
-      return [DIError.unknown(validatedArgs.error), { actualToken }];
-    }
-    return [void 0, { actualToken, validatedArgs: validatedArgs?.data }];
-  }
-  /**
-   * Generates a unique instance name based on token and arguments.
-   */
-  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, "=")}`;
-  }
-  /**
-   * 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);
-  }
-  /**
-   * Creates a factory context for dependency injection during service instantiation.
-   * @param serviceLocator Reference to the service locator for dependency resolution
-   */
-  createFactoryContext(serviceLocator) {
-    const destroyListeners = /* @__PURE__ */ new Set();
-    const deps = /* @__PURE__ */ new Set();
-    function addDestroyListener(listener) {
-      destroyListeners.add(listener);
-    }
-    function getDestroyListeners() {
-      return Array.from(destroyListeners);
-    }
-    return {
-      // @ts-expect-error This is correct type
-      async inject(token, args) {
-        const [error, instance] = await serviceLocator.getInstance(
-          token,
-          args,
-          ({ instanceName }) => {
-            deps.add(instanceName);
-          }
-        );
-        if (error) {
-          throw error;
-        }
-        return instance;
-      },
-      addDestroyListener,
-      getDestroyListeners,
-      locator: serviceLocator,
-      deps
-    };
-  }
-  /**
-   * Tries to get a pre-prepared instance from request contexts.
-   */
-  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;
-      }
-    }
-    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;
-  }
-};
-
-// 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;
-    }
-    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];
-    }
-    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);
-  }
-};
-
-// src/container.mts
-var _Container_decorators, _init2;
-_Container_decorators = [Injectable()];
-var _Container = class _Container {
-  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);
-    this.serviceLocator.getManager().storeCreatedHolder(
-      instanceName,
-      this,
-      "Class" /* Class */,
-      "Singleton" /* Singleton */
-    );
-  }
-  async get(token, args) {
-    return this.serviceLocator.getOrThrowInstance(token, args);
-  }
-  /**
-   * Gets the underlying ServiceLocator instance for advanced usage
-   */
-  getServiceLocator() {
-    return this.serviceLocator;
-  }
-  /**
-   * Invalidates a service and its dependencies
-   */
-  async invalidate(service) {
-    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
-   */
-  async ready() {
-    await this.serviceLocator.ready();
-  }
-  // ============================================================================
-  // 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.serviceLocator.beginRequest(requestId, metadata, priority);
-  }
-  /**
-   * Ends a request context and cleans up all associated instances.
-   * @param requestId The request ID to end
-   */
-  async endRequest(requestId) {
-    await this.serviceLocator.endRequest(requestId);
-  }
-  /**
-   * Gets the current request context.
-   * @returns The current request context holder or null
-   */
-  getCurrentRequestContext() {
-    return this.serviceLocator.getCurrentRequestContext();
-  }
-  /**
-   * Sets the current request context.
-   * @param requestId The request ID to set as current
-   */
-  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);
-__runInitializers(_init2, 1, _Container);
-var Container = _Container;
-
-exports.BaseInstanceHolderManager = BaseInstanceHolderManager;
-exports.BoundInjectionToken = BoundInjectionToken;
-exports.Container = Container;
-exports.DIError = DIError;
-exports.DIErrorCode = DIErrorCode;
-exports.DefaultRequestContextHolder = DefaultRequestContextHolder;
-exports.ErrorsEnum = DIErrorCode;
-exports.Factory = Factory;
-exports.FactoryInjectionToken = FactoryInjectionToken;
-exports.FactoryNotFound = DIError;
-exports.FactoryTokenNotResolved = DIError;
-exports.Injectable = Injectable;
-exports.InjectableScope = InjectableScope;
-exports.InjectableTokenMeta = InjectableTokenMeta;
-exports.InjectableType = InjectableType;
-exports.InjectionToken = InjectionToken;
-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 = DIError;
-exports.asyncInject = asyncInject;
-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
-//# sourceMappingURL=index.js.map