@imolko/ultra-agent 0.1.0-beta

package/eslint/index.mjs

@@ -0,0 +1,721 @@
+/**
+ * Preset flat-config del tier A — reglas ejecutables de forma, legibilidad y
+ * arquitectura.
+ *
+ * Materializa, como configuración de ESLint, las decisiones canónicas del
+ * registro:
+ *  - A-001/A-024/A-025/A-026/A-027: dirección de dependencias entre las capas
+ *    (`domain`, `feature`, `shared-infra`, `representation`, `app`), frameworks
+ *    de infraestructura vetados en las capas internas, y tipos sin especificar
+ *    en los ports.
+ *  - A-046: métricas de forma y legibilidad (parámetros, líneas, complejidad,
+ *    anidamiento, sentencias, números mágicos, tipos por archivo, identificadores
+ *    e igualdad estricta).
+ *  - A-047: sin globales ambientales (`console`, `process.env`).
+ *  - A-050: el caso de uso habla en términos del dominio; no lee la
+ *    representación serializada (`getPrimitive`/`getPayload`/`getSnapshot`) ni
+ *    decide comparando `status`/`state`/`type`.
+ *  - A-051: orden de imports por distancia, con el prefijo del paquete interno
+ *    como grupo `internal`.
+ *  - A-053: el catálogo compartido de errores (`feature-error`) es un hogar
+ *    hermano de las features, importable por ellas sin violar boundaries.
+ *  - A-054: la costura del driver port es raw data; ningún objeto con
+ *    comportamiento ni hecho de dominio sin confirmar cruza el puerto.
+ *
+ * El preset es un módulo componible: el consumidor lo importa, lo invoca con su
+ * prefijo interno y compone sus reglas de proyecto encima. No escribe archivos
+ * ni lintea por sí mismo — el único ejecutor sigue siendo `qa-guardrail`
+ * (A-045/A-049).
+ *
+ * Uso:
+ * ```js
+ * // eslint.config.mjs del consumidor
+ * import ultra from "@imolko/ultra-agent/eslint";
+ *
+ * export default [
+ *   ...ultra({ internal: "@acme/*" }),
+ *   // reglas de proyecto del consumidor
+ * ];
+ * ```
+ */
+
+import tsParser from "@typescript-eslint/parser";
+import tsPlugin from "@typescript-eslint/eslint-plugin";
+import importX from "eslint-plugin-import-x";
+import boundaries from "eslint-plugin-boundaries";
+
+/** Archivos que el preset cubre por defecto. */
+export const PRESET_FILES = ["**/*.{ts,tsx,js,mjs,cjs}"];
+
+/** Carpetas y archivos que el preset ignora por defecto. */
+export const PRESET_IGNORES = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "temp-*/**",
+  ".ultra-reporter/**",
+  ".nx/**",
+  ".pi/**",
+  "scenarios/**",
+  "docs/**",
+  "eslint.config.mjs",
+];
+
+/**
+ * Capas canónicas de A-001 y el glob que las identifica por defecto.
+ *
+ * `domain`, `shared-infra`, `representations` y `apps` son un elemento por glob;
+ * `feature` captura cada slice (`features/<caso-de-uso>`) como un elemento
+ * distinto para que la matriz pueda vetar el acoplamiento entre features (A-024).
+ * El consumidor puede sobreescribir cualquier glob vía `layers`.
+ */
+export const DEFAULT_LAYERS = Object.freeze({
+  domain: "domain/**",
+  feature: "features/*",
+  "shared-infra": "shared-infra/*",
+  representation: "representations/*",
+  app: "apps/*",
+});
+
+/** Nombres de capa, en el orden de A-001. */
+export const LAYER_TYPES = Object.freeze(Object.keys(DEFAULT_LAYERS));
+
+/**
+ * Tipo de elemento del catálogo compartido de errores de infraestructura
+ * (A-053): un módulo hermano de los slices de feature, no una feature. Las
+ * features lo importan sin violar «una feature nunca importa otra feature».
+ */
+export const FEATURE_ERROR_TYPE = "feature-error";
+
+/**
+ * Glob por defecto del catálogo compartido de errores (A-053). Se deriva del
+ * glob de `feature` cuando este termina en `/*`; el consumidor puede
+ * sobreescribirlo explícitamente vía `layers[FEATURE_ERROR_TYPE]`.
+ */
+export const DEFAULT_FEATURE_ERROR_GLOB = "features/errors/**";
+
+/**
+ * Frameworks de infraestructura vetados en las capas internas: el dominio no los
+ * importa (A-001) y una feature es tech-free (A-025).
+ */
+export const INFRA_FRAMEWORKS = Object.freeze([
+  // Patrones con `/**` para vetar también los imports profundos (p. ej.
+  // `@nestjs/common/decorators`): minimatch no cruza `/` con un solo `*`.
+  "@nestjs/**",
+  "mongoose",
+  "pg",
+  "postgres",
+  "typeorm",
+  "sequelize",
+  "knex",
+  "prisma",
+  "@prisma/**",
+  "graphql",
+  "@apollo/**",
+  "apollo-server*",
+  "apollo-server**",
+  "express",
+  "fastify",
+  "rxjs",
+  "ioredis",
+  "redis",
+  "mongodb",
+  "kafkajs",
+  "amqplib",
+]);
+
+const DOMAIN_FRAMEWORK_MESSAGE =
+  "El dominio no importa frameworks de infraestructura (A-001): solo validación y result-type.";
+const FEATURE_FRAMEWORK_MESSAGE =
+  "La feature es tech-free (A-025): el driver tecnológico vive en shared-infra/ y se inyecta por el driver port.";
+
+/**
+ * Driver ports: la costura raw (A-025/A-054). Además de los tipos sin
+ * especificar, se aplican los selectores de costura raw.
+ */
+export const DRIVER_PORT_FILES = Object.freeze([
+  "**/driver.port.ts",
+  "**/*.driver.port.ts",
+  "**/service.port.ts",
+  "**/*.service.port.ts",
+]);
+
+/**
+ * Puertos de dominio (`use-case/*.port.ts`). A-025 exige que un puerto de
+ * dominio hable en conceptos de dominio y que nunca use `any`/`unknown`; el
+ * bloque no aplica los selectores raw (el dominio sí usa tipos con
+ * comportamiento). Los globs se derivan del glob de `feature` para respetar el
+ * override del consumidor.
+ *
+ * @param {string} featureGlob
+ * @returns {string[]}
+ */
+export function domainPortFileGlobs(featureGlob) {
+  return [`${featureGlob}/use-case/**/*.port.ts`];
+}
+
+/** Selector de globales ambientales (A-047). */
+const AMBIENT_SYNTAX = {
+  selector: "MemberExpression[object.name='process'][property.name='env']",
+  message:
+    "Acceso directo a process.env prohibido (A-047). Inyecta la configuración por el contrato de settings.",
+};
+
+/** Tipos sin especificar vetados en los ports (A-025). */
+const UNTYPED_PORT_SYNTAX = [
+  {
+    selector: "TSAnyKeyword",
+    message: "Los ports no usan `any` (A-025): declara el raw data de la costura.",
+  },
+  {
+    selector: "TSUnknownKeyword",
+    message: "Los ports no usan `unknown` (A-025): declara el raw data de la costura.",
+  },
+];
+
+/**
+ * Patrones por defecto de las formas raw que sí cruzan la costura del driver
+ * port (A-054): mementos/snapshots, la envolvente CloudEvent, DTOs y demás data
+ * plana; el canal de error (`Execution`/`Validation`, cualquier `*Error`), la
+ * promesa y las utilidades genéricas del tier.
+ *
+ * Son fragmentos de expresión regular (sin anclas; el patrón final las añade).
+ * El consumidor puede extenderlos vía `rawSeamTypes` para sus propias formas
+ * raw (A-052: el preset sirve a cualquier consumidor, no a la nomenclatura de
+ * un proyecto concreto).
+ */
+const DEFAULT_RAW_SEAM_TYPES = Object.freeze([
+  ".*(?:Snapshot|Memento|Payload|DTO|Dto|Data|Event|CloudEvent|Props|Record|Row|Model|Schema|Filters|Filter|Query|Result)",
+  ".*Error",
+  "Error",
+  "Promise",
+  "Execution",
+  "Validation",
+  "TaskExecution",
+  "TaskValidation",
+  "Result",
+  "Array",
+  "ReadonlyArray",
+  "Readonly",
+  "Record",
+  "Partial",
+  "Pick",
+  "Omit",
+  "Map",
+  "Set",
+  "Date",
+  "Buffer",
+  "Uint8Array",
+  "URL",
+  "RegExp",
+]);
+
+/**
+ * Compone el patrón de los tipos que **sí** cruzan la costura raw (A-054) a
+ * partir de los defaults y de los patrones extra del consumidor.
+ *
+ * @param {string[]} extra Fragmentos de regex del consumidor.
+ * @returns {string}
+ */
+function rawSeamTypePattern(extra) {
+  return `^(?:${[...DEFAULT_RAW_SEAM_TYPES, ...extra].join("|")})$`;
+}
+
+/**
+ * Normaliza y valida los patrones raw extra del consumidor.
+ *
+ * @param {unknown} rawSeamTypes
+ * @returns {string[]}
+ */
+function requireRawSeamTypes(rawSeamTypes) {
+  if (rawSeamTypes === undefined) {
+    return [];
+  }
+  if (
+    !Array.isArray(rawSeamTypes) ||
+    rawSeamTypes.some((pattern) => typeof pattern !== "string" || pattern.trim() === "")
+  ) {
+    throw new Error(
+      "El preset @imolko/ultra-agent/eslint espera `rawSeamTypes` como array de patrones de tipo no vacíos.",
+    );
+  }
+  return rawSeamTypes.map((pattern) => pattern.trim());
+}
+
+/**
+ * Selectores de la costura raw del driver port (A-054): ningún objeto con
+ * comportamiento (agregado, entidad o value object) ni hecho de dominio sin
+ * confirmar cruza el puerto. El adaptador produce la forma raw.
+ *
+ * El primer selector es un heurístico de nomenclatura: marca toda referencia de
+ * tipo que no encaja en las formas raw conocidas (o en las que declare el
+ * consumidor vía `rawSeamTypes`). No distingue con certeza un objeto con
+ * comportamiento de un DTO plano de nombre no listado; A-054 mantiene esa
+ * detección como deuda de guardrail y la revisión sigue siendo la autoridad.
+ *
+ * @param {string[]} extra Fragmentos de regex extra del consumidor.
+ * @returns {Array<{ selector: string, message: string }>}
+ */
+function seamSyntax(extra) {
+  const raw = rawSeamTypePattern(extra).replaceAll("/", "\\/");
+  return [
+    {
+      selector: "TSTypeReference[typeName.name!=/" + raw + "/]",
+      message:
+        "La costura del driver port es raw data (A-054): ningún agregado, entidad ni value object del dominio cruza el puerto. Usa el memento/snapshot o un DTO plano, o declara tu forma raw en `rawSeamTypes`.",
+    },
+    {
+      selector: "Identifier[name='UncommittedEvent']",
+      message:
+        "La costura del driver port recibe la envolvente raw (A-054): el hecho de dominio sin confirmar no cruza el puerto; el adaptador construye la ocurrencia.",
+    },
+    {
+      selector: "Identifier[name='eventClass']",
+      message:
+        "El driver port no conoce la referencia de clase del hecho (A-054): el adaptador produce la envolvente raw; el puerto no arrastra `eventClass`.",
+    },
+  ];
+}
+
+/**
+ * Selectores del caso de uso que no lee la representación (A-050): prohíbe
+ * invocar los getters de la representación serializada y decidir comparando un
+ * campo de estado (`status`/`state`/`type`) en lugar de un predicado del dominio.
+ */
+const USE_CASE_SYNTAX = [
+  {
+    selector: "CallExpression[callee.property.name=/^(getPrimitive|getPayload|getSnapshot)$/]",
+    message:
+      "El caso de uso no lee la representación serializada del dominio (A-050): pide el hecho al dominio (predicados, consultas, fábricas); la traducción a la wire la hace la frontera.",
+  },
+  {
+    selector: "BinaryExpression[operator=/^[!=]=?=?$/][left.property.name=/^(status|state|type)$/]",
+    message:
+      "El caso de uso no decide comparando un campo de estado de la representación (A-050): usa un predicado del dominio (p. ej. claim.isOpen()).",
+  },
+  {
+    selector: "BinaryExpression[operator=/^[!=]=?=?$/][right.property.name=/^(status|state|type)$/]",
+    message:
+      "El caso de uso no decide comparando un campo de estado de la representación (A-050): usa un predicado del dominio (p. ej. claim.isOpen()).",
+  },
+];
+
+/**
+ * Reglas de forma y legibilidad (A-046) y dependencias explícitas (A-047).
+ * Son agnósticas al prefijo de paquete interno y a las capas, por eso viven
+ * fuera de la fábrica.
+ */
+export const STYLE_RULES = {
+  // A-046 — métricas de forma.
+  "max-params": ["error", 2],
+  "max-lines-per-function": ["error", { max: 50, skipBlankLines: true }],
+  "max-lines": ["error", { max: 250, skipBlankLines: true }],
+  "no-magic-numbers": [
+    "error",
+    {
+      detectObjects: false,
+      enforceConst: true,
+      ignore: [0, 1, -1, 2],
+      ignoreArrayIndexes: true,
+    },
+  ],
+  complexity: ["error", 10],
+  "max-depth": ["error", 4],
+  "max-statements": ["error", 20],
+  "max-classes-per-file": ["error", 1],
+  "ultra/one-type-per-file": "error",
+  "id-length": ["error", { min: 2 }],
+  eqeqeq: ["error", "always"],
+
+  // A-047 — sin globales ambientales.
+  "no-console": "error",
+  "no-restricted-syntax": ["error", AMBIENT_SYNTAX],
+};
+
+/** Tipos que definen un tipo con nombre a nivel de archivo. */
+const TYPE_DECLARATION_TYPES = new Set([
+  "ClassDeclaration",
+  "TSInterfaceDeclaration",
+  "TSTypeAliasDeclaration",
+  "TSEnumDeclaration",
+]);
+
+/**
+ * Reconoce una declaración de tipo, desenvolviendo el `export` que la envuelve.
+ *
+ * @param {{ type?: string, declaration?: unknown } | undefined} node
+ * @returns {boolean}
+ */
+function isTypeDeclaration(node) {
+  if (!node || typeof node.type !== "string") {
+    return false;
+  }
+  if (TYPE_DECLARATION_TYPES.has(node.type)) {
+    return true;
+  }
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
+    return isTypeDeclaration(node.declaration);
+  }
+  return false;
+}
+
+/**
+ * Regla local `ultra/one-type-per-file` (A-046 §8). `max-classes-per-file` solo
+ * cuenta clases; esta regla extiende la métrica a interfaces, alias de tipo y
+ * enums para que «un tipo principal por archivo» sea verificable de verdad.
+ */
+const ONE_TYPE_PER_FILE_RULE = {
+  meta: {
+    type: "problem",
+    docs: { description: "Un tipo principal por archivo (A-046 §8)." },
+    schema: [],
+    messages: {
+      tooMany:
+        "Un tipo principal por archivo (A-046 §8): mueve el tipo adicional a su propio archivo.",
+    },
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const declarations = node.body.filter(isTypeDeclaration);
+        for (const extra of declarations.slice(1)) {
+          context.report({ node: extra, messageId: "tooMany" });
+        }
+      },
+    };
+  },
+};
+
+/**
+ * Plugin local del preset: aloja las reglas que materializan una métrica de
+ * A-046 que el core de ESLint no cubre, sin introducir un segundo ejecutor.
+ */
+const ULTRA_PLUGIN = Object.freeze({
+  rules: Object.freeze({ "one-type-per-file": ONE_TYPE_PER_FILE_RULE }),
+});
+
+/**
+ * Matriz de dependencias entre capas (A-001/A-024/A-025/A-026/A-027). El default
+ * es vetar toda dependencia local no declarada; las capas interiores no conocen
+ * a las exteriores:
+ *  - app → domain, feature, shared-infra, representation
+ *  - feature → domain, feature-error (el catálogo compartido de A-053)
+ *  - feature-error → domain, feature-error (su propio catálogo)
+ *  - shared-infra → domain, feature (los driver ports)
+ *  - representation → domain
+ *  - domain → domain
+ */
+const LAYER_DEPENDENCY_POLICIES = [
+  {
+    from: { element: { type: "app" } },
+    allow: {
+      to: {
+        element: {
+          types: { anyOf: ["domain", "feature", "shared-infra", "representation"] },
+        },
+      },
+    },
+  },
+  {
+    from: { element: { type: "feature" } },
+    allow: {
+      to: { element: { types: { anyOf: ["domain", FEATURE_ERROR_TYPE] } } },
+    },
+  },
+  {
+    from: { element: { type: FEATURE_ERROR_TYPE } },
+    allow: {
+      to: { element: { types: { anyOf: ["domain", FEATURE_ERROR_TYPE] } } },
+    },
+  },
+  {
+    from: { element: { type: "shared-infra" } },
+    allow: { to: { element: { types: { anyOf: ["domain", "feature"] } } } },
+  },
+  {
+    from: { element: { type: "representation" } },
+    allow: { to: { element: { type: "domain" } } },
+  },
+  {
+    from: { element: { type: "domain" } },
+    allow: { to: { element: { type: "domain" } } },
+  },
+];
+
+const LAYER_DEPENDENCIES_OPTIONS = {
+  default: "disallow",
+  policies: LAYER_DEPENDENCY_POLICIES,
+};
+
+/**
+ * Construye las reglas de orden de imports por distancia (A-051): builtins,
+ * externos, internos, relativos de carpeta lejana a cercana. Dentro de cada
+ * grupo, orden alfabético. Los imports de efecto lateral quedan fuera del
+ * ordenador (la regla no los mueve).
+ *
+ * @param {string} internal Prefijo del paquete interno (p. ej. `@acme/*`).
+ * @returns {Record<string, unknown>} Reglas de `import-x`.
+ */
+export function importRules(internal) {
+  return {
+    "import-x/order": [
+      "error",
+      {
+        groups: [
+          "builtin",
+          "external",
+          "internal",
+          "parent",
+          "sibling",
+          "index",
+        ],
+        pathGroups: [{ pattern: internal, group: "internal", position: "before" }],
+        // Sin excluir `external`: un paquete con el prefijo interno se
+        // re-clasifica como `internal` y se ordena después de los externos.
+        pathGroupsExcludedImportTypes: ["builtin"],
+        alphabetize: { order: "asc", caseInsensitive: true },
+        // A-051: los imports se leen en bloques de distancia; el salto de línea
+        // separa cada capa y la funde visualmente si se omite.
+        "newlines-between": "always",
+      },
+    ],
+  };
+}
+
+/**
+ * Valida y normaliza el prefijo del paquete interno.
+ *
+ * @param {unknown} internal
+ * @returns {string}
+ */
+function requireInternal(internal) {
+  if (typeof internal !== "string" || internal.trim() === "") {
+    throw new Error(
+      "El preset @imolko/ultra-agent/eslint requiere `internal` (el prefijo del paquete interno, p. ej. \"@acme/*\").",
+    );
+  }
+  return internal.trim();
+}
+
+/**
+ * Deriva el glob del catálogo compartido de errores (A-053) del glob de las
+ * features: `features/*` describe slices hermanas de `features/errors/`. Si el
+ * glob no termina en `/*` no se puede derivar y se usa el default.
+ *
+ * @param {string} featureGlob
+ * @returns {string | undefined}
+ */
+function deriveFeatureErrorGlob(featureGlob) {
+  if (typeof featureGlob === "string" && featureGlob.endsWith("/*")) {
+    return `${featureGlob.slice(0, -2)}/errors/**`;
+  }
+  return undefined;
+}
+
+/**
+ * Resuelve las capas partiendo de los defaults de A-001 y aplicando los overrides
+ * del consumidor. Valida que la capa exista y que el glob sea una cadena no vacía.
+ * El catálogo de errores (A-053) se deriva del glob de `feature` salvo que se
+ * sobreescriba explícitamente con la clave `feature-error`.
+ *
+ * @param {unknown} overrides Globs de capa opcionales.
+ * @returns {Record<string, string>} Globs de capa completos.
+ */
+function resolveLayers(overrides) {
+  const layers = { ...DEFAULT_LAYERS };
+  if (overrides !== undefined) {
+    if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides)) {
+      throw new Error(
+        "El preset @imolko/ultra-agent/eslint espera `layers` como objeto de globs por capa.",
+      );
+    }
+    for (const [layer, glob] of Object.entries(overrides)) {
+      if (layer !== FEATURE_ERROR_TYPE && !Object.hasOwn(DEFAULT_LAYERS, layer)) {
+        throw new Error(
+          `Capa desconocida en \`layers\`: "${layer}". Capas válidas: ${[
+            ...LAYER_TYPES,
+            FEATURE_ERROR_TYPE,
+          ].join(", ")}.`,
+        );
+      }
+      if (typeof glob !== "string" || glob.trim() === "") {
+        throw new Error(`El glob de la capa "${layer}" debe ser una cadena no vacía.`);
+      }
+      layers[layer] = glob.trim();
+    }
+  }
+  if (layers[FEATURE_ERROR_TYPE] === undefined) {
+    layers[FEATURE_ERROR_TYPE] =
+      deriveFeatureErrorGlob(layers.feature) ?? DEFAULT_FEATURE_ERROR_GLOB;
+  }
+  return layers;
+}
+
+/**
+ * Traduce un glob de capa (patrón de elemento de `eslint-plugin-boundaries`) al
+ * conjunto de globs de archivo que ESLint acepta en `files`. Un glob que termina
+ * en `/*` describe la carpeta del elemento (p. ej. `features/*`), así que hay que
+ * alcanzar sus descendientes; un glob `**` ya los cubre.
+ *
+ * @param {string} glob
+ * @returns {string[]}
+ */
+function layerFileGlobs(glob) {
+  return glob.endsWith("/*") ? [glob, `${glob}/**`] : [glob];
+}
+
+/**
+ * Globs de archivo del caso de uso dentro de cada slice de feature (A-025). Se
+ * derivan del glob de `feature` para que respeten el override del consumidor.
+ *
+ * @param {string} featureGlob
+ * @returns {string[]}
+ */
+function useCaseFileGlobs(featureGlob) {
+  return [`${featureGlob}/use-case/**`];
+}
+
+/**
+ * Describe las capas para `eslint-plugin-boundaries`.
+ *
+ * @param {Record<string, string>} layers
+ * @returns {Array<{ type: string, pattern: string, capture: string[] }>}
+ */
+function elementDescriptors(layers) {
+  // El catálogo de errores (A-053) va antes que `feature`: `features/errors/**`
+  // también encajaría en `features/*`, y el primer descriptor que encaja gana.
+  return [FEATURE_ERROR_TYPE, ...LAYER_TYPES].map((type) => ({
+    type,
+    pattern: layers[type],
+    capture: ["elementName"],
+  }));
+}
+
+/**
+ * Crea el array flat-config del tier A.
+ *
+ * @param {{
+ *   internal: string,
+ *   layers?: Record<string, string>,
+ *   rawSeamTypes?: string[],
+ * }} options Opciones del preset. `internal` es obligatorio: el prefijo del
+ *   paquete interno del consumidor. `layers` sobreescribe los globs de capa
+ *   (defaults de A-001) y admite la clave `feature-error` para el catálogo de
+ *   errores de A-053. `rawSeamTypes` extiende, con fragmentos de expresión
+ *   regular, las formas raw que cruzan el driver port (A-054) cuando el
+ *   consumidor nombra sus DTOs al margen de los sufijos por defecto.
+ * @returns {import("eslint").Linter.Config[]}
+ */
+export function createPreset(options) {
+  const internal = requireInternal(options?.internal);
+  const layers = resolveLayers(options?.layers);
+  const rawSeamTypes = requireRawSeamTypes(options?.rawSeamTypes);
+
+  return [
+    { ignores: PRESET_IGNORES },
+    {
+      files: PRESET_FILES,
+      languageOptions: {
+        parser: tsParser,
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+        },
+      },
+      plugins: {
+        // Se registra aunque no habilita reglas propias: resuelve las
+        // directivas de supresión de `@typescript-eslint/*` que ya tenga el
+        // consumidor y sirve de superficie para que componga sus reglas de
+        // proyecto encima del preset (A-052: el preset es componible).
+        "@typescript-eslint": tsPlugin,
+        "import-x": importX,
+        boundaries,
+        ultra: ULTRA_PLUGIN,
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: "off",
+      },
+      settings: {
+        "import-x/resolver": { typescript: { alwaysTryTypes: true } },
+        "import-x/extensions": [".ts", ".tsx", ".js", ".mjs", ".cjs"],
+        // `eslint-plugin-boundaries` resuelve con el resolver de `import`.
+        "import/resolver": { typescript: { alwaysTryTypes: true } },
+        "boundaries/elements": elementDescriptors(layers),
+      },
+      rules: {
+        ...STYLE_RULES,
+        ...importRules(internal),
+        "boundaries/dependencies": ["error", LAYER_DEPENDENCIES_OPTIONS],
+      },
+    },
+    {
+      files: layerFileGlobs(layers.domain),
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          { patterns: [{ group: [...INFRA_FRAMEWORKS], message: DOMAIN_FRAMEWORK_MESSAGE }] },
+        ],
+      },
+    },
+    {
+      files: layerFileGlobs(layers.feature),
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          { patterns: [{ group: [...INFRA_FRAMEWORKS], message: FEATURE_FRAMEWORK_MESSAGE }] },
+        ],
+      },
+    },
+    // A-050 — el caso de uso no lee la representación serializada. Va antes del
+    // bloque de ports para que un `*.service.port.ts` conserve las reglas de
+    // A-025 (el último bloque que encaja gana). Los tests y el formateo de
+    // errores quedan fuera: consumen la representación legítimamente.
+    {
+      files: useCaseFileGlobs(layers.feature),
+      ignores: [
+        "**/*.spec.ts",
+        "**/*.test.ts",
+        "**/*.integration.test.ts",
+        "**/test-setup.ts",
+        "**/test-helpers.ts",
+        "**/test-doubles/**",
+        "**/errors/**",
+      ],
+      rules: {
+        "no-restricted-syntax": ["error", AMBIENT_SYNTAX, ...USE_CASE_SYNTAX],
+      },
+    },
+    // A-025 — un puerto de dominio también habla en conceptos de dominio y
+    // nunca usa `any`/`unknown`. Va después del bloque de A-050 para añadir la
+    // métrica a los `*.port.ts` sin perder los selectores de A-050 que ya
+    // recibían, y antes del bloque de driver ports para que un
+    // `*.service.port.ts` herede además los selectores de costura.
+    {
+      files: domainPortFileGlobs(layers.feature),
+      rules: {
+        "no-restricted-syntax": [
+          "error",
+          AMBIENT_SYNTAX,
+          ...USE_CASE_SYNTAX,
+          ...UNTYPED_PORT_SYNTAX,
+        ],
+      },
+    },
+    // A-054 — la costura raw del driver port (va al final: es el bloque que gana
+    // en los archivos que solapan con los anteriores).
+    {
+      files: [...DRIVER_PORT_FILES],
+      rules: {
+        "no-restricted-syntax": [
+          "error",
+          AMBIENT_SYNTAX,
+          ...UNTYPED_PORT_SYNTAX,
+          ...seamSyntax(rawSeamTypes),
+        ],
+      },
+    },
+  ];
+}
+
+export default createPreset;