alloy-di 1.2.2 → 1.2.3

package/dist/lib/container.d.ts

@@ -89,8 +89,12 @@ declare class Container {
    */
   private resolveParam;
   /**
-   * Execute a lazy importer with optional retry/backoff semantics.
-   * Implements exponential backoff for transient network failures.
+   * Execute a lazy importer with optional retry/backoff semantics, then
+   * validate that the imported value is a constructor.
+   *
+   * Only the dynamic import itself is retried; a successful import that does
+   * not yield a constructor is deterministic and fails immediately without
+   * backoff or re-wrapping.
    *
    * @param lazyDep - Lazy dependency wrapper with importer function and retry config
    * @param target - Service being resolved (for error messages)
@@ -99,6 +103,10 @@ declare class Container {
    * @throws Error if all retry attempts exhausted or import returns non-constructor
    */
   private importWithRetry;
+  /**
+   * Run a lazy importer, retrying failed imports with exponential backoff.
+   */
+  private runImporterWithRetry;
   /**
    * Resolve a token dependency via registered value providers.
    */

package/dist/lib/container.js

@@ -184,8 +184,12 @@ var Container = class {
 		return classification;
 	}
 	/**
-	* Execute a lazy importer with optional retry/backoff semantics.
-	* Implements exponential backoff for transient network failures.
+	* Execute a lazy importer with optional retry/backoff semantics, then
+	* validate that the imported value is a constructor.
+	*
+	* Only the dynamic import itself is retried; a successful import that does
+	* not yield a constructor is deterministic and fails immediately without
+	* backoff or re-wrapping.
 	*
 	* @param lazyDep - Lazy dependency wrapper with importer function and retry config
 	* @param target - Service being resolved (for error messages)
@@ -194,23 +198,28 @@ var Container = class {
 	* @throws Error if all retry attempts exhausted or import returns non-constructor
 	*/
 	async importWithRetry(lazyDep, target, resolutionStack) {
-		const runImport = async () => await lazyDep.importer();
+		const module = await this.runImporterWithRetry(lazyDep, target, resolutionStack);
+		const depClass = typeof module === "object" && module !== null && "default" in module ? module.default : module;
+		if (!isConstructor(depClass)) {
+			const stackPath = this.formatStackPath(target, resolutionStack);
+			throw new DependencyResolutionError(`Lazy importer did not return a class for dependency while resolving ${target.name}. Resolution stack: ${stackPath}. Received type: ${typeof depClass}`, {
+				target,
+				resolutionStack,
+				failedDependency: depClass
+			});
+		}
+		return depClass;
+	}
+	/**
+	* Run a lazy importer, retrying failed imports with exponential backoff.
+	*/
+	async runImporterWithRetry(lazyDep, target, resolutionStack) {
 		const retries = lazyDep.retry?.retries ?? 0;
 		const baseDelay = lazyDep.retry?.backoffMs ?? 0;
 		const factor = lazyDep.retry?.factor ?? 2;
 		let attempt = 0;
 		while (true) try {
-			const module = await runImport();
-			const depClass = typeof module === "object" && module !== null && "default" in module ? module.default : module;
-			if (!isConstructor(depClass)) {
-				const stackPath = this.formatStackPath(target, resolutionStack);
-				throw new DependencyResolutionError(`Lazy importer did not return a class for dependency while resolving ${target.name}. Resolution stack: ${stackPath}. Received type: ${typeof depClass}`, {
-					target,
-					resolutionStack,
-					failedDependency: depClass
-				});
-			}
-			return depClass;
+			return await lazyDep.importer();
 		} catch (err) {
 			if (attempt >= retries) {
 				const stackPath = this.formatStackPath(target, resolutionStack);
@@ -251,10 +260,14 @@ var Container = class {
 		const cached = this.metadataCache.get(target);
 		if (cached) return cached;
 		const registryEntry = dependenciesRegistry.get(target);
+		if (!registryEntry) return {
+			scope: ServiceScope.TRANSIENT,
+			dependencies: []
+		};
 		const metadata = {
-			scope: registryEntry?.scope ?? ServiceScope.TRANSIENT,
-			dependencies: (registryEntry?.dependencies ?? (() => []))(),
-			factory: registryEntry?.factory
+			scope: registryEntry.scope ?? ServiceScope.TRANSIENT,
+			dependencies: (registryEntry.dependencies ?? (() => []))(),
+			factory: registryEntry.factory
 		};
 		this.metadataCache.set(target, metadata);
 		return metadata;

package/dist/lib/decorators.js

@@ -65,11 +65,44 @@ function createDecoratorWithoutDeps(scope) {
 function isDependenciesArg(value) {
 	return typeof value === "function" || Array.isArray(value);
 }
+/**
+* Detect a class constructor passed where dependency metadata was expected.
+*
+* Class constructors have a non-writable `prototype`; dependency thunks
+* (arrow functions or plain functions) either lack a `prototype` descriptor
+* or have a writable one.
+*
+* @param value - The argument supplied to `@Injectable`/`@Singleton`.
+* @returns True if the value is a class constructor.
+* @internal
+*/
+function isClassConstructor(value) {
+	if (typeof value !== "function") return false;
+	const prototypeDescriptor = Object.getOwnPropertyDescriptor(value, "prototype");
+	return prototypeDescriptor !== void 0 && !prototypeDescriptor.writable;
+}
+/**
+* Reject the bare-decorator misuse `@Injectable` / `@Singleton` (no parens).
+*
+* Applied bare, the decorator factory itself receives the class, mistakes it
+* for a dependencies thunk, and returns a decorator function — which legacy
+* decorator semantics then substitute for the class. Throwing here turns that
+* silent class replacement into an immediate, actionable error.
+*
+* @param value - The first argument received by the decorator factory.
+* @param decoratorName - Public decorator name for the error message.
+* @internal
+*/
+function assertNotBareDecorator(value, decoratorName) {
+	if (isClassConstructor(value)) throw new TypeError(`@${decoratorName} must be called — use @${decoratorName}() instead of @${decoratorName}`);
+}
 function Injectable(depsOrScope, scopeOverride) {
+	assertNotBareDecorator(depsOrScope, "Injectable");
 	if (isDependenciesArg(depsOrScope)) return createDecoratorWithDeps(scopeOverride ?? ServiceScope.TRANSIENT, depsOrScope);
 	return createDecoratorWithoutDeps((typeof depsOrScope === "string" ? depsOrScope : void 0) ?? scopeOverride ?? ServiceScope.TRANSIENT);
 }
 function Singleton(dependencies) {
+	assertNotBareDecorator(dependencies, "Singleton");
 	if (isDependenciesArg(dependencies)) return createDecoratorWithDeps(ServiceScope.SINGLETON, dependencies);
 	return createDecoratorWithoutDeps(ServiceScope.SINGLETON);
 }

package/dist/lib/service-identifiers.d.ts

@@ -13,8 +13,11 @@ type ServiceIdentifier<T = unknown> = symbol & {
 /**
  * Associates a constructor with a stable identifier. When an explicit identifier
  * is provided (e.g., by generated metadata), it becomes canonical for the
- * constructor. Attempting to reuse an identifier with a different constructor
- * throws to surface manifest/config mismatches early.
+ * constructor when the constructor is first registered. If the constructor was
+ * already assigned an auto-generated identifier, later explicit identifiers are
+ * recorded as aliases so both symbols resolve to the same constructor.
+ * Attempting to reuse an identifier with a different constructor throws to
+ * surface manifest/config mismatches early.
  */
 declare function registerServiceIdentifier<T>(ctor: Constructor, explicitIdentifier?: ServiceIdentifier<T>): ServiceIdentifier<T>;
 /**

package/dist/lib/service-identifiers.js

@@ -11,8 +11,11 @@ function createServiceIdentifier(ctor) {
 /**
 * Associates a constructor with a stable identifier. When an explicit identifier
 * is provided (e.g., by generated metadata), it becomes canonical for the
-* constructor. Attempting to reuse an identifier with a different constructor
-* throws to surface manifest/config mismatches early.
+* constructor when the constructor is first registered. If the constructor was
+* already assigned an auto-generated identifier, later explicit identifiers are
+* recorded as aliases so both symbols resolve to the same constructor.
+* Attempting to reuse an identifier with a different constructor throws to
+* surface manifest/config mismatches early.
 */
 function registerServiceIdentifier(ctor, explicitIdentifier) {
 	const current = ctorToIdentifier.get(ctor);
@@ -20,6 +23,7 @@ function registerServiceIdentifier(ctor, explicitIdentifier) {
 		if (explicitIdentifier && explicitIdentifier !== current) {
 			const owner = identifierToCtor.get(explicitIdentifier);
 			if (owner && owner !== ctor) throw new Error("Attempted to reassign an existing ServiceIdentifier to a different constructor.");
+			identifierToCtor.set(explicitIdentifier, ctor);
 		}
 		return current;
 	}

package/dist/plugins/core/codegen.js

@@ -18,30 +18,73 @@ function createSymbolDescription(meta) {
 	return createSymbolKey(meta.filePath, meta.className);
 }
 /**
+* Allocates module-local names from a single shared pool so the generated
+* module's independent naming domains (runtime helpers, service imports,
+* factory-lazy stubs, dependency imports, identifier consts, generated
+* locals) can never collide.
+*/
+function createNamePool(reservedNames) {
+	const used = new Set(reservedNames);
+	return { claim(base) {
+		let candidate = base;
+		let suffix = 1;
+		while (used.has(candidate)) {
+			candidate = `${base}_${suffix}`;
+			suffix++;
+		}
+		used.add(candidate);
+		return candidate;
+	} };
+}
+function stripModuleExtension(importPath) {
+	return importPath.replace(/\.[cm]?[jt]sx?$/i, "");
+}
+/**
+* Identity of an imported binding: the module (extension-insensitive, since
+* references may resolve extensionless while service paths keep theirs) plus
+* the export name.
+*/
+function createBindingKey(importPath, exportName) {
+	return `${stripModuleExtension(importPath)}::${exportName}`;
+}
+/** Resolves a referenced import's specifier to a normalized module path. */
+function resolveReferencePath(ref, meta) {
+	return normalizeImportPath(ref.path.startsWith(".") ? path.resolve(path.dirname(meta.filePath), ref.path) : ref.path);
+}
+function resolveDependencyImport(ref, normalizedPath, pool, serviceBindings, runtimeImports) {
+	if (normalizedPath === "alloy-di/runtime" && ref.originalName && ref.name === ref.originalName && runtimeImports.has(ref.originalName)) return {
+		localName: ref.originalName,
+		importPath: normalizedPath,
+		originalName: ref.originalName,
+		reusesExistingBinding: true
+	};
+	const serviceLocalName = serviceBindings.get(createBindingKey(normalizedPath, ref.originalName ?? "default"));
+	if (serviceLocalName) return {
+		localName: serviceLocalName,
+		importPath: normalizedPath,
+		originalName: ref.originalName,
+		reusesExistingBinding: true
+	};
+	return {
+		localName: pool.claim(ref.name),
+		importPath: normalizedPath,
+		originalName: ref.originalName
+	};
+}
+/**
 * Analyzes dependencies across all discovered services and resolves imports.
-* Deduplicates imports and handles naming collisions by generating unique local names.
+* Deduplicates imports by binding identity, reuses bindings the module
+* already declares (runtime helpers, service imports, factory-lazy stubs),
+* and claims fresh local names from the shared pool otherwise.
 */
-function resolveDependencyImports(metas) {
+function resolveDependencyImports(metas, pool, serviceBindings, runtimeImports) {
 	const importMap = /* @__PURE__ */ new Map();
-	const nameCounts = /* @__PURE__ */ new Map();
-	const getUniqueName = (name) => {
-		const count = nameCounts.get(name) ?? 0;
-		nameCounts.set(name, count + 1);
-		return count === 0 ? name : `${name}_${count}`;
-	};
-	for (const meta of metas) {
-		if (!meta.referencedImports?.length) continue;
-		for (const ref of meta.referencedImports) {
-			if (ref.isTypeOnly) continue;
-			const normalizedPath = normalizeImportPath(ref.path.startsWith(".") ? path.resolve(path.dirname(meta.filePath), ref.path) : ref.path);
-			const key = `${normalizedPath}::${ref.originalName ?? "default"}`;
-			if (importMap.has(key)) continue;
-			importMap.set(key, {
-				localName: getUniqueName(ref.name),
-				importPath: normalizedPath,
-				originalName: ref.originalName
-			});
-		}
+	for (const meta of metas) for (const ref of meta.referencedImports ?? []) {
+		if (ref.isTypeOnly) continue;
+		const normalizedPath = resolveReferencePath(ref, meta);
+		const key = createBindingKey(normalizedPath, ref.originalName ?? "default");
+		if (importMap.has(key)) continue;
+		importMap.set(key, resolveDependencyImport(ref, normalizedPath, pool, serviceBindings, runtimeImports));
 	}
 	return {
 		dependencyImports: Array.from(importMap.values()),
@@ -60,7 +103,7 @@ function reconstructDependencyExpression(dep, rewriter, contextDir) {
 	});
 	return expr;
 }
-function reconstructOptionsText(meta, importMap) {
+function reconstructOptionsText(meta, importMap, serviceRenames) {
 	const { scope, dependencies, factory } = meta.metadata;
 	const parts = [];
 	if (factory) {
@@ -73,12 +116,11 @@ function reconstructOptionsText(meta, importMap) {
 			return reconstructDependencyExpression(dep, (ident) => {
 				const ref = meta.referencedImports?.find((r) => r.name === ident && !r.isTypeOnly);
 				if (ref) {
-					const dir = path.dirname(meta.filePath);
-					const key = `${normalizeImportPath(ref.path.startsWith(".") ? path.resolve(dir, ref.path) : ref.path)}::${ref.originalName ?? "default"}`;
+					const key = createBindingKey(resolveReferencePath(ref, meta), ref.originalName ?? "default");
 					const resolved = importMap.get(key);
 					return resolved ? resolved.localName : ident;
 				}
-				return ident;
+				return serviceRenames.get(ident) ?? ident;
 			}, path.dirname(meta.filePath));
 		});
 		parts.push(`dependencies: () => [${depExprs.join(", ")}]`);
@@ -86,13 +128,38 @@ function reconstructOptionsText(meta, importMap) {
 	if (parts.length === 0) return "{}";
 	return `{ ${parts.join(", ")} }`;
 }
-function buildImportsAndRegistrations(metas, lazyReferencedClassKeys, hasProviderModules) {
+function buildImportsAndRegistrations(metas, lazyReferencedClassKeys, providerModulePaths) {
+	const hasProviderModules = providerModulePaths.length > 0;
 	const activeMetas = filterActiveMetas(metas, lazyReferencedClassKeys);
-	const { dependencyImports, importMap } = resolveDependencyImports(activeMetas);
-	const resolvedRegistrations = enrichRegistrations(activeMetas, new IdentifierResolver(activeMetas), importMap);
-	const runtimeImports = computeRuntimeImports(resolvedRegistrations, hasProviderModules);
+	const resolver = new IdentifierResolver(activeMetas);
+	const runtimeImports = computeRuntimeImports(activeMetas, hasProviderModules);
+	const pool = createNamePool([
+		...runtimeImports,
+		"registrations",
+		"container",
+		"providerDefinitions",
+		...providerModulePaths.map((_, idx) => `providers_${idx}`)
+	]);
+	const serviceNames = /* @__PURE__ */ new Map();
+	const serviceRenames = /* @__PURE__ */ new Map();
+	const serviceBindings = /* @__PURE__ */ new Map();
+	for (const meta of activeMetas) {
+		const baseName = resolver.resolve(meta.className, meta.filePath);
+		const name = pool.claim(baseName);
+		serviceNames.set(meta, name);
+		if (name !== baseName) serviceRenames.set(baseName, name);
+		serviceBindings.set(createBindingKey(getServiceImportPath(meta), meta.className), name);
+	}
+	const { dependencyImports, importMap } = resolveDependencyImports(activeMetas, pool, serviceBindings, runtimeImports);
+	const resolvedRegistrations = enrichRegistrations(activeMetas, {
+		resolver,
+		serviceNames,
+		serviceRenames,
+		importMap,
+		pool
+	});
 	const runtimeImportStatement = formatRuntimeImportStatement(runtimeImports);
-	const stubsBlock = createStubBlock(dependencyImports, resolvedRegistrations, runtimeImports);
+	const stubsBlock = createStubBlock(dependencyImports, resolvedRegistrations);
 	return {
 		runtimeImportStatement,
 		registrationsBlock: createRegistrationsBlock(buildRegistrationEntries(resolvedRegistrations)),
@@ -103,13 +170,14 @@ function buildImportsAndRegistrations(metas, lazyReferencedClassKeys, hasProvide
 function filterActiveMetas(metas, lazyReferencedClassKeys) {
 	return metas.filter((meta) => !lazyReferencedClassKeys.has(createClassKey(meta.filePath, meta.className)));
 }
-function enrichRegistrations(activeMetas, resolver, importMap) {
+function enrichRegistrations(activeMetas, naming) {
+	const { resolver, serviceNames, serviceRenames, importMap, pool } = naming;
 	return activeMetas.map((meta) => {
-		const importName = resolver.resolve(meta.className, meta.filePath);
-		const identifierConst = `${importName}Identifier`;
+		const importName = serviceNames.get(meta) ?? meta.className;
+		const identifierConst = pool.claim(`${importName}Identifier`);
 		const exportKey = createIdentifierExportKey(meta, resolver);
 		const symbolDescription = meta.identifierKey ?? createSymbolDescription(meta);
-		const optionsText = reconstructOptionsText(meta, importMap);
+		const optionsText = reconstructOptionsText(meta, importMap, serviceRenames);
 		return {
 			...meta,
 			importName,
@@ -121,34 +189,29 @@ function enrichRegistrations(activeMetas, resolver, importMap) {
 		};
 	});
 }
-function computeRuntimeImports(registrations, hasProviderModules) {
+function computeRuntimeImports(activeMetas, hasProviderModules) {
 	const imports = new Set(["Container", "dependenciesRegistry"]);
-	const needsLazyImport = registrations.some((m) => m.metadata.dependencies.some((d) => d.isLazy) || !!m.metadata.factory);
+	const needsLazyImport = activeMetas.some((m) => m.metadata.dependencies.some((d) => d.isLazy) || !!m.metadata.factory);
 	if (hasProviderModules) imports.add("applyProviders");
 	if (needsLazyImport) imports.add("Lazy");
-	if (registrations.length) imports.add("registerServiceIdentifier");
+	if (activeMetas.length) imports.add("registerServiceIdentifier");
 	return imports;
 }
 function formatRuntimeImportStatement(imports) {
 	return `\nimport { ${Array.from(imports).join(", ")} } from 'alloy-di/runtime';\n`;
 }
-function createStubBlock(dependencyImports, registrations, runtimeImports) {
+function createStubBlock(dependencyImports, registrations) {
 	const statements = [];
-	const importedNames = new Set(runtimeImports);
 	for (const dep of dependencyImports) {
-		if (dep.importPath === "alloy-di/runtime" && dep.originalName && dep.localName === dep.originalName && runtimeImports.has(dep.originalName)) continue;
-		if (importedNames.has(dep.localName)) continue;
+		if (dep.reusesExistingBinding) continue;
 		statements.push(createDependencyImportStatement(dep));
-		importedNames.add(dep.localName);
 	}
 	for (const meta of registrations) {
 		if (meta.isFactoryLazy) {
 			statements.push(`class ${meta.importName} {}`);
 			continue;
 		}
-		if (importedNames.has(meta.importName)) continue;
 		statements.push(createServiceImportStatement(meta));
-		importedNames.add(meta.importName);
 	}
 	return statements.length ? `${statements.join("\n")}\n` : "";
 }
@@ -158,8 +221,11 @@ function createDependencyImportStatement(dep) {
 	if (dep.originalName && dep.originalName !== dep.localName) return `import { ${dep.originalName} as ${dep.localName} } from '${dep.importPath}';`;
 	return `import { ${dep.localName} } from '${dep.importPath}';`;
 }
+function getServiceImportPath(meta) {
+	return !/^(\/|[A-Za-z]:\\|\.|~)/.test(meta.filePath) && !meta.filePath.includes("\\") ? meta.filePath : normalizeImportPath(meta.filePath);
+}
 function createServiceImportStatement(meta) {
-	const importPath = !/^(\/|[A-Za-z]:\\|\.|~)/.test(meta.filePath) && !meta.filePath.includes("\\") ? meta.filePath : normalizeImportPath(meta.filePath);
+	const importPath = getServiceImportPath(meta);
 	if (meta.importName === meta.className) return `import { ${meta.className} } from '${importPath}';`;
 	return `import { ${meta.className} as ${meta.importName} } from '${importPath}';`;
 }
@@ -193,7 +259,7 @@ function createIdentifierExports(registrations) {
 */
 function generateContainerModule(metas, lazyReferencedClassKeys, providerModulePaths) {
 	const hasProviderModules = providerModulePaths.length > 0;
-	const { runtimeImportStatement, registrationsBlock, stubsBlock, identifierExportBlock } = buildImportsAndRegistrations(metas, lazyReferencedClassKeys, hasProviderModules);
+	const { runtimeImportStatement, registrationsBlock, stubsBlock, identifierExportBlock } = buildImportsAndRegistrations(metas, lazyReferencedClassKeys, providerModulePaths);
 	let providerImportBlock = "";
 	let providerInvocationBlock = "";
 	if (hasProviderModules) {
@@ -224,10 +290,15 @@ export default container;
 */
 function generateContainerTypeDefinition(metas, pathResolver) {
 	const resolver = new IdentifierResolver(metas);
+	const pool = createNamePool([
+		"Container",
+		"ServiceIdentifier",
+		"container"
+	]);
 	const imports = [];
 	const interfaceMembers = [];
 	for (const meta of metas) {
-		const importName = resolver.resolve(meta.className, meta.filePath);
+		const importName = pool.claim(resolver.resolve(meta.className, meta.filePath));
 		const importPath = pathResolver(meta.filePath);
 		if (importName === meta.className) imports.push(`import { ${meta.className} } from '${importPath}';`);
 		else imports.push(`import { ${meta.className} as ${importName} } from '${importPath}';`);

package/dist/plugins/core/scanner.js

@@ -80,7 +80,10 @@ function findServiceDecorator(node, sourceFile, fileImports, id, resolutionCache
 	const decorators = ts.getDecorators ? ts.getDecorators(node) : void 0;
 	if (!decorators?.length) return;
 	for (const decorator of decorators) {
-		if (!ts.isCallExpression(decorator.expression)) continue;
+		if (!ts.isCallExpression(decorator.expression)) {
+			warnOnBareAlloyDecorator(decorator, sourceFile, fileImports, id, resolutionCache);
+			continue;
+		}
 		const decoratorName = resolveDecoratorName(decorator.expression.expression, fileImports, id, new Set([id]), resolutionCache);
 		if (decoratorName) return {
 			decoratorCall: decorator.expression,
@@ -88,6 +91,20 @@ function findServiceDecorator(node, sourceFile, fileImports, id, resolutionCache
 		};
 	}
 }
+/**
+* Warn when an alloy decorator is applied bare (`@Injectable` instead of
+* `@Injectable()`). The scanner only registers call-expression decorators, so
+* the service would silently vanish from the container — and at runtime the
+* factory throws. Surfacing the location here makes the misuse findable at
+* build time.
+*/
+function warnOnBareAlloyDecorator(decorator, sourceFile, fileImports, id, resolutionCache) {
+	if (!ts.isIdentifier(decorator.expression) && !ts.isPropertyAccessExpression(decorator.expression)) return;
+	if (!resolveDecoratorName(decorator.expression, fileImports, id, new Set([id]), resolutionCache)) return;
+	const { line } = sourceFile.getLineAndCharacterOfPosition(decorator.getStart(sourceFile));
+	const appliedText = decorator.expression.getText(sourceFile);
+	console.warn(`[alloy] ${id}:${line + 1} applies @${appliedText} without calling it — use @${appliedText}(). The class will not be registered.`);
+}
 function resolveDecoratorName(expression, fileImports, id, visitedModules, resolutionCache) {
 	if (ts.isIdentifier(expression)) {
 		const importInfo = fileImports.get(expression.text);
@@ -104,11 +121,11 @@ function resolveImportedDecorator(importPath, requestedName, fromId, visitedModu
 	if (importPath === ALLOY_RUNTIME_MODULE) return isAlloyDecoratorName(requestedName) ? requestedName : void 0;
 	if (!importPath.startsWith(".")) return;
 	for (const candidate of resolveModuleSpecifierCandidates(fromId, importPath)) {
-		if (visitedModules.has(candidate) || !fs.existsSync(candidate)) continue;
 		const cacheKey = `${candidate}:${requestedName}`;
 		const cached = resolutionCache.get(cacheKey);
 		if (cached) return cached;
 		if (cached === null) continue;
+		if (visitedModules.has(candidate) || !fs.existsSync(candidate)) continue;
 		visitedModules.add(candidate);
 		try {
 			const source = fs.readFileSync(candidate, "utf8");

package/dist/plugins/core/utils.js

@@ -18,7 +18,7 @@ function ensureLeadingSlash(value) {
 }
 function hashString(value) {
 	let hash = 0;
-	for (let i = 0; i < value.length; i++) hash = Math.trunc(hash * 31 + value.charCodeAt(i));
+	for (let i = 0; i < value.length; i++) hash = hash * 31 + value.charCodeAt(i) | 0;
 	return Math.abs(hash).toString(36);
 }
 function createClassKey(filePath, className) {

package/dist/plugins/vite-plugin/container-loader.js

@@ -8,7 +8,11 @@ import path from "node:path";
 import fs from "node:fs";
 //#region src/plugins/vite-plugin/container-loader.ts
 async function loadVirtualContainerModule(options) {
-	const metas = options.localMetas;
+	const metas = options.localMetas.map((meta) => ({
+		...meta,
+		metadata: { ...meta.metadata }
+	}));
+	const lazyClassKeys = new Set(options.lazyReferencedClassKeys);
 	assignIdentifierKeys(metas, options.packageName, options.resolvedRoot);
 	const manifestData = await readManifests(options.manifests);
 	const manifestServices = manifestData.services;
@@ -24,14 +28,13 @@ async function loadVirtualContainerModule(options) {
 	}))];
 	const resolver = new IdentifierResolver(combinedMetas);
 	const metasByName = groupMetasByName(combinedMetas);
-	for (const svc of manifestServices) metas.push(toMetaFromManifest(svc, metasByName, resolver, options.lazyReferencedClassKeys));
+	for (const svc of manifestServices) metas.push(toMetaFromManifest(svc, metasByName, resolver, lazyClassKeys));
 	const providerImports = Array.from(new Set([...options.providerImportPaths, ...manifestData.providers]));
-	const eagerReferencedNames = collectEagerReferencedNames(metas);
-	reconcileLazySet(metas, options.lazyReferencedClassKeys, eagerReferencedNames);
+	reconcileLazySet(metas, lazyClassKeys, collectEagerReferencedNames(metas));
 	augmentFactoryLazyServices(metas, options.lazyServiceKeys);
-	const code = generateContainerModule(metas, new Set(options.lazyReferencedClassKeys), providerImports);
+	const code = generateContainerModule(metas, lazyClassKeys, providerImports);
 	writeTypeDefinitions(metas, loadedManifests, options.resolvedRoot, options.containerDeclarationDir);
-	writeVisualizationArtifact(metas, options.lazyReferencedClassKeys, options.resolvedVisualization);
+	writeVisualizationArtifact(metas, lazyClassKeys, options.resolvedVisualization);
 	return {
 		code,
 		moduleType: "js"

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/entry-points.test.ts","../src/rollup.ts","../src/runtime.ts","../src/test.ts","../src/vite.ts","../src/lib/container.identifiers.test.ts","../src/lib/container.internals.test.ts","../src/lib/container.test.ts","../src/lib/container.testing-features.test.ts","../src/lib/container.ts","../src/lib/decorators.runtime.test.ts","../src/lib/decorators.test-d.ts","../src/lib/decorators.ts","../src/lib/dependency-error.ts","../src/lib/env-detection.test.ts","../src/lib/env-detection.ts","../src/lib/lazy-retry.test.ts","../src/lib/lazy.ts","../src/lib/providers.test.ts","../src/lib/providers.ts","../src/lib/scope.ts","../src/lib/service-identifiers.test.ts","../src/lib/service-identifiers.ts","../src/lib/tokens.test.ts","../src/lib/types.ts","../src/lib/testing/mocking.test.ts","../src/lib/testing/mocking.ts","../src/lib/testing/registry.test.ts","../src/lib/testing/registry.ts","../src/plugins/core/codegen.test.ts","../src/plugins/core/codegen.ts","../src/plugins/core/decorators.helpers.test.ts","../src/plugins/core/decorators.ts","../src/plugins/core/discovery-store.ts","../src/plugins/core/identifier-resolver.test.ts","../src/plugins/core/identifier-resolver.ts","../src/plugins/core/lazy-utils.ts","../src/plugins/core/lazy.helpers.test.ts","../src/plugins/core/lazy.ts","../src/plugins/core/scanner.test.ts","../src/plugins/core/scanner.ts","../src/plugins/core/types.ts","../src/plugins/core/utils.ts","../src/plugins/rollup-plugin/build-utils.ts","../src/plugins/rollup-plugin/index.ts","../src/plugins/rollup-plugin/rollup-plugin.test.ts","../src/plugins/vite-plugin/codegen.specifier.test.ts","../src/plugins/vite-plugin/container-loader.ts","../src/plugins/vite-plugin/discovery-runtime.ts","../src/plugins/vite-plugin/duplicate-registrations.test.ts","../src/plugins/vite-plugin/fixture-subpaths.test.ts","../src/plugins/vite-plugin/index.ts","../src/plugins/vite-plugin/lazy-services.test.ts","../src/plugins/vite-plugin/lifecycle-and-hmr.test.ts","../src/plugins/vite-plugin/manifest-utils.ts","../src/plugins/vite-plugin/manifest-utils.validation.test.ts","../src/plugins/vite-plugin/module-generation.test.ts","../src/plugins/vite-plugin/test-utils.ts","../src/plugins/vite-plugin/transform-guards.test.ts","../src/plugins/vite-plugin/visualization-option.test.ts","../src/plugins/vite-plugin/visualization-utils.ts","../src/plugins/vite-plugin/visualizer.test.ts","../src/plugins/vite-plugin/visualizer.ts"],"version":"6.0.3"}
+{"root":["../src/entry-points.test.ts","../src/rollup.ts","../src/runtime.ts","../src/test.ts","../src/vite.ts","../src/lib/container.identifiers.test.ts","../src/lib/container.internals.test.ts","../src/lib/container.test.ts","../src/lib/container.testing-features.test.ts","../src/lib/container.ts","../src/lib/decorators.runtime.test.ts","../src/lib/decorators.test-d.ts","../src/lib/decorators.ts","../src/lib/dependency-error.ts","../src/lib/env-detection.test.ts","../src/lib/env-detection.ts","../src/lib/lazy-retry.test.ts","../src/lib/lazy.ts","../src/lib/providers.test.ts","../src/lib/providers.ts","../src/lib/scope.ts","../src/lib/service-identifiers.test.ts","../src/lib/service-identifiers.ts","../src/lib/tokens.test.ts","../src/lib/types.ts","../src/lib/testing/mocking.test.ts","../src/lib/testing/mocking.ts","../src/lib/testing/registry.test.ts","../src/lib/testing/registry.ts","../src/plugins/core/codegen.test.ts","../src/plugins/core/codegen.ts","../src/plugins/core/decorators.helpers.test.ts","../src/plugins/core/decorators.ts","../src/plugins/core/discovery-store.ts","../src/plugins/core/identifier-resolver.test.ts","../src/plugins/core/identifier-resolver.ts","../src/plugins/core/lazy-utils.ts","../src/plugins/core/lazy.helpers.test.ts","../src/plugins/core/lazy.ts","../src/plugins/core/scanner.test.ts","../src/plugins/core/scanner.ts","../src/plugins/core/types.ts","../src/plugins/core/utils.ts","../src/plugins/rollup-plugin/build-utils.ts","../src/plugins/rollup-plugin/index.ts","../src/plugins/rollup-plugin/rollup-plugin.test.ts","../src/plugins/vite-plugin/codegen.specifier.test.ts","../src/plugins/vite-plugin/container-loader.test.ts","../src/plugins/vite-plugin/container-loader.ts","../src/plugins/vite-plugin/discovery-runtime.ts","../src/plugins/vite-plugin/duplicate-registrations.test.ts","../src/plugins/vite-plugin/fixture-subpaths.test.ts","../src/plugins/vite-plugin/index.ts","../src/plugins/vite-plugin/lazy-services.test.ts","../src/plugins/vite-plugin/lifecycle-and-hmr.test.ts","../src/plugins/vite-plugin/manifest-utils.ts","../src/plugins/vite-plugin/manifest-utils.validation.test.ts","../src/plugins/vite-plugin/module-generation.test.ts","../src/plugins/vite-plugin/test-utils.ts","../src/plugins/vite-plugin/transform-guards.test.ts","../src/plugins/vite-plugin/visualization-option.test.ts","../src/plugins/vite-plugin/visualization-utils.ts","../src/plugins/vite-plugin/visualizer.test.ts","../src/plugins/vite-plugin/visualizer.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alloy-di",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "A compile-time dependency injection plugin for Vite",
   "keywords": [
     "dependency-injection",