@codefast/di 0.10.0 → 0.10.1

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,15 +316,6 @@ export class MissingContainerContextError extends DiError {
         this.accessorName = accessorName;
     }
 }
-/**
- * A fluent chain was refined before a `to*()` call gave it a binding to refine.
- *
- * @remarks The builder types make this unreachable from TypeScript — `bind()` returns
- * `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
- */
 /**
  * A second `to*()` on a chain that already registered its binding.
  *
@@ -358,6 +349,12 @@ export class ManyBindingSlotError extends DiError {
     }
 }
 /**
+ * A fluent chain was refined before a `to*()` call gave it a binding to refine.
+ *
+ * @remarks The builder types make this unreachable from TypeScript — `bind()` returns
+ * `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.10.0
  */
 export class ChainNotRegisteredError extends DiError {

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, 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";
+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, 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 { 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.
  *

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.
  *

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.

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.

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.
  *

package/dist/introspection/inspector.d.ts

@@ -1,7 +1,7 @@
-import type { BindingRegistry } from "#/core/registry";
-import type { Token } from "#/core/token";
-import type { BindingIdentifier, BindingKind, BindingScope, BindingTag, Constructor, ResolveOptions } from "#/core/types";
-import type { ScopeManager } from "#/lifecycle/scope-manager";
+import type { BindingRegistry } from "#core/registry";
+import type { Token } from "#core/token";
+import type { BindingIdentifier, BindingKind, BindingScope, BindingTag, Constructor, ResolveOptions } from "#core/types";
+import type { ScopeManager } from "#lifecycle/scope-manager";
 /**
  * A read-only view of one binding: token, kind, scope, slot, and id.
  *

package/dist/introspection/inspector.js

@@ -1,6 +1,6 @@
-import { effectiveBindingScope } from "#/core/binding-scope";
-import { tokenName } from "#/core/token";
-import { selectAllBindings } from "#/resolution/select/binding-select";
+import { effectiveBindingScope } from "#core/binding-scope";
+import { tokenName } from "#core/token";
+import { selectAllBindings } from "#resolution/select/binding-select";
 // ── Inspector ────────────────────────────────────────────────────────────────────────────────────────────────────────
 /**
  * The read-only introspection surface behind a container's `inspect()`.

package/dist/lifecycle/lifecycle-manager.d.ts

@@ -1,7 +1,7 @@
-import type { Binding } from "#/core/binding";
-import type { Token } from "#/core/token";
-import type { ActivationHandler, Constructor, DeactivationHandler, DependencyKey, ResolutionContext } from "#/core/types";
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { Binding } from "#core/binding";
+import type { Token } from "#core/token";
+import type { ActivationHandler, Constructor, DeactivationHandler, DependencyKey, ResolutionContext } from "#core/types";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * One container's registry of container-level activation and deactivation hooks, keyed by token.
  *

package/dist/lifecycle/lifecycle-manager.js

@@ -1,7 +1,7 @@
-import { getOrInsert } from "#/core/map-upsert";
-import { advanceStateEpoch } from "#/core/state-epoch";
-import { tokenName } from "#/core/token";
-import { AsyncActivationError, AsyncDeactivationError, InvalidMetadataError } from "#/errors/errors";
+import { getOrInsert } from "#core/map-upsert";
+import { advanceStateEpoch } from "#core/state-epoch";
+import { tokenName } from "#core/token";
+import { AsyncActivationError, AsyncDeactivationError, InvalidMetadataError } from "#errors/errors";
 /**
  * One container's registry of container-level activation and deactivation hooks, keyed by token.
  *

package/dist/lifecycle/scope-manager.d.ts

@@ -1,5 +1,5 @@
-import type { Binding } from "#/core/binding";
-import type { BindingIdentifier } from "#/core/types";
+import type { Binding } from "#core/binding";
+import type { BindingIdentifier } from "#core/types";
 /**
  * One container's instance caches — singletons, in-flight async creations, and the scoped cache.
  *

package/dist/lifecycle/scope-manager.js

@@ -1,6 +1,6 @@
-import { NO_INSTANCE } from "#/core/binding";
-import { tokenName } from "#/core/token";
-import { MissingScopeContextError } from "#/errors/errors";
+import { NO_INSTANCE } from "#core/binding";
+import { tokenName } from "#core/token";
+import { MissingScopeContextError } from "#errors/errors";
 /**
  * One container's instance caches — singletons, in-flight async creations, and the scoped cache.
  *

package/dist/metadata/metadata-reader-token.d.ts

@@ -1,5 +1,5 @@
-import type { Token } from "#/core/token";
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { Token } from "#core/token";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * The token a custom `MetadataReader` is bound to for a container to pick up.
  *

package/dist/metadata/metadata-reader-token.js

@@ -1,4 +1,4 @@
-import { token } from "#/core/token";
+import { token } from "#core/token";
 /**
  * The token a custom `MetadataReader` is bound to for a container to pick up.
  *

package/dist/metadata/metadata-types.d.ts

@@ -1,6 +1,6 @@
-import type { Constructor } from "#/core/types";
-import type { InjectionDescriptor } from "#/injection/descriptor";
-import type { DependencySlot } from "#/injection/resolve-options";
+import type { Constructor } from "#core/types";
+import type { InjectionDescriptor } from "#injection/descriptor";
+import type { DependencySlot } from "#injection/resolve-options";
 /**
  * One constructor parameter's declaration.
  *

package/dist/metadata/symbol-metadata-reader.d.ts

@@ -1,6 +1,6 @@
-import type { Constructor } from "#/core/types";
-import type { InjectionDescriptor } from "#/injection/descriptor";
-import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#/metadata/metadata-types";
+import type { Constructor } from "#core/types";
+import type { InjectionDescriptor } from "#injection/descriptor";
+import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#metadata/metadata-types";
 type AccessorEntry = {
     readonly key: string | symbol;
     readonly descriptor: InjectionDescriptor;

package/dist/metadata/symbol-metadata-reader.js

@@ -1,4 +1,4 @@
-import { INJECT_ACCESSOR_KEY, INJECTABLE_KEY, LIFECYCLE_KEY, METADATA_SYMBOL } from "#/metadata/metadata-keys";
+import { INJECT_ACCESSOR_KEY, INJECTABLE_KEY, LIFECYCLE_KEY, METADATA_SYMBOL } from "#metadata/metadata-keys";
 /**
  * The default `MetadataReader`, reading decorator metadata stored under `Symbol.metadata`.
  *

package/dist/metadata/verifying-metadata-reader.d.ts

@@ -2,7 +2,7 @@
  * Wraps a foreign {@link MetadataReader} so its answers are verified before anything dereferences
  * them.
  */
-import type { MetadataReader } from "#/metadata/metadata-types";
+import type { MetadataReader } from "#metadata/metadata-types";
 /**
  * The reader a container should hand its resolver: verified when it came from outside.
  *

package/dist/metadata/verifying-metadata-reader.js

@@ -2,8 +2,8 @@
  * Wraps a foreign {@link MetadataReader} so its answers are verified before anything dereferences
  * them.
  */
-import { defaultMetadataReader } from "#/metadata/symbol-metadata-reader";
-import { verifyAccessorMetadata, verifyConstructorMetadata, verifyLifecycleMetadata, } from "#/resolution/cache/class-introspector";
+import { defaultMetadataReader } from "#metadata/symbol-metadata-reader";
+import { verifyAccessorMetadata, verifyConstructorMetadata, verifyLifecycleMetadata, } from "#resolution/cache/class-introspector";
 // Wrapping a wrapper would stack a layer per child container, so each one is remembered.
 const verifyingReaders = new WeakSet();
 /**

package/dist/resolution/cache/activation-need.d.ts

@@ -4,10 +4,10 @@
  * @remarks Versioned on the lifecycle manager plus the own registry, since `onActivation` can be
  * registered at any time and a rebind mints binding ids the memo must not keep forever.
  */
-import type { Binding } from "#/core/binding";
-import type { BindingRegistry } from "#/core/registry";
-import type { LifecycleManager } from "#/lifecycle/lifecycle-manager";
-import type { ClassIntrospector } from "#/resolution/cache/class-introspector";
+import type { Binding } from "#core/binding";
+import type { BindingRegistry } from "#core/registry";
+import type { LifecycleManager } from "#lifecycle/lifecycle-manager";
+import type { ClassIntrospector } from "#resolution/cache/class-introspector";
 /**
  * A per-binding cache of whether activation work — hooks or `@postConstruct` — is needed on resolve.
  *

package/dist/resolution/cache/binding-lookup-cache.d.ts

@@ -4,11 +4,11 @@
  * @remarks Each cache links to its parent's, so a child answers from its own chain without walking
  * the container hierarchy again.
  */
-import type { Binding } from "#/core/binding";
-import type { BindingRegistry } from "#/core/registry";
-import type { BindingTag } from "#/core/tag";
-import type { Token } from "#/core/token";
-import type { Constructor } from "#/core/types";
+import type { Binding } from "#core/binding";
+import type { BindingRegistry } from "#core/registry";
+import type { BindingTag } from "#core/tag";
+import type { Token } from "#core/token";
+import type { Constructor } from "#core/types";
 /**
  * A token's terminal binding with alias hops already folded, plus the container that owns it.
  *

package/dist/resolution/cache/binding-lookup-cache.js

@@ -1,5 +1,5 @@
-import { getOrInsertComputed } from "#/core/map-upsert";
-import { stateEpoch } from "#/core/state-epoch";
+import { getOrInsertComputed } from "#core/map-upsert";
+import { stateEpoch } from "#core/state-epoch";
 /**
  * Alias folding gives up past this many hops and defers to the full resolve loop, whose
  * Set-based traversal detects genuine cycles exactly rather than by an arbitrary cap.

package/dist/resolution/cache/class-introspector.d.ts

@@ -3,11 +3,11 @@
  *
  * @remarks Metadata cannot change once a class is defined, so nothing here needs version stamping.
  */
-import type { AmbientResolution } from "#/ambient/active-container";
-import type { Container } from "#/container/container";
-import type { Constructor } from "#/core/types";
-import type { InjectionDescriptor } from "#/injection/descriptor";
-import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#/metadata/metadata-types";
+import type { AmbientResolution } from "#ambient/active-container";
+import type { Container } from "#container/container";
+import type { Constructor } from "#core/types";
+import type { InjectionDescriptor } from "#injection/descriptor";
+import type { ConstructorMetadata, LifecycleMetadata, MetadataReader } from "#metadata/metadata-types";
 /**
  * A reader's constructor metadata for a class, verified the first time this process asks.
  *

package/dist/resolution/cache/class-introspector.js

@@ -3,8 +3,8 @@
  *
  * @remarks Metadata cannot change once a class is defined, so nothing here needs version stamping.
  */
-import { constructWithAmbientResolution, runWithAmbientResolution } from "#/ambient/active-container";
-import { InvalidMetadataError } from "#/errors/errors";
+import { constructWithAmbientResolution, runWithAmbientResolution } from "#ambient/active-container";
+import { InvalidMetadataError } from "#errors/errors";
 // Verified pairs, not verified classes: two readers may disagree about the same class, and a reader
 // that goes out of scope takes its record with it.
 const verifiedTargets = new WeakMap();
@@ -21,6 +21,20 @@ function markVerified(cache, reader, target) {
     }
     verified.add(target);
 }
+/**
+ * Runs `validate` against a reader's metadata the first time this process sees the pair, then remembers it.
+ *
+ * @remarks An absent metadata answer needs no check; a verified pair is returned untouched, so the
+ * shape assertion runs once per `(reader, target)` rather than per container.
+ */
+function verifyOnce(cache, reader, target, metadata, validate) {
+    if (metadata === undefined || isVerified(cache, reader, target)) {
+        return metadata;
+    }
+    validate(metadata);
+    markVerified(cache, reader, target);
+    return metadata;
+}
 /**
  * A reader's constructor metadata for a class, verified the first time this process asks.
  *
@@ -31,16 +45,9 @@ function markVerified(cache, reader, target) {
  * @since 0.6.0
  */
 export function verifyConstructorMetadata(reader, target) {
-    const metadata = reader.getConstructorMetadata(target);
-    if (metadata === undefined) {
-        return undefined;
-    }
-    if (isVerified(verifiedTargets, reader, target)) {
-        return metadata;
-    }
-    assertConstructorMetadata(metadata, target);
-    markVerified(verifiedTargets, reader, target);
-    return metadata;
+    return verifyOnce(verifiedTargets, reader, target, reader.getConstructorMetadata(target), (metadata) => {
+        assertConstructorMetadata(metadata, target);
+    });
 }
 /**
  * Verifies what a reader claims about a class, since a `MetadataReader` is a public seam.
@@ -81,29 +88,25 @@ export function assertConstructorMetadata(metadata, target) {
  * @since 0.6.0
  */
 export function verifyLifecycleMetadata(reader, target) {
-    const metadata = reader.getLifecycleMetadata(target);
-    if (metadata === undefined || isVerified(verifiedLifecycleTargets, reader, target)) {
-        return metadata;
-    }
-    if (typeof metadata !== "object" || metadata === null) {
-        throw new InvalidMetadataError(target.name, `lifecycle metadata: expected an object, received ${typeof metadata}`);
-    }
-    for (const phase of ["postConstruct", "preDestroy"]) {
-        const methods = Reflect.get(metadata, phase);
-        if (methods === undefined) {
-            continue;
+    return verifyOnce(verifiedLifecycleTargets, reader, target, reader.getLifecycleMetadata(target), (metadata) => {
+        if (typeof metadata !== "object" || metadata === null) {
+            throw new InvalidMetadataError(target.name, `lifecycle metadata: expected an object, received ${typeof metadata}`);
         }
-        if (!Array.isArray(methods)) {
-            throw new InvalidMetadataError(target.name, `lifecycle metadata: ${phase} is not an array`);
-        }
-        for (const [position, name] of methods.entries()) {
-            if (typeof name !== "string") {
-                throw new InvalidMetadataError(target.name, `lifecycle metadata: ${phase}[${String(position)}] is not a string`);
+        for (const phase of ["postConstruct", "preDestroy"]) {
+            const methods = Reflect.get(metadata, phase);
+            if (methods === undefined) {
+                continue;
+            }
+            if (!Array.isArray(methods)) {
+                throw new InvalidMetadataError(target.name, `lifecycle metadata: ${phase} is not an array`);
+            }
+            for (const [position, name] of methods.entries()) {
+                if (typeof name !== "string") {
+                    throw new InvalidMetadataError(target.name, `lifecycle metadata: ${phase}[${String(position)}] is not a string`);
+                }
             }
         }
-    }
-    markVerified(verifiedLifecycleTargets, reader, target);
-    return metadata;
+    });
 }
 /**
  * A reader's accessor metadata for a class, verified the first time this process asks.
@@ -111,32 +114,28 @@ export function verifyLifecycleMetadata(reader, target) {
  * @since 0.6.0
  */
 export function verifyAccessorMetadata(reader, target) {
-    const metadata = reader.getAccessorMetadata?.(target);
-    if (metadata === undefined || isVerified(verifiedAccessorTargets, reader, target)) {
-        return metadata;
-    }
-    if (!Array.isArray(metadata)) {
-        throw new InvalidMetadataError(target.name, "accessor metadata: expected an array");
-    }
-    for (const [position, entry] of metadata.entries()) {
-        if (typeof entry !== "object" || entry === null) {
-            throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}] is not an object`);
-        }
-        const key = Reflect.get(entry, "key");
-        if (typeof key !== "string" && typeof key !== "symbol") {
-            throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}].key is not a string or symbol`);
+    return verifyOnce(verifiedAccessorTargets, reader, target, reader.getAccessorMetadata?.(target), (metadata) => {
+        if (!Array.isArray(metadata)) {
+            throw new InvalidMetadataError(target.name, "accessor metadata: expected an array");
         }
-        const descriptor = Reflect.get(entry, "descriptor");
-        if (typeof descriptor !== "object" || descriptor === null) {
-            throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}].descriptor is not an object`);
-        }
-        const dependency = Reflect.get(descriptor, "token");
-        if (typeof dependency !== "object" && typeof dependency !== "function") {
-            throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}].descriptor.token is not a token or a class`);
+        for (const [position, entry] of metadata.entries()) {
+            if (typeof entry !== "object" || entry === null) {
+                throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}] is not an object`);
+            }
+            const key = Reflect.get(entry, "key");
+            if (typeof key !== "string" && typeof key !== "symbol") {
+                throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}].key is not a string or symbol`);
+            }
+            const descriptor = Reflect.get(entry, "descriptor");
+            if (typeof descriptor !== "object" || descriptor === null) {
+                throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}].descriptor is not an object`);
+            }
+            const dependency = Reflect.get(descriptor, "token");
+            if (typeof dependency !== "object" && typeof dependency !== "function") {
+                throw new InvalidMetadataError(target.name, `accessor metadata: [${String(position)}].descriptor.token is not a token or a class`);
+            }
         }
-    }
-    markVerified(verifiedAccessorTargets, reader, target);
-    return metadata;
+    });
 }
 const cachesByReader = new WeakMap();
 function cachesFor(reader) {