@navios/di 0.8.0 → 0.9.0

package/lib/browser/interfaces/container.interface.d.mts

@@ -0,0 +1,59 @@
+import { BoundInjectionToken, ClassType, ClassTypeWithArgument, FactoryInjectionToken, InjectionToken, InjectionTokenSchemaType } from "../token/injection-token.mjs";
+import { Join, UnionToArray } from "../utils/types.mjs";
+import { Factorable } from "./factory.interface.mjs";
+import { ZodType, z } from "zod/v4";
+
+//#region src/interfaces/container.interface.d.mts
+
+/**
+ * Interface for dependency injection containers.
+ * Both Container and ScopedContainer implement this interface,
+ * allowing them to be used interchangeably in factory contexts.
+ */
+interface IContainer {
+  /**
+   * Gets an instance from the container.
+   */
+  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
+  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
+  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
+  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
+  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
+  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
+  /**
+   * Invalidates a service and its dependencies.
+   */
+  invalidate(service: unknown): Promise<void>;
+  /**
+   * Checks if a service is registered in the container.
+   */
+  isRegistered(token: any): boolean;
+  /**
+   * Adds an instance to the container.
+   * Accepts class types, InjectionTokens, and BoundInjectionTokens.
+   * Rejects InjectionTokens with required schemas (use BoundInjectionToken instead).
+   *
+   * @param token The class type, InjectionToken, or BoundInjectionToken to register the instance for
+   * @param instance The instance to store
+   */
+  addInstance<T>(token: ClassType | InjectionToken<T, any> | BoundInjectionToken<T, any>, instance: T): void;
+  /**
+   * Disposes the container and cleans up all resources.
+   */
+  dispose(): Promise<void>;
+  /**
+   * Waits for all pending operations to complete.
+   */
+  ready(): Promise<void>;
+  /**
+   * @internal
+   * Attempts to get an instance synchronously if it already exists.
+   * Returns null if the instance doesn't exist or is not ready.
+   * Used internally by the inject system for synchronous property initialization.
+   */
+  tryGetSync<T>(token: any, args?: any): T | null;
+}
+//#endregion
+export { IContainer };
+//# sourceMappingURL=container.interface.d.mts.map

package/lib/browser/interfaces/container.interface.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.interface.d.mts","names":[],"sources":["../../../src/interfaces/container.interface.mts"],"sourcesContent":[],"mappings":";;;;;;;;;AAkBA;;;AAOkB,UAPD,UAAA,CAOC;EAAb;;;EACC,GAAA,CAAA,UAHU,SAGV,CAAA,CAAA,KAAA,EAFK,CAEL,CAAA,EADD,YACC,CADY,CACZ,CAAA,SADuB,UACvB,CAAA,KAAA,EAAA,CAAA,GAAA,OAAA,CAAQ,CAAR,CAAA,GACA,OADA,CACQ,YADR,CACqB,CADrB,CAAA,CAAA;EACqB,GAAA,CAAA,UAEX,qBAFW,CAEW,CAFX,CAAA,EAAA,CAAA,CAAA,CAAA,KAAA,EAGhB,CAHgB,EAAA,IAAA,EAIjB,CAJiB,CAAA,EAKtB,OALsB,CAKd,YALc,CAKD,CALC,CAAA,CAAA;EAAb,GAAA,CAAA,CAAA,EAAA,UAOK,wBAPL,CAAA,CAAA,KAAA,EAQH,cARG,CAQY,CARZ,EAQe,CARf,CAAA,EAAA,IAAA,EASJ,CAAA,CAAE,KATE,CASI,CATJ,CAAA,CAAA,EAUT,OAVS,CAUD,CAVC,CAAA;EAAR,GAAA,CAAA,CAAA,EAAA,UAYa,wBAZb,EAAA,UAAA,OAAA,CAAA,CAAA,KAAA,EAaK,cAbL,CAaoB,CAbpB,EAauB,CAbvB,EAa0B,CAb1B,CAAA,CAAA,EAcD,CAdC,SAAA,KAAA,GAeA,OAfA,CAeQ,CAfR,CAAA,GAgBA,CAhBA,SAgBU,OAhBV,CAAA,KAAA,KAAA,CAAA,GAAA,oCAiBsC,IAjBtC,CAkBI,YAlBJ,CAAA,MAkBuB,IAlBvB,CAAA,EAAA,IAAA,CAAA,EAAA,GAAA,iCAAA;EAEgC,GAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAqBtB,cArBsB,CAqBP,CArBO,EAAA,SAAA,CAAA,CAAA,EAqBS,OArBT,CAqBiB,CArBjB,CAAA;EAAtB,GAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAsBA,mBAtBA,CAsBoB,CAtBpB,EAAA,GAAA,CAAA,CAAA,EAsB8B,OAtB9B,CAsBsC,CAtBtC,CAAA;EACL,GAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAsBK,qBAtBL,CAsB2B,CAtB3B,EAAA,GAAA,CAAA,CAAA,EAsBqC,OAtBrC,CAsB6C,CAtB7C,CAAA;EACD;;;EACL,UAAA,CAAA,OAAA,EAAA,OAAA,CAAA,EAyB2B,OAzB3B,CAAA,IAAA,CAAA;EAEc;;;EACR,YAAA,CAAA,KAAA,EAAA,GAAA,CAAA,EAAA,OAAA;EACO;;;;;;;;EAIP,WAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAiCA,SAjCA,GAiCY,cAjCZ,CAiC2B,CAjC3B,EAAA,GAAA,CAAA,GAiCqC,mBAjCrC,CAiCyD,CAjCzD,EAAA,GAAA,CAAA,EAAA,QAAA,EAkCG,CAlCH,CAAA,EAAA,IAAA;EACN;;;EAEC,OAAA,EAAA,EAqCO,OArCP,CAAA,IAAA,CAAA;EAAU;;;EAC4B,KAAA,EAAA,EAyCjC,OAzCiC,CAAA,IAAA,CAAA;EAMb;;;;;;EACuB,UAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAAA,GAAA,EAAA,IAAA,CAAA,EAAA,GAAA,CAAA,EA0Cb,CA1Ca,GAAA,IAAA"}

package/lib/browser/interfaces/factory.interface.d.mts

@@ -0,0 +1,14 @@
+import { InjectionTokenSchemaType } from "../token/injection-token.mjs";
+import { FactoryContext } from "../internal/context/factory-context.mjs";
+import { z } from "zod/v4";
+
+//#region src/interfaces/factory.interface.d.mts
+interface Factorable<T> {
+  create(ctx?: FactoryContext): Promise<T> | T;
+}
+interface FactorableWithArgs<T, A extends InjectionTokenSchemaType> {
+  create(ctx?: FactoryContext, ...args: [z.output<A>]): Promise<T> | T;
+}
+//#endregion
+export { Factorable, FactorableWithArgs };
+//# sourceMappingURL=factory.interface.d.mts.map

package/lib/browser/interfaces/factory.interface.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.interface.d.mts","names":[],"sources":["../../../src/interfaces/factory.interface.mts"],"sourcesContent":[],"mappings":";;;;;UAKiB;eACF,iBAAiB,QAAQ,KAAK;AAD7C;AACe,UAGE,kBAHF,CAAA,CAAA,EAAA,UAGkC,wBAHlC,CAAA,CAAA;EAAyB,MAAA,CAAA,GAAA,CAAA,EAIzB,cAJyB,EAAA,GAAA,IAAA,EAAA,CAIC,CAAA,CAAE,MAJH,CAIU,CAJV,CAAA,CAAA,CAAA,EAIgB,OAJhB,CAIwB,CAJxB,CAAA,GAI6B,CAJ7B"}

package/lib/browser/interfaces/on-service-destroy.interface.d.mts

@@ -0,0 +1,7 @@
+//#region src/interfaces/on-service-destroy.interface.d.mts
+interface OnServiceDestroy {
+  onServiceDestroy(): Promise<void> | void;
+}
+//#endregion
+export { OnServiceDestroy };
+//# sourceMappingURL=on-service-destroy.interface.d.mts.map

package/lib/browser/interfaces/on-service-destroy.interface.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-service-destroy.interface.d.mts","names":[],"sources":["../../../src/interfaces/on-service-destroy.interface.mts"],"sourcesContent":[],"mappings":";UAAiB,gBAAA;EAAA,gBAAA,EAAA,EACK,OADW,CAAA,IACX,CAAA,GAAA,IAAO"}

package/lib/browser/interfaces/on-service-init.interface.d.mts

@@ -0,0 +1,7 @@
+//#region src/interfaces/on-service-init.interface.d.mts
+interface OnServiceInit {
+  onServiceInit(): Promise<void> | void;
+}
+//#endregion
+export { OnServiceInit };
+//# sourceMappingURL=on-service-init.interface.d.mts.map

package/lib/browser/interfaces/on-service-init.interface.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-service-init.interface.d.mts","names":[],"sources":["../../../src/interfaces/on-service-init.interface.mts"],"sourcesContent":[],"mappings":";UAAiB,aAAA;EAAA,aAAA,EAAA,EACE,OADW,CAAA,IACX,CAAA,GAAA,IAAO"}

package/lib/browser/internal/context/async-local-storage.browser.mjs

@@ -0,0 +1,20 @@
+import { SyncLocalStorage } from "./sync-local-storage.mjs";
+
+//#region src/internal/context/async-local-storage.browser.mts
+/**
+* Browser implementation using SyncLocalStorage.
+*
+* This module is used in browser environments where async_hooks is not available.
+* It provides synchronous-only context tracking which is sufficient for
+* browser-based DI resolution.
+*/
+function createAsyncLocalStorage() {
+	return new SyncLocalStorage();
+}
+function isUsingNativeAsyncLocalStorage() {
+	return false;
+}
+
+//#endregion
+export { createAsyncLocalStorage, isUsingNativeAsyncLocalStorage };
+//# sourceMappingURL=async-local-storage.browser.mjs.map

package/lib/browser/internal/context/async-local-storage.browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-local-storage.browser.mjs","names":[],"sources":["../../../../src/internal/context/async-local-storage.browser.mts"],"sourcesContent":["/**\n * Browser implementation using SyncLocalStorage.\n *\n * This module is used in browser environments where async_hooks is not available.\n * It provides synchronous-only context tracking which is sufficient for\n * browser-based DI resolution.\n */\n\nimport { SyncLocalStorage } from './sync-local-storage.mjs'\n\nexport type { IAsyncLocalStorage } from './async-local-storage.types.mjs'\n\nexport function createAsyncLocalStorage<T>() {\n  return new SyncLocalStorage<T>()\n}\n\nexport function isUsingNativeAsyncLocalStorage(): boolean {\n  return false\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAgB,0BAA6B;AAC3C,QAAO,IAAI,kBAAqB;;AAGlC,SAAgB,iCAA0C;AACxD,QAAO"}

package/lib/browser/internal/context/async-local-storage.d.mts

@@ -0,0 +1,9 @@
+import { IAsyncLocalStorage } from "./async-local-storage.types.mjs";
+
+//#region src/internal/context/async-local-storage.d.mts
+
+declare function createAsyncLocalStorage<T>(): IAsyncLocalStorage<T>;
+declare function isUsingNativeAsyncLocalStorage(): boolean;
+//#endregion
+export { createAsyncLocalStorage, isUsingNativeAsyncLocalStorage };
+//# sourceMappingURL=async-local-storage.d.mts.map

package/lib/browser/internal/context/async-local-storage.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-local-storage.d.mts","names":[],"sources":["../../../../src/internal/context/async-local-storage.mts"],"sourcesContent":[],"mappings":";;;;iBA6DgB,8BAA8B,mBAAmB;iBAIjD,8BAAA,CAAA"}

package/lib/browser/internal/context/async-local-storage.types.d.mts

@@ -0,0 +1,11 @@
+//#region src/internal/context/async-local-storage.types.d.mts
+/**
+ * Interface matching the subset of AsyncLocalStorage API we use.
+ */
+interface IAsyncLocalStorage<T> {
+  run<R>(store: T, fn: () => R): R;
+  getStore(): T | undefined;
+}
+//#endregion
+export { IAsyncLocalStorage };
+//# sourceMappingURL=async-local-storage.types.d.mts.map

package/lib/browser/internal/context/async-local-storage.types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-local-storage.types.d.mts","names":[],"sources":["../../../../src/internal/context/async-local-storage.types.mts"],"sourcesContent":[],"mappings":";;AAGA;;AAC6B,UADZ,kBACY,CAAA,CAAA,CAAA,CAAA;EAAI,GAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAAjB,CAAiB,EAAA,EAAA,EAAA,GAAA,GAAJ,CAAI,CAAA,EAAA,CAAA;EACnB,QAAA,EAAA,EAAA,CAAA,GAAA,SAAA"}

package/lib/browser/internal/context/factory-context.d.mts

@@ -0,0 +1,23 @@
+import { IContainer } from "../../interfaces/container.interface.mjs";
+import { Injectors } from "../../utils/get-injectors.mjs";
+
+//#region src/internal/context/factory-context.d.mts
+
+/**
+ * Context provided to factory functions during service instantiation.
+ *
+ * Provides access to dependency injection (via inject), the container,
+ * and lifecycle hooks for cleanup.
+ */
+interface FactoryContext {
+  inject: Injectors['asyncInject'];
+  /**
+   * The container instance for dependency resolution.
+   * This may be either a Container or ScopedContainer.
+   */
+  container: IContainer;
+  addDestroyListener: (listener: () => void) => void;
+}
+//#endregion
+export { FactoryContext };
+//# sourceMappingURL=factory-context.d.mts.map

package/lib/browser/internal/context/factory-context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-context.d.mts","names":[],"sources":["../../../../src/internal/context/factory-context.mts"],"sourcesContent":[],"mappings":";;;;;;;AASA;;;;UAAiB,cAAA;UACP;;;;;aAKG"}

package/lib/browser/internal/context/resolution-context.d.mts

@@ -0,0 +1,43 @@
+import { InstanceHolder } from "../holder/instance-holder.mjs";
+
+//#region src/internal/context/resolution-context.d.mts
+
+/**
+ * Data stored in the resolution context during service instantiation.
+ */
+interface ResolutionContextData {
+  /** The holder that is currently being instantiated */
+  waiterHolder: InstanceHolder;
+  /** Function to get a holder by name (for cycle detection) */
+  getHolder: (name: string) => InstanceHolder | undefined;
+}
+/**
+ * Runs a function within a resolution context.
+ *
+ * The context tracks which holder is currently being instantiated,
+ * allowing circular dependency detection to work correctly.
+ *
+ * @param waiterHolder The holder being instantiated
+ * @param getHolder Function to retrieve holders by name
+ * @param fn The function to run within the context
+ */
+declare function withResolutionContext<T>(waiterHolder: InstanceHolder, getHolder: (name: string) => InstanceHolder | undefined, fn: () => T): T;
+/**
+ * Gets the current resolution context, if any.
+ *
+ * Returns undefined if we're not inside a resolution context
+ * (e.g., when resolving a top-level service that has no parent).
+ */
+declare function getCurrentResolutionContext(): ResolutionContextData | undefined;
+/**
+ * Runs a function outside any resolution context.
+ *
+ * This is useful for async injections that should not participate
+ * in circular dependency detection since they don't block.
+ *
+ * @param fn The function to run without resolution context
+ */
+declare function withoutResolutionContext<T>(fn: () => T): T;
+//#endregion
+export { ResolutionContextData, getCurrentResolutionContext, withResolutionContext, withoutResolutionContext };
+//# sourceMappingURL=resolution-context.d.mts.map

package/lib/browser/internal/context/resolution-context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution-context.d.mts","names":[],"sources":["../../../../src/internal/context/resolution-context.mts"],"sourcesContent":[],"mappings":";;;;;;AAQA;AAsCgB,UAtCC,qBAAA,CAsCoB;EACrB;EACe,YAAA,EAtCf,cAsCe;EACnB;EACT,SAAA,EAAA,CAAA,IAAA,EAAA,MAAA,EAAA,GAtC4B,cAsC5B,GAAA,SAAA;;AAUH;AAcA;;;;;;;;;iBA5BgB,uCACA,6CACe,sCACnB,IACT;;;;;;;iBAUa,2BAAA,CAAA,GACZ;;;;;;;;;iBAaY,sCAAsC,IAAI"}

package/lib/browser/internal/context/resolution-context.mjs

@@ -0,0 +1,56 @@
+import { createAsyncLocalStorage } from "./async-local-storage.browser.mjs";
+
+//#region src/internal/context/resolution-context.mts
+/**
+* AsyncLocalStorage for tracking the current resolution context.
+*
+* This allows tracking which service is being instantiated even across
+* async boundaries (like when inject() is called inside a constructor).
+* Essential for circular dependency detection.
+*
+* The actual implementation varies by environment:
+* - Production: No-op (returns undefined, run() just calls fn directly)
+* - Development: Real AsyncLocalStorage with full async tracking
+* - Browser: SyncLocalStorage for synchronous-only tracking
+*/ let resolutionContext = null;
+function getResolutionContext() {
+	if (!resolutionContext) resolutionContext = createAsyncLocalStorage();
+	return resolutionContext;
+}
+/**
+* Runs a function within a resolution context.
+*
+* The context tracks which holder is currently being instantiated,
+* allowing circular dependency detection to work correctly.
+*
+* @param waiterHolder The holder being instantiated
+* @param getHolder Function to retrieve holders by name
+* @param fn The function to run within the context
+*/ function withResolutionContext(waiterHolder, getHolder, fn) {
+	return getResolutionContext().run({
+		waiterHolder,
+		getHolder
+	}, fn);
+}
+/**
+* Gets the current resolution context, if any.
+*
+* Returns undefined if we're not inside a resolution context
+* (e.g., when resolving a top-level service that has no parent).
+*/ function getCurrentResolutionContext() {
+	return getResolutionContext().getStore();
+}
+/**
+* Runs a function outside any resolution context.
+*
+* This is useful for async injections that should not participate
+* in circular dependency detection since they don't block.
+*
+* @param fn The function to run without resolution context
+*/ function withoutResolutionContext(fn) {
+	return getResolutionContext().run(void 0, fn);
+}
+
+//#endregion
+export { getCurrentResolutionContext, withResolutionContext, withoutResolutionContext };
+//# sourceMappingURL=resolution-context.mjs.map

package/lib/browser/internal/context/resolution-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution-context.mjs","names":["createAsyncLocalStorage","resolutionContext","getResolutionContext","withResolutionContext","waiterHolder","getHolder","fn","run","getCurrentResolutionContext","getStore","withoutResolutionContext","undefined"],"sources":["../../../../src/internal/context/resolution-context.mts"],"sourcesContent":["import type { InstanceHolder } from '../holder/instance-holder.mjs'\nimport type { IAsyncLocalStorage } from './async-local-storage.types.mjs'\n\nimport { createAsyncLocalStorage } from './async-local-storage.mjs'\n\n/**\n * Data stored in the resolution context during service instantiation.\n */\nexport interface ResolutionContextData {\n  /** The holder that is currently being instantiated */\n  waiterHolder: InstanceHolder\n  /** Function to get a holder by name (for cycle detection) */\n  getHolder: (name: string) => InstanceHolder | undefined\n}\n\n/**\n * AsyncLocalStorage for tracking the current resolution context.\n *\n * This allows tracking which service is being instantiated even across\n * async boundaries (like when inject() is called inside a constructor).\n * Essential for circular dependency detection.\n *\n * The actual implementation varies by environment:\n * - Production: No-op (returns undefined, run() just calls fn directly)\n * - Development: Real AsyncLocalStorage with full async tracking\n * - Browser: SyncLocalStorage for synchronous-only tracking\n */\nlet resolutionContext: IAsyncLocalStorage<ResolutionContextData> | null = null\n\nfunction getResolutionContext(): IAsyncLocalStorage<ResolutionContextData> {\n  if (!resolutionContext) {\n    resolutionContext = createAsyncLocalStorage<ResolutionContextData>()\n  }\n  return resolutionContext\n}\n\n/**\n * Runs a function within a resolution context.\n *\n * The context tracks which holder is currently being instantiated,\n * allowing circular dependency detection to work correctly.\n *\n * @param waiterHolder The holder being instantiated\n * @param getHolder Function to retrieve holders by name\n * @param fn The function to run within the context\n */\nexport function withResolutionContext<T>(\n  waiterHolder: InstanceHolder,\n  getHolder: (name: string) => InstanceHolder | undefined,\n  fn: () => T,\n): T {\n  return getResolutionContext().run({ waiterHolder, getHolder }, fn)\n}\n\n/**\n * Gets the current resolution context, if any.\n *\n * Returns undefined if we're not inside a resolution context\n * (e.g., when resolving a top-level service that has no parent).\n */\nexport function getCurrentResolutionContext():\n  | ResolutionContextData\n  | undefined {\n  return getResolutionContext().getStore()\n}\n\n/**\n * Runs a function outside any resolution context.\n *\n * This is useful for async injections that should not participate\n * in circular dependency detection since they don't block.\n *\n * @param fn The function to run without resolution context\n */\nexport function withoutResolutionContext<T>(fn: () => T): T {\n  // Run with undefined context to clear any current context\n  return getResolutionContext().run(\n    undefined as unknown as ResolutionContextData,\n    fn,\n  )\n}\n\n"],"mappings":";;;;;;;;;;;;;;GA2BA,IAAIC,oBAAsE;AAE1E,SAASC,uBAAAA;AACP,KAAI,CAACD,kBACHA,qBAAoBD,yBAAAA;AAEtB,QAAOC;;;;;;;;;;;GAaT,SAAgBE,sBACdC,cACAC,WACAC,IAAW;AAEX,QAAOJ,sBAAAA,CAAuBK,IAAI;EAAEH;EAAcC;EAAU,EAAGC,GAAAA;;;;;;;GASjE,SAAgBE,8BAAAA;AAGd,QAAON,sBAAAA,CAAuBO,UAAQ;;;;;;;;;GAWxC,SAAgBC,yBAA4BJ,IAAW;AAErD,QAAOJ,sBAAAA,CAAuBK,IAC5BI,QACAL,GAAAA"}

package/lib/browser/internal/context/service-initialization-context.d.mts

@@ -0,0 +1,48 @@
+import { IContainer } from "../../interfaces/container.interface.mjs";
+import { InjectableScope } from "../../enums/injectable-scope.enum.mjs";
+import { Injectors } from "../../utils/get-injectors.mjs";
+
+//#region src/internal/context/service-initialization-context.d.mts
+
+/**
+ * Context provided to injectors during service initialization.
+ *
+ * Extends FactoryContext with additional tracking information about
+ * the service being initialized, its dependencies, and scope.
+ * Used for scope upgrade tracking and dependency management.
+ */
+interface ServiceInitializationContext {
+  inject: Injectors['asyncInject'];
+  /**
+   * The container instance for dependency resolution.
+   * This may be either a Container or ScopedContainer.
+   */
+  container: IContainer;
+  addDestroyListener: (listener: () => void) => void;
+  getDestroyListeners: () => (() => void)[];
+  /**
+   * The name of the service being initialized.
+   */
+  serviceName: string;
+  /**
+   * Set of dependency names that this service depends on.
+   * Automatically populated as dependencies are resolved.
+   */
+  dependencies: Set<string>;
+  /**
+   * The scope of the service being initialized.
+   */
+  scope: InjectableScope;
+  /**
+   * Track a dependency that was resolved.
+   * Used for scope upgrade tracking - if a Singleton service
+   * resolves a Request dependency, the scope can be upgraded.
+   *
+   * @param name The name of the dependency
+   * @param scope The scope of the dependency
+   */
+  trackDependency(name: string, scope: InjectableScope): void;
+}
+//#endregion
+export { ServiceInitializationContext };
+//# sourceMappingURL=service-initialization-context.d.mts.map

package/lib/browser/internal/context/service-initialization-context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-initialization-context.d.mts","names":[],"sources":["../../../../src/internal/context/service-initialization-context.mts"],"sourcesContent":[],"mappings":";;;;;;;;AAWA;;;;;AA8BuC,UA9BtB,4BAAA,CA8BsB;EAAe,MAAA,EA7B5C,SA6B4C,CAAA,aAAA,CAAA;;;;;aAxBzC;;;;;;;;;;;gBAWG;;;;SAIP;;;;;;;;;uCAS8B"}

package/lib/browser/internal/context/sync-local-storage.mjs

@@ -0,0 +1,53 @@
+//#region src/internal/context/sync-local-storage.mts
+/**
+* A synchronous-only polyfill for AsyncLocalStorage.
+*
+* This provides the same API as Node's AsyncLocalStorage but only works
+* for synchronous code paths. It uses a simple stack-based approach.
+*
+* Limitations:
+* - Context does NOT propagate across async boundaries (setTimeout, promises, etc.)
+* - Only suitable for environments where DI resolution is synchronous
+*
+* This is acceptable for browser environments where:
+* 1. Constructors are typically synchronous
+* 2. Circular dependency detection mainly needs sync tracking
+*/
+var SyncLocalStorage = class {
+	stack = [];
+	/**
+	* Runs a function within the given store context.
+	* The context is only available synchronously within the function.
+	*/
+	run(store, fn) {
+		this.stack.push(store);
+		try {
+			return fn();
+		} finally {
+			this.stack.pop();
+		}
+	}
+	/**
+	* Gets the current store value, or undefined if not in a context.
+	*/
+	getStore() {
+		return this.stack.length > 0 ? this.stack[this.stack.length - 1] : void 0;
+	}
+	/**
+	* Exits the current context and runs the function without any store.
+	* This matches AsyncLocalStorage.exit() behavior.
+	*/
+	exit(fn) {
+		const savedStack = this.stack;
+		this.stack = [];
+		try {
+			return fn();
+		} finally {
+			this.stack = savedStack;
+		}
+	}
+};
+
+//#endregion
+export { SyncLocalStorage };
+//# sourceMappingURL=sync-local-storage.mjs.map

package/lib/browser/internal/context/sync-local-storage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-local-storage.mjs","names":[],"sources":["../../../../src/internal/context/sync-local-storage.mts"],"sourcesContent":["import type { IAsyncLocalStorage } from './async-local-storage.types.mjs'\n\n/**\n * A synchronous-only polyfill for AsyncLocalStorage.\n *\n * This provides the same API as Node's AsyncLocalStorage but only works\n * for synchronous code paths. It uses a simple stack-based approach.\n *\n * Limitations:\n * - Context does NOT propagate across async boundaries (setTimeout, promises, etc.)\n * - Only suitable for environments where DI resolution is synchronous\n *\n * This is acceptable for browser environments where:\n * 1. Constructors are typically synchronous\n * 2. Circular dependency detection mainly needs sync tracking\n */\nexport class SyncLocalStorage<T> implements IAsyncLocalStorage<T> {\n  private stack: T[] = []\n\n  /**\n   * Runs a function within the given store context.\n   * The context is only available synchronously within the function.\n   */\n  run<R>(store: T, fn: () => R): R {\n    this.stack.push(store)\n    try {\n      return fn()\n    } finally {\n      this.stack.pop()\n    }\n  }\n\n  /**\n   * Gets the current store value, or undefined if not in a context.\n   */\n  getStore(): T | undefined {\n    return this.stack.length > 0 ? this.stack[this.stack.length - 1] : undefined\n  }\n\n  /**\n   * Exits the current context and runs the function without any store.\n   * This matches AsyncLocalStorage.exit() behavior.\n   */\n  exit<R>(fn: () => R): R {\n    const savedStack = this.stack\n    this.stack = []\n    try {\n      return fn()\n    } finally {\n      this.stack = savedStack\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,IAAa,mBAAb,MAAkE;CAChE,AAAQ,QAAa,EAAE;;;;;CAMvB,IAAO,OAAU,IAAgB;AAC/B,OAAK,MAAM,KAAK,MAAM;AACtB,MAAI;AACF,UAAO,IAAI;YACH;AACR,QAAK,MAAM,KAAK;;;;;;CAOpB,WAA0B;AACxB,SAAO,KAAK,MAAM,SAAS,IAAI,KAAK,MAAM,KAAK,MAAM,SAAS,KAAK;;;;;;CAOrE,KAAQ,IAAgB;EACtB,MAAM,aAAa,KAAK;AACxB,OAAK,QAAQ,EAAE;AACf,MAAI;AACF,UAAO,IAAI;YACH;AACR,QAAK,QAAQ"}

package/lib/browser/internal/core/instance-resolver.d.mts

@@ -0,0 +1,119 @@
+import { AnyInjectableType } from "../../token/injection-token.mjs";
+import { IContainer } from "../../interfaces/container.interface.mjs";
+import { Registry } from "../../token/registry.mjs";
+import { NameResolver } from "./name-resolver.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+import { IHolderStorage } from "../holder/holder-storage.interface.mjs";
+import { LifecycleEventBus } from "../lifecycle/lifecycle-event-bus.mjs";
+import { ServiceInvalidator } from "./service-invalidator.mjs";
+import { TokenResolver } from "./token-resolver.mjs";
+import { ScopedContainer } from "../../container/scoped-container.mjs";
+import { ScopeTracker } from "./scope-tracker.mjs";
+import { ServiceInitializer } from "./service-initializer.mjs";
+
+//#region src/internal/core/instance-resolver.d.mts
+
+/**
+ * Resolves instances from tokens, handling caching, creation, and scope rules.
+ *
+ * Uses unified storage for both singleton and request-scoped services.
+ * Coordinates with ServiceInitializer for actual service creation.
+ * Integrates ScopeTracker for automatic scope upgrades.
+ */
+declare class InstanceResolver {
+  private readonly registry;
+  private readonly storage;
+  private readonly serviceInitializer;
+  private readonly tokenResolver;
+  private readonly nameResolver;
+  private readonly scopeTracker;
+  private readonly serviceInvalidator;
+  private readonly eventBus;
+  private readonly logger;
+  constructor(registry: Registry, storage: IHolderStorage, serviceInitializer: ServiceInitializer, tokenResolver: TokenResolver, nameResolver: NameResolver, scopeTracker: ScopeTracker, serviceInvalidator: ServiceInvalidator, eventBus: LifecycleEventBus, logger?: Console | null);
+  /**
+   * Resolves an instance for the given token and arguments.
+   * This method is used for singleton and transient services.
+   *
+   * @param token The injection token
+   * @param args Optional arguments
+   * @param contextContainer The container to use for creating context
+   * @param requestStorage Optional request storage (for scope upgrades)
+   * @param requestId Optional request ID (for scope upgrades)
+   */
+  resolveInstance(token: AnyInjectableType, args: any, contextContainer: IContainer, requestStorage?: IHolderStorage, requestId?: string): Promise<[undefined, any] | [DIError]>;
+  /**
+   * Resolves a request-scoped instance for a ScopedContainer.
+   * The service will be stored in the ScopedContainer's request storage.
+   *
+   * @param token The injection token
+   * @param args Optional arguments
+   * @param scopedContainer The ScopedContainer that owns the request context
+   */
+  resolveRequestScopedInstance(token: AnyInjectableType, args: any, scopedContainer: ScopedContainer): Promise<[undefined, any] | [DIError]>;
+  /**
+   * Unified resolution method that works with any IHolderStorage.
+   * This eliminates duplication between singleton and request-scoped resolution.
+   *
+   * IMPORTANT: The check-and-store logic is carefully designed to avoid race conditions.
+   * The storage check and holder creation must happen synchronously (no awaits between).
+   *
+   * @param token The injection token
+   * @param args Optional arguments
+   * @param contextContainer The container for context
+   * @param storage The storage strategy to use
+   * @param scopedContainer Optional scoped container for request-scoped services
+   * @param requestStorage Optional request storage (for scope upgrades)
+   * @param requestId Optional request ID (for scope upgrades)
+   */
+  private resolveWithStorage;
+  /**
+   * Internal method to resolve token args and create instance name.
+   * Handles factory token resolution and validation.
+   */
+  private resolveTokenAndPrepareInstanceName;
+  /**
+   * Handles storage error states (destroying, error, etc.).
+   * Returns a result if handled, null if should proceed with creation.
+   */
+  private handleStorageError;
+  /**
+   * Creates a new instance and stores it using the provided storage strategy.
+   * This unified method replaces instantiateServiceFromRegistry and createRequestScopedInstance.
+   *
+   * For transient services, the instance is created but not stored (no caching).
+   */
+  private createAndStoreInstance;
+  /**
+   * Creates a transient instance without storage or locking.
+   * Each call creates a new instance.
+   */
+  private createTransientInstance;
+  /**
+   * Handles successful service instantiation.
+   */
+  private handleInstantiationSuccess;
+  /**
+   * Handles service instantiation errors.
+   */
+  private handleInstantiationError;
+  /**
+   * Handles instantiation result (success or error).
+   */
+  private handleInstantiationResult;
+  /**
+   * Waits for an instance holder to be ready and returns the appropriate result.
+   *
+   * @param holder The holder to wait for
+   * @param waiterHolder Optional holder that is doing the waiting (for circular dependency detection)
+   * @param getHolder Optional function to retrieve holders by name (required if waiterHolder is provided)
+   */
+  private waitForInstanceReady;
+  /**
+   * Creates a ServiceInitializationContext for service instantiation.
+   */
+  private createServiceInitializationContext;
+}
+//#endregion
+export { InstanceResolver };
+//# sourceMappingURL=instance-resolver.d.mts.map

package/lib/browser/internal/core/instance-resolver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-resolver.d.mts","names":[],"sources":["../../../../src/internal/core/instance-resolver.mts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;AAuCA;;;;;AAMmC,cANtB,gBAAA,CAMsB;EACA,iBAAA,QAAA;EACM,iBAAA,OAAA;EACV,iBAAA,kBAAA;EACF,iBAAA,aAAA;EAkBlB,iBAAA,YAAA;EAEW,iBAAA,YAAA;EACD,iBAAA,kBAAA;EAEY,iBAAA,QAAA;EAA5B,iBAAA,MAAA;EAqBM,WAAA,CAAA,QAAA,EApDoB,QAoDpB,EAAA,OAAA,EAnDmB,cAmDnB,EAAA,kBAAA,EAlD8B,kBAkD9B,EAAA,aAAA,EAjDyB,aAiDzB,EAAA,YAAA,EAhDwB,YAgDxB,EAAA,YAAA,EA/CwB,YA+CxB,EAAA,kBAAA,EA9C8B,kBA8C9B,EAAA,QAAA,EA7CoB,iBA6CpB,EAAA,MAAA,CAAA,EA5CkB,OA4ClB,GAAA,IAAA;EAEU;;;;;;;;;;yBA5BV,gDAEW,6BACD,qCAEhB,4BAA4B;;;;;;;;;sCAqBtB,+CAEU,kBAChB,4BAA4B"}