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

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @codefast/di
 
+## 0.3.14-canary.1
+
+### Patch Changes
+
+- [`2097bf6`](https://github.com/codefastlabs/codefast/commit/2097bf6c81639506c4c7f3f8a9a0f72bdb49ea49) Thanks [@thevuong](https://github.com/thevuong)! - refactor(di): update generateDependencyGraph method for improved clarity and functionality
+
+- [`0720553`](https://github.com/codefastlabs/codefast/commit/0720553f01bfae88725c1688efaf608e2cf45493) Thanks [@thevuong](https://github.com/thevuong)! - feat(di): add graph adapters for visualization formats
+
+- [`ab92dc7`](https://github.com/codefastlabs/codefast/commit/ab92dc7e5d864727bb5dcb1f2a3d08660c4112e8) Thanks [@thevuong](https://github.com/thevuong)! - refactor(di): enhance type definitions and documentation for clarity
+
 ## 0.3.14-canary.0
 
 ### Patch Changes

package/README.md

@@ -435,12 +435,21 @@ Control the environment heuristic via `NODE_ENV` — see `isDevelopmentOrTestEnv
 ### Introspection
 
 ```typescript
+import { toCytoscapeGraph } from "@codefast/di/graph-adapters/cytoscape";
+import { toDotGraph } from "@codefast/di/graph-adapters/dot";
+import { toReactFlowGraph } from "@codefast/di/graph-adapters/reactflow";
+
 const snapshot = container.inspect();
-const dot = container.generateDependencyGraph({ hideInternals: true });
-const json = container.generateDependencyGraph({ format: "json" });
+const json = container.generateDependencyGraph({ hideInternals: true });
+const dot = toDotGraph(json);
+
+// Adapters are pure converters from the canonical JSON graph.
+const cytoscape = toCytoscapeGraph(json);
+const reactflow = toReactFlowGraph(json);
 ```
 
-`generateDependencyGraph` returns a Graphviz DOT string by default, or a typed `ContainerGraphJson` when `format: "json"` is passed.
+`generateDependencyGraph` always returns the canonical typed `ContainerGraphJson` (`nodes` + `edges`).
+Keep visualization adapters (`toDotGraph`, `toCytoscapeGraph`, `toReactFlowGraph`, or your own converters) outside container/inspector core APIs and import them from direct subpaths under `@codefast/di/graph-adapters/*`.
 
 ### Disposal
 

package/dist/binding.d.mts

@@ -25,7 +25,7 @@ type BindingScope = "singleton" | "transient" | "scoped";
  * Hint for disambiguating multi-bindings registered against the same token or constructor.
  */
 type ResolveHint = {
-  readonly name?: string;
+  /** Matches bindings configured with `.whenNamed(name)`. */readonly name?: string; /** Matches bindings configured with `.whenTagged(tagKey, value)`. */
   readonly tag?: readonly [tag: string, value: unknown];
 };
 /**
@@ -44,10 +44,10 @@ type ConstraintBindingKind = "constant" | "class" | "dynamic" | "async-dynamic"
  * ({@link whenParentIs}, {@link whenAnyAncestorIs}) and captive-dependency detection.
  */
 type ConstraintParentFrame = {
-  readonly registryKey: RegistryKey;
-  readonly bindingId: BindingIdentifier;
-  readonly bindingKind: ConstraintBindingKind;
-  readonly tags: ReadonlyMap<string, unknown>;
+  /** Registry key (token/constructor) that selected this binding. */readonly registryKey: RegistryKey; /** Stable identifier of the materialized binding. */
+  readonly bindingId: BindingIdentifier; /** Discriminant of the selected binding strategy. */
+  readonly bindingKind: ConstraintBindingKind; /** Immutable tag map present on the selected binding. */
+  readonly tags: ReadonlyMap<string, unknown>; /** Effective scope of the selected binding. */
   readonly scope: BindingScope;
 };
 /**
@@ -58,10 +58,10 @@ type MaterializationFrame = ConstraintParentFrame;
  * Context for {@link BindingBuilder.when} predicates: path, ancestor metadata, and the current resolve hint.
  */
 type ConstraintContext = {
-  readonly resolutionPath: readonly string[];
-  readonly materializationStack: readonly ConstraintParentFrame[];
-  readonly parent: ConstraintParentFrame | undefined;
-  readonly ancestors: readonly ConstraintParentFrame[];
+  /** Resolution labels from root request to current key. */readonly resolutionPath: readonly string[]; /** Full chain of materialized parent frames (oldest → newest). */
+  readonly materializationStack: readonly ConstraintParentFrame[]; /** Immediate parent frame, if the current resolution has one. */
+  readonly parent: ConstraintParentFrame | undefined; /** Parent chain excluding the immediate parent frame. */
+  readonly ancestors: readonly ConstraintParentFrame[]; /** Name/tag hint used for the current lookup, if provided. */
   readonly currentResolveHint: ResolveHint | undefined;
 };
 /**
@@ -72,8 +72,8 @@ type ConstraintContext = {
  * context-sensitive bindings such as `whenParentIs` or `whenAnyAncestorIs`.
  */
 type ResolutionContext = {
-  readonly resolve: <Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions) => Value;
-  readonly resolveAsync: <Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions) => Promise<Value>;
+  /** Resolves one binding synchronously using current path/stack context. */readonly resolve: <Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions) => Value; /** Async variant of {@link ResolutionContext.resolve}. */
+  readonly resolveAsync: <Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions) => Promise<Value>; /** Returns `undefined` when the requested root key is unbound. */
   readonly resolveOptional: <Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions) => Value | undefined; /** Resolves every binding registered for `token` (multi-binding). */
   readonly resolveAll: <Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions) => Value[]; /** Async variant of {@link ResolutionContext.resolveAll}. */
   readonly resolveAllAsync: <Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions) => Promise<Value[]>;
@@ -213,7 +213,15 @@ declare class BindingBuilder<Value> {
    * Custom constraint predicates accumulated by `.when()`; all must pass for this binding to be selected.
    */
   private readonly constraintPredicates;
+  /**
+   * Latest `onActivation` hook provided by `.onActivation(...)`.
+   * Applied to emitted binding snapshots until replaced.
+   */
   private onActivationHandler;
+  /**
+   * Latest `onDeactivation` hook provided by `.onDeactivation(...)`.
+   * Emitted only on builder variants that expose deactivation support.
+   */
   private onDeactivationHandler;
   /**
    * Set when this binding was created inside a {@link Module} / {@link AsyncModule} setup callback.

package/dist/binding.mjs

@@ -50,7 +50,15 @@ var BindingBuilder = class {
 	* Custom constraint predicates accumulated by `.when()`; all must pass for this binding to be selected.
 	*/
 	constraintPredicates = [];
+	/**
+	* Latest `onActivation` hook provided by `.onActivation(...)`.
+	* Applied to emitted binding snapshots until replaced.
+	*/
 	onActivationHandler;
+	/**
+	* Latest `onDeactivation` hook provided by `.onDeactivation(...)`.
+	* Emitted only on builder variants that expose deactivation support.
+	*/
 	onDeactivationHandler;
 	/**
 	* Set when this binding was created inside a {@link Module} / {@link AsyncModule} setup callback.

package/dist/container.d.mts

@@ -1,7 +1,7 @@
 import { Token } from "./token.mjs";
 import { RegistryKey } from "./registry.mjs";
-import { Binding, BindingBuilder, BindingIdentifier, Constructor, ResolveHint, ResolveOptions } from "./binding.mjs";
-import { ContainerGraphJson, ContainerSnapshot, DotGraphOptions } from "./inspector.mjs";
+import { Binding, BindingBuilder, BindingIdentifier, Constructor, ResolveHint } from "./binding.mjs";
+import { ContainerGraphJson, ContainerSnapshot, GraphOptions } from "./inspector.mjs";
 import { AsyncModule, Module } from "./module.mjs";
 
 //#region src/container.d.ts
@@ -90,14 +90,9 @@ interface Container extends AsyncDisposable {
    */
   inspect(): ContainerSnapshot;
   /**
-   * Renders the dependency graph as a Graphviz DOT string (default) or a typed JSON object.
+   * Returns the canonical dependency graph as typed JSON (`nodes` + `edges`).
    */
-  generateDependencyGraph(options?: DotGraphOptions & {
-    format?: "dot";
-  }): string;
-  generateDependencyGraph(options: DotGraphOptions & {
-    format: "json";
-  }): ContainerGraphJson;
+  generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;
   /**
    * Creates a child container that inherits bindings from this container without polluting its registry.
    */
@@ -134,4 +129,4 @@ declare namespace Container {
   function fromModulesAsync(...modules: (Module | AsyncModule)[]): Promise<Container>;
 }
 //#endregion
-export { type BindingIdentifier, Container, type ContainerGraphJson, type ContainerSnapshot, type ResolveOptions };
+export { Container };

package/dist/container.mjs

@@ -53,6 +53,10 @@ var DefaultContainer = class DefaultContainer {
 	* Reset to `false` by {@link invalidateDevValidationState} on every registry mutation.
 	*/
 	devValidationRan = false;
+	/**
+	* Internal constructor for root/child instances.
+	* Use {@link Container.create}, {@link Container.fromModules}, or {@link createChild}.
+	*/
 	constructor(ownRegistry, ownScopeManager, parent, resolver, metadataReader) {
 		this.ownRegistry = ownRegistry;
 		this.ownScopeManager = ownScopeManager;
@@ -98,6 +102,12 @@ var DefaultContainer = class DefaultContainer {
 			}
 		});
 	}
+	/**
+	* Fast registry presence check without instantiation.
+	*
+	* When `hint` is provided, this only verifies that at least one binding matches
+	* the name/tag discriminator; it does not evaluate runtime `when()` predicates.
+	*/
 	has(token, hint) {
 		const list = this.lookupBindings(token);
 		if (list === void 0 || list.length === 0) return false;
@@ -111,6 +121,12 @@ var DefaultContainer = class DefaultContainer {
 			return true;
 		});
 	}
+	/**
+	* Removes bindings by token or by binding id and synchronously releases cached instances.
+	*
+	* - `binding id` path removes one binding and its cache entry.
+	* - `token` path removes all owned bindings for that key at once.
+	*/
 	unbind(tokenOrId) {
 		this.invalidateDevValidationState();
 		if (typeof tokenOrId === "string") {
@@ -122,6 +138,9 @@ var DefaultContainer = class DefaultContainer {
 		if (owned !== void 0) for (const binding of owned) this.ownScopeManager.releaseBinding(binding);
 		this.ownRegistry.remove(tokenOrId);
 	}
+	/**
+	* Async counterpart of {@link unbind}; awaits deactivation hooks before registry removal.
+	*/
 	async unbindAsync(tokenOrId) {
 		this.invalidateDevValidationState();
 		if (typeof tokenOrId === "string") {
@@ -133,6 +152,11 @@ var DefaultContainer = class DefaultContainer {
 		if (owned !== void 0) for (const binding of owned) await this.ownScopeManager.releaseBindingAsync(binding);
 		this.ownRegistry.remove(tokenOrId);
 	}
+	/**
+	* Replaces all owned bindings for `token` and returns a fresh builder.
+	*
+	* Existing cached instances for the removed bindings are synchronously released first.
+	*/
 	rebind(token) {
 		this.invalidateDevValidationState();
 		const owned = this.ownRegistry.get(token);
@@ -206,6 +230,10 @@ var DefaultContainer = class DefaultContainer {
 			this.maybeRunDevValidationOnce();
 		});
 	}
+	/**
+	* Optional root resolution: returns `undefined` when the requested key is absent (or filtered out
+	* without a name/tag hint), while preserving normal errors for nested required dependencies.
+	*/
 	resolveOptional(key, hint) {
 		try {
 			return this.resolver.resolveOptionalRoot(key, hint);
@@ -213,6 +241,10 @@ var DefaultContainer = class DefaultContainer {
 			this.maybeRunDevValidationOnce();
 		}
 	}
+	/**
+	* Synchronously resolves every matching binding for a key.
+	* Returns an empty array when no binding exists.
+	*/
 	resolveAll(key, hint) {
 		try {
 			return this.resolver.resolveAllRoot(key, hint);
@@ -277,11 +309,16 @@ var DefaultContainer = class DefaultContainer {
 	inspect() {
 		return this.createInspector().getSnapshot();
 	}
+	/**
+	* Delegates canonical dependency-graph generation to {@link ContainerInspector}.
+	*/
 	generateDependencyGraph(options) {
-		const inspector = this.createInspector();
-		if (options?.format === "json") return inspector.generateDependencyGraph(options);
-		return inspector.generateDotGraph(options);
+		return this.createInspector().generateDependencyGraph(options);
 	}
+	/**
+	* Registers every class collected by `@injectable({ autoRegister: true })`.
+	* Returns how many entries were processed.
+	*/
 	loadAutoRegistered() {
 		const entries = getAutoRegistered();
 		let count = 0;
@@ -352,14 +389,23 @@ var DefaultContainer = class DefaultContainer {
 		holder.current = child;
 		return child;
 	}
+	/**
+	* Lookup helper with parent fallback: own bindings take precedence over parent bindings.
+	*/
 	lookupBindings(token) {
 		const own = this.ownRegistry.get(token);
 		if (own !== void 0 && own.length > 0) return own;
 		return this.parent?.lookupBindings(token);
 	}
+	/**
+	* Disposes this container's scope manager and runs async deactivation hooks.
+	*/
 	async dispose() {
 		await this.ownScopeManager.disposeAsync();
 	}
+	/**
+	* Async-dispose protocol hook used by `await using`.
+	*/
 	[Symbol.asyncDispose]() {
 		return this.dispose();
 	}

package/dist/dependency-graph.d.mts

@@ -7,9 +7,9 @@ import { MetadataReader } from "./metadata/metadata-types.mjs";
  * A directed edge in the static dependency graph produced by {@link collectStaticDependencyEdges}.
  */
 type StaticDependencyEdge = {
-  readonly fromBindingId: BindingIdentifier;
-  readonly toBindingId: BindingIdentifier;
-  readonly resolutionPath: readonly string[];
+  /** Binding id of the consumer node (edge source). */readonly fromBindingId: BindingIdentifier; /** Binding id of the dependency node (edge target). */
+  readonly toBindingId: BindingIdentifier; /** Resolution labels leading to this edge. */
+  readonly resolutionPath: readonly string[]; /** Edge execution kind inferred from binding strategies. */
   readonly edgeKind: "sync" | "async";
   /**
    * True when the resolved target binding carries a {@link BindingBuilder.when} predicate (runtime may skip this edge).
@@ -28,8 +28,8 @@ type StaticDependencyEdge = {
  * A single resolved dependency entry produced by {@link listResolvedDependencies}.
  */
 type ResolvedDependency = {
-  readonly binding: Binding<unknown>;
-  readonly path: readonly string[];
+  /** Effective dependency binding selected for this edge. */readonly binding: Binding<unknown>; /** Resolution labels from consumer to dependency. */
+  readonly path: readonly string[]; /** Optional name/tag label shown in graph outputs. */
   readonly injectHintLabel?: string;
 };
 /**

package/dist/errors.d.mts

@@ -174,14 +174,14 @@ declare class AsyncResolutionError extends DiError {
  * Carries identities and scopes of both the long-lived consumer and the shorter-lived dependency.
  */
 type ScopeViolationDetails = {
-  readonly consumerBindingId: BindingIdentifier;
-  readonly consumerKind: Binding<unknown>["kind"];
-  readonly consumerScope: BindingScope;
-  readonly consumerLabel?: string;
-  readonly dependencyBindingId: BindingIdentifier;
-  readonly dependencyKind: Binding<unknown>["kind"];
-  readonly dependencyScope: BindingScope;
-  readonly dependencyLabel?: string;
+  /** Binding id of the long-lived consumer (typically singleton). */readonly consumerBindingId: BindingIdentifier; /** Binding strategy kind of the consumer. */
+  readonly consumerKind: Binding<unknown>["kind"]; /** Scope of the consumer binding. */
+  readonly consumerScope: BindingScope; /** Optional display label for consumer in error messages. */
+  readonly consumerLabel?: string; /** Binding id of the shorter-lived dependency. */
+  readonly dependencyBindingId: BindingIdentifier; /** Binding strategy kind of the dependency. */
+  readonly dependencyKind: Binding<unknown>["kind"]; /** Scope of the dependency binding. */
+  readonly dependencyScope: BindingScope; /** Optional display label for dependency in error messages. */
+  readonly dependencyLabel?: string; /** Resolution path captured at the violation point. */
   readonly resolutionPath: readonly string[];
 };
 /**

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

@@ -0,0 +1,10 @@
+import { ContainerGraphJson } from "../inspector.mjs";
+import { CytoscapeGraphJson } from "./types.mjs";
+
+//#region src/graph-adapters/cytoscape.d.ts
+/**
+ * Converts the canonical container graph JSON into Cytoscape elements format.
+ */
+declare function toCytoscapeGraph(graph: ContainerGraphJson): CytoscapeGraphJson;
+//#endregion
+export { toCytoscapeGraph };

package/dist/graph-adapters/cytoscape.mjs

@@ -0,0 +1,40 @@
+//#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}`;
+}
+//#endregion
+export { toCytoscapeGraph };

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

@@ -0,0 +1,9 @@
+import { ContainerGraphJson } from "../inspector.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

@@ -0,0 +1,97 @@
+//#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();
+	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 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}];`);
+	}
+	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

@@ -0,0 +1,10 @@
+import { ContainerGraphJson } from "../inspector.mjs";
+import { ReactFlowGraphJson } from "./types.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;
+//#endregion
+export { toReactFlowGraph };

package/dist/graph-adapters/reactflow.mjs

@@ -0,0 +1,80 @@
+//#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
+				}
+			};
+			const column = nextColumn;
+			nextColumn += 1;
+			moduleIndex.set(moduleId, column);
+			return {
+				...node,
+				position: {
+					...node.position,
+					x: column * DEFAULT_X_GAP
+				}
+			};
+		}),
+		edges
+	};
+}
+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

@@ -0,0 +1,91 @@
+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 };

package/dist/graph-adapters/types.mjs

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

package/dist/index.d.mts

@@ -1,10 +1,9 @@
 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 { 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 };
+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 };

package/dist/inspector.d.mts

@@ -12,10 +12,10 @@ 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"];
-  readonly scope: BindingScope;
+  /** 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).
@@ -27,28 +27,28 @@ type ContainerBindingSnapshot = {
  * Full debug snapshot returned by {@link Container.inspect}.
  */
 type ContainerSnapshot = {
-  readonly bindings: readonly ContainerBindingSnapshot[];
+  /** Flat list of every visible binding row in the container hierarchy. */readonly bindings: readonly ContainerBindingSnapshot[];
 };
 /**
- * Structured dependency graph returned by {@link Container.generateDependencyGraph} with `format: "json"`.
+ * Canonical structured dependency graph returned by {@link Container.generateDependencyGraph}.
  */
 type ContainerGraphJson = {
-  nodes: ContainerBindingSnapshot[];
+  /** 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 = {
-  collectAllRegistryKeys(): readonly RegistryKey[];
-  lookupBindings(key: RegistryKey): readonly Binding<unknown>[] | undefined;
-  isBindingCached(binding: Binding<unknown>): boolean;
+  /** 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 DotGraphOptions = {
+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.
@@ -57,7 +57,7 @@ type DotGraphOptions = {
 };
 /**
  * Reads the container's registry and scope-cache state to produce debug snapshots
- * and dependency-graph output (Graphviz DOT / typed JSON).
+ * 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.
@@ -70,31 +70,9 @@ declare class ContainerInspector {
    */
   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.
+   * Builds the canonical JSON graph (`nodes` + `edges`).
    */
-  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;
+  generateDependencyGraph(options?: GraphOptions): ContainerGraphJson;
 }
 //#endregion
-export { BindingActivationStatus, ContainerBindingSnapshot, ContainerGraphJson, ContainerInspector, ContainerInspectorContext, ContainerSnapshot, DotGraphOptions };
+export { BindingActivationStatus, ContainerBindingSnapshot, ContainerGraphJson, ContainerInspector, ContainerInspectorContext, ContainerSnapshot, GraphOptions };

package/dist/inspector.mjs

@@ -9,49 +9,6 @@ function activationStatusFor(binding, isCached) {
 	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;
-	}
-}
-/**
-* 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;
-	}
-}
-/**
-* 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) {
@@ -65,7 +22,7 @@ function isInternalRegistryKey(key) {
 }
 /**
 * Reads the container's registry and scope-cache state to produce debug snapshots
-* and dependency-graph output (Graphviz DOT / typed JSON).
+* 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.
@@ -104,106 +61,9 @@ var ContainerInspector = class {
 		return { bindings };
 	}
 	/**
-	* 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.
+	* Builds the canonical JSON graph (`nodes` + `edges`).
 	*/
-	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");
-	}
 	generateDependencyGraph(options) {
-		if (options?.format === "json") return this.generateDependencyGraphJsonTyped(options);
-		return this.generateDotGraph(options);
-	}
-	/**
-	* 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];
@@ -231,38 +91,6 @@ var ContainerInspector = class {
 			edges
 		};
 	}
-	/**
-	* 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 };

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

@@ -6,11 +6,11 @@ import { Constructor } from "../binding.mjs";
  * Metadata written per `accessor` field decorated with `@inject`; collected into `Symbol.metadata`.
  */
 type AccessorInjectionMetadata = {
-  readonly name: string;
-  readonly token: Token<unknown> | Constructor<unknown>;
-  readonly optional: boolean;
+  /** Accessor property name to inject after construction. */readonly name: string; /** Token/constructor resolved for this accessor. */
+  readonly token: Token<unknown> | Constructor<unknown>; /** Whether missing binding resolves to `undefined` instead of throwing. */
+  readonly optional: boolean; /** Optional name/tag filter forwarded to binding selection. */
   readonly resolveHint?: {
-    readonly name?: string;
+    /** Named-binding discriminator (`whenNamed`). */readonly name?: string; /** Tagged-binding discriminator (`whenTagged`). */
     readonly tag?: readonly [tag: string, value: unknown];
   };
 };
@@ -18,17 +18,17 @@ type AccessorInjectionMetadata = {
  * Lifecycle method names written by `@postConstruct()` / `@preDestroy()` into `Symbol.metadata`.
  */
 type LifecycleMetadata = {
-  readonly postConstruct?: string;
+  /** Method name marked with `@postConstruct()`. */readonly postConstruct?: string; /** Method name marked with `@preDestroy()`. */
   readonly preDestroy?: string;
 };
 /**
  * Per-parameter injection description collected by `@injectable()`.
  */
 type ParamMetadata = {
-  readonly index: number;
-  readonly token: Token<unknown> | Constructor<unknown>;
-  readonly optional: boolean;
-  readonly name?: string;
+  /** Zero-based constructor parameter index. */readonly index: number; /** Token/constructor used to resolve this parameter. */
+  readonly token: Token<unknown> | Constructor<unknown>; /** Whether missing binding resolves to `undefined`. */
+  readonly optional: boolean; /** Optional named-binding discriminator. */
+  readonly name?: string; /** Optional tagged-binding discriminator. */
   readonly tag?: readonly [tag: string, value: unknown];
   /**
    * When true, the parameter receives every binding for `token` as an array (same semantics as
@@ -41,9 +41,9 @@ type ParamMetadata = {
  * Used both as a deps-array entry in `@injectable()` and as accessor-field injection metadata.
  */
 type InjectionDescriptor<Value = unknown> = {
-  readonly token: Token<Value> | Constructor<Value>;
-  readonly optional: boolean;
-  readonly name?: string;
+  /** Token/constructor to resolve. */readonly token: Token<Value> | Constructor<Value>; /** Whether unbound token should resolve as `undefined`. */
+  readonly optional: boolean; /** Optional named-binding discriminator. */
+  readonly name?: string; /** Optional tagged-binding discriminator. */
   readonly tag?: readonly [tag: string, value: unknown]; /** When true, resolve every binding for {@link InjectionDescriptor.token} into an array. */
   readonly all?: boolean;
 };
@@ -51,7 +51,7 @@ type InjectionDescriptor<Value = unknown> = {
  * Constructor injection shape stored on the class `Symbol.metadata` object.
  */
 type ConstructorMetadata = {
-  readonly params: readonly ParamMetadata[];
+  /** Ordered constructor dependency descriptors. */readonly params: readonly ParamMetadata[];
 };
 /**
  * Abstraction for reading DI metadata without tying callers to `Symbol.metadata` directly.

package/dist/module.d.mts

@@ -17,7 +17,13 @@ import { BindingBuilder, Constructor } from "./binding.mjs";
  * binding in place and does not stack multiple registrations across lines.
  */
 type ModuleBuilder = {
+  /**
+   * Declares synchronous module dependencies to load before/alongside current setup.
+   */
   readonly import: (...modules: Module[]) => void;
+  /**
+   * Starts binding registration for a token/constructor within this module setup pass.
+   */
   readonly bind: <Value>(key: Token<Value> | Constructor<Value>) => BindingBuilder<Value>;
 };
 /**
@@ -26,7 +32,13 @@ type ModuleBuilder = {
  * Async sub-imports are collected and awaited **after** the setup callback returns.
  */
 type AsyncModuleBuilder = {
+  /**
+   * Declares sync/async module dependencies to be loaded by the async module loader.
+   */
   readonly import: (...modules: (Module | AsyncModule)[]) => void;
+  /**
+   * Starts binding registration for a token/constructor within this async module setup pass.
+   */
   readonly bind: <Value>(key: Token<Value> | Constructor<Value>) => BindingBuilder<Value>;
 };
 /**

package/dist/scope.d.mts

@@ -37,6 +37,10 @@ declare class ScopeManager {
    * {@link singletonPendingPromises} but for scoped bindings).
    */
   private readonly scopedPendingPromises;
+  /**
+   * Internal constructor for root/child scope managers.
+   * Prefer {@link createRoot} and {@link createChildScope}.
+   */
   private constructor();
   /**
    * Creates a root scope manager that owns both the singleton cache and scoped cache.

package/dist/scope.mjs

@@ -37,6 +37,10 @@ var ScopeManager = class ScopeManager {
 	* {@link singletonPendingPromises} but for scoped bindings).
 	*/
 	scopedPendingPromises;
+	/**
+	* Internal constructor for root/child scope managers.
+	* Prefer {@link createRoot} and {@link createChildScope}.
+	*/
 	constructor(singletonCache, scopedCache, ownsSingletonDisposal, singletonPendingPromises, scopedPendingPromises) {
 		this.singletonCache = singletonCache;
 		this.scopedCache = scopedCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/di",
-  "version": "0.3.14-canary.0",
+  "version": "0.3.14-canary.1",
   "description": "Lightweight dependency injection primitives for Codefast",
   "keywords": [
     "codefast",
@@ -81,6 +81,22 @@
       "types": "./dist/errors.d.mts",
       "import": "./dist/errors.mjs"
     },
+    "./graph-adapters/cytoscape": {
+      "types": "./dist/graph-adapters/cytoscape.d.mts",
+      "import": "./dist/graph-adapters/cytoscape.mjs"
+    },
+    "./graph-adapters/dot": {
+      "types": "./dist/graph-adapters/dot.d.mts",
+      "import": "./dist/graph-adapters/dot.mjs"
+    },
+    "./graph-adapters/reactflow": {
+      "types": "./dist/graph-adapters/reactflow.d.mts",
+      "import": "./dist/graph-adapters/reactflow.mjs"
+    },
+    "./graph-adapters/types": {
+      "types": "./dist/graph-adapters/types.d.mts",
+      "import": "./dist/graph-adapters/types.mjs"
+    },
     "./inspector": {
       "types": "./dist/inspector.d.mts",
       "import": "./dist/inspector.mjs"
@@ -141,7 +157,7 @@
     "typescript": "^6.0.2",
     "unplugin-swc": "^1.5.9",
     "vitest": "^4.1.4",
-    "@codefast/typescript-config": "0.3.14-canary.0"
+    "@codefast/typescript-config": "0.3.14-canary.1"
   },
   "engines": {
     "node": ">=22.0.0"