@moldea.ai/adapter-google-genai 1.0.0

package/dist/index.js

@@ -0,0 +1,1922 @@
+import { posix } from "node:path";
+import { intersects, subset, validRange } from "semver";
+import ts from "typescript";
+import { parseRepositoryPath } from "@moldea.ai/repository";
+//#region src/constants/index.ts
+var GOOGLE_GENAI_ADAPTER_ID = "google-genai";
+var GOOGLE_GENAI_GENERATE_CONTENT_RUNTIME_NAME = "models.generateContent";
+var GOOGLE_GENAI_SDK_PACKAGE_NAME = "@google/genai";
+var GOOGLE_GENAI_SDK_SUPPORTED_RANGE = ">=2.17.1 <3.0.0";
+var GOOGLE_GENAI_SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+var GOOGLE_GENAI_FUNCTION_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
+//#endregion
+//#region ../../packages/adapter-static-analysis/dist/index.js
+/**
+* Creates an operation-local inspection session with deterministic promise caches.
+* @param options Provider callbacks and the optional operation signal.
+* @returns Cached source, package, and entry inspection functions.
+* @throws If the inspection is aborted.
+*/
+var createInspectionSession = (options) => {
+	const sourceCache = /* @__PURE__ */ new Map();
+	const packageCache = /* @__PURE__ */ new Map();
+	const entryCache = /* @__PURE__ */ new Map();
+	const analyzeSource = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = sourceCache.get(path);
+		if (existing !== void 0) return existing;
+		const analysis = (async () => {
+			options.signal?.throwIfAborted();
+			const bytes = await options.readFile(path, options.signal);
+			options.signal?.throwIfAborted();
+			const result = await options.analyzeSource(path, bytes, options.signal);
+			options.signal?.throwIfAborted();
+			return result;
+		})();
+		sourceCache.set(path, analysis);
+		return analysis;
+	};
+	const discoverPackage = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = packageCache.get(path);
+		if (existing !== void 0) return existing;
+		const discovery = options.discoverPackage(path, options.signal);
+		packageCache.set(path, discovery);
+		return discovery;
+	};
+	const getEntry = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = entryCache.get(path);
+		if (existing !== void 0) return existing;
+		const entry = options.getEntry(path, options.signal);
+		entryCache.set(path, entry);
+		return entry;
+	};
+	return Object.freeze({
+		analyzeSource,
+		discoverPackage,
+		getEntry,
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	});
+};
+var decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+var findLineIndex = (lineStarts, offset) => {
+	let lower = 0;
+	let upper = lineStarts.length - 1;
+	while (lower < upper) {
+		const middle = Math.ceil((lower + upper) / 2);
+		if ((lineStarts[middle] ?? 0) <= offset) lower = middle;
+		else upper = middle - 1;
+	}
+	return lower;
+};
+/**
+* Creates a TypeScript UTF-16-offset to Unicode-scalar source locator.
+* @param value The normalized valid Unicode-scalar text.
+* @returns The scalar-aware source locator.
+*/
+var createSourceLocator = (value) => {
+	const scalarOffsets = new Uint32Array(value.length + 1);
+	const lineStarts = [0];
+	let scalarOffset = 0;
+	for (let codeUnitOffset = 0; codeUnitOffset < value.length;) {
+		const codePoint = value.codePointAt(codeUnitOffset);
+		const width = codePoint !== void 0 && codePoint > 65535 ? 2 : 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		for (let interiorOffset = 1; interiorOffset < width; interiorOffset += 1) scalarOffsets[codeUnitOffset + interiorOffset] = scalarOffset;
+		codeUnitOffset += width;
+		scalarOffset += 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		if (codePoint === 10) lineStarts.push(codeUnitOffset);
+	}
+	const locatePosition = (candidateOffset) => {
+		const codeUnitOffset = Math.max(0, Math.min(value.length, candidateOffset));
+		const lineIndex = findLineIndex(lineStarts, codeUnitOffset);
+		const lineStart = lineStarts[lineIndex] ?? 0;
+		const positionScalarOffset = scalarOffsets[codeUnitOffset] ?? 0;
+		return {
+			column: positionScalarOffset - (scalarOffsets[lineStart] ?? 0) + 1,
+			line: lineIndex + 1,
+			offset: positionScalarOffset
+		};
+	};
+	return Object.freeze({ locateRange: (startOffset, endOffset) => ({
+		end: locatePosition(endOffset),
+		start: locatePosition(startOffset)
+	}) });
+};
+/**
+* Decodes and normalizes source bytes through the runtime-adapter text contract.
+* @param bytes The exact reader-owned source bytes.
+* @returns The normalized text and locator or an invalid-text result.
+*/
+var normalizeText = (bytes) => {
+	let decoded;
+	try {
+		decoded = decoder.decode(bytes);
+	} catch {
+		return Object.freeze({ valid: false });
+	}
+	const value = (decoded.startsWith("") ? decoded.slice(1) : decoded).replace(/\r\n?/gu, "\n");
+	if (value.includes("\0")) return Object.freeze({ valid: false });
+	return Object.freeze({
+		locator: createSourceLocator(value),
+		valid: true,
+		value
+	});
+};
+var PACKAGE_DEPENDENCY_FIELDS = Object.freeze([
+	"dependencies",
+	"optionalDependencies",
+	"peerDependencies",
+	"devDependencies"
+]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Creates nearest-to-root package-manifest candidates for one source path.
+* @param sourcePath The normalized source path.
+* @returns Deterministically ordered manifest paths.
+*/
+var createPackageManifestCandidatePaths = (sourcePath) => {
+	const candidates = [];
+	let directory = posix.dirname(sourcePath);
+	while (true) {
+		candidates.push(posix.join(directory, "package.json"));
+		if (directory === "/") break;
+		directory = posix.dirname(directory);
+	}
+	return Object.freeze(candidates);
+};
+var extractPackageDeclarations = (manifest, packageName) => {
+	const declarations = [];
+	for (const field of PACKAGE_DEPENDENCY_FIELDS) {
+		const dependencies = manifest[field];
+		if (dependencies === void 0) continue;
+		if (!isRecord(dependencies)) return null;
+		const declaration = dependencies[packageName];
+		if (declaration === void 0) continue;
+		if (typeof declaration !== "string" || declaration.trim().length === 0) return null;
+		declarations.push(Object.freeze({
+			declaredRange: declaration,
+			dependencyKind: field
+		}));
+	}
+	return declarations;
+};
+var classifyPackageDeclarations = (declarations, supportedRange) => {
+	const classifications = declarations.map(({ declaredRange }) => {
+		const normalizedRange = validRange(declaredRange, {
+			loose: false,
+			includePrerelease: false
+		});
+		if (normalizedRange === null) return "ambiguous";
+		if (subset(normalizedRange, supportedRange, {
+			loose: false,
+			includePrerelease: false
+		})) return "supported";
+		if (!intersects(normalizedRange, supportedRange, {
+			loose: false,
+			includePrerelease: false
+		})) return "unsupported";
+		return "ambiguous";
+	});
+	if (classifications.every((classification) => classification === "supported")) return "supported";
+	if (classifications.every((classification) => classification === "unsupported")) return "unsupported";
+	return "ambiguous";
+};
+/**
+* Discovers the nearest package declaration without repository enumeration.
+* @param options The package target, repository callbacks, path, range, and signal.
+* @returns The first observed declaration, invalid manifest, or absence result.
+* @throws If repository reading or the active inspection is aborted.
+*/
+var discoverPackage = async (options) => {
+	const { packageName, reader, signal, sourcePath, supportedRange } = options;
+	for (const manifestPath of createPackageManifestCandidatePaths(sourcePath)) {
+		signal?.throwIfAborted();
+		const entry = await reader.getEntry(manifestPath);
+		signal?.throwIfAborted();
+		if (entry === null) continue;
+		if (entry.type !== "file") return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		const bytes = await reader.readFile(manifestPath);
+		signal?.throwIfAborted();
+		const text = normalizeText(bytes);
+		signal?.throwIfAborted();
+		if (!text.valid) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		let parsed;
+		try {
+			parsed = JSON.parse(text.value);
+		} catch {
+			return Object.freeze({
+				kind: "invalid",
+				path: manifestPath
+			});
+		}
+		signal?.throwIfAborted();
+		if (!isRecord(parsed)) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		const declarations = extractPackageDeclarations(parsed, packageName);
+		if (declarations === null) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		if (declarations.length === 0) return Object.freeze({ kind: "absent" });
+		return Object.freeze({
+			kind: "observed",
+			observation: Object.freeze({
+				compatibility: classifyPackageDeclarations(declarations, supportedRange),
+				declarations: Object.freeze(declarations),
+				path: manifestPath
+			})
+		});
+	}
+	return Object.freeze({ kind: "absent" });
+};
+/**
+* Removes the transparent expression wrappers supported by runtime adapters.
+* @param expression The expression to normalize.
+* @returns The underlying expression used by static matching.
+*/
+var unwrapExpression = (expression) => {
+	let current = expression;
+	while (ts.isAsExpression(current) || ts.isParenthesizedExpression(current) || ts.isSatisfiesExpression(current)) current = current.expression;
+	return current;
+};
+/**
+* Resolves one direct call with an optional outer `await` wrapper.
+* @param expression The candidate call expression.
+* @returns The direct call or `null` when the form is unsupported.
+*/
+var getDirectCall = (expression) => {
+	const unwrapped = unwrapExpression(expression);
+	const candidate = ts.isAwaitExpression(unwrapped) ? unwrapExpression(unwrapped.expression) : unwrapped;
+	return ts.isCallExpression(candidate) ? candidate : null;
+};
+var getStaticPropertyName = (name) => {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+	return null;
+};
+/**
+* Indexes a closed object literal with exact identifier or string-literal keys.
+* @param objectLiteral The candidate closed object.
+* @returns Exact property expressions or `null` for dynamic or duplicate members.
+*/
+var getClosedObjectProperties = (objectLiteral) => {
+	const properties = /* @__PURE__ */ new Map();
+	for (const property of objectLiteral.properties) {
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) return null;
+		const propertyName = getStaticPropertyName(property.name);
+		if (propertyName === null || properties.has(propertyName)) return null;
+		properties.set(propertyName, unwrapExpression(ts.isPropertyAssignment(property) ? property.initializer : property.name));
+	}
+	return properties;
+};
+/**
+* Reads an exact static string literal from one expression.
+* @param expression The candidate string expression.
+* @returns Its exact value or `null` when dynamic.
+*/
+var getStaticString = (expression) => {
+	if (expression === null || expression === void 0) return null;
+	const candidate = unwrapExpression(expression);
+	return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) ? candidate.text : null;
+};
+/**
+* Determines whether an expression is the `null` literal.
+* @param expression The candidate expression.
+* @returns Whether the expression is statically `null`.
+*/
+var isNullLiteral = (expression) => unwrapExpression(expression).kind === ts.SyntaxKind.NullKeyword;
+/**
+* Determines whether a JSON-like expression is fully static.
+* @param expression The candidate schema or literal value.
+* @returns Whether every nested value is statically represented.
+*/
+var isStaticLiteralValue = (expression) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) || ts.isNumericLiteral(candidate) || candidate.kind === ts.SyntaxKind.TrueKeyword || candidate.kind === ts.SyntaxKind.FalseKeyword || candidate.kind === ts.SyntaxKind.NullKeyword) return true;
+	if (ts.isPrefixUnaryExpression(candidate) && (candidate.operator === ts.SyntaxKind.PlusToken || candidate.operator === ts.SyntaxKind.MinusToken) && ts.isNumericLiteral(candidate.operand)) return true;
+	if (ts.isArrayLiteralExpression(candidate)) return candidate.elements.every((element) => !ts.isOmittedExpression(element) && !ts.isSpreadElement(element) && isStaticLiteralValue(element));
+	if (!ts.isObjectLiteralExpression(candidate)) return false;
+	const properties = getClosedObjectProperties(candidate);
+	return properties !== null && [...properties.values()].every((property) => isStaticLiteralValue(property));
+};
+var hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+var isConstDeclarationList = (declarationList) => (declarationList.flags & ts.NodeFlags.Const) !== 0;
+/**
+* Indexes static value imports and supported SDK constructor imports.
+* @param sourceFile The parsed TypeScript source.
+* @param config The provider package and constructor import forms.
+* @returns Module-owned import bindings needed by static checks.
+*/
+var indexImports = (sourceFile, config) => {
+	const constructorNames = /* @__PURE__ */ new Set();
+	const namedImports = /* @__PURE__ */ new Map();
+	const supportedNamedImports = new Set(config.namedConstructorImports);
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const importClause = statement.importClause;
+		if (importClause?.isTypeOnly === true) continue;
+		const moduleSpecifier = statement.moduleSpecifier.text;
+		if (moduleSpecifier === config.packageName && config.supportsDefaultConstructorImport && importClause?.name !== void 0) constructorNames.add(importClause.name.text);
+		if (moduleSpecifier === config.packageName && importClause?.namedBindings !== void 0 && ts.isNamedImports(importClause.namedBindings)) for (const element of importClause.namedBindings.elements) {
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (!element.isTypeOnly && supportedNamedImports.has(importedName)) constructorNames.add(element.name.text);
+		}
+		if (!moduleSpecifier.startsWith(".") || importClause?.namedBindings === void 0 || !ts.isNamedImports(importClause.namedBindings)) continue;
+		for (const element of importClause.namedBindings.elements) {
+			if (element.isTypeOnly) continue;
+			namedImports.set(element.name.text, Object.freeze({
+				importedName: element.propertyName?.text ?? element.name.text,
+				moduleSpecifier
+			}));
+		}
+	}
+	return {
+		constructorNames,
+		namedImports
+	};
+};
+/**
+* Indexes direct exports, module-level SDK clients, and constant arrays.
+* @param sourceFile The parsed TypeScript source.
+* @param constructorNames The supported constructor bindings.
+* @returns Static module declarations used by adapter inspection.
+*/
+var indexModuleDeclarations = (sourceFile, constructorNames) => {
+	const clientNames = /* @__PURE__ */ new Set();
+	const exports = /* @__PURE__ */ new Map();
+	const moduleArrays = /* @__PURE__ */ new Map();
+	const moduleConstDeclarations = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
+			if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) exports.set(statement.name.text, Object.freeze({
+				declaration: statement,
+				kind: statement.body === void 0 || hasModifier(statement, ts.SyntaxKind.DefaultKeyword) ? "present-unsupported" : "present-supported"
+			}));
+			continue;
+		}
+		if (ts.isExportDeclaration(statement) && statement.exportClause !== void 0) {
+			if (!ts.isNamedExports(statement.exportClause) || statement.isTypeOnly) continue;
+			for (const element of statement.exportClause.elements) if (!element.isTypeOnly) exports.set(element.name.text, Object.freeze({
+				declaration: element,
+				kind: "present-unsupported"
+			}));
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) {
+			if (hasModifier(statement, ts.SyntaxKind.ExportKeyword) && (ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) && statement.name !== void 0 && ts.isIdentifier(statement.name)) exports.set(statement.name.text, Object.freeze({
+				declaration: statement,
+				kind: "present-unsupported"
+			}));
+			continue;
+		}
+		const isConst = isConstDeclarationList(statement.declarationList);
+		const isExported = hasModifier(statement, ts.SyntaxKind.ExportKeyword);
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name)) continue;
+			if (isExported) exports.set(declaration.name.text, Object.freeze({
+				declaration,
+				kind: isConst && declaration.initializer !== void 0 ? "present-supported" : "present-unsupported"
+			}));
+			if (!isConst || declaration.initializer === void 0) continue;
+			moduleConstDeclarations.set(declaration.name.text, declaration);
+			const initializer = unwrapExpression(declaration.initializer);
+			if (ts.isNewExpression(initializer)) {
+				const constructor = unwrapExpression(initializer.expression);
+				if (ts.isIdentifier(constructor) && constructorNames.has(constructor.text)) clientNames.add(declaration.name.text);
+			}
+			if (ts.isArrayLiteralExpression(initializer)) moduleArrays.set(declaration.name.text, Object.freeze({
+				declaration,
+				expression: initializer
+			}));
+		}
+	}
+	return {
+		clientNames,
+		exports,
+		moduleArrays,
+		moduleConstDeclarations
+	};
+};
+var addBindingNames = (names, bindingName) => {
+	if (ts.isIdentifier(bindingName)) {
+		names.add(bindingName.text);
+		return;
+	}
+	for (const element of bindingName.elements) if (!ts.isOmittedExpression(element)) addBindingNames(names, element.name);
+};
+var addVariableDeclarationListBindings = (names, declarationList) => {
+	for (const declaration of declarationList.declarations) addBindingNames(names, declaration.name);
+};
+var addStatementBindings = (names, statement) => {
+	if (ts.isVariableStatement(statement)) {
+		addVariableDeclarationListBindings(names, statement.declarationList);
+		return;
+	}
+	if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) {
+		if (statement.name !== void 0 && ts.isIdentifier(statement.name)) names.add(statement.name.text);
+	}
+};
+var isFunctionScope = (node) => ts.isArrowFunction(node) || ts.isConstructorDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isGetAccessorDeclaration(node) || ts.isMethodDeclaration(node) || ts.isSetAccessorDeclaration(node);
+var getLocalBindingNames = (bindings, scope) => {
+	const existingNames = bindings.get(scope);
+	if (existingNames !== void 0) return existingNames;
+	const names = /* @__PURE__ */ new Set();
+	bindings.set(scope, names);
+	return names;
+};
+/**
+* Indexes local runtime bindings that can shadow module-owned identifiers.
+* @param sourceFile The parsed TypeScript source.
+* @returns Local binding names keyed by lexical or function scope.
+*/
+var indexLocalBindingNames = (sourceFile) => {
+	const bindings = /* @__PURE__ */ new Map();
+	const visit = (node, functionScope) => {
+		let childFunctionScope = functionScope;
+		if (isFunctionScope(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const parameter of node.parameters) addBindingNames(names, parameter.name);
+			if (node.name !== void 0 && ts.isIdentifier(node.name)) names.add(node.name.text);
+			childFunctionScope = node;
+		}
+		if (ts.isBlock(node) || ts.isModuleBlock(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const statement of node.statements) addStatementBindings(names, statement);
+		} else if (ts.isCaseBlock(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const clause of node.clauses) for (const statement of clause.statements) addStatementBindings(names, statement);
+		} else if (ts.isCatchClause(node) && node.variableDeclaration !== void 0) addBindingNames(getLocalBindingNames(bindings, node), node.variableDeclaration.name);
+		else if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer !== void 0 && ts.isVariableDeclarationList(node.initializer)) addVariableDeclarationListBindings(getLocalBindingNames(bindings, node), node.initializer);
+		else if (ts.isClassExpression(node) && node.name !== void 0) getLocalBindingNames(bindings, node).add(node.name.text);
+		if (childFunctionScope !== null && ts.isVariableDeclarationList(node) && (node.flags & ts.NodeFlags.BlockScoped) === 0) addVariableDeclarationListBindings(getLocalBindingNames(bindings, childFunctionScope), node);
+		ts.forEachChild(node, (child) => visit(child, childFunctionScope));
+	};
+	visit(sourceFile, null);
+	return bindings;
+};
+/**
+* Indexes identifier occurrences once for binding-specific safety analysis.
+* @param sourceFile The parsed TypeScript source.
+* @returns Identifier occurrences grouped by exact source spelling.
+*/
+var indexIdentifierUses = (sourceFile) => {
+	const identifierUses = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (ts.isIdentifier(node)) {
+			const uses = identifierUses.get(node.text) ?? [];
+			uses.push(node);
+			identifierUses.set(node.text, uses);
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return new Map([...identifierUses].map(([name, uses]) => [name, Object.freeze(uses)]));
+};
+/**
+* Determines whether a module-bound name is visible at one identifier use.
+* @param identifier The identifier whose lexical environment is inspected.
+* @param analysis The indexed source containing the identifier.
+* @returns Whether no parameter or local declaration shadows the module binding.
+*/
+var isModuleBindingVisible = (identifier, analysis) => {
+	let current = identifier.parent;
+	while (current !== void 0 && !ts.isSourceFile(current)) {
+		if (analysis.localBindingNames.get(current)?.has(identifier.text) === true) return false;
+		current = current.parent;
+	}
+	return true;
+};
+/**
+* Resolves TypeScript source candidates for a supported relative ESM specifier.
+* @param containingPath The importing source path.
+* @param moduleSpecifier The exact relative ESM specifier.
+* @returns Supported logical source candidates in deterministic order.
+*/
+var resolveImportCandidatePaths = (containingPath, moduleSpecifier) => {
+	const resolved = posix.resolve(posix.dirname(containingPath), moduleSpecifier);
+	if (resolved.endsWith(".js")) return [`${resolved.slice(0, -3)}.ts`, `${resolved.slice(0, -3)}.tsx`];
+	if (resolved.endsWith(".mjs")) return [`${resolved.slice(0, -4)}.mts`];
+	return [
+		".ts",
+		".tsx",
+		".mts"
+	].some((extension) => resolved.endsWith(extension)) ? [resolved] : [];
+};
+/**
+* Resolves the explicit module references an identifier can denote.
+* @param identifier The local source identifier.
+* @param analysis The source containing that identifier.
+* @returns Same-file or relative-import candidates in deterministic order.
+*/
+var resolveBindingReferences = (identifier, analysis) => {
+	if (!isModuleBindingVisible(identifier, analysis)) return [];
+	const references = [];
+	if (analysis.exports.has(identifier.text)) references.push(Object.freeze({
+		path: analysis.path,
+		symbol: identifier.text
+	}));
+	const namedImport = analysis.namedImports.get(identifier.text);
+	if (namedImport !== void 0) references.push(...resolveImportCandidatePaths(analysis.path, namedImport.moduleSpecifier).map((path) => Object.freeze({
+		path,
+		symbol: namedImport.importedName
+	})));
+	return references;
+};
+/**
+* Checks whether an identifier resolves directly to an explicit bound reference.
+* @param identifier The local source identifier.
+* @param analysis The source containing that identifier.
+* @param reference The explicit source binding to match.
+* @returns Whether local or named-import identity proves the relationship.
+*/
+var isBoundIdentifier = (identifier, analysis, reference) => {
+	if (reference.symbol === void 0) return false;
+	return resolveBindingReferences(identifier, analysis).some((candidate) => candidate.path === reference.path && candidate.symbol === reference.symbol);
+};
+var getAccessSegment = (expression) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isPropertyAccessExpression(candidate)) return {
+		isDirect: candidate.questionDotToken === void 0,
+		name: candidate.name.text,
+		target: candidate.expression
+	};
+	if (ts.isElementAccessExpression(candidate)) {
+		const argument = candidate.argumentExpression;
+		return {
+			isDirect: false,
+			name: argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null,
+			target: candidate.expression
+		};
+	}
+	return null;
+};
+var classifyKnownClientResourceAccess = (expression, analysis, config) => {
+	const resourceAccess = getAccessSegment(expression);
+	if (resourceAccess === null || resourceAccess.name !== null && resourceAccess.name !== config.resourceName) return null;
+	const client = unwrapExpression(resourceAccess.target);
+	if (!ts.isIdentifier(client) || !analysis.clientNames.has(client.text) || !isModuleBindingVisible(client, analysis)) return null;
+	return resourceAccess.isDirect ? "direct" : "indirect";
+};
+var classifyCreateAccess = (expression, analysis, config) => {
+	const methodAccess = getAccessSegment(expression);
+	if (methodAccess === null || methodAccess.name !== null && methodAccess.name !== config.methodName) return null;
+	const resourceAccess = getAccessSegment(methodAccess.target);
+	if (resourceAccess === null || resourceAccess.name !== null && resourceAccess.name !== config.resourceName) return null;
+	const knownAccess = classifyKnownClientResourceAccess(methodAccess.target, analysis, config);
+	if (knownAccess === null) return "indirect";
+	return methodAccess.isDirect && knownAccess === "direct" ? "direct" : "indirect";
+};
+var classifyRequestCall = (call, analysis, config) => {
+	const access = classifyCreateAccess(call.expression, analysis, config);
+	if (access === null) return "unrelated";
+	if (access === "indirect" || call.questionDotToken !== void 0) return "ambiguous";
+	if (!config.acceptedArgumentCounts.includes(call.arguments.length)) return "ambiguous";
+	const request = call.arguments[0];
+	if (request === void 0 || !ts.isObjectLiteralExpression(unwrapExpression(request))) return "ambiguous";
+	return "recognized";
+};
+var getDirectPropertyName = (name) => {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+	return null;
+};
+var getPotentialRelationshipNames = (name, relationshipNames) => {
+	const directName = getDirectPropertyName(name);
+	if (directName !== null) return relationshipNames.includes(directName) ? [directName] : [];
+	if (!ts.isComputedPropertyName(name)) return [];
+	const expression = unwrapExpression(name.expression);
+	if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) return relationshipNames.includes(expression.text) ? [expression.text] : [];
+	if (ts.isNumericLiteral(expression) || expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword || expression.kind === ts.SyntaxKind.NullKeyword) return [];
+	return relationshipNames;
+};
+/**
+* Classifies selected properties on one object literal without interpreting unrelated values.
+* @param object The object literal whose direct properties are inspected.
+* @param relationshipNames The exact properties owned by the caller.
+* @returns Independent closed, absent, or unresolved relationship observations.
+*/
+var analyzeObjectRelationships = (object, relationshipNames) => {
+	const states = new Map(relationshipNames.map((name) => [name, {
+		directPropertyCount: 0,
+		relationship: { kind: "absent" }
+	}]));
+	const markUnresolved = (names) => {
+		for (const name of names) {
+			const state = states.get(name);
+			if (state !== void 0) state.relationship = { kind: "unresolved" };
+		}
+	};
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property)) {
+			markUnresolved(relationshipNames);
+			continue;
+		}
+		const potentialNames = getPotentialRelationshipNames(property.name, relationshipNames);
+		const relationshipExpression = ts.isPropertyAssignment(property) ? property.initializer : ts.isShorthandPropertyAssignment(property) ? property.name : null;
+		if (relationshipExpression === null) {
+			markUnresolved(potentialNames);
+			continue;
+		}
+		const directName = getDirectPropertyName(property.name);
+		if (directName === null || !relationshipNames.includes(directName)) {
+			markUnresolved(potentialNames);
+			continue;
+		}
+		const state = states.get(directName);
+		if (state === void 0) continue;
+		state.directPropertyCount += 1;
+		state.relationship = state.directPropertyCount === 1 ? {
+			expression: unwrapExpression(relationshipExpression),
+			kind: "present"
+		} : { kind: "unresolved" };
+	}
+	return Object.freeze({
+		object,
+		relationships: new Map([...states].map(([name, state]) => [name, Object.freeze(state.relationship)]))
+	});
+};
+var isNestedLexicalBoundary = (node) => ts.isFunctionLike(node) || ts.isClassLike(node) || ts.isClassStaticBlockDeclaration(node);
+var skipTransparentParents$1 = (node) => {
+	let current = node;
+	while (ts.isAsExpression(current.parent) || ts.isParenthesizedExpression(current.parent) || ts.isSatisfiesExpression(current.parent)) current = current.parent;
+	return current;
+};
+var isAssignmentOperator$1 = (kind) => kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+var isResourceAccessCreateTarget = (expression, analysis, config) => {
+	const parent = skipTransparentParents$1(expression).parent;
+	if (!ts.isPropertyAccessExpression(parent) && !ts.isElementAccessExpression(parent)) return false;
+	const access = getAccessSegment(parent);
+	return access !== null && unwrapExpression(access.target) === unwrapExpression(expression) && classifyCreateAccess(parent, analysis, config) !== null;
+};
+var isKnownClientResourceTarget = (identifier, analysis, config) => {
+	const candidate = skipTransparentParents$1(identifier);
+	const parent = candidate.parent;
+	return (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === candidate && classifyKnownClientResourceAccess(parent, analysis, config) !== null;
+};
+var getClientValueExpression = (identifier) => {
+	let current = skipTransparentParents$1(identifier);
+	while (true) {
+		const parent = current.parent;
+		const isFlowingConditionalBranch = ts.isConditionalExpression(parent) && parent.condition !== current;
+		const isFlowingBinaryBranch = ts.isBinaryExpression(parent) && (parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || parent.operatorToken.kind === ts.SyntaxKind.BarBarToken || parent.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken || parent.operatorToken.kind === ts.SyntaxKind.CommaToken && parent.right === current);
+		const isFlowingWrapper = (ts.isAwaitExpression(parent) || ts.isNonNullExpression(parent)) && parent.expression === current;
+		if (!isFlowingConditionalBranch && !isFlowingBinaryBranch && !isFlowingWrapper) return current;
+		current = skipTransparentParents$1(parent);
+	}
+};
+var isClientEscape = (identifier) => {
+	const expression = getClientValueExpression(identifier);
+	const parent = expression.parent;
+	if (ts.isVariableDeclaration(parent) && parent.initializer !== void 0 && skipTransparentParents$1(parent.initializer) === expression) return true;
+	if (ts.isReturnStatement(parent) || ts.isYieldExpression(parent) || ts.isArrowFunction(parent) && parent.body === expression || ts.isSpreadElement(parent) || ts.isSpreadAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isArrayLiteralExpression(parent) || ts.isExportAssignment(parent)) return true;
+	if (ts.isPropertyAssignment(parent)) return skipTransparentParents$1(parent.initializer) === expression;
+	if ((ts.isCallExpression(parent) || ts.isNewExpression(parent)) && parent.arguments?.some((argument) => skipTransparentParents$1(argument) === expression) === true) return true;
+	return ts.isBinaryExpression(parent) && isAssignmentOperator$1(parent.operatorToken.kind);
+};
+/**
+* Finds direct provider requests owned by one runtime-agent body.
+* @param analysis The indexed runtime source.
+* @param body The supported runtime-agent lexical body.
+* @param config The provider call and relationship contract.
+* @param signal The active inspection signal.
+* @returns Recognized requests and conservative ambiguity state.
+* @throws If request analysis is aborted.
+*/
+var analyzeClientRequests = (analysis, body, config, signal) => {
+	const requests = [];
+	let hasAmbiguousCandidate = false;
+	if (isNestedLexicalBoundary(body)) return Object.freeze({
+		hasAmbiguousCandidate: false,
+		requests: Object.freeze([])
+	});
+	const visit = (node, isRoot) => {
+		signal?.throwIfAborted();
+		if (!isRoot && isNestedLexicalBoundary(node)) return;
+		if (ts.isCallExpression(node)) {
+			const classification = classifyRequestCall(node, analysis, config);
+			if (classification === "ambiguous") hasAmbiguousCandidate = true;
+			else if (classification === "recognized") {
+				const request = unwrapExpression(node.arguments[0]);
+				requests.push(analyzeObjectRelationships(request, config.relationshipNames));
+			}
+		}
+		if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+			if (classifyCreateAccess(node, analysis, config) !== null) {
+				let candidate = node;
+				while (ts.isAsExpression(candidate.parent) || ts.isParenthesizedExpression(candidate.parent) || ts.isSatisfiesExpression(candidate.parent)) candidate = candidate.parent;
+				if (!ts.isCallExpression(candidate.parent) || candidate.parent.expression !== candidate) hasAmbiguousCandidate = true;
+			}
+			const resourceAccess = classifyKnownClientResourceAccess(node, analysis, config);
+			if (resourceAccess !== null && (resourceAccess === "indirect" || !isResourceAccessCreateTarget(node, analysis, config))) hasAmbiguousCandidate = true;
+		}
+		if (ts.isIdentifier(node) && analysis.clientNames.has(node.text) && isModuleBindingVisible(node, analysis) && !isKnownClientResourceTarget(node, analysis, config) && isClientEscape(node)) hasAmbiguousCandidate = true;
+		ts.forEachChild(node, (child) => visit(child, false));
+	};
+	visit(body, true);
+	signal?.throwIfAborted();
+	return Object.freeze({
+		hasAmbiguousCandidate,
+		requests: Object.freeze(requests)
+	});
+};
+var SAFE_ARRAY_METHODS = /* @__PURE__ */ new Set([
+	"at",
+	"concat",
+	"entries",
+	"flat",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"slice",
+	"toLocaleString",
+	"toReversed",
+	"toSorted",
+	"toSpliced",
+	"toString",
+	"values",
+	"with"
+]);
+var isDirectToolRequestPropertyUse = (identifier, analysis, config) => {
+	if (config.toolRelationshipName === void 0) return false;
+	const expression = skipTransparentParents$1(identifier);
+	const property = expression.parent;
+	if (!(ts.isShorthandPropertyAssignment(property) && property.name.text === config.toolRelationshipName || ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) && property.name.text === config.toolRelationshipName || ts.isStringLiteral(property.name) && property.name.text === config.toolRelationshipName) && skipTransparentParents$1(property.initializer) === expression) || !ts.isObjectLiteralExpression(property.parent)) return false;
+	const request = skipTransparentParents$1(property.parent);
+	const call = request.parent;
+	if (!ts.isCallExpression(call) || !config.acceptedArgumentCounts.includes(call.arguments.length) || skipTransparentParents$1(call.arguments[0]) !== request) return false;
+	return classifyCreateAccess(call.expression, analysis, config) === "direct";
+};
+var isArrayMemberAssignmentTarget = (member) => {
+	let current = skipTransparentParents$1(member);
+	while (true) {
+		const parent = current.parent;
+		if (ts.isBinaryExpression(parent) && isAssignmentOperator$1(parent.operatorToken.kind)) return parent.left === current;
+		if ((ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && parent.operand === current && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken)) return true;
+		if (ts.isDeleteExpression(parent) && parent.expression === current) return true;
+		if ((ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === current) return true;
+		if (ts.isPropertyAssignment(parent) || ts.isSpreadAssignment(parent) || ts.isSpreadElement(parent) || ts.isArrayLiteralExpression(parent) || ts.isObjectLiteralExpression(parent)) {
+			current = skipTransparentParents$1(parent);
+			continue;
+		}
+		return false;
+	}
+};
+var isDisallowedArrayMemberUse = (member) => {
+	if (isArrayMemberAssignmentTarget(member)) return true;
+	const candidate = skipTransparentParents$1(member);
+	const parent = candidate.parent;
+	if (!ts.isCallExpression(parent) || parent.expression !== candidate) return false;
+	if (ts.isPropertyAccessExpression(member)) return !SAFE_ARRAY_METHODS.has(member.name.text);
+	const argument = member.argumentExpression;
+	const methodName = argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null;
+	return methodName === null || !SAFE_ARRAY_METHODS.has(methodName);
+};
+var isDisallowedArrayUse = (identifier, analysis, config) => {
+	if (isDirectToolRequestPropertyUse(identifier, analysis, config)) return false;
+	const expression = skipTransparentParents$1(identifier);
+	const parent = expression.parent;
+	if (ts.isPropertyAccessExpression(parent) && parent.expression === expression) return isDisallowedArrayMemberUse(parent);
+	if (ts.isElementAccessExpression(parent) && parent.expression === expression) return isDisallowedArrayMemberUse(parent);
+	return true;
+};
+/**
+* Indexes immutable module-local arrays through one AST traversal.
+* @param analysis The preliminary indexed source.
+* @param config The provider call and tool relationship contract.
+* @returns Module array names with no disallowed use.
+*/
+var indexSafeModuleArrayNames = (analysis, config) => {
+	if (config.toolRelationshipName === void 0) return /* @__PURE__ */ new Set();
+	const unsafeNames = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts.isIdentifier(node)) {
+			const moduleArray = analysis.moduleArrays.get(node.text);
+			if (moduleArray !== void 0 && node !== moduleArray.declaration.name && !(ts.isPropertyAssignment(node.parent) && node.parent.name === node) && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) && isModuleBindingVisible(node, analysis) && isDisallowedArrayUse(node, analysis, config)) unsafeNames.add(node.text);
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(analysis.sourceFile);
+	return new Set([...analysis.moduleArrays.keys()].filter((name) => !unsafeNames.has(name)));
+};
+/**
+* Classifies direct calls to one explicit instruction-loader binding.
+* @param analysis The runtime source containing request relationships.
+* @param relationships The provider request properties to inspect.
+* @param hasAmbiguousCandidate Whether request discovery found an unresolved provider call.
+* @param reference The declared instruction-loader reference.
+* @returns The provider-neutral relationship classification.
+*/
+var classifyDirectCallRelationship = (analysis, relationships, hasAmbiguousCandidate, reference) => {
+	let absentExpression = null;
+	let hasAmbiguousRelationship = hasAmbiguousCandidate;
+	for (const relationship of relationships) {
+		if (relationship.kind === "unresolved") {
+			hasAmbiguousRelationship = true;
+			continue;
+		}
+		if (relationship.kind === "absent") continue;
+		const expression = relationship.expression;
+		const call = getDirectCall(expression);
+		if (call !== null) {
+			const callee = unwrapExpression(call.expression);
+			if (ts.isIdentifier(callee) && isBoundIdentifier(callee, analysis, reference)) return { kind: "present" };
+			if (ts.isIdentifier(callee)) {
+				absentExpression ??= expression;
+				continue;
+			}
+		}
+		if (isStaticLiteralValue(expression)) absentExpression ??= expression;
+		else hasAmbiguousRelationship = true;
+	}
+	return hasAmbiguousRelationship ? { kind: "ambiguous" } : {
+		expression: absentExpression,
+		kind: "absent"
+	};
+};
+/**
+* Classifies one registration schema expression against an explicit schema binding.
+* @param analysis The registration source containing the schema expression.
+* @param expression The registration schema expression.
+* @param reference The declared schema reference.
+* @returns The provider-neutral relationship classification.
+*/
+var classifySchemaRelationship = (analysis, expression, reference) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isIdentifier(candidate) && isBoundIdentifier(candidate, analysis, reference)) return { kind: "present" };
+	return isNullLiteral(candidate) || ts.isObjectLiteralExpression(candidate) && isStaticLiteralValue(candidate) ? {
+		expression: candidate,
+		kind: "absent"
+	} : { kind: "ambiguous" };
+};
+var READONLY_ARRAY_METHODS = /* @__PURE__ */ new Set([
+	"at",
+	"concat",
+	"entries",
+	"flat",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"slice",
+	"toLocaleString",
+	"toReversed",
+	"toSpliced",
+	"toString",
+	"values",
+	"with"
+]);
+var skipTransparentParents = (node) => {
+	let current = node;
+	while (ts.isAsExpression(current.parent) || ts.isParenthesizedExpression(current.parent) || ts.isSatisfiesExpression(current.parent)) current = current.parent;
+	return current;
+};
+var isAssignmentOperator = (kind) => kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+var isAssignmentTarget = (expression) => {
+	let current = skipTransparentParents(expression);
+	while (true) {
+		const parent = current.parent;
+		if (ts.isBinaryExpression(parent) && isAssignmentOperator(parent.operatorToken.kind)) return parent.left === current;
+		if ((ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && parent.operand === current && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken)) return true;
+		if (ts.isDeleteExpression(parent) && parent.expression === current) return true;
+		if ((ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === current) return true;
+		if (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent) || ts.isPropertyAssignment(parent) || ts.isSpreadAssignment(parent) || ts.isSpreadElement(parent) || ts.isArrayLiteralExpression(parent) || ts.isObjectLiteralExpression(parent)) {
+			current = skipTransparentParents(parent);
+			continue;
+		}
+		return false;
+	}
+};
+var getStaticMemberName = (member) => {
+	if (ts.isPropertyAccessExpression(member)) return member.name.text;
+	const argument = member.argumentExpression;
+	return argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null;
+};
+var isSafeArrayMemberUse = (member) => {
+	if (isAssignmentTarget(member)) return false;
+	const candidate = skipTransparentParents(member);
+	const parent = candidate.parent;
+	if (!ts.isCallExpression(parent) || parent.expression !== candidate) return ts.isPropertyAccessExpression(member) && member.name.text === "length";
+	const memberName = getStaticMemberName(member);
+	const call = skipTransparentParents(parent);
+	return memberName !== null && READONLY_ARRAY_METHODS.has(memberName) && ts.isExpressionStatement(call.parent);
+};
+var isIgnoredIdentifierPosition = (identifier, declarationName) => identifier === declarationName || ts.isImportSpecifier(identifier.parent) || ts.isPropertyAssignment(identifier.parent) && identifier.parent.name === identifier || ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier;
+/**
+* Determines whether a module value binding has only explicitly allowed value uses.
+* @param analysis The indexed source containing the binding references.
+* @param bindingName The exact lexically visible module binding name.
+* @param declarationName The optional local declaration identifier to exclude.
+* @param allowedReferences Exact bare identifier occurrences owned by supported relationships.
+* @param kind Whether array read-only member access is permitted for the value.
+* @returns Whether the binding cannot be aliased, escaped, reassigned, or mutated.
+*/
+var isModuleValueBindingSafe = (analysis, bindingName, declarationName, allowedReferences, kind) => {
+	const identifierUses = analysis.identifierUses.get(bindingName) ?? [];
+	for (const identifier of identifierUses) {
+		if (isIgnoredIdentifierPosition(identifier, declarationName) || !isModuleBindingVisible(identifier, analysis)) continue;
+		if (allowedReferences.has(identifier)) continue;
+		const expression = skipTransparentParents(identifier);
+		const parent = expression.parent;
+		const member = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === expression ? parent : null;
+		if (kind !== "array" || member === null || !isSafeArrayMemberUse(member)) return false;
+	}
+	return true;
+};
+/**
+* Determines whether a module-local constant literal has only explicitly allowed value uses.
+* @param analysis The indexed source containing the declaration and its references.
+* @param declaration The module-local constant declaration to inspect.
+* @param allowedReferences Exact bare identifier occurrences owned by supported relationships.
+* @param kind Whether array read-only member access is permitted for the value.
+* @returns Whether the binding cannot be aliased, escaped, reassigned, or mutated.
+*/
+var isModuleConstValueSafe = (analysis, declaration, allowedReferences, kind) => {
+	if (!ts.isIdentifier(declaration.name)) return false;
+	return isModuleValueBindingSafe(analysis, declaration.name.text, declaration.name, allowedReferences, kind);
+};
+function getSafeModuleConstLiteral(expression, analysis, allowedReferences, kind) {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return null;
+	const declaration = analysis.moduleConstDeclarations.get(candidate.text);
+	const initializer = declaration?.initializer === void 0 ? null : unwrapExpression(declaration.initializer);
+	const isExpectedLiteral = initializer !== null && (kind === "array" ? ts.isArrayLiteralExpression(initializer) : ts.isObjectLiteralExpression(initializer));
+	if (declaration === void 0 || !isExpectedLiteral || !isModuleConstValueSafe(analysis, declaration, allowedReferences, kind)) return null;
+	return Object.freeze({
+		declaration,
+		expression: initializer
+	});
+}
+var getScriptKind = (path) => path.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+var createSyntaxProgram = (sourceFile, text) => {
+	return ts.createProgram({
+		host: {
+			fileExists: (fileName) => fileName === sourceFile.fileName,
+			getCanonicalFileName: (fileName) => fileName,
+			getCurrentDirectory: () => "/",
+			getDefaultLibFileName: () => "/lib.d.ts",
+			getDirectories: () => [],
+			getNewLine: () => "\n",
+			getSourceFile: (fileName) => fileName === sourceFile.fileName ? sourceFile : void 0,
+			readFile: (fileName) => fileName === sourceFile.fileName ? text : void 0,
+			useCaseSensitiveFileNames: () => true,
+			writeFile: () => void 0
+		},
+		options: {
+			jsx: ts.JsxEmit.Preserve,
+			module: ts.ModuleKind.ESNext,
+			noLib: true,
+			noResolve: true,
+			target: ts.ScriptTarget.ES2023
+		},
+		rootNames: [sourceFile.fileName]
+	});
+};
+/**
+* Parses and indexes one TypeScript source without execution, emit, or typechecking.
+* @param path The normalized logical source path.
+* @param bytes The exact source bytes returned by the adapter reader.
+* @param config The provider import and request analysis contract.
+* @param signal The active inspection signal.
+* @returns A source analysis or stable invalid-text or invalid-syntax result.
+* @throws If source analysis is aborted.
+*/
+var analyzeSource = (path, bytes, config, signal) => {
+	signal?.throwIfAborted();
+	const text = normalizeText(bytes);
+	if (!text.valid) return Object.freeze({ kind: "invalid-text" });
+	signal?.throwIfAborted();
+	const sourceFile = ts.createSourceFile(path, text.value, ts.ScriptTarget.ES2023, true, getScriptKind(path));
+	const syntaxDiagnostic = createSyntaxProgram(sourceFile, text.value).getSyntacticDiagnostics(sourceFile).filter(({ category }) => category === ts.DiagnosticCategory.Error).sort((left, right) => (left.start ?? 0) - (right.start ?? 0))[0];
+	signal?.throwIfAborted();
+	if (syntaxDiagnostic !== void 0) {
+		const start = syntaxDiagnostic.start;
+		return Object.freeze({
+			kind: "invalid-syntax",
+			range: start === void 0 ? null : text.locator.locateRange(start, start + (syntaxDiagnostic.length ?? 0))
+		});
+	}
+	const { constructorNames, namedImports } = indexImports(sourceFile, config.importConfig);
+	signal?.throwIfAborted();
+	const { clientNames, exports, moduleArrays, moduleConstDeclarations } = indexModuleDeclarations(sourceFile, constructorNames);
+	signal?.throwIfAborted();
+	const identifierUses = indexIdentifierUses(sourceFile);
+	signal?.throwIfAborted();
+	const localBindingNames = indexLocalBindingNames(sourceFile);
+	signal?.throwIfAborted();
+	const preliminaryAnalysis = Object.freeze({
+		clientNames,
+		constructorNames,
+		exports,
+		identifierUses,
+		localBindingNames,
+		moduleArrays,
+		moduleConstDeclarations,
+		namedImports,
+		path,
+		safeModuleArrayNames: /* @__PURE__ */ new Set(),
+		sourceFile,
+		text
+	});
+	const analysis = Object.freeze({
+		...preliminaryAnalysis,
+		safeModuleArrayNames: indexSafeModuleArrayNames(preliminaryAnalysis, config.requestConfig)
+	});
+	signal?.throwIfAborted();
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+/**
+* Determines whether a path uses a supported TypeScript source extension.
+* @param path The bound source path.
+* @returns Whether its extension is supported.
+*/
+var isSupportedTypeScriptSourcePath = (path) => [
+	".ts",
+	".tsx",
+	".mts"
+].some((extension) => path.endsWith(extension));
+/**
+* Classifies a direct exported runtime-agent function and exposes its body.
+* @param analysis The indexed runtime source.
+* @param symbol The bound runtime-agent symbol.
+* @returns The symbol state and supported body when available.
+*/
+var getRuntimeExport = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind === "present-unsupported") return exported;
+	const { declaration } = exported;
+	if (ts.isFunctionDeclaration(declaration) && declaration.body !== void 0) return Object.freeze({
+		body: declaration.body,
+		declaration,
+		kind: "present-supported"
+	});
+	if (ts.isVariableDeclaration(declaration) && declaration.initializer !== void 0) {
+		const initializer = unwrapExpression(declaration.initializer);
+		if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) return Object.freeze({
+			body: initializer.body,
+			declaration,
+			kind: "present-supported"
+		});
+	}
+	return Object.freeze({
+		declaration,
+		kind: "present-unsupported"
+	});
+};
+/**
+* Classifies a directly exported callable value such as an instruction loader.
+* @param analysis The indexed source.
+* @param symbol The exact bound symbol.
+* @returns The symbol state for conservative call matching.
+*/
+var getCallableExportState = (analysis, symbol) => {
+	const runtimeExport = getRuntimeExport(analysis, symbol);
+	return runtimeExport.kind === "present-supported" ? Object.freeze({
+		declaration: runtimeExport.declaration,
+		kind: "present-supported"
+	}) : runtimeExport;
+};
+/**
+* Classifies a directly exported constant and returns its static initializer.
+* @param analysis The indexed source.
+* @param symbol The exact bound symbol.
+* @returns The symbol state and initializer when supported.
+*/
+var getConstExport = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind === "present-supported" && ts.isVariableDeclaration(exported.declaration) && exported.declaration.initializer !== void 0) return Object.freeze({
+		declaration: exported.declaration,
+		expression: unwrapExpression(exported.declaration.initializer),
+		kind: "present-supported"
+	});
+	return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+};
+//#endregion
+//#region src/source-analysis/source-analysis.ts
+var GOOGLE_GENAI_SOURCE_CONFIG = Object.freeze({
+	importConfig: Object.freeze({
+		namedConstructorImports: Object.freeze(["GoogleGenAI"]),
+		packageName: "@google/genai",
+		supportsDefaultConstructorImport: false
+	}),
+	requestConfig: Object.freeze({
+		acceptedArgumentCounts: Object.freeze([1]),
+		methodName: "generateContent",
+		relationshipNames: Object.freeze(["config"]),
+		resourceName: "models"
+	})
+});
+/**
+* Parses and indexes one supported TypeScript source without execution.
+* @param path The normalized logical source path.
+* @param bytes The exact source bytes returned by the repository reader.
+* @param signal The active inspection signal.
+* @returns A source analysis or stable invalid source result.
+* @throws If source analysis is aborted.
+*/
+var analyzeGoogleGenAiSource = (path, bytes, signal) => {
+	const result = analyzeSource(path, bytes, GOOGLE_GENAI_SOURCE_CONFIG, signal);
+	if (result.kind !== "valid") return result;
+	return Object.freeze({
+		analysis: Object.freeze({
+			...result.analysis,
+			googleGenAiConstructorNames: result.analysis.constructorNames,
+			path
+		}),
+		kind: "valid"
+	});
+};
+//#endregion
+//#region src/source-analysis/generate-content.ts
+var ABSENT_RELATIONSHIP = Object.freeze({ kind: "absent" });
+var UNRESOLVED_RELATIONSHIP = Object.freeze({ kind: "unresolved" });
+var analyzeConfig = (config) => {
+	if (config.kind === "absent") return Object.freeze({
+		systemInstruction: ABSENT_RELATIONSHIP,
+		tools: ABSENT_RELATIONSHIP
+	});
+	if (config.kind === "unresolved") return Object.freeze({
+		systemInstruction: UNRESOLVED_RELATIONSHIP,
+		tools: UNRESOLVED_RELATIONSHIP
+	});
+	const expression = unwrapExpression(config.expression);
+	if (!ts.isObjectLiteralExpression(expression)) return Object.freeze({
+		systemInstruction: UNRESOLVED_RELATIONSHIP,
+		tools: UNRESOLVED_RELATIONSHIP
+	});
+	const relationships = analyzeObjectRelationships(expression, ["systemInstruction", "tools"]);
+	return Object.freeze({
+		systemInstruction: relationships.relationships.get("systemInstruction") ?? ABSENT_RELATIONSHIP,
+		tools: relationships.relationships.get("tools") ?? ABSENT_RELATIONSHIP
+	});
+};
+/**
+* Finds every direct generate-content request owned by one runtime-agent body.
+* @param analysis The indexed runtime source.
+* @param body The supported runtime-agent lexical body.
+* @param signal The active inspection signal.
+* @returns Recognized requests and conservative ambiguity state.
+* @throws If request analysis is aborted.
+*/
+var analyzeGoogleGenAiGenerateContent = (analysis, body, signal) => {
+	const result = analyzeClientRequests(analysis, body, GOOGLE_GENAI_SOURCE_CONFIG.requestConfig, signal);
+	const requests = result.requests.map(({ object, relationships }) => {
+		const config = relationships.get("config") ?? ABSENT_RELATIONSHIP;
+		const nested = analyzeConfig(config);
+		return Object.freeze({
+			config,
+			object,
+			systemInstruction: nested.systemInstruction,
+			tools: nested.tools
+		});
+	});
+	return Object.freeze({
+		hasAmbiguousCandidate: result.hasAmbiguousCandidate,
+		requests: Object.freeze(requests)
+	});
+};
+//#endregion
+//#region src/source-analysis/function-declarations.ts
+var ALLOWED_FUNCTION_DECLARATION_PROPERTIES = /* @__PURE__ */ new Set([
+	"behavior",
+	"description",
+	"name",
+	"parametersJsonSchema",
+	"response",
+	"responseJsonSchema"
+]);
+var isSupportedParametersJsonSchema = (expression, analysis, inputSchemaReference) => {
+	const candidate = unwrapExpression(expression);
+	return ts.isObjectLiteralExpression(candidate) && isStaticLiteralValue(candidate) || ts.isIdentifier(candidate) && inputSchemaReference?.symbol !== void 0 && isBoundIdentifier(candidate, analysis, inputSchemaReference);
+};
+/**
+* Validates one closed Google Gen AI function-declaration object.
+* @param analysis The source containing the declaration.
+* @param object The function-declaration object literal.
+* @param inputSchemaReference The optional exact manifest input-schema binding.
+* @returns Its supported static shape or an unsupported observation.
+*/
+var getGoogleGenAiFunctionDeclarationObjectShape = (analysis, object, inputSchemaReference) => {
+	if (object.properties.some((property) => !ts.isPropertyAssignment(property))) return { kind: "present-unsupported" };
+	const properties = getClosedObjectProperties(object);
+	if (properties === null || [...properties.keys()].some((propertyName) => !ALLOWED_FUNCTION_DECLARATION_PROPERTIES.has(propertyName))) return { kind: "present-unsupported" };
+	const name = properties.get("name");
+	const description = properties.get("description");
+	const parametersJsonSchema = properties.get("parametersJsonSchema");
+	const detectedName = getStaticString(name);
+	if (name === void 0 || detectedName === null || description !== void 0 && getStaticString(description) === null || parametersJsonSchema !== void 0 && !isSupportedParametersJsonSchema(parametersJsonSchema, analysis, inputSchemaReference)) return { kind: "present-unsupported" };
+	return Object.freeze({
+		detectedName,
+		kind: "present-supported",
+		name,
+		object,
+		parametersJsonSchema: parametersJsonSchema ?? null,
+		properties
+	});
+};
+/**
+* Resolves a directly exported constant function declaration.
+* @param analysis The source containing the declared registration.
+* @param symbol The exact exported registration symbol.
+* @param inputSchemaReference The optional exact manifest input-schema binding.
+* @returns The absent, unsupported, or supported registration shape.
+*/
+var getGoogleGenAiFunctionDeclarationShape = (analysis, symbol, inputSchemaReference) => {
+	const exported = getConstExport(analysis, symbol);
+	if (exported.kind === "absent") return { kind: "absent" };
+	if (exported.kind !== "present-supported" || exported.expression === void 0 || !ts.isObjectLiteralExpression(exported.expression)) return { kind: "present-unsupported" };
+	return getGoogleGenAiFunctionDeclarationObjectShape(analysis, exported.expression, inputSchemaReference);
+};
+/**
+* Checks the version-matched Google Gen AI SDK function-name declaration limits.
+* @param name The exact statically detected function name.
+* @returns Whether the name satisfies both scalar-length and ASCII-pattern limits.
+*/
+var isGoogleGenAiFunctionNameValid = (name) => {
+	const scalarLength = [...name].length;
+	return scalarLength >= 1 && scalarLength <= 128 && GOOGLE_GENAI_FUNCTION_NAME_PATTERN.test(name);
+};
+//#endregion
+//#region src/source-analysis/tool-collections.ts
+var ALLOWED_TOOL_PROPERTIES = /* @__PURE__ */ new Set([
+	"codeExecution",
+	"computerUse",
+	"enterpriseWebSearch",
+	"exaAiSearch",
+	"fileSearch",
+	"functionDeclarations",
+	"googleMaps",
+	"googleSearch",
+	"googleSearchRetrieval",
+	"mcpServers",
+	"parallelAiSearch",
+	"retrieval",
+	"urlContext"
+]);
+var getDirectIdentifier = (expression) => {
+	const candidate = unwrapExpression(expression);
+	return ts.isIdentifier(candidate) ? candidate : null;
+};
+var collectDirectIdentifiers = (expressions) => new Set(expressions.map((expression) => getDirectIdentifier(expression)).filter((identifier) => identifier !== null));
+var resolveArray = (expression, analysis, allowedReferences) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isArrayLiteralExpression(candidate)) return Object.freeze({
+		expression: candidate,
+		isClosed: true
+	});
+	const moduleArray = getSafeModuleConstLiteral(candidate, analysis, allowedReferences, "array");
+	return moduleArray === null || !ts.isArrayLiteralExpression(moduleArray.expression) ? null : Object.freeze({
+		expression: moduleArray.expression,
+		isClosed: true
+	});
+};
+var getArrayElements = (array) => {
+	const expressions = [];
+	let isClosed = true;
+	for (const element of array.elements) {
+		if (ts.isOmittedExpression(element) || ts.isSpreadElement(element)) {
+			isClosed = false;
+			continue;
+		}
+		expressions.push(unwrapExpression(element));
+	}
+	return Object.freeze({
+		expressions: Object.freeze(expressions),
+		isClosed
+	});
+};
+var resolveToolContainer = (expression, analysis, allowedReferences) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isObjectLiteralExpression(candidate)) return candidate;
+	const moduleObject = getSafeModuleConstLiteral(candidate, analysis, allowedReferences, "object");
+	return moduleObject !== null && ts.isObjectLiteralExpression(moduleObject.expression) ? moduleObject.expression : null;
+};
+var createReferenceKey = (path, symbol) => JSON.stringify([path, symbol]);
+/** Indexes registration positions once for direct binding-reference lookup. */
+var indexRegistrations = (registrations) => {
+	const registrationIndex = /* @__PURE__ */ new Map();
+	registrations.forEach(({ reference }, index) => {
+		const key = createReferenceKey(reference.path, reference.symbol);
+		const indexes = registrationIndex.get(key) ?? [];
+		indexes.push(index);
+		registrationIndex.set(key, indexes);
+	});
+	return new Map([...registrationIndex].map(([key, indexes]) => [key, Object.freeze(indexes)]));
+};
+var getRegistrationIndexes = (identifier, analysis, registrationIndex) => {
+	const references = resolveBindingReferences(identifier, analysis);
+	const matches = /* @__PURE__ */ new Set();
+	for (const reference of references) {
+		const indexes = registrationIndex.get(createReferenceKey(reference.path, reference.symbol));
+		for (const index of indexes ?? []) matches.add(index);
+	}
+	return [...matches];
+};
+var getExistingImportedReference = async (identifier, analysis, session) => {
+	const references = resolveBindingReferences(identifier, analysis).filter(({ path }) => path !== analysis.path);
+	const entries = await Promise.all(references.map(async (reference) => ({
+		entry: await session.getEntry(parseRepositoryPath(reference.path)),
+		reference
+	})));
+	session.signal?.throwIfAborted();
+	const files = entries.filter(({ entry }) => entry?.type === "file");
+	return files.length === 1 ? files[0]?.reference ?? null : null;
+};
+var resolveLocalFunctionDeclaration = (identifier, analysis, allowedReferences, inputSchema) => {
+	if (!isModuleBindingVisible(identifier, analysis)) return false;
+	const declaration = analysis.moduleConstDeclarations.get(identifier.text);
+	const initializer = declaration?.initializer === void 0 ? null : unwrapExpression(declaration.initializer);
+	return declaration !== void 0 && initializer !== null && ts.isObjectLiteralExpression(initializer) && isModuleConstValueSafe(analysis, declaration, allowedReferences, "object") && getGoogleGenAiFunctionDeclarationObjectShape(analysis, initializer, inputSchema).kind === "present-supported";
+};
+var resolveFunctionDeclaration = async (expression, analysis, allowedReferences, registrations, registrationIndex, session) => {
+	const candidate = unwrapExpression(expression);
+	if (ts.isObjectLiteralExpression(candidate)) return Object.freeze({
+		isSupported: getGoogleGenAiFunctionDeclarationObjectShape(analysis, candidate).kind === "present-supported",
+		matchingRegistrationIndexes: Object.freeze([])
+	});
+	if (!ts.isIdentifier(candidate)) return Object.freeze({
+		isSupported: false,
+		matchingRegistrationIndexes: Object.freeze([])
+	});
+	if (!isModuleValueBindingSafe(analysis, candidate.text, null, allowedReferences, "object")) return Object.freeze({
+		isSupported: false,
+		matchingRegistrationIndexes: Object.freeze([])
+	});
+	const matchingRegistrationIndexes = getRegistrationIndexes(candidate, analysis, registrationIndex);
+	const matchingRegistration = matchingRegistrationIndexes.length === 1 ? registrations[matchingRegistrationIndexes[0]] : void 0;
+	if (analysis.moduleConstDeclarations.get(candidate.text) !== void 0) return Object.freeze({
+		isSupported: resolveLocalFunctionDeclaration(candidate, analysis, allowedReferences, matchingRegistration?.inputSchema),
+		matchingRegistrationIndexes: Object.freeze(matchingRegistrationIndexes)
+	});
+	const importedReference = await getExistingImportedReference(candidate, analysis, session);
+	if (importedReference === null) return Object.freeze({
+		isSupported: false,
+		matchingRegistrationIndexes: Object.freeze(matchingRegistrationIndexes)
+	});
+	const importedResult = await session.analyzeSource(parseRepositoryPath(importedReference.path));
+	session.signal?.throwIfAborted();
+	if (importedResult.kind !== "valid") return Object.freeze({
+		isSupported: false,
+		matchingRegistrationIndexes: Object.freeze(matchingRegistrationIndexes)
+	});
+	const shape = getGoogleGenAiFunctionDeclarationShape(importedResult.analysis, importedReference.symbol, matchingRegistration?.inputSchema);
+	const declaration = importedResult.analysis.moduleConstDeclarations.get(importedReference.symbol);
+	const isSafe = declaration !== void 0 && isModuleConstValueSafe(importedResult.analysis, declaration, /* @__PURE__ */ new Set(), "object");
+	return Object.freeze({
+		isSupported: shape.kind === "present-supported" && isSafe,
+		matchingRegistrationIndexes: Object.freeze(matchingRegistrationIndexes)
+	});
+};
+/**
+* Resolves nested tools and function declarations for supported generate-content requests.
+* @param analysis The indexed runtime-agent source.
+* @param relationships The independently classified `config.tools` relationships.
+* @param registrations Declared manifest registrations in deterministic capability order.
+* @param session The operation-local repository and source-analysis session.
+* @param hasAmbiguousRequest Whether runtime request discovery found an unresolved candidate.
+* @returns Positive registrations, conservative ambiguity, and proved limit violations.
+*/
+var analyzeGoogleGenAiToolCollections = async (analysis, relationships, registrations, session, hasAmbiguousRequest) => {
+	const toolExpressions = relationships.filter((relationship) => relationship.kind === "present").map(({ expression }) => expression);
+	const allowedToolArrayReferences = collectDirectIdentifiers(toolExpressions);
+	const toolArrays = [];
+	let hasAmbiguousCandidate = hasAmbiguousRequest || relationships.some(({ kind }) => kind === "unresolved");
+	let absentExpression = null;
+	for (const expression of toolExpressions) {
+		session.signal?.throwIfAborted();
+		const array = resolveArray(expression, analysis, allowedToolArrayReferences);
+		if (array === null) {
+			hasAmbiguousCandidate = true;
+			continue;
+		}
+		toolArrays.push(array);
+		absentExpression ??= expression;
+	}
+	const toolContainerExpressions = [];
+	for (const { expression } of toolArrays) {
+		const elements = getArrayElements(expression);
+		hasAmbiguousCandidate ||= !elements.isClosed;
+		toolContainerExpressions.push(...elements.expressions);
+	}
+	const allowedToolContainerReferences = collectDirectIdentifiers(toolContainerExpressions);
+	const functionArrayExpressions = [];
+	for (const expression of toolContainerExpressions) {
+		session.signal?.throwIfAborted();
+		const container = resolveToolContainer(expression, analysis, allowedToolContainerReferences);
+		if (container === null) {
+			hasAmbiguousCandidate = true;
+			continue;
+		}
+		const properties = getClosedObjectProperties(container);
+		if (properties === null || [...properties.keys()].some((propertyName) => !ALLOWED_TOOL_PROPERTIES.has(propertyName))) {
+			hasAmbiguousCandidate = true;
+			continue;
+		}
+		const functionDeclarations = properties.get("functionDeclarations");
+		if (functionDeclarations !== void 0) functionArrayExpressions.push(functionDeclarations);
+	}
+	const allowedFunctionArrayReferences = collectDirectIdentifiers(functionArrayExpressions);
+	const functionArrays = [];
+	const resolvedFunctionArrays = /* @__PURE__ */ new Set();
+	for (const expression of functionArrayExpressions) {
+		session.signal?.throwIfAborted();
+		const array = resolveArray(expression, analysis, allowedFunctionArrayReferences);
+		if (array === null) {
+			hasAmbiguousCandidate = true;
+			continue;
+		}
+		if (!resolvedFunctionArrays.has(array.expression)) {
+			resolvedFunctionArrays.add(array.expression);
+			functionArrays.push(array);
+		}
+	}
+	const functionElements = functionArrays.map(({ expression }) => ({
+		array: expression,
+		elements: getArrayElements(expression)
+	}));
+	const allowedFunctionDeclarationReferences = collectDirectIdentifiers(functionElements.flatMap(({ elements }) => elements.expressions));
+	const presentRegistrationIndexes = /* @__PURE__ */ new Set();
+	const limitViolationExpressions = [];
+	const countedArrays = /* @__PURE__ */ new Set();
+	const resolutionCache = /* @__PURE__ */ new Map();
+	const registrationIndex = indexRegistrations(registrations);
+	for (const { array, elements } of functionElements) {
+		session.signal?.throwIfAborted();
+		let isClosed = elements.isClosed;
+		for (const expression of elements.expressions) {
+			const identifier = getDirectIdentifier(expression);
+			const cacheKey = identifier === null ? null : JSON.stringify({
+				name: identifier.text,
+				references: resolveBindingReferences(identifier, analysis)
+			});
+			let resolutionPromise = cacheKey === null ? void 0 : resolutionCache.get(cacheKey);
+			if (resolutionPromise === void 0) {
+				resolutionPromise = resolveFunctionDeclaration(expression, analysis, allowedFunctionDeclarationReferences, registrations, registrationIndex, session);
+				if (cacheKey !== null) resolutionCache.set(cacheKey, resolutionPromise);
+			}
+			const resolution = await resolutionPromise;
+			session.signal?.throwIfAborted();
+			if (!resolution.isSupported || resolution.matchingRegistrationIndexes.length > 1) {
+				isClosed = false;
+				continue;
+			}
+			if (resolution.matchingRegistrationIndexes.length === 1) presentRegistrationIndexes.add(resolution.matchingRegistrationIndexes[0]);
+		}
+		if (!isClosed) hasAmbiguousCandidate = true;
+		else if (elements.expressions.length > 512 && !countedArrays.has(array)) {
+			countedArrays.add(array);
+			limitViolationExpressions.push(array);
+		}
+	}
+	return Object.freeze({
+		absentExpression,
+		hasAmbiguousCandidate,
+		limitViolationExpressions: Object.freeze(limitViolationExpressions),
+		presentRegistrationIndexes
+	});
+};
+//#endregion
+//#region src/diagnostics/index.ts
+var GOOGLE_GENAI_ADAPTER_DIAGNOSTICS = Object.freeze({
+	GOOGLE_GENAI_FUNCTION_DECLARATION_LIMIT_EXCEEDED: "The detected Google Gen AI function-declaration collection exceeds the supported SDK declaration limit.",
+	GOOGLE_GENAI_INSTRUCTION_LOADER_NOT_WIRED: "The declared instruction loader is not wired to the detected Google Gen AI generate-content configuration.",
+	GOOGLE_GENAI_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND: "The declared instruction-loader symbol was not found.",
+	GOOGLE_GENAI_PACKAGE_MANIFEST_INVALID: "The owning package manifest is invalid for Google Gen AI dependency detection.",
+	GOOGLE_GENAI_RUNTIME_AGENT_SYMBOL_NOT_FOUND: "The declared runtime-agent symbol was not found.",
+	GOOGLE_GENAI_SDK_VERSION_UNSUPPORTED: "The observed Google Gen AI SDK dependency range is disjoint from the supported range.",
+	GOOGLE_GENAI_SOURCE_SYNTAX_INVALID: "The referenced Google Gen AI source file contains invalid TypeScript syntax.",
+	GOOGLE_GENAI_SOURCE_TEXT_INVALID: "The referenced Google Gen AI source file is not valid normalized text.",
+	GOOGLE_GENAI_TOOL_INPUT_SCHEMA_NOT_WIRED: "The declared tool input schema is not wired to the detected function declaration's parameters JSON schema.",
+	GOOGLE_GENAI_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared tool input-schema symbol was not found.",
+	GOOGLE_GENAI_TOOL_NAME_INVALID: "The detected Google Gen AI function name violates the supported SDK declaration limit.",
+	GOOGLE_GENAI_TOOL_NAME_MISMATCH: "The declared tool name does not match the detected Google Gen AI function name.",
+	GOOGLE_GENAI_TOOL_REGISTRATION_NOT_WIRED: "The declared tool registration is not wired to the detected Google Gen AI function-declaration collection.",
+	GOOGLE_GENAI_TOOL_REGISTRATION_SYMBOL_NOT_FOUND: "The declared tool-registration symbol was not found."
+});
+/**
+* Creates one frozen, safely namespaced Google Gen AI adapter diagnostic.
+* @param input The complete code, location, entity, and safe scalar details.
+* @returns The immutable adapter diagnostic.
+*/
+var createGoogleGenAiDiagnostic = (input) => Object.freeze({
+	...input,
+	details: Object.freeze({ ...input.details }),
+	entity: input.entity === null ? null : Object.freeze({ ...input.entity }),
+	message: GOOGLE_GENAI_ADAPTER_DIAGNOSTICS[input.code],
+	source: GOOGLE_GENAI_ADAPTER_ID
+});
+//#endregion
+//#region src/inspection/common.ts
+/** Compares exact strings without locale-dependent behavior. */
+var compareGoogleGenAiStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var freezeReference = (reference) => Object.freeze({
+	path: reference.path,
+	...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+});
+/**
+* Creates one deeply immutable Google Gen AI evidence record.
+* @param evidence The complete evidence value.
+* @returns The frozen evidence record.
+*/
+var createGoogleGenAiEvidence = (evidence) => Object.freeze({
+	...evidence,
+	details: Object.freeze({ ...evidence.details }),
+	references: Object.freeze(evidence.references.map(freezeReference))
+});
+var createEntity = (agentId, capabilityId) => Object.freeze({
+	adapterId: GOOGLE_GENAI_ADAPTER_ID,
+	agentId,
+	...capabilityId === void 0 ? {} : {
+		capabilityId,
+		capabilityKind: "tool"
+	}
+});
+/**
+* Appends one stable package-owned diagnostic.
+* @param diagnostics The operation result collection.
+* @param code The stable diagnostic code.
+* @param path The exact affected path.
+* @param agentId The owning agent identifier.
+* @param range The optional scalar source range.
+* @param capabilityId The optional owning tool capability.
+*/
+var addGoogleGenAiDiagnostic = (diagnostics, code, path, agentId, range = null, capabilityId) => {
+	diagnostics.push(createGoogleGenAiDiagnostic({
+		code,
+		details: {},
+		entity: createEntity(agentId, capabilityId),
+		path,
+		pointer: null,
+		range
+	}));
+};
+/**
+* Loads and validates one supported bound TypeScript source.
+* @param session The operation-local inspection session.
+* @param reference The exact manifest reference.
+* @param diagnostics The operation result collection.
+* @param agentId The owning agent identifier.
+* @param capabilityId The optional owning tool capability.
+* @returns The indexed source or `null` after unsupported or invalid input.
+*/
+var analyzeGoogleGenAiBoundReference = async (session, reference, diagnostics, agentId, capabilityId) => {
+	if (!isSupportedTypeScriptSourcePath(reference.path)) return null;
+	const result = await session.analyzeSource(reference.path);
+	if (result.kind === "invalid-text") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_SOURCE_TEXT_INVALID", reference.path, agentId, null, capabilityId);
+		return null;
+	}
+	if (result.kind === "invalid-syntax") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_SOURCE_SYNTAX_INVALID", reference.path, agentId, result.range, capabilityId);
+		return null;
+	}
+	return result.analysis;
+};
+//#endregion
+//#region src/inspection/package-inspection.ts
+/**
+* Inspects the nearest owning package manifest for one agent runtime source.
+* @param session The operation-local inspection session.
+* @param sourcePath The runtime-agent source path.
+* @param evidence The operation evidence collection.
+* @param diagnostics The operation diagnostic collection.
+* @param agentId The owning agent identifier.
+*/
+var inspectGoogleGenAiPackage = async (session, sourcePath, evidence, diagnostics, agentId) => {
+	const discovery = await session.discoverPackage(sourcePath);
+	if (discovery.kind === "absent") return;
+	if (discovery.kind === "invalid") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_PACKAGE_MANIFEST_INVALID", discovery.path, agentId);
+		return;
+	}
+	const { observation } = discovery;
+	if (observation.compatibility === "unsupported") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_SDK_VERSION_UNSUPPORTED", observation.path, agentId);
+		return;
+	}
+	for (const declaration of observation.declarations) evidence.push(createGoogleGenAiEvidence({
+		agentId,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			compatibility: observation.compatibility,
+			declaredRange: declaration.declaredRange,
+			dependencyKind: declaration.dependencyKind
+		},
+		kind: "runtime-package",
+		references: [{ path: observation.path }],
+		runtimeName: GOOGLE_GENAI_SDK_PACKAGE_NAME,
+		source: GOOGLE_GENAI_ADAPTER_ID
+	}));
+};
+//#endregion
+//#region src/inspection/relationships.ts
+var getExpressionRange = (analysis, expression) => expression === null ? null : analysis.text.locator.locateRange(expression.getStart(), expression.end);
+var inspectInputSchema = async (session, agent, capabilityId, reference, registrationAnalysis, parametersJsonSchema, evidence, diagnostics) => {
+	if (reference.symbol === void 0) return;
+	const schemaAnalysis = await analyzeGoogleGenAiBoundReference(session, reference, diagnostics, agent.id, capabilityId);
+	if (schemaAnalysis === null) return;
+	const schema = getConstExport(schemaAnalysis, reference.symbol);
+	if (schema.kind === "absent") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND", reference.path, agent.id, null, capabilityId);
+		return;
+	}
+	if (schema.kind !== "present-supported" || parametersJsonSchema === null) {
+		if (schema.kind === "present-supported" && parametersJsonSchema === null) addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_TOOL_INPUT_SCHEMA_NOT_WIRED", registrationAnalysis.path, agent.id, null, capabilityId);
+		return;
+	}
+	if (parametersJsonSchema === void 0) return;
+	const relationship = classifySchemaRelationship(registrationAnalysis, parametersJsonSchema, reference);
+	if (relationship.kind === "present") evidence.push(createGoogleGenAiEvidence({
+		agentId: agent.id,
+		capabilityId,
+		capabilityKind: "tool",
+		details: {
+			requestProperty: "parametersJsonSchema",
+			schemaRole: "input"
+		},
+		kind: "schema",
+		references: [{ path: registrationAnalysis.path }, {
+			path: reference.path,
+			symbol: reference.symbol
+		}],
+		runtimeName: reference.symbol,
+		source: GOOGLE_GENAI_ADAPTER_ID
+	}));
+	else if (relationship.kind === "absent") addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_TOOL_INPUT_SCHEMA_NOT_WIRED", registrationAnalysis.path, agent.id, getExpressionRange(registrationAnalysis, relationship.expression), capabilityId);
+};
+var inspectRegistration = async (session, agent, capabilityId, tool, evidence, diagnostics) => {
+	const reference = tool.registration;
+	if (reference?.symbol === void 0) return null;
+	const registrationAnalysis = await analyzeGoogleGenAiBoundReference(session, reference, diagnostics, agent.id, capabilityId);
+	if (registrationAnalysis === null) return null;
+	const shape = getGoogleGenAiFunctionDeclarationShape(registrationAnalysis, reference.symbol, tool.inputSchema);
+	if (shape.kind === "absent") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_TOOL_REGISTRATION_SYMBOL_NOT_FOUND", reference.path, agent.id, null, capabilityId);
+		return null;
+	}
+	const declaration = registrationAnalysis.moduleConstDeclarations.get(reference.symbol);
+	if (declaration === void 0 || !isModuleConstValueSafe(registrationAnalysis, declaration, /* @__PURE__ */ new Set(), "object")) return null;
+	if (shape.kind === "present-unsupported") {
+		if (tool.inputSchema !== void 0) await inspectInputSchema(session, agent, capabilityId, tool.inputSchema, registrationAnalysis, void 0, evidence, diagnostics);
+		return null;
+	}
+	const isNameMatch = shape.detectedName === tool.name;
+	const isNameValid = isGoogleGenAiFunctionNameValid(shape.detectedName);
+	if (!isNameMatch) addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_TOOL_NAME_MISMATCH", registrationAnalysis.path, agent.id, getExpressionRange(registrationAnalysis, shape.name), capabilityId);
+	if (!isNameValid) addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_TOOL_NAME_INVALID", registrationAnalysis.path, agent.id, getExpressionRange(registrationAnalysis, shape.name), capabilityId);
+	if (tool.inputSchema !== void 0) await inspectInputSchema(session, agent, capabilityId, tool.inputSchema, registrationAnalysis, shape.parametersJsonSchema, evidence, diagnostics);
+	return Object.freeze({
+		analysis: registrationAnalysis,
+		capabilityId,
+		detectedName: shape.detectedName,
+		...tool.inputSchema === void 0 ? {} : { inputSchema: tool.inputSchema },
+		isNameMatch,
+		isNameValid,
+		reference: Object.freeze({
+			path: reference.path,
+			symbol: reference.symbol
+		}),
+		shape
+	});
+};
+var inspectInstructionLoader = async (session, agent, runtimeAnalysis, generateContent, evidence, diagnostics) => {
+	const reference = agent.declaration.bindings?.instructionLoader;
+	if (reference?.symbol === void 0) return;
+	const loaderAnalysis = await analyzeGoogleGenAiBoundReference(session, reference, diagnostics, agent.id);
+	if (loaderAnalysis === null) return;
+	const loader = getCallableExportState(loaderAnalysis, reference.symbol);
+	if (loader.kind === "absent") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND", reference.path, agent.id);
+		return;
+	}
+	if (loader.kind === "present-unsupported") return;
+	const relationship = classifyDirectCallRelationship(runtimeAnalysis, generateContent.requests.map((request) => request.systemInstruction), generateContent.hasAmbiguousCandidate, reference);
+	if (relationship.kind === "present") evidence.push(createGoogleGenAiEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { requestProperty: "config.systemInstruction" },
+		kind: "instruction-loader",
+		references: [{ path: runtimeAnalysis.path }, {
+			path: reference.path,
+			symbol: reference.symbol
+		}],
+		runtimeName: reference.symbol,
+		source: GOOGLE_GENAI_ADAPTER_ID
+	}));
+	else if (relationship.kind === "absent") addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_INSTRUCTION_LOADER_NOT_WIRED", runtimeAnalysis.path, agent.id, getExpressionRange(runtimeAnalysis, relationship.expression));
+};
+var inspectToolRelationships = async (session, agent, runtimeAnalysis, generateContent, evidence, diagnostics) => {
+	const registrations = [];
+	for (const capabilityId of Object.keys(agent.declaration.tools ?? {}).sort(compareGoogleGenAiStrings)) {
+		const tool = agent.declaration.tools?.[capabilityId];
+		if (tool === void 0) continue;
+		const registration = await inspectRegistration(session, agent, capabilityId, tool, evidence, diagnostics);
+		if (registration !== null) registrations.push(registration);
+	}
+	const collectionRegistrations = registrations.map(({ inputSchema, reference }) => Object.freeze({
+		...inputSchema === void 0 ? {} : { inputSchema },
+		reference
+	}));
+	const collections = await analyzeGoogleGenAiToolCollections(runtimeAnalysis, generateContent.requests.map((request) => request.tools), collectionRegistrations, session, generateContent.hasAmbiguousCandidate);
+	for (const expression of collections.limitViolationExpressions) addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_FUNCTION_DECLARATION_LIMIT_EXCEEDED", runtimeAnalysis.path, agent.id, getExpressionRange(runtimeAnalysis, expression));
+	registrations.forEach((registration, index) => {
+		if (collections.presentRegistrationIndexes.has(index)) {
+			if (registration.isNameMatch && registration.isNameValid) evidence.push(createGoogleGenAiEvidence({
+				agentId: agent.id,
+				capabilityId: registration.capabilityId,
+				capabilityKind: "tool",
+				details: { toolType: "function-declaration" },
+				kind: "tool-registration",
+				references: [{ path: runtimeAnalysis.path }, {
+					path: registration.reference.path,
+					symbol: registration.reference.symbol
+				}],
+				runtimeName: registration.detectedName,
+				source: GOOGLE_GENAI_ADAPTER_ID
+			}));
+			return;
+		}
+		if (!collections.hasAmbiguousCandidate) addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_TOOL_REGISTRATION_NOT_WIRED", runtimeAnalysis.path, agent.id, getExpressionRange(runtimeAnalysis, collections.absentExpression), registration.capabilityId);
+	});
+};
+/**
+* Inspects loader, tool-registration, input-schema, and provider-limit relationships.
+* @param session The operation-local inspection session.
+* @param agent The indexed agent declaration.
+* @param runtimeAnalysis The indexed runtime-agent source.
+* @param generateContent The nested generate-content request analysis.
+* @param evidence The operation evidence collection.
+* @param diagnostics The operation diagnostic collection.
+*/
+var inspectGoogleGenAiRelationships = async (session, agent, runtimeAnalysis, generateContent, evidence, diagnostics) => {
+	await inspectInstructionLoader(session, agent, runtimeAnalysis, generateContent, evidence, diagnostics);
+	await inspectToolRelationships(session, agent, runtimeAnalysis, generateContent, evidence, diagnostics);
+};
+//#endregion
+//#region src/package-discovery/index.ts
+/**
+* Discovers the nearest relevant Google Gen AI package declaration without enumeration.
+* @param repository The Core-owned budget-aware repository reader.
+* @param sourcePath The bound source whose package scope is inspected.
+* @param signal The active inspection signal.
+* @returns The first observed declaration, invalid manifest, or absence result.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A repository reading resource limit was exceeded.
+* - ABORTED: The repository operation was aborted.
+*/
+var discoverGoogleGenAiPackage = async (repository, sourcePath, signal) => {
+	const repositoryOptions = signal === void 0 ? void 0 : { signal };
+	const result = await discoverPackage({
+		packageName: GOOGLE_GENAI_SDK_PACKAGE_NAME,
+		reader: {
+			getEntry: (path) => repository.getEntry(parseRepositoryPath(path), repositoryOptions),
+			readFile: (path) => repository.readFile(parseRepositoryPath(path), repositoryOptions)
+		},
+		...signal === void 0 ? {} : { signal },
+		sourcePath,
+		supportedRange: GOOGLE_GENAI_SDK_SUPPORTED_RANGE
+	});
+	if (result.kind === "invalid") return Object.freeze({
+		kind: "invalid",
+		path: parseRepositoryPath(result.path)
+	});
+	if (result.kind === "observed") return Object.freeze({
+		kind: "observed",
+		observation: Object.freeze({
+			...result.observation,
+			path: parseRepositoryPath(result.observation.path)
+		})
+	});
+	return result;
+};
+//#endregion
+//#region src/inspection/session.ts
+/**
+* Creates one operation-local Google Gen AI inspection session and its deterministic caches.
+* @param context The Core-owned adapter context.
+* @returns The source and package analysis session.
+*/
+var createGoogleGenAiInspectionSession = (context) => createInspectionSession({
+	analyzeSource: analyzeGoogleGenAiSource,
+	discoverPackage: (path, signal) => discoverGoogleGenAiPackage(context.repository, path, signal),
+	getEntry: (path, signal) => context.repository.getEntry(path, signal === void 0 ? void 0 : { signal }),
+	readFile: (path, signal) => context.repository.readFile(path, signal === void 0 ? void 0 : { signal }),
+	...context.signal === void 0 ? {} : { signal: context.signal }
+});
+//#endregion
+//#region src/inspection/inspection.ts
+var inspectAgent = async (session, agent, evidence, diagnostics) => {
+	const runtimeAgent = agent.declaration.bindings?.runtimeAgent;
+	if (runtimeAgent === void 0) return;
+	await inspectGoogleGenAiPackage(session, runtimeAgent.path, evidence, diagnostics, agent.id);
+	if (!isSupportedTypeScriptSourcePath(runtimeAgent.path)) return;
+	evidence.push(createGoogleGenAiEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { language: "typescript" },
+		kind: "language",
+		references: [runtimeAgent.symbol === void 0 ? { path: runtimeAgent.path } : {
+			path: runtimeAgent.path,
+			symbol: runtimeAgent.symbol
+		}],
+		runtimeName: null,
+		source: GOOGLE_GENAI_ADAPTER_ID
+	}));
+	if (runtimeAgent.symbol === void 0) return;
+	const analysis = await analyzeGoogleGenAiBoundReference(session, runtimeAgent, diagnostics, agent.id);
+	if (analysis === null) return;
+	const runtimeExport = getRuntimeExport(analysis, runtimeAgent.symbol);
+	if (runtimeExport.kind === "absent") {
+		addGoogleGenAiDiagnostic(diagnostics, "GOOGLE_GENAI_RUNTIME_AGENT_SYMBOL_NOT_FOUND", runtimeAgent.path, agent.id);
+		return;
+	}
+	if (runtimeExport.kind === "present-unsupported" || runtimeExport.body === void 0) return;
+	const generateContent = analyzeGoogleGenAiGenerateContent(analysis, runtimeExport.body, session.signal);
+	if (generateContent.requests.length === 0) return;
+	evidence.push(createGoogleGenAiEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { api: "models" },
+		kind: "runtime-pattern",
+		references: [{
+			path: runtimeAgent.path,
+			symbol: runtimeAgent.symbol
+		}],
+		runtimeName: GOOGLE_GENAI_GENERATE_CONTENT_RUNTIME_NAME,
+		source: GOOGLE_GENAI_ADAPTER_ID
+	}));
+	await inspectGoogleGenAiRelationships(session, agent, analysis, generateContent, evidence, diagnostics);
+};
+/**
+* Inspects all scoped Google Gen AI agents through one deterministic operation-local session.
+* @param context The Core-provided immutable adapter context.
+* @returns A promise resolving to source-grounded evidence and diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A repository reading resource limit was exceeded.
+* - ABORTED: The repository operation or inspection signal was aborted.
+*/
+var inspectGoogleGenAi = async (context) => {
+	context.signal?.throwIfAborted();
+	const session = createGoogleGenAiInspectionSession(context);
+	const evidence = [];
+	const diagnostics = [];
+	const agents = [...context.agents].sort((left, right) => compareGoogleGenAiStrings(left.id, right.id));
+	for (const agent of agents) {
+		context.signal?.throwIfAborted();
+		await inspectAgent(session, agent, evidence, diagnostics);
+	}
+	context.signal?.throwIfAborted();
+	return Object.freeze({
+		diagnostics: Object.freeze(diagnostics),
+		evidence: Object.freeze(evidence)
+	});
+};
+//#endregion
+//#region src/adapter/index.ts
+var googleGenAiAdapter = Object.freeze({
+	id: GOOGLE_GENAI_ADAPTER_ID,
+	inspect: inspectGoogleGenAi,
+	supportedRepositoryFormatVersions: GOOGLE_GENAI_SUPPORTED_REPOSITORY_FORMAT_VERSIONS
+});
+//#endregion
+export { googleGenAiAdapter };