@codefast/di 0.3.16-canary.1 → 0.3.16-canary.2

package/dist/dependency-graph.mjs

@@ -8,8 +8,8 @@ function buildDependencyGraph(registry, metadataReader, options, parentRegistry)
 	const nodes = [];
 	const edges = [];
 	const includesParent = options?.includeParent === true;
-	const addBindings = (reg, fromParent) => {
-		for (const binding of reg.allBindings()) {
+	const addBindings = (sourceRegistry, fromParent) => {
+		for (const binding of sourceRegistry.allBindings()) {
 			const scope = effectiveBindingScope(binding);
 			nodes.push({
 				id: binding.id,
@@ -20,27 +20,27 @@ function buildDependencyGraph(registry, metadataReader, options, parentRegistry)
 			});
 			if (binding.kind === "class") {
 				const meta = metadataReader.getConstructorMetadata(binding.target);
-				if (meta !== void 0) meta.params.forEach((param, idx) => {
-					const depBinding = reg.getAll(param.token)[0];
-					if (depBinding !== void 0) edges.push({
+				if (meta !== void 0) meta.params.forEach((param, index) => {
+					const dependencyBinding = sourceRegistry.getAll(param.token)[0];
+					if (dependencyBinding !== void 0) edges.push({
 						from: binding.id,
-						to: depBinding.id,
-						label: `[${idx}]`
+						to: dependencyBinding.id,
+						label: `[${index}]`
 					});
 				});
-			} else if (binding.kind === "resolved" || binding.kind === "resolved-async") binding.deps.forEach((dep, idx) => {
-				const depBindings = reg.getAll(dep.token);
-				if (depBindings.length > 0 && depBindings[0] !== void 0) {
-					const label = dep.name !== void 0 ? `name:${dep.name}` : dep.tags !== void 0 && dep.tags.length > 0 ? `tag:${dep.tags[0]?.[0]}=${String(dep.tags[0]?.[1])}` : `[${idx}]`;
+			} else if (binding.kind === "resolved" || binding.kind === "resolved-async") binding.deps.forEach((dependency, index) => {
+				const dependencyBindings = sourceRegistry.getAll(dependency.token);
+				if (dependencyBindings.length > 0 && dependencyBindings[0] !== void 0) {
+					const label = dependency.name !== void 0 ? `name:${dependency.name}` : dependency.tags !== void 0 && dependency.tags.length > 0 ? `tag:${dependency.tags[0]?.[0]}=${String(dependency.tags[0]?.[1])}` : `[${index}]`;
 					edges.push({
 						from: binding.id,
-						to: depBindings[0].id,
+						to: dependencyBindings[0].id,
 						label
 					});
 				}
 			});
 			else if (binding.kind === "alias") {
-				const targetBindings = reg.getAll(binding.target);
+				const targetBindings = sourceRegistry.getAll(binding.target);
 				if (targetBindings.length > 0 && targetBindings[0] !== void 0) edges.push({
 					from: binding.id,
 					to: targetBindings[0].id,

package/dist/environment.d.mts

@@ -1,6 +1,6 @@
 import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { BindingIdentifier, BindingKind, BindingScope, ConstraintContext, MaterializationFrame, ResolutionContext, ResolveOptions } from "./types.mjs";
+import { BindingIdentifier, BindingKind, BindingScope, ConstraintContext, ResolutionContext, ResolutionFrame, ResolveOptions } from "./types.mjs";
 import { Container } from "./container.mjs";
 
 //#region src/environment.d.ts
@@ -16,14 +16,14 @@ declare function getActiveContainer(): Container | undefined;
  * @since 0.3.16-canary.0
  */
 interface ResolverCallbacks {
-  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: Array<string>, stack: Array<MaterializationFrame>): Value;
-  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Value;
-  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Value>;
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Value>;
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Value | undefined;
-  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Value | undefined>;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Array<Value>;
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: Array<string>, stack: Array<MaterializationFrame>): Promise<Array<Value>>;
+  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value;
+  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Array<Value>>;
 }
 /**
  * @since 0.3.16-canary.0
@@ -31,12 +31,12 @@ interface ResolverCallbacks {
 declare class DefaultResolutionContext implements ResolutionContext {
   private _resolver;
   private _resolutionPath;
-  private _materializationStack;
+  private _resolutionStack;
   private _currentHint;
-  constructor(resolver: ResolverCallbacks, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>, currentHint: ResolveOptions | undefined);
+  constructor(resolver: ResolverCallbacks, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>, currentHint: ResolveOptions | undefined);
   private _graph;
   get graph(): ConstraintContext;
-  reset(resolver: ResolverCallbacks, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>, currentHint: ResolveOptions | undefined): void;
+  reset(resolver: ResolverCallbacks, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>, currentHint: ResolveOptions | undefined): void;
   resolve<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value;
   resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value>;
   resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined;
@@ -47,9 +47,9 @@ declare class DefaultResolutionContext implements ResolutionContext {
 /**
  * @since 0.3.16-canary.0
  */
-declare function buildMaterializationFrame(tokenName: string, scope: BindingScope, bindingId: BindingIdentifier, kind: BindingKind, slot: {
+declare function buildResolutionFrame(tokenName: string, scope: BindingScope, bindingId: BindingIdentifier, kind: BindingKind, slot: {
   name: string | undefined;
   tags: ReadonlyArray<readonly [string, unknown]>;
-}): MaterializationFrame;
+}): ResolutionFrame;
 //#endregion
-export { DefaultResolutionContext, ResolverCallbacks, buildMaterializationFrame, getActiveContainer, runWithContainer };
+export { DefaultResolutionContext, ResolverCallbacks, buildResolutionFrame, getActiveContainer, runWithContainer };

package/dist/environment.mjs

@@ -24,68 +24,68 @@ function getActiveContainer() {
 var DefaultResolutionContext = class {
 	_resolver;
 	_resolutionPath;
-	_materializationStack;
+	_resolutionStack;
 	_currentHint;
-	constructor(resolver, resolutionPath, materializationStack, currentHint) {
+	constructor(resolver, resolutionPath, resolutionStack, currentHint) {
 		this._resolver = resolver;
 		this._resolutionPath = resolutionPath;
-		this._materializationStack = materializationStack;
+		this._resolutionStack = resolutionStack;
 		this._currentHint = currentHint;
 	}
 	_graph;
 	get graph() {
-		if (this._graph === void 0) this._graph = new DefaultConstraintContext(this._resolutionPath, this._materializationStack, this._currentHint);
+		if (this._graph === void 0) this._graph = new DefaultConstraintContext(this._resolutionPath, this._resolutionStack, this._currentHint);
 		return this._graph;
 	}
-	reset(resolver, resolutionPath, materializationStack, currentHint) {
+	reset(resolver, resolutionPath, resolutionStack, currentHint) {
 		this._resolver = resolver;
 		this._resolutionPath = resolutionPath;
-		this._materializationStack = materializationStack;
+		this._resolutionStack = resolutionStack;
 		this._currentHint = currentHint;
 		this._graph = void 0;
 	}
 	resolve(token, hint) {
-		if (hint === void 0) return this._resolver.resolveFromContext(token, this._resolutionPath, this._materializationStack);
-		return this._resolver.resolve(token, hint, this._resolutionPath, this._materializationStack);
+		if (hint === void 0) return this._resolver.resolveFromContext(token, this._resolutionPath, this._resolutionStack);
+		return this._resolver.resolve(token, hint, this._resolutionPath, this._resolutionStack);
 	}
 	resolveAsync(token, hint) {
-		if (hint === void 0) return this._resolver.resolveAsyncFromContext(token, this._resolutionPath, this._materializationStack);
-		return this._resolver.resolveAsync(token, hint, this._resolutionPath, this._materializationStack);
+		if (hint === void 0) return this._resolver.resolveAsyncFromContext(token, this._resolutionPath, this._resolutionStack);
+		return this._resolver.resolveAsync(token, hint, this._resolutionPath, this._resolutionStack);
 	}
 	resolveOptional(token, hint) {
-		return this._resolver.resolveOptional(token, hint, this._resolutionPath, this._materializationStack);
+		return this._resolver.resolveOptional(token, hint, this._resolutionPath, this._resolutionStack);
 	}
 	resolveOptionalAsync(token, hint) {
-		return this._resolver.resolveOptionalAsync(token, hint, this._resolutionPath, this._materializationStack);
+		return this._resolver.resolveOptionalAsync(token, hint, this._resolutionPath, this._resolutionStack);
 	}
 	resolveAll(token, hint) {
-		return this._resolver.resolveAll(token, hint, this._resolutionPath, this._materializationStack);
+		return this._resolver.resolveAll(token, hint, this._resolutionPath, this._resolutionStack);
 	}
 	resolveAllAsync(token, hint) {
-		return this._resolver.resolveAllAsync(token, hint, this._resolutionPath, this._materializationStack);
+		return this._resolver.resolveAllAsync(token, hint, this._resolutionPath, this._resolutionStack);
 	}
 };
 var DefaultConstraintContext = class {
 	resolutionPath;
-	materializationStack;
+	resolutionStack;
 	parent;
 	currentResolveHint;
-	constructor(resolutionPath, materializationStack, currentResolveHint) {
+	constructor(resolutionPath, resolutionStack, currentResolveHint) {
 		this.resolutionPath = resolutionPath;
-		this.materializationStack = materializationStack;
-		this.parent = materializationStack.at(-1);
+		this.resolutionStack = resolutionStack;
+		this.parent = resolutionStack.at(-1);
 		this.currentResolveHint = currentResolveHint;
 	}
 	_ancestors;
 	get ancestors() {
-		if (this._ancestors === void 0) this._ancestors = this.materializationStack.length > 1 ? this.materializationStack.slice(0, -1) : [];
+		if (this._ancestors === void 0) this._ancestors = this.resolutionStack.length > 1 ? this.resolutionStack.slice(0, -1) : [];
 		return this._ancestors;
 	}
 };
 /**
 * @since 0.3.16-canary.0
 */
-function buildMaterializationFrame(tokenName, scope, bindingId, kind, slot) {
+function buildResolutionFrame(tokenName, scope, bindingId, kind, slot) {
 	return {
 		tokenName,
 		scope,
@@ -95,4 +95,4 @@ function buildMaterializationFrame(tokenName, scope, bindingId, kind, slot) {
 	};
 }
 //#endregion
-export { DefaultResolutionContext, buildMaterializationFrame, getActiveContainer, runWithContainer };
+export { DefaultResolutionContext, buildResolutionFrame, getActiveContainer, runWithContainer };

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { Constructor } from "./constructor-type.mjs";
 import { Token, isToken, token, tokenName } from "./token.mjs";
-import { ActivationHandler, BindingIdentifier, BindingKind, BindingScope, ConstraintContext, DeactivationHandler, DependencyKey, MaterializationFrame, ResolutionContext, ResolveOptions, TokenValue } from "./types.mjs";
+import { ActivationHandler, BindingIdentifier, BindingKind, BindingScope, ConstraintContext, DeactivationHandler, DependencyKey, ResolutionContext, ResolutionFrame, ResolveOptions, TokenValue } from "./types.mjs";
 import { InjectOptions, InjectableDependency, InjectionDescriptor, inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
 import { AliasBindingBuilder, BindToBuilder, BindingBuilder, ConstantBindingBuilder, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, TransientBindingBuilder } from "./binding.mjs";
 import { effectiveBindingScope } from "./binding-scope.mjs";
@@ -13,6 +13,6 @@ import { AutoRegisterRegistry, InjectableOptions, createAutoRegisterRegistry, in
 import { Container, ContainerStatic } from "./container.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
 import { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
-import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { bindingSlotToResolveOptions, injectionSlotToResolveOptions } from "./resolve-options.mjs";
 import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
-export { type ActivationHandler, type AliasBindingBuilder, AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModule, type AsyncModuleBuilder, AsyncModuleLoadError, AsyncResolutionError, type AutoRegisterRegistry, type BindToBuilder, type BindingBuilder, type BindingIdentifier, type BindingKind, type BindingScope, type BindingSnapshot, CircularDependencyError, type ConstantBindingBuilder, type ConstraintContext, type Constructor, Container, type ContainerGraphJson, type Container as ContainerInterface, type ContainerSnapshot, type ContainerStatic, type DeactivationHandler, type DependencyKey, DiError, DisposedContainerError, type GraphEdge, type GraphNode, type GraphOptions, type InjectOptions, type InjectableDependency, type InjectableOptions, type InjectionDescriptor, InternalError, type MaterializationFrame, type MetadataReader, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, type ModuleBuilder, type MutableLifecycleMetadata, NoMatchingBindingError, RebindUnboundTokenError, type ResolutionContext, type ResolveOptions, type ScopeViolationDetails, ScopeViolationError, type ScopedBindingBuilder, type SingletonBindingBuilder, type SingletonLifecycleBuilder, SyncDisposalNotSupportedError, SyncModule, type Token, TokenNotBoundError, type TokenValue, type TransientBindingBuilder, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, isSyncModule, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName, whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };
+export { type ActivationHandler, type AliasBindingBuilder, AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModule, type AsyncModuleBuilder, AsyncModuleLoadError, AsyncResolutionError, type AutoRegisterRegistry, type BindToBuilder, type BindingBuilder, type BindingIdentifier, type BindingKind, type BindingScope, type BindingSnapshot, CircularDependencyError, type ConstantBindingBuilder, type ConstraintContext, type Constructor, Container, type ContainerGraphJson, type Container as ContainerInterface, type ContainerSnapshot, type ContainerStatic, type DeactivationHandler, type DependencyKey, DiError, DisposedContainerError, type GraphEdge, type GraphNode, type GraphOptions, type InjectOptions, type InjectableDependency, type InjectableOptions, type InjectionDescriptor, InternalError, type MetadataReader, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, type ModuleBuilder, type MutableLifecycleMetadata, NoMatchingBindingError, RebindUnboundTokenError, type ResolutionContext, type ResolutionFrame, type ResolveOptions, type ScopeViolationDetails, ScopeViolationError, type ScopedBindingBuilder, type SingletonBindingBuilder, type SingletonLifecycleBuilder, SyncDisposalNotSupportedError, SyncModule, type Token, TokenNotBoundError, type TokenValue, type TransientBindingBuilder, bindingSlotToResolveOptions, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectionSlotToResolveOptions, isInjectionDescriptor, isSyncModule, isToken, optional, postConstruct, preDestroy, token, tokenName, whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/index.mjs

@@ -2,11 +2,11 @@ import { effectiveBindingScope } from "./binding-scope.mjs";
 import { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
 import { isToken, token, tokenName } from "./token.mjs";
 import { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll } from "./constraints.mjs";
-import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { bindingSlotToResolveOptions, injectionSlotToResolveOptions } from "./resolve-options.mjs";
 import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
 import { inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
 import { AsyncModule, Module, SyncModule, isSyncModule } from "./module.mjs";
 import { Container } from "./container.mjs";
 import { createAutoRegisterRegistry, injectable } from "./decorators/injectable.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
-export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, DisposedContainerError, InternalError, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, SyncModule, TokenNotBoundError, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, isSyncModule, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName, whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, DisposedContainerError, InternalError, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, SyncModule, TokenNotBoundError, bindingSlotToResolveOptions, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectionSlotToResolveOptions, isInjectionDescriptor, isSyncModule, isToken, optional, postConstruct, preDestroy, token, tokenName, whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/inspector.mjs

@@ -25,14 +25,14 @@ var Inspector = class {
 		};
 	}
 	lookupBindings(token) {
-		return this._registry.getAll(token).map((b) => this._toSnapshot(b));
+		return this._registry.getAll(token).map((binding) => this._toSnapshot(binding));
 	}
 	has(token, hint, parentHas) {
 		const bindings = this._registry.getAll(token);
 		if (bindings.length > 0) if (hint !== void 0) {
 			if (selectBinding(bindings, hint, {
 				resolutionPath: [],
-				materializationStack: [],
+				resolutionStack: [],
 				parent: void 0,
 				ancestors: [],
 				currentResolveHint: hint
@@ -45,7 +45,7 @@ var Inspector = class {
 		if (bindings.length === 0) return false;
 		if (hint !== void 0) return selectBinding(bindings, hint, {
 			resolutionPath: [],
-			materializationStack: [],
+			resolutionStack: [],
 			parent: void 0,
 			ancestors: [],
 			currentResolveHint: hint
@@ -53,20 +53,20 @@ var Inspector = class {
 		return true;
 	}
 	allBindingSnapshots() {
-		return this._registry.allBindings().map((b) => this._toSnapshot(b));
+		return this._registry.allBindings().map((binding) => this._toSnapshot(binding));
 	}
-	_toSnapshot(b) {
-		const scope = effectiveBindingScope(b);
-		const slot = b.slot.name !== void 0 ? {
-			name: b.slot.name,
-			tags: b.slot.tags
-		} : { tags: b.slot.tags };
+	_toSnapshot(binding) {
+		const scope = effectiveBindingScope(binding);
+		const slot = binding.slot.name !== void 0 ? {
+			name: binding.slot.name,
+			tags: binding.slot.tags
+		} : { tags: binding.slot.tags };
 		return {
-			tokenName: tokenName(b.token),
-			kind: b.kind,
+			tokenName: tokenName(binding.token),
+			kind: binding.kind,
 			scope,
 			slot,
-			id: b.id
+			id: binding.id
 		};
 	}
 };

package/dist/module.d.mts

@@ -57,6 +57,6 @@ declare const Module: {
 /**
  * @since 0.3.16-canary.0
  */
-declare function isSyncModule(m: SyncModule | AsyncModule): m is SyncModule;
+declare function isSyncModule(module: SyncModule | AsyncModule): module is SyncModule;
 //#endregion
 export { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule, isSyncModule };

package/dist/module.mjs

@@ -35,8 +35,8 @@ const Module = {
 /**
 * @since 0.3.16-canary.0
 */
-function isSyncModule(m) {
-	return m[SYNC_MODULE_BRAND] === true;
+function isSyncModule(module) {
+	return module[SYNC_MODULE_BRAND] === true;
 }
 //#endregion
 export { AsyncModule, Module, SyncModule, isSyncModule };

package/dist/registry.d.mts

@@ -16,15 +16,15 @@ declare class BindingRegistry {
   /** Add or replace binding using slot-aware last-wins. */
   add(binding: Binding): void;
   /** Remove all bindings for a token. Returns removed bindings. */
-  removeByToken(t: Token<unknown> | Constructor): Array<Binding>;
+  removeByToken(token: Token<unknown> | Constructor): Array<Binding>;
   /** Remove a specific binding by ID. Returns the removed binding or undefined. */
   removeById(id: BindingIdentifier): Binding | undefined;
   /** Get all bindings for a token. */
-  getAll(t: Token<unknown> | Constructor): ReadonlyArray<Binding>;
+  getAll(token: Token<unknown> | Constructor): ReadonlyArray<Binding>;
   /** Get binding by ID. */
   getById(id: BindingIdentifier): Binding | undefined;
   /** Check if any binding exists for token. */
-  has(t: Token<unknown> | Constructor): boolean;
+  has(token: Token<unknown> | Constructor): boolean;
   /** All bindings in the registry. */
   allBindings(): ReadonlyArray<Binding>;
   /** Remove all bindings. Returns all removed. */
@@ -33,7 +33,7 @@ declare class BindingRegistry {
   getSimpleTagged(token: Token<unknown> | Constructor, tagKey: string, tagValue: unknown): Binding | undefined;
   getFastDefault(token: Token<unknown> | Constructor): Binding | undefined;
   /** Summarize available slot strings for a token (for error messages). */
-  availableSlotStrings(t: Token<unknown> | Constructor): Array<string>;
+  availableSlotStrings(token: Token<unknown> | Constructor): Array<string>;
   private _indexSimpleTaggedBinding;
   private _deindexSimpleTaggedBinding;
   private _isPurePredicateBinding;

package/dist/registry.mjs

@@ -1,4 +1,4 @@
-import { slotKeyEquals, slotKeyToString } from "./binding.mjs";
+import { bindingSlotEquals, bindingSlotToString } from "./binding.mjs";
 //#region src/registry.ts
 /**
 * @since 0.3.16-canary.0
@@ -18,7 +18,7 @@ var BindingRegistry = class {
 			this._bindings.set(key, bindingsForToken);
 		}
 		if (!this._isPurePredicateBinding(binding)) {
-			const existingIndex = bindingsForToken.findIndex((b) => !this._isPurePredicateBinding(b) && slotKeyEquals(b.slot, binding.slot));
+			const existingIndex = bindingsForToken.findIndex((candidate) => !this._isPurePredicateBinding(candidate) && bindingSlotEquals(candidate.slot, binding.slot));
 			if (existingIndex !== -1) {
 				const replacedBinding = bindingsForToken[existingIndex];
 				this._byId.delete(replacedBinding.id);
@@ -32,8 +32,8 @@ var BindingRegistry = class {
 		this._refreshFastDefaultForToken(key);
 	}
 	/** Remove all bindings for a token. Returns removed bindings. */
-	removeByToken(t) {
-		const key = t;
+	removeByToken(token) {
+		const key = token;
 		const bindingsForToken = this._bindings.get(key) ?? [];
 		this._bindings.delete(key);
 		this._simpleNamed.delete(key);
@@ -64,16 +64,16 @@ var BindingRegistry = class {
 		return binding;
 	}
 	/** Get all bindings for a token. */
-	getAll(t) {
-		return this._bindings.get(t) ?? [];
+	getAll(token) {
+		return this._bindings.get(token) ?? [];
 	}
 	/** Get binding by ID. */
 	getById(id) {
 		return this._byId.get(id);
 	}
 	/** Check if any binding exists for token. */
-	has(t) {
-		const key = t;
+	has(token) {
+		const key = token;
 		const list = this._bindings.get(key);
 		return list !== void 0 && list.length > 0;
 	}
@@ -103,17 +103,17 @@ var BindingRegistry = class {
 		return this._fastDefault.get(token);
 	}
 	/** Summarize available slot strings for a token (for error messages). */
-	availableSlotStrings(t) {
-		return (this._bindings.get(t) ?? []).map((binding) => slotKeyToString(binding.slot));
+	availableSlotStrings(token) {
+		return (this._bindings.get(token) ?? []).map((binding) => bindingSlotToString(binding.slot));
 	}
-	_indexSimpleTaggedBinding(tokenKeyValue, binding) {
+	_indexSimpleTaggedBinding(tokenKey, binding) {
 		const slot = binding.slot;
 		if (slot.name !== void 0 || slot.tags.length !== 1 || binding.predicate !== void 0) return;
 		const [tagKey, tagValue] = slot.tags[0];
-		let byTagKey = this._simpleTagged.get(tokenKeyValue);
+		let byTagKey = this._simpleTagged.get(tokenKey);
 		if (byTagKey === void 0) {
 			byTagKey = /* @__PURE__ */ new Map();
-			this._simpleTagged.set(tokenKeyValue, byTagKey);
+			this._simpleTagged.set(tokenKey, byTagKey);
 		}
 		let byTagValue = byTagKey.get(tagKey);
 		if (byTagValue === void 0) {
@@ -122,11 +122,11 @@ var BindingRegistry = class {
 		}
 		byTagValue.set(tagValue, binding);
 	}
-	_deindexSimpleTaggedBinding(tokenKeyValue, binding) {
+	_deindexSimpleTaggedBinding(tokenKey, binding) {
 		const slot = binding.slot;
 		if (slot.name !== void 0 || slot.tags.length !== 1 || binding.predicate !== void 0) return;
 		const [tagKey, tagValue] = slot.tags[0];
-		const byTagKey = this._simpleTagged.get(tokenKeyValue);
+		const byTagKey = this._simpleTagged.get(tokenKey);
 		if (byTagKey === void 0) return;
 		const byTagValue = byTagKey.get(tagKey);
 		if (byTagValue === void 0) return;
@@ -134,7 +134,7 @@ var BindingRegistry = class {
 			byTagValue.delete(tagValue);
 			if (byTagValue.size === 0) {
 				byTagKey.delete(tagKey);
-				if (byTagKey.size === 0) this._simpleTagged.delete(tokenKeyValue);
+				if (byTagKey.size === 0) this._simpleTagged.delete(tokenKey);
 			}
 		}
 	}
@@ -144,38 +144,38 @@ var BindingRegistry = class {
 		const hasConstraint = slot.name !== void 0 || slot.tags.length > 0;
 		return hasPredicate && !hasConstraint;
 	}
-	_indexSimpleNamedBinding(tokenKeyValue, binding) {
+	_indexSimpleNamedBinding(tokenKey, binding) {
 		const slot = binding.slot;
 		if (slot.name === void 0 || slot.tags.length > 0) return;
-		let bindingsByName = this._simpleNamed.get(tokenKeyValue);
+		let bindingsByName = this._simpleNamed.get(tokenKey);
 		if (bindingsByName === void 0) {
 			bindingsByName = /* @__PURE__ */ new Map();
-			this._simpleNamed.set(tokenKeyValue, bindingsByName);
+			this._simpleNamed.set(tokenKey, bindingsByName);
 		}
 		bindingsByName.set(slot.name, binding);
 	}
-	_deindexSimpleNamedBinding(tokenKeyValue, binding) {
+	_deindexSimpleNamedBinding(tokenKey, binding) {
 		const slot = binding.slot;
 		if (slot.name === void 0 || slot.tags.length > 0) return;
-		const bindingsByName = this._simpleNamed.get(tokenKeyValue);
+		const bindingsByName = this._simpleNamed.get(tokenKey);
 		if (bindingsByName === void 0) return;
 		if (bindingsByName.get(slot.name)?.id === binding.id) {
 			bindingsByName.delete(slot.name);
-			if (bindingsByName.size === 0) this._simpleNamed.delete(tokenKeyValue);
+			if (bindingsByName.size === 0) this._simpleNamed.delete(tokenKey);
 		}
 	}
-	_refreshFastDefaultForToken(tokenKeyValue) {
-		const bindingsForToken = this._bindings.get(tokenKeyValue);
+	_refreshFastDefaultForToken(tokenKey) {
+		const bindingsForToken = this._bindings.get(tokenKey);
 		if (bindingsForToken === void 0 || bindingsForToken.length !== 1) {
-			this._fastDefault.delete(tokenKeyValue);
+			this._fastDefault.delete(tokenKey);
 			return;
 		}
 		const onlyBinding = bindingsForToken[0];
 		if (!(onlyBinding.slot.name === void 0 && onlyBinding.slot.tags.length === 0) || onlyBinding.predicate !== void 0) {
-			this._fastDefault.delete(tokenKeyValue);
+			this._fastDefault.delete(tokenKey);
 			return;
 		}
-		this._fastDefault.set(tokenKeyValue, onlyBinding);
+		this._fastDefault.set(tokenKey, onlyBinding);
 	}
 };
 //#endregion

package/dist/resolve-options.d.mts

@@ -1,5 +1,5 @@
 import { ResolveOptions } from "./types.mjs";
-import { SlotKey } from "./binding.mjs";
+import { BindingSlot } from "./binding.mjs";
 
 //#region src/resolve-options.d.ts
 /**
@@ -8,15 +8,15 @@ import { SlotKey } from "./binding.mjs";
  *
  * @since 0.3.16-canary.0
  */
-declare function injectableSlotToResolveOptions(slot: {
+declare function injectionSlotToResolveOptions(injectionSlot: {
   readonly name?: string;
   readonly tags?: ReadonlyArray<readonly [string, unknown]>;
 }): ResolveOptions | undefined;
 /**
- * Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+ * Hint from a binding {@link BindingSlot} (tags may be empty; omits when nothing to match).
  *
  * @since 0.3.16-canary.0
  */
-declare function slotKeyToResolveOptions(slot: SlotKey): ResolveOptions | undefined;
+declare function bindingSlotToResolveOptions(bindingSlot: BindingSlot): ResolveOptions | undefined;
 //#endregion
-export { injectableSlotToResolveOptions, slotKeyToResolveOptions };
+export { bindingSlotToResolveOptions, injectionSlotToResolveOptions };

package/dist/resolve-options.mjs

@@ -5,22 +5,22 @@
 *
 * @since 0.3.16-canary.0
 */
-function injectableSlotToResolveOptions(slot) {
+function injectionSlotToResolveOptions(injectionSlot) {
 	const options = {};
-	if (slot.name !== void 0) options.name = slot.name;
-	if (slot.tags !== void 0) options.tags = slot.tags;
+	if (injectionSlot.name !== void 0) options.name = injectionSlot.name;
+	if (injectionSlot.tags !== void 0) options.tags = injectionSlot.tags;
 	return options.name !== void 0 || options.tags !== void 0 ? options : void 0;
 }
 /**
-* Hint from a binding {@link SlotKey} (tags may be empty; omits when nothing to match).
+* Hint from a binding {@link BindingSlot} (tags may be empty; omits when nothing to match).
 *
 * @since 0.3.16-canary.0
 */
-function slotKeyToResolveOptions(slot) {
+function bindingSlotToResolveOptions(bindingSlot) {
 	const options = {};
-	if (slot.name !== void 0) options.name = slot.name;
-	if (slot.tags.length > 0) options.tags = slot.tags;
+	if (bindingSlot.name !== void 0) options.name = bindingSlot.name;
+	if (bindingSlot.tags.length > 0) options.tags = bindingSlot.tags;
 	return options.name !== void 0 || options.tags !== void 0 ? options : void 0;
 }
 //#endregion
-export { injectableSlotToResolveOptions, slotKeyToResolveOptions };
+export { bindingSlotToResolveOptions, injectionSlotToResolveOptions };

package/dist/resolver.d.mts

@@ -1,6 +1,6 @@
 import { Constructor } from "./constructor-type.mjs";
 import { Token } from "./token.mjs";
-import { MaterializationFrame, ResolveOptions } from "./types.mjs";
+import { ResolutionFrame, ResolveOptions } from "./types.mjs";
 import { Binding } from "./binding.mjs";
 import { BindingRegistry } from "./registry.mjs";
 import { ScopeManager } from "./scope.mjs";
@@ -47,22 +47,22 @@ declare class DependencyResolver {
    * Mirrors {@link DependencyResolver.resolveAll} candidate selection only (no instantiation).
    */
   peekCandidateBindingsForValidate(token: Token<unknown> | Constructor, hint: ResolveOptions | undefined): Array<Binding>;
-  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Value;
-  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Value;
+  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value;
   private _resolveBinding;
   private _instantiateSync;
   private _resolveClassDeps;
   private _resolveDescriptorDeps;
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Value | undefined;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Array<Value>;
-  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Value>;
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value | undefined;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Array<Value>;
+  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
   private _resolveBindingAsync;
   private _instantiateAsync;
   private _resolveClassDepsAsync;
   private _resolveDescriptorDepsAsync;
-  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Value | undefined>;
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, materializationStack: Array<MaterializationFrame>): Promise<Array<Value>>;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value | undefined>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Array<Value>>;
   private _getAllBindingsFromChain;
   private _getSimpleNamedBindingsFromChain;
   private _getAvailableSlots;
@@ -79,7 +79,7 @@ declare class DependencyResolver {
   private _resolveTransientDynamicAsyncSlow;
   private _resolveCandidateSync;
   private _resolveCandidateAsync;
-  private _getMaterializationFrame;
+  private _getResolutionFrame;
   private _needsActivation;
   private _refreshClassPostConstructCache;
   private _requiresResolutionContext;