alloy-di 1.4.0 → 2.0.0

package/dist/lib/providers.d.ts

@@ -1,6 +1,6 @@
 import { Newable, Token } from "./types.js";
 import { ServiceScope } from "./scope.js";
-import { Container } from "./container.js";
+import { Container, FactoryFn } from "./container.js";
 import { Lazy } from "./lazy.js";
 
 //#region src/lib/providers.d.ts
@@ -56,11 +56,19 @@ interface LazyServiceProviderDescriptor<T = unknown> {
   lifecycle: ProviderLifecycle;
   deps?: DependenciesOption;
 }
+/** Descriptor for a token-bound factory provider with an explicit lifecycle. */
+interface FactoryProviderDescriptor<T = unknown> {
+  kind: "factory";
+  token: Token<T>;
+  factory: FactoryFn<T>;
+  lifecycle: ProviderLifecycle;
+}
 /** Aggregate provider definitions for batch application. */
 interface ProviderDefinitions {
   values?: ValueProviderDescriptor[];
   services?: ServiceProviderDescriptor[];
   lazyServices?: LazyPlaceholder[];
+  factories?: FactoryProviderDescriptor[];
 }
 /**
  * Identity helper for provider definition blocks.
@@ -76,6 +84,22 @@ declare function asClass<T extends Newable<unknown>>(useClass: T, options: {
   lifecycle: ProviderLifecycle;
   deps?: DependenciesOption;
 }): ServiceProviderDescriptor<T>;
+/**
+ * Create a factory provider: bind a token to a function executed at resolution
+ * time. Mirrors `asClass` — a token, a factory function, and a lifecycle.
+ *
+ * The factory receives the resolving context and may be async, so it can
+ * resolve its own dependencies. `singleton` caches the result on the root;
+ * `transient` re-runs on every resolution; a custom scope caches once per
+ * matching scope instance and disposes the result with it.
+ *
+ * @param token Token the produced value is bound to (its type checks `factory`'s return).
+ * @param factory Function invoked with the resolving context; may be async.
+ * @param options.lifecycle Lifecycle scope (singleton, transient, or a custom scope).
+ */
+declare function asFactory<T>(token: Token<T>, factory: FactoryFn<T>, options: {
+  lifecycle: ProviderLifecycle;
+}): FactoryProviderDescriptor<T>;
 /**
  * Convenience lifecycle helpers for fluent provider creation.
  */
@@ -108,4 +132,4 @@ declare function asLazyClass<T, const TDeps extends DependenciesOption>(importer
  */
 declare function applyProviders(container: Container, definitions: ProviderDefinitions | ProviderDefinitions[]): void;
 //#endregion
-export { ProviderDefinitions, applyProviders, asClass, asLazyClass, asValue, defineProviders, lifecycle };
+export { FactoryProviderDescriptor, ProviderDefinitions, applyProviders, asClass, asFactory, asLazyClass, asValue, defineProviders, lifecycle };

package/dist/lib/providers.js

@@ -34,6 +34,27 @@ function asClass(useClass, options) {
 	};
 }
 /**
+* Create a factory provider: bind a token to a function executed at resolution
+* time. Mirrors `asClass` — a token, a factory function, and a lifecycle.
+*
+* The factory receives the resolving context and may be async, so it can
+* resolve its own dependencies. `singleton` caches the result on the root;
+* `transient` re-runs on every resolution; a custom scope caches once per
+* matching scope instance and disposes the result with it.
+*
+* @param token Token the produced value is bound to (its type checks `factory`'s return).
+* @param factory Function invoked with the resolving context; may be async.
+* @param options.lifecycle Lifecycle scope (singleton, transient, or a custom scope).
+*/
+function asFactory(token, factory, options) {
+	return {
+		kind: "factory",
+		token,
+		factory,
+		lifecycle: options.lifecycle
+	};
+}
+/**
 * Convenience lifecycle helpers for fluent provider creation.
 */
 const lifecycle = {
@@ -145,6 +166,7 @@ function applyProviders(container, definitions) {
 	detectProviderCycles(planEntries);
 	for (const definition of list) {
 		for (const valueProvider of definition.values ?? []) container.provideValue(valueProvider.token, valueProvider.value);
+		for (const factoryProvider of definition.factories ?? []) container.provideFactory(factoryProvider.token, factoryProvider.factory, { lifecycle: factoryProvider.lifecycle });
 		const registerService = (ctor, lifecycle, deps, factory) => {
 			dependenciesRegistry.set(ctor, {
 				scope: lifecycle,
@@ -161,4 +183,4 @@ function applyProviders(container, definitions) {
 	}
 }
 //#endregion
-export { applyProviders, asClass, asLazyClass, asValue, defineProviders, lifecycle };
+export { applyProviders, asClass, asFactory, asLazyClass, asValue, defineProviders, lifecycle };

package/dist/lib/scope.d.ts

@@ -10,16 +10,36 @@ interface AlloyScopes {
   transient: true;
 }
 type ServiceScope = keyof AlloyScopes;
+/**
+ * A cached factory result tagged with the `generation` of the descriptor that
+ * produced it. A mismatch against the current descriptor's generation (after a
+ * factory is re-registered) makes the entry stale, so it is recomputed.
+ */
+interface FactoryCacheEntry {
+  generation: number;
+  value: unknown;
+}
+/** An in-flight factory resolution tagged with its descriptor generation. */
+interface FactoryPendingEntry {
+  generation: number;
+  promise: Promise<unknown>;
+}
 interface ResolutionContext {
   readonly scopeName: ServiceScope;
   getCached(target: Constructor): unknown;
+  hasCached(target: Constructor): boolean;
   setCached(target: Constructor, instance: unknown): void;
   getPending(target: Constructor): Promise<unknown> | undefined;
   setPending(target: Constructor, promise: Promise<unknown>): void;
   deletePending(target: Constructor): void;
   getProvider(tokenId: symbol): unknown;
   hasProvider(tokenId: symbol): boolean;
+  getFactoryValue(tokenId: symbol): FactoryCacheEntry | undefined;
+  setFactoryValue(tokenId: symbol, generation: number, value: unknown): void;
+  getFactoryPending(tokenId: symbol): FactoryPendingEntry | undefined;
+  setFactoryPending(tokenId: symbol, generation: number, promise: Promise<unknown>): void;
+  deleteFactoryPending(tokenId: symbol, generation: number): void;
   readonly parent: ResolutionContext | null;
 }
 //#endregion
-export { AlloyScopes, ResolutionContext, ServiceScope };
+export { AlloyScopes, FactoryCacheEntry, FactoryPendingEntry, ResolutionContext, ServiceScope };

package/dist/lib/types.d.ts

@@ -18,5 +18,7 @@ interface Token<T> {
 }
 /** Create a unique typed token for values or abstractions. */
 declare function createToken<T>(description?: string): Token<T>;
+declare function isToken(value: unknown): value is Token<unknown>;
+declare function isConstructor(value: unknown): value is Constructor;
 //#endregion
-export { Constructor, Newable, Token, createToken };
+export { Constructor, Newable, Token, createToken, isConstructor, isToken };

package/dist/plugins/consumer-plugin.d.ts

@@ -0,0 +1,40 @@
+import { ServiceIdentifier } from "../lib/service-identifiers.js";
+import { AlloyManifest } from "./core/types.js";
+import { AlloyScopesConfig } from "./core/scopes-validation.js";
+import { AlloyMermaidVisualizerOptions, AlloyVisualizationOptions } from "./core/visualization-utils.js";
+
+//#region src/plugins/consumer-plugin.d.ts
+interface AlloyPluginOptions {
+  providers?: string[];
+  /**
+   * Source directories to scan for decorated services before the virtual
+   * container is loaded. Relative paths are resolved against the project root.
+   * Defaults to ["src"].
+   */
+  sourceDirs?: 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;
+}
+declare const ALLOY_PLUGIN_OPTIONS: unique symbol;
+//#endregion
+export { ALLOY_PLUGIN_OPTIONS, AlloyPluginOptions };

package/dist/plugins/consumer-plugin.js

@@ -0,0 +1,101 @@
+import { normalizeImportPath, writeFileIfChanged } 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 { DEFAULT_SOURCE_DIRS, readPackageName, scanSourceDirectories, toLazyServiceKey } from "./core/generation-inputs.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/plugins/consumer-plugin.ts
+const ALLOY_PLUGIN_OPTIONS = Symbol.for("alloy-di.plugin-options");
+function createConsumerPluginContext(options = {}) {
+	const configuredProviderEntries = Array.from(options.providers ?? []);
+	const configuredSourceDirs = Array.from(options.sourceDirs ?? DEFAULT_SOURCE_DIRS);
+	const providerModuleRefs = [];
+	const lazyServiceKeys = new Set((options.lazyServices ?? []).map(toLazyServiceKey));
+	const discoveryRuntime = createDiscoveryRuntime();
+	let resolvedRoot = process.cwd();
+	let packageName = "UNKNOWN_PACKAGE";
+	let resolvedVisualization = null;
+	let isDevMode;
+	function configure(config = {}) {
+		resolvedRoot = config.root ?? process.cwd();
+		isDevMode = config.isDevMode;
+		packageName = readPackageName(resolvedRoot);
+		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);
+	}
+	async function loadContainer() {
+		return loadVirtualContainerModule({
+			localMetas: Array.from(discoveryRuntime.discoveredClasses.values()),
+			lazyReferencedClassKeys: discoveryRuntime.lazyReferencedClassKeys,
+			manifests: options.manifests ?? [],
+			providerImportPaths: providerModuleRefs.map((ref) => ref.importPath),
+			factoryProviders: shouldTrackFactoryProviders() ? Array.from(discoveryRuntime.factoryProvidersByFile.values()).flat() : [],
+			lazyServiceKeys,
+			packageName,
+			resolvedRoot,
+			containerDeclarationDir: options.containerDeclarationDir,
+			resolvedVisualization,
+			isDevMode,
+			scopes: options.scopes
+		});
+	}
+	function shouldTrackFactoryProviders() {
+		return Boolean(resolvedVisualization);
+	}
+	return {
+		options,
+		virtualModuleId: "virtual:alloy-container",
+		resolvedVirtualModuleId: "\0virtual:alloy-container",
+		get root() {
+			return resolvedRoot;
+		},
+		sourceDirs: configuredSourceDirs,
+		configure,
+		shouldTrackFactoryProviders,
+		processTransform(code, id) {
+			return discoveryRuntime.processUpdate(id, code, { factoryProviders: shouldTrackFactoryProviders() });
+		},
+		processFileUpdate(file, code) {
+			return discoveryRuntime.processUpdate(file, code, { factoryProviders: shouldTrackFactoryProviders() });
+		},
+		removeFile(file) {
+			return discoveryRuntime.removeDiscoveredFile(file);
+		},
+		buildStart(addWatchFile) {
+			discoveryRuntime.clear();
+			for (const ref of providerModuleRefs) {
+				addWatchFile?.(ref.absPath);
+				if (shouldTrackFactoryProviders()) try {
+					const code = fs.readFileSync(ref.absPath, "utf-8");
+					discoveryRuntime.processUpdate(ref.absPath, code, { factoryProviders: true });
+				} catch {}
+			}
+			scanSourceDirectories(discoveryRuntime, resolvedRoot, configuredSourceDirs, { factoryProviders: shouldTrackFactoryProviders() });
+		},
+		loadContainer,
+		async writeContainerCache(filePath) {
+			const result = await loadContainer();
+			fs.mkdirSync(path.dirname(filePath), { recursive: true });
+			return writeFileIfChanged(filePath, result.code);
+		},
+		getWatchFiles() {
+			return providerModuleRefs.map((ref) => ref.absPath);
+		},
+		getWatchDirectories() {
+			return configuredSourceDirs.map((sourceDir) => path.isAbsolute(sourceDir) ? sourceDir : path.resolve(resolvedRoot, sourceDir));
+		}
+	};
+}
+function isAlloyDiscoverableFile(file) {
+	return isDiscoverableFile(file);
+}
+//#endregion
+export { ALLOY_PLUGIN_OPTIONS, createConsumerPluginContext, isAlloyDiscoverableFile };

package/dist/plugins/core/codegen.js

@@ -171,7 +171,7 @@ function reconstructOptionsText(meta, importMap, serviceRenames) {
 		const expr = reconstructDependencyExpression(factory, () => "", path.dirname(meta.filePath));
 		parts.push(`factory: ${expr}`);
 	}
-	if (scope === "singleton") parts.push(`scope: 'singleton'`);
+	if (scope && scope !== "transient") parts.push(`scope: '${escapeSingleQuotes(scope)}'`);
 	if (dependencies && dependencies.length > 0) {
 		const depExprs = dependencies.map((dep) => {
 			return reconstructDependencyExpression(dep, (ident) => {
@@ -381,8 +381,8 @@ function generateContainerTypeDefinition(metas, pathResolver) {
 	for (const meta of metas) {
 		const importName = pool.claim(resolver.resolve(meta.className, meta.filePath));
 		const importPath = pathResolver(meta.filePath);
-		if (importName === meta.className) imports.push(`import { ${meta.className} } from '${importPath}';`);
-		else imports.push(`import { ${meta.className} as ${importName} } from '${importPath}';`);
+		if (importName === meta.className) imports.push(`  import { ${meta.className} } from '${importPath}';`);
+		else imports.push(`  import { ${meta.className} as ${importName} } from '${importPath}';`);
 		const exportKey = createIdentifierExportKey(meta, resolver);
 		interfaceMembers.push(`${exportKey}: ServiceIdentifier<${importName}>;`);
 	}

package/dist/plugins/core/container-loader.js

@@ -5,10 +5,29 @@ import { augmentFactoryLazyServices, collectEagerReferencedNames, findDuplicateM
 import { validateScopeStability, validateScopesConfig } from "./scopes-validation.js";
 import { generateMermaidDiagram } from "./visualizer.js";
 import { ensureDirectoryForFile } from "./visualization-utils.js";
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 //#region src/plugins/core/container-loader.ts
 async function loadVirtualContainerModule(options) {
+	const prepared = await prepareContainerData(options);
+	const code = generateContainerModule(prepared.metas, prepared.lazyClassKeys, prepared.providerImports, {
+		isDev: options.isDevMode,
+		scopes: options.scopes
+	});
+	writeDeclarationArtifacts({
+		metas: prepared.metas,
+		loadedManifests: prepared.loadedManifests,
+		resolvedRoot: options.resolvedRoot,
+		containerDeclarationDir: options.containerDeclarationDir,
+		scopes: options.scopes
+	});
+	writeVisualizationArtifact(prepared.metas, prepared.lazyClassKeys, options.factoryProviders, options.resolvedVisualization, options.scopes);
+	return {
+		code,
+		moduleType: "js"
+	};
+}
+async function prepareContainerData(options) {
 	const metas = options.localMetas.map((meta) => ({
 		...meta,
 		metadata: { ...meta.metadata }
@@ -33,19 +52,13 @@ async function loadVirtualContainerModule(options) {
 	const providerImports = Array.from(new Set([...options.providerImportPaths, ...manifestData.providers]));
 	reconcileLazySet(metas, lazyClassKeys, collectEagerReferencedNames(metas));
 	augmentFactoryLazyServices(metas, options.lazyServiceKeys);
-	if (options.scopes && Object.keys(options.scopes).length > 0) {
-		validateScopesConfig(options.scopes);
-		validateScopeStability(metas, options.scopes);
-	}
-	const code = generateContainerModule(metas, lazyClassKeys, providerImports, {
-		isDev: options.isDevMode,
-		scopes: options.scopes
-	});
-	writeTypeDefinitions(metas, loadedManifests, options.resolvedRoot, options.containerDeclarationDir, options.scopes);
-	writeVisualizationArtifact(metas, lazyClassKeys, options.resolvedVisualization, options.scopes);
+	if (options.scopes && Object.keys(options.scopes).length > 0) validateScopesConfig(options.scopes);
+	validateScopeStability(metas, options.scopes);
 	return {
-		code,
-		moduleType: "js"
+		metas,
+		loadedManifests,
+		lazyClassKeys,
+		providerImports
 	};
 }
 function assignIdentifierKeys(metas, packageName, resolvedRoot) {
@@ -70,13 +83,14 @@ function assertNoDuplicateManifestServices(metas, manifestServices) {
 		"Resolve by removing one source (local or manifest) to avoid ambiguous DI keys."
 	].join("\n"));
 }
-function writeTypeDefinitions(metas, loadedManifests, resolvedRoot, containerDeclarationDir, scopes) {
+function writeDeclarationArtifacts(options) {
+	const { metas, loadedManifests, resolvedRoot, containerDeclarationDir } = options;
 	const dtsDir = path.resolve(resolvedRoot, containerDeclarationDir ?? "./src");
 	const dtsContent = generateContainerTypeDefinition(metas, (filePath) => resolveDeclarationImportPath(dtsDir, filePath));
 	if (!fs.existsSync(dtsDir)) fs.mkdirSync(dtsDir, { recursive: true });
 	writeFileIfChanged(path.join(dtsDir, "alloy-container.d.ts"), dtsContent);
 	const scopeAugmentationPath = path.join(dtsDir, "alloy-scopes.d.ts");
-	const scopeAugmentation = generateScopeAugmentationDefinition(scopes ? Object.keys(scopes) : []);
+	const scopeAugmentation = generateScopeAugmentationDefinition(options.scopes ? Object.keys(options.scopes) : []);
 	if (scopeAugmentation) writeFileIfChanged(scopeAugmentationPath, scopeAugmentation);
 	else if (fs.existsSync(scopeAugmentationPath)) fs.rmSync(scopeAugmentationPath);
 	if (loadedManifests.length === 0) return;
@@ -93,11 +107,12 @@ function resolveDeclarationImportPath(dtsDir, filePath) {
 	if (!rel.startsWith(".")) rel = "./" + rel;
 	return rel;
 }
-function writeVisualizationArtifact(metas, lazyReferencedClassKeys, resolvedVisualization, scopes) {
+function writeVisualizationArtifact(metas, lazyReferencedClassKeys, factoryProviders, resolvedVisualization, scopes) {
 	if (!resolvedVisualization) return;
 	const artifact = generateMermaidDiagram({
 		metas,
 		lazyClassKeys: new Set(lazyReferencedClassKeys),
+		factoryProviders,
 		options: resolvedVisualization.mermaidOptions,
 		scopes
 	});
@@ -105,4 +120,4 @@ function writeVisualizationArtifact(metas, lazyReferencedClassKeys, resolvedVisu
 	writeFileIfChanged(resolvedVisualization.outputPath, `%% ${GENERATED_FILE_NOTICE}\n${artifact.diagram}\n`);
 }
 //#endregion
-export { loadVirtualContainerModule };
+export { loadVirtualContainerModule, prepareContainerData, writeDeclarationArtifacts };

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

@@ -34,31 +34,46 @@ function lazyKeysSignature(keys) {
 	if (!keys || keys.size === 0) return "";
 	return Array.from(keys).toSorted().join("|");
 }
+function factoryProvidersSignature(providers) {
+	return JSON.stringify((providers ?? []).map((provider) => ({
+		filePath: provider.filePath,
+		tokenExpression: provider.tokenExpression,
+		tokenLabel: provider.tokenLabel,
+		lifecycle: provider.lifecycle
+	})));
+}
 function createDiscoveryRuntime() {
 	const discovery = createDiscoveryStore();
 	const discoveredClasses = /* @__PURE__ */ new Map();
 	const lazyReferencedClassKeys = /* @__PURE__ */ new Set();
+	const factoryProvidersByFile = /* @__PURE__ */ new Map();
 	return {
 		discoveredClasses,
 		lazyReferencedClassKeys,
-		processUpdate(id, code) {
-			const { metas, lazyClassKeys, previousMetas, previousLazyClassKeys } = discovery.updateFile(id, code);
+		factoryProvidersByFile,
+		processUpdate(id, code, options) {
+			const trackFactoryProviders = options?.factoryProviders ?? true;
+			const { metas, lazyClassKeys, factoryProviders, previousMetas, previousLazyClassKeys, previousFactoryProviders } = discovery.updateFile(id, code, { factoryProviders: trackFactoryProviders });
 			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 metasSignature(previousMetas ?? []) !== metasSignature(metas) || lazyKeysSignature(previousLazyClassKeys) !== lazyKeysSignature(lazyClassKeys);
+			if (trackFactoryProviders && factoryProviders.length) factoryProvidersByFile.set(id, factoryProviders);
+			else factoryProvidersByFile.delete(id);
+			return metasSignature(previousMetas ?? []) !== metasSignature(metas) || lazyKeysSignature(previousLazyClassKeys) !== lazyKeysSignature(lazyClassKeys) || trackFactoryProviders && factoryProvidersSignature(previousFactoryProviders) !== factoryProvidersSignature(factoryProviders);
 		},
 		removeDiscoveredFile(file) {
 			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 Boolean(removed.previousMetas?.length || removed.previousLazyClassKeys?.size);
+			factoryProvidersByFile.delete(file);
+			return Boolean(removed.previousMetas?.length || removed.previousLazyClassKeys?.size || removed.previousFactoryProviders?.length);
 		},
 		clear() {
 			discovery.clear();
 			discoveredClasses.clear();
 			lazyReferencedClassKeys.clear();
+			factoryProvidersByFile.clear();
 		}
 	};
 }

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

@@ -19,6 +19,7 @@ function hashContent(code) {
 function createDiscoveryStore(options = {}) {
 	const fileMetas = /* @__PURE__ */ new Map();
 	const fileLazyRefs = /* @__PURE__ */ new Map();
+	const fileFactoryProviders = /* @__PURE__ */ new Map();
 	const fileContentHashes = /* @__PURE__ */ new Map();
 	const fileSources = options.trackSources ? /* @__PURE__ */ new Map() : void 0;
 	/**
@@ -28,28 +29,36 @@ function createDiscoveryStore(options = {}) {
 	* @param id - Module identifier or path.
 	* @param code - Current file contents to analyze.
 	*/
-	function updateFile(id, code) {
+	function updateFile(id, code, options) {
+		const scanFactoryProviders = options?.factoryProviders ?? true;
 		const previousMetas = fileMetas.get(id);
 		const previousLazyClassKeys = fileLazyRefs.get(id);
-		const contentHash = hashContent(code);
+		const previousFactoryProviders = fileFactoryProviders.get(id);
+		const contentHash = hashContent(`${scanFactoryProviders ? "factory:1" : "factory:0"}\0${code}`);
 		if (fileContentHashes.get(id) === contentHash) return {
 			metas: previousMetas ?? [],
 			lazyClassKeys: new Set(previousLazyClassKeys),
+			factoryProviders: previousFactoryProviders ?? [],
 			previousMetas,
-			previousLazyClassKeys
+			previousLazyClassKeys,
+			previousFactoryProviders
 		};
 		fileContentHashes.set(id, contentHash);
 		if (fileSources) fileSources.set(id, code);
-		const { metas, lazyClassKeys } = scanSource(code, id);
+		const { metas, lazyClassKeys, factoryProviders } = scanSource(code, id, { factoryProviders: scanFactoryProviders });
 		if (metas.length) fileMetas.set(id, metas);
 		else fileMetas.delete(id);
 		if (lazyClassKeys.size) fileLazyRefs.set(id, lazyClassKeys);
 		else fileLazyRefs.delete(id);
+		if (factoryProviders.length) fileFactoryProviders.set(id, factoryProviders);
+		else fileFactoryProviders.delete(id);
 		return {
 			metas,
 			lazyClassKeys,
+			factoryProviders,
 			previousMetas,
-			previousLazyClassKeys
+			previousLazyClassKeys,
+			previousFactoryProviders
 		};
 	}
 	/**
@@ -60,13 +69,16 @@ function createDiscoveryStore(options = {}) {
 	function removeFile(id) {
 		const previousMetas = fileMetas.get(id);
 		const previousLazyClassKeys = fileLazyRefs.get(id);
+		const previousFactoryProviders = fileFactoryProviders.get(id);
 		fileMetas.delete(id);
 		fileLazyRefs.delete(id);
+		fileFactoryProviders.delete(id);
 		fileContentHashes.delete(id);
 		if (fileSources) fileSources.delete(id);
 		return {
 			previousMetas,
-			previousLazyClassKeys
+			previousLazyClassKeys,
+			previousFactoryProviders
 		};
 	}
 	/**
@@ -75,12 +87,14 @@ function createDiscoveryStore(options = {}) {
 	function clear() {
 		fileMetas.clear();
 		fileLazyRefs.clear();
+		fileFactoryProviders.clear();
 		fileContentHashes.clear();
 		fileSources?.clear();
 	}
 	return {
 		fileMetas,
 		fileLazyRefs,
+		fileFactoryProviders,
 		fileSources,
 		updateFile,
 		removeFile,

package/dist/plugins/core/generation-inputs.js

@@ -0,0 +1,41 @@
+import { walkSync } from "./utils.js";
+import { createDiscoveryRuntime } from "./discovery-runtime.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/plugins/core/generation-inputs.ts
+const DEFAULT_SOURCE_DIRS = ["src"];
+function toLazyServiceKey(identifier) {
+	const description = identifier.description;
+	if (!description?.startsWith("alloy:")) throw new Error("[alloy] lazyServices entries must be serviceIdentifiers exported by Alloy manifests.");
+	return description;
+}
+function readPackageName(root) {
+	try {
+		const pkgPath = path.resolve(root, "package.json");
+		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+		if (typeof pkg.name === "string") return pkg.name;
+	} catch {}
+	return "UNKNOWN_PACKAGE";
+}
+function isSourceFile(file) {
+	return /\.tsx?$/i.test(file) && !file.endsWith(".d.ts");
+}
+function scanSourceDirectories(discoveryRuntime, root, sourceDirs = DEFAULT_SOURCE_DIRS, options) {
+	for (const sourceDir of sourceDirs) {
+		const files = walkSync(path.isAbsolute(sourceDir) ? sourceDir : path.resolve(root, sourceDir));
+		for (const file of files) {
+			if (!isSourceFile(file)) continue;
+			try {
+				const code = fs.readFileSync(file, "utf-8");
+				discoveryRuntime.processUpdate(file, code, options);
+			} catch {}
+		}
+	}
+}
+function createDiscoveryRuntimeForSourceDirs(root, sourceDirs = DEFAULT_SOURCE_DIRS, options) {
+	const discoveryRuntime = createDiscoveryRuntime();
+	scanSourceDirectories(discoveryRuntime, root, sourceDirs, options);
+	return discoveryRuntime;
+}
+//#endregion
+export { DEFAULT_SOURCE_DIRS, createDiscoveryRuntimeForSourceDirs, readPackageName, scanSourceDirectories, toLazyServiceKey };