@navios/di 0.2.0 → 0.3.0

package/lib/index.js

@@ -1,19 +1,50 @@
 'use strict';
 
-// src/decorators/injectable.decorator.mts
+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__ */ ((InjectableScope3) => {
-  InjectableScope3["Singleton"] = "Singleton";
-  InjectableScope3["Instance"] = "Instance";
-  return InjectableScope3;
+var InjectableScope = /* @__PURE__ */ ((InjectableScope4) => {
+  InjectableScope4["Singleton"] = "Singleton";
+  InjectableScope4["Transient"] = "Transient";
+  InjectableScope4["Request"] = "Request";
+  return InjectableScope4;
 })(InjectableScope || {});
 
 // src/enums/injectable-type.enum.mts
-var InjectableType = /* @__PURE__ */ ((InjectableType2) => {
-  InjectableType2["Class"] = "Class";
-  InjectableType2["Factory"] = "Factory";
-  return InjectableType2;
+var InjectableType = /* @__PURE__ */ ((InjectableType4) => {
+  InjectableType4["Class"] = "Class";
+  InjectableType4["Factory"] = "Factory";
+  return InjectableType4;
 })(InjectableType || {});
 
 // src/injection-token.mts
@@ -80,9 +111,9 @@ var FactoryInjectionToken = class {
   id;
   name;
   schema;
-  async resolve() {
+  async resolve(ctx) {
     if (!this.value) {
-      this.value = await this.factory();
+      this.value = await this.factory(ctx);
       this.resolved = true;
     }
     return this.value;
@@ -117,8 +148,8 @@ var Registry = class {
     }
     return factory;
   }
-  set(token, factory, scope) {
-    this.factories.set(token.id, { factory, scope, originalToken: token });
+  set(token, scope, target, type) {
+    this.factories.set(token.id, { scope, originalToken: token, target, type });
   }
   delete(token) {
     this.factories.delete(token.id);
@@ -126,166 +157,29 @@ var Registry = class {
 };
 var globalRegistry = new Registry();
 
-// src/proxy-service-locator.mts
-var ProxyServiceLocator = class {
-  constructor(serviceLocator, ctx) {
-    this.serviceLocator = serviceLocator;
-    this.ctx = ctx;
-  }
-  getEventBus() {
-    return this.serviceLocator.getEventBus();
-  }
-  // @ts-expect-error We don't need all the properties of the class
-  getInstance(token, args) {
-    return this.ctx.inject(token, args).then(
-      (instance) => {
-        return [void 0, instance];
-      },
-      (error) => {
-        return [error];
-      }
-    );
-  }
-  getOrThrowInstance(token, args) {
-    return this.ctx.inject(token, args);
-  }
-  getSyncInstance(token, args) {
-    return this.serviceLocator.getSyncInstance(token, args);
-  }
-  invalidate(service, round) {
-    return this.serviceLocator.invalidate(service, round);
-  }
-  ready() {
-    return this.serviceLocator.ready();
-  }
-  makeInstanceName(token, args) {
-    return this.serviceLocator.makeInstanceName(token, args);
-  }
-};
-function makeProxyServiceLocator(serviceLocator, ctx) {
-  return new ProxyServiceLocator(serviceLocator, ctx);
-}
-
 // src/symbols/injectable-token.mts
 var InjectableTokenMeta = Symbol.for("InjectableTokenMeta");
 
-// src/utils/get-injectors.mts
-var InjectorsBase = /* @__PURE__ */ new Map();
-function getInjectors({ baseLocator }) {
-  if (InjectorsBase.has(baseLocator)) {
-    return InjectorsBase.get(baseLocator);
-  }
-  let currentLocator = baseLocator;
-  function getServiceLocator() {
-    if (!currentLocator) {
+// 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(
-        "[Injector] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
-      );
-    }
-    return currentLocator;
-  }
-  function provideServiceLocator2(locator) {
-    const original = currentLocator;
-    currentLocator = locator;
-    return original;
-  }
-  function inject2(token, args) {
-    const realToken = token[InjectableTokenMeta] ?? token;
-    return getServiceLocator().getOrThrowInstance(realToken, args);
-  }
-  let promiseCollector = null;
-  function wrapSyncInit2(cb) {
-    return () => {
-      const promises = [];
-      const originalPromiseCollector = promiseCollector;
-      promiseCollector = (promise) => {
-        promises.push(promise);
-      };
-      const result = cb();
-      promiseCollector = originalPromiseCollector;
-      return [result, promises];
-    };
-  }
-  function syncInject2(token, args) {
-    const realToken = token[InjectableTokenMeta] ?? token;
-    const instance = getServiceLocator().getSyncInstance(realToken, args);
-    if (!instance) {
-      if (promiseCollector) {
-        const promise = getServiceLocator().getInstance(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 inject() instead of syncInject() or do not use the value outside of class methods`
-            );
-          }
-        }
+        "[ServiceLocator] @Factory decorator can only be used on classes."
       );
     }
-    return instance;
-  }
-  const injectors = {
-    inject: inject2,
-    syncInject: syncInject2,
-    wrapSyncInit: wrapSyncInit2,
-    provideServiceLocator: provideServiceLocator2
+    let injectableToken = token ?? InjectionToken.create(target);
+    registry.set(injectableToken, scope, target, "Factory" /* Factory */);
+    target[InjectableTokenMeta] = injectableToken;
+    return target;
   };
-  InjectorsBase.set(baseLocator, injectors);
-  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/resolve-service.mts
-async function resolveService(ctx, target, args = []) {
-  const { wrapSyncInit: wrapSyncInit2, provideServiceLocator: provideServiceLocator2 } = getInjectors({
-    baseLocator: ctx.locator
-  });
-  const proxyServiceLocator = makeProxyServiceLocator(ctx.locator, ctx);
-  const tryLoad = wrapSyncInit2(() => {
-    const original = provideServiceLocator2(proxyServiceLocator);
-    let result = new target(...args);
-    provideServiceLocator2(original);
-    return result;
-  });
-  let [instance, promises] = tryLoad();
-  if (promises.length > 0) {
-    await Promise.allSettled(promises);
-    const newRes = tryLoad();
-    instance = newRes[0];
-    promises = newRes[1];
-  }
-  if (promises.length > 0) {
-    console.error(`[ServiceLocator] ${target.name} has problem with it's definition.
-
-     One or more of the dependencies are registered as a InjectableScope.Instance and are used with syncInject.
-
-     Please use inject instead of syncInject to load those dependencies.`);
-    throw new Error(
-      `[ServiceLocator] Service ${target.name} cannot be instantiated.`
-    );
-  }
-  return instance;
 }
-
-// src/decorators/injectable.decorator.mts
 function Injectable({
   scope = "Singleton" /* Singleton */,
-  type = "Class" /* Class */,
   token,
   registry = globalRegistry
 } = {}) {
@@ -296,27 +190,7 @@ function Injectable({
       );
     }
     let injectableToken = token ?? InjectionToken.create(target);
-    if (type === "Class" /* Class */) {
-      registry.set(
-        injectableToken,
-        async (ctx, args) => resolveService(ctx, target, [args]),
-        scope
-      );
-    } else if (type === "Factory" /* Factory */) {
-      registry.set(
-        injectableToken,
-        async (ctx, args) => {
-          const builder = await resolveService(ctx, target);
-          if (typeof builder.create !== "function") {
-            throw new Error(
-              `[ServiceLocator] Factory ${target.name} does not implement the create method.`
-            );
-          }
-          return builder.create(ctx, args);
-        },
-        scope
-      );
-    }
+    registry.set(injectableToken, scope, target, "Class" /* Class */);
     target[InjectableTokenMeta] = injectableToken;
     return target;
   };
@@ -391,8 +265,184 @@ var UnknownError = class extends Error {
   }
 };
 
+// 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/event-emitter.mts
-var EventEmitter = class {
+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)) {
@@ -423,12 +473,195 @@ var EventEmitter = class {
     if (!this.listeners.has(event)) {
       return;
     }
-    return Promise.all(Array.from(this.listeners.get(event)).map((listener) => listener(...args)));
+    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 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 {
+  constructor(requestId, priority = 100, initialMetadata) {
+    this.requestId = requestId;
+    this.priority = priority;
+    if (initialMetadata) {
+      Object.entries(initialMetadata).forEach(([key, value]) => {
+        this.metadata.set(key, value);
+      });
+    }
+  }
+  instances = /* @__PURE__ */ new Map();
+  holders = /* @__PURE__ */ new Map();
+  metadata = /* @__PURE__ */ new Map();
+  createdAt = Date.now();
+  addInstance(instanceName, instance, holder) {
+    this.instances.set(instanceName, instance);
+    this.holders.set(instanceName, holder);
+  }
+  getInstance(instanceName) {
+    return this.instances.get(instanceName);
+  }
+  getHolder(instanceName) {
+    return this.holders.get(instanceName);
+  }
+  hasInstance(instanceName) {
+    return this.instances.has(instanceName);
+  }
+  clear() {
+    this.instances.clear();
+    this.holders.clear();
+    this.metadata.clear();
   }
-  addChannel(ns, event, target) {
-    return this.on(event, (...args) => target.emit(ns, event, ...args));
+  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 {
@@ -461,19 +694,6 @@ var ServiceLocatorEventBus = class {
       return;
     }
     const events = this.listeners.get(key);
-    const preEvent = `pre:${event}`;
-    const postEvent = `post:${event}`;
-    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
-    await Promise.allSettled(
-      [...events.get(preEvent) ?? []].map((listener) => listener(preEvent))
-    ).then((results) => {
-      results.filter((result) => result.status === "rejected").forEach((result) => {
-        this.logger?.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
-          result.reason
-        );
-      });
-    });
     this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
     const res = await Promise.allSettled(
       [...events.get(event) ?? []].map((listener) => listener(event))
@@ -490,32 +710,16 @@ var ServiceLocatorEventBus = class {
       }
       return results;
     });
-    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`);
-    await Promise.allSettled(
-      [...events.get(postEvent) ?? []].map((listener) => listener(postEvent))
-    ).then((results) => {
-      results.filter((result) => result.status === "rejected").forEach((result) => {
-        this.logger?.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
-          result.reason
-        );
-      });
-    });
     return res;
   }
 };
 
 // src/service-locator-instance-holder.mts
-var ServiceLocatorInstanceHolderKind = /* @__PURE__ */ ((ServiceLocatorInstanceHolderKind2) => {
-  ServiceLocatorInstanceHolderKind2["Instance"] = "instance";
-  ServiceLocatorInstanceHolderKind2["Factory"] = "factory";
-  ServiceLocatorInstanceHolderKind2["AbstractFactory"] = "abstractFactory";
-  return ServiceLocatorInstanceHolderKind2;
-})(ServiceLocatorInstanceHolderKind || {});
 var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus2) => {
   ServiceLocatorInstanceHolderStatus2["Created"] = "created";
   ServiceLocatorInstanceHolderStatus2["Creating"] = "creating";
   ServiceLocatorInstanceHolderStatus2["Destroying"] = "destroying";
+  ServiceLocatorInstanceHolderStatus2["Error"] = "error";
   return ServiceLocatorInstanceHolderStatus2;
 })(ServiceLocatorInstanceHolderStatus || {});
 
@@ -541,6 +745,11 @@ var ServiceLocatorManager = class {
           `[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 {
@@ -575,116 +784,115 @@ var ServiceLocatorManager = class {
       )
     );
   }
+  /**
+   * 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
+   */
+  storeCreatedHolder(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
+    };
+    this.instancesHolders.set(name, holder);
+    return holder;
+  }
 };
 
 // src/service-locator.mts
 var ServiceLocator = class {
-  constructor(registry = globalRegistry, logger = null) {
+  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;
   }
-  storeInstance(instance, token, args) {
-    const instanceName = this.getInstanceIdentifier(token, args);
-    this.manager.set(instanceName, {
-      name: instanceName,
-      instance,
-      status: "created" /* Created */,
-      kind: "instance" /* Instance */,
-      createdAt: Date.now(),
-      ttl: Infinity,
-      deps: [],
-      destroyListeners: [],
-      effects: [],
-      destroyPromise: null,
-      creationPromise: null
-    });
-    this.notifyListeners(instanceName);
+  getManager() {
+    return this.manager;
   }
-  removeInstance(token, args) {
-    const instanceName = this.getInstanceIdentifier(token, args);
-    return this.invalidate(instanceName);
-  }
-  resolveTokenArgs(token, args) {
-    let realArgs = args;
-    if (token instanceof BoundInjectionToken) {
-      realArgs = token.value;
-    } else if (token instanceof FactoryInjectionToken) {
-      if (token.resolved) {
-        realArgs = token.value;
-      } else {
-        return [new FactoryTokenNotResolved(token.name)];
-      }
-    }
-    if (!token.schema) {
-      return [void 0, realArgs];
-    }
-    const validatedArgs = token.schema?.safeParse(realArgs);
-    if (validatedArgs && !validatedArgs.success) {
-      this.logger?.error(
-        `[ServiceLocator]#resolveTokenArgs(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error
-      );
-      return [new UnknownError(validatedArgs.error)];
+  getInstanceIdentifier(token, args) {
+    const [err, { actualToken, validatedArgs }] = this.validateAndResolveTokenArgs(token, args);
+    if (err) {
+      throw err;
     }
-    return [void 0, validatedArgs?.data];
+    return this.generateInstanceName(actualToken, validatedArgs);
   }
-  getInstanceIdentifier(token, args) {
-    const [err, realArgs] = this.resolveTokenArgs(
+  async getInstance(token, args, onPrepare) {
+    const [err, data] = await this.resolveTokenAndPrepareInstanceName(
       token,
       args
     );
     if (err) {
-      throw err;
-    }
-    return this.makeInstanceName(token, realArgs);
-  }
-  async getInstance(token, args) {
-    const [err, realArgs] = this.resolveTokenArgs(token, args);
-    if (err instanceof UnknownError) {
       return [err];
-    } else if (err instanceof FactoryTokenNotResolved && token instanceof FactoryInjectionToken) {
-      this.logger?.log(
-        `[ServiceLocator]#getInstance() Factory token not resolved, resolving it`
-      );
-      await token.resolve();
-      return this.getInstance(token);
     }
-    const instanceName = this.makeInstanceName(token, realArgs);
-    const [error, holder] = this.manager.get(instanceName);
-    if (!error) {
-      if (holder.status === "creating" /* Creating */) {
-        return holder.creationPromise;
-      } else if (holder.status === "destroying" /* Destroying */) {
-        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
-      }
-      return [void 0, holder.instance];
+    const { instanceName, validatedArgs, actualToken, realToken } = data;
+    if (onPrepare) {
+      onPrepare({ instanceName, actualToken, validatedArgs });
     }
-    switch (error.code) {
-      case "InstanceDestroying" /* InstanceDestroying */:
-        this.logger?.log(
-          `[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`
-        );
-        await holder?.destroyPromise;
-        return this.getInstance(token, args);
-      case "InstanceExpired" /* InstanceExpired */:
-        this.logger?.log(
-          `[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`
-        );
-        await this.invalidate(instanceName);
-        return this.getInstance(token, args);
-      case "InstanceNotFound" /* InstanceNotFound */:
-        break;
-      default:
-        return [error];
+    const [error, holder] = await this.retrieveOrCreateInstanceByInstanceName(
+      instanceName,
+      realToken,
+      validatedArgs
+    );
+    if (error) {
+      return [error];
     }
-    return this.createInstance(instanceName, token, realArgs);
+    return [void 0, holder.instance];
   }
   async getOrThrowInstance(token, args) {
     const [error, instance] = await this.getInstance(token, args);
@@ -693,142 +901,18 @@ var ServiceLocator = class {
     }
     return instance;
   }
-  notifyListeners(name, event = "create") {
-    this.logger?.log(
-      `[ServiceLocator]#notifyListeners() Notifying listeners for ${name} with event ${event}`
-    );
-    return this.eventBus.emit(name, event);
-  }
-  async createInstance(instanceName, token, args) {
-    this.logger?.log(
-      `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`
-    );
-    let realToken = token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken ? token.token : token;
-    if (this.registry.has(realToken)) {
-      return this.resolveInstance(instanceName, realToken, args);
-    } else {
-      return [new FactoryNotFound(realToken.name.toString())];
-    }
-  }
-  resolveInstance(instanceName, token, args) {
-    this.logger?.log(
-      `[ServiceLocator]#resolveInstance(): Creating instance for ${instanceName} from abstract factory`
-    );
-    const ctx = this.createFactoryContext(instanceName);
-    let { factory, scope } = this.registry.get(token);
-    const holder = {
-      name: instanceName,
-      instance: null,
-      status: "creating" /* Creating */,
-      kind: "abstractFactory" /* AbstractFactory */,
-      // @ts-expect-error TS2322 This is correct type
-      creationPromise: factory(ctx, args).then(async (instance) => {
-        holder.instance = instance;
-        holder.status = "created" /* Created */;
-        holder.deps = ctx.getDependencies();
-        holder.destroyListeners = ctx.getDestroyListeners();
-        holder.ttl = ctx.getTtl();
-        if (holder.deps.length > 0) {
-          this.logger?.log(
-            `[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(
-              ", "
-            )}`
-          );
-          holder.deps.forEach((dependency) => {
-            holder.destroyListeners.push(
-              this.eventBus.on(
-                dependency,
-                "destroy",
-                () => this.invalidate(instanceName)
-              )
-            );
-          });
-        }
-        if (holder.ttl === 0 || scope === "Instance" /* Instance */) {
-          await this.invalidate(instanceName);
-        }
-        await this.notifyListeners(instanceName);
-        return [void 0, instance];
-      }).catch((error) => {
-        this.logger?.error(
-          `[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`,
-          error
-        );
-        return [new UnknownError(error)];
-      }),
-      effects: [],
-      deps: [],
-      destroyListeners: [],
-      createdAt: Date.now(),
-      ttl: Infinity
-    };
-    if (scope === "Singleton" /* Singleton */) {
-      this.logger?.debug(
-        `[ServiceLocator]#resolveInstance(): Setting instance for ${instanceName}`
-      );
-      this.manager.set(instanceName, holder);
-    }
-    return holder.creationPromise;
-  }
-  createFactoryContext(instanceName) {
-    const dependencies = /* @__PURE__ */ new Set();
-    const destroyListeners = /* @__PURE__ */ new Set();
-    const self = this;
-    function invalidate(name = instanceName) {
-      return self.invalidate(name);
-    }
-    function addEffect(listener) {
-      destroyListeners.add(listener);
-    }
-    let ttl = Infinity;
-    function setTtl(value) {
-      ttl = value;
-    }
-    function getTtl() {
-      return ttl;
-    }
-    function on(key, event, listener) {
-      destroyListeners.add(self.eventBus.on(key, event, listener));
-    }
-    return {
-      // @ts-expect-error This is correct type
-      async inject(token, args) {
-        let injectionToken = token;
-        if (typeof token === "function") {
-          injectionToken = getInjectableToken(token);
-        }
-        if (injectionToken) {
-          const [err, validatedArgs] = self.resolveTokenArgs(
-            injectionToken,
-            args
-          );
-          if (err) {
-            throw err;
-          }
-          const instanceName2 = self.makeInstanceName(token, validatedArgs);
-          dependencies.add(instanceName2);
-          return self.getOrThrowInstance(injectionToken, args);
-        }
-        throw new Error(
-          `[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`
-        );
-      },
-      invalidate,
-      on,
-      getDependencies: () => Array.from(dependencies),
-      addEffect,
-      getDestroyListeners: () => Array.from(destroyListeners),
-      setTtl,
-      getTtl,
-      locator: self
-    };
-  }
   getSyncInstance(token, args) {
-    const [err, realArgs] = this.resolveTokenArgs(token, args);
+    const [err, { actualToken, validatedArgs }] = this.validateAndResolveTokenArgs(token, args);
     if (err) {
       return null;
     }
-    const instanceName = this.makeInstanceName(token, realArgs);
+    const instanceName = this.generateInstanceName(actualToken, validatedArgs);
+    if (this.currentRequestContext) {
+      const requestHolder = this.currentRequestContext.getHolder(instanceName);
+      if (requestHolder) {
+        return requestHolder.instance;
+      }
+    }
     const [error, holder] = this.manager.get(instanceName);
     if (error) {
       return null;
@@ -840,7 +924,7 @@ var ServiceLocator = class {
       `[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`
     );
     const toInvalidate = this.manager.filter(
-      (holder) => holder.name === service || holder.deps.includes(service)
+      (holder) => holder.name === service || holder.deps.has(service)
     );
     const promises = [];
     for (const [key, holder] of toInvalidate.entries()) {
@@ -876,7 +960,7 @@ var ServiceLocator = class {
         holder.destroyListeners.map((listener) => listener())
       ).then(async () => {
         this.manager.delete(key);
-        await this.notifyListeners(key, "destroy");
+        await this.emitInstanceEvent(key, "destroy");
       });
       promises.push(holder.destroyPromise);
     }
@@ -895,7 +979,384 @@ var ServiceLocator = class {
       })
     ).then(() => null);
   }
-  makeInstanceName(token, args) {
+  // ============================================================================
+  // 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) {
+    if (this.registry.has(realToken)) {
+      const record = this.registry.get(realToken);
+      if (record.scope === "Request" /* Request */) {
+        if (!this.currentRequestContext) {
+          this.logger?.log(
+            `[ServiceLocator]#retrieveOrCreateInstanceByInstanceName() No current request context available for request-scoped service ${instanceName}`
+          );
+          return [new UnknownError("InstanceNotFound" /* InstanceNotFound */)];
+        }
+        const requestHolder = this.currentRequestContext.getHolder(instanceName);
+        if (requestHolder) {
+          if (requestHolder.status === "creating" /* Creating */) {
+            await requestHolder.creationPromise;
+            return this.retrieveOrCreateInstanceByInstanceName(
+              instanceName,
+              realToken,
+              realArgs
+            );
+          } else if (requestHolder.status === "destroying" /* Destroying */) {
+            return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
+          }
+          return [void 0, requestHolder];
+        }
+      }
+    }
+    const [error, holder] = this.manager.get(instanceName);
+    if (!error) {
+      if (holder.status === "creating" /* Creating */) {
+        await holder.creationPromise;
+        return this.retrieveOrCreateInstanceByInstanceName(
+          instanceName,
+          realToken,
+          realArgs
+        );
+      } else if (holder.status === "destroying" /* Destroying */) {
+        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
+      }
+      return [void 0, holder];
+    }
+    switch (error.code) {
+      case "InstanceDestroying" /* InstanceDestroying */:
+        this.logger?.log(
+          `[ServiceLocator]#retrieveOrCreateInstanceByInstanceName() TTL expired for ${holder?.name}`
+        );
+        await holder?.destroyPromise;
+        return this.retrieveOrCreateInstanceByInstanceName(
+          instanceName,
+          realToken,
+          realArgs
+        );
+      case "InstanceExpired" /* InstanceExpired */:
+        this.logger?.log(
+          `[ServiceLocator]#retrieveOrCreateInstanceByInstanceName() TTL expired for ${holder?.name}`
+        );
+        await this.invalidate(instanceName);
+        return this.retrieveOrCreateInstanceByInstanceName(
+          instanceName,
+          realToken,
+          realArgs
+        );
+      case "InstanceNotFound" /* InstanceNotFound */:
+        break;
+      default:
+        return [error];
+    }
+    const result = await this.createNewInstance(
+      instanceName,
+      realToken,
+      realArgs
+    );
+    if (result[0]) {
+      return [result[0]];
+    }
+    if (result[1].status === "creating" /* Creating */) {
+      await result[1].creationPromise;
+    }
+    if (result[1].status === "error" /* Error */) {
+      return [result[1].instance];
+    }
+    return [void 0, result[1]];
+  }
+  /**
+   * 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]) => {
+      holder.destroyListeners = ctx.getDestroyListeners();
+      holder.creationPromise = null;
+      if (error) {
+        this.logger?.error(
+          `[ServiceLocator]#instantiateServiceFromRegistry(): Error creating instance for ${instanceName}`,
+          error
+        );
+        holder.status = "error" /* Error */;
+        holder.instance = error;
+        if (scope === "Singleton" /* Singleton */) {
+          setTimeout(() => this.invalidate(instanceName), 10);
+        }
+        deferred.reject(error);
+      } else {
+        holder.instance = instance;
+        holder.status = "created" /* Created */;
+        if (ctx.deps.size > 0) {
+          ctx.deps.forEach((dependency) => {
+            holder.destroyListeners.push(
+              this.eventBus.on(
+                dependency,
+                "destroy",
+                () => this.invalidate(instanceName)
+              )
+            );
+          });
+        }
+        await this.emitInstanceEvent(instanceName);
+        deferred.resolve([void 0, instance]);
+      }
+    }).catch((error) => {
+      this.logger?.error(
+        `[ServiceLocator]#instantiateServiceFromRegistry(): Unexpected error creating instance for ${instanceName}`,
+        error
+      );
+      holder.status = "error" /* Error */;
+      holder.instance = error;
+      holder.creationPromise = null;
+      if (scope === "Singleton" /* Singleton */) {
+        setTimeout(() => this.invalidate(instanceName), 10);
+      }
+      deferred.reject(error);
+    });
+    if (scope === "Singleton" /* Singleton */) {
+      this.logger?.debug(
+        `[ServiceLocator]#instantiateServiceFromRegistry(): Setting instance for ${instanceName}`
+      );
+      this.manager.set(instanceName, holder);
+    } else if (scope === "Request" /* Request */ && this.currentRequestContext) {
+      this.logger?.debug(
+        `[ServiceLocator]#instantiateServiceFromRegistry(): Setting request-scoped instance for ${instanceName}`
+      );
+      this.currentRequestContext.addInstance(
+        instanceName,
+        holder.instance,
+        holder
+      );
+    }
+    return [void 0, holder];
+  }
+  /**
+   * 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) {
+        if (contextHolder && contextHolder.priority > 0) {
+          const instanceName = self.generateInstanceName(token, args);
+          const prePreparedInstance = contextHolder.getInstance(instanceName);
+          if (prePreparedInstance !== void 0) {
+            self.logger?.debug(
+              `[ServiceLocator] Using pre-prepared instance ${instanceName} from request context ${contextHolder.requestId}`
+            );
+            deps.add(instanceName);
+            return prePreparedInstance;
+          }
+        }
+        if (self.currentRequestContext && self.currentRequestContext !== contextHolder) {
+          const instanceName = self.generateInstanceName(token, args);
+          const prePreparedInstance = self.currentRequestContext.getInstance(instanceName);
+          if (prePreparedInstance !== void 0) {
+            self.logger?.debug(
+              `[ServiceLocator] Using pre-prepared instance ${instanceName} from current request context ${self.currentRequestContext.requestId}`
+            );
+            deps.add(instanceName);
+            return prePreparedInstance;
+          }
+        }
+        const [error, instance] = await self.getInstance(
+          token,
+          args,
+          ({ instanceName }) => {
+            deps.add(instanceName);
+          }
+        );
+        if (error) {
+          throw error;
+        }
+        return instance;
+      },
+      addDestroyListener,
+      getDestroyListeners,
+      locator: self,
+      deps
+    };
+  }
+  /**
+   * Generates a unique instance name based on token and arguments.
+   */
+  generateInstanceName(token, args) {
     const formattedArgs = args ? ":" + Object.entries(args ?? {}).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => {
       if (typeof value === "function") {
         return `${key}=fn_${value.name}(${value.length})`;
@@ -909,27 +1370,99 @@ var ServiceLocator = class {
   }
 };
 
-// src/injector.mts
-var globalServiceLocator = new ServiceLocator(globalRegistry);
-function getGlobalServiceLocator() {
-  if (!globalServiceLocator) {
-    throw new Error(
-      "[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
+// 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 */
     );
   }
-  return globalServiceLocator;
-}
-var values = getInjectors({
-  baseLocator: globalServiceLocator
-});
-var inject = values.inject;
-var syncInject = values.syncInject;
-var wrapSyncInit = values.wrapSyncInit;
-var provideServiceLocator = values.provideServiceLocator;
+  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;
 
 exports.BoundInjectionToken = BoundInjectionToken;
+exports.Container = Container;
+exports.DefaultRequestContextHolder = DefaultRequestContextHolder;
+exports.Deferred = Deferred;
 exports.ErrorsEnum = ErrorsEnum;
-exports.EventEmitter = EventEmitter;
+exports.Factory = Factory;
 exports.FactoryInjectionToken = FactoryInjectionToken;
 exports.FactoryNotFound = FactoryNotFound;
 exports.FactoryTokenNotResolved = FactoryTokenNotResolved;
@@ -938,27 +1471,25 @@ exports.InjectableScope = InjectableScope;
 exports.InjectableTokenMeta = InjectableTokenMeta;
 exports.InjectableType = InjectableType;
 exports.InjectionToken = InjectionToken;
-exports.InjectorsBase = InjectorsBase;
 exports.InstanceDestroying = InstanceDestroying;
 exports.InstanceExpired = InstanceExpired;
 exports.InstanceNotFound = InstanceNotFound;
-exports.ProxyServiceLocator = ProxyServiceLocator;
 exports.Registry = Registry;
+exports.ServiceInstantiator = ServiceInstantiator;
 exports.ServiceLocator = ServiceLocator;
 exports.ServiceLocatorEventBus = ServiceLocatorEventBus;
-exports.ServiceLocatorInstanceHolderKind = ServiceLocatorInstanceHolderKind;
 exports.ServiceLocatorInstanceHolderStatus = ServiceLocatorInstanceHolderStatus;
 exports.ServiceLocatorManager = ServiceLocatorManager;
 exports.UnknownError = UnknownError;
-exports.getGlobalServiceLocator = getGlobalServiceLocator;
+exports.asyncInject = asyncInject;
+exports.createDeferred = createDeferred;
+exports.createRequestContextHolder = createRequestContextHolder;
+exports.defaultInjectors = defaultInjectors;
 exports.getInjectableToken = getInjectableToken;
 exports.getInjectors = getInjectors;
 exports.globalRegistry = globalRegistry;
 exports.inject = inject;
-exports.makeProxyServiceLocator = makeProxyServiceLocator;
-exports.provideServiceLocator = provideServiceLocator;
-exports.resolveService = resolveService;
-exports.syncInject = syncInject;
+exports.provideFactoryContext = provideFactoryContext;
 exports.wrapSyncInit = wrapSyncInit;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map