@solid-stack/mason 1.0.32 → 1.0.34

package/dist/bin.cjs

@@ -4,8 +4,8 @@
 var cac = require('cac');
 var p19 = require('@clack/prompts');
 var pc13 = require('picocolors');
-var fs14 = require('fs');
-var path2 = require('path');
+var fs17 = require('fs');
+var path26 = require('path');
 var url = require('url');
 var Handlebars = require('handlebars');
 var child_process = require('child_process');
@@ -34,14 +34,14 @@ function _interopNamespace(e) {
 
 var p19__namespace = /*#__PURE__*/_interopNamespace(p19);
 var pc13__default = /*#__PURE__*/_interopDefault(pc13);
-var fs14__default = /*#__PURE__*/_interopDefault(fs14);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
+var fs17__default = /*#__PURE__*/_interopDefault(fs17);
+var path26__default = /*#__PURE__*/_interopDefault(path26);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 
 function writeFileSafely(absolutePath, content, options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
-  const relPath = path2__default.default.relative(projectRoot, absolutePath).replace(/\\/g, "/");
-  const existedBefore = fs14__default.default.existsSync(absolutePath);
+  const relPath = path26__default.default.relative(projectRoot, absolutePath).replace(/\\/g, "/");
+  const existedBefore = fs17__default.default.existsSync(absolutePath);
   if (options.dryRun) {
     return {
       relativePath: relPath,
@@ -60,11 +60,11 @@ function writeFileSafely(absolutePath, content, options = {}) {
       existedBefore: true
     };
   }
-  const dir = path2__default.default.dirname(absolutePath);
-  if (!fs14__default.default.existsSync(dir)) {
-    fs14__default.default.mkdirSync(dir, { recursive: true });
+  const dir = path26__default.default.dirname(absolutePath);
+  if (!fs17__default.default.existsSync(dir)) {
+    fs17__default.default.mkdirSync(dir, { recursive: true });
   }
-  fs14__default.default.writeFileSync(absolutePath, content, "utf-8");
+  fs17__default.default.writeFileSync(absolutePath, content, "utf-8");
   return {
     relativePath: relPath,
     absolutePath,
@@ -155,17 +155,17 @@ function toStubName(ifaceName) {
   return `Stub${base}`;
 }
 function loadMasonConfig(startDir = process.cwd()) {
-  let current = path2__default.default.resolve(startDir);
+  let current = path26__default.default.resolve(startDir);
   while (true) {
-    const configPath = path2__default.default.join(current, "mason.config.json");
-    if (fs14__default.default.existsSync(configPath)) {
+    const configPath = path26__default.default.join(current, "mason.config.json");
+    if (fs17__default.default.existsSync(configPath)) {
       try {
-        return JSON.parse(fs14__default.default.readFileSync(configPath, "utf-8"));
+        return JSON.parse(fs17__default.default.readFileSync(configPath, "utf-8"));
       } catch {
         return null;
       }
     }
-    const parent = path2__default.default.dirname(current);
+    const parent = path26__default.default.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -175,60 +175,91 @@ function getEffectiveMode(projectRoot, flags) {
   if (flags?.registry) return "registry";
   const config = loadMasonConfig(projectRoot);
   if (config?.mode) return config.mode;
-  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "index.json")) && (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "features")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "shared")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/features")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared")))) {
+  if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "index.json")) && (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "features")) || fs17__default.default.existsSync(path26__default.default.join(projectRoot, "shared")) || fs17__default.default.existsSync(path26__default.default.join(projectRoot, "src/features")) || fs17__default.default.existsSync(path26__default.default.join(projectRoot, "src/shared")))) {
     return "registry";
   }
   return "app";
 }
 function getConfiguredFeaturesDir(projectRoot, flags) {
-  if (flags?.target) return path2__default.default.resolve(projectRoot, flags.target);
-  if (flags?.dest) return path2__default.default.resolve(projectRoot, flags.dest);
+  if (flags?.target) return path26__default.default.resolve(projectRoot, flags.target);
+  if (flags?.dest) return path26__default.default.resolve(projectRoot, flags.dest);
   const config = loadMasonConfig(projectRoot);
   if (config?.paths?.features) {
-    return path2__default.default.resolve(projectRoot, config.paths.features);
+    return path26__default.default.resolve(projectRoot, config.paths.features);
   }
   const mode = getEffectiveMode(projectRoot, flags);
   if (mode === "registry") {
-    if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
-      return path2__default.default.join(projectRoot, "src/features");
+    if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "src/features"))) {
+      return path26__default.default.join(projectRoot, "src/features");
     }
-    return path2__default.default.join(projectRoot, "features");
+    return path26__default.default.join(projectRoot, "features");
   }
-  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
-    return path2__default.default.join(projectRoot, "src/features");
+  if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "src/features"))) {
+    return path26__default.default.join(projectRoot, "src/features");
   }
-  return path2__default.default.join(projectRoot, "features");
+  return path26__default.default.join(projectRoot, "features");
 }
 function getConfiguredSharedDir(projectRoot, flags) {
-  if (flags?.target) return path2__default.default.resolve(projectRoot, flags.target);
-  if (flags?.dest) return path2__default.default.resolve(projectRoot, flags.dest);
+  if (flags?.target) return path26__default.default.resolve(projectRoot, flags.target);
+  if (flags?.dest) return path26__default.default.resolve(projectRoot, flags.dest);
   const config = loadMasonConfig(projectRoot);
   if (config?.paths?.shared) {
-    return path2__default.default.resolve(projectRoot, config.paths.shared);
+    return path26__default.default.resolve(projectRoot, config.paths.shared);
   }
   const mode = getEffectiveMode(projectRoot, flags);
   if (mode === "registry") {
-    if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
-      return path2__default.default.join(projectRoot, "src/shared");
+    if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "src/shared"))) {
+      return path26__default.default.join(projectRoot, "src/shared");
     }
-    return path2__default.default.join(projectRoot, "shared");
+    return path26__default.default.join(projectRoot, "shared");
   }
-  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
-    return path2__default.default.join(projectRoot, "src/shared");
+  if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "src/shared"))) {
+    return path26__default.default.join(projectRoot, "src/shared");
   }
-  return path2__default.default.join(projectRoot, "shared");
+  return path26__default.default.join(projectRoot, "shared");
+}
+function loadLintConfig(projectRoot) {
+  const configPath = path26__default.default.join(projectRoot, "mason-lint.config.json");
+  if (fs17__default.default.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs17__default.default.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  return {};
+}
+function getResolvedLintPaths(projectRoot, config) {
+  const masonConfig = loadMasonConfig(projectRoot);
+  const configuredFeatures = config.paths?.features ?? masonConfig?.paths?.features;
+  const configuredShared = config.paths?.shared ?? masonConfig?.paths?.shared;
+  const configuredErrors = config.paths?.errors;
+  const resolveBase = (configuredPath, defaultSrc, defaultRoot) => {
+    if (configuredPath !== void 0) {
+      return path26__default.default.resolve(projectRoot, configuredPath);
+    }
+    const srcPath = path26__default.default.join(projectRoot, defaultSrc);
+    if (fs17__default.default.existsSync(srcPath)) return srcPath;
+    const rootPath = path26__default.default.join(projectRoot, defaultRoot);
+    if (fs17__default.default.existsSync(rootPath)) return rootPath;
+    return srcPath;
+  };
+  return {
+    featuresBase: resolveBase(configuredFeatures, "src/features", "features"),
+    sharedBase: resolveBase(configuredShared, "src/shared", "shared"),
+    errorsBase: resolveBase(configuredErrors, "src/errors", "errors")
+  };
 }
 
 // src/utils/project.ts
 function findProjectRoot(startDir = process.cwd()) {
-  let current = path2__default.default.resolve(startDir);
+  let current = path26__default.default.resolve(startDir);
   while (true) {
-    if (fs14__default.default.existsSync(path2__default.default.join(current, "package.json"))) {
+    if (fs17__default.default.existsSync(path26__default.default.join(current, "package.json"))) {
       return current;
     }
-    const parent = path2__default.default.dirname(current);
+    const parent = path26__default.default.dirname(current);
     if (parent === current) {
-      return path2__default.default.resolve(startDir);
+      return path26__default.default.resolve(startDir);
     }
     current = parent;
   }
@@ -241,9 +272,9 @@ function resolveSharedDir(projectRoot, flags) {
 }
 function listExistingFeatures(projectRoot) {
   const featuresDir = resolveFeaturesDir(projectRoot);
-  if (!fs14__default.default.existsSync(featuresDir)) return [];
+  if (!fs17__default.default.existsSync(featuresDir)) return [];
   try {
-    const entries = fs14__default.default.readdirSync(featuresDir, { withFileTypes: true });
+    const entries = fs17__default.default.readdirSync(featuresDir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -253,14 +284,14 @@ function listDomainInterfaces(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs14__default.default.existsSync(domainDir)) continue;
+    const domainDir = path26__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs17__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs14__default.default.readdirSync(domainDir);
+      const files = fs17__default.default.readdirSync(domainDir);
       for (const file of files) {
         if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
           const name = file.replace(/\.ts$/, "");
-          const fullPath = path2__default.default.join(domainDir, file);
+          const fullPath = path26__default.default.join(domainDir, file);
           if (/^I[A-Z]/.test(name)) {
             results.push({
               name,
@@ -269,7 +300,7 @@ function listDomainInterfaces(projectRoot, featureName) {
             });
           } else {
             try {
-              const content = fs14__default.default.readFileSync(fullPath, "utf-8");
+              const content = fs17__default.default.readFileSync(fullPath, "utf-8");
               if (/export\s+(?:abstract\s+class|interface)\s+(\w+)/.test(content)) {
                 results.push({
                   name,
@@ -291,17 +322,17 @@ function listDomainEntities(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs14__default.default.existsSync(domainDir)) continue;
+    const domainDir = path26__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs17__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs14__default.default.readdirSync(domainDir);
+      const files = fs17__default.default.readdirSync(domainDir);
       for (const file of files) {
         if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
           const name = file.replace(/\.ts$/, "");
           if (!/^I[A-Z]/.test(name)) {
             results.push({
               name,
-              fullPath: path2__default.default.join(domainDir, file),
+              fullPath: path26__default.default.join(domainDir, file),
               feature: feat
             });
           }
@@ -316,16 +347,16 @@ function listUseCases(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const useCasesDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "useCases");
-    if (!fs14__default.default.existsSync(useCasesDir)) continue;
+    const useCasesDir = path26__default.default.join(resolveFeaturesDir(projectRoot), feat, "useCases");
+    if (!fs17__default.default.existsSync(useCasesDir)) continue;
     try {
-      const files = fs14__default.default.readdirSync(useCasesDir);
+      const files = fs17__default.default.readdirSync(useCasesDir);
       for (const file of files) {
         if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
           const name = file.replace(/\.ts$/, "");
           results.push({
             name,
-            fullPath: path2__default.default.join(useCasesDir, file),
+            fullPath: path26__default.default.join(useCasesDir, file),
             feature: feat
           });
         }
@@ -351,33 +382,33 @@ hbs.registerHelper("join", (arr, sep) => {
 });
 var cachedTemplatesDir = null;
 function getTemplatesDir() {
-  if (cachedTemplatesDir && fs14__default.default.existsSync(cachedTemplatesDir)) {
+  if (cachedTemplatesDir && fs17__default.default.existsSync(cachedTemplatesDir)) {
     return cachedTemplatesDir;
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path2__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
-  const cand1 = path2__default.default.resolve(currentDir, "../../templates");
-  if (fs14__default.default.existsSync(cand1)) {
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path26__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
+  const cand1 = path26__default.default.resolve(currentDir, "../../templates");
+  if (fs17__default.default.existsSync(cand1)) {
     cachedTemplatesDir = cand1;
     return cand1;
   }
-  const cand2 = path2__default.default.resolve(currentDir, "../templates");
-  if (fs14__default.default.existsSync(cand2)) {
+  const cand2 = path26__default.default.resolve(currentDir, "../templates");
+  if (fs17__default.default.existsSync(cand2)) {
     cachedTemplatesDir = cand2;
     return cand2;
   }
-  const cand3 = path2__default.default.resolve(currentDir, "templates");
-  if (fs14__default.default.existsSync(cand3)) {
+  const cand3 = path26__default.default.resolve(currentDir, "templates");
+  if (fs17__default.default.existsSync(cand3)) {
     cachedTemplatesDir = cand3;
     return cand3;
   }
   let curr = currentDir;
   while (true) {
-    const candTemplates = path2__default.default.join(curr, "templates");
-    if (fs14__default.default.existsSync(candTemplates)) {
+    const candTemplates = path26__default.default.join(curr, "templates");
+    if (fs17__default.default.existsSync(candTemplates)) {
       cachedTemplatesDir = candTemplates;
       return candTemplates;
     }
-    const parent = path2__default.default.dirname(curr);
+    const parent = path26__default.default.dirname(curr);
     if (parent === curr) break;
     curr = parent;
   }
@@ -385,8 +416,8 @@ function getTemplatesDir() {
 }
 var templateCache = /* @__PURE__ */ new Map();
 function loadTemplate(relativePath) {
-  const fullPath = path2__default.default.isAbsolute(relativePath) ? relativePath : path2__default.default.join(getTemplatesDir(), relativePath);
-  return fs14__default.default.readFileSync(fullPath, "utf-8");
+  const fullPath = path26__default.default.isAbsolute(relativePath) ? relativePath : path26__default.default.join(getTemplatesDir(), relativePath);
+  return fs17__default.default.readFileSync(fullPath, "utf-8");
 }
 function renderTemplateFile(relativePath, context) {
   let compiled = templateCache.get(relativePath);
@@ -473,8 +504,8 @@ function generateDomainEntityCode(name, kind = "interface", properties = []) {
 function generateDomain(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const entityName = toPascalCase(options.name);
-  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
-  const filePath = path2__default.default.join(targetDir, `${entityName}.ts`);
+  const targetDir = options.targetDir || path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path26__default.default.join(targetDir, `${entityName}.ts`);
   const code = generateDomainEntityCode(
     entityName,
     options.kind || "interface",
@@ -523,8 +554,8 @@ function generateInterfaceCode(ifaceName, kind = "abstractClass", entityName, me
 function generateInterface(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const ifaceName = ensureInterfacePrefix(options.name);
-  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
-  const filePath = path2__default.default.join(targetDir, `${ifaceName}.ts`);
+  const targetDir = options.targetDir || path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path26__default.default.join(targetDir, `${ifaceName}.ts`);
   const code = generateInterfaceCode(
     ifaceName,
     options.kind || "abstractClass",
@@ -759,7 +790,7 @@ function parseInterfaceMethodsAndImports(content, targetIfaceName) {
   };
 }
 function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
-  if (customPath && fs14__default.default.existsSync(customPath)) {
+  if (customPath && fs17__default.default.existsSync(customPath)) {
     return { filePath: customPath, ifaceName };
   }
   const candidateNames = [
@@ -769,22 +800,22 @@ function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
   ];
   const features = featureName ? [featureName, ...listExistingFeatures(projectRoot).filter((f) => f !== featureName)] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs14__default.default.existsSync(domainDir)) continue;
+    const domainDir = path26__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs17__default.default.existsSync(domainDir)) continue;
     for (const cand of candidateNames) {
-      const p1 = path2__default.default.join(domainDir, `${cand}.ts`);
-      if (fs14__default.default.existsSync(p1)) {
+      const p1 = path26__default.default.join(domainDir, `${cand}.ts`);
+      if (fs17__default.default.existsSync(p1)) {
         return { filePath: p1, ifaceName: cand, feature: feat };
       }
     }
   }
   for (const cand of candidateNames) {
-    const p1 = path2__default.default.join(projectRoot, "domain", `${cand}.ts`);
-    if (fs14__default.default.existsSync(p1)) return { filePath: p1, ifaceName: cand };
-    const p22 = path2__default.default.join(projectRoot, "src", "domain", `${cand}.ts`);
-    if (fs14__default.default.existsSync(p22)) return { filePath: p22, ifaceName: cand };
-    const p32 = path2__default.default.join(projectRoot, "interfaces", `${cand}.ts`);
-    if (fs14__default.default.existsSync(p32)) return { filePath: p32, ifaceName: cand };
+    const p1 = path26__default.default.join(projectRoot, "domain", `${cand}.ts`);
+    if (fs17__default.default.existsSync(p1)) return { filePath: p1, ifaceName: cand };
+    const p22 = path26__default.default.join(projectRoot, "src", "domain", `${cand}.ts`);
+    if (fs17__default.default.existsSync(p22)) return { filePath: p22, ifaceName: cand };
+    const p32 = path26__default.default.join(projectRoot, "interfaces", `${cand}.ts`);
+    if (fs17__default.default.existsSync(p32)) return { filePath: p32, ifaceName: cand };
   }
   return null;
 }
@@ -807,7 +838,7 @@ function loadInterfaceHierarchy(projectRoot, initialIfaceName, featureName, cust
   while (currentFile && !visited.has(currentFile)) {
     visited.add(currentFile);
     try {
-      const content = fs14__default.default.readFileSync(currentFile, "utf-8");
+      const content = fs17__default.default.readFileSync(currentFile, "utf-8");
       const parsed = parseInterfaceMethodsAndImports(content, currentName);
       for (const m of parsed.methods) {
         if (!allMethods.some((existing) => existing.name === m.name)) {
@@ -883,7 +914,7 @@ function generateStubCode(stubClassName, ifaceName, entityName, featureName, met
   const entitiesVar = `${entityVar}s`;
   const idKey = `${entityVar}Id`;
   const impPath = ifaceImportPath || `../domain/${ifaceName}.js`;
-  const entityImportPath = ifaceImportPath ? `${path2__default.default.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+  const entityImportPath = ifaceImportPath ? `${path26__default.default.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
   const importsByFrom = /* @__PURE__ */ new Map();
   for (const imp of domainImports) {
     if (imp.name === ifaceName || imp.name === baseEntity) continue;
@@ -932,7 +963,7 @@ function generateConcreteInfraCode(className, ifaceName, dependencies = [], meth
     if (baseEntity) {
       finalMethods = synthesizeCrudMethods(baseEntity);
       if (!finalDomainImports.some((imp) => imp.name === baseEntity)) {
-        const importPath = ifaceImportPath ? `${path2__default.default.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+        const importPath = ifaceImportPath ? `${path26__default.default.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
         finalDomainImports.push({
           name: baseEntity,
           from: importPath,
@@ -977,8 +1008,8 @@ function generateInfrastructure(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const className = toPascalCase(options.name);
   const isFeatureScope = options.scope !== "global" && Boolean(options.feature);
-  const targetDir = options.targetDir || (isFeatureScope ? path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "infrastructure") : path2__default.default.join(projectRoot, "infrastructure"));
-  const filePath = path2__default.default.join(targetDir, `${className}.ts`);
+  const targetDir = options.targetDir || (isFeatureScope ? path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "infrastructure") : path26__default.default.join(projectRoot, "infrastructure"));
+  const filePath = path26__default.default.join(targetDir, `${className}.ts`);
   let code;
   if (options.implementsInterface) {
     const rawIfaceName = options.implementsInterface;
@@ -992,7 +1023,7 @@ function generateInfrastructure(options) {
     const ifaceFilePath = hierarchy.ifaceFilePath;
     let ifaceImportPath;
     if (ifaceFilePath) {
-      let rel = path2__default.default.relative(targetDir, ifaceFilePath).replace(/\\/g, "/").replace(/\.ts$/, ".js");
+      let rel = path26__default.default.relative(targetDir, ifaceFilePath).replace(/\\/g, "/").replace(/\.ts$/, ".js");
       if (!rel.startsWith(".")) rel = "./" + rel;
       ifaceImportPath = rel;
     } else if (isFeatureScope) {
@@ -1005,8 +1036,8 @@ function generateInfrastructure(options) {
         if (new RegExp(`\\b${item.name}\\b`).test(allSignatures)) {
           let fromPath;
           if (imp.specifier.startsWith(".") && ifaceFilePath) {
-            const absTarget = path2__default.default.resolve(path2__default.default.dirname(ifaceFilePath), imp.specifier);
-            let rel = path2__default.default.relative(targetDir, absTarget).replace(/\\/g, "/");
+            const absTarget = path26__default.default.resolve(path26__default.default.dirname(ifaceFilePath), imp.specifier);
+            let rel = path26__default.default.relative(targetDir, absTarget).replace(/\\/g, "/");
             if (!rel.startsWith(".")) rel = "./" + rel;
             fromPath = rel;
           } else {
@@ -1193,8 +1224,8 @@ function generateUseCase(options) {
   const files = [];
   const projectRoot = options.projectRoot || findProjectRoot();
   const ucName = toPascalCase(options.name);
-  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "useCases");
-  const filePath = path2__default.default.join(targetDir, `${ucName}.ts`);
+  const targetDir = options.targetDir || path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "useCases");
+  const filePath = path26__default.default.join(targetDir, `${ucName}.ts`);
   const code = generateUseCaseCode(
     ucName,
     options.dependencies || [],
@@ -1210,7 +1241,7 @@ function generateUseCase(options) {
     })
   );
   if (options.includeTest) {
-    const testPath = path2__default.default.join(targetDir, `${ucName}.test.ts`);
+    const testPath = path26__default.default.join(targetDir, `${ucName}.test.ts`);
     const testCode = generateUseCaseTestCode(ucName, options.dependencies || []);
     files.push(
       writeFileSafely(testPath, testCode, {
@@ -1278,10 +1309,10 @@ function generateHttpHandler(options) {
   const files = [];
   const projectRoot = options.projectRoot || findProjectRoot();
   const className = toPascalCase(options.name);
-  const pxDir = path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress");
-  const handlersDir = path2__default.default.join(pxDir, "handlers");
-  const pxIndexPath = path2__default.default.join(pxDir, "index.ts");
-  if (!fs14__default.default.existsSync(pxIndexPath)) {
+  const pxDir = path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress");
+  const handlersDir = path26__default.default.join(pxDir, "handlers");
+  const pxIndexPath = path26__default.default.join(pxDir, "index.ts");
+  if (!fs17__default.default.existsSync(pxIndexPath)) {
     const featurePath = options.routePrefix || `/${options.feature.toLowerCase()}`;
     const pxIndexContent = renderTemplate(expressIndexTemplate, {
       routePath: featurePath
@@ -1294,7 +1325,7 @@ function generateHttpHandler(options) {
       })
     );
   }
-  const handlerFilePath = path2__default.default.join(handlersDir, `${className}.ts`);
+  const handlerFilePath = path26__default.default.join(handlersDir, `${className}.ts`);
   const code = generateHttpHandlerCode(
     className,
     options.method || "get",
@@ -1315,11 +1346,11 @@ function generateHttpHandler(options) {
   return files;
 }
 function updateOrGenerateDiProvider(featureDir, featureName, bindings = [], options = {}) {
-  const providerPath = path2__default.default.join(featureDir, "diProvider.ts");
+  const providerPath = path26__default.default.join(featureDir, "diProvider.ts");
   const pascalFeature = toPascalCase(featureName);
   const providerModuleName = `${pascalFeature}Provider`;
-  if (fs14__default.default.existsSync(providerPath) && !options.overwrite) {
-    let content = fs14__default.default.readFileSync(providerPath, "utf-8");
+  if (fs17__default.default.existsSync(providerPath) && !options.overwrite) {
+    let content = fs17__default.default.readFileSync(providerPath, "utf-8");
     content = content.replace(/\n*export\s+const\s+ScaffoldProvider\s*=[^;]+;?/g, "");
     for (const b of bindings) {
       const ifaceImp = b.ifaceImportPath || `./domain/${b.ifaceName}.js`;
@@ -1378,7 +1409,7 @@ function generateFeature(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const rawName = options.name.trim();
   const featureName = toCamelCase(rawName);
-  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), featureName);
+  const targetDir = options.targetDir || path26__default.default.join(resolveFeaturesDir(projectRoot), featureName);
   const routePath = options.routePath || `/${featureName}`;
   const rawEntities = [];
   if (options.entityNames && options.entityNames.length > 0) {
@@ -1399,7 +1430,7 @@ function generateFeature(options) {
       const domainFile = generateDomain({
         name: ent,
         feature: featureName,
-        targetDir: path2__default.default.join(targetDir, "domain"),
+        targetDir: path26__default.default.join(targetDir, "domain"),
         projectRoot,
         dryRun: options.dryRun,
         overwrite: options.overwrite,
@@ -1419,7 +1450,7 @@ function generateFeature(options) {
       const ifaceFile = generateInterface({
         name: ifaceName,
         feature: featureName,
-        targetDir: path2__default.default.join(targetDir, "domain"),
+        targetDir: path26__default.default.join(targetDir, "domain"),
         entityName: ent,
         projectRoot,
         dryRun: options.dryRun,
@@ -1436,7 +1467,7 @@ function generateFeature(options) {
       const stubFile = generateInfrastructure({
         name: stubName,
         feature: featureName,
-        targetDir: path2__default.default.join(targetDir, "infrastructure"),
+        targetDir: path26__default.default.join(targetDir, "infrastructure"),
         kind: "stub",
         implementsInterface: ifaceName,
         entityName: ent,
@@ -1478,7 +1509,7 @@ function generateFeature(options) {
       const ucFiles = generateUseCase({
         name: ucName,
         feature: featureName,
-        targetDir: path2__default.default.join(targetDir, "useCases"),
+        targetDir: path26__default.default.join(targetDir, "useCases"),
         dependencies: options.includeInterface !== false ? [ifaceName] : [],
         inputProperties: [{ name: idParam, type: "string" }],
         outputProperties: [{ name: entVar, type: primaryEntity }],
@@ -1523,7 +1554,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path2__default.default.join(targetDir, "useCases"),
+            targetDir: path26__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: entVar, type: ent }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1556,7 +1587,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path2__default.default.join(targetDir, "useCases"),
+            targetDir: path26__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: idParam, type: "string" }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1589,7 +1620,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path2__default.default.join(targetDir, "useCases"),
+            targetDir: path26__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [
               { name: "page", type: "number", optional: true },
@@ -1633,7 +1664,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path2__default.default.join(targetDir, "useCases"),
+            targetDir: path26__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: entVar, type: ent }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1666,7 +1697,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path2__default.default.join(targetDir, "useCases"),
+            targetDir: path26__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: idParam, type: "string" }],
             outputProperties: [{ name: "success", type: "boolean" }],
@@ -1703,7 +1734,7 @@ function generateFeature(options) {
       const ucFiles = generateUseCase({
         name: ucName,
         feature: featureName,
-        targetDir: path2__default.default.join(targetDir, "useCases"),
+        targetDir: path26__default.default.join(targetDir, "useCases"),
         dependencies: customUc.dependencies || [],
         inputProperties: customUc.inputProperties || [],
         outputProperties: customUc.outputProperties || [],
@@ -1735,8 +1766,8 @@ function generateFeature(options) {
     }
   }
   if (options.includeExpress !== false) {
-    const pxDir = path2__default.default.join(targetDir, "pxExpress");
-    const pxIndexPath = path2__default.default.join(pxDir, "index.ts");
+    const pxDir = path26__default.default.join(targetDir, "pxExpress");
+    const pxIndexPath = path26__default.default.join(pxDir, "index.ts");
     if (!files.some((f) => f.absolutePath === pxIndexPath)) {
       const pxIndexContent = renderTemplate(expressIndexTemplate, { routePath });
       files.push(
@@ -1866,7 +1897,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   }
   const normalizedName = toCamelCase(name);
   const baseFeaturesDir = resolveFeaturesDir(projectRoot, flags);
-  const defaultDir = path2__default.default.relative(projectRoot, path2__default.default.join(baseFeaturesDir, normalizedName));
+  const defaultDir = path26__default.default.relative(projectRoot, path26__default.default.join(baseFeaturesDir, normalizedName));
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
@@ -1877,7 +1908,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       })
     ).trim();
   }
-  const targetDir = flags.dest ? path2__default.default.resolve(projectRoot, flags.dest) : flags.target ? path2__default.default.resolve(projectRoot, flags.target) : path2__default.default.resolve(projectRoot, targetDirRel);
+  const targetDir = flags.dest ? path26__default.default.resolve(projectRoot, flags.dest) : flags.target ? path26__default.default.resolve(projectRoot, flags.target) : path26__default.default.resolve(projectRoot, targetDirRel);
   let includeExpress = flags.express !== void 0 ? Boolean(flags.express) : true;
   let routePath = `/${normalizedName}`;
   let includeDomain = true;
@@ -2119,8 +2150,8 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   };
   const files = generateFeature(options);
   if (isRegistry) {
-    const registryPath = path2__default.default.join(targetDir, "registry.json");
-    if (!fs14__default.default.existsSync(registryPath)) {
+    const registryPath = path26__default.default.join(targetDir, "registry.json");
+    if (!fs17__default.default.existsSync(registryPath)) {
       const manifest = {
         name: toKebabCase(normalizedName),
         type: "feature",
@@ -2146,7 +2177,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   printGeneratedFiles(files, options.dryRun);
   p19__namespace.outro(
     pc13__default.default.green(
-      `\u2713 Feature '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
+      `\u2713 Feature '${normalizedName}' initialized in ${path26__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
 }
@@ -2157,7 +2188,7 @@ function generateShared(options) {
   const pascalName = toPascalCase(rawName);
   const camelName = toCamelCase(rawName);
   const kebabName = toKebabCase(rawName);
-  const targetDir = options.targetDir || path2__default.default.join(resolveSharedDir(projectRoot), kebabName);
+  const targetDir = options.targetDir || path26__default.default.join(resolveSharedDir(projectRoot), kebabName);
   const fileDefs = [];
   const facadeContent = `import { MakeInjectable, type DepsType } from "@solid-stack/di";
 import { I${pascalName}Engine } from "./ports/I${pascalName}Engine.js";
@@ -2169,7 +2200,7 @@ export class ${pascalName} {
 }
 `;
   fileDefs.push({
-    absolutePath: path2__default.default.join(targetDir, `${pascalName}.ts`),
+    absolutePath: path26__default.default.join(targetDir, `${pascalName}.ts`),
     content: facadeContent
   });
   const portContent = `export abstract class I${pascalName}Engine {
@@ -2177,7 +2208,7 @@ export class ${pascalName} {
 }
 `;
   fileDefs.push({
-    absolutePath: path2__default.default.join(targetDir, "ports", `I${pascalName}Engine.ts`),
+    absolutePath: path26__default.default.join(targetDir, "ports", `I${pascalName}Engine.ts`),
     content: portContent
   });
   const concreteContent = `import { MakeInjectable } from "@solid-stack/di";
@@ -2189,7 +2220,7 @@ export class Default${pascalName}Engine implements I${pascalName}Engine {
 }
 `;
   fileDefs.push({
-    absolutePath: path2__default.default.join(targetDir, "infrastructure", `Default${pascalName}Engine.ts`),
+    absolutePath: path26__default.default.join(targetDir, "infrastructure", `Default${pascalName}Engine.ts`),
     content: concreteContent
   });
   if (options.includeStub !== false) {
@@ -2202,7 +2233,7 @@ export class Stub${pascalName}Engine implements I${pascalName}Engine {
 }
 `;
     fileDefs.push({
-      absolutePath: path2__default.default.join(targetDir, "infrastructure", `Stub${pascalName}Engine.ts`),
+      absolutePath: path26__default.default.join(targetDir, "infrastructure", `Stub${pascalName}Engine.ts`),
       content: stubContent
     });
   }
@@ -2217,7 +2248,7 @@ export const diProvider = (c: Container): void => {
 export default diProvider;
 `;
   fileDefs.push({
-    absolutePath: path2__default.default.join(targetDir, "diProvider.ts"),
+    absolutePath: path26__default.default.join(targetDir, "diProvider.ts"),
     content: providerContent
   });
   if (options.isRegistry) {
@@ -2234,7 +2265,7 @@ export default diProvider;
       files: []
     };
     fileDefs.push({
-      absolutePath: path2__default.default.join(targetDir, "registry.json"),
+      absolutePath: path26__default.default.join(targetDir, "registry.json"),
       content: JSON.stringify(registryManifest, null, 2) + "\n"
     });
   }
@@ -2271,7 +2302,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   }
   const normalizedName = toKebabCase(name);
   const baseSharedDir = resolveSharedDir(projectRoot, flags);
-  const defaultDir = path2__default.default.relative(projectRoot, path2__default.default.join(baseSharedDir, normalizedName));
+  const defaultDir = path26__default.default.relative(projectRoot, path26__default.default.join(baseSharedDir, normalizedName));
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
@@ -2282,7 +2313,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
       })
     ).trim();
   }
-  const targetDir = flags.dest ? path2__default.default.resolve(projectRoot, flags.dest) : flags.target ? path2__default.default.resolve(projectRoot, flags.target) : path2__default.default.resolve(projectRoot, targetDirRel);
+  const targetDir = flags.dest ? path26__default.default.resolve(projectRoot, flags.dest) : flags.target ? path26__default.default.resolve(projectRoot, flags.target) : path26__default.default.resolve(projectRoot, targetDirRel);
   let description = flags.description || "";
   let includeStub = true;
   if (!flags.yes) {
@@ -2316,7 +2347,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   printGeneratedFiles(files, Boolean(flags.dryRun));
   p19__namespace.outro(
     pc13__default.default.green(
-      `\u2713 Shared module '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
+      `\u2713 Shared module '${normalizedName}' initialized in ${path26__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
 }
@@ -2743,7 +2774,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   const infraFile = generateInfrastructure(options);
   files.push(infraFile);
   if (registerInProvider && scope === "feature" && feature && implementsInterface) {
-    const featureDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feature);
+    const featureDir = path26__default.default.join(resolveFeaturesDir(projectRoot), feature);
     const providerFile = updateOrGenerateDiProvider(
       featureDir,
       feature,
@@ -2905,7 +2936,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
     files.push(stubFile);
   }
   if (registerInProvider && generateStub) {
-    const featureDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feature);
+    const featureDir = path26__default.default.join(resolveFeaturesDir(projectRoot), feature);
     const providerFile = updateOrGenerateDiProvider(
       featureDir,
       feature,
@@ -3093,21 +3124,21 @@ function generateInjectable(options) {
   const className = toPascalCase(options.name);
   let targetDir = "";
   if (options.customPath) {
-    targetDir = path2__default.default.isAbsolute(options.customPath) ? options.customPath : path2__default.default.join(projectRoot, options.customPath);
+    targetDir = path26__default.default.isAbsolute(options.customPath) ? options.customPath : path26__default.default.join(projectRoot, options.customPath);
   } else if (options.location === "feature-service" && options.feature) {
-    targetDir = path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services");
+    targetDir = path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services");
   } else if (options.location === "feature-transformer" && options.feature) {
-    targetDir = path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress", "transformers");
+    targetDir = path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress", "transformers");
   } else if (options.location === "module") {
-    targetDir = path2__default.default.join(projectRoot, "modules", className);
+    targetDir = path26__default.default.join(projectRoot, "modules", className);
   } else {
-    targetDir = options.feature ? path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services") : path2__default.default.join(projectRoot, "shared", className.toLowerCase());
+    targetDir = options.feature ? path26__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services") : path26__default.default.join(projectRoot, "shared", className.toLowerCase());
   }
-  const filePath = path2__default.default.join(targetDir, `${className}.ts`);
+  const filePath = path26__default.default.join(targetDir, `${className}.ts`);
   let ifaceName;
   if (options.generateInterface) {
     ifaceName = `I${className}`;
-    const ifacePath = path2__default.default.join(targetDir, `${ifaceName}.ts`);
+    const ifacePath = path26__default.default.join(targetDir, `${ifaceName}.ts`);
     const ifaceContent = renderTemplate(injectableInterfaceTemplate, { ifaceName });
     files.push(
       writeFileSafely(ifacePath, ifaceContent, {
@@ -3236,7 +3267,7 @@ async function runEnvInit(flags = {}) {
   const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
   const s = p19__namespace.spinner();
   s.start("Scanning for .example environment files...");
-  const files = fs14__default.default.readdirSync(projectRoot);
+  const files = fs17__default.default.readdirSync(projectRoot);
   const exampleFiles = files.filter((file) => file.startsWith(".env") && file.endsWith(".example")).sort();
   if (exampleFiles.length === 0) {
     s.stop("No .example files found.");
@@ -3246,11 +3277,11 @@ async function runEnvInit(flags = {}) {
   s.message(`Found ${exampleFiles.length} template(s). Generating...`);
   const generatedFiles = [];
   for (const exampleFile of exampleFiles) {
-    const sourcePath = path2__default.default.join(projectRoot, exampleFile);
+    const sourcePath = path26__default.default.join(projectRoot, exampleFile);
     const targetFile = exampleFile.replace(/\.example$/, "");
-    const targetPath = path2__default.default.join(projectRoot, targetFile);
+    const targetPath = path26__default.default.join(projectRoot, targetFile);
     let overwrite = flags.overwrite;
-    if (overwrite === void 0 && !flags.dryRun && !flags.yes && !process.env.VITEST && process.stdin.isTTY && fs14__default.default.existsSync(targetPath)) {
+    if (overwrite === void 0 && !flags.dryRun && !flags.yes && !process.env.VITEST && process.stdin.isTTY && fs17__default.default.existsSync(targetPath)) {
       overwrite = await p19__namespace.confirm({
         message: `${targetFile} already exists. Overwrite?`,
         initialValue: false
@@ -3260,7 +3291,7 @@ async function runEnvInit(flags = {}) {
         process.exit(0);
       }
     }
-    const content = fs14__default.default.readFileSync(sourcePath, "utf-8");
+    const content = fs17__default.default.readFileSync(sourcePath, "utf-8");
     const genFile = writeFileSafely(targetPath, content, {
       projectRoot,
       dryRun: Boolean(flags.dryRun),
@@ -3278,7 +3309,7 @@ var EnvEditor = class {
   filePath;
   constructor(filePath) {
     this.filePath = filePath;
-    this.lines = fs14__default.default.existsSync(filePath) ? fs14__default.default.readFileSync(filePath, "utf-8").split(/\r?\n/) : [];
+    this.lines = fs17__default.default.existsSync(filePath) ? fs17__default.default.readFileSync(filePath, "utf-8").split(/\r?\n/) : [];
   }
   getLines() {
     return [...this.lines];
@@ -3342,18 +3373,18 @@ var EnvEditor = class {
     });
   }
   save() {
-    const dir = path2__default.default.dirname(this.filePath);
-    if (!fs14__default.default.existsSync(dir)) {
-      fs14__default.default.mkdirSync(dir, { recursive: true });
+    const dir = path26__default.default.dirname(this.filePath);
+    if (!fs17__default.default.existsSync(dir)) {
+      fs17__default.default.mkdirSync(dir, { recursive: true });
     }
-    fs14__default.default.writeFileSync(this.filePath, this.lines.join("\n"), "utf-8");
+    fs17__default.default.writeFileSync(this.filePath, this.lines.join("\n"), "utf-8");
   }
 };
 function discoverEnvironments(projectRoot) {
-  if (!fs14__default.default.existsSync(projectRoot)) {
+  if (!fs17__default.default.existsSync(projectRoot)) {
     return ["local", "dev", "prod"];
   }
-  const files = fs14__default.default.readdirSync(projectRoot);
+  const files = fs17__default.default.readdirSync(projectRoot);
   const envs = /* @__PURE__ */ new Set();
   for (const file of files) {
     if (file.startsWith(".env")) {
@@ -3378,7 +3409,7 @@ async function runEnvInitExamples(flags = {}) {
   const projectRoot = flags.cwd || flags.targetDir || findProjectRoot();
   const s = p19__namespace.spinner();
   s.start("Scanning for local environment files...");
-  const files = fs14__default.default.readdirSync(projectRoot, { withFileTypes: true });
+  const files = fs17__default.default.readdirSync(projectRoot, { withFileTypes: true });
   const envFiles = files.filter((dirent) => dirent.isFile() && dirent.name.startsWith(".env") && !dirent.name.endsWith(".example")).map((dirent) => dirent.name).sort();
   if (envFiles.length === 0) {
     s.stop("No local .env files found.");
@@ -3388,11 +3419,11 @@ async function runEnvInitExamples(flags = {}) {
   s.message(`Found ${envFiles.length} local .env file(s). Generating templates...`);
   const generatedFiles = [];
   for (const envFile of envFiles) {
-    const sourcePath = path2__default.default.join(projectRoot, envFile);
+    const sourcePath = path26__default.default.join(projectRoot, envFile);
     const targetFile = `${envFile}.example`;
-    const targetPath = path2__default.default.join(projectRoot, targetFile);
+    const targetPath = path26__default.default.join(projectRoot, targetFile);
     let overwrite = flags.overwrite;
-    if (overwrite === void 0 && !flags.dryRun && !flags.yes && !process.env.VITEST && process.stdin.isTTY && fs14__default.default.existsSync(targetPath)) {
+    if (overwrite === void 0 && !flags.dryRun && !flags.yes && !process.env.VITEST && process.stdin.isTTY && fs17__default.default.existsSync(targetPath)) {
       overwrite = await p19__namespace.confirm({
         message: `${targetFile} already exists. Overwrite with redacted values?`,
         initialValue: true
@@ -3425,12 +3456,12 @@ function isInteractive(flags) {
 function getAllExistingKeys(projectRoot, envs) {
   const keys = /* @__PURE__ */ new Set();
   for (const env of envs) {
-    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
-    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
-    if (fs14__default.default.existsSync(localPath)) {
+    const localPath = path26__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path26__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    if (fs17__default.default.existsSync(localPath)) {
       new EnvEditor(localPath).getKeys().forEach((k) => keys.add(k));
     }
-    if (fs14__default.default.existsSync(examplePath)) {
+    if (fs17__default.default.existsSync(examplePath)) {
       new EnvEditor(examplePath).getKeys().forEach((k) => keys.add(k));
     }
   }
@@ -3502,8 +3533,8 @@ async function runEnvAdd(key, value, flags = {}) {
         })
       );
     }
-    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
-    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    const localPath = path26__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path26__default.default.join(projectRoot, resolveEnvFilename(env, true));
     if (flags.dryRun) {
       p19__namespace.log.info(
         pc13__default.default.cyan(`[DRY RUN] Would set ${targetKey}=${envVal} in ${resolveEnvFilename(env, false)}`)
@@ -3550,8 +3581,8 @@ async function runEnvUpdate(key, value, flags = {}) {
     );
   }
   const envsWithKey = allEnvs.filter((env) => {
-    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
-    return fs14__default.default.existsSync(localPath) && new EnvEditor(localPath).has(targetKey);
+    const localPath = path26__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    return fs17__default.default.existsSync(localPath) && new EnvEditor(localPath).has(targetKey);
   });
   let targetEnvs = [];
   if (flags.env) {
@@ -3577,7 +3608,7 @@ async function runEnvUpdate(key, value, flags = {}) {
     return { key: targetKey, environments: [] };
   }
   for (const env of targetEnvs) {
-    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const localPath = path26__default.default.join(projectRoot, resolveEnvFilename(env, false));
     const localEditor = new EnvEditor(localPath);
     const currentVal = localEditor.getValue(targetKey);
     let newVal = value;
@@ -3607,7 +3638,7 @@ async function runEnvUpdate(key, value, flags = {}) {
     } else {
       localEditor.set(targetKey, newVal);
       localEditor.save();
-      const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+      const examplePath = path26__default.default.join(projectRoot, resolveEnvFilename(env, true));
       const exampleEditor = new EnvEditor(examplePath);
       if (!exampleEditor.has(targetKey)) {
         exampleEditor.set(targetKey, "");
@@ -3643,9 +3674,9 @@ async function runEnvDelete(key, flags = {}) {
     );
   }
   const envsWithKey = allEnvs.filter((env) => {
-    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
-    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
-    return fs14__default.default.existsSync(localPath) && new EnvEditor(localPath).has(targetKey) || fs14__default.default.existsSync(examplePath) && new EnvEditor(examplePath).has(targetKey);
+    const localPath = path26__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path26__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    return fs17__default.default.existsSync(localPath) && new EnvEditor(localPath).has(targetKey) || fs17__default.default.existsSync(examplePath) && new EnvEditor(examplePath).has(targetKey);
   });
   let targetEnvs = [];
   if (flags.env) {
@@ -3683,19 +3714,19 @@ async function runEnvDelete(key, flags = {}) {
     }
   }
   for (const env of targetEnvs) {
-    const localPath = path2__default.default.join(projectRoot, resolveEnvFilename(env, false));
-    const examplePath = path2__default.default.join(projectRoot, resolveEnvFilename(env, true));
+    const localPath = path26__default.default.join(projectRoot, resolveEnvFilename(env, false));
+    const examplePath = path26__default.default.join(projectRoot, resolveEnvFilename(env, true));
     if (flags.dryRun) {
       p19__namespace.log.info(
         pc13__default.default.cyan(`[DRY RUN] Would delete ${targetKey} from ${resolveEnvFilename(env, false)} and ${resolveEnvFilename(env, true)}`)
       );
     } else {
-      if (fs14__default.default.existsSync(localPath)) {
+      if (fs17__default.default.existsSync(localPath)) {
         const localEditor = new EnvEditor(localPath);
         localEditor.delete(targetKey);
         localEditor.save();
       }
-      if (fs14__default.default.existsSync(examplePath)) {
+      if (fs17__default.default.existsSync(examplePath)) {
         const exampleEditor = new EnvEditor(examplePath);
         exampleEditor.delete(targetKey);
         exampleEditor.save();
@@ -3720,10 +3751,10 @@ async function runEnvAudit(flags = {}) {
   for (const env of envs) {
     const localFile = resolveEnvFilename(env, false);
     const exampleFile = resolveEnvFilename(env, true);
-    const localPath = path2__default.default.join(projectRoot, localFile);
-    const examplePath = path2__default.default.join(projectRoot, exampleFile);
-    const localExists = fs14__default.default.existsSync(localPath);
-    const exampleExists = fs14__default.default.existsSync(examplePath);
+    const localPath = path26__default.default.join(projectRoot, localFile);
+    const examplePath = path26__default.default.join(projectRoot, exampleFile);
+    const localExists = fs17__default.default.existsSync(localPath);
+    const exampleExists = fs17__default.default.existsSync(examplePath);
     const localEditor = new EnvEditor(localPath);
     const exampleEditor = new EnvEditor(examplePath);
     const localKeys = localExists ? localEditor.getKeys() : [];
@@ -4050,25 +4081,25 @@ function normalizeRegistryUrl(urlOrPath, baseDir) {
     return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
   }
   if (baseDir && (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed === "." || trimmed === "..")) {
-    return path2__default.default.resolve(baseDir, trimmed);
+    return path26__default.default.resolve(baseDir, trimmed);
   }
   return trimmed;
 }
 function findLocalRegistry(startDir = process.cwd()) {
-  let current = path2__default.default.resolve(startDir);
+  let current = path26__default.default.resolve(startDir);
   while (true) {
-    const candidate = path2__default.default.join(current, "mason-registry");
-    if (fs14__default.default.existsSync(candidate) && fs14__default.default.existsSync(path2__default.default.join(candidate, "index.json"))) {
+    const candidate = path26__default.default.join(current, "mason-registry");
+    if (fs17__default.default.existsSync(candidate) && fs17__default.default.existsSync(path26__default.default.join(candidate, "index.json"))) {
       return candidate;
     }
-    const parent = path2__default.default.dirname(current);
+    const parent = path26__default.default.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   return null;
 }
 function getRegistryBase(projectRoot, override) {
-  const rootDir = projectRoot ? path2__default.default.resolve(projectRoot) : process.cwd();
+  const rootDir = projectRoot ? path26__default.default.resolve(projectRoot) : process.cwd();
   if (override && override.trim()) {
     return normalizeRegistryUrl(override.trim(), rootDir);
   }
@@ -4076,30 +4107,30 @@ function getRegistryBase(projectRoot, override) {
     return normalizeRegistryUrl(process.env.MASON_REGISTRY_URL.trim(), rootDir);
   }
   const configLocations = [
-    path2__default.default.join(rootDir, "mason.config.json"),
-    path2__default.default.join(process.cwd(), "mason.config.json")
+    path26__default.default.join(rootDir, "mason.config.json"),
+    path26__default.default.join(process.cwd(), "mason.config.json")
   ];
   for (const configPath of configLocations) {
-    if (fs14__default.default.existsSync(configPath)) {
+    if (fs17__default.default.existsSync(configPath)) {
       try {
-        const config = JSON.parse(fs14__default.default.readFileSync(configPath, "utf-8"));
+        const config = JSON.parse(fs17__default.default.readFileSync(configPath, "utf-8"));
         if (config.registry && typeof config.registry === "string") {
-          return normalizeRegistryUrl(config.registry.trim(), path2__default.default.dirname(configPath));
+          return normalizeRegistryUrl(config.registry.trim(), path26__default.default.dirname(configPath));
         }
       } catch {
       }
     }
   }
   const pkgLocations = [
-    path2__default.default.join(rootDir, "package.json"),
-    path2__default.default.join(process.cwd(), "package.json")
+    path26__default.default.join(rootDir, "package.json"),
+    path26__default.default.join(process.cwd(), "package.json")
   ];
   for (const pkgPath of pkgLocations) {
-    if (fs14__default.default.existsSync(pkgPath)) {
+    if (fs17__default.default.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs14__default.default.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs17__default.default.readFileSync(pkgPath, "utf-8"));
         if (pkg.mason?.registry && typeof pkg.mason.registry === "string") {
-          return normalizeRegistryUrl(pkg.mason.registry.trim(), path2__default.default.dirname(pkgPath));
+          return normalizeRegistryUrl(pkg.mason.registry.trim(), path26__default.default.dirname(pkgPath));
         }
       } catch {
       }
@@ -4147,16 +4178,16 @@ async function fetchRegistryFile(registryBase, relPath) {
   if (baseDir.startsWith("file://")) {
     baseDir = url.fileURLToPath(baseDir);
   }
-  let filePath = path2__default.default.resolve(baseDir, cleanRelPath);
-  if (!fs14__default.default.existsSync(filePath)) {
-    const inSrcPath = path2__default.default.resolve(baseDir, "src", cleanRelPath);
-    if (fs14__default.default.existsSync(inSrcPath)) {
+  let filePath = path26__default.default.resolve(baseDir, cleanRelPath);
+  if (!fs17__default.default.existsSync(filePath)) {
+    const inSrcPath = path26__default.default.resolve(baseDir, "src", cleanRelPath);
+    if (fs17__default.default.existsSync(inSrcPath)) {
       filePath = inSrcPath;
     } else {
       throw new Error(`Registry file not found at ${filePath}`);
     }
   }
-  return fs14__default.default.promises.readFile(filePath, "utf-8");
+  return fs17__default.default.promises.readFile(filePath, "utf-8");
 }
 async function fetchRegistryIndex(registryBase) {
   const content = await fetchRegistryFile(registryBase, "index.json");
@@ -4218,19 +4249,19 @@ function findClosestMatch(target, candidates) {
   return null;
 }
 function detectPackageManager(projectRoot) {
-  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "yarn.lock"))) return "yarn";
-  if (fs14__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lockb")) || fs14__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lock"))) return "bun";
+  if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (fs17__default.default.existsSync(path26__default.default.join(projectRoot, "bun.lockb")) || fs17__default.default.existsSync(path26__default.default.join(projectRoot, "bun.lock"))) return "bun";
   return "npm";
 }
 function getMissingNpmPackages(projectRoot, requiredPackages) {
   if (!requiredPackages || requiredPackages.length === 0) return [];
-  const pkgJsonPath = path2__default.default.join(projectRoot, "package.json");
-  if (!fs14__default.default.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path26__default.default.join(projectRoot, "package.json");
+  if (!fs17__default.default.existsSync(pkgJsonPath)) {
     return requiredPackages;
   }
   try {
-    const pkg = JSON.parse(fs14__default.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs17__default.default.readFileSync(pkgJsonPath, "utf-8"));
     const installed = /* @__PURE__ */ new Set([
       ...Object.keys(pkg.dependencies || {}),
       ...Object.keys(pkg.devDependencies || {}),
@@ -4269,12 +4300,12 @@ function installNpmPackages(projectRoot, packages, pm) {
   });
 }
 function getAllFiles(dir, baseDir = dir) {
-  if (!fs14__default.default.existsSync(dir)) return [];
-  const entries = fs14__default.default.readdirSync(dir, { withFileTypes: true });
+  if (!fs17__default.default.existsSync(dir)) return [];
+  const entries = fs17__default.default.readdirSync(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path2__default.default.join(dir, entry.name);
-    const relPath = path2__default.default.relative(baseDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path26__default.default.join(dir, entry.name);
+    const relPath = path26__default.default.relative(baseDir, fullPath).replace(/\\/g, "/");
     if (entry.isDirectory()) {
       if (entry.name === "__tests__" || entry.name.startsWith(".")) {
         continue;
@@ -4290,13 +4321,13 @@ function getAllFiles(dir, baseDir = dir) {
   return files.sort();
 }
 function computeDirectoryHash(dirPath, files) {
-  if (!fs14__default.default.existsSync(dirPath)) return "";
+  if (!fs17__default.default.existsSync(dirPath)) return "";
   const hash = crypto.createHash("sha256");
   const fileList = (getAllFiles(dirPath)).sort();
   for (const relativePath of fileList) {
-    const absolutePath = path2__default.default.join(dirPath, relativePath);
-    if (!fs14__default.default.existsSync(absolutePath)) continue;
-    const content = fs14__default.default.readFileSync(absolutePath, "utf8");
+    const absolutePath = path26__default.default.join(dirPath, relativePath);
+    if (!fs17__default.default.existsSync(absolutePath)) continue;
+    const content = fs17__default.default.readFileSync(absolutePath, "utf8");
     const normalizedContent = content.replace(/\r\n/g, "\n");
     hash.update(relativePath);
     hash.update(normalizedContent);
@@ -4334,17 +4365,17 @@ function getModuleBaseDir(projectRoot, modType) {
     return modType === "shared" ? getConfiguredSharedDir(projectRoot) : getConfiguredFeaturesDir(projectRoot);
   }
   const folder = modType === "shared" ? "shared" : "features";
-  return path2__default.default.join(projectRoot, "src", folder);
+  return path26__default.default.join(projectRoot, "src", folder);
 }
 function getExistingModuleDir(projectRoot, modType, modName) {
   const folder = modType === "shared" ? "shared" : "features";
   const configuredDir = modType === "shared" ? getConfiguredSharedDir(projectRoot) : getConfiguredFeaturesDir(projectRoot);
-  const inConfigured = path2__default.default.join(configuredDir, modName);
-  if (fs14__default.default.existsSync(inConfigured)) return inConfigured;
-  const inSrc = path2__default.default.join(projectRoot, "src", folder, modName);
-  if (fs14__default.default.existsSync(inSrc)) return inSrc;
-  const inRoot = path2__default.default.join(projectRoot, folder, modName);
-  if (fs14__default.default.existsSync(inRoot)) return inRoot;
+  const inConfigured = path26__default.default.join(configuredDir, modName);
+  if (fs17__default.default.existsSync(inConfigured)) return inConfigured;
+  const inSrc = path26__default.default.join(projectRoot, "src", folder, modName);
+  if (fs17__default.default.existsSync(inSrc)) return inSrc;
+  const inRoot = path26__default.default.join(projectRoot, folder, modName);
+  if (fs17__default.default.existsSync(inRoot)) return inRoot;
   return null;
 }
 function checkModuleExists(projectRoot, modType, modName) {
@@ -4355,14 +4386,14 @@ function getAvailableLocalModules(projectRoot, modType) {
   const configuredDir = modType === "shared" ? getConfiguredSharedDir(projectRoot) : getConfiguredFeaturesDir(projectRoot);
   const dirs = [
     configuredDir,
-    path2__default.default.join(projectRoot, "src", folder),
-    path2__default.default.join(projectRoot, folder)
+    path26__default.default.join(projectRoot, "src", folder),
+    path26__default.default.join(projectRoot, folder)
   ];
   const set = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
-    if (fs14__default.default.existsSync(dir)) {
+    if (fs17__default.default.existsSync(dir)) {
       try {
-        const entries = fs14__default.default.readdirSync(dir, { withFileTypes: true });
+        const entries = fs17__default.default.readdirSync(dir, { withFileTypes: true });
         for (const e of entries) {
           if (e.isDirectory() && !e.name.startsWith(".")) {
             set.add(e.name);
@@ -4564,7 +4595,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       globalAliasMap.set(`@/${folder}/${registryName}/`, `@/${folder}/${programmaticAlias}/`);
       globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${programmaticAlias}`);
       const baseDir = getModuleBaseDir(projectRoot, modType);
-      const displayDest = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, programmaticAlias));
+      const displayDest = path26__default.default.relative(projectRoot, path26__default.default.join(baseDir, programmaticAlias));
       p19__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
       resolutions.set(key, {
         type: modType,
@@ -4752,7 +4783,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       globalAliasMap.set(`@/${folder}/${registryName}/`, `@/${folder}/${newName}/`);
       globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${newName}`);
       const baseDir = getModuleBaseDir(projectRoot, modType);
-      const displayDest = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, newName));
+      const displayDest = path26__default.default.relative(projectRoot, path26__default.default.join(baseDir, newName));
       p19__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
       resolutions.set(key, {
         type: modType,
@@ -4804,7 +4835,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       continue;
     }
     const folder = res.type === "shared" ? "shared" : "features";
-    const targetDir = path2__default.default.join(getModuleBaseDir(projectRoot, res.type), res.targetName);
+    const targetDir = path26__default.default.join(getModuleBaseDir(projectRoot, res.type), res.targetName);
     const isOverwrite = Boolean(flags.overwrite || res.action === "overwrite");
     if (key !== rootKey) {
       p19__namespace.log.step(
@@ -4814,30 +4845,30 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     if (res.action === "overwrite" && !flags.dryRun) {
       const existingDir = getExistingModuleDir(projectRoot, res.type, res.targetName);
       if (existingDir && existingDir !== targetDir) {
-        fs14__default.default.rmSync(existingDir, { recursive: true, force: true });
+        fs17__default.default.rmSync(existingDir, { recursive: true, force: true });
       }
-      if (fs14__default.default.existsSync(targetDir)) {
-        fs14__default.default.rmSync(targetDir, { recursive: true, force: true });
+      if (fs17__default.default.existsSync(targetDir)) {
+        fs17__default.default.rmSync(targetDir, { recursive: true, force: true });
       }
     }
     for (const file of res.manifest.files || []) {
       if (file === "registry.json") continue;
       if (!includeTests && isTestFile(file)) continue;
       const remoteFilePath = `${folder}/${res.registryName}/${file}`;
-      const localFilePath = path2__default.default.join(targetDir, file);
-      if (fs14__default.default.existsSync(localFilePath) && !isOverwrite) {
+      const localFilePath = path26__default.default.join(targetDir, file);
+      if (fs17__default.default.existsSync(localFilePath) && !isOverwrite) {
         p19__namespace.log.warn(
-          `  \u21B3 Skipping existing file: ${pc13__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
+          `  \u21B3 Skipping existing file: ${pc13__default.default.dim(path26__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
         );
         continue;
       }
       let content = await fetchRegistryFile(registryBase, remoteFilePath);
       content = rewriteImports(content, globalAliasMap);
       if (!flags.dryRun) {
-        fs14__default.default.mkdirSync(path2__default.default.dirname(localFilePath), { recursive: true });
-        fs14__default.default.writeFileSync(localFilePath, content, "utf-8");
+        fs17__default.default.mkdirSync(path26__default.default.dirname(localFilePath), { recursive: true });
+        fs17__default.default.writeFileSync(localFilePath, content, "utf-8");
       }
-      const displayPath = path2__default.default.relative(projectRoot, localFilePath);
+      const displayPath = path26__default.default.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
       p19__namespace.log.message(`  ${pc13__default.default.green("+")} ${displayPath}`);
     }
@@ -4863,7 +4894,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   } 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));
+    const displayTarget = path26__default.default.relative(projectRoot, path26__default.default.join(baseDir, rootRes.targetName));
     p19__namespace.log.success(
       pc13__default.default.green(
         `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in ${displayTarget})`
@@ -4882,19 +4913,19 @@ var DependencyRuleError = class extends Error {
   }
 };
 function isTestFile2(filePath, projectRoot) {
-  const norm = (projectRoot ? path2__default.default.relative(projectRoot, filePath) : filePath).replace(/\\/g, "/");
-  const base = path2__default.default.basename(norm);
+  const norm = (projectRoot ? path26__default.default.relative(projectRoot, filePath) : filePath).replace(/\\/g, "/");
+  const base = path26__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 (!fs14__default.default.existsSync(dir)) return [];
-  const entries = fs14__default.default.readdirSync(dir, { withFileTypes: true });
+  if (!fs17__default.default.existsSync(dir)) return [];
+  const entries = fs17__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);
+    const fullPath = path26__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)) {
@@ -4903,101 +4934,194 @@ function scanDirFiles(dir, projectRoot) {
   }
   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]) {
-    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 { moduleType: "feature", moduleName: feature, feature, layer };
-  }
-  const sharedMatch = rel.match(/(?:^|\/)(?:src\/)?shared\/([^/]+)(?:\/(.*))?$/);
-  if (sharedMatch && sharedMatch[1]) {
-    const moduleName = sharedMatch[1];
-    const rest = sharedMatch[2] || "";
-    let layer = "root";
-    if (rest.startsWith("domain/") || rest === "domain" || rest.startsWith("errors/") || rest === "errors") {
-      layer = "domain";
-    } else if (rest.startsWith("ports/") || rest === "ports") {
-      layer = "ports";
-    } else if (rest.startsWith("infrastructure/") || rest === "infrastructure") {
-      layer = "infrastructure";
-    }
-    return { moduleType: "shared", moduleName, feature: moduleName, layer };
+function classifyFile(fullPathAbs, featuresBaseAbs, sharedBaseAbs, errorsBaseAbs) {
+  if (!sharedBaseAbs || !errorsBaseAbs) {
+    const paths = getResolvedLintPaths(featuresBaseAbs, loadLintConfig(featuresBaseAbs));
+    featuresBaseAbs = paths.featuresBase;
+    sharedBaseAbs = paths.sharedBase;
+    errorsBaseAbs = paths.errorsBase;
+  }
+  const normFullPath = path26__default.default.resolve(fullPathAbs);
+  const normErrorsBase = path26__default.default.resolve(errorsBaseAbs);
+  const normSharedBase = path26__default.default.resolve(sharedBaseAbs);
+  const normFeaturesBase = path26__default.default.resolve(featuresBaseAbs);
+  const relErrors = path26__default.default.relative(normErrorsBase, normFullPath).replace(/\\/g, "/");
+  if (!relErrors.startsWith("..") && !path26__default.default.isAbsolute(relErrors)) {
+    return {
+      moduleType: "error",
+      moduleName: "global-errors",
+      feature: "global-errors",
+      layer: "domain"
+    };
+  }
+  const relShared = path26__default.default.relative(normSharedBase, normFullPath).replace(/\\/g, "/");
+  if (!relShared.startsWith("..") && !path26__default.default.isAbsolute(relShared)) {
+    const parts = relShared.split("/").filter(Boolean);
+    if (parts.length >= 1) {
+      const moduleName = parts[0];
+      const rest = parts.slice(1).join("/");
+      let layer = "root";
+      if (rest.startsWith("domain/") || rest === "domain" || rest.startsWith("errors/") || rest === "errors") {
+        layer = "domain";
+      } else if (rest.startsWith("ports/") || rest === "ports") {
+        layer = "ports";
+      } else if (rest.startsWith("infrastructure/") || rest === "infrastructure") {
+        layer = "infrastructure";
+      }
+      return { moduleType: "shared", moduleName, feature: moduleName, layer };
+    }
+  }
+  const relFeatures = path26__default.default.relative(normFeaturesBase, normFullPath).replace(/\\/g, "/");
+  if (!relFeatures.startsWith("..") && !path26__default.default.isAbsolute(relFeatures)) {
+    const parts = relFeatures.split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      const moduleName = parts[0];
+      const subfolder = parts[1];
+      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 { moduleType: "feature", moduleName, feature: moduleName, layer };
+    }
   }
   return {};
 }
-function classifyTarget(specifier, sourceFileAbs, projectRoot) {
+function classifyTarget(specifier, sourceFileAbs, projectRoot, featuresBaseAbs, sharedBaseAbs, errorsBaseAbs) {
   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)) {
+  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 (!featuresBaseAbs || !sharedBaseAbs || !errorsBaseAbs) {
+    const paths = getResolvedLintPaths(projectRoot, loadLintConfig(projectRoot));
+    featuresBaseAbs = featuresBaseAbs || paths.featuresBase;
+    sharedBaseAbs = sharedBaseAbs || paths.sharedBase;
+    errorsBaseAbs = errorsBaseAbs || paths.errorsBase;
+  }
+  const isGlobalConfig = specifier === "@configs" || specifier.startsWith("@configs/") || specifier === "@/configs" || specifier.startsWith("@/configs/") || specifier === "~/configs" || specifier.startsWith("~/configs/") || specifier === "configs" || specifier.startsWith("configs/");
+  let targetAbs = 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("@/configs/") || specifier.startsWith("~/configs/") || specifier === "@/configs" || specifier === "~/configs") {
-    resolvedRel = specifier.replace(/^[@~]\//, "src/");
-  } else if (specifier === "@configs" || specifier.startsWith("@configs/")) {
-    resolvedRel = "src/" + specifier.slice(1);
-  } else if (specifier.startsWith("@/") || specifier.startsWith("~/")) {
-    resolvedRel = "src/" + specifier.slice(2);
-  } else if (specifier.startsWith("features/") || specifier.startsWith("shared/") || specifier.startsWith("configs/") || specifier === "configs") {
-    resolvedRel = specifier;
-  }
-  if (!resolvedRel) {
-    return { isExternal: true, isDiFramework: false };
+    targetAbs = path26__default.default.resolve(path26__default.default.dirname(sourceFileAbs), specifier);
+  } else {
+    const featRel = path26__default.default.relative(projectRoot, featuresBaseAbs).replace(/\\/g, "/");
+    const sharedRel = path26__default.default.relative(projectRoot, sharedBaseAbs).replace(/\\/g, "/");
+    const errorsRel = path26__default.default.relative(projectRoot, errorsBaseAbs).replace(/\\/g, "/");
+    const featPrefixes = ["features"];
+    if (featRel && featRel !== "." && !featRel.startsWith("..")) {
+      featPrefixes.push(featRel);
+      const b = path26__default.default.basename(featRel);
+      if (!featPrefixes.includes(b)) featPrefixes.push(b);
+    }
+    const sharedPrefixes = ["shared"];
+    if (sharedRel && sharedRel !== "." && !sharedRel.startsWith("..")) {
+      sharedPrefixes.push(sharedRel);
+      const b = path26__default.default.basename(sharedRel);
+      if (!sharedPrefixes.includes(b)) sharedPrefixes.push(b);
+    }
+    const errorsPrefixes = ["errors"];
+    if (errorsRel && errorsRel !== "." && !errorsRel.startsWith("..")) {
+      errorsPrefixes.push(errorsRel);
+      const b = path26__default.default.basename(errorsRel);
+      if (!errorsPrefixes.includes(b)) errorsPrefixes.push(b);
+    }
+    for (const prefix of featPrefixes) {
+      const aliasRegex = new RegExp(`^([@~]\\/|@)?${prefix}\\/(.*)$`);
+      const m = specifier.match(aliasRegex);
+      if (m && m[2]) {
+        targetAbs = path26__default.default.resolve(featuresBaseAbs, m[2]);
+        break;
+      }
+    }
+    if (!targetAbs) {
+      for (const prefix of sharedPrefixes) {
+        const aliasRegex = new RegExp(`^([@~]\\/|@)?${prefix}\\/(.*)$`);
+        const m = specifier.match(aliasRegex);
+        if (m && m[2]) {
+          targetAbs = path26__default.default.resolve(sharedBaseAbs, m[2]);
+          break;
+        }
+      }
+    }
+    if (!targetAbs) {
+      for (const prefix of errorsPrefixes) {
+        const aliasRegex = new RegExp(`^([@~]\\/|@)?${prefix}(?:\\/(.*))?$`);
+        const m = specifier.match(aliasRegex);
+        if (m) {
+          targetAbs = path26__default.default.resolve(errorsBaseAbs, m[2] || "");
+          break;
+        }
+      }
+    }
+    if (!targetAbs && (specifier.startsWith("@/") || specifier.startsWith("~/"))) {
+      const sub = specifier.slice(2);
+      const srcCandidate = path26__default.default.resolve(projectRoot, "src", sub);
+      const rootCandidate = path26__default.default.resolve(projectRoot, sub);
+      if (fs17__default.default.existsSync(srcCandidate)) {
+        targetAbs = srcCandidate;
+      } else if (fs17__default.default.existsSync(rootCandidate)) {
+        targetAbs = rootCandidate;
+      } else {
+        targetAbs = srcCandidate;
+      }
+    }
+    if (!targetAbs) {
+      const featCandidate = path26__default.default.resolve(featuresBaseAbs, specifier);
+      if (fs17__default.default.existsSync(featCandidate) || fs17__default.default.existsSync(featCandidate + ".ts") || fs17__default.default.existsSync(featCandidate + ".js")) {
+        targetAbs = featCandidate;
+      }
+    }
+  }
+  if (!targetAbs) {
+    return { isExternal: true, isDiFramework: false, isGlobalConfig };
+  }
+  const normTarget = path26__default.default.resolve(targetAbs);
+  const srcConfig = path26__default.default.resolve(projectRoot, "src/configs");
+  const rootConfig = path26__default.default.resolve(projectRoot, "configs");
+  const isTargetConfig = isGlobalConfig || normTarget === srcConfig || normTarget.startsWith(srcConfig + path26__default.default.sep) || normTarget === rootConfig || normTarget.startsWith(rootConfig + path26__default.default.sep);
+  const classification = classifyFile(targetAbs, featuresBaseAbs, sharedBaseAbs, errorsBaseAbs);
+  if (classification.moduleType === "error") {
+    return {
+      isExternal: false,
+      isDiFramework: false,
+      isGlobalError: true,
+      isTargetError: true
+    };
   }
-  const isGlobalConfig = resolvedRel.startsWith("src/configs/") || resolvedRel === "src/configs" || resolvedRel.startsWith("configs/") || resolvedRel === "configs";
-  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)$/, "");
+  if (classification.moduleType === "feature") {
+    const rel = path26__default.default.relative(featuresBaseAbs, targetAbs).replace(/\\/g, "/");
+    const parts = rel.split("/").filter(Boolean);
+    const targetSubfolder = parts[1];
+    const targetFileName = path26__default.default.basename(targetAbs).replace(/\.(js|ts|mjs|cjs)$/, "");
     const isTargetPort = /^I[A-Z]/.test(targetFileName);
     const isTargetRepo = isTargetPort && targetFileName.includes("Repo");
-    const isTargetError = targetSubfolder === "errors" || rest.startsWith("errors/") || rest.includes("/errors/") || targetFileName.endsWith("Error") || targetFileName.endsWith("Errors");
+    const isTargetError = targetSubfolder === "errors" || rel.includes("/errors/") || targetFileName.endsWith("Error") || targetFileName.endsWith("Errors");
     return {
       isExternal: false,
       isDiFramework: false,
-      targetFeature,
-      targetLayer,
+      targetFeature: classification.moduleName,
+      targetLayer: classification.layer,
       targetSubfolder,
       targetFileName,
       isTargetPort,
@@ -5005,25 +5129,21 @@ function classifyTarget(specifier, sourceFileAbs, projectRoot) {
       isTargetError
     };
   }
-  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";
+  if (classification.moduleType === "shared") {
+    const targetFileName = path26__default.default.basename(targetAbs).replace(/\.(js|ts|mjs|cjs)$/, "");
+    const isTargetError = classification.layer === "domain" && (targetFileName.endsWith("Error") || targetFileName.endsWith("Errors") || targetAbs.includes("/errors/"));
     return {
       isExternal: false,
       isDiFramework: false,
-      targetSharedModule,
-      isSharedRoot,
-      isSharedPorts,
-      isSharedInfra,
-      isSharedDomain
+      targetSharedModule: classification.moduleName,
+      isSharedRoot: classification.layer === "root",
+      isSharedPorts: classification.layer === "ports",
+      isSharedInfra: classification.layer === "infrastructure",
+      isSharedDomain: classification.layer === "domain",
+      isTargetError
     };
   }
-  return { isExternal: true, isDiFramework: false, isGlobalConfig };
+  return { isExternal: true, isDiFramework: false, isGlobalConfig: isTargetConfig };
 }
 function extractImportStatements(content) {
   const statements = [];
@@ -5145,22 +5265,50 @@ var FeatureDependencyGraph = class {
     return dfs(start);
   }
 };
-function discoverAllFeatures(projectRoot) {
-  const featuresBase = resolveFeaturesDir(projectRoot);
-  if (!fs14__default.default.existsSync(featuresBase)) return [];
-  const entries = fs14__default.default.readdirSync(featuresBase, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "__tests__" && e.name !== "tests").map((e) => ({
+function discoverAllFeatures(featuresBaseAbs, excludeDirs = []) {
+  const base = featuresBaseAbs;
+  if (!fs17__default.default.existsSync(base)) return [];
+  const excludeSet = new Set(excludeDirs.map((d) => path26__default.default.resolve(d)));
+  const entries = fs17__default.default.readdirSync(base, { withFileTypes: true });
+  return entries.filter((e) => {
+    if (!e.isDirectory()) return false;
+    if (e.name.startsWith(".")) return false;
+    if (["__tests__", "tests", "node_modules", "dist", "coverage", "scratch"].includes(e.name)) {
+      return false;
+    }
+    const resolved = path26__default.default.resolve(base, e.name);
+    for (const ex of excludeSet) {
+      if (ex === resolved || ex.startsWith(resolved + path26__default.default.sep) || resolved.startsWith(ex + path26__default.default.sep)) {
+        return false;
+      }
+    }
+    return true;
+  }).map((e) => ({
     name: e.name,
-    dir: path2__default.default.join(featuresBase, e.name)
+    dir: path26__default.default.join(base, e.name)
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
-function discoverAllShared(projectRoot) {
-  const sharedBase = resolveSharedDir(projectRoot);
-  if (!fs14__default.default.existsSync(sharedBase)) return [];
-  const entries = fs14__default.default.readdirSync(sharedBase, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "__tests__" && e.name !== "tests").map((e) => ({
+function discoverAllShared(sharedBaseAbs, excludeDirs = []) {
+  const base = sharedBaseAbs;
+  if (!fs17__default.default.existsSync(base)) return [];
+  const excludeSet = new Set(excludeDirs.map((d) => path26__default.default.resolve(d)));
+  const entries = fs17__default.default.readdirSync(base, { withFileTypes: true });
+  return entries.filter((e) => {
+    if (!e.isDirectory()) return false;
+    if (e.name.startsWith(".")) return false;
+    if (["__tests__", "tests", "node_modules", "dist", "coverage", "scratch"].includes(e.name)) {
+      return false;
+    }
+    const resolved = path26__default.default.resolve(base, e.name);
+    for (const ex of excludeSet) {
+      if (ex === resolved || ex.startsWith(resolved + path26__default.default.sep) || resolved.startsWith(ex + path26__default.default.sep)) {
+        return false;
+      }
+    }
+    return true;
+  }).map((e) => ({
     name: e.name,
-    dir: path2__default.default.join(sharedBase, e.name)
+    dir: path26__default.default.join(base, e.name)
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
 function extractClassMethods(content, className) {
@@ -5316,7 +5464,7 @@ function extractClassMethods(content, className) {
   return methods;
 }
 function checkUseCaseShape(featureName, filePath, relativePath, content, addViolation) {
-  const fileName = path2__default.default.basename(filePath);
+  const fileName = path26__default.default.basename(filePath);
   const lines = content.split(/\r?\n/);
   const classMatch = content.match(/(?:export\s+(?:default\s+)?)?class\s+([A-Za-z0-9_]+)/);
   if (!classMatch) {
@@ -5412,7 +5560,7 @@ private ${m.name}(...) { ... }`
   }
 }
 function checkServiceShape(featureName, filePath, relativePath, content, addViolation) {
-  const fileName = path2__default.default.basename(filePath);
+  const fileName = path26__default.default.basename(filePath);
   const lines = content.split(/\r?\n/);
   const classMatch = content.match(/(?:export\s+(?:default\s+)?)?class\s+([A-Za-z0-9_]+)/);
   if (!classMatch) {
@@ -5511,11 +5659,40 @@ 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 sharedModules = discoverAllShared(projectRoot);
+  const lintConfig = loadLintConfig(projectRoot);
+  const { featuresBase, sharedBase, errorsBase } = getResolvedLintPaths(projectRoot, lintConfig);
+  const missingFoundations = [];
+  if (!fs17__default.default.existsSync(featuresBase)) missingFoundations.push("features/");
+  if (!fs17__default.default.existsSync(sharedBase)) missingFoundations.push("shared/");
+  if (!fs17__default.default.existsSync(errorsBase)) missingFoundations.push("errors/");
+  if (missingFoundations.length > 0) {
+    throw new DependencyRuleError(
+      `Project Structure Violation: Missing required foundational directories: ${missingFoundations.join(", ")}. Every project must contain 'features/', 'shared/', and 'errors/'.`,
+      [],
+      true
+    );
+  }
+  const baseErrorRelative = lintConfig.baseErrorPath || path26__default.default.relative(projectRoot, path26__default.default.join(errorsBase, "AppError.ts")).replace(/\\/g, "/");
+  const baseErrorAbs = path26__default.default.resolve(projectRoot, baseErrorRelative);
+  if (!fs17__default.default.existsSync(baseErrorAbs)) {
+    throw new DependencyRuleError(
+      `Project Structure Violation: Base error class not found at '${baseErrorRelative}'. Create this file or update 'baseErrorPath' in mason-lint.config.json.`,
+      [],
+      true
+    );
+  }
+  const baseErrorContent = fs17__default.default.readFileSync(baseErrorAbs, "utf-8");
+  const baseClassMatch = baseErrorContent.match(
+    /(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Za-z0-9_]+)/
+  );
+  const baseErrorClassName = baseClassMatch ? baseClassMatch[1] : "AppError";
+  const features = discoverAllFeatures(featuresBase, [sharedBase, errorsBase]);
+  const sharedModules = discoverAllShared(sharedBase, [featuresBase, errorsBase]);
+  const errorModule = { name: "global-errors", dir: errorsBase, type: "error" };
   const allModules = [
     ...features.map((f) => ({ ...f, type: "feature" })),
-    ...sharedModules.map((s) => ({ ...s, type: "shared" }))
+    ...sharedModules.map((s) => ({ ...s, type: "shared" })),
+    errorModule
   ];
   const graph = new FeatureDependencyGraph();
   const allViolations = [];
@@ -5545,7 +5722,7 @@ Code: ${v.code}`;
       scannedFilesCount: 0,
       passed: true,
       violations: [],
-      layersChecked: mod.type === "feature" ? ["domain", "useCases", "services", "infrastructure", "presentation"] : ["domain", "ports", "infrastructure", "root"]
+      layersChecked: mod.type === "feature" ? ["domain", "useCases", "services", "infrastructure", "presentation"] : mod.type === "shared" ? ["domain", "ports", "infrastructure", "root"] : ["domain"]
     });
   }
   for (const mod of allModules) {
@@ -5553,13 +5730,128 @@ Code: ${v.code}`;
     const allFiles = scanDirFiles(mod.dir, projectRoot);
     modResult.scannedFilesCount = allFiles.length;
     for (const file of allFiles) {
-      const relPath = path2__default.default.relative(projectRoot, file).replace(/\\/g, "/");
-      const { moduleType, moduleName, layer } = classifyFile(file, projectRoot);
+      const relPath = path26__default.default.relative(projectRoot, file).replace(/\\/g, "/");
+      const { moduleType, moduleName, layer } = classifyFile(file, featuresBase, sharedBase, errorsBase);
       if (!layer || !moduleType || !moduleName) continue;
-      const content = fs14__default.default.readFileSync(file, "utf-8");
+      const content = fs17__default.default.readFileSync(file, "utf-8");
       const statements = extractImportStatements(content);
-      const baseName = path2__default.default.basename(file);
+      const baseName = path26__default.default.basename(file);
       const isBarrel = baseName === "index.ts" || baseName === "index.js";
+      const throwErrorRegex = /\bthrow\s+(?:new\s+)?Error\s*\(/g;
+      let throwMatch;
+      while ((throwMatch = throwErrorRegex.exec(content)) !== null) {
+        const charIndex = throwMatch.index;
+        const lineNum = content.substring(0, charIndex).split("\n").length;
+        const lineCode = content.split(/\r?\n/)[lineNum - 1]?.trim() || throwMatch[0];
+        if (lineCode.startsWith("//")) continue;
+        addViolation({
+          feature: moduleName,
+          layer,
+          file,
+          relativePath: relPath,
+          line: lineNum,
+          category: "Plain Error Throw Violation",
+          code: lineCode,
+          ruleId: "E3_PLAIN_ERROR_THROW",
+          severity: "error",
+          advice: `Throwing plain 'Error' is prohibited. You must throw '${baseErrorClassName}' or a domain-specific error class that inherits from it.`,
+          fixExample: {
+            bad: lineCode,
+            good: `throw new ${baseErrorClassName}("Something went wrong");`
+          }
+        });
+      }
+      const isErrorFile = relPath.includes("/errors/") || relPath.startsWith("errors/") || relPath.startsWith("src/errors/") || moduleType === "error" || baseName.endsWith("Error.ts") || baseName.endsWith("Errors.ts") || baseName.endsWith("Error.js") || baseName.endsWith("Errors.js");
+      const isBaseErrorFile = path26__default.default.resolve(file) === path26__default.default.resolve(baseErrorAbs);
+      if (isErrorFile && !isBaseErrorFile) {
+        const classRegex = /(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Za-z0-9_]+)(?:<[^>]+>)?(?:\s+extends\s+([A-Za-z0-9_]+))?/g;
+        let classMatch;
+        while ((classMatch = classRegex.exec(content)) !== null) {
+          const className = classMatch[1];
+          const extendsName = classMatch[2];
+          const charIndex = classMatch.index;
+          const lineNum = content.substring(0, charIndex).split("\n").length;
+          const lineCode = content.split(/\r?\n/)[lineNum - 1]?.trim() || classMatch[0];
+          if (lineCode.startsWith("//")) continue;
+          if (!extendsName) {
+            addViolation({
+              feature: moduleName,
+              layer,
+              file,
+              relativePath: relPath,
+              line: lineNum,
+              category: "Error Inheritance Violation",
+              code: lineCode,
+              ruleId: "E4_MISSING_INHERITANCE",
+              severity: "error",
+              advice: `Error class '${className}' must extend '${baseErrorClassName}' (or another class that derives from it).`,
+              fixExample: {
+                bad: lineCode,
+                good: `export class ${className} extends ${baseErrorClassName} { ... }`
+              }
+            });
+          } else if (extendsName === "Error") {
+            addViolation({
+              feature: moduleName,
+              layer,
+              file,
+              relativePath: relPath,
+              line: lineNum,
+              category: "Error Inheritance Violation",
+              code: lineCode,
+              ruleId: "E5_NATIVE_ERROR_INHERITANCE",
+              severity: "error",
+              advice: `Error class '${className}' extends the native 'Error'. It must extend your base error class ('${baseErrorClassName}').`,
+              fixExample: {
+                bad: lineCode,
+                good: `export class ${className} extends ${baseErrorClassName} { ... }`
+              }
+            });
+          }
+        }
+      }
+      if (moduleType === "error") {
+        for (const stmt of statements) {
+          const target = classifyTarget(stmt.specifier, file, projectRoot, featuresBase, sharedBase, errorsBase);
+          if (target.targetFeature) {
+            addViolation({
+              feature: "global-errors",
+              layer: "domain",
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Global Error Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "E1_FEATURE_DEPENDENCY",
+              severity: "error",
+              advice: `Global errors must not depend on features ('${target.targetFeature}'). Global errors represent pure domain or system states.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Global errors must not reference specific features. Keep error types pure."
+              }
+            });
+          }
+          if (target.targetSharedModule && !target.isSharedDomain) {
+            addViolation({
+              feature: "global-errors",
+              layer: "domain",
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Global Error Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "E2_SHARED_NON_DOMAIN",
+              severity: "error",
+              advice: `Global errors can only depend on shared domain elements (e.g., value objects). They cannot depend on shared ports or infrastructure.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Depend only on pure domain types from shared modules."
+              }
+            });
+          }
+        }
+        continue;
+      }
       if (moduleType === "shared") {
         if (layer === "domain") {
           const lines = content.split(/\r?\n/);
@@ -5586,7 +5878,7 @@ Code: ${v.code}`;
           }
         }
         for (const stmt of statements) {
-          const target = classifyTarget(stmt.specifier, file, projectRoot);
+          const target = classifyTarget(stmt.specifier, file, projectRoot, featuresBase, sharedBase, errorsBase);
           if (target.targetFeature) {
             addViolation({
               feature: moduleName,
@@ -5716,7 +6008,7 @@ Code: ${v.code}`;
         }
       }
       for (const stmt of statements) {
-        const target = classifyTarget(stmt.specifier, file, projectRoot);
+        const target = classifyTarget(stmt.specifier, file, projectRoot, featuresBase, sharedBase, errorsBase);
         if (target.targetFeature && target.targetFeature !== feat.name) {
           const evidence = {
             fromFeature: feat.name,