@solid-stack/mason 1.0.20 → 1.0.22

package/dist/bin.cjs

@@ -3,7 +3,7 @@
 
 var cac = require('cac');
 var p14 = require('@clack/prompts');
-var pc14 = require('picocolors');
+var pc15 = require('picocolors');
 var fs9 = require('fs');
 var path2 = require('path');
 var url = require('url');
@@ -33,7 +33,7 @@ function _interopNamespace(e) {
 }
 
 var p14__namespace = /*#__PURE__*/_interopNamespace(p14);
-var pc14__default = /*#__PURE__*/_interopDefault(pc14);
+var pc15__default = /*#__PURE__*/_interopDefault(pc15);
 var fs9__default = /*#__PURE__*/_interopDefault(fs9);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
@@ -76,17 +76,17 @@ function writeFileSafely(absolutePath, content, options = {}) {
 function printGeneratedFiles(files, isDryRun = false) {
   console.log("");
   if (isDryRun) {
-    p14__namespace.log.warn(pc14__default.default.yellow(pc14__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+    p14__namespace.log.warn(pc15__default.default.yellow(pc15__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
   }
   for (const f of files) {
     if (f.action === "created") {
-      p14__namespace.log.success(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(created)")}`);
+      p14__namespace.log.success(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(created)")}`);
     } else if (f.action === "overwritten") {
-      p14__namespace.log.warn(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(overwritten)")}`);
+      p14__namespace.log.warn(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(overwritten)")}`);
     } else if (f.action === "skipped") {
-      p14__namespace.log.info(`${pc14__default.default.dim(f.relativePath)} ${pc14__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
+      p14__namespace.log.info(`${pc15__default.default.dim(f.relativePath)} ${pc15__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
     } else {
-      p14__namespace.log.info(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(preview)")}`);
+      p14__namespace.log.info(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(preview)")}`);
     }
   }
 }
@@ -1773,13 +1773,13 @@ function handleCancel(result) {
 }
 function printBanner() {
   console.log("");
-  p14__namespace.intro(pc14__default.default.bgCyan(pc14__default.default.black(" @solid-stack/mason ")));
+  p14__namespace.intro(pc15__default.default.bgCyan(pc15__default.default.black(" @solid-stack/mason ")));
 }
 async function promptProperties(options = {}) {
   const properties = options.defaults ? [...options.defaults] : [];
   if (properties.length > 0) {
     const summary = properties.map((p16) => `${p16.name}: ${p16.type}${p16.optional ? "?" : ""}`).join(", ");
-    p14__namespace.log.info(pc14__default.default.dim(`Pre-configured fields: ${summary}`));
+    p14__namespace.log.info(pc15__default.default.dim(`Pre-configured fields: ${summary}`));
     const addMore = handleCancel(
       await p14__namespace.confirm({
         message: "Would you like to add custom fields/properties?",
@@ -1790,7 +1790,7 @@ async function promptProperties(options = {}) {
       return properties;
     }
   }
-  p14__namespace.log.info(pc14__default.default.cyan("Enter properties (leave name blank when finished):"));
+  p14__namespace.log.info(pc15__default.default.cyan("Enter properties (leave name blank when finished):"));
   while (true) {
     const name = handleCancel(
       await p14__namespace.text({
@@ -1838,7 +1838,7 @@ async function promptProperties(options = {}) {
       optional
     });
     p14__namespace.log.success(
-      pc14__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
+      pc15__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
     );
   }
   return properties;
@@ -2098,7 +2098,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating feature '${pc14__default.default.cyan(normalizedName)}'...`);
+  s.start(`Generating feature '${pc15__default.default.cyan(normalizedName)}'...`);
   const options = {
     name: normalizedName,
     projectRoot,
@@ -2145,7 +2145,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   s.stop("Feature scaffolded successfully!");
   printGeneratedFiles(files, options.dryRun);
   p14__namespace.outro(
-    pc14__default.default.green(
+    pc15__default.default.green(
       `\u2713 Feature '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2301,7 +2301,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
     );
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating shared module '${pc14__default.default.cyan(normalizedName)}'...`);
+  s.start(`Generating shared module '${pc15__default.default.cyan(normalizedName)}'...`);
   const files = generateShared({
     name: normalizedName,
     description,
@@ -2315,7 +2315,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   s.stop("Shared module generated successfully!");
   printGeneratedFiles(files, Boolean(flags.dryRun));
   p14__namespace.outro(
-    pc14__default.default.green(
+    pc15__default.default.green(
       `\u2713 Shared module '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2443,7 +2443,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating use case '${pc14__default.default.cyan(ucName)}'...`);
+  s.start(`Generating use case '${pc15__default.default.cyan(ucName)}'...`);
   const options = {
     name: ucName,
     feature,
@@ -2475,7 +2475,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   }
   s.stop("Use case generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc14__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc15__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
 }
 async function runDomainCommand(domainNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2546,7 +2546,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
     });
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating domain model '${pc14__default.default.cyan(entityName)}'...`);
+  s.start(`Generating domain model '${pc15__default.default.cyan(entityName)}'...`);
   const options = {
     name: entityName,
     feature,
@@ -2559,7 +2559,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   const file = generateDomain(options);
   s.stop("Domain model generated successfully!");
   printGeneratedFiles([file], options.dryRun);
-  p14__namespace.outro(pc14__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc15__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
 }
 async function runInfrastructureCommand(classNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2728,7 +2728,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     registerInProvider = !flags.noProvider;
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating infrastructure class '${pc14__default.default.cyan(className)}'...`);
+  s.start(`Generating infrastructure class '${pc15__default.default.cyan(className)}'...`);
   const files = [];
   const options = {
     name: className,
@@ -2763,7 +2763,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   s.stop("Infrastructure class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc14__default.default.green(`Infrastructure class '${className}' created!`));
+  p14__namespace.outro(pc15__default.default.green(`Infrastructure class '${className}' created!`));
 }
 async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2876,7 +2876,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating interface '${pc14__default.default.cyan(ifaceName)}'...`);
+  s.start(`Generating interface '${pc15__default.default.cyan(ifaceName)}'...`);
   const files = [];
   const options = {
     name: ifaceName,
@@ -2925,7 +2925,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   }
   s.stop("Interface generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc14__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc15__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
 }
 async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -3042,7 +3042,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating HTTP handler '${pc14__default.default.cyan(className)}'...`);
+  s.start(`Generating HTTP handler '${pc15__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3060,7 +3060,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const files = generateHttpHandler(options);
   s.stop("HTTP handler generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc14__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc15__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
 }
 function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
   const formattedDeps = dependencies.map((dep) => ({
@@ -3216,7 +3216,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
     );
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating injectable '${pc14__default.default.cyan(className)}'...`);
+  s.start(`Generating injectable '${pc15__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3230,7 +3230,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   const files = generateInjectable(options);
   s.stop("Injectable class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc14__default.default.green(`Injectable '${className}' created successfully!`));
+  p14__namespace.outro(pc15__default.default.green(`Injectable '${className}' created successfully!`));
 }
 async function runInteractiveMenu(flags = {}) {
   printBanner();
@@ -3344,7 +3344,7 @@ async function handleCreate(type, name, flags = {}) {
       break;
     default:
       p14__namespace.log.error(
-        pc14__default.default.red(
+        pc15__default.default.red(
           `Unknown component type: "${type}". Allowed types: feature, shared, usecase, domain, infrastructure, interface, httpHandler, injectable.`
         )
       );
@@ -3580,7 +3580,7 @@ function installNpmPackages(projectRoot, packages, pm) {
       installCmd = `npm install ${packages.join(" ")}`;
       break;
   }
-  p14__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc14__default.default.cyan(packages.join(", "))}`);
+  p14__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc15__default.default.cyan(packages.join(", "))}`);
   child_process.execSync(installCmd, {
     cwd: projectRoot,
     stdio: "inherit"
@@ -3736,19 +3736,19 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
   if (type !== "shared" && type !== "feature") {
-    p14__namespace.log.error(pc14__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    p14__namespace.log.error(pc15__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
     process.exit(1);
   }
   const registryBase = getRegistryBase(projectRoot, flags.registry);
   const s = p14__namespace.spinner();
-  s.start(`Connecting to registry at ${pc14__default.default.dim(registryBase)}...`);
+  s.start(`Connecting to registry at ${pc15__default.default.dim(registryBase)}...`);
   let index;
   try {
     index = await fetchRegistryIndex(registryBase);
     s.stop("Registry index loaded.");
   } catch (err) {
-    s.stop(pc14__default.default.red("Failed to load registry index."));
-    p14__namespace.log.error(pc14__default.default.red(err.message || String(err)));
+    s.stop(pc15__default.default.red("Failed to load registry index."));
+    p14__namespace.log.error(pc15__default.default.red(err.message || String(err)));
     process.exit(1);
   }
   const availableList = type === "shared" ? index.shared : index.features;
@@ -3772,9 +3772,9 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   }
   if (!candidateNames.includes(name)) {
     const closest = findClosestMatch(name, candidateNames);
-    p14__namespace.log.error(pc14__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    p14__namespace.log.error(pc15__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
     if (closest) {
-      p14__namespace.log.info(pc14__default.default.yellow(`Did you mean '${pc14__default.default.cyan(closest)}'?`));
+      p14__namespace.log.info(pc15__default.default.yellow(`Did you mean '${pc15__default.default.cyan(closest)}'?`));
     }
     process.exit(1);
   }
@@ -3786,7 +3786,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     try {
       manifest = await fetchModuleManifest(registryBase, modType, modName);
     } catch (err) {
-      p14__namespace.log.error(pc14__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
+      p14__namespace.log.error(pc15__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
       process.exit(1);
     }
     nodes.set(key, {
@@ -3826,7 +3826,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   buildTopologicalOrder(rootKey);
   const resolutions = /* @__PURE__ */ new Map();
   const globalAliasMap = /* @__PURE__ */ new Map();
-  p14__namespace.log.step(`Importing ${type}: ${pc14__default.default.cyan(name)}...`);
+  p14__namespace.log.step(`Importing ${type}: ${pc15__default.default.cyan(name)}...`);
   for (const key of orderedKeys) {
     const node = nodes.get(key);
     const { type: modType, name: registryName, manifest } = node;
@@ -3859,7 +3859,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     if (programmaticPointTo) {
       if (!checkModuleExists(projectRoot, modType, programmaticPointTo)) {
         p14__namespace.log.error(
-          pc14__default.default.red(
+          pc15__default.default.red(
             `Module '${programmaticPointTo}' specified in --point-to does not exist in ${folder}.`
           )
         );
@@ -3895,7 +3895,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     }
     const existingDir = getExistingModuleDir(projectRoot, modType, registryName);
     if (!existingDir) {
-      p14__namespace.log.info(`  \u21B3 Resolving required ${modType} dependency: ${pc14__default.default.cyan(registryName)}`);
+      p14__namespace.log.info(`  \u21B3 Resolving required ${modType} dependency: ${pc15__default.default.cyan(registryName)}`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -4126,7 +4126,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     const isOverwrite = Boolean(flags.overwrite || res.action === "overwrite");
     if (key !== rootKey) {
       p14__namespace.log.step(
-        `Importing ${res.type}: ${pc14__default.default.cyan(res.targetName)}${res.targetName !== res.registryName ? pc14__default.default.dim(` (from ${res.registryName})`) : ""}...`
+        `Importing ${res.type}: ${pc15__default.default.cyan(res.targetName)}${res.targetName !== res.registryName ? pc15__default.default.dim(` (from ${res.registryName})`) : ""}...`
       );
     }
     if (res.action === "overwrite" && !flags.dryRun) {
@@ -4145,7 +4145,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       const localFilePath = path2__default.default.join(targetDir, file);
       if (fs9__default.default.existsSync(localFilePath) && !isOverwrite) {
         p14__namespace.log.warn(
-          `  \u21B3 Skipping existing file: ${pc14__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
+          `  \u21B3 Skipping existing file: ${pc15__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
         );
         continue;
       }
@@ -4157,13 +4157,13 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       }
       const displayPath = path2__default.default.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
-      p14__namespace.log.message(`  ${pc14__default.default.green("+")} ${displayPath}`);
+      p14__namespace.log.message(`  ${pc15__default.default.green("+")} ${displayPath}`);
     }
   }
   const missingNpm = getMissingNpmPackages(projectRoot, Array.from(requiredNpmPackages));
   if (missingNpm.length > 0) {
     if (flags.skipInstall || flags.dryRun) {
-      p14__namespace.log.info(`Required npm dependencies to install: ${pc14__default.default.cyan(missingNpm.join(", "))}`);
+      p14__namespace.log.info(`Required npm dependencies to install: ${pc15__default.default.cyan(missingNpm.join(", "))}`);
     } else {
       try {
         installNpmPackages(projectRoot, missingNpm);
@@ -4177,18 +4177,901 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     }
   }
   if (flags.dryRun) {
-    p14__namespace.log.info(pc14__default.default.yellow("Dry run complete: No files were written to disk."));
+    p14__namespace.log.info(pc15__default.default.yellow("Dry run complete: No files were written to disk."));
   } else {
     const rootRes = resolutions.get(rootKey);
     const baseDir = getModuleBaseDir(projectRoot, type);
     const displayTarget = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, rootRes.targetName));
     p14__namespace.log.success(
-      pc14__default.default.green(
+      pc15__default.default.green(
         `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in ${displayTarget})`
       )
     );
   }
 }
+var DependencyRuleError = class extends Error {
+  violations;
+  isFailFast;
+  constructor(message, violations, isFailFast = false) {
+    super(message);
+    this.name = "DependencyRuleError";
+    this.violations = violations;
+    this.isFailFast = isFailFast;
+  }
+};
+function isTestFile2(filePath, projectRoot) {
+  const norm = (projectRoot ? path2__default.default.relative(projectRoot, filePath) : filePath).replace(/\\/g, "/");
+  const base = path2__default.default.basename(norm);
+  return base.endsWith(".test.ts") || base.endsWith(".test.js") || base.endsWith(".spec.ts") || base.endsWith(".spec.js") || base.endsWith(".d.ts") || norm.includes("/__tests__/") || norm.startsWith("__tests__/") || /(?:^|\/)tests?\//.test(norm);
+}
+function scanDirFiles(dir, projectRoot) {
+  if (!fs9__default.default.existsSync(dir)) return [];
+  const entries = fs9__default.default.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "__tests__" || entry.name.startsWith(".")) {
+      continue;
+    }
+    const fullPath = path2__default.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...scanDirFiles(fullPath, projectRoot));
+    } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js")) && !isTestFile2(fullPath, projectRoot)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function classifyFile(fullPath, projectRoot) {
+  const rel = path2__default.default.relative(projectRoot, fullPath).replace(/\\/g, "/");
+  const featureMatch = rel.match(/(?:^|\/)(?:src\/)?features\/([^/]+)\/([^/]+)(?:\/.*)?$/);
+  if (!featureMatch || !featureMatch[1] || !featureMatch[2]) return {};
+  const feature = featureMatch[1];
+  const subfolder = featureMatch[2];
+  let layer;
+  if (subfolder === "domain" || subfolder === "errors") {
+    layer = "domain";
+  } else if (subfolder === "useCases" || subfolder === "usecases") {
+    layer = "useCases";
+  } else if (subfolder === "services") {
+    layer = "services";
+  } else if (subfolder === "infrastructure") {
+    layer = "infrastructure";
+  } else if (subfolder === "pxExpress" || subfolder === "presentation" || subfolder === "handlers" || subfolder.startsWith("px")) {
+    layer = "presentation";
+  }
+  return { feature, layer };
+}
+function classifyTarget(specifier, sourceFileAbs, projectRoot) {
+  if (specifier === "@solid-stack/di" || specifier.startsWith("@solid-stack/di/")) {
+    return { isExternal: true, isDiFramework: true };
+  }
+  if (specifier.startsWith("node:") || ["crypto", "fs", "path", "http", "https", "url", "os", "child_process", "stream", "express", "cors", "dotenv"].includes(specifier)) {
+    return { isExternal: true, isDiFramework: false };
+  }
+  let resolvedRel = null;
+  if (specifier.startsWith(".")) {
+    const abs = path2__default.default.resolve(path2__default.default.dirname(sourceFileAbs), specifier);
+    resolvedRel = path2__default.default.relative(projectRoot, abs).replace(/\\/g, "/");
+  } else if (specifier.startsWith("@/features/") || specifier.startsWith("~/features/")) {
+    resolvedRel = specifier.replace(/^[@~]\//, "src/");
+  } else if (specifier.startsWith("@features/")) {
+    resolvedRel = "src/" + specifier.slice(1);
+  } else if (specifier.startsWith("@/shared/") || specifier.startsWith("~/shared/")) {
+    resolvedRel = specifier.replace(/^[@~]\//, "src/");
+  } else if (specifier.startsWith("@shared/")) {
+    resolvedRel = "src/" + specifier.slice(1);
+  } else if (specifier.startsWith("@/") || specifier.startsWith("~/")) {
+    resolvedRel = "src/" + specifier.slice(2);
+  } else if (specifier.startsWith("features/") || specifier.startsWith("shared/")) {
+    resolvedRel = specifier;
+  }
+  if (!resolvedRel) {
+    return { isExternal: true, isDiFramework: false };
+  }
+  const featMatch = resolvedRel.match(/(?:^|\/)(?:src\/)?features\/([^/]+)\/([^/]+)(?:\/(.*))?$/);
+  if (featMatch && featMatch[1] && featMatch[2]) {
+    const targetFeature = featMatch[1];
+    const targetSubfolder = featMatch[2];
+    const rest = featMatch[3] || "";
+    let targetLayer;
+    if (targetSubfolder === "domain" || targetSubfolder === "errors") {
+      targetLayer = "domain";
+    } else if (targetSubfolder === "useCases" || targetSubfolder === "usecases") {
+      targetLayer = "useCases";
+    } else if (targetSubfolder === "services") {
+      targetLayer = "services";
+    } else if (targetSubfolder === "infrastructure") {
+      targetLayer = "infrastructure";
+    } else if (targetSubfolder === "pxExpress" || targetSubfolder === "presentation" || targetSubfolder === "handlers" || targetSubfolder.startsWith("px")) {
+      targetLayer = "presentation";
+    }
+    const basePart = rest ? path2__default.default.basename(rest) : targetSubfolder;
+    const targetFileName = basePart.replace(/\.(js|ts|mjs|cjs)$/, "");
+    const isTargetPort = /^I[A-Z]/.test(targetFileName);
+    const isTargetRepo = isTargetPort && targetFileName.includes("Repo");
+    return {
+      isExternal: false,
+      isDiFramework: false,
+      targetFeature,
+      targetLayer,
+      targetSubfolder,
+      targetFileName,
+      isTargetPort,
+      isTargetRepo
+    };
+  }
+  const sharedMatch = resolvedRel.match(/(?:^|\/)(?:src\/)?shared\/([^/]+)(?:\/(.*))?$/);
+  if (sharedMatch) {
+    const targetSharedModule = sharedMatch[1];
+    const sharedRest = sharedMatch[2] || "";
+    const isSharedRoot = !sharedRest.includes("/");
+    const isSharedPorts = sharedRest.startsWith("ports/") || sharedRest === "ports";
+    const isSharedInfra = sharedRest.startsWith("infrastructure/") || sharedRest === "infrastructure";
+    const isSharedDomain = sharedRest.startsWith("domain/") || sharedRest === "domain";
+    return {
+      isExternal: false,
+      isDiFramework: false,
+      targetSharedModule,
+      isSharedRoot,
+      isSharedPorts,
+      isSharedInfra,
+      isSharedDomain
+    };
+  }
+  return { isExternal: true, isDiFramework: false };
+}
+function extractImportStatements(content) {
+  const statements = [];
+  const lines = content.split(/\r?\n/);
+  const regex = /(?:import\s+(?:type\s+)?(?:[\s\w*$,{}]+\s+from\s+)?|export\s+(?:type\s+)?(?:[\s\w*$,{}]+\s+from\s+)?|import\s*\(|require\s*\()\s*["']([^"']+)["']/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const specifier = match[1];
+    const charIndex = match.index;
+    const lineNum = content.substring(0, charIndex).split("\n").length;
+    const rawCode = lines[lineNum - 1]?.trim() || match[0].trim();
+    statements.push({
+      specifier,
+      line: lineNum,
+      rawCode
+    });
+  }
+  return statements;
+}
+var FeatureDependencyGraph = class {
+  edges = /* @__PURE__ */ new Map();
+  addEdge(evidence) {
+    const { fromFeature, toFeature } = evidence;
+    if (fromFeature === toFeature) {
+      return { createsCycle: false };
+    }
+    if (!this.edges.has(fromFeature)) {
+      this.edges.set(fromFeature, /* @__PURE__ */ new Map());
+    }
+    this.edges.get(fromFeature).set(toFeature, evidence);
+    const reverse = this.edges.get(toFeature)?.get(fromFeature);
+    if (reverse) {
+      return { createsCycle: true, directPartner: reverse, cycleChain: [fromFeature, toFeature, fromFeature] };
+    }
+    const cycle = this.findCycleFrom(fromFeature);
+    if (cycle && cycle.length > 0) {
+      return { createsCycle: true, cycleChain: cycle };
+    }
+    return { createsCycle: false };
+  }
+  getEdges() {
+    const list = [];
+    for (const [from, toMap] of this.edges.entries()) {
+      for (const [to, ev] of toMap.entries()) {
+        list.push({ from, to, evidence: ev });
+      }
+    }
+    return list;
+  }
+  findDirectCycles() {
+    const cycles = [];
+    const checkedPairs = /* @__PURE__ */ new Set();
+    for (const [from, toMap] of this.edges.entries()) {
+      for (const [to, evAtoB] of toMap.entries()) {
+        const pairKey = [from, to].sort().join("<->");
+        if (checkedPairs.has(pairKey)) continue;
+        const evBtoA = this.edges.get(to)?.get(from);
+        if (evBtoA) {
+          checkedPairs.add(pairKey);
+          cycles.push({
+            featureA: from,
+            featureB: to,
+            cycle: [from, to, from],
+            evidenceAtoB: evAtoB,
+            evidenceBtoA: evBtoA
+          });
+        }
+      }
+    }
+    return cycles;
+  }
+  findCycleFrom(start) {
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const parent = /* @__PURE__ */ new Map();
+    const dfs = (curr) => {
+      visited.add(curr);
+      inStack.add(curr);
+      const neighbors = this.edges.get(curr);
+      if (neighbors) {
+        for (const next of neighbors.keys()) {
+          if (!visited.has(next)) {
+            parent.set(next, curr);
+            const cycle = dfs(next);
+            if (cycle) return cycle;
+          } else if (inStack.has(next)) {
+            const cycle = [next];
+            let p16 = curr;
+            while (p16 !== next) {
+              cycle.push(p16);
+              p16 = parent.get(p16) || next;
+            }
+            cycle.push(next);
+            cycle.reverse();
+            return cycle;
+          }
+        }
+      }
+      inStack.delete(curr);
+      return null;
+    };
+    return dfs(start);
+  }
+};
+function discoverAllFeatures(projectRoot) {
+  const featuresBase = resolveFeaturesDir(projectRoot);
+  if (!fs9__default.default.existsSync(featuresBase)) return [];
+  const entries = fs9__default.default.readdirSync(featuresBase, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "__tests__" && e.name !== "tests").map((e) => ({
+    name: e.name,
+    dir: path2__default.default.join(featuresBase, e.name)
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function lintCodebase(options = {}) {
+  const startTime = Date.now();
+  const projectRoot = options.projectRoot || findProjectRoot(options.targetDir || process.cwd());
+  const failFast = !options.complete;
+  const features = discoverAllFeatures(projectRoot);
+  const graph = new FeatureDependencyGraph();
+  const allViolations = [];
+  const results = [];
+  const detectedCycles = [];
+  const addViolation = (v) => {
+    allViolations.push(v);
+    const featureResult = results.find((r) => r.featureName === v.feature);
+    if (featureResult) {
+      featureResult.violations.push(v);
+      featureResult.passed = false;
+    }
+    if (failFast) {
+      const errorMsg = `[FAIL FAST] Dependency rule violation detected:
+   Feature:     ${v.feature}
+   Category:    ${v.category}
+   Rule:        ${v.ruleId}
+   Location:    ${v.relativePath}:${v.line}
+   Code:        ${v.code}
+   Explanation: ${v.advice}`;
+      throw new DependencyRuleError(errorMsg, [v], true);
+    }
+  };
+  for (const feat of features) {
+    results.push({
+      featureName: feat.name,
+      featureDir: feat.dir,
+      scannedFilesCount: 0,
+      passed: true,
+      violations: [],
+      layersChecked: ["domain", "useCases", "services", "infrastructure", "presentation"]
+    });
+  }
+  for (const feat of features) {
+    const featResult = results.find((r) => r.featureName === feat.name);
+    const allFiles = scanDirFiles(feat.dir, projectRoot);
+    featResult.scannedFilesCount = allFiles.length;
+    for (const file of allFiles) {
+      const relPath = path2__default.default.relative(projectRoot, file).replace(/\\/g, "/");
+      const { layer } = classifyFile(file, projectRoot);
+      if (!layer) continue;
+      const content = fs9__default.default.readFileSync(file, "utf-8");
+      const statements = extractImportStatements(content);
+      if (layer === "domain") {
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+          const lineText = lines[i].trim();
+          if (lineText.includes("@MakeInjectable") || lineText.includes("public static deps =")) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: i + 1,
+              category: "Domain Dependence Violation",
+              code: lineText,
+              ruleId: "D2_DI_DEPENDENCE",
+              severity: "error",
+              advice: "Domain layer must have zero DI dependence. Remove @MakeInjectable decorators and static deps declarations.",
+              fixExample: {
+                bad: lineText,
+                good: "// Domain interfaces and value objects must remain plain TypeScript classes/interfaces."
+              }
+            });
+          }
+        }
+      }
+      for (const stmt of statements) {
+        const target = classifyTarget(stmt.specifier, file, projectRoot);
+        if (target.targetFeature && target.targetFeature !== feat.name) {
+          const evidence = {
+            fromFeature: feat.name,
+            toFeature: target.targetFeature,
+            file,
+            relativePath: relPath,
+            line: stmt.line,
+            code: stmt.rawCode
+          };
+          const cycleResult = graph.addEdge(evidence);
+          if (cycleResult.createsCycle) {
+            const partner = cycleResult.directPartner;
+            detectedCycles.push({
+              featureA: feat.name,
+              featureB: target.targetFeature,
+              cycle: cycleResult.cycleChain,
+              evidenceAtoB: evidence,
+              evidenceBtoA: partner || evidence
+            });
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Circular Feature Dependency Violation",
+              code: stmt.rawCode,
+              ruleId: "C1_CIRCULAR_FEATURE_DEPENDENCY",
+              severity: "error",
+              advice: `Circular feature dependency detected between '${feat.name}' and '${target.targetFeature}'. Dependency flow must be strictly one-way: for any two features, only one can know about the other exists. If '${feat.name}' needs to impose a side effect on '${target.targetFeature}' (or vice versa), it must do so via an event, never via a direct dependency.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Emit a Domain/Application Event (e.g. publish '${feat.name}Changed') instead of depending on '${target.targetFeature}'.`
+              }
+            });
+          }
+        }
+        if (layer === "domain") {
+          if (target.targetLayer && ["useCases", "services", "infrastructure", "presentation"].includes(target.targetLayer)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "D1_OUTER_IMPORT",
+              severity: "error",
+              advice: `Domain layer must not import from outer layers (${target.targetLayer}). Keep the domain core pure.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Define interfaces, types, or value objects directly within the domain layer."
+              }
+            });
+          }
+          if (target.isDiFramework) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Dependence Violation",
+              code: stmt.rawCode,
+              ruleId: "D2_DI_DEPENDENCE",
+              severity: "error",
+              advice: "Domain layer must have zero DI dependence. Domain interfaces and value objects are plain classes/types.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Remove @solid-stack/di import. Domain entities are pure TypeScript."
+              }
+            });
+          }
+          if (target.targetSharedModule && !target.isSharedDomain) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "D3_SHARED_NON_DOMAIN_IMPORT",
+              severity: "error",
+              advice: "Domain layer can only import pure value objects from shared/<module>/domain/*. Ports, infrastructure, and root classes must not be imported.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/domain/...";`
+              }
+            });
+          }
+          if (target.isExternal && !target.isDiFramework) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Domain Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "D4_EXTERNAL_LIBRARY",
+              severity: "error",
+              advice: `Domain layer must be pure and must not depend on external runtime libraries ('${stmt.specifier}').`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Model pure business interfaces without external libraries."
+              }
+            });
+          }
+        } else if (layer === "useCases") {
+          if (target.targetLayer === "useCases" && target.targetFeature === feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Intra-Feature Violation",
+              code: stmt.rawCode,
+              ruleId: "U1_INTRA_USE_CASE",
+              severity: "error",
+              advice: `Use cases cannot depend on other use cases of the same feature ('${feat.name}'). Extract shared business logic to a domain repository or domain service.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject a domain interface or domain service instead of another use case."
+              }
+            });
+          }
+          if (target.targetLayer === "useCases" && target.targetFeature && target.targetFeature !== feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Cross-Feature Use Case Violation",
+              code: stmt.rawCode,
+              ruleId: "U2_CROSS_FEATURE_USE_CASE",
+              severity: "error",
+              advice: `Use cases cannot depend directly on use cases of foreign feature '${target.targetFeature}'. Treat features as separate microservices: define an interface in '${feat.name}/domain/' specifying what is needed, and implement it in '${feat.name}/infrastructure/'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define an interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/ using '${target.targetFileName}'.`
+              }
+            });
+          }
+          if (target.targetLayer === "infrastructure") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "U3_DIRECT_INFRASTRUCTURE",
+              severity: "error",
+              advice: "Use cases cannot import concrete infrastructure directly. Depend on Domain Ports of the same feature via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Depend on the domain interface port declared in static deps."
+              }
+            });
+          }
+          if (target.targetLayer === "domain" && target.targetFeature && target.targetFeature !== feat.name && target.isTargetPort) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Cross-Feature Port Violation",
+              code: stmt.rawCode,
+              ruleId: "U4_CROSS_FEATURE_PORT",
+              severity: "error",
+              advice: `Use cases cannot depend on domain interfaces/ports of foreign feature '${target.targetFeature}'. Define an interface in '${feat.name}/domain/' (consumer-driven port) and implement it in '${feat.name}/infrastructure/'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define a local interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/.`
+              }
+            });
+          }
+          if (target.targetLayer === "services" && target.targetFeature && target.targetFeature !== feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Use Case Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "U5_CROSS_FEATURE_SERVICE",
+              severity: "error",
+              advice: `Use cases cannot depend on services of foreign feature '${target.targetFeature}'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define an interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/.`
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "U6_SHARED_NON_ROOT",
+              severity: "error",
+              advice: `Use cases can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        } else if (layer === "services") {
+          if (target.targetLayer === "useCases") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Service Intra-Feature Violation",
+              code: stmt.rawCode,
+              ruleId: "S1_USE_CASE_DEPENDENCY",
+              severity: "error",
+              advice: "Services cannot depend on use cases of any feature.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject domain repository ports directly instead of use cases."
+              }
+            });
+          }
+          if (target.targetLayer === "domain" && target.targetFeature && target.targetFeature !== feat.name && target.isTargetPort) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Service Cross-Feature Port Violation",
+              code: stmt.rawCode,
+              ruleId: "S2_CROSS_FEATURE_PORT",
+              severity: "error",
+              advice: `Services cannot depend on domain ports of foreign feature '${target.targetFeature}'.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `// Define an interface in ${feat.name}/domain/ and implement it in ${feat.name}/infrastructure/.`
+              }
+            });
+          }
+          if (target.targetLayer === "infrastructure") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Service Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "S3_DIRECT_INFRASTRUCTURE",
+              severity: "error",
+              advice: "Services cannot import concrete infrastructure directly. Depend on Domain Ports via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Depend on the domain interface port declared in static deps."
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "S4_SHARED_NON_ROOT",
+              severity: "error",
+              advice: "Services can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        } else if (layer === "infrastructure") {
+          if (target.targetLayer === "useCases" && target.targetFeature === feat.name) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Adapter Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "I1_INTRA_USE_CASE",
+              severity: "error",
+              advice: `Infrastructure adapters cannot depend on use cases of the same feature ('${feat.name}'). Adapters implement domain ports.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Adapters implement domain ports and should not invoke local application use cases."
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "I2_SHARED_NON_ROOT",
+              severity: "error",
+              advice: "Infrastructure adapters can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        } else if (layer === "presentation") {
+          if (target.targetLayer === "infrastructure") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Presentation Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "P1_DIRECT_INFRASTRUCTURE",
+              severity: "error",
+              advice: "Presentation handlers must not import infrastructure directly. Inject Use Cases via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject the corresponding Use Case via static deps and invoke its execute() method."
+              }
+            });
+          }
+          if (target.targetLayer === "domain" && (target.isTargetRepo || target.isTargetPort)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Presentation Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "P2_DIRECT_REPOSITORY",
+              severity: "error",
+              advice: "Presentation handlers must not depend on domain repositories or ports directly. Inject Use Cases via DI.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Presentation layer must only orchestrate Use Cases."
+              }
+            });
+          }
+          if (target.targetSharedModule && (target.isSharedPorts || target.isSharedInfra)) {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Module Root Class Violation",
+              code: stmt.rawCode,
+              ruleId: "P3_SHARED_NON_ROOT",
+              severity: "error",
+              advice: "Presentation handlers can only depend on root classes of shared modules. Never import from shared ports or infrastructure directly.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  const directCycles = graph.findDirectCycles();
+  for (const c of directCycles) {
+    const existing = detectedCycles.find(
+      (dc) => dc.featureA === c.featureA && dc.featureB === c.featureB || dc.featureA === c.featureB && dc.featureB === c.featureA
+    );
+    if (!existing) {
+      detectedCycles.push(c);
+      addViolation({
+        feature: c.featureA,
+        file: c.evidenceAtoB.file,
+        relativePath: c.evidenceAtoB.relativePath,
+        line: c.evidenceAtoB.line,
+        category: "Circular Feature Dependency Violation",
+        code: c.evidenceAtoB.code,
+        ruleId: "C1_CIRCULAR_FEATURE_DEPENDENCY",
+        severity: "error",
+        advice: `Circular feature dependency detected between '${c.featureA}' and '${c.featureB}'. Dependency flow must be strictly one-way: for any two features, only one can know about the other exists. If the unaware feature needs to impose a side effect on the other, it must do so via an event, never via a direct dependency.`
+      });
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  const cleanFeatures = results.filter((r) => r.passed).length;
+  const violatedFeatures = results.filter((r) => !r.passed).length;
+  const summary = {
+    totalFeatures: results.length,
+    cleanFeatures,
+    violatedFeatures,
+    totalViolations: allViolations.length,
+    durationMs,
+    results,
+    allViolations,
+    circularDependencies: detectedCycles
+  };
+  if (allViolations.length > 0 && options.throwOnError !== false) {
+    const errorHeader = `Dependency rule audit failed with ${allViolations.length} violation(s) across ${violatedFeatures} feature(s):`;
+    const compiledDetails = allViolations.map(
+      (v, i) => `${i + 1}. [${v.category}] ${v.relativePath}:${v.line}
+   Rule:   ${v.ruleId}
+   Code:   ${v.code}
+   Advice: ${v.advice}`
+    ).join("\n\n");
+    throw new DependencyRuleError(`${errorHeader}
+
+${compiledDetails}
+`, allViolations, false);
+  }
+  return summary;
+}
+
+// src/commands/lint.ts
+function printLintBanner(mode) {
+  console.log("");
+  const title = " Mason Clean Architecture Dependency Linter ";
+  const line = "\u2501".repeat(title.length + 2);
+  console.log(pc15__default.default.cyan(` \u250F${line}\u2513`));
+  console.log(` ${pc15__default.default.cyan("\u2503")} ${pc15__default.default.bgCyan(pc15__default.default.black(title))} ${pc15__default.default.cyan("\u2503")}`);
+  console.log(pc15__default.default.cyan(` \u2517${line}\u251B`));
+  const modeText = mode === "failFast" ? `${pc15__default.default.yellow("Fail-Fast")} ${pc15__default.default.dim("(default: stops at first error)")}` : `${pc15__default.default.magenta("Complete")} ${pc15__default.default.dim("(--complete: compiles all errors)")}`;
+  console.log(` Mode: ${modeText}`);
+  console.log("");
+}
+function formatViolation(v, showFixHint = true) {
+  const lines = [];
+  const categoryBadge = pc15__default.default.red(pc15__default.default.bold(`[${v.category}]`));
+  const location = pc15__default.default.white(`${v.relativePath}:${pc15__default.default.yellow(String(v.line))}`);
+  lines.push(`   ${categoryBadge} ${location}`);
+  lines.push(`   ${pc15__default.default.dim("Rule ID:")} ${pc15__default.default.yellow(v.ruleId)}`);
+  lines.push(`   ${pc15__default.default.dim("Code:")}    ${pc15__default.default.magenta(v.code)}`);
+  lines.push(`   ${pc15__default.default.dim("Advice:")}  ${pc15__default.default.cyan(v.advice)}`);
+  if (showFixHint && v.fixExample) {
+    lines.push(`   ${pc15__default.default.dim("Example:")}`);
+    lines.push(`     ${pc15__default.default.red(`- ${v.fixExample.bad}`)}`);
+    lines.push(`     ${pc15__default.default.green(`+ ${v.fixExample.good}`)}`);
+  }
+  return lines.join("\n");
+}
+function formatFeatureResult(res, options = {}) {
+  const lines = [];
+  if (res.passed) {
+    lines.push(
+      ` ${pc15__default.default.green("\u2714")} ${pc15__default.default.bold(res.featureName)} ${pc15__default.default.dim(
+        `(${res.scannedFilesCount} files checked - clean)`
+      )}`
+    );
+    return lines.join("\n");
+  }
+  const countBadge = pc15__default.default.red(
+    `(${res.violations.length} violation${res.violations.length > 1 ? "s" : ""})`
+  );
+  lines.push(`
+ ${pc15__default.default.red("\u2716")} ${pc15__default.default.bold(pc15__default.default.white(res.featureName))} ${countBadge}`);
+  lines.push(`   ${pc15__default.default.dim("Path:")} ${res.featureDir}`);
+  lines.push("");
+  for (const v of res.violations) {
+    lines.push(formatViolation(v, options.fixHint !== false));
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function printTerminalReport(summary, options = {}) {
+  for (const res of summary.results) {
+    const formatted = formatFeatureResult(res, options);
+    if (formatted.trim()) {
+      console.log(formatted);
+    }
+  }
+  console.log("\u2501".repeat(70));
+  const statusIcon = summary.totalViolations === 0 ? pc15__default.default.green("\u2714 PASS") : pc15__default.default.red("\u2716 FAIL");
+  console.log(
+    ` ${statusIcon}  ${pc15__default.default.bold("Dependency Rules Audit Result")}  ${pc15__default.default.dim(
+      `(${summary.durationMs}ms)`
+    )}`
+  );
+  console.log(
+    `   ${pc15__default.default.bold("Features:")}   ${pc15__default.default.cyan(String(summary.totalFeatures))} total  |  ${pc15__default.default.green(
+      String(summary.cleanFeatures)
+    )} clean  |  ${summary.violatedFeatures > 0 ? pc15__default.default.red(String(summary.violatedFeatures)) : pc15__default.default.green("0")} with violations`
+  );
+  console.log(
+    `   ${pc15__default.default.bold("Violations:")} ${summary.totalViolations > 0 ? pc15__default.default.red(pc15__default.default.bold(String(summary.totalViolations))) : pc15__default.default.green("0")} rule violations found`
+  );
+  console.log("\u2501".repeat(70));
+  console.log("");
+}
+async function handleLint(flags = {}) {
+  const complete = Boolean(flags.complete);
+  const mode = complete ? "complete" : "failFast";
+  const quiet = Boolean(flags.quiet);
+  if (!quiet) {
+    printLintBanner(mode);
+  }
+  const options = {
+    complete,
+    quiet,
+    targetDir: flags.targetDir || flags.target,
+    projectRoot: flags.projectRoot,
+    fixHint: flags.fixHint !== false,
+    throwOnError: false
+  };
+  try {
+    const summary = lintCodebase(options);
+    if (!quiet) {
+      printTerminalReport(summary, options);
+    }
+    if (summary.totalViolations > 0) {
+      const errorHeader = `Dependency rule audit failed with ${summary.totalViolations} violation(s) across ${summary.violatedFeatures} feature(s):`;
+      const compiledDetails = summary.allViolations.map(
+        (v, i) => `${i + 1}. [${v.category}] ${v.relativePath}:${v.line}
+   Rule:   ${v.ruleId}
+   Code:   ${v.code}
+   Advice: ${v.advice}`
+      ).join("\n\n");
+      throw new DependencyRuleError(`${errorHeader}
+
+${compiledDetails}
+`, summary.allViolations, false);
+    }
+    if (!quiet) {
+      console.log(
+        pc15__default.default.green(`\u2714 All dependency rules are being followed! (${summary.totalFeatures} features checked)`)
+      );
+      console.log("");
+    }
+    return summary;
+  } catch (err) {
+    if (err instanceof DependencyRuleError && err.isFailFast) {
+      if (!quiet) {
+        console.log(pc15__default.default.red(`
+\u2716 [FAIL FAST] Terminating on first detected dependency rule violation:`));
+        const v = err.violations[0];
+        if (v) {
+          console.log(formatViolation(v, options.fixHint !== false));
+        }
+        console.log("");
+      }
+    }
+    throw err;
+  }
+}
 
 // src/cli.ts
 function createCli() {
@@ -4196,7 +5079,7 @@ function createCli() {
   cli.command("[...args]", "Interactive scaffolding and import wizard").option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").option("--registry", "Run in registry mode").option("--point-to <mapping>", "Point a dependency to an existing local module (e.g. --point-to time:mytime)").option("--alias <mapping>", "Import a dependency fresh under an alias name (e.g. --alias time:time-mason)").option("--tests", "Include test files (use --no-tests to exclude)").action(async (args, flags) => {
     if (args && args.length > 0) {
       p14__namespace.log.error(
-        pc14__default.default.red(
+        pc15__default.default.red(
           `Unknown command: "${args.join(" ")}". Use --help to list available commands.`
         )
       );
@@ -4262,14 +5145,21 @@ function createCli() {
               value: "import",
               label: "Import from registry",
               hint: "Download and link pre-built shared modules or features from the registry"
+            },
+            {
+              value: "lint",
+              label: "Lint dependency rules",
+              hint: "Scan codebase and verify Clean Architecture dependency rules"
             }
           ]
         })
       );
       if (choice === "create") {
         await handleCreate(void 0, void 0, flags);
-      } else {
+      } else if (choice === "import") {
         await handleImport(void 0, void 0, flags);
+      } else if (choice === "lint") {
+        await handleLint(flags);
       }
     } catch (err) {
       handleCliError(err);
@@ -4295,6 +5185,22 @@ function createCli() {
       handleCliError(err);
     }
   });
+  cli.command(
+    "lint [target]",
+    "Scan codebase and verify Clean Architecture dependency rules"
+  ).option(
+    "-c, --complete",
+    "Scan entire codebase without failing fast, compiling all errors at the end"
+  ).option("-q, --quiet", "Suppress non-error output").example("mason lint").example("mason lint --complete").example("mason lint ./src").action(async (target, flags = {}) => {
+    try {
+      await handleLint({
+        ...flags,
+        targetDir: target || flags.target || flags.dest
+      });
+    } catch (err) {
+      handleCliError(err);
+    }
+  });
   const createSubtypes = [
     "feature",
     "shared",
@@ -4326,7 +5232,10 @@ function handleCliError(err) {
     process.exit(0);
   }
   const message = err instanceof Error ? err.message : String(err);
-  p14__namespace.log.error(pc14__default.default.red(`Error: ${message}`));
+  p14__namespace.log.error(pc15__default.default.red(`Error: ${message}`));
+  if (process.env.VITEST) {
+    throw err;
+  }
   process.exit(1);
 }
 async function runCli(argv = process.argv) {