alloy-di 1.4.0 → 2.0.0

package/dist/plugins/core/scanner.js

@@ -1,4 +1,5 @@
 import { createClassKey, createSymbolKey } from "./utils.js";
+import { ServiceScope } from "../../lib/scope.js";
 import { extractServiceMetadata } from "./decorators.js";
 import { processLazyCall, resolveModuleSpecifierCandidates } from "./lazy.js";
 import fs from "node:fs";
@@ -41,17 +42,23 @@ function collectFileImports(sourceFile) {
 * discovery results: decorators require an `@` and lazy references require
 * the `Lazy` identifier.
 */
-function mayContainDiscoverableSyntax(code) {
-	return code.includes("@") || code.includes("Lazy");
+function shouldScanFactoryProviders(options) {
+	return options?.factoryProviders ?? true;
 }
-function scanSource(code, id) {
-	if (!mayContainDiscoverableSyntax(code)) return {
+function mayContainDiscoverableSyntax(code, options) {
+	return code.includes("@") || code.includes("Lazy") || shouldScanFactoryProviders(options) && code.includes("asFactory");
+}
+function scanSource(code, id, options) {
+	const scanFactoryProviders = shouldScanFactoryProviders(options);
+	if (!mayContainDiscoverableSyntax(code, options)) return {
 		metas: [],
-		lazyClassKeys: /* @__PURE__ */ new Set()
+		lazyClassKeys: /* @__PURE__ */ new Set(),
+		factoryProviders: []
 	};
 	const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.ESNext, true);
 	const discovered = /* @__PURE__ */ new Map();
 	const lazyRefs = /* @__PURE__ */ new Set();
+	const factoryProviders = [];
 	const fileImports = collectFileImports(sourceFile);
 	const decoratorResolutionCache = /* @__PURE__ */ new Map();
 	const visit = (node) => {
@@ -62,15 +69,72 @@ function scanSource(code, id) {
 			discovered,
 			decoratorResolutionCache
 		});
-		else if (ts.isCallExpression(node)) processLazyCall(node, id, sourceFile, lazyRefs);
+		else if (ts.isCallExpression(node)) {
+			processLazyCall(node, id, sourceFile, lazyRefs);
+			if (scanFactoryProviders) handleFactoryProviderCall(node, {
+				id,
+				sourceFile,
+				fileImports,
+				factoryProviders
+			});
+		}
 		ts.forEachChild(node, visit);
 	};
 	ts.forEachChild(sourceFile, visit);
 	return {
 		metas: Array.from(discovered.values()),
-		lazyClassKeys: lazyRefs
+		lazyClassKeys: lazyRefs,
+		factoryProviders
 	};
 }
+function handleFactoryProviderCall(node, context) {
+	if (!isAlloyRuntimeHelper(node.expression, "asFactory", context.fileImports)) return;
+	const tokenArg = node.arguments[0];
+	if (!tokenArg) return;
+	context.factoryProviders.push({
+		filePath: context.id,
+		tokenExpression: tokenArg.getText(context.sourceFile),
+		tokenLabel: createFactoryTokenLabel(tokenArg, context.sourceFile),
+		lifecycle: extractFactoryLifecycle(node.arguments[2])
+	});
+}
+function isAlloyRuntimeHelper(expression, helperName, fileImports) {
+	if (ts.isIdentifier(expression)) {
+		const importInfo = fileImports.get(expression.text);
+		return Boolean(importInfo && !importInfo.isTypeOnly && importInfo.path === ALLOY_RUNTIME_MODULE && (importInfo.originalName ?? expression.text) === helperName);
+	}
+	if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression)) {
+		const importInfo = fileImports.get(expression.expression.text);
+		return Boolean(importInfo && !importInfo.isTypeOnly && importInfo.path === ALLOY_RUNTIME_MODULE && importInfo.originalName === "*" && expression.name.text === helperName);
+	}
+	return false;
+}
+function createFactoryTokenLabel(tokenArg, sourceFile) {
+	if (ts.isIdentifier(tokenArg)) return tokenArg.text;
+	return tokenArg.getText(sourceFile);
+}
+function extractFactoryLifecycle(optionsArg) {
+	if (!optionsArg || !ts.isObjectLiteralExpression(optionsArg)) return ServiceScope.SINGLETON;
+	for (const prop of optionsArg.properties) {
+		if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+		if (prop.name.text !== "lifecycle") continue;
+		return lifecycleExpressionToScope(prop.initializer);
+	}
+	return ServiceScope.SINGLETON;
+}
+function lifecycleExpressionToScope(expression) {
+	if (ts.isStringLiteralLike(expression)) return expression.text;
+	if (ts.isCallExpression(expression)) {
+		const callTarget = expression.expression;
+		if (ts.isPropertyAccessExpression(callTarget) && (callTarget.name.text === "singleton" || callTarget.name.text === "transient")) return callTarget.name.text;
+	}
+	if (ts.isPropertyAccessExpression(expression)) {
+		const member = expression.name.text;
+		if (member === "SINGLETON") return ServiceScope.SINGLETON;
+		if (member === "TRANSIENT") return ServiceScope.TRANSIENT;
+	}
+	return ServiceScope.SINGLETON;
+}
 function handleClassDeclaration(node, context) {
 	if (!node.name) return;
 	const decoratorMatch = findServiceDecorator(node, context.sourceFile, context.fileImports, context.id, context.decoratorResolutionCache);

package/dist/plugins/core/utils.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 //#region src/plugins/core/utils.ts
 const WINDOWS_DRIVE_PATTERN = /^[A-Za-z]:[\\/]/;
 function normalizeImportPath(p) {

package/dist/plugins/core/visualization-utils.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 //#region src/plugins/core/visualization-utils.ts
 const DEFAULT_MERMAID_FILENAME = "alloy-di.mmd";
 function resolveVisualizationOptions(input, projectRoot) {

package/dist/plugins/core/visualizer.js

@@ -49,7 +49,7 @@ const RESERVED_IDENTIFIERS = new Set([
 * @param input - Discovered metadata, optional lazy keys, and rendering options.
 * @returns The rendered diagram plus simple counts useful for reporting.
 */
-function generateMermaidDiagram({ metas, lazyClassKeys, options, scopes }) {
+function generateMermaidDiagram({ metas, lazyClassKeys, factoryProviders, options, scopes }) {
 	const mergedOptions = {
 		...DEFAULT_OPTIONS,
 		...options,
@@ -69,6 +69,7 @@ function generateMermaidDiagram({ metas, lazyClassKeys, options, scopes }) {
 	const nodesByClassName = /* @__PURE__ */ new Map();
 	const nodesByFilePath = /* @__PURE__ */ new Map();
 	const tokenNodes = /* @__PURE__ */ new Map();
+	const factoryNodes = /* @__PURE__ */ new Map();
 	const nodeByMeta = /* @__PURE__ */ new Map();
 	metas.forEach((meta, index) => {
 		const key = createClassKey(meta.filePath, meta.className);
@@ -94,6 +95,7 @@ function generateMermaidDiagram({ metas, lazyClassKeys, options, scopes }) {
 		pathBucket.push(node);
 		nodesByFilePath.set(normalizedPath, pathBucket);
 	});
+	for (const provider of factoryProviders ?? []) ensureFactoryNode(factoryNodes, provider);
 	const edges = [];
 	const edgeKeys = /* @__PURE__ */ new Set();
 	metas.forEach((meta) => {
@@ -105,7 +107,7 @@ function generateMermaidDiagram({ metas, lazyClassKeys, options, scopes }) {
 			if (!identifiers.length) continue;
 			const targets = /* @__PURE__ */ new Map();
 			for (const ident of identifiers) {
-				const resolvedTargets = resolveTargetsForIdentifier(ident, dep.expression, meta, nodesByClassName, nodesByFilePath, tokenNodes);
+				const resolvedTargets = resolveTargetsForIdentifier(ident, dep.expression, meta, nodesByClassName, nodesByFilePath, tokenNodes, factoryNodes);
 				for (const target of resolvedTargets) {
 					if (target.id === sourceNode.id) continue;
 					targets.set(target.id, target);
@@ -140,10 +142,14 @@ function generateMermaidDiagram({ metas, lazyClassKeys, options, scopes }) {
 			lines.push(`  %% Scope stability: ⚠️ ${VIOLATION_EDGE_COLOR} edge = captive dependency (longer-lived service depends on shorter-lived scope)`);
 		}
 	}
-	const allNodes = [...serviceNodes, ...Array.from(tokenNodes.values())];
+	const allNodes = [
+		...serviceNodes,
+		...Array.from(factoryNodes.values()),
+		...Array.from(tokenNodes.values())
+	];
 	const groupedNodes = /* @__PURE__ */ new Map();
 	const ungroupedNodes = [];
-	for (const node of allNodes) if (node.type === "service" && node.scope && customScopes.has(node.scope)) {
+	for (const node of allNodes) if ((node.type === "service" || node.type === "factory") && node.scope && customScopes.has(node.scope)) {
 		const bucket = groupedNodes.get(node.scope) ?? [];
 		bucket.push(node);
 		groupedNodes.set(node.scope, bucket);
@@ -179,7 +185,8 @@ function generateMermaidDiagram({ metas, lazyClassKeys, options, scopes }) {
 		diagram: lines.join("\n"),
 		nodeCount: allNodes.length,
 		edgeCount: edges.length,
-		tokenCount: tokenNodes.size
+		tokenCount: tokenNodes.size,
+		factoryCount: factoryNodes.size
 	};
 }
 /**
@@ -216,12 +223,14 @@ function scopeCode(node) {
 }
 /**
 * True when an edge captures a shorter-lived dependency in a longer-lived host,
-* per the declared hierarchy. Only service-to-service edges with known scopes
-* are considered, and only when a custom hierarchy is configured.
+* per the declared hierarchy. Service dependencies on scoped factory providers
+* are checked too: factory bodies are opaque, but the factory result lifecycle
+* is known and can still be captive.
 */
 function isStabilityViolation(from, to, scopes) {
 	if (!scopes) return false;
-	if (from.type !== "service" || to.type !== "service") return false;
+	if (from.type !== "service") return false;
+	if (to.type !== "service" && to.type !== "factory") return false;
 	if (!from.scope || !to.scope) return false;
 	return !isDependencyAllowed(from.scope, to.scope, scopes);
 }
@@ -238,6 +247,7 @@ function describeEdge(from, to) {
 */
 function nodeFill(node, opts) {
 	if (node.type === "token") return `fill:${opts.tokenNodeFill}`;
+	if (node.type === "factory") return `fill:${opts.factoryNodeFill}`;
 	if (node.hasFactory) return `fill:${opts.factoryNodeFill}`;
 	if (node.isLazyOnly) return `fill:${opts.lazyNodeFill}`;
 	const scopeFill = node.scope ? opts.scopeColors[node.scope] : void 0;
@@ -278,14 +288,17 @@ function inferIdentifiersFromExpression(expression) {
 /**
 * Resolves a dependency identifier to known service nodes, or creates a token node when unresolved.
 */
-function resolveTargetsForIdentifier(identifier, fallbackExpression, meta, nodesByClassName, nodesByFilePath, tokenNodes) {
+function resolveTargetsForIdentifier(identifier, fallbackExpression, meta, nodesByClassName, nodesByFilePath, tokenNodes, factoryNodes) {
 	const serviceMatches = resolveServiceTargets(identifier, meta, nodesByClassName, nodesByFilePath);
 	if (serviceMatches.length) {
 		const deduped = /* @__PURE__ */ new Map();
 		for (const node of serviceMatches) deduped.set(node.id, node);
 		return Array.from(deduped.values());
 	}
-	return [ensureTokenNode(tokenNodes, createTokenLabel(identifier || fallbackExpression))];
+	const tokenLabel = createTokenLabel(identifier || fallbackExpression);
+	const factoryNode = factoryNodes.get(tokenLabel);
+	if (factoryNode) return [factoryNode];
+	return [ensureTokenNode(tokenNodes, tokenLabel)];
 }
 /**
 * Attempts to find service nodes that match an identifier via import metadata or class names.
@@ -340,6 +353,23 @@ function ensureTokenNode(tokenNodes, label) {
 	tokenNodes.set(label, node);
 	return node;
 }
+function ensureFactoryNode(factoryNodes, provider) {
+	const label = createTokenLabel(provider.tokenLabel || provider.tokenExpression);
+	const existing = factoryNodes.get(label);
+	if (existing) return existing;
+	const node = {
+		id: sanitizeMermaidId(`factory:${provider.filePath}:${provider.tokenExpression}`, factoryNodes.size),
+		label: `Factory: ${label}`,
+		key: label,
+		scope: provider.lifecycle,
+		type: "factory",
+		isLazyOnly: false,
+		hasFactory: true,
+		filePath: normalizeImportPath(provider.filePath)
+	};
+	factoryNodes.set(label, node);
+	return node;
+}
 /**
 * Condenses arbitrary strings into stable token labels, truncating overly long values.
 */

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

@@ -5,8 +5,8 @@ import { determineBuildMode, hasPreserveModules, resolveImportPathForBuild } fro
 import { parseExportedNames } from "./barrel-exports.js";
 import { createManifestDependency } from "./manifest-deps.js";
 import { checkPackageExports } from "./package-exports.js";
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 //#region src/plugins/rollup-plugin/index.ts
 /**
 * Rollup/Rolldown plugin that scans decorated Alloy services and emits an ESM manifest.
@@ -47,10 +47,8 @@ function alloy(options = {}) {
 		},
 		generateBundle(outputOptions) {
 			const buildMode = getBuildMode(outputOptions);
-			if (options.scopes && Object.keys(options.scopes).length > 0) {
-				validateScopesConfig(options.scopes);
-				validateScopeStability([...discovery.fileMetas.values()].flat(), options.scopes);
-			}
+			if (options.scopes && Object.keys(options.scopes).length > 0) validateScopesConfig(options.scopes);
+			validateScopeStability([...discovery.fileMetas.values()].flat(), options.scopes);
 			const services = [];
 			const missingExports = [];
 			const exportedNames = buildMode === "preserve-modules" ? /* @__PURE__ */ new Set() : parseExportedNames(discovery.fileSources);

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

@@ -1,39 +1,12 @@
-import { AlloyManifest } from "../core/types.js";
-import { AlloyScopesConfig } from "../core/scopes-validation.js";
-import { ServiceIdentifier } from "../../lib/service-identifiers.js";
 import { AlloyMermaidVisualizerOptions, AlloyVisualizationOptions } from "../core/visualization-utils.js";
+import { AlloyPluginOptions } from "../consumer-plugin.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;
-  /**
-   * Emit dependency graph artifacts. When `true`, writes a Mermaid diagram to
-   * `${projectRoot}/alloy-di.mmd`. Provide an object to customize output.
-   */
-  visualize?: boolean | AlloyVisualizationOptions;
-  /**
-   * Declares custom, application-defined scopes and their parent ordering, e.g.
-   * `{ session: { parent: 'singleton' }, request: { parent: 'session' } }`.
-   * Drives type-safe scope names (emitted into the generated declaration),
-   * runtime hierarchy registration, and build-time scope-stability validation.
-   */
-  scopes?: AlloyScopesConfig;
-}
 /**
  * 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 };
+export { alloy };

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

@@ -1,56 +1,28 @@
-import { normalizeImportPath, walkSync } from "../core/utils.js";
-import { resolveVisualizationOptions } from "../core/visualization-utils.js";
-import { loadVirtualContainerModule } from "../core/container-loader.js";
-import { createDiscoveryRuntime, isDiscoverableFile } from "../core/discovery-runtime.js";
+import { ALLOY_PLUGIN_OPTIONS, createConsumerPluginContext, isAlloyDiscoverableFile } from "../consumer-plugin.js";
 import { invalidateContainerModule } from "./module-invalidation.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;
-}
+const ALLOY_VITE_PLUGIN_OPTIONS = Symbol.for("alloy-di.vite-plugin-options");
 /**
 * 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 = "\0virtual:alloy-container";
-	const configuredProviderEntries = Array.from(options.providers ?? []);
-	const providerModuleRefs = [];
-	let resolvedRoot = process.cwd();
-	let packageName = "UNKNOWN_PACKAGE";
-	let resolvedVisualization = null;
-	let isDevMode;
-	const lazyServiceKeys = new Set((options.lazyServices ?? []).map(toLazyServiceKey));
-	const discoveryRuntime = createDiscoveryRuntime();
+	const context = createConsumerPluginContext(options);
 	return {
 		name: "vite-plugin-alloy",
 		enforce: "pre",
+		[ALLOY_VITE_PLUGIN_OPTIONS]: options,
+		[ALLOY_PLUGIN_OPTIONS]: options,
 		configResolved(config) {
-			resolvedRoot = config.root ?? process.cwd();
-			isDevMode = !config.isProduction;
-			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)
-				});
-			}
-			resolvedVisualization = resolveVisualizationOptions(options.visualize, resolvedRoot);
+			context.configure({
+				root: config.root ?? process.cwd(),
+				isDevMode: !config.isProduction
+			});
 		},
 		resolveId: {
 			filter: { id: { include: [/^virtual:alloy-container$/] } },
 			handler(id) {
-				if (id === virtualModuleId) return resolvedVirtualModuleId;
+				if (id === context.virtualModuleId) return context.resolvedVirtualModuleId;
 			}
 		},
 		transform: {
@@ -59,16 +31,16 @@ function alloy(options = {}) {
 				exclude: [/\.d\.ts$/i, /node_modules/]
 			} },
 			handler(code, id) {
-				discoveryRuntime.processUpdate(id, code);
+				context.processTransform(code, id);
 				return null;
 			}
 		},
 		async hotUpdate(ctx) {
 			if (this.environment.name !== "client") return;
 			const { file } = ctx;
-			if (!isDiscoverableFile(file)) return;
+			if (!isAlloyDiscoverableFile(file)) return;
 			let discoveryChanged;
-			if (ctx.type === "delete") discoveryChanged = discoveryRuntime.removeDiscoveredFile(file);
+			if (ctx.type === "delete") discoveryChanged = context.removeFile(file);
 			else {
 				let code;
 				try {
@@ -76,42 +48,24 @@ function alloy(options = {}) {
 				} catch {
 					return;
 				}
-				discoveryChanged = discoveryRuntime.processUpdate(file, code);
+				discoveryChanged = context.processFileUpdate(file, code);
 			}
 			if (!discoveryChanged) return;
-			invalidateContainerModule(ctx.server, resolvedVirtualModuleId);
+			invalidateContainerModule(ctx.server, context.resolvedVirtualModuleId);
 			this.environment.hot.send({ type: "full-reload" });
 			return [];
 		},
 		buildStart() {
-			discoveryRuntime.clear();
-			for (const ref of providerModuleRefs) this.addWatchFile(ref.absPath);
-			const files = walkSync(path.join(resolvedRoot, "src"));
-			for (const file of files) if (/\.(tsx?|ts)$/i.test(file) && !file.endsWith(".d.ts")) try {
-				const code = fs.readFileSync(file, "utf-8");
-				discoveryRuntime.processUpdate(file, code);
-			} catch {}
+			context.buildStart((file) => this.addWatchFile(file));
 		},
 		load: {
 			filter: { id: { include: [/^\0virtual:alloy-container$/] } },
 			async handler(id) {
-				if (id !== resolvedVirtualModuleId) return;
-				return loadVirtualContainerModule({
-					localMetas: Array.from(discoveryRuntime.discoveredClasses.values()),
-					lazyReferencedClassKeys: discoveryRuntime.lazyReferencedClassKeys,
-					manifests: options.manifests ?? [],
-					providerImportPaths: providerModuleRefs.map((ref) => ref.importPath),
-					lazyServiceKeys,
-					packageName,
-					resolvedRoot,
-					containerDeclarationDir: options.containerDeclarationDir,
-					resolvedVisualization,
-					isDevMode,
-					scopes: options.scopes
-				});
+				if (id !== context.resolvedVirtualModuleId) return;
+				return context.loadContainer();
 			}
 		}
 	};
 }
 //#endregion
-export { alloy };
+export { ALLOY_VITE_PLUGIN_OPTIONS, alloy };

package/dist/plugins/webpack-like-plugin.d.ts

@@ -0,0 +1,32 @@
+import { ALLOY_PLUGIN_OPTIONS, AlloyPluginOptions } from "./consumer-plugin.js";
+
+//#region src/plugins/webpack-like-plugin.d.ts
+interface TapHook {
+  tap?(name: string, handler: (...args: unknown[]) => unknown): void;
+  tapPromise?(name: string, handler: (...args: unknown[]) => Promise<unknown>): void;
+}
+interface WebpackLikeCompiler {
+  context?: string;
+  options?: {
+    context?: string;
+    mode?: string;
+    resolve?: {
+      alias?: Record<string, string | false | string[]> | {
+        name?: string;
+        alias?: string | false | string[];
+      }[];
+    };
+  };
+  hooks?: {
+    beforeCompile?: TapHook;
+    thisCompilation?: TapHook;
+    normalModuleFactory?: TapHook;
+  };
+}
+interface AlloyWebpackLikePlugin {
+  readonly name: string;
+  readonly [ALLOY_PLUGIN_OPTIONS]: AlloyPluginOptions;
+  apply(compiler: WebpackLikeCompiler): void;
+}
+//#endregion
+export { AlloyWebpackLikePlugin };

package/dist/plugins/webpack-like-plugin.js

@@ -0,0 +1,86 @@
+import { ALLOY_PLUGIN_OPTIONS, createConsumerPluginContext } from "./consumer-plugin.js";
+import path from "node:path";
+//#region src/plugins/webpack-like-plugin.ts
+function addDependency(deps, file) {
+	deps?.add(file);
+}
+function addContextDependency(deps, dir) {
+	deps?.add(dir);
+}
+function isObject(value) {
+	return Boolean(value) && typeof value === "object";
+}
+function isWebpackLikeNormalModuleFactory(value) {
+	return isObject(value) && isObject(value.hooks);
+}
+function isResolveRequest(value) {
+	return value === void 0 || isObject(value);
+}
+function isWebpackLikeCompilation(value) {
+	return isObject(value);
+}
+function createWebpackLikeAlloyPlugin(options, pluginOptions) {
+	const context = createConsumerPluginContext(options);
+	let cacheFilePath = "";
+	async function writeContainer() {
+		context.buildStart();
+		await context.writeContainerCache(cacheFilePath);
+	}
+	function configureAlias(compiler) {
+		compiler.options ??= {};
+		compiler.options.resolve ??= {};
+		const alias = compiler.options.resolve.alias;
+		if (Array.isArray(alias)) {
+			const existing = alias.find((entry) => entry.name === context.virtualModuleId);
+			if (existing) existing.alias = cacheFilePath;
+			else alias.push({
+				name: context.virtualModuleId,
+				alias: cacheFilePath
+			});
+			return;
+		}
+		compiler.options.resolve.alias = {
+			...alias,
+			[context.virtualModuleId]: cacheFilePath
+		};
+	}
+	function configureVirtualResolve(compiler) {
+		compiler.hooks?.normalModuleFactory?.tap?.(pluginOptions.name, (factory) => {
+			if (!isWebpackLikeNormalModuleFactory(factory)) return;
+			factory.hooks?.beforeResolve?.tap?.(pluginOptions.name, (request) => {
+				if (!isResolveRequest(request)) return;
+				const resolveRequest = request;
+				if (resolveRequest?.request === context.virtualModuleId) resolveRequest.request = cacheFilePath;
+			});
+		});
+	}
+	function configureLifecycleHooks(compiler) {
+		compiler.hooks?.beforeCompile?.tapPromise?.(pluginOptions.name, async () => {
+			await writeContainer();
+		});
+		compiler.hooks?.thisCompilation?.tap?.(pluginOptions.name, (compilation) => {
+			if (!isWebpackLikeCompilation(compilation)) return;
+			addDependency(compilation.fileDependencies, cacheFilePath);
+			for (const watchFile of context.getWatchFiles()) addDependency(compilation.fileDependencies, watchFile);
+			for (const watchRoot of context.getWatchDirectories()) addContextDependency(compilation.contextDependencies, watchRoot);
+		});
+	}
+	return {
+		name: pluginOptions.name,
+		[ALLOY_PLUGIN_OPTIONS]: options,
+		apply(compiler) {
+			const root = compiler.options?.context ?? compiler.context ?? process.cwd();
+			const isDevMode = compiler.options?.mode ? compiler.options.mode !== "production" : void 0;
+			context.configure({
+				root,
+				isDevMode
+			});
+			cacheFilePath = path.resolve(root, "node_modules/.cache/alloy-di", pluginOptions.cacheFileName);
+			configureAlias(compiler);
+			configureVirtualResolve(compiler);
+			configureLifecycleHooks(compiler);
+		}
+	};
+}
+//#endregion
+export { createWebpackLikeAlloyPlugin };

package/dist/rspack.d.ts

@@ -0,0 +1,7 @@
+import { AlloyPluginOptions } from "./plugins/consumer-plugin.js";
+import { AlloyWebpackLikePlugin } from "./plugins/webpack-like-plugin.js";
+
+//#region src/rspack.d.ts
+declare function alloy(options?: AlloyPluginOptions): AlloyWebpackLikePlugin;
+//#endregion
+export { type AlloyPluginOptions, alloy, alloy as default };

package/dist/rspack.js

@@ -0,0 +1,10 @@
+import { createWebpackLikeAlloyPlugin } from "./plugins/webpack-like-plugin.js";
+//#region src/rspack.ts
+function alloy(options = {}) {
+	return createWebpackLikeAlloyPlugin(options, {
+		name: "alloy-di-rspack",
+		cacheFileName: "rspack-virtual-container.js"
+	});
+}
+//#endregion
+export { alloy, alloy as default };

package/dist/runtime.d.ts

@@ -1,9 +1,9 @@
-import { Newable, Token, createToken } from "./lib/types.js";
-import { AlloyScopes, ResolutionContext, ServiceScope } from "./lib/scope.js";
+import { Constructor, Newable, Token, createToken, isConstructor, isToken } from "./lib/types.js";
 import { ServiceIdentifier, clearServiceIdentifierRegistry, getConstructorByIdentifier, getServiceIdentifier, registerServiceIdentifier } from "./lib/service-identifiers.js";
-import { Container } from "./lib/container.js";
+import { AlloyScopes, ResolutionContext, ServiceScope } from "./lib/scope.js";
+import { Container, FactoryFn } from "./lib/container.js";
 import { EnvDetectionOverrides, setEnvDetectionOverrides } from "./lib/env-detection.js";
-import { LAZY_IDENTIFIER, Lazy } from "./lib/lazy.js";
+import { LAZY_IDENTIFIER, Lazy, isLazy } 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 { type AlloyScopes, Container, type EnvDetectionOverrides, Injectable, LAZY_IDENTIFIER, Lazy, type Lazy as LazyInterface, type Newable, type ProviderDefinitions, type ResolutionContext, type ServiceIdentifier, ServiceScope, Singleton, type Token, applyProviders, asClass, asLazyClass, asValue, assertDeps, clearServiceIdentifierRegistry, createToken, defineProviders, dependenciesRegistry, deps, getConstructorByIdentifier, getServiceIdentifier, lifecycle, registerServiceIdentifier, setEnvDetectionOverrides };
+import { FactoryProviderDescriptor, ProviderDefinitions, applyProviders, asClass, asFactory, asLazyClass, asValue, defineProviders, lifecycle } from "./lib/providers.js";
+export { type AlloyScopes, type Constructor, Container, type EnvDetectionOverrides, type FactoryFn, type FactoryProviderDescriptor, Injectable, LAZY_IDENTIFIER, Lazy, type Lazy as LazyInterface, type Newable, type ProviderDefinitions, type ResolutionContext, type ServiceIdentifier, ServiceScope, Singleton, type Token, applyProviders, asClass, asFactory, asLazyClass, asValue, assertDeps, clearServiceIdentifierRegistry, createToken, defineProviders, dependenciesRegistry, deps, getConstructorByIdentifier, getServiceIdentifier, isConstructor, isLazy, isToken, lifecycle, registerServiceIdentifier, setEnvDetectionOverrides };

package/dist/runtime.js

@@ -1,9 +1,9 @@
 import { ServiceScope } from "./lib/scope.js";
-import { createToken } from "./lib/types.js";
-import { LAZY_IDENTIFIER, Lazy } from "./lib/lazy.js";
+import { createToken, isConstructor, isToken } from "./lib/types.js";
+import { LAZY_IDENTIFIER, Lazy, isLazy } 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 { setEnvDetectionOverrides } from "./lib/env-detection.js";
 import { Container } from "./lib/container.js";
-import { applyProviders, asClass, asLazyClass, asValue, defineProviders, lifecycle } from "./lib/providers.js";
-export { Container, Injectable, LAZY_IDENTIFIER, Lazy, ServiceScope, Singleton, applyProviders, asClass, asLazyClass, asValue, assertDeps, clearServiceIdentifierRegistry, createToken, defineProviders, dependenciesRegistry, deps, getConstructorByIdentifier, getServiceIdentifier, lifecycle, registerServiceIdentifier, setEnvDetectionOverrides };
+import { applyProviders, asClass, asFactory, asLazyClass, asValue, defineProviders, lifecycle } from "./lib/providers.js";
+export { Container, Injectable, LAZY_IDENTIFIER, Lazy, ServiceScope, Singleton, applyProviders, asClass, asFactory, asLazyClass, asValue, assertDeps, clearServiceIdentifierRegistry, createToken, defineProviders, dependenciesRegistry, deps, getConstructorByIdentifier, getServiceIdentifier, isConstructor, isLazy, isToken, lifecycle, registerServiceIdentifier, setEnvDetectionOverrides };