@codefast/di 0.3.13 → 0.3.14-canary.1

package/dist/errors.mjs

@@ -1,9 +1,18 @@
 //#region src/errors.ts
-/** Formats a resolution path array into a human-readable `"A -> B -> C"` string. */
+/**
+* Formats a resolution path array into a human-readable `"A -> B -> C"` string.
+*/
 function formatResolutionPath(resolutionPath) {
 	return resolutionPath.length > 0 ? resolutionPath.join(" -> ") : "(empty)";
 }
-/** Serializes a {@link ResolveHint} to a debug string; never throws even for exotic values. */
+const SCOPE_LABELS = {
+	singleton: "Singleton",
+	scoped: "Scoped",
+	transient: "Transient"
+};
+/**
+* Serializes a {@link ResolveHint} to a debug string; never throws even for exotic values.
+*/
 function safeSerializeHint(hint) {
 	if (hint === void 0) return "(none)";
 	try {
@@ -19,7 +28,11 @@ function safeSerializeHint(hint) {
 	}
 }
 /**
-* Base error for all `@codefast/di` failures. Subclasses expose a stable, machine-readable `code`.
+* Base error for all `@codefast/di` failures.
+*
+* Every concrete subclass exposes a stable, machine-readable {@link DiError.code} property
+* (e.g. `"TOKEN_NOT_BOUND"`) so consumers can `switch` on error type without relying
+* on `instanceof` across package versions.
 */
 var DiError = class extends Error {
 	constructor(message, options) {
@@ -29,21 +42,43 @@ var DiError = class extends Error {
 };
 /**
 * Raised for internal programming errors — invalid library usage or unexpected state that
-* indicates a bug in the caller (e.g. accessing an uninitialized container, misconfigured binding).
+* indicates a bug in the caller or the library itself.
+*
+* Examples: double `to*()` call on a {@link BindingBuilder}, ambiguous binding resolution
+* with multiple candidates, or scope mutation on a constant binding.
+*
+* Code: `"INTERNAL_ERROR"`
 */
 var InternalError = class extends DiError {
 	code = "INTERNAL_ERROR";
 };
 /**
-* Raised when a name/tag filter matches no binding although other bindings exist for the token.
+* Raised when bindings exist for the token but none match the provided name/tag hint.
+* Distinguishes from {@link TokenNotBoundError} (no bindings at all).
+*
+* Thrown when a `{ name }` or `{ tag }` hint is specified but no registered binding satisfies it
+* (e.g. `Container.resolve`, `Container.resolveAsync`, `Container.resolveOptional`,
+* `Container.resolveAll`, `Container.resolveAllAsync`, and binding selection helpers such as
+* {@link selectBindingForRegistry}).
+*
+* Code: `"NO_MATCHING_BINDING"`
 */
 var NoMatchingBindingError = class extends DiError {
 	code = "NO_MATCHING_BINDING";
+	/**
+	* The `Token.name` or `Constructor.name` that was resolved.
+	*/
 	tokenName;
+	/**
+	* The name/tag hint that failed to match any binding.
+	*/
 	hint;
+	/**
+	* Label path from the resolution root to the failing token.
+	*/
 	resolutionPath;
 	constructor(tokenName, hint, resolutionPath, options) {
-		const pathText = resolutionPath.length > 0 ? resolutionPath.join(" -> ") : "(empty)";
+		const pathText = formatResolutionPath(resolutionPath);
 		const hintText = safeSerializeHint(hint);
 		super(`No binding matched resolve options ${hintText} for token "${tokenName}" (resolution path: ${pathText})`, options);
 		this.tokenName = tokenName;
@@ -52,11 +87,29 @@ var NoMatchingBindingError = class extends DiError {
 	}
 };
 /**
-* Raised when resolving a value for a token that has no binding.
+* Raised when no binding exists for the requested token or constructor.
+*
+* Thrown by `Container.resolve`, `Container.resolveAsync`, and during transitive
+* dependency resolution when a required token has never been registered.
+*
+* Note on optional resolution:
+* - Root-level `Container.resolveOptional` returns `undefined` when **that key** has no
+*   registry entries (it never throws this error for the root key in that case). Missing
+*   **transitive** dependencies still throw during instantiation.
+* - `ResolutionContext.resolveOptional` (used inside factories) catches this error
+*   internally to return `undefined` for missing dependencies.
+*
+* Code: `"TOKEN_NOT_BOUND"`
 */
 var TokenNotBoundError = class extends DiError {
 	code = "TOKEN_NOT_BOUND";
+	/**
+	* The `Token.name` or `Constructor.name` that could not be found.
+	*/
 	tokenName;
+	/**
+	* Label path from the resolution root to the missing token.
+	*/
 	resolutionPath;
 	constructor(tokenName, resolutionPath, options) {
 		const pathText = formatResolutionPath(resolutionPath);
@@ -66,11 +119,22 @@ var TokenNotBoundError = class extends DiError {
 	}
 };
 /**
-* Raised when the dependency graph contains a cycle during resolution.
+* Raised when a token is encountered a second time on the same resolution call stack,
+* indicating a cyclic dependency (A → B → … → A).
+*
+* Also raised during module loading when `import()` forms a cycle between modules.
+*
+* Code: `"CIRCULAR_DEPENDENCY"`
 */
 var CircularDependencyError = class extends DiError {
 	code = "CIRCULAR_DEPENDENCY";
+	/**
+	* Full label path including the repeated token at the end.
+	*/
 	resolutionPath;
+	/**
+	* Mutable copy of {@link resolutionPath} for consumer convenience.
+	*/
 	cycle;
 	constructor(resolutionPath, options) {
 		const pathText = formatResolutionPath(resolutionPath);
@@ -80,11 +144,26 @@ var CircularDependencyError = class extends DiError {
 	}
 };
 /**
-* Raised when a class binding requires `@injectable()` / `Symbol.metadata` constructor metadata but none is present.
+* Raised when the container's {@link MetadataReader} is **configured** and reports no
+* constructor metadata for a `class` binding whose implementation has `arity > 0`.
+*
+* If `metadataReader` is `undefined`, the resolver calls `new ImplementationClass()` without
+* this check — this error is **not** thrown in that configuration.
+*
+* Fix: add `@injectable([...deps])` on the class (so `getConstructorMetadata` returns params),
+* or omit constructor parameters if you intentionally run without a reader.
+*
+* Code: `"MISSING_METADATA"`
 */
 var MissingMetadataError = class extends DiError {
 	code = "MISSING_METADATA";
+	/**
+	* Name of the class that is missing `@injectable()` metadata.
+	*/
 	className;
+	/**
+	* Label path from the resolution root to the class binding.
+	*/
 	resolutionPath;
 	constructor(className, resolutionPath, options) {
 		const pathText = formatResolutionPath(resolutionPath);
@@ -93,9 +172,17 @@ var MissingMetadataError = class extends DiError {
 		this.resolutionPath = resolutionPath;
 	}
 };
-/** Raised when `load()` is used with an async module. */
+/**
+* Raised when the synchronous `Container.load()` is called with an {@link AsyncModule}.
+* Use `Container.loadAsync()` or `Container.fromModulesAsync()` instead.
+*
+* Code: `"ASYNC_MODULE_LOAD"`
+*/
 var AsyncModuleLoadError = class extends DiError {
 	code = "ASYNC_MODULE_LOAD";
+	/**
+	* Name of the async module that was passed to the sync loader.
+	*/
 	moduleName;
 	constructor(moduleName, options) {
 		super(`Cannot load async module "${moduleName}" synchronously; use loadAsync() or Container.fromModulesAsync().`, options);
@@ -103,13 +190,28 @@ var AsyncModuleLoadError = class extends DiError {
 	}
 };
 /**
-* Raised when `resolve()` is called on a binding chain that contains an async factory or
-* an async `onActivation` handler. Use `resolveAsync()` / `resolveAllAsync()` instead.
+* Raised when synchronous `Container.resolve()` / `Container.resolveAll()` encounters an
+* async operation: an `async-dynamic` factory, a `toDynamic` factory that returns a Promise,
+* an `onActivation` handler that returns a Promise, or a `@postConstruct` method that
+* returns a Promise.
+*
+* Fix: switch to `Container.resolveAsync()` / `Container.resolveAllAsync()`.
+*
+* Code: `"ASYNC_RESOLUTION"`
 */
 var AsyncResolutionError = class extends DiError {
 	code = "ASYNC_RESOLUTION";
+	/**
+	* Token or class name that triggered the async path.
+	*/
 	tokenName;
+	/**
+	* Label path from the resolution root to the async binding.
+	*/
 	resolutionPath;
+	/**
+	* Human-readable description of why async resolution was required.
+	*/
 	reason;
 	constructor(tokenName, resolutionPath, reason, options) {
 		const pathText = formatResolutionPath(resolutionPath);
@@ -120,8 +222,16 @@ var AsyncResolutionError = class extends DiError {
 	}
 };
 /**
-* Raised when a long-lived binding would capture a shorter-lived (scoped or transient) dependency
-* (captive dependency). Constant value dependencies are excluded.
+* Raised for a **captive dependency**: a singleton consumer resolves (or would resolve) a
+* non-constant binding whose lifetime is `scoped` or `transient`. Constant bindings are exempt.
+*
+* - **Runtime:** each resolution step checks the parent on the materialization stack, so
+*   violations are detected along the actual construction chain.
+* - **`Container.validate()`:** {@link validateScopeRules} walks **direct** static edges from
+*   {@link listResolvedDependencies} only — it does not recursively expand the whole graph,
+*   so it may miss violations that appear only deeper in the dependency tree.
+*
+* Code: `"SCOPE_VIOLATION"`
 */
 var ScopeViolationError = class extends DiError {
 	code = "SCOPE_VIOLATION";
@@ -136,9 +246,7 @@ var ScopeViolationError = class extends DiError {
 		const pathText = formatResolutionPath(details.resolutionPath);
 		const consumerLabel = details.consumerLabel ?? String(details.consumerBindingId);
 		const dependencyLabel = details.dependencyLabel ?? String(details.dependencyBindingId);
-		const consumerScopeLabel = details.consumerScope.charAt(0).toUpperCase() + details.consumerScope.slice(1);
-		const dependencyScopeLabel = details.dependencyScope.charAt(0).toUpperCase() + details.dependencyScope.slice(1);
-		super(`Scope Violation: ${consumerScopeLabel} "${consumerLabel}" cannot depend on ${dependencyScopeLabel} "${dependencyLabel}" (resolution path: ${pathText})`, options);
+		super(`Scope Violation: ${SCOPE_LABELS[details.consumerScope]} "${consumerLabel}" cannot depend on ${SCOPE_LABELS[details.dependencyScope]} "${dependencyLabel}" (resolution path: ${pathText})`, options);
 		this.consumerBindingId = details.consumerBindingId;
 		this.consumerKind = details.consumerKind;
 		this.consumerScope = details.consumerScope;
@@ -149,4 +257,4 @@ var ScopeViolationError = class extends DiError {
 	}
 };
 //#endregion
-export { AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError };
+export { AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError, formatResolutionPath };

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, isInjectionDescriptor, optional } from "./decorators/inject.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, 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/index.mjs

@@ -1,8 +1,8 @@
 import { AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError } from "./errors.mjs";
-import { inject, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
+import { inject, injectAll, isInjectionDescriptor, optional } from "./decorators/inject.mjs";
 import { getAutoRegistered, injectable } from "./decorators/injectable.mjs";
 import { AsyncModule, Module } from "./module.mjs";
 import { Container } from "./container.mjs";
 import { token } from "./token.mjs";
 import { postConstruct, preDestroy } from "./decorators/lifecycle-decorators.mjs";
-export { AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, InternalError, MissingMetadataError, Module, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError, getAutoRegistered, inject, injectable, isInjectionDescriptor, optional, postConstruct, preDestroy, token };
+export { AsyncModule, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, Container, DiError, InternalError, MissingMetadataError, Module, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError, getAutoRegistered, inject, injectAll, injectable, isInjectionDescriptor, optional, postConstruct, preDestroy, token };