@codefast/di 0.3.14-canary.1 → 0.3.14

package/dist/graph-adapters/cytoscape.mjs

@@ -1,40 +1,23 @@
 //#region src/graph-adapters/cytoscape.ts
-/**
-* Converts the canonical container graph JSON into Cytoscape elements format.
-*/
 function toCytoscapeGraph(graph) {
-	return { elements: {
-		nodes: graph.nodes.map((node) => ({ data: {
-			id: node.bindingId,
-			label: node.registryKeyLabel,
-			bindingId: node.bindingId,
-			kind: node.kind,
-			scope: node.scope,
-			activationStatus: node.activationStatus,
-			hasConditionalConstraint: node.hasConditionalConstraint,
-			...node.moduleId === void 0 ? {} : { moduleId: node.moduleId }
-		} })),
-		edges: graph.edges.map((edge) => ({ data: {
-			id: edgeIdForCytoscape(edge),
-			source: edge.fromBindingId,
-			target: edge.toBindingId,
-			edgeKind: edge.edgeKind,
-			...edge.injectHintLabel === void 0 ? {} : { injectHintLabel: edge.injectHintLabel },
-			toBindingConditional: edge.toBindingConditional,
-			isAliasEdge: edge.isAliasEdge,
-			resolutionPath: [...edge.resolutionPath]
-		} }))
-	} };
-}
-/**
-* Produces a stable Cytoscape edge id from edge metadata.
-*/
-function edgeIdForCytoscape(edge) {
-	const hint = edge.injectHintLabel ?? "";
-	const conditional = edge.toBindingConditional ? "conditional" : "plain";
-	const alias = edge.isAliasEdge ? "alias" : "direct";
-	const path = edge.resolutionPath.join("->");
-	return `${edge.fromBindingId}->${edge.toBindingId}:${edge.edgeKind}:${hint}:${conditional}:${alias}:${path}`;
+	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

@@ -1,9 +1,6 @@
-import { ContainerGraphJson } from "../inspector.mjs";
+import { ContainerGraphJson } from "../dependency-graph.mjs";
 
 //#region src/graph-adapters/dot.d.ts
-/**
- * Converts the canonical container graph JSON into a Graphviz DOT digraph string.
- */
 declare function toDotGraph(graph: ContainerGraphJson): string;
 //#endregion
 export { toDotGraph };

package/dist/graph-adapters/dot.mjs

@@ -1,97 +1,17 @@
 //#region src/graph-adapters/dot.ts
-/**
-* Converts the canonical container graph JSON into a Graphviz DOT digraph string.
-*/
 function toDotGraph(graph) {
-	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();
+	const lines = ["digraph DI {", "  rankdir=TB;"];
 	for (const node of graph.nodes) {
-		const group = byModule.get(node.moduleId);
-		if (group === void 0) byModule.set(node.moduleId, [node]);
-		else group.push(node);
+		const label = `${node.tokenName}\\n[${node.kind}/${node.scope}]`;
+		const style = node.fromParent ? " style=\"dashed\"" : "";
+		lines.push(`  "${node.id}" [label="${label}"${style}];`);
 	}
-	const moduleGroups = [...byModule.entries()].filter((entry) => entry[0] !== void 0);
-	const ungrouped = byModule.get(void 0) ?? [];
-	for (const [moduleName, nodes] of moduleGroups) {
-		const clusterId = sanitizeClusterId(moduleName);
-		lines.push(`  subgraph cluster_${clusterId} {`);
-		lines.push(`    label="${dotEscapeLabel(moduleName)}";`);
-		lines.push("    style=filled;");
-		lines.push("    fillcolor=lightgray;");
-		for (const node of nodes) lines.push(nodeAttributeLine(node, "    "));
-		lines.push("  }");
-	}
-	for (const node of ungrouped) lines.push(nodeAttributeLine(node, "  "));
-	const emittedNodeIds = new Set(graph.nodes.map((node) => node.bindingId));
-	const edgeSeen = /* @__PURE__ */ new Set();
 	for (const edge of graph.edges) {
-		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(`  "${dotEscapeId(edge.fromBindingId)}" [shape=box, style=dashed, label="(unlisted ${dotEscapeLabel(edge.fromBindingId)})"];`);
-		}
-		if (!emittedNodeIds.has(edge.toBindingId)) {
-			emittedNodeIds.add(edge.toBindingId);
-			lines.push(`  "${dotEscapeId(edge.toBindingId)}" [shape=box, style=dashed, label="(unlisted ${dotEscapeLabel(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(`  "${dotEscapeId(edge.fromBindingId)}" -> "${dotEscapeId(edge.toBindingId)}" [label="${edgeLabel}", xlabel="${pathLabel}"${edgeStyle}];`);
+		const label = edge.label !== void 0 ? ` [label="${edge.label}"]` : "";
+		lines.push(`  "${edge.from}" -> "${edge.to}"${label};`);
 	}
 	lines.push("}");
 	return lines.join("\n");
 }
-function nodeAttributeLine(node, indent) {
-	const shape = nodeShapeForKind(node.kind);
-	const scopeAttrs = scopeVisualAttributes(node.scope);
-	const labelLines = [
-		node.kind,
-		node.registryKeyLabel,
-		`scope=${node.scope}`
-	];
-	if (node.hasConditionalConstraint) labelLines.push("when(...)");
-	return `${indent}"${dotEscapeId(node.bindingId)}" [shape=${shape}, ${scopeAttrs}, label="${dotEscapeLabel(labelLines.join("\n"))}"];`;
-}
-function dotEscapeLabel(text) {
-	return text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n");
-}
-function dotEscapeId(id) {
-	return id.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n");
-}
-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;
-	}
-}
-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;
-	}
-}
-function sanitizeClusterId(moduleName) {
-	return moduleName.replace(/[^0-9a-zA-Z_]/g, "_");
-}
 //#endregion
 export { toDotGraph };

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

@@ -1,10 +1,29 @@
-import { ContainerGraphJson } from "../inspector.mjs";
-import { ReactFlowGraphJson } from "./types.mjs";
+import { ContainerGraphJson } from "../dependency-graph.mjs";
 
 //#region src/graph-adapters/reactflow.d.ts
-/**
- * Converts the canonical container graph JSON into React Flow nodes/edges format.
- */
-declare function toReactFlowGraph(graph: ContainerGraphJson): ReactFlowGraphJson;
+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 { toReactFlowGraph };
+export { ReactFlowEdge, ReactFlowGraph, ReactFlowNode, toReactFlowGraph };

package/dist/graph-adapters/reactflow.mjs

@@ -1,80 +1,29 @@
 //#region src/graph-adapters/reactflow.ts
-const DEFAULT_X_GAP = 240;
-const DEFAULT_Y_GAP = 110;
-/**
-* Converts the canonical container graph JSON into React Flow nodes/edges format.
-*/
 function toReactFlowGraph(graph) {
-	const nodes = graph.nodes.map((node, index) => ({
-		id: node.bindingId,
-		position: {
-			x: 0,
-			y: index * DEFAULT_Y_GAP
-		},
-		data: {
-			label: node.registryKeyLabel,
-			bindingId: node.bindingId,
-			kind: node.kind,
-			scope: node.scope,
-			activationStatus: node.activationStatus,
-			hasConditionalConstraint: node.hasConditionalConstraint,
-			...node.moduleId === void 0 ? {} : { moduleId: node.moduleId }
-		}
-	}));
-	const edges = graph.edges.map((edge) => ({
-		id: edgeIdForReactFlow(edge),
-		source: edge.fromBindingId,
-		target: edge.toBindingId,
-		label: edgeLabelForReactFlow(edge),
-		data: {
-			edgeKind: edge.edgeKind,
-			...edge.injectHintLabel === void 0 ? {} : { injectHintLabel: edge.injectHintLabel },
-			toBindingConditional: edge.toBindingConditional,
-			isAliasEdge: edge.isAliasEdge,
-			resolutionPath: [...edge.resolutionPath]
-		}
-	}));
-	const moduleIndex = /* @__PURE__ */ new Map();
-	let nextColumn = 1;
 	return {
-		nodes: nodes.map((node) => {
-			const moduleId = node.data.moduleId;
-			if (moduleId === void 0) return node;
-			const existingColumn = moduleIndex.get(moduleId);
-			if (existingColumn !== void 0) return {
-				...node,
-				position: {
-					...node.position,
-					x: existingColumn * DEFAULT_X_GAP
-				}
+		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
 			};
-			const column = nextColumn;
-			nextColumn += 1;
-			moduleIndex.set(moduleId, column);
-			return {
-				...node,
-				position: {
-					...node.position,
-					x: column * DEFAULT_X_GAP
-				}
-			};
-		}),
-		edges
+			if (edge.label !== void 0) reactFlowEdge.label = edge.label;
+			return reactFlowEdge;
+		})
 	};
 }
-function edgeLabelForReactFlow(edge) {
-	const parts = [];
-	if (edge.injectHintLabel !== void 0) parts.push(edge.injectHintLabel);
-	parts.push(edge.edgeKind);
-	if (edge.toBindingConditional) parts.push("conditional");
-	return parts.join(" | ");
-}
-function edgeIdForReactFlow(edge) {
-	const hint = edge.injectHintLabel ?? "";
-	const conditional = edge.toBindingConditional ? "conditional" : "plain";
-	const alias = edge.isAliasEdge ? "alias" : "direct";
-	const path = edge.resolutionPath.join("->");
-	return `${edge.fromBindingId}->${edge.toBindingId}:${edge.edgeKind}:${hint}:${conditional}:${alias}:${path}`;
-}
 //#endregion
 export { toReactFlowGraph };

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

@@ -1,91 +1,2 @@
-import { Binding, BindingIdentifier, BindingScope } from "../binding.mjs";
-import { StaticDependencyEdge } from "../dependency-graph.mjs";
-
-//#region src/graph-adapters/types.d.ts
-/**
- * Cytoscape node payload emitted by graph adapters.
- */
-type CytoscapeNodeData = {
-  readonly id: string;
-  readonly label: string;
-  readonly bindingId: BindingIdentifier;
-  readonly kind: Binding<unknown>["kind"];
-  readonly scope: BindingScope;
-  readonly activationStatus: "cached" | "not-cached" | "transient";
-  readonly hasConditionalConstraint: boolean;
-  readonly moduleId?: string;
-};
-/**
- * Cytoscape edge payload emitted by graph adapters.
- */
-type CytoscapeEdgeData = {
-  readonly id: string;
-  readonly source: StaticDependencyEdge["fromBindingId"];
-  readonly target: StaticDependencyEdge["toBindingId"];
-  readonly edgeKind: StaticDependencyEdge["edgeKind"];
-  readonly injectHintLabel?: string;
-  readonly toBindingConditional: boolean;
-  readonly isAliasEdge: boolean;
-  readonly resolutionPath: readonly string[];
-};
-type CytoscapeNode = {
-  readonly data: CytoscapeNodeData;
-};
-type CytoscapeEdge = {
-  readonly data: CytoscapeEdgeData;
-};
-/**
- * Cytoscape JSON graph output shape.
- */
-type CytoscapeGraphJson = {
-  readonly elements: {
-    readonly nodes: CytoscapeNode[];
-    readonly edges: CytoscapeEdge[];
-  };
-};
-/**
- * React Flow node payload emitted by graph adapters.
- */
-type ReactFlowNodeData = {
-  readonly label: string;
-  readonly bindingId: BindingIdentifier;
-  readonly kind: Binding<unknown>["kind"];
-  readonly scope: BindingScope;
-  readonly activationStatus: "cached" | "not-cached" | "transient";
-  readonly hasConditionalConstraint: boolean;
-  readonly moduleId?: string;
-};
-/**
- * React Flow edge payload emitted by graph adapters.
- */
-type ReactFlowEdgeData = {
-  readonly edgeKind: StaticDependencyEdge["edgeKind"];
-  readonly injectHintLabel?: string;
-  readonly toBindingConditional: boolean;
-  readonly isAliasEdge: boolean;
-  readonly resolutionPath: readonly string[];
-};
-type ReactFlowNode = {
-  readonly id: string;
-  readonly position: {
-    readonly x: number;
-    readonly y: number;
-  };
-  readonly data: ReactFlowNodeData;
-};
-type ReactFlowEdge = {
-  readonly id: string;
-  readonly source: StaticDependencyEdge["fromBindingId"];
-  readonly target: StaticDependencyEdge["toBindingId"];
-  readonly label: string;
-  readonly data: ReactFlowEdgeData;
-};
-/**
- * React Flow JSON graph output shape.
- */
-type ReactFlowGraphJson = {
-  readonly nodes: ReactFlowNode[];
-  readonly edges: ReactFlowEdge[];
-};
-//#endregion
-export { CytoscapeEdge, CytoscapeEdgeData, CytoscapeGraphJson, CytoscapeNode, CytoscapeNodeData, ReactFlowEdge, ReactFlowEdgeData, ReactFlowGraphJson, ReactFlowNode, ReactFlowNodeData };
+import { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions } from "../dependency-graph.mjs";
+export { type ContainerGraphJson, type GraphEdge, type GraphNode, type GraphOptions };

package/dist/index.d.mts

@@ -1,9 +1,17 @@
-import { Token, TokenValue, token } from "./token.mjs";
-import { ActivationHandler, BindingBuilder, BindingIdentifier, BindingScope, ConstraintContext, Constructor, DeactivationHandler, ResolveOptions } from "./binding.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 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,78 +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 = {
-  /** Human-readable token/constructor label that owns this binding row. */readonly registryKeyLabel: string; /** Stable binding identifier. */
-  readonly bindingId: BindingIdentifier; /** Binding strategy kind. */
-  readonly kind: Binding<unknown>["kind"]; /** Declared binding scope. */
-  readonly scope: BindingScope; /** Cache/materialization status at snapshot time. */
-  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 = {
-  /** Flat list of every visible binding row in the container hierarchy. */readonly bindings: readonly ContainerBindingSnapshot[];
-};
-/**
- * Canonical structured dependency graph returned by {@link Container.generateDependencyGraph}.
- */
-type ContainerGraphJson = {
-  /** Graph nodes (same shape as snapshot rows). */nodes: ContainerBindingSnapshot[]; /** Directed dependency edges between node binding ids. */
-  edges: ReturnType<typeof collectStaticDependencyEdges>[number][];
-};
-/**
- * Read-only view of the container internals exposed to {@link ContainerInspector}.
- */
-type ContainerInspectorContext = {
-  /** Enumerates every registry key visible to the inspector. */collectAllRegistryKeys(): readonly RegistryKey[]; /** Returns bindings for a given key, including hierarchy lookup behavior. */
-  lookupBindings(key: RegistryKey): readonly Binding<unknown>[] | undefined; /** Reports whether a binding currently has a cached scoped/singleton instance. */
-  isBindingCached(binding: Binding<unknown>): boolean; /** Metadata reader used for static constructor/lifecycle analysis. */
-  metadataReader: MetadataReader | undefined;
-};
-/**
- * Options for {@link Container.generateDependencyGraph}.
- */
-type GraphOptions = {
-  /**
-   * 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 canonical dependency-graph output (`nodes` + `edges`).
- *
- * 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;
-  /**
-   * Builds the canonical JSON graph (`nodes` + `edges`).
-   */
-  generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;
+interface BindingSnapshot {
+  readonly tokenName: string;
+  readonly kind: BindingKind;
+  readonly scope: BindingScope;
+  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, GraphOptions };
+export { BindingSnapshot, ContainerSnapshot, Inspector };