alloy-di 1.2.0 → 1.2.3

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.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.3",
   "description": "A compile-time dependency injection plugin for Vite",
   "keywords": [
     "dependency-injection",