@slip-stream-kit/eslint-plugin 0.43.2 → 0.44.0

package/dist/index.js

@@ -1,3 +1,197 @@
+// src/utils/path-match.ts
+var REGEX_METACHARS = /* @__PURE__ */ new Set(["\\", "^", "$", ".", "|", "+", "(", ")", "[", "]", "{", "}"]);
+var globToRegExp = (glob) => {
+  let source = "";
+  for (let index = 0; index < glob.length; index++) {
+    const char = glob[index];
+    if (char === "*") {
+      if (glob[index + 1] === "*") {
+        source += ".*";
+        index++;
+        if (glob[index + 1] === "/") {
+          index++;
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else if (REGEX_METACHARS.has(char)) {
+      source += `\\${char}`;
+    } else {
+      source += char;
+    }
+  }
+  return new RegExp(source);
+};
+var matchesAnyGlob = (filename, patterns) => {
+  const normalized = filename.split("\\").join("/");
+  return patterns.some((pattern) => {
+    return globToRegExp(pattern).test(normalized);
+  });
+};
+
+// src/rules/atom-naming/atom-naming.ts
+var ATOM_FACTORIES = /* @__PURE__ */ new Set([
+  "atom",
+  "atomWithStorage",
+  "atomWithReset",
+  "atomWithDefault",
+  "atomFamily",
+  "loadable",
+  "selectAtom",
+  "splitAtom",
+  "focusAtom"
+]);
+var isWriteOnly = (call) => {
+  const [read, write] = call.arguments;
+  return call.callee.type === "Identifier" && call.callee.name === "atom" && read?.type === "Literal" && read.value === null && write !== void 0;
+};
+var asFunction = (node) => {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" ? node : null;
+};
+var isNamedArgsType = (param, argsSuffix) => {
+  const target = param.type === "AssignmentPattern" ? param.left : param;
+  if (target.type === "RestElement") {
+    return false;
+  }
+  const annotation = target.typeAnnotation?.typeAnnotation;
+  if (annotation === void 0) {
+    return true;
+  }
+  return annotation.type === "TSTypeReference" && annotation.typeName?.type === "Identifier" && annotation.typeName.name.endsWith(argsSuffix);
+};
+var exampleArgsType = (name, suffixes, argsSuffix) => {
+  const suffix = suffixes.find((candidate) => {
+    return name.endsWith(candidate) && name.length > candidate.length;
+  });
+  const base = (suffix === void 0 ? name : name.slice(0, -suffix.length)).replace(/^\$+/, "");
+  return `${base.charAt(0).toUpperCase()}${base.slice(1)}${argsSuffix}`;
+};
+var atomNaming = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require readable Jotai atoms to start with `$`, write-only atoms to end with `Fx` (async) or `Atom` (sync), and write-only atoms to take a single `*Args` object.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#atom-naming"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          asyncSuffix: {
+            type: "string",
+            minLength: 1,
+            description: "Suffix of an async write-only atom (default 'Fx')."
+          },
+          syncSuffix: {
+            type: "string",
+            minLength: 1,
+            description: "Suffix of a sync write-only atom (default 'Atom')."
+          },
+          argsSuffix: {
+            type: "string",
+            minLength: 1,
+            description: "Suffix of the type naming a write-only atom's argument (default 'Args')."
+          },
+          readablePrefix: {
+            type: "string",
+            minLength: 1,
+            description: "Prefix of a readable atom (default '$')."
+          },
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. When provided, the rule only runs for files whose path matches one of them."
+          },
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. The rule is skipped for files whose path matches one of them, even if it also matches `paths`."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      readablePrefix: 'Readable atom "{{name}}" must start with "{{prefix}}" (e.g. "{{expected}}").',
+      writeOnlyPrefix: 'Write-only atom "{{name}}" must not start with "{{prefix}}": that prefix marks readable atoms.',
+      writeOnlySuffix: 'Write-only atom "{{name}}" must end with {{expected}}.',
+      argsNotNamed: 'Write-only atom "{{name}}" must take a single argument typed with a named `*{{suffix}}` type (e.g. `args: {{example}}`).'
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const paths = options.paths ?? [];
+    const ignore = options.ignore ?? [];
+    if (ignore.length > 0 && matchesAnyGlob(context.filename, ignore)) {
+      return {};
+    }
+    if (paths.length > 0 && !matchesAnyGlob(context.filename, paths)) {
+      return {};
+    }
+    const asyncSuffix = options.asyncSuffix ?? "Fx";
+    const syncSuffix = options.syncSuffix ?? "Atom";
+    const argsSuffix = options.argsSuffix ?? "Args";
+    const prefix = options.readablePrefix ?? "$";
+    const checkWriteOnly = (id, call) => {
+      const { name } = id;
+      const write = asFunction(call.arguments[1]);
+      if (name.startsWith(prefix)) {
+        context.report({ node: id, messageId: "writeOnlyPrefix", data: { name, prefix } });
+      }
+      const asyncForm = { suffix: asyncSuffix, kind: "async" };
+      const syncForm = { suffix: syncSuffix, kind: "sync" };
+      let accepted = [asyncForm, syncForm];
+      if (write !== null) {
+        accepted = [write.async ? asyncForm : syncForm];
+      }
+      const hasSuffix = accepted.some((form) => {
+        return name.endsWith(form.suffix);
+      });
+      if (!hasSuffix) {
+        const expected = accepted.map((form) => {
+          return `"${form.suffix}" (${form.kind})`;
+        }).join(" or ");
+        context.report({ node: id, messageId: "writeOnlySuffix", data: { name, expected } });
+      }
+      const inputs = write?.params.slice(2) ?? [];
+      if (inputs.length === 0) {
+        return;
+      }
+      if (inputs.length > 1 || !isNamedArgsType(inputs[0], argsSuffix)) {
+        context.report({
+          node: inputs[0],
+          messageId: "argsNotNamed",
+          data: { name, suffix: argsSuffix, example: exampleArgsType(name, [asyncSuffix, syncSuffix], argsSuffix) }
+        });
+      }
+    };
+    const check = (node) => {
+      const { id, init } = node;
+      if (id.type !== "Identifier" || init?.type !== "CallExpression" || init.callee.type !== "Identifier" || !ATOM_FACTORIES.has(init.callee.name)) {
+        return;
+      }
+      if (isWriteOnly(init)) {
+        checkWriteOnly(id, init);
+        return;
+      }
+      if (!id.name.startsWith(prefix)) {
+        context.report({
+          node: id,
+          messageId: "readablePrefix",
+          data: { name: id.name, prefix, expected: `${prefix}${id.name}` }
+        });
+      }
+    };
+    return {
+      "Program > VariableDeclaration > VariableDeclarator": check,
+      "Program > ExportNamedDeclaration > VariableDeclaration > VariableDeclarator": check
+    };
+  }
+};
+
 // src/utils/component.ts
 var COMPONENT_WRAPPER_CALLEES = /* @__PURE__ */ new Set(["memo", "forwardRef", "observer", "React.memo", "React.forwardRef"]);
 var NESTED_SCOPES = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
@@ -203,39 +397,6 @@ var bodyDeclaresComponent = (body) => {
   });
 };
 
-// src/utils/path-match.ts
-var REGEX_METACHARS = /* @__PURE__ */ new Set(["\\", "^", "$", ".", "|", "+", "(", ")", "[", "]", "{", "}"]);
-var globToRegExp = (glob) => {
-  let source = "";
-  for (let index = 0; index < glob.length; index++) {
-    const char = glob[index];
-    if (char === "*") {
-      if (glob[index + 1] === "*") {
-        source += ".*";
-        index++;
-        if (glob[index + 1] === "/") {
-          index++;
-        }
-      } else {
-        source += "[^/]*";
-      }
-    } else if (char === "?") {
-      source += "[^/]";
-    } else if (REGEX_METACHARS.has(char)) {
-      source += `\\${char}`;
-    } else {
-      source += char;
-    }
-  }
-  return new RegExp(source);
-};
-var matchesAnyGlob = (filename, patterns) => {
-  const normalized = filename.split("\\").join("/");
-  return patterns.some((pattern) => {
-    return globToRegExp(pattern).test(normalized);
-  });
-};
-
 // src/rules/component-arrow-function/component-arrow-function.ts
 var ANONYMOUS_NAME = "component";
 var reportName = (fn) => {
@@ -327,69 +488,551 @@ var componentArrowFunction = {
   }
 };
 
-// src/rules/component-file-order/component-file-order.ts
-var PROPS_SUFFIX = "Props";
-var getDirectivePrologueCount = (body) => {
-  let count = 0;
-  for (const statement of body) {
-    const isStringExpression = statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string";
-    if (!isStringExpression) {
-      break;
+// src/utils/package-root.ts
+import fs from "node:fs";
+import path from "node:path";
+var CONFIG_FILENAME = "infra-kit.config.ts";
+var PACKAGE_MARKERS = [CONFIG_FILENAME, "package.json"];
+var REPO_MARKERS = ["pnpm-workspace.yaml"];
+var hasAnyMarker = (dir, markers) => {
+  return markers.some((marker) => {
+    return fs.existsSync(path.posix.join(dir, marker));
+  });
+};
+var rootCache = /* @__PURE__ */ new Map();
+var findUp = (startDir, markers) => {
+  let current = startDir;
+  while (!hasAnyMarker(current, markers)) {
+    const parent = path.posix.dirname(current);
+    if (parent === current) {
+      return null;
     }
-    count += 1;
+    current = parent;
   }
-  return count;
+  return current;
 };
-var getTypeDeclName = (node) => {
-  if (!node) {
+var findPackageRoot = (filename) => {
+  if (!path.posix.isAbsolute(filename)) {
     return null;
   }
-  const named = node;
-  if (named.type !== "TSInterfaceDeclaration" && named.type !== "TSTypeAliasDeclaration") {
-    return null;
+  const dir = path.posix.dirname(filename);
+  const cached = rootCache.get(dir);
+  if (cached !== void 0) {
+    return cached;
   }
-  return named.id?.name ?? null;
+  const root = findUp(dir, PACKAGE_MARKERS);
+  rootCache.set(dir, root);
+  return root;
 };
-var collectTopLevel = (body) => {
-  const importIndices = [];
-  const components = [];
-  const declIndexByName = /* @__PURE__ */ new Map();
-  const importedNames = /* @__PURE__ */ new Set();
-  for (const [index, statement] of body.entries()) {
-    if (statement.type === "ImportDeclaration") {
-      importIndices.push(index);
-      for (const specifier of statement.specifiers) {
-        importedNames.add(specifier.local.name);
-      }
-      continue;
-    }
-    const declaration = unwrapExport(statement);
-    const declName = getTypeDeclName(declaration);
-    if (declName !== null && !declIndexByName.has(declName)) {
-      declIndexByName.set(declName, index);
-    }
-    if (declaresComponent(declaration)) {
-      const name = getDeclaredComponentName(declaration);
-      const propsName = getComponentPropsTypeName(declaration) ?? (name === null ? null : `${name}${PROPS_SUFFIX}`);
-      components.push({ index, name, propsName });
-    }
+var dirsUnderSrc = (packageRoot, filename) => {
+  const srcPrefix = `${packageRoot}/src/`;
+  if (!filename.startsWith(srcPrefix)) {
+    return null;
   }
-  return { importIndices, components, declIndexByName, importedNames };
+  return filename.slice(srcPrefix.length).split("/").slice(0, -1);
 };
-var hasStrayBefore = (body, boundary, directiveCount, skipIndex) => {
-  return body.some((statement, index) => {
-    return index < boundary && index >= directiveCount && index !== skipIndex && statement.type !== "ImportDeclaration";
-  });
+var findRepoRoot = (packageRoot) => {
+  return findUp(packageRoot, REPO_MARKERS);
 };
-var ANONYMOUS_COMPONENT = "component";
-var findImportOrderViolations = (importIndices, importBoundary) => {
-  return importIndices.filter((importIndex) => {
-    return importIndex > importBoundary;
-  }).map((importIndex) => {
-    return { index: importIndex, messageId: "importsFirst" };
+
+// ../config/dist/package-type.js
+import path2 from "node:path";
+var PACKAGE_TYPES = ["frontend", "backend", "lib", "e2e", "mobile"];
+var APP_DIRECTORY_TYPES = {
+  ui: "frontend",
+  api: "backend",
+  tests: "e2e"
+};
+var MOBILE_BASENAME = "mobile-app";
+var DEPENDENCY_SIGNALS = [
+  { type: "e2e", packages: ["@playwright/test"] },
+  { type: "mobile", packages: ["@capacitor/core", "@capacitor/cli"] },
+  // `aws-lambda` / `@types/aws-lambda` are deliberately NOT signals: every consumer backend already
+  // lives at `apps/<app>/api` (row 2), while the only packages those two deps would catch are
+  // libraries (`packages/lib-core` in both consumers, the infra-kit CLI itself) — a lambda types
+  // dependency alone never means backend, exactly as `react` alone never means frontend.
+  { type: "backend", packages: ["serverless"] }
+];
+var fromDirectory = (packageDir, repoRoot) => {
+  const segments = path2.relative(repoRoot, packageDir).split(path2.sep).filter((segment) => {
+    return segment !== "" && segment !== ".";
   });
+  const [first, , third] = segments;
+  if (segments.length === 3 && first === "apps" && third !== void 0) {
+    const appType = APP_DIRECTORY_TYPES[third];
+    if (appType) return appType;
+  }
+  return segments.at(-1) === MOBILE_BASENAME ? "mobile" : null;
 };
-var findAdjacencyViolations = (components, declIndexByName) => {
+var fromDependencies = (pkgJson) => {
+  const deps = /* @__PURE__ */ new Set([
+    ...Object.keys(pkgJson.dependencies ?? {}),
+    ...Object.keys(pkgJson.devDependencies ?? {}),
+    ...Object.keys(pkgJson.peerDependencies ?? {})
+  ]);
+  for (const signal of DEPENDENCY_SIGNALS) {
+    if (signal.packages.some((name) => {
+      return deps.has(name);
+    }))
+      return signal.type;
+  }
+  const isViteReactApp = deps.has("vite") && deps.has("react") && Boolean(pkgJson.scripts?.dev);
+  return isViteReactApp ? "frontend" : null;
+};
+var detectPackageType = ({
+  packageDir,
+  repoRoot,
+  pkgJson,
+  declaredType
+}) => {
+  return declaredType ?? fromDirectory(packageDir, repoRoot) ?? fromDependencies(pkgJson) ?? "lib";
+};
+
+// src/utils/package-type-reader.ts
+import fs2 from "node:fs";
+import path3 from "node:path";
+var BLOCK_COMMENT = /\/\*[\s\S]*?\*\//g;
+var FULL_LINE_COMMENT = /^[ \t]*\/\/.*$/gm;
+var DECLARED_TYPE = new RegExp(`(?:^|[\\s{,])type:\\s*['"](${PACKAGE_TYPES.join("|")})['"]`, "m");
+var readDeclaredType = (text) => {
+  const stripped = text.replace(BLOCK_COMMENT, "").replace(FULL_LINE_COMMENT, "");
+  const literal = DECLARED_TYPE.exec(stripped)?.[1];
+  return PACKAGE_TYPES.find((candidate) => {
+    return candidate === literal;
+  });
+};
+var typeCache = /* @__PURE__ */ new Map();
+var configMtimeMs = (configPath) => {
+  try {
+    return fs2.statSync(configPath).mtimeMs;
+  } catch {
+    return -1;
+  }
+};
+var readManifest = (manifestPath) => {
+  try {
+    return JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+  } catch {
+    return {};
+  }
+};
+var resolvePackageType = (packageRoot) => {
+  const configPath = path3.posix.join(packageRoot, CONFIG_FILENAME);
+  const mtimeMs = configMtimeMs(configPath);
+  const hit = typeCache.get(packageRoot);
+  if (hit !== void 0 && hit.mtimeMs === mtimeMs) {
+    return hit.type;
+  }
+  const declaredType = mtimeMs >= 0 ? readDeclaredType(fs2.readFileSync(configPath, "utf8")) : void 0;
+  const type = detectPackageType({
+    packageDir: packageRoot,
+    repoRoot: findRepoRoot(packageRoot) ?? packageRoot,
+    pkgJson: readManifest(path3.posix.join(packageRoot, "package.json")),
+    declaredType
+  });
+  typeCache.set(packageRoot, { mtimeMs, type });
+  return type;
+};
+
+// src/utils/component-file-scope.ts
+var DUMB_COMPONENT_PATHS = ["**/features/*/components/**/*.tsx", "**/*-component.tsx"];
+var NON_UI_TYPES = /* @__PURE__ */ new Set(["backend", "e2e"]);
+var STORY_OR_TEST_DIR = /(?:^|\/)(?:__tests__|__stories__)\//;
+var STORY_OR_TEST_EXT = /\.(?:stories|test|spec)\.[cm]?[jt]sx?$/;
+var isStoryOrTestFile = (filename) => {
+  return STORY_OR_TEST_DIR.test(filename) || STORY_OR_TEST_EXT.test(filename);
+};
+var isUiPackageFile = (filename) => {
+  const packageRoot = findPackageRoot(filename);
+  return packageRoot === null || !NON_UI_TYPES.has(resolvePackageType(packageRoot));
+};
+var isInScope = (filename, paths, ignore) => {
+  if (ignore.length > 0 && matchesAnyGlob(filename, ignore)) {
+    return false;
+  }
+  return paths.length === 0 || matchesAnyGlob(filename, paths);
+};
+
+// src/utils/exported-components.ts
+var fromFunctionDeclaration = (node) => {
+  if (!isComponent(node)) {
+    return null;
+  }
+  return { name: node.id?.name ?? null, id: node.id ?? null, declaration: node.id ? node : null, fn: node };
+};
+var fromVariableDeclaration = (node) => {
+  return node.declarations.flatMap((declarator) => {
+    const fn = getComponentFunction(declarator.init);
+    if (!fn || declarator.id.type !== "Identifier" || !isComponent(fn)) {
+      return [];
+    }
+    return [{ name: declarator.id.name, id: declarator.id, declaration: declarator, fn }];
+  });
+};
+var fromDeclaration = (node) => {
+  if (node?.type === "FunctionDeclaration") {
+    const component = fromFunctionDeclaration(node);
+    return component ? [component] : [];
+  }
+  if (node?.type === "VariableDeclaration") {
+    return fromVariableDeclaration(node);
+  }
+  return [];
+};
+var collectLocalComponents = (body) => {
+  const local = /* @__PURE__ */ new Map();
+  for (const statement of body) {
+    for (const component of fromDeclaration(statement)) {
+      if (component.name !== null) {
+        local.set(component.name, component);
+      }
+    }
+  }
+  return local;
+};
+var fromDefaultExport = (declaration, local) => {
+  if (declaration.type === "Identifier") {
+    const component = local.get(declaration.name);
+    return component ? [component] : [];
+  }
+  const node = declaration;
+  if (node.type === "FunctionDeclaration" && node.id) {
+    return fromDeclaration(node);
+  }
+  const fn = getComponentFunction(node);
+  return fn && isComponent(fn) ? [{ name: null, id: null, declaration: null, fn }] : [];
+};
+var fromStatement = (statement, local) => {
+  if (statement.type === "ExportDefaultDeclaration") {
+    return fromDefaultExport(statement.declaration, local);
+  }
+  if (statement.type !== "ExportNamedDeclaration") {
+    return [];
+  }
+  if (statement.declaration) {
+    return fromDeclaration(statement.declaration);
+  }
+  if (statement.source) {
+    return [];
+  }
+  return statement.specifiers.flatMap((specifier) => {
+    const component = specifier.local.type === "Identifier" ? local.get(specifier.local.name) : void 0;
+    return component ? [component] : [];
+  });
+};
+var collectExportedComponents = (program) => {
+  const local = collectLocalComponents(program.body);
+  const found = program.body.flatMap((statement) => {
+    return fromStatement(statement, local);
+  });
+  return [...new Set(found)];
+};
+
+// src/rules/component-classname/component-classname.ts
+var MAX_ALIAS_DEPTH = 5;
+var isClassNameMember = (member) => {
+  if (member.type !== "TSPropertySignature" || member.computed) {
+    return false;
+  }
+  return member.key?.name === "className" || member.key?.value === "className";
+};
+var findTypeDeclaration = (program, name) => {
+  for (const statement of program.body) {
+    const node = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+    if ((node?.type === "TSInterfaceDeclaration" || node?.type === "TSTypeAliasDeclaration") && node.id?.name === name) {
+      return node;
+    }
+  }
+  return null;
+};
+var fromMembers = (members, body) => {
+  return { hasClassName: members.some(isClassNameMember), container: { members, body } };
+};
+var fromIntersection = (shapes) => {
+  if (shapes.some((shape) => {
+    return shape?.hasClassName;
+  })) {
+    return { hasClassName: true, container: null };
+  }
+  if (shapes.includes(null)) {
+    return null;
+  }
+  return {
+    hasClassName: false,
+    container: shapes.findLast((shape) => {
+      return shape?.container;
+    })?.container ?? null
+  };
+};
+var resolveShape = (program, type, depth) => {
+  if (!type || depth > MAX_ALIAS_DEPTH) {
+    return null;
+  }
+  if (type.type === "TSTypeLiteral") {
+    return fromMembers(type.members ?? [], type);
+  }
+  if (type.type === "TSIntersectionType") {
+    return fromIntersection(
+      (type.types ?? []).map((part) => {
+        return resolveShape(program, part, depth + 1);
+      })
+    );
+  }
+  if (type.type !== "TSTypeReference" || type.typeName?.type !== "Identifier" || type.typeArguments) {
+    return null;
+  }
+  const declaration = findTypeDeclaration(program, type.typeName.name);
+  if (declaration?.type === "TSTypeAliasDeclaration") {
+    return resolveShape(program, declaration.typeAnnotation, depth + 1);
+  }
+  if (!declaration?.body) {
+    return null;
+  }
+  const shape = fromMembers(declaration.body.body, declaration.body);
+  return shape?.hasClassName || !declaration.extends?.length ? shape : null;
+};
+var bindingFromObjectPattern = (pattern) => {
+  const destructured = pattern.properties.find((property) => {
+    return property.type === "Property" && !property.computed && property.key.type === "Identifier" && property.key.name === "className";
+  });
+  if (destructured) {
+    const value = destructured.value.type === "AssignmentPattern" ? destructured.value.left : destructured.value;
+    return value.type === "Identifier" ? { kind: "identifier", name: value.name } : null;
+  }
+  const rest = pattern.properties.find((property) => {
+    return property.type === "RestElement";
+  });
+  return rest?.argument.type === "Identifier" ? { kind: "member", object: rest.argument.name } : null;
+};
+var bindingsFromBody = (fn, propsName) => {
+  const statements = fn.body.type === "BlockStatement" ? fn.body.body : [];
+  return statements.flatMap((statement) => {
+    if (statement.type !== "VariableDeclaration") {
+      return [];
+    }
+    return statement.declarations.flatMap((declarator) => {
+      const isPropsDestructure = declarator.id.type === "ObjectPattern" && declarator.init?.type === "Identifier" && declarator.init.name === propsName;
+      const binding = isPropsDestructure ? bindingFromObjectPattern(declarator.id) : null;
+      return binding ? [binding] : [];
+    });
+  });
+};
+var getClassNameBindings = (fn) => {
+  const param = fn.params[0];
+  const pattern = param ? getAnnotatedParam(param) : null;
+  if (pattern?.type === "Identifier") {
+    return [{ kind: "member", object: pattern.name }, ...bindingsFromBody(fn, pattern.name)];
+  }
+  const binding = pattern?.type === "ObjectPattern" ? bindingFromObjectPattern(pattern) : null;
+  return binding ? [binding] : [];
+};
+var matchesBinding = (node, binding) => {
+  if (binding.kind === "identifier") {
+    return node.type === "Identifier" && node.name === binding.name;
+  }
+  return node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === binding.object && node.property.type === "Identifier" && node.property.name === "className";
+};
+var referencesBinding = (node, binding, visitorKeys) => {
+  if (matchesBinding(node, binding)) {
+    return true;
+  }
+  const label = node.type === "MemberExpression" ? "property" : "key";
+  const keys = (visitorKeys[node.type] ?? []).filter((key) => {
+    return !(key === label && "computed" in node && !node.computed);
+  });
+  return keys.some((key) => {
+    const child = node[key];
+    const children = Array.isArray(child) ? child : [child];
+    return children.some((item) => {
+      return item !== null && typeof item?.type === "string" && referencesBinding(item, binding, visitorKeys);
+    });
+  });
+};
+var isFragment = (element) => {
+  const name = element.openingElement?.name;
+  if (name?.type === "JSXIdentifier") {
+    return name.name === "Fragment";
+  }
+  return name?.type === "JSXMemberExpression" && name.property?.name === "Fragment";
+};
+var getRootElement = (fn) => {
+  const returns = collectOwnReturnArguments(fn);
+  const root = returns.length === 1 ? returns[0] : null;
+  return root?.type === "JSXElement" && !isFragment(root) ? root : null;
+};
+var buildMemberFix = (sourceCode, container) => {
+  return (fixer) => {
+    const last = container.members.at(-1);
+    if (!last) {
+      return fixer.replaceTextRange(container.body.range, "{ className?: string }");
+    }
+    const separator = /[;,]$/.exec(sourceCode.text.slice(...last.range))?.[0] ?? "";
+    if (container.body.loc.start.line === container.body.loc.end.line) {
+      return fixer.insertTextAfterRange(
+        last.range,
+        separator ? ` className?: string${separator}` : "; className?: string"
+      );
+    }
+    const indent = /^\s*/.exec(sourceCode.lines[last.loc.start.line - 1])[0];
+    return fixer.insertTextAfterRange(last.range, `
+${indent}className?: string${separator}`);
+  };
+};
+var componentClassname = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "Require a dumb component to declare a `className` prop and merge it into its root element (`className={cn(..., className)}`).",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#component-classname"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: `Glob patterns of the files to check. Replaces the default (${DUMB_COMPONENT_PATHS.join(", ")}).`
+          },
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Glob patterns of files to skip (e.g. svg sprites, icons), even if they also match `paths`. Stories and tests are always skipped."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      missingClassNameProp: "`{{name}}` must accept a `className` prop: declare `className?: string` on its props type so callers can position it.",
+      rootMissingClassName: "The root element of `{{name}}` must merge the `className` prop, e.g. `className={cn('\u2026', className)}`."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    if (isStoryOrTestFile(filename) || !isInScope(filename, options.paths ?? DUMB_COMPONENT_PATHS, options.ignore ?? []) || !isUiPackageFile(filename)) {
+      return {};
+    }
+    const { sourceCode } = context;
+    const checkProps = (program, component, name) => {
+      const param = component.fn.params[0];
+      if (!param) {
+        context.report({ node: component.id ?? component.fn, messageId: "missingClassNameProp", data: { name } });
+        return;
+      }
+      const annotation = getAnnotatedParam(param).typeAnnotation?.typeAnnotation;
+      const shape = annotation ? resolveShape(program, annotation, 0) : null;
+      if (shape && !shape.hasClassName) {
+        context.report({
+          node: param,
+          messageId: "missingClassNameProp",
+          data: { name },
+          fix: shape.container ? buildMemberFix(sourceCode, shape.container) : null
+        });
+      }
+    };
+    const checkRoot = (component, name) => {
+      const root = getRootElement(component.fn);
+      const attributes = root?.openingElement?.attributes ?? [];
+      if (!root || attributes.some((attribute2) => {
+        return attribute2.type === "JSXSpreadAttribute";
+      })) {
+        return;
+      }
+      const attribute = attributes.find((candidate) => {
+        return candidate.type === "JSXAttribute" && candidate.name?.name === "className";
+      });
+      const bindings = getClassNameBindings(component.fn);
+      const expression = attribute?.value?.type === "JSXExpressionContainer" ? attribute.value.expression ?? null : null;
+      const merged = expression !== null && bindings.some((binding) => {
+        return referencesBinding(expression, binding, sourceCode.visitorKeys);
+      });
+      if (!merged) {
+        context.report({
+          node: attribute ?? root.openingElement.name,
+          messageId: "rootMissingClassName",
+          data: { name }
+        });
+      }
+    };
+    return {
+      Program(program) {
+        for (const component of collectExportedComponents(program)) {
+          const name = component.name ?? "this component";
+          checkProps(program, component, name);
+          checkRoot(component, name);
+        }
+      }
+    };
+  }
+};
+
+// src/rules/component-file-order/component-file-order.ts
+var PROPS_SUFFIX = "Props";
+var getDirectivePrologueCount = (body) => {
+  let count = 0;
+  for (const statement of body) {
+    const isStringExpression = statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string";
+    if (!isStringExpression) {
+      break;
+    }
+    count += 1;
+  }
+  return count;
+};
+var getTypeDeclName = (node) => {
+  if (!node) {
+    return null;
+  }
+  const named = node;
+  if (named.type !== "TSInterfaceDeclaration" && named.type !== "TSTypeAliasDeclaration") {
+    return null;
+  }
+  return named.id?.name ?? null;
+};
+var collectTopLevel = (body) => {
+  const importIndices = [];
+  const components = [];
+  const declIndexByName = /* @__PURE__ */ new Map();
+  const importedNames = /* @__PURE__ */ new Set();
+  for (const [index, statement] of body.entries()) {
+    if (statement.type === "ImportDeclaration") {
+      importIndices.push(index);
+      for (const specifier of statement.specifiers) {
+        importedNames.add(specifier.local.name);
+      }
+      continue;
+    }
+    const declaration = unwrapExport(statement);
+    const declName = getTypeDeclName(declaration);
+    if (declName !== null && !declIndexByName.has(declName)) {
+      declIndexByName.set(declName, index);
+    }
+    if (declaresComponent(declaration)) {
+      const name = getDeclaredComponentName(declaration);
+      const propsName = getComponentPropsTypeName(declaration) ?? (name === null ? null : `${name}${PROPS_SUFFIX}`);
+      components.push({ index, name, propsName });
+    }
+  }
+  return { importIndices, components, declIndexByName, importedNames };
+};
+var hasStrayBefore = (body, boundary, directiveCount, skipIndex) => {
+  return body.some((statement, index) => {
+    return index < boundary && index >= directiveCount && index !== skipIndex && statement.type !== "ImportDeclaration";
+  });
+};
+var ANONYMOUS_COMPONENT = "component";
+var findImportOrderViolations = (importIndices, importBoundary) => {
+  return importIndices.filter((importIndex) => {
+    return importIndex > importBoundary;
+  }).map((importIndex) => {
+    return { index: importIndex, messageId: "importsFirst" };
+  });
+};
+var findAdjacencyViolations = (components, declIndexByName) => {
   const violations = [];
   const referenceCount = /* @__PURE__ */ new Map();
   for (const component of components) {
@@ -520,167 +1163,264 @@ var componentFileOrder = {
   }
 };
 
-// src/utils/package-root.ts
-import fs from "node:fs";
-import path from "node:path";
-var CONFIG_FILENAME = "infra-kit.config.ts";
-var PACKAGE_MARKERS = [CONFIG_FILENAME, "package.json"];
-var REPO_MARKERS = ["pnpm-workspace.yaml"];
-var hasAnyMarker = (dir, markers) => {
-  return markers.some((marker) => {
-    return fs.existsSync(path.posix.join(dir, marker));
+// src/rules/component-name-matches-file/component-name-matches-file.ts
+import path4 from "node:path";
+var DEFAULT_PATHS = ["**/features/**", "**/*-component.tsx", "**/*-container.tsx"];
+var DEFAULT_IGNORE = ["**/pages/**", "**/routes/**", "**/renderer/**", "**/primitives/**"];
+var SUFFIX_BY_DIR = {
+  components: "-component",
+  containers: "-container"
+};
+var toPascalCase = (basename) => {
+  return basename.split(/[-_.]/).filter(Boolean).map((part) => {
+    return part[0].toUpperCase() + part.slice(1);
+  }).join("");
+};
+var requiredSuffix = (dirs) => {
+  const featureRoot2 = dirs.indexOf("features") + 2;
+  const index = dirs.findLastIndex((name, position) => {
+    return name in SUFFIX_BY_DIR && featureRoot2 > 1 && position >= featureRoot2;
   });
-};
-var rootCache = /* @__PURE__ */ new Map();
-var findUp = (startDir, markers) => {
-  let current = startDir;
-  while (!hasAnyMarker(current, markers)) {
-    const parent = path.posix.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-  return current;
-};
-var findPackageRoot = (filename) => {
-  if (!path.posix.isAbsolute(filename)) {
+  if (index === -1) {
     return null;
   }
-  const dir = path.posix.dirname(filename);
-  const cached = rootCache.get(dir);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const root = findUp(dir, PACKAGE_MARKERS);
-  rootCache.set(dir, root);
-  return root;
+  const dir = dirs[index];
+  return { dir, suffix: SUFFIX_BY_DIR[dir] };
 };
-var dirsUnderSrc = (packageRoot, filename) => {
-  const srcPrefix = `${packageRoot}/src/`;
-  if (!filename.startsWith(srcPrefix)) {
-    return null;
-  }
-  return filename.slice(srcPrefix.length).split("/").slice(0, -1);
+var findVariable = (sourceCode, component) => {
+  return sourceCode.getDeclaredVariables(component.declaration).find((variable) => {
+    return variable.name === component.name;
+  });
 };
-var findRepoRoot = (packageRoot) => {
-  return findUp(packageRoot, REPO_MARKERS);
+var renameFix = (variable, expected) => {
+  return (fixer) => {
+    const nodes = [
+      ...variable.identifiers,
+      ...variable.references.map((reference) => {
+        return reference.identifier;
+      })
+    ];
+    const ranges = new Map(
+      nodes.map((node) => {
+        return [node.range.join(":"), node.range];
+      })
+    );
+    return [...ranges.values()].map((range) => {
+      return fixer.replaceTextRange(range, expected);
+    });
+  };
 };
-
-// ../config/dist/package-type.js
-import path2 from "node:path";
-var PACKAGE_TYPES = ["frontend", "backend", "lib", "e2e", "mobile"];
-var APP_DIRECTORY_TYPES = {
-  ui: "frontend",
-  api: "backend",
-  tests: "e2e"
+var componentNameMatchesFile = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      description: "Require a `.tsx` file's exported component to be named after the file (`abroad-slider-component.tsx` \u2192 `AbroadSliderComponent`), and files under `components/` / `containers/` to end with `-component` / `-container`.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#component-name-matches-file"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: `Glob patterns of files to check. Replaces the default (${DEFAULT_PATHS.join(", ")}).`
+          },
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: `Glob patterns of files to skip, even if they also match \`paths\`. Replaces the default (${DEFAULT_IGNORE.join(", ")}).`
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      nameMismatch: "The exported component in `{{file}}` must be named `{{expected}}`, but it is named `{{actual}}`.",
+      wrongSuffix: "A file under `{{dir}}/` must be named `*{{suffix}}.tsx`, but it is `{{file}}`.",
+      renameComponent: "Rename `{{actual}}` to `{{expected}}`."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    const file = path4.posix.basename(filename);
+    if (!file.endsWith(".tsx") || file === "index.tsx" || isStoryOrTestFile(filename) || !isInScope(filename, options.paths ?? DEFAULT_PATHS, options.ignore ?? DEFAULT_IGNORE) || !isUiPackageFile(filename)) {
+      return {};
+    }
+    const basename = file.slice(0, -".tsx".length);
+    const expected = toPascalCase(basename);
+    return {
+      Program(program) {
+        const suffixRule = requiredSuffix(path4.posix.dirname(filename).split("/"));
+        if (suffixRule && !basename.endsWith(suffixRule.suffix)) {
+          context.report({
+            node: program,
+            loc: { line: 1, column: 0 },
+            messageId: "wrongSuffix",
+            data: { ...suffixRule, file }
+          });
+        }
+        const named = collectExportedComponents(program).filter((component2) => {
+          return component2.name !== null;
+        });
+        if (named.length !== 1 || named[0].name === expected) {
+          return;
+        }
+        const component = named[0];
+        const actual = component.name;
+        const variable = findVariable(context.sourceCode, component);
+        const moduleScope = context.sourceCode.getScope(program).childScopes[0] ?? context.sourceCode.getScope(program);
+        const nameTaken = moduleScope.set.has(expected);
+        context.report({
+          node: component.id,
+          messageId: "nameMismatch",
+          data: { file, expected, actual },
+          suggest: variable && !nameTaken ? [{ messageId: "renameComponent", data: { actual, expected }, fix: renameFix(variable, expected) }] : []
+        });
+      }
+    };
+  }
 };
-var MOBILE_BASENAME = "mobile-app";
-var DEPENDENCY_SIGNALS = [
-  { type: "e2e", packages: ["@playwright/test"] },
-  { type: "mobile", packages: ["@capacitor/core", "@capacitor/cli"] },
-  // `aws-lambda` / `@types/aws-lambda` are deliberately NOT signals: every consumer backend already
-  // lives at `apps/<app>/api` (row 2), while the only packages those two deps would catch are
-  // libraries (`packages/lib-core` in both consumers, the infra-kit CLI itself) — a lambda types
-  // dependency alone never means backend, exactly as `react` alone never means frontend.
-  { type: "backend", packages: ["serverless"] }
+
+// src/rules/dumb-component-purity/dumb-component-purity.ts
+var DEFAULT_ALLOWED_HOOKS = [
+  "useState",
+  "useRef",
+  "useMemo",
+  "useCallback",
+  "useId",
+  "useEffect",
+  "useLayoutEffect",
+  "useImperativeHandle"
 ];
-var fromDirectory = (packageDir, repoRoot) => {
-  const segments = path2.relative(repoRoot, packageDir).split(path2.sep).filter((segment) => {
-    return segment !== "" && segment !== ".";
-  });
-  const [first, , third] = segments;
-  if (segments.length === 3 && first === "apps" && third !== void 0) {
-    const appType = APP_DIRECTORY_TYPES[third];
-    if (appType) return appType;
+var EFFECT_HOOKS = /* @__PURE__ */ new Set(["useEffect", "useLayoutEffect"]);
+var HOOK_NAME = /^use[A-Z]/;
+var ANALYTICS = /analytics/i;
+var getHookName = (callee) => {
+  if (callee.type === "Identifier") {
+    return HOOK_NAME.test(callee.name) ? callee.name : null;
   }
-  return segments.at(-1) === MOBILE_BASENAME ? "mobile" : null;
-};
-var fromDependencies = (pkgJson) => {
-  const deps = /* @__PURE__ */ new Set([
-    ...Object.keys(pkgJson.dependencies ?? {}),
-    ...Object.keys(pkgJson.devDependencies ?? {}),
-    ...Object.keys(pkgJson.peerDependencies ?? {})
-  ]);
-  for (const signal of DEPENDENCY_SIGNALS) {
-    if (signal.packages.some((name) => {
-      return deps.has(name);
-    }))
-      return signal.type;
+  if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.type === "Identifier" && HOOK_NAME.test(callee.property.name)) {
+    return callee.property.name;
   }
-  const isViteReactApp = deps.has("vite") && deps.has("react") && Boolean(pkgJson.scripts?.dev);
-  return isViteReactApp ? "frontend" : null;
-};
-var detectPackageType = ({
-  packageDir,
-  repoRoot,
-  pkgJson,
-  declaredType
-}) => {
-  return declaredType ?? fromDirectory(packageDir, repoRoot) ?? fromDependencies(pkgJson) ?? "lib";
-};
-
-// src/utils/package-type-reader.ts
-import fs2 from "node:fs";
-import path3 from "node:path";
-var BLOCK_COMMENT = /\/\*[\s\S]*?\*\//g;
-var FULL_LINE_COMMENT = /^[ \t]*\/\/.*$/gm;
-var DECLARED_TYPE = new RegExp(`(?:^|[\\s{,])type:\\s*['"](${PACKAGE_TYPES.join("|")})['"]`, "m");
-var readDeclaredType = (text) => {
-  const stripped = text.replace(BLOCK_COMMENT, "").replace(FULL_LINE_COMMENT, "");
-  const literal = DECLARED_TYPE.exec(stripped)?.[1];
-  return PACKAGE_TYPES.find((candidate) => {
-    return candidate === literal;
-  });
+  return null;
 };
-var typeCache = /* @__PURE__ */ new Map();
-var configMtimeMs = (configPath) => {
-  try {
-    return fs2.statSync(configPath).mtimeMs;
-  } catch {
-    return -1;
+var calleeNames = (node) => {
+  if (node.type === "Identifier") {
+    return [node.name];
+  }
+  if (node.type === "MemberExpression") {
+    const property = !node.computed && node.property.type === "Identifier" ? [node.property.name] : [];
+    return [...calleeNames(node.object), ...property];
   }
+  return [];
 };
-var readManifest = (manifestPath) => {
-  try {
-    return JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
-  } catch {
-    return {};
+var rootObjectName = (node) => {
+  if (node.type === "Identifier") {
+    return node.name;
   }
+  return node.type === "MemberExpression" ? rootObjectName(node.object) : null;
 };
-var resolvePackageType = (packageRoot) => {
-  const configPath = path3.posix.join(packageRoot, CONFIG_FILENAME);
-  const mtimeMs = configMtimeMs(configPath);
-  const hit = typeCache.get(packageRoot);
-  if (hit !== void 0 && hit.mtimeMs === mtimeMs) {
-    return hit.type;
+var isSideEffectCall = (callee) => {
+  if (callee.type === "Identifier" && callee.name === "fetch") {
+    return true;
   }
-  const declaredType = mtimeMs >= 0 ? readDeclaredType(fs2.readFileSync(configPath, "utf8")) : void 0;
-  const type = detectPackageType({
-    packageDir: packageRoot,
-    repoRoot: findRepoRoot(packageRoot) ?? packageRoot,
-    pkgJson: readManifest(path3.posix.join(packageRoot, "package.json")),
-    declaredType
+  if (callee.type === "MemberExpression" && rootObjectName(callee) === "httpClient") {
+    return true;
+  }
+  return calleeNames(callee).some((name) => {
+    return ANALYTICS.test(name);
   });
-  typeCache.set(packageRoot, { mtimeMs, type });
-  return type;
+};
+var dumbComponentPurity = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Keep dumb components pure: only React's local-state hooks are allowed, and effects may not fetch, call `httpClient` or send analytics.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#dumb-component-purity"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: `Glob patterns of the files to check. Replaces the default (${DUMB_COMPONENT_PATHS.join(", ")}).`
+          },
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Glob patterns of files to skip, even if they also match `paths`. Stories and tests are always skipped."
+          },
+          allowHooks: {
+            type: "array",
+            items: { type: "string" },
+            description: `Hooks allowed on top of the defaults (${DEFAULT_ALLOWED_HOOKS.join(", ")}), e.g. UI-library hooks like \`useMediaQuery\`.`
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      forbiddenHook: '"{{hook}}" is not in the allowed hook list for dumb components. Call it in the container and pass the value as a prop.',
+      sideEffectInEffect: "`{{call}}` is a side effect a dumb component must not run. Move it to the container and pass a callback or the result as a prop."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    if (isStoryOrTestFile(filename) || !isInScope(filename, options.paths ?? DUMB_COMPONENT_PATHS, options.ignore ?? []) || !isUiPackageFile(filename)) {
+      return {};
+    }
+    const allowed = /* @__PURE__ */ new Set([...DEFAULT_ALLOWED_HOOKS, ...options.allowHooks ?? []]);
+    const effectCallbacks = /* @__PURE__ */ new Set();
+    return {
+      CallExpression(node) {
+        const hook = getHookName(node.callee);
+        if (hook !== null && !allowed.has(hook)) {
+          context.report({ node: node.callee, messageId: "forbiddenHook", data: { hook } });
+        }
+        if (hook !== null && EFFECT_HOOKS.has(hook) && node.arguments[0]) {
+          effectCallbacks.add(node.arguments[0]);
+        }
+        if (!isSideEffectCall(node.callee)) {
+          return;
+        }
+        const inEffect = context.sourceCode.getAncestors(node).some((ancestor) => {
+          return effectCallbacks.has(ancestor);
+        });
+        if (inEffect) {
+          context.report({
+            node: node.callee,
+            messageId: "sideEffectInEffect",
+            data: { call: context.sourceCode.getText(node.callee) }
+          });
+        }
+      }
+    };
+  }
 };
 
 // src/utils/playwright-call.ts
 var TEST_MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "fixme", "fail"]);
 var DESCRIBE_MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "fixme", "serial", "parallel"]);
-var calleeNames = (callee) => {
+var calleeNames2 = (callee) => {
   if (callee.type === "Identifier") {
     return [callee.name];
   }
   if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier") {
     return null;
   }
-  const head = calleeNames(callee.object);
+  const head = calleeNames2(callee.object);
   return head === null ? null : [...head, callee.property.name];
 };
 var playwrightCallKind = (node) => {
-  const names = calleeNames(node.callee);
+  const names = calleeNames2(node.callee);
   if (names === null || names[0] !== "test") {
     return null;
   }
@@ -714,7 +1454,7 @@ var testStatementNames = (statement) => {
   if (statement.type !== "ExpressionStatement" || statement.expression.type !== "CallExpression") {
     return null;
   }
-  const names = calleeNames(statement.expression.callee);
+  const names = calleeNames2(statement.expression.callee);
   return names?.[0] === "test" ? names : null;
 };
 var isInE2ePackage = (context) => {
@@ -1641,8 +2381,12 @@ var e2eTopLevelDescribe = {
   }
 };
 
+// src/rules/feature-files/feature-files.ts
+import fs3 from "node:fs";
+import path6 from "node:path";
+
 // src/utils/import-target.ts
-import path4 from "node:path";
+import path5 from "node:path";
 var DEFAULT_ROOT_ALIAS = "#root";
 var INDEX_FILE = /^index(?:\.[cm]?[jt]sx?)?$/;
 var literalValue = (source) => {
@@ -1678,9 +2422,9 @@ var srcDirOf = (filename) => {
 var resolveUnderSrc = (filename, srcDir, specifier, rootAlias) => {
   let absolute;
   if (specifier === rootAlias || specifier.startsWith(`${rootAlias}/`)) {
-    absolute = path4.posix.join(srcDir, specifier.slice(rootAlias.length));
+    absolute = path5.posix.join(srcDir, specifier.slice(rootAlias.length));
   } else if (specifier.startsWith(".")) {
-    absolute = path4.posix.resolve(path4.posix.dirname(filename), specifier);
+    absolute = path5.posix.resolve(path5.posix.dirname(filename), specifier);
   } else {
     return null;
   }
@@ -1714,6 +2458,132 @@ var isLayeredFile = (filename, ignore) => {
   return packageRoot === null || !UNLAYERED_TYPES.has(resolvePackageType(packageRoot));
 };
 
+// src/rules/feature-files/feature-files.ts
+var ROOT_FILES = ["index", "types", "services", "analytics", "constants", "translates"];
+var SERVICE_FILES = ["main", "api", "libs", "index", "types", "constants"];
+var SERVICES = "services";
+var TEST_OR_STORY_DIR = /\/__(?:tests|stories)__\//;
+var EXEMPT_FILE = /\.(?:(?:test|spec|stories)\.[cm]?[jt]sx?|d\.[cm]?ts)$/;
+var stemOf = (basename) => {
+  return basename.slice(0, basename.length - path6.posix.extname(basename).length);
+};
+var describeAllowed = (stems) => {
+  return stems.map((stem) => {
+    return `${stem}.ts`;
+  }).join(", ");
+};
+var isServiceFile = (filename, dirs) => {
+  return dirs[2] === SERVICES || dirs.length === 2 && stemOf(path6.posix.basename(filename)) === SERVICES;
+};
+var findNameViolation = (filename, dirs, options) => {
+  const basename = path6.posix.basename(filename);
+  const stem = stemOf(basename);
+  if (dirs.length === 2) {
+    const allowed = [...ROOT_FILES, ...options.extraRootFiles ?? []];
+    if (!allowed.includes(stem)) {
+      return { messageId: "unknownRootFile", data: { file: basename, allowed: describeAllowed(allowed) } };
+    }
+    if (stem === SERVICES && fs3.existsSync(path6.posix.join(path6.posix.dirname(filename), SERVICES))) {
+      return { messageId: "servicesFileAndFolder", data: { feature: dirs[1] } };
+    }
+    return null;
+  }
+  if (dirs.length === 3 && dirs[2] === SERVICES) {
+    const allowed = [...SERVICE_FILES, ...options.extraServiceFiles ?? []];
+    if (!allowed.includes(stem)) {
+      return { messageId: "unknownServiceFile", data: { file: basename, allowed: describeAllowed(allowed) } };
+    }
+  }
+  return null;
+};
+var featureFiles = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Allow only the conventional files in a feature root and its `services/`, one of `services.ts` or `services/`, and no JSX in services.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#feature-files"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          extraRootFiles: {
+            type: "array",
+            items: { type: "string", minLength: 1 },
+            uniqueItems: true,
+            description: `File names without extension allowed in a feature root besides ${ROOT_FILES.join(", ")}.`
+          },
+          extraServiceFiles: {
+            type: "array",
+            items: { type: "string", minLength: 1 },
+            uniqueItems: true,
+            description: `File names without extension allowed in \`services/\` besides ${SERVICE_FILES.join(", ")}.`
+          },
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. When provided, the rule only runs for files whose path matches one of them."
+          },
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. The rule is skipped for files whose path matches one of them, even if it also matches `paths`."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unknownRootFile: '"{{file}}" is not an allowed feature-root file. Allowed: {{allowed}}.',
+      unknownServiceFile: '"{{file}}" is not an allowed file in `services/`. Allowed: {{allowed}}.',
+      servicesFileAndFolder: 'Feature "{{feature}}" has both `services.ts` and a `services/` folder. Keep one: move this file into `services/main.ts`, or fold the folder into this file.',
+      jsxInService: "Services hold atoms and pure functions; JSX belongs in a component or container."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    const paths = options.paths ?? [];
+    const ignore = options.ignore ?? [];
+    if (ignore.length > 0 && matchesAnyGlob(filename, ignore)) {
+      return {};
+    }
+    if (paths.length > 0 && !matchesAnyGlob(filename, paths)) {
+      return {};
+    }
+    if (TEST_OR_STORY_DIR.test(filename) || EXEMPT_FILE.test(filename)) {
+      return {};
+    }
+    const srcDir = srcDirOf(filename);
+    if (srcDir === null) {
+      return {};
+    }
+    const dirs = fileDirsUnderSrc(filename, srcDir);
+    if (dirs[0] !== "features" || dirs.length < 2 || !isUiPackageFile(filename)) {
+      return {};
+    }
+    const violation = findNameViolation(filename, dirs, options);
+    const listeners = {};
+    if (violation !== null) {
+      listeners.Program = (program) => {
+        context.report({ ...violation, node: program });
+      };
+    }
+    if (isServiceFile(filename, dirs)) {
+      let reported = false;
+      const reportJsx = (node) => {
+        if (!reported) {
+          reported = true;
+          context.report({ node, messageId: "jsxInService" });
+        }
+      };
+      Object.assign(listeners, { JSXElement: reportJsx, JSXFragment: reportJsx });
+    }
+    return listeners;
+  }
+};
+
 // src/rules/feature-public-api/feature-public-api.ts
 var featurePublicApi = {
   meta: {
@@ -2444,6 +3314,80 @@ var noFeatureSelfImport = {
   }
 };
 
+// src/rules/no-hooks-in-services/no-hooks-in-services.ts
+var DEFAULT_PATHS2 = [
+  "/services/",
+  "/services.ts",
+  "/services.tsx",
+  "/service.ts",
+  "/service.tsx",
+  "/entities/**/model.ts",
+  "/entities/**/model.tsx"
+];
+var HOOK_NAME2 = /^use[A-Z0-9]/;
+var TEST_OR_STORY_DIR2 = /\/__(?:tests|stories)__\//;
+var TEST_OR_STORY_FILE = /\.(?:test|spec|stories)\.[cm]?[jt]sx?$/;
+var noHooksInServices = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow declaring React hooks in services and entity models: they hold atoms and pure functions, the hook belongs in a container or `lib/`.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#no-hooks-in-services"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: `Glob patterns of service files; replaces the default (${DEFAULT_PATHS2.join(", ")}).`
+          },
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional glob patterns. The rule is skipped for files whose path matches one of them, even if it also matches `paths`."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      hookInService: '"{{name}}" is a hook, and services hold only atoms and pure functions. Move it to a container or to `lib/`.'
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    const ignore = options.ignore ?? [];
+    if (ignore.length > 0 && matchesAnyGlob(filename, ignore)) {
+      return {};
+    }
+    if (!matchesAnyGlob(filename, options.paths ?? DEFAULT_PATHS2) || TEST_OR_STORY_DIR2.test(filename) || TEST_OR_STORY_FILE.test(filename) || // Backend packages have `src/services/` too, where `use*` means something else.
+    !isUiPackageFile(filename)) {
+      return {};
+    }
+    const report = (id) => {
+      if (HOOK_NAME2.test(id.name)) {
+        context.report({ node: id, messageId: "hookInService", data: { name: id.name } });
+      }
+    };
+    return {
+      FunctionDeclaration(node) {
+        if (node.id) {
+          report(node.id);
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && (node.init?.type === "ArrowFunctionExpression" || node.init?.type === "FunctionExpression")) {
+          report(node.id);
+        }
+      }
+    };
+  }
+};
+
 // src/rules/package-structure/package-structure.ts
 var DEFAULT_ENTRIES = {
   frontend: {
@@ -2929,10 +3873,10 @@ var propsTypeReference = {
 
 // src/rules/require-component-stories/require-component-stories.ts
 import { existsSync } from "node:fs";
-import path6 from "node:path";
+import path8 from "node:path";
 
 // src/utils/story-path.ts
-import path5 from "node:path";
+import path7 from "node:path";
 var DEFAULT_STORY_PATH_OPTIONS = {
   storiesDir: "__stories__",
   storySuffix: ".stories",
@@ -2951,10 +3895,10 @@ var parse = (filePath) => {
   const normalized = toPosix(filePath);
   const segments = normalized.split("/");
   const basename = segments[segments.length - 1] ?? "";
-  const ext = path5.posix.extname(basename);
+  const ext = path7.posix.extname(basename);
   const base = ext ? basename.slice(0, -ext.length) : basename;
   return {
-    dir: path5.posix.dirname(normalized),
+    dir: path7.posix.dirname(normalized),
     base,
     ext,
     parent: segments[segments.length - 2] ?? "",
@@ -2996,10 +3940,10 @@ var deriveExpectedStoryPaths = (filePath, opts) => {
     return [];
   }
   const parsed = parse(filePath);
-  const storyBaseDir = classification.mode === "feature-root" ? path5.posix.dirname(parsed.dir) : parsed.dir;
-  const storyDir = path5.posix.join(storyBaseDir, options.storiesDir);
+  const storyBaseDir = classification.mode === "feature-root" ? path7.posix.dirname(parsed.dir) : parsed.dir;
+  const storyDir = path7.posix.join(storyBaseDir, options.storiesDir);
   return options.storyExtensions.map((extension) => {
-    return path5.posix.join(storyDir, `${parsed.base}${options.storySuffix}${extension}`);
+    return path7.posix.join(storyDir, `${parsed.base}${options.storySuffix}${extension}`);
   });
 };
 
@@ -3119,7 +4063,7 @@ var requireComponentStories = {
           node: program,
           messageId: "missingStory",
           data: {
-            component: path6.posix.basename(context.filename.split("\\").join("/")),
+            component: path8.posix.basename(context.filename.split("\\").join("/")),
             expected: candidates[0] ?? ""
           }
         });
@@ -3522,7 +4466,13 @@ var rules = {
   "e2e-describe-order": e2eDescribeOrder,
   "e2e-top-level-describe": e2eTopLevelDescribe,
   "e2e-test-tags": e2eTestTags,
-  "e2e-test-title": e2eTestTitle
+  "e2e-test-title": e2eTestTitle,
+  "atom-naming": atomNaming,
+  "no-hooks-in-services": noHooksInServices,
+  "feature-files": featureFiles,
+  "component-name-matches-file": componentNameMatchesFile,
+  "component-classname": componentClassname,
+  "dumb-component-purity": dumbComponentPurity
 };
 
 // src/index.ts
@@ -3530,7 +4480,7 @@ var PLUGIN_NAME = "@wl";
 var plugin = {
   meta: {
     name: "@wl/eslint-plugin",
-    version: "0.43.2"
+    version: "0.44.0"
   },
   rules,
   configs: {}
@@ -3644,6 +4594,22 @@ plugin.configs.recommended = [
       [`${PLUGIN_NAME}/no-feature-self-import`]: "error"
     }
   },
+  // fe-architect naming and purity rules. Each gates itself on path and package type (backend and e2e
+  // packages are skipped), so one repo-wide block is enough.
+  {
+    files: ["**/*.{ts,tsx}"],
+    plugins: {
+      [PLUGIN_NAME]: plugin
+    },
+    rules: {
+      [`${PLUGIN_NAME}/atom-naming`]: "error",
+      [`${PLUGIN_NAME}/no-hooks-in-services`]: "error",
+      [`${PLUGIN_NAME}/feature-files`]: "error",
+      [`${PLUGIN_NAME}/component-name-matches-file`]: "error",
+      [`${PLUGIN_NAME}/component-classname`]: "error",
+      [`${PLUGIN_NAME}/dumb-component-purity`]: "error"
+    }
+  },
   // The e2e rules gate themselves on the package type, so a repo-wide glob costs one cached type
   // lookup per file elsewhere.
   {