alloy-di 1.0.0 → 1.2.0

package/README.md

@@ -5,6 +5,7 @@
 ## Highlights
 
 - **Build-time graph** – services, scopes, and dependencies are resolved while bundling, so runtime work stays minimal.
+- **Visualize your DI graph** – enable the Vite plugin’s `visualize` option to emit a Mermaid diagram (`./alloy-di.mmd` by default) that captures scopes, lazy edges, and tokens for easy review.
 - **First-class lazy loading** – use `Lazy()` or provider-based lazy registrations to keep optional features in separate chunks.
 - **Framework agnostic** – works anywhere Vite runs: React, Vue, Svelte, SSR, libraries, and plain TS apps.
 - **Type safe** – generates `serviceIdentifiers` and manifest declarations for precise inference.
@@ -54,6 +55,31 @@ pnpm add -D alloy-di
 
 Need manifests, providers, or testing utilities? See the docs site for complete guides.
 
+## Visualize your dependency graph
+
+Enable the Vite plugin’s `visualize` option to have Alloy emit a Mermaid diagram that reflects every discovered service, scope, lazy edge, and token. By default the graph is written to `./alloy-di.mmd`, but you can customize the output path, color palette, or layout direction to fit your workflow.
+
+```ts
+import { defineConfig } from "vite";
+import alloy from "alloy-di/vite";
+
+export default defineConfig({
+  plugins: [
+    alloy({
+      visualize: {
+        mermaid: {
+          outputPath: "./docs/di-graph.mmd",
+          direction: "TB",
+          includeLegend: false,
+        },
+      },
+    }),
+  ],
+});
+```
+
+Commit the artifact for PR reviews, or generate ad-hoc previews locally with any Mermaid-friendly tool (for example VS Code’s Mermaid extension, GitHub’s Markdown preview, or `npx @mermaid-js/mermaid-cli -i docs/di-graph.mmd -o graph.svg`). The diagram highlights scopes, lazy edges, factory nodes, and tokens so you can inspect DI wiring at a glance.
+
 ## Documentation
 
 - **Website**: https://alloy-di.dev (generated from `/docs`)

package/dist/lib/container.d.ts

@@ -2,7 +2,6 @@ import { Constructor, Newable, Token } from "./types.js";
 import { ServiceIdentifier } from "./service-identifiers.js";
 
 //#region src/lib/container.d.ts
-
 /**
  * Runtime dependency injection container used by generated modules and tests.
  *
@@ -10,12 +9,12 @@ import { ServiceIdentifier } from "./service-identifiers.js";
  * performs singleton caching, and supports token-based value providers.
  */
 declare class Container {
-  private singletons;
-  private pendingSingletons;
-  private instanceOverrides;
-  private metadataCache;
-  private valueProviders;
-  private factoryWarningCache;
+  private readonly singletons;
+  private readonly pendingSingletons;
+  private readonly instanceOverrides;
+  private readonly metadataCache;
+  private readonly valueProviders;
+  private readonly factoryWarningCache;
   /**
    * Resolve (and construct) the requested service.
    *

package/dist/lib/container.js

@@ -5,7 +5,6 @@ import { dependenciesRegistry } from "./decorators.js";
 import { DependencyResolutionError } from "./dependency-error.js";
 import { getConstructorByIdentifier, getServiceIdentifier } from "./service-identifiers.js";
 import { isDevEnvironment } from "./env-detection.js";
-
 //#region src/lib/container.ts
 function classifyDependency(value) {
 	if (isLazy(value)) return {
@@ -261,6 +260,5 @@ var Container = class {
 		return metadata;
 	}
 };
-
 //#endregion
-export { Container };
+export { Container };

package/dist/lib/decorators.d.ts

@@ -3,7 +3,6 @@ import { Lazy } from "./lazy.js";
 import { ServiceScope } from "./scope.js";
 
 //#region src/lib/decorators.d.ts
-
 /**
  * Resolve a declared dependency to the constructor parameter type expected by the service.
  *

package/dist/lib/decorators.js

@@ -1,5 +1,4 @@
 import { ServiceScope } from "./scope.js";
-
 //#region src/lib/decorators.ts
 /**
 * Global registry for service metadata used by the runtime container.
@@ -27,16 +26,16 @@ const dependenciesRegistry = /* @__PURE__ */ new Map();
 */
 function createDecoratorWithDeps(scope, depsOpt) {
 	if (typeof depsOpt === "function") {
-		const depsFn$1 = depsOpt;
+		const depsFn = depsOpt;
 		return (target) => {
 			dependenciesRegistry.set(target, {
 				scope,
-				dependencies: depsFn$1
+				dependencies: depsFn
 			});
 		};
 	}
-	const deps$1 = depsOpt;
-	const depsFn = () => deps$1;
+	const deps = depsOpt;
+	const depsFn = () => deps;
 	return (target) => {
 		dependenciesRegistry.set(target, {
 			scope,
@@ -121,6 +120,5 @@ function deps(...items) {
 function assertDeps(depsFn, klass) {
 	return klass;
 }
-
 //#endregion
-export { Injectable, Singleton, assertDeps, dependenciesRegistry, deps };
+export { Injectable, Singleton, assertDeps, dependenciesRegistry, deps };

package/dist/lib/dependency-error.js

@@ -1,6 +1,5 @@
 import { isConstructor, isToken } from "./types.js";
 import { isLazy } from "./lazy.js";
-
 //#region src/lib/dependency-error.ts
 function describeDependency(value) {
 	if (isConstructor(value)) return `constructor ${value.name || "<anonymous>"}`;
@@ -26,6 +25,5 @@ var DependencyResolutionError = class extends Error {
 		return `${this.message}\nResolution path: ${stackPath}${dependencyInfo}`;
 	}
 };
-
 //#endregion
-export { DependencyResolutionError };
+export { DependencyResolutionError };

package/dist/lib/env-detection.js

@@ -16,8 +16,7 @@ function readImportMetaEnvFromRuntime() {
 }
 function readProcessNodeEnv() {
 	if (typeof process === "undefined") return;
-	const nodeEnv = "development";
-	return typeof nodeEnv === "string" ? nodeEnv : void 0;
+	return "development";
 }
 function getImportMetaEnv(overrides) {
 	if (overrides?.importMetaEnv === null) return;
@@ -39,6 +38,5 @@ function isDevEnvironment(overrides) {
 	if (typeof importMetaEnv?.NODE_ENV === "string") return importMetaEnv.NODE_ENV !== "production";
 	return true;
 }
-
 //#endregion
-export { isDevEnvironment };
+export { isDevEnvironment };

package/dist/lib/lazy.js

@@ -13,6 +13,5 @@ function Lazy(importer, retry) {
 		retry
 	};
 }
-
 //#endregion
-export { LAZY_IDENTIFIER, Lazy, isLazy };
+export { LAZY_IDENTIFIER, Lazy, isLazy };

package/dist/lib/providers.d.ts

@@ -4,7 +4,6 @@ import { Lazy } from "./lazy.js";
 import { ServiceScope } from "./scope.js";
 
 //#region src/lib/providers.d.ts
-
 /**
  * Explicit lifecycle choices for providers. Mirrors decorator scopes but externalized.
  */

package/dist/lib/providers.js

@@ -2,7 +2,6 @@ import { ServiceScope } from "./scope.js";
 import { isConstructor } from "./types.js";
 import { Lazy } from "./lazy.js";
 import { dependenciesRegistry } from "./decorators.js";
-
 //#region src/lib/providers.ts
 /**
 * Hidden symbol used to attach lazy provider metadata to its placeholder constructor.
@@ -146,9 +145,9 @@ function applyProviders(container, definitions) {
 	detectProviderCycles(planEntries);
 	for (const definition of list) {
 		for (const valueProvider of definition.values ?? []) container.provideValue(valueProvider.token, valueProvider.value);
-		const registerService = (ctor, lifecycle$1, deps, factory) => {
+		const registerService = (ctor, lifecycle, deps, factory) => {
 			dependenciesRegistry.set(ctor, {
-				scope: lifecycle$1,
+				scope: lifecycle,
 				dependencies: normalizeDependencies(deps),
 				factory
 			});
@@ -161,6 +160,5 @@ function applyProviders(container, definitions) {
 		}
 	}
 }
-
 //#endregion
-export { applyProviders, asClass, asLazyClass, asValue, defineProviders, lifecycle };
+export { applyProviders, asClass, asLazyClass, asValue, defineProviders, lifecycle };

package/dist/lib/scope.js

@@ -3,6 +3,5 @@ const ServiceScope = {
 	SINGLETON: "singleton",
 	TRANSIENT: "transient"
 };
-
 //#endregion
-export { ServiceScope };
+export { ServiceScope };

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

@@ -1,7 +1,6 @@
 import { Constructor } from "./types.js";
 
 //#region src/lib/service-identifiers.d.ts
-
 /**
  * Symbol-based identifier used to resolve services in a minifier-safe way.
  * These identifiers never collide with minified constructor names and can be

package/dist/lib/service-identifiers.js

@@ -49,6 +49,5 @@ function clearServiceIdentifierRegistry() {
 	ctorToIdentifier = /* @__PURE__ */ new WeakMap();
 	identifierToCtor.clear();
 }
-
 //#endregion
-export { clearServiceIdentifierRegistry, getConstructorByIdentifier, getServiceIdentifier, registerServiceIdentifier };
+export { clearServiceIdentifierRegistry, getConstructorByIdentifier, getServiceIdentifier, registerServiceIdentifier };

package/dist/lib/testing/mocking.d.ts

@@ -5,9 +5,7 @@ import { vi } from "vitest";
 type MethodKeys<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
 /** Typed mock shape returned for class auto-mocking. */
 type MockOf<T> = Partial<T> & {
-  /** Map of method name -> vi spy function */
-  spies: Record<Extract<MethodKeys<T>, string>, ReturnType<typeof vi.fn>>;
-  /** Original constructor reference for introspection */
+  /** Map of method name -> vi spy function */spies: Record<Extract<MethodKeys<T>, string>, ReturnType<typeof vi.fn>>; /** Original constructor reference for introspection */
   __target: Newable<T>;
 };
 //#endregion

package/dist/lib/testing/mocking.js

@@ -2,7 +2,6 @@ import { isConstructor } from "../types.js";
 import { isLazy } from "../lazy.js";
 import { getRawDependencies } from "./registry.js";
 import { vi } from "vitest";
-
 //#region src/lib/testing/mocking.ts
 /** Create a lightweight auto-mock instance for a class constructor. */
 function mockClass(ctor) {
@@ -104,6 +103,5 @@ function buildMockCtorFrom(realCtor, mock) {
 	}
 	return MockCtor;
 }
-
 //#endregion
-export { applyAutoMocks };
+export { applyAutoMocks };

package/dist/lib/testing/registry.js

@@ -1,5 +1,4 @@
 import { dependenciesRegistry } from "../decorators.js";
-
 //#region src/lib/testing/registry.ts
 /** Take a deep(ish) snapshot of current dependency registry state. */
 function snapshotRegistry() {
@@ -14,6 +13,5 @@ function restoreRegistry(snapshot) {
 function getRawDependencies(target) {
 	return (dependenciesRegistry.get(target)?.dependencies ?? (() => []))();
 }
-
 //#endregion
-export { getRawDependencies, restoreRegistry, snapshotRegistry };
+export { getRawDependencies, restoreRegistry, snapshotRegistry };

package/dist/lib/types.js

@@ -16,6 +16,5 @@ function isConstructor(value) {
 	if (proto.constructor !== value) return false;
 	return true;
 }
-
 //#endregion
-export { createToken, isConstructor, isToken };
+export { createToken, isConstructor, isToken };

package/dist/plugins/core/codegen.js

@@ -1,10 +1,9 @@
 import { createClassKey, createSymbolKey, hashString, normalizeImportPath } from "./utils.js";
 import { IdentifierResolver } from "./identifier-resolver.js";
 import path from "node:path";
-
 //#region src/plugins/core/codegen.ts
 function escapeSingleQuotes(value) {
-	return value.replace(/'/g, "\\'");
+	return value.replaceAll("'", "\\'");
 }
 /**
 * Generates a unique export key for the service identifier map.
@@ -26,23 +25,22 @@ function resolveDependencyImports(metas) {
 	const importMap = /* @__PURE__ */ new Map();
 	const nameCounts = /* @__PURE__ */ new Map();
 	const getUniqueName = (name) => {
-		const count = nameCounts.get(name) || 0;
+		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) for (const ref of meta.referencedImports) {
-		if (ref.isTypeOnly) continue;
-		const dir = path.dirname(meta.filePath);
-		const normalizedPath = normalizeImportPath(ref.path.startsWith(".") ? path.resolve(dir, ref.path) : ref.path);
-		const key = `${normalizedPath}::${ref.originalName ?? "default"}`;
-		let resolved = importMap.get(key);
-		if (!resolved) {
-			resolved = {
+	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
-			};
-			importMap.set(key, resolved);
+			});
 		}
 	}
 	return {
@@ -54,9 +52,9 @@ function reconstructDependencyExpression(dep, rewriter, contextDir) {
 	let expr = dep.expression;
 	for (const ident of dep.referencedIdentifiers) {
 		const replacement = rewriter(ident);
-		if (replacement && replacement !== ident) expr = expr.replace(new RegExp(`\\b${ident}\\b`, "g"), replacement);
+		if (replacement && replacement !== ident) expr = expr.replaceAll(new RegExp(`\\b${ident}\\b`, "g"), replacement);
 	}
-	if (dep.isLazy) expr = expr.replace(/import\s*\(\s*(['"])(.+?)\1\s*\)/g, (match, quote, importPath) => {
+	if (dep.isLazy) expr = expr.replaceAll(/import\s*\(\s*(['"])(.+?)\1\s*\)/g, (match, quote, importPath) => {
 		if (importPath.startsWith(".")) return `import(${quote}${normalizeImportPath(path.resolve(contextDir, importPath))}${quote})`;
 		return match;
 	});
@@ -89,12 +87,25 @@ function reconstructOptionsText(meta, importMap) {
 	return `{ ${parts.join(", ")} }`;
 }
 function buildImportsAndRegistrations(metas, lazyReferencedClassKeys, hasProviderModules) {
-	const activeMetas = metas.filter((meta) => !lazyReferencedClassKeys.has(createClassKey(meta.filePath, meta.className)));
+	const activeMetas = filterActiveMetas(metas, lazyReferencedClassKeys);
 	const { dependencyImports, importMap } = resolveDependencyImports(activeMetas);
-	const resolver = new IdentifierResolver(activeMetas);
-	const resolvedImports = activeMetas.map((meta) => {
+	const resolvedRegistrations = enrichRegistrations(activeMetas, new IdentifierResolver(activeMetas), importMap);
+	const runtimeImports = computeRuntimeImports(resolvedRegistrations, hasProviderModules);
+	const runtimeImportStatement = formatRuntimeImportStatement(runtimeImports);
+	const stubsBlock = createStubBlock(dependencyImports, resolvedRegistrations, runtimeImports);
+	return {
+		runtimeImportStatement,
+		registrationsBlock: createRegistrationsBlock(buildRegistrationEntries(resolvedRegistrations)),
+		stubsBlock,
+		identifierExportBlock: createIdentifierExports(resolvedRegistrations)
+	};
+}
+function filterActiveMetas(metas, lazyReferencedClassKeys) {
+	return metas.filter((meta) => !lazyReferencedClassKeys.has(createClassKey(meta.filePath, meta.className)));
+}
+function enrichRegistrations(activeMetas, resolver, importMap) {
+	return activeMetas.map((meta) => {
 		const importName = resolver.resolve(meta.className, meta.filePath);
-		const isFactoryLazy = !!meta.metadata.factory;
 		const identifierConst = `${importName}Identifier`;
 		const exportKey = createIdentifierExportKey(meta, resolver);
 		const symbolDescription = meta.identifierKey ?? createSymbolDescription(meta);
@@ -102,53 +113,69 @@ function buildImportsAndRegistrations(metas, lazyReferencedClassKeys, hasProvide
 		return {
 			...meta,
 			importName,
-			isFactoryLazy,
+			isFactoryLazy: Boolean(meta.metadata.factory),
 			identifierConst,
 			exportKey,
 			symbolDescription,
 			optionsText
 		};
 	});
-	const needsLazyImport = activeMetas.some((m) => m.metadata.dependencies.some((d) => d.isLazy) || !!m.metadata.factory);
-	const runtimeImports = new Set(["Container", "dependenciesRegistry"]);
-	if (hasProviderModules) runtimeImports.add("applyProviders");
-	if (needsLazyImport) runtimeImports.add("Lazy");
-	if (resolvedImports.length) runtimeImports.add("registerServiceIdentifier");
-	const runtimeImportStatement = `\nimport { ${Array.from(runtimeImports).join(", ")} } from 'alloy-di/runtime';\n`;
-	const stubDeclarations = [];
+}
+function computeRuntimeImports(registrations, hasProviderModules) {
+	const imports = new Set(["Container", "dependenciesRegistry"]);
+	const needsLazyImport = registrations.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");
+	return imports;
+}
+function formatRuntimeImportStatement(imports) {
+	return `\nimport { ${Array.from(imports).join(", ")} } from 'alloy-di/runtime';\n`;
+}
+function createStubBlock(dependencyImports, registrations, runtimeImports) {
+	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.originalName === "default") stubDeclarations.push(`import ${dep.localName} from '${dep.importPath}';`);
-		else if (dep.originalName === "*") stubDeclarations.push(`import * as ${dep.localName} from '${dep.importPath}';`);
-		else if (dep.originalName && dep.originalName !== dep.localName) stubDeclarations.push(`import { ${dep.originalName} as ${dep.localName} } from '${dep.importPath}';`);
-		else stubDeclarations.push(`import { ${dep.localName} } from '${dep.importPath}';`);
+		statements.push(createDependencyImportStatement(dep));
 		importedNames.add(dep.localName);
 	}
-	for (const meta of resolvedImports) {
+	for (const meta of registrations) {
 		if (meta.isFactoryLazy) {
-			stubDeclarations.push(`class ${meta.importName} {}`);
+			statements.push(`class ${meta.importName} {}`);
 			continue;
 		}
 		if (importedNames.has(meta.importName)) continue;
-		const importPath = !/^(\/|[A-Za-z]:\\|\.|~)/.test(meta.filePath) && !meta.filePath.includes("\\") ? meta.filePath : normalizeImportPath(meta.filePath);
-		if (meta.importName === meta.className) stubDeclarations.push(`import { ${meta.className} } from '${importPath}';`);
-		else stubDeclarations.push(`import { ${meta.className} as ${meta.importName} } from '${importPath}';`);
+		statements.push(createServiceImportStatement(meta));
 		importedNames.add(meta.importName);
 	}
-	const registrationEntries = resolvedImports.map((m) => `  { ctor: ${m.importName}, meta: ${m.optionsText} }`).join(",\n");
-	const registrationsBlock = registrationEntries ? `const registrations = [\n${registrationEntries}\n];` : `const registrations = [];`;
-	const stubsBlock = stubDeclarations.length ? `${stubDeclarations.join("\n")}\n` : "";
-	const identifierDeclarations = resolvedImports.map((meta) => `const ${meta.identifierConst} = registerServiceIdentifier(${meta.importName}, Symbol.for('${escapeSingleQuotes(meta.symbolDescription)}'));`).join("\n");
-	const identifierExportEntries = resolvedImports.map((meta) => `  '${meta.exportKey}': ${meta.identifierConst}`).join(",\n");
-	return {
-		runtimeImportStatement,
-		registrationsBlock,
-		stubsBlock,
-		identifierDeclarations,
-		identifierExportBlock: resolvedImports.length ? `${identifierDeclarations}\n\nexport const serviceIdentifiers = {\n${identifierExportEntries}\n};\n` : `export const serviceIdentifiers = {};\n`
-	};
+	return statements.length ? `${statements.join("\n")}\n` : "";
+}
+function createDependencyImportStatement(dep) {
+	if (dep.originalName === "default") return `import ${dep.localName} from '${dep.importPath}';`;
+	if (dep.originalName === "*") return `import * as ${dep.localName} from '${dep.importPath}';`;
+	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 createServiceImportStatement(meta) {
+	const importPath = !/^(\/|[A-Za-z]:\\|\.|~)/.test(meta.filePath) && !meta.filePath.includes("\\") ? meta.filePath : normalizeImportPath(meta.filePath);
+	if (meta.importName === meta.className) return `import { ${meta.className} } from '${importPath}';`;
+	return `import { ${meta.className} as ${meta.importName} } from '${importPath}';`;
+}
+function buildRegistrationEntries(registrations) {
+	return registrations.map((m) => ({
+		ctorName: m.importName,
+		metaText: m.optionsText
+	}));
+}
+function createRegistrationsBlock(entries) {
+	if (!entries.length) return "const registrations = [];";
+	return `const registrations = [\n${entries.map((entry) => `  { ctor: ${entry.ctorName}, meta: ${entry.metaText} }`).join(",\n")}\n];`;
+}
+function createIdentifierExports(registrations) {
+	if (!registrations.length) return "export const serviceIdentifiers = {};\n";
+	return `${registrations.map((meta) => `const ${meta.identifierConst} = registerServiceIdentifier(${meta.importName}, Symbol.for('${escapeSingleQuotes(meta.symbolDescription)}'));`).join("\n")}\n\nexport const serviceIdentifiers = {\n${registrations.map((meta) => `  '${meta.exportKey}': ${meta.identifierConst}`).join(",\n")}\n};\n`;
 }
 /**
 * Generates the virtual container module code.
@@ -283,6 +310,5 @@ ${serviceIdentifiers}
 `;
 	}).join("\n");
 }
-
 //#endregion
-export { generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition };
+export { generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition };

package/dist/plugins/core/decorators.js

@@ -1,38 +1,60 @@
 import { ServiceScope } from "../../lib/scope.js";
 import ts from "typescript";
-
 //#region src/plugins/core/decorators.ts
-function extractRefs(node, sourceFile, identifiers) {
+function collectBindingIdentifiers(name, ignored) {
+	if (ts.isIdentifier(name)) {
+		ignored.add(name.text);
+		return;
+	}
+	name.elements.forEach((element) => {
+		if (ts.isOmittedExpression(element)) return;
+		collectBindingIdentifiers(element.name, ignored);
+	});
+}
+function isDynamicImportExpression(node) {
+	return node.expression.kind === ts.SyntaxKind.ImportKeyword;
+}
+function extractRefs(node, sourceFile, identifiers, ignored) {
 	if (ts.isPropertyAssignment(node)) {
-		extractRefs(node.initializer, sourceFile, identifiers);
-		if (ts.isComputedPropertyName(node.name)) extractRefs(node.name.expression, sourceFile, identifiers);
+		extractRefs(node.initializer, sourceFile, identifiers, ignored);
+		if (ts.isComputedPropertyName(node.name)) extractRefs(node.name.expression, sourceFile, identifiers, ignored);
 		return;
 	}
+	if (ts.isParameter(node)) {
+		collectBindingIdentifiers(node.name, ignored);
+		if (node.initializer) extractRefs(node.initializer, sourceFile, identifiers, ignored);
+		return;
+	}
+	if (ts.isPropertyAccessExpression(node)) {
+		if (ts.isCallExpression(node.expression) && isDynamicImportExpression(node.expression) && ts.isIdentifier(node.name)) ignored.add(node.name.text);
+	}
 	if (ts.isIdentifier(node)) {
-		identifiers.add(node.text);
+		if (!ignored.has(node.text)) identifiers.add(node.text);
 		return;
 	}
 	if (ts.isCallExpression(node)) {
 		const name = node.expression.getText(sourceFile);
 		if (name === "Lazy" || name.endsWith(".Lazy")) {
-			node.arguments.forEach((arg) => extractRefs(arg, sourceFile, identifiers));
+			node.arguments.forEach((arg) => extractRefs(arg, sourceFile, identifiers, ignored));
 			return;
 		}
 	}
-	ts.forEachChild(node, (n) => extractRefs(n, sourceFile, identifiers));
+	ts.forEachChild(node, (n) => extractRefs(n, sourceFile, identifiers, ignored));
 }
 function createDependencyDescriptor(node, sourceFile) {
 	const expression = node.getText(sourceFile);
 	const referencedIdentifiers = /* @__PURE__ */ new Set();
+	const ignoredIdentifiers = /* @__PURE__ */ new Set();
 	let isLazy = false;
 	if (ts.isCallExpression(node)) {
 		const callName = node.expression.getText(sourceFile);
 		if (callName === "Lazy" || callName.endsWith(".Lazy")) isLazy = true;
 	}
-	extractRefs(node, sourceFile, referencedIdentifiers);
+	extractRefs(node, sourceFile, referencedIdentifiers, ignoredIdentifiers);
 	return {
 		expression,
 		referencedIdentifiers: Array.from(referencedIdentifiers),
+		ignoredIdentifiers: ignoredIdentifiers.size ? Array.from(ignoredIdentifiers) : void 0,
 		isLazy
 	};
 }
@@ -85,6 +107,5 @@ function extractServiceMetadata(decoratorName, callExpression, sourceFile) {
 		dependencies
 	};
 }
-
 //#endregion
-export { extractServiceMetadata };
+export { extractServiceMetadata };

package/dist/plugins/core/discovery-store.js

@@ -1,5 +1,4 @@
 import { scanSource } from "./scanner.js";
-
 //#region src/plugins/core/discovery-store.ts
 /**
 * Maintains a per-file cache of discovered DI metadata, lazy references, and
@@ -73,6 +72,5 @@ function createDiscoveryStore(options = {}) {
 		clear
 	};
 }
-
 //#endregion
-export { createDiscoveryStore };
+export { createDiscoveryStore };

package/dist/plugins/core/identifier-resolver.js

@@ -1,5 +1,4 @@
 import { createAliasName } from "./utils.js";
-
 //#region src/plugins/core/identifier-resolver.ts
 var IdentifierResolver = class {
 	counts;
@@ -17,6 +16,5 @@ var IdentifierResolver = class {
 		return this.count(className) > 1 ? createAliasName(className, importPath) : className;
 	}
 };
-
 //#endregion
-export { IdentifierResolver };
+export { IdentifierResolver };