@cmflow/atlas 3.4.0-alpha.1

package/dist/bin/atlas.mjs

@@ -0,0 +1,4514 @@
+#!/usr/bin/env node
+import { Command, InvalidArgumentError, Option } from "commander";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { cancel, intro, log, note, outro, progress, spinner } from "@clack/prompts";
+import fs from "node:fs/promises";
+import { createDirectus, createItem, deleteItem, readItems, rest, staticToken, updateItem } from "@directus/sdk";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { globby } from "globby";
+import { Node, Project, SyntaxKind } from "ts-morph";
+import { minimatch } from "minimatch";
+import fs$1 from "node:fs";
+import { createHash } from "node:crypto";
+import { parse, stringify } from "yaml";
+import { Worker } from "node:worker_threads";
+import { NoObjectGeneratedError, Output, generateText } from "ai";
+import { z } from "zod";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+//#region src/utils/config.ts
+let _config;
+function setUserConfig(config) {
+	_config = config;
+}
+function getUserConfig() {
+	if (!_config) throw new Error("Atlas config not loaded. Run Atlas from a directory containing atlas.config.ts or pass --config.");
+	return _config;
+}
+async function loadAtlasConfig(configPath) {
+	const filePath = path.resolve(configPath);
+	try {
+		let mod;
+		if (filePath.endsWith(".ts")) {
+			const { tsImport } = await import("tsx/esm/api");
+			mod = await tsImport(filePath, import.meta.url);
+		} else mod = await import(pathToFileURL(filePath).href);
+		const config = mod.default ?? mod;
+		const repoRoot = config.repoRoot || process.cwd();
+		return {
+			...config,
+			repoRoot,
+			cwd: repoRoot
+		};
+	} catch (error) {
+		throw new Error(`Unable to load Atlas configuration at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+//#endregion
+//#region src/services/taskProgressService.ts
+function formatDuration(durationMs) {
+	if (durationMs < 1e3) return `${durationMs}ms`;
+	return `${(durationMs / 1e3).toFixed(1)}s`;
+}
+var TaskProgressService = class {
+	#storage = new AsyncLocalStorage();
+	attach(sink, task) {
+		return this.#storage.run(sink, task);
+	}
+	log(message) {
+		this.#storage.getStore()?.log(message);
+	}
+	report(message) {
+		const sink = this.#storage.getStore();
+		(sink?.report || sink?.log)?.(message);
+	}
+	createStepProgress(classify = (message) => ({
+		id: message,
+		title: message
+	})) {
+		const progress = spinner();
+		let active;
+		const finishActive = (label) => {
+			if (!active) return;
+			const duration = formatDuration(Date.now() - active.startedAt);
+			progress.stop(`${label || active.completedTitle || `${active.title} completed`} (${duration})`);
+			active = void 0;
+		};
+		const start = (step) => {
+			if (active?.id === step.id) {
+				progress.message(step.detail ? `${step.title}: ${step.detail}` : step.title);
+				return;
+			}
+			finishActive();
+			active = {
+				id: step.id,
+				title: step.title,
+				completedTitle: step.completedTitle,
+				startedAt: Date.now()
+			};
+			progress.start(step.detail ? `${step.title}: ${step.detail}` : step.title);
+		};
+		const execute = (task) => this.attach({
+			log: (message) => progress.message(active ? `${active.title}: ${message}` : message),
+			report: (message) => start(classify(message))
+		}, task);
+		return {
+			report(message) {
+				start(classify(message));
+			},
+			start,
+			execute,
+			run: async (step, task) => {
+				start(step);
+				await new Promise((resolve) => setImmediate(resolve));
+				const result = await execute(task);
+				finishActive();
+				return result;
+			},
+			finish(label) {
+				finishActive(label);
+			},
+			fail(label) {
+				if (!active) return;
+				const duration = formatDuration(Date.now() - active.startedAt);
+				progress.stop(`${label} (${duration})`);
+				active = void 0;
+			}
+		};
+	}
+};
+const taskProgressService = new TaskProgressService();
+//#endregion
+//#region src/utils/catalogueStats.ts
+function calculateNeedsReviewPercentage(inputProperties, outputProperties, needsReview) {
+	const properties = inputProperties + outputProperties;
+	return properties ? Number((needsReview / properties * 100).toFixed(2)) : 0;
+}
+//#endregion
+//#region src/services/analysisFileService.ts
+function shouldKeepAnalysisFile(filePath) {
+	const normalizedProjectPath = filePath.replaceAll(path.sep, "/").replace(/^.*?(app\/)/, "app/");
+	return !getUserConfig().analysis.excluded.some((pattern) => minimatch(normalizedProjectPath, pattern, { dot: true }));
+}
+function filterAnalysisFiles(filePaths) {
+	return filePaths.filter(shouldKeepAnalysisFile);
+}
+//#endregion
+//#region src/services/useCaseAnalysisService.ts
+function normalizeCodeText(value) {
+	return value.replace(/\s+/g, " ").replace(/;$/, "").trim();
+}
+function describeRuleEffect(node) {
+	if (Node.isBlock(node)) return node.getStatements().map(describeRuleEffect).filter(Boolean).join("; ");
+	if (Node.isReturnStatement(node)) return node.getExpression() ? `return ${normalizeCodeText(node.getExpression().getText())}` : "return";
+	if (Node.isThrowStatement(node)) return `throw ${normalizeCodeText(node.getExpression().getText())}`;
+	if (Node.isExpressionStatement(node)) {
+		const expression = node.getExpression();
+		if (Node.isCallExpression(expression)) {
+			const callee = expression.getExpression();
+			if (Node.isPropertyAccessExpression(callee) && ["push", "unshift"].includes(callee.getName())) return `add ${expression.getArguments().map((argument) => normalizeCodeText(argument.getText())).join(", ")} to ${normalizeCodeText(callee.getExpression().getText())}`;
+		}
+		return normalizeCodeText(expression.getText());
+	}
+	return normalizeCodeText(node.getText());
+}
+function extractUseCaseRules(sourceFile) {
+	return sourceFile.getDescendantsOfKind(SyntaxKind.IfStatement).map((statement) => ({
+		condition: normalizeCodeText(statement.getExpression().getText()),
+		effect: describeRuleEffect(statement.getThenStatement()),
+		elseEffect: statement.getElseStatement() ? describeRuleEffect(statement.getElseStatement()) : void 0,
+		sourceFile: sourceFile.getFilePath()
+	}));
+}
+function getAggregationTarget(call) {
+	let current = call;
+	while (current) {
+		const parent = current.getParent();
+		if (!parent) return void 0;
+		if (Node.isVariableDeclaration(parent)) return normalizeCodeText(parent.getName());
+		if (Node.isReturnStatement(parent)) return "return";
+		if (Node.isStatement(parent)) return void 0;
+		current = parent;
+	}
+}
+function getAggregationCondition(call) {
+	const callback = call.getArguments().find((argument) => Node.isArrowFunction(argument) || Node.isFunctionExpression(argument));
+	if (!callback || !Node.isArrowFunction(callback) && !Node.isFunctionExpression(callback)) return void 0;
+	const body = callback.getBody();
+	if (!Node.isBlock(body)) return normalizeCodeText(body.getText());
+	const condition = body.getDescendantsOfKind(SyntaxKind.IfStatement)[0]?.getExpression();
+	return condition ? normalizeCodeText(condition.getText()) : void 0;
+}
+function getAggregationType(operation, call, condition) {
+	if (operation === "reduce") return call.getDescendantsOfKind(SyntaxKind.CallExpression).some((nestedCall) => {
+		const expression = nestedCall.getExpression();
+		return Node.isPropertyAccessExpression(expression) && ["push", "unshift"].includes(expression.getName());
+	}) ? "filter" : "reduction";
+	if (operation === "find") return condition && /={2,3}/.test(condition) ? "join" : "lookup";
+	if (operation === "some") return "membership";
+	return operation === "map" ? "mapping" : "filter";
+}
+function extractUseCaseAggregations(sourceFile) {
+	const supportedOperations = /* @__PURE__ */ new Set([
+		"filter",
+		"find",
+		"map",
+		"reduce",
+		"some"
+	]);
+	const candidates = [];
+	for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression)) continue;
+		const operation = expression.getName();
+		if (!supportedOperations.has(operation)) continue;
+		const callback = call.getArguments().find((argument) => Node.isArrowFunction(argument) || Node.isFunctionExpression(argument));
+		const accumulator = operation === "reduce" && callback && (Node.isArrowFunction(callback) || Node.isFunctionExpression(callback)) ? callback.getParameters()[0]?.getName() : void 0;
+		const condition = getAggregationCondition(call);
+		const targetCollection = accumulator || getAggregationTarget(call);
+		candidates.push({
+			type: getAggregationType(operation, call, condition),
+			operation,
+			sourceCollection: normalizeCodeText(expression.getExpression().getText()),
+			targetCollection,
+			condition,
+			description: [
+				`${operation} ${normalizeCodeText(expression.getExpression().getText())}`,
+				targetCollection ? `into ${targetCollection}` : void 0,
+				condition ? `when ${condition}` : void 0
+			].filter(Boolean).join(" "),
+			sourceFile: sourceFile.getFilePath()
+		});
+	}
+	const map = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) map.set([
+		candidate.type,
+		candidate.operation,
+		candidate.sourceCollection,
+		candidate.targetCollection || "",
+		candidate.condition || "",
+		candidate.sourceFile
+	].join(":"), candidate);
+	return [...map.values()];
+}
+//#endregion
+//#region src/services/analysisCacheService.ts
+/**
+* Memoizes expensive ts-morph descendant queries for the lifetime of a source
+* file. Weak keys let TypeScript release parsed files after an analysis run.
+*/
+var AnalysisCacheService = class {
+	constructor() {
+		this.callExpressionsByFile = /* @__PURE__ */ new WeakMap();
+	}
+	getCallExpressions(sourceFile) {
+		const cached = this.callExpressionsByFile.get(sourceFile);
+		if (cached) return cached;
+		const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+		this.callExpressionsByFile.set(sourceFile, calls);
+		return calls;
+	}
+};
+const analysisCacheService = new AnalysisCacheService();
+//#endregion
+//#region src/services/openapi/downloadService.ts
+async function downloadOpenApiDocument(url, timeoutMs = getUserConfig().openapiTimeoutMs) {
+	const response = await fetch(url, {
+		headers: { accept: "application/json" },
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+	if (!response.ok) throw new Error(`Unable to fetch OpenAPI document from ${url}: ${response.status} ${response.statusText}`);
+	const reader = response.body?.getReader();
+	if (!reader) return response.json();
+	const decoder = new TextDecoder();
+	let content = "";
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		content += decoder.decode(value, { stream: true });
+		taskProgressService.log(`Downloading (${(content.length / 1048576).toFixed(1)} MB)`);
+	}
+	taskProgressService.log("Parsing document");
+	return JSON.parse(content + decoder.decode());
+}
+async function loadOpenApiDocument(url, timeoutMs) {
+	try {
+		return await downloadOpenApiDocument(url, timeoutMs);
+	} catch (error) {
+		if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) throw new Error(`OpenAPI download timed out after ${timeoutMs}ms: ${url}`);
+		throw new Error(`Unable to fetch OpenAPI document from ${url}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+//#endregion
+//#region src/services/openapi/schemaService.ts
+function resolveOpenApiReference(value, swagger) {
+	if (!value || typeof value !== "object" || typeof value.$ref !== "string" || !value.$ref.startsWith("#/")) return value;
+	let current = swagger;
+	for (const segment of value.$ref.replace("#/", "").split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"))) {
+		current = current?.[segment];
+		if (current === void 0) return value;
+	}
+	return current;
+}
+//#endregion
+//#region src/services/openapi/propertyExtractionService.ts
+function isSuccessStatusCode(statusCode) {
+	return /^\d+$/.test(statusCode) && Number(statusCode) >= 200 && Number(statusCode) <= 299;
+}
+function selectPreferredSchema(content, swagger) {
+	if (!content || typeof content !== "object") return;
+	if (content["application/json"]?.schema) return resolveOpenApiReference(content["application/json"].schema, swagger);
+	const firstSchema = Object.values(content).find((entry) => entry?.schema);
+	return firstSchema ? resolveOpenApiReference(firstSchema.schema, swagger) : void 0;
+}
+function extractLeafProperties(schema, swagger, currentPath = "") {
+	const resolvedSchema = resolveOpenApiReference(schema, swagger);
+	if (!resolvedSchema || typeof resolvedSchema !== "object") return [];
+	if (Array.isArray(resolvedSchema.allOf)) return resolvedSchema.allOf.flatMap((item) => extractLeafProperties(item, swagger, currentPath));
+	if (resolvedSchema.type === "array" || resolvedSchema.items) {
+		const arrayPath = currentPath ? `${currentPath}[]` : "[]";
+		return extractLeafProperties(resolvedSchema.items, swagger, arrayPath);
+	}
+	const properties = resolvedSchema.properties || {};
+	if (!Object.keys(properties).length) return currentPath ? [{
+		path: currentPath,
+		description: resolvedSchema.description,
+		deprecated: resolvedSchema.deprecated
+	}] : [];
+	return Object.entries(properties).flatMap(([propertyName, propertySchema]) => {
+		return extractLeafProperties(propertySchema, swagger, currentPath ? `${currentPath}.${propertyName}` : propertyName);
+	});
+}
+function mapInputType(inType) {
+	if (inType === "query") return "QUERY";
+	if (inType === "path") return "PATH";
+	if (inType === "header") return "HEADER";
+	return null;
+}
+function extractOpenApiInputProperties(operation, swagger) {
+	const map = /* @__PURE__ */ new Map();
+	const parameters = Array.isArray(operation.parameters) ? operation.parameters : [];
+	for (const rawParameter of parameters) {
+		const parameter = resolveOpenApiReference(rawParameter, swagger);
+		const inputType = mapInputType(parameter?.in);
+		if (!parameter || !inputType || !parameter.name) continue;
+		const properties = extractLeafProperties(parameter.schema, swagger, parameter.name);
+		const resolvedProperties = properties.length ? properties : [{
+			path: parameter.name,
+			description: parameter.description,
+			deprecated: parameter.deprecated
+		}];
+		for (const property of resolvedProperties) map.set(`${inputType}:${property.path}`, {
+			path: property.path,
+			description: property.description || parameter.description,
+			deprecated: property.deprecated ?? parameter.deprecated ?? false,
+			type: inputType
+		});
+	}
+	const requestBody = resolveOpenApiReference(operation.requestBody, swagger);
+	if (requestBody?.content) {
+		const schema = selectPreferredSchema(requestBody.content, swagger);
+		for (const property of extractLeafProperties(schema, swagger)) map.set(`BODY:${property.path}`, {
+			path: property.path,
+			description: property.description || requestBody.description,
+			deprecated: property.deprecated ?? false,
+			type: "BODY"
+		});
+	}
+	return [...map.values()];
+}
+function extractOpenApiOutputProperties(operation, swagger) {
+	const map = /* @__PURE__ */ new Map();
+	const responses = operation?.responses || {};
+	for (const [statusCode, rawResponse] of Object.entries(responses)) {
+		if (!isSuccessStatusCode(statusCode)) continue;
+		const response = resolveOpenApiReference(rawResponse, swagger);
+		const schema = selectPreferredSchema(response?.content, swagger);
+		for (const property of extractLeafProperties(schema, swagger)) map.set(property.path, {
+			path: property.path,
+			description: property.description || response?.description,
+			deprecated: property.deprecated ?? false,
+			type: "RESPONSE_BODY"
+		});
+	}
+	return [...map.values()];
+}
+//#endregion
+//#region src/services/backendTypeService.ts
+let knownBackendTypesCache = null;
+function isKnownBackendType(value) {
+	const config = getUserConfig();
+	const filePath = path.resolve(config.repoRoot, config.backendTypesFile);
+	if (!knownBackendTypesCache || knownBackendTypesCache.filePath !== filePath) {
+		const fileContent = fs$1.readFileSync(filePath, "utf8");
+		knownBackendTypesCache = {
+			filePath,
+			values: new Set([...fileContent.matchAll(/([A-Z0-9_]+)\s*=\s*"([A-Z0-9_]+)"/g)].map(([, key, backend]) => key === backend ? backend : null).filter((backend) => Boolean(backend)))
+		};
+	}
+	return knownBackendTypesCache.values.has(value);
+}
+//#endregion
+//#region src/services/backendSourceService.ts
+function inferBackendNameFromFile(sourceFile) {
+	const declaredType = sourceFile.getFullText().match(/BackendTypes\.([A-Z0-9_]+)/)?.[1];
+	if (declaredType) return isKnownBackendType(declaredType) ? declaredType : null;
+	const parts = sourceFile.getFilePath().split(path.sep);
+	const backIndex = parts.lastIndexOf("back");
+	const infrastructureIndex = parts.lastIndexOf("_infra");
+	const candidate = backIndex >= 0 ? parts[backIndex + 1] : infrastructureIndex >= 0 ? parts[infrastructureIndex + 2] : void 0;
+	return candidate && isKnownBackendType(candidate.toUpperCase()) ? candidate.toUpperCase() : null;
+}
+//#endregion
+//#region src/services/backendRouteExtractionService.ts
+function looksLikeBackendRoute(value) {
+	return value.startsWith("/") || /^https?:\/\//.test(value) || /^graphql$/i.test(value);
+}
+function extractBackendRouteCandidates(params) {
+	const methods = /* @__PURE__ */ new Set([
+		"get",
+		"post",
+		"put",
+		"patch",
+		"delete",
+		"head",
+		"query"
+	]);
+	return analysisCacheService.getCallExpressions(params.sourceFile).flatMap((call) => {
+		if (params.reachableFunctionNames && !params.reachableFunctionNames.has(params.enclosingCallableName(call))) return [];
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression) || !methods.has(expression.getName())) return [];
+		const firstArgument = call.getArguments()[0];
+		if (!firstArgument || !Node.isStringLiteral(firstArgument) && !Node.isNoSubstitutionTemplateLiteral(firstArgument)) return [];
+		const route = firstArgument.getLiteralValue();
+		if (!looksLikeBackendRoute(route)) return [];
+		return [{
+			backend: params.backendName,
+			method: expression.getName() === "query" ? "POST" : expression.getName().toUpperCase(),
+			route,
+			sourceFile: params.sourceFile.getFilePath()
+		}];
+	});
+}
+//#endregion
+//#region src/utils/routeKey.ts
+function stableKey$2(...parts) {
+	return createHash("sha1").update(parts.join("::")).digest("hex");
+}
+function buildRouteKey(method, routePath) {
+	return stableKey$2(method, routePath);
+}
+//#endregion
+//#region src/utils/pathNormalization.ts
+function normalizePathForMatch(value) {
+	return value.replace(/\[\]/g, "").replace(/\{[^}]+\}/g, "").replace(/[^a-z0-9]/gi, "").toLowerCase();
+}
+function lastPathSegment(value) {
+	return value.split(/[.[\]]+/).filter(Boolean).at(-1)?.toLowerCase() || value.toLowerCase();
+}
+function normalizeDescription(description) {
+	return description?.trim() || "";
+}
+//#endregion
+//#region src/utils/resolveAliasPath.ts
+function resolveAliasPath(moduleSpecifier, aliases, rootPath) {
+	for (const [alias, target] of Object.entries(aliases)) {
+		if (moduleSpecifier !== alias && !moduleSpecifier.startsWith(`${alias}/`)) continue;
+		const modulePath = moduleSpecifier.slice(alias.length).replace(/^\//, "");
+		return path.join(rootPath, target, modulePath);
+	}
+	return null;
+}
+//#endregion
+//#region src/utils/tryResolveWithExtensions.ts
+function tryResolveWithExtensions(basePath) {
+	const ext = path.extname(basePath);
+	const withoutExt = ext ? basePath.slice(0, -ext.length) : basePath;
+	const candidates = [
+		basePath,
+		ext === ".js" ? `${withoutExt}.ts` : null,
+		ext === ".ts" ? `${withoutExt}.js` : null,
+		ext === ".mjs" ? `${withoutExt}.mts` : null,
+		ext === ".mts" ? `${withoutExt}.mjs` : null,
+		`${basePath}.ts`,
+		`${basePath}.js`,
+		`${basePath}.mts`,
+		`${basePath}.mjs`,
+		path.join(withoutExt, "index.ts"),
+		path.join(withoutExt, "index.js"),
+		path.join(basePath, "index.ts"),
+		path.join(basePath, "index.js")
+	].filter((candidate) => Boolean(candidate));
+	for (const candidate of candidates) try {
+		const normalized = path.normalize(candidate);
+		if (fs$1.existsSync(normalized)) return normalized;
+	} catch {
+		continue;
+	}
+	return null;
+}
+//#endregion
+//#region src/utils/resolveModulePath.ts
+function resolveModulePath(sourceFilePath, moduleSpecifier, aliases, rootPath) {
+	if (moduleSpecifier.startsWith(".")) return tryResolveWithExtensions(path.resolve(path.dirname(sourceFilePath), moduleSpecifier));
+	const aliased = resolveAliasPath(moduleSpecifier, aliases, rootPath);
+	return aliased ? tryResolveWithExtensions(aliased) : null;
+}
+//#endregion
+//#region src/utils/dedupeByKey.ts
+function dedupeByKey(items, keyFn) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of items) map.set(keyFn(item), item);
+	return [...map.values()];
+}
+//#endregion
+//#region src/services/codeAnalysisService.ts
+const userConfig = new Proxy({}, { get: (_target, property) => Reflect.get(getUserConfig(), property) });
+function getStringLiteralValue(objectLiteral, propertyName) {
+	const property = objectLiteral.getProperty(propertyName);
+	if (!property || !Node.isPropertyAssignment(property)) return;
+	const initializer = property.getInitializer();
+	if (!initializer) return;
+	if (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) return initializer.getLiteralValue();
+}
+function expressionToText(expression) {
+	if (!expression) return;
+	if (Node.isIdentifier(expression)) return expression.getText();
+	if (Node.isPropertyAccessExpression(expression)) return expression.getText();
+}
+function extractRoutesFromArray(sourceFilePath, routesArray) {
+	const routes = [];
+	for (const element of routesArray.getElements()) {
+		if (!Node.isObjectLiteralExpression(element)) continue;
+		const method = getStringLiteralValue(element, "method");
+		const routePath = getStringLiteralValue(element, "path");
+		const handlerRef = expressionToText(Node.isPropertyAssignment(element.getProperty("handler")) ? element.getProperty("handler").getInitializer() : void 0);
+		if (!method || !routePath) continue;
+		routes.push({
+			method: method.toUpperCase(),
+			path: routePath,
+			file: sourceFilePath,
+			handlerRef
+		});
+	}
+	return routes;
+}
+function isHttpClientInfrastructure(sourceFile) {
+	return sourceFile.getClasses().some((declaration) => declaration.getExtends()?.getText() === "HttpClient");
+}
+function extractMapperType(expression) {
+	if (Node.isNonNullExpression(expression) || Node.isAsExpression(expression) || Node.isTypeAssertion(expression)) return extractMapperType(expression.getExpression());
+	if (!Node.isCallExpression(expression)) return;
+	return userConfig.analysis.rules.find((rule) => rule.match(expression, userConfig))?.parse(expression, userConfig)?.mapperType;
+}
+function unwrapMappingUtilityExpression(expression) {
+	if (Node.isNonNullExpression(expression) || Node.isAsExpression(expression) || Node.isTypeAssertion(expression)) return unwrapMappingUtilityExpression(expression.getExpression());
+	if (!Node.isCallExpression(expression)) return expression;
+	if (!(userConfig.analysis.rules.find((rule) => rule.match(expression, userConfig))?.parse(expression, userConfig))?.transparent) return expression;
+	const firstArg = expression.getArguments()[0];
+	return firstArg && Node.isExpression(firstArg) ? unwrapMappingUtilityExpression(firstArg) : expression;
+}
+function looksLikeBackendFieldAccess(value) {
+	return value.includes(".") && !userConfig.analysis.backendFieldAccess.excludedPrefixes.some((prefix) => value.startsWith(prefix));
+}
+function firstBackendPropertyAccess(expression) {
+	const unwrappedExpression = unwrapMappingUtilityExpression(expression);
+	for (const rule of userConfig.analysis.rules) {
+		if (!rule.match(unwrappedExpression, userConfig)) continue;
+		const result = rule.parse(unwrappedExpression, userConfig);
+		if (result?.backendField) return result.backendField;
+	}
+	if (Node.isIdentifier(unwrappedExpression)) {
+		const initializer = (unwrappedExpression.getSymbol()?.getDeclarations().find(Node.isVariableDeclaration))?.getInitializer();
+		const initializerCallee = Node.isCallExpression(initializer) ? initializer.getExpression().getText() : "";
+		if (initializer && Node.isExpression(initializer) && /^back(?:\.serialize)?\./.test(initializerCallee)) {
+			const resolvedField = firstBackendPropertyAccess(initializer);
+			if (resolvedField && resolvedField !== unwrappedExpression.getText()) return resolvedField;
+		}
+		return unwrappedExpression.getText();
+	}
+	if (Node.isPropertyAccessExpression(unwrappedExpression)) {
+		const value = unwrappedExpression.getText();
+		return looksLikeBackendFieldAccess(value) ? value : void 0;
+	}
+	if (Node.isElementAccessExpression(unwrappedExpression)) {
+		const argument = unwrappedExpression.getArgumentExpression();
+		if (argument && Node.isExpression(argument)) {
+			const argumentProperty = firstBackendPropertyAccess(argument);
+			if (argumentProperty) return argumentProperty;
+		}
+		return unwrappedExpression.getText();
+	}
+	if (Node.isCallExpression(unwrappedExpression)) {
+		const callTarget = unwrappedExpression.getExpression();
+		if (!unwrappedExpression.getArguments().length && Node.isPropertyAccessExpression(callTarget)) {
+			const receiver = callTarget.getExpression();
+			if (Node.isExpression(receiver)) {
+				const receiverProperty = firstBackendPropertyAccess(receiver);
+				if (receiverProperty) return receiverProperty;
+			}
+		}
+		const firstArg = unwrappedExpression.getArguments()[0];
+		if (firstArg && Node.isExpression(firstArg)) return firstBackendPropertyAccess(firstArg);
+	}
+	if (Node.isBinaryExpression(unwrappedExpression)) {
+		const left = unwrappedExpression.getLeft();
+		const right = unwrappedExpression.getRight();
+		if (unwrappedExpression.getOperatorToken().getKind() === SyntaxKind.QuestionQuestionToken) return firstBackendPropertyAccess(left) || firstBackendPropertyAccess(right);
+		const isTransparentWrapper = Node.isCallExpression(left) && userConfig.analysis.rules.some((rule) => rule.match(left, userConfig) && rule.parse(left, userConfig)?.transparent);
+		if (Node.isNullLiteral(right) && isTransparentWrapper) return firstBackendPropertyAccess(left);
+	}
+	const propertyAccess = unwrappedExpression.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).map((descendant) => descendant.getText()).find(looksLikeBackendFieldAccess);
+	if (propertyAccess) return propertyAccess;
+	return unwrappedExpression.getDescendantsOfKind(SyntaxKind.ElementAccessExpression)[0]?.getText();
+}
+function propertyAccessMatchingField(expression, field) {
+	return [...Node.isPropertyAccessExpression(expression) ? [expression] : [], ...expression.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)].map((access) => access.getText()).find((value) => looksLikeBackendFieldAccess(value) && lastPathSegment(value) === lastPathSegment(field));
+}
+function collectObjectLiteralMappings(objectLiteral, currentPath = "") {
+	const mappings = [];
+	for (const property of objectLiteral.getProperties()) {
+		if (Node.isShorthandPropertyAssignment(property)) {
+			const name = property.getName();
+			mappings.push({
+				apiPath: currentPath ? `${currentPath}.${name}` : name,
+				backendField: name,
+				line: property.getStartLineNumber()
+			});
+			continue;
+		}
+		if (!Node.isPropertyAssignment(property)) continue;
+		const name = property.getName().replace(/^["']|["']$/g, "");
+		const nextPath = currentPath ? `${currentPath}.${name}` : name;
+		const initializer = property.getInitializer();
+		if (!initializer) continue;
+		const unwrappedInitializer = Node.isAsExpression(initializer) || Node.isTypeAssertion(initializer) || Node.isSatisfiesExpression(initializer) ? initializer.getExpression() : initializer;
+		if (Node.isObjectLiteralExpression(unwrappedInitializer)) {
+			mappings.push(...collectObjectLiteralMappings(unwrappedInitializer, nextPath));
+			continue;
+		}
+		if (Node.isArrayLiteralExpression(unwrappedInitializer)) {
+			const objectChild = unwrappedInitializer.getElements().find(Node.isObjectLiteralExpression);
+			if (objectChild) {
+				mappings.push(...collectObjectLiteralMappings(objectChild, `${nextPath}[]`));
+				continue;
+			}
+		}
+		mappings.push({
+			apiPath: nextPath,
+			backendField: firstBackendPropertyAccess(unwrappedInitializer),
+			mapperType: extractMapperType(unwrappedInitializer),
+			line: property.getStartLineNumber()
+		});
+	}
+	return mappings;
+}
+function propertyAssignmentPath(property) {
+	const segments = [...property.getAncestors().filter(Node.isPropertyAssignment).map((ancestor) => ancestor.getName().replace(/^['"]|['"]$/g, "")).reverse(), property.getName().replace(/^['"]|['"]$/g, "")];
+	const mapDepth = property.getAncestors().filter((ancestor) => {
+		if (!Node.isCallExpression(ancestor)) return false;
+		const expression = ancestor.getExpression();
+		return Node.isPropertyAccessExpression(expression) && expression.getName() === "map";
+	}).length;
+	const arrayPrefix = "[]".repeat(mapDepth);
+	return arrayPrefix ? `${arrayPrefix}.${segments.join(".")}` : segments.join(".");
+}
+function enclosingCallableName(node) {
+	const callables = node.getAncestors().filter((ancestor) => Node.isFunctionDeclaration(ancestor) || Node.isMethodDeclaration(ancestor) || Node.isArrowFunction(ancestor) || Node.isFunctionExpression(ancestor));
+	for (const callable of callables) {
+		if (Node.isFunctionDeclaration(callable) || Node.isMethodDeclaration(callable)) {
+			const name = callable.getName();
+			if (name) return name;
+			continue;
+		}
+		const parent = callable.getParent();
+		if (parent && Node.isVariableDeclaration(parent)) return parent.getName();
+	}
+	return "";
+}
+function mapperDirectionFromName(name) {
+	if (userConfig.analysis.mapperNaming.inputPatterns.some((pattern) => pattern.test(name))) return "input";
+	if (userConfig.analysis.mapperNaming.outputPatterns.some((pattern) => pattern.test(name))) return "output";
+}
+function collectApiMapperDirections(sourceFile) {
+	const directions = /* @__PURE__ */ new Map();
+	const isApiMapperFile = sourceFile.getFilePath().includes(`${path.sep}mappers${path.sep}`);
+	for (const declaration of sourceFile.getFunctions()) {
+		const name = declaration.getName();
+		const direction = name ? mapperDirectionFromName(name) || (isApiMapperFile && /^map[A-Z]/.test(name) ? "output" : void 0) : void 0;
+		if (name && direction) directions.set(name, direction);
+	}
+	for (const declaration of sourceFile.getVariableDeclarations()) {
+		const initializer = declaration.getInitializer();
+		if (!initializer || !Node.isArrowFunction(initializer) && !Node.isFunctionExpression(initializer)) continue;
+		const name = declaration.getName();
+		const direction = mapperDirectionFromName(name) || (isApiMapperFile && /^map[A-Z]/.test(name) ? "output" : void 0);
+		if (direction) directions.set(name, direction);
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+			const direction = directions.get(enclosingCallableName(call));
+			const calledName = calledFunctionName(call);
+			if (direction && calledName && !directions.has(calledName)) {
+				directions.set(calledName, direction);
+				changed = true;
+			}
+		}
+	}
+	return directions;
+}
+function joinApiFieldPath(prefix, field) {
+	if (!prefix) return field;
+	return `${prefix}.${field.replace(/^\[\]\.?/, "")}`;
+}
+function localCallableReturnsArray(sourceFile, callableName) {
+	const declaration = sourceFile.getFunctions().find((item) => item.getName() === callableName);
+	if (!declaration) return false;
+	return declaration.getDescendantsOfKind(SyntaxKind.ReturnStatement).some((statement) => {
+		const expression = statement.getExpression();
+		if (Node.isArrayLiteralExpression(expression)) return true;
+		if (!Node.isCallExpression(expression)) return false;
+		const callee = expression.getExpression();
+		return Node.isPropertyAccessExpression(callee) && callee.getName() === "map";
+	});
+}
+function extractApiFieldSourceCandidates(sourceFile) {
+	const mapperDirections = collectApiMapperDirections(sourceFile);
+	const candidates = [...sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment), ...sourceFile.getDescendantsOfKind(SyntaxKind.ShorthandPropertyAssignment)].sort((left, right) => left.getStart() - right.getStart()).flatMap((property) => {
+		if (Node.isShorthandPropertyAssignment(property)) {
+			const functionName = enclosingCallableName(property);
+			const direction = mapperDirections.get(functionName);
+			if (!direction) return [];
+			return [{
+				direction,
+				field: propertyAssignmentPath(property),
+				domainField: property.getName(),
+				sourceFile: sourceFile.getFilePath(),
+				line: property.getStartLineNumber(),
+				callableName: functionName
+			}];
+		}
+		const initializer = property.getInitializer();
+		if (!initializer || Node.isObjectLiteralExpression(initializer)) return [];
+		const usesApiMapper = (Node.isCallExpression(initializer) ? [initializer, ...initializer.getDescendantsOfKind(SyntaxKind.CallExpression)] : initializer.getDescendantsOfKind(SyntaxKind.CallExpression)).some((call) => userConfig.analysis.rules.find((rule) => rule.match(call, userConfig))?.parse(call, userConfig)?.apiMapping);
+		const functionName = enclosingCallableName(property);
+		const direction = mapperDirections.get(functionName) || (usesApiMapper ? "output" : void 0);
+		if (!direction) return [];
+		const objectField = propertyAssignmentPath(property);
+		const mappedValue = direction === "input" ? propertyAccessMatchingField(initializer, objectField) || firstBackendPropertyAccess(initializer) : firstBackendPropertyAccess(initializer);
+		const inputField = mappedValue?.replace(/^[^.]+\./, "");
+		return [{
+			direction,
+			field: direction === "input" && inputField ? inputField : objectField,
+			domainField: direction === "input" ? objectField : mappedValue,
+			sourceFile: sourceFile.getFilePath(),
+			line: property.getStartLineNumber(),
+			callableName: functionName
+		}];
+	});
+	const candidatesByCallable = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const values = candidatesByCallable.get(candidate.callableName) || [];
+		values.push(candidate);
+		candidatesByCallable.set(candidate.callableName, values);
+	}
+	const calledLocalFunctions = /* @__PURE__ */ new Set();
+	const qualifiedCandidates = [];
+	for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const calledName = calledFunctionName(call);
+		if (!calledName || !candidatesByCallable.has(calledName)) continue;
+		calledLocalFunctions.add(calledName);
+		const property = call.getFirstAncestorByKind(SyntaxKind.PropertyAssignment);
+		const spread = call.getFirstAncestorByKind(SyntaxKind.SpreadAssignment);
+		const prefix = property ? propertyAssignmentPath(property) : spread ? "" : void 0;
+		if (prefix === void 0) {
+			const mapCall = call.getAncestors().find((ancestor) => {
+				if (!Node.isCallExpression(ancestor)) return false;
+				const expression = ancestor.getExpression();
+				return Node.isPropertyAccessExpression(expression) && expression.getName() === "map";
+			});
+			const callback = mapCall?.getArguments()[0];
+			const callbackParameter = callback && (Node.isArrowFunction(callback) || Node.isFunctionExpression(callback)) ? callback.getParameters()[0]?.getName() : void 0;
+			const mapExpression = mapCall?.getExpression();
+			const collection = mapExpression && Node.isPropertyAccessExpression(mapExpression) ? mapExpression.getExpression().getText() : void 0;
+			const variable = call.getFirstAncestorByKind(SyntaxKind.VariableDeclaration)?.getName();
+			if (!variable || !collection || !callbackParameter) continue;
+			for (const candidate of candidatesByCallable.get(calledName) || []) qualifiedCandidates.push({
+				...candidate,
+				field: `${variable}[].${candidate.field}`,
+				domainField: candidate.domainField?.startsWith(`${callbackParameter}.`) ? `${collection}[].${candidate.domainField.slice(callbackParameter.length + 1)}` : candidate.domainField
+			});
+			continue;
+		}
+		const qualifiedPrefix = localCallableReturnsArray(sourceFile, calledName) ? `${prefix}[]` : prefix;
+		for (const candidate of candidatesByCallable.get(calledName) || []) qualifiedCandidates.push({
+			...candidate,
+			field: joinApiFieldPath(qualifiedPrefix, candidate.field)
+		});
+	}
+	return dedupeByKey([...candidates.filter((candidate) => !calledLocalFunctions.has(candidate.callableName)), ...qualifiedCandidates], (candidate) => `${candidate.direction}:${candidate.field}:${candidate.domainField || ""}:${candidate.sourceFile}:${candidate.line}`).map(({ callableName: _callableName, ...candidate }) => candidate);
+}
+/**
+* Resolves the value passed to a local output mapper back to its parameter.
+* This preserves the domain root across a handler-to-mapper boundary without
+* weakening matching to a field-name-only comparison.
+*/
+function extractRouteApiFieldSourceCandidates(sourceFiles) {
+	const candidates = sourceFiles.flatMap(extractApiFieldSourceCandidates);
+	const collectionOutputByVariable = /* @__PURE__ */ new Map();
+	for (const sourceFile of sourceFiles) for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const mapperName = calledFunctionName(call);
+		if (!mapperName) continue;
+		for (const mapperFile of sourceFiles) {
+			const mapper = mapperFile.getFunctions().find((declaration) => declaration.getName() === mapperName);
+			const returned = mapper?.getDescendantsOfKind(SyntaxKind.ReturnStatement).map(resolveReturnedObjectLiteral).find((value) => Boolean(value));
+			if (!mapper || !returned) continue;
+			for (const [index, parameter] of mapper.getParameters().entries()) {
+				const argument = call.getArguments()[index];
+				if (!argument || !Node.isIdentifier(argument)) continue;
+				const output = returned.getProperties().find((property) => Node.isShorthandPropertyAssignment(property) && property.getName() === parameter.getName() || Node.isPropertyAssignment(property) && property.getInitializer()?.getText() === parameter.getName());
+				if (output && (Node.isShorthandPropertyAssignment(output) || Node.isPropertyAssignment(output))) collectionOutputByVariable.set(`${sourceFile.getFilePath()}:${argument.getText()}`, output.getName());
+			}
+		}
+	}
+	const qualifiedCollectionCandidates = candidates.map((candidate) => {
+		const [variable, ...suffix] = candidate.field.split("[].");
+		const output = collectionOutputByVariable.get(`${candidate.sourceFile}:${variable}`);
+		return output && suffix.length ? {
+			...candidate,
+			field: `${output}[].${suffix.join("[].")}`
+		} : candidate;
+	});
+	const aliasesByMapper = /* @__PURE__ */ new Map();
+	for (const sourceFile of sourceFiles) for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const mapperName = calledFunctionName(call);
+		const argument = call.getArguments()[0];
+		if (!mapperName || !argument || !Node.isExpression(argument) || !(Node.isIdentifier(argument) || Node.isPropertyAccessExpression(argument) || Node.isElementAccessExpression(argument))) continue;
+		for (const mapperFile of sourceFiles) {
+			const mapper = mapperFile.getFunctions().find((declaration) => declaration.getName() === mapperName);
+			const parameter = mapper?.getParameters()[0]?.getName();
+			if (!mapper || !parameter || mapperDirectionFromName(mapperName) !== "output") continue;
+			const key = `${mapperFile.getFilePath()}:${mapperName}`;
+			const aliases = aliasesByMapper.get(key) || [];
+			const ownerName = sourceFile.getFunctions().find((declaration) => declaration.getStartLineNumber() <= call.getStartLineNumber() && call.getStartLineNumber() <= declaration.getEndLineNumber())?.getName();
+			aliases.push({
+				parameter,
+				argument: argument.getText(),
+				ownerMapperKey: ownerName && mapperDirectionFromName(ownerName) === "output" ? `${sourceFile.getFilePath()}:${ownerName}` : void 0
+			});
+			aliasesByMapper.set(key, aliases);
+		}
+	}
+	const resolveArgument = (argument, ownerMapperKey, seen = /* @__PURE__ */ new Set()) => {
+		if (!ownerMapperKey) return argument;
+		const [root, ...suffix] = argument.split(".");
+		const alias = (aliasesByMapper.get(ownerMapperKey) || []).find((item) => item.parameter === root);
+		if (!alias || seen.has(`${ownerMapperKey}:${root}`)) return argument;
+		seen.add(`${ownerMapperKey}:${root}`);
+		return resolveArgument(`${alias.argument}${suffix.length ? `.${suffix.join(".")}` : ""}`, alias.ownerMapperKey, seen);
+	};
+	return dedupeByKey(qualifiedCollectionCandidates.flatMap((candidate) => {
+		if (candidate.direction !== "output" || !candidate.domainField) return [candidate];
+		const mapperName = (sourceFiles.find((file) => file.getFilePath() === candidate.sourceFile)?.getFunctions().find((declaration) => declaration.getStartLineNumber() <= candidate.line && candidate.line <= declaration.getEndLineNumber()))?.getName();
+		if (!mapperName) return [candidate];
+		const aliases = aliasesByMapper.get(`${candidate.sourceFile}:${mapperName}`) || [];
+		if (!aliases.length) return [candidate];
+		return aliases.map(({ parameter, argument, ownerMapperKey }) => ({
+			...candidate,
+			domainField: candidate.domainField === parameter ? resolveArgument(argument, ownerMapperKey) : candidate.domainField?.startsWith(`${parameter}.`) ? resolveArgument(`${argument}${candidate.domainField.slice(parameter.length)}`, ownerMapperKey) : candidate.domainField
+		}));
+	}), (candidate) => `${candidate.direction}:${candidate.field}:${candidate.domainField || ""}:${candidate.sourceFile}:${candidate.line}`);
+}
+function enclosingFunctionName(node) {
+	return node.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration)?.getName();
+}
+function isDomainToBackendMapper(node) {
+	return userConfig.analysis.mapperNaming.domainToBackendPattern.test(enclosingFunctionName(node) || "");
+}
+function resolveReturnedObjectLiteral(returnStatement) {
+	const expression = returnStatement.getExpression();
+	if (!expression) return;
+	const unwrappedExpression = Node.isAsExpression(expression) || Node.isTypeAssertion(expression) || Node.isSatisfiesExpression(expression) ? expression.getExpression() : expression;
+	if (Node.isObjectLiteralExpression(unwrappedExpression)) return unwrappedExpression;
+	if (Node.isCallExpression(unwrappedExpression)) {
+		const firstArgument = unwrappedExpression.getArguments()[0];
+		if (userConfig.analysis.rules.some((rule) => rule.match(unwrappedExpression, userConfig) && rule.parse(unwrappedExpression, userConfig)?.transparent) && firstArgument && Node.isObjectLiteralExpression(firstArgument)) return firstArgument;
+	}
+	if (!Node.isIdentifier(unwrappedExpression)) return;
+	const initializer = (unwrappedExpression.getSymbol()?.getDeclarations().find(Node.isVariableDeclaration))?.getInitializer();
+	return initializer && Node.isObjectLiteralExpression(initializer) ? initializer : void 0;
+}
+function resolveObjectLiteralExpression(expression) {
+	if (Node.isObjectLiteralExpression(expression)) return expression;
+	if (!Node.isIdentifier(expression)) return;
+	const initializer = (expression.getSymbol()?.getDeclarations().find(Node.isVariableDeclaration))?.getInitializer();
+	return initializer && Node.isExpression(initializer) ? resolveObjectLiteralExpression(initializer) : void 0;
+}
+function resolveRequestPayloadObject(call) {
+	const optionsArgument = call.getArguments()[1];
+	if (!optionsArgument || !Node.isExpression(optionsArgument)) return;
+	const optionsObject = resolveObjectLiteralExpression(optionsArgument);
+	if (!optionsObject) return;
+	for (const propertyName of [
+		"body",
+		"json",
+		"data",
+		"payload",
+		"qs",
+		"query",
+		"searchParams"
+	]) {
+		const property = optionsObject.getProperty(propertyName);
+		if (property && Node.isPropertyAssignment(property)) {
+			const initializer = property.getInitializer();
+			if (initializer && Node.isExpression(initializer)) {
+				const payloadObject = resolveObjectLiteralExpression(initializer);
+				if (payloadObject) return payloadObject;
+			}
+		}
+		if (property && Node.isShorthandPropertyAssignment(property)) {
+			const initializer = (property.getValueSymbol()?.getDeclarations().find(Node.isVariableDeclaration))?.getInitializer();
+			if (initializer && Node.isExpression(initializer)) {
+				const payloadObject = resolveObjectLiteralExpression(initializer);
+				if (payloadObject) return payloadObject;
+			}
+		}
+	}
+	return optionsObject;
+}
+function isBackendRequestCall(call) {
+	const expression = call.getExpression();
+	if (!Node.isPropertyAccessExpression(expression) || ![
+		"get",
+		"post",
+		"put",
+		"patch",
+		"delete",
+		"head",
+		"query"
+	].includes(expression.getName())) return false;
+	const routeArgument = call.getArguments()[0];
+	return Boolean(routeArgument && (Node.isStringLiteral(routeArgument) || Node.isNoSubstitutionTemplateLiteral(routeArgument)) && looksLikeBackendRoute(routeArgument.getLiteralValue()));
+}
+function isTechnicalRequestValue(value) {
+	const root = value.split(/[.[\]]/).find(Boolean);
+	return root === "context" || root === "ctx";
+}
+function normalizeBackendFieldForBackend(backendName, field) {
+	return backendName === "QUABLE_REST" && field.startsWith("i18n.") ? `document.attributes.${field.slice(5)}` : field;
+}
+function extractBackendFieldCandidates(sourceFile, backendName, reachableFunctionNames) {
+	const candidates = [];
+	const localFunctionsByName = new Map(sourceFile.getFunctions().filter((declaration) => Boolean(declaration.getName())).map((declaration) => [declaration.getName(), declaration]));
+	const shorthandPropertiesByName = /* @__PURE__ */ new Map();
+	for (const property of sourceFile.getDescendantsOfKind(SyntaxKind.ShorthandPropertyAssignment)) {
+		const properties = shorthandPropertiesByName.get(property.getName()) || [];
+		properties.push(property);
+		shorthandPropertiesByName.set(property.getName(), properties);
+	}
+	const addBackendToDomainMappings = (objectLiteral, constructorDomainRoot) => {
+		for (const mapping of collectObjectLiteralMappings(objectLiteral)) {
+			if (!mapping.backendField) continue;
+			const sourceRoot = mapping.backendField.split(/[.[\]]/).find(Boolean);
+			const mappedDomainName = enclosingCallableName(objectLiteral).match(userConfig.analysis.mapperNaming.domainNameFromToDomainPattern)?.[1];
+			const domainRoot = constructorDomainRoot || (sourceRoot === "response" && mappedDomainName ? `${mappedDomainName.charAt(0).toLowerCase()}${mappedDomainName.slice(1)}` : sourceRoot);
+			const domainPath = domainRoot && normalizePathForMatch(domainRoot) !== normalizePathForMatch(mapping.apiPath) ? `${domainRoot}.${mapping.apiPath}` : mapping.apiPath;
+			candidates.push({
+				backend: backendName,
+				direction: "output",
+				apiPathCandidate: domainPath,
+				backendField: mapping.backendField,
+				sourceFile: sourceFile.getFilePath(),
+				sourceLine: mapping.line,
+				confidence: normalizePathForMatch(mapping.apiPath) === normalizePathForMatch(mapping.backendField) ? 95 : 65,
+				mapperType: mapping.mapperType
+			});
+		}
+	};
+	for (const constructorCall of sourceFile.getDescendantsOfKind(SyntaxKind.NewExpression)) {
+		if (reachableFunctionNames && !reachableFunctionNames.has(enclosingCallableName(constructorCall))) continue;
+		const objectArgument = constructorCall.getArguments().find(Node.isObjectLiteralExpression);
+		if (objectArgument) {
+			const constructorName = constructorCall.getExpression().getText().split(".").at(-1);
+			const mapperName = enclosingCallableName(constructorCall);
+			const mapsConstructedType = constructorName && userConfig.analysis.mapperNaming.constructedTypeToDomainPattern(constructorName).test(mapperName);
+			const constructorDomainRoot = constructorName && mapsConstructedType ? `${constructorName.charAt(0).toLowerCase()}${constructorName.slice(1)}` : void 0;
+			addBackendToDomainMappings(objectArgument, constructorDomainRoot);
+			const parentProperty = constructorCall.getFirstAncestorByKind(SyntaxKind.PropertyAssignment);
+			const mappedDomainName = mapperName.match(userConfig.analysis.mapperNaming.domainNameFromToDomainPattern)?.[1];
+			if (!constructorDomainRoot && parentProperty && mappedDomainName) {
+				const domainRoot = `${mappedDomainName.charAt(0).toLowerCase()}${mappedDomainName.slice(1)}`;
+				const propertyName = parentProperty.getName().replace(/^['"]|['"]$/g, "");
+				for (const mapping of collectObjectLiteralMappings(objectArgument)) {
+					if (!mapping.backendField) continue;
+					candidates.push({
+						backend: backendName,
+						direction: "output",
+						apiPathCandidate: `${domainRoot}.${propertyName}.${mapping.apiPath}`,
+						backendField: mapping.backendField,
+						sourceFile: sourceFile.getFilePath(),
+						sourceLine: mapping.line,
+						confidence: 65,
+						mapperType: mapping.mapperType
+					});
+				}
+			}
+		}
+	}
+	for (const objectLiteral of sourceFile.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)) {
+		if (!objectLiteral.getProperties().some(Node.isShorthandPropertyAssignment)) continue;
+		if (!objectLiteral.getFirstAncestorByKind(SyntaxKind.ArrowFunction)) continue;
+		if (reachableFunctionNames && !reachableFunctionNames.has(enclosingCallableName(objectLiteral))) continue;
+		addBackendToDomainMappings(objectLiteral);
+	}
+	for (const assignment of sourceFile.getDescendantsOfKind(SyntaxKind.BinaryExpression)) {
+		if (assignment.getOperatorToken().getKind() !== SyntaxKind.EqualsToken) continue;
+		if (reachableFunctionNames && !reachableFunctionNames.has(enclosingCallableName(assignment))) continue;
+		const left = assignment.getLeft();
+		const right = assignment.getRight();
+		if (Node.isPropertyAccessExpression(left) && Node.isExpression(right)) {
+			const backendField = firstBackendPropertyAccess(right);
+			if (backendField) candidates.push({
+				backend: backendName,
+				direction: "output",
+				apiPathCandidate: left.getText(),
+				backendField,
+				sourceFile: sourceFile.getFilePath(),
+				sourceLine: assignment.getStartLineNumber(),
+				confidence: 65
+			});
+			continue;
+		}
+		if (!Node.isElementAccessExpression(left) || !Node.isElementAccessExpression(right)) continue;
+		const key = left.getArgumentExpression();
+		const backendKey = right.getArgumentExpression();
+		if (!key || !backendKey || key.getText() !== backendKey.getText()) continue;
+		candidates.push({
+			backend: backendName,
+			apiPathCandidate: key.getText(),
+			backendField: right.getText(),
+			sourceFile: sourceFile.getFilePath(),
+			sourceLine: assignment.getStartLineNumber(),
+			confidence: 0,
+			requiresReview: true,
+			reviewReason: `Dynamic key mapping: ${assignment.getText()}`
+		});
+	}
+	for (const returnStatement of sourceFile.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+		if (reachableFunctionNames && !reachableFunctionNames.has(enclosingCallableName(returnStatement))) continue;
+		const objectLiteral = resolveReturnedObjectLiteral(returnStatement);
+		if (!objectLiteral) continue;
+		for (const mapping of collectObjectLiteralMappings(objectLiteral)) {
+			if (!mapping.backendField) continue;
+			const domainToBackend = isDomainToBackendMapper(returnStatement);
+			const apiPathCandidate = domainToBackend ? mapping.backendField : mapping.apiPath;
+			const backendField = domainToBackend ? mapping.apiPath : mapping.backendField;
+			candidates.push({
+				backend: backendName,
+				direction: domainToBackend ? "input" : "output",
+				apiPathCandidate,
+				backendField,
+				sourceFile: sourceFile.getFilePath(),
+				sourceLine: mapping.line,
+				confidence: normalizePathForMatch(apiPathCandidate) === normalizePathForMatch(backendField) ? 95 : 65,
+				mapperType: mapping.mapperType
+			});
+		}
+	}
+	for (const call of analysisCacheService.getCallExpressions(sourceFile).filter(isBackendRequestCall)) {
+		if (reachableFunctionNames && !reachableFunctionNames.has(enclosingCallableName(call))) continue;
+		const payloadObject = resolveRequestPayloadObject(call);
+		if (!payloadObject) continue;
+		for (const mapping of collectObjectLiteralMappings(payloadObject)) {
+			if (!mapping.backendField || isTechnicalRequestValue(mapping.backendField)) continue;
+			candidates.push({
+				backend: backendName,
+				direction: "input",
+				apiPathCandidate: mapping.backendField,
+				backendField: mapping.apiPath,
+				sourceFile: sourceFile.getFilePath(),
+				sourceLine: mapping.line,
+				confidence: normalizePathForMatch(mapping.backendField) === normalizePathForMatch(mapping.apiPath) ? 95 : 65,
+				mapperType: mapping.mapperType
+			});
+		}
+	}
+	for (const call of analysisCacheService.getCallExpressions(sourceFile)) {
+		if (reachableFunctionNames && !reachableFunctionNames.has(enclosingCallableName(call))) continue;
+		if (isDomainToBackendMapper(call)) continue;
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression) || !userConfig.analysis.neutralExpressionMatchers.some((matcher) => expression.getExpression().getText().startsWith(matcher.prefix.replace(/\.$/, "")))) continue;
+		const firstArg = call.getArguments()[0];
+		if (!firstArg || !Node.isExpression(firstArg)) continue;
+		const backendField = firstBackendPropertyAccess(firstArg);
+		if (!backendField) continue;
+		candidates.push({
+			backend: backendName,
+			backendField,
+			sourceFile: sourceFile.getFilePath(),
+			sourceLine: call.getStartLineNumber(),
+			confidence: 55,
+			mapperType: extractMapperType(call)
+		});
+	}
+	for (const call of analysisCacheService.getCallExpressions(sourceFile)) {
+		const calledName = calledFunctionName(call);
+		const declaration = calledName ? localFunctionsByName.get(calledName) : void 0;
+		const firstParameter = declaration?.getParameters()[0]?.getName();
+		const firstArgument = call.getArguments()[0];
+		if (!declaration || !firstParameter || !firstArgument || !Node.isExpression(firstArgument)) continue;
+		const argumentPath = firstBackendPropertyAccess(firstArgument);
+		const startLine = declaration.getStartLineNumber();
+		const endLine = declaration.getEndLineNumber();
+		const helperCandidates = candidates.filter((candidate) => candidate.sourceLine !== void 0 && candidate.sourceLine >= startLine && candidate.sourceLine <= endLine);
+		for (const candidate of helperCandidates) {
+			if (argumentPath?.includes(".") && candidate.apiPathCandidate?.startsWith(`${firstParameter}.`)) candidates.push({
+				...candidate,
+				apiPathCandidate: `${argumentPath}${candidate.apiPathCandidate.slice(firstParameter.length)}`
+			});
+			const collectionExpression = call.getAncestors().find((ancestor) => {
+				if (!Node.isCallExpression(ancestor)) return false;
+				const expression = ancestor.getExpression();
+				return Node.isPropertyAccessExpression(expression) && expression.getName() === "map";
+			})?.getExpression();
+			if (collectionExpression && Node.isPropertyAccessExpression(collectionExpression) && candidate.apiPathCandidate?.startsWith(`${firstParameter}.`)) candidates.push({
+				...candidate,
+				apiPathCandidate: `${collectionExpression.getExpression().getText()}[].${candidate.apiPathCandidate.slice(firstParameter.length + 1)}`
+			});
+			const property = call.getFirstAncestorByKind(SyntaxKind.PropertyAssignment);
+			const constructorName = call.getFirstAncestorByKind(SyntaxKind.NewExpression)?.getExpression().getText().split(".").at(-1);
+			if (!property || !constructorName || !candidate.apiPathCandidate || candidate.apiPathCandidate.startsWith(`${firstParameter}.`)) continue;
+			candidates.push({
+				...candidate,
+				apiPathCandidate: `${constructorName.charAt(0).toLowerCase()}${constructorName.slice(1)}.${property.getName()}.${candidate.apiPathCandidate}`
+			});
+		}
+		const localVariableName = call.getFirstAncestorByKind(SyntaxKind.VariableDeclaration)?.getName();
+		if (!localVariableName) continue;
+		const shorthandProperties = shorthandPropertiesByName.get(localVariableName) || [];
+		for (const shorthandProperty of shorthandProperties) {
+			const constructorName = shorthandProperty.getFirstAncestorByKind(SyntaxKind.NewExpression)?.getExpression().getText().split(".").at(-1);
+			if (!constructorName) continue;
+			for (const candidate of helperCandidates) {
+				if (!candidate.apiPathCandidate) continue;
+				candidates.push({
+					...candidate,
+					apiPathCandidate: `${constructorName.charAt(0).toLowerCase()}${constructorName.slice(1)}.${localVariableName}.${candidate.apiPathCandidate}`
+				});
+			}
+		}
+	}
+	return candidates.map((candidate) => ({
+		...candidate,
+		backendField: normalizeBackendFieldForBackend(backendName, candidate.backendField)
+	}));
+}
+/**
+* Carries a backend response mapper's Domain root through a client return and
+* the variable receiving that client call in the route handler.
+*/
+function extractRouteBackendFieldCandidates(backendSourceFiles, reachableFunctionNames, callingSourceFiles) {
+	const candidates = backendSourceFiles.flatMap((sourceFile) => {
+		const backendName = inferBackendNameFromFile(sourceFile);
+		return backendName && !isHttpClientInfrastructure(sourceFile) ? extractBackendFieldCandidates(sourceFile, backendName, reachableFunctionNames) : [];
+	});
+	const allSourceFiles = dedupeByKey([...backendSourceFiles, ...callingSourceFiles], (file) => file.getFilePath());
+	const outputCandidatesByApiPath = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		if (candidate.direction !== "output" || !candidate.apiPathCandidate) continue;
+		const key = normalizePathForMatch(candidate.apiPathCandidate);
+		const values = outputCandidatesByApiPath.get(key) || [];
+		values.push(candidate);
+		outputCandidatesByApiPath.set(key, values);
+	}
+	const callsByName = /* @__PURE__ */ new Map();
+	for (const sourceFile of allSourceFiles) for (const call of analysisCacheService.getCallExpressions(sourceFile)) {
+		const name = calledFunctionName(call);
+		if (!name) continue;
+		const values = callsByName.get(name) || [];
+		values.push(call);
+		callsByName.set(name, values);
+	}
+	const receiverNamesByMapper = /* @__PURE__ */ new Map();
+	const receiverNamesForMapper = (mapperName) => {
+		const cached = receiverNamesByMapper.get(mapperName);
+		if (cached) return cached;
+		const receiverNames = [...new Set((callsByName.get(mapperName) || []).flatMap((call) => {
+			const returnExpression = call.getFirstAncestorByKind(SyntaxKind.ReturnStatement)?.getExpression();
+			const clientName = returnExpression === call || returnExpression?.getDescendants().includes(call) ? enclosingCallableName(call) : void 0;
+			return clientName ? [clientName] : [];
+		}))].flatMap((clientName) => (callsByName.get(clientName) || []).flatMap((call) => {
+			const receiver = call.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+			return receiver ? [receiver.getName()] : [];
+		}));
+		receiverNamesByMapper.set(mapperName, receiverNames);
+		return receiverNames;
+	};
+	const linkedCandidates = candidates.flatMap((candidate) => {
+		if (candidate.direction !== "output" || !candidate.apiPathCandidate) return [candidate];
+		return [candidate, ...(outputCandidatesByApiPath.get(normalizePathForMatch(candidate.backendField)) || []).filter((downstreamCandidate) => downstreamCandidate !== candidate && downstreamCandidate.backend === candidate.backend).map((downstreamCandidate) => ({
+			...candidate,
+			backendField: downstreamCandidate.backendField,
+			sourceFile: downstreamCandidate.sourceFile,
+			sourceLine: downstreamCandidate.sourceLine,
+			mapperType: downstreamCandidate.mapperType
+		}))];
+	});
+	const bindingNamesForCall = (call) => {
+		const declaration = call.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+		if (!declaration) return [];
+		const name = declaration.getNameNode();
+		if (Node.isIdentifier(name)) return [name.getText()];
+		const values = call.getFirstAncestorByKind(SyntaxKind.ArrayLiteralExpression);
+		if (!values || !Node.isArrayBindingPattern(name)) return [];
+		const index = values.getElements().findIndex((value) => value === call || value.getDescendants().includes(call));
+		const binding = name.getElements()[index];
+		return binding && Node.isBindingElement(binding) ? [binding.getNameNode().getText()] : [];
+	};
+	const sourceFilesByPath = new Map(backendSourceFiles.map((file) => [file.getFilePath(), file]));
+	const collectionOwnersByMapper = /* @__PURE__ */ new Map();
+	const findAliasesByCollection = /* @__PURE__ */ new Map();
+	const spreadOwnersByLocal = /* @__PURE__ */ new Map();
+	for (const source of allSourceFiles) {
+		for (const declaration of source.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+			const initializer = declaration.getInitializer();
+			if (!initializer || !Node.isCallExpression(initializer) || !Node.isPropertyAccessExpression(initializer.getExpression())) continue;
+			const find = initializer.getExpression().asKindOrThrow(SyntaxKind.PropertyAccessExpression);
+			if (find.getName() !== "find") continue;
+			const collection = find.getExpression().getText();
+			findAliasesByCollection.set(collection, [...findAliasesByCollection.get(collection) || [], declaration.getName()]);
+		}
+		for (const spread of source.getDescendantsOfKind(SyntaxKind.SpreadAssignment)) {
+			const owner = enclosingCallableName(spread);
+			if (!owner || !spread.getFirstAncestorByKind(SyntaxKind.ReturnStatement)) continue;
+			const local = spread.getExpression().getText();
+			spreadOwnersByLocal.set(local, [...spreadOwnersByLocal.get(local) || [], owner]);
+		}
+		for (const mapCall of analysisCacheService.getCallExpressions(source)) {
+			const expression = mapCall.getExpression();
+			if (!Node.isPropertyAccessExpression(expression) || expression.getName() !== "map") continue;
+			const owner = enclosingCallableName(mapCall);
+			if (!owner) continue;
+			for (const argument of mapCall.getArguments().filter(Node.isIdentifier)) {
+				const key = `${source.getFilePath()}:${argument.getText()}`;
+				collectionOwnersByMapper.set(key, [...collectionOwnersByMapper.get(key) || [], owner]);
+			}
+		}
+	}
+	const propagatedCandidates = [...linkedCandidates];
+	const queuedCandidates = [...linkedCandidates];
+	const seenCandidates = new Set(linkedCandidates.map((candidate) => `${candidate.backend}:${candidate.backendField}:${candidate.apiPathCandidate || ""}:${candidate.sourceFile}:${candidate.sourceLine || ""}`));
+	while (queuedCandidates.length) {
+		const candidate = queuedCandidates.shift();
+		if (candidate.direction !== "output" || !candidate.apiPathCandidate) continue;
+		const add = (pathCandidate) => {
+			const key = `${candidate.backend}:${candidate.backendField}:${pathCandidate}:${candidate.sourceFile}:${candidate.sourceLine || ""}`;
+			if (seenCandidates.has(key)) return;
+			seenCandidates.add(key);
+			const propagated = {
+				...candidate,
+				apiPathCandidate: pathCandidate
+			};
+			propagatedCandidates.push(propagated);
+			queuedCandidates.push(propagated);
+		};
+		const mapper = sourceFilesByPath.get(candidate.sourceFile)?.getFunctions().find((declaration) => candidate.sourceLine && declaration.getStartLineNumber() <= candidate.sourceLine && candidate.sourceLine <= declaration.getEndLineNumber());
+		for (const owner of collectionOwnersByMapper.get(`${candidate.sourceFile}:${mapper?.getName() || ""}`) || []) add(`${owner}[].${lastPathSegment(candidate.apiPathCandidate)}`);
+		const [root, ...segments] = candidate.apiPathCandidate.split(".");
+		const functionName = root.replace(/\[\]$/, "");
+		const collection = root.endsWith("[]");
+		const suffix = segments.join(".");
+		for (const call of callsByName.get(functionName) || []) for (const binding of bindingNamesForCall(call)) add(`${binding}${collection ? "[]" : ""}.${suffix}`);
+		if (collection) for (const alias of findAliasesByCollection.get(functionName) || []) add(`${alias}.${suffix}`);
+		if (!collection) for (const owner of spreadOwnersByLocal.get(functionName) || []) add(`${owner}.${suffix}`);
+	}
+	return dedupeByKey(propagatedCandidates.flatMap((candidate) => {
+		if (candidate.direction !== "output" || !candidate.apiPathCandidate || !candidate.sourceLine) return [candidate];
+		const mapper = backendSourceFiles.find((file) => file.getFilePath() === candidate.sourceFile)?.getFunctions().find((declaration) => declaration.getStartLineNumber() <= candidate.sourceLine && candidate.sourceLine <= declaration.getEndLineNumber());
+		const mapperName = mapper?.getName();
+		const mapperParameter = mapper?.getParameters()[0]?.getName();
+		if (!mapperName || !mapperParameter || !candidate.apiPathCandidate.startsWith(`${mapperParameter}.`)) return [candidate];
+		const receiverNames = receiverNamesForMapper(mapperName);
+		if (!receiverNames.length) return [candidate];
+		return [candidate, ...receiverNames.map((receiverName) => ({
+			...candidate,
+			apiPathCandidate: `${receiverName}${candidate.apiPathCandidate.slice(mapperParameter.length)}`
+		}))];
+	}), (candidate) => `${candidate.backend}:${candidate.direction || ""}:${candidate.apiPathCandidate || ""}:${candidate.backendField}:${candidate.sourceFile}:${candidate.sourceLine || ""}`);
+}
+function calledFunctionName(call) {
+	const expression = call.getExpression();
+	if (Node.isIdentifier(expression)) return expression.getText();
+	if (Node.isPropertyAccessExpression(expression)) return expression.getName();
+}
+function referencedFunctionNames(call) {
+	return call.getArguments().flatMap((argument) => {
+		if (Node.isIdentifier(argument)) return [argument.getText()];
+		if (Node.isPropertyAccessExpression(argument)) return [argument.getName()];
+		return [];
+	});
+}
+function collectReachableBackendFunctionNames(entrySourceFiles, backendSourceFiles) {
+	const reachable = new Set(entrySourceFiles.flatMap((sourceFile) => analysisCacheService.getCallExpressions(sourceFile).map(calledFunctionName).filter((name) => Boolean(name))));
+	for (const sourceFile of backendSourceFiles) for (const property of sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment)) {
+		if (property.getName() !== "mapper") continue;
+		const mapperName = expressionToText(property.getInitializer());
+		if (mapperName) reachable.add(mapperName.split(".").at(-1) || mapperName);
+		const mapperImport = property.getInitializer()?.getSymbol()?.getDeclarations().find(Node.isImportSpecifier);
+		if (mapperImport) reachable.add(mapperImport.getName());
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const sourceFile of backendSourceFiles) for (const call of analysisCacheService.getCallExpressions(sourceFile)) {
+			if (!reachable.has(enclosingCallableName(call))) continue;
+			const calledName = calledFunctionName(call);
+			if (calledName && !reachable.has(calledName)) {
+				reachable.add(calledName);
+				changed = true;
+			}
+			for (const referencedName of referencedFunctionNames(call)) if (!reachable.has(referencedName)) {
+				reachable.add(referencedName);
+				changed = true;
+			}
+		}
+	}
+	return reachable;
+}
+function resolveHandlerFile(routeSourceFile, handlerRef, resolvePath = (sourceFilePath, moduleSpecifier) => resolveModulePath(sourceFilePath, moduleSpecifier, userConfig.resolver.alias, userConfig.repoRoot)) {
+	if (!handlerRef) return {};
+	if (!handlerRef.includes(".")) {
+		if (routeSourceFile.getFunction(handlerRef) || routeSourceFile.getVariableDeclaration(handlerRef)) return {
+			handlerName: handlerRef,
+			handlerFile: routeSourceFile.getFilePath()
+		};
+		for (const importDecl of routeSourceFile.getImportDeclarations()) {
+			if (!importDecl.getNamedImports().find((entry) => entry.getName() === handlerRef)) continue;
+			const resolved = resolvePath(routeSourceFile.getFilePath(), importDecl.getModuleSpecifierValue());
+			if (resolved) return {
+				handlerName: handlerRef,
+				handlerFile: resolved
+			};
+		}
+		return { handlerName: handlerRef };
+	}
+	const [namespaceAlias, memberName] = handlerRef.split(".");
+	for (const importDecl of routeSourceFile.getImportDeclarations()) if (importDecl.getNamespaceImport()?.getText() === namespaceAlias) {
+		const resolved = resolvePath(routeSourceFile.getFilePath(), importDecl.getModuleSpecifierValue());
+		if (resolved) return {
+			handlerName: memberName,
+			handlerFile: resolved
+		};
+	}
+	return { handlerName: memberName };
+}
+async function yieldToEventLoop() {
+	await new Promise((resolve) => setImmediate(resolve));
+}
+async function collectDependencyFiles(project, entryFilePath, routeLabel, resolvePath = (sourceFilePath, moduleSpecifier) => resolveModulePath(sourceFilePath, moduleSpecifier, userConfig.resolver.alias, userConfig.repoRoot)) {
+	const queue = [entryFilePath];
+	const visited = /* @__PURE__ */ new Set();
+	while (queue.length) {
+		const current = queue.shift();
+		if (visited.has(current)) continue;
+		visited.add(current);
+		if (visited.size % 20 === 0) {
+			taskProgressService.log(`${routeLabel} ... Dependency graph: ${visited.size} files scanned, ${queue.length} queued`);
+			await yieldToEventLoop();
+		}
+		let sourceFile = project.getSourceFile(current);
+		if (!sourceFile) try {
+			sourceFile = project.addSourceFileAtPath(current);
+		} catch {
+			continue;
+		}
+		const moduleSpecifiers = [...sourceFile.getImportDeclarations().map((declaration) => declaration.getModuleSpecifierValue()), ...sourceFile.getExportDeclarations().map((declaration) => declaration.getModuleSpecifierValue()).filter((value) => Boolean(value))];
+		for (const moduleSpecifier of moduleSpecifiers) {
+			const resolved = resolvePath(sourceFile.getFilePath(), moduleSpecifier);
+			if (!resolved || visited.has(resolved) || !shouldKeepAnalysisFile(resolved)) continue;
+			queue.push(resolved);
+		}
+	}
+	return [...visited];
+}
+async function analyzeCodebaseRouteContracts(params) {
+	const { cwd, openApiDocument: swagger, selectedRouteKeys, routeContracts, onDocument, routeAnalysisScope } = params;
+	taskProgressService.log("Discovering route files");
+	const routeFiles = await globby(["app/_api/**/routes.@(js|ts)", "app/legacy/**/routes.@(js|ts)"], {
+		cwd,
+		absolute: true
+	});
+	taskProgressService.log(`${routeFiles.length} route files discovered`);
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		compilerOptions: {
+			allowJs: true,
+			checkJs: false,
+			target: 99,
+			module: 99
+		}
+	});
+	const routeDeclarations = [];
+	for (const routeFile of routeFiles) {
+		const routesInitializer = project.addSourceFileAtPath(routeFile).getVariableDeclaration("routes")?.getInitializer();
+		if (!routesInitializer) continue;
+		if (Node.isArrayLiteralExpression(routesInitializer)) {
+			routeDeclarations.push(...extractRoutesFromArray(routeFile, routesInitializer));
+			continue;
+		}
+		if (Node.isAsExpression(routesInitializer) || Node.isSatisfiesExpression(routesInitializer)) {
+			const expression = routesInitializer.getExpression();
+			if (Node.isArrayLiteralExpression(expression)) routeDeclarations.push(...extractRoutesFromArray(routeFile, expression));
+		}
+	}
+	const routeDeclarationsByKey = dedupeByKey(routeDeclarations, (item) => stableKey$2(item.method, item.path, item.file, item.handlerRef || ""));
+	const selectedRouteDeclarations = selectedRouteKeys ? routeDeclarationsByKey.filter((route) => selectedRouteKeys.has(stableKey$2(route.method, route.path))) : routeDeclarationsByKey;
+	taskProgressService.log(`${selectedRouteDeclarations.length} route definitions selected from ${routeDeclarationsByKey.length} discovered`);
+	const documents = [];
+	const dependencyFilesByHandler = /* @__PURE__ */ new Map();
+	const resolvedModulePaths = /* @__PURE__ */ new Map();
+	const resolveCachedModulePath = (sourceFilePath, moduleSpecifier) => {
+		const key = `${sourceFilePath}${moduleSpecifier}`;
+		if (resolvedModulePaths.has(key)) return resolvedModulePaths.get(key);
+		const resolved = resolveModulePath(sourceFilePath, moduleSpecifier, userConfig.resolver.alias, userConfig.repoRoot);
+		resolvedModulePaths.set(key, resolved);
+		return resolved;
+	};
+	const rulesByFile = /* @__PURE__ */ new Map();
+	const aggregationsByFile = /* @__PURE__ */ new Map();
+	const backendFieldsByGraph = /* @__PURE__ */ new Map();
+	for (const [index, routeDeclaration] of selectedRouteDeclarations.entries()) {
+		const routeLabel = `[${index + 1}/${selectedRouteDeclarations.length}] - ${routeDeclaration.method} ${routeDeclaration.path}`;
+		taskProgressService.log(`${routeLabel} ...`);
+		await yieldToEventLoop();
+		const routeKey = stableKey$2(routeDeclaration.method, routeDeclaration.path);
+		const routeContract = routeContracts?.get(routeKey);
+		const operation = swagger?.paths?.[routeDeclaration.path]?.[routeDeclaration.method.toLowerCase()];
+		if (!routeContract && (!operation || !swagger)) continue;
+		const routeSourceFile = project.getSourceFile(routeDeclaration.file);
+		taskProgressService.log(`${routeLabel} ... Resolving handler`);
+		const handler = resolveHandlerFile(routeSourceFile, routeDeclaration.handlerRef, resolveCachedModulePath);
+		const topologyScope = routeAnalysisScope ? await routeAnalysisScope({
+			method: routeDeclaration.method,
+			path: routeDeclaration.path
+		}) : void 0;
+		if (routeAnalysisScope && !topologyScope) continue;
+		taskProgressService.log(topologyScope ? `${routeLabel} ... Loading dependencies from backend graph` : `${routeLabel} ... Collecting dependencies`);
+		const analysisFiles = filterAnalysisFiles(dedupeByKey(await (topologyScope ? topologyScope.analysisFiles : handler.handlerFile ? dependencyFilesByHandler.get(handler.handlerFile) || (() => {
+			const files = collectDependencyFiles(project, handler.handlerFile, routeLabel, resolveCachedModulePath);
+			dependencyFilesByHandler.set(handler.handlerFile, files);
+			return files;
+		})() : [routeDeclaration.file]), (value) => value));
+		taskProgressService.log(`${routeLabel} ... Extracting mappings from ${analysisFiles.length} relevant files`);
+		await yieldToEventLoop();
+		const backendSourceFiles = analysisFiles.filter((file) => file.includes(`${path.sep}app${path.sep}_infra${path.sep}back${path.sep}`)).map((file) => project.getSourceFile(file) || project.addSourceFileAtPath(file)).filter((sourceFile) => {
+			if (!topologyScope) return true;
+			const backendName = inferBackendNameFromFile(sourceFile);
+			return Boolean(backendName && topologyScope.backendTypes.has(backendName));
+		});
+		const apiSourceFiles = analysisFiles.filter((file) => file.includes(`${path.sep}app${path.sep}_api${path.sep}`)).map((file) => project.getSourceFile(file) || project.addSourceFileAtPath(file));
+		const useCaseSourceFiles = analysisFiles.filter((file) => file.includes(`${path.sep}app${path.sep}_usecases${path.sep}`)).map((file) => project.getSourceFile(file) || project.addSourceFileAtPath(file));
+		const reachableBackendFunctionNames = collectReachableBackendFunctionNames([...apiSourceFiles, ...useCaseSourceFiles], backendSourceFiles);
+		const backendNames = dedupeByKey([...topologyScope?.backendTypes || [], ...backendSourceFiles.map((sourceFile) => inferBackendNameFromFile(sourceFile)).filter((value) => Boolean(value))], (value) => value);
+		const backendRouteCandidates = dedupeByKey(backendSourceFiles.flatMap((sourceFile) => {
+			const backendName = inferBackendNameFromFile(sourceFile);
+			return backendName ? extractBackendRouteCandidates({
+				sourceFile,
+				backendName,
+				reachableFunctionNames: reachableBackendFunctionNames,
+				enclosingCallableName
+			}) : [];
+		}), (item) => `${item.backend}:${item.method}:${item.route}:${item.sourceFile}`);
+		const backendGraphKey = `${backendSourceFiles.map((file) => file.getFilePath()).sort().join("|")}::${[...reachableBackendFunctionNames].sort().join("|")}`;
+		const backendFieldCandidates = backendFieldsByGraph.get(backendGraphKey) || (() => {
+			const candidates = extractRouteBackendFieldCandidates(backendSourceFiles, reachableBackendFunctionNames, [...apiSourceFiles, ...useCaseSourceFiles]);
+			backendFieldsByGraph.set(backendGraphKey, candidates);
+			return candidates;
+		})();
+		const apiFieldSourceCandidates = extractRouteApiFieldSourceCandidates(apiSourceFiles);
+		const rules = dedupeByKey(useCaseSourceFiles.flatMap((sourceFile) => {
+			const filePath = sourceFile.getFilePath();
+			const cached = rulesByFile.get(filePath) || extractUseCaseRules(sourceFile);
+			rulesByFile.set(filePath, cached);
+			return cached;
+		}), (item) => `${item.condition}:${item.effect}:${item.elseEffect || ""}:${item.sourceFile}`);
+		const aggregations = dedupeByKey(useCaseSourceFiles.flatMap((sourceFile) => {
+			const filePath = sourceFile.getFilePath();
+			const cached = aggregationsByFile.get(filePath) || extractUseCaseAggregations(sourceFile);
+			aggregationsByFile.set(filePath, cached);
+			return cached;
+		}), (item) => `${item.type}:${item.operation}:${item.sourceCollection}:${item.targetCollection || ""}:${item.condition || ""}:${item.sourceFile}`);
+		const version = routeContract?.version || swagger?.info?.version || "unknown";
+		const document = {
+			key: routeKey,
+			method: routeDeclaration.method,
+			path: routeDeclaration.path,
+			version,
+			routeFile: routeDeclaration.file,
+			handlerName: handler.handlerName,
+			handlerFile: handler.handlerFile,
+			analysisFiles,
+			input: routeContract?.input || extractOpenApiInputProperties(operation, swagger),
+			output: routeContract?.output || extractOpenApiOutputProperties(operation, swagger),
+			backendNames,
+			backendRouteCandidates,
+			backendFieldCandidates,
+			apiFieldSourceCandidates,
+			mappingContext: topologyScope?.mappingContext,
+			backendPathSources: topologyScope?.backendPathSources,
+			rules,
+			aggregations
+		};
+		documents.push(document);
+		await onDocument?.(document);
+	}
+	taskProgressService.log(`Static analysis completed: ${documents.length} exposed routes`);
+	return documents.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+}
+function matchesNormalizedPathSuffix(left, right) {
+	const leftKey = normalizePathForMatch(left);
+	const rightKey = normalizePathForMatch(right);
+	return leftKey.length >= 4 && rightKey.length >= 4 && (leftKey.endsWith(rightKey) || rightKey.endsWith(leftKey));
+}
+function candidateDomainPaths(candidate, direction) {
+	if (!candidate.apiPathCandidate) return [];
+	if (direction === "input") return [candidate.apiPathCandidate.replace(/^[^.]+\./, "")];
+	const paths = [candidate.apiPathCandidate];
+	if (!candidate.apiPathCandidate.includes(".")) {
+		const backendRoot = candidate.backendField.split(/[.[\]]/).find(Boolean);
+		if (backendRoot) paths.push(`${backendRoot}.${candidate.apiPathCandidate}`);
+	}
+	return paths;
+}
+function matchesDomainPath(domainPath, candidate, direction) {
+	if (!domainPath) return false;
+	const domainKey = normalizePathForMatch(domainPath);
+	return candidateDomainPaths(candidate, direction).some((candidatePath) => normalizePathForMatch(candidatePath) === domainKey);
+}
+function matchCandidates(property, document, direction) {
+	const propertyKey = normalizePathForMatch(property.path);
+	const domainPath = resolveApiFieldSourceCandidate(document, property, direction)?.domainField;
+	const domainKey = domainPath ? normalizePathForMatch(domainPath) : void 0;
+	const mapperBackendSources = (document.mappingContext || []).filter((context) => context.layer === "backend" && context.direction === direction).map((context) => `${context.backend_type}:${context.source}`);
+	const scopedBackendSources = new Set(mapperBackendSources.length ? [...mapperBackendSources, ...(document.backendPathSources || []).map((context) => `${context.backend}:${context.sourceFile}`)] : []);
+	const matchingCandidates = document.backendFieldCandidates.filter((candidate) => candidate.backend && candidate.backendField).filter((candidate) => !candidate.direction || candidate.direction === direction).filter((candidate) => {
+		if (direction === "output" && domainKey) return Boolean(candidate.apiPathCandidate && matchesDomainPath(domainPath, candidate, direction));
+		if (domainKey && candidate.apiPathCandidate && matchesDomainPath(domainPath, candidate, direction)) return true;
+		if (candidate.apiPathCandidate && normalizePathForMatch(candidate.apiPathCandidate) === propertyKey) return true;
+		if (candidate.requiresReview && candidate.apiPathCandidate && lastPathSegment(property.path) === candidate.apiPathCandidate) return true;
+		if (matchesNormalizedPathSuffix(property.path, candidate.backendField)) return true;
+		return false;
+	}).map((candidate) => ({
+		...candidate,
+		confidence: candidate.apiPathCandidate && (normalizePathForMatch(candidate.apiPathCandidate) === propertyKey || matchesNormalizedPathSuffix(property.path, candidate.backendField) || matchesDomainPath(domainPath, candidate, direction)) ? candidate.requiresReview ? candidate.confidence : Math.max(candidate.confidence, 90) : candidate.confidence
+	}));
+	if (!scopedBackendSources.size) return matchingCandidates;
+	return [...new Set(matchingCandidates.map((candidate) => candidate.backend))].flatMap((backend) => {
+		const backendMatches = matchingCandidates.filter((candidate) => candidate.backend === backend);
+		const scopedMatches = backendMatches.filter((candidate) => scopedBackendSources.has(`${candidate.backend}:${candidate.sourceFile}`));
+		return scopedMatches.length ? scopedMatches : backendMatches;
+	});
+}
+function evidenceStatusFromCandidates(candidates) {
+	if (!candidates.length) return "needs_review";
+	if (candidates.some((candidate) => candidate.requiresReview)) return "needs_review";
+	return candidates.some((candidate) => candidate.confidence >= 90) ? "confirmed" : "inferred";
+}
+function backendFieldSource(candidate) {
+	return candidate.sourceLine ? `${candidate.sourceFile}:${candidate.sourceLine}` : candidate.sourceFile;
+}
+function isTransversalInput(property) {
+	const rootField = property.path.split(/[.[\]]/).find(Boolean)?.toLowerCase();
+	const leafField = lastPathSegment(property.path).toLowerCase();
+	return userConfig.analysis.transversalInputs.includes(property.path) || userConfig.analysis.transversalInputs.includes(leafField) || Boolean(rootField && userConfig.analysis.transversalInputs.includes(rootField));
+}
+function isIgnoredOutput(property) {
+	return userConfig.analysis.ignoredOutputs.some((ignoredPath) => property.path === ignoredPath || property.path.startsWith(`${ignoredPath}.`) || property.path.includes(`.${ignoredPath}.`) || property.path.endsWith(`.${ignoredPath}`));
+}
+function unresolvedBackendCandidates(property, domainField, document, direction) {
+	const expectedPath = domainField || property.path;
+	const expectedField = lastPathSegment(expectedPath);
+	const candidates = document.backendFieldCandidates.filter((candidate) => candidate.direction !== (direction === "output" ? "input" : "output")).filter((candidate) => candidate.apiPathCandidate && lastPathSegment(candidate.apiPathCandidate) === expectedField).slice(0, 3);
+	return candidates.length ? candidates.map((candidate) => ({
+		backend: candidate.backend,
+		field: candidate.backendField,
+		domain_field: candidate.apiPathCandidate,
+		source_file: backendFieldSource(candidate),
+		reason: `Candidate domain path "${candidate.apiPathCandidate}" does not deterministically reach "${expectedPath}"; an intermediate helper result or local alias was not resolved.`
+	})) : void 0;
+}
+function resolveApiFieldSourceCandidate(document, property, direction) {
+	const exactMatches = (document.apiFieldSourceCandidates || []).filter((candidate) => candidate.direction === direction).filter((candidate) => normalizePathForMatch(candidate.field) === normalizePathForMatch(property.path));
+	const scopedApiSources = (document.mappingContext || []).filter((context) => context.layer === "api" && context.direction === direction).map((context) => context.source);
+	const sourceRank = new Map(scopedApiSources.map((source, index) => [source, index]));
+	return exactMatches.map((candidate, index) => ({
+		candidate,
+		index,
+		rank: sourceRank.get(candidate.sourceFile) ?? Number.MAX_SAFE_INTEGER
+	})).sort((left, right) => left.rank - right.rank || left.index - right.index)[0]?.candidate;
+}
+function resolveApiPropertySource(document, property, direction, matches = []) {
+	const match = resolveApiFieldSourceCandidate(document, property, direction);
+	return match ? `${match.sourceFile}:${match.line}` : matches[0] ? backendFieldSource(matches[0]) : document.routeFile || null;
+}
+function ensureBackendRouteRecord(backendRoutesByKey, document, candidate) {
+	const key = stableKey$2(document.key, candidate.backend, candidate.route);
+	const existing = backendRoutesByKey.get(key);
+	if (existing) return existing;
+	const created = {
+		key,
+		backend: candidate.backend,
+		route_key: document.key,
+		route: `${candidate.method || "CALL"} ${candidate.route}`,
+		source_file: candidate.sourceFile,
+		provenance: "code_analysis"
+	};
+	backendRoutesByKey.set(key, created);
+	return created;
+}
+function resolveBackendRouteCandidate(document, match) {
+	const sameBackendCandidates = document.backendRouteCandidates.filter((candidate) => candidate.backend === match.backend);
+	return sameBackendCandidates.find((candidate) => candidate.sourceFile === match.sourceFile) || sameBackendCandidates[0];
+}
+async function buildCatalogue(documents) {
+	const routes = documents.map((document) => ({
+		key: document.key,
+		method: document.method,
+		path: document.path,
+		version: document.version,
+		source_file: document.routeFile || null,
+		analysis_files: document.analysisFiles,
+		backends: document.backendNames
+	}));
+	const routeInputProperties = [];
+	const routeOutputProperties = [];
+	const backendRoutesByKey = /* @__PURE__ */ new Map();
+	const backendPropertiesByKey = /* @__PURE__ */ new Map();
+	const mappingEvidence = [];
+	const rules = documents.flatMap((document) => document.rules.map((rule) => ({
+		route_key: document.key,
+		condition: rule.condition,
+		effect: rule.effect,
+		else_effect: rule.elseEffect,
+		source_file: rule.sourceFile
+	})));
+	const aggregations = documents.flatMap((document) => document.aggregations.map((aggregation) => ({
+		route_key: document.key,
+		type: aggregation.type,
+		operation: aggregation.operation,
+		source_collection: aggregation.sourceCollection,
+		target_collection: aggregation.targetCollection,
+		condition: aggregation.condition,
+		description: aggregation.description,
+		source_file: aggregation.sourceFile
+	})));
+	for (const document of documents) {
+		for (const backendRoute of document.backendRouteCandidates) ensureBackendRouteRecord(backendRoutesByKey, document, backendRoute);
+		for (const property of document.input) {
+			const matches = matchCandidates(property, document, "input");
+			const apiSource = resolveApiFieldSourceCandidate(document, property, "input");
+			const apiPropertyKey = stableKey$2(document.key, "input", property.path);
+			const backendNames = dedupeByKey(matches.map((candidate) => candidate.backend), (value) => value);
+			const isTransverseWithoutMapping = isTransversalInput(property) && !matches.length;
+			const evidenceStatus = isTransverseWithoutMapping ? "confirmed" : evidenceStatusFromCandidates(matches);
+			const backendMappings = dedupeByKey(matches.map((match) => {
+				const backendRouteCandidate = resolveBackendRouteCandidate(document, match);
+				return {
+					backend: match.backend,
+					method: backendRouteCandidate?.method || null,
+					route: backendRouteCandidate?.route || "unknown",
+					field: match.backendField,
+					source_file: backendFieldSource(match),
+					confidence: match.confidence,
+					mapper_type: match.mapperType,
+					reason: match.reviewReason
+				};
+			}), (mapping) => `${mapping.backend}:${mapping.method || "CALL"}:${mapping.route}:${mapping.field}:${mapping.source_file}`);
+			routeInputProperties.push({
+				key: apiPropertyKey,
+				route_key: document.key,
+				direction: "input",
+				field: property.path,
+				domain_field: apiSource?.domainField,
+				transversal: isTransversalInput(property) || void 0,
+				backend_names: backendNames,
+				backend_mappings: backendMappings,
+				description: normalizeDescription(property.description),
+				source_file: resolveApiPropertySource(document, property, "input", matches),
+				analysis_files: document.analysisFiles,
+				evidence_status: evidenceStatus
+			});
+			if (!matches.length && !isTransverseWithoutMapping) mappingEvidence.push({
+				key: stableKey$2(apiPropertyKey, "needs_review"),
+				evidence_type: "static_analysis",
+				status: "needs_review",
+				confidence_score: 0,
+				comment: `No backend property candidate matched ${property.path}`,
+				input_property_key: apiPropertyKey,
+				backend_property_key: stableKey$2(document.key, "unmatched", "input", property.path),
+				source_file: document.routeFile || null
+			});
+			for (const match of matches) {
+				const backendRouteKey = ensureBackendRouteRecord(backendRoutesByKey, document, resolveBackendRouteCandidate(document, match) || {
+					backend: match.backend,
+					route: "unknown",
+					sourceFile: match.sourceFile
+				}).key;
+				const backendPropertyKey = stableKey$2(backendRouteKey, "input", match.backendField);
+				backendPropertiesByKey.set(backendPropertyKey, {
+					key: backendPropertyKey,
+					backend_route_key: backendRouteKey,
+					backend: match.backend,
+					field: match.backendField,
+					direction: "input",
+					source_file: backendFieldSource(match),
+					provenance: "code_analysis"
+				});
+				mappingEvidence.push({
+					key: stableKey$2(apiPropertyKey, backendPropertyKey),
+					evidence_type: "static_analysis",
+					status: match.requiresReview ? "needs_review" : match.confidence >= 90 ? "confirmed" : "inferred",
+					confidence_score: match.confidence,
+					comment: match.reviewReason || `Code analysis candidate from ${path.basename(match.sourceFile)}`,
+					input_property_key: apiPropertyKey,
+					backend_property_key: backendPropertyKey,
+					source_file: backendFieldSource(match)
+				});
+			}
+		}
+		for (const property of document.output) {
+			if (isIgnoredOutput(property)) continue;
+			const matches = matchCandidates(property, document, "output");
+			const apiSource = resolveApiFieldSourceCandidate(document, property, "output");
+			const apiPropertyKey = stableKey$2(document.key, "output", property.path);
+			const backendNames = dedupeByKey(matches.map((candidate) => candidate.backend), (value) => value);
+			const evidenceStatus = evidenceStatusFromCandidates(matches);
+			const backendMappings = dedupeByKey(matches.map((match) => {
+				const backendRouteCandidate = resolveBackendRouteCandidate(document, match);
+				return {
+					backend: match.backend,
+					method: backendRouteCandidate?.method || null,
+					route: backendRouteCandidate?.route || "unknown",
+					field: match.backendField,
+					source_file: backendFieldSource(match),
+					confidence: match.confidence,
+					mapper_type: match.mapperType,
+					reason: match.reviewReason
+				};
+			}), (mapping) => `${mapping.backend}:${mapping.method || "CALL"}:${mapping.route}:${mapping.field}:${mapping.source_file}`);
+			routeOutputProperties.push({
+				key: apiPropertyKey,
+				route_key: document.key,
+				direction: "output",
+				field: property.path,
+				domain_field: apiSource?.domainField,
+				backend_names: backendNames,
+				backend_mappings: backendMappings,
+				description: normalizeDescription(property.description),
+				source_file: resolveApiPropertySource(document, property, "output", matches),
+				analysis_files: document.analysisFiles,
+				evidence_status: evidenceStatus,
+				...matches.length ? {} : { unresolved_backend_candidates: unresolvedBackendCandidates(property, apiSource?.domainField, document, "output") }
+			});
+			if (!matches.length) mappingEvidence.push({
+				key: stableKey$2(apiPropertyKey, "needs_review"),
+				evidence_type: "static_analysis",
+				status: "needs_review",
+				confidence_score: 0,
+				comment: `No backend property candidate matched ${property.path}`,
+				output_property_key: apiPropertyKey,
+				backend_property_key: stableKey$2(document.key, "unmatched", "output", property.path),
+				source_file: document.routeFile || null
+			});
+			for (const match of matches) {
+				const backendRouteKey = ensureBackendRouteRecord(backendRoutesByKey, document, resolveBackendRouteCandidate(document, match) || {
+					backend: match.backend,
+					route: "unknown",
+					sourceFile: match.sourceFile
+				}).key;
+				const backendPropertyKey = stableKey$2(backendRouteKey, "output", match.backendField);
+				backendPropertiesByKey.set(backendPropertyKey, {
+					key: backendPropertyKey,
+					backend_route_key: backendRouteKey,
+					backend: match.backend,
+					field: match.backendField,
+					direction: "output",
+					source_file: backendFieldSource(match),
+					provenance: "code_analysis"
+				});
+				mappingEvidence.push({
+					key: stableKey$2(apiPropertyKey, backendPropertyKey),
+					evidence_type: "static_analysis",
+					status: match.requiresReview ? "needs_review" : match.confidence >= 90 ? "confirmed" : "inferred",
+					confidence_score: match.confidence,
+					comment: match.reviewReason || `Code analysis candidate from ${path.basename(match.sourceFile)}`,
+					output_property_key: apiPropertyKey,
+					backend_property_key: backendPropertyKey,
+					source_file: backendFieldSource(match)
+				});
+			}
+		}
+	}
+	const needsReviewCount = routeInputProperties.filter((item) => item.evidence_status === "needs_review").length + routeOutputProperties.filter((item) => item.evidence_status === "needs_review").length;
+	return {
+		generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+		routes,
+		route_input_properties: routeInputProperties,
+		route_output_properties: routeOutputProperties,
+		backend_routes: [...backendRoutesByKey.values()],
+		backend_properties: [...backendPropertiesByKey.values()],
+		mapping_evidence: mappingEvidence,
+		rules,
+		aggregations,
+		stats: {
+			routes: routes.length,
+			input_properties: routeInputProperties.length,
+			output_properties: routeOutputProperties.length,
+			backend_routes: backendRoutesByKey.size,
+			backend_properties: backendPropertiesByKey.size,
+			mapping_evidence: mappingEvidence.length,
+			rules: rules.length,
+			aggregations: aggregations.length,
+			needs_review: needsReviewCount,
+			needs_review_percentage: calculateNeedsReviewPercentage(routeInputProperties.length, routeOutputProperties.length, needsReviewCount)
+		}
+	};
+}
+//#endregion
+//#region src/services/directusSyncService.ts
+const ROUTE_STATUSES = { published: "published" };
+const LOCAL_SOURCE_FILE = "digital-api:tools/datasource-catalogue";
+const DIRECTUS_RETRY_MAX_ATTEMPTS = 6;
+const DIRECTUS_RETRY_INITIAL_DELAY_MS = 1e3;
+const DIRECTUS_RETRY_MAX_DELAY_MS = 8e3;
+const DIRECTUS_DELETE_WORKERS = 2;
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isServiceUnavailableError(error) {
+	if (!isRecord$2(error)) return false;
+	if ((isRecord$2(error.response) ? error.response.status : void 0) === 503) return true;
+	return Array.isArray(error.errors) && error.errors.some((item) => isRecord$2(item) && isRecord$2(item.extensions) && item.extensions.code === "SERVICE_UNAVAILABLE");
+}
+function isTransientNetworkError(error) {
+	if (error instanceof TypeError && error.message === "fetch failed") return true;
+	if (!isRecord$2(error)) return false;
+	if (error.message === "fetch failed") return true;
+	const cause = isRecord$2(error.cause) ? error.cause : void 0;
+	return cause?.code === "ECONNRESET" || cause?.code === "ECONNREFUSED" || cause?.code === "ETIMEDOUT" || cause?.code === "UND_ERR_CONNECT_TIMEOUT";
+}
+async function retryDirectusRequest(request, options = {}) {
+	const maxAttempts = options.maxAttempts ?? DIRECTUS_RETRY_MAX_ATTEMPTS;
+	const initialDelayMs = options.initialDelayMs ?? DIRECTUS_RETRY_INITIAL_DELAY_MS;
+	const maxDelayMs = options.maxDelayMs ?? DIRECTUS_RETRY_MAX_DELAY_MS;
+	const sleep = options.sleep || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) try {
+		return await request();
+	} catch (error) {
+		if (!isServiceUnavailableError(error) && !isTransientNetworkError(error) || attempt === maxAttempts) throw error;
+		const delayMs = Math.min(initialDelayMs * 2 ** (attempt - 1), maxDelayMs);
+		taskProgressService.report(`Directus request temporarily unavailable; retrying ${attempt + 1}/${maxAttempts} in ${(delayMs / 1e3).toFixed(1)}s`);
+		await sleep(delayMs);
+	}
+	throw new Error("Directus retry attempts exhausted");
+}
+function toRouteIdentifier(route) {
+	return `${route.method} ${route.path}`;
+}
+function toBackendRouteIdentifier(route) {
+	return toRouteIdentifier(route);
+}
+function groupBackendRoutesForDirectusSync(backendRoutes, apiRoutesByKey) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const backendRoute of backendRoutes) {
+		const apiRoute = apiRoutesByKey.get(backendRoute.route_key);
+		const key = apiRoute ? `${backendRoute.backend}${apiRoute.method}${apiRoute.path}` : `${backendRoute.backend}missing-api-route${backendRoute.key}`;
+		const group = groups.get(key);
+		if (group) group.keys.push(backendRoute.key);
+		else groups.set(key, {
+			route: backendRoute,
+			keys: [backendRoute.key]
+		});
+	}
+	return [...groups.values()];
+}
+function selectCatalogueForDirectusPush(catalogue, routeSelector) {
+	if (!routeSelector) return catalogue;
+	const routes = catalogue.routes.filter((route) => route.method === routeSelector.method && route.path === routeSelector.path);
+	if (!routes.length) throw new Error(`Route not found in catalogue: ${routeSelector.method} ${routeSelector.path}`);
+	const routeKeys = new Set(routes.map((route) => route.key));
+	const routeInputProperties = catalogue.route_input_properties.filter((property) => routeKeys.has(property.route_key));
+	const routeOutputProperties = catalogue.route_output_properties.filter((property) => routeKeys.has(property.route_key));
+	const backendRoutes = catalogue.backend_routes.filter((route) => routeKeys.has(route.route_key));
+	const backendRouteKeys = new Set(backendRoutes.map((route) => route.key));
+	const backendProperties = catalogue.backend_properties.filter((property) => backendRouteKeys.has(property.backend_route_key));
+	const apiPropertyKeys = new Set([...routeInputProperties, ...routeOutputProperties].map((property) => property.key));
+	const backendPropertyKeys = new Set(backendProperties.map((property) => property.key));
+	return {
+		...catalogue,
+		routes,
+		route_input_properties: routeInputProperties,
+		route_output_properties: routeOutputProperties,
+		backend_routes: backendRoutes,
+		backend_properties: backendProperties,
+		mapping_evidence: catalogue.mapping_evidence.filter((evidence) => backendPropertyKeys.has(evidence.backend_property_key) && (apiPropertyKeys.has(evidence.input_property_key || "") || apiPropertyKeys.has(evidence.output_property_key || ""))),
+		rules: catalogue.rules.filter((rule) => routeKeys.has(rule.route_key)),
+		aggregations: catalogue.aggregations.filter((aggregation) => routeKeys.has(aggregation.route_key))
+	};
+}
+function inferInputType(field) {
+	if (field.startsWith("params.")) return "PATH";
+	if (field.startsWith("query.")) return "QUERY";
+	if (field.startsWith("headers.")) return "HEADER";
+	return "BODY";
+}
+function normalizeLookupKey(value) {
+	return value.toUpperCase().replace(/[^A-Z0-9]/g, "");
+}
+function normalizeDirectusPath(value) {
+	return value.replace(/\?\.\[/g, "[").replace(/\?\./g, ".");
+}
+function toPascalCase(value) {
+	return value.toLowerCase().replace(/(^|[^a-z0-9]+)([a-z0-9])/g, (_match, _separator, character) => character.toUpperCase());
+}
+function buildTranslationSummary(route) {
+	const routeIdentifier = toRouteIdentifier(route);
+	const primarySource = route.analysis_files[0] || route.source_file || LOCAL_SOURCE_FILE;
+	return [{
+		languages_code: "en-US",
+		summary: routeIdentifier,
+		description: `Generated from ${path.basename(primarySource)} on 2026-07-16`
+	}];
+}
+async function createClient(baseUrl, token) {
+	const client = createDirectus(baseUrl).with(rest()).with(staticToken(token));
+	return { request: (request) => retryDirectusRequest(() => client.request(request)) };
+}
+function directusReadItems(collection, query) {
+	return readItems(collection, query);
+}
+function directusCreateItem(collection, payload) {
+	return createItem(collection, payload);
+}
+function directusUpdateItem(collection, id, payload) {
+	return updateItem(collection, id, payload);
+}
+function directusDeleteItem(collection, id) {
+	return deleteItem(collection, id);
+}
+async function findOrphanedPropertyLinks(client) {
+	const [inputProperties, outputProperties, backendProperties, inputLinks, outputLinks] = await Promise.all([
+		client.request(directusReadItems("route_input_properties", {
+			fields: ["id"],
+			limit: -1
+		})),
+		client.request(directusReadItems("route_output_properties", {
+			fields: ["id"],
+			limit: -1
+		})),
+		client.request(directusReadItems("backend_properties", {
+			fields: ["id"],
+			limit: -1
+		})),
+		client.request(directusReadItems("route_input_properties_backend_properties", {
+			fields: [
+				"id",
+				"route_input_properties_id",
+				"backend_properties_id"
+			],
+			limit: -1
+		})),
+		client.request(directusReadItems("route_output_properties_backend_properties", {
+			fields: [
+				"id",
+				"route_output_properties_id",
+				"backend_properties_id"
+			],
+			limit: -1
+		}))
+	]);
+	const ids = (items) => new Set(items.map((item) => String(item.id)));
+	const inputIds = ids(inputProperties);
+	const outputIds = ids(outputProperties);
+	const backendIds = ids(backendProperties);
+	return {
+		input: inputLinks.filter((link) => !inputIds.has(String(link.route_input_properties_id)) || !backendIds.has(String(link.backend_properties_id))),
+		output: outputLinks.filter((link) => !outputIds.has(String(link.route_output_properties_id)) || !backendIds.has(String(link.backend_properties_id)))
+	};
+}
+async function deleteOrphanedPropertyLinks(client, orphanedLinks) {
+	const links = [...orphanedLinks.input.map((link) => ({
+		collection: "route_input_properties_backend_properties",
+		id: link.id
+	})), ...orphanedLinks.output.map((link) => ({
+		collection: "route_output_properties_backend_properties",
+		id: link.id
+	}))];
+	let nextIndex = 0;
+	await Promise.all(Array.from({ length: Math.min(DIRECTUS_DELETE_WORKERS, links.length) }, async () => {
+		while (nextIndex < links.length) {
+			const link = links[nextIndex++];
+			await client.request(directusDeleteItem(link.collection, link.id));
+		}
+	}));
+	return links.length;
+}
+async function cleanupOrphanedPropertyLinks(client) {
+	taskProgressService.report("Cleaning orphaned property links");
+	const removed = await deleteOrphanedPropertyLinks(client, await findOrphanedPropertyLinks(client));
+	taskProgressService.report(`Removed ${removed} orphaned property links`);
+	return removed;
+}
+async function cleanDirectusOrphanedPropertyLinks(options) {
+	taskProgressService.report("Connecting to Directus");
+	const client = await createClient(options.baseUrl, options.token);
+	taskProgressService.report("Finding orphaned property links");
+	const orphanedLinks = await findOrphanedPropertyLinks(client);
+	const orphanedCount = orphanedLinks.input.length + orphanedLinks.output.length;
+	if (options.dryRun) {
+		taskProgressService.report(`${orphanedCount} orphaned property links found (dry-run)`);
+		return {
+			orphanedLinks: orphanedCount,
+			removedOrphanedLinks: 0
+		};
+	}
+	taskProgressService.report("Removing orphaned property links");
+	const removedOrphanedLinks = await deleteOrphanedPropertyLinks(client, orphanedLinks);
+	taskProgressService.report(`Removed ${removedOrphanedLinks} orphaned property links`);
+	return {
+		orphanedLinks: orphanedCount,
+		removedOrphanedLinks
+	};
+}
+async function loadDirectusReferenceData(client) {
+	const values = await client.request(directusReadItems("predefined_values", {
+		filter: { type: { _in: [
+			"backend",
+			"in_type",
+			"out_type"
+		] } },
+		fields: [
+			"id",
+			"label",
+			"type"
+		],
+		limit: -1
+	}));
+	const backendIds = /* @__PURE__ */ new Map();
+	const inTypeIds = /* @__PURE__ */ new Map();
+	const outTypeIds = /* @__PURE__ */ new Map();
+	for (const value of values) {
+		const normalizedKeys = [normalizeLookupKey(value.id), normalizeLookupKey(value.label)];
+		const target = value.type === "backend" ? backendIds : value.type === "in_type" ? inTypeIds : outTypeIds;
+		for (const key of normalizedKeys) target.set(key, value.id);
+	}
+	return {
+		backendIds,
+		inTypeIds,
+		outTypeIds
+	};
+}
+async function resolveBackendReference(client, references, backend) {
+	const lookupKey = normalizeLookupKey(backend);
+	const existingId = references.backendIds.get(lookupKey);
+	if (existingId) return {
+		id: existingId,
+		created: false
+	};
+	if (!isKnownBackendType(backend)) return { created: false };
+	const created = await client.request(directusCreateItem("predefined_values", {
+		id: backend,
+		label: toPascalCase(backend),
+		type: "backend"
+	}));
+	const id = typeof created === "string" ? created : created.id;
+	references.backendIds.set(lookupKey, id);
+	return {
+		id,
+		created: true
+	};
+}
+async function upsertRoute(client, route) {
+	const routeIdentifier = toRouteIdentifier(route);
+	const [existing] = await client.request(directusReadItems("routes", {
+		filter: { route: { _eq: routeIdentifier } },
+		fields: ["id", "route"],
+		limit: 1
+	}));
+	const payload = {
+		route: routeIdentifier,
+		status: ROUTE_STATUSES.published,
+		deprecated: false,
+		first_published_version: route.version,
+		last_published_version: route.version,
+		translations: buildTranslationSummary(route)
+	};
+	if (!existing) {
+		const created = await client.request(directusCreateItem("routes", payload));
+		return typeof created === "string" ? created : created.id;
+	}
+	await client.request(directusUpdateItem("routes", existing.id, payload));
+	return existing.id;
+}
+async function upsertInputProperty(client, property, routeId, inType) {
+	const field = normalizeDirectusPath(property.field);
+	const [existing] = await client.request(directusReadItems("route_input_properties", {
+		filter: {
+			route_id: { _eq: routeId },
+			path: { _eq: field },
+			in_type: { _eq: inType }
+		},
+		fields: [
+			"id",
+			"route_id",
+			"path",
+			"in_type"
+		],
+		limit: 1
+	}));
+	const payload = {
+		route_id: routeId,
+		path: field,
+		in_type: inType,
+		description: property.description || null,
+		source_file: property.source_file || LOCAL_SOURCE_FILE,
+		deprecated: false
+	};
+	if (!existing) {
+		const created = await client.request(directusCreateItem("route_input_properties", payload));
+		return typeof created === "string" ? created : created.id;
+	}
+	await client.request(directusUpdateItem("route_input_properties", existing.id, payload));
+	return existing.id;
+}
+async function upsertOutputProperty(client, property, routeId, outType) {
+	const field = normalizeDirectusPath(property.field);
+	const [existing] = await client.request(directusReadItems("route_output_properties", {
+		filter: {
+			route_id: { _eq: routeId },
+			path: { _eq: field },
+			out_type: { _eq: outType }
+		},
+		fields: [
+			"id",
+			"route_id",
+			"path",
+			"out_type"
+		],
+		limit: 1
+	}));
+	const payload = {
+		route_id: routeId,
+		path: field,
+		out_type: outType,
+		description: property.description || null,
+		source_file: property.source_file || LOCAL_SOURCE_FILE,
+		deprecated: false,
+		is_dynamic: field.includes("[]") || field.includes("{")
+	};
+	if (!existing) {
+		const created = await client.request(directusCreateItem("route_output_properties", payload));
+		return typeof created === "string" ? created : created.id;
+	}
+	await client.request(directusUpdateItem("route_output_properties", existing.id, payload));
+	return existing.id;
+}
+async function upsertBackendRoute(client, apiRoute, backendRoute, backendValueId) {
+	const routeValue = toBackendRouteIdentifier(apiRoute);
+	const [existing] = await client.request(directusReadItems("backend_routes", {
+		filter: { route: { _eq: routeValue } },
+		fields: [
+			"id",
+			"route",
+			"backend"
+		],
+		limit: 1
+	}));
+	const payload = {
+		route: routeValue,
+		backend: backendValueId
+	};
+	if (!existing) {
+		const created = await client.request(directusCreateItem("backend_routes", payload));
+		return typeof created === "string" ? created : created.id;
+	}
+	return existing.id;
+}
+async function upsertBackendProperty(client, property, backendRouteId, typeId) {
+	const field = normalizeDirectusPath(property.field);
+	const [existing] = await client.request(directusReadItems("backend_properties", {
+		filter: {
+			route: { _eq: backendRouteId },
+			path: { _eq: field },
+			type: { _eq: typeId }
+		},
+		fields: [
+			"id",
+			"route",
+			"path",
+			"type",
+			"source_file"
+		],
+		limit: 1
+	}));
+	const payload = {
+		route: backendRouteId,
+		path: field || null,
+		type: typeId,
+		source_file: property.source_file || LOCAL_SOURCE_FILE,
+		comments: property.provenance === "ai" ? "Inferred with AI" : null,
+		content_name: null
+	};
+	if (!existing) {
+		const created = await client.request(directusCreateItem("backend_properties", payload));
+		return typeof created === "string" ? created : created.id;
+	}
+	return existing.id;
+}
+async function ensureInputLink(client, inputPropertyId, backendPropertyId) {
+	const [existing] = await client.request(directusReadItems("route_input_properties_backend_properties", {
+		filter: {
+			route_input_properties_id: { _eq: inputPropertyId },
+			backend_properties_id: { _eq: backendPropertyId }
+		},
+		fields: ["id"],
+		limit: 1
+	}));
+	if (existing) return false;
+	await client.request(directusCreateItem("route_input_properties_backend_properties", {
+		route_input_properties_id: inputPropertyId,
+		backend_properties_id: backendPropertyId
+	}));
+	return true;
+}
+async function ensureOutputLink(client, outputPropertyId, backendPropertyId) {
+	const [existing] = await client.request(directusReadItems("route_output_properties_backend_properties", {
+		filter: {
+			route_output_properties_id: { _eq: outputPropertyId },
+			backend_properties_id: { _eq: backendPropertyId }
+		},
+		fields: ["id"],
+		limit: 1
+	}));
+	if (existing) return false;
+	await client.request(directusCreateItem("route_output_properties_backend_properties", {
+		route_output_properties_id: outputPropertyId,
+		backend_properties_id: backendPropertyId
+	}));
+	return true;
+}
+async function pushCatalogueToDirectus(catalogue, options) {
+	const pushedCollections = [
+		"predefined_values",
+		"routes",
+		"route_input_properties",
+		"route_output_properties",
+		"backend_routes",
+		"backend_properties",
+		"route_input_properties_backend_properties",
+		"route_output_properties_backend_properties"
+	];
+	const skippedCollections = ["mapping_evidence"];
+	const catalogueToPush = selectCatalogueForDirectusPush(catalogue, options.routeSelector);
+	if (options.dryRun) {
+		taskProgressService.report("Validating reconstructed catalogue (dry-run)");
+		return {
+			pushedCollections,
+			pushedItems: catalogueToPush.routes.length + catalogueToPush.route_input_properties.length + catalogueToPush.route_output_properties.length + catalogueToPush.backend_routes.length + catalogueToPush.backend_properties.length + catalogueToPush.mapping_evidence.length,
+			skippedCollections,
+			warnings: [],
+			removedOrphanedLinks: 0
+		};
+	}
+	taskProgressService.report("Connecting to Directus");
+	const client = await createClient(options.baseUrl, options.token);
+	taskProgressService.report("Loading predefined values from Directus");
+	const refs = await loadDirectusReferenceData(client);
+	const warnings = /* @__PURE__ */ new Set();
+	let pushedItems = 0;
+	const apiRoutesByKey = new Map(catalogueToPush.routes.map((route) => [route.key, route]));
+	const backendRouteGroups = groupBackendRoutesForDirectusSync(catalogueToPush.backend_routes, apiRoutesByKey);
+	const backendRouteGroupsByApiRouteKey = /* @__PURE__ */ new Map();
+	const backendRouteApiRouteKeys = /* @__PURE__ */ new Map();
+	for (const group of backendRouteGroups) {
+		const routeKey = group.route.route_key;
+		if (!apiRoutesByKey.has(routeKey)) {
+			warnings.add(`MISSING_API_ROUTE: backend route ${group.route.key} could not be linked to an API route`);
+			continue;
+		}
+		backendRouteGroupsByApiRouteKey.set(routeKey, [...backendRouteGroupsByApiRouteKey.get(routeKey) || [], group]);
+		for (const key of group.keys) backendRouteApiRouteKeys.set(key, routeKey);
+	}
+	for (const [routeIndex, route] of catalogueToPush.routes.entries()) {
+		taskProgressService.report(`Synchronizing routes ${routeIndex + 1}/${catalogueToPush.routes.length}: ${route.method} ${route.path}`);
+		const routeId = await upsertRoute(client, route);
+		pushedItems += 1;
+		const backendRouteIds = /* @__PURE__ */ new Map();
+		const backendPropertyIds = /* @__PURE__ */ new Map();
+		const routeBackendGroups = backendRouteGroupsByApiRouteKey.get(route.key) || [];
+		for (const [index, backendRouteGroup] of routeBackendGroups.entries()) {
+			const { route: backendRoute, keys } = backendRouteGroup;
+			taskProgressService.report(`Synchronizing backend routes ${index + 1}/${routeBackendGroups.length}: ${backendRoute.backend}`);
+			const backendReference = await resolveBackendReference(client, refs, backendRoute.backend);
+			if (!backendReference.id) {
+				warnings.add(`UNKNOWN_BACKEND_TYPE: ${backendRoute.backend} is not declared in BackendTypes.ts for route ${route.method} ${route.path}`);
+				continue;
+			}
+			if (backendReference.created) pushedItems += 1;
+			const backendRouteId = await upsertBackendRoute(client, route, backendRoute, backendReference.id);
+			for (const key of keys) backendRouteIds.set(key, backendRouteId);
+			pushedItems += 1;
+		}
+		const routeBackendProperties = catalogueToPush.backend_properties.filter((property) => backendRouteApiRouteKeys.get(property.backend_route_key) === route.key);
+		for (const [index, backendProperty] of routeBackendProperties.entries()) {
+			taskProgressService.report(`Synchronizing backend properties ${index + 1}/${routeBackendProperties.length}: ${backendProperty.field}`);
+			const backendRouteId = backendRouteIds.get(backendProperty.backend_route_key);
+			if (!backendRouteId) {
+				warnings.add(`MISSING_BACKEND_ROUTE_ID: backend property ${backendProperty.key} could not be linked to a backend route`);
+				continue;
+			}
+			const typeId = backendProperty.direction === "output" ? refs.outTypeIds.get("RESPONSEBODY") : refs.inTypeIds.get(normalizeLookupKey(inferInputType(backendProperty.field || "")));
+			if (!typeId) {
+				warnings.add(`UNKNOWN_BACKEND_PROPERTY_TYPE: ${backendProperty.direction} ${backendProperty.field}`);
+				continue;
+			}
+			const backendPropertyId = await upsertBackendProperty(client, backendProperty, backendRouteId, typeId);
+			backendPropertyIds.set(backendProperty.key, backendPropertyId);
+			pushedItems += 1;
+		}
+		const routeInputProperties = catalogueToPush.route_input_properties.filter((property) => property.route_key === route.key);
+		for (const [index, property] of routeInputProperties.entries()) {
+			taskProgressService.report(`Synchronizing input properties ${index + 1}/${routeInputProperties.length}: ${property.field}`);
+			const inType = refs.inTypeIds.get(normalizeLookupKey(inferInputType(property.field)));
+			if (!inType) {
+				warnings.add(`UNKNOWN_IN_TYPE: ${property.field}`);
+				continue;
+			}
+			const inputPropertyId = await upsertInputProperty(client, property, routeId, inType);
+			pushedItems += 1;
+			for (const evidence of catalogueToPush.mapping_evidence.filter((item) => item.input_property_key === property.key)) {
+				const backendPropertyId = backendPropertyIds.get(evidence.backend_property_key);
+				if (backendPropertyId && await ensureInputLink(client, inputPropertyId, backendPropertyId)) pushedItems += 1;
+			}
+		}
+		const routeOutputProperties = catalogueToPush.route_output_properties.filter((property) => property.route_key === route.key);
+		for (const [index, property] of routeOutputProperties.entries()) {
+			taskProgressService.report(`Synchronizing output properties ${index + 1}/${routeOutputProperties.length}: ${property.field}`);
+			const outType = refs.outTypeIds.get("RESPONSEBODY");
+			if (!outType) {
+				warnings.add("UNKNOWN_OUT_TYPE: RESPONSE_BODY");
+				continue;
+			}
+			const outputPropertyId = await upsertOutputProperty(client, property, routeId, outType);
+			pushedItems += 1;
+			for (const evidence of catalogueToPush.mapping_evidence.filter((item) => item.output_property_key === property.key)) {
+				const backendPropertyId = backendPropertyIds.get(evidence.backend_property_key);
+				if (backendPropertyId && await ensureOutputLink(client, outputPropertyId, backendPropertyId)) pushedItems += 1;
+			}
+		}
+	}
+	if (options.outputPath) await fs.appendFile(options.outputPath, "", "utf8");
+	const removedOrphanedLinks = await cleanupOrphanedPropertyLinks(client);
+	taskProgressService.report("Finalizing Directus synchronization");
+	if (warnings.size) {
+		console.warn("========================================");
+		console.warn("BIG WARNING: missing predefined values or unresolved Directus links");
+		for (const warning of warnings) console.warn(`- ${warning}`);
+		console.warn("========================================");
+	}
+	return {
+		pushedCollections,
+		pushedItems,
+		skippedCollections,
+		warnings: Array.from(warnings),
+		removedOrphanedLinks
+	};
+}
+//#endregion
+//#region src/utils/routeReview.ts
+function sanitizePathSegment(value) {
+	return value.replace(/[{}]/g, "").replace(/[^a-z0-9._-]+/gi, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || "root";
+}
+function buildRouteReviewRelativePath(method, routePath) {
+	const rawSegments = routePath.split("/").filter(Boolean);
+	const versionSegment = rawSegments.find((segment) => /^v\d+$/i.test(segment));
+	const sanitizedResourceSegments = rawSegments.filter((segment) => segment !== versionSegment).map(sanitizePathSegment);
+	const resourceDir = sanitizedResourceSegments.length ? path.join(...sanitizedResourceSegments) : "root";
+	const versionDir = sanitizePathSegment(versionSegment || "unversioned");
+	const fileNameParts = [
+		method.toLowerCase(),
+		versionDir,
+		...sanitizedResourceSegments
+	];
+	return path.join(resourceDir, versionDir, `${fileNameParts.join("_")}.yaml`);
+}
+function parseBackendRoute(route) {
+	const match = route.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|CALL)\s+(.+)$/);
+	if (!match || match[1] === "CALL" && match[2] === "unknown") return;
+	return {
+		method: match[1] === "CALL" ? null : match[1],
+		route: match[2]
+	};
+}
+function buildReviewProperty(property) {
+	const backends = property.backend_mappings.map((mapping) => ({
+		type: mapping.backend,
+		field: mapping.field,
+		source: mapping.source_file,
+		...mapping.route !== "unknown" || mapping.method ? { operation: {
+			method: mapping.method,
+			route: mapping.route
+		} } : {},
+		confidence: mapping.confidence,
+		mapper_type: mapping.mapper_type,
+		provenance: mapping.provenance,
+		reason: mapping.reason
+	}));
+	const suggestions = property.inference_suggestions?.map((suggestion) => ({
+		type: suggestion.backend,
+		field: suggestion.field,
+		source: suggestion.source_file,
+		...suggestion.route !== "unknown" || suggestion.method ? { operation: {
+			method: suggestion.method,
+			route: suggestion.route
+		} } : {},
+		confidence: suggestion.confidence,
+		reason: suggestion.reason,
+		status: suggestion.status,
+		rejection_reason: suggestion.rejection_reason
+	}));
+	const unresolvedBackendCandidates = property.unresolved_backend_candidates?.map((candidate) => ({
+		type: candidate.backend,
+		field: candidate.field,
+		domain_field: candidate.domain_field,
+		source: candidate.source_file,
+		reason: candidate.reason
+	}));
+	const mapping = {};
+	if (property.domain_field) mapping.domain = { field: property.domain_field };
+	if (backends.length) mapping.backends = backends;
+	const hasMapping = Boolean(mapping.domain || mapping.backends?.length);
+	return {
+		field: property.field,
+		description: property.description,
+		source: property.source_file,
+		evidence_status: property.evidence_status,
+		transversal: property.transversal,
+		...hasMapping ? { mapping } : {},
+		...suggestions?.length || unresolvedBackendCandidates?.length ? { review: {
+			...suggestions?.length ? { suggestions } : {},
+			...unresolvedBackendCandidates?.length ? { unresolved_backend_candidates: unresolvedBackendCandidates } : {}
+		} } : {}
+	};
+}
+function buildRouteReviewDocument(catalogue, routeKey) {
+	const route = catalogue.routes.find((item) => item.key === routeKey);
+	if (!route) throw new Error(`Unable to build review document for unknown route key ${routeKey}`);
+	const backendRoutes = catalogue.backend_routes.filter((item) => item.route_key === routeKey);
+	const routeProperties = [...catalogue.route_input_properties, ...catalogue.route_output_properties].filter((property) => property.route_key === routeKey);
+	const mappedBackendTypes = new Set(routeProperties.flatMap((property) => property.backend_names));
+	const datasources = backendRoutes.map((backendRoute) => ({
+		type: backendRoute.backend,
+		source: backendRoute.source_file,
+		...parseBackendRoute(backendRoute.route) ? { operation: parseBackendRoute(backendRoute.route) } : {},
+		...backendRoute.provenance === "ai" ? { provenance: backendRoute.provenance } : {}
+	}));
+	for (const backend of route.backends) if (!datasources.some((datasource) => datasource.type === backend) && !mappedBackendTypes.has(backend)) datasources.push({
+		type: backend,
+		source: route.source_file || "unknown"
+	});
+	return {
+		schema_version: 1,
+		generated_at: catalogue.generated_at,
+		route: {
+			method: route.method,
+			path: route.path,
+			version: route.version,
+			source: route.source_file,
+			analysis_files: route.analysis_files
+		},
+		datasources,
+		inputs: catalogue.route_input_properties.filter((item) => item.route_key === routeKey).map(buildReviewProperty),
+		outputs: catalogue.route_output_properties.filter((item) => item.route_key === routeKey).map(buildReviewProperty),
+		rules: catalogue.rules.filter((item) => item.route_key === routeKey).map(({ route_key: _routeKey, source_file: source, ...rule }) => ({
+			...rule,
+			source
+		})),
+		aggregations: catalogue.aggregations.filter((item) => item.route_key === routeKey).map(({ route_key: _routeKey, source_file: source, ...aggregation }) => ({
+			...aggregation,
+			source
+		}))
+	};
+}
+function toRelativeFilePath(repoRoot, filePath) {
+	if (!filePath) return filePath;
+	if (!path.isAbsolute(filePath)) return filePath.replaceAll(path.sep, "/");
+	return path.relative(repoRoot, filePath).replaceAll(path.sep, "/");
+}
+function relativizeProperty(property, repoRoot) {
+	return {
+		...property,
+		source: toRelativeFilePath(repoRoot, property.source),
+		mapping: property.mapping && {
+			...property.mapping,
+			domain: property.mapping.domain,
+			backends: property.mapping.backends?.map((backend) => ({
+				...backend,
+				source: toRelativeFilePath(repoRoot, backend.source) || backend.source
+			}))
+		},
+		review: property.review && {
+			...property.review.suggestions ? { suggestions: property.review.suggestions.map((suggestion) => ({
+				...suggestion,
+				source: toRelativeFilePath(repoRoot, suggestion.source) || suggestion.source
+			})) } : {},
+			...property.review.unresolved_backend_candidates ? { unresolved_backend_candidates: property.review.unresolved_backend_candidates.map((candidate) => ({
+				...candidate,
+				source: toRelativeFilePath(repoRoot, candidate.source) || candidate.source
+			})) } : {}
+		}
+	};
+}
+function relativizeRouteReviewDocument(document, repoRoot) {
+	return {
+		...document,
+		route: {
+			...document.route,
+			source: toRelativeFilePath(repoRoot, document.route.source),
+			analysis_files: document.route.analysis_files.map((filePath) => toRelativeFilePath(repoRoot, filePath) || filePath)
+		},
+		datasources: document.datasources.map((datasource) => ({
+			...datasource,
+			source: toRelativeFilePath(repoRoot, datasource.source) || datasource.source
+		})),
+		inputs: document.inputs.map((property) => relativizeProperty(property, repoRoot)),
+		outputs: document.outputs.map((property) => relativizeProperty(property, repoRoot)),
+		rules: document.rules.map((rule) => ({
+			...rule,
+			source: toRelativeFilePath(repoRoot, rule.source) || rule.source
+		})),
+		aggregations: document.aggregations.map((aggregation) => ({
+			...aggregation,
+			source: toRelativeFilePath(repoRoot, aggregation.source) || aggregation.source
+		}))
+	};
+}
+//#endregion
+//#region src/services/catalogueArtifactService.ts
+function stableKey$1(...parts) {
+	return createHash("sha1").update(parts.join("::")).digest("hex");
+}
+async function writeRouteReviewDocument(catalogue, outputDir, repoRoot, routeKey) {
+	const route = catalogue.routes.find((item) => item.key === routeKey);
+	if (!route) throw new Error(`Unable to write review document for unknown route key ${routeKey}`);
+	const document = relativizeRouteReviewDocument(buildRouteReviewDocument(catalogue, route.key), repoRoot);
+	const filePath = path.join(outputDir, buildRouteReviewRelativePath(route.method, route.path));
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${stringify(document)}\n`, "utf8");
+	return filePath;
+}
+async function writeRouteReviewDocuments(catalogue, outputDir, repoRoot) {
+	await fs.mkdir(outputDir, { recursive: true });
+	for (const [index, route] of catalogue.routes.entries()) {
+		taskProgressService.log(`[${index + 1}/${catalogue.routes.length}] - ${route.method} ${route.path} ...`);
+		await writeRouteReviewDocument(catalogue, outputDir, repoRoot, route.key);
+	}
+	return outputDir;
+}
+async function prepareCatalogueOutputDirectory(outputDir) {
+	await fs.mkdir(outputDir, { recursive: true });
+	await Promise.all(["catalogue.yaml", "catalogue.yml"].map((fileName) => fs.rm(path.join(outputDir, fileName), { force: true })));
+}
+async function writeCatalogueArtifacts(catalogue, outputDir, repoRoot = process.cwd()) {
+	await prepareCatalogueOutputDirectory(outputDir);
+	await writeRouteReviewDocuments(catalogue, outputDir, repoRoot);
+	return {
+		outputDir,
+		routeDocuments: catalogue.routes.length
+	};
+}
+function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backendRoutesByKey, backendPropertiesByKey, mappingEvidence) {
+	const backendRouteKey = stableKey$1(routeKey, mapping.backend, mapping.route);
+	const backendRoute = backendRoutesByKey.get(backendRouteKey) || {
+		key: backendRouteKey,
+		backend: mapping.backend,
+		route_key: routeKey,
+		route: `${mapping.method || "CALL"} ${mapping.route}`,
+		source_file: mapping.source_file,
+		provenance: "code_analysis"
+	};
+	backendRoutesByKey.set(backendRouteKey, backendRoute);
+	const backendPropertyKey = stableKey$1(backendRouteKey, direction, mapping.field);
+	backendPropertiesByKey.set(backendPropertyKey, {
+		key: backendPropertyKey,
+		backend_route_key: backendRouteKey,
+		backend: mapping.backend,
+		field: mapping.field,
+		direction,
+		source_file: mapping.source_file,
+		provenance: mapping.provenance || "code_analysis"
+	});
+	mappingEvidence.push({
+		key: stableKey$1(apiPropertyKey, backendPropertyKey),
+		evidence_type: mapping.provenance === "ai" ? "inference" : "static_analysis",
+		status: mapping.confidence >= 90 ? "confirmed" : "inferred",
+		confidence_score: mapping.confidence,
+		comment: mapping.reason || `Reconstructed from route artifact ${path.basename(mapping.source_file)}`,
+		...direction === "input" ? { input_property_key: apiPropertyKey } : { output_property_key: apiPropertyKey },
+		backend_property_key: backendPropertyKey,
+		source_file: mapping.source_file
+	});
+}
+function toCatalogueBackendMapping(mapping) {
+	return {
+		backend: mapping.type,
+		method: mapping.operation?.method || null,
+		route: mapping.operation?.route || "unknown",
+		field: mapping.field,
+		source_file: mapping.source,
+		confidence: mapping.confidence,
+		mapper_type: mapping.mapper_type,
+		provenance: mapping.provenance,
+		reason: mapping.reason
+	};
+}
+function addDatasourceRoute(routeKey, datasource, backendRoutesByKey) {
+	const backendRoute = datasource.operation?.route || "unknown";
+	const backendRouteKey = stableKey$1(routeKey, datasource.type, backendRoute);
+	backendRoutesByKey.set(backendRouteKey, {
+		key: backendRouteKey,
+		backend: datasource.type,
+		route_key: routeKey,
+		route: `${datasource.operation?.method || "CALL"} ${backendRoute}`,
+		source_file: datasource.source,
+		provenance: datasource.provenance || "code_analysis"
+	});
+}
+function mergeRouteReviewDocuments(documents) {
+	const routes = [];
+	const routeInputProperties = [];
+	const routeOutputProperties = [];
+	const backendRoutesByKey = /* @__PURE__ */ new Map();
+	const backendPropertiesByKey = /* @__PURE__ */ new Map();
+	const mappingEvidence = [];
+	const rules = [];
+	const aggregations = [];
+	for (const document of documents) {
+		const routeKey = stableKey$1(document.route.method, document.route.path);
+		const mappedBackendNames = [...document.inputs, ...document.outputs].flatMap((property) => property.mapping?.backends?.map((mapping) => mapping.type) || []);
+		const backendNames = [.../* @__PURE__ */ new Set([...document.datasources.map((datasource) => datasource.type), ...mappedBackendNames])];
+		routes.push({
+			key: routeKey,
+			method: document.route.method,
+			path: document.route.path,
+			version: document.route.version,
+			source_file: document.route.source,
+			analysis_files: document.route.analysis_files,
+			backends: backendNames
+		});
+		for (const datasource of document.datasources) addDatasourceRoute(routeKey, datasource, backendRoutesByKey);
+		const appendProperties = (direction, properties) => {
+			for (const property of properties) {
+				const apiPropertyKey = stableKey$1(routeKey, direction, property.field);
+				const backendMappings = property.mapping?.backends?.map(toCatalogueBackendMapping) || [];
+				const catalogueProperty = {
+					key: apiPropertyKey,
+					route_key: routeKey,
+					direction,
+					field: property.field,
+					domain_field: property.mapping?.domain?.field,
+					transversal: property.transversal,
+					backend_names: [...new Set(backendMappings.map((mapping) => mapping.backend))],
+					backend_mappings: backendMappings,
+					inference_suggestions: property.review?.suggestions?.map((suggestion) => ({
+						backend: suggestion.type,
+						method: suggestion.operation?.method || null,
+						route: suggestion.operation?.route || "unknown",
+						field: suggestion.field,
+						source_file: suggestion.source,
+						confidence: suggestion.confidence,
+						reason: suggestion.reason,
+						status: suggestion.status,
+						rejection_reason: suggestion.rejection_reason
+					})),
+					unresolved_backend_candidates: property.review?.unresolved_backend_candidates?.map((candidate) => ({
+						backend: candidate.type,
+						field: candidate.field,
+						domain_field: candidate.domain_field,
+						source_file: candidate.source,
+						reason: candidate.reason
+					})),
+					description: property.description,
+					source_file: property.source,
+					analysis_files: document.route.analysis_files,
+					evidence_status: property.evidence_status
+				};
+				if (direction === "input") routeInputProperties.push(catalogueProperty);
+				else routeOutputProperties.push(catalogueProperty);
+				for (const mapping of backendMappings) addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backendRoutesByKey, backendPropertiesByKey, mappingEvidence);
+			}
+		};
+		appendProperties("input", document.inputs);
+		appendProperties("output", document.outputs);
+		rules.push(...document.rules.map(({ source, ...rule }) => ({
+			route_key: routeKey,
+			...rule,
+			source_file: source
+		})));
+		aggregations.push(...document.aggregations.map(({ source, ...aggregation }) => ({
+			route_key: routeKey,
+			...aggregation,
+			source_file: source
+		})));
+	}
+	const needsReview = routeInputProperties.filter((property) => property.evidence_status === "needs_review").length + routeOutputProperties.filter((property) => property.evidence_status === "needs_review").length;
+	return {
+		generated_at: documents.map((document) => document.generated_at).sort().at(-1) || (/* @__PURE__ */ new Date()).toISOString(),
+		routes,
+		route_input_properties: routeInputProperties,
+		route_output_properties: routeOutputProperties,
+		backend_routes: [...backendRoutesByKey.values()],
+		backend_properties: [...backendPropertiesByKey.values()],
+		mapping_evidence: mappingEvidence,
+		rules,
+		aggregations,
+		stats: {
+			routes: routes.length,
+			input_properties: routeInputProperties.length,
+			output_properties: routeOutputProperties.length,
+			backend_routes: backendRoutesByKey.size,
+			backend_properties: backendPropertiesByKey.size,
+			mapping_evidence: mappingEvidence.length,
+			rules: rules.length,
+			aggregations: aggregations.length,
+			needs_review: needsReview,
+			needs_review_percentage: calculateNeedsReviewPercentage(routeInputProperties.length, routeOutputProperties.length, needsReview)
+		}
+	};
+}
+async function readCatalogueFromDirectory(inputDir) {
+	const files = await globby("**/*.@(yaml|yml)", {
+		cwd: inputDir,
+		absolute: true,
+		ignore: ["**/*.graph.yaml", "**/*.graph.yml"]
+	});
+	if (!files.length) throw new Error(`No route YAML documents found in ${inputDir}`);
+	return {
+		catalogue: mergeRouteReviewDocuments(await Promise.all(files.sort().map(async (file) => {
+			const parsed = parse(await fs.readFile(file, "utf8"));
+			if (parsed?.schema_version !== 1 || !parsed?.route?.method || !parsed?.route?.path) throw new Error(`Invalid route YAML document: ${file}`);
+			return parsed;
+		}))),
+		files
+	};
+}
+//#endregion
+//#region src/services/directusPushService.ts
+async function pushCatalogueDirectoryToDirectus(params) {
+	const inputPath = path.resolve(params.cwd, params.catalogueDirectory);
+	taskProgressService.report("Loading and reconstructing route YAML documents");
+	const { catalogue, files } = await readCatalogueFromDirectory(inputPath);
+	taskProgressService.report(`${files.length} route documents loaded, ${catalogue.backend_routes.length} backend routes reconstructed`);
+	const directusUrl = params.directusUrl || process.env.DIRECTUS_URL || process.env.CMS_API_URL || getUserConfig().directusUrl;
+	const directusToken = params.directusToken || process.env.DIRECTUS_TOKEN || process.env.CMS_DIRECTUS_TOKEN || process.env.CMS_API_TOKEN;
+	if (!directusToken) throw new Error("Directus push requested but DIRECTUS_TOKEN/directus-token is missing");
+	return {
+		inputPath,
+		files,
+		result: await pushCatalogueToDirectus(catalogue, {
+			baseUrl: directusUrl,
+			token: directusToken,
+			dryRun: !params.write,
+			routeSelector: params.routeSelector
+		})
+	};
+}
+//#endregion
+//#region src/utils/routeSelector.ts
+function parseRouteSelector(value) {
+	if (!value) return;
+	const match = value.trim().match(/^([A-Z]+)\s+(\S+)$/i);
+	if (!match) throw new Error(`Invalid route selector "${value}". Expected format: "GET /v0/products"`);
+	return {
+		method: match[1].toUpperCase(),
+		path: match[2]
+	};
+}
+//#endregion
+//#region src/commands/push.ts
+const DEFAULT_CATALOGUE_DIRECTORY = ".tmp/datasource-catalogue";
+function isRouteSelectorArgument(value) {
+	return /^[A-Z]+\s+\//i.test(value.trim());
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatPushError(error) {
+	if (error instanceof Error) return error.message;
+	if (!isRecord$1(error)) return String(error);
+	const details = (Array.isArray(error.errors) ? error.errors : []).flatMap((item) => {
+		if (!isRecord$1(item) || typeof item.message !== "string") return [];
+		return [`${isRecord$1(item.extensions) && typeof item.extensions.code === "string" ? `${item.extensions.code}: ` : ""}${item.message}`];
+	});
+	if (details.length) return `Directus API error: ${details.join("; ")}`;
+	if (typeof error.message === "string") return error.message;
+	return "Directus push failed with an unrecognized error response";
+}
+function createPushStepClassifier() {
+	let currentRoute;
+	let currentRouteIndex = 0;
+	let totalRoutes = 0;
+	return (message) => {
+		const route = message.match(/^Synchronizing routes (\d+)\/(\d+): ([A-Z]+) (.+)$/);
+		if (route) {
+			currentRouteIndex = Number(route[1]);
+			totalRoutes = Number(route[2]);
+			currentRoute = {
+				method: route[3],
+				path: route[4]
+			};
+			return {
+				id: `push-${currentRoute.method}-${currentRoute.path}`,
+				title: `1 worker · Push · [${currentRouteIndex}/${totalRoutes}] routes · ${currentRoute.method} ${currentRoute.path} [Synchronizing route]`,
+				completedTitle: `Push completed: ${currentRoute.method} ${currentRoute.path}`
+			};
+		}
+		if (currentRoute && /^Synchronizing (backend routes|backend properties|input properties|output properties) \d+\//.test(message)) return {
+			id: `push-${currentRoute.method}-${currentRoute.path}`,
+			title: `1 worker · Push · [${currentRouteIndex}/${totalRoutes}] routes · ${currentRoute.method} ${currentRoute.path} [${message}]`,
+			completedTitle: `Push completed: ${currentRoute.method} ${currentRoute.path}`
+		};
+		if (/Loading and reconstructing|route documents loaded/.test(message)) return {
+			id: "artifacts",
+			title: "Loading route artifacts",
+			completedTitle: "Route artifacts loaded",
+			detail: message
+		};
+		if (/Validating reconstructed/.test(message)) return {
+			id: "validation",
+			title: "Validating catalogue",
+			completedTitle: "Catalogue validated",
+			detail: message
+		};
+		if (/Connecting to Directus/.test(message)) return {
+			id: "connection",
+			title: "Connecting to Directus",
+			completedTitle: "Connected to Directus",
+			detail: message
+		};
+		if (/Loading predefined/.test(message)) return {
+			id: "references",
+			title: "Loading Directus references",
+			completedTitle: "Directus references loaded",
+			detail: message
+		};
+		return {
+			id: "finalization",
+			title: "Finalizing Directus synchronization",
+			completedTitle: "Directus synchronization finalized",
+			detail: message
+		};
+	};
+}
+var push_default = (program) => void program.command("push").argument("[catalogue-directory-or-route]", "Directory or route such as \"GET /v1/offers\"", DEFAULT_CATALOGUE_DIRECTORY).option("--route <route>", "Push one route only, for example \"POST /v0/accommodations_arrangement/check\"").option("--directus-url <url>", "Directus base URL").option("--directus-token <token>", "Directus bearer token").option("--write", "Persist changes to Directus", false).description("Push generated per-route YAML documents to Directus").action(async (catalogueDirectoryOrRoute, options) => {
+	intro("Datasource catalogue push");
+	const { cwd } = getUserConfig();
+	const progress = taskProgressService.createStepProgress(createPushStepClassifier());
+	try {
+		const positionalRouteSelector = isRouteSelectorArgument(catalogueDirectoryOrRoute) ? parseRouteSelector(catalogueDirectoryOrRoute) : void 0;
+		if (options.route && positionalRouteSelector) throw new Error("Specify the route either as the positional argument or with --route, not both");
+		const routeSelector = options.route ? parseRouteSelector(options.route) : positionalRouteSelector;
+		const catalogueDirectory = positionalRouteSelector ? DEFAULT_CATALOGUE_DIRECTORY : catalogueDirectoryOrRoute;
+		const pushResult = await progress.execute(() => pushCatalogueDirectoryToDirectus({
+			cwd,
+			catalogueDirectory,
+			directusUrl: options.directusUrl,
+			directusToken: options.directusToken,
+			routeSelector,
+			write: options.write
+		}));
+		progress.finish(options.write ? "Directus synchronization completed" : "Directus dry-run completed");
+		note([
+			`Input directory: ${pushResult.inputPath}`,
+			`Route documents: ${pushResult.files.length}`,
+			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null,
+			`Collections targeted: ${pushResult.result.pushedCollections.join(", ")}`,
+			`Items processed: ${pushResult.result.pushedItems}`,
+			`Warnings: ${pushResult.result.warnings.length}`
+		].filter(Boolean).join("\n"), "Directus");
+		outro("Datasource catalogue push completed");
+	} catch (error) {
+		progress.fail("Directus push failed");
+		cancel(formatPushError(error));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/commands/cleanOrphans.ts
+var cleanOrphans_default = (program) => void program.command("clean-orphans").option("--directus-url <url>", "Directus base URL").option("--directus-token <token>", "Directus bearer token").option("--write", "Remove the orphaned links", false).description("Find and optionally remove orphaned property-to-backend-property links in Directus").action(async (options) => {
+	intro("Datasource catalogue orphan cleanup");
+	const progress = taskProgressService.createStepProgress();
+	try {
+		const config = getUserConfig();
+		const directusUrl = options.directusUrl || process.env.DIRECTUS_URL || process.env.CMS_API_URL || config.directusUrl;
+		const directusToken = options.directusToken || process.env.DIRECTUS_TOKEN || process.env.CMS_DIRECTUS_TOKEN || process.env.CMS_API_TOKEN;
+		if (!directusToken) throw new Error("Directus cleanup requested but DIRECTUS_TOKEN/directus-token is missing");
+		const result = await progress.execute(() => cleanDirectusOrphanedPropertyLinks({
+			baseUrl: directusUrl,
+			token: directusToken,
+			dryRun: !options.write
+		}));
+		progress.finish(options.write ? "Orphaned property links removed" : "Orphaned property links inspected");
+		note([
+			`Orphaned links found: ${result.orphanedLinks}`,
+			`Orphaned links removed: ${result.removedOrphanedLinks}`,
+			options.write ? null : "Run again with --write to remove them."
+		].filter(Boolean).join("\n"), "Directus");
+		outro("Datasource catalogue orphan cleanup completed");
+	} catch (error) {
+		progress.fail("Orphan cleanup failed");
+		cancel(formatPushError(error));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/services/analysisProfileService.ts
+function createAnalysisProfile(enabled) {
+	const durations = /* @__PURE__ */ new Map();
+	return {
+		add: (label, durationMs) => {
+			if (enabled) durations.set(label, (durations.get(label) || 0) + durationMs);
+		},
+		report: () => [...durations.entries()].sort((a, b) => b[1] - a[1]).map(([label, duration]) => `${label}: ${(duration / 1e3).toFixed(2)}s`)
+	};
+}
+//#endregion
+//#region src/services/backendTopologyArtifactService.ts
+function buildBackendTopologyRelativePath(method, routePath) {
+	return buildRouteReviewRelativePath(method, routePath).replace(/\.yaml$/, ".graph.yaml");
+}
+async function writeBackendTopologyArtifact(artifact, outputDir) {
+	const filePath = path.join(outputDir, buildBackendTopologyRelativePath(artifact.route.method, artifact.route.path));
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${stringify(artifact, { aliasDuplicateObjects: false })}\n`, "utf8");
+	return filePath;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseBackendTopologyArtifact(value, expectedMethod, expectedPath, filePath) {
+	if (!isRecord(value) || value.schema_version !== 3) throw new Error(`Invalid backend graph artifact schema: ${filePath}. Run generate:graph again.`);
+	const route = value.route;
+	const analysisFiles = value.analysis_files;
+	const backendPaths = value.backend_paths;
+	const mappingContext = value.mapping_context;
+	if (!isRecord(route) || route.method !== expectedMethod || route.path !== expectedPath || !Array.isArray(analysisFiles) || !analysisFiles.length || analysisFiles.some((item) => typeof item !== "string" || !item) || !Array.isArray(mappingContext) || mappingContext.some((item) => !isRecord(item) || item.layer !== "api" && item.layer !== "backend" || item.direction !== "input" && item.direction !== "output" || typeof item.symbol !== "string" || typeof item.source !== "string" || typeof item.line !== "number" || typeof item.backend_path !== "number" || typeof item.backend_type !== "string") || !Array.isArray(backendPaths) || !backendPaths.length || backendPaths.some((item) => !isRecord(item) || item.status !== "resolved" || typeof item.backend_type !== "string" || !item.backend_type)) throw new Error(`Invalid backend graph artifact for ${expectedMethod} ${expectedPath}: ${filePath}`);
+	return value;
+}
+async function loadBackendTopologyAnalysisScope(outputDir, cwd, method, routePath) {
+	const filePath = path.join(outputDir, buildBackendTopologyRelativePath(method, routePath));
+	let content;
+	try {
+		content = await fs.readFile(filePath, "utf8");
+	} catch (error) {
+		if (isRecord(error) && error.code === "ENOENT") throw new Error(`Backend graph artifact not found for ${method} ${routePath}: ${filePath}. Run generate:graph first.`);
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = parse(content);
+	} catch {
+		throw new Error(`Unable to parse backend graph artifact for ${method} ${routePath}: ${filePath}`);
+	}
+	const artifact = parseBackendTopologyArtifact(parsed, method, routePath, filePath);
+	const analysisFiles = artifact.analysis_files.map((source) => {
+		const absolutePath = path.resolve(cwd, source);
+		const relativePath = path.relative(cwd, absolutePath);
+		if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) throw new Error(`Backend graph analysis file is outside the repository: ${source}`);
+		return absolutePath;
+	});
+	const missingFiles = [];
+	await Promise.all(analysisFiles.map(async (analysisFile) => {
+		try {
+			await fs.access(analysisFile);
+		} catch {
+			missingFiles.push(path.relative(cwd, analysisFile));
+		}
+	}));
+	if (missingFiles.length) throw new Error(`Backend graph references missing analysis files for ${method} ${routePath}: ${missingFiles.sort().join(", ")}. Run generate:graph again.`);
+	return {
+		analysisFiles,
+		backendTypes: new Set(artifact.backend_paths.map((backendPath) => backendPath.backend_type)),
+		mappingContext: artifact.mapping_context.map((context) => ({
+			...context,
+			source: path.resolve(cwd, context.source)
+		})),
+		backendPathSources: [...new Map(artifact.backend_paths.flatMap((backendPath) => backendPath.nodes.filter((node) => node.source.includes("app/_infra/back/")).map((node) => {
+			const sourceFile = path.resolve(cwd, node.source);
+			return [`${backendPath.backend_type}:${sourceFile}`, {
+				backend: backendPath.backend_type,
+				sourceFile
+			}];
+		}))).values()]
+	};
+}
+//#endregion
+//#region src/commands/generate.ts
+async function generateHandler(cwd, routeArgument, options) {
+	intro("Datasource catalogue generation");
+	const progress$3 = taskProgressService.createStepProgress();
+	const routeSelector = parseRouteSelector(routeArgument);
+	const profile = createAnalysisProfile(Boolean(options.profile));
+	try {
+		const outputDir = path.resolve(cwd, options.output);
+		await progress$3.run({
+			id: "artifacts",
+			title: "Preparing route documents",
+			completedTitle: "Route document directory prepared",
+			detail: outputDir
+		}, () => prepareCatalogueOutputDirectory(outputDir));
+		const openApiStartedAt = performance.now();
+		const openApiDocument = await progress$3.run({
+			id: "openapi",
+			title: "Loading OpenAPI contract",
+			completedTitle: "OpenAPI contract loaded"
+		}, () => loadOpenApiDocument(options.openapiUrl));
+		profile.add("OpenAPI", performance.now() - openApiStartedAt);
+		const selectedRouteKeys = routeSelector ? /* @__PURE__ */ new Set([buildRouteKey(routeSelector.method, routeSelector.path)]) : void 0;
+		const totalRoutes = routeSelector ? 1 : Object.values(openApiDocument.paths || {}).reduce((total, pathItem) => total + Object.keys(pathItem || {}).filter((method) => /^(get|post|put|patch|delete|head|options)$/i.test(method)).length, 0);
+		const analysisStartedAt = performance.now();
+		progress$3.finish("OpenAPI contract loaded");
+		const analysisProgress = progress({
+			style: "heavy",
+			max: totalRoutes,
+			size: 40
+		});
+		let analyzedRoutes = 0;
+		analysisProgress.start(`Analyzing · [0/${totalRoutes}] routes`);
+		const documents = await analyzeCodebaseRouteContracts({
+			cwd,
+			openApiDocument,
+			selectedRouteKeys,
+			routeAnalysisScope: async ({ method, path: routePath }) => {
+				try {
+					return await loadBackendTopologyAnalysisScope(outputDir, cwd, method, routePath);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					taskProgressService.log(`Warning: ${message} Route skipped.`);
+					return;
+				}
+			},
+			onDocument: async (document) => {
+				const artifactStartedAt = performance.now();
+				analyzedRoutes += 1;
+				analysisProgress.advance(1, `Analyzing · [${analyzedRoutes}/${totalRoutes}] routes · ${document.method} ${document.path} ...`);
+				await writeRouteReviewDocument(await buildCatalogue([document]), outputDir, cwd, document.key);
+				profile.add("Artifacts", performance.now() - artifactStartedAt);
+			}
+		});
+		analysisProgress.stop("Static route analysis completed");
+		profile.add("Static analysis", performance.now() - analysisStartedAt);
+		const catalogueStartedAt = performance.now();
+		const catalogue = await progress$3.run({
+			id: "catalogue",
+			title: "Building catalogue",
+			completedTitle: "Catalogue built",
+			detail: `${documents.length} route${documents.length === 1 ? "" : "s"}`
+		}, () => buildCatalogue(documents));
+		profile.add("Catalogue build", performance.now() - catalogueStartedAt);
+		note([
+			`Output directory: ${outputDir}`,
+			`Route documents: ${catalogue.routes.length}`,
+			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null
+		].filter(Boolean).join("\n"), "Artifacts");
+		note(JSON.stringify(catalogue.stats, null, 2), "Stats");
+		if (options.profile) note(profile.report().join("\n"), "Performance profile");
+		outro("Datasource catalogue generation completed");
+	} catch (error) {
+		progress$3.fail("Generation failed");
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+}
+var generate_default = (program) => void program.command("generate:catalogue").argument("[route]", "Route selector in the format \"GET /v1/products\"").option("-o, --output <directory>", "Directory where catalogue artifacts are generated", ".tmp/datasource-catalogue").option("--openapi-url <url>", "OpenAPI document URL").option("--profile", "Display elapsed time by generation stage").description("Analyze the codebase and generate one YAML review document per route").action((routeArgument, options) => {
+	const config = getUserConfig();
+	return generateHandler(config.cwd, routeArgument, {
+		...options,
+		openapiUrl: options.openapiUrl ?? config.openapiUrl
+	});
+});
+//#endregion
+//#region src/services/routeBackendTopologyService.ts
+function stringProperty(object, name) {
+	const property = object.getProperty(name);
+	if (!property || !Node.isPropertyAssignment(property)) return void 0;
+	const initializer = property.getInitializer();
+	return initializer && (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) ? initializer.getLiteralValue() : void 0;
+}
+function handlerProperty(object) {
+	const property = object.getProperty("handler");
+	if (!property || !Node.isPropertyAssignment(property)) return void 0;
+	const initializer = property.getInitializer();
+	return initializer && (Node.isIdentifier(initializer) || Node.isPropertyAccessExpression(initializer)) ? initializer.getText() : void 0;
+}
+function extractRouteDeclarations(sourceFile) {
+	const initializer = sourceFile.getVariableDeclaration("routes")?.getInitializer();
+	let expression = initializer;
+	if (initializer && (Node.isAsExpression(initializer) || Node.isSatisfiesExpression(initializer))) expression = initializer.getExpression();
+	if (!expression || !Node.isArrayLiteralExpression(expression)) return [];
+	return expression.getElements().flatMap((element) => {
+		if (!Node.isObjectLiteralExpression(element)) return [];
+		const method = stringProperty(element, "method");
+		const routePath = stringProperty(element, "path");
+		const handlerRef = handlerProperty(element);
+		return method && routePath && handlerRef ? [{
+			method: method.toUpperCase(),
+			path: routePath,
+			sourceFile,
+			handlerRef
+		}] : [];
+	});
+}
+async function discoverBackendTopologyRouteSelectors(cwd) {
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		compilerOptions: {
+			allowJs: true,
+			checkJs: false
+		}
+	});
+	return (await globby(["app/_api/**/routes.@(js|ts)", "app/legacy/**/routes.@(js|ts)"], {
+		cwd,
+		absolute: true
+	})).flatMap((routeFile) => extractRouteDeclarations(project.addSourceFileAtPath(routeFile))).map((route) => ({
+		method: route.method,
+		path: route.path
+	}));
+}
+async function generateBackendTopologyArtifactsInWorkers(params) {
+	const selectors = params.routeSelector ? [params.routeSelector] : await discoverBackendTopologyRouteSelectors(params.cwd);
+	params.onRoutesDiscovered?.(selectors.length);
+	const workerCount = Math.min(params.workers || 2, selectors.length);
+	const chunks = Array.from({ length: workerCount }, () => []);
+	selectors.forEach((selector, index) => chunks[index % workerCount].push(selector));
+	const artifacts = [];
+	let completed = 0;
+	let writeQueue = Promise.resolve();
+	const workers = [];
+	try {
+		await Promise.all(chunks.map((routeSelectors) => new Promise((resolve, reject) => {
+			const worker = new Worker(new URL("./routeBackendTopologyWorker.ts", import.meta.url), {
+				workerData: {
+					cwd: params.cwd,
+					routeSelectors
+				},
+				execArgv: process.execArgv
+			});
+			workers.push(worker);
+			worker.on("message", (message) => {
+				if (message.type === "error") {
+					reject(new Error(message.message));
+					return;
+				}
+				writeQueue = writeQueue.then(async () => {
+					if (message.type === "artifact") {
+						await params.onArtifact(message.artifact);
+						artifacts.push(message.artifact);
+						return;
+					}
+					completed += 1;
+					params.onRouteProgress?.({
+						current: completed,
+						total: selectors.length,
+						route: message.route,
+						stage: "completed"
+					});
+				}).catch(reject);
+			});
+			worker.once("error", reject);
+			worker.once("exit", (code) => code === 0 ? resolve() : reject(/* @__PURE__ */ new Error(`Topology worker exited with code ${code}`)));
+		})));
+		await writeQueue;
+		return artifacts;
+	} catch (error) {
+		await Promise.all(workers.map((worker) => worker.terminate().catch(() => void 0)));
+		throw error;
+	}
+}
+//#endregion
+//#region src/commands/generateGraph.ts
+function parseWorkerCount$1(value) {
+	const workers = Number(value);
+	if (!Number.isInteger(workers) || workers < 1) throw new Error("Worker count must be a positive integer");
+	return workers;
+}
+async function generateGraphHandler(cwd, routeArgument, options) {
+	intro("Code source Graph generation");
+	const progress$2 = taskProgressService.createStepProgress((message) => {
+		if (message === "Discovering route files") return {
+			id: "route-files",
+			title: message,
+			completedTitle: "Route files discovered"
+		};
+		if (message === "Extracting route declarations") return {
+			id: "routes",
+			title: message,
+			completedTitle: "Route declarations extracted"
+		};
+		if (message.startsWith("Writing graph document ")) return {
+			id: "artifacts",
+			title: "Writing graph documents",
+			completedTitle: "Graph YAML document written",
+			detail: message.slice(23)
+		};
+		return {
+			id: message,
+			title: message
+		};
+	});
+	try {
+		const routeSelector = parseRouteSelector(routeArgument);
+		const outputDir = path.resolve(cwd, options.output);
+		const workerCount = options.workers ?? 2;
+		const files = [];
+		let routeProgress;
+		const onRoutesDiscovered = (total) => {
+			progress$2.finish("Route declarations extracted");
+			routeProgress = progress({
+				style: "heavy",
+				max: total,
+				size: 40
+			});
+			routeProgress.start(`${workerCount} worker${workerCount > 1 ? "s" : ""} · Graph · [0/${total}] routes`);
+		};
+		const onArtifact = async (artifact) => {
+			routeProgress?.message(`${workerCount} worker${workerCount > 1 ? "s" : ""} · Graph · Writing ${artifact.route.method} ${artifact.route.path}`);
+			files.push(await writeBackendTopologyArtifact(artifact, outputDir));
+		};
+		const onRouteProgress = ({ current, total, route }) => {
+			routeProgress?.advance(1, `${workerCount} worker${workerCount > 1 ? "s" : ""} · Graph · [${current}/${total}] routes · ${route.method} ${route.path}`);
+		};
+		const artifacts = await progress$2.execute(() => generateBackendTopologyArtifactsInWorkers({
+			cwd,
+			routeSelector,
+			workers: workerCount,
+			onRoutesDiscovered,
+			onRouteProgress,
+			onArtifact
+		}));
+		routeProgress?.stop("API-to-backend graph generated");
+		progress$2.finish("API-to-backend graph generated");
+		const backendPaths = artifacts.reduce((total, artifact) => total + artifact.backend_paths.length, 0);
+		note([
+			`Output directory: ${outputDir}`,
+			`Route documents: ${files.length}`,
+			`Backend paths: ${backendPaths}`,
+			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null
+		].filter(Boolean).join("\n"), "Artifacts");
+		outro("Code source graph generation completed");
+	} catch (error) {
+		progress$2.fail("Graph generation failed");
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exitCode = 1;
+	}
+}
+var generateGraph_default = (program) => void program.command("generate:graph").argument("[route]", "Optional route selector in the format \"GET /v1/products\"").option("-o, --output <directory>", "Directory where backend graph artifacts are generated", ".tmp/datasource-catalogue").option("-w, --workers <count>", "Maximum number of topology workers", parseWorkerCount$1, 2).description("Generate weighted call graphs from API routes to backend types").action((routeArgument, options) => {
+	const { cwd } = getUserConfig();
+	return generateGraphHandler(cwd, routeArgument, options);
+});
+//#endregion
+//#region src/services/catalogueCoverageService.ts
+/**
+* Coverage is the percentage of fields that do not need manual review. A higher
+* value is an improvement, so configured values are lower bounds.
+*/
+function validateCoverage(coverage, catalogues) {
+	return coverage.map(({ route, minimum_coverage }) => {
+		const expected = Number(minimum_coverage);
+		if (!Number.isFinite(expected) || expected < 0 || expected > 100) throw new Error(`Invalid minimum coverage for ${route}: ${minimum_coverage}`);
+		const catalogue = catalogues.get(route);
+		if (!catalogue) throw new Error(`No generated catalogue found for configured route: ${route}`);
+		const actual = 100 - catalogue.stats.needs_review_percentage;
+		return {
+			route,
+			expected,
+			actual,
+			passed: actual >= expected
+		};
+	});
+}
+function formatCoverageFailure(results) {
+	return ["Coverage regression detected:", ...results.filter((result) => !result.passed).map((result) => `- ${result.route}: ${result.actual.toFixed(2)}% is below ${result.expected.toFixed(2)}%`)].join("\n");
+}
+//#endregion
+//#region src/commands/generateTest.ts
+async function generateTestHandler(cwd) {
+	const config = getUserConfig();
+	const coverage = config.test.coverage;
+	if (!coverage.length) throw new Error("No route coverage is configured in atlas.config.ts");
+	const progress = taskProgressService.createStepProgress();
+	const openApiDocument = await progress.run({
+		id: "openapi",
+		title: "Loading OpenAPI contract",
+		completedTitle: "OpenAPI contract loaded"
+	}, () => loadOpenApiDocument(config.openapiUrl));
+	const catalogues = /* @__PURE__ */ new Map();
+	for (const [index, expectation] of coverage.entries()) {
+		const routeSelector = parseRouteSelector(expectation.route);
+		const documents = await progress.run({
+			id: `analysis-${index}`,
+			title: `Analyzing ${expectation.route}`,
+			completedTitle: `Analyzed ${expectation.route}`
+		}, () => analyzeCodebaseRouteContracts({
+			cwd,
+			openApiDocument,
+			selectedRouteKeys: /* @__PURE__ */ new Set([buildRouteKey(routeSelector.method, routeSelector.path)])
+		}));
+		if (documents.length !== 1) throw new Error(`Configured route was not found: ${expectation.route}`);
+		catalogues.set(expectation.route, await buildCatalogue(documents));
+	}
+	const results = validateCoverage(coverage, catalogues);
+	log.message(results.map((result) => `${result.passed ? "✓" : "✗"} ${result.route}: ${result.actual.toFixed(2)}% (minimum ${result.expected.toFixed(2)}%)`).join("\n"));
+	if (results.some((result) => !result.passed)) throw new Error(formatCoverageFailure(results));
+}
+var generateTest_default = (program) => void program.command("generate:test").description("Generate configured routes and verify their resolved-field coverage does not regress").action(async () => {
+	intro("Datasource catalogue generation regression check");
+	const { cwd, test } = getUserConfig();
+	try {
+		await generateTestHandler(cwd);
+		note(`Routes checked: ${test.coverage.length}`, "Coverage");
+		outro("Datasource catalogue generation regression check completed");
+	} catch (error) {
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/services/aiSdkClient.ts
+var AISdkClient = class {
+	#config;
+	constructor(config) {
+		this.#config = config;
+	}
+	getModel() {
+		return createOpenAICompatible({
+			name: "litellm",
+			baseURL: this.#config.baseUrl,
+			apiKey: this.#config.apiKey ?? "",
+			supportsStructuredOutputs: true
+		})(this.#config.model);
+	}
+	async generateStructuredObject({ schema, prompt, schemaName, schemaDescription, temperature, abortSignal }) {
+		const outputSpec = Output.object({
+			schema,
+			name: schemaName,
+			description: schemaDescription
+		});
+		const { output } = await generateText({
+			model: this.getModel(),
+			prompt,
+			output: outputSpec,
+			temperature,
+			abortSignal
+		});
+		return output;
+	}
+};
+//#endregion
+//#region src/services/inferenceService.ts
+const MAPPING_OUTPUT_SCHEMA = z.object({ mappings: z.array(z.object({
+	property_index: z.number().int(),
+	candidate_index: z.number().int(),
+	confidence: z.number().min(0).max(100),
+	reason: z.string().min(1)
+})) });
+const MAX_SOURCE_EXCERPTS = 36;
+const MAX_EXCERPT_CHARACTERS = 16e3;
+const EXCERPT_RADIUS = 7;
+const PROPERTIES_PER_BATCH = 8;
+const MAX_CANDIDATES_PER_BATCH = 48;
+function normalizeFieldForRanking(field) {
+	return (field || "").replace(/\[\]/g, "").replace(/[^a-zA-Z0-9.]/g, "").toLowerCase();
+}
+function terminalFieldForRanking(field) {
+	return normalizeFieldForRanking(field).split(".").filter(Boolean).at(-1) || "";
+}
+/**
+* Guards against a model picking the right reasoning but the wrong array index: the chosen
+* backend field must share a term with the API property, either as an exact terminal match
+* or as the container of a nested object property (e.g. "address.number" <-> "address").
+*/
+function candidateSharesTermWithProperty(candidate, property) {
+	const propertySegments = normalizeFieldForRanking(property.field).split(".").filter(Boolean);
+	const domainSegments = normalizeFieldForRanking(property.domainField).split(".").filter(Boolean);
+	const propertyTerminal = propertySegments.at(-1) || "";
+	const propertyRoot = propertySegments[0] || "";
+	const backendTerminal = terminalFieldForRanking(candidate.backendField);
+	const apiPathTerminal = terminalFieldForRanking(candidate.apiPathCandidate);
+	if (backendTerminal && (backendTerminal === propertyTerminal || domainSegments.includes(backendTerminal))) return true;
+	if (apiPathTerminal && apiPathTerminal === propertyTerminal) return true;
+	return Boolean(propertySegments.length > 1 && backendTerminal && backendTerminal === propertyRoot);
+}
+function scopeCandidatesToProperties(document, properties) {
+	const candidates = document.backendFieldCandidates.filter((candidate) => !candidate.direction || properties.some((property) => property.direction === candidate.direction)).map((candidate, index) => {
+		const apiPath = normalizeFieldForRanking(candidate.apiPathCandidate);
+		const backendTerminal = terminalFieldForRanking(candidate.backendField);
+		return {
+			candidate,
+			index,
+			relevance: Math.max(...properties.map((property) => {
+				const field = normalizeFieldForRanking(property.field);
+				const terminal = terminalFieldForRanking(property.field);
+				if (apiPath && (apiPath.endsWith(field) || field.endsWith(apiPath))) return 1e3;
+				if (terminal && backendTerminal === terminal) return 100;
+				return 0;
+			}))
+		};
+	}).sort((left, right) => right.relevance - left.relevance || right.candidate.confidence - left.candidate.confidence || left.index - right.index).slice(0, MAX_CANDIDATES_PER_BATCH).map(({ candidate }) => candidate);
+	return {
+		...document,
+		backendFieldCandidates: candidates
+	};
+}
+async function readSourceExcerpts(document) {
+	const analysisFiles = new Set(document.analysisFiles.map((file) => path.resolve(file)));
+	const locations = [
+		...(document.mappingContext || []).map((context) => ({
+			sourceFile: context.source,
+			line: context.line
+		})),
+		...(document.apiFieldSourceCandidates || []).map((candidate) => ({
+			sourceFile: candidate.sourceFile,
+			line: candidate.line
+		})),
+		...document.backendFieldCandidates.filter((candidate) => Boolean(candidate.sourceLine)).map((candidate) => ({
+			sourceFile: candidate.sourceFile,
+			line: candidate.sourceLine
+		}))
+	];
+	const uniqueLocations = [...new Map(locations.filter(({ sourceFile, line }) => analysisFiles.has(path.resolve(sourceFile)) && Number.isInteger(line) && line > 0).map((location) => [`${path.resolve(location.sourceFile)}:${location.line}`, location])).values()].slice(0, MAX_SOURCE_EXCERPTS);
+	const excerpts = [];
+	let totalCharacters = 0;
+	for (const location of uniqueLocations) try {
+		const lines = (await fs.readFile(location.sourceFile, "utf8")).split("\n");
+		const startLine = Math.max(1, location.line - EXCERPT_RADIUS);
+		const endLine = Math.min(lines.length, location.line + EXCERPT_RADIUS);
+		const code = lines.slice(startLine - 1, endLine).map((line, index) => `${String(startLine + index).padStart(5)} | ${line}`).join("\n");
+		if (totalCharacters + code.length > MAX_EXCERPT_CHARACTERS) break;
+		excerpts.push({
+			source_file: location.sourceFile,
+			start_line: startLine,
+			end_line: endLine,
+			code
+		});
+		totalCharacters += code.length;
+	} catch {}
+	return excerpts;
+}
+async function buildPrompt(document, properties) {
+	const candidates = document.backendFieldCandidates.map((candidate, index) => ({
+		index,
+		backend: candidate.backend,
+		api_path_candidate: candidate.apiPathCandidate || null,
+		backend_field: candidate.backendField,
+		direction: candidate.direction || null,
+		mapper_type: candidate.mapperType || null,
+		deterministic_review_reason: candidate.reviewReason || null,
+		source_file: candidate.sourceLine ? `${candidate.sourceFile}:${candidate.sourceLine}` : candidate.sourceFile,
+		static_confidence: candidate.confidence
+	}));
+	const sourceExcerpts = await readSourceExcerpts(document);
+	return [
+		"You review API-to-backend field mappings extracted from TypeScript code.",
+		"Select mappings only when the API property is semantically produced from or sent to an existing candidate.",
+		"Never create a backend, field, route, property index, or candidate index.",
+		"A candidate can only be selected for the listed API property and direction. Do not infer a mapping from name similarity alone.",
+		"Return every defensible mapping in the structured output. Return an empty mappings array only if no supplied candidate is defensible.",
+		"Omit uncertain mappings. Multiple candidates may be returned for one API property only when the code metadata supports aggregation.",
+		"Double-check candidate_index points at the candidate you actually mean to select, not merely one that supports your reasoning about the surrounding code.",
+		"Confidence is an integer from 0 to 100. The reason must be concise and based only on the supplied metadata.",
+		JSON.stringify({
+			api_route: `${document.method} ${document.path}`,
+			unresolved_properties: properties.map((property, index) => ({
+				index,
+				direction: property.direction,
+				field: property.field,
+				domain_field: property.domainField || null,
+				description: property.description,
+				deterministic_review_reasons: property.reviewReasons || []
+			})),
+			backend_routes: document.backendRouteCandidates.map((route) => ({
+				backend: route.backend,
+				method: route.method || null,
+				route: route.route,
+				source_file: route.sourceFile
+			})),
+			backend_field_candidates: candidates,
+			graph_context: {
+				analysis_files: document.analysisFiles,
+				mapping_context: document.mappingContext || [],
+				backend_path_sources: document.backendPathSources || []
+			},
+			source_excerpts: sourceExcerpts,
+			rules: document.rules,
+			aggregations: document.aggregations
+		})
+	].join("\n\n");
+}
+function parseSuggestions(content, document, properties, minimumConfidence) {
+	let raw;
+	try {
+		raw = JSON.parse(content);
+	} catch {
+		throw new Error("Inference returned invalid JSON for mapping inference");
+	}
+	let parsed;
+	if (typeof raw.mappings === "string") try {
+		parsed = {
+			...raw,
+			mappings: JSON.parse(raw.mappings.replace(/<UNKNOWN>/g, "null"))
+		};
+	} catch {
+		throw new Error("Inference returned invalid mappings JSON for mapping inference");
+	}
+	else parsed = raw;
+	const suggestions = /* @__PURE__ */ new Map();
+	const reviewSuggestions = [];
+	const rejectionReasons = {
+		invalid_property_index: 0,
+		invalid_candidate_index: 0,
+		invalid_confidence: 0,
+		below_confidence: 0,
+		missing_reason: 0,
+		duplicate: 0,
+		candidate_mismatch: 0
+	};
+	for (const mapping of parsed.mappings || []) {
+		if (typeof mapping.property_index !== "number" || !Number.isInteger(mapping.property_index)) {
+			rejectionReasons.invalid_property_index += 1;
+			continue;
+		}
+		if (typeof mapping.candidate_index !== "number" || !Number.isInteger(mapping.candidate_index)) {
+			rejectionReasons.invalid_candidate_index += 1;
+			continue;
+		}
+		if (typeof mapping.confidence !== "number" || mapping.confidence < 0 || mapping.confidence > 100) {
+			rejectionReasons.invalid_confidence += 1;
+			continue;
+		}
+		const confidence = mapping.confidence > 0 && mapping.confidence <= 1 ? mapping.confidence * 100 : mapping.confidence;
+		if (typeof mapping.reason !== "string" || !mapping.reason.trim()) {
+			rejectionReasons.missing_reason += 1;
+			continue;
+		}
+		const property = properties[mapping.property_index];
+		if (!property) {
+			rejectionReasons.invalid_property_index += 1;
+			continue;
+		}
+		const candidate = document.backendFieldCandidates[mapping.candidate_index];
+		if (!candidate) {
+			rejectionReasons.invalid_candidate_index += 1;
+			continue;
+		}
+		if (!candidateSharesTermWithProperty(candidate, property)) {
+			rejectionReasons.candidate_mismatch += 1;
+			continue;
+		}
+		const key = `${mapping.property_index}:${mapping.candidate_index}`;
+		if (suggestions.has(key)) {
+			rejectionReasons.duplicate += 1;
+			continue;
+		}
+		const suggestion = {
+			apiPropertyKey: property.key,
+			candidate,
+			confidence,
+			reason: mapping.reason.trim()
+		};
+		if (confidence < minimumConfidence) {
+			rejectionReasons.below_confidence += 1;
+			reviewSuggestions.push({
+				...suggestion,
+				accepted: false,
+				rejectionReason: "below_confidence"
+			});
+			continue;
+		}
+		suggestions.set(key, suggestion);
+		reviewSuggestions.push({
+			...suggestion,
+			accepted: true
+		});
+	}
+	const acceptedSuggestions = [...suggestions.values()];
+	return {
+		suggestions: acceptedSuggestions,
+		reviewSuggestions,
+		diagnostics: {
+			candidates: document.backendFieldCandidates.length,
+			proposals: parsed.mappings?.length || 0,
+			rejectedProposals: Math.max(0, (parsed.mappings?.length || 0) - acceptedSuggestions.length),
+			rejectionReasons
+		}
+	};
+}
+function chunkProperties(properties) {
+	return Array.from({ length: Math.ceil(properties.length / PROPERTIES_PER_BATCH) }, (_, index) => properties.slice(index * PROPERTIES_PER_BATCH, (index + 1) * PROPERTIES_PER_BATCH));
+}
+async function inferMissingMappings(document, properties, config) {
+	if (!config.enabled || !properties.length || !document.backendFieldCandidates.length) return {
+		suggestions: [],
+		reviewSuggestions: [],
+		diagnostics: {
+			candidates: document.backendFieldCandidates.length,
+			proposals: 0,
+			rejectedProposals: 0,
+			rejectionReasons: {
+				invalid_property_index: 0,
+				invalid_candidate_index: 0,
+				invalid_confidence: 0,
+				below_confidence: 0,
+				missing_reason: 0,
+				duplicate: 0,
+				candidate_mismatch: 0
+			}
+		}
+	};
+	const client = new AISdkClient({
+		baseUrl: config.baseUrl,
+		model: config.model,
+		apiKey: process.env.LITELLM_API_KEY
+	});
+	const results = [];
+	for (const batch of chunkProperties(properties)) {
+		const scopedDocument = scopeCandidatesToProperties(document, batch);
+		let content;
+		try {
+			const object = await client.generateStructuredObject({
+				schema: MAPPING_OUTPUT_SCHEMA,
+				prompt: await buildPrompt(scopedDocument, batch),
+				temperature: 0,
+				abortSignal: AbortSignal.timeout(config.timeoutMs)
+			});
+			content = JSON.stringify(object);
+		} catch (error) {
+			if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) throw new Error(`Inference timed out after ${config.timeoutMs}ms for ${document.method} ${document.path} with model ${config.model}. Increase the infer --timeout option.`);
+			if (NoObjectGeneratedError.isInstance(error)) {
+				const rawText = (error.text || "").slice(0, 2e3);
+				try {
+					results.push(parseSuggestions(rawText, scopedDocument, batch, config.minimumConfidence));
+					continue;
+				} catch {}
+				throw new Error(`Inference for ${document.method} ${document.path} with model ${config.model} did not return parseable structured output (finish reason: ${error.finishReason ?? "unknown"}). Raw response: ${rawText || "<empty>"}`);
+			}
+			throw error;
+		}
+		if (!content) throw new Error("Mapping inference returned no response content");
+		results.push(parseSuggestions(content, scopedDocument, batch, config.minimumConfidence));
+	}
+	const rejectionReasons = {
+		invalid_property_index: 0,
+		invalid_candidate_index: 0,
+		invalid_confidence: 0,
+		below_confidence: 0,
+		missing_reason: 0,
+		duplicate: 0,
+		candidate_mismatch: 0
+	};
+	for (const result of results) for (const [reason, count] of Object.entries(result.diagnostics.rejectionReasons)) rejectionReasons[reason] += count;
+	return {
+		suggestions: results.flatMap((result) => result.suggestions),
+		reviewSuggestions: results.flatMap((result) => result.reviewSuggestions),
+		diagnostics: {
+			candidates: document.backendFieldCandidates.length,
+			proposals: results.reduce((total, result) => total + result.diagnostics.proposals, 0),
+			rejectedProposals: results.reduce((total, result) => total + result.diagnostics.rejectedProposals, 0),
+			rejectionReasons
+		}
+	};
+}
+//#endregion
+//#region src/services/catalogueInferenceService.ts
+function stableKey(...parts) {
+	return createHash("sha1").update(parts.join("::")).digest("hex");
+}
+function candidateSource(candidate) {
+	return candidate.sourceLine ? `${candidate.sourceFile}:${candidate.sourceLine}` : candidate.sourceFile;
+}
+function findBackendRoute(document, suggestion) {
+	const candidates = document.backendRouteCandidates.filter((candidate) => candidate.backend === suggestion.candidate.backend);
+	return candidates.find((candidate) => candidate.sourceFile === suggestion.candidate.sourceFile) || candidates[0];
+}
+function ensureBackendRoute(catalogue, document, suggestion) {
+	const candidate = findBackendRoute(document, suggestion);
+	const backendRoutePath = candidate?.route || "unknown";
+	const key = stableKey(document.key, suggestion.candidate.backend, backendRoutePath);
+	const existing = catalogue.backend_routes.find((route) => route.key === key);
+	if (existing) return existing;
+	const created = {
+		key,
+		backend: suggestion.candidate.backend,
+		route_key: document.key,
+		route: `${candidate?.method || "CALL"} ${backendRoutePath}`,
+		source_file: candidate?.sourceFile || suggestion.candidate.sourceFile,
+		provenance: "ai"
+	};
+	catalogue.backend_routes.push(created);
+	return created;
+}
+function removeNeedsReviewEvidence(catalogue, property) {
+	catalogue.mapping_evidence = catalogue.mapping_evidence.filter((evidence) => !(evidence.status === "needs_review" && (evidence.input_property_key === property.key || evidence.output_property_key === property.key)));
+}
+function applyRefreshedStaticMappings(catalogue, staticCatalogue, unresolvedProperties) {
+	let resolved = 0;
+	const staticProperties = [...staticCatalogue.route_input_properties, ...staticCatalogue.route_output_properties];
+	for (const property of unresolvedProperties) {
+		const staticProperty = staticProperties.find((item) => item.key === property.key);
+		if (!staticProperty?.backend_mappings.length || staticProperty.evidence_status === "needs_review") continue;
+		property.backend_names = staticProperty.backend_names;
+		property.backend_mappings = staticProperty.backend_mappings;
+		property.evidence_status = staticProperty.evidence_status;
+		property.inference_suggestions = [];
+		removeNeedsReviewEvidence(catalogue, property);
+		for (const evidence of staticCatalogue.mapping_evidence.filter((item) => item.input_property_key === property.key || item.output_property_key === property.key)) if (!catalogue.mapping_evidence.some((item) => item.key === evidence.key)) catalogue.mapping_evidence.push(evidence);
+		resolved += 1;
+	}
+	for (const backendRoute of staticCatalogue.backend_routes) if (!catalogue.backend_routes.some((item) => item.key === backendRoute.key)) catalogue.backend_routes.push(backendRoute);
+	for (const backendProperty of staticCatalogue.backend_properties) if (!catalogue.backend_properties.some((item) => item.key === backendProperty.key)) catalogue.backend_properties.push(backendProperty);
+	return resolved;
+}
+function applySuggestion(catalogue, document, property, suggestion) {
+	const backendRouteCandidate = findBackendRoute(document, suggestion);
+	const backendRoute = ensureBackendRoute(catalogue, document, suggestion);
+	const backendPropertyKey = stableKey(backendRoute.key, property.direction, suggestion.candidate.backendField);
+	if (!catalogue.backend_properties.some((item) => item.key === backendPropertyKey)) catalogue.backend_properties.push({
+		key: backendPropertyKey,
+		backend_route_key: backendRoute.key,
+		backend: suggestion.candidate.backend,
+		field: suggestion.candidate.backendField,
+		direction: property.direction,
+		source_file: candidateSource(suggestion.candidate),
+		provenance: "ai"
+	});
+	if (!property.backend_mappings.some((mapping) => mapping.backend === suggestion.candidate.backend && mapping.field === suggestion.candidate.backendField)) property.backend_mappings.push({
+		backend: suggestion.candidate.backend,
+		method: backendRouteCandidate?.method || null,
+		route: backendRouteCandidate?.route || "unknown",
+		field: suggestion.candidate.backendField,
+		source_file: candidateSource(suggestion.candidate),
+		confidence: suggestion.confidence,
+		mapper_type: suggestion.candidate.mapperType,
+		provenance: "ai",
+		reason: suggestion.reason
+	});
+	if (!property.backend_names.includes(suggestion.candidate.backend)) property.backend_names.push(suggestion.candidate.backend);
+	property.evidence_status = "inferred";
+	removeNeedsReviewEvidence(catalogue, property);
+	catalogue.mapping_evidence.push({
+		key: stableKey(property.key, backendPropertyKey),
+		evidence_type: "inference",
+		status: "inferred",
+		confidence_score: suggestion.confidence,
+		comment: suggestion.reason,
+		...property.direction === "input" ? { input_property_key: property.key } : { output_property_key: property.key },
+		backend_property_key: backendPropertyKey,
+		source_file: candidateSource(suggestion.candidate)
+	});
+}
+function recordReviewSuggestion(document, property, suggestion) {
+	const backendRouteCandidate = findBackendRoute(document, suggestion);
+	property.inference_suggestions ||= [];
+	property.inference_suggestions.push({
+		backend: suggestion.candidate.backend,
+		method: backendRouteCandidate?.method || null,
+		route: backendRouteCandidate?.route || "unknown",
+		field: suggestion.candidate.backendField,
+		source_file: candidateSource(suggestion.candidate),
+		confidence: suggestion.confidence,
+		reason: suggestion.reason,
+		status: suggestion.accepted ? "accepted" : "needs_review",
+		rejection_reason: suggestion.rejectionReason
+	});
+}
+function ensureNeedsReviewEvidence(catalogue) {
+	const properties = [...catalogue.route_input_properties, ...catalogue.route_output_properties];
+	for (const property of properties.filter((item) => item.evidence_status === "needs_review")) {
+		if (catalogue.mapping_evidence.some((evidence) => evidence.input_property_key === property.key || evidence.output_property_key === property.key)) continue;
+		catalogue.mapping_evidence.push({
+			key: stableKey(property.key, "needs_review"),
+			evidence_type: "static_analysis",
+			status: "needs_review",
+			confidence_score: 0,
+			comment: `No backend property candidate matched ${property.field}`,
+			...property.direction === "input" ? { input_property_key: property.key } : { output_property_key: property.key },
+			backend_property_key: stableKey(property.route_key, "unmatched", property.direction, property.field),
+			source_file: property.source_file
+		});
+	}
+}
+function refreshStats(catalogue) {
+	catalogue.stats.backend_routes = catalogue.backend_routes.length;
+	catalogue.stats.backend_properties = catalogue.backend_properties.length;
+	catalogue.stats.mapping_evidence = catalogue.mapping_evidence.length;
+	catalogue.stats.needs_review = [...catalogue.route_input_properties, ...catalogue.route_output_properties].filter((property) => property.evidence_status === "needs_review").length;
+	catalogue.stats.needs_review_percentage = calculateNeedsReviewPercentage(catalogue.stats.input_properties, catalogue.stats.output_properties, catalogue.stats.needs_review);
+	catalogue.generated_at = (/* @__PURE__ */ new Date()).toISOString();
+}
+function formatInferenceFailure(error) {
+	return (error instanceof Error ? error.message : String(error)).split(" Raw response:")[0];
+}
+async function runWithConcurrency(items, workers, task) {
+	let nextIndex = 0;
+	await Promise.all(Array.from({ length: Math.min(Math.max(1, workers), items.length) }, async (_, workerId) => {
+		while (nextIndex < items.length) {
+			const item = items[nextIndex++];
+			await task(item, workerId);
+		}
+	}));
+}
+async function inferCatalogueDirectory(params) {
+	const inputPath = path.resolve(params.cwd, params.catalogueDirectory);
+	const outputPath = path.resolve(params.cwd, params.outputDirectory || params.catalogueDirectory);
+	taskProgressService.report("Loading route YAML documents");
+	const { catalogue, files } = await readCatalogueFromDirectory(inputPath);
+	ensureNeedsReviewEvidence(catalogue);
+	const needsReviewBefore = [...catalogue.route_input_properties, ...catalogue.route_output_properties].filter((property) => property.evidence_status === "needs_review").length;
+	const needsReviewPercentageBefore = calculateNeedsReviewPercentage(catalogue.stats.input_properties, catalogue.stats.output_properties, needsReviewBefore);
+	const selectedRoute = params.routeSelector ? catalogue.routes.find((route) => route.method.toUpperCase() === params.routeSelector?.method.toUpperCase() && route.path === params.routeSelector?.path) : void 0;
+	if (params.routeSelector && !selectedRoute) throw new Error(`Route not found in catalogue artifacts: ${params.routeSelector.method} ${params.routeSelector.path}`);
+	const scopeProperties = [...catalogue.route_input_properties, ...catalogue.route_output_properties].filter((property) => !selectedRoute || property.route_key === selectedRoute.key);
+	const needsReviewInScopeBefore = scopeProperties.filter((property) => property.evidence_status === "needs_review").length;
+	const needsReviewPercentageInScopeBefore = calculateNeedsReviewPercentage(scopeProperties.filter((property) => property.direction === "input").length, scopeProperties.filter((property) => property.direction === "output").length, needsReviewInScopeBefore);
+	const scopeStats = (needsReview, needsReviewPercentage) => ({
+		routes: selectedRoute ? 1 : catalogue.routes.length,
+		input_properties: scopeProperties.filter((property) => property.direction === "input").length,
+		output_properties: scopeProperties.filter((property) => property.direction === "output").length,
+		needs_review: needsReview,
+		needs_review_percentage: needsReviewPercentage
+	});
+	const unresolvedProperties = [...catalogue.route_input_properties, ...catalogue.route_output_properties].filter((property) => property.evidence_status === "needs_review").filter((property) => !selectedRoute || property.route_key === selectedRoute.key);
+	if (outputPath !== inputPath) {
+		taskProgressService.report("Copying source YAML documents to the output directory");
+		await writeCatalogueArtifacts(catalogue, outputPath, params.cwd);
+	}
+	if (!unresolvedProperties.length) return {
+		inputPath,
+		outputPath,
+		files,
+		catalogue,
+		reviewed: 0,
+		staticallyResolved: 0,
+		inferred: 0,
+		candidates: 0,
+		proposals: 0,
+		rejectedProposals: 0,
+		reviewSuggestions: 0,
+		rejectionReasons: {
+			invalid_property_index: 0,
+			invalid_candidate_index: 0,
+			invalid_confidence: 0,
+			below_confidence: 0,
+			missing_reason: 0,
+			duplicate: 0,
+			candidate_mismatch: 0
+		},
+		remainingInScope: 0,
+		graphScopedRoutes: 0,
+		skippedWithoutGraph: 0,
+		needsReviewBefore,
+		needsReviewPercentageBefore,
+		needsReviewGain: 0,
+		needsReviewPercentageGain: 0,
+		needsReviewInScopeBefore,
+		needsReviewPercentageInScopeBefore,
+		needsReviewPercentageInScopeAfter: needsReviewPercentageInScopeBefore,
+		scopeStats: scopeStats(needsReviewInScopeBefore, needsReviewPercentageInScopeBefore)
+	};
+	const routeKeys = [...new Set(unresolvedProperties.map((property) => property.route_key))];
+	const graphErrors = /* @__PURE__ */ new Map();
+	const analysisDocuments = [];
+	let staticallyResolved = 0;
+	let inferred = 0;
+	let candidates = 0;
+	let proposals = 0;
+	let rejectedProposals = 0;
+	let reviewSuggestions = 0;
+	const rejectionReasons = {
+		invalid_property_index: 0,
+		invalid_candidate_index: 0,
+		invalid_confidence: 0,
+		below_confidence: 0,
+		missing_reason: 0,
+		duplicate: 0,
+		candidate_mismatch: 0
+	};
+	await runWithConcurrency(routeKeys, Math.min(params.inference.workers, 10), async (routeKey, workerId) => {
+		const route = catalogue.routes.find((item) => item.key === routeKey);
+		const reportRoute = (phase) => {
+			params.onWorkerProgress?.({
+				workerId,
+				total: routeKeys.length,
+				route,
+				phase
+			});
+			if (!params.onWorkerProgress) taskProgressService.report(`Infer: ${route.method} ${route.path} [${phase}]`);
+		};
+		const routeProperties = unresolvedProperties.filter((property) => property.route_key === routeKey);
+		reportRoute("Load artifacts");
+		const routeContracts = /* @__PURE__ */ new Map([[routeKey, {
+			version: route.version,
+			input: catalogue.route_input_properties.filter((property) => property.route_key === routeKey).map((property) => ({
+				path: property.field,
+				description: property.description,
+				type: "BODY"
+			})),
+			output: catalogue.route_output_properties.filter((property) => property.route_key === routeKey).map((property) => ({
+				path: property.field,
+				description: property.description,
+				type: "RESPONSE_BODY"
+			}))
+		}]]);
+		reportRoute("Static analysis refresh");
+		const [document] = await analyzeCodebaseRouteContracts({
+			cwd: params.cwd,
+			selectedRouteKeys: /* @__PURE__ */ new Set([routeKey]),
+			routeContracts,
+			routeAnalysisScope: async ({ method, path: routePath }) => {
+				try {
+					return await loadBackendTopologyAnalysisScope(inputPath, params.cwd, method, routePath);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					graphErrors.set(`${method} ${routePath}`, message);
+					taskProgressService.log(`Warning: ${message} Route skipped.`);
+					return;
+				}
+			}
+		});
+		if (!document) {
+			params.onWorkerProgress?.({
+				workerId,
+				total: routeKeys.length,
+				route,
+				phase: "Skipped",
+				completed: true
+			});
+			return;
+		}
+		analysisDocuments.push(document);
+		reportRoute("Deterministic mapping refresh");
+		staticallyResolved += applyRefreshedStaticMappings(catalogue, await buildCatalogue([document]), routeProperties);
+		const remainingRouteProperties = routeProperties.filter((property) => property.evidence_status === "needs_review");
+		for (const property of routeProperties) property.inference_suggestions = [];
+		if (!remainingRouteProperties.length) {
+			refreshStats(catalogue);
+			reportRoute("Update artifacts");
+			await writeRouteReviewDocument(catalogue, outputPath, params.cwd, routeKey);
+			params.onWorkerProgress?.({
+				workerId,
+				total: routeKeys.length,
+				route,
+				phase: "Completed",
+				completed: true
+			});
+			return;
+		}
+		reportRoute(`AI inference: ${remainingRouteProperties.length} fields`);
+		let inferenceResult;
+		try {
+			inferenceResult = await inferMissingMappings(document, remainingRouteProperties.map((property) => ({
+				key: property.key,
+				direction: property.direction,
+				field: property.field,
+				domainField: property.domain_field,
+				description: property.description,
+				reviewReasons: property.unresolved_backend_candidates?.map((candidate) => candidate.reason)
+			})), params.inference);
+		} catch (error) {
+			taskProgressService.log(`Warning: AI inference failed for ${route.method} ${route.path}: ${formatInferenceFailure(error)}. Route kept for review.`);
+			refreshStats(catalogue);
+			reportRoute("Update artifacts");
+			await writeRouteReviewDocument(catalogue, outputPath, params.cwd, routeKey);
+			params.onWorkerProgress?.({
+				workerId,
+				total: routeKeys.length,
+				route,
+				phase: "Completed with AI error",
+				completed: true
+			});
+			return;
+		}
+		candidates += inferenceResult.diagnostics.candidates;
+		proposals += inferenceResult.diagnostics.proposals;
+		rejectedProposals += inferenceResult.diagnostics.rejectedProposals;
+		for (const [reason, count] of Object.entries(inferenceResult.diagnostics.rejectionReasons)) rejectionReasons[reason] += count;
+		for (const suggestion of inferenceResult.reviewSuggestions) {
+			const property = remainingRouteProperties.find((item) => item.key === suggestion.apiPropertyKey);
+			if (!property) continue;
+			recordReviewSuggestion(document, property, suggestion);
+			reviewSuggestions += 1;
+		}
+		for (const suggestion of inferenceResult.suggestions) {
+			const property = remainingRouteProperties.find((item) => item.key === suggestion.apiPropertyKey);
+			if (!property) continue;
+			applySuggestion(catalogue, document, property, suggestion);
+			inferred += 1;
+		}
+		refreshStats(catalogue);
+		reportRoute("Update artifacts");
+		await writeRouteReviewDocument(catalogue, outputPath, params.cwd, routeKey);
+		params.onWorkerProgress?.({
+			workerId,
+			total: routeKeys.length,
+			route,
+			phase: "Completed",
+			completed: true
+		});
+	});
+	refreshStats(catalogue);
+	const remainingInScope = [...catalogue.route_input_properties, ...catalogue.route_output_properties].filter((property) => routeKeys.includes(property.route_key) && property.evidence_status === "needs_review").length;
+	const needsReviewPercentageInScopeAfter = calculateNeedsReviewPercentage(scopeProperties.filter((property) => property.direction === "input").length, scopeProperties.filter((property) => property.direction === "output").length, remainingInScope);
+	taskProgressService.report(`Inference completed with ${remainingInScope} reviews remaining in selected scope`);
+	return {
+		inputPath,
+		outputPath,
+		files,
+		catalogue,
+		reviewed: unresolvedProperties.length,
+		staticallyResolved,
+		inferred,
+		candidates,
+		proposals,
+		rejectedProposals,
+		reviewSuggestions,
+		rejectionReasons,
+		remainingInScope,
+		graphScopedRoutes: analysisDocuments.length,
+		skippedWithoutGraph: graphErrors.size,
+		needsReviewBefore,
+		needsReviewPercentageBefore,
+		needsReviewGain: needsReviewBefore - catalogue.stats.needs_review,
+		needsReviewPercentageGain: Number((needsReviewPercentageBefore - catalogue.stats.needs_review_percentage).toFixed(2)),
+		needsReviewInScopeBefore,
+		needsReviewPercentageInScopeBefore,
+		needsReviewPercentageInScopeAfter,
+		scopeStats: scopeStats(remainingInScope, needsReviewPercentageInScopeAfter)
+	};
+}
+//#endregion
+//#region src/commands/infer.ts
+function createInferenceStepClassifier() {
+	return (message) => {
+		const routePhase = message.match(/^Infer: ([A-Z]+) (.+) \[(.+)]$/);
+		if (routePhase) {
+			const [, method, routePath, phase] = routePhase;
+			return {
+				id: `infer-${method}-${routePath}`,
+				title: `Infer: ${method} ${routePath} [${phase}]`,
+				completedTitle: `Inference completed: ${method} ${routePath}`
+			};
+		}
+		if (/Loading route YAML|Copying source YAML/.test(message)) return {
+			id: "artifacts",
+			title: "Loading route artifacts",
+			completedTitle: "Route artifacts loaded",
+			detail: message
+		};
+		return {
+			id: "inference",
+			title: "Processing inference",
+			completedTitle: "Inference processed",
+			detail: message
+		};
+	};
+}
+function parsePositiveNumber(value) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) throw new InvalidArgumentError("Expected a positive number");
+	return parsed;
+}
+function parseConfidence(value) {
+	const parsed = parsePositiveNumber(value);
+	if (parsed > 100) throw new InvalidArgumentError("Confidence must be between 1 and 100");
+	return parsed;
+}
+function parseWorkerCount(value) {
+	const workers = parsePositiveNumber(value);
+	if (workers > 10) throw new InvalidArgumentError("A maximum of 10 inference workers is supported");
+	return workers;
+}
+var infer_default = (program) => void program.command("infer").argument("[route-or-directory]", "Route selector (GET /v1/offers) or catalogue directory").option("-i, --input <directory>", "Directory containing generated route YAML documents", ".tmp/datasource-catalogue").option("-o, --output <directory>", "Output directory; defaults to updating the input directory").option("--model <name>", "AI model name").option("--ai-url <url>", "AI base URL").option("--min-confidence <number>", "Minimum confidence required to accept an ai/sdk mapping", parseConfidence).option("--timeout <milliseconds>", "Maximum duration of one route-level ai/sdk request", parsePositiveNumber).option("-w, --workers <count>", "Maximum number of concurrent route inference jobs (max 10)", parseWorkerCount).description("Use AI to review unresolved mappings in generated route YAML documents").action(async (routeOrDirectory, options) => {
+	intro("Datasource catalogue inference");
+	const config = getUserConfig();
+	const inference = config.inference;
+	const resolvedOptions = {
+		model: options.model ?? process.env.AI_MODEL ?? inference.model,
+		aiUrl: options.aiUrl ?? process.env.AI_URL ?? inference.baseUrl,
+		minConfidence: options.minConfidence ?? inference.minimumConfidence,
+		timeout: options.timeout ?? inference.timeoutMs,
+		workers: options.workers ?? inference.workers
+	};
+	const progress$1 = taskProgressService.createStepProgress(createInferenceStepClassifier());
+	try {
+		const routeSelector = routeOrDirectory && /^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+/i.test(routeOrDirectory) ? parseRouteSelector(routeOrDirectory) : void 0;
+		const catalogueDirectory = routeSelector ? options.input : routeOrDirectory || options.input;
+		let inferenceProgress;
+		let completedRoutes = 0;
+		const result = await progress$1.execute(() => inferCatalogueDirectory({
+			cwd: config.cwd,
+			catalogueDirectory,
+			routeSelector,
+			outputDirectory: options.output,
+			inference: {
+				enabled: true,
+				model: resolvedOptions.model,
+				baseUrl: resolvedOptions.aiUrl,
+				minimumConfidence: resolvedOptions.minConfidence,
+				timeoutMs: resolvedOptions.timeout,
+				workers: resolvedOptions.workers
+			},
+			onWorkerProgress: ({ total, route, phase, completed }) => {
+				const w = resolvedOptions.workers;
+				if (!inferenceProgress) {
+					progress$1.finish("Route artifacts loaded");
+					inferenceProgress = progress({
+						style: "heavy",
+						max: total,
+						size: 40
+					});
+					inferenceProgress.start(`${w} worker${w > 1 ? "s" : ""} · Infer · [0/${total}] routes`);
+				}
+				const label = `${w} worker${w > 1 ? "s" : ""} · Infer · [${completedRoutes}/${total}] routes · ${route.method} ${route.path} [${phase}]`;
+				if (completed) {
+					completedRoutes += 1;
+					inferenceProgress.advance(1, label.replace(`[${completedRoutes - 1}/${total}]`, `[${completedRoutes}/${total}]`));
+					return;
+				}
+				inferenceProgress.message(label);
+			}
+		}));
+		inferenceProgress?.stop(`Inference completed: ${completedRoutes} route${completedRoutes > 1 ? "s" : ""} · ${resolvedOptions.workers} worker${resolvedOptions.workers > 1 ? "s" : ""}`);
+		progress$1.finish("Inferrence mapping review completed");
+		const rejectionSummary = Object.entries(result.rejectionReasons).filter(([, count]) => count > 0).map(([reason, count]) => `${reason}=${count}`).join(", ");
+		note([
+			`Input directory: ${result.inputPath}`,
+			`Output directory: ${result.outputPath}`,
+			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null,
+			`Properties reviewed: ${result.reviewed}`,
+			`AI workers: ${resolvedOptions.workers}`,
+			`Mappings resolved by static refresh: ${result.staticallyResolved}`,
+			`AI proposals received: ${result.proposals}`,
+			`AI proposals rejected: ${result.rejectedProposals}`,
+			rejectionSummary ? `Rejection reasons: ${rejectionSummary}` : null,
+			`Mappings inferred: ${result.inferred}`,
+			`Needs review remaining in scope: ${result.remainingInScope}`
+		].filter(Boolean).join("\n"), "Inference");
+		outro("Datasource catalogue inference completed");
+	} catch (error) {
+		progress$1.fail("AI mapping review failed");
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/commands/init.ts
+const CONFIG_FILE_NAME = "atlas.config.ts";
+const configTemplate = `import { defineConfig } from "@cmflow/atlas";
+
+export default defineConfig({
+  repoRoot: process.cwd(),
+  backendTypesFile: "app/_infra/back/BackendTypes.ts",
+  openapiUrl: "https://api.example.com/openapi.json",
+  openapiTimeoutMs: 60_000,
+  directusUrl: "https://cms.api.clubmed",
+  resolver: {
+    alias: {}
+  },
+  inference: {
+    model: process.env.AI_MODEL ?? "gpt-4o-mini",
+    baseUrl: process.env.AI_BASE_URL ?? "https://api.openai.com/v1",
+    minimumConfidence: 75,
+    timeoutMs: 120_000,
+    workers: 2
+  },
+  analysis: {
+    excluded: [],
+    transversalInputs: [],
+    ignoredOutputs: [],
+    backendFieldAccess: {
+      excludedPrefixes: []
+    },
+    mapperNaming: {
+      inputPatterns: [/(?:FromApiToDomain|ApiToDomain|ToDomain)/i],
+      outputPatterns: [/(?:FromDomainToApi|DomainToApi|ToApi)/i],
+      domainToBackendPattern: /(?:DomainTo|To)(?:Back|Backend)$/i,
+      domainNameFromToDomainPattern: /^map(.+)ToDomain$/i,
+      constructedTypeToDomainPattern: (constructorName) =>
+        new RegExp(\`^map\${constructorName}(?:From(?:Back|Backend))?ToDomain$|^map\${constructorName}$\`, "i")
+    },
+    neutralExpressionMatchers: [],
+    rules: []
+  },
+  test: {
+    coverage: []
+  }
+});
+`;
+var init_default = (program, datasourceCommand) => void program.command("init").option("--force", "Overwrite an existing atlas.config.ts", false).description("Create an atlas.config.ts in the target API project").action(async (options) => {
+	const configPath = path.resolve(datasourceCommand.opts().config ?? CONFIG_FILE_NAME);
+	const configDirectory = path.dirname(configPath);
+	intro("Initialize datasource configuration");
+	try {
+		await fs.mkdir(configDirectory, { recursive: true });
+		if (!options.force) {
+			let exists = false;
+			try {
+				await fs.access(configPath);
+				exists = true;
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			if (exists) throw new Error(`${configPath} already exists. Use --force to overwrite it.`);
+		}
+		await fs.writeFile(configPath, configTemplate, "utf8");
+		outro(`Created ${configPath}`);
+	} catch (error) {
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exitCode = 1;
+	}
+});
+//#endregion
+//#region src/services/catalogueReviewReportService.ts
+async function buildNeedsReviewRouteReport(params) {
+	const inputPath = path.resolve(params.cwd, params.catalogueDirectory);
+	const { catalogue, files } = await readCatalogueFromDirectory(inputPath);
+	const rows = catalogue.routes.map((route) => {
+		const inputs = catalogue.route_input_properties.filter((property) => property.route_key === route.key);
+		const outputs = catalogue.route_output_properties.filter((property) => property.route_key === route.key);
+		const inputNeedsReview = inputs.filter((property) => property.evidence_status === "needs_review").length;
+		const outputNeedsReview = outputs.filter((property) => property.evidence_status === "needs_review").length;
+		const needsReview = inputNeedsReview + outputNeedsReview;
+		return {
+			method: route.method,
+			path: route.path,
+			inputProperties: inputs.length,
+			outputProperties: outputs.length,
+			inputNeedsReview,
+			outputNeedsReview,
+			needsReview,
+			needsReviewPercentage: calculateNeedsReviewPercentage(inputs.length, outputs.length, needsReview)
+		};
+	}).filter((row) => row.needsReview > 0);
+	rows.sort((left, right) => {
+		return (params.sort === "percentage" ? right.needsReviewPercentage - left.needsReviewPercentage : right.needsReview - left.needsReview) || right.needsReview - left.needsReview || left.path.localeCompare(right.path);
+	});
+	return {
+		inputPath,
+		files,
+		totalRoutes: catalogue.routes.length,
+		candidateRoutes: rows.length,
+		totalProperties: catalogue.stats.input_properties + catalogue.stats.output_properties,
+		needsReview: catalogue.stats.needs_review,
+		needsReviewPercentage: catalogue.stats.needs_review_percentage,
+		rows: params.limit ? rows.slice(0, params.limit) : rows
+	};
+}
+//#endregion
+//#region src/commands/needsReview.ts
+function parsePositiveInteger(value) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new InvalidArgumentError("Expected a positive integer");
+	return parsed;
+}
+function formatNeedsReviewTable(rows) {
+	const headers = [
+		"#",
+		"Route",
+		"In review",
+		"Out review",
+		"Properties",
+		"Need review",
+		"Need %"
+	];
+	const values = rows.map((row, index) => [
+		String(index + 1),
+		`${row.method} ${row.path}`,
+		String(row.inputNeedsReview),
+		String(row.outputNeedsReview),
+		String(row.inputProperties + row.outputProperties),
+		String(row.needsReview),
+		`${row.needsReviewPercentage.toFixed(2)}%`
+	]);
+	const widths = headers.map((header, column) => Math.max(header.length, ...values.map((row) => row[column].length)));
+	const formatRow = (row) => row.map((cell, column) => column < 2 ? cell.padEnd(widths[column]) : cell.padStart(widths[column])).join(" | ");
+	return [
+		formatRow(headers),
+		widths.map((width) => "-".repeat(width)).join("-+-"),
+		...values.map(formatRow)
+	].join("\n");
+}
+var needsReview_default = (program) => void program.command("needs-review").argument("[catalogue-directory]", "Directory containing generated route YAML documents", ".tmp/datasource-catalogue").addOption(new Option("--sort <metric>", "Sort candidates by review count or percentage").choices(["count", "percentage"]).default("count")).option("--limit <number>", "Maximum number of candidate routes to display", parsePositiveInteger).description("Display needs_review metrics grouped by route").action(async (catalogueDirectory, options) => {
+	intro("Datasource catalogue needs review report");
+	const { cwd } = getUserConfig();
+	const progress = taskProgressService.createStepProgress();
+	try {
+		const report = await progress.run({
+			id: "report",
+			title: "Loading route review documents",
+			completedTitle: "Route review report built"
+		}, () => buildNeedsReviewRouteReport({
+			cwd,
+			catalogueDirectory,
+			sort: options.sort,
+			limit: options.limit
+		}));
+		if (report.rows.length) {
+			log.info("Candidate routes");
+			log.message(formatNeedsReviewTable(report.rows));
+		} else log.info("No route requires review.");
+		note([
+			`Input directory: ${report.inputPath}`,
+			`Route documents: ${report.files.length}`,
+			`Candidate routes: ${report.candidateRoutes}/${report.totalRoutes}`,
+			`Properties: ${report.totalProperties}`,
+			`Needs review: ${report.needsReview}`,
+			`Needs review percentage: ${report.needsReviewPercentage.toFixed(2)}%`,
+			options.limit ? `Rows displayed: ${report.rows.length}/${report.candidateRoutes}` : null
+		].filter(Boolean).join("\n"), "Summary");
+		outro("Datasource catalogue needs review report completed");
+	} catch (error) {
+		progress.fail("Needs review report failed");
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/services/changedRouteReportService.ts
+function sortPropertiesByStatus(properties) {
+	return [...properties].sort((left, right) => {
+		const rank = (status) => status === "needs_review" ? 0 : 1;
+		return rank(left.status) - rank(right.status) || left.field.localeCompare(right.field);
+	});
+}
+function normalizeFilePath(filePath) {
+	return filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function isGraphDocument(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const document = value;
+	return typeof document.route?.method === "string" && typeof document.route.path === "string" && Array.isArray(document.analysis_files) && document.analysis_files.every((filePath) => typeof filePath === "string");
+}
+function collectImpactedRoutes(params) {
+	const changedFiles = new Set(params.changedFiles.map(normalizeFilePath));
+	return params.graphs.filter((graph) => graph.analysisFiles.some((analysisFile) => changedFiles.has(normalizeFilePath(analysisFile)))).sort((left, right) => `${left.method} ${left.path}`.localeCompare(`${right.method} ${right.path}`));
+}
+async function readChangedFiles(filePath) {
+	return (await fs.readFile(filePath, "utf8")).split(/\r?\n/).map((line) => normalizeFilePath(line.trim())).filter(Boolean);
+}
+async function readRouteGraphs(outputDirectory) {
+	const graphFiles = await globby("**/*.graph.yaml", {
+		cwd: outputDirectory,
+		absolute: true
+	});
+	const graphs = await Promise.all(graphFiles.map(async (graphFile) => {
+		const document = parse(await fs.readFile(graphFile, "utf8"));
+		if (!isGraphDocument(document)) throw new Error(`Invalid graph document: ${graphFile}`);
+		return {
+			method: document.route.method,
+			path: document.route.path,
+			analysisFiles: document.analysis_files.map(normalizeFilePath)
+		};
+	}));
+	if (!graphs.length) throw new Error(`No graph documents found in ${path.resolve(outputDirectory)}. Run generate:graph first.`);
+	return graphs;
+}
+function renderChangedRouteReport(params) {
+	const changedFiles = params.changedFiles.sort();
+	const routeRows = params.routes.length ? params.routes.map((route) => `| ${route.method} ${route.path} | ${route.coverage.toFixed(2)}% | ${route.needsReview}/${route.fields} |`).join("\n") : "| _Aucune route impactée_ | — | — |";
+	return [
+		"<!-- datasource-catalogue-report -->",
+		"## Datasource mapping report",
+		"",
+		`Fichiers modifiés analysés : **${changedFiles.length}**`,
+		"",
+		"<details><summary>Fichiers modifiés</summary>",
+		"",
+		...changedFiles.map((filePath) => `- \`${filePath}\``),
+		"",
+		"</details>",
+		"",
+		`Routes impactées : **${params.routes.length}**`,
+		"",
+		"| Route | Couverture mapping | Champs à revoir |",
+		"| --- | ---: | ---: |",
+		routeRows,
+		...params.routes.flatMap((route) => {
+			const inputs = sortPropertiesByStatus(route.properties.filter((property) => property.direction === "input"));
+			const outputs = sortPropertiesByStatus(route.properties.filter((property) => property.direction === "output"));
+			return [
+				"",
+				`### ${route.method} ${route.path}`,
+				"",
+				`Backends détectés : ${route.backends.length ? route.backends.map((backend) => `\`${backend}\``).join(", ") : "aucun"}`,
+				"",
+				"#### Routes backend",
+				"",
+				"| Backend | Route |",
+				"| --- | --- |",
+				...route.backendRoutes.length ? route.backendRoutes.map((backendRoute) => `| ${backendRoute.backend} | \`${backendRoute.route}\` |`) : ["| — | — |"],
+				"",
+				`<details><summary>Inputs (${inputs.length})</summary>`,
+				"",
+				"| Champ | Statut |",
+				"| --- | --- |",
+				...inputs.length ? inputs.map((property) => `| \`${property.field}\` | ${property.status} |`) : ["| — | — |"],
+				"",
+				"</details>",
+				"",
+				`<details><summary>Outputs (${outputs.length})</summary>`,
+				"",
+				"| Champ | Statut |",
+				"| --- | --- |",
+				...outputs.length ? outputs.map((property) => `| \`${property.field}\` | ${property.status} |`) : ["| — | — |"],
+				"",
+				"</details>"
+			];
+		}),
+		"",
+		"Couverture = part des champs dont le mapping déterministe ne nécessite pas de revue manuelle."
+	].join("\n");
+}
+//#endregion
+//#region src/commands/reportChanged.ts
+async function reportChangedHandler(cwd, options) {
+	const config = getUserConfig();
+	const outputDirectory = path.resolve(cwd, options.output);
+	const changedFiles = await readChangedFiles(path.resolve(cwd, options.changedFiles));
+	const impactedRoutes = collectImpactedRoutes({
+		changedFiles,
+		graphs: await readRouteGraphs(outputDirectory)
+	});
+	const coverages = [];
+	if (impactedRoutes.length) {
+		const openApiDocument = await loadOpenApiDocument(config.openapiUrl);
+		for (const route of impactedRoutes) try {
+			const documents = await analyzeCodebaseRouteContracts({
+				cwd,
+				openApiDocument,
+				selectedRouteKeys: /* @__PURE__ */ new Set([buildRouteKey(route.method, route.path)]),
+				routeAnalysisScope: ({ method, path: routePath }) => loadBackendTopologyAnalysisScope(outputDirectory, cwd, method, routePath)
+			});
+			if (documents.length !== 1) throw new Error("Route was not found in the OpenAPI contract");
+			const catalogue = await buildCatalogue(documents);
+			const catalogueRoute = catalogue.routes[0];
+			const properties = [...catalogue.route_input_properties, ...catalogue.route_output_properties];
+			coverages.push({
+				...route,
+				coverage: 100 - catalogue.stats.needs_review_percentage,
+				fields: properties.length,
+				needsReview: properties.filter((p) => p.evidence_status === "needs_review").length,
+				backends: catalogueRoute?.backends || [],
+				backendRoutes: catalogue.backend_routes.filter((br) => br.route_key === catalogueRoute?.key).map((br) => ({
+					backend: br.backend,
+					route: br.route
+				})),
+				properties: [...catalogue.route_input_properties.map((p) => ({
+					direction: "input",
+					field: p.field,
+					status: p.evidence_status
+				})), ...catalogue.route_output_properties.map((p) => ({
+					direction: "output",
+					field: p.field,
+					status: p.evidence_status
+				}))]
+			});
+		} catch {}
+	}
+	const report = renderChangedRouteReport({
+		changedFiles,
+		routes: coverages
+	});
+	const reportPath = path.resolve(cwd, options.report);
+	await fs.mkdir(path.dirname(reportPath), { recursive: true });
+	await fs.writeFile(reportPath, `${report}\n`, "utf8");
+	note(report, "Datasource mapping report");
+}
+var reportChanged_default = (program) => void program.command("report:changed").requiredOption("--changed-files <file>", "Newline-delimited list of changed repository files").option("-o, --output <directory>", "Directory containing generated graph artifacts", ".tmp/datasource-catalogue").option("--report <file>", "Markdown report output path", ".tmp/datasource-catalogue/changed-routes-report.md").description("Report deterministic mapping coverage for routes impacted by changed files").action(async (options) => {
+	intro("Datasource changed-route report");
+	const { cwd } = getUserConfig();
+	try {
+		await reportChangedHandler(cwd, options);
+		outro("Datasource changed-route report completed");
+	} catch (error) {
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/bin/atlas.ts
+const program = new Command();
+program.version("3.4.0-alpha.1");
+program.name("atlas").description("Manage the API-to-backend mapping catalogue").option("--project-root <path>", "Root directory of the API project to analyze").option("-c, --config <path>", "Path to atlas.config.ts", path.resolve(process.cwd(), "atlas.config.ts")).hook("preAction", async (_thisCommand, actionCommand) => {
+	if (actionCommand.name() === "init") return;
+	const config = await loadAtlasConfig(program.opts().config);
+	const repoRoot = program.opts().projectRoot ?? config.repoRoot;
+	setUserConfig({
+		...config,
+		repoRoot,
+		cwd: repoRoot
+	});
+});
+init_default(program, program);
+generate_default(program);
+generateGraph_default(program);
+generateTest_default(program);
+infer_default(program);
+needsReview_default(program);
+push_default(program);
+cleanOrphans_default(program);
+reportChanged_default(program);
+await program.parseAsync(process.argv);
+//#endregion
+export {};