@navios/di 0.6.1 → 0.7.1

package/lib/testing/index.mjs

@@ -1,3 +1,342 @@
-import { n as _TestContainer, t as TestBindingBuilder } from "../testing-BG_fa9TJ.mjs";
+import { A as Injectable, C as getInjectableToken, L as InjectableType, N as globalRegistry, R as InjectableScope, t as _Container$1 } from "../container-Pb_Y4Z4x.mjs";
 
-export { TestBindingBuilder, _TestContainer as TestContainer };
+//#region src/testing/test-container.mts
+function applyDecs2203RFactory() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass, _Container;
+/**
+* A binding builder for the TestContainer that allows chaining binding operations.
+*/ var TestBindingBuilder = class {
+	container;
+	token;
+	constructor(container, token) {
+		this.container = container;
+		this.token = token;
+	}
+	/**
+	* Binds the token to a specific value.
+	* This is useful for testing with mock values or constants.
+	* @param value The value to bind to the token
+	*/ toValue(value) {
+		const instanceName = this.container.getServiceLocator().getInstanceIdentifier(this.token);
+		this.container.getServiceLocator().getManager().storeCreatedHolder(instanceName, value, InjectableType.Class, InjectableScope.Singleton);
+		return this.container;
+	}
+	/**
+	* Binds the token to a class constructor.
+	* @param target The class constructor to bind to
+	*/ toClass(target) {
+		this.container["registry"].set(this.token, InjectableScope.Singleton, target, InjectableType.Class);
+		return this.container;
+	}
+};
+let _TestContainer;
+_dec = Injectable();
+var TestContainer = class extends (_Container = _Container$1) {
+	static {
+		({c: [_TestContainer, _initClass]} = _apply_decs_2203_r(this, [], [_dec], _Container));
+	}
+	constructor(registry = globalRegistry, logger = null, injectors = void 0) {
+		super(registry, logger, injectors);
+	}
+	bind(token) {
+		let realToken = token;
+		if (typeof token === "function") realToken = getInjectableToken(token);
+		return new TestBindingBuilder(this, realToken);
+	}
+	bindValue(token, value) {
+		return this.bind(token).toValue(value);
+	}
+	bindClass(token, target) {
+		return this.bind(token).toClass(target);
+	}
+	/**
+	* Creates a new TestContainer instance with the same configuration.
+	* This is useful for creating isolated test containers.
+	* @returns A new TestContainer instance
+	*/ createChild() {
+		return new _TestContainer(this.registry, this.logger, this.injectors);
+	}
+	static {
+		_initClass();
+	}
+};
+
+//#endregion
+export { TestBindingBuilder, _TestContainer as TestContainer };
+//# sourceMappingURL=index.mjs.map

package/lib/testing/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["Container","Injectable","InjectableScope","InjectableType","globalRegistry","getInjectableToken","TestBindingBuilder","container","token","toValue","value","instanceName","getServiceLocator","getInstanceIdentifier","getManager","storeCreatedHolder","Class","Singleton","toClass","target","set","TestContainer","registry","logger","injectors","undefined","bind","realToken","bindValue","bindClass","createChild"],"sources":["../../src/testing/test-container.mts"],"sourcesContent":["import type { ClassType, InjectionToken } from '../token/injection-token.mjs'\nimport type { Registry } from '../token/registry.mjs'\nimport type { Injectors } from '../utils/index.mjs'\n\nimport { Container } from '../container/container.mjs'\nimport { Injectable } from '../decorators/injectable.decorator.mjs'\nimport { InjectableScope, InjectableType } from '../enums/index.mjs'\nimport { globalRegistry } from '../token/registry.mjs'\nimport { getInjectableToken } from '../utils/index.mjs'\n\n/**\n * A binding builder for the TestContainer that allows chaining binding operations.\n */\nexport class TestBindingBuilder<T> {\n  constructor(\n    private readonly container: TestContainer,\n    private readonly token: InjectionToken<T, any>,\n  ) {}\n\n  /**\n   * Binds the token to a specific value.\n   * This is useful for testing with mock values or constants.\n   * @param value The value to bind to the token\n   */\n  toValue(value: T): TestContainer {\n    const instanceName = this.container\n      .getServiceLocator()\n      .getInstanceIdentifier(this.token)\n    this.container\n      .getServiceLocator()\n      .getManager()\n      .storeCreatedHolder(\n        instanceName,\n        value,\n        InjectableType.Class,\n        InjectableScope.Singleton,\n      )\n    return this.container\n  }\n\n  /**\n   * Binds the token to a class constructor.\n   * @param target The class constructor to bind to\n   */\n  toClass(target: ClassType): TestContainer {\n    this.container['registry'].set(\n      this.token,\n      InjectableScope.Singleton,\n      target,\n      InjectableType.Class,\n    )\n    return this.container\n  }\n}\n\n/**\n * TestContainer extends the base Container with additional methods useful for testing.\n * It provides a simplified API for binding values and classes during test setup.\n */\n@Injectable()\nexport class TestContainer extends Container {\n  constructor(\n    registry: Registry = globalRegistry,\n    logger: Console | null = null,\n    injectors: Injectors = undefined as any,\n  ) {\n    super(registry, logger, injectors)\n  }\n\n  /**\n   * Creates a binding builder for the given token.\n   * This allows chaining binding operations like bind(Token).toValue(value).\n   * @param token The injection token to bind\n   * @returns A TestBindingBuilder for chaining binding operations\n   */\n  bind<T>(token: ClassType): TestBindingBuilder<T>\n  bind<T>(token: InjectionToken<T, any>): TestBindingBuilder<T>\n  bind(token: any): TestBindingBuilder<any> {\n    let realToken = token\n    if (typeof token === 'function') {\n      realToken = getInjectableToken(token)\n    }\n    return new TestBindingBuilder(this, realToken)\n  }\n\n  /**\n   * Binds a value directly to a token.\n   * This is a convenience method equivalent to bind(token).toValue(value).\n   * @param token The injection token to bind\n   * @param value The value to bind to the token\n   * @returns The TestContainer instance for chaining\n   */\n  bindValue<T>(token: ClassType, value: T): TestContainer\n  bindValue<T>(token: InjectionToken<T, any>, value: T): TestContainer\n  bindValue(token: any, value: any): TestContainer {\n    return this.bind(token).toValue(value)\n  }\n\n  /**\n   * Binds a class to a token.\n   * This is a convenience method equivalent to bind(token).toClass(target).\n   * @param token The injection token to bind\n   * @param target The class constructor to bind to\n   * @returns The TestContainer instance for chaining\n   */\n  bindClass(token: ClassType, target: ClassType): TestContainer\n  bindClass<T>(token: InjectionToken<T, any>, target: ClassType): TestContainer\n  bindClass(token: any, target: any): TestContainer {\n    return this.bind(token).toClass(target)\n  }\n\n  /**\n   * Creates a new TestContainer instance with the same configuration.\n   * This is useful for creating isolated test containers.\n   * @returns A new TestContainer instance\n   */\n  createChild(): TestContainer {\n    return new TestContainer(this.registry, this.logger, this.injectors)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA4DmCA;;;GA/CnC,IAAaM,qBAAb,MAAaA;;;CACX,YACE,WACA,OACA;OAFiBC,YAAAA;OACAC,QAAAA;;;;;;IAQnBC,QAAQC,OAAyB;EAC/B,MAAMC,eAAe,KAAKJ,UACvBK,mBAAiB,CACjBC,sBAAsB,KAAKL,MAAK;AACnC,OAAKD,UACFK,mBAAiB,CACjBE,YAAU,CACVC,mBACCJ,cACAD,OACAP,eAAea,OACfd,gBAAgBe,UAAS;AAE7B,SAAO,KAAKV;;;;;IAOdW,QAAQC,QAAkC;AACxC,OAAKZ,UAAU,YAAYa,IACzB,KAAKZ,OACLN,gBAAgBe,WAChBE,QACAhB,eAAea,MAAK;AAEtB,SAAO,KAAKT;;;;OAQfN,YAAAA;AACM,IAAMoB,gBAAN,eAA4BrB,aAAAA,cAAAA;;4EAAAA,WAAAA;;CACjC,YACEsB,WAAqBlB,gBACrBmB,SAAyB,MACzBC,YAAuBC,QACvB;AACA,QAAMH,UAAUC,QAAQC,UAAAA;;CAW1BE,KAAKlB,OAAqC;EACxC,IAAImB,YAAYnB;AAChB,MAAI,OAAOA,UAAU,WACnBmB,aAAYtB,mBAAmBG,MAAAA;AAEjC,SAAO,IAAIF,mBAAmB,MAAMqB,UAAAA;;CAYtCC,UAAUpB,OAAYE,OAA2B;AAC/C,SAAO,KAAKgB,KAAKlB,MAAAA,CAAOC,QAAQC,MAAAA;;CAYlCmB,UAAUrB,OAAYW,QAA4B;AAChD,SAAO,KAAKO,KAAKlB,MAAAA,CAAOU,QAAQC,OAAAA;;;;;;IAQlCW,cAA6B;AAC3B,SAAO,IAAIT,eAAc,KAAKC,UAAU,KAAKC,QAAQ,KAAKC,UAAS"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/di",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"

package/src/__tests__/async-local-storage.browser.spec.mts

@@ -6,51 +6,47 @@
  * 2. All DI functionality works correctly with the polyfill
  * 3. The resolution context pattern works for synchronous operations
  *
- * Note: We use __testing__.forceSyncMode() to simulate browser behavior
- * since happy-dom still runs on Node.js and has process.versions.node.
+ * Note: We directly import the browser implementation to test it
+ * in isolation, simulating how it would work in a browser bundle.
  */
 
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { describe, expect, it } from 'vitest'
 
 import {
   createAsyncLocalStorage,
   isUsingNativeAsyncLocalStorage,
-  __testing__,
-} from '../internal/context/async-local-storage.mjs'
+} from '../internal/context/async-local-storage.browser.mjs'
 import {
   getCurrentResolutionContext,
   withResolutionContext,
-  withoutResolutionContext,
 } from '../internal/context/resolution-context.mjs'
-import type { InstanceHolder } from '../internal/holder/instance-holder.mjs'
-import { InstanceStatus } from '../internal/holder/instance-holder.mjs'
-import { InjectableScope } from '../enums/index.mjs'
-
-// Force sync mode for all tests in this file to simulate browser behavior
-beforeAll(() => {
-  __testing__.forceSyncMode()
-})
-
-afterAll(() => {
-  __testing__.reset()
-})
+import { SyncLocalStorage } from '../internal/context/sync-local-storage.mjs'
 
 // ============================================================================
 // SECTION 1: Environment Detection
 // ============================================================================
 
-describe('Browser Environment Detection (forced sync mode)', () => {
-  it('should use sync polyfill when forced', () => {
-    // After forcing sync mode, native AsyncLocalStorage should not be used
+describe('Browser Environment Detection', () => {
+  it('should use sync polyfill in browser build', () => {
     expect(isUsingNativeAsyncLocalStorage()).toBe(false)
   })
 
+  it('should create a SyncLocalStorage instance', () => {
+    const storage = createAsyncLocalStorage<{ value: number }>()
+    expect(storage).toBeInstanceOf(SyncLocalStorage)
+  })
+
   it('should create a working storage instance', () => {
     const storage = createAsyncLocalStorage<{ value: number }>()
     expect(storage).toBeDefined()
     expect(typeof storage.run).toBe('function')
     expect(typeof storage.getStore).toBe('function')
   })
+
+  it('should create a resolution context instance', () => {
+    const resolutionContext = getCurrentResolutionContext()
+    expect(resolutionContext).toBeUndefined()
+  })
 })
 
 // ============================================================================
@@ -111,77 +107,7 @@ describe('SyncLocalStorage in Browser', () => {
 })
 
 // ============================================================================
-// SECTION 3: Resolution Context Integration
-// ============================================================================
-
-describe('Resolution Context in Browser', () => {
-  function createMockHolder(name: string): InstanceHolder {
-    return {
-      status: InstanceStatus.Creating,
-      name,
-      instance: null,
-      creationPromise: null,
-      destroyPromise: null,
-      type: class {} as unknown as InstanceHolder['type'],
-      scope: InjectableScope.Singleton,
-      deps: new Set(),
-      destroyListeners: [],
-      createdAt: Date.now(),
-      waitingFor: new Set(),
-    }
-  }
-
-  it('should track resolution context correctly', () => {
-    const holderA = createMockHolder('ServiceA')
-    const getHolder = () => undefined
-
-    expect(getCurrentResolutionContext()).toBeUndefined()
-
-    withResolutionContext(holderA, getHolder, () => {
-      const ctx = getCurrentResolutionContext()
-      expect(ctx).toBeDefined()
-      expect(ctx?.waiterHolder).toBe(holderA)
-    })
-
-    expect(getCurrentResolutionContext()).toBeUndefined()
-  })
-
-  it('should handle nested resolution contexts', () => {
-    const holderA = createMockHolder('ServiceA')
-    const holderB = createMockHolder('ServiceB')
-    const getHolder = () => undefined
-
-    withResolutionContext(holderA, getHolder, () => {
-      expect(getCurrentResolutionContext()?.waiterHolder.name).toBe('ServiceA')
-
-      withResolutionContext(holderB, getHolder, () => {
-        expect(getCurrentResolutionContext()?.waiterHolder.name).toBe(
-          'ServiceB',
-        )
-      })
-
-      expect(getCurrentResolutionContext()?.waiterHolder.name).toBe('ServiceA')
-    })
-  })
-
-  it('should clear context with withoutResolutionContext', () => {
-    const holderA = createMockHolder('ServiceA')
-    const getHolder = () => undefined
-
-    withResolutionContext(holderA, getHolder, () => {
-      expect(getCurrentResolutionContext()).toBeDefined()
-
-      withoutResolutionContext(() => {
-        expect(getCurrentResolutionContext()).toBeUndefined()
-      })
-
-      expect(getCurrentResolutionContext()).toBeDefined()
-    })
-  })
-})
-
-// ============================================================================
-// SECTION 4: Async Limitations in Browser
+// SECTION 3: Async Limitations in Browser
 // ============================================================================
 
 describe('Async Limitations in Browser (expected behavior)', () => {

package/src/__tests__/container.spec.mts

@@ -1317,6 +1317,99 @@ describe('Container', () => {
         await expect(container.get(ServiceWithUnregistered)).rejects.toThrow()
       })
     })
+
+    describe('failed service retry', () => {
+      it('should allow retrying service creation after initialization failure', async () => {
+        let callCount = 0
+
+        @Factory({ registry })
+        class FailingFactory implements Factorable<TestService> {
+          async create() {
+            callCount++
+            if (callCount === 1) {
+              throw new Error('First attempt fails')
+            }
+            return new TestService()
+          }
+        }
+
+        @Injectable({ registry })
+        class TestService {
+          public value = 'success'
+        }
+
+        // First attempt should fail
+        await expect(container.get(FailingFactory)).rejects.toThrow(
+          'First attempt fails',
+        )
+
+        // Second attempt should succeed (service should be removed from storage after failure)
+        const instance = await container.get(FailingFactory)
+        expect(instance).toBeInstanceOf(TestService)
+        expect(instance.value).toBe('success')
+        expect(callCount).toBe(2)
+      })
+
+      it('should allow retrying injectable service creation after constructor throws', async () => {
+        let callCount = 0
+
+        @Injectable({ registry })
+        class FailingService {
+          public value: string
+
+          constructor() {
+            callCount++
+            if (callCount === 1) {
+              throw new Error('Constructor fails on first attempt')
+            }
+            this.value = 'success'
+          }
+        }
+
+        // First attempt should fail
+        await expect(container.get(FailingService)).rejects.toThrow(
+          'Constructor fails on first attempt',
+        )
+
+        // Second attempt should succeed
+        const instance = await container.get(FailingService)
+        expect(instance).toBeInstanceOf(FailingService)
+        expect(instance.value).toBe('success')
+        expect(callCount).toBe(2)
+      })
+
+      it('should allow retrying request-scoped service creation after failure', async () => {
+        let callCount = 0
+
+        @Injectable({ registry, scope: InjectableScope.Request })
+        class FailingRequestService {
+          public value: string
+
+          constructor() {
+            callCount++
+            if (callCount === 1) {
+              throw new Error('Request service fails on first attempt')
+            }
+            this.value = 'success'
+          }
+        }
+
+        const scoped = container.beginRequest('retry-test-request')
+
+        // First attempt should fail
+        await expect(scoped.get(FailingRequestService)).rejects.toThrow(
+          'Request service fails on first attempt',
+        )
+
+        // Second attempt should succeed within the same request
+        const instance = await scoped.get(FailingRequestService)
+        expect(instance).toBeInstanceOf(FailingRequestService)
+        expect(instance.value).toBe('success')
+        expect(callCount).toBe(2)
+
+        await scoped.endRequest()
+      })
+    })
   })
   describe('custom injectors', () => {
     it('should work with custom injectors', async () => {

package/src/__tests__/e2e.browser.spec.mts

@@ -1,33 +1,25 @@
 /**
  * E2E tests for @navios/di running with SyncLocalStorage (browser mode).
  *
- * This file runs all the same E2E tests but with the sync polyfill forced,
- * simulating browser environment behavior.
+ * This file tests the browser implementation by directly importing from
+ * the browser-specific async-local-storage module.
  *
  * The key difference: In browser mode, AsyncLocalStorage context does NOT
  * propagate across async boundaries. This affects circular dependency detection
  * for async operations, but synchronous DI operations should work identically.
  */
 
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { OnServiceDestroy } from '../interfaces/on-service-destroy.interface.mjs'
+import type { OnServiceInit } from '../interfaces/on-service-init.interface.mjs'
 
 import { Container } from '../container/container.mjs'
 import { Injectable } from '../decorators/injectable.decorator.mjs'
 import { InjectableScope } from '../enums/index.mjs'
-import type { OnServiceDestroy } from '../interfaces/on-service-destroy.interface.mjs'
-import type { OnServiceInit } from '../interfaces/on-service-init.interface.mjs'
+import { isUsingNativeAsyncLocalStorage } from '../internal/context/async-local-storage.browser.mjs'
 import { Registry } from '../token/registry.mjs'
 import { getInjectors } from '../utils/get-injectors.mjs'
-import { __testing__, isUsingNativeAsyncLocalStorage } from '../internal/context/async-local-storage.mjs'
-
-// Force sync mode for all tests in this file
-beforeAll(() => {
-  __testing__.forceSyncMode()
-})
-
-afterAll(() => {
-  __testing__.reset()
-})
 
 // ============================================================================
 // TEST UTILITIES