alloy-di 1.3.0 → 1.4.0

package/README.md

@@ -1,6 +1,6 @@
 # alloy-di
 
-`alloy-di` is a compile-time dependency injection toolkit for Vite. It scans your TypeScript during build, generates a static container, and ships a tiny runtime so you get dependency injection without reflection overhead.
+`alloy-di` is a build-time dependency injection toolkit for Vite. It scans your TypeScript during build, generates a static container, and ships a tiny runtime so you get dependency injection without reflection overhead.
 
 ## Highlights
 

package/dist/lib/container.d.ts

@@ -1,4 +1,5 @@
 import { Constructor, Newable, Token } from "./types.js";
+import { ResolutionContext, ServiceScope } from "./scope.js";
 import { ServiceIdentifier } from "./service-identifiers.js";
 
 //#region src/lib/container.d.ts
@@ -8,13 +9,23 @@ import { ServiceIdentifier } from "./service-identifiers.js";
  * It stores metadata discovered at build time, resolves constructor dependencies,
  * performs singleton caching, and supports token-based value providers.
  */
-declare class Container {
+declare class Container implements ResolutionContext {
   private readonly singletons;
   private readonly pendingSingletons;
   private readonly instanceOverrides;
   private readonly metadataCache;
   private readonly valueProviders;
   private readonly factoryWarningCache;
+  private readonly scopeHierarchy;
+  readonly scopeName: ServiceScope;
+  readonly parent: ResolutionContext | null;
+  getCached(target: Constructor): unknown;
+  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;
   /**
    * Resolve (and construct) the requested service.
    *
@@ -23,6 +34,14 @@ declare class Container {
    */
   get<T>(target: Newable<T>): Promise<T>;
   get<T>(identifier: ServiceIdentifier<T>): Promise<T>;
+  /** @internal */
+  _registerScopeHierarchy(hierarchy: Record<string, string>): void;
+  /** @internal */
+  _validateScopeParent(childScope: ServiceScope, parentScope: ServiceScope): void;
+  /** @internal */
+  _resolveInContext<T>(target: Newable<T> | ServiceIdentifier<T>, context: ResolutionContext, options?: {
+    skipFactoryWarning?: boolean;
+  }): Promise<T>;
   /**
    * Provide a concrete instance override for a class constructor.
    * Used by test utilities to inject mocks/stubs without altering global metadata.
@@ -62,10 +81,8 @@ declare class Container {
    * @throws Error if a circular dependency is detected
    */
   private resolve;
-  /**
-   * Resolve a singleton service with caching and in-flight creation coalescing.
-   */
-  private resolveSingleton;
+  private findContextForScope;
+  private resolveCached;
   /**
    * Instantiate a class by resolving and injecting all declared dependencies.
    * Handles factory-lazy services by importing the real class before instantiation.

package/dist/lib/container.js

@@ -43,9 +43,51 @@ var Container = class {
 	metadataCache = /* @__PURE__ */ new Map();
 	valueProviders = /* @__PURE__ */ new Map();
 	factoryWarningCache = /* @__PURE__ */ new WeakSet();
+	scopeHierarchy = /* @__PURE__ */ new Map();
+	scopeName = ServiceScope.SINGLETON;
+	parent = null;
+	getCached(target) {
+		return this.singletons.get(target);
+	}
+	setCached(target, instance) {
+		this.singletons.set(target, instance);
+	}
+	getPending(target) {
+		return this.pendingSingletons.get(target);
+	}
+	setPending(target, promise) {
+		this.pendingSingletons.set(target, promise);
+	}
+	deletePending(target) {
+		this.pendingSingletons.delete(target);
+	}
+	getProvider(tokenId) {
+		return this.valueProviders.get(tokenId);
+	}
+	hasProvider(tokenId) {
+		return this.valueProviders.has(tokenId);
+	}
 	async get(targetOrIdentifier) {
 		if (typeof targetOrIdentifier === "symbol") return this.getByIdentifier(targetOrIdentifier);
-		return this.getByConstructor(targetOrIdentifier);
+		return this.getByConstructor(targetOrIdentifier, this);
+	}
+	/** @internal */
+	_registerScopeHierarchy(hierarchy) {
+		for (const [child, parent] of Object.entries(hierarchy)) this.scopeHierarchy.set(child, parent);
+	}
+	/** @internal */
+	_validateScopeParent(childScope, parentScope) {
+		const declaredParent = this.scopeHierarchy.get(childScope);
+		if (declaredParent && declaredParent !== parentScope) throw new Error(`[alloy] Invalid scope hierarchy construction: scope '${String(childScope)}' is declared with parent '${String(declaredParent)}', but was constructed with parent scope '${String(parentScope)}'.`);
+	}
+	/** @internal */
+	async _resolveInContext(target, context, options) {
+		if (typeof target === "symbol") {
+			const ctor = getConstructorByIdentifier(target);
+			if (!ctor) throw new Error(`No service registered for identifier ${target.description ?? target.toString()}`);
+			return this.getByConstructor(ctor, context, { skipFactoryWarning: true });
+		}
+		return this.getByConstructor(target, context, options);
 	}
 	/**
 	* Provide a concrete instance override for a class constructor.
@@ -69,7 +111,7 @@ var Container = class {
 	async getByIdentifier(identifier) {
 		const ctor = getConstructorByIdentifier(identifier);
 		if (!ctor) throw new Error(`No service registered for identifier ${identifier.description ?? identifier.toString()}`);
-		return this.getByConstructor(ctor, { skipFactoryWarning: true });
+		return this.getByConstructor(ctor, this, { skipFactoryWarning: true });
 	}
 	/**
 	* Register a concrete value for an injection token at runtime.
@@ -88,9 +130,9 @@ var Container = class {
 		if (!this.valueProviders.has(token.id)) throw new Error(`No provider registered for token ${token.description ?? String(token.id)}`);
 		return this.valueProviders.get(token.id);
 	}
-	async getByConstructor(target, options) {
+	async getByConstructor(target, context, options) {
 		if (!options?.skipFactoryWarning) this.maybeWarnFactoryLazyConstructorUsage(target);
-		return this.resolve(target, []);
+		return this.resolve(target, [], context);
 	}
 	maybeWarnFactoryLazyConstructorUsage(target) {
 		if (!isDevEnvironment()) return;
@@ -107,7 +149,7 @@ var Container = class {
 	* @returns Promise resolving to the service instance
 	* @throws Error if a circular dependency is detected
 	*/
-	async resolve(target, resolutionStack) {
+	async resolve(target, resolutionStack, context) {
 		const overridden = this.instanceOverrides.get(target);
 		if (overridden) return overridden;
 		if (resolutionStack.includes(target)) throw new DependencyResolutionError(`Circular dependency detected: ${[...resolutionStack.map((t) => t.name), target.name].join(" -> ")}`, {
@@ -117,26 +159,40 @@ var Container = class {
 		});
 		const metadata = this.getServiceMetadata(target);
 		const nextStack = [...resolutionStack, target];
-		if (metadata.scope === ServiceScope.SINGLETON) return this.resolveSingleton(target, metadata, nextStack);
-		return this.createInstance(target, metadata.dependencies, nextStack, metadata.factory);
+		const targetCtx = this.findContextForScope(metadata.scope, context);
+		if (metadata.scope === ServiceScope.SINGLETON) return this.resolveCached(target, metadata, nextStack, targetCtx);
+		if (metadata.scope === ServiceScope.TRANSIENT) return this.createInstance(target, metadata.dependencies, nextStack, metadata.factory, targetCtx);
+		if (targetCtx.scopeName === metadata.scope) return this.resolveCached(target, metadata, nextStack, targetCtx);
+		return this.createInstance(target, metadata.dependencies, nextStack, metadata.factory, targetCtx);
 	}
-	/**
-	* Resolve a singleton service with caching and in-flight creation coalescing.
-	*/
-	async resolveSingleton(target, metadata, resolutionStack) {
-		const cached = this.singletons.get(target);
+	findContextForScope(scope, startingContext) {
+		if (scope === ServiceScope.SINGLETON) {
+			let current = startingContext;
+			while (current.parent) current = current.parent;
+			return current;
+		}
+		if (scope === ServiceScope.TRANSIENT) return startingContext;
+		let current = startingContext;
+		while (current) {
+			if (current.scopeName === scope) return current;
+			current = current.parent;
+		}
+		return startingContext;
+	}
+	async resolveCached(target, metadata, resolutionStack, targetCtx) {
+		const cached = targetCtx.getCached(target);
 		if (cached) return cached;
-		const pending = this.pendingSingletons.get(target);
+		const pending = targetCtx.getPending(target);
 		if (pending) return await pending;
-		const creation = this.createInstance(target, metadata.dependencies, resolutionStack, metadata.factory).then((instance) => {
-			this.singletons.set(target, instance);
+		const creation = this.createInstance(target, metadata.dependencies, resolutionStack, metadata.factory, targetCtx).then((instance) => {
+			targetCtx.setCached(target, instance);
 			return instance;
 		});
-		this.pendingSingletons.set(target, creation);
+		targetCtx.setPending(target, creation);
 		try {
 			return await creation;
 		} finally {
-			this.pendingSingletons.delete(target);
+			targetCtx.deletePending(target);
 		}
 	}
 	/**
@@ -149,9 +205,9 @@ var Container = class {
 	* @param factory - Optional lazy factory to import the real class
 	* @returns Promise resolving to the instantiated service
 	*/
-	async createInstance(target, dependencies, resolutionStack, factory) {
+	async createInstance(target, dependencies, resolutionStack, factory, context) {
 		const ctor = factory ? await this.importWithRetry(factory, target, resolutionStack) : target;
-		return new ctor(...await Promise.all(dependencies.map((param) => this.resolveParam(param, ctor, resolutionStack))));
+		return new ctor(...await Promise.all(dependencies.map((param) => this.resolveParam(param, ctor, resolutionStack, context))));
 	}
 	/**
 	* Resolve a single dependency entry, handling lazies, tokens, and constructors.
@@ -163,7 +219,7 @@ var Container = class {
 	* @returns Promise resolving to the dependency instance
 	* @throws Error if dependency type is invalid
 	*/
-	async resolveParam(param, target, resolutionStack) {
+	async resolveParam(param, target, resolutionStack, context) {
 		const classification = classifyDependency(param);
 		if (!classification) {
 			const stackPath = this.formatStackPath(target, resolutionStack);
@@ -176,10 +232,10 @@ var Container = class {
 		switch (classification.kind) {
 			case "lazy": {
 				const depClass = await this.importWithRetry(classification.lazy, target, resolutionStack);
-				return this.resolve(depClass, resolutionStack);
+				return this.resolve(depClass, resolutionStack, context);
 			}
-			case "token": return this.resolveTokenLike(classification.token, target, resolutionStack);
-			case "constructor": return this.resolve(classification.ctor, resolutionStack);
+			case "token": return this.resolveTokenLike(classification.token, target, resolutionStack, context);
+			case "constructor": return this.resolve(classification.ctor, resolutionStack, context);
 		}
 		return classification;
 	}
@@ -238,8 +294,12 @@ var Container = class {
 	/**
 	* Resolve a token dependency via registered value providers.
 	*/
-	resolveTokenLike(tok, target, resolutionStack) {
-		if (this.valueProviders.has(tok.id)) return this.valueProviders.get(tok.id);
+	resolveTokenLike(tok, target, resolutionStack, context) {
+		let current = context;
+		while (current) {
+			if (current.hasProvider(tok.id)) return current.getProvider(tok.id);
+			current = current.parent;
+		}
 		const stackPath = this.formatStackPath(target, resolutionStack);
 		throw new DependencyResolutionError(`No provider registered for token ${tok.description ?? String(tok.id)} while resolving ${target.name}. Resolution stack: ${stackPath}`, {
 			target,

package/dist/lib/decorators.d.ts

@@ -1,6 +1,6 @@
 import { Newable, Token } from "./types.js";
-import { Lazy } from "./lazy.js";
 import { ServiceScope } from "./scope.js";
+import { Lazy } from "./lazy.js";
 
 //#region src/lib/decorators.d.ts
 /**

package/dist/lib/providers.d.ts

@@ -1,7 +1,7 @@
 import { Newable, Token } from "./types.js";
+import { ServiceScope } from "./scope.js";
 import { Container } from "./container.js";
 import { Lazy } from "./lazy.js";
-import { ServiceScope } from "./scope.js";
 
 //#region src/lib/providers.d.ts
 /**

package/dist/lib/scope.d.ts

@@ -1,8 +1,25 @@
+import { Constructor } from "./types.js";
+
 //#region src/lib/scope.d.ts
 declare const ServiceScope: {
   readonly SINGLETON: "singleton";
   readonly TRANSIENT: "transient";
 };
-type ServiceScope = (typeof ServiceScope)[keyof typeof ServiceScope];
+interface AlloyScopes {
+  singleton: true;
+  transient: true;
+}
+type ServiceScope = keyof AlloyScopes;
+interface ResolutionContext {
+  readonly scopeName: ServiceScope;
+  getCached(target: Constructor): unknown;
+  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;
+  readonly parent: ResolutionContext | null;
+}
 //#endregion
-export { ServiceScope };
+export { AlloyScopes, ResolutionContext, ServiceScope };

package/dist/plugins/core/codegen.js

@@ -306,6 +306,18 @@ function createIdentifierExports(registrations) {
 	return `${registrations.map((meta) => `const ${meta.identifierConst} = registerServiceIdentifier(${meta.importName}, Symbol.for('${escapeSingleQuotes(meta.symbolDescription)}'));`).join("\n")}\n\nexport const serviceIdentifiers = {\n${registrations.map((meta) => `  '${meta.exportKey}': ${meta.identifierConst}`).join(",\n")}\n};\n`;
 }
 /**
+* Builds the runtime scope-hierarchy registration statement. The generated
+* container records the declared parent of each custom scope so child scopes
+* constructed via `alloy-di/scopes` can be validated against the build-time
+* hierarchy. Returns an empty string when no custom scopes are configured.
+*/
+function createScopeHierarchyBlock(scopes) {
+	if (!scopes) return "";
+	const names = Object.keys(scopes);
+	if (!names.length) return "";
+	return `\ncontainer._registerScopeHierarchy({\n${names.map((name) => `  ${JSON.stringify(name)}: ${JSON.stringify(scopes[name].parent ?? "singleton")}`).join(",\n")}\n});\n`;
+}
+/**
 * Generates the virtual container module code.
 * This module:
 * 1. Imports the runtime container and necessary helpers.
@@ -323,6 +335,7 @@ function generateContainerModule(metas, lazyReferencedClassKeys, providerModuleP
 	const hasProviderModules = providerModulePaths.length > 0;
 	const { runtimeImportStatement, registrationsBlock, stubsBlock, identifierExportBlock } = buildImportsAndRegistrations(metas, lazyReferencedClassKeys, providerModulePaths, options);
 	const envOverridesBlock = options?.isDev === void 0 ? "" : `\nsetEnvDetectionOverrides({ isDev: ${options.isDev} });\n`;
+	const scopeHierarchyBlock = createScopeHierarchyBlock(options?.scopes);
 	let providerImportBlock = "";
 	let providerInvocationBlock = "";
 	if (hasProviderModules) {
@@ -336,7 +349,7 @@ ${providerImportBlock}
 ${registrationsBlock}
 
 const container = new Container();
-
+${scopeHierarchyBlock}
 for (const entry of registrations) {
   dependenciesRegistry.set(entry.ctor, entry.meta);
 }
@@ -389,6 +402,29 @@ declare module "virtual:alloy-container" {
 `;
 }
 /**
+* Generates a standalone declaration file that augments `AlloyScopes` with the
+* custom scope names, opening the `ServiceScope` union so `@Injectable('<scope>')`
+* type-checks. Returns `undefined` when no custom scopes are configured.
+*
+* This MUST live in its own file: module augmentation requires the file to be a
+* module (hence the trailing `export {}`), whereas the container declaration
+* must stay a global script so `virtual:alloy-container` resolves everywhere.
+* Combining the two in one file turns the container declaration into a module
+* and breaks resolution of the virtual module.
+*/
+function generateScopeAugmentationDefinition(scopeNames) {
+	if (!scopeNames.length) return;
+	return `${GENERATED_FILE_HEADER}
+declare module "alloy-di/runtime" {
+  interface AlloyScopes {
+${scopeNames.map((name) => `    ${JSON.stringify(name)}: true;`).join("\n")}
+  }
+}
+
+export {};
+`;
+}
+/**
 * Generates ambient type declarations for external Alloy manifests consumed by the project.
 * Creates:
 * 1. `declare module "PKG/manifest"` typed as `LibraryManifest`.
@@ -488,4 +524,4 @@ ${serviceIdentifiers}
 	}).join("\n");
 }
 //#endregion
-export { GENERATED_FILE_NOTICE, generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition };
+export { GENERATED_FILE_NOTICE, generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition, generateScopeAugmentationDefinition };

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

@@ -1,7 +1,8 @@
 import { normalizeImportPath, writeFileIfChanged } from "./utils.js";
 import { IdentifierResolver } from "./identifier-resolver.js";
-import { GENERATED_FILE_NOTICE, generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition } from "./codegen.js";
+import { GENERATED_FILE_NOTICE, generateContainerModule, generateContainerTypeDefinition, generateManifestTypeDefinition, generateScopeAugmentationDefinition } from "./codegen.js";
 import { augmentFactoryLazyServices, collectEagerReferencedNames, findDuplicateManifestServices, groupMetasByName, readManifests, reconcileLazySet, toMetaFromManifest } from "./manifest-utils.js";
+import { validateScopeStability, validateScopesConfig } from "./scopes-validation.js";
 import { generateMermaidDiagram } from "./visualizer.js";
 import { ensureDirectoryForFile } from "./visualization-utils.js";
 import path from "node:path";
@@ -32,9 +33,16 @@ async function loadVirtualContainerModule(options) {
 	const providerImports = Array.from(new Set([...options.providerImportPaths, ...manifestData.providers]));
 	reconcileLazySet(metas, lazyClassKeys, collectEagerReferencedNames(metas));
 	augmentFactoryLazyServices(metas, options.lazyServiceKeys);
-	const code = generateContainerModule(metas, lazyClassKeys, providerImports, { isDev: options.isDevMode });
-	writeTypeDefinitions(metas, loadedManifests, options.resolvedRoot, options.containerDeclarationDir);
-	writeVisualizationArtifact(metas, lazyClassKeys, options.resolvedVisualization);
+	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);
 	return {
 		code,
 		moduleType: "js"
@@ -62,11 +70,15 @@ 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) {
+function writeTypeDefinitions(metas, loadedManifests, resolvedRoot, containerDeclarationDir, scopes) {
 	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) : []);
+	if (scopeAugmentation) writeFileIfChanged(scopeAugmentationPath, scopeAugmentation);
+	else if (fs.existsSync(scopeAugmentationPath)) fs.rmSync(scopeAugmentationPath);
 	if (loadedManifests.length === 0) return;
 	const manifestsDts = generateManifestTypeDefinition(loadedManifests.map((m) => ({
 		packageName: m.packageName,
@@ -81,12 +93,13 @@ function resolveDeclarationImportPath(dtsDir, filePath) {
 	if (!rel.startsWith(".")) rel = "./" + rel;
 	return rel;
 }
-function writeVisualizationArtifact(metas, lazyReferencedClassKeys, resolvedVisualization) {
+function writeVisualizationArtifact(metas, lazyReferencedClassKeys, resolvedVisualization, scopes) {
 	if (!resolvedVisualization) return;
 	const artifact = generateMermaidDiagram({
 		metas,
 		lazyClassKeys: new Set(lazyReferencedClassKeys),
-		options: resolvedVisualization.mermaidOptions
+		options: resolvedVisualization.mermaidOptions,
+		scopes
 	});
 	ensureDirectoryForFile(resolvedVisualization.outputPath);
 	writeFileIfChanged(resolvedVisualization.outputPath, `%% ${GENERATED_FILE_NOTICE}\n${artifact.diagram}\n`);

package/dist/plugins/core/decorators.js

@@ -66,9 +66,9 @@ function parseDependencies(node, sourceFile) {
 	return [];
 }
 function extractServiceMetadata(decoratorName, callExpression, sourceFile) {
-	let scope = ServiceScope.TRANSIENT;
+	const isSingletonDecorator = decoratorName.endsWith("Singleton");
+	let scope = isSingletonDecorator ? ServiceScope.SINGLETON : ServiceScope.TRANSIENT;
 	let dependencies = [];
-	if (decoratorName.endsWith("Singleton")) scope = ServiceScope.SINGLETON;
 	const args = callExpression.arguments;
 	if (args.length === 0) return {
 		scope,
@@ -78,30 +78,20 @@ function extractServiceMetadata(decoratorName, callExpression, sourceFile) {
 	if (ts.isObjectLiteralExpression(firstArg)) {
 		for (const prop of firstArg.properties) if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
 			if (prop.name.text === "scope") {
-				if (ts.isStringLiteral(prop.initializer)) {
-					const val = prop.initializer.text;
-					if (val === "singleton") scope = ServiceScope.SINGLETON;
-					else if (val === "transient") scope = ServiceScope.TRANSIENT;
-				}
+				if (ts.isStringLiteralLike(prop.initializer)) scope = prop.initializer.text;
 			} else if (prop.name.text === "dependencies") dependencies = parseDependencies(prop.initializer, sourceFile);
 		}
-		if (decoratorName.endsWith("Singleton")) scope = ServiceScope.SINGLETON;
-		return {
-			scope,
-			dependencies
-		};
-	}
-	let depsNode;
-	if (ts.isStringLiteralLike(firstArg)) {
-		if (firstArg.text === "singleton") scope = ServiceScope.SINGLETON;
-	} else depsNode = firstArg;
-	if (args.length > 1) {
-		const secondArg = args[1];
-		if (ts.isStringLiteralLike(secondArg)) {
-			if (secondArg.text === "singleton") scope = ServiceScope.SINGLETON;
+	} else {
+		let depsNode;
+		if (ts.isStringLiteralLike(firstArg)) scope = firstArg.text;
+		else depsNode = firstArg;
+		if (args.length > 1) {
+			const secondArg = args[1];
+			if (ts.isStringLiteralLike(secondArg)) scope = secondArg.text;
 		}
+		if (depsNode) dependencies = parseDependencies(depsNode, sourceFile);
 	}
-	if (depsNode) dependencies = parseDependencies(depsNode, sourceFile);
+	if (isSingletonDecorator) scope = ServiceScope.SINGLETON;
 	return {
 		scope,
 		dependencies

package/dist/plugins/core/scopes-validation.d.ts

@@ -0,0 +1,19 @@
+//#region src/plugins/core/scopes-validation.d.ts
+/** Declared parent relationship for a single custom scope. */
+interface AlloyScopeConfig {
+  /**
+   * The next-longer-lived scope: either `"singleton"` or another custom scope.
+   * Defaults to `"singleton"` when omitted.
+   */
+  parent?: string;
+}
+/**
+ * Hierarchy of custom, application-defined scopes keyed by scope name. The two
+ * built-in lifecycles (`singleton` as the implicit root, `transient` as the
+ * implicit leaf) are never declared here.
+ */
+interface AlloyScopesConfig {
+  [scopeName: string]: AlloyScopeConfig;
+}
+//#endregion
+export { AlloyScopesConfig };