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

package/dist/decorators/inject.mjs

@@ -1,7 +1,7 @@
-import { MissingContainerContextError } from "../errors.mjs";
+import { InternalError, MissingContainerContextError } from "../errors.mjs";
 import { getActiveContainer } from "../environment.mjs";
-import { injectableSlotToResolveOptions } from "../resolve-options.mjs";
-import { INJECT_ACCESSOR_KEY } from "../metadata/metadata-keys.mjs";
+import { injectionSlotToResolveOptions } from "../resolve-options.mjs";
+import { INJECT_ACCESSOR_KEY, accessorMetadataByMetadataObjectMap } 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,9 +54,9 @@ function materializeInjectionDescriptor(dep) {
 	};
 	return base;
 }
-function buildInjectionDescriptor(t, options) {
+function buildInjectionDescriptor(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: false,
 		multi: false
 	};
@@ -78,23 +78,25 @@ function buildInjectionDescriptor(t, options) {
 /**
 * @since 0.3.16-canary.0
 */
-function inject(t, options) {
-	const descriptor = buildInjectionDescriptor(t, options);
+function inject(token, options) {
+	const descriptor = buildInjectionDescriptor(token, options);
 	const decoratorFn = (_target, context) => {
+		if (context.static === true) throw new InternalError("@inject() on static accessors is not supported; only instance accessors participate in runWithContainer-based property injection.");
 		const meta = context.metadata;
 		if (!Array.isArray(meta[INJECT_ACCESSOR_KEY])) meta[INJECT_ACCESSOR_KEY] = [];
 		meta[INJECT_ACCESSOR_KEY].push({
 			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 } : {}
 			});
-			const value = descriptor.optional ? container.resolveOptional(t, hint) : container.resolve(t, hint);
+			const value = descriptor.optional ? container.resolveOptional(token, hint) : container.resolve(token, hint);
 			context.access.set(this, value);
 		});
 		return {};
@@ -112,9 +114,9 @@ function inject(t, options) {
 /**
 * @since 0.3.16-canary.0
 */
-function optional(t, options) {
+function optional(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: true,
 		multi: false
 	};
@@ -136,9 +138,9 @@ function optional(t, options) {
 /**
 * @since 0.3.16-canary.0
 */
-function injectAll(t, options) {
+function injectAll(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: false,
 		multi: true
 	};

package/dist/decorators/injectable.d.mts

@@ -27,6 +27,6 @@ interface InjectableOptions {
 /**
  * @since 0.3.16-canary.0
  */
-declare function injectable(deps?: readonly InjectableDependency[], options?: InjectableOptions): (target: unknown, context: ClassDecoratorContext) => void;
+declare function injectable(deps?: ReadonlyArray<InjectableDependency>, options?: InjectableOptions): (target: unknown, context: ClassDecoratorContext) => void;
 //#endregion
 export { AutoRegisterRegistry, type InjectableDependency, InjectableOptions, createAutoRegisterRegistry, injectable };

package/dist/decorators/injectable.mjs

@@ -1,20 +1,20 @@
-import { INJECTABLE_KEY, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
+import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, accessorMetadataByConstructorMap, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
 import { normalizeToDescriptor } from "./inject.mjs";
 //#region src/decorators/injectable.ts
 /**
 * @since 0.3.16-canary.0
 */
 function createAutoRegisterRegistry() {
-	const _entries = [];
+	const _registeredEntries = [];
 	return {
 		register(target, scope) {
-			_entries.push({
+			_registeredEntries.push({
 				target,
 				scope
 			});
 		},
 		entries() {
-			return _entries;
+			return _registeredEntries;
 		}
 	};
 }
@@ -23,33 +23,37 @@ function createAutoRegisterRegistry() {
 */
 function injectable(deps, options) {
 	return function(target, context) {
-		const constructorMeta = { params: (deps ?? []).map((dep, index) => {
-			const descriptor = normalizeToDescriptor(dep);
-			const base = {
+		const constructorMetadata = { params: (deps ?? []).map((dependency, index) => {
+			const descriptor = normalizeToDescriptor(dependency);
+			const baseParameterMetadata = {
 				index,
 				token: descriptor.token,
 				optional: descriptor.optional,
 				multi: descriptor.multi
 			};
 			if (descriptor.name !== void 0 && descriptor.tags !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				name: descriptor.name,
 				tags: descriptor.tags
 			};
 			if (descriptor.name !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				name: descriptor.name
 			};
 			if (descriptor.tags !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				tags: descriptor.tags
 			};
-			return base;
+			return baseParameterMetadata;
 		}) };
-		constructorMetadataMap.set(target, constructorMeta);
+		constructorMetadataMap.set(target, constructorMetadata);
 		try {
-			const meta = context.metadata;
-			if (meta !== null && typeof meta === "object") meta[INJECTABLE_KEY] = constructorMeta;
+			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 {}
 		if (options?.autoRegister !== void 0) {
 			const scope = options.scope ?? "transient";

package/dist/decorators/lifecycle-decorators.mjs

@@ -1,3 +1,4 @@
+import { InternalError } from "../errors.mjs";
 import { LIFECYCLE_KEY, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/lifecycle-decorators.ts
 function appendUniqueMethod(metadata, phase, methodName) {
@@ -25,6 +26,7 @@ function registerByConstructor(target, phase, methodName) {
 */
 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);
@@ -61,6 +63,7 @@ function postConstruct() {
 */
 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);

package/dist/dependency-graph.d.mts

@@ -25,8 +25,8 @@ interface GraphEdge {
  * @since 0.3.16-canary.0
  */
 interface ContainerGraphJson {
-  readonly nodes: readonly GraphNode[];
-  readonly edges: readonly GraphEdge[];
+  readonly nodes: ReadonlyArray<GraphNode>;
+  readonly edges: ReadonlyArray<GraphEdge>;
   readonly includesParent: boolean;
 }
 /**

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: string[], stack: MaterializationFrame[]): Value;
-  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value;
-  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: string[], stack: MaterializationFrame[]): Promise<Value>;
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value>;
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value | undefined;
-  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value | undefined>;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value[];
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<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,25 +31,25 @@ interface ResolverCallbacks {
 declare class DefaultResolutionContext implements ResolutionContext {
   private _resolver;
   private _resolutionPath;
-  private _materializationStack;
+  private _resolutionStack;
   private _currentHint;
-  constructor(resolver: ResolverCallbacks, resolutionPath: string[], materializationStack: 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: string[], materializationStack: 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;
   resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value | undefined>;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value[];
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value[]>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Array<Value>>;
 }
 /**
  * @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/errors.d.mts

@@ -30,8 +30,8 @@ declare class NoMatchingBindingError extends DiError {
   readonly code = "NO_MATCHING_BINDING";
   readonly tokenName: string;
   readonly hint: ResolveOptions;
-  readonly availableSlots: string[];
-  constructor(tokenName: string, hint: ResolveOptions, availableSlots: string[]);
+  readonly availableSlots: Array<string>;
+  constructor(tokenName: string, hint: ResolveOptions, availableSlots: Array<string>);
 }
 /**
  * @since 0.3.16-canary.0
@@ -39,16 +39,16 @@ declare class NoMatchingBindingError extends DiError {
 declare class AmbiguousBindingError extends DiError {
   readonly code = "AMBIGUOUS_BINDING";
   readonly tokenName: string;
-  readonly candidateIds: readonly BindingIdentifier[];
-  constructor(tokenName: string, candidateIds: readonly BindingIdentifier[]);
+  readonly candidateIds: ReadonlyArray<BindingIdentifier>;
+  constructor(tokenName: string, candidateIds: ReadonlyArray<BindingIdentifier>);
 }
 /**
  * @since 0.3.16-canary.0
  */
 declare class CircularDependencyError extends DiError {
   readonly code = "CIRCULAR_DEPENDENCY";
-  readonly cycle: string[];
-  constructor(cycle: string[]);
+  readonly cycle: Array<string>;
+  constructor(cycle: Array<string>);
 }
 /**
  * @since 0.3.16-canary.0
@@ -75,7 +75,7 @@ interface ScopeViolationDetails {
   readonly consumerScope: BindingScope;
   readonly dependencyToken: string;
   readonly dependencyScope: BindingScope;
-  readonly path: string[];
+  readonly path: Array<string>;
 }
 /**
  * @since 0.3.16-canary.0
@@ -139,5 +139,15 @@ declare class DisposedContainerError extends DiError {
   readonly code = "DISPOSED_CONTAINER";
   constructor();
 }
+/**
+ * @since 0.3.16-canary.0
+ */
+declare class AsyncActivationError extends DiError {
+  readonly code = "ASYNC_ACTIVATION";
+  readonly tokenName: string;
+  readonly hookKind: "postConstruct" | "onActivation";
+  readonly methodName: string | undefined;
+  constructor(tokenName: string, hookKind: "postConstruct" | "onActivation", methodName?: string);
+}
 //#endregion
-export { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };

package/dist/errors.mjs

@@ -177,5 +177,21 @@ var DisposedContainerError = class extends DiError {
 		super("Cannot perform operations on a disposed container.");
 	}
 };
+/**
+* @since 0.3.16-canary.0
+*/
+var AsyncActivationError = class extends DiError {
+	code = "ASYNC_ACTIVATION";
+	tokenName;
+	hookKind;
+	methodName;
+	constructor(tokenName, hookKind, methodName) {
+		const detail = hookKind === "postConstruct" ? `@postConstruct method '${methodName ?? ""}' returned a Promise` : `onActivation for '${tokenName}' returned a Promise`;
+		super(`${detail}. Use resolveAsync() instead.`);
+		this.tokenName = tokenName;
+		this.hookKind = hookKind;
+		this.methodName = methodName;
+	}
+};
 //#endregion
-export { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };

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

@@ -30,8 +30,8 @@ interface ReactFlowEdge {
  * @since 0.3.16-canary.0
  */
 interface ReactFlowGraph {
-  nodes: ReactFlowNode[];
-  edges: ReactFlowEdge[];
+  nodes: Array<ReactFlowNode>;
+  edges: Array<ReactFlowEdge>;
 }
 /**
  * @since 0.3.16-canary.0

package/dist/index.d.mts

@@ -1,17 +1,18 @@
 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";
-import { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule } from "./module.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";
 import { BindingSnapshot, ContainerSnapshot } from "./inspector.mjs";
 import { MetadataReader, MutableLifecycleMetadata } from "./metadata/metadata-types.mjs";
 import { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions } from "./dependency-graph.mjs";
 import { AutoRegisterRegistry, InjectableOptions, createAutoRegisterRegistry, injectable } from "./decorators/injectable.mjs";
 import { Container, ContainerStatic } from "./container.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
-import { AmbiguousBindingError, 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 { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
+import { bindingSlotToResolveOptions, injectionSlotToResolveOptions } from "./resolve-options.mjs";
 import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
-export { type ActivationHandler, type AliasBindingBuilder, AmbiguousBindingError, 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, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName };
+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

@@ -1,11 +1,12 @@
 import { effectiveBindingScope } from "./binding-scope.mjs";
-import { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.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 { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll } from "./constraints.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 } from "./module.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, 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, isToken, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token, tokenName };
+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.d.mts

@@ -22,8 +22,7 @@ interface BindingSnapshot {
  * @since 0.3.16-canary.0
  */
 interface ContainerSnapshot {
-  readonly ownBindings: readonly BindingSnapshot[];
-  readonly bindings: readonly BindingSnapshot[];
+  readonly ownBindings: ReadonlyArray<BindingSnapshot>;
   readonly cachedSingletonCount: number;
   readonly hasParent: boolean;
   readonly isDisposed: boolean;
@@ -38,7 +37,7 @@ declare class Inspector {
   private readonly _isDisposed;
   constructor(_registry: BindingRegistry, _scope: ScopeManager, _hasParent: boolean, _isDisposed: () => boolean);
   inspect(): ContainerSnapshot;
-  lookupBindings<Value>(token: Token<Value> | Constructor<Value>): readonly BindingSnapshot[];
+  lookupBindings<Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot>;
   has(token: Token<unknown> | Constructor, hint?: ResolveOptions, parentHas?: () => boolean): boolean;
   hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
   private allBindingSnapshots;