alloy-di 0.1.0

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

@@ -0,0 +1,154 @@
+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 path from "node:path";
+import fs from "node:fs";
+
+//#region src/plugins/vite-plugin/index.ts
+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.");
+	return description;
+}
+/**
+* Creates the Alloy Vite plugin that statically discovers injectable classes
+* and exposes them through a virtual container module at build time.
+*/
+function alloy(options = {}) {
+	const virtualModuleId = "virtual:alloy-container";
+	const resolvedVirtualModuleId = "\0" + virtualModuleId;
+	const configuredProviderEntries = Array.from(options.providers ?? []);
+	const providerModuleRefs = [];
+	let resolvedRoot = process.cwd();
+	let packageName = "UNKNOWN_PACKAGE";
+	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);
+	};
+	return {
+		name: "vite-plugin-alloy",
+		configResolved(config) {
+			resolvedRoot = config.root ?? process.cwd();
+			try {
+				const pkgPath = path.resolve(resolvedRoot, "package.json");
+				const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+				if (typeof pkg.name === "string") packageName = pkg.name;
+			} catch {}
+			providerModuleRefs.length = 0;
+			for (const entry of configuredProviderEntries) {
+				const absPath = path.isAbsolute(entry) ? entry : path.resolve(resolvedRoot, entry);
+				providerModuleRefs.push({
+					absPath,
+					importPath: normalizeImportPath(absPath)
+				});
+			}
+		},
+		resolveId(id) {
+			if (id === virtualModuleId) return resolvedVirtualModuleId;
+		},
+		transform(code, id) {
+			if (!/\.(tsx?|ts)$/i.test(id) || id.endsWith(".d.ts")) return null;
+			if (id.includes("node_modules")) return null;
+			processUpdate(id, code);
+			return {
+				code,
+				map: null
+			};
+		},
+		handleHotUpdate(ctx) {
+			const file = ctx.file;
+			if (!ctx.modules.length) {
+				const removed = discovery.removeFile(file);
+				if (removed.previousMetas) for (const meta of removed.previousMetas) discoveredClasses.delete(createClassKey(meta.filePath, meta.className));
+				if (removed.previousLazyClassKeys) for (const key of removed.previousLazyClassKeys) lazyReferencedClassKeys.delete(key);
+			}
+			return ctx.modules;
+		},
+		buildStart() {
+			discovery.clear();
+			discoveredClasses.clear();
+			lazyReferencedClassKeys.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"));
+			} catch {}
+		},
+		async load(id) {
+			if (id !== resolvedVirtualModuleId) return;
+			const metas = Array.from(discoveredClasses.values());
+			for (const meta of metas) {
+				const normalizedMetaPath = normalizeImportPath(meta.filePath);
+				const trimmedNormalizedMetaPath = normalizedMetaPath.replace(/^\/+/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.replace(/^\/+/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;
+			});
+			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);
+			}
+			return code;
+		}
+	};
+}
+
+//#endregion
+export { alloy };

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

@@ -0,0 +1,213 @@
+import { createClassKey, createSymbolKey, normalizeImportPath } from "../core/utils.js";
+import { z } from "zod";
+
+//#region src/plugins/vite-plugin/manifest-utils.ts
+/**
+* Reads a list of manifest objects and returns aggregated service + provider module specifiers.
+*
+* @param inputs Direct manifest objects.
+* @returns Aggregated arrays of service descriptors and provider specifiers.
+*/
+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);
+	}
+	return Promise.resolve({
+		services,
+		providers,
+		loadedManifests
+	});
+}
+/**
+* Groups metas by class name to support resolving dependencies that reference classes with collisions.
+*
+* @param metas Metas to index.
+* @returns Map className -> list of metas sharing that name.
+*/
+function groupMetasByName(metas) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const m of metas) {
+		const list = byName.get(m.className) ?? [];
+		list.push(m);
+		byName.set(m.className, list);
+	}
+	return byName;
+}
+/**
+* Chooses the best meta for a dependency name when there are naming collisions.
+* Preference order:
+*  1. Exact unique match
+*  2. First meta from same package scope (prefix before first slash)
+*  3. Fallback to first candidate
+*/
+function selectMetaForDep(metasByName, depName, currentImportPath) {
+	const candidates = metasByName.get(depName);
+	if (!candidates || candidates.length === 0) return;
+	if (candidates.length === 1) return candidates[0];
+	const scopePrefix = currentImportPath.split("/")[0];
+	return candidates.find((c) => c.filePath.startsWith(scopePrefix)) ?? candidates[0];
+}
+/**
+* Converts a manifest service descriptor into a DiscoveredMeta ready for container codegen.
+* Handles:
+*  - Eager dependency identifier resolution (with aliasing)
+*  - Token dependencies inclusion
+*  - Generation of Lazy(...) expressions for lazyDeps (with optional retry config)
+*  - Recording lazy dependency keys into provided lazySet
+*
+* @param svc Manifest descriptor
+* @param metasByName Grouped metas for duplicate resolution
+* @param resolver Collision-aware identifier resolver
+* @param lazySet Target set tracking lazy-only class keys
+*/
+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 (Array.isArray(svc.tokenDeps)) for (const tok of svc.tokenDeps) {
+		deps.push({
+			expression: tok.exportName,
+			referencedIdentifiers: [tok.exportName],
+			isLazy: false
+		});
+		referencedImports.push({
+			name: tok.exportName,
+			path: tok.importPath,
+			originalName: tok.exportName
+		});
+	}
+	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({
+			expression: expr,
+			referencedIdentifiers: [],
+			isLazy: true
+		});
+		lazySet.add(createClassKey(lazy.importPath, lazy.exportName));
+	}
+	const metadata = {
+		scope: svc.scope,
+		dependencies: deps
+	};
+	return {
+		className: svc.exportName,
+		filePath: svc.importPath,
+		identifierKey: svc.symbolKey,
+		metadata,
+		referencedImports
+	};
+}
+/**
+* Extracts class names referenced eagerly (not wrapped in Lazy) from meta metadata blocks.
+* This allows distinguishing services that must remain in static import set.
+*
+* @param metas All metas to scan.
+* @returns Set of class names with at least one eager reference.
+*/
+function collectEagerReferencedNames(metas) {
+	const eager = /* @__PURE__ */ new Set();
+	for (const meta of metas) for (const dep of meta.metadata.dependencies) if (!dep.isLazy) for (const id of dep.referencedIdentifiers) eager.add(id);
+	return eager;
+}
+/**
+* Removes any service key from lazySet if the service is also referenced eagerly.
+* A service is only lazy-only if ALL references are lazy.
+*/
+function reconcileLazySet(metas, lazySet, eagerNames) {
+	for (const meta of metas) if (eagerNames.has(meta.className)) {
+		const key = createClassKey(meta.filePath, meta.className);
+		lazySet.delete(key);
+	}
+}
+/**
+* Adds a factory-lazy wrapper to services configured via plugin option `lazyServices`.
+* Injects a `factory: Lazy(() => import(...))` property into the metadata.
+* Safely skips metas already containing a factory property.
+*/
+function augmentFactoryLazyServices(metas, lazyServiceKeys) {
+	for (const m of metas) {
+		const identifierKey = m.identifierKey ?? createSymbolKey(m.filePath, m.className);
+		if (!lazyServiceKeys.has(identifierKey)) continue;
+		if (m.metadata.factory) continue;
+		const rawPath = m.filePath.startsWith("/@") ? m.filePath.slice(1) : m.filePath;
+		const importPath = !/^(\.|\/|[A-Za-z]:\\)/.test(rawPath) ? rawPath : normalizeImportPath(m.filePath);
+		const factoryExpr = `Lazy(() => import('${importPath.startsWith("/@") ? importPath.slice(1) : importPath}').then(m => m.${m.className}))`;
+		m.metadata.factory = {
+			expression: factoryExpr,
+			referencedIdentifiers: [],
+			isLazy: true
+		};
+	}
+}
+/**
+* Detects duplicate service registrations between locally discovered metas and ingested manifests.
+* 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
+	}));
+}
+
+//#endregion
+export { augmentFactoryLazyServices, collectEagerReferencedNames, findDuplicateManifestServices, groupMetasByName, readManifests, reconcileLazySet, toMetaFromManifest };

package/dist/rollup.d.ts

@@ -0,0 +1,2 @@
+import { alloy } from "./plugins/rollup-plugin/index.js";
+export { alloy, alloy as default };

package/dist/rollup.js

@@ -0,0 +1,7 @@
+import { alloy } from "./plugins/rollup-plugin/index.js";
+
+//#region src/rollup.ts
+var rollup_default = alloy;
+
+//#endregion
+export { alloy, rollup_default as default };

package/dist/runtime.d.ts

@@ -0,0 +1,7 @@
+import { Newable, Token, createToken } from "./lib/types.js";
+import { ServiceIdentifier, clearServiceIdentifierRegistry, getConstructorByIdentifier, getServiceIdentifier, registerServiceIdentifier } from "./lib/service-identifiers.js";
+import { Container } from "./lib/container.js";
+import { LAZY_IDENTIFIER, Lazy } from "./lib/lazy.js";
+import { Injectable, Singleton, assertDeps, dependenciesRegistry, deps } from "./lib/decorators.js";
+import { ProviderDefinitions, applyProviders, asClass, asLazyClass, asValue, defineProviders, lifecycle } from "./lib/providers.js";
+export { Container, Injectable, LAZY_IDENTIFIER, Lazy, type Lazy as LazyInterface, type Newable, type ProviderDefinitions, type ServiceIdentifier, Singleton, type Token, applyProviders, asClass, asLazyClass, asValue, assertDeps, clearServiceIdentifierRegistry, createToken, defineProviders, dependenciesRegistry, deps, getConstructorByIdentifier, getServiceIdentifier, lifecycle, registerServiceIdentifier };

package/dist/runtime.js

@@ -0,0 +1,8 @@
+import { createToken } from "./lib/types.js";
+import { LAZY_IDENTIFIER, Lazy } from "./lib/lazy.js";
+import { Injectable, Singleton, assertDeps, dependenciesRegistry, deps } from "./lib/decorators.js";
+import { clearServiceIdentifierRegistry, getConstructorByIdentifier, getServiceIdentifier, registerServiceIdentifier } from "./lib/service-identifiers.js";
+import { Container } from "./lib/container.js";
+import { applyProviders, asClass, asLazyClass, asValue, defineProviders, lifecycle } from "./lib/providers.js";
+
+export { Container, Injectable, LAZY_IDENTIFIER, Lazy, Singleton, applyProviders, asClass, asLazyClass, asValue, assertDeps, clearServiceIdentifierRegistry, createToken, defineProviders, dependenciesRegistry, deps, getConstructorByIdentifier, getServiceIdentifier, lifecycle, registerServiceIdentifier };

package/dist/test.d.ts

@@ -0,0 +1,50 @@
+import { Newable, Token, createToken } from "./lib/types.js";
+import { ServiceIdentifier } from "./lib/service-identifiers.js";
+import { Container } from "./lib/container.js";
+import { ProviderDefinitions } from "./lib/providers.js";
+import { MockOf } from "./lib/testing/mocking.js";
+import { vi } from "vitest";
+
+//#region src/test.d.ts
+interface OverrideSpec {
+  /** Class constructor instance overrides */
+  instances?: Array<[Newable<unknown>, unknown]>;
+  /** Token value overrides */
+  tokens?: Array<[Token<unknown>, unknown]>;
+}
+interface CreateTestContainerOptions {
+  overrides?: OverrideSpec;
+  autoMock?: boolean;
+  target?: Newable<unknown>;
+  providers?: ProviderDefinitions | ProviderDefinitions[];
+}
+interface TestContainerHandle {
+  container: Container;
+  get<T>(target: Newable<T> | ServiceIdentifier<T>): Promise<T>;
+  getIdentifier?<T>(ctor: Newable<T>): ServiceIdentifier<T>;
+  /** Retrieve a token value via a synthetic classless access */
+  getToken<T>(token: Token<T>): T;
+  /** Provide a token value into the container */
+  provideToken?<T>(token: Token<T>, value: T): void;
+  /** Placeholder restore hook (future phases may implement overlay stacks). */
+  restore(): void;
+  /** Retrieve a single class mock (if autoMock enabled). */
+  getMock?<T>(ctor: Newable<T>): MockOf<T> | undefined;
+  /** Retrieve multiple class mocks preserving tuple order. */
+  getMocks?<T extends readonly Newable<unknown>[]>(ctors: T): { [K in keyof T]: T[K] extends Newable<infer I> ? MockOf<I> | undefined : never };
+  /** Convenience: get a specific method spy from a mock. */
+  spyOf?<T>(ctor: Newable<T>, method: Extract<keyof T, string>): ReturnType<typeof vi.fn> | undefined;
+  /** Convenience: reset all mock spies (calls vi.fn().mockReset()). */
+  clearMockSpies?(): void;
+}
+/**
+ * Create a test-focused container with manual overrides.
+ * - Does not perform auto-mocking (Phase 2 will expand this).
+ */
+declare function createTestContainer(opts?: CreateTestContainerOptions | OverrideSpec): TestContainerHandle & {
+  getMock<T>(ctor: Newable<T>): MockOf<T> | undefined;
+  getMocks<T extends readonly Newable<unknown>[]>(ctors: T): { [K in keyof T]: T[K] extends Newable<infer I> ? MockOf<I> | undefined : never };
+  provideToken<T>(token: Token<T>, value: T): void;
+};
+//#endregion
+export { CreateTestContainerOptions, type MockOf, OverrideSpec, TestContainerHandle, createTestContainer, createToken };

package/dist/test.js

@@ -0,0 +1,67 @@
+import { createToken } from "./lib/types.js";
+import { Container } from "./lib/container.js";
+import { applyProviders } from "./lib/providers.js";
+import { restoreRegistry, snapshotRegistry } from "./lib/testing/registry.js";
+import { applyAutoMocks } from "./lib/testing/mocking.js";
+
+//#region src/test.ts
+/**
+* Create a test-focused container with manual overrides.
+* - Does not perform auto-mocking (Phase 2 will expand this).
+*/
+function createTestContainer(opts) {
+	const isLegacy = !!opts && !("autoMock" in opts) && !("target" in opts) && !("overrides" in opts);
+	const normalizedOpts = isLegacy ? { overrides: opts } : opts ?? {};
+	const overrides = normalizedOpts.overrides ?? (isLegacy ? opts : void 0);
+	const container = new Container();
+	const snapshot = snapshotRegistry();
+	if (normalizedOpts.providers) applyProviders(container, normalizedOpts.providers);
+	for (const [tok, value] of overrides?.tokens ?? []) container.provideValue(tok, value);
+	const overriddenCtors = new Set(overrides?.instances?.map(([c]) => c) ?? []);
+	for (const [ctor, instance] of overrides?.instances ?? []) container.overrideInstance(ctor, instance);
+	let mocks;
+	let lazyPatches;
+	if (normalizedOpts.autoMock && normalizedOpts.target) {
+		const auto = applyAutoMocks({
+			target: normalizedOpts.target,
+			container,
+			overridesCtors: overriddenCtors
+		});
+		mocks = auto.mocks;
+		lazyPatches = auto.lazyPatches;
+	}
+	return {
+		container,
+		get: (target) => typeof target === "symbol" ? container.getByIdentifier(target) : container.get(target),
+		getIdentifier: (ctor) => container.getIdentifier(ctor),
+		getToken: (token) => {
+			return container.getToken(token);
+		},
+		provideToken: (token, value) => {
+			container.provideValue(token, value);
+		},
+		getMock: (ctor) => {
+			return mocks?.get(ctor) ?? void 0;
+		},
+		getMocks: (ctors) => {
+			return ctors.map((c) => mocks?.get(c));
+		},
+		spyOf: (ctor, method) => {
+			return (mocks?.get(ctor))?.spies[method];
+		},
+		clearMockSpies: () => {
+			if (!mocks) return;
+			for (const [, m] of mocks) {
+				const spies = m.spies;
+				for (const key of Object.keys(spies)) spies[key].mockReset();
+			}
+		},
+		restore: () => {
+			for (const patch of lazyPatches ?? []) patch.lazy.importer = patch.originalImporter;
+			restoreRegistry(snapshot);
+		}
+	};
+}
+
+//#endregion
+export { createTestContainer, createToken };

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/alloy-container.d.ts","../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/transform-guards.test.ts"],"version":"5.9.3"}

package/dist/vite.d.ts

@@ -0,0 +1,2 @@
+import { AlloyPluginOptions, alloy } from "./plugins/vite-plugin/index.js";
+export { type AlloyPluginOptions, alloy, alloy as default };

package/dist/vite.js

@@ -0,0 +1,7 @@
+import { alloy } from "./plugins/vite-plugin/index.js";
+
+//#region src/vite.ts
+var vite_default = alloy;
+
+//#endregion
+export { alloy, vite_default as default };

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "alloy-di",
+  "version": "0.1.0",
+  "description": "A compile-time dependency injection plugin for Vite",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "rimraf dist && rolldown -c",
+    "dev": "rolldown -c rolldown.config.ts --watch",
+    "format": "prettier -u --write ./",
+    "format:check": "prettier -u --check ./",
+    "lint": "oxlint --fix --type-aware --config ./.oxlintrc.json .",
+    "lint:check": "oxlint --type-aware --config ./.oxlintrc.json .",
+    "test": "vitest --run",
+    "test:cover": "vitest --run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc -b . --noEmit"
+  },
+  "exports": {
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
+    },
+    "./rollup": {
+      "types": "./dist/rollup.d.ts",
+      "import": "./dist/rollup.js"
+    },
+    "./test": {
+      "types": "./dist/test.d.ts",
+      "import": "./dist/test.js"
+    }
+  },
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "di",
+    "dependency-injection",
+    "typescript"
+  ],
+  "author": "Mikael Selander",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.3.0",
+    "rimraf": "^6.1.0",
+    "rolldown": "1.0.0-beta.52",
+    "rolldown-plugin-dts": "^0.18.1"
+  },
+  "dependencies": {
+    "tslib": "^2.8.1",
+    "zod": "^4.1.13"
+  },
+  "peerDependencies": {
+    "vitest": ">=4.0.14 <5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  }
+}