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

package/dist/decorators/inject.mjs

@@ -1,7 +1,7 @@
 import { InternalError, MissingContainerContextError } from "../errors.mjs";
 import { getActiveContainer } from "../environment.mjs";
-import { injectableSlotToResolveOptions } from "../resolve-options.mjs";
-import { INJECT_ACCESSOR_KEY, accessorMetadataByMetadataObjectMap } from "../metadata/metadata-keys.mjs";
+import { injectionSlotToResolveOptions } from "../resolve-options.mjs";
+import { INJECT_ACCESSOR_KEY } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/inject.ts
 /**
 * @since 0.3.16-canary.0
@@ -15,10 +15,10 @@ function isInjectionDescriptor(value) {
 /**
 * @since 0.3.16-canary.0
 */
-function normalizeToDescriptor(dep) {
-	if (isInjectionDescriptor(dep)) return materializeInjectionDescriptor(dep);
+function normalizeToDescriptor(dependency) {
+	if (isInjectionDescriptor(dependency)) return materializeInjectionDescriptor(dependency);
 	return {
-		token: dep,
+		token: dependency,
 		optional: false,
 		multi: false
 	};
@@ -27,9 +27,9 @@ function normalizeToDescriptor(dep) {
 * Dual-role `inject()` values are functions: [[Function]].name must not be treated as a DI slot name.
 * Only enumerable own `name` / `tags` from `Object.defineProperties` are real injection options.
 */
-function materializeInjectionDescriptor(dep) {
-	if (typeof dep !== "function") return dep;
-	const dualRole = dep;
+function materializeInjectionDescriptor(dependency) {
+	if (typeof dependency !== "function") return dependency;
+	const dualRole = dependency;
 	const base = {
 		token: dualRole.token,
 		optional: dualRole.optional,
@@ -54,12 +54,7 @@ function materializeInjectionDescriptor(dep) {
 	};
 	return base;
 }
-function buildInjectionDescriptor(token, options) {
-	const base = {
-		token,
-		optional: false,
-		multi: false
-	};
+function withOptions(base, options) {
 	if (options?.name !== void 0 && options.tags !== void 0) return {
 		...base,
 		name: options.name,
@@ -75,6 +70,13 @@ function buildInjectionDescriptor(token, options) {
 	};
 	return base;
 }
+function buildInjectionDescriptor(token, options) {
+	return withOptions({
+		token,
+		optional: false,
+		multi: false
+	}, options);
+}
 /**
 * @since 0.3.16-canary.0
 */
@@ -88,11 +90,10 @@ function inject(token, options) {
 			key: context.name,
 			descriptor
 		});
-		accessorMetadataByMetadataObjectMap.set(context.metadata, meta[INJECT_ACCESSOR_KEY]);
 		context.addInitializer(function() {
 			const container = getActiveContainer();
 			if (container === void 0) throw new MissingContainerContextError(String(context.name));
-			const hint = options === void 0 ? void 0 : injectableSlotToResolveOptions({
+			const hint = options === void 0 ? void 0 : injectionSlotToResolveOptions({
 				...options.name !== void 0 ? { name: options.name } : {},
 				...options.tags !== void 0 ? { tags: options.tags } : {}
 			});
@@ -115,49 +116,21 @@ function inject(token, options) {
 * @since 0.3.16-canary.0
 */
 function optional(token, options) {
-	const base = {
+	return withOptions({
 		token,
 		optional: true,
 		multi: false
-	};
-	if (options?.name !== void 0 && options.tags !== void 0) return {
-		...base,
-		name: options.name,
-		tags: options.tags
-	};
-	if (options?.name !== void 0) return {
-		...base,
-		name: options.name
-	};
-	if (options?.tags !== void 0) return {
-		...base,
-		tags: options.tags
-	};
-	return base;
+	}, options);
 }
 /**
 * @since 0.3.16-canary.0
 */
 function injectAll(token, options) {
-	const base = {
+	return withOptions({
 		token,
 		optional: false,
 		multi: true
-	};
-	if (options?.name !== void 0 && options.tags !== void 0) return {
-		...base,
-		name: options.name,
-		tags: options.tags
-	};
-	if (options?.name !== void 0) return {
-		...base,
-		name: options.name
-	};
-	if (options?.tags !== void 0) return {
-		...base,
-		tags: options.tags
-	};
-	return base;
+	}, options);
 }
 //#endregion
 export { inject, injectAll, isInjectionDescriptor, normalizeToDescriptor, optional };

package/dist/decorators/injectable.mjs

@@ -1,4 +1,4 @@
-import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, accessorMetadataByConstructorMap, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
+import { INJECTABLE_KEY } from "../metadata/metadata-keys.mjs";
 import { normalizeToDescriptor } from "./inject.mjs";
 //#region src/decorators/injectable.ts
 /**
@@ -23,7 +23,7 @@ function createAutoRegisterRegistry() {
 */
 function injectable(deps, options) {
 	return function(target, context) {
-		const constructorMetadata = { params: (deps ?? []).map((dependency, index) => {
+		const parameterMetadataList = (deps ?? []).map((dependency, index) => {
 			const descriptor = normalizeToDescriptor(dependency);
 			const baseParameterMetadata = {
 				index,
@@ -45,16 +45,8 @@ function injectable(deps, options) {
 				tags: descriptor.tags
 			};
 			return baseParameterMetadata;
-		}) };
-		constructorMetadataMap.set(target, constructorMetadata);
-		try {
-			const metadata = context.metadata;
-			if (metadata !== null && typeof metadata === "object") {
-				const accessorList = metadata[INJECT_ACCESSOR_KEY];
-				if (Array.isArray(accessorList) && accessorList.length > 0) accessorMetadataByConstructorMap.set(target, accessorList);
-				metadata[INJECTABLE_KEY] = constructorMetadata;
-			}
-		} catch {}
+		});
+		context.metadata[INJECTABLE_KEY] = { params: parameterMetadataList };
 		if (options?.autoRegister !== void 0) {
 			const scope = options.scope ?? "transient";
 			options.autoRegister.register(target, scope);

package/dist/decorators/lifecycle-decorators.mjs

@@ -1,26 +1,9 @@
 import { InternalError } from "../errors.mjs";
-import { LIFECYCLE_KEY, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "../metadata/metadata-keys.mjs";
+import { LIFECYCLE_KEY } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/lifecycle-decorators.ts
 function appendUniqueMethod(metadata, phase, methodName) {
 	if (!metadata[phase].includes(methodName)) metadata[phase].push(methodName);
 }
-function resolveConstructorFromDecoratorTarget(target) {
-	if (typeof target === "function") return target;
-	if (typeof target === "object" && target !== null) {
-		const ctor = target.constructor;
-		if (typeof ctor === "function") return ctor;
-	}
-}
-function registerByConstructor(target, phase, methodName) {
-	const ctor = resolveConstructorFromDecoratorTarget(target);
-	if (ctor === void 0) return;
-	const ctorExisting = lifecycleByConstructorMetadataMap.get(ctor);
-	if (ctorExisting !== void 0) appendUniqueMethod(ctorExisting, phase, methodName);
-	else lifecycleByConstructorMetadataMap.set(ctor, {
-		postConstruct: phase === "postConstruct" ? [methodName] : [],
-		preDestroy: phase === "preDestroy" ? [methodName] : []
-	});
-}
 /**
 * @since 0.3.16-canary.0
 */
@@ -28,34 +11,12 @@ function postConstruct() {
 	return function(target, context) {
 		if (context.static === true) throw new InternalError("@postConstruct() applies to instance methods only; static methods are not invoked during instance lifecycle.");
 		const methodName = String(context.name);
-		registerByConstructor(target, "postConstruct", methodName);
-		const existing = lifecycleMetadataMap.get(context.metadata);
-		if (existing !== void 0) appendUniqueMethod(existing, "postConstruct", methodName);
-		else lifecycleMetadataMap.set(context.metadata, {
-			postConstruct: [methodName],
+		const meta = context.metadata;
+		if (!meta[LIFECYCLE_KEY]) meta[LIFECYCLE_KEY] = {
+			postConstruct: [],
 			preDestroy: []
-		});
-		context.addInitializer(function() {
-			const targetOrInstance = this;
-			const ctor = typeof targetOrInstance === "function" ? targetOrInstance : targetOrInstance.constructor;
-			const ctorExisting = lifecycleByConstructorMetadataMap.get(ctor);
-			if (ctorExisting !== void 0) appendUniqueMethod(ctorExisting, "postConstruct", methodName);
-			else lifecycleByConstructorMetadataMap.set(ctor, {
-				postConstruct: [methodName],
-				preDestroy: []
-			});
-		});
-		try {
-			const meta = context.metadata;
-			if (meta !== null && typeof meta === "object") {
-				if (!meta[LIFECYCLE_KEY]) meta[LIFECYCLE_KEY] = {
-					postConstruct: [],
-					preDestroy: []
-				};
-				const lifecycle = meta[LIFECYCLE_KEY];
-				appendUniqueMethod(lifecycle, "postConstruct", methodName);
-			}
-		} catch {}
+		};
+		appendUniqueMethod(meta[LIFECYCLE_KEY], "postConstruct", methodName);
 	};
 }
 /**
@@ -65,34 +26,12 @@ function preDestroy() {
 	return function(target, context) {
 		if (context.static === true) throw new InternalError("@preDestroy() applies to instance methods only; static methods are not invoked during instance teardown.");
 		const methodName = String(context.name);
-		registerByConstructor(target, "preDestroy", methodName);
-		const existing = lifecycleMetadataMap.get(context.metadata);
-		if (existing !== void 0) appendUniqueMethod(existing, "preDestroy", methodName);
-		else lifecycleMetadataMap.set(context.metadata, {
+		const meta = context.metadata;
+		if (!meta[LIFECYCLE_KEY]) meta[LIFECYCLE_KEY] = {
 			postConstruct: [],
-			preDestroy: [methodName]
-		});
-		context.addInitializer(function() {
-			const targetOrInstance = this;
-			const ctor = typeof targetOrInstance === "function" ? targetOrInstance : targetOrInstance.constructor;
-			const ctorExisting = lifecycleByConstructorMetadataMap.get(ctor);
-			if (ctorExisting !== void 0) appendUniqueMethod(ctorExisting, "preDestroy", methodName);
-			else lifecycleByConstructorMetadataMap.set(ctor, {
-				postConstruct: [],
-				preDestroy: [methodName]
-			});
-		});
-		try {
-			const meta = context.metadata;
-			if (meta !== null && typeof meta === "object") {
-				if (!meta[LIFECYCLE_KEY]) meta[LIFECYCLE_KEY] = {
-					postConstruct: [],
-					preDestroy: []
-				};
-				const lifecycle = meta[LIFECYCLE_KEY];
-				appendUniqueMethod(lifecycle, "preDestroy", methodName);
-			}
-		} catch {}
+			preDestroy: []
+		};
+		appendUniqueMethod(meta[LIFECYCLE_KEY], "preDestroy", methodName);
 	};
 }
 //#endregion

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,29 @@ 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) for (let index = 0; index < meta.params.length; index += 1) {
+					const param = meta.params[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") for (let index = 0; index < binding.deps.length; index += 1) {
+				const dependency = binding.deps[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/graph-adapters/cytoscape.d.mts

@@ -5,29 +5,29 @@ import { ContainerGraphJson } from "../dependency-graph.mjs";
  * @since 0.3.16-canary.0
  */
 interface CytoscapeNode {
-  data: {
-    id: string;
-    label: string;
-    kind: string;
-    scope: string;
-    fromParent: boolean;
+  readonly data: {
+    readonly id: string;
+    readonly label: string;
+    readonly kind: string;
+    readonly scope: string;
+    readonly fromParent: boolean;
   };
 }
 /**
  * @since 0.3.16-canary.0
  */
 interface CytoscapeEdge {
-  data: {
-    id: string;
-    source: string;
-    target: string;
-    label?: string;
+  readonly data: {
+    readonly id: string;
+    readonly source: string;
+    readonly target: string;
+    readonly label?: string;
   };
 }
 /**
  * @since 0.3.16-canary.0
  */
-type CytoscapeElements = Array<CytoscapeNode | CytoscapeEdge>;
+type CytoscapeElements = ReadonlyArray<CytoscapeNode | CytoscapeEdge>;
 /**
  * @since 0.3.16-canary.0
  */

package/dist/graph-adapters/cytoscape.mjs

@@ -11,15 +11,15 @@ function toCytoscapeGraph(graph) {
 		scope: node.scope,
 		fromParent: node.fromParent
 	} });
-	graph.edges.forEach((edge, idx) => {
-		const data = {
+	for (let idx = 0; idx < graph.edges.length; idx += 1) {
+		const edge = graph.edges[idx];
+		elements.push({ data: {
 			id: `edge-${idx}`,
 			source: edge.from,
-			target: edge.to
-		};
-		if (edge.label !== void 0) data.label = edge.label;
-		elements.push({ data });
-	});
+			target: edge.to,
+			...edge.label !== void 0 ? { label: edge.label } : {}
+		} });
+	}
 	return elements;
 }
 //#endregion

package/dist/graph-adapters/reactflow.d.mts

@@ -5,33 +5,33 @@ import { ContainerGraphJson } from "../dependency-graph.mjs";
  * @since 0.3.16-canary.0
  */
 interface ReactFlowNode {
-  id: string;
-  data: {
-    label: string;
-    kind: string;
-    scope: string;
-    fromParent: boolean;
+  readonly id: string;
+  readonly data: {
+    readonly label: string;
+    readonly kind: string;
+    readonly scope: string;
+    readonly fromParent: boolean;
   };
-  position: {
-    x: number;
-    y: number;
+  readonly position: {
+    readonly x: number;
+    readonly y: number;
   };
 }
 /**
  * @since 0.3.16-canary.0
  */
 interface ReactFlowEdge {
-  id: string;
-  source: string;
-  target: string;
-  label?: string;
+  readonly id: string;
+  readonly source: string;
+  readonly target: string;
+  readonly label?: string;
 }
 /**
  * @since 0.3.16-canary.0
  */
 interface ReactFlowGraph {
-  nodes: Array<ReactFlowNode>;
-  edges: Array<ReactFlowEdge>;
+  readonly nodes: ReadonlyArray<ReactFlowNode>;
+  readonly edges: ReadonlyArray<ReactFlowEdge>;
 }
 /**
  * @since 0.3.16-canary.0

package/dist/graph-adapters/reactflow.mjs

@@ -17,15 +17,12 @@ function toReactFlowGraph(graph) {
 				y: Math.floor(idx / 5) * 100
 			}
 		})),
-		edges: graph.edges.map((edge, idx) => {
-			const reactFlowEdge = {
-				id: `edge-${idx}`,
-				source: edge.from,
-				target: edge.to
-			};
-			if (edge.label !== void 0) reactFlowEdge.label = edge.label;
-			return reactFlowEdge;
-		})
+		edges: graph.edges.map((edge, idx) => ({
+			id: `edge-${idx}`,
+			source: edge.from,
+			target: edge.to,
+			...edge.label !== void 0 ? { label: edge.label } : {}
+		}))
 	};
 }
 //#endregion

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 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, BindingTag, 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 { AliasBindingBuilder, BindToBuilder, BindingBuilder, ConstantBindingBuilder, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, SlotConstrainedBuilder, TransientBindingBuilder } from "./binding.mjs";
 import { effectiveBindingScope } from "./binding-scope.mjs";
 import { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll } from "./constraints.mjs";
 import { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule, isSyncModule } from "./module.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, type BindingTag, 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, type SlotConstrainedBuilder, 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 };