npm - @solid-stack/mason - Versions diffs - 1.0.12 → 1.0.14 - Mend

@solid-stack/mason 1.0.12 → 1.0.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

package/dist/bin.cjs +750 -217
package/dist/bin.cjs.map +1 -1
package/dist/bin.js +747 -214
package/dist/bin.js.map +1 -1
package/dist/cli.d.ts.map +1 -1
package/dist/commands/create.d.ts.map +1 -1
package/dist/commands/feature.d.ts.map +1 -1
package/dist/commands/import.d.ts +23 -0
package/dist/commands/import.d.ts.map +1 -1
package/dist/commands/menu.d.ts.map +1 -1
package/dist/commands/shared.d.ts +2 -0
package/dist/commands/shared.d.ts.map +1 -0
package/dist/core/sharedGenerator.d.ts +13 -0
package/dist/core/sharedGenerator.d.ts.map +1 -0
package/dist/index.cjs +770 -217
package/dist/index.cjs.map +1 -1
package/dist/index.d.ts +4 -0
package/dist/index.d.ts.map +1 -1
package/dist/index.js +758 -215
package/dist/index.js.map +1 -1
package/dist/utils/config.d.ts +35 -0
package/dist/utils/config.d.ts.map +1 -0
package/dist/utils/integrity.d.ts +11 -0
package/dist/utils/integrity.d.ts.map +1 -0
package/dist/utils/project.d.ts +18 -2
package/dist/utils/project.d.ts.map +1 -1
package/dist/utils/registry.d.ts +2 -0
package/dist/utils/registry.d.ts.map +1 -1
package/package.json +1 -1

package/dist/bin.js CHANGED Viewed

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import { cac } from 'cac';
 import * as p3 from '@clack/prompts';
-import pc13 from 'picocolors';
-import path15 from 'path';
-import fs7 from 'fs';
+import pc14 from 'picocolors';
+import fs9 from 'fs';
+import path2 from 'path';
 import { fileURLToPath } from 'url';
 import Handlebars from 'handlebars';
 import { execSync } from 'child_process';
+import { createHash } from 'crypto';
 function writeFileSafely(absolutePath, content, options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
-  const relPath = path15.relative(projectRoot, absolutePath).replace(/\\/g, "/");
-  const existedBefore = fs7.existsSync(absolutePath);
+  const relPath = path2.relative(projectRoot, absolutePath).replace(/\\/g, "/");
+  const existedBefore = fs9.existsSync(absolutePath);
   if (options.dryRun) {
     return {
       relativePath: relPath,
@@ -30,11 +31,11 @@ function writeFileSafely(absolutePath, content, options = {}) {
       existedBefore: true
     };
   }
-  const dir = path15.dirname(absolutePath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path2.dirname(absolutePath);
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
   }
-  fs7.writeFileSync(absolutePath, content, "utf-8");
+  fs9.writeFileSync(absolutePath, content, "utf-8");
   return {
     relativePath: relPath,
     absolutePath,
@@ -46,17 +47,17 @@ function writeFileSafely(absolutePath, content, options = {}) {
 function printGeneratedFiles(files, isDryRun = false) {
   console.log("");
   if (isDryRun) {
-    p3.log.warn(pc13.yellow(pc13.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+    p3.log.warn(pc14.yellow(pc14.bold("[DRY RUN PREVIEW] No files were written to disk.")));
   }
   for (const f of files) {
     if (f.action === "created") {
-      p3.log.success(`${pc13.bold(f.relativePath)} ${pc13.dim("(created)")}`);
+      p3.log.success(`${pc14.bold(f.relativePath)} ${pc14.dim("(created)")}`);
     } else if (f.action === "overwritten") {
-      p3.log.warn(`${pc13.bold(f.relativePath)} ${pc13.dim("(overwritten)")}`);
+      p3.log.warn(`${pc14.bold(f.relativePath)} ${pc14.dim("(overwritten)")}`);
     } else if (f.action === "skipped") {
-      p3.log.info(`${pc13.dim(f.relativePath)} ${pc13.dim("(skipped - already exists, pass -o to overwrite)")}`);
+      p3.log.info(`${pc14.dim(f.relativePath)} ${pc14.dim("(skipped - already exists, pass -o to overwrite)")}`);
     } else {
-      p3.log.info(`${pc13.bold(f.relativePath)} ${pc13.dim("(preview)")}`);
+      p3.log.info(`${pc14.bold(f.relativePath)} ${pc14.dim("(preview)")}`);
     }
   }
 }
@@ -124,27 +125,90 @@ function toStubName(ifaceName) {
   }
   return `Stub${base}`;
 }
+function loadMasonConfig(startDir = process.cwd()) {
+  let current = path2.resolve(startDir);
+  while (true) {
+    const configPath = path2.join(current, "mason.config.json");
+    if (fs9.existsSync(configPath)) {
+      try {
+        return JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function getEffectiveMode(projectRoot, flags) {
+  if (flags?.registry) return "registry";
+  const config = loadMasonConfig(projectRoot);
+  if (config?.mode) return config.mode;
+  if (fs9.existsSync(path2.join(projectRoot, "index.json")) && (fs9.existsSync(path2.join(projectRoot, "features")) || fs9.existsSync(path2.join(projectRoot, "shared"))) && !fs9.existsSync(path2.join(projectRoot, "src"))) {
+    return "registry";
+  }
+  return "app";
+}
+function getConfiguredFeaturesDir(projectRoot, flags) {
+  if (flags?.target) return path2.resolve(projectRoot, flags.target);
+  if (flags?.dest) return path2.resolve(projectRoot, flags.dest);
+  const config = loadMasonConfig(projectRoot);
+  if (config?.paths?.features) {
+    return path2.resolve(projectRoot, config.paths.features);
+  }
+  const mode = getEffectiveMode(projectRoot, flags);
+  if (mode === "registry") {
+    return path2.join(projectRoot, "features");
+  }
+  if (fs9.existsSync(path2.join(projectRoot, "src/features"))) {
+    return path2.join(projectRoot, "src/features");
+  }
+  return path2.join(projectRoot, "features");
+}
+function getConfiguredSharedDir(projectRoot, flags) {
+  if (flags?.target) return path2.resolve(projectRoot, flags.target);
+  if (flags?.dest) return path2.resolve(projectRoot, flags.dest);
+  const config = loadMasonConfig(projectRoot);
+  if (config?.paths?.shared) {
+    return path2.resolve(projectRoot, config.paths.shared);
+  }
+  const mode = getEffectiveMode(projectRoot, flags);
+  if (mode === "registry") {
+    return path2.join(projectRoot, "shared");
+  }
+  if (fs9.existsSync(path2.join(projectRoot, "src/shared"))) {
+    return path2.join(projectRoot, "src/shared");
+  }
+  return path2.join(projectRoot, "shared");
+}
+// src/utils/project.ts
 function findProjectRoot(startDir = process.cwd()) {
-  let current = path15.resolve(startDir);
+  let current = path2.resolve(startDir);
   while (true) {
-    if (fs7.existsSync(path15.join(current, "package.json"))) {
+    if (fs9.existsSync(path2.join(current, "package.json"))) {
       return current;
     }
-    const parent = path15.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current) {
-      return path15.resolve(startDir);
+      return path2.resolve(startDir);
     }
     current = parent;
   }
 }
-function resolveFeaturesDir(projectRoot) {
-  return path15.join(projectRoot, "features");
+function resolveFeaturesDir(projectRoot, flags) {
+  return getConfiguredFeaturesDir(projectRoot, flags);
+}
+function resolveSharedDir(projectRoot, flags) {
+  return getConfiguredSharedDir(projectRoot, flags);
 }
 function listExistingFeatures(projectRoot) {
   const featuresDir = resolveFeaturesDir(projectRoot);
-  if (!fs7.existsSync(featuresDir)) return [];
+  if (!fs9.existsSync(featuresDir)) return [];
   try {
-    const entries = fs7.readdirSync(featuresDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(featuresDir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -154,14 +218,14 @@ function listDomainInterfaces(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const domainDir = path15.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs7.existsSync(domainDir)) continue;
+    const domainDir = path2.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs9.existsSync(domainDir)) continue;
     try {
-      const files = fs7.readdirSync(domainDir);
+      const files = fs9.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 = path15.join(domainDir, file);
+          const fullPath = path2.join(domainDir, file);
           if (/^I[A-Z]/.test(name)) {
             results.push({
               name,
@@ -170,7 +234,7 @@ function listDomainInterfaces(projectRoot, featureName) {
             });
           } else {
             try {
-              const content = fs7.readFileSync(fullPath, "utf-8");
+              const content = fs9.readFileSync(fullPath, "utf-8");
               if (/export\s+(?:abstract\s+class|interface)\s+(\w+)/.test(content)) {
                 results.push({
                   name,
@@ -192,17 +256,17 @@ function listDomainEntities(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const domainDir = path15.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs7.existsSync(domainDir)) continue;
+    const domainDir = path2.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs9.existsSync(domainDir)) continue;
     try {
-      const files = fs7.readdirSync(domainDir);
+      const files = fs9.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: path15.join(domainDir, file),
+              fullPath: path2.join(domainDir, file),
               feature: feat
             });
           }
@@ -217,16 +281,16 @@ function listUseCases(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const useCasesDir = path15.join(resolveFeaturesDir(projectRoot), feat, "useCases");
-    if (!fs7.existsSync(useCasesDir)) continue;
+    const useCasesDir = path2.join(resolveFeaturesDir(projectRoot), feat, "useCases");
+    if (!fs9.existsSync(useCasesDir)) continue;
     try {
-      const files = fs7.readdirSync(useCasesDir);
+      const files = fs9.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: path15.join(useCasesDir, file),
+            fullPath: path2.join(useCasesDir, file),
             feature: feat
           });
         }
@@ -252,33 +316,33 @@ hbs.registerHelper("join", (arr, sep) => {
 });
 var cachedTemplatesDir = null;
 function getTemplatesDir() {
-  if (cachedTemplatesDir && fs7.existsSync(cachedTemplatesDir)) {
+  if (cachedTemplatesDir && fs9.existsSync(cachedTemplatesDir)) {
     return cachedTemplatesDir;
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path15.dirname(fileURLToPath(import.meta.url));
-  const cand1 = path15.resolve(currentDir, "../../templates");
-  if (fs7.existsSync(cand1)) {
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath(import.meta.url));
+  const cand1 = path2.resolve(currentDir, "../../templates");
+  if (fs9.existsSync(cand1)) {
     cachedTemplatesDir = cand1;
     return cand1;
   }
-  const cand2 = path15.resolve(currentDir, "../templates");
-  if (fs7.existsSync(cand2)) {
+  const cand2 = path2.resolve(currentDir, "../templates");
+  if (fs9.existsSync(cand2)) {
     cachedTemplatesDir = cand2;
     return cand2;
   }
-  const cand3 = path15.resolve(currentDir, "templates");
-  if (fs7.existsSync(cand3)) {
+  const cand3 = path2.resolve(currentDir, "templates");
+  if (fs9.existsSync(cand3)) {
     cachedTemplatesDir = cand3;
     return cand3;
   }
   let curr = currentDir;
   while (true) {
-    const candTemplates = path15.join(curr, "templates");
-    if (fs7.existsSync(candTemplates)) {
+    const candTemplates = path2.join(curr, "templates");
+    if (fs9.existsSync(candTemplates)) {
       cachedTemplatesDir = candTemplates;
       return candTemplates;
     }
-    const parent = path15.dirname(curr);
+    const parent = path2.dirname(curr);
     if (parent === curr) break;
     curr = parent;
   }
@@ -286,8 +350,8 @@ function getTemplatesDir() {
 }
 var templateCache = /* @__PURE__ */ new Map();
 function loadTemplate(relativePath) {
-  const fullPath = path15.isAbsolute(relativePath) ? relativePath : path15.join(getTemplatesDir(), relativePath);
-  return fs7.readFileSync(fullPath, "utf-8");
+  const fullPath = path2.isAbsolute(relativePath) ? relativePath : path2.join(getTemplatesDir(), relativePath);
+  return fs9.readFileSync(fullPath, "utf-8");
 }
 function renderTemplateFile(relativePath, context) {
   let compiled = templateCache.get(relativePath);
@@ -374,8 +438,8 @@ function generateDomainEntityCode(name, kind = "interface", properties = []) {
 function generateDomain(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const entityName = toPascalCase(options.name);
-  const targetDir = options.targetDir || path15.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
-  const filePath = path15.join(targetDir, `${entityName}.ts`);
+  const targetDir = options.targetDir || path2.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path2.join(targetDir, `${entityName}.ts`);
   const code = generateDomainEntityCode(
     entityName,
     options.kind || "interface",
@@ -399,7 +463,7 @@ function generateInterfaceCode(ifaceName, kind = "abstractClass", entityName, me
   const idKey = `${entityKey}Id`;
   const listKey = `${entityKey}s`;
   const formattedCustomMethods = customMethods.map((m) => {
-    const params = m.params && m.params.length > 0 ? m.params.map((p15) => `${p15.name}: ${p15.type}`).join("; ") : "";
+    const params = m.params && m.params.length > 0 ? m.params.map((p16) => `${p16.name}: ${p16.type}`).join("; ") : "";
     const returnType = m.returnType ? `Promise<${m.returnType}>` : "Promise<void>";
     return {
       name: m.name,
@@ -424,8 +488,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 || path15.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
-  const filePath = path15.join(targetDir, `${ifaceName}.ts`);
+  const targetDir = options.targetDir || path2.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path2.join(targetDir, `${ifaceName}.ts`);
   const code = generateInterfaceCode(
     ifaceName,
     options.kind || "abstractClass",
@@ -660,7 +724,7 @@ function parseInterfaceMethodsAndImports(content, targetIfaceName) {
   };
 }
 function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
-  if (customPath && fs7.existsSync(customPath)) {
+  if (customPath && fs9.existsSync(customPath)) {
     return { filePath: customPath, ifaceName };
   }
   const candidateNames = [
@@ -670,22 +734,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 = path15.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs7.existsSync(domainDir)) continue;
+    const domainDir = path2.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs9.existsSync(domainDir)) continue;
     for (const cand of candidateNames) {
-      const p1 = path15.join(domainDir, `${cand}.ts`);
-      if (fs7.existsSync(p1)) {
+      const p1 = path2.join(domainDir, `${cand}.ts`);
+      if (fs9.existsSync(p1)) {
         return { filePath: p1, ifaceName: cand, feature: feat };
       }
     }
   }
   for (const cand of candidateNames) {
-    const p1 = path15.join(projectRoot, "domain", `${cand}.ts`);
-    if (fs7.existsSync(p1)) return { filePath: p1, ifaceName: cand };
-    const p22 = path15.join(projectRoot, "src", "domain", `${cand}.ts`);
-    if (fs7.existsSync(p22)) return { filePath: p22, ifaceName: cand };
-    const p32 = path15.join(projectRoot, "interfaces", `${cand}.ts`);
-    if (fs7.existsSync(p32)) return { filePath: p32, ifaceName: cand };
+    const p1 = path2.join(projectRoot, "domain", `${cand}.ts`);
+    if (fs9.existsSync(p1)) return { filePath: p1, ifaceName: cand };
+    const p22 = path2.join(projectRoot, "src", "domain", `${cand}.ts`);
+    if (fs9.existsSync(p22)) return { filePath: p22, ifaceName: cand };
+    const p32 = path2.join(projectRoot, "interfaces", `${cand}.ts`);
+    if (fs9.existsSync(p32)) return { filePath: p32, ifaceName: cand };
   }
   return null;
 }
@@ -708,7 +772,7 @@ function loadInterfaceHierarchy(projectRoot, initialIfaceName, featureName, cust
   while (currentFile && !visited.has(currentFile)) {
     visited.add(currentFile);
     try {
-      const content = fs7.readFileSync(currentFile, "utf-8");
+      const content = fs9.readFileSync(currentFile, "utf-8");
       const parsed = parseInterfaceMethodsAndImports(content, currentName);
       for (const m of parsed.methods) {
         if (!allMethods.some((existing) => existing.name === m.name)) {
@@ -784,7 +848,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 ? `${path15.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+  const entityImportPath = ifaceImportPath ? `${path2.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;
@@ -833,7 +897,7 @@ function generateConcreteInfraCode(className, ifaceName, dependencies = [], meth
     if (baseEntity) {
       finalMethods = synthesizeCrudMethods(baseEntity);
       if (!finalDomainImports.some((imp) => imp.name === baseEntity)) {
-        const importPath = ifaceImportPath ? `${path15.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+        const importPath = ifaceImportPath ? `${path2.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
         finalDomainImports.push({
           name: baseEntity,
           from: importPath,
@@ -878,8 +942,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 ? path15.join(resolveFeaturesDir(projectRoot), options.feature, "infrastructure") : path15.join(projectRoot, "infrastructure"));
-  const filePath = path15.join(targetDir, `${className}.ts`);
+  const targetDir = options.targetDir || (isFeatureScope ? path2.join(resolveFeaturesDir(projectRoot), options.feature, "infrastructure") : path2.join(projectRoot, "infrastructure"));
+  const filePath = path2.join(targetDir, `${className}.ts`);
   let code;
   if (options.implementsInterface) {
     const rawIfaceName = options.implementsInterface;
@@ -893,7 +957,7 @@ function generateInfrastructure(options) {
     const ifaceFilePath = hierarchy.ifaceFilePath;
     let ifaceImportPath;
     if (ifaceFilePath) {
-      let rel = path15.relative(targetDir, ifaceFilePath).replace(/\\/g, "/").replace(/\.ts$/, ".js");
+      let rel = path2.relative(targetDir, ifaceFilePath).replace(/\\/g, "/").replace(/\.ts$/, ".js");
       if (!rel.startsWith(".")) rel = "./" + rel;
       ifaceImportPath = rel;
     } else if (isFeatureScope) {
@@ -906,8 +970,8 @@ function generateInfrastructure(options) {
         if (new RegExp(`\\b${item.name}\\b`).test(allSignatures)) {
           let fromPath;
           if (imp.specifier.startsWith(".") && ifaceFilePath) {
-            const absTarget = path15.resolve(path15.dirname(ifaceFilePath), imp.specifier);
-            let rel = path15.relative(targetDir, absTarget).replace(/\\/g, "/");
+            const absTarget = path2.resolve(path2.dirname(ifaceFilePath), imp.specifier);
+            let rel = path2.relative(targetDir, absTarget).replace(/\\/g, "/");
             if (!rel.startsWith(".")) rel = "./" + rel;
             fromPath = rel;
           } else {
@@ -980,22 +1044,22 @@ function generateUseCaseCode(useCaseName, dependencies = [], inputProps = [], ou
     from: /^I[A-Z]/.test(dep) ? `../domain/${dep}.js` : `./${dep}.js`
   }));
   const domainTypesToImport = new Set(domainImports);
-  for (const p15 of [...inputProps, ...outputProps]) {
-    const rawType = p15.type.trim();
+  for (const p16 of [...inputProps, ...outputProps]) {
+    const rawType = p16.type.trim();
     const baseType = rawType.replace(/\[\]$/, "").trim();
     if (!primitiveTypes.has(baseType) && /^[A-Z][A-Za-z0-9_]*$/.test(baseType) && !dependencies.includes(baseType)) {
       domainTypesToImport.add(baseType);
     }
   }
-  const formattedInputProps = inputProps.map((p15) => ({
-    name: p15.name,
-    optional: p15.optional,
-    type: p15.optional && !p15.type.includes("undefined") ? `${p15.type} | undefined` : p15.type
+  const formattedInputProps = inputProps.map((p16) => ({
+    name: p16.name,
+    optional: p16.optional,
+    type: p16.optional && !p16.type.includes("undefined") ? `${p16.type} | undefined` : p16.type
   }));
-  const formattedOutputProps = outputProps.map((p15) => ({
-    name: p15.name,
-    optional: p15.optional,
-    type: p15.optional && !p15.type.includes("undefined") ? `${p15.type} | undefined` : p15.type
+  const formattedOutputProps = outputProps.map((p16) => ({
+    name: p16.name,
+    optional: p16.optional,
+    type: p16.optional && !p16.type.includes("undefined") ? `${p16.type} | undefined` : p16.type
   }));
   const formattedDeps = dependencies.map((dep) => ({
     key: toCamelCase(dep),
@@ -1094,8 +1158,8 @@ function generateUseCase(options) {
   const files = [];
   const projectRoot = options.projectRoot || findProjectRoot();
   const ucName = toPascalCase(options.name);
-  const targetDir = options.targetDir || path15.join(resolveFeaturesDir(projectRoot), options.feature, "useCases");
-  const filePath = path15.join(targetDir, `${ucName}.ts`);
+  const targetDir = options.targetDir || path2.join(resolveFeaturesDir(projectRoot), options.feature, "useCases");
+  const filePath = path2.join(targetDir, `${ucName}.ts`);
   const code = generateUseCaseCode(
     ucName,
     options.dependencies || [],
@@ -1111,7 +1175,7 @@ function generateUseCase(options) {
     })
   );
   if (options.includeTest) {
-    const testPath = path15.join(targetDir, `${ucName}.test.ts`);
+    const testPath = path2.join(targetDir, `${ucName}.test.ts`);
     const testCode = generateUseCaseTestCode(ucName, options.dependencies || []);
     files.push(
       writeFileSafely(testPath, testCode, {
@@ -1179,10 +1243,10 @@ function generateHttpHandler(options) {
   const files = [];
   const projectRoot = options.projectRoot || findProjectRoot();
   const className = toPascalCase(options.name);
-  const pxDir = path15.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress");
-  const handlersDir = path15.join(pxDir, "handlers");
-  const pxIndexPath = path15.join(pxDir, "index.ts");
-  if (!fs7.existsSync(pxIndexPath)) {
+  const pxDir = path2.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress");
+  const handlersDir = path2.join(pxDir, "handlers");
+  const pxIndexPath = path2.join(pxDir, "index.ts");
+  if (!fs9.existsSync(pxIndexPath)) {
     const featurePath = options.routePrefix || `/${options.feature.toLowerCase()}`;
     const pxIndexContent = renderTemplate(expressIndexTemplate, {
       routePath: featurePath
@@ -1195,7 +1259,7 @@ function generateHttpHandler(options) {
       })
     );
   }
-  const handlerFilePath = path15.join(handlersDir, `${className}.ts`);
+  const handlerFilePath = path2.join(handlersDir, `${className}.ts`);
   const code = generateHttpHandlerCode(
     className,
     options.method || "get",
@@ -1216,11 +1280,11 @@ function generateHttpHandler(options) {
   return files;
 }
 function updateOrGenerateDiProvider(featureDir, featureName, bindings = [], options = {}) {
-  const providerPath = path15.join(featureDir, "diProvider.ts");
+  const providerPath = path2.join(featureDir, "diProvider.ts");
   const pascalFeature = toPascalCase(featureName);
   const providerModuleName = `${pascalFeature}Provider`;
-  if (fs7.existsSync(providerPath) && !options.overwrite) {
-    let content = fs7.readFileSync(providerPath, "utf-8");
+  if (fs9.existsSync(providerPath) && !options.overwrite) {
+    let content = fs9.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`;
@@ -1279,7 +1343,7 @@ function generateFeature(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const rawName = options.name.trim();
   const featureName = toCamelCase(rawName);
-  const targetDir = options.targetDir || path15.join(resolveFeaturesDir(projectRoot), featureName);
+  const targetDir = options.targetDir || path2.join(resolveFeaturesDir(projectRoot), featureName);
   const routePath = options.routePath || `/${featureName}`;
   const rawEntities = [];
   if (options.entityNames && options.entityNames.length > 0) {
@@ -1300,7 +1364,7 @@ function generateFeature(options) {
       const domainFile = generateDomain({
         name: ent,
         feature: featureName,
-        targetDir: path15.join(targetDir, "domain"),
+        targetDir: path2.join(targetDir, "domain"),
         projectRoot,
         dryRun: options.dryRun,
         overwrite: options.overwrite,
@@ -1320,7 +1384,7 @@ function generateFeature(options) {
       const ifaceFile = generateInterface({
         name: ifaceName,
         feature: featureName,
-        targetDir: path15.join(targetDir, "domain"),
+        targetDir: path2.join(targetDir, "domain"),
         entityName: ent,
         projectRoot,
         dryRun: options.dryRun,
@@ -1337,7 +1401,7 @@ function generateFeature(options) {
       const stubFile = generateInfrastructure({
         name: stubName,
         feature: featureName,
-        targetDir: path15.join(targetDir, "infrastructure"),
+        targetDir: path2.join(targetDir, "infrastructure"),
         kind: "stub",
         implementsInterface: ifaceName,
         entityName: ent,
@@ -1379,7 +1443,7 @@ function generateFeature(options) {
       const ucFiles = generateUseCase({
         name: ucName,
         feature: featureName,
-        targetDir: path15.join(targetDir, "useCases"),
+        targetDir: path2.join(targetDir, "useCases"),
         dependencies: options.includeInterface !== false ? [ifaceName] : [],
         inputProperties: [{ name: idParam, type: "string" }],
         outputProperties: [{ name: entVar, type: primaryEntity }],
@@ -1424,7 +1488,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path15.join(targetDir, "useCases"),
+            targetDir: path2.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: entVar, type: ent }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1457,7 +1521,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path15.join(targetDir, "useCases"),
+            targetDir: path2.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: idParam, type: "string" }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1490,7 +1554,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path15.join(targetDir, "useCases"),
+            targetDir: path2.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [
               { name: "page", type: "number", optional: true },
@@ -1534,7 +1598,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path15.join(targetDir, "useCases"),
+            targetDir: path2.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: entVar, type: ent }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1567,7 +1631,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path15.join(targetDir, "useCases"),
+            targetDir: path2.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: idParam, type: "string" }],
             outputProperties: [{ name: "success", type: "boolean" }],
@@ -1604,7 +1668,7 @@ function generateFeature(options) {
       const ucFiles = generateUseCase({
         name: ucName,
         feature: featureName,
-        targetDir: path15.join(targetDir, "useCases"),
+        targetDir: path2.join(targetDir, "useCases"),
         dependencies: customUc.dependencies || [],
         inputProperties: customUc.inputProperties || [],
         outputProperties: customUc.outputProperties || [],
@@ -1636,8 +1700,8 @@ function generateFeature(options) {
     }
   }
   if (options.includeExpress !== false) {
-    const pxDir = path15.join(targetDir, "pxExpress");
-    const pxIndexPath = path15.join(pxDir, "index.ts");
+    const pxDir = path2.join(targetDir, "pxExpress");
+    const pxIndexPath = path2.join(pxDir, "index.ts");
     if (!files.some((f) => f.absolutePath === pxIndexPath)) {
       const pxIndexContent = renderTemplate(expressIndexTemplate, { routePath });
       files.push(
@@ -1674,13 +1738,13 @@ function handleCancel(result) {
 }
 function printBanner() {
   console.log("");
-  p3.intro(pc13.bgCyan(pc13.black(" @solid-stack/mason ")));
+  p3.intro(pc14.bgCyan(pc14.black(" @solid-stack/mason ")));
 }
 async function promptProperties(options = {}) {
   const properties = options.defaults ? [...options.defaults] : [];
   if (properties.length > 0) {
-    const summary = properties.map((p15) => `${p15.name}: ${p15.type}${p15.optional ? "?" : ""}`).join(", ");
-    p3.log.info(pc13.dim(`Pre-configured fields: ${summary}`));
+    const summary = properties.map((p16) => `${p16.name}: ${p16.type}${p16.optional ? "?" : ""}`).join(", ");
+    p3.log.info(pc14.dim(`Pre-configured fields: ${summary}`));
     const addMore = handleCancel(
       await p3.confirm({
         message: "Would you like to add custom fields/properties?",
@@ -1691,7 +1755,7 @@ async function promptProperties(options = {}) {
       return properties;
     }
   }
-  p3.log.info(pc13.cyan("Enter properties (leave name blank when finished):"));
+  p3.log.info(pc14.cyan("Enter properties (leave name blank when finished):"));
   while (true) {
     const name = handleCancel(
       await p3.text({
@@ -1739,7 +1803,7 @@ async function promptProperties(options = {}) {
       optional
     });
     p3.log.success(
-      pc13.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
+      pc14.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
     );
   }
   return properties;
@@ -1748,6 +1812,7 @@ async function promptProperties(options = {}) {
 // src/commands/feature.ts
 async function runFeatureCommand(featureNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
+  const isRegistry = getEffectiveMode(projectRoot, flags) === "registry";
   let name = featureNameArg?.trim();
   if (!name && flags.yes) {
     name = "feature";
@@ -1765,9 +1830,10 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
     ).trim();
   }
   const normalizedName = toCamelCase(name);
-  const defaultDir = path15.relative(projectRoot, path15.join(resolveFeaturesDir(projectRoot), normalizedName));
+  const baseFeaturesDir = resolveFeaturesDir(projectRoot, flags);
+  const defaultDir = path2.relative(projectRoot, path2.join(baseFeaturesDir, normalizedName));
   let targetDirRel = defaultDir;
-  if (!flags.yes && !flags.target) {
+  if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
       await p3.text({
         message: "Target directory for the feature:",
@@ -1776,7 +1842,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       })
     ).trim();
   }
-  const targetDir = flags.target ? path15.resolve(projectRoot, flags.target) : path15.resolve(projectRoot, targetDirRel);
+  const targetDir = flags.dest ? path2.resolve(projectRoot, flags.dest) : flags.target ? path2.resolve(projectRoot, flags.target) : path2.resolve(projectRoot, targetDirRel);
   let includeExpress = flags.express !== void 0 ? Boolean(flags.express) : true;
   let routePath = `/${normalizedName}`;
   let includeDomain = true;
@@ -1997,7 +2063,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
     }
   }
   const s = p3.spinner();
-  s.start(`Generating feature '${pc13.cyan(normalizedName)}'...`);
+  s.start(`Generating feature '${pc14.cyan(normalizedName)}'...`);
   const options = {
     name: normalizedName,
     projectRoot,
@@ -2017,9 +2083,207 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
     includeDiProvider
   };
   const files = generateFeature(options);
+  if (isRegistry) {
+    const registryPath = path2.join(targetDir, "registry.json");
+    if (!fs9.existsSync(registryPath)) {
+      const manifest = {
+        name: toKebabCase(normalizedName),
+        type: "feature",
+        description: flags.description || `${normalizedName} feature module`,
+        version: "1.0.0",
+        dependencies: {
+          npm: includeExpress ? ["@solid-stack/agnos-express", "express"] : [],
+          shared: [],
+          features: []
+        },
+        files: []
+      };
+      const content = JSON.stringify(manifest, null, 2) + "\n";
+      const genFile = writeFileSafely(registryPath, content, {
+        projectRoot,
+        overwrite: options.overwrite,
+        dryRun: options.dryRun
+      });
+      files.push(genFile);
+    }
+  }
   s.stop("Feature scaffolded successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p3.outro(pc13.green(`Feature '${normalizedName}' ready to use!`));
+  p3.outro(
+    pc14.green(
+      `\u2713 Feature '${normalizedName}' initialized in ${path2.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
+    )
+  );
+}
+function generateShared(options) {
+  const files = [];
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const rawName = options.name.trim();
+  const pascalName = toPascalCase(rawName);
+  const camelName = toCamelCase(rawName);
+  const kebabName = toKebabCase(rawName);
+  const targetDir = options.targetDir || path2.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";
+@MakeInjectable
+export class ${pascalName} {
+  public static deps = { ${camelName}Engine: I${pascalName}Engine };
+  constructor(public readonly deps: DepsType<typeof ${pascalName}.deps>) {}
+}
+`;
+  fileDefs.push({
+    absolutePath: path2.join(targetDir, `${pascalName}.ts`),
+    content: facadeContent
+  });
+  const portContent = `export abstract class I${pascalName}Engine {
+  // Define abstract port contracts for ${pascalName} here
+}
+`;
+  fileDefs.push({
+    absolutePath: path2.join(targetDir, "ports", `I${pascalName}Engine.ts`),
+    content: portContent
+  });
+  const concreteContent = `import { MakeInjectable } from "@solid-stack/di";
+import { I${pascalName}Engine } from "../ports/I${pascalName}Engine.js";
+@MakeInjectable
+export class Default${pascalName}Engine implements I${pascalName}Engine {
+  // Default concrete implementation for production
+}
+`;
+  fileDefs.push({
+    absolutePath: path2.join(targetDir, "infrastructure", `Default${pascalName}Engine.ts`),
+    content: concreteContent
+  });
+  if (options.includeStub !== false) {
+    const stubContent = `import { MakeInjectable } from "@solid-stack/di";
+import { I${pascalName}Engine } from "../ports/I${pascalName}Engine.js";
+@MakeInjectable
+export class Stub${pascalName}Engine implements I${pascalName}Engine {
+  // In-memory or stub implementation for testing
+}
+`;
+    fileDefs.push({
+      absolutePath: path2.join(targetDir, "infrastructure", `Stub${pascalName}Engine.ts`),
+      content: stubContent
+    });
+  }
+  const providerContent = `import type { Container } from "@solid-stack/di";
+import { I${pascalName}Engine } from "./ports/I${pascalName}Engine.js";
+import { Default${pascalName}Engine } from "./infrastructure/Default${pascalName}Engine.js";
+export const diProvider = (c: Container): void => {
+  c.provide(I${pascalName}Engine, Default${pascalName}Engine);
+};
+export default diProvider;
+`;
+  fileDefs.push({
+    absolutePath: path2.join(targetDir, "diProvider.ts"),
+    content: providerContent
+  });
+  if (options.isRegistry) {
+    const registryManifest = {
+      name: kebabName,
+      type: "shared",
+      description: options.description || `${kebabName} shared module`,
+      version: "1.0.0",
+      dependencies: {
+        npm: [],
+        shared: [],
+        features: []
+      },
+      files: []
+    };
+    fileDefs.push({
+      absolutePath: path2.join(targetDir, "registry.json"),
+      content: JSON.stringify(registryManifest, null, 2) + "\n"
+    });
+  }
+  for (const def of fileDefs) {
+    const genFile = writeFileSafely(def.absolutePath, def.content, {
+      projectRoot,
+      overwrite: options.overwrite,
+      dryRun: options.dryRun
+    });
+    files.push(genFile);
+  }
+  return files;
+}
+// src/commands/shared.ts
+async function runSharedCommand(sharedNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const isRegistry = getEffectiveMode(projectRoot, flags) === "registry";
+  let name = sharedNameArg?.trim();
+  if (!name && flags.yes) {
+    name = "shared";
+  }
+  if (!name) {
+    name = handleCancel(
+      await p3.text({
+        message: "What is the shared module name?",
+        placeholder: "e.g. hasher, time, uuid, cache, logger",
+        validate: (val) => {
+          if (!val || !val.trim()) return "Shared module name cannot be empty.";
+          return void 0;
+        }
+      })
+    ).trim();
+  }
+  const normalizedName = toKebabCase(name);
+  const baseSharedDir = resolveSharedDir(projectRoot, flags);
+  const defaultDir = path2.relative(projectRoot, path2.join(baseSharedDir, normalizedName));
+  let targetDirRel = defaultDir;
+  if (!flags.yes && !flags.target && !flags.dest) {
+    targetDirRel = handleCancel(
+      await p3.text({
+        message: "Target directory for the shared module:",
+        initialValue: defaultDir,
+        defaultValue: defaultDir
+      })
+    ).trim();
+  }
+  const targetDir = flags.dest ? path2.resolve(projectRoot, flags.dest) : flags.target ? path2.resolve(projectRoot, flags.target) : path2.resolve(projectRoot, targetDirRel);
+  let description = flags.description || "";
+  let includeStub = true;
+  if (!flags.yes) {
+    description = handleCancel(
+      await p3.text({
+        message: "Module description (optional):",
+        placeholder: "e.g. In-memory caching and Redis port abstraction",
+        initialValue: ""
+      })
+    ).trim();
+    includeStub = handleCancel(
+      await p3.confirm({
+        message: "Include stub implementation in infrastructure/?",
+        initialValue: true
+      })
+    );
+  }
+  const s = p3.spinner();
+  s.start(`Generating shared module '${pc14.cyan(normalizedName)}'...`);
+  const files = generateShared({
+    name: normalizedName,
+    description,
+    projectRoot,
+    targetDir,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite),
+    includeStub,
+    isRegistry
+  });
+  s.stop("Shared module generated successfully!");
+  printGeneratedFiles(files, Boolean(flags.dryRun));
+  p3.outro(
+    pc14.green(
+      `\u2713 Shared module '${normalizedName}' initialized in ${path2.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
+    )
+  );
 }
 async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2144,7 +2408,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
     }
   }
   const s = p3.spinner();
-  s.start(`Generating use case '${pc13.cyan(ucName)}'...`);
+  s.start(`Generating use case '${pc14.cyan(ucName)}'...`);
   const options = {
     name: ucName,
     feature,
@@ -2176,7 +2440,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   }
   s.stop("Use case generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p3.outro(pc13.green(`Use case '${ucName}' created in feature '${feature}'!`));
+  p3.outro(pc14.green(`Use case '${ucName}' created in feature '${feature}'!`));
 }
 async function runDomainCommand(domainNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2247,7 +2511,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
     });
   }
   const s = p3.spinner();
-  s.start(`Generating domain model '${pc13.cyan(entityName)}'...`);
+  s.start(`Generating domain model '${pc14.cyan(entityName)}'...`);
   const options = {
     name: entityName,
     feature,
@@ -2260,7 +2524,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   const file = generateDomain(options);
   s.stop("Domain model generated successfully!");
   printGeneratedFiles([file], options.dryRun);
-  p3.outro(pc13.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+  p3.outro(pc14.green(`Domain model '${entityName}' created in feature '${feature}'!`));
 }
 async function runInfrastructureCommand(classNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2429,7 +2693,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     registerInProvider = !flags.noProvider;
   }
   const s = p3.spinner();
-  s.start(`Generating infrastructure class '${pc13.cyan(className)}'...`);
+  s.start(`Generating infrastructure class '${pc14.cyan(className)}'...`);
   const files = [];
   const options = {
     name: className,
@@ -2444,7 +2708,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   const infraFile = generateInfrastructure(options);
   files.push(infraFile);
   if (registerInProvider && scope === "feature" && feature && implementsInterface) {
-    const featureDir = path15.join(resolveFeaturesDir(projectRoot), feature);
+    const featureDir = path2.join(resolveFeaturesDir(projectRoot), feature);
     const providerFile = updateOrGenerateDiProvider(
       featureDir,
       feature,
@@ -2464,7 +2728,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   s.stop("Infrastructure class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p3.outro(pc13.green(`Infrastructure class '${className}' created!`));
+  p3.outro(pc14.green(`Infrastructure class '${className}' created!`));
 }
 async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2577,7 +2841,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
     }
   }
   const s = p3.spinner();
-  s.start(`Generating interface '${pc13.cyan(ifaceName)}'...`);
+  s.start(`Generating interface '${pc14.cyan(ifaceName)}'...`);
   const files = [];
   const options = {
     name: ifaceName,
@@ -2606,7 +2870,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
     files.push(stubFile);
   }
   if (registerInProvider && generateStub) {
-    const featureDir = path15.join(resolveFeaturesDir(projectRoot), feature);
+    const featureDir = path2.join(resolveFeaturesDir(projectRoot), feature);
     const providerFile = updateOrGenerateDiProvider(
       featureDir,
       feature,
@@ -2626,7 +2890,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   }
   s.stop("Interface generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p3.outro(pc13.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+  p3.outro(pc14.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
 }
 async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2743,7 +3007,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     }
   }
   const s = p3.spinner();
-  s.start(`Generating HTTP handler '${pc13.cyan(className)}'...`);
+  s.start(`Generating HTTP handler '${pc14.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -2761,7 +3025,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const files = generateHttpHandler(options);
   s.stop("HTTP handler generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p3.outro(pc13.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+  p3.outro(pc14.green(`HTTP handler '${className}' created in feature '${feature}'!`));
 }
 function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
   const formattedDeps = dependencies.map((dep) => ({
@@ -2771,7 +3035,7 @@ function generateInjectableCode(className, dependencies = [], methods = [], impl
   const formattedMethods = methods.map((m) => {
     const isAsync = m.async !== false;
     const retType = m.returnType ? isAsync ? `Promise<${m.returnType}>` : m.returnType : isAsync ? "Promise<void>" : "void";
-    const params = m.params && m.params.length > 0 ? m.params.map((p15) => `${p15.name}: ${p15.type}`).join(", ") : "";
+    const params = m.params && m.params.length > 0 ? m.params.map((p16) => `${p16.name}: ${p16.type}`).join(", ") : "";
     return {
       name: m.name,
       isAsync,
@@ -2794,21 +3058,21 @@ function generateInjectable(options) {
   const className = toPascalCase(options.name);
   let targetDir = "";
   if (options.customPath) {
-    targetDir = path15.isAbsolute(options.customPath) ? options.customPath : path15.join(projectRoot, options.customPath);
+    targetDir = path2.isAbsolute(options.customPath) ? options.customPath : path2.join(projectRoot, options.customPath);
   } else if (options.location === "feature-service" && options.feature) {
-    targetDir = path15.join(resolveFeaturesDir(projectRoot), options.feature, "services");
+    targetDir = path2.join(resolveFeaturesDir(projectRoot), options.feature, "services");
   } else if (options.location === "feature-transformer" && options.feature) {
-    targetDir = path15.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress", "transformers");
+    targetDir = path2.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress", "transformers");
   } else if (options.location === "module") {
-    targetDir = path15.join(projectRoot, "modules", className);
+    targetDir = path2.join(projectRoot, "modules", className);
   } else {
-    targetDir = options.feature ? path15.join(resolveFeaturesDir(projectRoot), options.feature, "services") : path15.join(projectRoot, "shared", className.toLowerCase());
+    targetDir = options.feature ? path2.join(resolveFeaturesDir(projectRoot), options.feature, "services") : path2.join(projectRoot, "shared", className.toLowerCase());
   }
-  const filePath = path15.join(targetDir, `${className}.ts`);
+  const filePath = path2.join(targetDir, `${className}.ts`);
   let ifaceName;
   if (options.generateInterface) {
     ifaceName = `I${className}`;
-    const ifacePath = path15.join(targetDir, `${ifaceName}.ts`);
+    const ifacePath = path2.join(targetDir, `${ifaceName}.ts`);
     const ifaceContent = renderTemplate(injectableInterfaceTemplate, { ifaceName });
     files.push(
       writeFileSafely(ifacePath, ifaceContent, {
@@ -2917,7 +3181,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
     );
   }
   const s = p3.spinner();
-  s.start(`Generating injectable '${pc13.cyan(className)}'...`);
+  s.start(`Generating injectable '${pc14.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -2931,7 +3195,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   const files = generateInjectable(options);
   s.stop("Injectable class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p3.outro(pc13.green(`Injectable '${className}' created successfully!`));
+  p3.outro(pc14.green(`Injectable '${className}' created successfully!`));
 }
 async function runInteractiveMenu(flags = {}) {
   printBanner();
@@ -2944,6 +3208,11 @@ async function runInteractiveMenu(flags = {}) {
           label: "Feature",
           hint: "Complete vertical slice (domain, infra, usecase, pxExpress, diProvider)"
         },
+        {
+          value: "shared",
+          label: "Shared Module",
+          hint: "Foundational utility or port with ports, infrastructure & diProvider"
+        },
         {
           value: "usecase",
           label: "Use Case",
@@ -2981,6 +3250,9 @@ async function runInteractiveMenu(flags = {}) {
     case "feature":
       await runFeatureCommand(void 0, flags);
       break;
+    case "shared":
+      await runSharedCommand(void 0, flags);
+      break;
     case "usecase":
       await runUseCaseCommand(void 0, flags);
       break;
@@ -3013,6 +3285,9 @@ async function handleCreate(type, name, flags = {}) {
     case "feature":
       await runFeatureCommand(name, flags);
       break;
+    case "shared":
+      await runSharedCommand(name, flags);
+      break;
     case "usecase":
       await runUseCaseCommand(name, flags);
       break;
@@ -3034,8 +3309,8 @@ async function handleCreate(type, name, flags = {}) {
       break;
     default:
       p3.log.error(
-        pc13.red(
-          `Unknown component type: "${type}". Allowed types: feature, usecase, domain, infrastructure, interface, httpHandler, injectable.`
+        pc14.red(
+          `Unknown component type: "${type}". Allowed types: feature, shared, usecase, domain, infrastructure, interface, httpHandler, injectable.`
         )
       );
       process.exit(1);
@@ -3058,25 +3333,25 @@ function normalizeRegistryUrl(urlOrPath, baseDir) {
     return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
   }
   if (baseDir && (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed === "." || trimmed === "..")) {
-    return path15.resolve(baseDir, trimmed);
+    return path2.resolve(baseDir, trimmed);
   }
   return trimmed;
 }
 function findLocalRegistry(startDir = process.cwd()) {
-  let current = path15.resolve(startDir);
+  let current = path2.resolve(startDir);
   while (true) {
-    const candidate = path15.join(current, "mason-registry");
-    if (fs7.existsSync(candidate) && fs7.existsSync(path15.join(candidate, "index.json"))) {
+    const candidate = path2.join(current, "mason-registry");
+    if (fs9.existsSync(candidate) && fs9.existsSync(path2.join(candidate, "index.json"))) {
       return candidate;
     }
-    const parent = path15.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   return null;
 }
 function getRegistryBase(projectRoot, override) {
-  const rootDir = projectRoot ? path15.resolve(projectRoot) : process.cwd();
+  const rootDir = projectRoot ? path2.resolve(projectRoot) : process.cwd();
   if (override && override.trim()) {
     return normalizeRegistryUrl(override.trim(), rootDir);
   }
@@ -3084,30 +3359,30 @@ function getRegistryBase(projectRoot, override) {
     return normalizeRegistryUrl(process.env.MASON_REGISTRY_URL.trim(), rootDir);
   }
   const configLocations = [
-    path15.join(rootDir, "mason.config.json"),
-    path15.join(process.cwd(), "mason.config.json")
+    path2.join(rootDir, "mason.config.json"),
+    path2.join(process.cwd(), "mason.config.json")
   ];
   for (const configPath of configLocations) {
-    if (fs7.existsSync(configPath)) {
+    if (fs9.existsSync(configPath)) {
       try {
-        const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+        const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
         if (config.registry && typeof config.registry === "string") {
-          return normalizeRegistryUrl(config.registry.trim(), path15.dirname(configPath));
+          return normalizeRegistryUrl(config.registry.trim(), path2.dirname(configPath));
         }
       } catch {
       }
     }
   }
   const pkgLocations = [
-    path15.join(rootDir, "package.json"),
-    path15.join(process.cwd(), "package.json")
+    path2.join(rootDir, "package.json"),
+    path2.join(process.cwd(), "package.json")
   ];
   for (const pkgPath of pkgLocations) {
-    if (fs7.existsSync(pkgPath)) {
+    if (fs9.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
         if (pkg.mason?.registry && typeof pkg.mason.registry === "string") {
-          return normalizeRegistryUrl(pkg.mason.registry.trim(), path15.dirname(pkgPath));
+          return normalizeRegistryUrl(pkg.mason.registry.trim(), path2.dirname(pkgPath));
         }
       } catch {
       }
@@ -3148,11 +3423,11 @@ async function fetchRegistryFile(registryBase, relPath) {
   if (baseDir.startsWith("file://")) {
     baseDir = fileURLToPath(baseDir);
   }
-  const filePath = path15.resolve(baseDir, cleanRelPath);
-  if (!fs7.existsSync(filePath)) {
+  const filePath = path2.resolve(baseDir, cleanRelPath);
+  if (!fs9.existsSync(filePath)) {
     throw new Error(`Registry file not found at ${filePath}`);
   }
-  return fs7.promises.readFile(filePath, "utf-8");
+  return fs9.promises.readFile(filePath, "utf-8");
 }
 async function fetchRegistryIndex(registryBase) {
   const content = await fetchRegistryFile(registryBase, "index.json");
@@ -3214,26 +3489,26 @@ function findClosestMatch(target, candidates) {
   return null;
 }
 function detectPackageManager(projectRoot) {
-  if (fs7.existsSync(path15.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs7.existsSync(path15.join(projectRoot, "yarn.lock"))) return "yarn";
-  if (fs7.existsSync(path15.join(projectRoot, "bun.lockb")) || fs7.existsSync(path15.join(projectRoot, "bun.lock"))) return "bun";
+  if (fs9.existsSync(path2.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs9.existsSync(path2.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (fs9.existsSync(path2.join(projectRoot, "bun.lockb")) || fs9.existsSync(path2.join(projectRoot, "bun.lock"))) return "bun";
   return "npm";
 }
 function getMissingNpmPackages(projectRoot, requiredPackages) {
   if (!requiredPackages || requiredPackages.length === 0) return [];
-  const pkgJsonPath = path15.join(projectRoot, "package.json");
-  if (!fs7.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path2.join(projectRoot, "package.json");
+  if (!fs9.existsSync(pkgJsonPath)) {
     return requiredPackages;
   }
   try {
-    const pkg = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
     const installed = /* @__PURE__ */ new Set([
       ...Object.keys(pkg.dependencies || {}),
       ...Object.keys(pkg.devDependencies || {}),
       ...Object.keys(pkg.peerDependencies || {})
     ]);
-    return requiredPackages.filter((p15) => {
-      const nameOnly = p15.startsWith("@") ? `@${p15.slice(1).split("@")[0] || ""}` : p15.split("@")[0] || p15;
+    return requiredPackages.filter((p16) => {
+      const nameOnly = p16.startsWith("@") ? `@${p16.slice(1).split("@")[0] || ""}` : p16.split("@")[0] || p16;
       return !installed.has(nameOnly);
     });
   } catch {
@@ -3258,21 +3533,207 @@ function installNpmPackages(projectRoot, packages, pm) {
       installCmd = `npm install ${packages.join(" ")}`;
       break;
   }
-  p3.log.info(`Installing missing dependencies with ${manager}: ${pc13.cyan(packages.join(", "))}`);
+  p3.log.info(`Installing missing dependencies with ${manager}: ${pc14.cyan(packages.join(", "))}`);
   execSync(installCmd, {
     cwd: projectRoot,
     stdio: "inherit"
   });
 }
+function getAllFiles(dir, baseDir = dir) {
+  if (!fs9.existsSync(dir)) return [];
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    const relPath = path2.relative(baseDir, fullPath).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      if (entry.name === "__tests__" || entry.name.startsWith(".")) {
+        continue;
+      }
+      files.push(...getAllFiles(fullPath, baseDir));
+    } else if (entry.isFile()) {
+      if (entry.name === "registry.json" || entry.name.endsWith(".test.ts") || entry.name.endsWith(".spec.ts") || entry.name.startsWith(".")) {
+        continue;
+      }
+      files.push(relPath);
+    }
+  }
+  return files.sort();
+}
+function computeDirectoryHash(dirPath, files) {
+  if (!fs9.existsSync(dirPath)) return "";
+  const hash = createHash("sha256");
+  const fileList = (getAllFiles(dirPath)).sort();
+  for (const relativePath of fileList) {
+    const absolutePath = path2.join(dirPath, relativePath);
+    if (!fs9.existsSync(absolutePath)) continue;
+    const content = fs9.readFileSync(absolutePath, "utf8");
+    const normalizedContent = content.replace(/\r\n/g, "\n");
+    hash.update(relativePath);
+    hash.update(normalizedContent);
+  }
+  return `sha256-${hash.digest("hex")}`;
+}
 // src/commands/import.ts
+var importPrompts = {
+  select: p3.select,
+  text: p3.text
+};
+function rewriteImports(content, aliasMap) {
+  if (aliasMap.size === 0) return content;
+  let rewritten = content;
+  for (const [oldImport, newImport] of aliasMap.entries()) {
+    const rawOld = oldImport.endsWith("/") ? oldImport.slice(0, -1) : oldImport;
+    const rawNew = newImport.endsWith("/") ? newImport.slice(0, -1) : newImport;
+    const escaped = rawOld.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`${escaped}(?=[\\/'"\`]|$)`, "g");
+    rewritten = rewritten.replace(regex, rawNew);
+  }
+  return rewritten;
+}
+function getModuleBaseDir(projectRoot, modType) {
+  const folder = modType === "shared" ? "shared" : "features";
+  return path2.join(projectRoot, "src", folder);
+}
+function getExistingModuleDir(projectRoot, modType, modName) {
+  const folder = modType === "shared" ? "shared" : "features";
+  const inSrc = path2.join(projectRoot, "src", folder, modName);
+  if (fs9.existsSync(inSrc)) return inSrc;
+  const inRoot = path2.join(projectRoot, folder, modName);
+  if (fs9.existsSync(inRoot)) return inRoot;
+  return null;
+}
+function checkModuleExists(projectRoot, modType, modName) {
+  return getExistingModuleDir(projectRoot, modType, modName) !== null;
+}
+async function resolveDependency(depType, depName, aliasMap, projectRoot, flags, importModuleRecursive, importedModules, registryBase, index) {
+  const folder = depType === "shared" ? "shared" : "features";
+  const isAlreadyImportedThisRun = importedModules.has(`${depType}:${depName}`);
+  if (isAlreadyImportedThisRun) return;
+  const programmaticAlias = flags.alias?.[depName] || flags.alias?.[`${depType}/${depName}`];
+  if (programmaticAlias) {
+    aliasMap.set(`@/${folder}/${depName}/`, `@/${folder}/${programmaticAlias}/`);
+    const baseDir = getModuleBaseDir(projectRoot, depType);
+    const displayDest = path2.relative(
+      projectRoot,
+      path2.join(baseDir, programmaticAlias)
+    );
+    p3.log.step(`Importing '${depName}' into '${displayDest}'...`);
+    await importModuleRecursive(depType, depName, programmaticAlias);
+    return;
+  }
+  const existingDir = getExistingModuleDir(projectRoot, depType, depName);
+  if (!existingDir) {
+    p3.log.info(`  \u21B3 Resolving required ${depType} dependency: ${pc14.cyan(depName)}`);
+    await importModuleRecursive(depType, depName, depName);
+    return;
+  }
+  const entry = (depType === "shared" ? index?.shared : index?.features)?.find(
+    (item) => item.name === depName
+  );
+  let remoteIntegrity = entry?.integrity;
+  if (!remoteIntegrity) {
+    try {
+      const depManifest = await fetchModuleManifest(registryBase, depType, depName);
+      remoteIntegrity = depManifest.integrity;
+    } catch {
+    }
+  }
+  const localHash = computeDirectoryHash(existingDir);
+  if (remoteIntegrity && localHash === remoteIntegrity) {
+    p3.log.step(`\u2713 ${depType}/${depName} is up to date (reusing existing)`);
+    importedModules.add(`${depType}:${depName}`);
+    return;
+  }
+  if (flags.overwrite) {
+    p3.log.step(`Overwriting '${depType}/${depName}' with registry version (--overwrite)...`);
+    const baseDir = getModuleBaseDir(projectRoot, depType);
+    const targetDir = path2.join(baseDir, depName);
+    if (!flags.dryRun) {
+      if (existingDir !== targetDir) {
+        fs9.rmSync(existingDir, { recursive: true, force: true });
+      }
+      fs9.rmSync(targetDir, { recursive: true, force: true });
+    }
+    await importModuleRecursive(depType, depName, depName, { overwrite: true });
+    return;
+  }
+  if (flags.yes) {
+    p3.log.info(`Using existing '${depType}/${depName}'`);
+    importedModules.add(`${depType}:${depName}`);
+    return;
+  }
+  const choice = handleCancel(
+    await importPrompts.select({
+      message: `Local '${depType}/${depName}' differs from the registry version.`,
+      options: [
+        {
+          value: "keep_existing",
+          label: `Keep existing local version (Recommended)`
+        },
+        {
+          value: "rename",
+          label: "Import fresh copy under a new name (alias)"
+        },
+        {
+          value: "overwrite",
+          label: "Overwrite local version with registry version"
+        }
+      ]
+    })
+  );
+  if (choice === "keep_existing" || choice === "use_existing") {
+    p3.log.step(`Skipping '${depType}/${depName}' (keeping existing)`);
+    importedModules.add(`${depType}:${depName}`);
+    return;
+  }
+  if (choice === "rename") {
+    const newName = handleCancel(
+      await importPrompts.text({
+        message: "What should we name the new copy?",
+        placeholder: `${depName}-copy`,
+        validate(val) {
+          const v = val?.trim();
+          if (!v) return "Name cannot be empty";
+          if (v === depName) return `Name must be different from '${depName}'`;
+          if (!/^[a-zA-Z0-9_-]+$/.test(v)) {
+            return "Name can only contain alphanumeric characters, dashes, and underscores";
+          }
+          if (checkModuleExists(projectRoot, depType, v)) {
+            return `'${v}' already exists in ${folder}, please choose another name`;
+          }
+        }
+      })
+    ).trim();
+    aliasMap.set(`@/${folder}/${depName}/`, `@/${folder}/${newName}/`);
+    const baseDir = getModuleBaseDir(projectRoot, depType);
+    const displayDest = path2.relative(projectRoot, path2.join(baseDir, newName));
+    p3.log.step(`Importing '${depName}' into '${displayDest}'...`);
+    await importModuleRecursive(depType, depName, newName);
+    return;
+  }
+  if (choice === "overwrite") {
+    p3.log.step(`Overwriting '${depType}/${depName}' with registry version...`);
+    const baseDir = getModuleBaseDir(projectRoot, depType);
+    const targetDir = path2.join(baseDir, depName);
+    if (!flags.dryRun) {
+      if (existingDir !== targetDir) {
+        fs9.rmSync(existingDir, { recursive: true, force: true });
+      }
+      fs9.rmSync(targetDir, { recursive: true, force: true });
+    }
+    await importModuleRecursive(depType, depName, depName, { overwrite: true });
+    return;
+  }
+}
 async function handleImport(typeArg, nameArg, flags = {}) {
   const projectRoot = findProjectRoot();
   let type = typeArg?.trim().toLowerCase();
   if (type === "features") type = "feature";
   if (!type) {
     type = handleCancel(
-      await p3.select({
+      await importPrompts.select({
         message: "What kind of module would you like to import?",
         options: [
           {
@@ -3290,19 +3751,19 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
   if (type !== "shared" && type !== "feature") {
-    p3.log.error(pc13.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    p3.log.error(pc14.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
     process.exit(1);
   }
   const registryBase = getRegistryBase(projectRoot, flags.registry);
   const s = p3.spinner();
-  s.start(`Connecting to registry at ${pc13.dim(registryBase)}...`);
+  s.start(`Connecting to registry at ${pc14.dim(registryBase)}...`);
   let index;
   try {
     index = await fetchRegistryIndex(registryBase);
     s.stop("Registry index loaded.");
   } catch (err) {
-    s.stop(pc13.red("Failed to load registry index."));
-    p3.log.error(pc13.red(err.message || String(err)));
+    s.stop(pc14.red("Failed to load registry index."));
+    p3.log.error(pc14.red(err.message || String(err)));
     process.exit(1);
   }
   const availableList = type === "shared" ? index.shared : index.features;
@@ -3314,7 +3775,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       return;
     }
     name = handleCancel(
-      await p3.select({
+      await importPrompts.select({
         message: `Select a ${type} to import:`,
         options: availableList.map((item) => ({
           value: item.name,
@@ -3326,71 +3787,94 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   }
   if (!candidateNames.includes(name)) {
     const closest = findClosestMatch(name, candidateNames);
-    p3.log.error(pc13.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    p3.log.error(pc14.red(`\u274C Module '${name}' not found in the ${type} registry.`));
     if (closest) {
-      p3.log.info(pc13.yellow(`Did you mean '${pc13.cyan(closest)}'?`));
+      p3.log.info(pc14.yellow(`Did you mean '${pc14.cyan(closest)}'?`));
     }
     process.exit(1);
   }
   const importedModules = /* @__PURE__ */ new Set();
   const totalWrittenFiles = [];
   const requiredNpmPackages = /* @__PURE__ */ new Set();
-  async function importModuleRecursive(modType, modName) {
-    const modKey = `${modType}:${modName}`;
+  async function importModuleRecursive(modType, registryName, targetName = registryName, options) {
+    const modKey = `${modType}:${targetName}`;
     if (importedModules.has(modKey)) return;
-    p3.log.step(`Importing ${modType}: ${pc13.cyan(modName)}...`);
+    p3.log.step(
+      `Importing ${modType}: ${pc14.cyan(targetName)}${targetName !== registryName ? pc14.dim(` (from ${registryName})`) : ""}...`
+    );
     let manifest;
     try {
-      manifest = await fetchModuleManifest(registryBase, modType, modName);
+      manifest = await fetchModuleManifest(registryBase, modType, registryName);
     } catch (err) {
-      p3.log.error(pc13.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
+      p3.log.error(pc14.red(`Failed to fetch manifest for ${modType} '${registryName}': ${err.message}`));
       process.exit(1);
     }
+    const aliasMap = /* @__PURE__ */ new Map();
+    if (targetName !== registryName) {
+      const folder2 = modType === "shared" ? "shared" : "features";
+      aliasMap.set(`@/${folder2}/${registryName}/`, `@/${folder2}/${targetName}/`);
+    }
     const sharedDeps = manifest.dependencies?.shared || [];
     for (const dep of sharedDeps) {
-      const depPath = path15.join(projectRoot, "src", "shared", dep);
-      if (!fs7.existsSync(depPath) && !importedModules.has(`shared:${dep}`)) {
-        p3.log.info(`  \u21B3 Resolving required shared dependency: ${pc13.cyan(dep)}`);
-        await importModuleRecursive("shared", dep);
-      }
+      await resolveDependency(
+        "shared",
+        dep,
+        aliasMap,
+        projectRoot,
+        flags,
+        importModuleRecursive,
+        importedModules,
+        registryBase,
+        index
+      );
     }
     const featureDeps = manifest.dependencies?.features || [];
     for (const dep of featureDeps) {
-      const depPath = path15.join(projectRoot, "src", "features", dep);
-      if (!fs7.existsSync(depPath) && !importedModules.has(`feature:${dep}`)) {
-        p3.log.info(`  \u21B3 Resolving required feature dependency: ${pc13.cyan(dep)}`);
-        await importModuleRecursive("feature", dep);
-      }
+      await resolveDependency(
+        "feature",
+        dep,
+        aliasMap,
+        projectRoot,
+        flags,
+        importModuleRecursive,
+        importedModules,
+        registryBase,
+        index
+      );
     }
     for (const pkg of manifest.dependencies?.npm || []) {
       requiredNpmPackages.add(pkg);
     }
     const folder = modType === "shared" ? "shared" : "features";
-    const targetDir = path15.join(projectRoot, "src", folder, modName);
+    const targetDir = path2.join(getModuleBaseDir(projectRoot, modType), targetName);
+    const isOverwrite = Boolean(flags.overwrite || options?.overwrite);
     for (const file of manifest.files || []) {
       if (file === "registry.json") continue;
-      const remoteFilePath = `${folder}/${modName}/${file}`;
-      const localFilePath = path15.join(targetDir, file);
-      if (fs7.existsSync(localFilePath) && !flags.overwrite) {
-        p3.log.warn(`  \u21B3 Skipping existing file: ${pc13.dim(path15.relative(projectRoot, localFilePath))} (use --overwrite to replace)`);
+      const remoteFilePath = `${folder}/${registryName}/${file}`;
+      const localFilePath = path2.join(targetDir, file);
+      if (fs9.existsSync(localFilePath) && !isOverwrite) {
+        p3.log.warn(
+          `  \u21B3 Skipping existing file: ${pc14.dim(path2.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
+        );
         continue;
       }
-      const content = await fetchRegistryFile(registryBase, remoteFilePath);
+      let content = await fetchRegistryFile(registryBase, remoteFilePath);
+      content = rewriteImports(content, aliasMap);
       if (!flags.dryRun) {
-        fs7.mkdirSync(path15.dirname(localFilePath), { recursive: true });
-        fs7.writeFileSync(localFilePath, content, "utf-8");
+        fs9.mkdirSync(path2.dirname(localFilePath), { recursive: true });
+        fs9.writeFileSync(localFilePath, content, "utf-8");
       }
-      const displayPath = path15.relative(projectRoot, localFilePath);
+      const displayPath = path2.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
-      p3.log.message(`  ${pc13.green("+")} ${displayPath}`);
+      p3.log.message(`  ${pc14.green("+")} ${displayPath}`);
     }
     importedModules.add(modKey);
   }
-  await importModuleRecursive(type, name);
+  await importModuleRecursive(type, name, name);
   const missingNpm = getMissingNpmPackages(projectRoot, Array.from(requiredNpmPackages));
   if (missingNpm.length > 0) {
     if (flags.skipInstall || flags.dryRun) {
-      p3.log.info(`Required npm dependencies to install: ${pc13.cyan(missingNpm.join(", "))}`);
+      p3.log.info(`Required npm dependencies to install: ${pc14.cyan(missingNpm.join(", "))}`);
     } else {
       try {
         installNpmPackages(projectRoot, missingNpm);
@@ -3400,11 +3884,13 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     }
   }
   if (flags.dryRun) {
-    p3.log.info(pc13.yellow("Dry run complete: No files were written to disk."));
+    p3.log.info(pc14.yellow("Dry run complete: No files were written to disk."));
   } else {
+    const baseDir = getModuleBaseDir(projectRoot, type);
+    const displayTarget = path2.relative(projectRoot, path2.join(baseDir, name));
     p3.log.success(
-      pc13.green(
-        `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in src/${type === "shared" ? "shared" : "features"}/${name})`
+      pc14.green(
+        `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in ${displayTarget})`
       )
     );
   }
@@ -3413,24 +3899,70 @@ async function handleImport(typeArg, nameArg, flags = {}) {
 // src/cli.ts
 function createCli() {
   const cli = cac("mason");
-  cli.command("[...args]", "Interactive scaffolding and import wizard").option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").action(async (args, flags) => {
+  cli.command("[...args]", "Interactive scaffolding and import wizard").option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").option("--registry", "Run in registry mode").action(async (args, flags) => {
     if (args && args.length > 0) {
       p3.log.error(
-        pc13.red(
+        pc14.red(
           `Unknown command: "${args.join(" ")}". Use --help to list available commands.`
         )
       );
       process.exit(1);
     }
     try {
+      const projectRoot = findProjectRoot();
+      const mode = getEffectiveMode(projectRoot, flags);
+      if (mode === "registry") {
+        const choice2 = handleCancel(
+          await p3.select({
+            message: "\u{1F3DB}\uFE0F  Mason (Registry Mode): What would you like to scaffold?",
+            options: [
+              {
+                value: "create_feature",
+                label: "Initialize New Feature",
+                hint: "Scaffold a new feature slice under features/"
+              },
+              {
+                value: "create_shared",
+                label: "Initialize New Shared Module",
+                hint: "Scaffold a new shared utility/port under shared/"
+              },
+              {
+                value: "create_usecase",
+                label: "Create New Use Case",
+                hint: "Add a new use case to an existing feature"
+              },
+              {
+                value: "import",
+                label: "Import from Remote Registry",
+                hint: "Download a module from upstream"
+              }
+            ]
+          })
+        );
+        switch (choice2) {
+          case "create_feature":
+            await handleCreate("feature", void 0, flags);
+            break;
+          case "create_shared":
+            await handleCreate("shared", void 0, flags);
+            break;
+          case "create_usecase":
+            await handleCreate("usecase", void 0, flags);
+            break;
+          case "import":
+            await handleImport(void 0, void 0, flags);
+            break;
+        }
+        return;
+      }
       const choice = handleCancel(
         await p3.select({
           message: "\u{1F9F1} Mason: What would you like to do?",
           options: [
             {
               value: "create",
-              label: "Create local component",
-              hint: "Scaffold a new feature, use case, domain entity, interface, etc."
+              label: "Create component",
+              hint: "Scaffold a new feature, shared module, use case, domain entity, etc."
             },
             {
               value: "import",
@@ -3451,8 +3983,8 @@ function createCli() {
   });
   cli.command(
     "create [type] [name]",
-    "Scaffold local Clean Architecture components (feature, usecase, domain, etc.)"
-  ).option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").option("-f, --feature <feature>", "Target feature name").option("-t, --target <dir>", "Override target directory").option("--express", "Include Express presentation layer (pxExpress)").option("--no-express", "Skip Express presentation layer").option("-i, --interface <interface>", "Interface or abstract class to implement").option("-k, --kind <kind>", "Implementation kind ('stub' or 'concrete')").option("-g, --global", "Place in global infrastructure/ instead of feature").option("-m, --method <method>", "HTTP method (get, post, put, patch, delete)").option("-p, --path <path>", "Route subpath (e.g. /:id)").option("-u, --usecase <usecase>", "Connected use case name").option("--message <message>", "Custom success message").option("--domainNames <names>", "Comma-separated domain entity names").example("mason create").example("mason create feature users").example("mason create usecase PlaceOrder -f orders").example("mason create domain User -f users").example("mason create infrastructure PostgresUserRepository -f users -i IUserRepository").example("mason create interface IUserRepository -f users").example("mason create httpHandler GetUserHttp -f users -m get -p /:id").example("mason create injectable PasswordHasher").action(async (type, name, flags = {}) => {
+    "Scaffold local Clean Architecture components (feature, shared, usecase, domain, etc.)"
+  ).option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").option("-f, --feature <feature>", "Target feature name").option("-t, --target <dir>", "Override target directory").option("--dest <dir>", "Override target directory (alias for --target)").option("--registry", "Scaffold in registry mode (stamps registry.json)").option("--express", "Include Express presentation layer (pxExpress)").option("--no-express", "Skip Express presentation layer").option("-i, --interface <interface>", "Interface or abstract class to implement").option("-k, --kind <kind>", "Implementation kind ('stub' or 'concrete')").option("-g, --global", "Place in global infrastructure/ instead of feature").option("-m, --method <method>", "HTTP method (get, post, put, patch, delete)").option("-p, --path <path>", "Route subpath (e.g. /:id)").option("-u, --usecase <usecase>", "Connected use case name").option("--message <message>", "Custom success message").option("--domainNames <names>", "Comma-separated domain entity names").example("mason create").example("mason create feature users").example("mason create usecase PlaceOrder -f orders").example("mason create domain User -f users").example("mason create infrastructure PostgresUserRepository -f users -i IUserRepository").example("mason create interface IUserRepository -f users").example("mason create httpHandler GetUserHttp -f users -m get -p /:id").example("mason create injectable PasswordHasher").action(async (type, name, flags = {}) => {
     try {
       await handleCreate(type, name, flags);
     } catch (err) {
@@ -3471,6 +4003,7 @@ function createCli() {
   });
   const createSubtypes = [
     "feature",
+    "shared",
     "usecase",
     "domain",
     "infrastructure",
@@ -3491,7 +4024,7 @@ function createCli() {
     });
   }
   cli.help();
-  cli.version("1.0.10");
+  cli.version("1.0.14");
   return cli;
 }
 function handleCliError(err) {
@@ -3499,7 +4032,7 @@ function handleCliError(err) {
     process.exit(0);
   }
   const message = err instanceof Error ? err.message : String(err);
-  p3.log.error(pc13.red(`Error: ${message}`));
+  p3.log.error(pc14.red(`Error: ${message}`));
   process.exit(1);
 }
 async function runCli(argv = process.argv) {