@codefast/di 0.3.14-canary.0 → 0.3.14-canary.2

package/dist/graph-adapters/cytoscape.mjs

@@ -0,0 +1,23 @@
+//#region src/graph-adapters/cytoscape.ts
+function toCytoscapeGraph(graph) {
+	const elements = [];
+	for (const node of graph.nodes) elements.push({ data: {
+		id: node.id,
+		label: node.tokenName,
+		kind: node.kind,
+		scope: node.scope,
+		fromParent: node.fromParent
+	} });
+	graph.edges.forEach((edge, idx) => {
+		const data = {
+			id: `edge-${idx}`,
+			source: edge.from,
+			target: edge.to
+		};
+		if (edge.label !== void 0) data.label = edge.label;
+		elements.push({ data });
+	});
+	return elements;
+}
+//#endregion
+export { toCytoscapeGraph };

package/dist/graph-adapters/dot.d.mts

@@ -0,0 +1,6 @@
+import { ContainerGraphJson } from "../dependency-graph.mjs";
+
+//#region src/graph-adapters/dot.d.ts
+declare function toDotGraph(graph: ContainerGraphJson): string;
+//#endregion
+export { toDotGraph };

package/dist/graph-adapters/dot.mjs

@@ -0,0 +1,17 @@
+//#region src/graph-adapters/dot.ts
+function toDotGraph(graph) {
+	const lines = ["digraph DI {", "  rankdir=TB;"];
+	for (const node of graph.nodes) {
+		const label = `${node.tokenName}\\n[${node.kind}/${node.scope}]`;
+		const style = node.fromParent ? " style=\"dashed\"" : "";
+		lines.push(`  "${node.id}" [label="${label}"${style}];`);
+	}
+	for (const edge of graph.edges) {
+		const label = edge.label !== void 0 ? ` [label="${edge.label}"]` : "";
+		lines.push(`  "${edge.from}" -> "${edge.to}"${label};`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+//#endregion
+export { toDotGraph };

package/dist/graph-adapters/reactflow.d.mts

@@ -0,0 +1,29 @@
+import { ContainerGraphJson } from "../dependency-graph.mjs";
+
+//#region src/graph-adapters/reactflow.d.ts
+interface ReactFlowNode {
+  id: string;
+  data: {
+    label: string;
+    kind: string;
+    scope: string;
+    fromParent: boolean;
+  };
+  position: {
+    x: number;
+    y: number;
+  };
+}
+interface ReactFlowEdge {
+  id: string;
+  source: string;
+  target: string;
+  label?: string;
+}
+interface ReactFlowGraph {
+  nodes: ReactFlowNode[];
+  edges: ReactFlowEdge[];
+}
+declare function toReactFlowGraph(graph: ContainerGraphJson): ReactFlowGraph;
+//#endregion
+export { ReactFlowEdge, ReactFlowGraph, ReactFlowNode, toReactFlowGraph };

package/dist/graph-adapters/reactflow.mjs

@@ -0,0 +1,29 @@
+//#region src/graph-adapters/reactflow.ts
+function toReactFlowGraph(graph) {
+	return {
+		nodes: graph.nodes.map((node, idx) => ({
+			id: node.id,
+			data: {
+				label: node.tokenName,
+				kind: node.kind,
+				scope: node.scope,
+				fromParent: node.fromParent
+			},
+			position: {
+				x: idx % 5 * 200,
+				y: Math.floor(idx / 5) * 100
+			}
+		})),
+		edges: graph.edges.map((edge, idx) => {
+			const reactFlowEdge = {
+				id: `edge-${idx}`,
+				source: edge.from,
+				target: edge.to
+			};
+			if (edge.label !== void 0) reactFlowEdge.label = edge.label;
+			return reactFlowEdge;
+		})
+	};
+}
+//#endregion
+export { toReactFlowGraph };

package/dist/graph-adapters/types.d.mts

@@ -0,0 +1,2 @@
+import { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions } from "../dependency-graph.mjs";
+export { type ContainerGraphJson, type GraphEdge, type GraphNode, type GraphOptions };

package/dist/graph-adapters/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/index.d.mts

@@ -1,10 +1,17 @@
-import { Token, TokenValue, token } from "./token.mjs";
-import { ActivationHandler, BindingBuilder, BindingIdentifier, BindingScope, ConstraintContext, Constructor, DeactivationHandler, ResolveOptions } from "./binding.mjs";
-import { ContainerGraphJson, ContainerSnapshot } from "./inspector.mjs";
-import { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder } from "./module.mjs";
-import { Container } from "./container.mjs";
-import { InjectOptions, inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
-import { InjectableDependency, getAutoRegistered, injectable } from "./decorators/injectable.mjs";
+import { Constructor } from "./constructor-type.mjs";
+import { Token, token } from "./token.mjs";
+import { ActivationHandler, BindingIdentifier, BindingKind, BindingScope, ConstraintContext, DeactivationHandler, DependencyKey, MaterializationFrame, ResolutionContext, ResolveOptions, TokenValue } from "./types.mjs";
+import { InjectOptions, InjectableDependency, InjectionDescriptor, inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
+import { AliasBindingBuilder, BindToBuilder, BindingBuilder, ConstantBindingBuilder, ScopedBindingBuilder, SingletonBindingBuilder, SingletonLifecycleBuilder, TransientBindingBuilder } from "./binding.mjs";
+import { effectiveBindingScope } from "./binding-scope.mjs";
+import { AsyncModule, AsyncModuleBuilder, Module, ModuleBuilder, SyncModule } from "./module.mjs";
+import { BindingSnapshot, ContainerSnapshot } from "./inspector.mjs";
+import { MetadataReader, MutableLifecycleMetadata } from "./metadata/metadata-types.mjs";
+import { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions } from "./dependency-graph.mjs";
+import { AutoRegisterRegistry, InjectableOptions, createAutoRegisterRegistry, injectable } from "./decorators/injectable.mjs";
+import { Container, ContainerStatic } from "./container.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
-import { AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationDetails, ScopeViolationError, TokenNotBoundError } from "./errors.mjs";
-export { type ActivationHandler, AsyncModule, type AsyncModuleBuilder, AsyncModuleLoadError, AsyncResolutionError, type BindingBuilder, type BindingIdentifier, type BindingScope, CircularDependencyError, type ConstraintContext, type Constructor, Container, type ContainerGraphJson, type ContainerSnapshot, type DeactivationHandler, DiError, type InjectOptions, type InjectableDependency, InternalError, MissingMetadataError, Module, type ModuleBuilder, NoMatchingBindingError, type ResolveOptions, type ScopeViolationDetails, ScopeViolationError, type Token, TokenNotBoundError, type TokenValue, getAutoRegistered, inject, injectAll, injectable, isInjectionDescriptor, optional, postConstruct, preDestroy, token };
+import { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
+import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
+export { type ActivationHandler, type AliasBindingBuilder, AmbiguousBindingError, AsyncDeactivationError, AsyncModule, type AsyncModuleBuilder, AsyncModuleLoadError, AsyncResolutionError, type AutoRegisterRegistry, type BindToBuilder, type BindingBuilder, type BindingIdentifier, type BindingKind, type BindingScope, type BindingSnapshot, CircularDependencyError, type ConstantBindingBuilder, type ConstraintContext, type Constructor, Container, type ContainerGraphJson, type Container as ContainerInterface, type ContainerSnapshot, type ContainerStatic, type DeactivationHandler, type DependencyKey, DiError, DisposedContainerError, type GraphEdge, type GraphNode, type GraphOptions, type InjectOptions, type InjectableDependency, type InjectableOptions, type InjectionDescriptor, InternalError, type MaterializationFrame, type MetadataReader, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, type ModuleBuilder, type MutableLifecycleMetadata, NoMatchingBindingError, RebindUnboundTokenError, type ResolutionContext, type ResolveOptions, type ScopeViolationDetails, ScopeViolationError, type ScopedBindingBuilder, type SingletonBindingBuilder, type SingletonLifecycleBuilder, SyncDisposalNotSupportedError, SyncModule, type Token, TokenNotBoundError, type TokenValue, type TransientBindingBuilder, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token };

package/dist/index.mjs

@@ -1,8 +1,11 @@
-import { AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError } from "./errors.mjs";
+import { effectiveBindingScope } from "./binding-scope.mjs";
+import { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError } from "./errors.mjs";
+import { token } from "./token.mjs";
+import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { MetadataReaderToken } from "./metadata/metadata-reader-token.mjs";
 import { inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
-import { getAutoRegistered, injectable } from "./decorators/injectable.mjs";
-import { AsyncModule, Module } from "./module.mjs";
+import { AsyncModule, Module, SyncModule } from "./module.mjs";
 import { Container } from "./container.mjs";
-import { token } from "./token.mjs";
+import { createAutoRegisterRegistry, injectable } from "./decorators/injectable.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
-export { AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, InternalError, MissingMetadataError, Module, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError, getAutoRegistered, inject, injectAll, injectable, isInjectionDescriptor, optional, postConstruct, preDestroy, token };
+export { AmbiguousBindingError, AsyncDeactivationError, AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, DisposedContainerError, InternalError, MetadataReaderToken, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, Module, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, SyncModule, TokenNotBoundError, createAutoRegisterRegistry, effectiveBindingScope, inject, injectAll, injectable, injectableSlotToResolveOptions, isInjectionDescriptor, optional, postConstruct, preDestroy, slotKeyToResolveOptions, token };

package/dist/inspector.d.mts

@@ -1,100 +1,39 @@
-import { RegistryKey } from "./registry.mjs";
-import { Binding, BindingIdentifier, BindingScope } from "./binding.mjs";
-import { MetadataReader } from "./metadata/metadata-types.mjs";
-import { collectStaticDependencyEdges } from "./dependency-graph.mjs";
+import { Constructor } from "./constructor-type.mjs";
+import { Token } from "./token.mjs";
+import { BindingIdentifier, BindingKind, BindingScope, ResolveOptions } from "./types.mjs";
+import { BindingRegistry } from "./registry.mjs";
+import { ScopeManager } from "./scope.mjs";
 
 //#region src/inspector.d.ts
-/**
- * Whether a singleton/scoped binding's instance is currently held in the scope cache.
- */
-type BindingActivationStatus = "cached" | "not-cached" | "transient";
-/**
- * Per-binding row inside a {@link ContainerSnapshot}.
- */
-type ContainerBindingSnapshot = {
-  readonly registryKeyLabel: string;
-  readonly bindingId: BindingIdentifier;
-  readonly kind: Binding<unknown>["kind"];
+interface BindingSnapshot {
+  readonly tokenName: string;
+  readonly kind: BindingKind;
   readonly scope: BindingScope;
-  readonly activationStatus: BindingActivationStatus;
-  /**
-   * True when {@link BindingBuilder.when} was used (runtime predicate; static graph may still show edges).
-   */
-  readonly hasConditionalConstraint: boolean;
-  readonly moduleId?: string;
-};
-/**
- * Full debug snapshot returned by {@link Container.inspect}.
- */
-type ContainerSnapshot = {
-  readonly bindings: readonly ContainerBindingSnapshot[];
-};
-/**
- * Structured dependency graph returned by {@link Container.generateDependencyGraph} with `format: "json"`.
- */
-type ContainerGraphJson = {
-  nodes: ContainerBindingSnapshot[];
-  edges: ReturnType<typeof collectStaticDependencyEdges>[number][];
-};
-/**
- * Read-only view of the container internals exposed to {@link ContainerInspector}.
- */
-type ContainerInspectorContext = {
-  collectAllRegistryKeys(): readonly RegistryKey[];
-  lookupBindings(key: RegistryKey): readonly Binding<unknown>[] | undefined;
-  isBindingCached(binding: Binding<unknown>): boolean;
-  metadataReader: MetadataReader | undefined;
-};
-/**
- * Options for {@link Container.generateDependencyGraph}.
- */
-type DotGraphOptions = {
-  /**
-   * When true, omit registry keys whose label starts with `CODEFAST_DI_` (framework-style tokens)
-   * and any edges that would only connect hidden nodes.
-   */
-  readonly hideInternals?: boolean;
-};
-/**
- * Reads the container's registry and scope-cache state to produce debug snapshots
- * and dependency-graph output (Graphviz DOT / typed JSON).
- *
- * Constructed internally by the container; advanced consumers can also construct it
- * directly via the `@codefast/di/inspector` subpath export.
- */
-declare class ContainerInspector {
-  private readonly ctx;
-  constructor(ctx: ContainerInspectorContext);
-  /**
-   * Collects all registered bindings into a flat, serialisable snapshot.
-   */
-  getSnapshot(): ContainerSnapshot;
-  /**
-   * Produces a Graphviz `digraph` string with HTML-label nodes and styled edges.
-   * Cycles are represented as ordinary edges (Graphviz renders them correctly).
-   * Pass `hideInternals: true` to suppress `CODEFAST_DI_`-prefixed tokens.
-   */
-  generateDotGraph(options?: DotGraphOptions): string;
-  /**
-   * Overloaded entry point: returns DOT format by default, or a typed {@link ContainerGraphJson}
-   * when `format: "json"` is specified.
-   */
-  generateDependencyGraph(options?: DotGraphOptions & {
-    format?: "dot";
-  }): string;
-  generateDependencyGraph(options: DotGraphOptions & {
-    format: "json";
-  }): ContainerGraphJson;
-  /**
-   * Builds the typed JSON graph (nodes + edges) used by the `"json"` format path.
-   * Applies the same `hideInternals` / deduplication logic as {@link generateDotGraph}.
-   */
-  generateDependencyGraphJsonTyped(options?: DotGraphOptions): ContainerGraphJson;
-  /**
-   * Produces a JSON graph representation with `nodes` and `edges`.
-   * @internal Use `generateDependencyGraph({ format: "json" })` for typed output.
-   */
-  generateDependencyGraphJson(options?: DotGraphOptions): string;
+  readonly slot: {
+    readonly name?: string;
+    readonly tags: ReadonlyArray<readonly [string, unknown]>;
+  };
+  readonly id: BindingIdentifier;
+}
+interface ContainerSnapshot {
+  readonly ownBindings: readonly BindingSnapshot[];
+  readonly bindings: readonly BindingSnapshot[];
+  readonly cachedSingletonCount: number;
+  readonly hasParent: boolean;
+  readonly isDisposed: boolean;
+}
+declare class Inspector {
+  private readonly _registry;
+  private readonly _scope;
+  private readonly _hasParent;
+  private readonly _isDisposed;
+  constructor(_registry: BindingRegistry, _scope: ScopeManager, _hasParent: boolean, _isDisposed: () => boolean);
+  inspect(): ContainerSnapshot;
+  lookupBindings<Value>(token: Token<Value> | Constructor<Value>): readonly BindingSnapshot[];
+  has(token: Token<unknown> | Constructor, hint?: ResolveOptions, parentHas?: () => boolean): boolean;
+  hasOwn(token: Token<unknown> | Constructor, hint?: ResolveOptions): boolean;
+  private allBindingSnapshots;
+  private _toSnapshot;
 }
 //#endregion
-export { BindingActivationStatus, ContainerBindingSnapshot, ContainerGraphJson, ContainerInspector, ContainerInspectorContext, ContainerSnapshot, DotGraphOptions };
+export { BindingSnapshot, ContainerSnapshot, Inspector };

package/dist/inspector.mjs

@@ -1,268 +1,69 @@
-import { registryKeyLabel } from "./binding-select.mjs";
-import { collectStaticDependencyEdges } from "./dependency-graph.mjs";
+import { effectiveBindingScope } from "./binding-scope.mjs";
+import { selectBinding } from "./binding-select.mjs";
+import { tokenName } from "./token.mjs";
 //#region src/inspector.ts
-/**
-* Maps a binding's scope and cache state to a {@link BindingActivationStatus} label.
-*/
-function activationStatusFor(binding, isCached) {
-	if (binding.scope === "transient") return "transient";
-	return isCached(binding) ? "cached" : "not-cached";
-}
-/**
-* Escapes a string for use as a DOT `label="..."` attribute value.
-*/
-function dotEscapeLabel(text) {
-	return text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n");
-}
-/**
-* Escapes a string for safe embedding inside a DOT HTML-label (`<...>`) table cell.
-*/
-function dotEscapeHtml(text) {
-	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
-}
-/**
-* Returns the Graphviz node shape name for a given binding kind.
-*/
-function nodeShapeForKind(kind) {
-	switch (kind) {
-		case "constant": return "ellipse";
-		case "class": return "box";
-		case "dynamic":
-		case "async-dynamic":
-		case "resolved": return "diamond";
-		case "alias": return "octagon";
-		default: return kind;
+var Inspector = class {
+	constructor(_registry, _scope, _hasParent, _isDisposed) {
+		this._registry = _registry;
+		this._scope = _scope;
+		this._hasParent = _hasParent;
+		this._isDisposed = _isDisposed;
 	}
-}
-/**
-* Returns DOT fill-color and style attributes that visually distinguish binding scopes.
-*/
-function scopeVisualAttributes(scope) {
-	switch (scope) {
-		case "singleton": return "style=\"filled\", fillcolor=\"#FFD700\", penwidth=2";
-		case "scoped": return "style=\"filled\", fillcolor=\"#ADD8E6\"";
-		case "transient": return "style=\"dashed\"";
-		default: return scope;
+	inspect() {
+		const snapshots = this.allBindingSnapshots();
+		return {
+			ownBindings: snapshots,
+			bindings: snapshots,
+			cachedSingletonCount: this._scope.getAllSingletons().size,
+			hasParent: this._hasParent,
+			isDisposed: this._isDisposed()
+		};
 	}
-}
-/**
-* Strips non-alphanumeric characters from a module name to produce a valid DOT subgraph identifier.
-*/
-function sanitizeClusterId(moduleName) {
-	return moduleName.replace(/[^0-9a-zA-Z_]/g, "_");
-}
-/**
-* Returns `true` when the label string belongs to a framework-internal registry key.
-*/
-function registryKeyLabelIsInternal(label) {
-	return label.startsWith("CODEFAST_DI_");
-}
-/**
-* Returns `true` when the registry key resolves to an internal framework label.
-*/
-function isInternalRegistryKey(key) {
-	return registryKeyLabelIsInternal(registryKeyLabel(key));
-}
-/**
-* Reads the container's registry and scope-cache state to produce debug snapshots
-* and dependency-graph output (Graphviz DOT / typed JSON).
-*
-* Constructed internally by the container; advanced consumers can also construct it
-* directly via the `@codefast/di/inspector` subpath export.
-*/
-var ContainerInspector = class {
-	constructor(ctx) {
-		this.ctx = ctx;
+	lookupBindings(token) {
+		return this._registry.getAll(token).map((b) => this._toSnapshot(b));
 	}
-	/**
-	* Collects all registered bindings into a flat, serialisable snapshot.
-	*/
-	getSnapshot() {
-		const bindings = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (const registryKey of this.ctx.collectAllRegistryKeys()) {
-			const list = this.ctx.lookupBindings(registryKey);
-			if (list === void 0 || list.length === 0) continue;
-			const registryLabel = registryKeyLabel(registryKey);
-			for (const binding of list) {
-				if (seen.has(binding.id)) continue;
-				seen.add(binding.id);
-				const row = {
-					registryKeyLabel: registryLabel,
-					bindingId: binding.id,
-					kind: binding.kind,
-					scope: binding.scope,
-					activationStatus: activationStatusFor(binding, (bindingArg) => this.ctx.isBindingCached(bindingArg)),
-					hasConditionalConstraint: binding.constraint !== void 0
-				};
-				bindings.push(binding.moduleId === void 0 ? row : {
-					...row,
-					moduleId: binding.moduleId
-				});
-			}
-		}
-		return { bindings };
+	has(token, hint, parentHas) {
+		const bindings = this._registry.getAll(token);
+		if (bindings.length > 0) if (hint !== void 0) {
+			if (selectBinding(bindings, hint, {
+				resolutionPath: [],
+				materializationStack: [],
+				parent: void 0,
+				ancestors: [],
+				currentResolveHint: hint
+			}, tokenName(token)) !== void 0) return true;
+		} else return true;
+		return parentHas?.() ?? false;
 	}
-	/**
-	* Produces a Graphviz `digraph` string with HTML-label nodes and styled edges.
-	* Cycles are represented as ordinary edges (Graphviz renders them correctly).
-	* Pass `hideInternals: true` to suppress `CODEFAST_DI_`-prefixed tokens.
-	*/
-	generateDotGraph(options) {
-		const hideInternals = options?.hideInternals === true;
-		const fullSnapshot = this.getSnapshot();
-		const visibleRows = hideInternals ? fullSnapshot.bindings.filter((row) => !registryKeyLabelIsInternal(row.registryKeyLabel)) : fullSnapshot.bindings;
-		const allowedBindingIds = new Set(visibleRows.map((row) => row.bindingId));
-		const lines = [
-			"digraph codefast_di {",
-			"  rankdir=LR;",
-			"  graph [fontname=\"Arial\", fontsize=12, nodesep=0.8, ranksep=1.2];",
-			"  node  [fontname=\"Arial\", fontsize=12, shape=box, style=\"filled,rounded\", fillcolor=\"#F5F5F5\"];",
-			"  edge  [fontname=\"Arial\", fontsize=10];"
-		];
-		const byModule = /* @__PURE__ */ new Map();
-		for (const row of visibleRows) {
-			const key = row.moduleId;
-			const moduleGroup = byModule.get(key);
-			if (moduleGroup === void 0) byModule.set(key, [row]);
-			else moduleGroup.push(row);
-		}
-		const clusteredEntries = [...byModule.entries()].filter((entry) => entry[0] !== void 0);
-		const unclustered = byModule.get(void 0) ?? [];
-		const nodeAttributeLine = (row, indent) => {
-			const shape = nodeShapeForKind(row.kind);
-			const scopeAttrs = scopeVisualAttributes(row.scope);
-			const kindText = dotEscapeHtml(row.kind);
-			const nameText = dotEscapeHtml(row.registryKeyLabel);
-			const scopeText = dotEscapeHtml(`scope=${row.scope}`);
-			const whenRow = row.hasConditionalConstraint ? `      <TR><TD ALIGN="LEFT"><FONT POINT-SIZE="9" COLOR="#666666">when(...)</FONT></TD></TR>\n` : "";
-			const htmlLabel = [
-				"<",
-				"    <TABLE BORDER=\"0\" CELLPADDING=\"4\" CELLSPACING=\"0\">",
-				`      <TR><TD ALIGN="LEFT"><FONT POINT-SIZE="9" COLOR="#666666">${kindText}</FONT></TD></TR>`,
-				`      <TR><TD ALIGN="LEFT"><B>${nameText}</B></TD></TR>`,
-				`      <TR><TD ALIGN="LEFT"><FONT POINT-SIZE="9">${scopeText}</FONT></TD></TR>`,
-				whenRow.trimEnd(),
-				"    </TABLE>",
-				"  >"
-			].filter((line) => line.length > 0).join("\n");
-			return `${indent}"${row.bindingId}" [shape=${shape}, ${scopeAttrs}, label=${htmlLabel}];`;
-		};
-		for (const [moduleName, rows] of clusteredEntries) {
-			const clusterId = sanitizeClusterId(moduleName);
-			lines.push(`  subgraph cluster_${clusterId} {`);
-			lines.push(`    label="${dotEscapeLabel(moduleName)}";`);
-			lines.push(`    style=filled;`);
-			lines.push(`    fillcolor=lightgray;`);
-			for (const row of rows) lines.push(nodeAttributeLine(row, "    "));
-			lines.push(`  }`);
-		}
-		for (const row of unclustered) lines.push(nodeAttributeLine(row, "  "));
-		const emittedNodeIds = new Set(visibleRows.map((row) => row.bindingId));
-		const edgeSeen = /* @__PURE__ */ new Set();
-		for (const registryKey of this.ctx.collectAllRegistryKeys()) {
-			if (hideInternals && isInternalRegistryKey(registryKey)) continue;
-			const list = this.ctx.lookupBindings(registryKey);
-			if (list === void 0) continue;
-			const pathStart = [registryKeyLabel(registryKey)];
-			for (const consumerBinding of list) {
-				if (hideInternals && !allowedBindingIds.has(consumerBinding.id)) continue;
-				const edges = collectStaticDependencyEdges(consumerBinding, (dependencyKey) => this.ctx.lookupBindings(dependencyKey), this.ctx.metadataReader, pathStart);
-				for (const edge of edges) {
-					if (hideInternals && (!allowedBindingIds.has(edge.fromBindingId) || !allowedBindingIds.has(edge.toBindingId))) continue;
-					const edgeKey = `${edge.fromBindingId}->${edge.toBindingId}:${edge.edgeKind}:${edge.injectHintLabel ?? ""}`;
-					if (edgeSeen.has(edgeKey)) continue;
-					edgeSeen.add(edgeKey);
-					if (!emittedNodeIds.has(edge.fromBindingId)) {
-						emittedNodeIds.add(edge.fromBindingId);
-						lines.push(`  "${edge.fromBindingId}" [shape=box, style=dashed, label="(unlisted ${edge.fromBindingId})"];`);
-					}
-					if (!emittedNodeIds.has(edge.toBindingId)) {
-						emittedNodeIds.add(edge.toBindingId);
-						lines.push(`  "${edge.toBindingId}" [shape=box, style=dashed, label="(unlisted ${edge.toBindingId})"];`);
-					}
-					const labelParts = [];
-					if (edge.injectHintLabel !== void 0) labelParts.push(edge.injectHintLabel);
-					labelParts.push(edge.edgeKind);
-					if (edge.toBindingConditional) labelParts.push("conditional");
-					const edgeLabel = dotEscapeLabel(labelParts.join(" | "));
-					const pathLabel = dotEscapeLabel(edge.resolutionPath.join(" -> "));
-					const edgeStyle = edge.isAliasEdge ? ", style=dashed" : "";
-					lines.push(`  "${edge.fromBindingId}" -> "${edge.toBindingId}" [label="${edgeLabel}", xlabel="${pathLabel}"${edgeStyle}];`);
-				}
-			}
-		}
-		lines.push("}");
-		return lines.join("\n");
+	hasOwn(token, hint) {
+		const bindings = this._registry.getAll(token);
+		if (bindings.length === 0) return false;
+		if (hint !== void 0) return selectBinding(bindings, hint, {
+			resolutionPath: [],
+			materializationStack: [],
+			parent: void 0,
+			ancestors: [],
+			currentResolveHint: hint
+		}, tokenName(token)) !== void 0;
+		return true;
 	}
-	generateDependencyGraph(options) {
-		if (options?.format === "json") return this.generateDependencyGraphJsonTyped(options);
-		return this.generateDotGraph(options);
+	allBindingSnapshots() {
+		return this._registry.allBindings().map((b) => this._toSnapshot(b));
 	}
-	/**
-	* Builds the typed JSON graph (nodes + edges) used by the `"json"` format path.
-	* Applies the same `hideInternals` / deduplication logic as {@link generateDotGraph}.
-	*/
-	generateDependencyGraphJsonTyped(options) {
-		const hideInternals = options?.hideInternals === true;
-		const snapshot = this.getSnapshot();
-		const visibleNodes = hideInternals ? snapshot.bindings.filter((row) => !registryKeyLabelIsInternal(row.registryKeyLabel)) : [...snapshot.bindings];
-		const allowedBindingIds = new Set(visibleNodes.map((row) => row.bindingId));
-		const edges = [];
-		const edgeSeen = /* @__PURE__ */ new Set();
-		for (const registryKey of this.ctx.collectAllRegistryKeys()) {
-			if (hideInternals && isInternalRegistryKey(registryKey)) continue;
-			const list = this.ctx.lookupBindings(registryKey);
-			if (list === void 0) continue;
-			const pathStart = [registryKeyLabel(registryKey)];
-			for (const consumerBinding of list) {
-				if (hideInternals && !allowedBindingIds.has(consumerBinding.id)) continue;
-				for (const edge of collectStaticDependencyEdges(consumerBinding, (dependencyKey) => this.ctx.lookupBindings(dependencyKey), this.ctx.metadataReader, pathStart)) {
-					if (hideInternals && (!allowedBindingIds.has(edge.fromBindingId) || !allowedBindingIds.has(edge.toBindingId))) continue;
-					const edgeKey = `${edge.fromBindingId}->${edge.toBindingId}:${edge.edgeKind}:${edge.injectHintLabel ?? ""}`;
-					if (edgeSeen.has(edgeKey)) continue;
-					edgeSeen.add(edgeKey);
-					edges.push(edge);
-				}
-			}
-		}
+	_toSnapshot(b) {
+		const scope = effectiveBindingScope(b);
+		const slot = b.slot.name !== void 0 ? {
+			name: b.slot.name,
+			tags: b.slot.tags
+		} : { tags: b.slot.tags };
 		return {
-			nodes: visibleNodes,
-			edges
+			tokenName: tokenName(b.token),
+			kind: b.kind,
+			scope,
+			slot,
+			id: b.id
 		};
 	}
-	/**
-	* Produces a JSON graph representation with `nodes` and `edges`.
-	* @internal Use `generateDependencyGraph({ format: "json" })` for typed output.
-	*/
-	generateDependencyGraphJson(options) {
-		const hideInternals = options?.hideInternals === true;
-		const snapshot = this.getSnapshot();
-		const visibleNodes = hideInternals ? snapshot.bindings.filter((row) => !registryKeyLabelIsInternal(row.registryKeyLabel)) : snapshot.bindings;
-		const allowedBindingIds = new Set(visibleNodes.map((row) => row.bindingId));
-		const edges = [];
-		const edgeSeen = /* @__PURE__ */ new Set();
-		for (const registryKey of this.ctx.collectAllRegistryKeys()) {
-			if (hideInternals && isInternalRegistryKey(registryKey)) continue;
-			const list = this.ctx.lookupBindings(registryKey);
-			if (list === void 0) continue;
-			const pathStart = [registryKeyLabel(registryKey)];
-			for (const consumerBinding of list) {
-				if (hideInternals && !allowedBindingIds.has(consumerBinding.id)) continue;
-				for (const edge of collectStaticDependencyEdges(consumerBinding, (dependencyKey) => this.ctx.lookupBindings(dependencyKey), this.ctx.metadataReader, pathStart)) {
-					if (hideInternals && (!allowedBindingIds.has(edge.fromBindingId) || !allowedBindingIds.has(edge.toBindingId))) continue;
-					const edgeKey = `${edge.fromBindingId}->${edge.toBindingId}:${edge.edgeKind}:${edge.injectHintLabel ?? ""}`;
-					if (edgeSeen.has(edgeKey)) continue;
-					edgeSeen.add(edgeKey);
-					edges.push(edge);
-				}
-			}
-		}
-		return JSON.stringify({
-			nodes: visibleNodes,
-			edges
-		});
-	}
 };
 //#endregion
-export { ContainerInspector };
+export { Inspector };