@codefast/di 0.5.0-canary.3 → 0.5.0-canary.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @codefast/di
 
+## 0.5.0-canary.4
+
+### Minor Changes
+
+- [`4f7a188`](https://github.com/codefastlabs/codefast/commit/4f7a188a5f4a281882606f11ed660aecb9844753) Thanks [@thevuong](https://github.com/thevuong)! - Rename the `hint` resolve parameter to `options` throughout — "hint" implied optional guidance the container may ignore, but the value is a hard selection criterion (`resolve` throws `NoMatchingBindingError` when nothing matches), so the name misstated its role. Positional call sites are unaffected; the one breaking surface is `NoMatchingBindingError.hint`, now `NoMatchingBindingError.options`.
+
 ## 0.5.0-canary.3
 
 ## 0.5.0-canary.2

package/README.md

@@ -239,7 +239,7 @@ container.bind(LoggerToken).toConstantValue(consoleLogger).whenNamed("console");
 container.resolve(LoggerToken, { name: "file" });
 ```
 
-**Tagged** — the hint is a tuple `[tag, value]`:
+**Tagged** — the tag option is a tuple `[tag, value]`:
 
 ```typescript
 container.bind(StorageToken).to(S3Storage).whenTagged("provider", "s3");
@@ -250,7 +250,7 @@ container.resolve(StorageToken, { tag: ["provider", "s3"] });
 
 **Default slot**
 
-`.whenDefault()` is a documentation-only marker — it is a no-op at runtime. A binding without any constraint already participates in resolution when no `name` / `tag` hint is provided. Use it to signal intent when mixing constrained and unconstrained bindings for the same token.
+`.whenDefault()` is a documentation-only marker — it is a no-op at runtime. A binding without any constraint already participates in resolution when no `name` / `tag` option is provided. Use it to signal intent when mixing constrained and unconstrained bindings for the same token.
 
 **Predicate** — inspect the full resolution graph:
 
@@ -590,7 +590,7 @@ All errors extend `DiError` and expose a stable `code` property.
 | `MissingContainerContextError`  | `"MISSING_CONTAINER_CONTEXT"`   | `@inject` accessor resolved without an active container                 |
 | `MissingMetadataError`          | `"MISSING_METADATA"`            | Class resolution missing `@injectable()` metadata                       |
 | `MissingScopeContextError`      | `"MISSING_SCOPE_CONTEXT"`       | `scoped` binding resolved without a child container context             |
-| `NoMatchingBindingError`        | `"NO_MATCHING_BINDING"`         | Hint matches no registered binding                                      |
+| `NoMatchingBindingError`        | `"NO_MATCHING_BINDING"`         | Resolve options match no registered binding                             |
 | `RebindUnboundTokenError`       | `"REBIND_UNBOUND_TOKEN"`        | `rebind` targets a token with no binding owned by this container        |
 | `ScopeViolationError`           | `"SCOPE_VIOLATION"`             | Captive dependency found by `validate()` (`details` describes the path) |
 | `SyncDisposalNotSupportedError` | `"SYNC_DISPOSAL_NOT_SUPPORTED"` | Sync `using` / `[Symbol.dispose]` on the container                      |

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: ReadonlyArray<Binding>, hint: ResolveOptions | undefined, ctx: ConstraintContext, tokenDisplayName: string): Binding | undefined;
+declare function selectBinding(bindings: ReadonlyArray<Binding>, options: ResolveOptions | undefined, ctx: ConstraintContext, tokenDisplayName: string): Binding | undefined;
 /**
- * Select all candidates matching hint + predicates.
+ * Select all candidates matching options + predicates.
  *
  * @since 0.3.16-canary.0
  */
-declare function selectAllBindings(bindings: ReadonlyArray<Binding>, hint: ResolveOptions | undefined, ctx: ConstraintContext): Array<Binding>;
+declare function selectAllBindings(bindings: ReadonlyArray<Binding>, options: ResolveOptions | undefined, ctx: ConstraintContext): Array<Binding>;
 //#endregion
 export { selectAllBindings, selectBinding };

package/dist/binding-select.mjs

@@ -6,61 +6,61 @@ import { AmbiguousBindingError } from "./errors.mjs";
 *
 * @since 0.3.16-canary.0
 */
-function selectBinding(bindings, hint, ctx, tokenDisplayName) {
-	const candidates = filterBindings(bindings, hint, ctx);
+function selectBinding(bindings, options, ctx, tokenDisplayName) {
+	const candidates = filterBindings(bindings, options, ctx);
 	if (candidates.length === 0) return;
 	if (candidates.length === 1) return candidates[0];
 	throw new AmbiguousBindingError(tokenDisplayName, candidates.map((c) => c.id));
 }
 /**
-* Select all candidates matching hint + predicates.
+* Select all candidates matching options + predicates.
 *
 * @since 0.3.16-canary.0
 */
-function selectAllBindings(bindings, hint, ctx) {
-	return filterBindings(bindings, hint, ctx, "all");
+function selectAllBindings(bindings, options, ctx) {
+	return filterBindings(bindings, options, ctx, "all");
 }
-function filterBindings(bindings, hint, ctx, selectionMode = "single") {
-	if (hint === void 0) {
-		const resultWithoutHint = [];
+function filterBindings(bindings, options, ctx, selectionMode = "single") {
+	if (options === void 0) {
+		const resultWithoutOptions = [];
 		if (selectionMode === "all") {
-			for (const binding of bindings) if (matchesPredicate(binding, ctx)) resultWithoutHint.push(binding);
+			for (const binding of bindings) if (matchesPredicate(binding, ctx)) resultWithoutOptions.push(binding);
 		} else for (const binding of bindings) {
 			const slot = binding.slot;
-			if (slot.name === void 0 && slot.tags.length === 0 && matchesPredicate(binding, ctx)) resultWithoutHint.push(binding);
+			if (slot.name === void 0 && slot.tags.length === 0 && matchesPredicate(binding, ctx)) resultWithoutOptions.push(binding);
 		}
-		return resultWithoutHint;
+		return resultWithoutOptions;
 	}
 	const result = [];
-	for (const binding of bindings) if ((selectionMode === "all" ? matchesSlotForResolveAll(binding, hint) : matchesSlot(binding, hint)) && matchesPredicate(binding, ctx)) result.push(binding);
+	for (const binding of bindings) if ((selectionMode === "all" ? matchesSlotForResolveAll(binding, options) : matchesSlot(binding, options)) && matchesPredicate(binding, ctx)) result.push(binding);
 	return result;
 }
-function matchesSlotForResolveAll(binding, hint) {
-	if (!(hint !== void 0 && (hint.name !== void 0 || hint.tags !== void 0 && hint.tags.length > 0 || hint.tag !== void 0))) return true;
-	return matchesSlot(binding, hint);
+function matchesSlotForResolveAll(binding, options) {
+	if (!(options !== void 0 && (options.name !== void 0 || options.tags !== void 0 && options.tags.length > 0 || options.tag !== void 0))) return true;
+	return matchesSlot(binding, options);
 }
-function matchesSlot(binding, hint) {
+function matchesSlot(binding, options) {
 	const slot = binding.slot;
-	const hintName = hint?.name;
-	const hintTags = hint?.tags;
-	const singleHintTag = hint?.tag;
-	const hasHintTags = (hintTags?.length ?? 0) > 0 || singleHintTag !== void 0;
+	const requestedName = options?.name;
+	const requestedTags = options?.tags;
+	const singleRequestedTag = options?.tag;
+	const hasRequestedTags = (requestedTags?.length ?? 0) > 0 || singleRequestedTag !== void 0;
 	if (slot.name !== void 0) {
-		if (hintName === void 0) return false;
-		if (slot.name !== hintName) return false;
-	} else if (hintName !== void 0) return false;
+		if (requestedName === void 0) return false;
+		if (slot.name !== requestedName) return false;
+	} else if (requestedName !== void 0) return false;
 	if (slot.tags.length > 0) {
-		if (!hasHintTags) return false;
-		for (const [tagKey, tagValue] of slot.tags) if (!matchHintTag(tagKey, tagValue, hintTags, singleHintTag)) return false;
-	} else if (hasHintTags) return false;
+		if (!hasRequestedTags) return false;
+		for (const [tagKey, tagValue] of slot.tags) if (!matchesRequestedTag(tagKey, tagValue, requestedTags, singleRequestedTag)) return false;
+	} else if (hasRequestedTags) return false;
 	return true;
 }
-function matchHintTag(tagKey, tagValue, hintTags, singleHintTag) {
-	if (singleHintTag !== void 0 && singleHintTag[0] === tagKey && Object.is(singleHintTag[1], tagValue)) return true;
-	if (hintTags === void 0 || hintTags.length === 0) return false;
-	for (let index = 0; index < hintTags.length; index += 1) {
-		const hintTag = hintTags[index];
-		if (hintTag[0] === tagKey && Object.is(hintTag[1], tagValue)) return true;
+function matchesRequestedTag(tagKey, tagValue, requestedTags, singleRequestedTag) {
+	if (singleRequestedTag !== void 0 && singleRequestedTag[0] === tagKey && Object.is(singleRequestedTag[1], tagValue)) return true;
+	if (requestedTags === void 0 || requestedTags.length === 0) return false;
+	for (let index = 0; index < requestedTags.length; index += 1) {
+		const requestedTag = requestedTags[index];
+		if (requestedTag[0] === tagKey && Object.is(requestedTag[1], tagValue)) return true;
 	}
 	return false;
 }

package/dist/container.d.mts

@@ -26,20 +26,20 @@ interface Container {
   loadAutoRegistered(registry: AutoRegisterRegistry): number;
   onActivation<const Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
   onDeactivation<const Value>(token: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): 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): Array<Value>;
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Array<Value>>;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Array<Value>>;
   createChild(): Container;
   dispose(): Promise<void>;
   [Symbol.asyncDispose](): Promise<void>;
   [Symbol.dispose](): never;
   initializeAsync(): Promise<void>;
   validate(): void;
-  has(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
-  hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
+  has(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean;
+  hasOwn(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean;
   lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot>;
   inspect(): ContainerSnapshot;
   generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;

package/dist/container.mjs

@@ -262,31 +262,31 @@ var DefaultContainer = class DefaultContainer {
 		this._assertNotDisposed();
 		this._lifecycle.registerDeactivation(token, handler);
 	}
-	resolve(token, hint) {
+	resolve(token, options) {
 		this._assertNotDisposed();
-		if (hint === void 0) return this._resolver.resolveFromContext(token, [], []);
-		return this._resolver.resolve(token, hint, [], []);
+		if (options === void 0) return this._resolver.resolveFromContext(token, [], []);
+		return this._resolver.resolve(token, options, [], []);
 	}
-	resolveAsync(token, hint) {
+	resolveAsync(token, options) {
 		this._assertNotDisposed();
-		if (hint === void 0) return this._resolver.resolveAsyncFromContext(token, [], []);
-		return this._resolver.resolveAsync(token, hint, [], []);
+		if (options === void 0) return this._resolver.resolveAsyncFromContext(token, [], []);
+		return this._resolver.resolveAsync(token, options, [], []);
 	}
-	resolveOptional(token, hint) {
+	resolveOptional(token, options) {
 		this._assertNotDisposed();
-		return this._resolver.resolveOptional(token, hint, [], []);
+		return this._resolver.resolveOptional(token, options, [], []);
 	}
-	resolveOptionalAsync(token, hint) {
+	resolveOptionalAsync(token, options) {
 		this._assertNotDisposed();
-		return this._resolver.resolveOptionalAsync(token, hint, [], []);
+		return this._resolver.resolveOptionalAsync(token, options, [], []);
 	}
-	resolveAll(token, hint) {
+	resolveAll(token, options) {
 		this._assertNotDisposed();
-		return this._resolver.resolveAll(token, hint, [], []);
+		return this._resolver.resolveAll(token, options, [], []);
 	}
-	resolveAllAsync(token, hint) {
+	resolveAllAsync(token, options) {
 		this._assertNotDisposed();
-		return this._resolver.resolveAllAsync(token, hint, [], []);
+		return this._resolver.resolveAllAsync(token, options, [], []);
 	}
 	createChild() {
 		this._assertNotDisposed();
@@ -316,8 +316,8 @@ var DefaultContainer = class DefaultContainer {
 			if (effectiveBindingScope(binding) === "singleton" && !this._scope.hasSingleton(binding.id)) {
 				if (binding.predicate !== void 0) continue;
 				if (binding.kind === "constant" && binding.onActivation === void 0) continue;
-				const slotHint = bindingSlotToResolveOptions(binding.slot);
-				await this.resolveAsync(binding.token, slotHint);
+				const slotOptions = bindingSlotToResolveOptions(binding.slot);
+				await this.resolveAsync(binding.token, slotOptions);
 			}
 		}
 	}
@@ -372,7 +372,7 @@ var DefaultContainer = class DefaultContainer {
 			default: return terminal;
 		}
 	}
-	_followAliasChainToTerminal(binding, hint) {
+	_followAliasChainToTerminal(binding, options) {
 		const cyclePath = [];
 		const seenAliasIds = /* @__PURE__ */ new Set();
 		let current = binding;
@@ -381,7 +381,7 @@ var DefaultContainer = class DefaultContainer {
 			seenAliasIds.add(current.id);
 			cyclePath.push(tokenName(current.token));
 			const nextToken = current.target;
-			const next = this._resolver.peekBindingForValidate(nextToken, hint);
+			const next = this._resolver.peekBindingForValidate(nextToken, options);
 			if (next === void 0) return;
 			current = next.binding;
 		}
@@ -400,50 +400,50 @@ var DefaultContainer = class DefaultContainer {
 			const meta = reader.getConstructorMetadata(binding.target);
 			if (meta === void 0) return edges;
 			for (const param of meta.params) {
-				const paramHint = injectionSlotToResolveOptions(param);
+				const paramOptions = injectionSlotToResolveOptions(param);
 				if (param.optional) continue;
 				const tokenRef = param.token;
 				if (param.multi) {
-					const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, paramHint);
+					const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, paramOptions);
 					for (const cand of candidates) {
-						const term = this._followAliasChainToTerminal(cand, paramHint);
+						const term = this._followAliasChainToTerminal(cand, paramOptions);
 						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);
+				const found = paramOptions === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, paramOptions);
 				if (found === void 0) continue;
-				const term = this._followAliasChainToTerminal(found.binding, paramHint);
+				const term = this._followAliasChainToTerminal(found.binding, paramOptions);
 				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 = injectionSlotToResolveOptions(dep);
+			const depOptions = injectionSlotToResolveOptions(dep);
 			if (dep.optional) continue;
 			const tokenRef = dep.token;
 			if (dep.multi) {
-				const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, depHint);
+				const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, depOptions);
 				for (const cand of candidates) {
-					const term = this._followAliasChainToTerminal(cand, depHint);
+					const term = this._followAliasChainToTerminal(cand, depOptions);
 					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);
+			const found = depOptions === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, depOptions);
 			if (found === void 0) continue;
-			const term = this._followAliasChainToTerminal(found.binding, depHint);
+			const term = this._followAliasChainToTerminal(found.binding, depOptions);
 			pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
 		}
 		return edges;
 	}
-	has(token, hint) {
+	has(token, options) {
 		this._assertNotDisposed();
-		return this._inspector.has(token, hint, () => this._parent?.has(token, hint) ?? false);
+		return this._inspector.has(token, options, () => this._parent?.has(token, options) ?? false);
 	}
-	hasOwn(token, hint) {
+	hasOwn(token, options) {
 		this._assertNotDisposed();
-		return this._inspector.hasOwn(token, hint);
+		return this._inspector.hasOwn(token, options);
 	}
 	lookupBindings(token) {
 		this._assertNotDisposed();

package/dist/decorators/inject.mjs

@@ -93,11 +93,11 @@ function inject(token, options) {
 		context.addInitializer(function() {
 			const container = getActiveContainer();
 			if (container === void 0) throw new MissingContainerContextError(String(context.name));
-			const hint = options === void 0 ? void 0 : injectionSlotToResolveOptions({
+			const resolveOptions = 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(token, hint) : container.resolve(token, hint);
+			const value = descriptor.optional ? container.resolveOptional(token, resolveOptions) : container.resolve(token, resolveOptions);
 			context.access.set(this, value);
 		});
 		return {};

package/dist/environment.d.mts

@@ -17,13 +17,13 @@ declare function getActiveContainer(): Container | undefined;
  */
 interface ResolverCallbacks {
   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;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, options: 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>>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Array<Value>>;
 }
 /**
  * @since 0.3.16-canary.0
@@ -32,17 +32,17 @@ declare class DefaultResolutionContext implements ResolutionContext {
   private _resolver;
   private _resolutionPath;
   private _resolutionStack;
-  private _currentHint;
-  constructor(resolver: ResolverCallbacks, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>, currentHint: ResolveOptions | undefined);
+  private _currentOptions;
+  constructor(resolver: ResolverCallbacks, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>, currentOptions: ResolveOptions | undefined);
   private _graph;
   get graph(): ConstraintContext;
-  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): Array<Value>;
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Array<Value>>;
+  reset(resolver: ResolverCallbacks, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>, currentOptions: ResolveOptions | undefined): void;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Array<Value>>;
 }
 /**
  * @since 0.3.16-canary.0

package/dist/environment.mjs

@@ -25,56 +25,56 @@ var DefaultResolutionContext = class {
 	_resolver;
 	_resolutionPath;
 	_resolutionStack;
-	_currentHint;
-	constructor(resolver, resolutionPath, resolutionStack, currentHint) {
+	_currentOptions;
+	constructor(resolver, resolutionPath, resolutionStack, currentOptions) {
 		this._resolver = resolver;
 		this._resolutionPath = resolutionPath;
 		this._resolutionStack = resolutionStack;
-		this._currentHint = currentHint;
+		this._currentOptions = currentOptions;
 	}
 	_graph;
 	get graph() {
-		if (this._graph === void 0) this._graph = new DefaultConstraintContext(this._resolutionPath, this._resolutionStack, this._currentHint);
+		if (this._graph === void 0) this._graph = new DefaultConstraintContext(this._resolutionPath, this._resolutionStack, this._currentOptions);
 		return this._graph;
 	}
-	reset(resolver, resolutionPath, resolutionStack, currentHint) {
+	reset(resolver, resolutionPath, resolutionStack, currentOptions) {
 		this._resolver = resolver;
 		this._resolutionPath = resolutionPath;
 		this._resolutionStack = resolutionStack;
-		this._currentHint = currentHint;
+		this._currentOptions = currentOptions;
 		this._graph = void 0;
 	}
-	resolve(token, hint) {
-		if (hint === void 0) return this._resolver.resolveFromContext(token, this._resolutionPath, this._resolutionStack);
-		return this._resolver.resolve(token, hint, this._resolutionPath, this._resolutionStack);
+	resolve(token, options) {
+		if (options === void 0) return this._resolver.resolveFromContext(token, this._resolutionPath, this._resolutionStack);
+		return this._resolver.resolve(token, options, this._resolutionPath, this._resolutionStack);
 	}
-	resolveAsync(token, hint) {
-		if (hint === void 0) return this._resolver.resolveAsyncFromContext(token, this._resolutionPath, this._resolutionStack);
-		return this._resolver.resolveAsync(token, hint, this._resolutionPath, this._resolutionStack);
+	resolveAsync(token, options) {
+		if (options === void 0) return this._resolver.resolveAsyncFromContext(token, this._resolutionPath, this._resolutionStack);
+		return this._resolver.resolveAsync(token, options, this._resolutionPath, this._resolutionStack);
 	}
-	resolveOptional(token, hint) {
-		return this._resolver.resolveOptional(token, hint, this._resolutionPath, this._resolutionStack);
+	resolveOptional(token, options) {
+		return this._resolver.resolveOptional(token, options, this._resolutionPath, this._resolutionStack);
 	}
-	resolveOptionalAsync(token, hint) {
-		return this._resolver.resolveOptionalAsync(token, hint, this._resolutionPath, this._resolutionStack);
+	resolveOptionalAsync(token, options) {
+		return this._resolver.resolveOptionalAsync(token, options, this._resolutionPath, this._resolutionStack);
 	}
-	resolveAll(token, hint) {
-		return this._resolver.resolveAll(token, hint, this._resolutionPath, this._resolutionStack);
+	resolveAll(token, options) {
+		return this._resolver.resolveAll(token, options, this._resolutionPath, this._resolutionStack);
 	}
-	resolveAllAsync(token, hint) {
-		return this._resolver.resolveAllAsync(token, hint, this._resolutionPath, this._resolutionStack);
+	resolveAllAsync(token, options) {
+		return this._resolver.resolveAllAsync(token, options, this._resolutionPath, this._resolutionStack);
 	}
 };
 var DefaultConstraintContext = class {
 	resolutionPath;
 	resolutionStack;
 	parent;
-	currentResolveHint;
-	constructor(resolutionPath, resolutionStack, currentResolveHint) {
+	currentResolveOptions;
+	constructor(resolutionPath, resolutionStack, currentResolveOptions) {
 		this.resolutionPath = resolutionPath;
 		this.resolutionStack = resolutionStack;
 		this.parent = resolutionStack.at(-1);
-		this.currentResolveHint = currentResolveHint;
+		this.currentResolveOptions = currentResolveOptions;
 	}
 	_ancestors;
 	get ancestors() {

package/dist/errors.d.mts

@@ -29,9 +29,9 @@ declare class TokenNotBoundError extends DiError {
 declare class NoMatchingBindingError extends DiError {
   readonly code = "NO_MATCHING_BINDING";
   readonly tokenName: string;
-  readonly hint: ResolveOptions;
+  readonly options: ResolveOptions;
   readonly availableSlots: Array<string>;
-  constructor(tokenName: string, hint: ResolveOptions, availableSlots: Array<string>);
+  constructor(tokenName: string, options: ResolveOptions, availableSlots: Array<string>);
 }
 /**
  * @since 0.3.16-canary.0

package/dist/errors.mjs

@@ -34,14 +34,14 @@ var TokenNotBoundError = class extends DiError {
 var NoMatchingBindingError = class extends DiError {
 	code = "NO_MATCHING_BINDING";
 	tokenName;
-	hint;
+	options;
 	availableSlots;
-	constructor(tokenName, hint, availableSlots) {
-		const hintStr = JSON.stringify(hint);
+	constructor(tokenName, options, availableSlots) {
+		const optionsString = JSON.stringify(options);
 		const slotsStr = availableSlots.join(", ");
-		super(`No binding for '${tokenName}' matching ${hintStr}. Available slots: [${slotsStr}].`);
+		super(`No binding for '${tokenName}' matching ${optionsString}. Available slots: [${slotsStr}].`);
 		this.tokenName = tokenName;
-		this.hint = hint;
+		this.options = options;
 		this.availableSlots = availableSlots;
 	}
 };

package/dist/inspector.d.mts

@@ -38,9 +38,9 @@ declare class Inspector {
   constructor(_registry: BindingRegistry, _scope: ScopeManager, _hasParent: boolean, _isDisposed: () => boolean);
   inspect(): ContainerSnapshot;
   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 _makeHintContext;
+  has(token: Token<unknown> | Constructor, options?: ResolveOptions, parentHas?: () => boolean): boolean;
+  hasOwn(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean;
+  private _makeConstraintContext;
   private allBindingSnapshots;
   private _toSnapshot;
 }

package/dist/inspector.mjs

@@ -27,26 +27,26 @@ var Inspector = class {
 	lookupBindings(token) {
 		return this._registry.getAll(token).map((binding) => this._toSnapshot(binding));
 	}
-	has(token, hint, parentHas) {
+	has(token, options, parentHas) {
 		const bindings = this._registry.getAll(token);
-		if (bindings.length > 0) if (hint !== void 0) {
-			if (selectBinding(bindings, hint, this._makeHintContext(hint), tokenName(token)) !== void 0) return true;
+		if (bindings.length > 0) if (options !== void 0) {
+			if (selectBinding(bindings, options, this._makeConstraintContext(options), tokenName(token)) !== void 0) return true;
 		} else return true;
 		return parentHas?.() ?? false;
 	}
-	hasOwn(token, hint) {
+	hasOwn(token, options) {
 		const bindings = this._registry.getAll(token);
 		if (bindings.length === 0) return false;
-		if (hint !== void 0) return selectBinding(bindings, hint, this._makeHintContext(hint), tokenName(token)) !== void 0;
+		if (options !== void 0) return selectBinding(bindings, options, this._makeConstraintContext(options), tokenName(token)) !== void 0;
 		return true;
 	}
-	_makeHintContext(hint) {
+	_makeConstraintContext(options) {
 		return {
 			resolutionPath: [],
 			resolutionStack: [],
 			parent: void 0,
 			ancestors: [],
-			currentResolveHint: hint
+			currentResolveOptions: options
 		};
 	}
 	allBindingSnapshots() {

package/dist/resolve-options.d.mts

@@ -13,7 +13,7 @@ declare function injectionSlotToResolveOptions(injectionSlot: {
   readonly tags?: ReadonlyArray<BindingTag>;
 }): ResolveOptions | undefined;
 /**
- * Hint from a binding {@link BindingSlot} (tags may be empty; omits when nothing to match).
+ * Resolve options derived from a binding {@link BindingSlot} (tags may be empty; omits when nothing to match).
  *
  * @since 0.3.16-canary.0
  */

package/dist/resolve-options.mjs

@@ -17,7 +17,7 @@ function injectionSlotToResolveOptions(injectionSlot) {
 	return buildOptions(injectionSlot.name, injectionSlot.tags);
 }
 /**
-* Hint from a binding {@link BindingSlot} (tags may be empty; omits when nothing to match).
+* Resolve options derived from a binding {@link BindingSlot} (tags may be empty; omits when nothing to match).
 *
 * @since 0.3.16-canary.0
 */

package/dist/resolver.d.mts

@@ -39,30 +39,30 @@ declare class DependencyResolver {
   /**
    * Binding lookup aligned with `resolve` — used by `Container.validate` without instantiating.
    */
-  peekBindingForValidate(token: Token<unknown> | Constructor, hint: ResolveOptions | undefined): {
+  peekBindingForValidate(token: Token<unknown> | Constructor, options: ResolveOptions | undefined): {
     binding: Binding;
     owner: DependencyResolver;
   } | undefined;
   /**
    * Mirrors {@link DependencyResolver.resolveAll} candidate selection only (no instantiation).
    */
-  peekCandidateBindingsForValidate(token: Token<unknown> | Constructor, hint: ResolveOptions | undefined): Array<Binding>;
+  peekCandidateBindingsForValidate(token: Token<unknown> | Constructor, options: ResolveOptions | undefined): Array<Binding>;
   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;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value;
   private _resolveBinding;
   private _instantiateSync;
   private _resolveClassDeps;
   private _resolveDescriptorDeps;
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value | undefined;
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Array<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Value | undefined;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Array<Value>;
   resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value>;
   private _resolveBindingAsync;
   private _instantiateAsync;
   private _resolveClassDepsAsync;
   private _resolveDescriptorDepsAsync;
-  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value | undefined>;
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Array<Value>>;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Value | undefined>;
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, options: ResolveOptions | undefined, resolutionPath: Array<string>, resolutionStack: Array<ResolutionFrame>): Promise<Array<Value>>;
   private _getAllBindingsFromChain;
   private _getSimpleNamedBindingsFromChain;
   private _getAvailableSlots;
@@ -72,7 +72,7 @@ declare class DependencyResolver {
   private _getTokenName;
   private _getConstructorMetadata;
   private _instantiateClass;
-  private _matchesHintTag;
+  private _matchesRequestedTag;
   private _resolveTransientDynamicSyncFromContext;
   private _resolveTransientDynamicSyncSlow;
   private _resolveTransientDynamicAsyncFromContext;