@codefast/di 0.3.15 → 0.3.16-canary.1

package/dist/container.mjs

@@ -1,11 +1,11 @@
 import { effectiveBindingScope } from "./binding-scope.mjs";
-import { DisposedContainerError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
+import { AsyncModuleLoadError, CircularDependencyError, DisposedContainerError, InternalError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError } from "./errors.mjs";
 import { DEFAULT_SLOT, generateBindingId } from "./binding.mjs";
 import { tokenName } from "./token.mjs";
 import { BindingRegistry } from "./registry.mjs";
 import { ScopeManager } from "./scope.mjs";
 import { LifecycleManager } from "./lifecycle.mjs";
-import { slotKeyToResolveOptions } from "./resolve-options.mjs";
+import { injectableSlotToResolveOptions, slotKeyToResolveOptions } from "./resolve-options.mjs";
 import { DependencyResolver } from "./resolver.mjs";
 import { Inspector } from "./inspector.mjs";
 import { buildDependencyGraph } from "./dependency-graph.mjs";
@@ -142,6 +142,7 @@ var DefaultContainer = class DefaultContainer {
 	_loadSyncModules(modules) {
 		const toLoad = this._collectModuleDeps(modules);
 		for (const mod of toLoad) {
+			if (!isSyncModule(mod)) throw new AsyncModuleLoadError(mod.name);
 			const ref = mod;
 			const existing = this._moduleRefs.get(ref);
 			if (existing !== void 0) {
@@ -332,43 +333,116 @@ var DefaultContainer = class DefaultContainer {
 		const reader = this._getMetadataReader();
 		const allBindings = this._registry.allBindings();
 		for (const binding of allBindings) {
-			if (binding.kind === "alias" || binding.kind === "constant" || binding.kind === "dynamic" || binding.kind === "dynamic-async") continue;
-			const scope = effectiveBindingScope(binding);
-			if (scope !== "singleton") continue;
-			const deps = this._getDepsForBinding(binding, reader);
-			for (const dep of deps) this._validateDep(tokenName(binding.token), scope, dep, [tokenName(binding.token)], reader);
+			if (!this._isSingletonStaticAnalyzableBinding(binding)) continue;
+			this._validateSingletonBindingGraph(binding, reader);
 		}
 	}
-	_getDepsForBinding(binding, reader) {
-		const result = [];
-		if (binding.kind === "class") {
-			const meta = reader.getConstructorMetadata(binding.target);
-			if (meta !== void 0) for (const param of meta.params) {
-				const depBindings = this._registry.getAll(param.token);
-				for (const db of depBindings) if (db.kind !== "alias") result.push({
-					token: param.token,
-					scope: effectiveBindingScope(db)
+	_isSingletonStaticAnalyzableBinding(binding) {
+		if (effectiveBindingScope(binding) !== "singleton") return false;
+		return binding.kind === "class" || binding.kind === "resolved" || binding.kind === "resolved-async";
+	}
+	/**
+	* DFS over explicit constructor / `toResolved*` dependency edges. Follows `toAlias` chains to the
+	* terminal binding for scope checks (SPEC §6.9). Skips `toDynamic*` subtrees (opaque).
+	*/
+	_validateSingletonBindingGraph(root, reader) {
+		const rootName = tokenName(root.token);
+		const dfs = (current, pathNames, pathBindingIds) => {
+			if (pathBindingIds.has(current.id)) return;
+			const extendedPathIds = new Set(pathBindingIds);
+			extendedPathIds.add(current.id);
+			for (const edge of this._collectStaticDependencyEdges(current, reader)) {
+				const { terminal, depTokenName } = edge;
+				const depScope = this._validationScopeFromTerminal(terminal);
+				if (depScope === "opaque") continue;
+				if (depScope === "scoped" || depScope === "transient") throw new ScopeViolationError({
+					consumerToken: rootName,
+					consumerScope: "singleton",
+					dependencyToken: depTokenName,
+					dependencyScope: depScope,
+					path: [...pathNames, depTokenName]
 				});
+				if (terminal.kind === "class" || terminal.kind === "resolved" || terminal.kind === "resolved-async") dfs(terminal, [...pathNames, depTokenName], extendedPathIds);
 			}
-		} else if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
-			const depBindings = this._registry.getAll(dep.token);
-			for (const db of depBindings) if (db.kind !== "alias") result.push({
-				token: dep.token,
-				scope: effectiveBindingScope(db)
-			});
+		};
+		dfs(root, [rootName], /* @__PURE__ */ new Set());
+	}
+	_validationScopeFromTerminal(terminal) {
+		switch (terminal.kind) {
+			case "constant": return "singleton";
+			case "dynamic":
+			case "dynamic-async": return "opaque";
+			case "class":
+			case "resolved":
+			case "resolved-async": return terminal.scope;
+			case "alias": throw new InternalError("validate: expected terminal binding after alias resolution");
+			default: return terminal;
 		}
-		return result;
 	}
-	_validateDep(consumerToken, consumerScope, dep, path, _reader) {
-		if (consumerScope === "singleton") {
-			if (dep.scope === "scoped" || dep.scope === "transient") throw new ScopeViolationError({
-				consumerToken,
-				consumerScope,
-				dependencyToken: tokenName(dep.token),
-				dependencyScope: dep.scope,
-				path
+	_followAliasChainToTerminal(binding, hint) {
+		const cyclePath = [];
+		const seenAliasIds = /* @__PURE__ */ new Set();
+		let current = binding;
+		while (current !== void 0 && current.kind === "alias") {
+			if (seenAliasIds.has(current.id)) throw new CircularDependencyError(cyclePath);
+			seenAliasIds.add(current.id);
+			cyclePath.push(tokenName(current.token));
+			const nextToken = current.target;
+			const next = this._resolver.peekBindingForValidate(nextToken, hint);
+			if (next === void 0) return;
+			current = next.binding;
+		}
+		return current;
+	}
+	_collectStaticDependencyEdges(binding, reader) {
+		const edges = [];
+		const pushTerminal = (terminal, displayName) => {
+			if (terminal === void 0) return;
+			edges.push({
+				terminal,
+				depTokenName: displayName
 			});
+		};
+		if (binding.kind === "class") {
+			const meta = reader.getConstructorMetadata(binding.target);
+			if (meta === void 0) return edges;
+			for (const param of meta.params) {
+				const paramHint = injectableSlotToResolveOptions(param);
+				if (param.optional) continue;
+				const tokenRef = param.token;
+				if (param.multi) {
+					const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, paramHint);
+					for (const cand of candidates) {
+						const term = this._followAliasChainToTerminal(cand, paramHint);
+						pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+					}
+					continue;
+				}
+				const found = paramHint === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, paramHint);
+				if (found === void 0) continue;
+				const term = this._followAliasChainToTerminal(found.binding, paramHint);
+				pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+			}
+			return edges;
 		}
+		if (binding.kind === "resolved" || binding.kind === "resolved-async") for (const dep of binding.deps) {
+			const depHint = injectableSlotToResolveOptions(dep);
+			if (dep.optional) continue;
+			const tokenRef = dep.token;
+			if (dep.multi) {
+				const candidates = this._resolver.peekCandidateBindingsForValidate(tokenRef, depHint);
+				for (const cand of candidates) {
+					const term = this._followAliasChainToTerminal(cand, depHint);
+					pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+				}
+				continue;
+			}
+			const found = depHint === void 0 ? this._resolver.peekBindingForValidate(tokenRef, void 0) : this._resolver.peekBindingForValidate(tokenRef, depHint);
+			if (found === void 0) continue;
+			const term = this._followAliasChainToTerminal(found.binding, depHint);
+			pushTerminal(term, term !== void 0 ? tokenName(term.token) : "");
+		}
+		return edges;
 	}
 	has(token, hint) {
 		this._assertNotDisposed();
@@ -394,7 +468,19 @@ var DefaultContainer = class DefaultContainer {
 		if (this._disposed) throw new DisposedContainerError();
 	}
 };
+function updateSlotTag(slot, tag, value) {
+	const existing = [...slot.tags];
+	const idx = existing.findIndex(([k]) => k === tag);
+	if (idx !== -1) existing[idx] = [tag, value];
+	else existing.push([tag, value]);
+	return {
+		...slot,
+		tags: existing
+	};
+}
 var BindToBuilderImpl = class {
+	_token;
+	_commit;
 	constructor(_token, _commit) {
 		this._token = _token;
 		this._commit = _commit;
@@ -454,6 +540,9 @@ var BindToBuilderImpl = class {
 	}
 };
 var BindingBuilderImpl = class {
+	_token;
+	_partial;
+	_commit;
 	_slot;
 	_predicate;
 	_committed;
@@ -492,14 +581,7 @@ var BindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}
@@ -535,6 +617,13 @@ var BindingBuilderImpl = class {
 	}
 };
 var ScopeBuilderImpl = class {
+	_token;
+	_partial;
+	_slot;
+	_predicate;
+	_commit;
+	_scope;
+	_initialPreviousId;
 	_onActivation;
 	_onDeactivation;
 	_committed;
@@ -576,6 +665,9 @@ var ScopeBuilderImpl = class {
 	}
 };
 var ConstantBindingBuilderImpl = class {
+	_token;
+	_value;
+	_commit;
 	_slot;
 	_predicate;
 	_onActivation;
@@ -620,14 +712,7 @@ var ConstantBindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}
@@ -649,6 +734,9 @@ var ConstantBindingBuilderImpl = class {
 	}
 };
 var AliasBindingBuilderImpl = class {
+	_token;
+	_target;
+	_commit;
 	_slot;
 	_predicate;
 	_committed;
@@ -688,14 +776,7 @@ var AliasBindingBuilderImpl = class {
 		return this;
 	}
 	whenTagged(tag, value) {
-		const existing = [...this._slot.tags];
-		const idx = existing.findIndex(([k]) => k === tag);
-		if (idx !== -1) existing[idx] = [tag, value];
-		else existing.push([tag, value]);
-		this._slot = {
-			...this._slot,
-			tags: existing
-		};
+		this._slot = updateSlotTag(this._slot, tag, value);
 		this._doCommit();
 		return this;
 	}
@@ -706,6 +787,9 @@ var AliasBindingBuilderImpl = class {
 		return this._committed;
 	}
 };
+/**
+* @since 0.3.16-canary.0
+*/
 const Container = {
 	create() {
 		return new DefaultContainer();

package/dist/decorators/inject.d.mts

@@ -2,10 +2,16 @@ import { Constructor } from "../constructor-type.mjs";
 import { Token } from "../token.mjs";
 
 //#region src/decorators/inject.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 interface InjectOptions {
   name?: string;
   tags?: ReadonlyArray<readonly [tag: string, value: unknown]>;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface InjectionDescriptor<Value = unknown> {
   readonly token: Token<Value> | Constructor<Value>;
   readonly optional: boolean;
@@ -13,12 +19,30 @@ interface InjectionDescriptor<Value = unknown> {
   readonly name?: string;
   readonly tags?: ReadonlyArray<readonly [string, unknown]>;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 type InjectableDependency<Value = unknown> = Token<Value> | Constructor<Value> | InjectionDescriptor<Value>;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function isInjectionDescriptor(value: unknown): value is InjectionDescriptor;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function normalizeToDescriptor(dep: InjectableDependency): InjectionDescriptor;
 type ClassAccessorDecorator<This, Value> = (target: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext<This, Value>) => ClassAccessorDecoratorResult<This, Value> | void;
-declare function inject<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
-declare function optional<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value | undefined>;
-declare function injectAll<const Value>(t: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value[]>;
+/**
+ * @since 0.3.16-canary.0
+ */
+declare function inject<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value> & ClassAccessorDecorator<unknown, Value>;
+/**
+ * @since 0.3.16-canary.0
+ */
+declare function optional<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Value | undefined>;
+/**
+ * @since 0.3.16-canary.0
+ */
+declare function injectAll<const Value>(token: Token<Value> | Constructor<Value>, options?: InjectOptions): InjectionDescriptor<Array<Value>>;
 //#endregion
 export { InjectOptions, InjectableDependency, InjectionDescriptor, inject, injectAll, isInjectionDescriptor, normalizeToDescriptor, optional };

package/dist/decorators/inject.mjs

@@ -1,14 +1,20 @@
-import { MissingContainerContextError } from "../errors.mjs";
+import { InternalError, MissingContainerContextError } from "../errors.mjs";
 import { getActiveContainer } from "../environment.mjs";
 import { injectableSlotToResolveOptions } from "../resolve-options.mjs";
-import { INJECT_ACCESSOR_KEY } from "../metadata/metadata-keys.mjs";
+import { INJECT_ACCESSOR_KEY, accessorMetadataByMetadataObjectMap } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/inject.ts
+/**
+* @since 0.3.16-canary.0
+*/
 function isInjectionDescriptor(value) {
 	if (value === null || value === void 0) return false;
 	const type = typeof value;
 	if (type !== "object" && type !== "function") return false;
 	return "token" in value && "optional" in value && "multi" in value && typeof value.optional === "boolean" && typeof value.multi === "boolean";
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function normalizeToDescriptor(dep) {
 	if (isInjectionDescriptor(dep)) return materializeInjectionDescriptor(dep);
 	return {
@@ -48,9 +54,9 @@ function materializeInjectionDescriptor(dep) {
 	};
 	return base;
 }
-function buildInjectionDescriptor(t, options) {
+function buildInjectionDescriptor(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: false,
 		multi: false
 	};
@@ -69,15 +75,20 @@ function buildInjectionDescriptor(t, options) {
 	};
 	return base;
 }
-function inject(t, options) {
-	const descriptor = buildInjectionDescriptor(t, options);
+/**
+* @since 0.3.16-canary.0
+*/
+function inject(token, options) {
+	const descriptor = buildInjectionDescriptor(token, options);
 	const decoratorFn = (_target, context) => {
+		if (context.static === true) throw new InternalError("@inject() on static accessors is not supported; only instance accessors participate in runWithContainer-based property injection.");
 		const meta = context.metadata;
 		if (!Array.isArray(meta[INJECT_ACCESSOR_KEY])) meta[INJECT_ACCESSOR_KEY] = [];
 		meta[INJECT_ACCESSOR_KEY].push({
 			key: context.name,
 			descriptor
 		});
+		accessorMetadataByMetadataObjectMap.set(context.metadata, meta[INJECT_ACCESSOR_KEY]);
 		context.addInitializer(function() {
 			const container = getActiveContainer();
 			if (container === void 0) throw new MissingContainerContextError(String(context.name));
@@ -85,7 +96,7 @@ function inject(t, options) {
 				...options.name !== void 0 ? { name: options.name } : {},
 				...options.tags !== void 0 ? { tags: options.tags } : {}
 			});
-			const value = descriptor.optional ? container.resolveOptional(t, hint) : container.resolve(t, hint);
+			const value = descriptor.optional ? container.resolveOptional(token, hint) : container.resolve(token, hint);
 			context.access.set(this, value);
 		});
 		return {};
@@ -100,9 +111,12 @@ function inject(t, options) {
 	Object.defineProperties(decoratorFn, props);
 	return decoratorFn;
 }
-function optional(t, options) {
+/**
+* @since 0.3.16-canary.0
+*/
+function optional(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: true,
 		multi: false
 	};
@@ -121,9 +135,12 @@ function optional(t, options) {
 	};
 	return base;
 }
-function injectAll(t, options) {
+/**
+* @since 0.3.16-canary.0
+*/
+function injectAll(token, options) {
 	const base = {
-		token: t,
+		token,
 		optional: false,
 		multi: true
 	};

package/dist/decorators/injectable.d.mts

@@ -3,6 +3,9 @@ import { BindingScope } from "../types.mjs";
 import { InjectableDependency } from "./inject.mjs";
 
 //#region src/decorators/injectable.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 interface AutoRegisterRegistry {
   register(target: Constructor, scope: BindingScope): void;
   entries(): ReadonlyArray<{
@@ -10,11 +13,20 @@ interface AutoRegisterRegistry {
     scope: BindingScope;
   }>;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function createAutoRegisterRegistry(): AutoRegisterRegistry;
+/**
+ * @since 0.3.16-canary.0
+ */
 interface InjectableOptions {
   autoRegister?: AutoRegisterRegistry;
   scope?: BindingScope;
 }
-declare function injectable(deps?: readonly InjectableDependency[], options?: InjectableOptions): (target: unknown, context: ClassDecoratorContext) => void;
+/**
+ * @since 0.3.16-canary.0
+ */
+declare function injectable(deps?: ReadonlyArray<InjectableDependency>, options?: InjectableOptions): (target: unknown, context: ClassDecoratorContext) => void;
 //#endregion
 export { AutoRegisterRegistry, type InjectableDependency, InjectableOptions, createAutoRegisterRegistry, injectable };

package/dist/decorators/injectable.mjs

@@ -1,49 +1,59 @@
-import { INJECTABLE_KEY, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
+import { INJECTABLE_KEY, INJECT_ACCESSOR_KEY, accessorMetadataByConstructorMap, constructorMetadataMap } from "../metadata/metadata-keys.mjs";
 import { normalizeToDescriptor } from "./inject.mjs";
 //#region src/decorators/injectable.ts
+/**
+* @since 0.3.16-canary.0
+*/
 function createAutoRegisterRegistry() {
-	const _entries = [];
+	const _registeredEntries = [];
 	return {
 		register(target, scope) {
-			_entries.push({
+			_registeredEntries.push({
 				target,
 				scope
 			});
 		},
 		entries() {
-			return _entries;
+			return _registeredEntries;
 		}
 	};
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function injectable(deps, options) {
 	return function(target, context) {
-		const constructorMeta = { params: (deps ?? []).map((dep, index) => {
-			const descriptor = normalizeToDescriptor(dep);
-			const base = {
+		const constructorMetadata = { params: (deps ?? []).map((dependency, index) => {
+			const descriptor = normalizeToDescriptor(dependency);
+			const baseParameterMetadata = {
 				index,
 				token: descriptor.token,
 				optional: descriptor.optional,
 				multi: descriptor.multi
 			};
 			if (descriptor.name !== void 0 && descriptor.tags !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				name: descriptor.name,
 				tags: descriptor.tags
 			};
 			if (descriptor.name !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				name: descriptor.name
 			};
 			if (descriptor.tags !== void 0) return {
-				...base,
+				...baseParameterMetadata,
 				tags: descriptor.tags
 			};
-			return base;
+			return baseParameterMetadata;
 		}) };
-		constructorMetadataMap.set(target, constructorMeta);
+		constructorMetadataMap.set(target, constructorMetadata);
 		try {
-			const meta = context.metadata;
-			if (meta !== null && typeof meta === "object") meta[INJECTABLE_KEY] = constructorMeta;
+			const metadata = context.metadata;
+			if (metadata !== null && typeof metadata === "object") {
+				const accessorList = metadata[INJECT_ACCESSOR_KEY];
+				if (Array.isArray(accessorList) && accessorList.length > 0) accessorMetadataByConstructorMap.set(target, accessorList);
+				metadata[INJECTABLE_KEY] = constructorMetadata;
+			}
 		} catch {}
 		if (options?.autoRegister !== void 0) {
 			const scope = options.scope ?? "transient";

package/dist/decorators/lifecycle-decorators.d.mts

@@ -1,5 +1,11 @@
 //#region src/decorators/lifecycle-decorators.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function postConstruct(): (target: unknown, context: ClassMethodDecoratorContext) => void;
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function preDestroy(): (target: unknown, context: ClassMethodDecoratorContext) => void;
 //#endregion
 export { postConstruct, preDestroy };

package/dist/decorators/lifecycle-decorators.mjs

@@ -1,3 +1,4 @@
+import { InternalError } from "../errors.mjs";
 import { LIFECYCLE_KEY, lifecycleByConstructorMetadataMap, lifecycleMetadataMap } from "../metadata/metadata-keys.mjs";
 //#region src/decorators/lifecycle-decorators.ts
 function appendUniqueMethod(metadata, phase, methodName) {
@@ -20,8 +21,12 @@ function registerByConstructor(target, phase, methodName) {
 		preDestroy: phase === "preDestroy" ? [methodName] : []
 	});
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function postConstruct() {
 	return function(target, context) {
+		if (context.static === true) throw new InternalError("@postConstruct() applies to instance methods only; static methods are not invoked during instance lifecycle.");
 		const methodName = String(context.name);
 		registerByConstructor(target, "postConstruct", methodName);
 		const existing = lifecycleMetadataMap.get(context.metadata);
@@ -53,8 +58,12 @@ function postConstruct() {
 		} catch {}
 	};
 }
+/**
+* @since 0.3.16-canary.0
+*/
 function preDestroy() {
 	return function(target, context) {
+		if (context.static === true) throw new InternalError("@preDestroy() applies to instance methods only; static methods are not invoked during instance teardown.");
 		const methodName = String(context.name);
 		registerByConstructor(target, "preDestroy", methodName);
 		const existing = lifecycleMetadataMap.get(context.metadata);

package/dist/dependency-graph.d.mts

@@ -3,6 +3,9 @@ import { BindingRegistry } from "./registry.mjs";
 import { MetadataReader } from "./metadata/metadata-types.mjs";
 
 //#region src/dependency-graph.d.ts
+/**
+ * @since 0.3.16-canary.0
+ */
 interface GraphNode {
   readonly id: string;
   readonly tokenName: string;
@@ -10,19 +13,31 @@ interface GraphNode {
   readonly scope: BindingScope;
   readonly fromParent: boolean;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface GraphEdge {
   readonly from: string;
   readonly to: string;
   readonly label?: string;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface ContainerGraphJson {
-  readonly nodes: readonly GraphNode[];
-  readonly edges: readonly GraphEdge[];
+  readonly nodes: ReadonlyArray<GraphNode>;
+  readonly edges: ReadonlyArray<GraphEdge>;
   readonly includesParent: boolean;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 interface GraphOptions {
   readonly includeParent?: boolean;
 }
+/**
+ * @since 0.3.16-canary.0
+ */
 declare function buildDependencyGraph(registry: BindingRegistry, metadataReader: MetadataReader, options: GraphOptions | undefined, parentRegistry?: BindingRegistry): ContainerGraphJson;
 //#endregion
 export { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions, buildDependencyGraph };

package/dist/dependency-graph.mjs

@@ -1,6 +1,9 @@
 import { effectiveBindingScope } from "./binding-scope.mjs";
 import { tokenName } from "./token.mjs";
 //#region src/dependency-graph.ts
+/**
+* @since 0.3.16-canary.0
+*/
 function buildDependencyGraph(registry, metadataReader, options, parentRegistry) {
 	const nodes = [];
 	const edges = [];