@codefast/di 0.9.0 → 0.10.1

package/dist/core/state-epoch.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The process-wide counter every container mutation advances, so a chain walk can be skipped while nothing moved.
+ */
+/**
+ * The current state epoch: unchanged between two reads exactly when no registry or lifecycle table
+ * in the process was mutated in between.
+ *
+ * @since 0.10.0
+ */
+export declare function stateEpoch(): number;
+/**
+ * Advances the epoch; every registry version bump and every activation-hook registration calls it.
+ *
+ * @since 0.10.0
+ */
+export declare function advanceStateEpoch(): void;

package/dist/core/state-epoch.js

@@ -0,0 +1,21 @@
+/**
+ * The process-wide counter every container mutation advances, so a chain walk can be skipped while nothing moved.
+ */
+let epoch = 0;
+/**
+ * The current state epoch: unchanged between two reads exactly when no registry or lifecycle table
+ * in the process was mutated in between.
+ *
+ * @since 0.10.0
+ */
+export function stateEpoch() {
+    return epoch;
+}
+/**
+ * Advances the epoch; every registry version bump and every activation-hook registration calls it.
+ *
+ * @since 0.10.0
+ */
+export function advanceStateEpoch() {
+    epoch += 1;
+}

package/dist/core/token.d.ts

@@ -1,4 +1,4 @@
-import type { Constructor } from "#/core/constructor-type";
+import type { Constructor } from "#core/constructor-type";
 declare const TOKEN_BRAND: unique symbol;
 declare const TOKEN_NAMES_BRAND: unique symbol;
 /**

package/dist/core/types.d.ts

@@ -1,8 +1,8 @@
-import type { Constructor } from "#/core/constructor-type";
-import type { BindingTag, TagKeyMask } from "#/core/tag";
-import type { Token } from "#/core/token";
-export type { Constructor } from "#/core/constructor-type";
-export type { BindingTag, TagKey, TagKeyMask } from "#/core/tag";
+import type { Constructor } from "#core/constructor-type";
+import type { BindingTag, TagKeyMask } from "#core/tag";
+import type { Token } from "#core/token";
+export type { Constructor } from "#core/constructor-type";
+export type { BindingTag, TagKey, TagKeyMask } from "#core/tag";
 /**
  * Token or class constructor used as a binding / injection / resolve key.
  *
@@ -17,11 +17,14 @@ export type DependencyKey = Token<unknown> | Constructor;
 export type BindingScope = "singleton" | "transient" | "scoped";
 declare const BINDING_ID_BRAND: unique symbol;
 /**
- * A branded string that uniquely identifies one binding.
+ * A branded number that uniquely identifies one binding for the life of the process.
+ *
+ * @remarks Minted from a counter, never parsed or displayed as an identity: the brand is what makes
+ * it opaque, and a number costs a plain bind nothing where a string cost it an allocation.
  *
  * @since 0.3.16-canary.0
  */
-export type BindingIdentifier = string & {
+export type BindingIdentifier = number & {
     readonly [BINDING_ID_BRAND]: true;
 };
 /**
@@ -109,8 +112,8 @@ export interface ResolutionContext {
     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>>;
+    resolveAll<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): ReadonlyArray<Value>;
+    resolveAllAsync<Value>(token: Token<Value> | Constructor<Value>, options?: ResolveOptions): Promise<ReadonlyArray<Value>>;
     readonly graph: ConstraintContext;
 }
 /**

package/dist/decorators/inject.d.ts

@@ -1,7 +1,7 @@
 /** `@inject` — the accessor-decorator channel, resolving from the ambient container. */
-import type { Token } from "#/core/token";
-import type { Constructor } from "#/core/types";
-import type { InjectionDescriptor, InjectOptions } from "#/injection/descriptor";
+import type { Token } from "#core/token";
+import type { Constructor } from "#core/types";
+import type { InjectionDescriptor, InjectOptions } from "#injection/descriptor";
 type ClassAccessorDecorator<This, Value> = (target: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext<This, Value>) => ClassAccessorDecoratorResult<This, Value> | void;
 /**
  * Creates a dual-role value: an injection descriptor that also works as a class accessor decorator.

package/dist/decorators/inject.js

@@ -1,8 +1,8 @@
-import { getActiveContainer, getAmbientResolution } from "#/ambient/active-container";
-import { MissingContainerContextError, StaticMemberDecoratorError } from "#/errors/errors";
-import { buildInjectionDescriptor } from "#/injection/descriptor";
-import { injectionSlotToResolveOptions } from "#/injection/resolve-options";
-import { INJECT_ACCESSOR_KEY } from "#/metadata/metadata-keys";
+import { getActiveContainer, getAmbientResolution } from "#ambient/active-container";
+import { MissingContainerContextError, StaticMemberDecoratorError } from "#errors/errors";
+import { buildInjectionDescriptor } from "#injection/descriptor";
+import { injectionSlotToResolveOptions } from "#injection/resolve-options";
+import { INJECT_ACCESSOR_KEY } from "#metadata/metadata-keys";
 /**
  * The name of the class being constructed, or `undefined` when there is none to report.
  *

package/dist/decorators/injectable.d.ts

@@ -1,5 +1,5 @@
-import type { BindingScope, Constructor } from "#/core/types";
-import type { InjectableDependency, ResolvedDependencyValue } from "#/injection/descriptor";
+import type { BindingScope, Constructor } from "#core/types";
+import type { InjectableDependency, ResolvedDependencyValue } from "#injection/descriptor";
 /**
  * The collector `@injectable` registers a class into, for a container to bind later.
  *

package/dist/decorators/injectable.js

@@ -1,5 +1,5 @@
-import { normalizeToDescriptor } from "#/injection/descriptor";
-import { INJECTABLE_KEY } from "#/metadata/metadata-keys";
+import { normalizeToDescriptor } from "#injection/descriptor";
+import { INJECTABLE_KEY } from "#metadata/metadata-keys";
 /**
  * Creates an empty auto-register registry.
  *

package/dist/decorators/lifecycle-decorators.js

@@ -1,5 +1,5 @@
-import { StaticMemberDecoratorError } from "#/errors/errors";
-import { LIFECYCLE_KEY } from "#/metadata/metadata-keys";
+import { StaticMemberDecoratorError } from "#errors/errors";
+import { LIFECYCLE_KEY } from "#metadata/metadata-keys";
 /** Records the decorated method under one lifecycle phase; both decorators differ only in that phase. */
 function recordLifecycleMethod(phase) {
     return function (target, context) {

package/dist/errors/diagnostics.d.ts

@@ -25,6 +25,8 @@ export interface ResolutionDiagnostics {
     readonly compiledPlanCount: number;
     /** Bindings with a compiled async instantiation plan. */
     readonly compiledAsyncPlanCount: number;
+    /** Plans this container's resolver has generated as functions of their own. */
+    readonly generatedPlanCount: number;
     /** Contexts held by the depth-indexed sync pool. */
     readonly syncContextPoolSize: number;
     /** Scoped instances currently cached by this container's scope manager. */

package/dist/errors/errors.d.ts

@@ -1,5 +1,5 @@
-import type { ConstraintRequirement } from "#/core/constraint-requirement";
-import type { BindingIdentifier, BindingScope, ResolveOptions } from "#/core/types";
+import type { ConstraintRequirement } from "#core/constraint-requirement";
+import type { BindingIdentifier, BindingScope, ResolveOptions } from "#core/types";
 /**
  * Base class for every error the library throws, each carrying a machine-readable `code`.
  *
@@ -223,6 +223,32 @@ export declare class MissingContainerContextError extends DiError {
     readonly accessorName: string | symbol;
     constructor(className: string | undefined, accessorName: string | symbol);
 }
+/**
+ * A second `to*()` on a chain that already registered its binding.
+ *
+ * @remarks A chain is its binding, so it registers exactly once; a token bound twice is two `bind()`
+ * calls, the second of which displaces the first under slot last-wins.
+ *
+ * @since 0.10.0
+ */
+export declare class ChainAlreadyRegisteredError extends DiError {
+    readonly code = "CHAIN_ALREADY_REGISTERED";
+    readonly tokenName: string;
+    constructor(tokenName: string);
+}
+/**
+ * `many()` on a binding with a named or tagged slot, or a slot constraint on a collection member.
+ *
+ * @remarks A collection member keeps the default slot: its membership replaces slot last-wins, and a
+ * tagged member would have no index able to return every member of the tag.
+ *
+ * @since 0.10.0
+ */
+export declare class ManyBindingSlotError extends DiError {
+    readonly code = "MANY_BINDING_SLOT";
+    readonly tokenName: string;
+    constructor(tokenName: string);
+}
 /**
  * A fluent chain was refined before a `to*()` call gave it a binding to refine.
  *
@@ -230,7 +256,7 @@ export declare class MissingContainerContextError extends DiError {
  * `BindToBuilder`, which exposes only `to*()`. It exists for JavaScript callers and for anyone who
  * casts past the types, so the misuse fails loudly instead of mutating nothing.
  *
- * @since 0.5.0-canary.8
+ * @since 0.10.0
  */
 export declare class ChainNotRegisteredError extends DiError {
     readonly code = "CHAIN_NOT_REGISTERED";

package/dist/errors/errors.js

@@ -1,4 +1,4 @@
-import { slotName } from "#/core/tag";
+import { slotName } from "#core/tag";
 /**
  * Base class for every error the library throws, each carrying a machine-readable `code`.
  *
@@ -316,6 +316,38 @@ export class MissingContainerContextError extends DiError {
         this.accessorName = accessorName;
     }
 }
+/**
+ * A second `to*()` on a chain that already registered its binding.
+ *
+ * @remarks A chain is its binding, so it registers exactly once; a token bound twice is two `bind()`
+ * calls, the second of which displaces the first under slot last-wins.
+ *
+ * @since 0.10.0
+ */
+export class ChainAlreadyRegisteredError extends DiError {
+    code = "CHAIN_ALREADY_REGISTERED";
+    tokenName;
+    constructor(tokenName) {
+        super(`The binding for token '${tokenName}' is already registered on this chain. Call bind() again to register another binding for the token.`);
+        this.tokenName = tokenName;
+    }
+}
+/**
+ * `many()` on a binding with a named or tagged slot, or a slot constraint on a collection member.
+ *
+ * @remarks A collection member keeps the default slot: its membership replaces slot last-wins, and a
+ * tagged member would have no index able to return every member of the tag.
+ *
+ * @since 0.10.0
+ */
+export class ManyBindingSlotError extends DiError {
+    code = "MANY_BINDING_SLOT";
+    tokenName;
+    constructor(tokenName) {
+        super(`A many() binding for token '${tokenName}' keeps the default slot: it cannot also declare whenNamed() or whenTagged().`);
+        this.tokenName = tokenName;
+    }
+}
 /**
  * A fluent chain was refined before a `to*()` call gave it a binding to refine.
  *
@@ -323,7 +355,7 @@ export class MissingContainerContextError extends DiError {
  * `BindToBuilder`, which exposes only `to*()`. It exists for JavaScript callers and for anyone who
  * casts past the types, so the misuse fails loudly instead of mutating nothing.
  *
- * @since 0.5.0-canary.8
+ * @since 0.10.0
  */
 export class ChainNotRegisteredError extends DiError {
     code = "CHAIN_NOT_REGISTERED";

package/dist/index.d.ts

@@ -1,35 +1,35 @@
-export type { ActivationHandler, BindingConstraint, BindingIdentifier, BindingKind, BindingScope, BindingTag, ConstraintContext, Constructor, DependencyKey, DeactivationHandler, ResolutionFrame, ResolveOptions, ResolutionContext, TokenValue, } from "#/core/types";
-export { token, tokenName } from "#/core/token";
-export type { SlotNamesOf, Token } from "#/core/token";
-export { coversTagKeys, NO_TAG_KEYS, slotName, tag, tagKeyMaskOf } from "#/core/tag";
-export type { TagKey, TagKeyMask } from "#/core/tag";
-export type { AliasBindingBuilder, BindToBuilder, BindingBuilder, ConstantBindingBuilder, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, SlotConstrainedBuilder, TransientBindingBuilder, } from "#/core/binding";
-export { Container } from "#/container/container";
-export type { Container as ContainerInterface, ContainerOptions, ContainerStatic } from "#/container/container";
-export { getActiveContainer, runWithContainer } from "#/ambient/active-container";
-export { bindingSlotToResolveOptions, injectionSlotToResolveOptions, resolveOptionsForSlot, } from "#/injection/resolve-options";
-export type { DependencySlot } from "#/injection/resolve-options";
-export type { BindingSnapshot, ContainerSnapshot } from "#/introspection/inspector";
-export type { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions } from "#/introspection/dependency-graph";
-export { AsyncModule, isSyncModule, Module, SyncModule } from "#/core/module";
-export type { AsyncModuleBuilder, ModuleBuilder } from "#/core/module";
-export { inject } from "#/decorators/inject";
-export { injectAll, isInjectionDescriptor, optional } from "#/injection/descriptor";
-export type { InjectionDescriptor, InjectOptions } from "#/injection/descriptor";
-export { injectable } from "#/decorators/injectable";
-export type { InjectableDependency, InjectableOptions } from "#/decorators/injectable";
-export { postConstruct, preDestroy } from "#/decorators/lifecycle-decorators";
-export { createAutoRegisterRegistry } from "#/decorators/injectable";
-export type { AutoRegisterRegistry } from "#/decorators/injectable";
-export { MetadataReaderToken } from "#/metadata/metadata-reader-token";
-export type { ConstructorMetadata, LifecycleMetadata, MetadataReader, MutableLifecycleMetadata, ParamMetadata, } from "#/metadata/metadata-types";
-export { defaultMetadataReader, SymbolMetadataReader } from "#/metadata/symbol-metadata-reader";
-export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll, } from "#/resolution/select/constraints";
-export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainNotRegisteredError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#/errors/errors";
-export type { ScopeViolationDetails } from "#/errors/errors";
-export { toDotGraph } from "#/introspection/graph-adapters/dot";
-export { toCytoscapeGraph } from "#/introspection/graph-adapters/cytoscape";
-export type { CytoscapeEdge, CytoscapeElements, CytoscapeNode } from "#/introspection/graph-adapters/cytoscape";
-export { toReactFlowGraph } from "#/introspection/graph-adapters/reactflow";
-export type { ReactFlowEdge, ReactFlowGraph, ReactFlowNode } from "#/introspection/graph-adapters/reactflow";
-export { toMermaidGraph } from "#/introspection/graph-adapters/mermaid";
+export type { ActivationHandler, BindingConstraint, BindingIdentifier, BindingKind, BindingScope, BindingTag, ConstraintContext, Constructor, DependencyKey, DeactivationHandler, ResolutionFrame, ResolveOptions, ResolutionContext, TokenValue, } from "#core/types";
+export { token, tokenName } from "#core/token";
+export type { SlotNamesOf, Token } from "#core/token";
+export { coversTagKeys, NO_TAG_KEYS, slotName, tag, tagKeyMaskOf } from "#core/tag";
+export type { TagKey, TagKeyMask } from "#core/tag";
+export type { AliasBindingBuilder, BindToBuilder, BindingBuilder, ConstantBindingBuilder, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, SlotConstrainedBuilder, TransientBindingBuilder, } from "#core/binding";
+export { Container } from "#container/container";
+export type { Container as ContainerInterface, ContainerOptions, ContainerStatic } from "#container/container";
+export { getActiveContainer, runWithContainer } from "#ambient/active-container";
+export { bindingSlotToResolveOptions, injectionSlotToResolveOptions, resolveOptionsForSlot, } from "#injection/resolve-options";
+export type { DependencySlot } from "#injection/resolve-options";
+export type { BindingSnapshot, ContainerSnapshot } from "#introspection/inspector";
+export type { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions } from "#introspection/dependency-graph";
+export { AsyncModule, isSyncModule, Module, SyncModule } from "#core/module";
+export type { AsyncModuleBuilder, ModuleBuilder } from "#core/module";
+export { inject } from "#decorators/inject";
+export { injectAll, isInjectionDescriptor, optional } from "#injection/descriptor";
+export type { InjectionDescriptor, InjectOptions } from "#injection/descriptor";
+export { injectable } from "#decorators/injectable";
+export type { InjectableDependency, InjectableOptions } from "#decorators/injectable";
+export { postConstruct, preDestroy } from "#decorators/lifecycle-decorators";
+export { createAutoRegisterRegistry } from "#decorators/injectable";
+export type { AutoRegisterRegistry } from "#decorators/injectable";
+export { MetadataReaderToken } from "#metadata/metadata-reader-token";
+export type { ConstructorMetadata, LifecycleMetadata, MetadataReader, MutableLifecycleMetadata, ParamMetadata, } from "#metadata/metadata-types";
+export { defaultMetadataReader, SymbolMetadataReader } from "#metadata/symbol-metadata-reader";
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll, } from "#resolution/select/constraints";
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainAlreadyRegisteredError, ChainNotRegisteredError, ManyBindingSlotError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#errors/errors";
+export type { ScopeViolationDetails } from "#errors/errors";
+export { toDotGraph } from "#introspection/graph-adapters/dot";
+export { toCytoscapeGraph } from "#introspection/graph-adapters/cytoscape";
+export type { CytoscapeEdge, CytoscapeElements, CytoscapeNode } from "#introspection/graph-adapters/cytoscape";
+export { toReactFlowGraph } from "#introspection/graph-adapters/reactflow";
+export type { ReactFlowEdge, ReactFlowGraph, ReactFlowNode } from "#introspection/graph-adapters/reactflow";
+export { toMermaidGraph } from "#introspection/graph-adapters/mermaid";

package/dist/index.js

@@ -1,33 +1,33 @@
 // Token
-export { token, tokenName } from "#/core/token";
+export { token, tokenName } from "#core/token";
 // Tag — the interned slot criteria a `whenTagged` and a resolve both take
-export { coversTagKeys, NO_TAG_KEYS, slotName, tag, tagKeyMaskOf } from "#/core/tag";
+export { coversTagKeys, NO_TAG_KEYS, slotName, tag, tagKeyMaskOf } from "#core/tag";
 // Container
-export { Container } from "#/container/container";
+export { Container } from "#container/container";
 // Ambient container — the context an `@inject` accessor initializer resolves from. `resolution/context`
 // stays internal: it hands out resolver callbacks, not public values.
-export { getActiveContainer, runWithContainer } from "#/ambient/active-container";
+export { getActiveContainer, runWithContainer } from "#ambient/active-container";
 // `effectiveBindingScope` is deliberately absent: it reads a `Binding`, which is internal, and no
 // public API hands one out. `BindingSnapshot.scope` and `GraphNode.scope` are the public answers.
-export { bindingSlotToResolveOptions, injectionSlotToResolveOptions, resolveOptionsForSlot, } from "#/injection/resolve-options";
+export { bindingSlotToResolveOptions, injectionSlotToResolveOptions, resolveOptionsForSlot, } from "#injection/resolve-options";
 // Module
-export { AsyncModule, isSyncModule, Module, SyncModule } from "#/core/module";
+export { AsyncModule, isSyncModule, Module, SyncModule } from "#core/module";
 // Decorators
-export { inject } from "#/decorators/inject";
-export { injectAll, isInjectionDescriptor, optional } from "#/injection/descriptor";
-export { injectable } from "#/decorators/injectable";
-export { postConstruct, preDestroy } from "#/decorators/lifecycle-decorators";
+export { inject } from "#decorators/inject";
+export { injectAll, isInjectionDescriptor, optional } from "#injection/descriptor";
+export { injectable } from "#decorators/injectable";
+export { postConstruct, preDestroy } from "#decorators/lifecycle-decorators";
 // Auto-register
-export { createAutoRegisterRegistry } from "#/decorators/injectable";
+export { createAutoRegisterRegistry } from "#decorators/injectable";
 // MetadataReader — everything a consumer needs to write one and pass it to Container.create()
-export { MetadataReaderToken } from "#/metadata/metadata-reader-token";
-export { defaultMetadataReader, SymbolMetadataReader } from "#/metadata/symbol-metadata-reader";
+export { MetadataReaderToken } from "#metadata/metadata-reader-token";
+export { defaultMetadataReader, SymbolMetadataReader } from "#metadata/symbol-metadata-reader";
 // Constraints — contextual injection predicates for .when()
-export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll, } from "#/resolution/select/constraints";
+export { whenAnyAncestorIs, whenAnyAncestorNamed, whenAnyAncestorTagged, whenAnyAncestorTaggedAll, whenNoAncestorIs, whenNoParentIs, whenParentIs, whenParentNamed, whenParentTagged, whenParentTaggedAll, } from "#resolution/select/constraints";
 // Errors
-export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainNotRegisteredError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#/errors/errors";
+export { AmbiguousBindingError, AsyncActivationError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, ChainAlreadyRegisteredError, ChainNotRegisteredError, ManyBindingSlotError, CircularDependencyError, DiError, DisposedContainerError, InternalError, InvalidMetadataError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SyncDisposalNotSupportedError, EmptyTagCriteriaError, TokenNotBoundError, UnreachableConstraintError, UnreachableLifecycleHookError, } from "#errors/errors";
 // Graph adapters — render `generateDependencyGraph()` output for common viewers
-export { toDotGraph } from "#/introspection/graph-adapters/dot";
-export { toCytoscapeGraph } from "#/introspection/graph-adapters/cytoscape";
-export { toReactFlowGraph } from "#/introspection/graph-adapters/reactflow";
-export { toMermaidGraph } from "#/introspection/graph-adapters/mermaid";
+export { toDotGraph } from "#introspection/graph-adapters/dot";
+export { toCytoscapeGraph } from "#introspection/graph-adapters/cytoscape";
+export { toReactFlowGraph } from "#introspection/graph-adapters/reactflow";
+export { toMermaidGraph } from "#introspection/graph-adapters/mermaid";

package/dist/injection/descriptor.d.ts

@@ -1,7 +1,7 @@
 /** The one shape every declared dependency is normalised to, whatever channel declared it. */
-import type { Token } from "#/core/token";
-import type { BindingTag, Constructor, TokenValue } from "#/core/types";
-import type { DependencySlot } from "#/injection/resolve-options";
+import type { Token } from "#core/token";
+import type { BindingTag, Constructor, TokenValue } from "#core/types";
+import type { DependencySlot } from "#injection/resolve-options";
 /**
  * Slot-selection options — a name and tags — a declared dependency narrows its binding with.
  *
@@ -51,7 +51,7 @@ export type InjectableDependency<Value = unknown> = Token<Value> | Constructor<V
  */
 export type ResolvedDependencyValue<Dependency> = Dependency extends {
     readonly multi: true;
-} ? Array<DescribedValue<Dependency>> : Dependency extends {
+} ? ReadonlyArray<DescribedValue<Dependency>> : Dependency extends {
     readonly optional: true;
 } ? DescribedValue<Dependency> | undefined : DescribedValue<Dependency>;
 /**
@@ -59,7 +59,7 @@ export type ResolvedDependencyValue<Dependency> = Dependency extends {
  *
  * @remarks Split out because a hand-written descriptor states its flags and its value type
  * separately, and only the flags are load-bearing: `{ token: Plugin, multi: true }` says `Plugin`
- * and delivers `Array<Plugin>`. `injectAll()` and `optional()` already fold their effect in, so the
+ * and delivers `ReadonlyArray<Plugin>`. `injectAll()` and `optional()` already fold their effect in, so the
  * flags find an array or an optional there and leave it alone.
  */
 type DescribedValue<Dependency> = Dependency extends InjectionDescriptor<infer Value> ? Value : TokenValue<Dependency>;
@@ -88,9 +88,11 @@ export declare function buildInjectionDescriptor<Value, Names extends string = s
  */
 export declare function optional<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<InjectOptions<Names>>): InjectionDescriptor<Value | undefined>;
 /**
- * Creates a descriptor that resolves every matching binding for the token into an array.
+ * Creates a descriptor that resolves every matching binding for the token into a read-only array.
+ *
+ * @remarks Read-only because a root-level read may hand out the engine's own cached list.
  *
  * @since 0.3.16-canary.0
  */
-export declare function injectAll<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<InjectOptions<Names>>): InjectionDescriptor<Array<Value>>;
+export declare function injectAll<Value, Names extends string = string>(token: Token<Value, Names> | Constructor<Value>, options?: NoInfer<InjectOptions<Names>>): InjectionDescriptor<ReadonlyArray<Value>>;
 export {};

package/dist/injection/descriptor.js

@@ -112,7 +112,9 @@ export function optional(token, options) {
     }, options);
 }
 /**
- * Creates a descriptor that resolves every matching binding for the token into an array.
+ * Creates a descriptor that resolves every matching binding for the token into a read-only array.
+ *
+ * @remarks Read-only because a root-level read may hand out the engine's own cached list.
  *
  * @since 0.3.16-canary.0
  */

package/dist/injection/resolve-options.d.ts

@@ -1,6 +1,6 @@
-import type { BindingTag } from "#/core/tag";
-import type { Token } from "#/core/token";
-import type { Constructor, ResolveOptions } from "#/core/types";
+import type { BindingTag } from "#core/tag";
+import type { Token } from "#core/token";
+import type { Constructor, ResolveOptions } from "#core/types";
 /**
  * What one resolvable dependency declares.
  *
@@ -26,6 +26,12 @@ export interface DependencySlot {
  * @since 0.5.0-canary.9
  */
 export declare function singleCriterionOnlyOf(options: ResolveOptions | undefined): BindingTag | undefined;
+/**
+ * The one tag a request carries beside its name, for the name-plus-tag lane; `undefined` for every other shape.
+ *
+ * @since 0.10.0
+ */
+export declare function loneTagBesideNameOf(options: ResolveOptions): BindingTag | undefined;
 /**
  * Builds a {@link ResolveOptions} safe for `exactOptionalPropertyTypes`:
  * omits keys instead of assigning `undefined`.

package/dist/injection/resolve-options.js

@@ -1,4 +1,4 @@
-import { slotName, slotNameCriterionOf } from "#/core/tag";
+import { slotName, slotNameCriterionOf } from "#core/tag";
 /**
  * The lone criterion of a request that carries exactly one, whatever its spelling — the shape the
  * registry has a direct index for.
@@ -22,6 +22,22 @@ export function singleCriterionOnlyOf(options) {
     }
     return listed !== undefined && listed.length === 1 ? listed[0] : undefined;
 }
+/**
+ * The one tag a request carries beside its name, for the name-plus-tag lane; `undefined` for every other shape.
+ *
+ * @since 0.10.0
+ */
+export function loneTagBesideNameOf(options) {
+    if (options.name === undefined) {
+        return undefined;
+    }
+    const listed = options.tags;
+    const shorthand = options.tag;
+    if (shorthand !== undefined) {
+        return listed === undefined || listed.length === 0 ? shorthand : undefined;
+    }
+    return listed !== undefined && listed.length === 1 ? listed[0] : undefined;
+}
 /** The name spelling's half of the fold, kept apart so the common body stays small enough to inline. */
 function loneNameCriterionOf(options) {
     // A name next to any tag means the request carries two criteria, which no single index answers.

package/dist/introspection/dependency-graph.d.ts

@@ -1,6 +1,6 @@
-import type { BindingRegistry } from "#/core/registry";
-import type { BindingKind, BindingScope } from "#/core/types";
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { BindingRegistry } from "#core/registry";
+import type { BindingKind, BindingScope } from "#core/types";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * @remarks `kind`/`scope` are `"unbound"` for the placeholder node an optional, currently
  * unsatisfied dependency points at.

package/dist/introspection/dependency-graph.js

@@ -1,8 +1,8 @@
-import { effectiveBindingScope } from "#/core/binding-scope";
-import { slotName } from "#/core/tag";
-import { tokenName } from "#/core/token";
-import { bindingSlotToResolveOptions } from "#/injection/resolve-options";
-import { matchesSlot } from "#/resolution/select/binding-select";
+import { effectiveBindingScope } from "#core/binding-scope";
+import { slotName } from "#core/tag";
+import { tokenName } from "#core/token";
+import { bindingSlotToResolveOptions } from "#injection/resolve-options";
+import { matchesSlot } from "#resolution/select/binding-select";
 // ── Builder ──────────────────────────────────────────────────────────────────────────────────────────────────────────
 // Tokens are compared by object identity, and a name is free to repeat, so the graph mints its
 // own per-process key. Weakly held: a discarded token takes its key with it.
@@ -100,7 +100,7 @@ function addDependencyEdges(accumulator, from, ref, index, lookup) {
             : label;
         accumulator.edges.push({
             from,
-            to: target.id,
+            to: String(target.identifier),
             label: perTargetLabel,
             optional: ref.optional,
             ...(edgeSlotName !== undefined ? { slotName: edgeSlotName } : {}),
@@ -113,21 +113,26 @@ function addBindingEdges(accumulator, binding, metadataReader, lookup) {
         const meta = metadataReader.getConstructorMetadata(binding.target);
         if (meta !== undefined) {
             for (const [index, param] of meta.params.entries()) {
-                addDependencyEdges(accumulator, binding.id, param, index, lookup);
+                addDependencyEdges(accumulator, String(binding.identifier), param, index, lookup);
             }
         }
         return;
     }
     if (binding.kind === "resolved" || binding.kind === "resolved-async") {
         for (const [index, dependency] of binding.deps.entries()) {
-            addDependencyEdges(accumulator, binding.id, dependency, index, lookup);
+            addDependencyEdges(accumulator, String(binding.identifier), dependency, index, lookup);
         }
         return;
     }
     if (binding.kind === "alias") {
         const aliasRef = { token: binding.target, optional: false, multi: false };
         for (const target of matchingTargets(lookup(binding.target), aliasRef)) {
-            accumulator.edges.push({ from: binding.id, to: target.id, label: "alias", optional: false });
+            accumulator.edges.push({
+                from: String(binding.identifier),
+                to: String(target.identifier),
+                label: "alias",
+                optional: false,
+            });
         }
     }
 }
@@ -135,7 +140,7 @@ function addRegistryBindings(accumulator, sourceRegistry, metadataReader, fromPa
     const lookup = bindingLookup(sourceRegistry, fallbackRegistry);
     for (const binding of sourceRegistry.allBindings()) {
         accumulator.nodes.push({
-            id: binding.id,
+            id: String(binding.identifier),
             tokenName: tokenName(binding.token),
             tokenKey: tokenKeyOf(binding.token),
             kind: binding.kind,

package/dist/introspection/graph-adapters/cytoscape.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerGraphJson, GraphNode } from "#/introspection/dependency-graph";
+import type { ContainerGraphJson, GraphNode } from "#introspection/dependency-graph";
 /**
  * A dependency-graph node in Cytoscape's element format.
  *

package/dist/introspection/graph-adapters/dot.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerGraphJson } from "#/introspection/dependency-graph";
+import type { ContainerGraphJson } from "#introspection/dependency-graph";
 /**
  * Renders a container's dependency graph as Graphviz DOT source.
  *

package/dist/introspection/graph-adapters/mermaid.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerGraphJson } from "#/introspection/dependency-graph";
+import type { ContainerGraphJson } from "#introspection/dependency-graph";
 /**
  * Mermaid `flowchart TD` source for a container graph — renders anywhere Mermaid does
  * (GitHub markdown, docs tooling, mermaid.live) with no extra library.

package/dist/introspection/graph-adapters/reactflow.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerGraphJson, GraphNode } from "#/introspection/dependency-graph";
+import type { ContainerGraphJson, GraphNode } from "#introspection/dependency-graph";
 /**
  * A dependency-graph node in React Flow's node format.
  *