@navios/di 0.7.1 → 0.9.0

package/lib/browser/internal/core/scope-tracker.d.mts

@@ -0,0 +1,65 @@
+import { InjectionToken } from "../../token/injection-token.mjs";
+import { InjectableScope } from "../../enums/injectable-scope.enum.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";
+
+//#region src/internal/core/scope-tracker.d.mts
+
+/**
+ * Component for tracking and handling scope upgrades.
+ *
+ * Detects when a Singleton service needs to be upgraded to Request scope
+ * and coordinates the scope upgrade process atomically.
+ */
+declare class ScopeTracker {
+  private readonly registry;
+  private readonly nameResolver;
+  private readonly logger;
+  constructor(registry: Registry, nameResolver: NameResolver, logger?: Console | null);
+  /**
+   * Checks if a dependency requires scope upgrade and performs it if needed.
+   * Called during service resolution when a dependency is resolved.
+   *
+   * @param currentServiceName - Name of the service being created
+   * @param currentServiceScope - Current scope of the service being created
+   * @param dependencyName - Name of the dependency being resolved
+   * @param dependencyScope - Scope of the dependency
+   * @param dependencyToken - Token of the dependency
+   * @param singletonStorage - Singleton storage instance
+   * @param requestStorage - Request storage instance (if in request context)
+   * @param requestId - Request ID (if in request context)
+   * @returns [needsUpgrade: boolean, newName?: string] - whether upgrade occurred and new name
+   */
+  checkAndUpgradeScope(currentServiceName: string, currentServiceScope: InjectableScope, dependencyName: string, dependencyScope: InjectableScope, dependencyToken: InjectionToken<any, any>, singletonStorage: IHolderStorage, requestStorage?: IHolderStorage, requestId?: string): [boolean, string?];
+  /**
+   * Performs the actual scope upgrade from Singleton to Request.
+   * This is the core migration logic.
+   *
+   * @param serviceName - Current service name (without requestId)
+   * @param token - Service injection token
+   * @param singletonStorage - Source storage
+   * @param requestStorage - Target storage
+   * @param requestId - Request ID to include in new name
+   * @returns [success: boolean, newName?: string, error?: DIError]
+   */
+  upgradeScopeToRequest(serviceName: string, token: InjectionToken<any, any>, singletonStorage: IHolderStorage, requestStorage: IHolderStorage, requestId: string): Promise<[boolean, string?, DIError?]>;
+  /**
+   * Synchronous part of scope upgrade - handles immediate updates.
+   * Async operations (like waiting for holder creation) should be done separately.
+   */
+  private upgradeScopeToRequestSync;
+  /**
+   * Updates all parent dependencies to reference the new service name.
+   *
+   * @param oldName - Original service name
+   * @param newName - New service name with requestId
+   * @param singletonStorage - Singleton storage to check
+   * @param requestStorage - Request storage to check
+   */
+  updateParentDependencies(oldName: string, newName: string, singletonStorage: IHolderStorage, requestStorage?: IHolderStorage): void;
+}
+//#endregion
+export { ScopeTracker };
+//# sourceMappingURL=scope-tracker.d.mts.map

package/lib/browser/internal/core/scope-tracker.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-tracker.d.mts","names":[],"sources":["../../../../src/internal/core/scope-tracker.mts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAgBA;;;;AAuByB,cAvBZ,YAAA,CAuBY;EAEJ,iBAAA,QAAA;EACA,iBAAA,YAAA;EACC,iBAAA,MAAA;EACD,WAAA,CAAA,QAAA,EA1BU,QA0BV,EAAA,YAAA,EAzBc,YAyBd,EAAA,MAAA,CAAA,EAxBQ,OAwBR,GAAA,IAAA;EA2DV;;;;;;;;;;;;;;wEAhEc,0DAEJ,kCACA,4CACC,iCACD;;;;;;;;;;;;oDA2DV,4CACW,gCACF,oCAEf,2BAA2B;;;;;;;;;;;;;;+EA2HV,iCACD"}

package/lib/browser/internal/core/scope-tracker.mjs

@@ -0,0 +1,120 @@
+import { InjectableScope } from "../../enums/injectable-scope.enum.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+import { InstanceStatus } from "../holder/instance-holder.mjs";
+
+//#region src/internal/core/scope-tracker.mts
+/**
+* Component for tracking and handling scope upgrades.
+*
+* Detects when a Singleton service needs to be upgraded to Request scope
+* and coordinates the scope upgrade process atomically.
+*/ var ScopeTracker = class {
+	registry;
+	nameResolver;
+	logger;
+	constructor(registry, nameResolver, logger = null) {
+		this.registry = registry;
+		this.nameResolver = nameResolver;
+		this.logger = logger;
+	}
+	/**
+	* Checks if a dependency requires scope upgrade and performs it if needed.
+	* Called during service resolution when a dependency is resolved.
+	*
+	* @param currentServiceName - Name of the service being created
+	* @param currentServiceScope - Current scope of the service being created
+	* @param dependencyName - Name of the dependency being resolved
+	* @param dependencyScope - Scope of the dependency
+	* @param dependencyToken - Token of the dependency
+	* @param singletonStorage - Singleton storage instance
+	* @param requestStorage - Request storage instance (if in request context)
+	* @param requestId - Request ID (if in request context)
+	* @returns [needsUpgrade: boolean, newName?: string] - whether upgrade occurred and new name
+	*/ checkAndUpgradeScope(currentServiceName, currentServiceScope, dependencyName, dependencyScope, dependencyToken, singletonStorage, requestStorage, requestId) {
+		if (currentServiceScope !== InjectableScope.Singleton || dependencyScope !== InjectableScope.Request) return [false];
+		if (!requestStorage || !requestId) {
+			this.logger?.warn(`[ScopeTracker] Cannot upgrade scope for ${currentServiceName}: missing requestStorage or requestId`);
+			return [false];
+		}
+		this.logger?.log(`[ScopeTracker] Upgrading ${currentServiceName} from Singleton to Request scope`);
+		try {
+			const [success, newName] = this.upgradeScopeToRequestSync(currentServiceName, dependencyToken, singletonStorage, requestStorage, requestId);
+			if (success && newName) return [true, newName];
+		} catch (error) {
+			this.logger?.error(`[ScopeTracker] Error upgrading scope for ${currentServiceName}:`, error);
+		}
+		return [false];
+	}
+	/**
+	* Performs the actual scope upgrade from Singleton to Request.
+	* This is the core migration logic.
+	*
+	* @param serviceName - Current service name (without requestId)
+	* @param token - Service injection token
+	* @param singletonStorage - Source storage
+	* @param requestStorage - Target storage
+	* @param requestId - Request ID to include in new name
+	* @returns [success: boolean, newName?: string, error?: DIError]
+	*/ async upgradeScopeToRequest(serviceName, token, singletonStorage, requestStorage, requestId) {
+		try {
+			const [success, newName] = this.upgradeScopeToRequestSync(serviceName, token, singletonStorage, requestStorage, requestId);
+			if (success && newName) return [true, newName];
+			return [
+				false,
+				void 0,
+				DIError.storageError("Scope upgrade failed", "upgradeScopeToRequest", serviceName)
+			];
+		} catch (error) {
+			return [
+				false,
+				void 0,
+				error instanceof DIError ? error : DIError.unknown(error)
+			];
+		}
+	}
+	/**
+	* Synchronous part of scope upgrade - handles immediate updates.
+	* Async operations (like waiting for holder creation) should be done separately.
+	*/ upgradeScopeToRequestSync(serviceName, token, singletonStorage, requestStorage, requestId) {
+		const newName = this.nameResolver.upgradeInstanceNameToRequest(serviceName, requestId);
+		if (!this.registry.updateScope(token, InjectableScope.Request)) {
+			this.logger?.warn(`[ScopeTracker] Could not update scope in registry for ${serviceName}`);
+			return [false];
+		}
+		const holderResult = singletonStorage.get(serviceName);
+		if (holderResult === null) return [true, newName];
+		const [error, holder] = holderResult;
+		if (error) {
+			this.logger?.warn(`[ScopeTracker] Holder for ${serviceName} is in error state: ${error.message}`);
+			return [false];
+		}
+		if (!holder) return [false];
+		if (holder.status === InstanceStatus.Creating) {
+			holder.name = newName;
+			requestStorage.set(newName, holder);
+			singletonStorage.delete(serviceName);
+			this.updateParentDependencies(serviceName, newName, singletonStorage, requestStorage);
+			return [true, newName];
+		}
+		holder.name = newName;
+		requestStorage.set(newName, holder);
+		singletonStorage.delete(serviceName);
+		this.updateParentDependencies(serviceName, newName, singletonStorage, requestStorage);
+		return [true, newName];
+	}
+	/**
+	* Updates all parent dependencies to reference the new service name.
+	*
+	* @param oldName - Original service name
+	* @param newName - New service name with requestId
+	* @param singletonStorage - Singleton storage to check
+	* @param requestStorage - Request storage to check
+	*/ updateParentDependencies(oldName, newName, singletonStorage, requestStorage) {
+		singletonStorage.updateDependencyReference(oldName, newName);
+		if (requestStorage) requestStorage.updateDependencyReference(oldName, newName);
+	}
+};
+
+//#endregion
+export { ScopeTracker };
+//# sourceMappingURL=scope-tracker.mjs.map

package/lib/browser/internal/core/scope-tracker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-tracker.mjs","names":["InjectableScope","Scope","DIError","InstanceStatus","ScopeTracker","registry","nameResolver","logger","checkAndUpgradeScope","currentServiceName","currentServiceScope","dependencyName","dependencyScope","dependencyToken","singletonStorage","requestStorage","requestId","Singleton","Request","warn","log","success","newName","upgradeScopeToRequestSync","error","upgradeScopeToRequest","serviceName","token","undefined","storageError","unknown","upgradeInstanceNameToRequest","updated","updateScope","holderResult","get","holder","message","status","Creating","name","set","delete","updateParentDependencies","oldName","updateDependencyReference"],"sources":["../../../../src/internal/core/scope-tracker.mts"],"sourcesContent":["import type { InjectableScope } from '../../enums/index.mjs'\nimport type { InjectionToken } from '../../token/injection-token.mjs'\nimport type { IHolderStorage } from '../holder/holder-storage.interface.mjs'\n\nimport { InjectableScope as Scope } from '../../enums/index.mjs'\nimport { DIError } from '../../errors/index.mjs'\nimport { InstanceStatus } from '../holder/instance-holder.mjs'\nimport { Registry } from '../../token/registry.mjs'\nimport { NameResolver } from './name-resolver.mjs'\n\n/**\n * Component for tracking and handling scope upgrades.\n *\n * Detects when a Singleton service needs to be upgraded to Request scope\n * and coordinates the scope upgrade process atomically.\n */\nexport class ScopeTracker {\n  constructor(\n    private readonly registry: Registry,\n    private readonly nameResolver: NameResolver,\n    private readonly logger: Console | null = null,\n  ) {}\n\n  /**\n   * Checks if a dependency requires scope upgrade and performs it if needed.\n   * Called during service resolution when a dependency is resolved.\n   *\n   * @param currentServiceName - Name of the service being created\n   * @param currentServiceScope - Current scope of the service being created\n   * @param dependencyName - Name of the dependency being resolved\n   * @param dependencyScope - Scope of the dependency\n   * @param dependencyToken - Token of the dependency\n   * @param singletonStorage - Singleton storage instance\n   * @param requestStorage - Request storage instance (if in request context)\n   * @param requestId - Request ID (if in request context)\n   * @returns [needsUpgrade: boolean, newName?: string] - whether upgrade occurred and new name\n   */\n  checkAndUpgradeScope(\n    currentServiceName: string,\n    currentServiceScope: InjectableScope,\n    dependencyName: string,\n    dependencyScope: InjectableScope,\n    dependencyToken: InjectionToken<any, any>,\n    singletonStorage: IHolderStorage,\n    requestStorage?: IHolderStorage,\n    requestId?: string,\n  ): [boolean, string?] {\n    // Only upgrade if current service is Singleton and dependency is Request\n    if (\n      currentServiceScope !== Scope.Singleton ||\n      dependencyScope !== Scope.Request\n    ) {\n      return [false]\n    }\n\n    // Need request storage and requestId for upgrade\n    if (!requestStorage || !requestId) {\n      this.logger?.warn(\n        `[ScopeTracker] Cannot upgrade scope for ${currentServiceName}: missing requestStorage or requestId`,\n      )\n      return [false]\n    }\n\n    // Perform the upgrade\n    this.logger?.log(\n      `[ScopeTracker] Upgrading ${currentServiceName} from Singleton to Request scope`,\n    )\n\n    try {\n      const [success, newName] = this.upgradeScopeToRequestSync(\n        currentServiceName,\n        dependencyToken,\n        singletonStorage,\n        requestStorage,\n        requestId,\n      )\n\n      if (success && newName) {\n        return [true, newName]\n      }\n    } catch (error) {\n      this.logger?.error(\n        `[ScopeTracker] Error upgrading scope for ${currentServiceName}:`,\n        error,\n      )\n    }\n\n    return [false]\n  }\n\n  /**\n   * Performs the actual scope upgrade from Singleton to Request.\n   * This is the core migration logic.\n   *\n   * @param serviceName - Current service name (without requestId)\n   * @param token - Service injection token\n   * @param singletonStorage - Source storage\n   * @param requestStorage - Target storage\n   * @param requestId - Request ID to include in new name\n   * @returns [success: boolean, newName?: string, error?: DIError]\n   */\n  async upgradeScopeToRequest(\n    serviceName: string,\n    token: InjectionToken<any, any>,\n    singletonStorage: IHolderStorage,\n    requestStorage: IHolderStorage,\n    requestId: string,\n  ): Promise<[boolean, string?, DIError?]> {\n    try {\n      const [success, newName] = this.upgradeScopeToRequestSync(\n        serviceName,\n        token,\n        singletonStorage,\n        requestStorage,\n        requestId,\n      )\n\n      if (success && newName) {\n        return [true, newName]\n      }\n      return [\n        false,\n        undefined,\n        DIError.storageError(\n          'Scope upgrade failed',\n          'upgradeScopeToRequest',\n          serviceName,\n        ),\n      ]\n    } catch (error) {\n      return [\n        false,\n        undefined,\n        error instanceof DIError ? error : DIError.unknown(error as Error),\n      ]\n    }\n  }\n\n  /**\n   * Synchronous part of scope upgrade - handles immediate updates.\n   * Async operations (like waiting for holder creation) should be done separately.\n   */\n  private upgradeScopeToRequestSync(\n    serviceName: string,\n    token: InjectionToken<any, any>,\n    singletonStorage: IHolderStorage,\n    requestStorage: IHolderStorage,\n    requestId: string,\n  ): [boolean, string?] {\n    // 1. Upgrade existing instance name to include requestId\n    // This preserves any args hash that might be in the original name\n    const newName = this.nameResolver.upgradeInstanceNameToRequest(\n      serviceName,\n      requestId,\n    )\n\n    // 2. Update Registry scope to Request (synchronous)\n    const updated = this.registry.updateScope(token, Scope.Request)\n    if (!updated) {\n      this.logger?.warn(\n        `[ScopeTracker] Could not update scope in registry for ${serviceName}`,\n      )\n      return [false]\n    }\n\n    // 3. Check if holder exists in singleton storage\n    const holderResult = singletonStorage.get(serviceName)\n    if (holderResult === null) {\n      // No holder exists yet - just update registry, future resolutions will use request storage\n      return [true, newName]\n    }\n\n    const [error, holder] = holderResult\n    if (error) {\n      this.logger?.warn(\n        `[ScopeTracker] Holder for ${serviceName} is in error state: ${error.message}`,\n      )\n      return [false]\n    }\n\n    if (!holder) {\n      return [false]\n    }\n\n    // 4. If holder is in \"Creating\" state, we need to wait for it before migrating\n    // For now, we'll update the name and move it, but the caller should wait for creation\n    if (holder.status === InstanceStatus.Creating) {\n      // Update holder name\n      holder.name = newName\n      // Move to request storage\n      requestStorage.set(newName, holder)\n      // Remove from singleton storage\n      singletonStorage.delete(serviceName)\n      // Update parent dependencies\n      this.updateParentDependencies(\n        serviceName,\n        newName,\n        singletonStorage,\n        requestStorage,\n      )\n      return [true, newName]\n    }\n\n    // 5. Move holder from singleton to request storage\n    holder.name = newName\n    requestStorage.set(newName, holder)\n    singletonStorage.delete(serviceName)\n\n    // 6. Update all parent dependencies\n    this.updateParentDependencies(\n      serviceName,\n      newName,\n      singletonStorage,\n      requestStorage,\n    )\n\n    return [true, newName]\n  }\n\n  /**\n   * Updates all parent dependencies to reference the new service name.\n   *\n   * @param oldName - Original service name\n   * @param newName - New service name with requestId\n   * @param singletonStorage - Singleton storage to check\n   * @param requestStorage - Request storage to check\n   */\n  updateParentDependencies(\n    oldName: string,\n    newName: string,\n    singletonStorage: IHolderStorage,\n    requestStorage?: IHolderStorage,\n  ): void {\n    // Update dependencies in singleton storage\n    singletonStorage.updateDependencyReference(oldName, newName)\n\n    // Update dependencies in request storage if provided\n    if (requestStorage) {\n      requestStorage.updateDependencyReference(oldName, newName)\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;GAgBA,IAAaI,eAAb,MAAaA;;;;CACX,YACE,UACA,cACA,SAA0C,MAC1C;OAHiBC,WAAAA;OACAC,eAAAA;OACAC,SAAAA;;;;;;;;;;;;;;;IAiBnBC,qBACEC,oBACAC,qBACAC,gBACAC,iBACAC,iBACAC,kBACAC,gBACAC,WACoB;AAEpB,MACEN,wBAAwBT,gBAAMgB,aAC9BL,oBAAoBX,gBAAMiB,QAE1B,QAAO,CAAC,MAAM;AAIhB,MAAI,CAACH,kBAAkB,CAACC,WAAW;AACjC,QAAKT,QAAQY,KACX,2CAA2CV,mBAAmB,uCAAsC;AAEtG,UAAO,CAAC,MAAM;;AAIhB,OAAKF,QAAQa,IACX,4BAA4BX,mBAAmB,kCAAiC;AAGlF,MAAI;GACF,MAAM,CAACY,SAASC,WAAW,KAAKC,0BAC9Bd,oBACAI,iBACAC,kBACAC,gBACAC,UAAAA;AAGF,OAAIK,WAAWC,QACb,QAAO,CAAC,MAAMA,QAAQ;WAEjBE,OAAO;AACd,QAAKjB,QAAQiB,MACX,4CAA4Cf,mBAAmB,IAC/De,MAAAA;;AAIJ,SAAO,CAAC,MAAM;;;;;;;;;;;;IAchB,MAAMC,sBACJC,aACAC,OACAb,kBACAC,gBACAC,WACuC;AACvC,MAAI;GACF,MAAM,CAACK,SAASC,WAAW,KAAKC,0BAC9BG,aACAC,OACAb,kBACAC,gBACAC,UAAAA;AAGF,OAAIK,WAAWC,QACb,QAAO,CAAC,MAAMA,QAAQ;AAExB,UAAO;IACL;IACAM;IACA1B,QAAQ2B,aACN,wBACA,yBACAH,YAAAA;IAEH;WACMF,OAAO;AACd,UAAO;IACL;IACAI;IACAJ,iBAAiBtB,UAAUsB,QAAQtB,QAAQ4B,QAAQN,MAAAA;IACpD;;;;;;IAQL,0BACEE,aACAC,OACAb,kBACAC,gBACAC,WACoB;EAGpB,MAAMM,UAAU,KAAKhB,aAAayB,6BAChCL,aACAV,UAAAA;AAKF,MAAI,CADY,KAAKX,SAAS4B,YAAYN,OAAO1B,gBAAMiB,QAAO,EAChD;AACZ,QAAKX,QAAQY,KACX,yDAAyDO,cAAa;AAExE,UAAO,CAAC,MAAM;;EAIhB,MAAMQ,eAAepB,iBAAiBqB,IAAIT,YAAAA;AAC1C,MAAIQ,iBAAiB,KAEnB,QAAO,CAAC,MAAMZ,QAAQ;EAGxB,MAAM,CAACE,OAAOY,UAAUF;AACxB,MAAIV,OAAO;AACT,QAAKjB,QAAQY,KACX,6BAA6BO,YAAY,sBAAsBF,MAAMa,UAAS;AAEhF,UAAO,CAAC,MAAM;;AAGhB,MAAI,CAACD,OACH,QAAO,CAAC,MAAM;AAKhB,MAAIA,OAAOE,WAAWnC,eAAeoC,UAAU;AAE7CH,UAAOI,OAAOlB;AAEdP,kBAAe0B,IAAInB,SAASc,OAAAA;AAE5BtB,oBAAiB4B,OAAOhB,YAAAA;AAExB,QAAKiB,yBACHjB,aACAJ,SACAR,kBACAC,eAAAA;AAEF,UAAO,CAAC,MAAMO,QAAQ;;AAIxBc,SAAOI,OAAOlB;AACdP,iBAAe0B,IAAInB,SAASc,OAAAA;AAC5BtB,mBAAiB4B,OAAOhB,YAAAA;AAGxB,OAAKiB,yBACHjB,aACAJ,SACAR,kBACAC,eAAAA;AAGF,SAAO,CAAC,MAAMO,QAAQ;;;;;;;;;IAWxBqB,yBACEC,SACAtB,SACAR,kBACAC,gBACM;AAEND,mBAAiB+B,0BAA0BD,SAAStB,QAAAA;AAGpD,MAAIP,eACFA,gBAAe8B,0BAA0BD,SAAStB,QAAAA"}

package/lib/browser/internal/core/service-initializer.d.mts

@@ -0,0 +1,44 @@
+import { ServiceInitializationContext } from "../context/service-initialization-context.mjs";
+import { Injectors } from "../../utils/get-injectors.mjs";
+import { FactoryRecord } from "../../token/registry.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+
+//#region src/internal/core/service-initializer.d.mts
+
+/**
+ * Creates service instances from registry records.
+ *
+ * Handles both class-based (@Injectable) and factory-based (@Factory) services,
+ * managing the instantiation lifecycle including lifecycle hook invocation.
+ */
+declare class ServiceInitializer {
+  private readonly injectors;
+  constructor(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]
+   */
+  instantiateService<T>(ctx: ServiceInitializationContext, record: FactoryRecord<T, any>, args?: any): Promise<[undefined, T] | [DIError]>;
+  /**
+   * 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]
+   */
+  private instantiateClass;
+  /**
+   * 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]
+   */
+  private instantiateFactory;
+}
+//#endregion
+export { ServiceInitializer };
+//# sourceMappingURL=service-initializer.d.mts.map

package/lib/browser/internal/core/service-initializer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-initializer.d.mts","names":[],"sources":["../../../../src/internal/core/service-initializer.mts"],"sourcesContent":[],"mappings":";;;;;;;;;AAaA;;;;AAYY,cAZC,kBAAA,CAYD;EAEa,iBAAA,SAAA;EAAM,WAAA,CAAA,SAAA,EAbW,SAaX;EAA1B;;;;;;;6BAHI,sCACG,cAAc,sBAErB,oBAAoB,MAAM"}

package/lib/browser/internal/core/service-initializer.mjs

@@ -0,0 +1,109 @@
+import { InjectableType } from "../../enums/injectable-type.enum.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+
+//#region src/internal/core/service-initializer.mts
+/**
+* Creates service instances from registry records.
+*
+* Handles both class-based (@Injectable) and factory-based (@Factory) services,
+* managing the instantiation lifecycle including lifecycle hook invocation.
+*/ var ServiceInitializer = class {
+	injectors;
+	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 InjectableType.Class: return this.instantiateClass(ctx, record, args);
+				case InjectableType.Factory: return this.instantiateFactory(ctx, record, args);
+				default: throw DIError.unknown(`[ServiceInitializer] Unknown service type: ${record.type}`);
+			}
+		} catch (error) {
+			return [error instanceof DIError ? error : DIError.initializationError(record.target.name, 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) {
+				if ((await Promise.allSettled(promises)).some((result) => result.status === "rejected")) throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service cannot be instantiated"));
+				const newRes = tryLoad(injectState);
+				instance = newRes[0];
+				promises = newRes[1];
+			}
+			if (promises.length > 0) {
+				console.error(`[ServiceInitializer] ${record.target.name} has problem with it's definition.
+
+       One or more of the dependencies are registered as a InjectableScope.Transient and are used with inject.
+
+       Please use asyncInject instead of inject to load those dependencies.`);
+				throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service 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 DIError ? error : DIError.initializationError(record.target.name, 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) {
+				if ((await Promise.allSettled(promises)).some((result) => result.status === "rejected")) throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service cannot be instantiated"));
+				const newRes = tryLoad(injectState);
+				builder = newRes[0];
+				promises = newRes[1];
+			}
+			if (promises.length > 0) {
+				console.error(`[ServiceInitializer] ${record.target.name} has problem with it's definition.
+
+       One or more of the dependencies are registered as a InjectableScope.Transient and are used with inject.
+
+       Please use asyncInject instead of inject to load those dependencies.`);
+				throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Service cannot be instantiated"));
+			}
+			if (typeof builder.create !== "function") throw DIError.initializationError(record.target.name, /* @__PURE__ */ new Error("Factory does not implement the create method"));
+			return [void 0, await builder.create(ctx, args)];
+		} catch (error) {
+			return [error instanceof DIError ? error : DIError.initializationError(record.target.name, error)];
+		}
+	}
+};
+
+//#endregion
+export { ServiceInitializer };
+//# sourceMappingURL=service-initializer.mjs.map

package/lib/browser/internal/core/service-initializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-initializer.mjs","names":["InjectableType","DIError","ServiceInitializer","injectors","instantiateService","ctx","record","args","undefined","type","Class","instantiateClass","Factory","instantiateFactory","unknown","error","initializationError","target","name","tryLoad","wrapSyncInit","original","provideFactoryContext","result","instance","promises","injectState","length","results","Promise","allSettled","some","status","Error","newRes","console","onServiceInit","addDestroyListener","onServiceDestroy","builder","create"],"sources":["../../../../src/internal/core/service-initializer.mts"],"sourcesContent":["import type { FactoryRecord } from '../../token/registry.mjs'\nimport type { Injectors } from '../../utils/index.mjs'\nimport type { ServiceInitializationContext } from '../context/service-initialization-context.mjs'\n\nimport { InjectableType } from '../../enums/index.mjs'\nimport { DIError } from '../../errors/index.mjs'\n\n/**\n * Creates service instances from registry records.\n *\n * Handles both class-based (@Injectable) and factory-based (@Factory) services,\n * managing the instantiation lifecycle including lifecycle hook invocation.\n */\nexport class ServiceInitializer {\n  constructor(private readonly injectors: Injectors) {}\n\n  /**\n   * Instantiates a service based on its registry record.\n   * @param ctx The factory context for dependency injection\n   * @param record The factory record from the registry\n   * @param args Optional arguments for the service\n   * @returns Promise resolving to [undefined, instance] or [error]\n   */\n  async instantiateService<T>(\n    ctx: ServiceInitializationContext,\n    record: FactoryRecord<T, any>,\n    args: any = undefined,\n  ): Promise<[undefined, T] | [DIError]> {\n    try {\n      switch (record.type) {\n        case InjectableType.Class:\n          return this.instantiateClass(ctx, record, args)\n        case InjectableType.Factory:\n          return this.instantiateFactory(ctx, record, args)\n        default:\n          throw DIError.unknown(\n            `[ServiceInitializer] Unknown service type: ${record.type}`,\n          )\n      }\n    } catch (error) {\n      return [\n        error instanceof DIError\n          ? error\n          : DIError.initializationError(record.target.name, error as Error),\n      ]\n    }\n  }\n\n  /**\n   * Instantiates a class-based service (Injectable decorator).\n   * @param ctx The factory context for dependency injection\n   * @param record The factory record from the registry\n   * @param args Optional arguments for the service constructor\n   * @returns Promise resolving to [undefined, instance] or [error]\n   */\n  private async instantiateClass<T>(\n    ctx: ServiceInitializationContext,\n    record: FactoryRecord<T, any>,\n    args: any,\n  ): Promise<[undefined, T] | [DIError]> {\n    try {\n      const tryLoad = this.injectors.wrapSyncInit(() => {\n        const original = this.injectors.provideFactoryContext(\n          ctx as ServiceInitializationContext,\n        )\n        let result = new record.target(...(args ? [args] : []))\n        this.injectors.provideFactoryContext(original)\n        return result\n      })\n\n      let [instance, promises, injectState] = tryLoad()\n      if (promises.length > 0) {\n        const results = await Promise.allSettled(promises)\n        if (results.some((result) => result.status === 'rejected')) {\n          throw DIError.initializationError(\n            record.target.name,\n            new Error('Service cannot be instantiated'),\n          )\n        }\n        const newRes = tryLoad(injectState)\n        instance = newRes[0]\n        promises = newRes[1]\n      }\n\n      if (promises.length > 0) {\n        console.error(\n          `[ServiceInitializer] ${record.target.name} has problem with it's definition.\n\n       One or more of the dependencies are registered as a InjectableScope.Transient and are used with inject.\n\n       Please use asyncInject instead of inject to load those dependencies.`,\n        )\n        throw DIError.initializationError(\n          record.target.name,\n          new Error('Service cannot be instantiated'),\n        )\n      }\n\n      // Handle lifecycle hooks\n      if ('onServiceInit' in instance) {\n        await (instance as any).onServiceInit()\n      }\n      if ('onServiceDestroy' in instance) {\n        ctx.addDestroyListener(async () => {\n          await (instance as any).onServiceDestroy()\n        })\n      }\n\n      return [undefined, instance]\n    } catch (error) {\n      return [\n        error instanceof DIError\n          ? error\n          : DIError.initializationError(record.target.name, error as Error),\n      ]\n    }\n  }\n\n  /**\n   * Instantiates a factory-based service (Factory decorator).\n   * @param ctx The factory context for dependency injection\n   * @param record The factory record from the registry\n   * @param args Optional arguments for the factory\n   * @returns Promise resolving to [undefined, instance] or [error]\n   */\n  private async instantiateFactory<T>(\n    ctx: ServiceInitializationContext,\n    record: FactoryRecord<T, any>,\n    args: any,\n  ): Promise<[undefined, T] | [DIError]> {\n    try {\n      const tryLoad = this.injectors.wrapSyncInit(() => {\n        const original = this.injectors.provideFactoryContext(ctx)\n        let result = new record.target()\n        this.injectors.provideFactoryContext(original)\n        return result\n      })\n\n      let [builder, promises, injectState] = tryLoad()\n      if (promises.length > 0) {\n        const results = await Promise.allSettled(promises)\n        if (results.some((result) => result.status === 'rejected')) {\n          throw DIError.initializationError(\n            record.target.name,\n            new Error('Service cannot be instantiated'),\n          )\n        }\n        const newRes = tryLoad(injectState)\n        builder = newRes[0]\n        promises = newRes[1]\n      }\n\n      if (promises.length > 0) {\n        console.error(\n          `[ServiceInitializer] ${record.target.name} has problem with it's definition.\n\n       One or more of the dependencies are registered as a InjectableScope.Transient and are used with inject.\n\n       Please use asyncInject instead of inject to load those dependencies.`,\n        )\n        throw DIError.initializationError(\n          record.target.name,\n          new Error('Service cannot be instantiated'),\n        )\n      }\n\n      if (typeof builder.create !== 'function') {\n        throw DIError.initializationError(\n          record.target.name,\n          new Error('Factory does not implement the create method'),\n        )\n      }\n\n      const instance = await builder.create(ctx, args)\n      return [undefined, instance]\n    } catch (error) {\n      return [\n        error instanceof DIError\n          ? error\n          : DIError.initializationError(record.target.name, error as Error),\n      ]\n    }\n  }\n}\n"],"mappings":"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"}

package/lib/browser/internal/core/service-invalidator.d.mts

@@ -0,0 +1,81 @@
+import { InstanceHolder } from "../holder/instance-holder.mjs";
+import { IHolderStorage } from "../holder/holder-storage.interface.mjs";
+import { LifecycleEventBus } from "../lifecycle/lifecycle-event-bus.mjs";
+
+//#region src/internal/core/service-invalidator.d.mts
+interface ClearAllOptions {
+  /** Whether to wait for all services to settle before starting (default: true) */
+  waitForSettlement?: boolean;
+}
+interface InvalidationOptions {
+  /** Whether to emit events after invalidation (default: true) */
+  emitEvents?: boolean;
+  /** Custom event emitter function */
+  onInvalidated?: (instanceName: string) => Promise<void>;
+  /** Whether to cascade invalidation to dependents (default: false - events handle it) */
+  cascade?: boolean;
+}
+/**
+ * Manages graceful service cleanup with event-based invalidation.
+ *
+ * Uses event subscriptions instead of manual dependent finding.
+ * When a service is created, it subscribes to destroy events of its dependencies.
+ * When a dependency is destroyed, the event automatically invalidates dependents.
+ */
+declare class ServiceInvalidator {
+  private readonly eventBus;
+  private readonly logger;
+  constructor(eventBus: LifecycleEventBus | null, logger?: Console | null);
+  /**
+   * Invalidates a service using a specific storage.
+   * Event-based invalidation means dependents are automatically invalidated
+   * via destroy event subscriptions - no need to manually find dependents.
+   *
+   * @param service The instance name to invalidate
+   * @param storage The storage to use for this invalidation
+   * @param options Additional options for invalidation behavior
+   */
+  invalidateWithStorage(service: string, storage: IHolderStorage, options?: InvalidationOptions): Promise<void>;
+  /**
+   * Sets up destroy event subscriptions for a service's dependencies.
+   * Called when a service is successfully instantiated.
+   *
+   * @param serviceName The name of the service
+   * @param dependencies The set of dependency names
+   * @param storage The storage to use for invalidation
+   * @param holder The holder for the service (to add unsubscribe to destroy listeners)
+   */
+  setupDependencySubscriptions(serviceName: string, dependencies: Set<string>, storage: IHolderStorage, holder: InstanceHolder): void;
+  /**
+   * Gracefully clears all services in a specific storage.
+   * This allows clearing request-scoped services using a RequestStorage.
+   */
+  clearAllWithStorage(storage: IHolderStorage, options?: ClearAllOptions): Promise<void>;
+  /**
+   * Waits for all services in a specific storage to settle.
+   */
+  readyWithStorage(storage: IHolderStorage): Promise<void>;
+  /**
+   * Invalidates a single holder using a specific storage.
+   */
+  private invalidateHolderWithStorage;
+  /**
+   * Common invalidation logic for holders based on their status.
+   */
+  private invalidateHolderByStatus;
+  /**
+   * Destroys a holder using a specific storage.
+   */
+  private destroyHolderWithStorage;
+  /**
+   * Waits for a holder to settle (either created, destroyed, or error state).
+   */
+  private waitForHolderToSettle;
+  /**
+   * Emits events to listeners for instance lifecycle events.
+   */
+  private emitInstanceEvent;
+}
+//#endregion
+export { ClearAllOptions, InvalidationOptions, ServiceInvalidator };
+//# sourceMappingURL=service-invalidator.d.mts.map

package/lib/browser/internal/core/service-invalidator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-invalidator.d.mts","names":[],"sources":["../../../../src/internal/core/service-invalidator.mts"],"sourcesContent":[],"mappings":";;;;;UAMiB,eAAA;;EAAA,iBAAA,CAAe,EAAA,OAAA;AAKhC;AAgBa,UAhBI,mBAAA,CAgBc;EAEA;EACF,UAAA,CAAA,EAAA,OAAA;EAchB;EACA,aAAA,CAAA,EAAA,CAAA,YAAA,EAAA,MAAA,EAAA,GA9B+B,OA8B/B,CAAA,IAAA,CAAA;EACR;EAmCa,OAAA,CAAA,EAAA,OAAA;;;;;;;;;cAtDL,kBAAA;;;wBAEkB,mCACF;;;;;;;;;;kDAchB,0BACA,sBACR;;;;;;;;;;kEAmCa,sBACL,wBACD;;;;;+BAgCC,0BACA,kBACR;;;;4BAuC6B,iBAAiB"}

package/lib/browser/internal/core/service-invalidator.mjs

@@ -0,0 +1,142 @@
+import { InstanceStatus } from "../holder/instance-holder.mjs";
+
+//#region src/internal/core/service-invalidator.mts
+/**
+* Manages graceful service cleanup with event-based invalidation.
+*
+* Uses event subscriptions instead of manual dependent finding.
+* When a service is created, it subscribes to destroy events of its dependencies.
+* When a dependency is destroyed, the event automatically invalidates dependents.
+*/ var ServiceInvalidator = class {
+	eventBus;
+	logger;
+	constructor(eventBus, logger = null) {
+		this.eventBus = eventBus;
+		this.logger = logger;
+	}
+	/**
+	* Invalidates a service using a specific storage.
+	* Event-based invalidation means dependents are automatically invalidated
+	* via destroy event subscriptions - no need to manually find dependents.
+	*
+	* @param service The instance name to invalidate
+	* @param storage The storage to use for this invalidation
+	* @param options Additional options for invalidation behavior
+	*/ async invalidateWithStorage(service, storage, options = {}) {
+		const { emitEvents = true, onInvalidated } = options;
+		this.logger?.log(`[ServiceInvalidator] Starting invalidation process for ${service}`);
+		const result = storage.get(service);
+		if (result === null) return;
+		const [, holder] = result;
+		if (holder) await this.invalidateHolderWithStorage(service, holder, storage, emitEvents, onInvalidated);
+	}
+	/**
+	* Sets up destroy event subscriptions for a service's dependencies.
+	* Called when a service is successfully instantiated.
+	*
+	* @param serviceName The name of the service
+	* @param dependencies The set of dependency names
+	* @param storage The storage to use for invalidation
+	* @param holder The holder for the service (to add unsubscribe to destroy listeners)
+	*/ setupDependencySubscriptions(serviceName, dependencies, storage, holder) {
+		if (!this.eventBus) return;
+		for (const dependencyName of dependencies) {
+			const unsubscribe = this.eventBus.on(dependencyName, "destroy", () => {
+				this.logger?.log(`[ServiceInvalidator] Dependency ${dependencyName} destroyed, invalidating ${serviceName}`);
+				this.invalidateWithStorage(serviceName, storage).catch((error) => {
+					this.logger?.error(`[ServiceInvalidator] Error invalidating ${serviceName} after dependency ${dependencyName} destroyed:`, error);
+				});
+			});
+			holder.destroyListeners.push(unsubscribe);
+		}
+	}
+	/**
+	* Gracefully clears all services in a specific storage.
+	* This allows clearing request-scoped services using a RequestStorage.
+	*/ async clearAllWithStorage(storage, options = {}) {
+		const { waitForSettlement = true } = options;
+		this.logger?.log("[ServiceInvalidator] Starting graceful clearing of all services");
+		if (waitForSettlement) {
+			this.logger?.log("[ServiceInvalidator] Waiting for all services to settle...");
+			await this.readyWithStorage(storage);
+		}
+		const allServiceNames = storage.getAllNames();
+		if (allServiceNames.length === 0) this.logger?.log("[ServiceInvalidator] No services to clear");
+		else {
+			this.logger?.log(`[ServiceInvalidator] Found ${allServiceNames.length} services to clear: ${allServiceNames.join(", ")}`);
+			const clearPromises = allServiceNames.map((serviceName) => this.invalidateWithStorage(serviceName, storage));
+			await Promise.all(clearPromises);
+		}
+		this.logger?.log("[ServiceInvalidator] Graceful clearing completed");
+	}
+	/**
+	* Waits for all services in a specific storage to settle.
+	*/ async readyWithStorage(storage) {
+		const holders = [];
+		storage.forEach((_, holder) => holders.push(holder));
+		await Promise.all(holders.map((holder) => this.waitForHolderToSettle(holder)));
+	}
+	/**
+	* Invalidates a single holder using a specific storage.
+	*/ async invalidateHolderWithStorage(key, holder, storage, emitEvents, onInvalidated) {
+		await this.invalidateHolderByStatus(holder, {
+			context: key,
+			onDestroy: () => this.destroyHolderWithStorage(key, holder, storage, emitEvents, onInvalidated)
+		});
+	}
+	/**
+	* Common invalidation logic for holders based on their status.
+	*/ async invalidateHolderByStatus(holder, options) {
+		switch (holder.status) {
+			case InstanceStatus.Destroying:
+				await holder.destroyPromise;
+				break;
+			case InstanceStatus.Creating:
+				await holder.creationPromise;
+				await options.onDestroy();
+				break;
+			default:
+				await options.onDestroy();
+				break;
+		}
+	}
+	/**
+	* Destroys a holder using a specific storage.
+	*/ async destroyHolderWithStorage(key, holder, storage, emitEvents, onInvalidated) {
+		holder.status = InstanceStatus.Destroying;
+		this.logger?.log(`[ServiceInvalidator] Invalidating ${key} and notifying listeners`);
+		holder.destroyPromise = Promise.all(holder.destroyListeners.map((listener) => listener())).then(async () => {
+			holder.destroyListeners = [];
+			holder.deps.clear();
+			storage.delete(key);
+			if (emitEvents && this.eventBus) await this.emitInstanceEvent(key, "destroy");
+			if (onInvalidated) await onInvalidated(key);
+		});
+		await holder.destroyPromise;
+	}
+	/**
+	* Waits for a holder to settle (either created, destroyed, or error state).
+	*/ async waitForHolderToSettle(holder) {
+		switch (holder.status) {
+			case InstanceStatus.Creating:
+				await holder.creationPromise;
+				break;
+			case InstanceStatus.Destroying:
+				await holder.destroyPromise;
+				break;
+			case InstanceStatus.Created:
+			case InstanceStatus.Error: break;
+		}
+	}
+	/**
+	* Emits events to listeners for instance lifecycle events.
+	*/ emitInstanceEvent(name, event = "create") {
+		if (!this.eventBus) return Promise.resolve();
+		this.logger?.log(`[ServiceInvalidator]#emitInstanceEvent() Notifying listeners for ${name} with event ${event}`);
+		return this.eventBus.emit(name, event);
+	}
+};
+
+//#endregion
+export { ServiceInvalidator };
+//# sourceMappingURL=service-invalidator.mjs.map