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

package/src/binding-select.ts

@@ -10,11 +10,11 @@ import type { BindingTag, ConstraintContext, ResolveOptions } from "#/types";
  */
 export function selectBinding(
   bindings: ReadonlyArray<Binding>,
-  hint: ResolveOptions | undefined,
+  options: ResolveOptions | undefined,
   ctx: ConstraintContext,
   tokenDisplayName: string,
 ): Binding | undefined {
-  const candidates = filterBindings(bindings, hint, ctx);
+  const candidates = filterBindings(bindings, options, ctx);
   if (candidates.length === 0) {
     return undefined;
   }
@@ -31,46 +31,47 @@ export function selectBinding(
 }
 
 /**
- * Select all candidates matching hint + predicates.
+ * Select all candidates matching options + predicates.
  *
  * @since 0.3.16-canary.0
  */
 export function selectAllBindings(
   bindings: ReadonlyArray<Binding>,
-  hint: ResolveOptions | undefined,
+  options: ResolveOptions | undefined,
   ctx: ConstraintContext,
 ): Array<Binding> {
-  return filterBindings(bindings, hint, ctx, "all");
+  return filterBindings(bindings, options, ctx, "all");
 }
 
 function filterBindings(
   bindings: ReadonlyArray<Binding>,
-  hint: ResolveOptions | undefined,
+  options: ResolveOptions | undefined,
   ctx: ConstraintContext,
   selectionMode: "single" | "all" = "single",
 ): Array<Binding> {
-  if (hint === undefined) {
-    const resultWithoutHint: Array<Binding> = [];
+  if (options === undefined) {
+    const resultWithoutOptions: Array<Binding> = [];
     if (selectionMode === "all") {
       for (const binding of bindings) {
         if (matchesPredicate(binding, ctx)) {
-          resultWithoutHint.push(binding);
+          resultWithoutOptions.push(binding);
         }
       }
     } else {
       for (const binding of bindings) {
         const slot = binding.slot;
         if (slot.name === undefined && slot.tags.length === 0 && matchesPredicate(binding, ctx)) {
-          resultWithoutHint.push(binding);
+          resultWithoutOptions.push(binding);
         }
       }
     }
-    return resultWithoutHint;
+    return resultWithoutOptions;
   }
 
   const result: Array<Binding> = [];
   for (const binding of bindings) {
-    const slotMatched = selectionMode === "all" ? matchesSlotForResolveAll(binding, hint) : matchesSlot(binding, hint);
+    const slotMatched =
+      selectionMode === "all" ? matchesSlotForResolveAll(binding, options) : matchesSlot(binding, options);
     if (slotMatched && matchesPredicate(binding, ctx)) {
       result.push(binding);
     }
@@ -78,49 +79,51 @@ function filterBindings(
   return result;
 }
 
-function matchesSlotForResolveAll(binding: Binding, hint: ResolveOptions | undefined): boolean {
+function matchesSlotForResolveAll(binding: Binding, options: ResolveOptions | undefined): boolean {
   const hasExplicitSlotFilter =
-    hint !== undefined &&
-    (hint.name !== undefined || (hint.tags !== undefined && hint.tags.length > 0) || hint.tag !== undefined);
+    options !== undefined &&
+    (options.name !== undefined ||
+      (options.tags !== undefined && options.tags.length > 0) ||
+      options.tag !== undefined);
   if (!hasExplicitSlotFilter) {
     return true;
   }
-  return matchesSlot(binding, hint);
+  return matchesSlot(binding, options);
 }
 
-function matchesSlot(binding: Binding, hint: ResolveOptions | undefined): boolean {
+function matchesSlot(binding: Binding, options: ResolveOptions | undefined): boolean {
   const slot = binding.slot;
-  const hintName = hint?.name;
-  const hintTags = hint?.tags;
-  const singleHintTag = hint?.tag;
-  const hasHintTags = (hintTags?.length ?? 0) > 0 || singleHintTag !== undefined;
+  const requestedName = options?.name;
+  const requestedTags = options?.tags;
+  const singleRequestedTag = options?.tag;
+  const hasRequestedTags = (requestedTags?.length ?? 0) > 0 || singleRequestedTag !== undefined;
 
   // Match by name
   if (slot.name !== undefined) {
-    if (hintName === undefined) {
+    if (requestedName === undefined) {
       return false;
     }
-    if (slot.name !== hintName) {
+    if (slot.name !== requestedName) {
       return false;
     }
-  } else if (hintName !== undefined) {
-    // Binding has no name but hint requests a specific name — no match
+  } else if (requestedName !== undefined) {
+    // Binding has no name but options requests a specific name — no match
     return false;
   }
 
-  // Match by tags — binding's tags must all be present in hint
+  // Match by tags — binding's tags must all be present in options
   if (slot.tags.length > 0) {
-    if (!hasHintTags) {
+    if (!hasRequestedTags) {
       return false;
     }
     for (const [tagKey, tagValue] of slot.tags) {
-      if (!matchHintTag(tagKey, tagValue, hintTags, singleHintTag)) {
+      if (!matchesRequestedTag(tagKey, tagValue, requestedTags, singleRequestedTag)) {
         return false;
       }
     }
-  } else if (hasHintTags) {
-    // Binding has no tags but hint requires tags — no match for tagged slots
-    // But: default slot (no tags, no name) can match when hint has tags if there are no tag-slotted bindings
+  } else if (hasRequestedTags) {
+    // Binding has no tags but options requires tags — no match for tagged slots
+    // But: default slot (no tags, no name) can match when options has tags if there are no tag-slotted bindings
     // Actually per spec: resolveAll with tags only returns bindings that have those tags
     // and resolve with tags requires exact match
     return false;
@@ -129,21 +132,25 @@ function matchesSlot(binding: Binding, hint: ResolveOptions | undefined): boolea
   return true;
 }
 
-function matchHintTag(
+function matchesRequestedTag(
   tagKey: string,
   tagValue: unknown,
-  hintTags: ReadonlyArray<BindingTag> | undefined,
-  singleHintTag: BindingTag | undefined,
+  requestedTags: ReadonlyArray<BindingTag> | undefined,
+  singleRequestedTag: BindingTag | undefined,
 ): boolean {
-  if (singleHintTag !== undefined && singleHintTag[0] === tagKey && Object.is(singleHintTag[1], tagValue)) {
+  if (
+    singleRequestedTag !== undefined &&
+    singleRequestedTag[0] === tagKey &&
+    Object.is(singleRequestedTag[1], tagValue)
+  ) {
     return true;
   }
-  if (hintTags === undefined || hintTags.length === 0) {
+  if (requestedTags === undefined || requestedTags.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)) {
+  for (let index = 0; index < requestedTags.length; index += 1) {
+    const requestedTag = requestedTags[index]!;
+    if (requestedTag[0] === tagKey && Object.is(requestedTag[1], tagValue)) {
       return true;
     }
   }

package/src/container.ts

@@ -78,15 +78,18 @@ export interface Container {
   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;
+  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>,
-    hint?: ResolveOptions,
+    options?: 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>>;
+  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;
 
@@ -97,8 +100,8 @@ export interface Container {
   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;
@@ -480,43 +483,46 @@ class DefaultContainer implements Container {
 
   // ── Resolution ────────────────────────────────────────────────────────────
 
-  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value {
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value {
     this._assertNotDisposed();
-    if (hint === undefined) {
+    if (options === undefined) {
       return this._resolver.resolveFromContext(token, [], []);
     }
-    return this._resolver.resolve(token, hint, [], []);
+    return this._resolver.resolve(token, options, [], []);
   }
 
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value> {
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value> {
     this._assertNotDisposed();
-    if (hint === undefined) {
+    if (options === undefined) {
       return this._resolver.resolveAsyncFromContext(token, [], []);
     }
-    return this._resolver.resolveAsync(token, hint, [], []);
+    return this._resolver.resolveAsync(token, options, [], []);
   }
 
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined {
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined {
     this._assertNotDisposed();
-    return this._resolver.resolveOptional(token, hint, [], []);
+    return this._resolver.resolveOptional(token, options, [], []);
   }
 
   resolveOptionalAsync<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint?: ResolveOptions,
+    options?: ResolveOptions,
   ): Promise<Value | undefined> {
     this._assertNotDisposed();
-    return this._resolver.resolveOptionalAsync(token, hint, [], []);
+    return this._resolver.resolveOptionalAsync(token, options, [], []);
   }
 
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Array<Value> {
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value> {
     this._assertNotDisposed();
-    return this._resolver.resolveAll(token, hint, [], []);
+    return this._resolver.resolveAll(token, options, [], []);
   }
 
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Array<Value>> {
+  resolveAllAsync<const Value>(
+    token: Token<Value> | Constructor<Value>,
+    options?: ResolveOptions,
+  ): Promise<Array<Value>> {
     this._assertNotDisposed();
-    return this._resolver.resolveAllAsync(token, hint, [], []);
+    return this._resolver.resolveAllAsync(token, options, [], []);
   }
 
   // ── Child ─────────────────────────────────────────────────────────────────
@@ -572,8 +578,8 @@ class DefaultContainer implements Container {
         if (binding.kind === "constant" && binding.onActivation === undefined) {
           continue;
         }
-        const slotHint = bindingSlotToResolveOptions(binding.slot);
-        await this.resolveAsync(binding.token as Token<unknown>, slotHint);
+        const slotOptions = bindingSlotToResolveOptions(binding.slot);
+        await this.resolveAsync(binding.token as Token<unknown>, slotOptions);
       }
     }
   }
@@ -658,7 +664,7 @@ class DefaultContainer implements Container {
     }
   }
 
-  private _followAliasChainToTerminal(binding: Binding, hint: ResolveOptions | undefined): Binding | undefined {
+  private _followAliasChainToTerminal(binding: Binding, options: ResolveOptions | undefined): Binding | undefined {
     const cyclePath: Array<string> = [];
     const seenAliasIds = new Set<BindingIdentifier>();
     let current: Binding | undefined = binding;
@@ -670,7 +676,7 @@ class DefaultContainer implements Container {
       seenAliasIds.add(current.id);
       cyclePath.push(tokenName(current.token as Token<unknown>));
       const nextToken = current.target as Token<unknown> | Constructor;
-      const next = this._resolver.peekBindingForValidate(nextToken, hint);
+      const next = this._resolver.peekBindingForValidate(nextToken, options);
       if (next === undefined) {
         return undefined;
       }
@@ -698,27 +704,27 @@ class DefaultContainer implements Container {
         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 !== undefined ? tokenName(term.token as Token<unknown>) : "");
           }
           continue;
         }
         const found =
-          paramHint === undefined
+          paramOptions === undefined
             ? this._resolver.peekBindingForValidate(tokenRef, undefined)
-            : this._resolver.peekBindingForValidate(tokenRef, paramHint);
+            : this._resolver.peekBindingForValidate(tokenRef, paramOptions);
         if (found === undefined) {
           continue;
         }
-        const term = this._followAliasChainToTerminal(found.binding, paramHint);
+        const term = this._followAliasChainToTerminal(found.binding, paramOptions);
         pushTerminal(term, term !== undefined ? tokenName(term.token as Token<unknown>) : "");
       }
       return edges;
@@ -726,27 +732,27 @@ class DefaultContainer implements Container {
 
     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 as Token<unknown> | Constructor;
         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 !== undefined ? tokenName(term.token as Token<unknown>) : "");
           }
           continue;
         }
         const found =
-          depHint === undefined
+          depOptions === undefined
             ? this._resolver.peekBindingForValidate(tokenRef, undefined)
-            : this._resolver.peekBindingForValidate(tokenRef, depHint);
+            : this._resolver.peekBindingForValidate(tokenRef, depOptions);
         if (found === undefined) {
           continue;
         }
-        const term = this._followAliasChainToTerminal(found.binding, depHint);
+        const term = this._followAliasChainToTerminal(found.binding, depOptions);
         pushTerminal(term, term !== undefined ? tokenName(term.token as Token<unknown>) : "");
       }
     }
@@ -756,14 +762,14 @@ class DefaultContainer implements Container {
 
   // ── Introspection ─────────────────────────────────────────────────────────
 
-  has(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean {
+  has(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean {
     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: Token<unknown> | Constructor, hint?: ResolveOptions): boolean {
+  hasOwn(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean {
     this._assertNotDisposed();
-    return this._inspector.hasOwn(token, hint);
+    return this._inspector.hasOwn(token, options);
   }
 
   lookupBindings<const Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot> {

package/src/decorators/inject.ts

@@ -159,14 +159,16 @@ export function inject<const Value>(
       if (container === undefined) {
         throw new MissingContainerContextError(String(context.name));
       }
-      const hint =
+      const resolveOptions =
         options === undefined
           ? undefined
           : injectionSlotToResolveOptions({
               ...(options.name !== undefined ? { name: options.name } : {}),
               ...(options.tags !== undefined ? { 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 as Value);
     });
 

package/src/environment.ts

@@ -48,7 +48,7 @@ export interface ResolverCallbacks {
   ): Value;
   resolve<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint: ResolveOptions | undefined,
+    options: ResolveOptions | undefined,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
   ): Value;
@@ -59,31 +59,31 @@ export interface ResolverCallbacks {
   ): Promise<Value>;
   resolveAsync<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint: ResolveOptions | undefined,
+    options: ResolveOptions | undefined,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
   ): Promise<Value>;
   resolveOptional<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint: ResolveOptions | undefined,
+    options: ResolveOptions | undefined,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
   ): Value | undefined;
   resolveOptionalAsync<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint: ResolveOptions | undefined,
+    options: ResolveOptions | undefined,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
   ): Promise<Value | undefined>;
   resolveAll<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint: ResolveOptions | undefined,
+    options: ResolveOptions | undefined,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
   ): Array<Value>;
   resolveAllAsync<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint: ResolveOptions | undefined,
+    options: ResolveOptions | undefined,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
   ): Promise<Array<Value>>;
@@ -96,25 +96,25 @@ export class DefaultResolutionContext implements ResolutionContext {
   private _resolver: ResolverCallbacks;
   private _resolutionPath: Array<string>;
   private _resolutionStack: Array<ResolutionFrame>;
-  private _currentHint: ResolveOptions | undefined;
+  private _currentOptions: ResolveOptions | undefined;
 
   constructor(
     resolver: ResolverCallbacks,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
-    currentHint: ResolveOptions | undefined,
+    currentOptions: ResolveOptions | undefined,
   ) {
     this._resolver = resolver;
     this._resolutionPath = resolutionPath;
     this._resolutionStack = resolutionStack;
-    this._currentHint = currentHint;
+    this._currentOptions = currentOptions;
   }
 
   private _graph: ConstraintContext | undefined;
 
   get graph(): ConstraintContext {
     if (this._graph === undefined) {
-      this._graph = new DefaultConstraintContext(this._resolutionPath, this._resolutionStack, this._currentHint);
+      this._graph = new DefaultConstraintContext(this._resolutionPath, this._resolutionStack, this._currentOptions);
     }
     return this._graph;
   }
@@ -123,46 +123,49 @@ export class DefaultResolutionContext implements ResolutionContext {
     resolver: ResolverCallbacks,
     resolutionPath: Array<string>,
     resolutionStack: Array<ResolutionFrame>,
-    currentHint: ResolveOptions | undefined,
+    currentOptions: ResolveOptions | undefined,
   ): void {
     this._resolver = resolver;
     this._resolutionPath = resolutionPath;
     this._resolutionStack = resolutionStack;
-    this._currentHint = currentHint;
+    this._currentOptions = currentOptions;
     this._graph = undefined;
   }
 
-  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value {
-    if (hint === undefined) {
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value {
+    if (options === undefined) {
       return this._resolver.resolveFromContext(token, this._resolutionPath, this._resolutionStack);
     }
-    return this._resolver.resolve(token, hint, this._resolutionPath, this._resolutionStack);
+    return this._resolver.resolve(token, options, this._resolutionPath, this._resolutionStack);
   }
 
-  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value> {
-    if (hint === undefined) {
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value> {
+    if (options === undefined) {
       return this._resolver.resolveAsyncFromContext(token, this._resolutionPath, this._resolutionStack);
     }
-    return this._resolver.resolveAsync(token, hint, this._resolutionPath, this._resolutionStack);
+    return this._resolver.resolveAsync(token, options, this._resolutionPath, this._resolutionStack);
   }
 
-  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined {
-    return this._resolver.resolveOptional(token, hint, this._resolutionPath, this._resolutionStack);
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined {
+    return this._resolver.resolveOptional(token, options, this._resolutionPath, this._resolutionStack);
   }
 
   resolveOptionalAsync<const Value>(
     token: Token<Value> | Constructor<Value>,
-    hint?: ResolveOptions,
+    options?: ResolveOptions,
   ): Promise<Value | undefined> {
-    return this._resolver.resolveOptionalAsync(token, hint, this._resolutionPath, this._resolutionStack);
+    return this._resolver.resolveOptionalAsync(token, options, this._resolutionPath, this._resolutionStack);
   }
 
-  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Array<Value> {
-    return this._resolver.resolveAll(token, hint, this._resolutionPath, this._resolutionStack);
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value> {
+    return this._resolver.resolveAll(token, options, this._resolutionPath, this._resolutionStack);
   }
 
-  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Array<Value>> {
-    return this._resolver.resolveAllAsync(token, hint, this._resolutionPath, this._resolutionStack);
+  resolveAllAsync<const Value>(
+    token: Token<Value> | Constructor<Value>,
+    options?: ResolveOptions,
+  ): Promise<Array<Value>> {
+    return this._resolver.resolveAllAsync(token, options, this._resolutionPath, this._resolutionStack);
   }
 }
 
@@ -170,17 +173,17 @@ class DefaultConstraintContext implements ConstraintContext {
   readonly resolutionPath: ReadonlyArray<string>;
   readonly resolutionStack: ReadonlyArray<ResolutionFrame>;
   readonly parent: ResolutionFrame | undefined;
-  readonly currentResolveHint: ResolveOptions | undefined;
+  readonly currentResolveOptions: ResolveOptions | undefined;
 
   constructor(
     resolutionPath: ReadonlyArray<string>,
     resolutionStack: ReadonlyArray<ResolutionFrame>,
-    currentResolveHint: ResolveOptions | undefined,
+    currentResolveOptions: ResolveOptions | undefined,
   ) {
     this.resolutionPath = resolutionPath;
     this.resolutionStack = resolutionStack;
     this.parent = resolutionStack.at(-1);
-    this.currentResolveHint = currentResolveHint;
+    this.currentResolveOptions = currentResolveOptions;
   }
 
   private _ancestors: ReadonlyArray<ResolutionFrame> | undefined;

package/src/errors.ts

@@ -42,15 +42,15 @@ export class TokenNotBoundError extends DiError {
 export 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>) {
-    const hintStr = JSON.stringify(hint);
+  constructor(tokenName: string, options: ResolveOptions, availableSlots: Array<string>) {
+    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/src/inspector.ts

@@ -69,11 +69,11 @@ export class Inspector {
     return bindings.map((binding) => this._toSnapshot(binding));
   }
 
-  has(token: Token<unknown> | Constructor, hint?: ResolveOptions, parentHas?: () => boolean): boolean {
+  has(token: Token<unknown> | Constructor, options?: ResolveOptions, parentHas?: () => boolean): boolean {
     const bindings = this._registry.getAll(token);
     if (bindings.length > 0) {
-      if (hint !== undefined) {
-        if (selectBinding(bindings, hint, this._makeHintContext(hint), tokenName(token)) !== undefined) {
+      if (options !== undefined) {
+        if (selectBinding(bindings, options, this._makeConstraintContext(options), tokenName(token)) !== undefined) {
           return true;
         }
       } else {
@@ -83,24 +83,24 @@ export class Inspector {
     return parentHas?.() ?? false;
   }
 
-  hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean {
+  hasOwn(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean {
     const bindings = this._registry.getAll(token);
     if (bindings.length === 0) {
       return false;
     }
-    if (hint !== undefined) {
-      return selectBinding(bindings, hint, this._makeHintContext(hint), tokenName(token)) !== undefined;
+    if (options !== undefined) {
+      return selectBinding(bindings, options, this._makeConstraintContext(options), tokenName(token)) !== undefined;
     }
     return true;
   }
 
-  private _makeHintContext(hint: ResolveOptions): ConstraintContext {
+  private _makeConstraintContext(options: ResolveOptions): ConstraintContext {
     return {
       resolutionPath: [],
       resolutionStack: [],
       parent: undefined,
       ancestors: [],
-      currentResolveHint: hint,
+      currentResolveOptions: options,
     };
   }
 

package/src/resolve-options.ts

@@ -33,7 +33,7 @@ export function injectionSlotToResolveOptions(injectionSlot: {
 }
 
 /**
- * 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
  */