@cmflow/atlas 3.4.0-beta.3 → 3.4.0-beta.5

package/README.md

@@ -50,13 +50,60 @@ The configuration imports `defineConfig` from Atlas:
 import { defineConfig } from "@cmflow/atlas";
 
 export default defineConfig({
-  backendTypesFile: "app/_infra/back/BackendTypes.ts",
+  backends: ["ICC", "CMS", "CMS_B2C"],
   openapiUrl: "https://api.example.com/openapi.json",
   openapiTimeoutMs: 60_000,
   directusUrl: "https://cms.api.clubmed"
 });
 ```
 
+Atlas reads `compilerOptions.paths` from the project's `tsconfig.json` and uses them as module aliases. Add `resolver.alias` only to override or complement those aliases.
+
+## Custom expression rules
+
+Use `defineExpressionRule` when a project-specific helper hides a backend field or wraps an expression that Atlas should follow. Add the rule to `analysis.rules` in `atlas.config.ts`.
+
+`match` is a cheap predicate that selects the `ts-morph` expression. `parse` returns the information Atlas should use: a backend field, a transparent wrapper, or both.
+
+```ts
+import { defineConfig, defineExpressionRule } from "@cmflow/atlas";
+import { Node } from "ts-morph";
+
+const localizedFieldRule = defineExpressionRule({
+  name: "localized-field",
+  match: (expression) =>
+    Node.isCallExpression(expression) && expression.getExpression().getText() === "localizedField",
+  parse: (expression) => {
+    if (!Node.isCallExpression(expression)) return undefined;
+
+    const [source, field] = expression.getArguments();
+    if (!source || !Node.isExpression(source) || !Node.isStringLiteral(field)) return undefined;
+
+    return { backendField: `${source.getText()}.${field.getLiteralValue()}` };
+  }
+});
+
+export default defineConfig({
+  // …other Atlas options
+  analysis: {
+    // …other analysis options
+    rules: [localizedFieldRule]
+  }
+});
+```
+
+For a wrapper that does not change the field path, return `transparent: true`:
+
+```ts
+const unwrapRule = defineExpressionRule({
+  name: "unwrap-api-value",
+  match: (expression) => Node.isCallExpression(expression) && expression.getExpression().getText() === "unwrap",
+  parse: () => ({ transparent: true })
+});
+```
+
+`parse` may also set `mapperType` to annotate the generated mapping, or `apiMapping: true` when the helper maps an API value rather than a backend value.
+
 Create a `.env.local` in the target API project when pushing to Directus:
 
 ```dotenv

package/dist/bin/atlas.mjs

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import { Command, InvalidArgumentError, Option } from "commander";
 import path from "node:path";
+import fs from "node:fs";
 import { pathToFileURL } from "node:url";
+import { Node, Project, SyntaxKind } from "ts-morph";
 import { cancel, intro, log, note, outro, progress, spinner } from "@clack/prompts";
-import fs from "node:fs/promises";
+import fs$1 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";
@@ -25,7 +25,20 @@ 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) {
+function getTsconfigAliases(repoRoot) {
+	const tsconfigPath = path.join(repoRoot, "tsconfig.json");
+	if (!fs.existsSync(tsconfigPath)) return {};
+	const paths = new Project({
+		tsConfigFilePath: tsconfigPath,
+		skipAddingFilesFromTsConfig: true
+	}).getCompilerOptions().paths ?? {};
+	return Object.fromEntries(Object.entries(paths).flatMap(([alias, targets]) => {
+		const target = targets?.[0];
+		if (!target) return [];
+		return [[alias.replace(/\/\*$/, ""), target.replace(/^\.\//, "").replace(/\/\*$/, "")]];
+	}));
+}
+async function loadAtlasConfig(configPath, projectRoot) {
 	const filePath = path.resolve(configPath);
 	try {
 		let mod;
@@ -34,11 +47,15 @@ async function loadAtlasConfig(configPath) {
 			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();
+		const repoRoot = projectRoot || config.repoRoot || process.cwd();
 		return {
 			...config,
 			repoRoot,
-			cwd: repoRoot
+			cwd: repoRoot,
+			resolver: { alias: {
+				...getTsconfigAliases(repoRoot),
+				...config.resolver?.alias
+			} }
 		};
 	} catch (error) {
 		throw new Error(`Unable to load Atlas configuration at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
@@ -375,18 +392,11 @@ function extractOpenApiOutputProperties(operation, swagger) {
 }
 //#endregion
 //#region src/services/backendTypeService.ts
-let knownBackendTypesCache = null;
+function getBackendTypes() {
+	return Object.fromEntries(getUserConfig().backends.map((backend) => [backend, backend]));
+}
 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);
+	return Object.hasOwn(getBackendTypes(), value);
 }
 //#endregion
 //#region src/services/backendSourceService.ts
@@ -481,7 +491,7 @@ function tryResolveWithExtensions(basePath) {
 	].filter((candidate) => Boolean(candidate));
 	for (const candidate of candidates) try {
 		const normalized = path.normalize(candidate);
-		if (fs$1.existsSync(normalized)) return normalized;
+		if (fs.existsSync(normalized)) return normalized;
 	} catch {
 		continue;
 	}
@@ -2349,7 +2359,7 @@ async function pushCatalogueToDirectus(catalogue, options) {
 			}
 		}
 	}
-	if (options.outputPath) await fs.appendFile(options.outputPath, "", "utf8");
+	if (options.outputPath) await fs$1.appendFile(options.outputPath, "", "utf8");
 	const removedOrphanedLinks = await cleanupOrphanedPropertyLinks(client);
 	taskProgressService.report("Finalizing Directus synchronization");
 	if (warnings.size) {
@@ -2545,12 +2555,12 @@ async function writeRouteReviewDocument(catalogue, outputDir, repoRoot, 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");
+	await fs$1.mkdir(path.dirname(filePath), { recursive: true });
+	await fs$1.writeFile(filePath, `${stringify(document)}\n`, "utf8");
 	return filePath;
 }
 async function writeRouteReviewDocuments(catalogue, outputDir, repoRoot) {
-	await fs.mkdir(outputDir, { recursive: true });
+	await fs$1.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);
@@ -2558,8 +2568,8 @@ async function writeRouteReviewDocuments(catalogue, outputDir, repoRoot) {
 	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 })));
+	await fs$1.mkdir(outputDir, { recursive: true });
+	await Promise.all(["catalogue.yaml", "catalogue.yml"].map((fileName) => fs$1.rm(path.join(outputDir, fileName), { force: true })));
 }
 async function writeCatalogueArtifacts(catalogue, outputDir, repoRoot = process.cwd()) {
 	await prepareCatalogueOutputDirectory(outputDir);
@@ -2737,7 +2747,7 @@ async function readCatalogueFromDirectory(inputDir) {
 	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"));
+			const parsed = parse(await fs$1.readFile(file, "utf8"));
 			if (parsed?.schema_version !== 1 || !parsed?.route?.method || !parsed?.route?.path) throw new Error(`Invalid route YAML document: ${file}`);
 			return parsed;
 		}))),
@@ -2931,8 +2941,8 @@ function buildBackendTopologyRelativePath(method, routePath) {
 }
 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");
+	await fs$1.mkdir(path.dirname(filePath), { recursive: true });
+	await fs$1.writeFile(filePath, `${stringify(artifact, { aliasDuplicateObjects: false })}\n`, "utf8");
 	return filePath;
 }
 function isRecord(value) {
@@ -2951,7 +2961,7 @@ async function loadBackendTopologyAnalysisScope(outputDir, cwd, method, routePat
 	const filePath = path.join(outputDir, buildBackendTopologyRelativePath(method, routePath));
 	let content;
 	try {
-		content = await fs.readFile(filePath, "utf8");
+		content = await fs$1.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;
@@ -2972,7 +2982,7 @@ async function loadBackendTopologyAnalysisScope(outputDir, cwd, method, routePat
 	const missingFiles = [];
 	await Promise.all(analysisFiles.map(async (analysisFile) => {
 		try {
-			await fs.access(analysisFile);
+			await fs$1.access(analysisFile);
 		} catch {
 			missingFiles.push(path.relative(cwd, analysisFile));
 		}
@@ -3432,7 +3442,7 @@ async function readSourceExcerpts(document) {
 	const excerpts = [];
 	let totalCharacters = 0;
 	for (const location of uniqueLocations) try {
-		const lines = (await fs.readFile(location.sourceFile, "utf8")).split("\n");
+		const lines = (await fs$1.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");
@@ -4159,13 +4169,10 @@ const configTemplate = `import { defineConfig } from "@cmflow/atlas";
 
 export default defineConfig({
   repoRoot: process.cwd(),
-  backendTypesFile: "app/_infra/back/BackendTypes.ts",
+  backends: [],
   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",
@@ -4201,18 +4208,18 @@ var init_default = (program, datasourceCommand) => void program.command("init").
 	const configDirectory = path.dirname(configPath);
 	intro("Initialize datasource configuration");
 	try {
-		await fs.mkdir(configDirectory, { recursive: true });
+		await fs$1.mkdir(configDirectory, { recursive: true });
 		if (!options.force) {
 			let exists = false;
 			try {
-				await fs.access(configPath);
+				await fs$1.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");
+		await fs$1.writeFile(configPath, configTemplate, "utf8");
 		outro(`Created ${configPath}`);
 	} catch (error) {
 		cancel(error instanceof Error ? error.message : String(error));
@@ -4345,7 +4352,7 @@ function collectImpactedRoutes(params) {
 	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);
+	return (await fs$1.readFile(filePath, "utf8")).split(/\r?\n/).map((line) => normalizeFilePath(line.trim())).filter(Boolean);
 }
 async function readRouteGraphs(outputDirectory) {
 	const graphFiles = await globby("**/*.graph.yaml", {
@@ -4353,7 +4360,7 @@ async function readRouteGraphs(outputDirectory) {
 		absolute: true
 	});
 	const graphs = await Promise.all(graphFiles.map(async (graphFile) => {
-		const document = parse(await fs.readFile(graphFile, "utf8"));
+		const document = parse(await fs$1.readFile(graphFile, "utf8"));
 		if (!isGraphDocument(document)) throw new Error(`Invalid graph document: ${graphFile}`);
 		return {
 			method: document.route.method,
@@ -4471,8 +4478,8 @@ async function reportChangedHandler(cwd, options) {
 		routes: coverages
 	});
 	const reportPath = path.resolve(cwd, options.report);
-	await fs.mkdir(path.dirname(reportPath), { recursive: true });
-	await fs.writeFile(reportPath, `${report}\n`, "utf8");
+	await fs$1.mkdir(path.dirname(reportPath), { recursive: true });
+	await fs$1.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) => {
@@ -4492,13 +4499,7 @@ 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
-	});
+	setUserConfig(await loadAtlasConfig(program.opts().config, program.opts().projectRoot));
 });
 init_default(program, program);
 generate_default(program);

package/dist/defineExpressionRule-Dfvzj6n2.mjs

@@ -0,0 +1,2 @@
+function e(e){return e}export{e as t};
+//# sourceMappingURL=defineExpressionRule-Dfvzj6n2.mjs.map

package/dist/defineExpressionRule-Dfvzj6n2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineExpressionRule-Dfvzj6n2.mjs","names":[],"sources":["../src/utils/defineExpressionRule.ts"],"sourcesContent":["import type { Expression } from \"ts-morph\";\nimport type { UserConfig } from \"../models/types\";\n\nexport type FieldExtractionRuleResult = {\n  backendField?: string;\n  transparent?: boolean;\n  mapperType?: string;\n  apiMapping?: boolean;\n};\n\nexport type FieldExtractionRule = {\n  name: string;\n  match: (expression: Expression, config: UserConfig) => boolean;\n  parse: (expression: Expression, config: UserConfig) => FieldExtractionRuleResult | undefined;\n};\n\nexport function defineExpressionRule(rule: FieldExtractionRule): FieldExtractionRule {\n  return rule;\n}\n"],"mappings":"AAgBA,SAAgB,EAAqB,EAAgD,CACnF,OAAO,CACT"}

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { r as defineExpressionRule, t as UserConfig } from "./types-DcvdOZ2j.mjs";
+//#region src/utils/defineConfig.d.ts
+declare function defineConfig(config: UserConfig): UserConfig;
+//#endregion
+export { type UserConfig, defineConfig, defineExpressionRule };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./defineExpressionRule-Dfvzj6n2.mjs";function t(e){return e}export{t as defineConfig,e as defineExpressionRule};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/utils/defineConfig.ts"],"sourcesContent":["import type { UserConfig } from \"../models/types\";\n\nexport function defineConfig(config: UserConfig): UserConfig {\n  return config;\n}\n"],"mappings":"wDAEA,SAAgB,EAAa,EAAgC,CAC3D,OAAO,CACT"}

package/dist/rules/cleanObjectRule.d.mts

@@ -0,0 +1,6 @@
+import { n as FieldExtractionRule } from "../types-DcvdOZ2j.mjs";
+//#region src/rules/cleanObjectRule.d.ts
+declare const cleanObjectRule: FieldExtractionRule;
+//#endregion
+export { cleanObjectRule };
+//# sourceMappingURL=cleanObjectRule.d.mts.map

package/dist/rules/cleanObjectRule.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";const n=e({name:`clean-object-wrapper`,match:e=>t.isCallExpression(e)&&/^(?:(?:MappingUtils\.)?cleanObject|clean)$/.test(e.getExpression().getText()),parse:()=>({transparent:!0})});export{n as cleanObjectRule};
+//# sourceMappingURL=cleanObjectRule.mjs.map

package/dist/rules/cleanObjectRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanObjectRule.mjs","names":[],"sources":["../../src/rules/cleanObjectRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nexport const cleanObjectRule = defineExpressionRule({\n  name: \"clean-object-wrapper\",\n  match: (expression) =>\n    Node.isCallExpression(expression) && /^(?:(?:MappingUtils\\.)?cleanObject|clean)$/.test(expression.getExpression().getText()),\n  parse: () => ({ transparent: true })\n});\n"],"mappings":"yFAGA,MAAa,EAAkB,EAAqB,CAClD,KAAM,uBACN,MAAQ,GACN,EAAK,iBAAiB,CAAU,GAAK,6CAA6C,KAAK,EAAW,cAAc,CAAC,CAAC,QAAQ,CAAC,EAC7H,WAAc,CAAE,YAAa,EAAK,EACpC,CAAC"}

package/dist/rules/cmsI18nFieldRule.d.mts

@@ -0,0 +1,12 @@
+import { n as FieldExtractionRule } from "../types-DcvdOZ2j.mjs";
+//#region src/rules/cmsI18nFieldRule.d.ts
+/**
+ * `CmsI18n#get`/`getAll` reads a localized field off the translations array passed to the
+ * constructor (e.g. `new CmsI18n(offer.translations)`). Resolving to `i18n.field` breaks
+ * domain-path matching downstream because the receiver name ("i18n") is not the domain root
+ * ("offer"); resolving through the constructor argument restores that root.
+ */
+declare const cmsI18nFieldRule: FieldExtractionRule;
+//#endregion
+export { cmsI18nFieldRule };
+//# sourceMappingURL=cmsI18nFieldRule.d.mts.map

package/dist/rules/cmsI18nFieldRule.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";function n(e){if(!t.isIdentifier(e))return;let n=(e.getSymbol()?.getDeclarations().find(t.isVariableDeclaration))?.getInitializer();if(!n||!t.isNewExpression(n)||n.getExpression().getText()!==`CmsI18n`)return;let r=n.getArguments()[0];return r&&t.isExpression(r)?r.getText():void 0}function r(e){if(!t.isCallExpression(e))return;let r=e.getExpression();if(!t.isPropertyAccessExpression(r)||![`get`,`getAll`].includes(r.getName()))return;let i=e.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));if(!i||!t.isStringLiteral(i)&&!t.isNoSubstitutionTemplateLiteral(i))return;let a=n(r.getExpression());return a?`${a}[locale].${i.getLiteralValue()}`:void 0}const i=e({name:`cms-i18n-field`,match:e=>!!r(e),parse:e=>{let t=r(e);return t?{backendField:t}:void 0}});export{i as cmsI18nFieldRule};
+//# sourceMappingURL=cmsI18nFieldRule.mjs.map

package/dist/rules/cmsI18nFieldRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmsI18nFieldRule.mjs","names":[],"sources":["../../src/rules/cmsI18nFieldRule.ts"],"sourcesContent":["import { type Expression, Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nconst CMS_I18N_CLASS_NAME = \"CmsI18n\";\n\nfunction resolveCmsI18nSource(receiver: Expression): string | undefined {\n  if (!Node.isIdentifier(receiver)) {\n    return undefined;\n  }\n\n  const declaration = receiver.getSymbol()?.getDeclarations().find(Node.isVariableDeclaration);\n  const initializer = declaration?.getInitializer();\n  if (!initializer || !Node.isNewExpression(initializer)) {\n    return undefined;\n  }\n\n  if (initializer.getExpression().getText() !== CMS_I18N_CLASS_NAME) {\n    return undefined;\n  }\n\n  const constructorArgument = initializer.getArguments()[0];\n  return constructorArgument && Node.isExpression(constructorArgument) ? constructorArgument.getText() : undefined;\n}\n\nfunction parseCmsI18nField(expression: Expression): string | undefined {\n  if (!Node.isCallExpression(expression)) {\n    return undefined;\n  }\n\n  const target = expression.getExpression();\n  if (!Node.isPropertyAccessExpression(target) || ![\"get\", \"getAll\"].includes(target.getName())) {\n    return undefined;\n  }\n\n  const field = expression\n    .getArguments()\n    .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n  if (!field || (!Node.isStringLiteral(field) && !Node.isNoSubstitutionTemplateLiteral(field))) {\n    return undefined;\n  }\n\n  const source = resolveCmsI18nSource(target.getExpression());\n  return source ? `${source}[locale].${field.getLiteralValue()}` : undefined;\n}\n\n/**\n * `CmsI18n#get`/`getAll` reads a localized field off the translations array passed to the\n * constructor (e.g. `new CmsI18n(offer.translations)`). Resolving to `i18n.field` breaks\n * domain-path matching downstream because the receiver name (\"i18n\") is not the domain root\n * (\"offer\"); resolving through the constructor argument restores that root.\n */\nexport const cmsI18nFieldRule = defineExpressionRule({\n  name: \"cms-i18n-field\",\n  match: (expression) => Boolean(parseCmsI18nField(expression)),\n  parse: (expression) => {\n    const backendField = parseCmsI18nField(expression);\n    return backendField ? { backendField } : undefined;\n  }\n});\n"],"mappings":"yFAKA,SAAS,EAAqB,EAA0C,CACtE,GAAI,CAAC,EAAK,aAAa,CAAQ,EAC7B,OAIF,IAAM,GADc,EAAS,UAAU,CAAC,EAAE,gBAAgB,CAAC,CAAC,KAAK,EAAK,qBAAqB,EAAA,EAC1D,eAAe,EAKhD,GAJI,CAAC,GAAe,CAAC,EAAK,gBAAgB,CAAW,GAIjD,EAAY,cAAc,CAAC,CAAC,QAAQ,IAAM,UAC5C,OAGF,IAAM,EAAsB,EAAY,aAAa,CAAC,CAAC,GACvD,OAAO,GAAuB,EAAK,aAAa,CAAmB,EAAI,EAAoB,QAAQ,EAAI,IAAA,EACzG,CAEA,SAAS,EAAkB,EAA4C,CACrE,GAAI,CAAC,EAAK,iBAAiB,CAAU,EACnC,OAGF,IAAM,EAAS,EAAW,cAAc,EACxC,GAAI,CAAC,EAAK,2BAA2B,CAAM,GAAK,CAAC,CAAC,MAAO,QAAQ,CAAC,CAAC,SAAS,EAAO,QAAQ,CAAC,EAC1F,OAGF,IAAM,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EACtG,GAAI,CAAC,GAAU,CAAC,EAAK,gBAAgB,CAAK,GAAK,CAAC,EAAK,gCAAgC,CAAK,EACxF,OAGF,IAAM,EAAS,EAAqB,EAAO,cAAc,CAAC,EAC1D,OAAO,EAAS,GAAG,EAAO,WAAW,EAAM,gBAAgB,IAAM,IAAA,EACnE,CAQA,MAAa,EAAmB,EAAqB,CACnD,KAAM,iBACN,MAAQ,GAAe,EAAQ,EAAkB,CAAU,EAC3D,MAAQ,GAAe,CACrB,IAAM,EAAe,EAAkB,CAAU,EACjD,OAAO,EAAe,CAAE,cAAa,EAAI,IAAA,EAC3C,CACF,CAAC"}

package/dist/rules/dateConversionRule.d.mts

@@ -0,0 +1,6 @@
+import { n as FieldExtractionRule } from "../types-DcvdOZ2j.mjs";
+//#region src/rules/dateConversionRule.d.ts
+declare const dateConversionRule: FieldExtractionRule;
+//#endregion
+export { dateConversionRule };
+//# sourceMappingURL=dateConversionRule.d.mts.map

package/dist/rules/dateConversionRule.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";const n=e({name:`date-utils-wrapper`,match:e=>t.isCallExpression(e)&&e.getExpression().getText().startsWith(`DateUtils.`),parse:()=>({transparent:!0})});export{n as dateConversionRule};
+//# sourceMappingURL=dateConversionRule.mjs.map

package/dist/rules/dateConversionRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateConversionRule.mjs","names":[],"sources":["../../src/rules/dateConversionRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nexport const dateConversionRule = defineExpressionRule({\n  name: \"date-utils-wrapper\",\n  match: (expression) => Node.isCallExpression(expression) && expression.getExpression().getText().startsWith(\"DateUtils.\"),\n  parse: () => ({ transparent: true })\n});\n"],"mappings":"yFAGA,MAAa,EAAqB,EAAqB,CACrD,KAAM,qBACN,MAAQ,GAAe,EAAK,iBAAiB,CAAU,GAAK,EAAW,cAAc,CAAC,CAAC,QAAQ,CAAC,CAAC,WAAW,YAAY,EACxH,WAAc,CAAE,YAAa,EAAK,EACpC,CAAC"}

package/dist/rules/lodashGetRule.d.mts

@@ -0,0 +1,6 @@
+import { n as FieldExtractionRule } from "../types-DcvdOZ2j.mjs";
+//#region src/rules/lodashGetRule.d.ts
+declare const lodashGetRule: FieldExtractionRule;
+//#endregion
+export { lodashGetRule };
+//# sourceMappingURL=lodashGetRule.d.mts.map

package/dist/rules/lodashGetRule.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";const n=e({name:`lodash-get`,match:e=>{if(!t.isCallExpression(e)||e.getExpression().getText()!==`get`)return!1;let n=e.getArguments()[1];return t.isStringLiteral(n)||t.isNoSubstitutionTemplateLiteral(n)},parse:e=>{if(!t.isCallExpression(e))return;let[n,r]=e.getArguments();if(!(!n||!t.isExpression(n)||!t.isStringLiteral(r)&&!t.isNoSubstitutionTemplateLiteral(r)))return{backendField:`${n.getText()}.${r.getLiteralValue()}`}}});export{n as lodashGetRule};
+//# sourceMappingURL=lodashGetRule.mjs.map

package/dist/rules/lodashGetRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lodashGetRule.mjs","names":[],"sources":["../../src/rules/lodashGetRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nexport const lodashGetRule = defineExpressionRule({\n  name: \"lodash-get\",\n  match: (expression) => {\n    if (!Node.isCallExpression(expression) || expression.getExpression().getText() !== \"get\") {\n      return false;\n    }\n\n    const path = expression.getArguments()[1];\n    return Node.isStringLiteral(path) || Node.isNoSubstitutionTemplateLiteral(path);\n  },\n  parse: (expression) => {\n    if (!Node.isCallExpression(expression)) {\n      return undefined;\n    }\n\n    const [object, path] = expression.getArguments();\n    if (!object || !Node.isExpression(object) || (!Node.isStringLiteral(path) && !Node.isNoSubstitutionTemplateLiteral(path))) {\n      return undefined;\n    }\n\n    return { backendField: `${object.getText()}.${path.getLiteralValue()}` };\n  }\n});\n"],"mappings":"yFAGA,MAAa,EAAgB,EAAqB,CAChD,KAAM,aACN,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,GAAK,EAAW,cAAc,CAAC,CAAC,QAAQ,IAAM,MACjF,MAAO,GAGT,IAAM,EAAO,EAAW,aAAa,CAAC,CAAC,GACvC,OAAO,EAAK,gBAAgB,CAAI,GAAK,EAAK,gCAAgC,CAAI,CAChF,EACA,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,EACnC,OAGF,GAAM,CAAC,EAAQ,GAAQ,EAAW,aAAa,EAC3C,MAAC,GAAU,CAAC,EAAK,aAAa,CAAM,GAAM,CAAC,EAAK,gBAAgB,CAAI,GAAK,CAAC,EAAK,gCAAgC,CAAI,GAIvH,MAAO,CAAE,aAAc,GAAG,EAAO,QAAQ,EAAE,GAAG,EAAK,gBAAgB,GAAI,CACzE,CACF,CAAC"}

package/dist/rules/mappingUtilityRule.d.mts

@@ -0,0 +1,6 @@
+import { n as FieldExtractionRule } from "../types-DcvdOZ2j.mjs";
+//#region src/rules/mappingUtilityRule.d.ts
+declare const mappingUtilityRule: FieldExtractionRule;
+//#endregion
+export { mappingUtilityRule };
+//# sourceMappingURL=mappingUtilityRule.d.mts.map

package/dist/rules/mappingUtilityRule.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";const n=new Set([`string`,`number`,`boolean`,`date`,`datetime`,`enum`,`array`,`object`]),r=e({name:`mapping-utility-wrapper`,match:(e,n)=>{if(!t.isCallExpression(e))return!1;let r=e.getExpression().getText();return n.analysis.neutralExpressionMatchers.some(e=>r.startsWith(e.prefix))},parse:(e,r)=>{if(!t.isCallExpression(e))return;let i=e.getExpression().getText(),a=r.analysis.neutralExpressionMatchers.find(e=>i.startsWith(e.prefix));return{transparent:!0,mapperType:i.split(`.`).find(e=>n.has(e)),apiMapping:a?.apiMapping??!1}}});export{r as mappingUtilityRule};
+//# sourceMappingURL=mappingUtilityRule.mjs.map

package/dist/rules/mappingUtilityRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappingUtilityRule.mjs","names":[],"sources":["../../src/rules/mappingUtilityRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nconst mapperTypes = new Set([\"string\", \"number\", \"boolean\", \"date\", \"datetime\", \"enum\", \"array\", \"object\"]);\n\nexport const mappingUtilityRule = defineExpressionRule({\n  name: \"mapping-utility-wrapper\",\n  match: (expression, config) => {\n    if (!Node.isCallExpression(expression)) return false;\n\n    const callee = expression.getExpression().getText();\n    return config.analysis.neutralExpressionMatchers.some((matcher) => callee.startsWith(matcher.prefix));\n  },\n  parse: (expression, config) => {\n    if (!Node.isCallExpression(expression)) return undefined;\n\n    const callee = expression.getExpression().getText();\n    const matcher = config.analysis.neutralExpressionMatchers.find((item) => callee.startsWith(item.prefix));\n    const mapperType = callee.split(\".\").find((segment) => mapperTypes.has(segment));\n\n    return {\n      transparent: true,\n      mapperType,\n      apiMapping: matcher?.apiMapping ?? false\n    };\n  }\n});\n"],"mappings":"yFAGA,MAAM,EAAc,IAAI,IAAI,CAAC,SAAU,SAAU,UAAW,OAAQ,WAAY,OAAQ,QAAS,QAAQ,CAAC,EAE7F,EAAqB,EAAqB,CACrD,KAAM,0BACN,OAAQ,EAAY,IAAW,CAC7B,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,MAAO,GAE/C,IAAM,EAAS,EAAW,cAAc,CAAC,CAAC,QAAQ,EAClD,OAAO,EAAO,SAAS,0BAA0B,KAAM,GAAY,EAAO,WAAW,EAAQ,MAAM,CAAC,CACtG,EACA,OAAQ,EAAY,IAAW,CAC7B,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,OAExC,IAAM,EAAS,EAAW,cAAc,CAAC,CAAC,QAAQ,EAC5C,EAAU,EAAO,SAAS,0BAA0B,KAAM,GAAS,EAAO,WAAW,EAAK,MAAM,CAAC,EAGvG,MAAO,CACL,YAAa,GACb,WAJiB,EAAO,MAAM,GAAG,CAAC,CAAC,KAAM,GAAY,EAAY,IAAI,CAAO,CAInE,EACT,WAAY,GAAS,YAAc,EACrC,CACF,CACF,CAAC"}

package/dist/rules/memberGetFieldRule.d.mts

@@ -0,0 +1,6 @@
+import { n as FieldExtractionRule } from "../types-DcvdOZ2j.mjs";
+//#region src/rules/memberGetFieldRule.d.ts
+declare const memberGetFieldRule: FieldExtractionRule;
+//#endregion
+export { memberGetFieldRule };
+//# sourceMappingURL=memberGetFieldRule.d.mts.map

package/dist/rules/memberGetFieldRule.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";const n=e({name:`member-get-field`,match:e=>{if(!t.isCallExpression(e))return!1;let n=e.getExpression(),r=e.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));return t.isPropertyAccessExpression(n)&&[`get`,`getAll`].includes(n.getName())&&!!r},parse:e=>{if(!t.isCallExpression(e))return;let n=e.getExpression(),r=e.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));if(!(!t.isPropertyAccessExpression(n)||!t.isStringLiteral(r)&&!t.isNoSubstitutionTemplateLiteral(r)))return{backendField:`${n.getExpression().getText()}.${r.getLiteralValue()}`}}});export{n as memberGetFieldRule};
+//# sourceMappingURL=memberGetFieldRule.mjs.map

package/dist/rules/memberGetFieldRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memberGetFieldRule.mjs","names":[],"sources":["../../src/rules/memberGetFieldRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nexport const memberGetFieldRule = defineExpressionRule({\n  name: \"member-get-field\",\n  match: (expression) => {\n    if (!Node.isCallExpression(expression)) return false;\n\n    const target = expression.getExpression();\n    const field = expression\n      .getArguments()\n      .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n    return Node.isPropertyAccessExpression(target) && [\"get\", \"getAll\"].includes(target.getName()) && Boolean(field);\n  },\n  parse: (expression) => {\n    if (!Node.isCallExpression(expression)) return undefined;\n\n    const target = expression.getExpression();\n    const field = expression\n      .getArguments()\n      .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n    if (!Node.isPropertyAccessExpression(target) || (!Node.isStringLiteral(field) && !Node.isNoSubstitutionTemplateLiteral(field))) {\n      return undefined;\n    }\n\n    return { backendField: `${target.getExpression().getText()}.${field.getLiteralValue()}` };\n  }\n});\n"],"mappings":"yFAGA,MAAa,EAAqB,EAAqB,CACrD,KAAM,mBACN,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,MAAO,GAE/C,IAAM,EAAS,EAAW,cAAc,EAClC,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EACtG,OAAO,EAAK,2BAA2B,CAAM,GAAK,CAAC,MAAO,QAAQ,CAAC,CAAC,SAAS,EAAO,QAAQ,CAAC,GAAK,EAAQ,CAC5G,EACA,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,OAExC,IAAM,EAAS,EAAW,cAAc,EAClC,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EAClG,MAAC,EAAK,2BAA2B,CAAM,GAAM,CAAC,EAAK,gBAAgB,CAAK,GAAK,CAAC,EAAK,gCAAgC,CAAK,GAI5H,MAAO,CAAE,aAAc,GAAG,EAAO,cAAc,CAAC,CAAC,QAAQ,EAAE,GAAG,EAAM,gBAAgB,GAAI,CAC1F,CACF,CAAC"}

package/dist/rules/quableI18nFieldRule.d.mts

@@ -0,0 +1,6 @@
+import { n as FieldExtractionRule } from "../types-DcvdOZ2j.mjs";
+//#region src/rules/quableI18nFieldRule.d.ts
+declare const quableI18nFieldRule: FieldExtractionRule;
+//#endregion
+export { quableI18nFieldRule };
+//# sourceMappingURL=quableI18nFieldRule.d.mts.map

package/dist/rules/quableI18nFieldRule.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";function n(e){if(!t.isPropertyAccessExpression(e))return;let n=e.getExpression();if(!t.isElementAccessExpression(n))return;let r=n.getExpression();if(!t.isCallExpression(r))return;let i=r.getExpression(),a=r.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));if(!(!t.isPropertyAccessExpression(i)||i.getName()!==`getAll`||!a||!t.isStringLiteral(a)&&!t.isNoSubstitutionTemplateLiteral(a)))return`${a.getLiteralValue()}[locale].${e.getName()}`}const r=e({name:`quable-i18n-field`,match:e=>!!n(e),parse:e=>{let t=n(e);return t?{backendField:t}:void 0}});export{r as quableI18nFieldRule};
+//# sourceMappingURL=quableI18nFieldRule.mjs.map

package/dist/rules/quableI18nFieldRule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"quableI18nFieldRule.mjs","names":[],"sources":["../../src/rules/quableI18nFieldRule.ts"],"sourcesContent":["import { type Expression, Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nfunction parseLocalizedI18nField(expression: Expression): string | undefined {\n  if (!Node.isPropertyAccessExpression(expression)) {\n    return undefined;\n  }\n\n  const elementAccess = expression.getExpression();\n\n  if (!Node.isElementAccessExpression(elementAccess)) {\n    return undefined;\n  }\n\n  const getAllCall = elementAccess.getExpression();\n\n  if (!Node.isCallExpression(getAllCall)) {\n    return undefined;\n  }\n\n  const target = getAllCall.getExpression();\n  const field = getAllCall\n    .getArguments()\n    .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n\n  if (\n    !Node.isPropertyAccessExpression(target) ||\n    target.getName() !== \"getAll\" ||\n    !field ||\n    (!Node.isStringLiteral(field) && !Node.isNoSubstitutionTemplateLiteral(field))\n  ) {\n    return undefined;\n  }\n\n  return `${field.getLiteralValue()}[locale].${expression.getName()}`;\n}\n\nexport const quableI18nFieldRule = defineExpressionRule({\n  name: \"quable-i18n-field\",\n  match: (expression) => Boolean(parseLocalizedI18nField(expression)),\n  parse: (expression) => {\n    const backendField = parseLocalizedI18nField(expression);\n    return backendField ? { backendField } : undefined;\n  }\n});\n"],"mappings":"yFAGA,SAAS,EAAwB,EAA4C,CAC3E,GAAI,CAAC,EAAK,2BAA2B,CAAU,EAC7C,OAGF,IAAM,EAAgB,EAAW,cAAc,EAE/C,GAAI,CAAC,EAAK,0BAA0B,CAAa,EAC/C,OAGF,IAAM,EAAa,EAAc,cAAc,EAE/C,GAAI,CAAC,EAAK,iBAAiB,CAAU,EACnC,OAGF,IAAM,EAAS,EAAW,cAAc,EAClC,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EAGpG,MAAC,EAAK,2BAA2B,CAAM,GACvC,EAAO,QAAQ,IAAM,UACrB,CAAC,GACA,CAAC,EAAK,gBAAgB,CAAK,GAAK,CAAC,EAAK,gCAAgC,CAAK,GAK9E,MAAO,GAAG,EAAM,gBAAgB,EAAE,WAAW,EAAW,QAAQ,GAClE,CAEA,MAAa,EAAsB,EAAqB,CACtD,KAAM,oBACN,MAAQ,GAAe,EAAQ,EAAwB,CAAU,EACjE,MAAQ,GAAe,CACrB,IAAM,EAAe,EAAwB,CAAU,EACvD,OAAO,EAAe,CAAE,cAAa,EAAI,IAAA,EAC3C,CACF,CAAC"}

package/dist/types-DcvdOZ2j.d.mts

@@ -0,0 +1,102 @@
+import { Expression } from "ts-morph";
+//#region src/utils/defineExpressionRule.d.ts
+type FieldExtractionRuleResult = {
+  backendField?: string;
+  transparent?: boolean;
+  mapperType?: string;
+  apiMapping?: boolean;
+};
+type FieldExtractionRule = {
+  name: string;
+  match: (expression: Expression, config: UserConfig) => boolean;
+  parse: (expression: Expression, config: UserConfig) => FieldExtractionRuleResult | undefined;
+};
+declare function defineExpressionRule(rule: FieldExtractionRule): FieldExtractionRule;
+//#endregion
+//#region src/models/types.d.ts
+interface NeutralExpressionMatcher {
+  prefix: string;
+  apiMapping?: boolean;
+}
+interface UserConfig {
+  /**
+   * Absolute path to the root of the repository to analyze (e.g. the digital-api repo).
+   * Can be set via the ATLAS_CWD environment variable.
+   */
+  repoRoot?: string;
+  /** Backend identifiers used by the API project. */
+  backends: string[];
+  /**
+   * Default OpenAPI document URL used to extract the public contract exposed by the API.
+   * The CLI can still override this value with `--openapi-url`.
+   */
+  openapiUrl: string;
+  /** Maximum duration allowed to connect to and download the OpenAPI document. */
+  openapiTimeoutMs: number;
+  /** Default Directus base URL used by `push` when no CLI option or environment variable overrides it. */
+  directusUrl: string;
+  /**
+   * Module aliases resolved while traversing static-analysis dependencies.
+   * Defaults are read from `compilerOptions.paths` in the repository tsconfig.
+   */
+  resolver?: {
+    /** Explicit aliases override aliases read from tsconfig. */
+    alias?: Record<string, string>;
+  };
+  /** Defaults used by the optional AI pass that reviews unresolved static mappings. */
+  inference: {
+    /** ai/sdk model used for structured mapping suggestions. */
+    model: string;
+    /** ai/sdk HTTP API base URL. */
+    baseUrl: string;
+    /** Minimum model confidence required to replace a `needs_review` mapping. */
+    minimumConfidence: number;
+    /** Maximum duration of one route-level AI request before aborting it. */
+    timeoutMs: number;
+    /** Maximum number of route-level AI requests run concurrently. */
+    workers: number;
+  };
+  /**
+   * Static analysis options used to keep generated artifacts focused on business-relevant files and fields.
+   */
+  analysis: {
+    /**
+     * Glob patterns excluded from `analysis_files`.
+     * Use this to hide technical plumbing files that add noise to route review documents.
+     */
+    excluded: string[];
+    /**
+     * Input root fields considered transverse to the API, such as access headers or generic list filters.
+     * These fields are kept in the extracted contract but are not flagged as `needs_review`
+     * when they do not map to a backend property. A detected backend mapping always takes precedence.
+     */
+    transversalInputs: string[];
+    /** Output field paths omitted from catalogues and coverage checks, including nested fields. */
+    ignoredOutputs: string[];
+    /** Technical property-access prefixes that must not be treated as backend fields. */
+    backendFieldAccess: {
+      excludedPrefixes: string[];
+    };
+    /** Mapper naming conventions used to infer mapping direction and domain roots. */
+    mapperNaming: {
+      inputPatterns: RegExp[];
+      outputPatterns: RegExp[];
+      domainToBackendPattern: RegExp;
+      domainNameFromToDomainPattern: RegExp;
+      constructedTypeToDomainPattern: (constructorName: string) => RegExp;
+    };
+    /** Expressions that are transparent while tracing a field through a mapping. */
+    neutralExpressionMatchers: NeutralExpressionMatcher[];
+    rules: FieldExtractionRule[];
+  };
+  /** Route-level minimum resolved-field coverage accepted by the static-analysis regression check. */
+  test: {
+    coverage: Array<{
+      route: string;
+      minimum_coverage: number | string;
+    }>;
+  };
+}
+//#endregion
+export { FieldExtractionRule as n, defineExpressionRule as r, UserConfig as t };
+//# sourceMappingURL=types-DcvdOZ2j.d.mts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmflow/atlas",
-  "version": "3.4.0-beta.3",
+  "version": "3.4.0-beta.5",
   "description": "API-to-backend mapping catalogue for Club Med Flow",
   "license": "MIT",
   "author": "romakita",
@@ -9,9 +9,16 @@
   "type": "module",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
-    ".": "./dist/index.mjs",
-    "./rules/*": "./dist/rules/*.mjs"
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./rules/*": {
+      "types": "./dist/rules/*.d.mts",
+      "import": "./dist/rules/*.mjs"
+    }
   },
   "scripts": {
     "build": "tsdown",

package/dist/defineRule-Dfvzj6n2.mjs

@@ -1,2 +0,0 @@
-function e(e){return e}export{e as t};
-//# sourceMappingURL=defineRule-Dfvzj6n2.mjs.map

package/dist/defineRule-Dfvzj6n2.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineRule-Dfvzj6n2.mjs","names":[],"sources":["../src/utils/defineRule.ts"],"sourcesContent":["import type { Expression } from \"ts-morph\";\nimport type { UserConfig } from \"../models/types\";\n\nexport type FieldExtractionRuleResult = {\n  backendField?: string;\n  transparent?: boolean;\n  mapperType?: string;\n  apiMapping?: boolean;\n};\n\nexport type FieldExtractionRule = {\n  name: string;\n  match: (expression: Expression, config: UserConfig) => boolean;\n  parse: (expression: Expression, config: UserConfig) => FieldExtractionRuleResult | undefined;\n};\n\nexport function defineExpressionRule(rule: FieldExtractionRule): FieldExtractionRule {\n  return rule;\n}\n"],"mappings":"AAgBA,SAAgB,EAAqB,EAAgD,CACnF,OAAO,CACT"}