alloy-di 0.1.0

package/dist/plugins/core/lazy.js

@@ -0,0 +1,98 @@
+import { createClassKey } from "./utils.js";
+import ts from "typescript";
+import path from "path";
+
+//#region src/plugins/core/lazy.ts
+const RESOLVED_EXTENSIONS = [
+	"",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".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);
+}
+function resolveLazyTarget(node, fileId) {
+	if (node.arguments.length === 0) return;
+	const factory = node.arguments[0];
+	if (!(ts.isArrowFunction(factory) || ts.isFunctionExpression(factory))) return;
+	const body = getReturnedExpression(factory);
+	if (!body) return;
+	const importInfo = extractImportInfo(body);
+	if (!importInfo) return;
+	const resolvedPaths = resolveModuleSpecifierCandidates(fileId, importInfo.specifier);
+	if (!resolvedPaths.length) return;
+	const exportName = importInfo.exportName;
+	if (!exportName) return;
+	return resolvedPaths.map((candidate) => createClassKey(candidate, exportName));
+}
+function getReturnedExpression(fn) {
+	if (ts.isBlock(fn.body)) {
+		for (const statement of fn.body.statements) if (ts.isReturnStatement(statement) && statement.expression) return statement.expression;
+		return;
+	}
+	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
+			};
+		}
+	}
+}
+function isDynamicImport(node) {
+	return node.expression.kind === ts.SyntaxKind.ImportKeyword;
+}
+function getImportSpecifier(node) {
+	if (!node) return;
+	if (ts.isStringLiteralLike(node)) return node.text;
+}
+function extractExportName(callback) {
+	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+		const body = getReturnedExpression(callback);
+		if (!body) return;
+		return extractExportNameFromExpression(body);
+	}
+	return extractExportNameFromExpression(callback);
+}
+function extractExportNameFromExpression(expr) {
+	if (ts.isPropertyAccessExpression(expr)) return expr.name.text;
+	if (ts.isIdentifier(expr)) return expr.text;
+	if (ts.isNewExpression(expr) && expr.expression) return extractExportNameFromExpression(expr.expression);
+}
+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;
+}
+
+//#endregion
+export { processLazyCall };

package/dist/plugins/core/scanner.js

@@ -0,0 +1,93 @@
+import { createClassKey, createSymbolKey } from "./utils.js";
+import { extractServiceMetadata } from "./decorators.js";
+import { processLazyCall } from "./lazy.js";
+import ts, { SyntaxKind } from "typescript";
+
+//#region src/plugins/core/scanner.ts
+function collectFileImports(sourceFile) {
+	const imports = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) if (ts.isImportDeclaration(statement) && statement.importClause && ts.isStringLiteral(statement.moduleSpecifier)) {
+		const path = statement.moduleSpecifier.text;
+		const clause = statement.importClause;
+		const isTypeOnly = clause.phaseModifier === SyntaxKind.TypeKeyword;
+		if (clause.name) imports.set(clause.name.text, {
+			path,
+			originalName: "default",
+			isTypeOnly
+		});
+		if (clause.namedBindings) {
+			if (ts.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) {
+				const localName = element.name.text;
+				const originalName = element.propertyName ? element.propertyName.text : localName;
+				const elementIsTypeOnly = isTypeOnly || element.isTypeOnly;
+				imports.set(localName, {
+					path,
+					originalName,
+					isTypeOnly: elementIsTypeOnly
+				});
+			}
+			else if (ts.isNamespaceImport(clause.namedBindings)) imports.set(clause.namedBindings.name.text, {
+				path,
+				originalName: "*",
+				isTypeOnly
+			});
+		}
+	}
+	return imports;
+}
+function scanSource(code, id) {
+	const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.ESNext, true);
+	const discovered = /* @__PURE__ */ new Map();
+	const lazyRefs = /* @__PURE__ */ new Set();
+	const fileImports = collectFileImports(sourceFile);
+	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
+		});
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(sourceFile, visit);
+	return {
+		metas: Array.from(discovered.values()),
+		lazyClassKeys: lazyRefs
+	};
+}
+
+//#endregion
+export { scanSource };

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

@@ -0,0 +1,44 @@
+import { ServiceScope } from "../../lib/scope.js";
+
+//#region src/plugins/core/types.d.ts
+
+interface ManifestServiceDescriptor {
+  exportName: string;
+  importPath: string;
+  /**
+   * Stable, unique key used to generate the ServiceIdentifier.
+   * Format: `alloy:<package-name>/<relative-path>#<ClassName>`
+   */
+  symbolKey: string;
+  scope: ServiceScope;
+  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;
+    };
+  }[];
+}
+interface AlloyManifest {
+  schemaVersion: number;
+  packageName: string;
+  buildMode: "preserve-modules" | "bundled" | "chunks";
+  services: ManifestServiceDescriptor[];
+  /** Optional provider module import specifiers (internal library-provided). */
+  providers?: string[];
+  diagnostics?: {
+    barrelFallback?: boolean;
+    duplicateServices?: string[];
+    missingExports?: string[];
+  };
+}
+//#endregion
+export { AlloyManifest };

package/dist/plugins/core/utils.js

@@ -0,0 +1,45 @@
+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;
+}
+function hashString(value) {
+	let hash = 0;
+	for (let i = 0; i < value.length; i++) hash = hash * 31 + value.charCodeAt(i) | 0;
+	return Math.abs(hash).toString(36);
+}
+function createClassKey(filePath, className) {
+	return `${filePath}::${className}`;
+}
+function createAliasName(className, filePath) {
+	return `${className}__${hashString(normalizeImportPath(filePath))}`;
+}
+function createSymbolKey(filePath, className) {
+	return `alloy:${normalizeImportPath(filePath)}#${className}`;
+}
+function walkSync(dir, fileList = []) {
+	if (!fs.existsSync(dir)) return fileList;
+	fs.readdirSync(dir).forEach((file) => {
+		const filePath = path.join(dir, file);
+		if (fs.statSync(filePath).isDirectory()) walkSync(filePath, fileList);
+		else fileList.push(filePath);
+	});
+	return fileList;
+}
+
+//#endregion
+export { createAliasName, createClassKey, createSymbolKey, hashString, normalizeImportPath, walkSync };

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

@@ -0,0 +1,49 @@
+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.
+* Logic: preserveModules wins first; otherwise if >1 service we treat as chunked; else bundled.
+*
+* @param preserveModules Whether the bundler output preserves modules (Rollup output.preserveModules).
+* @param discoveredServiceCount Total number of decorated Alloy services found during scanning.
+* @returns Resolved BuildMode used for import path derivation and manifest shape.
+*/
+function determineBuildMode(preserveModules, discoveredServiceCount) {
+	if (preserveModules) return "preserve-modules";
+	return !preserveModules && discoveredServiceCount > 1 ? "chunks" : "bundled";
+}
+/**
+* Derives the public import path for a source file based on build mode.
+*
+* Rules:
+*  - preserve-modules: subpath mirrors /src/ relative path with extension stripped.
+*  - chunks: base filename becomes the subpath (extension stripped).
+*  - bundled: all services accessible from the package root (no subpath suffix).
+*
+* @param targetPath Absolute filesystem path of the source file defining the service.
+* @param packageName NPM package name as resolved from library package.json.
+* @param buildMode Previously resolved build mode.
+* @returns Public import specifier consumers will use (e.g. `@scope/pkg/service-a`).
+*/
+function resolveImportPathForBuild(targetPath, packageName, buildMode) {
+	const normalized = normalizeImportPath(targetPath);
+	if (buildMode === "preserve-modules") {
+		const srcIndex = normalized.lastIndexOf("/src/");
+		if (srcIndex !== -1) {
+			let sub = normalized.slice(srcIndex + 5);
+			sub = sub.replace(/\.(tsx?|ts|js|jsx|mts|cts)$/i, "");
+			return `${packageName}/${sub}`;
+		}
+		return packageName;
+	}
+	if (buildMode === "chunks") return `${packageName}/${path.basename(targetPath).replace(/\.(tsx?|ts|js|jsx|mts|cts)$/i, "")}`;
+	return packageName;
+}
+function hasPreserveModules(o) {
+	return typeof o === "object" && o !== null && "preserveModules" in o;
+}
+
+//#endregion
+export { determineBuildMode, hasPreserveModules, resolveImportPathForBuild };

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

@@ -0,0 +1,30 @@
+//#region src/plugins/rollup-plugin/index.d.ts
+interface AlloyManifestPluginOptions {
+  /** Optional override for emitted filename. Defaults to 'alloy.manifest.mjs'. */
+  fileName?: string;
+  /** Relative or absolute path to package.json if not at cwd root. */
+  packageJsonPath?: string;
+  /**
+   * Optional list of provider module source paths to include in the manifest.
+   * These should be file paths within the library (e.g., 'src/providers.ts').
+   * In `preserveModules` builds, import specifiers will be derived and emitted
+   * so consumer apps can import and apply them automatically.
+   */
+  providers?: string[];
+}
+/**
+ * Rollup/Rolldown plugin that scans decorated Alloy services and emits an ESM manifest.
+ */
+interface MinimalRollupPlugin {
+  name: string;
+  transform?(code: string, id: string): unknown;
+  generateBundle?(outputOptions: unknown): void;
+  emitFile?(file: {
+    type: "asset";
+    fileName: string;
+    source: string;
+  }): void;
+}
+declare function alloy(options?: AlloyManifestPluginOptions): MinimalRollupPlugin;
+//#endregion
+export { alloy };

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

@@ -0,0 +1,225 @@
+import { ServiceScope } from "../../lib/scope.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
+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");
+	let packageName = "UNKNOWN_PACKAGE";
+	try {
+		const pkgRaw = fs.readFileSync(packageJsonFile, "utf8");
+		const pkg = JSON.parse(pkgRaw);
+		if (typeof pkg.name === "string") packageName = pkg.name;
+	} catch {}
+	const packageRoot = path.dirname(packageJsonFile);
+	const discovery = createDiscoveryStore({ trackSources: true });
+	/**
+	* Determines the build mode based on output options and discovered services.
+	*
+	* Build modes affect import path resolution:
+	* - `preserve-modules`: Each source file becomes a separate output module with subpath imports
+	* - `chunks`: Multiple services with chunked output (multi-entry)
+	* - `bundled`: All services bundled into a single entry point
+	*
+	* @param outputOptions - Rollup/Rolldown output configuration
+	* @returns Build mode identifier
+	*/
+	function getBuildMode(outputOptions) {
+		return determineBuildMode(hasPreserveModules(outputOptions) ? Boolean(outputOptions.preserveModules) : false, [...discovery.fileMetas.values()].reduce((acc, metas) => acc + metas.length, 0));
+	}
+	/**
+	* Parses the barrel export file (index.ts) to extract all publicly exported symbol names.
+	* Used in bundled/chunks modes to detect services that aren't properly exported.
+	*
+	* Looks for:
+	* - `export class Foo`
+	* - `export const bar`
+	* - `export function baz`
+	* - `export { Foo, Bar }`
+	*
+	* @returns Set of exported symbol names found in the barrel file
+	*/
+	function parseExportedNames() {
+		let exportedNames = /* @__PURE__ */ new Set();
+		const sources = discovery.fileSources;
+		if (!sources) return exportedNames;
+		const barrelEntry = [...sources.keys()].find((p) => /\/src\/index\.(tsx?|mts|cts)$/i.test(p)) ?? [...sources.keys()].find((p) => /\/index\.(tsx?|ts)$/i.test(p));
+		const sourceText = barrelEntry ? sources.get(barrelEntry) : void 0;
+		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)) {
+				for (const decl of node.declarationList.declarations) if (ts.isIdentifier(decl.name)) names.add(decl.name.text);
+			}
+			if (ts.isFunctionDeclaration(node) && node.name && hasExportModifier(node)) names.add(node.name.text);
+			if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) for (const el of node.exportClause.elements) names.add(el.name.text);
+			ts.forEachChild(node, visit);
+		};
+		ts.forEachChild(sf, visit);
+		exportedNames = names;
+		return exportedNames;
+	}
+	/**
+	* Resolves the public import path for a service based on build mode and source location.
+	*
+	* Resolution strategies:
+	* - `preserve-modules`: Derives subpath from /src/ directory structure
+	* - `chunks`: Uses base filename as subpath
+	* - `bundled`: Uses package root
+	*
+	* @param targetPath - Absolute path to source file
+	* @param buildMode - Current build mode
+	* @returns Public import specifier (e.g., "@myorg/pkg/subpath")
+	*/
+	function resolveImportPath(targetPath, buildMode) {
+		return resolveImportPathForBuild(targetPath, packageName, buildMode);
+	}
+	return {
+		name: "alloy-manifest",
+		transform(code, id) {
+			const isTS = /\.(tsx?|mts|cts)$/i.test(id);
+			const isDeclaration = id.endsWith(".d.ts");
+			if (!isTS || isDeclaration) return null;
+			discovery.updateFile(id, code);
+			return null;
+		},
+		generateBundle(outputOptions) {
+			const buildMode = getBuildMode(outputOptions);
+			const services = [];
+			const missingExports = [];
+			const exportedNames = buildMode === "preserve-modules" ? /* @__PURE__ */ new Set() : parseExportedNames();
+			for (const metas of discovery.fileMetas.values()) for (const meta of metas) {
+				const scope = meta.metadata.scope ?? ServiceScope.TRANSIENT;
+				const importPath = resolveImportPath(meta.filePath, buildMode);
+				let relPath = path.relative(packageRoot, meta.filePath);
+				if (path.sep === "\\") relPath = relPath.split(path.sep).join("/");
+				const symbolKey = `alloy:${packageName}/${relPath}#${meta.className}`;
+				services.push({
+					exportName: meta.className,
+					importPath,
+					symbolKey,
+					scope,
+					deps: [],
+					lazyDeps: []
+				});
+				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();
+			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
+					});
+				}
+			}
+			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,
+				packageName,
+				buildMode,
+				services,
+				diagnostics: {
+					barrelFallback: buildMode !== "preserve-modules",
+					missingExports: missingExports.length ? missingExports : void 0
+				}
+			};
+			const nameOccurrences = /* @__PURE__ */ new Map();
+			for (const svc of services) {
+				const arr = nameOccurrences.get(svc.exportName);
+				if (arr) arr.push(svc);
+				else nameOccurrences.set(svc.exportName, [svc]);
+			}
+			for (const arr of nameOccurrences.values()) if (arr.length > 1) {
+				if (!manifest.diagnostics) manifest.diagnostics = {};
+				const dup = manifest.diagnostics.duplicateServices ?? [];
+				for (const svc of arr) dup.push(`${svc.exportName}|${svc.importPath}`);
+				manifest.diagnostics.duplicateServices = dup;
+			}
+			const providerPaths = Array.isArray(options.providers) ? options.providers : [];
+			if (providerPaths.length) {
+				if (buildMode !== "preserve-modules") throw new Error("Alloy manifest plugin: 'providers' requires preserveModules=true to emit stable public import specifiers. Enable preserveModules in your library build, or expose provider modules via root exports and omit 'providers' here.");
+				const resolvedProviders = [];
+				for (const p of providerPaths) {
+					const spec = resolveImportPath(path.isAbsolute(p) ? p : path.resolve(process.cwd(), p), "preserve-modules");
+					resolvedProviders.push(spec);
+				}
+				manifest.providers = resolvedProviders;
+			}
+			const code = `// Generated Alloy manifest (v1)\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({
+					type: "asset",
+					fileName,
+					source: code
+				});
+				this.emitFile({
+					type: "asset",
+					fileName: "service-identifiers.mjs",
+					source: identifiersCode
+				});
+			} else try {
+				fs.writeFileSync(path.resolve(process.cwd(), fileName), code, "utf8");
+				fs.writeFileSync(path.resolve(process.cwd(), "service-identifiers.mjs"), identifiersCode, "utf8");
+			} catch {}
+			checkPackageExports(packageJsonFile, fileName);
+		}
+	};
+}
+function checkPackageExports(packageJsonPath, manifestFileName) {
+	try {
+		const pkgRaw = fs.readFileSync(packageJsonPath, "utf8");
+		const pkg = JSON.parse(pkgRaw);
+		if (!pkg.exports) return;
+		const exports = pkg.exports;
+		const hasManifest = Object.values(exports).some((e) => typeof e === "string" && e.includes(manifestFileName) || typeof e === "object" && e !== null && Object.values(e).some((v) => String(v).includes(manifestFileName)));
+		const hasIdentifiers = Object.values(exports).some((e) => typeof e === "string" && e.includes("service-identifiers.mjs") || typeof e === "object" && e !== null && Object.values(e).some((v) => String(v).includes("service-identifiers.mjs")));
+		if (!hasManifest) console.warn(`[alloy] Warning: ${manifestFileName} is not exposed in package.json "exports". Consumers may not be able to access the manifest.`);
+		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 };

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

@@ -0,0 +1,25 @@
+import { ServiceIdentifier } from "../../lib/service-identifiers.js";
+import { AlloyManifest } from "../core/types.js";
+import { Plugin } from "vite";
+
+//#region src/plugins/vite-plugin/index.d.ts
+interface AlloyPluginOptions {
+  providers?: string[];
+  /** Optional list of manifest objects to ingest */
+  manifests?: AlloyManifest[];
+  /** List of ServiceIdentifiers to mark as instantiation-lazy (adds factory Lazy wrapper) */
+  lazyServices?: ServiceIdentifier[];
+  /**
+   * Output directory for the generated `virtual-container.d.ts` file.
+   * Relative paths are resolved against the project root.
+   * Defaults to "./src".
+   */
+  containerDeclarationDir?: string;
+}
+/**
+ * Creates the Alloy Vite plugin that statically discovers injectable classes
+ * and exposes them through a virtual container module at build time.
+ */
+declare function alloy(options?: AlloyPluginOptions): Plugin;
+//#endregion
+export { AlloyPluginOptions, alloy };