@codefast/di 0.8.0 → 0.9.0

package/dist/container/binding-builders.d.ts

@@ -31,23 +31,23 @@ export interface BindingRegistration {
  *
  * @since 0.5.0-canary.8
  */
-export declare class BindingChain<Value> implements AliasBindingBuilder, BindingBuilder<Value>, BindToBuilder<Value>, ConstantBindingBuilder<Value>, ScopedBindingBuilder<Value>, SingletonBindingBuilder<Value>, SingletonLifecycleBuilder<Value>, TransientBindingBuilder<Value> {
+export declare class BindingChain<Value, Names extends string = string> implements AliasBindingBuilder<Names>, BindingBuilder<Value, Names>, BindToBuilder<Value, Names>, ConstantBindingBuilder<Value, Names>, ScopedBindingBuilder<Value>, SingletonBindingBuilder<Value>, SingletonLifecycleBuilder<Value>, TransientBindingBuilder<Value> {
     #private;
-    constructor(token: Token<Value> | Constructor<Value>, registration: BindingRegistration);
-    to(type: Constructor<Value>): BindingBuilder<Value>;
-    toSelf(): BindingBuilder<Value>;
-    toConstantValue(value: Value): ConstantBindingBuilder<Value>;
-    toDynamic(factory: (ctx: ResolutionContext) => Value): BindingBuilder<Value>;
-    toDynamicAsync(factory: (ctx: ResolutionContext) => Promise<Value>): BindingBuilder<Value>;
+    constructor(token: Token<Value, Names> | Constructor<Value>, registration: BindingRegistration);
+    to(type: Constructor<Value>): BindingBuilder<Value, Names>;
+    toSelf(): BindingBuilder<Value, Names>;
+    toConstantValue(value: Value): ConstantBindingBuilder<Value, Names>;
+    toDynamic(factory: (ctx: ResolutionContext) => Value): BindingBuilder<Value, Names>;
+    toDynamicAsync(factory: (ctx: ResolutionContext) => Promise<Value>): BindingBuilder<Value, Names>;
     toResolved<const Deps extends ReadonlyArray<InjectableDependency>>(factory: (...args: {
         [K in keyof Deps]: ResolvedDependencyValue<NoInfer<Deps>[K]>;
-    }) => Value, deps: Deps): BindingBuilder<Value>;
+    }) => Value, deps: Deps): BindingBuilder<Value, Names>;
     toResolvedAsync<const Deps extends ReadonlyArray<InjectableDependency>>(factory: (...args: {
         [K in keyof Deps]: ResolvedDependencyValue<NoInfer<Deps>[K]>;
-    }) => Promise<Value>, deps: Deps): BindingBuilder<Value>;
-    toAlias(target: Token<Value> | Constructor<Value>): AliasBindingBuilder;
+    }) => Promise<Value>, deps: Deps): BindingBuilder<Value, Names>;
+    toAlias(target: Token<Value> | Constructor<Value>): AliasBindingBuilder<Names>;
     when(predicate: BindingConstraint): this;
-    whenNamed(name: string): this;
+    whenNamed(name: Names): this;
     whenTagged(criterion: BindingTag): this;
     whenDefault(): this;
     singleton(): SingletonBindingBuilder<Value>;
@@ -56,5 +56,4 @@ export declare class BindingChain<Value> implements AliasBindingBuilder, Binding
     onActivation(fn: ActivationHandler<Value>): this;
     onDeactivation(fn: DeactivationHandler<Value>): this;
     id(): BindingIdentifier;
-}
-//# sourceMappingURL=binding-builders.d.ts.map
+}

package/dist/container/binding-builders.js

@@ -225,5 +225,4 @@ export class BindingChain {
             }
         }
     }
-}
-//# sourceMappingURL=binding-builders.js.map
+}

package/dist/container/container.d.ts

@@ -13,12 +13,12 @@ import type { MetadataReader } from "#/metadata/metadata-types";
  */
 export interface Container {
     readonly isDisposed: boolean;
-    bind<Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+    bind<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>): BindToBuilder<Value, Names>;
     unbind(tokenOrId: Token<unknown> | Constructor | BindingIdentifier): void;
     unbindAsync(tokenOrId: Token<unknown> | Constructor | BindingIdentifier): Promise<void>;
     unbindAll(): void;
     unbindAllAsync(): Promise<void>;
-    rebind<Value>(token: Token<Value> | Constructor<Value>): BindToBuilder<Value>;
+    rebind<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>): BindToBuilder<Value, Names>;
     load(...modules: Array<SyncModule>): void;
     loadAsync(...modules: Array<SyncModule | AsyncModule>): Promise<void>;
     unload(...modules: Array<SyncModule>): void;
@@ -26,20 +26,20 @@ export interface Container {
     loadAutoRegistered(registry: AutoRegisterRegistry): number;
     onActivation<Value>(token: Token<Value> | Constructor<Value>, handler: ActivationHandler<Value>): void;
     onDeactivation<Value>(token: Token<Value> | Constructor<Value>, handler: DeactivationHandler<Value>): void;
-    resolve<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value;
-    resolveAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value>;
-    resolveOptional<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Value | undefined;
-    resolveOptionalAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Value | undefined>;
-    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Array<Value>;
-    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<Array<Value>>;
+    resolve<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<ResolveOptions<Names>>): Value;
+    resolveAsync<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<ResolveOptions<Names>>): Promise<Value>;
+    resolveOptional<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<ResolveOptions<Names>>): Value | undefined;
+    resolveOptionalAsync<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<ResolveOptions<Names>>): Promise<Value | undefined>;
+    resolveAll<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<ResolveOptions<Names>>): Array<Value>;
+    resolveAllAsync<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<ResolveOptions<Names>>): 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, options?: ResolveOptions): boolean;
-    hasOwn(token: Token<unknown> | Constructor, options?: ResolveOptions): boolean;
+    has<Names extends string = string>(token: Token<unknown, Names> | Constructor, options?: NoInfer<ResolveOptions<Names>>): boolean;
+    hasOwn<Names extends string = string>(token: Token<unknown, Names> | Constructor, options?: NoInfer<ResolveOptions<Names>>): boolean;
     lookupBindings<Value>(token: Token<Value> | Constructor<Value>): ReadonlyArray<BindingSnapshot>;
     inspect(): ContainerSnapshot;
     generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;
@@ -74,5 +74,4 @@ export interface ContainerStatic {
  *
  * @since 0.3.16-canary.0
  */
-export declare const Container: ContainerStatic;
-//# sourceMappingURL=container.d.ts.map
+export declare const Container: ContainerStatic;

package/dist/container/container.js

@@ -2,7 +2,7 @@ import { BindingChain } from "#/container/binding-builders";
 import { NO_INSTANCE } from "#/core/binding";
 import { effectiveBindingScope } from "#/core/binding-scope";
 import { constraintRequirementsOf } from "#/core/constraint-requirement";
-import { getOrInsert } from "#/core/map-upsert";
+import { getOrInsert, getOrInsertComputed } from "#/core/map-upsert";
 import { isSyncModule, MODULE_SETUP } from "#/core/module";
 import { BindingRegistry } from "#/core/registry";
 import { tokenName } from "#/core/token";
@@ -18,6 +18,20 @@ import { defaultMetadataReader } from "#/metadata/symbol-metadata-reader";
 import { verifyingMetadataReader } from "#/metadata/verifying-metadata-reader";
 import { ROOT_BRANCH } from "#/resolution/path/resolution-path";
 import { DependencyResolver } from "#/resolution/resolver";
+/** Whether a requirement's name is declared — on its token when it names one, on any token otherwise. */
+function isSlotNameDeclared(declared, requirement) {
+    if (requirement.tokenName !== undefined) {
+        return declared.get(requirement.tokenName)?.has(requirement.name) ?? false;
+    }
+    for (const names of declared.values()) {
+        if (names.has(requirement.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Hoisted so the slot-name index's `getOrInsertComputed` allocates only on a miss, no closure per call. */
+const newSlotNameSet = () => new Set();
 // A Record rather than an if-chain, so a new `BindingScope` is a compile error here instead of
 // silently landing in whichever branch happened to be last.
 const APPLY_BINDING_SCOPE = {
@@ -552,18 +566,19 @@ class DefaultContainer {
             }
             declaredSlotNames ??= this.#slotNamesInChain();
             for (const requirement of requirements) {
-                if (!declaredSlotNames.has(requirement.name)) {
-                    throw new UnreachableConstraintError(tokenName(binding.token), requirement.name, requirement.helperName);
+                if (!isSlotNameDeclared(declaredSlotNames, requirement)) {
+                    throw new UnreachableConstraintError(tokenName(binding.token), requirement);
                 }
             }
         }
     }
-    /** Every slot name declared anywhere a resolve through this container could reach. */
+    /** Every slot name declared anywhere a resolve through this container could reach, by declaring token. */
     #slotNamesInChain() {
-        const names = this.#parent === undefined ? new Set() : this.#parent.#slotNamesInChain();
+        const names = this.#parent === undefined ? new Map() : this.#parent.#slotNamesInChain();
         for (const binding of this.#registry.allBindings()) {
-            if (binding.slot.name !== undefined) {
-                names.add(binding.slot.name);
+            const name = binding.slot.name;
+            if (name !== undefined) {
+                getOrInsertComputed(names, tokenName(binding.token), newSlotNameSet).add(name);
             }
         }
         return names;
@@ -743,5 +758,4 @@ export const Container = {
         await container.loadAsync(...modules);
         return container;
     },
-};
-//# sourceMappingURL=container.js.map
+};

package/dist/core/binding-scope.d.ts

@@ -9,5 +9,4 @@ import type { BindingScope } from "#/core/types";
  *
  * @since 0.3.16-canary.0
  */
-export declare function effectiveBindingScope(binding: Binding): BindingScope;
-//# sourceMappingURL=binding-scope.d.ts.map
+export declare function effectiveBindingScope(binding: Binding): BindingScope;

package/dist/core/binding-scope.js

@@ -9,5 +9,4 @@
  */
 export function effectiveBindingScope(binding) {
     return binding.scope;
-}
-//# sourceMappingURL=binding-scope.js.map
+}

package/dist/core/binding.d.ts

@@ -248,11 +248,16 @@ export declare function clearBindingFrame<Value>(binding: Binding<Value>): void;
  *
  * @since 0.3.16-canary.0
  */
-export interface SlotConstrainedBuilder {
+export interface SlotConstrainedBuilder<Names extends string = string> {
+    /** Narrows the binding to requests the predicate accepts, evaluated on every resolve. */
     when(predicate: BindingConstraint): this;
-    whenNamed(name: string): this;
+    /** Declares the binding's slot name, one of the names the token declares. */
+    whenNamed(name: Names): this;
+    /** Declares one criterion of the binding's slot, replacing any earlier criterion of the same key. */
     whenTagged(criterion: BindingTag): this;
+    /** Keeps the binding on the default slot, the one an unconstrained request selects. */
     whenDefault(): this;
+    /** The identifier this binding is registered under. */
     id(): BindingIdentifier;
 }
 /**
@@ -260,26 +265,26 @@ export interface SlotConstrainedBuilder {
  *
  * @since 0.3.16-canary.0
  */
-export interface BindToBuilder<Value> {
-    to(type: Constructor<Value>): BindingBuilder<Value>;
-    toSelf(): BindingBuilder<Value>;
-    toConstantValue(value: Value): ConstantBindingBuilder<Value>;
-    toDynamic(factory: (ctx: ResolutionContext) => Value): BindingBuilder<Value>;
-    toDynamicAsync(factory: (ctx: ResolutionContext) => Promise<Value>): BindingBuilder<Value>;
+export interface BindToBuilder<Value, Names extends string = string> {
+    to(type: Constructor<Value>): BindingBuilder<Value, Names>;
+    toSelf(): BindingBuilder<Value, Names>;
+    toConstantValue(value: Value): ConstantBindingBuilder<Value, Names>;
+    toDynamic(factory: (ctx: ResolutionContext) => Value): BindingBuilder<Value, Names>;
+    toDynamicAsync(factory: (ctx: ResolutionContext) => Promise<Value>): BindingBuilder<Value, Names>;
     toResolved<const Deps extends ReadonlyArray<InjectableDependency>>(factory: (...args: {
         [K in keyof Deps]: ResolvedDependencyValue<NoInfer<Deps>[K]>;
-    }) => Value, deps: Deps): BindingBuilder<Value>;
+    }) => Value, deps: Deps): BindingBuilder<Value, Names>;
     toResolvedAsync<const Deps extends ReadonlyArray<InjectableDependency>>(factory: (...args: {
         [K in keyof Deps]: ResolvedDependencyValue<NoInfer<Deps>[K]>;
-    }) => Promise<Value>, deps: Deps): BindingBuilder<Value>;
-    toAlias(target: Token<Value> | Constructor<Value>): AliasBindingBuilder;
+    }) => Promise<Value>, deps: Deps): BindingBuilder<Value, Names>;
+    toAlias(target: Token<Value> | Constructor<Value>): AliasBindingBuilder<Names>;
 }
 /**
  * The scope-selection step of the fluent chain.
  *
  * @since 0.3.16-canary.0
  */
-export interface BindingBuilder<Value> extends SlotConstrainedBuilder {
+export interface BindingBuilder<Value, Names extends string = string> extends SlotConstrainedBuilder<Names> {
     singleton(): SingletonBindingBuilder<Value>;
     transient(): TransientBindingBuilder<Value>;
     scoped(): ScopedBindingBuilder<Value>;
@@ -289,7 +294,7 @@ export interface BindingBuilder<Value> extends SlotConstrainedBuilder {
  *
  * @since 0.3.16-canary.0
  */
-export interface ConstantBindingBuilder<Value> extends SlotConstrainedBuilder {
+export interface ConstantBindingBuilder<Value, Names extends string = string> extends SlotConstrainedBuilder<Names> {
     onActivation(fn: ActivationHandler<Value>): SingletonLifecycleBuilder<Value>;
     onDeactivation(fn: DeactivationHandler<Value>): SingletonLifecycleBuilder<Value>;
 }
@@ -298,7 +303,7 @@ export interface ConstantBindingBuilder<Value> extends SlotConstrainedBuilder {
  *
  * @since 0.3.16-canary.0
  */
-export interface AliasBindingBuilder extends SlotConstrainedBuilder {
+export interface AliasBindingBuilder<Names extends string = string> extends SlotConstrainedBuilder<Names> {
 }
 /**
  * The fluent chain after `singleton()`, where both lifecycle hooks stay available.
@@ -336,5 +341,4 @@ export interface SingletonLifecycleBuilder<Value> {
     onDeactivation(fn: DeactivationHandler<Value>): this;
     id(): BindingIdentifier;
 }
-export {};
-//# sourceMappingURL=binding.d.ts.map
+export {};

package/dist/core/binding.js

@@ -137,5 +137,4 @@ export function refinableFields(binding) {
  */
 export function clearBindingFrame(binding) {
     binding.frame = undefined;
-}
-//# sourceMappingURL=binding.js.map
+}

package/dist/core/constraint-requirement.d.ts

@@ -12,23 +12,38 @@ export declare const CONSTRAINT_REQUIREMENT: unique symbol;
 /**
  * The slot name a constraint waits for on an ancestor.
  *
- * @remarks Only names are described. A tag criterion is interned, so a typo cannot produce one that
- * looks valid, while a name is a bare string that nothing checks.
+ * @remarks Only names are described, however spelled: a tag criterion of any other key is minted from
+ * a typed key, so a typo cannot produce one that looks valid, while a name is a bare string that
+ * nothing checks — through `whenNamed`'s reserved key included.
  *
  * @since 0.6.0
  */
 export interface ConstraintRequirement {
     readonly requires: "ancestorSlotName";
+    /** The token whose slot must carry the name, or `undefined` when the spelling named no token. */
+    readonly tokenName: string | undefined;
     readonly name: string;
     /** The helper that built the predicate, so a report can name what the caller wrote. */
     readonly helperName: string;
 }
 /**
- * Records what a predicate waits for. Called once, where the predicate is built.
+ * What a helper records about one waited-for slot name, before the discriminant is stamped on.
+ *
+ * @since 0.9.0
+ */
+export type SlotNameRequirement = Omit<ConstraintRequirement, "requires">;
+/**
+ * Records the one slot name a predicate waits for. Called once, where the predicate is built.
  *
  * @since 0.6.0
  */
-export declare function requiringAncestorSlotName(predicate: BindingConstraint, name: string, helperName: string): BindingConstraint;
+export declare function requiringAncestorSlotName(predicate: BindingConstraint, requirement: SlotNameRequirement): BindingConstraint;
+/**
+ * Records every slot name a predicate waits for — one per reserved criterion in a `…TaggedAll` list.
+ *
+ * @since 0.9.0
+ */
+export declare function requiringAncestorSlotNames(predicate: BindingConstraint, requirements: ReadonlyArray<SlotNameRequirement>): BindingConstraint;
 /**
  * The requirement a predicate carries, if it was built by a helper that records one.
  *
@@ -49,5 +64,4 @@ export declare function constraintRequirementsOf(predicate: BindingConstraint):
  *
  * @since 0.6.1
  */
-export declare function mergingConstraintRequirements(composite: BindingConstraint, left: BindingConstraint, right: BindingConstraint): BindingConstraint;
-//# sourceMappingURL=constraint-requirement.d.ts.map
+export declare function mergingConstraintRequirements(composite: BindingConstraint, left: BindingConstraint, right: BindingConstraint): BindingConstraint;

package/dist/core/constraint-requirement.js

@@ -8,13 +8,27 @@
  */
 export const CONSTRAINT_REQUIREMENT = Symbol("di:constraint-requirement");
 /**
- * Records what a predicate waits for. Called once, where the predicate is built.
+ * Records the one slot name a predicate waits for. Called once, where the predicate is built.
  *
  * @since 0.6.0
  */
-export function requiringAncestorSlotName(predicate, name, helperName) {
-    const requirement = { requires: "ancestorSlotName", name, helperName };
-    Object.defineProperty(predicate, CONSTRAINT_REQUIREMENT, { value: requirement, enumerable: false });
+export function requiringAncestorSlotName(predicate, requirement) {
+    return requiringAncestorSlotNames(predicate, [requirement]);
+}
+/**
+ * Records every slot name a predicate waits for — one per reserved criterion in a `…TaggedAll` list.
+ *
+ * @since 0.9.0
+ */
+export function requiringAncestorSlotNames(predicate, requirements) {
+    return attachRequirements(predicate, requirements.map((requirement) => ({ requires: "ancestorSlotName", ...requirement })));
+}
+/** One non-enumerable write per predicate: a second define on the same key would throw. */
+function attachRequirements(predicate, requirements) {
+    Object.defineProperty(predicate, CONSTRAINT_REQUIREMENT, {
+        value: requirements.length === 1 ? requirements[0] : requirements,
+        enumerable: false,
+    });
     return predicate;
 }
 /**
@@ -53,10 +67,5 @@ export function mergingConstraintRequirements(composite, left, right) {
     if (merged.length === 0) {
         return composite;
     }
-    Object.defineProperty(composite, CONSTRAINT_REQUIREMENT, {
-        value: merged.length === 1 ? merged[0] : merged,
-        enumerable: false,
-    });
-    return composite;
-}
-//# sourceMappingURL=constraint-requirement.js.map
+    return attachRequirements(composite, merged);
+}

package/dist/core/constructor-type.d.ts

@@ -14,5 +14,4 @@ export type Constructor<out Value = unknown> = new (...args: Array<never>) => Va
  *
  * @since 0.3.16-canary.0
  */
-export type ConstructorInvocation = new (...args: Array<unknown>) => unknown;
-//# sourceMappingURL=constructor-type.d.ts.map
+export type ConstructorInvocation = new (...args: Array<unknown>) => unknown;

package/dist/core/constructor-type.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=constructor-type.js.map
+export {};

package/dist/core/map-upsert.d.ts

@@ -25,5 +25,4 @@ export declare function getOrInsert<Key, Value extends {} | null>(map: Map<Key,
  *
  * @since 0.7.0
  */
-export declare function getOrInsertComputed<Key, Value extends {} | null>(map: Map<Key, Value>, key: NoInfer<Key>, create: (key: NoInfer<Key>) => NoInfer<Value>): Value;
-//# sourceMappingURL=map-upsert.d.ts.map
+export declare function getOrInsertComputed<Key, Value extends {} | null>(map: Map<Key, Value>, key: NoInfer<Key>, create: (key: NoInfer<Key>) => NoInfer<Value>): Value;

package/dist/core/map-upsert.js

@@ -40,5 +40,4 @@ export function getOrInsertComputed(map, key, create) {
     const created = create(key);
     map.set(key, created);
     return created;
-}
-//# sourceMappingURL=map-upsert.js.map
+}

package/dist/core/module.d.ts

@@ -79,5 +79,4 @@ export declare const Module: {
  * @since 0.3.16-canary.0
  */
 export declare function isSyncModule(module: SyncModule | AsyncModule): module is SyncModule;
-export {};
-//# sourceMappingURL=module.d.ts.map
+export {};

package/dist/core/module.js

@@ -58,5 +58,4 @@ export const Module = {
  */
 export function isSyncModule(module) {
     return module[SYNC_MODULE_BRAND] === true;
-}
-//# sourceMappingURL=module.js.map
+}

package/dist/core/registry.d.ts

@@ -60,5 +60,4 @@ export declare class BindingRegistry {
     availableSlotStrings(token: Token<unknown> | Constructor): Array<string>;
     /** Whether the deferred tagged-slot index has had to be built. */
     get isTaggedIndexBuilt(): boolean;
-}
-//# sourceMappingURL=registry.d.ts.map
+}

package/dist/core/registry.js

@@ -280,5 +280,4 @@ function isDefaultSlotBinding(binding) {
 /** A predicate with no slot constraint: last-wins does not apply to it. */
 function isPurePredicateBinding(binding) {
     return binding.predicate !== undefined && binding.slot.tags.length === 0;
-}
-//# sourceMappingURL=registry.js.map
+}

package/dist/core/tag.d.ts

@@ -59,12 +59,12 @@ export interface TagKey<Value = unknown> {
 /**
  * Declares a tag key, whose `of()` builds the criteria a `whenTagged` and a resolve both take.
  *
- * @remarks The value type is checked at both ends: a key declared `tag<Region>("region")` refuses a
+ * @remarks The value type is checked at both ends: a key declared `tag<Region>("di:region")` refuses a
  * value that is not a `Region`, so a bind site and a resolve site cannot drift apart silently.
  *
  * @example
  * ```ts
- * const Region = tag<"eu" | "us">("region");
+ * const Region = tag<"eu" | "us">("di:region");
  * container.bind(Storage).to(S3).whenTagged(Region.of("eu"));
  * container.resolve(Storage, { tag: Region.of("eu") });
  * ```
@@ -102,5 +102,4 @@ export declare function tagKeyMaskOf(tags: ReadonlyArray<BindingTag>): TagKeyMas
  * @since 0.6.0
  */
 export declare function coversTagKeys(requestMask: TagKeyMask, slotMask: TagKeyMask): boolean;
-export {};
-//# sourceMappingURL=tag.d.ts.map
+export {};

package/dist/core/tag.js

@@ -27,12 +27,12 @@ function internKeyFor(value) {
 /**
  * Declares a tag key, whose `of()` builds the criteria a `whenTagged` and a resolve both take.
  *
- * @remarks The value type is checked at both ends: a key declared `tag<Region>("region")` refuses a
+ * @remarks The value type is checked at both ends: a key declared `tag<Region>("di:region")` refuses a
  * value that is not a `Region`, so a bind site and a resolve site cannot drift apart silently.
  *
  * @example
  * ```ts
- * const Region = tag<"eu" | "us">("region");
+ * const Region = tag<"eu" | "us">("di:region");
  * container.bind(Storage).to(S3).whenTagged(Region.of("eu"));
  * container.resolve(Storage, { tag: Region.of("eu") });
  * ```
@@ -135,5 +135,4 @@ export function tagKeyMaskOf(tags) {
  */
 export function coversTagKeys(requestMask, slotMask) {
     return (requestMask & slotMask) === slotMask;
-}
-//# sourceMappingURL=tag.js.map
+}

package/dist/core/token.d.ts

@@ -1,25 +1,44 @@
 import type { Constructor } from "#/core/constructor-type";
 declare const TOKEN_BRAND: unique symbol;
+declare const TOKEN_NAMES_BRAND: unique symbol;
 /**
- * A branded identifier carrying the value type its bindings resolve to.
+ * A branded identifier carrying the value type its bindings resolve to, and the slot names they may declare.
+ *
+ * @remarks `Names` exists at the type level only: `whenNamed`, and `name` in `ResolveOptions` and
+ * `InjectOptions`, narrow to it, so a bind site and a request site cannot drift apart silently. It
+ * is covariant, so a token declaring names is still a `Token<unknown>` wherever the engine erases
+ * the value type; the default `string` leaves a token that declares none unconstrained.
+ *
+ * @example
+ * ```ts
+ * const Logger = token<Logger, "console" | "file">("di:Logger");
+ * container.bind(Logger).to(FileLogger).whenNamed("file");
+ * container.resolve(Logger, { name: "file" });
+ * ```
  *
  * @since 0.3.16-canary.0
  */
-export interface Token<out Value> {
+export interface Token<out Value, out Names extends string = string> {
     readonly name: string;
     readonly [TOKEN_BRAND]: Value;
+    readonly [TOKEN_NAMES_BRAND]?: Names;
 }
 /**
- * Creates a named `Token` for the given value type.
+ * The slot names a dependency key declares — `string` for a class, or a token that declares none.
+ *
+ * @since 0.9.0
+ */
+export type SlotNamesOf<Key> = Key extends Token<unknown, infer Names extends string> ? Names : string;
+/**
+ * Creates a named `Token` for the given value type, optionally declaring the slot names its bindings may use.
  *
  * @since 0.3.16-canary.0
  */
-export declare function token<Value>(name: string): Token<Value>;
+export declare function token<Value, Names extends string = string>(name: string): Token<Value, Names>;
 /**
  * Returns the display name of a token or class used as a dependency key.
  *
  * @since 0.3.16-canary.0
  */
 export declare function tokenName(dependency: Token<unknown> | Constructor): string;
-export {};
-//# sourceMappingURL=token.d.ts.map
+export {};

package/dist/core/token.js

@@ -1,5 +1,5 @@
 /**
- * Creates a named `Token` for the given value type.
+ * Creates a named `Token` for the given value type, optionally declaring the slot names its bindings may use.
  *
  * @since 0.3.16-canary.0
  */
@@ -13,5 +13,4 @@ export function token(name) {
  */
 export function tokenName(dependency) {
     return dependency.name;
-}
-//# sourceMappingURL=token.js.map
+}

package/dist/core/types.d.ts

@@ -47,8 +47,14 @@ export type DeactivationHandler<Value> = (instance: Value) => void | Promise<voi
  *
  * @since 0.3.16-canary.0
  */
-export interface ResolveOptions {
-    name?: string | undefined;
+export interface ResolveOptions<Names extends string = string> {
+    /**
+     * The slot name a binding declared with `whenNamed`.
+     *
+     * @remarks Narrowed to the names the token declares, so a request cannot ask for a name no
+     * binding could carry; a token declaring none takes any string.
+     */
+    name?: Names | undefined;
     /**
      * Single-tag shorthand, equivalent to listing the one pair in `tags`.
      *
@@ -112,5 +118,4 @@ export interface ResolutionContext {
  *
  * @since 0.3.16-canary.0
  */
-export type TokenValue<Type> = Type extends Token<infer Value> ? Value : Type extends Constructor<infer Value> ? Value : never;
-//# sourceMappingURL=types.d.ts.map
+export type TokenValue<Type> = Type extends Token<infer Value> ? Value : Type extends Constructor<infer Value> ? Value : never;

package/dist/core/types.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=types.js.map
+export {};

package/dist/decorators/inject.d.ts

@@ -8,6 +8,5 @@ type ClassAccessorDecorator<This, Value> = (target: ClassAccessorDecoratorTarget
  *
  * @since 0.3.16-canary.0
  */
-export declare function inject<Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
-export {};
-//# sourceMappingURL=inject.d.ts.map
+export declare function inject<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<InjectOptions<Names>>): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
+export {};

package/dist/decorators/inject.js

@@ -30,6 +30,8 @@ export function inject(token, options) {
     // Derived from the descriptor, not from `options`: the descriptor is where the tag shorthand has
     // already been folded. Built once here rather than per constructed instance.
     const resolveOptions = injectionSlotToResolveOptions(descriptor);
+    // The names are checked above; the container lane only needs the value type.
+    const resolveKey = token;
     const decoratorFn = (_target, context) => {
         if (context.static) {
             throw new StaticMemberDecoratorError("inject", String(context.name));
@@ -50,8 +52,8 @@ export function inject(token, options) {
             const ambient = getAmbientResolution();
             if (ambient !== undefined) {
                 const value = descriptor.optional
-                    ? ambient.resolveOptional(token, resolveOptions)
-                    : ambient.resolve(token, resolveOptions);
+                    ? ambient.resolveOptional(resolveKey, resolveOptions)
+                    : ambient.resolve(resolveKey, resolveOptions);
                 context.access.set(this, value);
                 return;
             }
@@ -60,8 +62,8 @@ export function inject(token, options) {
                 throw new MissingContainerContextError(classNameOf(this), context.name);
             }
             const value = descriptor.optional
-                ? container.resolveOptional(token, resolveOptions)
-                : container.resolve(token, resolveOptions);
+                ? container.resolveOptional(resolveKey, resolveOptions)
+                : container.resolve(resolveKey, resolveOptions);
             context.access.set(this, value);
         });
         return {};
@@ -73,5 +75,4 @@ export function inject(token, options) {
     }
     Object.defineProperties(decoratorFn, props);
     return decoratorFn;
-}
-//# sourceMappingURL=inject.js.map
+}

package/dist/decorators/injectable.d.ts

@@ -54,5 +54,4 @@ export declare function injectable(): (target: unknown, context: ClassDecoratorC
  * @since 0.3.16-canary.0
  */
 export declare function injectable<const Deps extends ReadonlyArray<InjectableDependency>>(deps: Deps, options?: InjectableOptions): <Target extends abstract new (...args: InjectedParameters<Deps>) => unknown>(target: Target & (number extends Deps["length"] ? unknown : Deps["length"] extends ConstructorParameters<Target>["length"] ? unknown : never), context: ClassDecoratorContext) => void;
-export type { InjectableDependency };
-//# sourceMappingURL=injectable.d.ts.map
+export type { InjectableDependency };

package/dist/decorators/injectable.js

@@ -52,5 +52,4 @@ export function injectable(deps, options) {
             options.autoRegister.register(target, scope);
         }
     };
-}
-//# sourceMappingURL=injectable.js.map
+}