@navios/di 0.4.1 → 0.5.0

package/lib/index.mjs

@@ -1,162 +1,5 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : 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 = Symbol.for("InjectableTokenMeta");
+import { Injectable, __decoratorStart, __decorateElement, __runInitializers, InjectionToken, globalRegistry, InjectableTokenMeta } from './chunk-44F3LXW5.mjs';
+export { BaseInstanceHolderManager, BoundInjectionToken, Container, DIError, DIErrorCode, DefaultRequestContextHolder, DIErrorCode as ErrorsEnum, FactoryInjectionToken, DIError as FactoryNotFound, DIError as FactoryTokenNotResolved, Injectable, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, DIError as InstanceDestroying, DIError as InstanceNotFound, Registry, ServiceInstantiator, ServiceLocator, ServiceLocatorEventBus, ServiceLocatorInstanceHolderStatus, ServiceLocatorManager, DIError as UnknownError, asyncInject, createRequestContextHolder, defaultInjectors, getInjectableToken, getInjectors, globalRegistry, inject, optional, provideFactoryContext, wrapSyncInit } from './chunk-44F3LXW5.mjs';
 
 // src/decorators/factory.decorator.mts
 function Factory({
@@ -176,392 +19,6 @@ function Factory({
     return target;
   };
 }
-function Injectable({
-  scope = "Singleton" /* Singleton */,
-  token,
-  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."
-      );
-    }
-    let injectableToken = token ?? InjectionToken.create(target);
-    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/instance-destroying.mts
-var InstanceDestroying = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} destroying`);
-    this.name = name;
-  }
-  code = "InstanceDestroying" /* InstanceDestroying */;
-};
-
-// src/errors/instance-expired.mts
-var InstanceExpired = class extends Error {
-  constructor(name) {
-    super(`Instance ${name} expired`);
-    this.name = 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;
-  }
-  code = "InstanceNotFound" /* InstanceNotFound */;
-};
-
-// src/errors/unknown-error.mts
-var UnknownError = class extends Error {
-  code = "UnknownError" /* UnknownError */;
-  parent;
-  constructor(message) {
-    if (message instanceof Error) {
-      super(message.message);
-      this.parent = message;
-      return;
-    }
-    super(message);
-  }
-};
-
-// 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 asyncInject2(token, args) {
-    if (!injectState) {
-      throw new Error(
-        "[Injector] Trying to access inject outside of a injectable context"
-      );
-    }
-    if (injectState.isFrozen) {
-      const idx = injectState.currentIndex++;
-      const request = injectState.requests[idx];
-      if (request.token !== token) {
-        throw new Error(
-          `[Injector] Wrong token order. Expected ${request.token.toString()} but got ${token.toString()}`
-        );
-      }
-      return request.promise;
-    }
-    const promise = getFactoryContext().inject(token, args);
-    injectState.requests.push({
-      token,
-      promise
-    });
-    injectState.currentIndex++;
-    return promise;
-  }
-  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;
-    const instance = getFactoryContext().locator.getSyncInstance(
-      realToken,
-      args
-    );
-    if (!instance) {
-      if (promiseCollector) {
-        const promise = getFactoryContext().inject(realToken, args);
-        promiseCollector(promise);
-      } else {
-        throw new Error(`[Injector] Cannot initiate ${realToken.toString()}`);
-      }
-      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`
-            );
-          }
-        }
-      );
-    }
-    return instance;
-  }
-  const injectors = {
-    asyncInject: asyncInject2,
-    inject: inject2,
-    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/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;
-})(ServiceLocatorInstanceHolderStatus || {});
-
-// src/base-instance-holder-manager.mts
-var BaseInstanceHolderManager = class {
-  constructor(logger = null) {
-    this.logger = logger;
-    this._holders = /* @__PURE__ */ new Map();
-  }
-  _holders;
-  /**
-   * Protected getter for accessing the holders map from subclasses.
-   */
-  get holders() {
-    return this._holders;
-  }
-  /**
-   * Deletes a holder by name.
-   * @param name The name of the holder to delete
-   * @returns true if the holder was deleted, false if it didn't exist
-   */
-  delete(name) {
-    return this._holders.delete(name);
-  }
-  /**
-   * Filters holders based on a predicate function.
-   * @param predicate Function to test each holder
-   * @returns A new Map containing only the holders that match the predicate
-   */
-  filter(predicate) {
-    return new Map(
-      [...this._holders].filter(([key, value]) => predicate(value, key))
-    );
-  }
-  /**
-   * Clears all holders from this manager.
-   */
-  clear() {
-    this._holders.clear();
-  }
-  /**
-   * Gets the number of holders currently managed.
-   */
-  size() {
-    return this._holders.size;
-  }
-  /**
-   * Creates a new holder with Creating status and a deferred creation promise.
-   * This is useful for creating placeholder holders that can be fulfilled later.
-   * @param name The name of the instance
-   * @param type The injectable type
-   * @param scope The injectable scope
-   * @param deps Optional set of dependencies
-   * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
-   * @returns A tuple containing the deferred promise and the holder
-   */
-  createCreatingHolder(name, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
-    const deferred = createDeferred();
-    const holder = {
-      status: "creating" /* Creating */,
-      name,
-      instance: null,
-      creationPromise: deferred.promise,
-      destroyPromise: null,
-      type,
-      scope,
-      deps,
-      destroyListeners: [],
-      createdAt: Date.now(),
-      ttl
-    };
-    return [deferred, holder];
-  }
-  /**
-   * Creates a new holder with Created status and an actual instance.
-   * This is useful for creating holders that already have their instance ready.
-   * @param name The name of the instance
-   * @param instance The actual instance to store
-   * @param type The injectable type
-   * @param scope The injectable scope
-   * @param deps Optional set of dependencies
-   * @param ttl Optional time-to-live in milliseconds (defaults to Infinity)
-   * @returns The created holder
-   */
-  createCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
-    const holder = {
-      status: "created" /* Created */,
-      name,
-      instance,
-      creationPromise: null,
-      destroyPromise: null,
-      type,
-      scope,
-      deps,
-      destroyListeners: [],
-      createdAt: Date.now(),
-      ttl
-    };
-    return holder;
-  }
-  /**
-   * Gets all holder names currently managed.
-   */
-  getAllNames() {
-    return Array.from(this._holders.keys());
-  }
-  /**
-   * Gets all holders currently managed.
-   */
-  getAllHolders() {
-    return Array.from(this._holders.values());
-  }
-  /**
-   * Checks if this manager has any holders.
-   */
-  isEmpty() {
-    return this._holders.size === 0;
-  }
-};
 
 // src/event-emitter.mts
 var _EventEmitter_decorators, _init;
@@ -604,1062 +61,10 @@ var EventEmitter = class {
     );
   }
 };
-_init = __decoratorStart();
+_init = __decoratorStart(null);
 EventEmitter = __decorateElement(_init, 0, "EventEmitter", _EventEmitter_decorators, EventEmitter);
 __runInitializers(_init, 1, EventEmitter);
 
-// src/injector.mts
-var defaultInjectors = getInjectors();
-var asyncInject = defaultInjectors.asyncInject;
-var inject = defaultInjectors.inject;
-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/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(),
-        Infinity
-      );
-      this._holders.set(name, createdHolder);
-    } else {
-      if (!holder) {
-        throw new Error("Holder is required when adding an instance by name");
-      }
-      this._holders.set(instanceName, holder);
-    }
-  }
-  clear() {
-    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());
-    }
-    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.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];
-    }
-    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
-   */
-  storeCreatedHolder(name, instance, type, scope, deps = /* @__PURE__ */ new Set(), ttl = Infinity) {
-    const holder = this.createCreatedHolder(
-      name,
-      instance,
-      type,
-      scope,
-      deps,
-      ttl
-    );
-    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;
-    }
-    return this.generateInstanceName(actualToken, validatedArgs);
-  }
-  async getInstance(token, args, onPrepare) {
-    const [err, data] = await this.resolveTokenAndPrepareInstanceName(
-      token,
-      args
-    );
-    if (err) {
-      return [err];
-    }
-    const { instanceName, validatedArgs, actualToken, realToken } = data;
-    onPrepare?.({ instanceName, actualToken, validatedArgs });
-    const [error, holder] = await this.retrieveOrCreateInstanceByInstanceName(
-      instanceName,
-      realToken,
-      validatedArgs
-    );
-    if (error) {
-      return [error];
-    }
-    return [void 0, holder.instance];
-  }
-  async getOrThrowInstance(token, args) {
-    const [error, instance] = await this.getInstance(token, args);
-    if (error) {
-      throw error;
-    }
-    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;
-    }
-    return holder.instance;
-  }
-  invalidate(service, round = 1) {
-    this.logger?.log(
-      `[ServiceLocator] Starting invalidation process for ${service}`
-    );
-    const toInvalidate = this.manager.filter(
-      (holder) => holder.name === service || holder.deps.has(service)
-    );
-    const promises = [];
-    for (const [key, holder] of toInvalidate.entries()) {
-      promises.push(this.invalidateHolder(key, holder, round));
-    }
-    return Promise.all(promises);
-  }
-  /**
-   * Invalidates a single holder based on its current status.
-   */
-  async invalidateHolder(key, holder, round) {
-    switch (holder.status) {
-      case "destroying" /* Destroying */:
-        this.logger?.trace(`[ServiceLocator] ${key} is already being destroyed`);
-        await holder.destroyPromise;
-        break;
-      case "creating" /* Creating */:
-        this.logger?.trace(
-          `[ServiceLocator] ${key} is being created, waiting...`
-        );
-        await holder.creationPromise;
-        if (round > 3) {
-          this.logger?.error(
-            `[ServiceLocator] ${key} creation triggered too many invalidation rounds`
-          );
-          return;
-        }
-        await this.invalidate(key, round + 1);
-        break;
-      default:
-        await this.destroyHolder(key, holder);
-        break;
-    }
-  }
-  /**
-   * Destroys a holder and cleans up its resources.
-   */
-  async destroyHolder(key, holder) {
-    holder.status = "destroying" /* Destroying */;
-    this.logger?.log(
-      `[ServiceLocator] Invalidating ${key} and notifying listeners`
-    );
-    holder.destroyPromise = Promise.all(
-      holder.destroyListeners.map((listener) => listener())
-    ).then(async () => {
-      this.manager.delete(key);
-      await this.emitInstanceEvent(key, "destroy");
-    });
-    await holder.destroyPromise;
-  }
-  async ready() {
-    const holders = Array.from(this.manager.filter(() => true)).map(
-      ([, holder]) => holder
-    );
-    await Promise.all(
-      holders.map((holder) => this.waitForHolderToSettle(holder))
-    );
-  }
-  /**
-   * Waits for a holder to settle (either created, destroyed, or error state).
-   */
-  async waitForHolderToSettle(holder) {
-    switch (holder.status) {
-      case "creating" /* Creating */:
-        await holder.creationPromise;
-        break;
-      case "destroying" /* Destroying */:
-        await holder.destroyPromise;
-        break;
-    }
-  }
-  // ============================================================================
-  // REQUEST CONTEXT MANAGEMENT
-  // ============================================================================
-  /**
-   * 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(
-        `[ServiceLocator] Request context ${requestId} already exists`
-      );
-    }
-    const contextHolder = new DefaultRequestContextHolder(
-      requestId,
-      priority,
-      metadata
-    );
-    this.requestContexts.set(requestId, contextHolder);
-    this.currentRequestContext = contextHolder;
-    this.logger?.log(`[ServiceLocator] 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(
-        `[ServiceLocator] Request context ${requestId} not found`
-      );
-      return;
-    }
-    this.logger?.log(`[ServiceLocator] 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(`[ServiceLocator] 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(`[ServiceLocator] Request context ${requestId} not found`);
-    }
-    this.currentRequestContext = contextHolder;
-  }
-  // ============================================================================
-  // PRIVATE METHODS
-  // ============================================================================
-  /**
-   * 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 [new 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(
-        `[ServiceLocator]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`,
-        validatedArgs.error
-      );
-      return [new UnknownError(validatedArgs.error), { actualToken }];
-    }
-    return [void 0, { actualToken, validatedArgs: validatedArgs?.data }];
-  }
-  /**
-   * 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.validateAndResolveTokenArgs(token, args);
-    if (err instanceof UnknownError) {
-      return [err];
-    } else if (err instanceof FactoryTokenNotResolved && actualToken instanceof FactoryInjectionToken) {
-      this.logger?.log(
-        `[ServiceLocator]#resolveTokenAndPrepareInstanceName() Factory token not resolved, resolving it`
-      );
-      await actualToken.resolve(this.createFactoryContext());
-      return this.resolveTokenAndPrepareInstanceName(token);
-    }
-    const instanceName = this.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) {
-    const existingHolder = await this.tryGetExistingInstance(
-      instanceName,
-      realToken
-    );
-    if (existingHolder) {
-      return existingHolder;
-    }
-    const result = await this.createNewInstance(
-      instanceName,
-      realToken,
-      realArgs
-    );
-    if (result[0]) {
-      return [result[0]];
-    }
-    const [, holder] = result;
-    return this.waitForInstanceReady(holder);
-  }
-  /**
-   * Attempts to retrieve an existing instance, handling request-scoped and singleton instances.
-   * Returns null if no instance exists and a new one should be created.
-   */
-  async tryGetExistingInstance(instanceName, realToken) {
-    const requestResult = await this.tryGetRequestScopedInstance(
-      instanceName,
-      realToken
-    );
-    if (requestResult) {
-      return requestResult;
-    }
-    return this.tryGetSingletonInstance(instanceName);
-  }
-  /**
-   * Attempts to get a request-scoped instance if applicable.
-   */
-  async tryGetRequestScopedInstance(instanceName, realToken) {
-    if (!this.registry.has(realToken)) {
-      return null;
-    }
-    const record = this.registry.get(realToken);
-    if (record.scope !== "Request" /* Request */) {
-      return null;
-    }
-    if (!this.currentRequestContext) {
-      this.logger?.log(
-        `[ServiceLocator] No current request context available for request-scoped service ${instanceName}`
-      );
-      return [new UnknownError("InstanceNotFound" /* InstanceNotFound */)];
-    }
-    const requestHolder = this.currentRequestContext.get(instanceName);
-    if (!requestHolder) {
-      return null;
-    }
-    return this.waitForInstanceReady(requestHolder);
-  }
-  /**
-   * Attempts to get a singleton instance from the manager.
-   */
-  async tryGetSingletonInstance(instanceName) {
-    const [error, holder] = this.manager.get(instanceName);
-    if (!error) {
-      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...`
-        );
-        await this.invalidate(instanceName);
-        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 [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
-      case "error" /* Error */:
-        return [holder.instance];
-      case "created" /* Created */:
-        return [void 0, holder];
-      default:
-        return [new UnknownError("InstanceNotFound" /* InstanceNotFound */)];
-    }
-  }
-  /**
-   * Emits events to listeners for instance lifecycle events.
-   */
-  emitInstanceEvent(name, event = "create") {
-    this.logger?.log(
-      `[ServiceLocator]#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())];
-    }
-  }
-  /**
-   * 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
-      );
-    });
-    this.storeInstanceByScope(scope, instanceName, holder);
-    return [void 0, holder];
-  }
-  /**
-   * Handles the result of service instantiation.
-   */
-  async handleInstantiationResult(instanceName, holder, ctx, deferred, scope, error, instance) {
-    holder.destroyListeners = ctx.getDestroyListeners();
-    holder.creationPromise = null;
-    if (error) {
-      await this.handleInstantiationError(
-        instanceName,
-        holder,
-        deferred,
-        scope,
-        error
-      );
-    } 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.eventBus.on(
-            dependency,
-            "destroy",
-            () => this.invalidate(instanceName)
-          )
-        );
-      });
-    }
-    await this.emitInstanceEvent(instanceName);
-    deferred.resolve([void 0, instance]);
-  }
-  /**
-   * Handles service instantiation errors.
-   */
-  async handleInstantiationError(instanceName, holder, deferred, scope, error) {
-    this.logger?.error(
-      `[ServiceLocator] Error creating instance for ${instanceName}`,
-      error
-    );
-    holder.status = "error" /* Error */;
-    holder.instance = error;
-    holder.creationPromise = null;
-    if (scope === "Singleton" /* Singleton */) {
-      setTimeout(() => this.invalidate(instanceName), 10);
-    }
-    deferred.reject(error);
-  }
-  /**
-   * Stores an instance holder based on its scope.
-   */
-  storeInstanceByScope(scope, instanceName, holder) {
-    switch (scope) {
-      case "Singleton" /* Singleton */:
-        this.logger?.debug(
-          `[ServiceLocator] Setting singleton instance for ${instanceName}`
-        );
-        this.manager.set(instanceName, holder);
-        break;
-      case "Request" /* Request */:
-        if (this.currentRequestContext) {
-          this.logger?.debug(
-            `[ServiceLocator] Setting request-scoped instance for ${instanceName}`
-          );
-          this.currentRequestContext.addInstance(
-            instanceName,
-            holder.instance,
-            holder
-          );
-        }
-        break;
-    }
-  }
-  /**
-   * Tries to get a pre-prepared instance from request contexts.
-   */
-  tryGetPrePreparedInstance(instanceName, contextHolder, deps) {
-    if (contextHolder && contextHolder.priority > 0) {
-      const prePreparedInstance = contextHolder.get(instanceName)?.instance;
-      if (prePreparedInstance !== void 0) {
-        this.logger?.debug(
-          `[ServiceLocator] Using pre-prepared instance ${instanceName} from request context ${contextHolder.requestId}`
-        );
-        deps.add(instanceName);
-        return prePreparedInstance;
-      }
-    }
-    if (this.currentRequestContext && this.currentRequestContext !== contextHolder) {
-      const prePreparedInstance = this.currentRequestContext.get(instanceName)?.instance;
-      if (prePreparedInstance !== void 0) {
-        this.logger?.debug(
-          `[ServiceLocator] Using pre-prepared instance ${instanceName} from current request context ${this.currentRequestContext.requestId}`
-        );
-        deps.add(instanceName);
-        return prePreparedInstance;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Creates a factory context for dependency injection during service instantiation.
-   * @param contextHolder Optional request context holder for priority-based resolution
-   */
-  createFactoryContext(contextHolder) {
-    const destroyListeners = /* @__PURE__ */ new Set();
-    const deps = /* @__PURE__ */ new Set();
-    const self = this;
-    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 instanceName = self.generateInstanceName(token, args);
-        const prePreparedInstance = self.tryGetPrePreparedInstance(
-          instanceName,
-          contextHolder,
-          deps
-        );
-        if (prePreparedInstance !== void 0) {
-          return prePreparedInstance;
-        }
-        const [error, instance] = await self.getInstance(
-          token,
-          args,
-          ({ instanceName: instanceName2 }) => {
-            deps.add(instanceName2);
-          }
-        );
-        if (error) {
-          throw error;
-        }
-        return instance;
-      },
-      addDestroyListener,
-      getDestroyListeners,
-      locator: self,
-      deps
-    };
-  }
-  /**
-   * 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);
-  }
-};
-
-// src/container.mts
-var _Container_decorators, _init2;
-_Container_decorators = [Injectable()];
-var _Container = class _Container {
-  serviceLocator;
-  constructor(registry = globalRegistry, logger = null, injectors = defaultInjectors) {
-    this.serviceLocator = new ServiceLocator(registry, logger, injectors);
-    this.registerSelf();
-  }
-  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 holderMap = this.serviceLocator.getManager().filter((holder2) => holder2.instance === service);
-    if (holderMap.size === 0) {
-      return;
-    }
-    const holder = holderMap.values().next().value;
-    if (holder) {
-      await this.serviceLocator.invalidate(holder.name);
-    }
-  }
-  /**
-   * 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);
-  }
-};
-_init2 = __decoratorStart();
-_Container = __decorateElement(_init2, 0, "Container", _Container_decorators, _Container);
-__runInitializers(_init2, 1, _Container);
-var Container = _Container;
-
-export { BaseInstanceHolderManager, BoundInjectionToken, Container, DefaultRequestContextHolder, Deferred, ErrorsEnum, EventEmitter, Factory, FactoryInjectionToken, FactoryNotFound, FactoryTokenNotResolved, Injectable, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, InstanceDestroying, InstanceExpired, InstanceNotFound, Registry, ServiceInstantiator, ServiceLocator, ServiceLocatorEventBus, ServiceLocatorInstanceHolderStatus, ServiceLocatorManager, UnknownError, asyncInject, createDeferred, createRequestContextHolder, defaultInjectors, getInjectableToken, getInjectors, globalRegistry, inject, provideFactoryContext, wrapSyncInit };
+export { EventEmitter, Factory };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map