alloy-di 1.2.0 → 1.2.2

package/dist/plugins/core/codegen.js

@@ -264,7 +264,7 @@ function generateManifestTypeDefinition(manifests) {
 declare module "${m.packageName}/manifest" {
   type ServiceScope = "singleton" | "transient";
 
-  interface ManifestLazyDependency {
+  interface ManifestLegacyLazyDependency {
     exportName: string;
     importPath: string;
     retry?: {
@@ -274,22 +274,60 @@ declare module "${m.packageName}/manifest" {
     };
   }
 
+  interface ManifestLegacyTokenDependency {
+    exportName: string;
+    importPath: string;
+    symbolKey?: string;
+  }
+
+  interface ManifestClassDependency {
+    kind: "class";
+    exportName: string;
+  }
+
   interface ManifestTokenDependency {
+    kind: "token";
     exportName: string;
     importPath: string;
     symbolKey?: string;
   }
 
-  interface ManifestService {
+  interface ManifestLazyDependency {
+    kind: "lazy";
+    exportName: string;
+    importPath: string;
+    retry?: {
+      retries: number;
+      backoffMs?: number;
+      factor?: number;
+    };
+  }
+
+  type ManifestDependency =
+    | ManifestClassDependency
+    | ManifestTokenDependency
+    | ManifestLazyDependency;
+
+  interface ManifestServiceV1 {
     exportName: string;
     importPath: string;
     symbolKey: string;
     scope: ServiceScope;
     deps: string[];
-    lazyDeps: ManifestLazyDependency[];
-    tokenDeps?: ManifestTokenDependency[];
+    lazyDeps: ManifestLegacyLazyDependency[];
+    tokenDeps?: ManifestLegacyTokenDependency[];
   }
 
+  interface ManifestServiceV2 {
+    exportName: string;
+    importPath: string;
+    symbolKey: string;
+    scope: ServiceScope;
+    deps: ManifestDependency[];
+  }
+
+  type ManifestService = ManifestServiceV1 | ManifestServiceV2;
+
   interface LibraryManifest {
     schemaVersion: number;
     packageName: string;

package/dist/plugins/core/lazy.js

@@ -12,12 +12,20 @@ const RESOLVED_EXTENSIONS = [
 	".cts"
 ];
 function processLazyCall(node, fileId, sourceFile, localLazyRefs) {
-	if (node.expression.getText(sourceFile) !== "Lazy") return;
-	const classKeys = resolveLazyTarget(node, fileId);
-	if (!classKeys) return;
-	for (const key of classKeys) localLazyRefs.add(key);
+	if (!isLazyCall(node, sourceFile)) return;
+	const parsed = resolveLazyDependency(node, fileId);
+	if (!parsed) return;
+	for (const key of parsed.classKeys) localLazyRefs.add(key);
 }
-function resolveLazyTarget(node, fileId) {
+function parseLazyDependencyExpression(expression, fileId) {
+	const statement = ts.createSourceFile(fileId, `const __alloyLazy = (${expression});`, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS).statements[0];
+	if (!statement || !ts.isVariableStatement(statement)) return;
+	const initializer = statement.declarationList.declarations[0]?.initializer;
+	const call = initializer ? unwrapExpression(initializer) : void 0;
+	if (!call || !ts.isCallExpression(call)) return;
+	return resolveLazyDependency(call, fileId);
+}
+function resolveLazyDependency(node, fileId) {
 	const factory = getLazyFactory(node.arguments[0]);
 	if (!factory) return;
 	const body = getReturnedExpression(factory);
@@ -25,14 +33,49 @@ function resolveLazyTarget(node, fileId) {
 	const importInfo = extractImportInfo(body);
 	const exportName = importInfo?.exportName;
 	if (!importInfo || !exportName) return;
+	const retry = extractRetryOptions(node.arguments[1]);
 	const resolvedPaths = resolveModuleSpecifierCandidates(fileId, importInfo.specifier);
 	if (!resolvedPaths.length) return;
-	return resolvedPaths.map((candidate) => createClassKey(candidate, exportName));
+	return {
+		specifier: importInfo.specifier,
+		exportName,
+		retry,
+		importPath: importInfo.specifier,
+		classKeys: resolvedPaths.map((candidate) => createClassKey(candidate, exportName))
+	};
 }
 function getLazyFactory(arg) {
 	if (!arg) return;
 	if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) return arg;
 }
+function extractRetryOptions(expr) {
+	if (!expr || !ts.isObjectLiteralExpression(expr)) return;
+	let retries;
+	let backoffMs;
+	let factor;
+	for (const prop of expr.properties) {
+		if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+		const value = extractNumberLiteral(prop.initializer);
+		if (typeof value !== "number") continue;
+		if (prop.name.text === "retries") retries = value;
+		else if (prop.name.text === "backoffMs") backoffMs = value;
+		else if (prop.name.text === "factor") factor = value;
+	}
+	if (typeof retries !== "number") return;
+	return {
+		retries,
+		...typeof backoffMs === "number" ? { backoffMs } : {},
+		...typeof factor === "number" ? { factor } : {}
+	};
+}
+function extractNumberLiteral(expr) {
+	if (ts.isNumericLiteral(expr)) return Number(expr.text);
+	if (ts.isPrefixUnaryExpression(expr) && expr.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expr.operand)) return -Number(expr.operand.text);
+}
+function unwrapExpression(expr) {
+	if (ts.isParenthesizedExpression(expr) || ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr) || ts.isNonNullExpression(expr)) return unwrapExpression(expr.expression);
+	return expr;
+}
 function getReturnedExpression(fn) {
 	if (ts.isBlock(fn.body)) {
 		for (const statement of fn.body.statements) if (ts.isReturnStatement(statement) && statement.expression) return statement.expression;
@@ -61,6 +104,10 @@ function extractImportInfo(expr) {
 function isDynamicImport(node) {
 	return node.expression.kind === ts.SyntaxKind.ImportKeyword;
 }
+function isLazyCall(node, sourceFile) {
+	const text = node.expression.getText(sourceFile);
+	return text === "Lazy" || text.endsWith(".Lazy");
+}
 function getImportSpecifier(node) {
 	return node && ts.isStringLiteralLike(node) ? node.text : void 0;
 }
@@ -86,4 +133,4 @@ function resolveModuleSpecifierCandidates(fromId, specifier) {
 	return [...fileCandidates, ...indexCandidates];
 }
 //#endregion
-export { processLazyCall };
+export { parseLazyDependencyExpression, processLazyCall, resolveModuleSpecifierCandidates };

package/dist/plugins/core/scanner.js

@@ -1,8 +1,10 @@
 import { createClassKey, createSymbolKey } from "./utils.js";
 import { extractServiceMetadata } from "./decorators.js";
-import { processLazyCall } from "./lazy.js";
+import { processLazyCall, resolveModuleSpecifierCandidates } from "./lazy.js";
+import fs from "node:fs";
 import ts, { SyntaxKind } from "typescript";
 //#region src/plugins/core/scanner.ts
+const ALLOY_RUNTIME_MODULE = "alloy-di/runtime";
 function collectFileImports(sourceFile) {
 	const imports = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.statements) if (ts.isImportDeclaration(statement) && statement.importClause && ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -39,12 +41,14 @@ function scanSource(code, id) {
 	const discovered = /* @__PURE__ */ new Map();
 	const lazyRefs = /* @__PURE__ */ new Set();
 	const fileImports = collectFileImports(sourceFile);
+	const decoratorResolutionCache = /* @__PURE__ */ new Map();
 	const visit = (node) => {
 		if (ts.isClassDeclaration(node)) handleClassDeclaration(node, {
 			id,
 			sourceFile,
 			fileImports,
-			discovered
+			discovered,
+			decoratorResolutionCache
 		});
 		else if (ts.isCallExpression(node)) processLazyCall(node, id, sourceFile, lazyRefs);
 		ts.forEachChild(node, visit);
@@ -57,9 +61,9 @@ function scanSource(code, id) {
 }
 function handleClassDeclaration(node, context) {
 	if (!node.name) return;
-	const decoratorCall = findServiceDecorator(node, context.sourceFile);
-	if (!decoratorCall) return;
-	const decoratorName = decoratorCall.expression.getText(context.sourceFile);
+	const decoratorMatch = findServiceDecorator(node, context.sourceFile, context.fileImports, context.id, context.decoratorResolutionCache);
+	if (!decoratorMatch) return;
+	const { decoratorCall, decoratorName } = decoratorMatch;
 	const className = node.name.getText(context.sourceFile);
 	const metadata = extractServiceMetadata(decoratorName, decoratorCall, context.sourceFile);
 	const referencedImports = collectReferencedImports(metadata, context.fileImports);
@@ -72,15 +76,81 @@ function handleClassDeclaration(node, context) {
 		referencedImports
 	});
 }
-function findServiceDecorator(node, sourceFile) {
+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;
-		const name = decorator.expression.expression.getText(sourceFile);
-		if (name.endsWith("Injectable") || name.endsWith("Singleton")) return decorator.expression;
+		const decoratorName = resolveDecoratorName(decorator.expression.expression, fileImports, id, new Set([id]), resolutionCache);
+		if (decoratorName) return {
+			decoratorCall: decorator.expression,
+			decoratorName
+		};
 	}
 }
+function resolveDecoratorName(expression, fileImports, id, visitedModules, resolutionCache) {
+	if (ts.isIdentifier(expression)) {
+		const importInfo = fileImports.get(expression.text);
+		if (!importInfo || importInfo.isTypeOnly) return;
+		return resolveImportedDecorator(importInfo.path, importInfo.originalName ?? expression.text, id, visitedModules, resolutionCache);
+	}
+	if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression)) {
+		const importInfo = fileImports.get(expression.expression.text);
+		if (!importInfo || importInfo.isTypeOnly || importInfo.originalName !== "*") return;
+		return resolveImportedDecorator(importInfo.path, expression.name.text, id, visitedModules, resolutionCache);
+	}
+}
+function resolveImportedDecorator(importPath, requestedName, fromId, visitedModules, resolutionCache) {
+	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;
+		visitedModules.add(candidate);
+		try {
+			const source = fs.readFileSync(candidate, "utf8");
+			const sourceFile = ts.createSourceFile(candidate, source, ts.ScriptTarget.ESNext, true);
+			const resolved = resolveDecoratorExport(requestedName, sourceFile, collectFileImports(sourceFile), candidate, visitedModules, resolutionCache);
+			resolutionCache.set(cacheKey, resolved ?? null);
+			if (resolved) return resolved;
+		} catch {
+			continue;
+		} finally {
+			visitedModules.delete(candidate);
+		}
+	}
+}
+function resolveDecoratorExport(requestedName, sourceFile, fileImports, id, visitedModules, resolutionCache) {
+	for (const statement of sourceFile.statements) {
+		if (!ts.isExportDeclaration(statement)) continue;
+		const moduleSpecifier = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : void 0;
+		if (!statement.exportClause) {
+			if (!moduleSpecifier) continue;
+			const resolved = resolveImportedDecorator(moduleSpecifier, requestedName, id, visitedModules, resolutionCache);
+			if (resolved) return resolved;
+			continue;
+		}
+		if (!ts.isNamedExports(statement.exportClause)) continue;
+		for (const element of statement.exportClause.elements) {
+			if (element.name.text !== requestedName) continue;
+			const resolved = resolveNamedExportElement(element, moduleSpecifier, fileImports, id, visitedModules, resolutionCache);
+			if (resolved) return resolved;
+		}
+	}
+}
+function resolveNamedExportElement(element, moduleSpecifier, fileImports, id, visitedModules, resolutionCache) {
+	const sourceName = element.propertyName?.text ?? element.name.text;
+	if (moduleSpecifier) return resolveImportedDecorator(moduleSpecifier, sourceName, id, visitedModules, resolutionCache);
+	const importInfo = fileImports.get(sourceName);
+	if (!importInfo || importInfo.isTypeOnly) return;
+	return resolveImportedDecorator(importInfo.path, importInfo.originalName ?? sourceName, id, visitedModules, resolutionCache);
+}
+function isAlloyDecoratorName(name) {
+	return name === "Injectable" || name === "Singleton";
+}
 function collectReferencedImports(metadata, fileImports) {
 	const referenced = [];
 	const seen = /* @__PURE__ */ new Set();

package/dist/plugins/core/types.d.ts

@@ -1,7 +1,31 @@
 import { ServiceScope } from "../../lib/scope.js";
 
 //#region src/plugins/core/types.d.ts
-interface ManifestServiceDescriptor {
+interface ManifestTokenDependency {
+  exportName: string;
+  importPath: string;
+}
+interface ManifestLazyDependency {
+  exportName: string;
+  importPath: string;
+  retry?: {
+    retries: number;
+    backoffMs?: number;
+    factor?: number;
+  };
+}
+interface ManifestClassDependencyEntry {
+  kind: "class";
+  exportName: string;
+}
+interface ManifestTokenDependencyEntry extends ManifestTokenDependency {
+  kind: "token";
+}
+interface ManifestLazyDependencyEntry extends ManifestLazyDependency {
+  kind: "lazy";
+}
+type ManifestDependencyEntry = ManifestClassDependencyEntry | ManifestTokenDependencyEntry | ManifestLazyDependencyEntry;
+interface ManifestServiceDescriptorBase {
   exportName: string;
   importPath: string;
   /**
@@ -10,22 +34,17 @@ interface ManifestServiceDescriptor {
    */
   symbolKey: string;
   scope: ServiceScope;
+}
+interface ManifestServiceDescriptorV1 extends ManifestServiceDescriptorBase {
   deps: string[];
   /** Token dependencies (non-service identifiers) exported publicly by the package. */
-  tokenDeps?: {
-    exportName: string;
-    importPath: string;
-  }[];
-  lazyDeps: {
-    exportName: string;
-    importPath: string;
-    retry?: {
-      retries: number;
-      backoffMs?: number;
-      factor?: number;
-    };
-  }[];
+  tokenDeps?: ManifestTokenDependency[];
+  lazyDeps: ManifestLazyDependency[];
+}
+interface ManifestServiceDescriptorV2 extends ManifestServiceDescriptorBase {
+  deps: ManifestDependencyEntry[];
 }
+type ManifestServiceDescriptor = ManifestServiceDescriptorV1 | ManifestServiceDescriptorV2;
 interface AlloyManifest {
   schemaVersion: number;
   packageName: string;

package/dist/plugins/rollup-plugin/index.js

@@ -1,4 +1,5 @@
 import { ServiceScope } from "../../lib/scope.js";
+import { parseLazyDependencyExpression, resolveModuleSpecifierCandidates } from "../core/lazy.js";
 import { createDiscoveryStore } from "../core/discovery-store.js";
 import { determineBuildMode, hasPreserveModules, resolveImportPathForBuild } from "./build-utils.js";
 import path from "node:path";
@@ -9,6 +10,31 @@ import ts from "typescript";
 function hasExportModifier(node) {
 	return !!(ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
 }
+function getDependencyImports(meta, dep) {
+	const imports = meta.referencedImports ?? [];
+	if (imports.length === 0 || dep.referencedIdentifiers.length === 0) return [];
+	const identifiers = new Set(dep.referencedIdentifiers);
+	return imports.filter((entry) => identifiers.has(entry.name));
+}
+function getDependencyReferenceName(expression) {
+	const statement = ts.createSourceFile("dependency.ts", `const __dep = (${expression});`, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS).statements[0];
+	if (!statement || !ts.isVariableStatement(statement)) return;
+	const initializer = statement.declarationList.declarations[0]?.initializer;
+	if (!initializer) return;
+	return extractReferenceNameFromExpression(initializer);
+}
+function extractReferenceNameFromExpression(expression) {
+	if (ts.isIdentifier(expression)) return expression.text;
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
+	if (ts.isAsExpression(expression) || ts.isParenthesizedExpression(expression) || ts.isNonNullExpression(expression) || ts.isTypeAssertionExpression(expression)) return extractReferenceNameFromExpression(expression.expression);
+}
+function resolveClassDependencyName(dep, meta, knownServiceNames) {
+	const imports = getDependencyImports(meta, dep);
+	for (const entry of imports) if (entry.originalName && knownServiceNames.has(entry.originalName)) return entry.originalName;
+	const referenceName = getDependencyReferenceName(dep.expression);
+	if (referenceName && knownServiceNames.has(referenceName)) return referenceName;
+	return dep.referencedIdentifiers.find((name) => knownServiceNames.has(name));
+}
 function alloy(options = {}) {
 	const fileName = options.fileName ?? "alloy.manifest.mjs";
 	const packageJsonFile = options.packageJsonPath ? path.isAbsolute(options.packageJsonPath) ? options.packageJsonPath : path.resolve(process.cwd(), options.packageJsonPath) : path.resolve(process.cwd(), "package.json");
@@ -83,6 +109,38 @@ function alloy(options = {}) {
 	function resolveImportPath(targetPath, buildMode) {
 		return resolveImportPathForBuild(targetPath, packageName, buildMode);
 	}
+	function resolveDependencyImportPath(specifier, sourceFilePath, buildMode) {
+		if (specifier.startsWith(".")) return resolveImportPath(resolveModuleSpecifierCandidates(sourceFilePath, specifier)[0] ?? path.resolve(path.dirname(sourceFilePath), specifier), buildMode);
+		if (path.isAbsolute(specifier)) return resolveImportPath(specifier, buildMode);
+		return specifier;
+	}
+	function createTokenDependency(dep, meta, buildMode) {
+		const preferredImport = getDependencyImports(meta, dep).find((entry) => entry.originalName !== "*");
+		return {
+			kind: "token",
+			exportName: preferredImport?.originalName ?? getDependencyReferenceName(dep.expression) ?? dep.referencedIdentifiers[0] ?? dep.expression,
+			importPath: preferredImport ? resolveDependencyImportPath(preferredImport.path, meta.filePath, buildMode) : packageName
+		};
+	}
+	function createManifestDependency(dep, meta, knownServiceNames, buildMode) {
+		if (dep.isLazy) {
+			const parsedLazy = parseLazyDependencyExpression(dep.expression, meta.filePath);
+			if (!parsedLazy) return null;
+			const entry = {
+				kind: "lazy",
+				exportName: parsedLazy.exportName,
+				importPath: resolveDependencyImportPath(parsedLazy.specifier, meta.filePath, buildMode)
+			};
+			if (parsedLazy.retry) entry.retry = parsedLazy.retry;
+			return entry;
+		}
+		const className = resolveClassDependencyName(dep, meta, knownServiceNames);
+		if (className) return {
+			kind: "class",
+			exportName: className
+		};
+		return createTokenDependency(dep, meta, buildMode);
+	}
 	return {
 		name: "alloy-manifest",
 		transform(code, id) {
@@ -108,55 +166,26 @@ function alloy(options = {}) {
 					importPath,
 					symbolKey,
 					scope,
-					deps: [],
-					lazyDeps: []
+					deps: []
 				});
 				if (buildMode !== "preserve-modules" && !exportedNames.has(meta.className)) missingExports.push(meta.className);
 			}
 			const serviceByName = /* @__PURE__ */ new Map();
-			for (const s of services) serviceByName.set(s.exportName, s);
-			const serviceTokenDeps = /* @__PURE__ */ new Map();
+			const knownServiceNames = /* @__PURE__ */ new Set();
+			for (const service of services) {
+				serviceByName.set(service.exportName, service);
+				knownServiceNames.add(service.exportName);
+			}
 			for (const metas of discovery.fileMetas.values()) for (const meta of metas) {
 				const svc = serviceByName.get(meta.className);
 				if (!svc) continue;
 				for (const dep of meta.metadata.dependencies) {
-					if (dep.isLazy) continue;
-					for (const name of dep.referencedIdentifiers) if (serviceByName.has(name)) svc.deps.push(name);
-					else {
-						const set = serviceTokenDeps.get(svc.exportName) ?? /* @__PURE__ */ new Set();
-						set.add(name);
-						serviceTokenDeps.set(svc.exportName, set);
-					}
+					const manifestDep = createManifestDependency(dep, meta, knownServiceNames, buildMode);
+					if (manifestDep) svc.deps.push(manifestDep);
 				}
 			}
-			for (const [id, refs] of discovery.fileLazyRefs.entries()) {
-				const metas = discovery.fileMetas.get(id) ?? [];
-				for (const meta of metas) {
-					const svc = serviceByName.get(meta.className);
-					if (!svc) continue;
-					const firstForExport = /* @__PURE__ */ new Map();
-					for (const key of refs) {
-						const [targetPath, exportName] = key.split("::");
-						if (!targetPath || !exportName) continue;
-						const importPath = resolveImportPath(targetPath, buildMode);
-						if (!firstForExport.has(exportName)) firstForExport.set(exportName, importPath);
-					}
-					for (const [exportName, importPath] of firstForExport.entries()) svc.lazyDeps.push({
-						exportName,
-						importPath
-					});
-				}
-			}
-			for (const [exportName, tokens] of serviceTokenDeps.entries()) {
-				const svc = serviceByName.get(exportName);
-				if (!svc || !tokens.size) continue;
-				svc.tokenDeps = Array.from(tokens).map((t) => ({
-					exportName: t,
-					importPath: packageName
-				}));
-			}
 			const manifest = {
-				schemaVersion: 1,
+				schemaVersion: 2,
 				packageName,
 				buildMode,
 				services,
@@ -187,7 +216,7 @@ function alloy(options = {}) {
 				}
 				manifest.providers = resolvedProviders;
 			}
-			const code = `// Generated Alloy manifest (v1)\nexport const manifest = ${JSON.stringify(manifest, null, 2)};\n`;
+			const code = `// Generated Alloy manifest (v2)\nexport const manifest = ${JSON.stringify(manifest, null, 2)};\n`;
 			const identifiersCode = ["// Generated Alloy Service Identifiers", ...services.map((s) => `export const ${s.exportName}Identifier = Symbol.for("${s.symbolKey}");`)].join("\n");
 			if (this.emitFile) {
 				this.emitFile({

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

@@ -0,0 +1,92 @@
+import { normalizeImportPath } from "../core/utils.js";
+import { IdentifierResolver } from "../core/identifier-resolver.js";
+import { generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition } from "../core/codegen.js";
+import { augmentFactoryLazyServices, collectEagerReferencedNames, findDuplicateManifestServices, groupMetasByName, readManifests, reconcileLazySet, toMetaFromManifest } from "./manifest-utils.js";
+import { generateMermaidDiagram } from "./visualizer.js";
+import { ensureDirectoryForFile } from "./visualization-utils.js";
+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;
+	assignIdentifierKeys(metas, options.packageName, options.resolvedRoot);
+	const manifestData = await readManifests(options.manifests);
+	const manifestServices = manifestData.services;
+	const loadedManifests = manifestData.loadedManifests;
+	assertNoDuplicateManifestServices(metas, manifestServices);
+	const combinedMetas = [...metas, ...manifestServices.map((svc) => ({
+		className: svc.exportName,
+		filePath: svc.importPath,
+		metadata: {
+			scope: svc.scope,
+			dependencies: []
+		}
+	}))];
+	const resolver = new IdentifierResolver(combinedMetas);
+	const metasByName = groupMetasByName(combinedMetas);
+	for (const svc of manifestServices) metas.push(toMetaFromManifest(svc, metasByName, resolver, options.lazyReferencedClassKeys));
+	const providerImports = Array.from(new Set([...options.providerImportPaths, ...manifestData.providers]));
+	const eagerReferencedNames = collectEagerReferencedNames(metas);
+	reconcileLazySet(metas, options.lazyReferencedClassKeys, eagerReferencedNames);
+	augmentFactoryLazyServices(metas, options.lazyServiceKeys);
+	const code = generateContainerModule(metas, new Set(options.lazyReferencedClassKeys), providerImports);
+	writeTypeDefinitions(metas, loadedManifests, options.resolvedRoot, options.containerDeclarationDir);
+	writeVisualizationArtifact(metas, options.lazyReferencedClassKeys, options.resolvedVisualization);
+	return {
+		code,
+		moduleType: "js"
+	};
+}
+function assignIdentifierKeys(metas, packageName, resolvedRoot) {
+	for (const meta of metas) {
+		const normalizedMetaPath = normalizeImportPath(meta.filePath);
+		const trimmedNormalizedMetaPath = normalizedMetaPath.replaceAll(/^\/+/g, "");
+		const looksRootRelative = normalizedMetaPath === "/src" || normalizedMetaPath.startsWith("/src/");
+		let relPath = path.relative(resolvedRoot, meta.filePath);
+		if (path.sep === "\\") relPath = relPath.split(path.sep).join("/");
+		if (looksRootRelative || !relPath || relPath.startsWith("..") || relPath.startsWith("\\")) relPath = trimmedNormalizedMetaPath || normalizedMetaPath.replaceAll(/^\/+/g, "");
+		meta.identifierKey = `alloy:${packageName}/${relPath}#${meta.className}`;
+	}
+}
+function assertNoDuplicateManifestServices(metas, manifestServices) {
+	if (!metas.length || !manifestServices.length) return;
+	const duplicates = findDuplicateManifestServices(metas, manifestServices);
+	if (!duplicates.length) return;
+	const details = duplicates.map((d) => `- ${d.exportName}: local [${d.localPaths.join(", ")}] vs manifest '${d.manifestImport}'`).join("\n");
+	throw new Error([
+		"[alloy] Duplicate service registrations detected.",
+		details,
+		"Resolve by removing one source (local or manifest) to avoid ambiguous DI keys."
+	].join("\n"));
+}
+function writeTypeDefinitions(metas, loadedManifests, resolvedRoot, containerDeclarationDir) {
+	const dtsDir = path.resolve(resolvedRoot, containerDeclarationDir ?? "./src");
+	const dtsContent = generateContainerTypeDefinition(metas, (filePath) => resolveDeclarationImportPath(dtsDir, filePath));
+	if (!fs.existsSync(dtsDir)) fs.mkdirSync(dtsDir, { recursive: true });
+	fs.writeFileSync(path.join(dtsDir, "alloy-container.d.ts"), dtsContent);
+	if (loadedManifests.length === 0) return;
+	const manifestsDts = generateManifestTypeDefinition(loadedManifests.map((m) => ({
+		packageName: m.packageName,
+		services: m.services
+	})));
+	fs.writeFileSync(path.join(dtsDir, "alloy-manifests.d.ts"), manifestsDts);
+}
+function resolveDeclarationImportPath(dtsDir, filePath) {
+	if (!path.isAbsolute(filePath)) return filePath;
+	let rel = path.relative(dtsDir, filePath);
+	rel = rel.split(path.sep).join(path.posix.sep);
+	if (!rel.startsWith(".")) rel = "./" + rel;
+	return rel;
+}
+function writeVisualizationArtifact(metas, lazyReferencedClassKeys, resolvedVisualization) {
+	if (!resolvedVisualization) return;
+	const artifact = generateMermaidDiagram({
+		metas,
+		lazyClassKeys: new Set(lazyReferencedClassKeys),
+		options: resolvedVisualization.mermaidOptions
+	});
+	ensureDirectoryForFile(resolvedVisualization.outputPath);
+	fs.writeFileSync(resolvedVisualization.outputPath, `${artifact.diagram}\n`);
+}
+//#endregion
+export { loadVirtualContainerModule };

package/dist/plugins/vite-plugin/discovery-runtime.js

@@ -0,0 +1,76 @@
+import { createClassKey } from "../core/utils.js";
+import { createDiscoveryStore } from "../core/discovery-store.js";
+//#region src/plugins/vite-plugin/discovery-runtime.ts
+/** Files the discovery scanner processes (mirrors the transform hook filter). */
+function isDiscoverableFile(file) {
+	return /\.tsx?$/i.test(file) && !/\.d\.ts$/i.test(file) && !file.includes("node_modules");
+}
+/**
+* Serializes the codegen-relevant fields of a file's discovered metas so two
+* scans can be compared. Changes here (added/removed services, scope, deps,
+* factory, or resolved imports) mean the generated container must be rebuilt;
+* edits that leave them untouched (e.g. a method body) should not.
+*/
+function metasSignature(metas) {
+	return JSON.stringify(metas.map((m) => ({
+		className: m.className,
+		filePath: m.filePath,
+		scope: m.metadata.scope,
+		factory: m.metadata.factory?.expression ?? null,
+		dependencies: m.metadata.dependencies.map((d) => ({
+			expression: d.expression,
+			isLazy: d.isLazy,
+			referencedIdentifiers: d.referencedIdentifiers
+		})),
+		referencedImports: (m.referencedImports ?? []).map((r) => ({
+			name: r.name,
+			path: r.path,
+			originalName: r.originalName ?? null,
+			isTypeOnly: Boolean(r.isTypeOnly)
+		}))
+	})));
+}
+function lazyKeysSignature(keys) {
+	if (!keys || keys.size === 0) return "";
+	return Array.from(keys).toSorted().join("|");
+}
+function createDiscoveryRuntime() {
+	const discovery = createDiscoveryStore();
+	const discoveredClasses = /* @__PURE__ */ new Map();
+	const lazyReferencedClassKeys = /* @__PURE__ */ new Set();
+	return {
+		discoveredClasses,
+		lazyReferencedClassKeys,
+		processUpdate(id, code) {
+			const { metas, lazyClassKeys, previousMetas, previousLazyClassKeys } = discovery.updateFile(id, code);
+			if (previousMetas) for (const meta of previousMetas) discoveredClasses.delete(createClassKey(meta.filePath, meta.className));
+			for (const meta of metas) discoveredClasses.set(createClassKey(meta.filePath, meta.className), meta);
+			if (previousLazyClassKeys) for (const key of previousLazyClassKeys) lazyReferencedClassKeys.delete(key);
+			if (lazyClassKeys.size) for (const key of lazyClassKeys) lazyReferencedClassKeys.add(key);
+			return metasSignature(previousMetas ?? []) !== metasSignature(metas) || lazyKeysSignature(previousLazyClassKeys) !== lazyKeysSignature(lazyClassKeys);
+		},
+		removeDiscoveredFile(file) {
+			const removed = discovery.removeFile(file);
+			if (removed.previousMetas) for (const meta of removed.previousMetas) discoveredClasses.delete(createClassKey(meta.filePath, meta.className));
+			if (removed.previousLazyClassKeys) for (const key of removed.previousLazyClassKeys) lazyReferencedClassKeys.delete(key);
+			return Boolean(removed.previousMetas?.length || removed.previousLazyClassKeys?.size);
+		},
+		clear() {
+			discovery.clear();
+			discoveredClasses.clear();
+			lazyReferencedClassKeys.clear();
+		}
+	};
+}
+/**
+* Invalidate the generated container module in every environment's module
+* graph so its `load` hook re-runs and regenerates from current discovery.
+*/
+function invalidateContainerModule(server, resolvedVirtualModuleId) {
+	for (const environment of Object.values(server.environments)) {
+		const mod = environment.moduleGraph.getModuleById(resolvedVirtualModuleId);
+		if (mod) environment.moduleGraph.invalidateModule(mod);
+	}
+}
+//#endregion
+export { createDiscoveryRuntime, invalidateContainerModule, isDiscoverableFile };

package/dist/plugins/vite-plugin/index.d.ts

@@ -1,19 +1,9 @@
 import { ServiceIdentifier } from "../../lib/service-identifiers.js";
 import { AlloyManifest } from "../core/types.js";
-import { MermaidDiagramOptions } from "./visualizer.js";
+import { AlloyMermaidVisualizerOptions, AlloyVisualizationOptions } from "./visualization-utils.js";
 import { Plugin } from "vite";
 
 //#region src/plugins/vite-plugin/index.d.ts
-interface AlloyMermaidVisualizerOptions extends MermaidDiagramOptions {
-  outputPath?: string;
-}
-interface AlloyVisualizationOptions {
-  /**
-   * Configure Mermaid diagram emission. Use `true` for defaults or provide
-   * overrides for layout, colors, or output path.
-   */
-  mermaid?: boolean | AlloyMermaidVisualizerOptions;
-}
 interface AlloyPluginOptions {
   providers?: string[];
   /** Optional list of manifest objects to ingest */

package/dist/plugins/vite-plugin/index.js

@@ -1,13 +1,10 @@
-import { createClassKey, normalizeImportPath, walkSync } from "../core/utils.js";
-import { IdentifierResolver } from "../core/identifier-resolver.js";
-import { generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition } from "../core/codegen.js";
-import { createDiscoveryStore } from "../core/discovery-store.js";
-import { augmentFactoryLazyServices, collectEagerReferencedNames, findDuplicateManifestServices, groupMetasByName, readManifests, reconcileLazySet, toMetaFromManifest } from "./manifest-utils.js";
-import { generateMermaidDiagram } from "./visualizer.js";
+import { normalizeImportPath, walkSync } from "../core/utils.js";
+import { resolveVisualizationOptions } from "./visualization-utils.js";
+import { loadVirtualContainerModule } from "./container-loader.js";
+import { createDiscoveryRuntime, invalidateContainerModule, isDiscoverableFile } from "./discovery-runtime.js";
 import path from "node:path";
 import fs from "node:fs";
 //#region src/plugins/vite-plugin/index.ts
-const DEFAULT_MERMAID_FILENAME = "alloy-di.mmd";
 function toLazyServiceKey(identifier) {
 	const description = identifier.description;
 	if (!description || !description.startsWith("alloy:")) throw new Error("[alloy] lazyServices entries must be serviceIdentifiers exported by Alloy manifests.");
@@ -26,18 +23,10 @@ function alloy(options = {}) {
 	let packageName = "UNKNOWN_PACKAGE";
 	let resolvedVisualization = null;
 	const lazyServiceKeys = new Set((options.lazyServices ?? []).map(toLazyServiceKey));
-	const discovery = createDiscoveryStore();
-	const discoveredClasses = /* @__PURE__ */ new Map();
-	const lazyReferencedClassKeys = /* @__PURE__ */ new Set();
-	const processUpdate = (id, code) => {
-		const { metas, lazyClassKeys, previousMetas, previousLazyClassKeys } = discovery.updateFile(id, code);
-		if (previousMetas) for (const meta of previousMetas) discoveredClasses.delete(createClassKey(meta.filePath, meta.className));
-		for (const meta of metas) discoveredClasses.set(createClassKey(meta.filePath, meta.className), meta);
-		if (previousLazyClassKeys) for (const key of previousLazyClassKeys) lazyReferencedClassKeys.delete(key);
-		if (lazyClassKeys.size) for (const key of lazyClassKeys) lazyReferencedClassKeys.add(key);
-	};
+	const discoveryRuntime = createDiscoveryRuntime();
 	return {
 		name: "vite-plugin-alloy",
+		enforce: "pre",
 		configResolved(config) {
 			resolvedRoot = config.root ?? process.cwd();
 			try {
@@ -67,133 +56,57 @@ function alloy(options = {}) {
 				exclude: [/\.d\.ts$/i, /node_modules/]
 			} },
 			handler(code, id) {
-				processUpdate(id, code);
+				discoveryRuntime.processUpdate(id, code);
 				return null;
 			}
 		},
-		hotUpdate(ctx) {
+		async hotUpdate(ctx) {
 			if (this.environment.name !== "client") return;
-			const file = ctx.file;
-			const inAnyGraph = Object.values(ctx.server.environments).some((env) => env.moduleGraph.getModulesByFile(file)?.size);
-			if (ctx.type === "delete" || !inAnyGraph) {
-				const removed = discovery.removeFile(file);
-				if (removed.previousMetas) for (const meta of removed.previousMetas) discoveredClasses.delete(createClassKey(meta.filePath, meta.className));
-				if (removed.previousLazyClassKeys) for (const key of removed.previousLazyClassKeys) lazyReferencedClassKeys.delete(key);
+			const { file } = ctx;
+			if (!isDiscoverableFile(file)) return;
+			let discoveryChanged;
+			if (ctx.type === "delete") discoveryChanged = discoveryRuntime.removeDiscoveredFile(file);
+			else {
+				let code;
+				try {
+					code = await ctx.read();
+				} catch {
+					return;
+				}
+				discoveryChanged = discoveryRuntime.processUpdate(file, code);
 			}
-			return ctx.modules;
+			if (!discoveryChanged) return;
+			invalidateContainerModule(ctx.server, resolvedVirtualModuleId);
+			this.environment.hot.send({ type: "full-reload" });
+			return [];
 		},
 		buildStart() {
-			discovery.clear();
-			discoveredClasses.clear();
-			lazyReferencedClassKeys.clear();
+			discoveryRuntime.clear();
 			for (const ref of providerModuleRefs) this.addWatchFile(ref.absPath);
 			const files = walkSync(path.join(resolvedRoot, "src"));
 			for (const file of files) if (/\.(tsx?|ts)$/i.test(file) && !file.endsWith(".d.ts")) try {
-				processUpdate(file, fs.readFileSync(file, "utf-8"));
+				const code = fs.readFileSync(file, "utf-8");
+				discoveryRuntime.processUpdate(file, code);
 			} catch {}
 		},
 		load: {
 			filter: { id: { include: [/^\0virtual:alloy-container$/] } },
 			async handler(id) {
 				if (id !== resolvedVirtualModuleId) return;
-				const metas = Array.from(discoveredClasses.values());
-				for (const meta of metas) {
-					const normalizedMetaPath = normalizeImportPath(meta.filePath);
-					const trimmedNormalizedMetaPath = normalizedMetaPath.replaceAll(/^\/+/g, "");
-					const looksRootRelative = normalizedMetaPath === "/src" || normalizedMetaPath.startsWith("/src/");
-					let relPath = path.relative(resolvedRoot, meta.filePath);
-					if (path.sep === "\\") relPath = relPath.split(path.sep).join("/");
-					if (looksRootRelative || !relPath || relPath.startsWith("..") || relPath.startsWith("\\")) relPath = trimmedNormalizedMetaPath || normalizedMetaPath.replaceAll(/^\/+/g, "");
-					meta.identifierKey = `alloy:${packageName}/${relPath}#${meta.className}`;
-				}
-				const manifestData = await readManifests(options.manifests ?? []);
-				const manifestServices = manifestData.services;
-				const loadedManifests = manifestData.loadedManifests;
-				if (metas.length && manifestServices.length) {
-					const duplicates = findDuplicateManifestServices(metas, manifestServices);
-					if (duplicates.length) {
-						const details = duplicates.map((d) => `- ${d.exportName}: local [${d.localPaths.join(", ")}] vs manifest '${d.manifestImport}'`).join("\n");
-						throw new Error([
-							"[alloy] Duplicate service registrations detected.",
-							details,
-							"Resolve by removing one source (local or manifest) to avoid ambiguous DI keys."
-						].join("\n"));
-					}
-				}
-				const combinedMetas = [...metas, ...manifestServices.map((svc) => ({
-					className: svc.exportName,
-					filePath: svc.importPath,
-					metadata: {
-						scope: svc.scope,
-						dependencies: []
-					}
-				}))];
-				const resolver = new IdentifierResolver(combinedMetas);
-				const metasByName = groupMetasByName(combinedMetas);
-				for (const svc of manifestServices) metas.push(toMetaFromManifest(svc, metasByName, resolver, lazyReferencedClassKeys));
-				const providerImports = Array.from(new Set([...providerModuleRefs.map((ref) => ref.importPath), ...manifestData.providers]));
-				reconcileLazySet(metas, lazyReferencedClassKeys, collectEagerReferencedNames(metas));
-				augmentFactoryLazyServices(metas, lazyServiceKeys);
-				const code = generateContainerModule(metas, new Set(lazyReferencedClassKeys), providerImports);
-				const dtsDir = path.resolve(resolvedRoot, options.containerDeclarationDir ?? "./src");
-				const dtsContent = generateContainerTypeDefinition(metas, (filePath) => {
-					if (path.isAbsolute(filePath)) {
-						let rel = path.relative(dtsDir, filePath);
-						rel = rel.split(path.sep).join(path.posix.sep);
-						if (!rel.startsWith(".")) rel = "./" + rel;
-						return rel;
-					}
-					return filePath;
+				return loadVirtualContainerModule({
+					localMetas: Array.from(discoveryRuntime.discoveredClasses.values()),
+					lazyReferencedClassKeys: discoveryRuntime.lazyReferencedClassKeys,
+					manifests: options.manifests ?? [],
+					providerImportPaths: providerModuleRefs.map((ref) => ref.importPath),
+					lazyServiceKeys,
+					packageName,
+					resolvedRoot,
+					containerDeclarationDir: options.containerDeclarationDir,
+					resolvedVisualization
 				});
-				if (!fs.existsSync(dtsDir)) fs.mkdirSync(dtsDir, { recursive: true });
-				const dtsPath = path.join(dtsDir, "alloy-container.d.ts");
-				fs.writeFileSync(dtsPath, dtsContent);
-				if (loadedManifests && loadedManifests.length > 0) {
-					const manifestsDts = generateManifestTypeDefinition(loadedManifests.map((m) => ({
-						packageName: m.packageName,
-						services: m.services
-					})));
-					const manifestsDtsPath = path.join(dtsDir, "alloy-manifests.d.ts");
-					fs.writeFileSync(manifestsDtsPath, manifestsDts);
-				}
-				if (resolvedVisualization) {
-					const artifact = generateMermaidDiagram({
-						metas,
-						lazyClassKeys: new Set(lazyReferencedClassKeys),
-						options: resolvedVisualization.mermaidOptions
-					});
-					ensureDirectoryForFile(resolvedVisualization.outputPath);
-					fs.writeFileSync(resolvedVisualization.outputPath, `${artifact.diagram}\n`);
-				}
-				return {
-					code,
-					moduleType: "js"
-				};
 			}
 		}
 	};
 }
-function resolveVisualizationOptions(input, projectRoot) {
-	if (!input) return null;
-	if (typeof input === "boolean") return {
-		outputPath: path.resolve(projectRoot, DEFAULT_MERMAID_FILENAME),
-		mermaidOptions: void 0
-	};
-	const mermaidConfig = input.mermaid;
-	if (!mermaidConfig) return null;
-	if (mermaidConfig === true) return {
-		outputPath: path.resolve(projectRoot, DEFAULT_MERMAID_FILENAME),
-		mermaidOptions: void 0
-	};
-	const { outputPath, ...rest } = mermaidConfig;
-	return {
-		outputPath: path.resolve(projectRoot, outputPath ?? DEFAULT_MERMAID_FILENAME),
-		mermaidOptions: Object.keys(rest).length > 0 ? rest : void 0
-	};
-}
-function ensureDirectoryForFile(filePath) {
-	const dir = path.dirname(filePath);
-	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-}
 //#endregion
 export { alloy };

package/dist/plugins/vite-plugin/manifest-utils.js

@@ -7,45 +7,72 @@ import { z } from "zod";
 * @param inputs Direct manifest objects.
 * @returns Aggregated arrays of service descriptors and provider specifiers.
 */
+const retrySchema = z.object({
+	retries: z.number(),
+	backoffMs: z.number().optional(),
+	factor: z.number().optional()
+});
+const manifestServiceSchemaV1 = z.object({
+	importPath: z.string(),
+	exportName: z.string(),
+	symbolKey: z.string(),
+	scope: z.enum(["singleton", "transient"]),
+	deps: z.array(z.string()).default([]),
+	tokenDeps: z.array(z.object({
+		exportName: z.string(),
+		importPath: z.string()
+	})).default([]),
+	lazyDeps: z.array(z.object({
+		importPath: z.string(),
+		exportName: z.string(),
+		retry: retrySchema.optional()
+	})).default([])
+});
+const manifestServiceSchemaV2 = z.object({
+	importPath: z.string(),
+	exportName: z.string(),
+	symbolKey: z.string(),
+	scope: z.enum(["singleton", "transient"]),
+	deps: z.array(z.discriminatedUnion("kind", [
+		z.object({
+			kind: z.literal("class"),
+			exportName: z.string()
+		}),
+		z.object({
+			kind: z.literal("token"),
+			exportName: z.string(),
+			importPath: z.string()
+		}),
+		z.object({
+			kind: z.literal("lazy"),
+			exportName: z.string(),
+			importPath: z.string(),
+			retry: retrySchema.optional()
+		})
+	])).default([])
+});
+const manifestSchemaV1 = z.object({
+	schemaVersion: z.number().optional(),
+	packageName: z.string(),
+	services: z.array(manifestServiceSchemaV1).default([]),
+	providers: z.array(z.string()).default([])
+});
+const manifestSchemaV2 = z.object({
+	schemaVersion: z.literal(2),
+	packageName: z.string(),
+	services: z.array(manifestServiceSchemaV2).default([]),
+	providers: z.array(z.string()).default([])
+});
 async function readManifests(inputs) {
 	const services = [];
 	const providers = [];
 	const loadedManifests = [];
-	const manifestSchema = z.object({
-		schemaVersion: z.number().optional(),
-		packageName: z.string(),
-		services: z.array(z.object({
-			importPath: z.string(),
-			exportName: z.string(),
-			symbolKey: z.string(),
-			scope: z.enum(["singleton", "transient"]),
-			deps: z.array(z.string()).default([]),
-			tokenDeps: z.array(z.object({
-				exportName: z.string(),
-				importPath: z.string()
-			})).default([]),
-			lazyDeps: z.array(z.object({
-				importPath: z.string(),
-				exportName: z.string(),
-				retry: z.object({
-					retries: z.number(),
-					backoffMs: z.number().optional(),
-					factor: z.number().optional()
-				}).optional()
-			})).default([])
-		})).default([]),
-		providers: z.array(z.string()).default([])
-	});
 	for (const manifest of inputs) {
-		const parsed = manifestSchema.safeParse(manifest);
-		if (!parsed.success) continue;
-		loadedManifests.push({
-			packageName: parsed.data.packageName,
-			services: parsed.data.services,
-			providers: parsed.data.providers
-		});
-		for (const svc of parsed.data.services) services.push(svc);
-		for (const p of parsed.data.providers) providers.push(p);
+		const parsed = readManifestByVersion(manifest);
+		if (!parsed) continue;
+		loadedManifests.push(parsed);
+		for (const svc of parsed.services) services.push(svc);
+		for (const p of parsed.providers) providers.push(p);
 	}
 	return Promise.resolve({
 		services,
@@ -53,6 +80,35 @@ async function readManifests(inputs) {
 		loadedManifests
 	});
 }
+function readManifestByVersion(manifest) {
+	return (manifest.schemaVersion ?? 1) === 2 ? readManifestV2(manifest) : readManifestV1(manifest);
+}
+function readManifestV1(manifest) {
+	const parsed = manifestSchemaV1.safeParse(manifest);
+	if (!parsed.success) return null;
+	return {
+		schemaVersion: 1,
+		packageName: parsed.data.packageName,
+		services: parsed.data.services.map((svc) => ({
+			...svc,
+			schemaVersion: 1
+		})),
+		providers: parsed.data.providers
+	};
+}
+function readManifestV2(manifest) {
+	const parsed = manifestSchemaV2.safeParse(manifest);
+	if (!parsed.success) return null;
+	return {
+		schemaVersion: 2,
+		packageName: parsed.data.packageName,
+		services: parsed.data.services.map((svc) => ({
+			...svc,
+			schemaVersion: 2
+		})),
+		providers: parsed.data.providers
+	};
+}
 /**
 * Groups metas by class name to support resolving dependencies that reference classes with collisions.
 *
@@ -98,21 +154,22 @@ function selectMetaForDep(metasByName, depName, currentImportPath) {
 function toMetaFromManifest(svc, metasByName, resolver, lazySet) {
 	const deps = [];
 	const referencedImports = [];
-	for (const depName of svc.deps ?? []) {
-		const targetMeta = selectMetaForDep(metasByName, depName, svc.importPath);
-		if (targetMeta) {
-			const expression = resolver.resolve(targetMeta.className, targetMeta.filePath);
-			deps.push({
-				expression,
-				referencedIdentifiers: [expression],
-				isLazy: false
-			});
-		} else deps.push({
-			expression: depName,
-			referencedIdentifiers: [depName],
-			isLazy: false
-		});
-	}
+	if (svc.schemaVersion === 2) appendDependenciesFromManifestV2(svc, deps, referencedImports, metasByName, resolver, lazySet);
+	else appendDependenciesFromManifestV1(svc, deps, referencedImports, metasByName, resolver, lazySet);
+	const metadata = {
+		scope: svc.scope,
+		dependencies: deps
+	};
+	return {
+		className: svc.exportName,
+		filePath: svc.importPath,
+		identifierKey: svc.symbolKey,
+		metadata,
+		referencedImports
+	};
+}
+function appendDependenciesFromManifestV1(svc, deps, referencedImports, metasByName, resolver, lazySet) {
+	for (const depName of svc.deps ?? []) deps.push(createClassOrTokenDependency(depName, svc.importPath, metasByName, resolver));
 	if (Array.isArray(svc.tokenDeps)) for (const tok of svc.tokenDeps) {
 		deps.push({
 			expression: tok.exportName,
@@ -126,31 +183,63 @@ function toMetaFromManifest(svc, metasByName, resolver, lazySet) {
 		});
 	}
 	for (const lazy of svc.lazyDeps ?? []) {
-		const importer = `() => import('${lazy.importPath}').then(m => m.${lazy.exportName})`;
-		let expr;
-		if (lazy.retry) {
-			const opts = [`retries: ${lazy.retry.retries}`];
-			if (typeof lazy.retry.backoffMs === "number") opts.push(`backoffMs: ${lazy.retry.backoffMs}`);
-			if (typeof lazy.retry.factor === "number") opts.push(`factor: ${lazy.retry.factor}`);
-			expr = `Lazy(${importer}, { ${opts.join(", ")} })`;
-		} else expr = `Lazy(${importer})`;
+		deps.push(createLazyDependencyDescriptor(lazy));
+		lazySet.add(createClassKey(lazy.importPath, lazy.exportName));
+	}
+}
+function appendDependenciesFromManifestV2(svc, deps, referencedImports, metasByName, resolver, lazySet) {
+	for (const dep of svc.deps) appendV2Dependency(dep, svc.importPath, deps, referencedImports, metasByName, resolver, lazySet);
+}
+function appendV2Dependency(dep, currentImportPath, deps, referencedImports, metasByName, resolver, lazySet) {
+	if (dep.kind === "class") {
+		deps.push(createClassOrTokenDependency(dep.exportName, currentImportPath, metasByName, resolver));
+		return;
+	}
+	if (dep.kind === "token") {
 		deps.push({
-			expression: expr,
-			referencedIdentifiers: [],
-			isLazy: true
+			expression: dep.exportName,
+			referencedIdentifiers: [dep.exportName],
+			isLazy: false
 		});
-		lazySet.add(createClassKey(lazy.importPath, lazy.exportName));
+		referencedImports.push({
+			name: dep.exportName,
+			path: dep.importPath,
+			originalName: dep.exportName
+		});
+		return;
 	}
-	const metadata = {
-		scope: svc.scope,
-		dependencies: deps
+	deps.push(createLazyDependencyDescriptor(dep));
+	lazySet.add(createClassKey(dep.importPath, dep.exportName));
+}
+function createClassOrTokenDependency(depName, currentImportPath, metasByName, resolver) {
+	const targetMeta = selectMetaForDep(metasByName, depName, currentImportPath);
+	if (targetMeta) {
+		const expression = resolver.resolve(targetMeta.className, targetMeta.filePath);
+		return {
+			expression,
+			referencedIdentifiers: [expression],
+			isLazy: false
+		};
+	}
+	return {
+		expression: depName,
+		referencedIdentifiers: [depName],
+		isLazy: false
 	};
+}
+function createLazyDependencyDescriptor(lazy) {
+	const importer = `() => import('${lazy.importPath}').then(m => m.${lazy.exportName})`;
+	let expression = `Lazy(${importer})`;
+	if (lazy.retry) {
+		const opts = [`retries: ${lazy.retry.retries}`];
+		if (typeof lazy.retry.backoffMs === "number") opts.push(`backoffMs: ${lazy.retry.backoffMs}`);
+		if (typeof lazy.retry.factor === "number") opts.push(`factor: ${lazy.retry.factor}`);
+		expression = `Lazy(${importer}, { ${opts.join(", ")} })`;
+	}
 	return {
-		className: svc.exportName,
-		filePath: svc.importPath,
-		identifierKey: svc.symbolKey,
-		metadata,
-		referencedImports
+		expression,
+		referencedIdentifiers: [],
+		isLazy: true
 	};
 }
 /**
@@ -200,12 +289,22 @@ function augmentFactoryLazyServices(metas, lazyServiceKeys) {
 * Returns structured info for error reporting.
 */
 function findDuplicateManifestServices(localMetas, manifestServices) {
-	const discoveredNames = new Set(localMetas.map((m) => m.className));
-	return manifestServices.filter((svc) => discoveredNames.has(svc.exportName)).map((d) => ({
-		exportName: d.exportName,
-		localPaths: localMetas.filter((m) => m.className === d.exportName).map((m) => normalizeImportPath(m.filePath)),
-		manifestImport: d.importPath
-	}));
+	const localMetasByIdentifier = /* @__PURE__ */ new Map();
+	for (const meta of localMetas) {
+		const identifierKey = meta.identifierKey ?? createSymbolKey(meta.filePath, meta.className);
+		const matches = localMetasByIdentifier.get(identifierKey) ?? [];
+		matches.push(meta);
+		localMetasByIdentifier.set(identifierKey, matches);
+	}
+	return manifestServices.flatMap((svc) => {
+		const matches = localMetasByIdentifier.get(svc.symbolKey);
+		if (!matches?.length) return [];
+		return [{
+			exportName: svc.exportName,
+			localPaths: matches.map((m) => normalizeImportPath(m.filePath)),
+			manifestImport: svc.importPath
+		}];
+	});
 }
 //#endregion
 export { augmentFactoryLazyServices, collectEagerReferencedNames, findDuplicateManifestServices, groupMetasByName, readManifests, reconcileLazySet, toMetaFromManifest };

package/dist/plugins/vite-plugin/visualization-utils.d.ts

@@ -0,0 +1,15 @@
+import { MermaidDiagramOptions } from "./visualizer.js";
+
+//#region src/plugins/vite-plugin/visualization-utils.d.ts
+interface AlloyMermaidVisualizerOptions extends MermaidDiagramOptions {
+  outputPath?: string;
+}
+interface AlloyVisualizationOptions {
+  /**
+   * Configure Mermaid diagram emission. Use `true` for defaults or provide
+   * overrides for layout, colors, or output path.
+   */
+  mermaid?: boolean | AlloyMermaidVisualizerOptions;
+}
+//#endregion
+export { AlloyMermaidVisualizerOptions, AlloyVisualizationOptions };

package/dist/plugins/vite-plugin/visualization-utils.js

@@ -0,0 +1,28 @@
+import path from "node:path";
+import fs from "node:fs";
+//#region src/plugins/vite-plugin/visualization-utils.ts
+const DEFAULT_MERMAID_FILENAME = "alloy-di.mmd";
+function resolveVisualizationOptions(input, projectRoot) {
+	if (!input) return null;
+	if (typeof input === "boolean") return {
+		outputPath: path.resolve(projectRoot, DEFAULT_MERMAID_FILENAME),
+		mermaidOptions: void 0
+	};
+	const mermaidConfig = input.mermaid;
+	if (!mermaidConfig) return null;
+	if (mermaidConfig === true) return {
+		outputPath: path.resolve(projectRoot, DEFAULT_MERMAID_FILENAME),
+		mermaidOptions: void 0
+	};
+	const { outputPath, ...rest } = mermaidConfig;
+	return {
+		outputPath: path.resolve(projectRoot, outputPath ?? "alloy-di.mmd"),
+		mermaidOptions: Object.keys(rest).length > 0 ? rest : void 0
+	};
+}
+function ensureDirectoryForFile(filePath) {
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+//#endregion
+export { ensureDirectoryForFile, resolveVisualizationOptions };

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/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/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.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.0",
+  "version": "1.2.2",
   "description": "A compile-time dependency injection plugin for Vite",
   "keywords": [
     "dependency-injection",