alloy-di 1.1.0 → 1.2.2

package/dist/plugins/core/lazy.js

@@ -1,7 +1,6 @@
 import { createClassKey } from "./utils.js";
 import ts from "typescript";
 import path from "path";
-
 //#region src/plugins/core/lazy.ts
 const RESOLVED_EXTENSIONS = [
 	"",
@@ -13,23 +12,69 @@ const RESOLVED_EXTENSIONS = [
 	".cts"
 ];
 function processLazyCall(node, fileId, sourceFile, localLazyRefs) {
-	if (node.expression.getText(sourceFile) !== "Lazy") return;
-	const classKeys = resolveLazyTarget(node, fileId);
-	if (classKeys) 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) {
-	if (node.arguments.length === 0) return;
-	const factory = node.arguments[0];
-	if (!(ts.isArrowFunction(factory) || ts.isFunctionExpression(factory))) return;
+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);
 	if (!body) return;
 	const importInfo = extractImportInfo(body);
-	if (!importInfo) return;
+	const exportName = importInfo?.exportName;
+	if (!importInfo || !exportName) return;
+	const retry = extractRetryOptions(node.arguments[1]);
 	const resolvedPaths = resolveModuleSpecifierCandidates(fileId, importInfo.specifier);
 	if (!resolvedPaths.length) return;
-	const exportName = importInfo.exportName;
-	if (!exportName) 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)) {
@@ -39,40 +84,37 @@ function getReturnedExpression(fn) {
 	return fn.body;
 }
 function extractImportInfo(expr) {
-	if (ts.isCallExpression(expr)) {
-		if (isDynamicImport(expr)) {
-			const spec = getImportSpecifier(expr.arguments[0]);
-			if (!spec) return;
-			return {
-				specifier: spec,
-				exportName: void 0
-			};
-		}
-		if (ts.isPropertyAccessExpression(expr.expression) && expr.expression.name.text === "then") {
-			const importCall = expr.expression.expression;
-			if (!ts.isCallExpression(importCall) || !isDynamicImport(importCall)) return;
-			const spec = getImportSpecifier(importCall.arguments[0]);
-			if (!spec) return;
-			const callback = expr.arguments[0];
-			return {
-				specifier: spec,
-				exportName: callback ? extractExportName(callback) : void 0
-			};
-		}
+	if (!ts.isCallExpression(expr)) return;
+	if (isDynamicImport(expr)) {
+		const spec = getImportSpecifier(expr.arguments[0]);
+		return spec ? { specifier: spec } : void 0;
 	}
+	if (!ts.isPropertyAccessExpression(expr.expression)) return;
+	if (expr.expression.name.text !== "then") return;
+	const importCall = expr.expression.expression;
+	if (!ts.isCallExpression(importCall) || !isDynamicImport(importCall)) return;
+	const spec = getImportSpecifier(importCall.arguments[0]);
+	if (!spec) return;
+	const callback = expr.arguments[0];
+	return {
+		specifier: spec,
+		exportName: callback ? extractExportName(callback) : void 0
+	};
 }
 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) {
-	if (!node) return;
-	if (ts.isStringLiteralLike(node)) return node.text;
+	return node && ts.isStringLiteralLike(node) ? node.text : void 0;
 }
 function extractExportName(callback) {
 	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
 		const body = getReturnedExpression(callback);
-		if (!body) return;
-		return extractExportNameFromExpression(body);
+		return body ? extractExportNameFromExpression(body) : void 0;
 	}
 	return extractExportNameFromExpression(callback);
 }
@@ -85,14 +127,10 @@ function resolveModuleSpecifierCandidates(fromId, specifier) {
 	if (!specifier.startsWith(".")) return [];
 	const baseDir = path.dirname(fromId);
 	const resolvedBase = path.resolve(baseDir, specifier);
-	const candidates = [];
-	if (Boolean(path.extname(resolvedBase))) candidates.push(resolvedBase);
-	else {
-		for (const ext of RESOLVED_EXTENSIONS) candidates.push(resolvedBase + ext);
-		for (const ext of RESOLVED_EXTENSIONS) candidates.push(path.join(resolvedBase, "index" + ext));
-	}
-	return candidates;
+	if (path.extname(resolvedBase)) return [resolvedBase];
+	const fileCandidates = RESOLVED_EXTENSIONS.map((ext) => resolvedBase + ext);
+	const indexCandidates = RESOLVED_EXTENSIONS.map((ext) => path.join(resolvedBase, `index${ext}`));
+	return [...fileCandidates, ...indexCandidates];
 }
-
 //#endregion
-export { processLazyCall };
+export { parseLazyDependencyExpression, processLazyCall, resolveModuleSpecifierCandidates };

package/dist/plugins/core/scanner.js

@@ -1,9 +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)) {
@@ -40,46 +41,16 @@ 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) || !node.name) {
-			if (ts.isCallExpression(node)) processLazyCall(node, id, sourceFile, lazyRefs);
-			ts.forEachChild(node, visit);
-			return;
-		}
-		const targetDecorator = (ts.getDecorators ? ts.getDecorators(node) : [])?.find((d) => {
-			if (!ts.isCallExpression(d.expression)) return false;
-			const name = d.expression.expression.getText(sourceFile);
-			return name.endsWith("Injectable") || name.endsWith("Singleton");
-		});
-		if (!targetDecorator || !ts.isCallExpression(targetDecorator.expression)) {
-			ts.forEachChild(node, visit);
-			return;
-		}
-		const decoratorName = targetDecorator.expression.expression.getText(sourceFile);
-		const className = node.name.getText(sourceFile);
-		const callExpression = targetDecorator.expression;
-		const metadata = extractServiceMetadata(decoratorName, callExpression, sourceFile);
-		const referencedImports = [];
-		const seenIdentifiers = /* @__PURE__ */ new Set();
-		for (const dep of metadata.dependencies) for (const ident of dep.referencedIdentifiers) {
-			if (seenIdentifiers.has(ident)) continue;
-			seenIdentifiers.add(ident);
-			const importInfo = fileImports.get(ident);
-			if (importInfo) referencedImports.push({
-				name: ident,
-				path: importInfo.path,
-				originalName: importInfo.originalName,
-				isTypeOnly: importInfo.isTypeOnly
-			});
-		}
-		const classKey = createClassKey(id, className);
-		discovered.set(classKey, {
-			className,
-			filePath: id,
-			identifierKey: createSymbolKey(id, className),
-			metadata,
-			referencedImports
+		if (ts.isClassDeclaration(node)) handleClassDeclaration(node, {
+			id,
+			sourceFile,
+			fileImports,
+			discovered,
+			decoratorResolutionCache
 		});
+		else if (ts.isCallExpression(node)) processLazyCall(node, id, sourceFile, lazyRefs);
 		ts.forEachChild(node, visit);
 	};
 	ts.forEachChild(sourceFile, visit);
@@ -88,6 +59,114 @@ function scanSource(code, id) {
 		lazyClassKeys: lazyRefs
 	};
 }
-
+function handleClassDeclaration(node, context) {
+	if (!node.name) return;
+	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);
+	const classKey = createClassKey(context.id, className);
+	context.discovered.set(classKey, {
+		className,
+		filePath: context.id,
+		identifierKey: createSymbolKey(context.id, className),
+		metadata,
+		referencedImports
+	});
+}
+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 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();
+	for (const dep of metadata.dependencies) for (const ident of dep.referencedIdentifiers) {
+		if (seen.has(ident)) continue;
+		seen.add(ident);
+		const importInfo = fileImports.get(ident);
+		if (!importInfo) continue;
+		referenced.push({
+			name: ident,
+			path: importInfo.path,
+			originalName: importInfo.originalName,
+			isTypeOnly: importInfo.isTypeOnly
+		});
+	}
+	return referenced;
+}
 //#endregion
-export { scanSource };
+export { scanSource };

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

@@ -1,8 +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;
   /**
@@ -11,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/core/utils.js

@@ -1,25 +1,24 @@
 import path from "node:path";
 import fs from "node:fs";
-
 //#region src/plugins/core/utils.ts
 const WINDOWS_DRIVE_PATTERN = /^[A-Za-z]:[\\/]/;
 function normalizeImportPath(p) {
 	const raw = p.trim();
-	if (!raw) return raw;
-	const startsWithSlash = raw.startsWith("/") || raw.startsWith("\\");
-	const startsWithDot = raw.startsWith(".");
-	const startsWithTilde = raw.startsWith("~");
-	const isWindowsDrive = WINDOWS_DRIVE_PATTERN.test(raw);
-	const containsBackslash = raw.includes("\\");
-	if (!startsWithSlash && !startsWithDot && !startsWithTilde && !isWindowsDrive && !containsBackslash) return raw;
-	let out = raw.replace(/\\/g, "/");
-	out = out.replace(/^\/+/g, "/");
-	if (!out.startsWith("/")) out = "/" + out;
-	return out;
+	if (!raw || isBareModuleSpecifier(raw)) return raw;
+	return ensureLeadingSlash(normalizeSlashes(raw));
+}
+function isBareModuleSpecifier(raw) {
+	return !raw.startsWith("/") && !raw.startsWith("\\") && !raw.startsWith(".") && !raw.startsWith("~") && !WINDOWS_DRIVE_PATTERN.test(raw) && !raw.includes("\\");
+}
+function normalizeSlashes(value) {
+	return value.replaceAll("\\", "/").replaceAll(/^\/+/g, "/");
+}
+function ensureLeadingSlash(value) {
+	return value.startsWith("/") ? value : `/${value}`;
 }
 function hashString(value) {
 	let hash = 0;
-	for (let i = 0; i < value.length; i++) hash = hash * 31 + value.charCodeAt(i) | 0;
+	for (let i = 0; i < value.length; i++) hash = Math.trunc(hash * 31 + value.charCodeAt(i));
 	return Math.abs(hash).toString(36);
 }
 function createClassKey(filePath, className) {
@@ -40,6 +39,5 @@ function walkSync(dir, fileList = []) {
 	});
 	return fileList;
 }
-
 //#endregion
-export { createAliasName, createClassKey, createSymbolKey, hashString, normalizeImportPath, walkSync };
+export { createAliasName, createClassKey, createSymbolKey, hashString, normalizeImportPath, walkSync };

package/dist/plugins/rollup-plugin/build-utils.js

@@ -1,6 +1,5 @@
 import { normalizeImportPath } from "../core/utils.js";
 import path from "node:path";
-
 //#region src/plugins/rollup-plugin/build-utils.ts
 /**
 * Determines build mode from Rollup/Rolldown output configuration + count of discovered services.
@@ -44,6 +43,5 @@ function resolveImportPathForBuild(targetPath, packageName, buildMode) {
 function hasPreserveModules(o) {
 	return typeof o === "object" && o !== null && "preserveModules" in o;
 }
-
 //#endregion
-export { determineBuildMode, hasPreserveModules, resolveImportPathForBuild };
+export { determineBuildMode, hasPreserveModules, resolveImportPathForBuild };

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

@@ -1,11 +1,40 @@
 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";
 import fs from "node:fs";
 import ts from "typescript";
-
 //#region src/plugins/rollup-plugin/index.ts
+/** Check if a node has the 'export' modifier */
+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");
@@ -52,9 +81,6 @@ function alloy(options = {}) {
 		if (!barrelEntry || !sourceText) return exportedNames;
 		const sf = ts.createSourceFile(barrelEntry, sourceText, ts.ScriptTarget.ESNext, true);
 		const names = /* @__PURE__ */ new Set();
-		const hasExportModifier = (node) => {
-			return !!(ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-		};
 		const visit = (node) => {
 			if (ts.isClassDeclaration(node) && node.name && hasExportModifier(node)) names.add(node.name.text);
 			if (ts.isVariableStatement(node) && hasExportModifier(node)) {
@@ -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);
-					}
-				}
-			}
-			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
-					});
+					const manifestDep = createManifestDependency(dep, meta, knownServiceNames, buildMode);
+					if (manifestDep) svc.deps.push(manifestDep);
 				}
 			}
-			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({
@@ -220,6 +249,5 @@ function checkPackageExports(packageJsonPath, manifestFileName) {
 		if (!hasIdentifiers) console.warn(`[alloy] Warning: service-identifiers.mjs is not exposed in package.json "exports". Consumers may not be able to access the generated identifiers helper.`);
 	} catch {}
 }
-
 //#endregion
-export { alloy };
+export { alloy as default };