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

package/dist/errors.d.mts

@@ -1,211 +1,92 @@
-import { Binding, BindingIdentifier, BindingScope, ResolveHint } from "./binding.mjs";
+import { BindingIdentifier, BindingScope, ResolveOptions } from "./types.mjs";
 
 //#region src/errors.d.ts
-/**
- * Formats a resolution path array into a human-readable `"A -> B -> C"` string.
- */
-declare function formatResolutionPath(resolutionPath: readonly string[]): string;
-/**
- * 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.
- */
 declare abstract class DiError extends Error {
-  /**
-   * Machine-readable error code, constant per subclass (e.g. `"TOKEN_NOT_BOUND"`).
-   */
   abstract readonly code: string;
-  constructor(message: string, options?: ErrorOptions);
-}
-/**
- * Raised for internal programming errors — invalid library usage or unexpected state that
- * 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"`
- */
+  constructor(message: string);
+}
 declare class InternalError extends DiError {
   readonly code = "INTERNAL_ERROR";
+  constructor(message: string);
+}
+declare class TokenNotBoundError extends DiError {
+  readonly code = "TOKEN_NOT_BOUND";
+  readonly tokenName: string;
+  constructor(tokenName: string);
 }
-/**
- * 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"`
- */
 declare class NoMatchingBindingError extends DiError {
   readonly code = "NO_MATCHING_BINDING";
-  /**
-   * The `Token.name` or `Constructor.name` that was resolved.
-   */
   readonly tokenName: string;
-  /**
-   * The name/tag hint that failed to match any binding.
-   */
-  readonly hint: ResolveHint;
-  /**
-   * Label path from the resolution root to the failing token.
-   */
-  readonly resolutionPath: readonly string[];
-  constructor(tokenName: string, hint: ResolveHint, resolutionPath: readonly string[], options?: ErrorOptions);
-}
-/**
- * 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"`
- */
-declare class TokenNotBoundError extends DiError {
-  readonly code = "TOKEN_NOT_BOUND";
-  /**
-   * The `Token.name` or `Constructor.name` that could not be found.
-   */
+  readonly hint: ResolveOptions;
+  readonly availableSlots: string[];
+  constructor(tokenName: string, hint: ResolveOptions, availableSlots: string[]);
+}
+declare class AmbiguousBindingError extends DiError {
+  readonly code = "AMBIGUOUS_BINDING";
   readonly tokenName: string;
-  /**
-   * Label path from the resolution root to the missing token.
-   */
-  readonly resolutionPath: readonly string[];
-  constructor(tokenName: string, resolutionPath: readonly string[], options?: ErrorOptions);
-}
-/**
- * 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"`
- */
+  readonly candidateIds: readonly BindingIdentifier[];
+  constructor(tokenName: string, candidateIds: readonly BindingIdentifier[]);
+}
 declare class CircularDependencyError extends DiError {
   readonly code = "CIRCULAR_DEPENDENCY";
-  /**
-   * Full label path including the repeated token at the end.
-   */
-  readonly resolutionPath: readonly string[];
-  /**
-   * Mutable copy of {@link resolutionPath} for consumer convenience.
-   */
   readonly cycle: string[];
-  constructor(resolutionPath: readonly string[], options?: ErrorOptions);
-}
-/**
- * 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"`
- */
+  constructor(cycle: string[]);
+}
+declare class AsyncResolutionError extends DiError {
+  readonly code = "ASYNC_RESOLUTION";
+  readonly tokenName: string;
+  readonly asyncSourceToken: string;
+  constructor(tokenName: string, asyncSourceToken: string);
+}
+declare class AsyncDeactivationError extends DiError {
+  readonly code = "ASYNC_DEACTIVATION";
+  readonly tokenName: string;
+  constructor(tokenName: string);
+}
+interface ScopeViolationDetails {
+  readonly consumerToken: string;
+  readonly consumerScope: BindingScope;
+  readonly dependencyToken: string;
+  readonly dependencyScope: BindingScope;
+  readonly path: string[];
+}
+declare class ScopeViolationError extends DiError {
+  readonly code = "SCOPE_VIOLATION";
+  readonly details: ScopeViolationDetails;
+  constructor(details: ScopeViolationDetails);
+}
 declare class MissingMetadataError extends DiError {
   readonly code = "MISSING_METADATA";
-  /**
-   * Name of the class that is missing `@injectable()` metadata.
-   */
-  readonly className: string;
-  /**
-   * Label path from the resolution root to the class binding.
-   */
-  readonly resolutionPath: readonly string[];
-  constructor(className: string, resolutionPath: readonly string[], options?: ErrorOptions);
-}
-/**
- * Raised when the synchronous `Container.load()` is called with an {@link AsyncModule}.
- * Use `Container.loadAsync()` or `Container.fromModulesAsync()` instead.
- *
- * Code: `"ASYNC_MODULE_LOAD"`
- */
+  readonly targetName: string;
+  constructor(targetName: string);
+}
 declare class AsyncModuleLoadError extends DiError {
   readonly code = "ASYNC_MODULE_LOAD";
-  /**
-   * Name of the async module that was passed to the sync loader.
-   */
   readonly moduleName: string;
-  constructor(moduleName: string, options?: ErrorOptions);
-}
-/**
- * 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"`
- */
-declare class AsyncResolutionError extends DiError {
-  readonly code = "ASYNC_RESOLUTION";
-  /**
-   * Token or class name that triggered the async path.
-   */
+  constructor(moduleName: string);
+}
+declare class SyncDisposalNotSupportedError extends DiError {
+  readonly code = "SYNC_DISPOSAL_NOT_SUPPORTED";
+  constructor();
+}
+declare class MissingScopeContextError extends DiError {
+  readonly code = "MISSING_SCOPE_CONTEXT";
   readonly tokenName: string;
-  /**
-   * Label path from the resolution root to the async binding.
-   */
-  readonly resolutionPath: readonly string[];
-  /**
-   * Human-readable description of why async resolution was required.
-   */
-  readonly reason: string;
-  constructor(tokenName: string, resolutionPath: readonly string[], reason: string, options?: ErrorOptions);
-}
-/**
- * Structured payload passed to the {@link ScopeViolationError} constructor.
- * Carries identities and scopes of both the long-lived consumer and the shorter-lived dependency.
- */
-type ScopeViolationDetails = {
-  /** 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[];
-};
-/**
- * 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"`
- */
-declare class ScopeViolationError extends DiError {
-  readonly code = "SCOPE_VIOLATION";
-  readonly consumerBindingId: BindingIdentifier;
-  readonly consumerKind: Binding<unknown>["kind"];
-  readonly consumerScope: BindingScope;
-  readonly dependencyBindingId: BindingIdentifier;
-  readonly dependencyKind: Binding<unknown>["kind"];
-  readonly dependencyScope: BindingScope;
-  readonly resolutionPath: readonly string[];
-  constructor(details: ScopeViolationDetails, options?: ErrorOptions);
+  constructor(tokenName: string);
+}
+declare class MissingContainerContextError extends DiError {
+  readonly code = "MISSING_CONTAINER_CONTEXT";
+  readonly targetName: string;
+  constructor(targetName: string);
+}
+declare class RebindUnboundTokenError extends DiError {
+  readonly code = "REBIND_UNBOUND_TOKEN";
+  readonly tokenName: string;
+  constructor(tokenName: string);
+}
+declare class DisposedContainerError extends DiError {
+  readonly code = "DISPOSED_CONTAINER";
+  constructor();
 }
 //#endregion
-export { AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationDetails, ScopeViolationError, TokenNotBoundError, formatResolutionPath };
+export { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationDetails, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };

package/dist/errors.mjs

@@ -1,260 +1,133 @@
 //#region src/errors.ts
-/**
-* Formats a resolution path array into a human-readable `"A -> B -> C"` string.
-*/
-function formatResolutionPath(resolutionPath) {
-	return resolutionPath.length > 0 ? resolutionPath.join(" -> ") : "(empty)";
-}
-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 {
-		const parts = [];
-		if (hint.name !== void 0) parts.push(`name: ${String(hint.name)}`);
-		if (hint.tag !== void 0) {
-			const [tagKey, tagValue] = hint.tag;
-			parts.push(`tag: [${tagKey}, <${typeof tagValue}>]`);
-		}
-		return `{ ${parts.join(", ")} }`;
-	} catch {
-		return "(unserializable hint)";
-	}
-}
-/**
-* 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) {
-		super(message, options);
-		this.name = new.target.name;
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
 	}
 };
-/**
-* Raised for internal programming errors — invalid library usage or unexpected state that
-* 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";
+	constructor(message) {
+		super(message);
+	}
+};
+var TokenNotBoundError = class extends DiError {
+	code = "TOKEN_NOT_BOUND";
+	tokenName;
+	constructor(tokenName) {
+		super(`No binding found for token '${tokenName}'. Did you forget container.bind(${tokenName})?`);
+		this.tokenName = tokenName;
+	}
 };
-/**
-* 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 = formatResolutionPath(resolutionPath);
-		const hintText = safeSerializeHint(hint);
-		super(`No binding matched resolve options ${hintText} for token "${tokenName}" (resolution path: ${pathText})`, options);
+	availableSlots;
+	constructor(tokenName, hint, availableSlots) {
+		const hintStr = JSON.stringify(hint);
+		const slotsStr = availableSlots.join(", ");
+		super(`No binding for '${tokenName}' matching ${hintStr}. Available slots: [${slotsStr}].`);
 		this.tokenName = tokenName;
 		this.hint = hint;
-		this.resolutionPath = resolutionPath;
+		this.availableSlots = availableSlots;
 	}
 };
-/**
-* 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.
-	*/
+var AmbiguousBindingError = class extends DiError {
+	code = "AMBIGUOUS_BINDING";
 	tokenName;
-	/**
-	* Label path from the resolution root to the missing token.
-	*/
-	resolutionPath;
-	constructor(tokenName, resolutionPath, options) {
-		const pathText = formatResolutionPath(resolutionPath);
-		super(`Token not bound: ${tokenName} (resolution path: ${pathText})`, options);
+	candidateIds;
+	constructor(tokenName, candidateIds) {
+		super(`Multiple bindings for '${tokenName}' matched without a clear winner. Candidates: [${candidateIds.join(", ")}]. Ensure when() predicates are mutually exclusive.`);
 		this.tokenName = tokenName;
-		this.resolutionPath = resolutionPath;
+		this.candidateIds = candidateIds;
 	}
 };
-/**
-* 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);
-		super(`Circular dependency detected: ${pathText}`, options);
-		this.resolutionPath = resolutionPath;
-		this.cycle = [...resolutionPath];
+	constructor(cycle) {
+		super(`Circular dependency detected: ${cycle.join(" → ")}`);
+		this.cycle = cycle;
+	}
+};
+var AsyncResolutionError = class extends DiError {
+	code = "ASYNC_RESOLUTION";
+	tokenName;
+	asyncSourceToken;
+	constructor(tokenName, asyncSourceToken) {
+		super(`Token '${tokenName}' requires async resolution because '${asyncSourceToken}' in its dependency chain has an async factory. Use container.resolveAsync(${tokenName}).`);
+		this.tokenName = tokenName;
+		this.asyncSourceToken = asyncSourceToken;
+	}
+};
+var AsyncDeactivationError = class extends DiError {
+	code = "ASYNC_DEACTIVATION";
+	tokenName;
+	constructor(tokenName) {
+		super(`Token '${tokenName}' has an async onDeactivation handler. Use unbindAsync() instead.`);
+		this.tokenName = tokenName;
+	}
+};
+var ScopeViolationError = class extends DiError {
+	code = "SCOPE_VIOLATION";
+	details;
+	constructor(details) {
+		super(`Scope violation: '${details.consumerToken}' (${details.consumerScope}) depends on '${details.dependencyToken}' (${details.dependencyScope}). Path: ${details.path.join(" → ")}`);
+		this.details = details;
 	}
 };
-/**
-* 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);
-		super(`Missing injectable constructor metadata for class "${className}" (resolution path: ${pathText})`, options);
-		this.className = className;
-		this.resolutionPath = resolutionPath;
+	targetName;
+	constructor(targetName) {
+		super(`Class '${targetName}' is missing @injectable() decorator. Add @injectable([...deps]) or use toDynamic()/toResolved() instead.`);
+		this.targetName = targetName;
 	}
 };
-/**
-* 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);
+	constructor(moduleName) {
+		super(`Module '${moduleName}' is async. Use container.loadAsync() instead.`);
 		this.moduleName = moduleName;
 	}
 };
-/**
-* 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.
-	*/
+var SyncDisposalNotSupportedError = class extends DiError {
+	code = "SYNC_DISPOSAL_NOT_SUPPORTED";
+	constructor() {
+		super("Container cannot be disposed synchronously because onDeactivation handlers may be async. Use `await using` or call container.dispose() explicitly.");
+	}
+};
+var MissingScopeContextError = class extends DiError {
+	code = "MISSING_SCOPE_CONTEXT";
 	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);
-		super(`Cannot resolve "${tokenName}" synchronously: ${reason} (resolution path: ${pathText})`, options);
+	constructor(tokenName) {
+		super(`Token '${tokenName}' is scoped but was resolved from a container without a child scope context. Use container.createChild() to create a scoped context.`);
 		this.tokenName = tokenName;
-		this.resolutionPath = resolutionPath;
-		this.reason = reason;
 	}
 };
-/**
-* 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";
-	consumerBindingId;
-	consumerKind;
-	consumerScope;
-	dependencyBindingId;
-	dependencyKind;
-	dependencyScope;
-	resolutionPath;
-	constructor(details, options) {
-		const pathText = formatResolutionPath(details.resolutionPath);
-		const consumerLabel = details.consumerLabel ?? String(details.consumerBindingId);
-		const dependencyLabel = details.dependencyLabel ?? String(details.dependencyBindingId);
-		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;
-		this.dependencyBindingId = details.dependencyBindingId;
-		this.dependencyKind = details.dependencyKind;
-		this.dependencyScope = details.dependencyScope;
-		this.resolutionPath = details.resolutionPath;
+var MissingContainerContextError = class extends DiError {
+	code = "MISSING_CONTAINER_CONTEXT";
+	targetName;
+	constructor(targetName) {
+		super(`Class '${targetName}' has @inject accessor fields but was instantiated outside a container context. Resolve it via container.resolve(${targetName}) instead.`);
+		this.targetName = targetName;
+	}
+};
+var RebindUnboundTokenError = class extends DiError {
+	code = "REBIND_UNBOUND_TOKEN";
+	tokenName;
+	constructor(tokenName) {
+		super(`Cannot rebind token '${tokenName}' because it has no own binding in this container. Use container.bind(${tokenName}) to create a new binding instead.`);
+		this.tokenName = tokenName;
+	}
+};
+var DisposedContainerError = class extends DiError {
+	code = "DISPOSED_CONTAINER";
+	constructor() {
+		super("Cannot perform operations on a disposed container.");
 	}
 };
 //#endregion
-export { AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, InternalError, MissingMetadataError, NoMatchingBindingError, ScopeViolationError, TokenNotBoundError, formatResolutionPath };
+export { AmbiguousBindingError, AsyncDeactivationError, AsyncModuleLoadError, AsyncResolutionError, CircularDependencyError, DiError, DisposedContainerError, InternalError, MissingContainerContextError, MissingMetadataError, MissingScopeContextError, NoMatchingBindingError, RebindUnboundTokenError, ScopeViolationError, SyncDisposalNotSupportedError, TokenNotBoundError };

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

@@ -1,10 +1,24 @@
-import { ContainerGraphJson } from "../inspector.mjs";
-import { CytoscapeGraphJson } from "./types.mjs";
+import { ContainerGraphJson } from "../dependency-graph.mjs";
 
 //#region src/graph-adapters/cytoscape.d.ts
-/**
- * Converts the canonical container graph JSON into Cytoscape elements format.
- */
-declare function toCytoscapeGraph(graph: ContainerGraphJson): CytoscapeGraphJson;
+interface CytoscapeNode {
+  data: {
+    id: string;
+    label: string;
+    kind: string;
+    scope: string;
+    fromParent: boolean;
+  };
+}
+interface CytoscapeEdge {
+  data: {
+    id: string;
+    source: string;
+    target: string;
+    label?: string;
+  };
+}
+type CytoscapeElements = Array<CytoscapeNode | CytoscapeEdge>;
+declare function toCytoscapeGraph(graph: ContainerGraphJson): CytoscapeElements;
 //#endregion
-export { toCytoscapeGraph };
+export { CytoscapeEdge, CytoscapeElements, CytoscapeNode, toCytoscapeGraph };