@codefast/di 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -1,35 +1,37 @@
-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 { binding } from "#core/binding-declaration";
+export type { BindingDeclaration, BindingDefinition } from "#core/binding-declaration";
+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, InvalidBindingDeclarationError, InvalidMetadataError, MissingContainerContextError, MissingDecoratorMetadataError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SymbolKeyedLifecycleError, 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,34 @@
 // 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";
+export { binding } from "#core/binding-declaration";
 // 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, InvalidBindingDeclarationError, InvalidMetadataError, MissingContainerContextError, MissingDecoratorMetadataError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SelfBindingRequiresClassError, StaticMemberDecoratorError, SymbolKeyedLifecycleError, 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/descriptor.js

@@ -4,12 +4,8 @@
  * @since 0.3.16-canary.0
  */
 export function isInjectionDescriptor(value) {
-    if (value === null || value === undefined) {
-        return false;
-    }
-    const type = typeof value;
-    // inject() returns a function (dual-role), so must check both object and function
-    if (type !== "object" && type !== "function") {
+    // inject() returns a function (dual-role), so both an object and a function qualify.
+    if ((typeof value !== "object" && typeof value !== "function") || value === null) {
         return false;
     }
     return ("token" in value &&
@@ -106,7 +102,7 @@ export function buildInjectionDescriptor(token, options) {
  */
 export function optional(token, options) {
     return withOptions({
-        token: token,
+        token,
         optional: true,
         multi: false,
     }, options);

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.
@@ -49,15 +49,17 @@ function loneNameCriterionOf(options) {
 }
 /** Shared core: build a ResolveOptions from already-normalised name + tags. */
 function buildOptions(name, tags) {
-    if (name === undefined && tags === undefined) {
+    // An empty criterion list selects nothing, so it states no criterion at all.
+    const criteria = tags !== undefined && tags.length > 0 ? tags : undefined;
+    if (name === undefined && criteria === undefined) {
         return undefined;
     }
     const options = {};
     if (name !== undefined) {
         options.name = name;
     }
-    if (tags !== undefined) {
-        options.tags = tags;
+    if (criteria !== undefined) {
+        options.tags = criteria;
     }
     return options;
 }
@@ -85,7 +87,7 @@ const MEMOIZED_SINGLE_CRITERION = Symbol("di:single-criterion");
  */
 export function resolveOptionsForSlot(injectionSlot) {
     const { name, tags } = injectionSlot;
-    if (name === undefined && tags === undefined) {
+    if (name === undefined && (tags === undefined || tags.length === 0)) {
         return undefined;
     }
     const slot = injectionSlot;

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.
@@ -49,8 +49,13 @@ export interface GraphOptions {
     readonly includeParent?: boolean | undefined;
 }
 /**
- * Builds the JSON dependency graph of a registry's bindings, optionally including the parent's.
+ * Builds the JSON dependency graph of a registry's bindings, optionally including its ancestors'.
+ *
+ * @param registry - The registry whose bindings the graph is for.
+ * @param metadataReader - The reader class dependencies are read through.
+ * @param options - Whether the ancestors' bindings join the graph.
+ * @param ancestorRegistries - The ancestor containers' registries, nearest first.
  *
  * @since 0.3.16-canary.0
  */
-export declare function buildDependencyGraph(registry: BindingRegistry, metadataReader: MetadataReader, options: GraphOptions | undefined, parentRegistry?: BindingRegistry): ContainerGraphJson;
+export declare function buildDependencyGraph(registry: BindingRegistry, metadataReader: MetadataReader, options: GraphOptions | undefined, ancestorRegistries?: ReadonlyArray<BindingRegistry>): ContainerGraphJson;

package/dist/introspection/dependency-graph.js

@@ -1,8 +1,9 @@
-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 { stringifyTagValue } from "#core/binding";
+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.
@@ -41,18 +42,31 @@ function edgeLabel(ref, index) {
     const criterion = name !== undefined
         ? `name:${name}`
         : firstPlainTag !== undefined
-            ? `tag:${firstPlainTag.key.name}=${String(firstPlainTag.value)}`
+            ? `tag:${firstPlainTag.key.name}=${stringifyTagValue(firstPlainTag.value)}`
             : `[${index}]`;
     return ref.optional ? `${criterion} optional` : criterion;
 }
-function bindingLookup(sourceRegistry, fallbackRegistry) {
-    return (token) => {
-        const own = sourceRegistry.getAll(token);
-        if (own.length > 0 || fallbackRegistry === undefined) {
-            return own;
+/**
+ * The bindings a dependency reaches, found the way resolution finds them.
+ *
+ * @remarks A single dependency stops at the nearest registry holding a binding its slot matches, and
+ * a collection gathers every registry's matches — `resolve` and `resolveAll` respectively.
+ */
+function dependencyTargets(chain, ref) {
+    if (ref.multi) {
+        const gathered = [];
+        for (const registry of chain) {
+            gathered.push(...matchingTargets(registry.getAll(ref.token), ref));
+        }
+        return gathered;
+    }
+    for (const registry of chain) {
+        const targets = matchingTargets(registry.getAll(ref.token), ref);
+        if (targets.length > 0) {
+            return targets;
         }
-        return fallbackRegistry.getAll(token);
-    };
+    }
+    return [];
 }
 /** The placeholder node an optional-but-unbound dependency points at, minted once per token. */
 function unboundNodeIdFor(accumulator, dependency) {
@@ -73,8 +87,8 @@ function unboundNodeIdFor(accumulator, dependency) {
     });
     return id;
 }
-function addDependencyEdges(accumulator, from, ref, index, lookup) {
-    const targets = matchingTargets(lookup(ref.token), ref);
+function addDependencyEdges(accumulator, from, ref, index, chain) {
+    const targets = dependencyTargets(chain, ref);
     const label = edgeLabel(ref, index);
     if (targets.length === 0) {
         // A required-but-unbound dependency is validate()'s story, not the graph's.
@@ -108,25 +122,25 @@ function addDependencyEdges(accumulator, from, ref, index, lookup) {
     }
 }
 /** What one binding declares up front — a class's params, a factory's descriptors, an alias's target. */
-function addBindingEdges(accumulator, binding, metadataReader, lookup) {
+function addBindingEdges(accumulator, binding, metadataReader, chain) {
     if (binding.kind === "class") {
         const meta = metadataReader.getConstructorMetadata(binding.target);
         if (meta !== undefined) {
             for (const [index, param] of meta.params.entries()) {
-                addDependencyEdges(accumulator, String(binding.identifier), param, index, lookup);
+                addDependencyEdges(accumulator, String(binding.identifier), param, index, chain);
             }
         }
         return;
     }
     if (binding.kind === "resolved" || binding.kind === "resolved-async") {
         for (const [index, dependency] of binding.deps.entries()) {
-            addDependencyEdges(accumulator, String(binding.identifier), dependency, index, lookup);
+            addDependencyEdges(accumulator, String(binding.identifier), dependency, index, chain);
         }
         return;
     }
     if (binding.kind === "alias") {
         const aliasRef = { token: binding.target, optional: false, multi: false };
-        for (const target of matchingTargets(lookup(binding.target), aliasRef)) {
+        for (const target of dependencyTargets(chain, aliasRef)) {
             accumulator.edges.push({
                 from: String(binding.identifier),
                 to: String(target.identifier),
@@ -136,9 +150,9 @@ function addBindingEdges(accumulator, binding, metadataReader, lookup) {
         }
     }
 }
-function addRegistryBindings(accumulator, sourceRegistry, metadataReader, fromParent, fallbackRegistry) {
-    const lookup = bindingLookup(sourceRegistry, fallbackRegistry);
-    for (const binding of sourceRegistry.allBindings()) {
+/** Adds the nodes of `chain[0]`, the registry the chain starts at, and the edges each of its bindings declares. */
+function addRegistryBindings(accumulator, chain, metadataReader, fromParent) {
+    for (const binding of chain[0].allBindings()) {
         accumulator.nodes.push({
             id: String(binding.identifier),
             tokenName: tokenName(binding.token),
@@ -147,20 +161,29 @@ function addRegistryBindings(accumulator, sourceRegistry, metadataReader, fromPa
             scope: effectiveBindingScope(binding),
             fromParent,
         });
-        addBindingEdges(accumulator, binding, metadataReader, lookup);
+        addBindingEdges(accumulator, binding, metadataReader, chain);
     }
 }
 /**
- * Builds the JSON dependency graph of a registry's bindings, optionally including the parent's.
+ * Builds the JSON dependency graph of a registry's bindings, optionally including its ancestors'.
+ *
+ * @param registry - The registry whose bindings the graph is for.
+ * @param metadataReader - The reader class dependencies are read through.
+ * @param options - Whether the ancestors' bindings join the graph.
+ * @param ancestorRegistries - The ancestor containers' registries, nearest first.
  *
  * @since 0.3.16-canary.0
  */
-export function buildDependencyGraph(registry, metadataReader, options, parentRegistry) {
+export function buildDependencyGraph(registry, metadataReader, options, ancestorRegistries = []) {
     const accumulator = { nodes: [], edges: [], unboundNodeIds: new Map() };
     const includesParent = options?.includeParent === true;
-    addRegistryBindings(accumulator, registry, metadataReader, false, includesParent ? parentRegistry : undefined);
-    if (includesParent && parentRegistry !== undefined) {
-        addRegistryBindings(accumulator, parentRegistry, metadataReader, true);
+    if (!includesParent) {
+        addRegistryBindings(accumulator, [registry], metadataReader, false);
+        return { nodes: accumulator.nodes, edges: accumulator.edges, includesParent };
+    }
+    const chain = [registry, ...ancestorRegistries];
+    for (let depth = 0; depth < chain.length; depth += 1) {
+        addRegistryBindings(accumulator, chain.slice(depth), metadataReader, depth > 0);
     }
     return { nodes: accumulator.nodes, edges: accumulator.edges, includesParent };
 }

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/graph-adapters/reactflow.js

@@ -1,9 +1,9 @@
 /**
- * Initial grid layout: React Flow expects concrete positions; viewers re-layout anyway.
+ * Initial grid cell, in the pixels React Flow positions in: a starting layout viewers re-lay out,
+ * fixed by no contract.
  *
  * @since 0.3.16-canary.0
  */
-const GRID_COLUMN_COUNT = 5;
 const GRID_CELL_WIDTH_PX = 200;
 const GRID_CELL_HEIGHT_PX = 100;
 /**
@@ -12,6 +12,8 @@ const GRID_CELL_HEIGHT_PX = 100;
  * @since 0.5.0-canary.7
  */
 export function toReactFlowGraph(graph) {
+    // A square grid over the graph: as many columns as rows, derived from the node count.
+    const columnCount = Math.max(1, Math.ceil(Math.sqrt(graph.nodes.length)));
     const nodes = graph.nodes.map((node, idx) => ({
         id: node.id,
         data: {
@@ -22,8 +24,8 @@ export function toReactFlowGraph(graph) {
             fromParent: node.fromParent,
         },
         position: {
-            x: (idx % GRID_COLUMN_COUNT) * GRID_CELL_WIDTH_PX,
-            y: Math.floor(idx / GRID_COLUMN_COUNT) * GRID_CELL_HEIGHT_PX,
+            x: (idx % columnCount) * GRID_CELL_WIDTH_PX,
+            y: Math.floor(idx / columnCount) * GRID_CELL_HEIGHT_PX,
         },
     }));
     const edges = graph.edges.map((edge, idx) => ({

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,7 @@
-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 { DefaultConstraintContext } from "#resolution/context";
+import { selectAllBindings } from "#resolution/select/binding-select";
 // ── Inspector ────────────────────────────────────────────────────────────────────────────────────────────────────────
 /**
  * The read-only introspection surface behind a container's `inspect()`.
@@ -38,17 +39,13 @@ export class Inspector {
         }
         const bindings = this.#registry.getAll(token);
         // An existence probe answers ambiguity with `true` — several matches still exist; only
-        // resolution has to pick one.
-        return bindings.length > 0 && selectAllBindings(bindings, options, this.#makeConstraintContext(options)).length > 0;
+        // resolution has to pick one. A default-slot alias answers any criteria by forwarding them.
+        return (bindings.length > 0 &&
+            (selectAllBindings(bindings, options, this.#makeConstraintContext(options)).length > 0 ||
+                this.#registry.getDefaultSlotBinding(token)?.kind === "alias"));
     }
     #makeConstraintContext(options) {
-        return {
-            resolutionPath: [],
-            resolutionStack: [],
-            parent: undefined,
-            ancestors: [],
-            currentResolveOptions: options,
-        };
+        return new DefaultConstraintContext([], options);
     }
     #toSnapshot(binding) {
         // Aliased, not copied: slot tags are frozen where they are built, so a caller's write throws

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.
  *
@@ -97,7 +97,11 @@ export class LifecycleManager {
         let activatedInstance = instance;
         // 1. @postConstruct() — must be sync (instance fully constructed per TC39 order)
         for (const methodName of lifecycleMethods(binding, metadataReader, "postConstruct")) {
-            if (callHook(activatedInstance, methodName) instanceof Promise) {
+            const hookResult = callHook(activatedInstance, methodName);
+            if (hookResult instanceof Promise) {
+                // The hook has already run; adopt its rejection so a failing async hook cannot become an
+                // unhandled rejection that ends the process, then report the sync-lane violation.
+                void hookResult.catch(() => { });
                 throw new AsyncActivationError(tokenName(binding.token), "postConstruct", methodName);
             }
         }
@@ -105,6 +109,7 @@ export class LifecycleManager {
         if (binding.kind !== "alias" && binding.activationHook !== undefined) {
             const activationResult = binding.activationHook(resolutionContext, activatedInstance);
             if (activationResult instanceof Promise) {
+                void activationResult.catch(() => { });
                 throw new AsyncActivationError(tokenName(binding.token), "onActivation");
             }
             activatedInstance = activationResult;
@@ -116,6 +121,7 @@ export class LifecycleManager {
             for (const hook of containerHooks) {
                 const activationResult = hook(resolutionContext, activatedInstance);
                 if (activationResult instanceof Promise) {
+                    void activationResult.catch(() => { });
                     throw new AsyncActivationError(tokenDisplayName, "onActivation");
                 }
                 activatedInstance = activationResult;
@@ -159,6 +165,9 @@ export class LifecycleManager {
             for (const hook of containerHooks) {
                 const hookResult = hook(instance);
                 if (hookResult instanceof Promise) {
+                    // The hook has already run; adopt its rejection so a failing async hook cannot become an
+                    // unhandled rejection that ends the process, then report the sync-lane violation.
+                    void hookResult.catch(() => { });
                     throw new AsyncDeactivationError(tokenDisplayName);
                 }
             }
@@ -167,12 +176,15 @@ export class LifecycleManager {
         if (binding.kind !== "alias" && binding.deactivationHook !== undefined) {
             const hookResult = binding.deactivationHook(instance);
             if (hookResult instanceof Promise) {
+                void hookResult.catch(() => { });
                 throw new AsyncDeactivationError(tokenDisplayName);
             }
         }
         // 3. @preDestroy()
         for (const methodName of lifecycleMethods(binding, metadataReader, "preDestroy")) {
-            if (callHook(instance, methodName) instanceof Promise) {
+            const hookResult = callHook(instance, methodName);
+            if (hookResult instanceof Promise) {
+                void hookResult.catch(() => { });
                 throw new AsyncDeactivationError(tokenDisplayName);
             }
         }

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