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

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # @codefast/di
 
+## 0.3.16-canary.1
+
 ## 0.3.16-canary.0
 
 ## 0.3.15

package/README.md

@@ -203,7 +203,10 @@ container.bind(DbToken).toDynamicAsync(async (ctx) => {
 
 container
   .bind(UserServiceToken)
-  .toResolved((repo, cfg) => new UserService(repo, cfg), [UserRepository, AppConfigToken] as const);
+  .toResolved((repository, config) => new UserService(repository, config), [
+    UserRepository,
+    AppConfigToken,
+  ] as const);
 
 container
   .bind(MetricsToken)

package/dist/binding-select.d.mts

@@ -8,12 +8,12 @@ import { Binding } from "./binding.mjs";
  *
  * @since 0.3.16-canary.0
  */
-declare function selectBinding(bindings: readonly Binding[], hint: ResolveOptions | undefined, ctx: ConstraintContext, tName: string): Binding | undefined;
+declare function selectBinding(bindings: ReadonlyArray<Binding>, hint: ResolveOptions | undefined, ctx: ConstraintContext, tName: string): Binding | undefined;
 /**
  * Select all candidates matching hint + predicates.
  *
  * @since 0.3.16-canary.0
  */
-declare function selectAllBindings(bindings: readonly Binding[], hint: ResolveOptions | undefined, ctx: ConstraintContext): Binding[];
+declare function selectAllBindings(bindings: ReadonlyArray<Binding>, hint: ResolveOptions | undefined, ctx: ConstraintContext): Array<Binding>;
 //#endregion
 export { selectAllBindings, selectBinding };

package/dist/binding.d.mts

@@ -64,8 +64,8 @@ interface DynamicAsyncBinding<Value> extends BindingBase<Value> {
  */
 interface ResolvedBinding<Value> extends BindingBase<Value> {
   readonly kind: "resolved";
-  readonly factory: (...args: unknown[]) => Value;
-  readonly deps: readonly InjectionDescriptor[];
+  readonly factory: (...args: Array<unknown>) => Value;
+  readonly deps: ReadonlyArray<InjectionDescriptor>;
   readonly scope: BindingScope;
   readonly onActivation?: ActivationHandler<Value>;
   readonly onDeactivation?: DeactivationHandler<Value>;
@@ -75,8 +75,8 @@ interface ResolvedBinding<Value> extends BindingBase<Value> {
  */
 interface ResolvedAsyncBinding<Value> extends BindingBase<Value> {
   readonly kind: "resolved-async";
-  readonly factory: (...args: unknown[]) => Promise<Value>;
-  readonly deps: readonly InjectionDescriptor[];
+  readonly factory: (...args: Array<unknown>) => Promise<Value>;
+  readonly deps: ReadonlyArray<InjectionDescriptor>;
   readonly scope: BindingScope;
   readonly onActivation?: ActivationHandler<Value>;
   readonly onDeactivation?: DeactivationHandler<Value>;
@@ -121,8 +121,8 @@ interface BindToBuilder<Value> {
   toConstantValue(value: Value): ConstantBindingBuilder<Value>;
   toDynamic(factory: (ctx: ResolutionContext) => Value): BindingBuilder<Value>;
   toDynamicAsync(factory: (ctx: ResolutionContext) => Promise<Value>): BindingBuilder<Value>;
-  toResolved<const Deps extends readonly DependencyKey[]>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Value, deps: Deps): BindingBuilder<Value>;
-  toResolvedAsync<const Deps extends readonly DependencyKey[]>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Promise<Value>, deps: Deps): BindingBuilder<Value>;
+  toResolved<const Deps extends ReadonlyArray<DependencyKey>>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Value, deps: Deps): BindingBuilder<Value>;
+  toResolvedAsync<const Deps extends ReadonlyArray<DependencyKey>>(factory: (...args: { [K in keyof Deps]: TokenValue<NoInfer<Deps>[K]> }) => Promise<Value>, deps: Deps): BindingBuilder<Value>;
   toAlias(target: Token<Value> | Constructor<Value>): AliasBindingBuilder;
 }
 /**

package/dist/constraints.d.mts

@@ -6,34 +6,50 @@ import { ConstraintContext } from "./types.mjs";
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenParentIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenParentIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenNoParentIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenNoParentIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenAnyAncestorIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenNoAncestorIs(t: Token<unknown> | Constructor): (ctx: ConstraintContext) => boolean;
+declare function whenNoAncestorIs(token: Token<unknown> | Constructor): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenParentNamed(name: string): (ctx: ConstraintContext) => boolean;
+declare function whenParentNamed(name: string): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenAnyAncestorNamed(name: string): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorNamed(name: string): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenParentTagged(tag: string, value: unknown): (ctx: ConstraintContext) => boolean;
+declare function whenParentTagged(tag: string, value: unknown): (constraintContext: ConstraintContext) => boolean;
 /**
  * @since 0.3.16-canary.0
  */
-declare function whenAnyAncestorTagged(tag: string, value: unknown): (ctx: ConstraintContext) => boolean;
+declare function whenAnyAncestorTagged(tag: string, value: unknown): (constraintContext: ConstraintContext) => boolean;
+/**
+ * Matches when the direct parent slot carries **all** of the given tag pairs.
+ * Equivalent to AND-composing multiple `whenParentTagged` calls but evaluates
+ * in a single predicate invocation — no intermediate closure allocations.
+ *
+ * @since 0.3.16-canary.1
+ */
+declare function whenParentTaggedAll(tags: ReadonlyArray<readonly [tag: string, value: unknown]>): (constraintContext: ConstraintContext) => boolean;
+/**
+ * Matches when at least one ancestor slot carries **all** of the given tag pairs.
+ * Equivalent to AND-composing multiple `whenAnyAncestorTagged` calls but evaluates
+ * in a single predicate invocation — no intermediate closure allocations.
+ *
+ * @since 0.3.16-canary.1
+ */
+declare function whenAnyAncestorTaggedAll(tags: ReadonlyArray<readonly [tag: string, value: unknown]>): (constraintContext: ConstraintContext) => boolean;
 //#endregion
-export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged };
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/constraints.mjs

@@ -1,59 +1,87 @@
 import { tokenName } from "./token.mjs";
 //#region src/constraints.ts
-function tokenNameOf(t) {
-	return tokenName(t);
+function tokenNameOf(token) {
+	return tokenName(token);
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenParentIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.parent !== void 0 && ctx.parent.tokenName === name;
+function whenParentIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.parent !== void 0 && constraintContext.parent.tokenName === tokenDisplayName;
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenNoParentIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.parent === void 0 || ctx.parent.tokenName !== name;
+function whenNoParentIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.parent === void 0 || constraintContext.parent.tokenName !== tokenDisplayName;
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenAnyAncestorIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.ancestors.some((f) => f.tokenName === name);
+function whenAnyAncestorIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.tokenName === tokenDisplayName);
 }
 /**
 * @since 0.3.16-canary.0
 */
-function whenNoAncestorIs(t) {
-	const name = tokenNameOf(t);
-	return (ctx) => ctx.ancestors.every((f) => f.tokenName !== name);
+function whenNoAncestorIs(token) {
+	const tokenDisplayName = tokenNameOf(token);
+	return (constraintContext) => constraintContext.ancestors.every((ancestorFrame) => ancestorFrame.tokenName !== tokenDisplayName);
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenParentNamed(name) {
-	return (ctx) => ctx.parent !== void 0 && ctx.parent.slot.name === name;
+	return (constraintContext) => constraintContext.parent !== void 0 && constraintContext.parent.slot.name === name;
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenAnyAncestorNamed(name) {
-	return (ctx) => ctx.ancestors.some((f) => f.slot.name === name);
+	return (constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.slot.name === name);
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenParentTagged(tag, value) {
-	return (ctx) => ctx.parent !== void 0 && ctx.parent.slot.tags.some(([t, v]) => t === tag && Object.is(v, value));
+	return (constraintContext) => constraintContext.parent !== void 0 && constraintContext.parent.slot.tags.some(([tagKey, tagValue]) => tagKey === tag && Object.is(tagValue, value));
 }
 /**
 * @since 0.3.16-canary.0
 */
 function whenAnyAncestorTagged(tag, value) {
-	return (ctx) => ctx.ancestors.some((f) => f.slot.tags.some(([t, v]) => t === tag && Object.is(v, value)));
+	return (constraintContext) => constraintContext.ancestors.some((ancestorFrame) => ancestorFrame.slot.tags.some(([tagKey, tagValue]) => tagKey === tag && Object.is(tagValue, value)));
+}
+/**
+* Matches when the direct parent slot carries **all** of the given tag pairs.
+* Equivalent to AND-composing multiple `whenParentTagged` calls but evaluates
+* in a single predicate invocation — no intermediate closure allocations.
+*
+* @since 0.3.16-canary.1
+*/
+function whenParentTaggedAll(tags) {
+	return (constraintContext) => {
+		const { parent } = constraintContext;
+		if (parent === void 0) return false;
+		const { tags: parentTags } = parent.slot;
+		return tags.every(([tagKey, tagValue]) => parentTags.some(([k, v]) => k === tagKey && Object.is(v, tagValue)));
+	};
+}
+/**
+* Matches when at least one ancestor slot carries **all** of the given tag pairs.
+* Equivalent to AND-composing multiple `whenAnyAncestorTagged` calls but evaluates
+* in a single predicate invocation — no intermediate closure allocations.
+*
+* @since 0.3.16-canary.1
+*/
+function whenAnyAncestorTaggedAll(tags) {
+	return (constraintContext) => constraintContext.ancestors.some((frame) => {
+		const { tags: frameTags } = frame.slot;
+		return tags.every(([tagKey, tagValue]) => frameTags.some(([k, v]) => k === tagKey && Object.is(v, tagValue)));
+	});
 }
 //#endregion
-export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged };
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll };

package/dist/constructor-type.d.mts

@@ -8,7 +8,7 @@
  *
  * @since 0.3.16-canary.0
  */
-type Constructor<Value = unknown> = new (...args: never[]) => Value;
+type Constructor<Value = unknown> = new (...args: Array<never>) => Value;
 /**
  * Class constructor as invoked by the resolver after metadata-driven
  * resolution of `unknown[]` dependencies — separate from {@link Constructor},
@@ -16,6 +16,6 @@ type Constructor<Value = unknown> = new (...args: never[]) => Value;
  *
  * @since 0.3.16-canary.0
  */
-type ConstructorInvocation = new (...args: unknown[]) => unknown;
+type ConstructorInvocation = new (...args: Array<unknown>) => unknown;
 //#endregion
 export { Constructor, ConstructorInvocation };

package/dist/container.d.mts

@@ -19,9 +19,9 @@ interface Container {
   unbindAll(): void;
   unbindAllAsync(): Promise<void>;
   rebind<const Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
-  load(...modules: SyncModule[]): void;
+  load(...modules: Array<SyncModule>): void;
   loadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void>;
-  unload(...modules: SyncModule[]): void;
+  unload(...modules: Array<SyncModule>): void;
   unloadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void>;
   loadAutoRegistered(registry: AutoRegisterRegistry): number;
   onActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
@@ -30,8 +30,8 @@ interface Container {
   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>>;
   createChild(): Container;
   dispose(): Promise<void>;
   [Symbol.asyncDispose](): Promise<void>;
@@ -40,7 +40,7 @@ interface Container {
   validate(): void;
   has(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
   hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
-  lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): readonly BindingSnapshot[];
+  lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot>;
   inspect(): ContainerSnapshot;
   generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;
 }
@@ -49,7 +49,7 @@ interface Container {
  */
 interface ContainerStatic {
   create(): Container;
-  fromModules(...modules: SyncModule[]): Container;
+  fromModules(...modules: Array<SyncModule>): Container;
   fromModulesAsync(...modules: Array<SyncModule | AsyncModule>): Promise<Container>;
 }
 /**

package/dist/container.mjs

@@ -1,11 +1,11 @@
 import { effectiveBindingScope } from "./binding-scope.mjs";
-import { DisposedContainerError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
+import { AsyncModuleLoadError, CircularDependencyError, DisposedContainerError, InternalError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
 import { DEFAULT_SLOT, generateBindingId } from "./binding.mjs";
 import { tokenName } from "./token.mjs";
 import { BindingRegistry } from "./registry.mjs";
 import { ScopeManager } from "./scope.mjs";
 import { LifecycleManager } from "./lifecycle.mjs";
-import { slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
 import { DependencyResolver } from "./resolver.mjs";
 import { Inspector } from "./inspector.mjs";
 import { buildDependencyGraph } from "./dependency-graph.mjs";
@@ -142,6 +142,7 @@ var DefaultContainer = class DefaultContainer {
 	_loadSyncModules(modules) {
 		const toLoad = this._collectModuleDeps(modules);
 		for (const mod of toLoad) {
+			if (!isSyncModule(mod)) throw new AsyncModuleLoadError(mod.name);
 			const ref = mod;
 			const existing = this._moduleRefs.get(ref);
 			if (existing !== void 0) {
@@ -332,43 +333,116 @@ var DefaultContainer = class DefaultContainer {
 		const reader = this._getMetadataReader();
 		const allBindings = this._registry.allBindings();
 		for (const binding of allBindings) {
-			if (binding.kind === "alias" || binding.kind === "constant" || binding.kind === "dynamic" || binding.kind === "dynamic-async") continue;
-			const scope = effectiveBindingScope(binding);
-			if (scope !== "singleton") continue;
-			const deps = this._getDepsForBinding(binding, reader);
-			for (const dep of deps) this._validateDep(tokenName(binding.token), scope, dep, [tokenName(binding.token)], reader);
+			if (!this._isSingletonStaticAnalyzableBinding(binding)) continue;
+			this._validateSingletonBindingGraph(binding, reader);
 		}
 	}
-	_getDepsForBinding(binding, reader) {
-		const result = [];
-		if (binding.kind === "class") {
-			const meta = reader.getConstructorMetadata(binding.target);
-			if (meta !== void 0) for (const param of meta.params) {
-				const depBindings = this._registry.getAll(param.token);
-				for (const db of depBindings) if (db.kind !== "alias") result.push({
-					token: param.token,
-					scope: effectiveBindingScope(db)
+	_isSingletonStaticAnalyzableBinding(binding) {
+		if (effectiveBindingScope(binding) !== "singleton") return false;
+		return binding.kind === "class" || binding.kind === "resolved" || binding.kind === "resolved-async";
+	}
+	/**
+	* DFS over explicit constructor / `toResolved*` dependency edges. Follows `toAlias` chains to the
+	* terminal binding for scope checks (SPEC §6.9). Skips `toDynamic*` subtrees (opaque).
+	*/
+	_validateSingletonBindingGraph(root, reader) {
+		const rootName = tokenName(root.token);
+		const dfs = (current, pathNames, pathBindingIds) => {
+			if (pathBindingIds.has(current.id)) return;
+			const extendedPathIds = new Set(pathBindingIds);
+			extendedPathIds.add(current.id);
+			for (const edge of this._collectStaticDependencyEdges(current, reader)) {
+				const { terminal, depTokenName } = edge;
+				const depScope = this._validationScopeFromTerminal(terminal);
+				if (depScope === "opaque") continue;
+				if (depScope === "scoped" || depScope === "transient") throw new ScopeViolationError({
+					consumerToken: rootName,
+					consumerScope: "singleton",
+					dependencyToken: depTokenName,
+					dependencyScope: depScope,
+					path: [...pathNames, depTokenName]
 				});
+				if (terminal.kind === "class" || terminal.kind === "resolved" || terminal.kind === "resolved-async") dfs(terminal, [...pathNames, depTokenName], extendedPathIds);
 			}
-		} else if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
-			const depBindings = this._registry.getAll(dep.token);
-			for (const db of depBindings) if (db.kind !== "alias") result.push({
-				token: dep.token,
-				scope: effectiveBindingScope(db)
-			});
+		};
+		dfs(root, [rootName], /* @__PURE__ */ new Set());
+	}
+	_validationScopeFromTerminal(terminal) {
+		switch (terminal.kind) {
+			case "constant": return "singleton";
+			case "dynamic":
+			case "dynamic-async": return "opaque";
+			case "class":
+			case "resolved":
+			case "resolved-async": return terminal.scope;
+			case "alias": throw new InternalError("validate: expected terminal binding after alias resolution");
+			default: return terminal;
 		}
-		return result;
 	}
-	_validateDep(consumerToken, consumerScope, dep, path, _reader) {
-		if (consumerScope === "singleton") {
-			if (dep.scope === "scoped" || dep.scope === "transient") throw new ScopeViolationError({
-				consumerToken,
-				consumerScope,
-				dependencyToken: tokenName(dep.token),
-				dependencyScope: dep.scope,
-				path
+	_followAliasChainToTerminal(binding, hint) {
+		const cyclePath = [];
+		const seenAliasIds = /* @__PURE__ */ new Set();
+		let current = binding;
+		while (current !== void 0 && current.kind === "alias") {
+			if (seenAliasIds.has(current.id)) throw new CircularDependencyError(cyclePath);
+			seenAliasIds.add(current.id);
+			cyclePath.push(tokenName(current.token));
+			const nextToken = current.target;
+			const next = this._resolver.peekBindingForValidate(nextToken, hint);
+			if (next === void 0) return;
+			current = next.binding;
+		}
+		return current;
+	}
+	_collectStaticDependencyEdges(binding, reader) {
+		const edges = [];
+		const pushTerminal = (terminal, displayName) => {
+			if (terminal === void 0) return;
+			edges.push({
+				terminal,
+				depTokenName: displayName
 			});
+		};
+		if (binding.kind === "class") {
+			const meta = reader.getConstructorMetadata(binding.target);
+			if (meta === void 0) return edges;
+			for (const param of meta.params) {
+				const paramHint = injectableSlotToResolveOptions(param);
+				if (param.optional) continue;
+				const tokenRef = param.token;
+				if (param.multi) {
+					const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, paramHint);
+					for (const cand of candidates) {
+						const term = this._followAliasChainToTerminal(cand, paramHint);
+						pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+					}
+					continue;
+				}
+				const found = paramHint === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, paramHint);
+				if (found === void 0) continue;
+				const term = this._followAliasChainToTerminal(found.binding, paramHint);
+				pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+			}
+			return edges;
 		}
+		if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
+			const depHint = injectableSlotToResolveOptions(dep);
+			if (dep.optional) continue;
+			const tokenRef = dep.token;
+			if (dep.multi) {
+				const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, depHint);
+				for (const cand of candidates) {
+					const term = this._followAliasChainToTerminal(cand, depHint);
+					pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+				}
+				continue;
+			}
+			const found = depHint === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, depHint);
+			if (found === void 0) continue;
+			const term = this._followAliasChainToTerminal(found.binding, depHint);
+			pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+		}
+		return edges;
 	}
 	has(token, hint) {
 		this._assertNotDisposed();
@@ -394,7 +468,19 @@ var DefaultContainer = class DefaultContainer {
 		if (this._disposed) throw new DisposedContainerError();
 	}
 };
+function updateSlotTag(slot, tag, value) {
+	const existing = [...slot.tags];
+	const idx = existing.findIndex(([k]) => k === tag);
+	if (idx !== -1) existing[idx] = [tag, value];
+	else existing.push([tag, value]);
+	return {
+		...slot,
+		tags: existing
+	};
+}
 var BindToBuilderImpl = class {
+	_token;
+	_commit;
 	constructor(_token, _commit) {
 		this._token = _token;
 		this._commit = _commit;
@@ -454,6 +540,9 @@ var BindToBuilderImpl = class {
 	}
 };
 var BindingBuilderImpl = class {
+	_token;
+	_partial;
+	_commit;
 	_slot;
 	_predicate;
 	_committed;
@@ -492,14 +581,7 @@ var BindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}
@@ -535,6 +617,13 @@ var BindingBuilderImpl = class {
 	}
 };
 var ScopeBuilderImpl = class {
+	_token;
+	_partial;
+	_slot;
+	_predicate;
+	_commit;
+	_scope;
+	_initialPreviousId;
 	_onActivation;
 	_onDeactivation;
 	_committed;
@@ -576,6 +665,9 @@ var ScopeBuilderImpl = class {
 	}
 };
 var ConstantBindingBuilderImpl = class {
+	_token;
+	_value;
+	_commit;
 	_slot;
 	_predicate;
 	_onActivation;
@@ -620,14 +712,7 @@ var ConstantBindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}
@@ -649,6 +734,9 @@ var ConstantBindingBuilderImpl = class {
 	}
 };
 var AliasBindingBuilderImpl = class {
+	_token;
+	_target;
+	_commit;
 	_slot;
 	_predicate;
 	_committed;
@@ -688,14 +776,7 @@ var AliasBindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}

package/dist/decorators/inject.d.mts

@@ -35,14 +35,14 @@ type ClassAccessorDecorator<This, Value> = (target: ClassAccessorDecoratorTarget
 /**
  * @since 0.3.16-canary.0
  */
-declare function inject<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
+declare function inject<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
 /**
  * @since 0.3.16-canary.0
  */
-declare function optional<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value | undefined>;
+declare function optional<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value | undefined>;
 /**
  * @since 0.3.16-canary.0
  */
-declare function injectAll<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value[]>;
+declare function injectAll<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Array<Value>>;
 //#endregion
 export { InjectOptions, InjectableDependency, InjectionDescriptor, inject, injectAll, isInjectionDescriptor, normalizeToDescriptor, optional };