@noctcore/eslint-plugin-architecture 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -38,13 +38,26 @@ module.exports = __toCommonJS(index_exports);
 
 // src/configs/recommended.ts
 var recommended = {
+  "noctcore-architecture/barrel-purity": "error",
+  // Ships OFF: this rule does nothing until you name the source globs that must
+  // be tested (there is no universal "everything needs a test" default). Enable
+  // it with your own `include`, e.g.
+  //   'noctcore-architecture/colocated-test-required': ['error', { include: ['**/use*.ts', '**/*.service.ts'] }]
+  "noctcore-architecture/colocated-test-required": "off",
   "noctcore-architecture/component-folder-structure": "error",
+  "noctcore-architecture/filename-matches-export": "error",
   "noctcore-architecture/index-must-reexport-default": "error",
-  "noctcore-architecture/no-cross-feature-imports": "error"
+  "noctcore-architecture/max-import-depth": "error",
+  "noctcore-architecture/no-cross-feature-imports": "error",
+  // Ships OFF: which files it governs and which category mixes they may keep
+  // (a NestJS `.constants.ts` legitimately holds constants, types and enums) is
+  // a per-codebase decision best made from measured counts. Enable it with
+  //   'noctcore-architecture/single-semantic-module': ['error', { allow: [['constant', 'type', 'enum']] }]
+  "noctcore-architecture/single-semantic-module": "off"
 };
 
-// src/rules/component-folder-structure.ts
-var import_node_path2 = __toESM(require("path"), 1);
+// src/rules/barrel-purity.ts
+var import_utils = require("@typescript-eslint/utils");
 
 // src/createRule.ts
 var import_eslint_utils = require("@noctcore/eslint-utils");
@@ -136,8 +149,154 @@ function readDirSafe(dir) {
   }
 }
 
+// src/rules/barrel-purity.ts
+var RULE_NAME = "barrel-purity";
+var DEFAULT_ALLOW = [];
+var BARREL_BASENAME = /^index\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+var optionSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allow: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+function impurityOf(stmt) {
+  switch (stmt.type) {
+    case import_utils.AST_NODE_TYPES.ImportDeclaration:
+      return stmt.specifiers.length === 0 ? "a side-effect import" : null;
+    case import_utils.AST_NODE_TYPES.ExportAllDeclaration:
+      return null;
+    case import_utils.AST_NODE_TYPES.ExportNamedDeclaration:
+      if (stmt.source !== null) {
+        return null;
+      }
+      if (stmt.declaration === null) {
+        return null;
+      }
+      return "a local declaration";
+    case import_utils.AST_NODE_TYPES.ExportDefaultDeclaration:
+      return stmt.declaration.type === import_utils.AST_NODE_TYPES.Identifier ? null : "a default-exported value";
+    case import_utils.AST_NODE_TYPES.ExpressionStatement:
+      return "a side-effect statement";
+    default:
+      return "non-re-export code";
+  }
+}
+var barrelPurityRule = createRule({
+  name: RULE_NAME,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A barrel (`index.ts` / `index.tsx`) must contain only re-exports \u2014 never local declarations, side effects, or default-exported values."
+    },
+    schema: [optionSchema],
+    messages: {
+      impureBarrel: "A barrel must contain only re-exports; found {{kind}}. Move it into a sibling module and re-export it from here."
+    }
+  },
+  defaultOptions: [{ allow: [] }],
+  create(context, [options]) {
+    const allow = options.allow ?? DEFAULT_ALLOW;
+    const filename = context.filename;
+    if (!BARREL_BASENAME.test(getBasename(filename)) || isIgnoredPath(filename, allow)) {
+      return {};
+    }
+    return {
+      Program(node) {
+        for (const stmt of node.body) {
+          const kind = impurityOf(stmt);
+          if (kind !== null) {
+            context.report({ node: stmt, messageId: "impureBarrel", data: { kind } });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/colocated-test-required.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+var RULE_NAME2 = "colocated-test-required";
+var DEFAULT_INCLUDE = [];
+var DEFAULT_IGNORE = [];
+var TEST_SIBLING = /\.(test|spec)\.[^.]+$/;
+var optionSchema2 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    include: { type: "array", items: { type: "string" }, uniqueItems: true },
+    ignore: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+var dirCache = /* @__PURE__ */ new Map();
+function readDirCached(dir) {
+  const cached = dirCache.get(dir);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let entries;
+  try {
+    entries = (0, import_node_fs2.readdirSync)(dir);
+  } catch {
+    entries = [];
+  }
+  dirCache.set(dir, entries);
+  return entries;
+}
+function stemOf(basename) {
+  const ext = import_node_path2.default.extname(basename);
+  return ext === "" ? basename : basename.slice(0, -ext.length);
+}
+function hasColocatedTest(dir, stem) {
+  const prefix = `${stem}.`;
+  return readDirCached(dir).some(
+    (entry) => entry.startsWith(prefix) && TEST_SIBLING.test(entry)
+  );
+}
+var colocatedTestRequiredRule = createRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A source file matching an `include` glob must have a colocated `*.test.*` / `*.spec.*` sibling on disk. Off until `include` is configured."
+    },
+    schema: [optionSchema2],
+    messages: {
+      missingTest: "Source file `{{basename}}` has no colocated test. Add a sibling `{{stem}}.test.*` (or `.spec.*`) next to it."
+    }
+  },
+  defaultOptions: [{ include: [], ignore: [] }],
+  create(context, [options]) {
+    const include = options.include ?? DEFAULT_INCLUDE;
+    const ignore = options.ignore ?? DEFAULT_IGNORE;
+    const filename = context.filename;
+    if (include.length === 0 || !isIgnoredPath(filename, include)) {
+      return {};
+    }
+    const basename = getBasename(filename);
+    if (TEST_SIBLING.test(basename) || isIgnoredPath(filename, ignore)) {
+      return {};
+    }
+    const stem = stemOf(basename);
+    const dir = import_node_path2.default.dirname(filename);
+    return {
+      Program(node) {
+        if (!hasColocatedTest(dir, stem)) {
+          context.report({
+            node,
+            messageId: "missingTest",
+            data: { basename, stem }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/component-folder-structure.ts
-var RULE_NAME = "component-folder-structure";
+var import_node_path3 = __toESM(require("path"), 1);
+var RULE_NAME3 = "component-folder-structure";
 var DEFAULT_COMPONENT_ROOT = "components";
 var DEFAULT_IGNORE_PATHS = ["**/ui/**"];
 var DEFAULT_REQUIRED_SIBLINGS = [
@@ -150,7 +309,7 @@ var DEFAULT_REQUIRED_SIBLINGS = [
 function resolveSibling(template, name) {
   return template.startsWith(".") ? `${name}${template}` : template;
 }
-var optionSchema = {
+var optionSchema3 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -160,13 +319,13 @@ var optionSchema = {
   }
 };
 var componentFolderStructureRule = createRule({
-  name: RULE_NAME,
+  name: RULE_NAME3,
   meta: {
     type: "problem",
     docs: {
       description: "A component `<Name>/<Name>.tsx` under `<componentRoot>/<feature>/...` must have its sibling set (`.hooks.ts`, `.types.ts`, `.stories.tsx`, `.test.tsx`, `index.ts`) present on disk."
     },
-    schema: [optionSchema],
+    schema: [optionSchema3],
     messages: {
       missingSiblings: "Component `{{name}}` is missing sibling file(s): {{missing}}. Every component folder must carry its hooks, types, stories, test, and index barrel."
     }
@@ -190,7 +349,7 @@ var componentFolderStructureRule = createRule({
       return {};
     }
     const name = getComponentName(filename);
-    const dir = import_node_path2.default.dirname(filename);
+    const dir = import_node_path3.default.dirname(filename);
     const required = siblingTemplates.map((template) => resolveSibling(template, name));
     const present = readDirSafe(dir);
     const missing = required.filter((sibling) => !present.has(sibling));
@@ -208,12 +367,164 @@ var componentFolderStructureRule = createRule({
   }
 });
 
+// src/rules/filename-matches-export.ts
+var import_node_path4 = __toESM(require("path"), 1);
+var import_utils5 = require("@typescript-eslint/utils");
+var RULE_NAME4 = "filename-matches-export";
+var DEFAULT_IGNORE2 = [];
+var VALID_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var optionSchema4 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    ignore: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+function stemOf2(filename) {
+  const basename = getBasename(filename);
+  const ext = import_node_path4.default.extname(basename);
+  return ext === "" ? basename : basename.slice(0, -ext.length);
+}
+function normalize(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function namedExportId(decl) {
+  if (decl.declaration === null) {
+    return null;
+  }
+  const d = decl.declaration;
+  switch (d.type) {
+    case import_utils5.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils5.AST_NODE_TYPES.ClassDeclaration:
+      return d.id;
+    case import_utils5.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils5.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils5.AST_NODE_TYPES.TSEnumDeclaration:
+      return d.id;
+    case import_utils5.AST_NODE_TYPES.VariableDeclaration: {
+      const only = d.declarations.length === 1 ? d.declarations[0] : void 0;
+      return only !== void 0 && only.id.type === import_utils5.AST_NODE_TYPES.Identifier ? only.id : null;
+    }
+    default:
+      return null;
+  }
+}
+function defaultExportId(decl) {
+  const d = decl.declaration;
+  if ((d.type === import_utils5.AST_NODE_TYPES.FunctionDeclaration || d.type === import_utils5.AST_NODE_TYPES.ClassDeclaration) && d.id !== null) {
+    return d.id;
+  }
+  return d.type === import_utils5.AST_NODE_TYPES.Identifier ? d : null;
+}
+function resolvePrimary(body) {
+  let hasDefault = false;
+  let defaultId = null;
+  const named = [];
+  for (const stmt of body) {
+    if (stmt.type === import_utils5.AST_NODE_TYPES.ExportDefaultDeclaration) {
+      hasDefault = true;
+      defaultId = defaultExportId(stmt);
+    } else if (stmt.type === import_utils5.AST_NODE_TYPES.ExportNamedDeclaration && stmt.source === null) {
+      const id = namedExportId(stmt);
+      if (id !== null) {
+        named.push(id);
+      } else if (stmt.declaration === null) {
+        for (const spec of stmt.specifiers) {
+          if (spec.exported.type === import_utils5.AST_NODE_TYPES.Identifier) {
+            named.push(spec.exported);
+          }
+        }
+      }
+    }
+  }
+  if (hasDefault) {
+    return defaultId === null ? null : { name: defaultId.name, node: defaultId };
+  }
+  const only = named.length === 1 ? named[0] : void 0;
+  return only !== void 0 ? { name: only.name, node: only } : null;
+}
+function moduleVariable(sourceCode, name) {
+  const globalScope = sourceCode.scopeManager?.globalScope ?? null;
+  if (globalScope === null) {
+    return null;
+  }
+  const moduleScope = globalScope.childScopes[0] ?? globalScope;
+  return moduleScope.variables.find((v) => v.name === name) ?? null;
+}
+var IMPORT_DEF_NODES = /* @__PURE__ */ new Set([
+  import_utils5.AST_NODE_TYPES.ImportSpecifier,
+  import_utils5.AST_NODE_TYPES.ImportDefaultSpecifier,
+  import_utils5.AST_NODE_TYPES.ImportNamespaceSpecifier
+]);
+function isImportBinding(variable) {
+  return variable.defs.some((def) => IMPORT_DEF_NODES.has(def.node.type));
+}
+var filenameMatchesExportRule = createRule({
+  name: RULE_NAME4,
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      description: "A file's basename must match its primary export (a default export, or the sole named export)."
+    },
+    schema: [optionSchema4],
+    messages: {
+      filenameMismatch: "File `{{basename}}` exports `{{name}}` as its primary export \u2014 the basename should match it (rename the file to `{{expected}}`, or the export).",
+      renameExport: "Rename the export to `{{expected}}` to match the filename."
+    }
+  },
+  defaultOptions: [{ ignore: [] }],
+  create(context, [options]) {
+    const ignore = options.ignore ?? DEFAULT_IGNORE2;
+    const filename = context.filename;
+    const stem = stemOf2(filename);
+    if (stem === "index" || isIgnoredPath(filename, ignore)) {
+      return {};
+    }
+    return {
+      Program(node) {
+        const primary = resolvePrimary(node.body);
+        if (primary === null || normalize(primary.name) === normalize(stem)) {
+          return;
+        }
+        const basename = getBasename(filename);
+        const canRename = VALID_IDENTIFIER.test(stem) && stem !== primary.name;
+        context.report({
+          node: primary.node,
+          messageId: "filenameMismatch",
+          data: { basename, name: primary.name, expected: stem },
+          suggest: canRename ? [
+            {
+              messageId: "renameExport",
+              data: { expected: stem },
+              fix: (fixer) => {
+                const variable = moduleVariable(context.sourceCode, primary.name);
+                if (variable !== null && !isImportBinding(variable)) {
+                  const targets = /* @__PURE__ */ new Map();
+                  for (const id of variable.identifiers) {
+                    targets.set(id.range[0], id);
+                  }
+                  for (const ref of variable.references) {
+                    targets.set(ref.identifier.range[0], ref.identifier);
+                  }
+                  return [...targets.values()].map((id) => fixer.replaceText(id, stem));
+                }
+                return [fixer.replaceText(primary.node, stem)];
+              }
+            }
+          ] : void 0
+        });
+      }
+    };
+  }
+});
+
 // src/rules/index-must-reexport-default.ts
-var import_node_path3 = __toESM(require("path"), 1);
-var import_utils2 = require("@typescript-eslint/utils");
-var RULE_NAME2 = "index-must-reexport-default";
+var import_node_path5 = __toESM(require("path"), 1);
+var import_utils7 = require("@typescript-eslint/utils");
+var RULE_NAME5 = "index-must-reexport-default";
 var DEFAULT_IGNORE_PATHS2 = [];
-var optionSchema2 = {
+var optionSchema5 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -225,17 +536,17 @@ function reexportsDefault(node) {
     return false;
   }
   return node.specifiers.some(
-    (specifier) => specifier.local.type === import_utils2.AST_NODE_TYPES.Identifier && specifier.local.name === "default"
+    (specifier) => specifier.local.type === import_utils7.AST_NODE_TYPES.Identifier && specifier.local.name === "default"
   );
 }
 var indexMustReexportDefaultRule = createRule({
-  name: RULE_NAME2,
+  name: RULE_NAME5,
   meta: {
     type: "problem",
     docs: {
       description: "A component folder's `index.ts` must re-export the component default (`export { default as <Name> } from './<Name>'`)."
     },
-    schema: [optionSchema2],
+    schema: [optionSchema5],
     messages: {
       missingDefaultReexport: "`index.ts` must re-export the {{name}} default: `export { default as {{name}} } from './{{name}}'`."
     }
@@ -247,8 +558,8 @@ var indexMustReexportDefaultRule = createRule({
     if (getBasename(filename) !== "index.ts" || isIgnoredPath(filename, ignorePaths)) {
       return {};
     }
-    const dir = import_node_path3.default.dirname(filename);
-    const folderName = import_node_path3.default.basename(dir);
+    const dir = import_node_path5.default.dirname(filename);
+    const folderName = import_node_path5.default.basename(dir);
     if (!isPascalCase(folderName) || !siblingExists(dir, `${folderName}.tsx`)) {
       return {};
     }
@@ -272,14 +583,120 @@ var indexMustReexportDefaultRule = createRule({
   }
 });
 
+// src/rules/max-import-depth.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var import_utils9 = require("@typescript-eslint/utils");
+var RULE_NAME6 = "max-import-depth";
+var DEFAULT_MAX = 3;
+var optionSchema6 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    max: { type: "integer", minimum: 0 },
+    alias: {
+      type: "object",
+      additionalProperties: { type: "string" }
+    }
+  }
+};
+function climbDepth(source) {
+  if (!source.startsWith(".")) {
+    return 0;
+  }
+  let depth = 0;
+  for (const segment of source.split("/")) {
+    if (segment === "..") {
+      depth += 1;
+    } else if (segment === ".") {
+      continue;
+    } else {
+      break;
+    }
+  }
+  return depth;
+}
+function aliasRewrite(source, currentFile, alias) {
+  const resolved = toPosix(import_node_path6.default.resolve(import_node_path6.default.dirname(currentFile), source));
+  for (const [anchor, prefix] of Object.entries(alias)) {
+    const marker = `/${anchor}/`;
+    const idx = resolved.lastIndexOf(marker);
+    if (idx === -1) {
+      continue;
+    }
+    const rest = resolved.slice(idx + marker.length);
+    if (rest.length === 0) {
+      continue;
+    }
+    return `${prefix}/${rest}`;
+  }
+  return null;
+}
+var maxImportDepthRule = createRule({
+  name: RULE_NAME6,
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "A relative import may not climb more than `max` parent levels (default 3). Autofixed to a path alias when one is configured."
+    },
+    schema: [optionSchema6],
+    messages: {
+      tooDeep: "Relative import `{{source}}` climbs {{depth}} levels \u2014 over the limit of {{max}}. Use a path alias instead of reaching this far up the tree."
+    }
+  },
+  defaultOptions: [{ max: DEFAULT_MAX, alias: {} }],
+  create(context, [options]) {
+    const max = options.max ?? DEFAULT_MAX;
+    const alias = options.alias ?? {};
+    const filename = context.filename;
+    function check(sourceNode) {
+      if (sourceNode === null || sourceNode === void 0 || typeof sourceNode.value !== "string") {
+        return;
+      }
+      const source = sourceNode.value;
+      const depth = climbDepth(source);
+      if (depth <= max) {
+        return;
+      }
+      const rewrite = aliasRewrite(source, filename, alias);
+      context.report({
+        node: sourceNode,
+        messageId: "tooDeep",
+        data: { source, depth, max },
+        fix: rewrite === null ? void 0 : (fixer) => {
+          const quote = sourceNode.raw.charAt(0);
+          return fixer.replaceText(sourceNode, `${quote}${rewrite}${quote}`);
+        }
+      });
+    }
+    function literalSource(node) {
+      return node !== null && node !== void 0 && node.type === import_utils9.AST_NODE_TYPES.Literal ? node : null;
+    }
+    return {
+      ImportDeclaration(node) {
+        check(node.source);
+      },
+      ImportExpression(node) {
+        check(literalSource(node.source));
+      },
+      ExportNamedDeclaration(node) {
+        check(literalSource(node.source));
+      },
+      ExportAllDeclaration(node) {
+        check(literalSource(node.source));
+      }
+    };
+  }
+});
+
 // src/rules/no-cross-feature-imports.ts
-var import_node_path4 = __toESM(require("path"), 1);
-var import_utils4 = require("@typescript-eslint/utils");
-var RULE_NAME3 = "no-cross-feature-imports";
+var import_node_path7 = __toESM(require("path"), 1);
+var import_utils11 = require("@typescript-eslint/utils");
+var RULE_NAME7 = "no-cross-feature-imports";
 var DEFAULT_FEATURE_ROOT = "components";
 var DEFAULT_ALIAS = "@/components";
 var DEFAULT_SHARED_FEATURES = ["ui"];
-var optionSchema3 = {
+var optionSchema7 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -301,19 +718,19 @@ function resolveTargetFeature(source, currentFile, aliasRe, featureRoot) {
     return aliasMatch[1] ?? null;
   }
   if (source.startsWith(".")) {
-    const resolved = import_node_path4.default.resolve(import_node_path4.default.dirname(currentFile), source);
+    const resolved = import_node_path7.default.resolve(import_node_path7.default.dirname(currentFile), source);
     return getFeatureName(resolved, featureRoot);
   }
   return null;
 }
 var noCrossFeatureImportsRule = createRule({
-  name: RULE_NAME3,
+  name: RULE_NAME7,
   meta: {
     type: "problem",
     docs: {
       description: "A file in one feature may not import runtime code from another feature. Move shared code to a shared module or a shared feature."
     },
-    schema: [optionSchema3],
+    schema: [optionSchema7],
     messages: {
       crossFeatureImport: "Cross-feature import: `{{current}}` may not import runtime code from `{{root}}/{{target}}`. Move shared code to a shared module or a shared feature (e.g. `{{root}}/ui`)."
     }
@@ -356,25 +773,25 @@ var noCrossFeatureImportsRule = createRule({
     }
     return {
       ImportDeclaration(node) {
-        if (node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, node.importKind === "type");
         }
       },
       // Dynamic `import()` is runtime by nature — never type-only.
       ImportExpression(node) {
-        if (node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, false);
         }
       },
       // `export { x } from '…'` re-export laundering.
       ExportNamedDeclaration(node) {
-        if (node.source !== null && node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source !== null && node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, node.exportKind === "type");
         }
       },
       // `export * from '…'` re-export laundering.
       ExportAllDeclaration(node) {
-        if (node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, node.exportKind === "type");
         }
       }
@@ -382,16 +799,593 @@ var noCrossFeatureImportsRule = createRule({
   }
 });
 
+// src/semantic-module/classify.ts
+var import_utils15 = require("@typescript-eslint/utils");
+
+// src/semantic-module/ast.ts
+var import_utils13 = require("@typescript-eslint/utils");
+function getDeclarationName(node) {
+  if ("id" in node) {
+    const id = node.id;
+    if (isIdentifier(id)) {
+      return id.name;
+    }
+  }
+  return void 0;
+}
+function getVariableDeclaratorName(declarator) {
+  return declarator.id.type === import_utils13.AST_NODE_TYPES.Identifier ? declarator.id.name : void 0;
+}
+function isWrapperExpression(expression) {
+  return expression.type === import_utils13.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils13.AST_NODE_TYPES.TSTypeAssertion || expression.type === import_utils13.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils13.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils13.AST_NODE_TYPES.TSInstantiationExpression;
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (isWrapperExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function isAmbientDeclaration(node) {
+  if ("declare" in node && node.declare === true) {
+    return true;
+  }
+  return node.type === import_utils13.AST_NODE_TYPES.TSModuleDeclaration && node.kind === "global";
+}
+function functionReturnsJsx(node) {
+  if (node.type === import_utils13.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (!node.expression && node.body.type === import_utils13.AST_NODE_TYPES.BlockStatement) {
+      return blockReturnsJsx(node.body);
+    }
+    return containsJsx(node.body);
+  }
+  return blockReturnsJsx(node.body);
+}
+function blockReturnsJsx(block) {
+  return containsNode(block, (node) => {
+    if (node.type !== import_utils13.AST_NODE_TYPES.ReturnStatement || !node.argument) {
+      return false;
+    }
+    return containsJsx(node.argument);
+  });
+}
+function containsJsx(node) {
+  return containsNode(
+    node,
+    (candidate) => candidate.type === import_utils13.AST_NODE_TYPES.JSXElement || candidate.type === import_utils13.AST_NODE_TYPES.JSXFragment
+  );
+}
+var SKIPPED_KEYS = /* @__PURE__ */ new Set(["parent", "loc", "range", "tokens", "comments"]);
+function containsNode(root, predicate) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    if (predicate(current)) {
+      return true;
+    }
+    for (const [key, value] of Object.entries(current)) {
+      if (SKIPPED_KEYS.has(key)) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (isNodeLike(item)) {
+            stack.push(item);
+          }
+        }
+        continue;
+      }
+      if (isNodeLike(value)) {
+        stack.push(value);
+      }
+    }
+  }
+  return false;
+}
+function isNodeLike(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function isIdentifier(value) {
+  return isNodeLike(value) && value.type === import_utils13.AST_NODE_TYPES.Identifier;
+}
+
+// src/semantic-module/classifiers.ts
+var import_utils14 = require("@typescript-eslint/utils");
+function isHookName(name, options) {
+  if (!options.hookDetection.enabled || !name) {
+    return false;
+  }
+  return options.hookDetection.namePattern.test(name);
+}
+function isReactComponentName(name) {
+  return Boolean(name && /^[A-Z][A-Za-z0-9]*$/u.test(name));
+}
+function isReactComponentFunction(node, name, options, isDefaultExport = false) {
+  if (!options.reactComponentDetection.enabled) {
+    return false;
+  }
+  if (!isReactComponentName(name) && !isDefaultExport) {
+    return false;
+  }
+  if (node.returnType && typeReferencesJsxValue(node.returnType.typeAnnotation)) {
+    return true;
+  }
+  return functionReturnsJsx(node);
+}
+function isReactComponentVariable(declarator, options) {
+  if (!options.reactComponentDetection.enabled) {
+    return false;
+  }
+  const name = getVariableDeclaratorName(declarator);
+  if (!isReactComponentName(name)) {
+    return false;
+  }
+  if (declarator.id.type === import_utils14.AST_NODE_TYPES.Identifier && declarator.id.typeAnnotation && typeReferencesReactComponent(declarator.id.typeAnnotation.typeAnnotation)) {
+    return true;
+  }
+  if (!declarator.init) {
+    return false;
+  }
+  if (declarator.init.type === import_utils14.AST_NODE_TYPES.ArrowFunctionExpression || declarator.init.type === import_utils14.AST_NODE_TYPES.FunctionExpression) {
+    return isReactComponentFunction(declarator.init, name, options);
+  }
+  return containsJsx(declarator.init);
+}
+var REACT_COMPONENT_TYPES = /* @__PURE__ */ new Set([
+  "FC",
+  "FunctionComponent",
+  "React.FC",
+  "React.FunctionComponent"
+]);
+var JSX_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "JSX.Element",
+  "React.ReactElement",
+  "React.ReactNode"
+]);
+function typeReferencesReactComponent(node) {
+  return containsNode(
+    node,
+    (candidate) => candidate.type === import_utils14.AST_NODE_TYPES.TSTypeReference && REACT_COMPONENT_TYPES.has(entityNameToString(candidate.typeName))
+  );
+}
+function typeReferencesJsxValue(node) {
+  return containsNode(
+    node,
+    (candidate) => candidate.type === import_utils14.AST_NODE_TYPES.TSTypeReference && JSX_VALUE_TYPES.has(entityNameToString(candidate.typeName))
+  );
+}
+function entityNameToString(entityName) {
+  if (entityName.type === import_utils14.AST_NODE_TYPES.Identifier) {
+    return entityName.name;
+  }
+  if (entityName.type === import_utils14.AST_NODE_TYPES.TSQualifiedName) {
+    return `${entityNameToString(entityName.left)}.${entityName.right.name}`;
+  }
+  return "this";
+}
+var SCHEMA_LIBRARY_MODULES = {
+  zod: ["zod"],
+  yup: ["yup"],
+  valibot: ["valibot"]
+};
+var SCHEMA_BUILDER_NAMES = /* @__PURE__ */ new Set([
+  "array",
+  "boolean",
+  "date",
+  "enum",
+  "literal",
+  "number",
+  "object",
+  "record",
+  "string",
+  "tuple",
+  "union"
+]);
+function collectSchemaImportContext(program, options) {
+  const namespaceIdentifiers = /* @__PURE__ */ new Set();
+  const builderIdentifiers = /* @__PURE__ */ new Set();
+  const enabledModules = new Set(
+    options.schemaLibraries.flatMap((library) => SCHEMA_LIBRARY_MODULES[library])
+  );
+  for (const statement of program.body) {
+    if (statement.type !== import_utils14.AST_NODE_TYPES.ImportDeclaration || statement.importKind === "type" || !enabledModules.has(String(statement.source.value))) {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === import_utils14.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils14.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        namespaceIdentifiers.add(specifier.local.name);
+        continue;
+      }
+      if (specifier.importKind === "type") {
+        continue;
+      }
+      const importedName = specifier.imported.type === import_utils14.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+      if (importedName === "z") {
+        namespaceIdentifiers.add(specifier.local.name);
+      }
+      if (SCHEMA_BUILDER_NAMES.has(importedName)) {
+        builderIdentifiers.add(specifier.local.name);
+      }
+    }
+  }
+  return { namespaceIdentifiers, builderIdentifiers };
+}
+function isSchemaExpression(expression, context) {
+  const unwrapped = unwrapExpression(expression);
+  if (unwrapped.type !== import_utils14.AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
+  const rootName = expressionRootIdentifier(unwrapped.callee);
+  if (!rootName) {
+    return false;
+  }
+  return context.namespaceIdentifiers.has(rootName) || context.builderIdentifiers.has(rootName);
+}
+function expressionRootIdentifier(node) {
+  switch (node.type) {
+    case import_utils14.AST_NODE_TYPES.Identifier:
+      return node.name;
+    case import_utils14.AST_NODE_TYPES.MemberExpression:
+      return expressionRootIdentifier(node.object);
+    case import_utils14.AST_NODE_TYPES.CallExpression:
+      return expressionRootIdentifier(node.callee);
+    case import_utils14.AST_NODE_TYPES.ChainExpression:
+      return expressionRootIdentifier(node.expression);
+    default:
+      return null;
+  }
+}
+function getConstantReason(expression) {
+  if (!expression) {
+    return "top-level variable declaration without initializer";
+  }
+  switch (unwrapExpression(expression).type) {
+    case import_utils14.AST_NODE_TYPES.Literal:
+      return "literal runtime value";
+    case import_utils14.AST_NODE_TYPES.ObjectExpression:
+      return "object literal runtime value";
+    case import_utils14.AST_NODE_TYPES.ArrayExpression:
+      return "array literal runtime value";
+    case import_utils14.AST_NODE_TYPES.TemplateLiteral:
+      return "template literal runtime value";
+    case import_utils14.AST_NODE_TYPES.CallExpression:
+      return "computed top-level runtime value";
+    default:
+      return "top-level runtime value";
+  }
+}
+
+// src/semantic-module/options.ts
+var SEMANTIC_CATEGORIES = [
+  "type",
+  "constant",
+  "function",
+  "class",
+  "react-component",
+  "hook",
+  "schema",
+  "enum"
+];
+var SCHEMA_LIBRARIES = ["zod", "yup", "valibot"];
+function sortCategories(categories) {
+  const categorySet = new Set(categories);
+  return SEMANTIC_CATEGORIES.filter((category) => categorySet.has(category));
+}
+var DEFAULT_HOOK_NAME_PATTERN = "^use[A-Z0-9].*";
+var DEFAULT_OPTIONS = {
+  allow: [],
+  enumCategory: "enum",
+  debug: false,
+  ignoreAmbientDeclarations: false,
+  ignorePrivateDeclarations: true,
+  schemaLibraries: SCHEMA_LIBRARIES,
+  reactComponentDetection: { enabled: true },
+  hookDetection: { enabled: true, namePattern: DEFAULT_HOOK_NAME_PATTERN }
+};
+function normalizeOptions(options) {
+  return {
+    allow: options.allow ?? DEFAULT_OPTIONS.allow,
+    enumCategory: options.enumCategory ?? DEFAULT_OPTIONS.enumCategory,
+    debug: options.debug ?? DEFAULT_OPTIONS.debug,
+    ignoreAmbientDeclarations: options.ignoreAmbientDeclarations ?? DEFAULT_OPTIONS.ignoreAmbientDeclarations,
+    ignorePrivateDeclarations: options.ignorePrivateDeclarations ?? DEFAULT_OPTIONS.ignorePrivateDeclarations,
+    schemaLibraries: options.schemaLibraries ?? DEFAULT_OPTIONS.schemaLibraries,
+    reactComponentDetection: { enabled: options.reactComponentDetection?.enabled ?? true },
+    hookDetection: {
+      enabled: options.hookDetection?.enabled ?? true,
+      namePattern: compilePattern(options.hookDetection?.namePattern ?? DEFAULT_HOOK_NAME_PATTERN)
+    }
+  };
+}
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch (error) {
+    throw new Error(
+      `single-semantic-module: hookDetection.namePattern ${JSON.stringify(pattern)} is not a valid regular expression (${String(error)}).`
+    );
+  }
+}
+function isCategorySetAllowed(categories, allow) {
+  if (categories.size <= 1) {
+    return true;
+  }
+  const detected = [...categories];
+  return allow.some((group) => {
+    const allowed = new Set(group);
+    return detected.every((category) => allowed.has(category));
+  });
+}
+
+// src/semantic-module/classify.ts
+function analyzeSemanticModule(program, rawOptions) {
+  const options = normalizeOptions(rawOptions);
+  const context = {
+    options,
+    schemaImports: collectSchemaImportContext(program, options),
+    exportedNames: collectLocallyExportedNames(program)
+  };
+  const classifications = program.body.flatMap(
+    (statement) => classifyTopLevelStatement(statement, context)
+  );
+  return {
+    categories: new Set(classifications.map((classification2) => classification2.category)),
+    classifications,
+    options
+  };
+}
+function collectLocallyExportedNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    if (statement.type === import_utils15.AST_NODE_TYPES.ExportNamedDeclaration && statement.source === null && statement.declaration === null) {
+      for (const specifier of statement.specifiers) {
+        if (specifier.local.type === import_utils15.AST_NODE_TYPES.Identifier) {
+          names.add(specifier.local.name);
+        }
+      }
+    } else if (statement.type === import_utils15.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils15.AST_NODE_TYPES.Identifier) {
+      names.add(statement.declaration.name);
+    }
+  }
+  return names;
+}
+function classifyTopLevelStatement(statement, context) {
+  switch (statement.type) {
+    case import_utils15.AST_NODE_TYPES.ImportDeclaration:
+    case import_utils15.AST_NODE_TYPES.EmptyStatement:
+    case import_utils15.AST_NODE_TYPES.ExportAllDeclaration:
+      return [];
+    case import_utils15.AST_NODE_TYPES.ExportNamedDeclaration:
+      return statement.declaration ? classifyDeclarationLike(statement.declaration, context) : [];
+    case import_utils15.AST_NODE_TYPES.ExportDefaultDeclaration:
+      return classifyDeclarationLike(statement.declaration, { ...context, isDefaultExport: true });
+    default:
+      if (!context.options.ignorePrivateDeclarations) {
+        return classifyDeclarationLike(statement, context);
+      }
+      return classifyExportedByName(statement, context);
+  }
+}
+function classifyExportedByName(statement, context) {
+  if (context.exportedNames.size === 0) {
+    return [];
+  }
+  if (statement.type === import_utils15.AST_NODE_TYPES.VariableDeclaration) {
+    const exported = statement.declarations.filter((declarator) => {
+      const name2 = getVariableDeclaratorName(declarator);
+      return name2 !== void 0 && context.exportedNames.has(name2);
+    });
+    return exported.map((declarator) => classifyVariableDeclarator(declarator, context));
+  }
+  const name = getDeclarationName(statement);
+  return name !== void 0 && context.exportedNames.has(name) ? classifyDeclarationLike(statement, context) : [];
+}
+function classifyDeclarationLike(node, context) {
+  if (isAmbientDeclaration(node)) {
+    return context.options.ignoreAmbientDeclarations ? [] : [classification("type", node, getDeclarationName(node), "ambient declaration")];
+  }
+  switch (node.type) {
+    case import_utils15.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils15.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils15.AST_NODE_TYPES.TSModuleDeclaration:
+      return [
+        classification("type", node, getDeclarationName(node), "TypeScript type-space declaration")
+      ];
+    case import_utils15.AST_NODE_TYPES.TSEnumDeclaration:
+      return [
+        classification(
+          context.options.enumCategory,
+          node,
+          getDeclarationName(node),
+          context.options.enumCategory === "type" ? "enum configured as type" : "enum declaration"
+        )
+      ];
+    case import_utils15.AST_NODE_TYPES.ClassDeclaration:
+      return [classification("class", node, getDeclarationName(node), "class declaration")];
+    case import_utils15.AST_NODE_TYPES.FunctionDeclaration:
+      return [classifyFunction(node, getDeclarationName(node), context, "function declaration")];
+    case import_utils15.AST_NODE_TYPES.VariableDeclaration:
+      return node.declarations.map((declarator) => classifyVariableDeclarator(declarator, context));
+    case import_utils15.AST_NODE_TYPES.ArrowFunctionExpression:
+    case import_utils15.AST_NODE_TYPES.FunctionExpression:
+      return [classifyFunction(node, void 0, context, "function expression")];
+    case import_utils15.AST_NODE_TYPES.ClassExpression:
+      return [classification("class", node, getDeclarationName(node), "class expression")];
+    case import_utils15.AST_NODE_TYPES.CallExpression:
+    case import_utils15.AST_NODE_TYPES.ArrayExpression:
+    case import_utils15.AST_NODE_TYPES.ObjectExpression:
+    case import_utils15.AST_NODE_TYPES.Literal:
+    case import_utils15.AST_NODE_TYPES.TemplateLiteral:
+      return [classifyDefaultExpression(node, context)];
+    case import_utils15.AST_NODE_TYPES.TSDeclareFunction:
+      return [
+        classification("function", node, getDeclarationName(node), "function overload signature")
+      ];
+    default:
+      return [];
+  }
+}
+function classifyFunction(node, name, context, reason) {
+  if (isHookName(name, context.options)) {
+    return classification("hook", node, name, "function name matches hook pattern");
+  }
+  if (isReactComponentFunction(node, name, context.options, context.isDefaultExport === true)) {
+    return classification(
+      "react-component",
+      node,
+      name,
+      `${reason === "function declaration" ? "function component" : "function expression"} returns JSX or React element`
+    );
+  }
+  return classification("function", node, name, reason);
+}
+function classifyVariableDeclarator(declarator, context) {
+  const name = getVariableDeclaratorName(declarator);
+  const init = declarator.init ? unwrapExpression(declarator.init) : null;
+  if (init && isSchemaExpression(init, context.schemaImports)) {
+    return classification("schema", declarator, name, "schema builder expression");
+  }
+  if (isReactComponentVariable(declarator, context.options)) {
+    return classification("react-component", declarator, name, "React component variable");
+  }
+  if (isHookName(name, context.options)) {
+    return classification("hook", declarator, name, "variable name matches hook pattern");
+  }
+  if (init?.type === import_utils15.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils15.AST_NODE_TYPES.FunctionExpression) {
+    return classifyFunction(init, name, context, "function expression");
+  }
+  if (init?.type === import_utils15.AST_NODE_TYPES.ClassExpression) {
+    return classification("class", declarator, name, "class expression");
+  }
+  return classification("constant", declarator, name, getConstantReason(init));
+}
+function classifyDefaultExpression(expression, context) {
+  const unwrapped = unwrapExpression(expression);
+  if (isSchemaExpression(unwrapped, context.schemaImports)) {
+    return classification("schema", expression, void 0, "default schema expression");
+  }
+  if (unwrapped.type === import_utils15.AST_NODE_TYPES.ArrowFunctionExpression || unwrapped.type === import_utils15.AST_NODE_TYPES.FunctionExpression) {
+    return classifyFunction(unwrapped, void 0, context, "function expression");
+  }
+  if (unwrapped.type === import_utils15.AST_NODE_TYPES.ClassExpression) {
+    return classification("class", expression, void 0, "default class expression");
+  }
+  return classification("constant", expression, void 0, getConstantReason(unwrapped));
+}
+function classification(category, node, declarationName, reason) {
+  return declarationName ? { category, node, reason, declarationName } : { category, node, reason };
+}
+function buildMixedCategoriesMessage(classifications, debug) {
+  const categories = sortCategories(classifications.map((entry) => entry.category));
+  const lines = [
+    "Mixed semantic categories detected in module:",
+    ...categories.map((category) => `- ${category}`)
+  ];
+  if (debug) {
+    lines.push("", "Detected declarations:");
+    for (const entry of classifications) {
+      lines.push(`- ${entry.category}: ${entry.declarationName ?? "<anonymous>"} (${entry.reason})`);
+    }
+  }
+  lines.push(
+    "",
+    "A module must contain only one semantic concern.",
+    "Move declarations into separate files/modules."
+  );
+  return lines.join("\n");
+}
+
+// src/rules/single-semantic-module.ts
+var RULE_NAME8 = "single-semantic-module";
+var optionSchema8 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allow: {
+      type: "array",
+      items: {
+        type: "array",
+        minItems: 2,
+        uniqueItems: true,
+        items: { type: "string", enum: [...SEMANTIC_CATEGORIES] }
+      }
+    },
+    enumCategory: { type: "string", enum: ["enum", "type"] },
+    debug: { type: "boolean" },
+    ignoreAmbientDeclarations: { type: "boolean" },
+    ignorePrivateDeclarations: { type: "boolean" },
+    schemaLibraries: {
+      type: "array",
+      uniqueItems: true,
+      items: { type: "string", enum: [...SCHEMA_LIBRARIES] }
+    },
+    reactComponentDetection: {
+      type: "object",
+      additionalProperties: false,
+      properties: { enabled: { type: "boolean" } }
+    },
+    hookDetection: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        namePattern: { type: "string" }
+      }
+    }
+  }
+};
+var singleSemanticModuleRule = createRule({
+  name: RULE_NAME8,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require each module to export only one semantic concern (types, constants, functions, classes, components, hooks, schemas or enums)."
+    },
+    schema: [optionSchema8],
+    messages: {
+      mixedSemanticCategories: "{{message}}"
+    }
+  },
+  defaultOptions: [DEFAULT_OPTIONS],
+  create(context, [options]) {
+    return {
+      Program(program) {
+        const analysis = analyzeSemanticModule(program, options);
+        if (isCategorySetAllowed(analysis.categories, analysis.options.allow)) {
+          return;
+        }
+        const [first] = analysis.classifications;
+        const reportNode = analysis.classifications.find((entry) => entry.category !== first?.category)?.node ?? program;
+        context.report({
+          node: reportNode,
+          messageId: "mixedSemanticCategories",
+          data: {
+            message: buildMixedCategoriesMessage(analysis.classifications, analysis.options.debug)
+          }
+        });
+      }
+    };
+  }
+});
+
 // src/rules/index.ts
 var rules = {
+  "barrel-purity": barrelPurityRule,
+  "colocated-test-required": colocatedTestRequiredRule,
   "component-folder-structure": componentFolderStructureRule,
+  "filename-matches-export": filenameMatchesExportRule,
   "index-must-reexport-default": indexMustReexportDefaultRule,
-  "no-cross-feature-imports": noCrossFeatureImportsRule
+  "max-import-depth": maxImportDepthRule,
+  "no-cross-feature-imports": noCrossFeatureImportsRule,
+  "single-semantic-module": singleSemanticModuleRule
 };
 
 // src/index.ts
 var NAMESPACE = "noctcore-architecture";
-var VERSION = "0.1.0";
+var VERSION = "0.3.0";
 var plugin = {
   meta: { name: "@noctcore/eslint-plugin-architecture", version: VERSION },
   rules,