@djodjonx/neosyringe-core 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @djodjonx/neosyringe-core
+
+The core analysis and generation engine for NeoSyringe. Used by the CLI and Plugin.
+
+Not intended for direct use. See [Documentation](https://djodjonx.github.io/neosyringe/).

package/dist/analyzer/index.cjs

@@ -0,0 +1,462 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let typescript = require("typescript");
+typescript = __toESM(typescript);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+
+//#region src/analyzer/Analyzer.ts
+/**
+* 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 = node_path.relative(process.cwd(), sourceFile.fileName);
+	relativePath = relativePath.split(node_path.sep).join("/");
+	return `${name}_${node_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.
+	*
+	* @returns A `DependencyGraph` containing all registered services and their dependencies.
+	*/
+	extract() {
+		const graph = {
+			nodes: /* @__PURE__ */ new Map(),
+			roots: [],
+			buildArguments: []
+		};
+		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;
+	}
+	/**
+	* First pass: identify containers used as parents so we can skip them in visitNode.
+	*/
+	identifyParentContainers(node) {
+		if (typescript.isPropertyAssignment(node) && typescript.isIdentifier(node.name) && node.name.text === "useContainer" && typescript.isIdentifier(node.initializer)) this.parentContainerNames.add(node.initializer.text);
+		typescript.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 (typescript.isCallExpression(node)) {
+			if (this.isDefineBuilderConfigCall(node)) {
+				const parent = node.parent;
+				if (typescript.isVariableDeclaration(parent) && typescript.isIdentifier(parent.name)) {
+					if (this.parentContainerNames.has(parent.name.text)) return;
+					graph.exportedVariableName = parent.name.text;
+					let current = parent;
+					while (current && !typescript.isVariableStatement(current)) current = current.parent;
+					if (current && typescript.isVariableStatement(current)) graph.variableStatementStart = current.getStart();
+				}
+				graph.defineBuilderConfigStart = node.getStart();
+				graph.defineBuilderConfigEnd = node.getEnd();
+				this.parseBuilderConfig(node, graph);
+			}
+		}
+		typescript.forEachChild(node, (child) => this.visitNode(child, graph));
+	}
+	isDefineBuilderConfigCall(node) {
+		const expression = node.expression;
+		if (typescript.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 (!typescript.isObjectLiteralExpression(configObj)) return;
+		const nameProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "name");
+		if (nameProp && typescript.isPropertyAssignment(nameProp) && typescript.isStringLiteral(nameProp.initializer)) graph.containerName = nameProp.initializer.text;
+		const injectionsProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "injections");
+		if (injectionsProp && typescript.isPropertyAssignment(injectionsProp) && typescript.isArrayLiteralExpression(injectionsProp.initializer)) this.parseInjectionsArray(injectionsProp.initializer, graph);
+		const extendsProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "extends");
+		if (extendsProp && typescript.isPropertyAssignment(extendsProp) && typescript.isArrayLiteralExpression(extendsProp.initializer)) this.parseExtendsArray(extendsProp.initializer, graph);
+		const useContainerProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "useContainer");
+		if (useContainerProp && typescript.isPropertyAssignment(useContainerProp)) {
+			if (!graph.legacyContainers) graph.legacyContainers = [];
+			if (!graph.parentProvidedTokens) graph.parentProvidedTokens = /* @__PURE__ */ new Set();
+			const containerExpr = useContainerProp.initializer;
+			if (typescript.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 (typescript.isVariableDeclaration(declaration) && declaration.initializer) {
+			const init = declaration.initializer;
+			if (typescript.isCallExpression(init)) {
+				if (this.isDefineBuilderConfigCall(init) || this.isDefinePartialConfigCall(init)) {
+					const parentGraph = {
+						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 (typescript.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 (typescript.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 (typescript.isVariableDeclaration(declaration) && declaration.initializer && typescript.isCallExpression(declaration.initializer)) {
+			const callExpr = declaration.initializer;
+			if (this.isDefinePartialConfigCall(callExpr)) this.parseBuilderConfig(callExpr, graph);
+		}
+		if (typescript.isExportSpecifier(declaration)) {}
+	}
+	isDefinePartialConfigCall(node) {
+		const expression = node.expression;
+		if (typescript.isIdentifier(expression)) return expression.text === "definePartialConfig";
+		return false;
+	}
+	parseInjectionsArray(arrayLiteral, graph) {
+		for (const element of arrayLiteral.elements) if (typescript.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 (!typescript.isPropertyAssignment(prop) || !typescript.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" && typescript.isStringLiteral(prop.initializer)) {
+				if (prop.initializer.text === "transient") lifecycle = "transient";
+			} else if (prop.name.text === "useFactory") {
+				if (prop.initializer.kind === typescript.SyntaxKind.TrueKeyword) useFactory = true;
+			} else if (prop.name.text === "scoped") {
+				if (prop.initializer.kind === typescript.SyntaxKind.TrueKeyword) isScoped = true;
+			}
+		}
+		if (!tokenNode) return;
+		if (providerNode && (typescript.isArrowFunction(providerNode) || typescript.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 (typescript.isCallExpression(resolvedTokenNode) && this.isUseInterfaceCall(resolvedTokenNode)) {
+			tokenId = this.extractInterfaceTokenId(resolvedTokenNode);
+			type = "explicit";
+			isInterfaceToken = true;
+		} else if (typescript.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 (typescript.isIdentifier(tokenNode)) tokenSymbol = this.checker.getSymbolAtLocation(tokenNode);
+		}
+		if (useFactory && providerNode) {
+			factorySource = providerNode.getText();
+			type = "factory";
+			if (tokenId) {
+				if (graph.nodes.has(tokenId) && !isScoped) throw new Error(`Duplicate registration: '${tokenId}' is already registered.`);
+				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 (typescript.isIdentifier(tokenNode)) {
+				implementationSymbol = this.checker.getSymbolAtLocation(tokenNode);
+				type = "autowire";
+			}
+		} else if (typescript.isIdentifier(tokenNode)) {
+			implementationSymbol = this.checker.getSymbolAtLocation(tokenNode);
+			type = "autowire";
+		}
+		if (tokenId && implementationSymbol) {
+			if (graph.nodes.has(tokenId) && !isScoped) throw new Error(`Duplicate registration: '${tokenId}' is already registered.`);
+			const definition = {
+				tokenId,
+				implementationSymbol: this.resolveSymbol(implementationSymbol),
+				tokenSymbol: tokenSymbol ? this.resolveSymbol(tokenSymbol) : void 0,
+				registrationNode: obj,
+				type,
+				lifecycle,
+				isInterfaceToken: isInterfaceToken || typescript.isCallExpression(tokenNode) && this.isUseInterfaceCall(tokenNode),
+				isScoped
+			};
+			graph.nodes.set(tokenId, {
+				service: definition,
+				dependencies: []
+			});
+		}
+	}
+	isUseInterfaceCall(node) {
+		if (typescript.isIdentifier(node.expression)) return node.expression.text === "useInterface";
+		return false;
+	}
+	isUsePropertyCall(node) {
+		if (typescript.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 (typescript.isParenthesizedExpression(expr) || typescript.isAsExpression(expr) || typescript.isTypeAssertionExpression(expr) || typescript.isSatisfiesExpression && typescript.isSatisfiesExpression(expr)) expr = expr.expression;
+		if (typescript.isCallExpression(expr)) return expr;
+		if (typescript.isIdentifier(expr)) return this.resolveIdentifierToInitializer(expr);
+		if (typescript.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 (typescript.isVariableDeclaration(decl) && decl.initializer) return this.resolveToInitializer(decl.initializer) ?? decl.initializer;
+	}
+	resolvePropertyAccessToInitializer(node) {
+		const objectInitializer = this.resolveToInitializer(node.expression);
+		if (objectInitializer && typescript.isObjectLiteralExpression(objectInitializer)) {
+			const propName = node.name.text;
+			const prop = objectInitializer.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === propName);
+			if (prop && typescript.isPropertyAssignment(prop)) return this.resolveToInitializer(prop.initializer) ?? prop.initializer;
+		}
+	}
+	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 (!typescript.isIdentifier(classArg)) throw new Error("useProperty first argument must be a class identifier.");
+		if (!typescript.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 (typescript.isPropertyAssignment(prop) && typescript.isIdentifier(prop.name) && prop.name.text === "scope" && typescript.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) => typescript.isClassDeclaration(d));
+		if (!classDecl) return;
+		const className = classDecl.name?.getText() ?? "Anonymous";
+		const constructor = classDecl.members.find((m) => typescript.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 & typescript.SymbolFlags.Alias) return this.resolveSymbol(this.checker.getAliasedSymbol(symbol));
+		return symbol;
+	}
+};
+
+//#endregion
+exports.Analyzer = Analyzer;
+exports.generateTokenId = generateTokenId;

package/dist/analyzer/index.d.cts

@@ -0,0 +1,108 @@
+import { a as TokenId, i as ServiceDefinition, n as DependencyNode, r as RegistrationType, t as DependencyGraph } from "../types-DeLOEpiR.cjs";
+import * as ts from "typescript";
+
+//#region src/analyzer/Analyzer.d.ts
+/**
+ * Generates a unique, deterministic Token ID for a symbol.
+ * Uses the symbol name and a short hash of its relative file path.
+ */
+declare function generateTokenId(symbol: ts.Symbol, sourceFile: ts.SourceFile): string;
+/**
+ * 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.
+ */
+declare class Analyzer {
+  private program;
+  private checker;
+  /** Set of variable names that are parent containers (should not be added to main graph) */
+  private parentContainerNames;
+  /**
+       * Creates a new Analyzer instance.
+       * @param program - The TypeScript Program instance containing the source files to analyze.
+       */
+  constructor(program: ts.Program);
+  /**
+       * Extracts the dependency graph from the program's source files.
+       *
+       * It scans all non-declaration source files for container configurations.
+       *
+       * @returns A `DependencyGraph` containing all registered services and their dependencies.
+       */
+  extract(): DependencyGraph;
+  /**
+       * First pass: identify containers used as parents so we can skip them in visitNode.
+       */
+  private identifyParentContainers;
+  /**
+       * Visits an AST node to find container calls.
+       * @param node - The AST node to visit.
+       * @param graph - The graph to populate.
+       */
+  private visitNode;
+  private isDefineBuilderConfigCall;
+  private parseBuilderConfig;
+  /**
+       * Extracts tokens provided by a parent container.
+       * Handles both NeoSyringe containers (defineBuilderConfig) and
+       * declared legacy containers (declareContainerTokens).
+       */
+  private extractParentContainerTokens;
+  /**
+       * Checks if a call expression is declareContainerTokens<T>().
+       */
+  private isDeclareContainerTokensCall;
+  /**
+       * Extracts tokens from declareContainerTokens<{ Token: Type }>().
+       * The type argument contains the token names.
+       */
+  private extractDeclaredTokens;
+  private parseExtendsArray;
+  private parsePartialConfig;
+  private isDefinePartialConfigCall;
+  private parseInjectionsArray;
+  private parseInjectionObject;
+  private isUseInterfaceCall;
+  private isUsePropertyCall;
+  /**
+       * Resolves a node to its original initializer expression.
+       * Handles identifiers, property access, imports, and unwraps type assertions/casts.
+       */
+  private resolveToInitializer;
+  private resolveIdentifierToInitializer;
+  private resolvePropertyAccessToInitializer;
+  private extractPropertyTokenId;
+  private extractInterfaceTokenId;
+  private getTypeIdFromConstructor;
+  private extractScope;
+  /**
+       * Resolves dependencies for all nodes in the graph.
+       * @param graph - The dependency graph.
+       */
+  private resolveAllDependencies;
+  /**
+       * Resolves dependencies for a single service node by inspecting its constructor.
+       * @param node - The dependency node to resolve.
+       */
+  private resolveDependencies;
+  /**
+       * 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.
+       */
+  private getTypeId;
+  /**
+       * Resolves a symbol, following aliases if necessary.
+       * @param symbol - The symbol to resolve.
+       * @returns The resolved symbol.
+       */
+  private resolveSymbol;
+}
+//#endregion
+export { Analyzer, DependencyGraph, DependencyNode, RegistrationType, ServiceDefinition, TokenId, generateTokenId };

package/dist/analyzer/index.d.mts

@@ -0,0 +1,108 @@
+import { a as TokenId, i as ServiceDefinition, n as DependencyNode, r as RegistrationType, t as DependencyGraph } from "../types-EnrcFw9C.mjs";
+import * as ts from "typescript";
+
+//#region src/analyzer/Analyzer.d.ts
+/**
+ * Generates a unique, deterministic Token ID for a symbol.
+ * Uses the symbol name and a short hash of its relative file path.
+ */
+declare function generateTokenId(symbol: ts.Symbol, sourceFile: ts.SourceFile): string;
+/**
+ * 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.
+ */
+declare class Analyzer {
+  private program;
+  private checker;
+  /** Set of variable names that are parent containers (should not be added to main graph) */
+  private parentContainerNames;
+  /**
+       * Creates a new Analyzer instance.
+       * @param program - The TypeScript Program instance containing the source files to analyze.
+       */
+  constructor(program: ts.Program);
+  /**
+       * Extracts the dependency graph from the program's source files.
+       *
+       * It scans all non-declaration source files for container configurations.
+       *
+       * @returns A `DependencyGraph` containing all registered services and their dependencies.
+       */
+  extract(): DependencyGraph;
+  /**
+       * First pass: identify containers used as parents so we can skip them in visitNode.
+       */
+  private identifyParentContainers;
+  /**
+       * Visits an AST node to find container calls.
+       * @param node - The AST node to visit.
+       * @param graph - The graph to populate.
+       */
+  private visitNode;
+  private isDefineBuilderConfigCall;
+  private parseBuilderConfig;
+  /**
+       * Extracts tokens provided by a parent container.
+       * Handles both NeoSyringe containers (defineBuilderConfig) and
+       * declared legacy containers (declareContainerTokens).
+       */
+  private extractParentContainerTokens;
+  /**
+       * Checks if a call expression is declareContainerTokens<T>().
+       */
+  private isDeclareContainerTokensCall;
+  /**
+       * Extracts tokens from declareContainerTokens<{ Token: Type }>().
+       * The type argument contains the token names.
+       */
+  private extractDeclaredTokens;
+  private parseExtendsArray;
+  private parsePartialConfig;
+  private isDefinePartialConfigCall;
+  private parseInjectionsArray;
+  private parseInjectionObject;
+  private isUseInterfaceCall;
+  private isUsePropertyCall;
+  /**
+       * Resolves a node to its original initializer expression.
+       * Handles identifiers, property access, imports, and unwraps type assertions/casts.
+       */
+  private resolveToInitializer;
+  private resolveIdentifierToInitializer;
+  private resolvePropertyAccessToInitializer;
+  private extractPropertyTokenId;
+  private extractInterfaceTokenId;
+  private getTypeIdFromConstructor;
+  private extractScope;
+  /**
+       * Resolves dependencies for all nodes in the graph.
+       * @param graph - The dependency graph.
+       */
+  private resolveAllDependencies;
+  /**
+       * Resolves dependencies for a single service node by inspecting its constructor.
+       * @param node - The dependency node to resolve.
+       */
+  private resolveDependencies;
+  /**
+       * 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.
+       */
+  private getTypeId;
+  /**
+       * Resolves a symbol, following aliases if necessary.
+       * @param symbol - The symbol to resolve.
+       * @returns The resolved symbol.
+       */
+  private resolveSymbol;
+}
+//#endregion
+export { Analyzer, DependencyGraph, DependencyNode, RegistrationType, ServiceDefinition, TokenId, generateTokenId };