@djodjonx/neosyringe-core 0.1.2 → 1.1.0

package/dist/Analyzer-CsTQzjGb.mjs

@@ -0,0 +1,1356 @@
+import { createRequire } from "node:module";
+import * as ts from "typescript";
+import * as crypto from "node:crypto";
+import * as path from "node:path";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/analyzer/collectors/ConfigCollector.ts
+/**
+* Collects defineBuilderConfig and definePartialConfig calls from the program.
+*/
+var ConfigCollector = class {
+	constructor(program, checker) {
+		this.program = program;
+		this.checker = checker;
+	}
+	collect() {
+		const configs = /* @__PURE__ */ new Map();
+		const containerIdsByFile = /* @__PURE__ */ new Map();
+		for (const sourceFile of this.program.getSourceFiles()) {
+			if (sourceFile.isDeclarationFile) continue;
+			const fileConfigs = /* @__PURE__ */ new Map();
+			this.visitNode(sourceFile, sourceFile, configs, fileConfigs);
+			if (fileConfigs.size > 0) containerIdsByFile.set(sourceFile.fileName, fileConfigs);
+		}
+		this.validateContainerIdCollisions(containerIdsByFile);
+		return configs;
+	}
+	validateContainerIdCollisions(containerIdsByFile) {
+		for (const [fileName, fileConfigs] of containerIdsByFile) {
+			const seenIds = /* @__PURE__ */ new Map();
+			for (const config of fileConfigs.values()) {
+				const existing = seenIds.get(config.containerId);
+				if (existing) throw new Error(`Duplicate container name '${config.containerId}' found in ${fileName}.\nEach container must have a unique 'name' field within the same file.\nFirst occurrence: line ${config.sourceFile.getLineAndCharacterOfPosition(existing.node.getStart()).line + 1}\nSecond occurrence: line ${config.sourceFile.getLineAndCharacterOfPosition(config.node.getStart()).line + 1}`);
+				seenIds.set(config.containerId, config);
+			}
+		}
+	}
+	visitNode(node, sourceFile, configs, fileConfigs) {
+		if (ts.isCallExpression(node)) {
+			const config = this.tryParseConfig(node, sourceFile);
+			if (config) {
+				const uniqueKey = `${sourceFile.fileName}:${config.name}`;
+				configs.set(uniqueKey, config);
+				if (fileConfigs) {
+					const fileUniqueKey = `${config.name}:${node.getStart()}`;
+					fileConfigs.set(fileUniqueKey, config);
+				}
+			}
+		}
+		ts.forEachChild(node, (child) => this.visitNode(child, sourceFile, configs, fileConfigs));
+	}
+	tryParseConfig(node, sourceFile) {
+		const funcName = this.getFunctionName(node);
+		if (funcName === "defineBuilderConfig") return this.parseConfig(node, sourceFile, "builder");
+		if (funcName === "definePartialConfig") return this.parseConfig(node, sourceFile, "partial");
+		return null;
+	}
+	getFunctionName(node) {
+		const expression = node.expression;
+		if (ts.isIdentifier(expression)) return expression.text;
+		return null;
+	}
+	parseConfig(node, sourceFile, type) {
+		const name = this.getConfigName(node);
+		if (!name) return null;
+		const configArg = node.arguments[0];
+		if (!configArg || !ts.isObjectLiteralExpression(configArg)) return null;
+		const containerId = this.generateContainerId(configArg, sourceFile, node.getStart());
+		const { injections: localInjections, duplicates } = this.collectInjections(configArg, sourceFile);
+		const extendsRefs = type === "builder" ? this.getExtendsRefs(configArg) : [];
+		const useContainerRef = type === "builder" ? this.getUseContainerRef(configArg) : null;
+		return {
+			containerId,
+			name,
+			type,
+			sourceFile,
+			node,
+			localInjections,
+			duplicates,
+			extendsRefs,
+			useContainerRef,
+			legacyParentTokens: type === "builder" && useContainerRef ? this.extractLegacyParentTokens(useContainerRef, sourceFile) : void 0,
+			containerName: this.getContainerName(configArg)
+		};
+	}
+	getConfigName(node) {
+		const parent = node.parent;
+		if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) return parent.name.text;
+		if (ts.isExportAssignment(parent)) return "__default__";
+		return null;
+	}
+	collectInjections(configObj, sourceFile) {
+		const injections = /* @__PURE__ */ new Map();
+		const duplicates = [];
+		const injectionsProperty = this.findProperty(configObj, "injections");
+		if (!injectionsProperty || !ts.isArrayLiteralExpression(injectionsProperty.initializer)) return {
+			injections,
+			duplicates
+		};
+		for (const element of injectionsProperty.initializer.elements) {
+			if (!ts.isObjectLiteralExpression(element)) continue;
+			const info = this.parseInjection(element, sourceFile);
+			if (info) if (injections.has(info.definition.tokenId)) duplicates.push(info);
+			else injections.set(info.definition.tokenId, info);
+		}
+		return {
+			injections,
+			duplicates
+		};
+	}
+	parseInjection(obj, sourceFile) {
+		let tokenNode;
+		let providerNode;
+		let lifecycle = "singleton";
+		let useFactory = false;
+		let isScoped = false;
+		for (const prop of obj.properties) {
+			if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+			switch (prop.name.text) {
+				case "token":
+					tokenNode = prop.initializer;
+					break;
+				case "provider":
+					providerNode = prop.initializer;
+					break;
+				case "lifecycle":
+					if (ts.isStringLiteral(prop.initializer) && prop.initializer.text === "transient") lifecycle = "transient";
+					break;
+				case "useFactory":
+					if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) useFactory = true;
+					break;
+				case "scoped":
+					if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) isScoped = true;
+					break;
+			}
+		}
+		if (!tokenNode) return null;
+		const tokenText = tokenNode.getText(sourceFile);
+		const tokenId = this.resolveTokenId(tokenNode);
+		if (!tokenId) return null;
+		if (providerNode && (ts.isArrowFunction(providerNode) || ts.isFunctionExpression(providerNode))) useFactory = true;
+		let registrationType = "autowire";
+		if (useFactory) registrationType = "factory";
+		else if (providerNode) registrationType = "explicit";
+		const implementationSymbol = providerNode ? this.getSymbolForNode(providerNode) : this.getSymbolForNode(tokenNode);
+		const isInterfaceToken = this.isUseInterfaceCall(tokenNode);
+		return {
+			definition: {
+				tokenId,
+				implementationSymbol,
+				registrationNode: obj,
+				type: registrationType,
+				lifecycle,
+				isInterfaceToken,
+				isFactory: useFactory,
+				factorySource: useFactory && providerNode ? providerNode.getText(sourceFile) : void 0,
+				isScoped
+			},
+			node: obj,
+			tokenText,
+			isScoped
+		};
+	}
+	resolveTokenId(tokenNode) {
+		const node = this.resolveToInitializer(tokenNode) || tokenNode;
+		if (ts.isCallExpression(node) && this.isUseInterfaceCall(node)) return this.extractInterfaceTokenId(node);
+		if (ts.isCallExpression(node) && this.isUsePropertyCall(node)) return this.extractPropertyTokenId(node);
+		const type = this.checker.getTypeAtLocation(tokenNode);
+		return this.getTypeId(type);
+	}
+	resolveToInitializer(node) {
+		if (ts.isIdentifier(node)) {
+			const symbol = this.checker.getSymbolAtLocation(node);
+			if (!symbol) return null;
+			const declarations = symbol.getDeclarations();
+			if (!declarations || declarations.length === 0) return null;
+			const decl = declarations[0];
+			if (ts.isVariableDeclaration(decl) && decl.initializer) return decl.initializer;
+			return null;
+		}
+		if (ts.isPropertyAccessExpression(node)) {
+			const objectSymbol = this.checker.getSymbolAtLocation(node.expression);
+			if (!objectSymbol) return null;
+			const declarations = objectSymbol.getDeclarations();
+			if (!declarations || declarations.length === 0) return null;
+			const decl = declarations[0];
+			if (ts.isVariableDeclaration(decl) && decl.initializer && ts.isObjectLiteralExpression(decl.initializer)) {
+				const propName = node.name.text;
+				for (const prop of decl.initializer.properties) if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === propName) return prop.initializer;
+			}
+			return null;
+		}
+		return null;
+	}
+	isUseInterfaceCall(node) {
+		if (!ts.isCallExpression(node)) return false;
+		const expr = node.expression;
+		return ts.isIdentifier(expr) && expr.text === "useInterface";
+	}
+	isUsePropertyCall(node) {
+		if (!ts.isCallExpression(node)) return false;
+		const expr = node.expression;
+		return ts.isIdentifier(expr) && expr.text === "useProperty";
+	}
+	extractInterfaceTokenId(node) {
+		const typeArgs = node.typeArguments;
+		if (!typeArgs || typeArgs.length === 0) return "UnknownInterface";
+		const typeArg = typeArgs[0];
+		const type = this.checker.getTypeAtLocation(typeArg);
+		return `useInterface<${this.getTypeId(type)}>()`;
+	}
+	extractPropertyTokenId(node) {
+		const args = node.arguments;
+		if (args.length < 2) return "UnknownProperty";
+		return `useProperty<${args[0].getText()}>('${ts.isStringLiteral(args[1]) ? args[1].text : args[1].getText()}')`;
+	}
+	getTypeId(type) {
+		const symbol = type.getSymbol() || type.aliasSymbol;
+		if (!symbol) return this.checker.typeToString(type);
+		const declarations = symbol.getDeclarations();
+		if (declarations && declarations.length > 0) return generateTokenId(symbol, declarations[0].getSourceFile());
+		return symbol.getName();
+	}
+	simpleHash(str) {
+		let hash = 0;
+		for (let i = 0; i < str.length; i++) {
+			const char = str.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return Math.abs(hash).toString(16).slice(0, 8);
+	}
+	getSymbolForNode(node) {
+		return this.checker.getSymbolAtLocation(node);
+	}
+	getExtendsRefs(configObj) {
+		const refs = [];
+		const extendsProp = this.findProperty(configObj, "extends");
+		if (extendsProp && ts.isArrayLiteralExpression(extendsProp.initializer)) {
+			for (const element of extendsProp.initializer.elements) if (ts.isIdentifier(element)) refs.push(element.text);
+		}
+		return refs;
+	}
+	getUseContainerRef(configObj) {
+		const useContainerProp = this.findProperty(configObj, "useContainer");
+		if (useContainerProp && ts.isIdentifier(useContainerProp.initializer)) return useContainerProp.initializer.text;
+		return null;
+	}
+	getContainerName(configObj) {
+		const nameProp = this.findProperty(configObj, "name");
+		if (nameProp && ts.isStringLiteral(nameProp.initializer)) return nameProp.initializer.text;
+	}
+	/**
+	* Extracts tokens from a legacy parent container (declareContainerTokens).
+	* @param useContainerRef - Variable name of the parent container
+	* @param sourceFile - Source file containing the reference
+	* @returns Set of token IDs provided by the legacy container, or undefined if not a legacy container
+	*/
+	extractLegacyParentTokens(useContainerRef, sourceFile) {
+		const identifier = this.findIdentifierInFile(useContainerRef, sourceFile);
+		if (!identifier) return void 0;
+		const symbol = this.checker.getSymbolAtLocation(identifier);
+		if (!symbol) return void 0;
+		const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+		if (!declaration) return void 0;
+		if (ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isCallExpression(declaration.initializer)) {
+			const callExpr = declaration.initializer;
+			if (ts.isIdentifier(callExpr.expression) && callExpr.expression.text === "declareContainerTokens") return this.extractDeclaredTokens(callExpr);
+		}
+	}
+	/**
+	* Extracts tokens from declareContainerTokens<{ Token: Type }>().
+	*/
+	extractDeclaredTokens(node) {
+		if (!node.typeArguments || node.typeArguments.length === 0) return;
+		const typeArg = node.typeArguments[0];
+		const type = this.checker.getTypeFromTypeNode(typeArg);
+		const tokens = /* @__PURE__ */ new Set();
+		const properties = type.getProperties();
+		for (const prop of properties) {
+			const propType = this.checker.getTypeOfSymbol(prop);
+			if (propType) {
+				const tokenId = this.getTypeId(propType);
+				tokens.add(tokenId);
+			}
+		}
+		return tokens.size > 0 ? tokens : void 0;
+	}
+	/**
+	* Helper to find an identifier in a source file.
+	*/
+	findIdentifierInFile(name, sourceFile) {
+		let result;
+		const visit = (node) => {
+			if (result) return;
+			if (ts.isIdentifier(node) && node.text === name) {
+				result = node;
+				return;
+			}
+			ts.forEachChild(node, visit);
+		};
+		visit(sourceFile);
+		return result;
+	}
+	findProperty(obj, name) {
+		for (const prop of obj.properties) if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === name) return prop;
+	}
+	/**
+	* Generates a unique container ID from the 'name' field or a hash.
+	* Priority 1: Use the 'name' field from the config object
+	* Priority 2: Generate a stable hash based on file + position + content
+	*/
+	generateContainerId(configObject, sourceFile, position) {
+		const configName = this.extractConfigName(configObject);
+		if (configName) return configName;
+		const fileName = __require("path").basename(sourceFile.fileName, ".ts");
+		const configText = configObject.getText();
+		return `Container_${this.createHash(`${fileName}:${position}:${configText}`).substring(0, 8)}`;
+	}
+	/**
+	* Extracts the value of the 'name' field from a config object.
+	*/
+	extractConfigName(configObject) {
+		for (const prop of configObject.properties) if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "name") {
+			if (ts.isStringLiteral(prop.initializer)) return prop.initializer.text;
+		}
+	}
+	/**
+	* Creates a simple hash from a string.
+	*/
+	createHash(str) {
+		let hash = 0;
+		for (let i = 0; i < str.length; i++) {
+			const char = str.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return Math.abs(hash).toString(16);
+	}
+};
+
+//#endregion
+//#region src/analyzer/errors/CycleError.ts
+/**
+* Custom error for cycle detection.
+*/
+var CycleError = class extends Error {
+	constructor(chain) {
+		super(`Circular dependency detected: ${chain.join(" -> ")}`);
+		this.chain = chain;
+		this.name = "CycleError";
+	}
+};
+
+//#endregion
+//#region src/analyzer/resolvers/TokenResolver.ts
+/**
+* Resolves inherited tokens from useContainer and extends.
+*
+* Priority order:
+* 1. useContainer (parent) - highest priority, recursive
+* 2. extends (partials) - in array order
+*/
+var TokenResolver = class {
+	resolveInheritedTokens(config, allConfigs) {
+		const inherited = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		this.resolveRecursive(config, allConfigs, inherited, visited, []);
+		return inherited;
+	}
+	resolveRecursive(config, allConfigs, inherited, visited, chain) {
+		if (visited.has(config.name)) throw new CycleError([...chain, config.name]);
+		visited.add(config.name);
+		if (config.useContainerRef) {
+			const parent = this.findConfigByName(allConfigs, config.useContainerRef);
+			if (parent) {
+				this.resolveRecursive(parent, allConfigs, inherited, new Set(visited), [...chain, config.name]);
+				this.addTokensFromConfig(parent, inherited, "parent", chain);
+			}
+		}
+		for (const partialName of config.extendsRefs) {
+			const partial = this.findConfigByName(allConfigs, partialName);
+			if (partial) this.addTokensFromConfig(partial, inherited, "extends", chain);
+		}
+	}
+	/**
+	* Find a config by its variable name.
+	* Config keys are now "fileName:variableName", so we need to search for it.
+	*/
+	findConfigByName(allConfigs, variableName) {
+		for (const [_key, config] of allConfigs) if (config.name === variableName) return config;
+	}
+	addTokensFromConfig(config, inherited, type, chain) {
+		for (const [tokenId, info] of config.localInjections) if (!inherited.has(tokenId)) inherited.set(tokenId, {
+			tokenId,
+			tokenText: info.tokenText,
+			source: {
+				name: config.name,
+				type,
+				chain: chain.length > 0 ? [...chain] : void 0
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/analyzer/validators/Validator.ts
+/**
+* Composite validator that combines multiple validators.
+* Use this to compose validation rules.
+*/
+var CompositeValidator = class {
+	name = "CompositeValidator";
+	constructor(validators = []) {
+		this.validators = validators;
+	}
+	validate(config, context) {
+		const errors = [];
+		for (const validator of this.validators) errors.push(...validator.validate(config, context));
+		return errors;
+	}
+	/** Add a validator (for extensibility) */
+	addValidator(validator) {
+		this.validators.push(validator);
+		return this;
+	}
+	/** Remove a validator by name */
+	removeValidator(name) {
+		this.validators = this.validators.filter((v) => v.name !== name);
+		return this;
+	}
+	/** Get all validators */
+	getValidators() {
+		return this.validators;
+	}
+};
+
+//#endregion
+//#region src/analyzer/validators/DuplicateValidator.ts
+/**
+* Validates duplicate registrations.
+* - Internal duplicates (same config)
+* - Inherited duplicates (from parent/extends) for builders
+*/
+var DuplicateValidator = class {
+	name = "DuplicateValidator";
+	constructor(errorFormatter) {
+		this.errorFormatter = errorFormatter;
+	}
+	validate(config, context) {
+		const errors = [];
+		errors.push(...this.validateInternalDuplicates(config));
+		if (config.type === "builder" && context.inheritedTokens) errors.push(...this.validateInheritedDuplicates(config, context.inheritedTokens));
+		return errors;
+	}
+	validateInternalDuplicates(config) {
+		const errors = [];
+		for (const duplicate of config.duplicates) errors.push(this.errorFormatter.formatDuplicateError(duplicate, {
+			name: config.name,
+			type: "internal"
+		}));
+		return errors;
+	}
+	validateInheritedDuplicates(config, inheritedTokens) {
+		const errors = [];
+		for (const [tokenId, info] of config.localInjections) {
+			if (info.isScoped) continue;
+			const inherited = inheritedTokens.get(tokenId);
+			if (inherited) errors.push(this.errorFormatter.formatDuplicateError(info, inherited.source));
+		}
+		return errors;
+	}
+};
+
+//#endregion
+//#region src/analyzer/validators/TypeValidator.ts
+/**
+* Validates type compatibility between tokens and providers.
+* Ensures that the provider implements the interface/class expected by the token.
+*/
+var TypeValidator = class {
+	name = "TypeValidator";
+	constructor(checker, errorFormatter) {
+		this.checker = checker;
+		this.errorFormatter = errorFormatter;
+	}
+	validate(config, _context) {
+		const errors = [];
+		for (const [_tokenId, info] of config.localInjections) {
+			const typeError = this.checkTypeCompatibility(info);
+			if (typeError) errors.push(typeError);
+		}
+		return errors;
+	}
+	checkTypeCompatibility(info) {
+		const { definition } = info;
+		if (!definition.implementationSymbol) return null;
+		if (!definition.isInterfaceToken) return null;
+		const tokenType = this.getTokenType(info);
+		if (!tokenType) return null;
+		const implType = this.getImplementationType(info);
+		if (!implType) return null;
+		if (!this.checker.isTypeAssignableTo(implType, tokenType)) {
+			const expectedTypeName = this.checker.typeToString(tokenType);
+			const actualTypeName = this.checker.typeToString(implType);
+			return this.errorFormatter.formatTypeMismatchError(info, expectedTypeName, actualTypeName);
+		}
+		return null;
+	}
+	getTokenType(_info) {
+		return null;
+	}
+	getImplementationType(info) {
+		const { definition } = info;
+		if (!definition.implementationSymbol) return null;
+		const declarations = definition.implementationSymbol.getDeclarations();
+		if (!declarations || declarations.length === 0) return null;
+		return this.checker.getTypeOfSymbolAtLocation(definition.implementationSymbol, declarations[0]);
+	}
+};
+
+//#endregion
+//#region src/analyzer/validators/MissingDependencyValidator.ts
+/**
+* Validates that all required dependencies are available in the container.
+* - For partialConfig: checks only local injections
+* - For defineBuilder: checks local + parent + extends (recursive)
+*/
+var MissingDependencyValidator = class {
+	name = "MissingDependencyValidator";
+	constructor(errorFormatter, dependencyAnalyzer) {
+		this.errorFormatter = errorFormatter;
+		this.dependencyAnalyzer = dependencyAnalyzer;
+	}
+	validate(config, context) {
+		const errors = [];
+		const availableTokens = this.collectAvailableTokens(config, context);
+		for (const [_tokenId, info] of config.localInjections) {
+			const requiredDeps = this.dependencyAnalyzer.getRequiredDependencies(info.definition);
+			for (const depTokenId of requiredDeps) if (!(availableTokens.has(depTokenId) || availableTokens.has(`useInterface<${depTokenId}>()`))) {
+				const errorNode = this.findTokenNode(info.node) || info.node;
+				const sourceFile = config.sourceFile;
+				errors.push({
+					type: "missing",
+					message: `Missing injection: '${depTokenId}' required by '${info.tokenText}' is not registered in this ${config.type === "builder" ? "builder nor its parents/extends" : "partial config"}`,
+					node: errorNode,
+					sourceFile,
+					context: { tokenText: depTokenId }
+				});
+			}
+		}
+		return errors;
+	}
+	/**
+	* Finds the token property node within an injection object for better error positioning.
+	* Returns the entire property assignment (e.g., "token: UserService") not just the value,
+	* because the value might be an imported symbol whose AST node is in a different file.
+	*/
+	findTokenNode(injectionNode) {
+		if (!ts.isObjectLiteralExpression(injectionNode)) return null;
+		for (const prop of injectionNode.properties) if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "token") return prop;
+		return null;
+	}
+	/**
+	* Collects all available tokens in the current context.
+	* - partialConfig: only local tokens
+	* - defineBuilder: local + inherited from parent/extends + legacy parent tokens
+	*/
+	collectAvailableTokens(config, context) {
+		const available = /* @__PURE__ */ new Set();
+		for (const tokenId of config.localInjections.keys()) available.add(tokenId);
+		if (config.type === "builder" && context.inheritedTokens) for (const tokenId of context.inheritedTokens.keys()) available.add(tokenId);
+		if (config.type === "builder" && config.legacyParentTokens) for (const tokenId of config.legacyParentTokens) available.add(tokenId);
+		return available;
+	}
+};
+
+//#endregion
+//#region src/analyzer/validators/DependencyAnalyzer.ts
+/**
+* Analyzes class constructors and factory functions to extract required dependencies.
+*/
+var DependencyAnalyzer = class {
+	constructor(checker) {
+		this.checker = checker;
+	}
+	/**
+	* Extracts all dependencies required by a service definition.
+	* @param definition - Service definition to analyze
+	* @returns Array of token IDs required by this service
+	*/
+	getRequiredDependencies(definition) {
+		if (definition.isFactory || definition.type === "factory") return [];
+		if (!definition.implementationSymbol) return [];
+		return this.getConstructorDependencies(definition.implementationSymbol);
+	}
+	/**
+	* Extracts dependencies from a class constructor.
+	* @param symbol - Class symbol to analyze
+	* @returns Array of token IDs required by the constructor
+	*/
+	getConstructorDependencies(symbol) {
+		const dependencies = [];
+		const declarations = symbol.getDeclarations();
+		if (!declarations || declarations.length === 0) return dependencies;
+		const classDecl = declarations.find((d) => ts.isClassDeclaration(d));
+		if (!classDecl) return dependencies;
+		const className = classDecl.name?.getText() ?? "Anonymous";
+		const constructor = classDecl.members.find((m) => ts.isConstructorDeclaration(m));
+		if (!constructor) return dependencies;
+		for (const param of constructor.parameters) {
+			const paramName = param.name.getText();
+			const typeNode = param.type;
+			if (!typeNode) continue;
+			const type = this.checker.getTypeFromTypeNode(typeNode);
+			const depTokenId = this.getTypeId(type, className, paramName);
+			dependencies.push(depTokenId);
+		}
+		return dependencies;
+	}
+	/**
+	* Generates a unique Token ID for a given Type.
+	* Uses symbol name and file path hash for consistency.
+	*
+	* @param type - The TypeScript Type
+	* @param _className - Parent class name (for property tokens) - reserved for future use
+	* @param _paramName - Parameter name (for property tokens) - reserved for future use
+	* @returns A string identifier for the token
+	*/
+	getTypeId(type, _className, _paramName) {
+		const symbol = type.getSymbol();
+		if (!symbol) return this.checker.typeToString(type);
+		const name = symbol.getName();
+		if (name === "__type" || name === "InterfaceToken" || name === "__brand") return this.checker.typeToString(type);
+		const declarations = symbol.getDeclarations();
+		if (declarations && declarations.length > 0) return generateTokenId(symbol, declarations[0].getSourceFile());
+		return name;
+	}
+};
+
+//#endregion
+//#region src/analyzer/errors/ErrorFormatter.ts
+/**
+* Default error formatter with descriptive messages.
+*/
+var ErrorFormatter = class {
+	/**
+	* Finds the token property node within an injection object for better error positioning.
+	* Returns the entire property assignment (e.g., "token: UserService") not just the value,
+	* because the value might be an imported symbol whose AST node is in a different file.
+	*/
+	findTokenNode(injectionNode) {
+		if (!ts.isObjectLiteralExpression(injectionNode)) return null;
+		for (const prop of injectionNode.properties) if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "token") return prop;
+		return null;
+	}
+	formatDuplicateError(injection, source) {
+		let message;
+		if (source.type === "internal") message = `Duplicate registration: '${injection.tokenText}' is already registered.`;
+		else if (source.type === "parent") message = `Duplicate registration: '${injection.tokenText}' is already registered in parent container '${source.name}'.`;
+		else message = `Duplicate registration: '${injection.tokenText}' is already registered in partial '${source.name}'.`;
+		const errorNode = this.findTokenNode(injection.node) || injection.node;
+		return {
+			type: "duplicate",
+			message,
+			node: errorNode,
+			sourceFile: errorNode.getSourceFile(),
+			context: {
+				tokenText: injection.tokenText,
+				conflictSource: source.name
+			}
+		};
+	}
+	formatTypeMismatchError(injection, expectedType, actualType) {
+		const errorNode = this.findTokenNode(injection.node) || injection.node;
+		return {
+			type: "type-mismatch",
+			message: `Type mismatch: Provider '${actualType}' is not assignable to token type '${expectedType}'.`,
+			node: errorNode,
+			sourceFile: errorNode.getSourceFile(),
+			context: { tokenText: injection.tokenText }
+		};
+	}
+	formatCycleError(chain, node, sourceFile) {
+		return {
+			type: "cycle",
+			message: `Circular dependency detected: ${chain.join(" -> ")}`,
+			node,
+			sourceFile,
+			context: { chain }
+		};
+	}
+};
+
+//#endregion
+//#region src/analyzer/Analyzer.ts
+/**
+* Error thrown when a duplicate registration is detected.
+* Includes the position of the duplicate registration node.
+*/
+var DuplicateRegistrationError = class extends Error {
+	constructor(message, node, sourceFile) {
+		super(message);
+		this.node = node;
+		this.sourceFile = sourceFile;
+		this.name = "DuplicateRegistrationError";
+	}
+};
+/**
+* Error thrown when a provider type is incompatible with the token type.
+* Includes the position of the registration node.
+*/
+var TypeMismatchError = class extends Error {
+	constructor(message, node, sourceFile) {
+		super(message);
+		this.node = node;
+		this.sourceFile = sourceFile;
+		this.name = "TypeMismatchError";
+	}
+};
+/**
+* Generates a unique, deterministic Token ID for a symbol.
+* Uses the symbol name and a short hash of its relative file path.
+*/
+function generateTokenId(symbol, sourceFile) {
+	const name = symbol.getName();
+	let relativePath = path.relative(process.cwd(), sourceFile.fileName);
+	relativePath = relativePath.split(path.sep).join("/");
+	return `${name}_${crypto.createHash("md5").update(relativePath).digest("hex").substring(0, 8)}`;
+}
+/**
+* Analyzes TypeScript source code to extract the dependency injection graph.
+*
+* This class uses the TypeScript Compiler API to:
+* 1. Locate `createContainer` calls.
+* 2. Parse the fluent chain of `bind` and `register` calls.
+* 3. Resolve symbols and types for services and their dependencies.
+* 4. Build a `DependencyGraph` representing the system.
+*/
+var Analyzer = class {
+	program;
+	checker;
+	/** Set of variable names that are parent containers (should not be added to main graph) */
+	parentContainerNames = /* @__PURE__ */ new Set();
+	/**
+	* Creates a new Analyzer instance.
+	* @param program - The TypeScript Program instance containing the source files to analyze.
+	*/
+	constructor(program) {
+		this.program = program;
+		this.checker = program.getTypeChecker();
+	}
+	/**
+	* Extracts the dependency graph from the program's source files.
+	*
+	* It scans all non-declaration source files for container configurations.
+	* Each defineBuilderConfig gets its own isolated graph to avoid false positives.
+	*
+	* @returns A `DependencyGraph` containing all registered services and their dependencies.
+	*/
+	extract() {
+		const graph = {
+			containerId: "DefaultContainer",
+			nodes: /* @__PURE__ */ new Map(),
+			roots: [],
+			buildArguments: [],
+			errors: []
+		};
+		for (const sourceFile of this.program.getSourceFiles()) {
+			if (sourceFile.isDeclarationFile) continue;
+			this.identifyParentContainers(sourceFile);
+		}
+		for (const sourceFile of this.program.getSourceFiles()) {
+			if (sourceFile.isDeclarationFile) continue;
+			this.visitNode(sourceFile, graph);
+		}
+		this.resolveAllDependencies(graph);
+		return graph;
+	}
+	configCollector = null;
+	tokenResolver = null;
+	validator = null;
+	collectedConfigs = null;
+	collectionError = null;
+	/**
+	* Lazily initialize the modular components.
+	*/
+	initModularComponents() {
+		if (this.configCollector) return;
+		const errorFormatter = new ErrorFormatter();
+		const dependencyAnalyzer = new DependencyAnalyzer(this.checker);
+		this.configCollector = new ConfigCollector(this.program, this.checker);
+		this.tokenResolver = new TokenResolver();
+		this.validator = new CompositeValidator([
+			new DuplicateValidator(errorFormatter),
+			new TypeValidator(this.checker, errorFormatter),
+			new MissingDependencyValidator(errorFormatter, dependencyAnalyzer)
+		]);
+	}
+	/**
+	* Get collected configs (with caching).
+	*/
+	getCollectedConfigs() {
+		if (this.collectionError) throw this.collectionError;
+		if (!this.collectedConfigs) {
+			this.initModularComponents();
+			try {
+				this.collectedConfigs = this.configCollector.collect();
+			} catch (e) {
+				if (e instanceof Error) this.collectionError = e;
+				throw e;
+			}
+		}
+		return this.collectedConfigs;
+	}
+	/**
+	* Entry point for LSP - analyzes a specific file.
+	* Uses the modular architecture for isolated validation.
+	*
+	* @param fileName - The file to analyze
+	* @returns Analysis result with errors for this file only
+	*/
+	extractForFile(fileName) {
+		this.initModularComponents();
+		const allConfigs = this.getCollectedConfigs();
+		const errors = [];
+		const configsInFile = [...allConfigs.values()].filter((c) => c.sourceFile.fileName === fileName);
+		for (const config of configsInFile) {
+			const context = { allConfigs };
+			if (config.type === "builder") try {
+				context.inheritedTokens = this.tokenResolver.resolveInheritedTokens(config, allConfigs);
+			} catch (e) {
+				if (e instanceof CycleError) {
+					errors.push({
+						type: "cycle",
+						message: e.message,
+						node: config.node,
+						sourceFile: config.sourceFile,
+						context: { chain: e.chain }
+					});
+					continue;
+				}
+				throw e;
+			}
+			errors.push(...this.validator.validate(config, context));
+		}
+		return {
+			configs: allConfigs,
+			errors
+		};
+	}
+	/**
+	* First pass: identify containers used as parents so we can skip them in visitNode.
+	*/
+	identifyParentContainers(node) {
+		if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name) && node.name.text === "useContainer" && ts.isIdentifier(node.initializer)) this.parentContainerNames.add(node.initializer.text);
+		ts.forEachChild(node, (child) => this.identifyParentContainers(child));
+	}
+	/**
+	* Visits an AST node to find container calls.
+	* @param node - The AST node to visit.
+	* @param graph - The graph to populate.
+	*/
+	visitNode(node, graph) {
+		if (ts.isCallExpression(node)) {
+			if (this.isDefineBuilderConfigCall(node)) {
+				const parent = node.parent;
+				if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+					if (this.parentContainerNames.has(parent.name.text)) return;
+					graph.exportedVariableName = parent.name.text;
+					let current = parent;
+					while (current && !ts.isVariableStatement(current)) current = current.parent;
+					if (current && ts.isVariableStatement(current)) {
+						graph.variableStatementStart = current.getStart();
+						const modifiers = ts.canHaveModifiers(current) ? ts.getModifiers(current) : void 0;
+						if (modifiers) {
+							const hasExport = modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+							const hasDefault = modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+							if (hasExport && hasDefault) graph.variableExportModifier = "export default";
+							else if (hasExport) graph.variableExportModifier = "export";
+							else graph.variableExportModifier = "none";
+						} else graph.variableExportModifier = "none";
+					}
+				} else if (ts.isExportAssignment(parent) && parent.isExportEquals === false) {
+					graph.variableExportModifier = "export default";
+					graph.variableStatementStart = parent.getStart();
+				}
+				graph.defineBuilderConfigStart = node.getStart();
+				graph.defineBuilderConfigEnd = node.getEnd();
+				this.parseBuilderConfig(node, graph);
+			} else if (this.isDefinePartialConfigCall(node)) {
+				const parent = node.parent;
+				if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+					const partialName = parent.name.text;
+					if (!this.isPartialUsedInExtends(partialName)) {
+						const partialGraph = {
+							containerId: partialName,
+							nodes: /* @__PURE__ */ new Map(),
+							roots: [],
+							errors: []
+						};
+						this.parseBuilderConfig(node, partialGraph);
+						if (partialGraph.errors && partialGraph.errors.length > 0) {
+							if (!graph.errors) graph.errors = [];
+							graph.errors.push(...partialGraph.errors);
+						}
+					}
+				}
+			}
+		}
+		ts.forEachChild(node, (child) => this.visitNode(child, graph));
+	}
+	/**
+	* Check if a partial config is used in any extends array.
+	*/
+	partialNamesUsedInExtends = null;
+	isPartialUsedInExtends(partialName) {
+		if (this.partialNamesUsedInExtends === null) {
+			this.partialNamesUsedInExtends = /* @__PURE__ */ new Set();
+			for (const sourceFile of this.program.getSourceFiles()) {
+				if (sourceFile.isDeclarationFile) continue;
+				this.collectPartialsInExtends(sourceFile);
+			}
+		}
+		return this.partialNamesUsedInExtends.has(partialName);
+	}
+	collectPartialsInExtends(node) {
+		if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name) && node.name.text === "extends" && ts.isArrayLiteralExpression(node.initializer)) {
+			for (const element of node.initializer.elements) if (ts.isIdentifier(element)) this.partialNamesUsedInExtends.add(element.text);
+		}
+		ts.forEachChild(node, (child) => this.collectPartialsInExtends(child));
+	}
+	isDefineBuilderConfigCall(node) {
+		const expression = node.expression;
+		if (ts.isIdentifier(expression)) return expression.text === "defineBuilderConfig";
+		return false;
+	}
+	parseBuilderConfig(node, graph) {
+		const args = node.arguments;
+		if (args.length < 1) return;
+		const configObj = args[0];
+		if (!ts.isObjectLiteralExpression(configObj)) return;
+		const nameProp = configObj.properties.find((p) => p.name && ts.isIdentifier(p.name) && p.name.text === "name");
+		if (nameProp && ts.isPropertyAssignment(nameProp) && ts.isStringLiteral(nameProp.initializer)) {
+			graph.containerName = nameProp.initializer.text;
+			graph.containerId = nameProp.initializer.text;
+		} else graph.containerId = this.generateHashBasedContainerId(node);
+		const injectionsProp = configObj.properties.find((p) => p.name && ts.isIdentifier(p.name) && p.name.text === "injections");
+		if (injectionsProp && ts.isPropertyAssignment(injectionsProp) && ts.isArrayLiteralExpression(injectionsProp.initializer)) this.parseInjectionsArray(injectionsProp.initializer, graph);
+		const extendsProp = configObj.properties.find((p) => p.name && ts.isIdentifier(p.name) && p.name.text === "extends");
+		if (extendsProp && ts.isPropertyAssignment(extendsProp) && ts.isArrayLiteralExpression(extendsProp.initializer)) this.parseExtendsArray(extendsProp.initializer, graph);
+		const useContainerProp = configObj.properties.find((p) => p.name && ts.isIdentifier(p.name) && p.name.text === "useContainer");
+		if (useContainerProp && ts.isPropertyAssignment(useContainerProp)) {
+			if (!graph.legacyContainers) graph.legacyContainers = [];
+			if (!graph.parentProvidedTokens) graph.parentProvidedTokens = /* @__PURE__ */ new Set();
+			const containerExpr = useContainerProp.initializer;
+			if (ts.isIdentifier(containerExpr)) {
+				graph.legacyContainers.push(containerExpr.text);
+				this.extractParentContainerTokens(containerExpr, graph);
+			}
+		}
+	}
+	/**
+	* Extracts tokens provided by a parent container.
+	* Handles both NeoSyringe containers (defineBuilderConfig) and
+	* declared legacy containers (declareContainerTokens).
+	*/
+	extractParentContainerTokens(containerIdentifier, graph) {
+		const symbol = this.checker.getSymbolAtLocation(containerIdentifier);
+		if (!symbol) return;
+		this.parentContainerNames.add(containerIdentifier.text);
+		const resolvedSymbol = this.resolveSymbol(symbol);
+		const declaration = resolvedSymbol.valueDeclaration ?? resolvedSymbol.declarations?.[0];
+		if (!declaration) return;
+		if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+			const init = declaration.initializer;
+			if (ts.isCallExpression(init)) {
+				if (this.isDefineBuilderConfigCall(init) || this.isDefinePartialConfigCall(init)) {
+					const parentGraph = {
+						containerId: containerIdentifier.text,
+						nodes: /* @__PURE__ */ new Map(),
+						roots: []
+					};
+					this.parseBuilderConfig(init, parentGraph);
+					for (const tokenId of parentGraph.nodes.keys()) graph.parentProvidedTokens.add(tokenId);
+					if (parentGraph.parentProvidedTokens) for (const tokenId of parentGraph.parentProvidedTokens) graph.parentProvidedTokens.add(tokenId);
+					return;
+				}
+				if (this.isDeclareContainerTokensCall(init)) {
+					this.extractDeclaredTokens(init, graph);
+					return;
+				}
+			}
+		}
+	}
+	/**
+	* Checks if a call expression is declareContainerTokens<T>().
+	*/
+	isDeclareContainerTokensCall(node) {
+		if (ts.isIdentifier(node.expression)) return node.expression.text === "declareContainerTokens";
+		return false;
+	}
+	/**
+	* Extracts tokens from declareContainerTokens<{ Token: Type }>().
+	* The type argument contains the token names.
+	*/
+	extractDeclaredTokens(node, graph) {
+		if (!node.typeArguments || node.typeArguments.length === 0) return;
+		const typeArg = node.typeArguments[0];
+		const properties = this.checker.getTypeFromTypeNode(typeArg).getProperties();
+		for (const prop of properties) {
+			const propType = this.checker.getTypeOfSymbol(prop);
+			if (propType) {
+				const tokenId = this.getTypeId(propType);
+				graph.parentProvidedTokens.add(tokenId);
+			} else graph.parentProvidedTokens.add(prop.getName());
+		}
+	}
+	parseExtendsArray(arrayLiteral, graph) {
+		for (const element of arrayLiteral.elements) if (ts.isIdentifier(element)) this.parsePartialConfig(element, graph);
+	}
+	parsePartialConfig(identifier, graph) {
+		const symbol = this.checker.getSymbolAtLocation(identifier);
+		if (!symbol) return;
+		const resolvedSymbol = this.resolveSymbol(symbol);
+		const declaration = resolvedSymbol.valueDeclaration ?? resolvedSymbol.declarations?.[0];
+		if (!declaration) return;
+		if (ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isCallExpression(declaration.initializer)) {
+			const callExpr = declaration.initializer;
+			if (this.isDefinePartialConfigCall(callExpr)) this.parseBuilderConfig(callExpr, graph);
+		}
+		if (ts.isExportSpecifier(declaration)) {}
+	}
+	isDefinePartialConfigCall(node) {
+		const expression = node.expression;
+		if (ts.isIdentifier(expression)) return expression.text === "definePartialConfig";
+		return false;
+	}
+	parseInjectionsArray(arrayLiteral, graph) {
+		for (const element of arrayLiteral.elements) if (ts.isObjectLiteralExpression(element)) this.parseInjectionObject(element, graph);
+	}
+	parseInjectionObject(obj, graph) {
+		let tokenNode;
+		let providerNode;
+		let lifecycle = "singleton";
+		let useFactory = false;
+		let isScoped = false;
+		for (const prop of obj.properties) {
+			if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+			if (prop.name.text === "token") tokenNode = prop.initializer;
+			else if (prop.name.text === "provider") providerNode = prop.initializer;
+			else if (prop.name.text === "lifecycle" && ts.isStringLiteral(prop.initializer)) {
+				if (prop.initializer.text === "transient") lifecycle = "transient";
+			} else if (prop.name.text === "useFactory") {
+				if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) useFactory = true;
+			} else if (prop.name.text === "scoped") {
+				if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) isScoped = true;
+			}
+		}
+		if (!tokenNode) return;
+		if (providerNode && (ts.isArrowFunction(providerNode) || ts.isFunctionExpression(providerNode))) useFactory = true;
+		let tokenId;
+		let implementationSymbol;
+		let tokenSymbol;
+		let type = "autowire";
+		let isInterfaceToken = false;
+		let isValueToken = false;
+		let factorySource;
+		let resolvedTokenNode = tokenNode;
+		const resolved = this.resolveToInitializer(tokenNode);
+		if (resolved) resolvedTokenNode = resolved;
+		if (ts.isCallExpression(resolvedTokenNode) && this.isUseInterfaceCall(resolvedTokenNode)) {
+			tokenId = this.extractInterfaceTokenId(resolvedTokenNode);
+			type = "explicit";
+			isInterfaceToken = true;
+		} else if (ts.isCallExpression(resolvedTokenNode) && this.isUsePropertyCall(resolvedTokenNode)) {
+			const propertyInfo = this.extractPropertyTokenId(resolvedTokenNode);
+			tokenId = propertyInfo.tokenId;
+			type = "explicit";
+			isValueToken = true;
+			if (!providerNode) throw new Error(`useProperty(${propertyInfo.className}, '${propertyInfo.paramName}') requires a provider (factory).`);
+			useFactory = true;
+		} else {
+			const tokenType = this.checker.getTypeAtLocation(tokenNode);
+			tokenId = this.getTypeIdFromConstructor(tokenType);
+			if (ts.isIdentifier(tokenNode)) tokenSymbol = this.checker.getSymbolAtLocation(tokenNode);
+		}
+		if (useFactory && providerNode) {
+			factorySource = providerNode.getText();
+			type = "factory";
+			if (tokenId) {
+				if (graph.nodes.has(tokenId) && !isScoped) {
+					const sourceFile = obj.getSourceFile();
+					const tokenText = tokenNode.getText(sourceFile);
+					if (!graph.errors) graph.errors = [];
+					graph.errors.push({
+						type: "duplicate",
+						message: `Duplicate registration: '${tokenText}' is already registered.`,
+						node: obj,
+						sourceFile
+					});
+					return;
+				}
+				const definition = {
+					tokenId,
+					tokenSymbol: tokenSymbol ? this.resolveSymbol(tokenSymbol) : void 0,
+					registrationNode: obj,
+					type: "factory",
+					lifecycle,
+					isInterfaceToken,
+					isValueToken,
+					isFactory: true,
+					factorySource,
+					isScoped
+				};
+				graph.nodes.set(tokenId, {
+					service: definition,
+					dependencies: []
+				});
+			}
+			return;
+		}
+		if (providerNode) {
+			implementationSymbol = this.checker.getSymbolAtLocation(providerNode);
+			type = "explicit";
+		} else if (type === "explicit" && !providerNode) {
+			if (ts.isIdentifier(tokenNode)) {
+				implementationSymbol = this.checker.getSymbolAtLocation(tokenNode);
+				type = "autowire";
+			}
+		} else if (ts.isIdentifier(tokenNode)) {
+			implementationSymbol = this.checker.getSymbolAtLocation(tokenNode);
+			type = "autowire";
+		}
+		if (tokenId && implementationSymbol) {
+			if (graph.nodes.has(tokenId) && !isScoped) {
+				const sourceFile = obj.getSourceFile();
+				const tokenText = tokenNode.getText(sourceFile);
+				if (!graph.errors) graph.errors = [];
+				graph.errors.push({
+					type: "duplicate",
+					message: `Duplicate registration: '${tokenText}' is already registered.`,
+					node: obj,
+					sourceFile
+				});
+				return;
+			}
+			if (type === "explicit" && isInterfaceToken && providerNode) this.validateTypeCompatibility(tokenNode, providerNode, obj, graph);
+			const definition = {
+				tokenId,
+				implementationSymbol: this.resolveSymbol(implementationSymbol),
+				tokenSymbol: tokenSymbol ? this.resolveSymbol(tokenSymbol) : void 0,
+				registrationNode: obj,
+				type,
+				lifecycle,
+				isInterfaceToken: isInterfaceToken || ts.isCallExpression(tokenNode) && this.isUseInterfaceCall(tokenNode),
+				isScoped
+			};
+			graph.nodes.set(tokenId, {
+				service: definition,
+				dependencies: []
+			});
+		}
+	}
+	isUseInterfaceCall(node) {
+		if (ts.isIdentifier(node.expression)) return node.expression.text === "useInterface";
+		return false;
+	}
+	isUsePropertyCall(node) {
+		if (ts.isIdentifier(node.expression)) return node.expression.text === "useProperty";
+		return false;
+	}
+	/**
+	* Resolves a node to its original initializer expression.
+	* Handles identifiers, property access, imports, and unwraps type assertions/casts.
+	*/
+	resolveToInitializer(node) {
+		let expr = node;
+		while (ts.isParenthesizedExpression(expr) || ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr) || ts.isSatisfiesExpression && ts.isSatisfiesExpression(expr)) expr = expr.expression;
+		if (ts.isCallExpression(expr)) return expr;
+		if (ts.isIdentifier(expr)) return this.resolveIdentifierToInitializer(expr);
+		if (ts.isPropertyAccessExpression(expr)) return this.resolvePropertyAccessToInitializer(expr);
+	}
+	resolveIdentifierToInitializer(identifier) {
+		const symbol = this.checker.getSymbolAtLocation(identifier);
+		if (!symbol) return void 0;
+		const declarations = this.resolveSymbol(symbol).getDeclarations();
+		if (!declarations || declarations.length === 0) return void 0;
+		for (const decl of declarations) if (ts.isVariableDeclaration(decl) && decl.initializer) return this.resolveToInitializer(decl.initializer) ?? decl.initializer;
+	}
+	resolvePropertyAccessToInitializer(node) {
+		const objectInitializer = this.resolveToInitializer(node.expression);
+		if (objectInitializer && ts.isObjectLiteralExpression(objectInitializer)) {
+			const propName = node.name.text;
+			const prop = objectInitializer.properties.find((p) => p.name && ts.isIdentifier(p.name) && p.name.text === propName);
+			if (prop && ts.isPropertyAssignment(prop)) return this.resolveToInitializer(prop.initializer) ?? prop.initializer;
+		}
+	}
+	/**
+	* Validates that the provider type is compatible with the token type.
+	* @param tokenNode - The token node (e.g., useInterface<ILogger>())
+	* @param providerNode - The provider node (e.g., ConsoleLogger)
+	* @param registrationNode - The full registration object for error reporting
+	* @param graph - The dependency graph to collect errors
+	*/
+	validateTypeCompatibility(tokenNode, providerNode, registrationNode, graph) {
+		let tokenType;
+		let resolvedTokenNode = tokenNode;
+		if (ts.isExpression(tokenNode)) {
+			const resolved = this.resolveToInitializer(tokenNode);
+			if (resolved) resolvedTokenNode = resolved;
+		}
+		if (ts.isCallExpression(resolvedTokenNode) && this.isUseInterfaceCall(resolvedTokenNode)) {
+			const typeArgs = resolvedTokenNode.typeArguments;
+			if (typeArgs && typeArgs.length > 0) tokenType = this.checker.getTypeFromTypeNode(typeArgs[0]);
+		}
+		if (!tokenType) return;
+		const providerType = this.checker.getTypeAtLocation(providerNode);
+		let providerInstanceType;
+		const constructSignatures = providerType.getConstructSignatures();
+		if (constructSignatures.length > 0) providerInstanceType = constructSignatures[0].getReturnType();
+		else providerInstanceType = providerType;
+		if (!providerInstanceType) return;
+		if (!this.checker.isTypeAssignableTo(providerInstanceType, tokenType)) {
+			const sourceFile = registrationNode.getSourceFile();
+			const tokenTypeName = this.checker.typeToString(tokenType);
+			const providerTypeName = this.checker.typeToString(providerInstanceType);
+			if (!graph.errors) graph.errors = [];
+			graph.errors.push({
+				type: "type-mismatch",
+				message: `Type mismatch: Provider '${providerTypeName}' is not assignable to token type '${tokenTypeName}'.`,
+				node: registrationNode,
+				sourceFile
+			});
+		}
+	}
+	extractPropertyTokenId(node) {
+		if (node.arguments.length < 2) throw new Error("useProperty requires two arguments: (Class, paramName)");
+		const classArg = node.arguments[0];
+		const nameArg = node.arguments[1];
+		if (!ts.isIdentifier(classArg)) throw new Error("useProperty first argument must be a class identifier.");
+		if (!ts.isStringLiteral(nameArg)) throw new Error("useProperty second argument must be a string literal.");
+		const className = classArg.text;
+		const paramName = nameArg.text;
+		return {
+			tokenId: `PropertyToken:${className}.${paramName}`,
+			className,
+			paramName
+		};
+	}
+	extractInterfaceTokenId(node) {
+		if (!node.typeArguments || node.typeArguments.length === 0) throw new Error("useInterface must have a type argument.");
+		const typeNode = node.typeArguments[0];
+		const symbol = this.checker.getTypeFromTypeNode(typeNode).getSymbol();
+		if (!symbol) return "AnonymousInterface";
+		const declarations = symbol.getDeclarations();
+		if (declarations && declarations.length > 0) return generateTokenId(symbol, declarations[0].getSourceFile());
+		return symbol.getName();
+	}
+	getTypeIdFromConstructor(type) {
+		const constructSignatures = type.getConstructSignatures();
+		let instanceType;
+		if (constructSignatures.length > 0) instanceType = constructSignatures[0].getReturnType();
+		else instanceType = type;
+		return this.getTypeId(instanceType);
+	}
+	extractScope(optionsNode) {
+		for (const prop of optionsNode.properties) if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "scope" && ts.isStringLiteral(prop.initializer)) {
+			if (prop.initializer.text === "transient") return "transient";
+		}
+		return "singleton";
+	}
+	/**
+	* Resolves dependencies for all nodes in the graph.
+	* @param graph - The dependency graph.
+	*/
+	resolveAllDependencies(graph) {
+		for (const node of graph.nodes.values()) this.resolveDependencies(node, graph);
+	}
+	/**
+	* Resolves dependencies for a single service node by inspecting its constructor.
+	* @param node - The dependency node to resolve.
+	*/
+	resolveDependencies(node, graph) {
+		if (node.service.isFactory || node.service.type === "factory") return;
+		const symbol = node.service.implementationSymbol;
+		if (!symbol) return;
+		const declarations = symbol.getDeclarations();
+		if (!declarations || declarations.length === 0) return;
+		const classDecl = declarations.find((d) => ts.isClassDeclaration(d));
+		if (!classDecl) return;
+		const className = classDecl.name?.getText() ?? "Anonymous";
+		const constructor = classDecl.members.find((m) => ts.isConstructorDeclaration(m));
+		if (!constructor) return;
+		for (const param of constructor.parameters) {
+			const paramName = param.name.getText();
+			const typeNode = param.type;
+			if (!typeNode) continue;
+			const type = this.checker.getTypeFromTypeNode(typeNode);
+			const propertyTokenId = `PropertyToken:${className}.${paramName}`;
+			if (graph.nodes.has(propertyTokenId)) {
+				node.dependencies.push(propertyTokenId);
+				continue;
+			}
+			const depTokenId = this.getTypeId(type);
+			node.dependencies.push(depTokenId);
+		}
+	}
+	/**
+	* Generates a unique Token ID for a given Type.
+	* Uses file path hash + name for consistency and collision avoidance.
+	*
+	* @param type - The TypeScript Type.
+	* @returns A string identifier for the token.
+	*/
+	getTypeId(type) {
+		const symbol = type.getSymbol();
+		if (!symbol) return this.checker.typeToString(type);
+		const name = symbol.getName();
+		if (name === "__type" || name === "InterfaceToken" || name === "__brand") return this.checker.typeToString(type);
+		const declarations = symbol.getDeclarations();
+		if (declarations && declarations.length > 0) return generateTokenId(symbol, declarations[0].getSourceFile());
+		return symbol.getName();
+	}
+	/**
+	* Resolves a symbol, following aliases if necessary.
+	* @param symbol - The symbol to resolve.
+	* @returns The resolved symbol.
+	*/
+	resolveSymbol(symbol) {
+		if (symbol.flags & ts.SymbolFlags.Alias) return this.resolveSymbol(this.checker.getAliasedSymbol(symbol));
+		return symbol;
+	}
+	/**
+	* Generates a hash-based container ID when no 'name' field is provided.
+	* @param node - The defineBuilderConfig call expression
+	* @returns A unique container ID like "Container_a1b2c3d4"
+	*/
+	generateHashBasedContainerId(node) {
+		const sourceFile = node.getSourceFile();
+		const hashInput = `${path.basename(sourceFile.fileName, ".ts")}:${node.getStart()}:${node.getText()}`;
+		let hash = 0;
+		for (let i = 0; i < hashInput.length; i++) {
+			const char = hashInput.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return `Container_${Math.abs(hash).toString(16).substring(0, 8)}`;
+	}
+};
+
+//#endregion
+export { ErrorFormatter as a, TypeValidator as c, TokenResolver as d, CycleError as f, generateTokenId as i, DuplicateValidator as l, DuplicateRegistrationError as n, DependencyAnalyzer as o, ConfigCollector as p, TypeMismatchError as r, MissingDependencyValidator as s, Analyzer as t, CompositeValidator as u };