@cmflow/atlas 3.4.0-beta.21 → 3.4.0-beta.22

package/dist/bin/atlas.mjs

@@ -3,8 +3,8 @@ import { fileURLToPath as __atlasFileURLToPath } from "node:url";
 const __filename = __atlasFileURLToPath(import.meta.url);
 import { n as __require, r as __toESM, t as __commonJSMin } from "../rolldown-runtime-CGR6nZuH.mjs";
 import { a as note, c as select, d as setUserConfig, f as userConfig$1, i as log, l as isCancel, n as cancel, o as outro, r as intro, s as progress, t as taskProgressService, u as getUserConfig } from "../taskProgressService-CAC_RIoa.mjs";
-import { a as isKnownBackendType, c as globby, i as inferBackendNameFromFile, n as generateBackendTopologyArtifactsInWorkers, o as filterAnalysisFiles, r as resolveModulePath, s as shouldKeepAnalysisFile } from "../routeBackendTopologyService-CkOLUfcj.mjs";
-import { i as loadOpenApiDocument, n as extractOpenApiInputProperties, r as extractOpenApiOutputProperties } from "../propertyExtractionService-8BjqpPFa.mjs";
+import { a as inferBackendNameFromFile, c as shouldKeepAnalysisFile, i as resolveModulePath, l as normalizeFilePath, n as generateBackendTopologyArtifactsInWorkers, o as isKnownBackendType, r as matchesRouteSelector, s as filterAnalysisFiles, u as globby } from "../routeBackendTopologyService-CQyRyoSN.mjs";
+import { i as loadOpenApiDocument, n as extractOpenApiInputProperties, r as extractOpenApiOutputProperties } from "../propertyExtractionService-BLat-Hsf.mjs";
 import { n as require_auth_errors, r as require_token_error, t as require_token_util } from "../token-util-Dnzm6rU4.mjs";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -2888,6 +2888,233 @@ const r = (r = {}) => (i) => {
 	} };
 };
 
+//#endregion
+//#region src/utils/isRecord.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/services/directus/utils/isServiceUnavailableError.ts
+function isServiceUnavailableError(error) {
+	if (!isRecord$1(error)) return false;
+	if ((isRecord$1(error.response) ? error.response.status : void 0) === 503) return true;
+	return Array.isArray(error.errors) && error.errors.some((item) => isRecord$1(item) && isRecord$1(item.extensions) && item.extensions.code === "SERVICE_UNAVAILABLE");
+}
+
+//#endregion
+//#region src/services/directus/utils/isTransientNetworkError.ts
+function isTransientNetworkError(error) {
+	if (error instanceof TypeError && error.message === "fetch failed") return true;
+	if (!isRecord$1(error)) return false;
+	if (error.message === "fetch failed") return true;
+	const cause = isRecord$1(error.cause) ? error.cause : void 0;
+	return cause?.code === "ECONNRESET" || cause?.code === "ECONNREFUSED" || cause?.code === "ETIMEDOUT" || cause?.code === "UND_ERR_CONNECT_TIMEOUT";
+}
+
+//#endregion
+//#region src/services/directus/utils/retryDirectusRequest.ts
+const DIRECTUS_RETRY_MAX_ATTEMPTS = 6;
+const DIRECTUS_RETRY_INITIAL_DELAY_MS = 1e3;
+const DIRECTUS_RETRY_MAX_DELAY_MS = 8e3;
+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");
+}
+
+//#endregion
+//#region src/services/directus/createClient.ts
+async function createClient() {
+	const baseUrl = getUserConfig().directusUrl;
+	const token = getUserConfig().directusToken;
+	if (!token) throw new Error("Directus push requested but Directus token is missing");
+	const client = t$1(baseUrl).with(r()).with(e$3(token));
+	return { request: (command) => retryDirectusRequest(() => client.request(command)) };
+}
+
+//#endregion
+//#region src/services/directus/queries/deleteOrphanedPropertyLinks.ts
+const DIRECTUS_DELETE_WORKERS = 2;
+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(r$1(link.collection, link.id));
+		}
+	}));
+	return links.length;
+}
+
+//#endregion
+//#region src/services/directus/queries/findOrphanedPropertyLinks.ts
+async function findOrphanedPropertyLinks(client) {
+	const [inputProperties, outputProperties, backendProperties, inputLinks, outputLinks] = await Promise.all([
+		client.request(n$1("route_input_properties", {
+			fields: ["id"],
+			limit: -1
+		})),
+		client.request(n$1("route_output_properties", {
+			fields: ["id"],
+			limit: -1
+		})),
+		client.request(n$1("backend_properties", {
+			fields: ["id"],
+			limit: -1
+		})),
+		client.request(n$1("route_input_properties_backend_properties", {
+			fields: [
+				"id",
+				"route_input_properties_id",
+				"backend_properties_id"
+			],
+			limit: -1
+		})),
+		client.request(n$1("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)))
+	};
+}
+
+//#endregion
+//#region src/services/directus/cleanDirectusOrphanedPropertyLinks.ts
+async function cleanDirectusOrphanedPropertyLinks(options) {
+	taskProgressService.report("Connecting to Directus");
+	const client = await createClient();
+	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
+	};
+}
+
+//#endregion
+//#region src/utils/normalizeLookupKey.ts
+function normalizeLookupKey(value) {
+	return value.toUpperCase().replace(/[^A-Z0-9]/g, "");
+}
+
+//#endregion
+//#region src/services/directus/cleanupOrphanedPropertyLinks.ts
+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;
+}
+
+//#endregion
+//#region src/services/directus/queries/ensureInputLink.ts
+async function ensureInputLink(client, inputPropertyId, backendPropertyId) {
+	const [existing] = await client.request(n$1("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(n$2("route_input_properties_backend_properties", {
+		route_input_properties_id: inputPropertyId,
+		backend_properties_id: backendPropertyId
+	}));
+	return true;
+}
+
+//#endregion
+//#region src/services/directus/queries/ensureOutputLink.ts
+async function ensureOutputLink(client, outputPropertyId, backendPropertyId) {
+	const [existing] = await client.request(n$1("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(n$2("route_output_properties_backend_properties", {
+		route_output_properties_id: outputPropertyId,
+		backend_properties_id: backendPropertyId
+	}));
+	return true;
+}
+
+//#endregion
+//#region src/services/directus/queries/loadDirectusReferenceData.ts
+async function loadDirectusReferenceData(client) {
+	const values = await client.request(n$1("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
+	};
+}
+
 //#endregion
 //#region src/utils/catalogueStats.ts
 function calculateNeedsReviewPercentage(inputProperties, outputProperties, needsReview) {
@@ -2896,10 +3123,36 @@ function calculateNeedsReviewPercentage(inputProperties, outputProperties, needs
 }
 
 //#endregion
-//#region src/services/useCaseAnalysisService.ts
+//#region src/utils/hash/stableKey.ts
+function stableKey(...parts) {
+	return createHash("sha1").update(parts.join("::")).digest("hex");
+}
+
+//#endregion
+//#region src/utils/normalizeField.ts
+function normalizeField(value) {
+	return value.replace(/\[locale\]/g, "").replace(/\[\]/g, "").replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+}
+
+//#endregion
+//#region src/utils/matchBackendProperty.ts
+function matchBackendProperty(field, properties) {
+	if (!properties) return;
+	const normalized = normalizeField(field);
+	return properties.find((property) => {
+		const reference = normalizeField(property.field);
+		return normalized === reference || normalized.endsWith(reference) || reference.endsWith(normalized);
+	});
+}
+
+//#endregion
+//#region src/utils/normalizeCodeText.ts
 function normalizeCodeText(value) {
-	return value.replace(/\s+/g, " ").replace(/;$/, "").trim();
+	return value.replace(/\s+/g, " ").trim().replace(/;$/, "");
 }
+
+//#endregion
+//#region src/services/useCaseAnalysisService.ts
 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";
@@ -3015,7 +3268,7 @@ var AnalysisCacheService = class {
 const analysisCacheService = new AnalysisCacheService();
 
 //#endregion
-//#region src/services/backendPropertyService.ts
+//#region src/services/resolveBackendProperties.ts
 const propertiesBySource = /* @__PURE__ */ new WeakMap();
 async function resolveBackendProperties(sources) {
 	const resolved = await Promise.all(sources.map(async (source) => {
@@ -3032,17 +3285,6 @@ async function resolveBackendProperties(sources) {
 	}));
 	return new Map(resolved.filter((entry) => entry[1] !== void 0).map(([backend, properties]) => [backend, properties]));
 }
-function matchBackendProperty(field, properties) {
-	if (!properties) return;
-	const normalized = normalizeField(field);
-	return properties.find((property) => {
-		const reference = normalizeField(property.field);
-		return normalized === reference || normalized.endsWith(reference) || reference.endsWith(normalized);
-	});
-}
-function normalizeField(value) {
-	return value.replace(/\[locale\]/g, "").replace(/\[\]/g, "").replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
-}
 
 //#endregion
 //#region src/services/backendRouteExtractionService.ts
@@ -3077,16 +3319,7 @@ function extractBackendRouteCandidates(params) {
 }
 
 //#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
+//#region src/utils/path/pathNormalization.ts
 function normalizePathForMatch(value) {
 	return value.replace(/\[\]/g, "").replace(/\{[^}]+\}/g, "").replace(/[^a-z0-9]/gi, "").toLowerCase();
 }
@@ -4008,8 +4241,8 @@ async function analyzeCodebaseRouteContracts(params) {
 			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;
+	const routeDeclarationsByKey = dedupeByKey(routeDeclarations, (item) => stableKey(item.method, item.path, item.file, item.handlerRef || ""));
+	const selectedRouteDeclarations = selectedRouteKeys ? routeDeclarationsByKey.filter((route) => selectedRouteKeys.has(stableKey(route.method, route.path))) : routeDeclarationsByKey;
 	taskProgressService.log(`${selectedRouteDeclarations.length} route definitions selected from ${routeDeclarationsByKey.length} discovered`);
 	const documents = [];
 	const dependencyFilesByHandler = /* @__PURE__ */ new Map();
@@ -4028,7 +4261,7 @@ async function analyzeCodebaseRouteContracts(params) {
 		const routeLabel = `[${index + 1}/${selectedRouteDeclarations.length}] - ${routeDeclaration.method} ${routeDeclaration.path}`;
 		taskProgressService.log(`${routeLabel} ...`);
 		await yieldToEventLoop();
-		const routeKey = stableKey$2(routeDeclaration.method, routeDeclaration.path);
+		const routeKey = stableKey(routeDeclaration.method, routeDeclaration.path);
 		const routeContract = routeContracts?.get(routeKey);
 		const operation = swagger?.paths?.[routeDeclaration.path]?.[routeDeclaration.method.toLowerCase()];
 		if (!routeContract && (!operation || !swagger)) continue;
@@ -4208,7 +4441,7 @@ function resolveApiPropertySource(document, property, direction, matches = []) {
 	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 key = stableKey(document.key, candidate.backend, candidate.route);
 	const existing = backendRoutesByKey.get(key);
 	if (existing) return existing;
 	const created = {
@@ -4288,7 +4521,7 @@ async function buildCatalogue(documents) {
 		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 apiPropertyKey = stableKey(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);
@@ -4308,13 +4541,13 @@ async function buildCatalogue(documents) {
 				evidence_status: evidenceStatus
 			});
 			if (!matches.length && !isTransverseWithoutMapping) mappingEvidence.push({
-				key: stableKey$2(apiPropertyKey, "needs_review"),
+				key: stableKey(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),
+				backend_property_key: stableKey(document.key, "unmatched", "input", property.path),
 				source_file: document.routeFile || null
 			});
 			for (const match of matches) {
@@ -4323,7 +4556,7 @@ async function buildCatalogue(documents) {
 					route: "unknown",
 					sourceFile: match.sourceFile
 				}).key;
-				const backendPropertyKey = stableKey$2(backendRouteKey, "input", match.resolvedProperty?.field || match.backendField);
+				const backendPropertyKey = stableKey(backendRouteKey, "input", match.resolvedProperty?.field || match.backendField);
 				backendPropertiesByKey.set(backendPropertyKey, {
 					key: backendPropertyKey,
 					backend_route_key: backendRouteKey,
@@ -4336,7 +4569,7 @@ async function buildCatalogue(documents) {
 					provenance: "code_analysis"
 				});
 				mappingEvidence.push({
-					key: stableKey$2(apiPropertyKey, backendPropertyKey),
+					key: stableKey(apiPropertyKey, backendPropertyKey),
 					evidence_type: "static_analysis",
 					status: match.requiresReview ? "needs_review" : match.confidence >= 90 ? "confirmed" : "inferred",
 					confidence_score: match.confidence,
@@ -4351,7 +4584,7 @@ async function buildCatalogue(documents) {
 			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 apiPropertyKey = stableKey(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) => toBackendMapping(document, match)), (mapping) => `${mapping.backend}:${mapping.document || ""}:${mapping.method || "CALL"}:${mapping.route || ""}:${mapping.field}:${mapping.source_file}`);
@@ -4370,13 +4603,13 @@ async function buildCatalogue(documents) {
 				...matches.length ? {} : { unresolved_backend_candidates: unresolvedBackendCandidates(property, apiSource?.domainField, document, "output") }
 			});
 			if (!matches.length) mappingEvidence.push({
-				key: stableKey$2(apiPropertyKey, "needs_review"),
+				key: stableKey(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),
+				backend_property_key: stableKey(document.key, "unmatched", "output", property.path),
 				source_file: document.routeFile || null
 			});
 			for (const match of matches) {
@@ -4385,7 +4618,7 @@ async function buildCatalogue(documents) {
 					route: "unknown",
 					sourceFile: match.sourceFile
 				}).key;
-				const backendPropertyKey = stableKey$2(backendRouteKey, "output", match.resolvedProperty?.field || match.backendField);
+				const backendPropertyKey = stableKey(backendRouteKey, "output", match.resolvedProperty?.field || match.backendField);
 				backendPropertiesByKey.set(backendPropertyKey, {
 					key: backendPropertyKey,
 					backend_route_key: backendRouteKey,
@@ -4398,7 +4631,7 @@ async function buildCatalogue(documents) {
 					provenance: "code_analysis"
 				});
 				mappingEvidence.push({
-					key: stableKey$2(apiPropertyKey, backendPropertyKey),
+					key: stableKey(apiPropertyKey, backendPropertyKey),
 					evidence_type: "static_analysis",
 					status: match.requiresReview ? "needs_review" : match.confidence >= 90 ? "confirmed" : "inferred",
 					confidence_score: match.confidence,
@@ -4437,239 +4670,13 @@ async function buildCatalogue(documents) {
 }
 
 //#endregion
-//#region src/services/directus/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$3(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isServiceUnavailableError(error) {
-	if (!isRecord$3(error)) return false;
-	if ((isRecord$3(error.response) ? error.response.status : void 0) === 503) return true;
-	return Array.isArray(error.errors) && error.errors.some((item) => isRecord$3(item) && isRecord$3(item.extensions) && item.extensions.code === "SERVICE_UNAVAILABLE");
-}
-function isTransientNetworkError(error) {
-	if (error instanceof TypeError && error.message === "fetch failed") return true;
-	if (!isRecord$3(error)) return false;
-	if (error.message === "fetch failed") return true;
-	const cause = isRecord$3(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, ".");
-}
+//#region src/utils/string/toPascalCase.ts
 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 = t$1(baseUrl).with(r()).with(e$3(token));
-	return { request: (request) => retryDirectusRequest(() => client.request(request)) };
-}
-function directusReadItems(collection, query) {
-	return n$1(collection, query);
-}
-function directusCreateItem(collection, payload) {
-	return n$2(collection, payload);
-}
-function directusUpdateItem(collection, id, payload) {
-	return i(collection, id, payload);
-}
-function directusDeleteItem(collection, id) {
-	return r$1(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
-	};
+	return value.toLowerCase().replace(/(^|[^a-z0-9]+)([a-z0-9])/g, (_match, _separator, character) => character.toUpperCase());
 }
+
+//#endregion
+//#region src/services/directus/queries/resolveBackendReference.ts
 async function resolveBackendReference(client, references, backend) {
 	const lookupKey = normalizeLookupKey(backend);
 	const existingId = references.backendIds.get(lookupKey);
@@ -4678,7 +4685,7 @@ async function resolveBackendReference(client, references, backend) {
 		created: false
 	};
 	if (!isKnownBackendType(backend)) return { created: false };
-	const created = await client.request(directusCreateItem("predefined_values", {
+	const created = await client.request(n$2("predefined_values", {
 		id: backend,
 		label: toPascalCase(backend),
 		type: "backend"
@@ -4690,42 +4697,72 @@ async function resolveBackendReference(client, references, backend) {
 		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"],
+
+//#endregion
+//#region src/services/directus/utils/normalizeDirectusPath.ts
+function normalizeDirectusPath(value) {
+	return value.replace(/\?\.\[/g, "[").replace(/\?\./g, ".");
+}
+
+//#endregion
+//#region src/services/directus/queries/upsertBackendProperty.ts
+async function upsertBackendProperty(client, property, backendRouteId, typeId) {
+	const path = normalizeDirectusPath(property.field);
+	const [existing] = await client.request(n$1("backend_properties", {
+		filter: {
+			route: { _eq: backendRouteId },
+			path: { _eq: path },
+			type: { _eq: typeId }
+		},
+		fields: ["id"],
 		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;
+	if (existing) return existing.id;
+	const created = await client.request(n$2("backend_properties", {
+		route: backendRouteId,
+		path: path || null,
+		type: typeId,
+		source_file: property.source_file || null,
+		comments: property.provenance === "ai" ? "Inferred with AI" : null,
+		content_name: null
+	}));
+	return typeof created === "string" ? created : created.id;
+}
+
+//#endregion
+//#region src/services/directus/utils/toBackendRouteIdentifier.ts
+function toBackendRouteIdentifier(route) {
+	return `${route.method} ${route.path}`;
+}
+
+//#endregion
+//#region src/services/directus/queries/upsertBackendRoute.ts
+async function upsertBackendRoute(client, apiRoute, backendValueId) {
+	const route = toBackendRouteIdentifier(apiRoute);
+	const [existing] = await client.request(n$1("backend_routes", {
+		filter: { route: { _eq: route } },
+		fields: ["id"],
+		limit: 1
+	}));
+	if (existing) return existing.id;
+	const created = await client.request(n$2("backend_routes", {
+		route,
+		backend: backendValueId
+	}));
+	return typeof created === "string" ? created : created.id;
 }
+
+//#endregion
+//#region src/services/directus/queries/upsertInputProperty.ts
 async function upsertInputProperty(client, property, routeId, inType) {
 	const field = normalizeDirectusPath(property.field);
-	const [existing] = await client.request(directusReadItems("route_input_properties", {
+	const [existing] = await client.request(n$1("route_input_properties", {
 		filter: {
 			route_id: { _eq: routeId },
 			path: { _eq: field },
 			in_type: { _eq: inType }
 		},
-		fields: [
-			"id",
-			"route_id",
-			"path",
-			"in_type"
-		],
+		fields: ["id"],
 		limit: 1
 	}));
 	const payload = {
@@ -4733,30 +4770,28 @@ async function upsertInputProperty(client, property, routeId, inType) {
 		path: field,
 		in_type: inType,
 		description: property.description || null,
-		source_file: property.source_file || LOCAL_SOURCE_FILE,
+		source_file: property.source_file || null,
 		deprecated: false
 	};
 	if (!existing) {
-		const created = await client.request(directusCreateItem("route_input_properties", payload));
+		const created = await client.request(n$2("route_input_properties", payload));
 		return typeof created === "string" ? created : created.id;
 	}
-	await client.request(directusUpdateItem("route_input_properties", existing.id, payload));
+	await client.request(i("route_input_properties", existing.id, payload));
 	return existing.id;
 }
+
+//#endregion
+//#region src/services/directus/queries/upsertOutputProperty.ts
 async function upsertOutputProperty(client, property, routeId, outType) {
 	const field = normalizeDirectusPath(property.field);
-	const [existing] = await client.request(directusReadItems("route_output_properties", {
+	const [existing] = await client.request(n$1("route_output_properties", {
 		filter: {
 			route_id: { _eq: routeId },
 			path: { _eq: field },
 			out_type: { _eq: outType }
 		},
-		fields: [
-			"id",
-			"route_id",
-			"path",
-			"out_type"
-		],
+		fields: ["id"],
 		limit: 1
 	}));
 	const payload = {
@@ -4764,101 +4799,110 @@ async function upsertOutputProperty(client, property, routeId, outType) {
 		path: field,
 		out_type: outType,
 		description: property.description || null,
-		source_file: property.source_file || LOCAL_SOURCE_FILE,
+		source_file: property.source_file || null,
 		deprecated: false,
 		is_dynamic: field.includes("[]") || field.includes("{")
 	};
 	if (!existing) {
-		const created = await client.request(directusCreateItem("route_output_properties", payload));
+		const created = await client.request(n$2("route_output_properties", payload));
 		return typeof created === "string" ? created : created.id;
 	}
-	await client.request(directusUpdateItem("route_output_properties", existing.id, payload));
+	await client.request(i("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"
-		],
+
+//#endregion
+//#region src/services/directus/utils/buildTranslationSummary.ts
+function buildTranslationSummary(route) {
+	const routeIdentifier = toBackendRouteIdentifier(route);
+	const primarySource = route.analysis_files[0] || route.source_file;
+	return [{
+		languages_code: "en-US",
+		summary: routeIdentifier,
+		description: primarySource ? `Generated from ${path.basename(primarySource)}` : "Generated by Atlas"
+	}];
+}
+
+//#endregion
+//#region src/services/directus/queries/upsertRoute.ts
+async function upsertRoute(client, route) {
+	const routeIdentifier = toBackendRouteIdentifier(route);
+	const [existing] = await client.request(n$1("routes", {
+		filter: { route: { _eq: routeIdentifier } },
+		fields: ["id"],
 		limit: 1
 	}));
 	const payload = {
-		route: routeValue,
-		backend: backendValueId
+		route: routeIdentifier,
+		status: "published",
+		deprecated: false,
+		first_published_version: route.version,
+		last_published_version: route.version,
+		translations: buildTranslationSummary(route)
 	};
 	if (!existing) {
-		const created = await client.request(directusCreateItem("backend_routes", payload));
+		const created = await client.request(n$2("routes", payload));
 		return typeof created === "string" ? created : created.id;
 	}
+	await client.request(i("routes", existing.id, payload));
 	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;
+
+//#endregion
+//#region src/services/directus/utils/groupBackendRoutesForDirectusSync.ts
+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}\0${apiRoute.method}\0${apiRoute.path}` : `${backendRoute.backend}\0missing-api-route\0${backendRoute.key}`;
+		const group = groups.get(key);
+		if (group) group.keys.push(backendRoute.key);
+		else groups.set(key, {
+			route: backendRoute,
+			keys: [backendRoute.key]
+		});
 	}
-	return existing.id;
+	return [...groups.values()];
 }
-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;
+
+//#endregion
+//#region src/services/directus/utils/inferInputType.ts
+function inferInputType(field) {
+	if (field.startsWith("params.")) return "PATH";
+	if (field.startsWith("query.")) return "QUERY";
+	if (field.startsWith("headers.")) return "HEADER";
+	return "BODY";
 }
-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;
+
+//#endregion
+//#region src/services/directus/utils/selectCatalogueForDirectusPush.ts
+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))
+	};
 }
+
+//#endregion
+//#region src/services/directus/pushCatalogueToDirectus.ts
 async function pushCatalogueToDirectus(catalogue, options) {
 	const pushedCollections = [
 		"predefined_values",
@@ -4883,7 +4927,7 @@ async function pushCatalogueToDirectus(catalogue, options) {
 		};
 	}
 	taskProgressService.report("Connecting to Directus");
-	const client = await createClient(options.baseUrl, options.token);
+	const client = await createClient();
 	taskProgressService.report("Loading predefined values from Directus");
 	const refs = await loadDirectusReferenceData(client);
 	const warnings = /* @__PURE__ */ new Set();
@@ -4917,7 +4961,7 @@ async function pushCatalogueToDirectus(catalogue, options) {
 				continue;
 			}
 			if (backendReference.created) pushedItems += 1;
-			const backendRouteId = await upsertBackendRoute(client, route, backendRoute, backendReference.id);
+			const backendRouteId = await upsertBackendRoute(client, route, backendReference.id);
 			for (const key of keys) backendRouteIds.set(key, backendRouteId);
 			pushedItems += 1;
 		}
@@ -11724,7 +11768,7 @@ var require_dist$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region src/utils/routeReview.ts
+//#region src/utils/route/routeReview.ts
 var import_dist$1 = require_dist$1();
 function sanitizePathSegment(value) {
 	return value.replace(/[{}]/g, "").replace(/[^a-z0-9._-]+/gi, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || "root";
@@ -11898,9 +11942,6 @@ function relativizeRouteReviewDocument(document, repoRoot) {
 
 //#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}`);
@@ -11932,7 +11973,7 @@ async function writeCatalogueArtifacts(catalogue, outputDir, repoRoot = process.
 }
 function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backendRoutesByKey, backendPropertiesByKey, mappingEvidence) {
 	const backendRoute = mapping.route || (mapping.document ? `DOCUMENT ${mapping.document}` : "unknown");
-	const backendRouteKey = stableKey$1(routeKey, mapping.backend, backendRoute);
+	const backendRouteKey = stableKey(routeKey, mapping.backend, backendRoute);
 	const backendRouteRecord = backendRoutesByKey.get(backendRouteKey) || {
 		key: backendRouteKey,
 		backend: mapping.backend,
@@ -11942,7 +11983,7 @@ function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backend
 		provenance: "code_analysis"
 	};
 	backendRoutesByKey.set(backendRouteKey, backendRouteRecord);
-	const backendPropertyKey = stableKey$1(backendRouteKey, direction, mapping.field);
+	const backendPropertyKey = stableKey(backendRouteKey, direction, mapping.field);
 	backendPropertiesByKey.set(backendPropertyKey, {
 		key: backendPropertyKey,
 		backend_route_key: backendRouteKey,
@@ -11953,7 +11994,7 @@ function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backend
 		provenance: mapping.provenance || "code_analysis"
 	});
 	mappingEvidence.push({
-		key: stableKey$1(apiPropertyKey, backendPropertyKey),
+		key: stableKey(apiPropertyKey, backendPropertyKey),
 		evidence_type: mapping.provenance === "ai" ? "inference" : "static_analysis",
 		status: mapping.confidence >= 90 ? "confirmed" : "inferred",
 		confidence_score: mapping.confidence,
@@ -11980,7 +12021,7 @@ function toCatalogueBackendMapping(mapping) {
 }
 function addDatasourceRoute(routeKey, datasource, backendRoutesByKey) {
 	const backendRoute = datasource.operation?.route || "unknown";
-	const backendRouteKey = stableKey$1(routeKey, datasource.type, backendRoute);
+	const backendRouteKey = stableKey(routeKey, datasource.type, backendRoute);
 	backendRoutesByKey.set(backendRouteKey, {
 		key: backendRouteKey,
 		backend: datasource.type,
@@ -12000,7 +12041,7 @@ function mergeRouteReviewDocuments(documents) {
 	const rules = [];
 	const aggregations = [];
 	for (const document of documents) {
-		const routeKey = stableKey$1(document.route.method, document.route.path);
+		const routeKey = stableKey(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({
@@ -12015,7 +12056,7 @@ function mergeRouteReviewDocuments(documents) {
 		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 apiPropertyKey = stableKey(routeKey, direction, property.field);
 				const backendMappings = property.mapping?.backends?.map(toCatalogueBackendMapping) || [];
 				const catalogueProperty = {
 					key: apiPropertyKey,
@@ -12110,21 +12151,16 @@ async function readCatalogueFromDirectory(inputDir) {
 }
 
 //#endregion
-//#region src/services/directus/directusPushService.ts
+//#region src/services/directus/pushCatalogueDirectoryToDirectus.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
 		})
@@ -12132,7 +12168,13 @@ async function pushCatalogueDirectoryToDirectus(params) {
 }
 
 //#endregion
-//#region src/utils/routeSelector.ts
+//#region src/utils/route/isRouteSelector.ts
+function isRouteSelector(value) {
+	return /^[A-Z]+\s+\//i.test(value.trim());
+}
+
+//#endregion
+//#region src/utils/route/routeSelector.ts
 function parseRouteSelector(value) {
 	if (!value) return;
 	const match = value.trim().match(/^([A-Z]+)\s+(\S+)$/i);
@@ -12146,18 +12188,12 @@ function parseRouteSelector(value) {
 //#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$2(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function formatPushError(error) {
 	if (error instanceof Error) return error.message;
-	if (!isRecord$2(error)) return String(error);
+	if (!isRecord$1(error)) return String(error);
 	const details = (Array.isArray(error.errors) ? error.errors : []).flatMap((item) => {
-		if (!isRecord$2(item) || typeof item.message !== "string") return [];
-		return [`${isRecord$2(item.extensions) && typeof item.extensions.code === "string" ? `${item.extensions.code}: ` : ""}${item.message}`];
+		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;
@@ -12219,20 +12255,18 @@ function createPushStepClassifier() {
 		};
 	};
 }
-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) => {
+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("--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;
+		const positionalRouteSelector = isRouteSelector(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
 		}));
@@ -12344,9 +12378,6 @@ async function writeBackendTopologyArtifact(artifact, outputDir) {
 	await fsPromises.writeFile(filePath, `${(0, import_dist$1.stringify)(artifact, { aliasDuplicateObjects: false })}\n`, "utf8");
 	return filePath;
 }
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function parseBackendTopologyArtifact(value, expectedMethod, expectedPath, filePath) {
 	if (!isRecord$1(value) || value.schema_version !== 3) throw new Error(`Invalid backend graph artifact schema: ${filePath}. Run generate:graph again.`);
 	const route = value.route;
@@ -12426,7 +12457,7 @@ async function generateHandler(cwd, routeArgument, options) {
 			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 selectedRouteKeys = routeSelector ? /* @__PURE__ */ new Set([stableKey(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");
@@ -12492,12 +12523,16 @@ var generate_default = (program) => void program.command("generate:catalog").arg
 });
 
 //#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;
+//#region src/utils/number/parsePositiveInteger.ts
+function parsePositiveInteger(value, message = "Expected a positive integer") {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(message);
+	return parsed;
 }
+
+//#endregion
+//#region src/commands/generateGraph.ts
+const parseWorkerCount$1 = (value) => parsePositiveInteger(value, "Worker count must be a positive integer");
 async function generateGraphHandler(cwd, routeArgument, options) {
 	intro("Code source Graph generation");
 	const progress$2 = taskProgressService.createStepProgress((message) => {
@@ -12573,6 +12608,12 @@ var generateGraph_default = (program) => void program.command("generate:graph").
 	return generateGraphHandler(cwd, routeArgument, options);
 });
 
+//#endregion
+//#region src/utils/number/formatPercentage.ts
+function formatPercentage(value, fractionDigits = 2) {
+	return `${value.toFixed(fractionDigits)}%`;
+}
+
 //#endregion
 //#region src/services/catalogueCoverageService.ts
 /**
@@ -12595,7 +12636,7 @@ function validateCoverage(coverage, catalogues) {
 	});
 }
 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");
+	return ["Coverage regression detected:", ...results.filter((result) => !result.passed).map((result) => `- ${result.route}: ${formatPercentage(result.actual)} is below ${formatPercentage(result.expected)}`)].join("\n");
 }
 
 //#endregion
@@ -12620,13 +12661,13 @@ async function generateTestHandler(cwd) {
 		}, () => analyzeCodebaseRouteContracts({
 			cwd,
 			openApiDocument,
-			selectedRouteKeys: /* @__PURE__ */ new Set([buildRouteKey(routeSelector.method, routeSelector.path)])
+			selectedRouteKeys: /* @__PURE__ */ new Set([stableKey(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"));
+	log.message(results.map((result) => `${result.passed ? "✓" : "✗"} ${result.route}: ${formatPercentage(result.actual)} (minimum ${formatPercentage(result.expected)})`).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 () => {
@@ -12642,6 +12683,25 @@ var generateTest_default = (program) => void program.command("generate:test").de
 	}
 });
 
+//#endregion
+//#region src/utils/collection/forEachWithConcurrency.ts
+async function forEachWithConcurrency(items, workers, task) {
+	let nextIndex = 0;
+	const workerCount = Math.min(Math.max(1, workers), items.length);
+	await Promise.all(Array.from({ length: workerCount }, async (_, workerId) => {
+		while (nextIndex < items.length) {
+			const item = items[nextIndex++];
+			await task(item, workerId);
+		}
+	}));
+}
+
+//#endregion
+//#region src/utils/source/formatSourceLocation.ts
+function formatSourceLocation(sourceFile, sourceLine) {
+	return sourceLine ? `${sourceFile}:${sourceLine}` : sourceFile;
+}
+
 //#endregion
 //#region ../../node_modules/@ai-sdk/provider/dist/index.js
 var marker$2 = "vercel.ai.error";
@@ -27940,6 +28000,25 @@ var originalGenerateCallId6 = createIdGenerator({
 });
 var defaultDownload2 = createDownload();
 
+//#endregion
+//#region src/utils/collection/chunk.ts
+function chunk(items, size) {
+	if (!Number.isInteger(size) || size <= 0) throw new Error("Chunk size must be a positive integer");
+	return Array.from({ length: Math.ceil(items.length / size) }, (_, index) => items.slice(index * size, (index + 1) * size));
+}
+
+//#endregion
+//#region src/utils/path/normalizeFieldPath.ts
+function normalizeFieldPath(value) {
+	return (value || "").replace(/\[\]/g, "").replace(/[^a-zA-Z0-9.]/g, "").toLowerCase();
+}
+
+//#endregion
+//#region src/utils/path/getTerminalField.ts
+function getTerminalField(value) {
+	return normalizeFieldPath(value).split(".").filter(Boolean).at(-1) || "";
+}
+
 //#endregion
 //#region ../../node_modules/@ai-sdk/openai-compatible/dist/index.js
 function toCamelCase(str) {
@@ -29359,38 +29438,32 @@ 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 propertySegments = normalizeFieldPath(property.field).split(".").filter(Boolean);
+	const domainSegments = normalizeFieldPath(property.domainField).split(".").filter(Boolean);
 	const propertyTerminal = propertySegments.at(-1) || "";
 	const propertyRoot = propertySegments[0] || "";
-	const backendTerminal = terminalFieldForRanking(candidate.backendField);
-	const apiPathTerminal = terminalFieldForRanking(candidate.apiPathCandidate);
+	const backendTerminal = getTerminalField(candidate.backendField);
+	const apiPathTerminal = getTerminalField(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);
+		const apiPath = normalizeFieldPath(candidate.apiPathCandidate);
+		const backendTerminal = getTerminalField(candidate.backendField);
 		return {
 			candidate,
 			index,
 			relevance: Math.max(...properties.map((property) => {
-				const field = normalizeFieldForRanking(property.field);
-				const terminal = terminalFieldForRanking(property.field);
+				const field = normalizeFieldPath(property.field);
+				const terminal = getTerminalField(property.field);
 				if (apiPath && (apiPath.endsWith(field) || field.endsWith(apiPath))) return 1e3;
 				if (terminal && backendTerminal === terminal) return 100;
 				return 0;
@@ -29446,7 +29519,7 @@ async function buildPrompt(document, properties) {
 		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,
+		source_file: formatSourceLocation(candidate.sourceFile, candidate.sourceLine),
 		static_confidence: candidate.confidence
 	}));
 	const sourceExcerpts = await readSourceExcerpts(document);
@@ -29585,9 +29658,6 @@ function parseSuggestions(content, document, properties, minimumConfidence) {
 		}
 	};
 }
-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: [],
@@ -29613,7 +29683,7 @@ async function inferMissingMappings(document, properties, config) {
 		apiKey: process.env.LITELLM_API_KEY
 	});
 	const results = [];
-	for (const batch of chunkProperties(properties)) {
+	for (const batch of chunk(properties, PROPERTIES_PER_BATCH)) {
 		const scopedDocument = scopeCandidatesToProperties(document, batch);
 		let content;
 		try {
@@ -29663,11 +29733,8 @@ async function inferMissingMappings(document, properties, config) {
 
 //#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;
+	return formatSourceLocation(candidate.sourceFile, candidate.sourceLine);
 }
 function findBackendRoute(document, suggestion) {
 	const candidates = document.backendRouteCandidates.filter((candidate) => candidate.backend === suggestion.candidate.backend);
@@ -29791,15 +29858,6 @@ function refreshStats(catalogue) {
 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);
@@ -29808,7 +29866,8 @@ async function inferCatalogueDirectory(params) {
 	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;
+	const routeSelector = params.routeSelector;
+	const selectedRoute = routeSelector ? catalogue.routes.find((route) => matchesRouteSelector(route, routeSelector)) : 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;
@@ -29876,7 +29935,7 @@ async function inferCatalogueDirectory(params) {
 		duplicate: 0,
 		candidate_mismatch: 0
 	};
-	await runWithConcurrency(routeKeys, Math.min(params.inference.workers, 10), async (routeKey, workerId) => {
+	await forEachWithConcurrency(routeKeys, Math.min(params.inference.workers, 10), async (routeKey, workerId) => {
 		const route = catalogue.routes.find((item) => item.key === routeKey);
 		const reportRoute = (phase) => {
 			params.onWorkerProgress?.({
@@ -30029,6 +30088,14 @@ async function inferCatalogueDirectory(params) {
 	};
 }
 
+//#endregion
+//#region src/utils/number/parsePositiveNumber.ts
+function parsePositiveNumber(value, message = "Expected a positive number") {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(message);
+	return parsed;
+}
+
 //#endregion
 //#region src/commands/infer.ts
 function createInferenceStepClassifier() {
@@ -30056,11 +30123,6 @@ function createInferenceStepClassifier() {
 		};
 	};
 }
-function parsePositiveNumber(value) {
-	const parsed = Number(value);
-	if (!Number.isFinite(parsed) || parsed <= 0) throw new InvalidArgumentError$2("Expected a positive number");
-	return parsed;
-}
 function parseConfidence(value) {
 	const parsed = parsePositiveNumber(value);
 	if (parsed > 100) throw new InvalidArgumentError$2("Confidence must be between 1 and 100");
@@ -30071,7 +30133,7 @@ function parseWorkerCount(value) {
 	if (workers > 10) throw new InvalidArgumentError$2("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) => {
+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", (value) => parsePositiveNumber(value)).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;
@@ -30250,11 +30312,6 @@ async function buildNeedsReviewRouteReport(params) {
 
 //#endregion
 //#region src/commands/needsReview.ts
-function parsePositiveInteger(value) {
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed <= 0) throw new InvalidArgumentError$2("Expected a positive integer");
-	return parsed;
-}
 function formatNeedsReviewTable(rows) {
 	const headers = [
 		"#",
@@ -30272,7 +30329,7 @@ function formatNeedsReviewTable(rows) {
 		String(row.outputNeedsReview),
 		String(row.inputProperties + row.outputProperties),
 		String(row.needsReview),
-		`${row.needsReviewPercentage.toFixed(2)}%`
+		formatPercentage(row.needsReviewPercentage)
 	]);
 	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(" | ");
@@ -30282,7 +30339,7 @@ function formatNeedsReviewTable(rows) {
 		...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) => {
+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", (value) => parsePositiveInteger(value)).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();
@@ -30307,7 +30364,7 @@ var needsReview_default = (program) => void program.command("needs-review").argu
 			`Candidate routes: ${report.candidateRoutes}/${report.totalRoutes}`,
 			`Properties: ${report.totalProperties}`,
 			`Needs review: ${report.needsReview}`,
-			`Needs review percentage: ${report.needsReviewPercentage.toFixed(2)}%`,
+			`Needs review percentage: ${formatPercentage(report.needsReviewPercentage)}`,
 			options.limit ? `Rows displayed: ${report.rows.length}/${report.candidateRoutes}` : null
 		].filter(Boolean).join("\n"), "Summary");
 		outro("Datasource catalogue needs review report completed");
@@ -30326,9 +30383,6 @@ function sortPropertiesByStatus(properties) {
 		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;
@@ -30338,9 +30392,6 @@ 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 fsPromises.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,
@@ -30360,7 +30411,7 @@ async function readRouteGraphs(outputDirectory) {
 }
 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_ | — | — |";
+	const routeRows = params.routes.length ? params.routes.map((route) => `| ${route.method} ${route.path} | ${formatPercentage(route.coverage)} | ${route.needsReview}/${route.fields} |`).join("\n") : "| _Aucune route impactée_ | — | — |";
 	return [
 		"<!-- datasource-catalogue-report -->",
 		"## Datasource mapping report",
@@ -30415,6 +30466,12 @@ function renderChangedRouteReport(params) {
 	].join("\n");
 }
 
+//#endregion
+//#region src/utils/fs/readChangedFiles.ts
+async function readChangedFiles(filePath) {
+	return (await fsPromises.readFile(filePath, "utf8")).split(/\r?\n/).map((line) => normalizeFilePath(line.trim())).filter(Boolean);
+}
+
 //#endregion
 //#region src/commands/reportChanged.ts
 async function reportChangedHandler(cwd, options) {
@@ -30432,7 +30489,7 @@ async function reportChangedHandler(cwd, options) {
 			const documents = await analyzeCodebaseRouteContracts({
 				cwd,
 				openApiDocument,
-				selectedRouteKeys: /* @__PURE__ */ new Set([buildRouteKey(route.method, route.path)]),
+				selectedRouteKeys: /* @__PURE__ */ new Set([stableKey(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");