@solid-stack/mason 1.0.11 → 1.0.13

package/dist/index.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
-var fs3 = require('fs');
-var path7 = require('path');
-var p4 = require('@clack/prompts');
-var pc13 = require('picocolors');
+var fs12 = require('fs');
+var path2 = require('path');
+var p15 = require('@clack/prompts');
+var pc15 = require('picocolors');
 var url = require('url');
 var child_process = require('child_process');
+var crypto = require('crypto');
 var Handlebars = require('handlebars');
 var cac = require('cac');
 
@@ -30,10 +31,10 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs3__default = /*#__PURE__*/_interopDefault(fs3);
-var path7__default = /*#__PURE__*/_interopDefault(path7);
-var p4__namespace = /*#__PURE__*/_interopNamespace(p4);
-var pc13__default = /*#__PURE__*/_interopDefault(pc13);
+var fs12__default = /*#__PURE__*/_interopDefault(fs12);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var p15__namespace = /*#__PURE__*/_interopNamespace(p15);
+var pc15__default = /*#__PURE__*/_interopDefault(pc15);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 
 // src/utils/formatting.ts
@@ -104,8 +105,8 @@ function isValidIdentifier(str) {
 }
 function writeFileSafely(absolutePath, content, options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
-  const relPath = path7__default.default.relative(projectRoot, absolutePath).replace(/\\/g, "/");
-  const existedBefore = fs3__default.default.existsSync(absolutePath);
+  const relPath = path2__default.default.relative(projectRoot, absolutePath).replace(/\\/g, "/");
+  const existedBefore = fs12__default.default.existsSync(absolutePath);
   if (options.dryRun) {
     return {
       relativePath: relPath,
@@ -124,11 +125,11 @@ function writeFileSafely(absolutePath, content, options = {}) {
       existedBefore: true
     };
   }
-  const dir = path7__default.default.dirname(absolutePath);
-  if (!fs3__default.default.existsSync(dir)) {
-    fs3__default.default.mkdirSync(dir, { recursive: true });
+  const dir = path2__default.default.dirname(absolutePath);
+  if (!fs12__default.default.existsSync(dir)) {
+    fs12__default.default.mkdirSync(dir, { recursive: true });
   }
-  fs3__default.default.writeFileSync(absolutePath, content, "utf-8");
+  fs12__default.default.writeFileSync(absolutePath, content, "utf-8");
   return {
     relativePath: relPath,
     absolutePath,
@@ -140,41 +141,114 @@ function writeFileSafely(absolutePath, content, options = {}) {
 function printGeneratedFiles(files, isDryRun = false) {
   console.log("");
   if (isDryRun) {
-    p4__namespace.log.warn(pc13__default.default.yellow(pc13__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+    p15__namespace.log.warn(pc15__default.default.yellow(pc15__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
   }
   for (const f of files) {
     if (f.action === "created") {
-      p4__namespace.log.success(`${pc13__default.default.bold(f.relativePath)} ${pc13__default.default.dim("(created)")}`);
+      p15__namespace.log.success(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(created)")}`);
     } else if (f.action === "overwritten") {
-      p4__namespace.log.warn(`${pc13__default.default.bold(f.relativePath)} ${pc13__default.default.dim("(overwritten)")}`);
+      p15__namespace.log.warn(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(overwritten)")}`);
     } else if (f.action === "skipped") {
-      p4__namespace.log.info(`${pc13__default.default.dim(f.relativePath)} ${pc13__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
+      p15__namespace.log.info(`${pc15__default.default.dim(f.relativePath)} ${pc15__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
     } else {
-      p4__namespace.log.info(`${pc13__default.default.bold(f.relativePath)} ${pc13__default.default.dim("(preview)")}`);
+      p15__namespace.log.info(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(preview)")}`);
     }
   }
 }
+function loadMasonConfig(startDir = process.cwd()) {
+  let current = path2__default.default.resolve(startDir);
+  while (true) {
+    const configPath = path2__default.default.join(current, "mason.config.json");
+    if (fs12__default.default.existsSync(configPath)) {
+      try {
+        return JSON.parse(fs12__default.default.readFileSync(configPath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+    const parent = path2__default.default.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 (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "index.json")) && (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "features")) || fs12__default.default.existsSync(path2__default.default.join(projectRoot, "shared"))) && !fs12__default.default.existsSync(path2__default.default.join(projectRoot, "src"))) {
+    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);
+  const config = loadMasonConfig(projectRoot);
+  if (config?.paths?.features) {
+    return path2__default.default.resolve(projectRoot, config.paths.features);
+  }
+  const mode = getEffectiveMode(projectRoot, flags);
+  if (mode === "registry") {
+    return path2__default.default.join(projectRoot, "features");
+  }
+  if (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
+    return path2__default.default.join(projectRoot, "src/features");
+  }
+  return path2__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);
+  const config = loadMasonConfig(projectRoot);
+  if (config?.paths?.shared) {
+    return path2__default.default.resolve(projectRoot, config.paths.shared);
+  }
+  const mode = getEffectiveMode(projectRoot, flags);
+  if (mode === "registry") {
+    return path2__default.default.join(projectRoot, "shared");
+  }
+  if (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
+    return path2__default.default.join(projectRoot, "src/shared");
+  }
+  return path2__default.default.join(projectRoot, "shared");
+}
+
+// src/utils/project.ts
 function findProjectRoot(startDir = process.cwd()) {
-  let current = path7__default.default.resolve(startDir);
+  let current = path2__default.default.resolve(startDir);
   while (true) {
-    if (fs3__default.default.existsSync(path7__default.default.join(current, "package.json"))) {
+    if (fs12__default.default.existsSync(path2__default.default.join(current, "package.json"))) {
       return current;
     }
-    const parent = path7__default.default.dirname(current);
+    const parent = path2__default.default.dirname(current);
     if (parent === current) {
-      return path7__default.default.resolve(startDir);
+      return path2__default.default.resolve(startDir);
     }
     current = parent;
   }
 }
-function resolveFeaturesDir(projectRoot) {
-  return path7__default.default.join(projectRoot, "features");
+function resolveFeaturesDir(projectRoot, flags) {
+  return getConfiguredFeaturesDir(projectRoot, flags);
+}
+function resolveSharedDir(projectRoot, flags) {
+  return getConfiguredSharedDir(projectRoot, flags);
+}
+function listExistingShared(projectRoot) {
+  const sharedDir = resolveSharedDir(projectRoot);
+  if (!fs12__default.default.existsSync(sharedDir)) return [];
+  try {
+    const entries = fs12__default.default.readdirSync(sharedDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
 }
 function listExistingFeatures(projectRoot) {
   const featuresDir = resolveFeaturesDir(projectRoot);
-  if (!fs3__default.default.existsSync(featuresDir)) return [];
+  if (!fs12__default.default.existsSync(featuresDir)) return [];
   try {
-    const entries = fs3__default.default.readdirSync(featuresDir, { withFileTypes: true });
+    const entries = fs12__default.default.readdirSync(featuresDir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -184,14 +258,14 @@ function listDomainInterfaces(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const domainDir = path7__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs3__default.default.existsSync(domainDir)) continue;
+    const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs12__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs3__default.default.readdirSync(domainDir);
+      const files = fs12__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 = path7__default.default.join(domainDir, file);
+          const fullPath = path2__default.default.join(domainDir, file);
           if (/^I[A-Z]/.test(name)) {
             results.push({
               name,
@@ -200,7 +274,7 @@ function listDomainInterfaces(projectRoot, featureName) {
             });
           } else {
             try {
-              const content = fs3__default.default.readFileSync(fullPath, "utf-8");
+              const content = fs12__default.default.readFileSync(fullPath, "utf-8");
               if (/export\s+(?:abstract\s+class|interface)\s+(\w+)/.test(content)) {
                 results.push({
                   name,
@@ -222,17 +296,17 @@ function listDomainEntities(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const domainDir = path7__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs3__default.default.existsSync(domainDir)) continue;
+    const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs12__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs3__default.default.readdirSync(domainDir);
+      const files = fs12__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: path7__default.default.join(domainDir, file),
+              fullPath: path2__default.default.join(domainDir, file),
               feature: feat
             });
           }
@@ -247,16 +321,16 @@ function listUseCases(projectRoot, featureName) {
   const results = [];
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
-    const useCasesDir = path7__default.default.join(resolveFeaturesDir(projectRoot), feat, "useCases");
-    if (!fs3__default.default.existsSync(useCasesDir)) continue;
+    const useCasesDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "useCases");
+    if (!fs12__default.default.existsSync(useCasesDir)) continue;
     try {
-      const files = fs3__default.default.readdirSync(useCasesDir);
+      const files = fs12__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: path7__default.default.join(useCasesDir, file),
+            fullPath: path2__default.default.join(useCasesDir, file),
             feature: feat
           });
         }
@@ -273,23 +347,23 @@ var PromptCancelledError = class extends Error {
   }
 };
 function handleCancel(result) {
-  if (p4__namespace.isCancel(result)) {
-    p4__namespace.cancel("Operation cancelled.");
+  if (p15__namespace.isCancel(result)) {
+    p15__namespace.cancel("Operation cancelled.");
     throw new PromptCancelledError();
   }
   return result;
 }
 function printBanner() {
   console.log("");
-  p4__namespace.intro(pc13__default.default.bgCyan(pc13__default.default.black(" @solid-stack/mason ")));
+  p15__namespace.intro(pc15__default.default.bgCyan(pc15__default.default.black(" @solid-stack/mason ")));
 }
 async function promptProperties(options = {}) {
   const properties = options.defaults ? [...options.defaults] : [];
   if (properties.length > 0) {
-    const summary = properties.map((p15) => `${p15.name}: ${p15.type}${p15.optional ? "?" : ""}`).join(", ");
-    p4__namespace.log.info(pc13__default.default.dim(`Pre-configured fields: ${summary}`));
+    const summary = properties.map((p17) => `${p17.name}: ${p17.type}${p17.optional ? "?" : ""}`).join(", ");
+    p15__namespace.log.info(pc15__default.default.dim(`Pre-configured fields: ${summary}`));
     const addMore = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Would you like to add custom fields/properties?",
         initialValue: false
       })
@@ -298,10 +372,10 @@ async function promptProperties(options = {}) {
       return properties;
     }
   }
-  p4__namespace.log.info(pc13__default.default.cyan("Enter properties (leave name blank when finished):"));
+  p15__namespace.log.info(pc15__default.default.cyan("Enter properties (leave name blank when finished):"));
   while (true) {
     const name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Property name (or press Enter to finish):",
         placeholder: "e.g. title, email, status"
       })
@@ -310,7 +384,7 @@ async function promptProperties(options = {}) {
       break;
     }
     const type = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: `Type for property "${name.trim()}":`,
         options: [
           { value: "string", label: "string" },
@@ -327,7 +401,7 @@ async function promptProperties(options = {}) {
     let finalType = type;
     if (type === "custom") {
       finalType = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: `Enter custom type for "${name.trim()}":`,
           placeholder: "e.g. UserRole, string | null",
           validate: (val) => val && val.trim() ? void 0 : "Type cannot be empty"
@@ -335,7 +409,7 @@ async function promptProperties(options = {}) {
       );
     }
     const optional = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: `Is "${name.trim()}" optional?`,
         initialValue: false
       })
@@ -345,47 +419,112 @@ async function promptProperties(options = {}) {
       type: finalType.trim(),
       optional
     });
-    p4__namespace.log.success(
-      pc13__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
+    p15__namespace.log.success(
+      pc15__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
     );
   }
   return properties;
 }
 var DEFAULT_REGISTRY_BASE = "https://raw.githubusercontent.com/solid-stack-digital/mason-registry/main";
+function normalizeRegistryUrl(urlOrPath, baseDir) {
+  let trimmed = urlOrPath.trim();
+  const gitSshRegex = /^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/;
+  const sshMatch = trimmed.match(gitSshRegex);
+  if (sshMatch && sshMatch[1] && sshMatch[2]) {
+    return `https://raw.githubusercontent.com/${sshMatch[1]}/${sshMatch[2]}/main`;
+  }
+  const githubWebRegex = /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+))?\/?$/;
+  const webMatch = trimmed.match(githubWebRegex);
+  if (webMatch && webMatch[1] && webMatch[2]) {
+    const owner = webMatch[1];
+    const repo = webMatch[2];
+    const branch = webMatch[3] || "main";
+    return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
+  }
+  if (baseDir && (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed === "." || trimmed === "..")) {
+    return path2__default.default.resolve(baseDir, trimmed);
+  }
+  return trimmed;
+}
+function findLocalRegistry(startDir = process.cwd()) {
+  let current = path2__default.default.resolve(startDir);
+  while (true) {
+    const candidate = path2__default.default.join(current, "mason-registry");
+    if (fs12__default.default.existsSync(candidate) && fs12__default.default.existsSync(path2__default.default.join(candidate, "index.json"))) {
+      return candidate;
+    }
+    const parent = path2__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();
   if (override && override.trim()) {
-    return override.trim();
+    return normalizeRegistryUrl(override.trim(), rootDir);
   }
   if (process.env.MASON_REGISTRY_URL && process.env.MASON_REGISTRY_URL.trim()) {
-    return process.env.MASON_REGISTRY_URL.trim();
+    return normalizeRegistryUrl(process.env.MASON_REGISTRY_URL.trim(), rootDir);
   }
-  if (projectRoot) {
-    const configPath = path7__default.default.join(projectRoot, "mason.config.json");
-    if (fs3__default.default.existsSync(configPath)) {
+  const configLocations = [
+    path2__default.default.join(rootDir, "mason.config.json"),
+    path2__default.default.join(process.cwd(), "mason.config.json")
+  ];
+  for (const configPath of configLocations) {
+    if (fs12__default.default.existsSync(configPath)) {
       try {
-        const config = JSON.parse(fs3__default.default.readFileSync(configPath, "utf-8"));
+        const config = JSON.parse(fs12__default.default.readFileSync(configPath, "utf-8"));
         if (config.registry && typeof config.registry === "string") {
-          return config.registry.trim();
+          return normalizeRegistryUrl(config.registry.trim(), path2__default.default.dirname(configPath));
         }
       } catch {
       }
     }
   }
-  if (projectRoot) {
-    const siblingRegistry = path7__default.default.resolve(projectRoot, "../mason-registry");
-    if (fs3__default.default.existsSync(siblingRegistry) && fs3__default.default.existsSync(path7__default.default.join(siblingRegistry, "index.json"))) {
-      return siblingRegistry;
+  const pkgLocations = [
+    path2__default.default.join(rootDir, "package.json"),
+    path2__default.default.join(process.cwd(), "package.json")
+  ];
+  for (const pkgPath of pkgLocations) {
+    if (fs12__default.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs12__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));
+        }
+      } catch {
+      }
     }
   }
+  const localRegistry = findLocalRegistry(rootDir);
+  if (localRegistry) {
+    return localRegistry;
+  }
   return DEFAULT_REGISTRY_BASE;
 }
 async function fetchRegistryFile(registryBase, relPath) {
   const cleanRelPath = relPath.replace(/^\/+/, "");
   if (registryBase.startsWith("http://") || registryBase.startsWith("https://")) {
     const url = `${registryBase.replace(/\/+$/, "")}/${cleanRelPath}`;
-    const res = await fetch(url);
+    const headers = {};
+    const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const res = await fetch(url, { headers });
     if (!res.ok) {
-      throw new Error(`Failed to fetch ${cleanRelPath} from ${url} (HTTP ${res.status}: ${res.statusText})`);
+      let extraHint = "";
+      if (res.status === 404) {
+        extraHint = `
+  Possible reasons:
+  \u2022 If using a private GitHub repository, ensure GITHUB_TOKEN is set in your environment.
+  \u2022 If your registry has not yet been pushed to GitHub, point to your local directory:
+    - CLI flag:      mason import ... --registry /path/to/mason-registry
+    - Environment:   export MASON_REGISTRY_URL=/path/to/mason-registry
+    - Config file:   Create mason.config.json with { "registry": "/path/to/mason-registry" }`;
+      }
+      throw new Error(`Failed to fetch ${cleanRelPath} from ${url} (HTTP ${res.status}: ${res.statusText})${extraHint}`);
     }
     return await res.text();
   }
@@ -393,11 +532,11 @@ async function fetchRegistryFile(registryBase, relPath) {
   if (baseDir.startsWith("file://")) {
     baseDir = url.fileURLToPath(baseDir);
   }
-  const filePath = path7__default.default.resolve(baseDir, cleanRelPath);
-  if (!fs3__default.default.existsSync(filePath)) {
+  const filePath = path2__default.default.resolve(baseDir, cleanRelPath);
+  if (!fs12__default.default.existsSync(filePath)) {
     throw new Error(`Registry file not found at ${filePath}`);
   }
-  return fs3__default.default.promises.readFile(filePath, "utf-8");
+  return fs12__default.default.promises.readFile(filePath, "utf-8");
 }
 async function fetchRegistryIndex(registryBase) {
   const content = await fetchRegistryFile(registryBase, "index.json");
@@ -459,26 +598,26 @@ function findClosestMatch(target, candidates) {
   return null;
 }
 function detectPackageManager(projectRoot) {
-  if (fs3__default.default.existsSync(path7__default.default.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs3__default.default.existsSync(path7__default.default.join(projectRoot, "yarn.lock"))) return "yarn";
-  if (fs3__default.default.existsSync(path7__default.default.join(projectRoot, "bun.lockb")) || fs3__default.default.existsSync(path7__default.default.join(projectRoot, "bun.lock"))) return "bun";
+  if (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lockb")) || fs12__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lock"))) return "bun";
   return "npm";
 }
 function getMissingNpmPackages(projectRoot, requiredPackages) {
   if (!requiredPackages || requiredPackages.length === 0) return [];
-  const pkgJsonPath = path7__default.default.join(projectRoot, "package.json");
-  if (!fs3__default.default.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path2__default.default.join(projectRoot, "package.json");
+  if (!fs12__default.default.existsSync(pkgJsonPath)) {
     return requiredPackages;
   }
   try {
-    const pkg = JSON.parse(fs3__default.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs12__default.default.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((p17) => {
+      const nameOnly = p17.startsWith("@") ? `@${p17.slice(1).split("@")[0] || ""}` : p17.split("@")[0] || p17;
       return !installed.has(nameOnly);
     });
   } catch {
@@ -503,12 +642,47 @@ function installNpmPackages(projectRoot, packages, pm) {
       installCmd = `npm install ${packages.join(" ")}`;
       break;
   }
-  p4__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc13__default.default.cyan(packages.join(", "))}`);
+  p15__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc15__default.default.cyan(packages.join(", "))}`);
   child_process.execSync(installCmd, {
     cwd: projectRoot,
     stdio: "inherit"
   });
 }
+function getAllFiles(dir, baseDir = dir) {
+  if (!fs12__default.default.existsSync(dir)) return [];
+  const entries = fs12__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, "/");
+    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 (!fs12__default.default.existsSync(dirPath)) return "";
+  const hash = crypto.createHash("sha256");
+  const fileList = (files ?? getAllFiles(dirPath)).sort();
+  for (const relativePath of fileList) {
+    const absolutePath = path2__default.default.join(dirPath, relativePath);
+    if (!fs12__default.default.existsSync(absolutePath)) continue;
+    const content = fs12__default.default.readFileSync(absolutePath, "utf8");
+    const normalizedContent = content.replace(/\r\n/g, "\n");
+    hash.update(relativePath);
+    hash.update(normalizedContent);
+  }
+  return `sha256-${hash.digest("hex")}`;
+}
 var hbs = Handlebars__default.default.create();
 hbs.registerHelper("eq", (a, b) => a === b);
 hbs.registerHelper("ne", (a, b) => a !== b);
@@ -525,33 +699,33 @@ hbs.registerHelper("join", (arr, sep) => {
 });
 var cachedTemplatesDir = null;
 function getTemplatesDir() {
-  if (cachedTemplatesDir && fs3__default.default.existsSync(cachedTemplatesDir)) {
+  if (cachedTemplatesDir && fs12__default.default.existsSync(cachedTemplatesDir)) {
     return cachedTemplatesDir;
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path7__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
-  const cand1 = path7__default.default.resolve(currentDir, "../../templates");
-  if (fs3__default.default.existsSync(cand1)) {
+  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('index.cjs', document.baseURI).href))));
+  const cand1 = path2__default.default.resolve(currentDir, "../../templates");
+  if (fs12__default.default.existsSync(cand1)) {
     cachedTemplatesDir = cand1;
     return cand1;
   }
-  const cand2 = path7__default.default.resolve(currentDir, "../templates");
-  if (fs3__default.default.existsSync(cand2)) {
+  const cand2 = path2__default.default.resolve(currentDir, "../templates");
+  if (fs12__default.default.existsSync(cand2)) {
     cachedTemplatesDir = cand2;
     return cand2;
   }
-  const cand3 = path7__default.default.resolve(currentDir, "templates");
-  if (fs3__default.default.existsSync(cand3)) {
+  const cand3 = path2__default.default.resolve(currentDir, "templates");
+  if (fs12__default.default.existsSync(cand3)) {
     cachedTemplatesDir = cand3;
     return cand3;
   }
   let curr = currentDir;
   while (true) {
-    const candTemplates = path7__default.default.join(curr, "templates");
-    if (fs3__default.default.existsSync(candTemplates)) {
+    const candTemplates = path2__default.default.join(curr, "templates");
+    if (fs12__default.default.existsSync(candTemplates)) {
       cachedTemplatesDir = candTemplates;
       return candTemplates;
     }
-    const parent = path7__default.default.dirname(curr);
+    const parent = path2__default.default.dirname(curr);
     if (parent === curr) break;
     curr = parent;
   }
@@ -559,8 +733,8 @@ function getTemplatesDir() {
 }
 var templateCache = /* @__PURE__ */ new Map();
 function loadTemplate(relativePath) {
-  const fullPath = path7__default.default.isAbsolute(relativePath) ? relativePath : path7__default.default.join(getTemplatesDir(), relativePath);
-  return fs3__default.default.readFileSync(fullPath, "utf-8");
+  const fullPath = path2__default.default.isAbsolute(relativePath) ? relativePath : path2__default.default.join(getTemplatesDir(), relativePath);
+  return fs12__default.default.readFileSync(fullPath, "utf-8");
 }
 function renderTemplateFile(relativePath, context) {
   let compiled = templateCache.get(relativePath);
@@ -645,8 +819,8 @@ function generateDomainEntityCode(name, kind = "interface", properties = []) {
 function generateDomain(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const entityName = toPascalCase(options.name);
-  const targetDir = options.targetDir || path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
-  const filePath = path7__default.default.join(targetDir, `${entityName}.ts`);
+  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path2__default.default.join(targetDir, `${entityName}.ts`);
   const code = generateDomainEntityCode(
     entityName,
     options.kind || "interface",
@@ -670,7 +844,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((p17) => `${p17.name}: ${p17.type}`).join("; ") : "";
     const returnType = m.returnType ? `Promise<${m.returnType}>` : "Promise<void>";
     return {
       name: m.name,
@@ -695,8 +869,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 || path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
-  const filePath = path7__default.default.join(targetDir, `${ifaceName}.ts`);
+  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path2__default.default.join(targetDir, `${ifaceName}.ts`);
   const code = generateInterfaceCode(
     ifaceName,
     options.kind || "abstractClass",
@@ -931,7 +1105,7 @@ function parseInterfaceMethodsAndImports(content, targetIfaceName) {
   };
 }
 function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
-  if (customPath && fs3__default.default.existsSync(customPath)) {
+  if (customPath && fs12__default.default.existsSync(customPath)) {
     return { filePath: customPath, ifaceName };
   }
   const candidateNames = [
@@ -941,22 +1115,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 = path7__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs3__default.default.existsSync(domainDir)) continue;
+    const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs12__default.default.existsSync(domainDir)) continue;
     for (const cand of candidateNames) {
-      const p1 = path7__default.default.join(domainDir, `${cand}.ts`);
-      if (fs3__default.default.existsSync(p1)) {
+      const p1 = path2__default.default.join(domainDir, `${cand}.ts`);
+      if (fs12__default.default.existsSync(p1)) {
         return { filePath: p1, ifaceName: cand, feature: feat };
       }
     }
   }
   for (const cand of candidateNames) {
-    const p1 = path7__default.default.join(projectRoot, "domain", `${cand}.ts`);
-    if (fs3__default.default.existsSync(p1)) return { filePath: p1, ifaceName: cand };
-    const p22 = path7__default.default.join(projectRoot, "src", "domain", `${cand}.ts`);
-    if (fs3__default.default.existsSync(p22)) return { filePath: p22, ifaceName: cand };
-    const p32 = path7__default.default.join(projectRoot, "interfaces", `${cand}.ts`);
-    if (fs3__default.default.existsSync(p32)) return { filePath: p32, ifaceName: cand };
+    const p1 = path2__default.default.join(projectRoot, "domain", `${cand}.ts`);
+    if (fs12__default.default.existsSync(p1)) return { filePath: p1, ifaceName: cand };
+    const p22 = path2__default.default.join(projectRoot, "src", "domain", `${cand}.ts`);
+    if (fs12__default.default.existsSync(p22)) return { filePath: p22, ifaceName: cand };
+    const p32 = path2__default.default.join(projectRoot, "interfaces", `${cand}.ts`);
+    if (fs12__default.default.existsSync(p32)) return { filePath: p32, ifaceName: cand };
   }
   return null;
 }
@@ -979,7 +1153,7 @@ function loadInterfaceHierarchy(projectRoot, initialIfaceName, featureName, cust
   while (currentFile && !visited.has(currentFile)) {
     visited.add(currentFile);
     try {
-      const content = fs3__default.default.readFileSync(currentFile, "utf-8");
+      const content = fs12__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)) {
@@ -1055,7 +1229,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 ? `${path7__default.default.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+  const entityImportPath = ifaceImportPath ? `${path2__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;
@@ -1104,7 +1278,7 @@ function generateConcreteInfraCode(className, ifaceName, dependencies = [], meth
     if (baseEntity) {
       finalMethods = synthesizeCrudMethods(baseEntity);
       if (!finalDomainImports.some((imp) => imp.name === baseEntity)) {
-        const importPath = ifaceImportPath ? `${path7__default.default.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+        const importPath = ifaceImportPath ? `${path2__default.default.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
         finalDomainImports.push({
           name: baseEntity,
           from: importPath,
@@ -1149,8 +1323,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 ? path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "infrastructure") : path7__default.default.join(projectRoot, "infrastructure"));
-  const filePath = path7__default.default.join(targetDir, `${className}.ts`);
+  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`);
   let code;
   if (options.implementsInterface) {
     const rawIfaceName = options.implementsInterface;
@@ -1164,7 +1338,7 @@ function generateInfrastructure(options) {
     const ifaceFilePath = hierarchy.ifaceFilePath;
     let ifaceImportPath;
     if (ifaceFilePath) {
-      let rel = path7__default.default.relative(targetDir, ifaceFilePath).replace(/\\/g, "/").replace(/\.ts$/, ".js");
+      let rel = path2__default.default.relative(targetDir, ifaceFilePath).replace(/\\/g, "/").replace(/\.ts$/, ".js");
       if (!rel.startsWith(".")) rel = "./" + rel;
       ifaceImportPath = rel;
     } else if (isFeatureScope) {
@@ -1177,8 +1351,8 @@ function generateInfrastructure(options) {
         if (new RegExp(`\\b${item.name}\\b`).test(allSignatures)) {
           let fromPath;
           if (imp.specifier.startsWith(".") && ifaceFilePath) {
-            const absTarget = path7__default.default.resolve(path7__default.default.dirname(ifaceFilePath), imp.specifier);
-            let rel = path7__default.default.relative(targetDir, absTarget).replace(/\\/g, "/");
+            const absTarget = path2__default.default.resolve(path2__default.default.dirname(ifaceFilePath), imp.specifier);
+            let rel = path2__default.default.relative(targetDir, absTarget).replace(/\\/g, "/");
             if (!rel.startsWith(".")) rel = "./" + rel;
             fromPath = rel;
           } else {
@@ -1251,22 +1425,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 p17 of [...inputProps, ...outputProps]) {
+    const rawType = p17.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((p17) => ({
+    name: p17.name,
+    optional: p17.optional,
+    type: p17.optional && !p17.type.includes("undefined") ? `${p17.type} | undefined` : p17.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((p17) => ({
+    name: p17.name,
+    optional: p17.optional,
+    type: p17.optional && !p17.type.includes("undefined") ? `${p17.type} | undefined` : p17.type
   }));
   const formattedDeps = dependencies.map((dep) => ({
     key: toCamelCase(dep),
@@ -1365,8 +1539,8 @@ function generateUseCase(options) {
   const files = [];
   const projectRoot = options.projectRoot || findProjectRoot();
   const ucName = toPascalCase(options.name);
-  const targetDir = options.targetDir || path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "useCases");
-  const filePath = path7__default.default.join(targetDir, `${ucName}.ts`);
+  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "useCases");
+  const filePath = path2__default.default.join(targetDir, `${ucName}.ts`);
   const code = generateUseCaseCode(
     ucName,
     options.dependencies || [],
@@ -1382,7 +1556,7 @@ function generateUseCase(options) {
     })
   );
   if (options.includeTest) {
-    const testPath = path7__default.default.join(targetDir, `${ucName}.test.ts`);
+    const testPath = path2__default.default.join(targetDir, `${ucName}.test.ts`);
     const testCode = generateUseCaseTestCode(ucName, options.dependencies || []);
     files.push(
       writeFileSafely(testPath, testCode, {
@@ -1450,10 +1624,10 @@ function generateHttpHandler(options) {
   const files = [];
   const projectRoot = options.projectRoot || findProjectRoot();
   const className = toPascalCase(options.name);
-  const pxDir = path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress");
-  const handlersDir = path7__default.default.join(pxDir, "handlers");
-  const pxIndexPath = path7__default.default.join(pxDir, "index.ts");
-  if (!fs3__default.default.existsSync(pxIndexPath)) {
+  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 (!fs12__default.default.existsSync(pxIndexPath)) {
     const featurePath = options.routePrefix || `/${options.feature.toLowerCase()}`;
     const pxIndexContent = renderTemplate(expressIndexTemplate, {
       routePath: featurePath
@@ -1466,7 +1640,7 @@ function generateHttpHandler(options) {
       })
     );
   }
-  const handlerFilePath = path7__default.default.join(handlersDir, `${className}.ts`);
+  const handlerFilePath = path2__default.default.join(handlersDir, `${className}.ts`);
   const code = generateHttpHandlerCode(
     className,
     options.method || "get",
@@ -1487,11 +1661,11 @@ function generateHttpHandler(options) {
   return files;
 }
 function updateOrGenerateDiProvider(featureDir, featureName, bindings = [], options = {}) {
-  const providerPath = path7__default.default.join(featureDir, "diProvider.ts");
+  const providerPath = path2__default.default.join(featureDir, "diProvider.ts");
   const pascalFeature = toPascalCase(featureName);
   const providerModuleName = `${pascalFeature}Provider`;
-  if (fs3__default.default.existsSync(providerPath) && !options.overwrite) {
-    let content = fs3__default.default.readFileSync(providerPath, "utf-8");
+  if (fs12__default.default.existsSync(providerPath) && !options.overwrite) {
+    let content = fs12__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`;
@@ -1550,7 +1724,7 @@ function generateFeature(options) {
   const projectRoot = options.projectRoot || findProjectRoot();
   const rawName = options.name.trim();
   const featureName = toCamelCase(rawName);
-  const targetDir = options.targetDir || path7__default.default.join(resolveFeaturesDir(projectRoot), featureName);
+  const targetDir = options.targetDir || path2__default.default.join(resolveFeaturesDir(projectRoot), featureName);
   const routePath = options.routePath || `/${featureName}`;
   const rawEntities = [];
   if (options.entityNames && options.entityNames.length > 0) {
@@ -1571,7 +1745,7 @@ function generateFeature(options) {
       const domainFile = generateDomain({
         name: ent,
         feature: featureName,
-        targetDir: path7__default.default.join(targetDir, "domain"),
+        targetDir: path2__default.default.join(targetDir, "domain"),
         projectRoot,
         dryRun: options.dryRun,
         overwrite: options.overwrite,
@@ -1591,7 +1765,7 @@ function generateFeature(options) {
       const ifaceFile = generateInterface({
         name: ifaceName,
         feature: featureName,
-        targetDir: path7__default.default.join(targetDir, "domain"),
+        targetDir: path2__default.default.join(targetDir, "domain"),
         entityName: ent,
         projectRoot,
         dryRun: options.dryRun,
@@ -1608,7 +1782,7 @@ function generateFeature(options) {
       const stubFile = generateInfrastructure({
         name: stubName,
         feature: featureName,
-        targetDir: path7__default.default.join(targetDir, "infrastructure"),
+        targetDir: path2__default.default.join(targetDir, "infrastructure"),
         kind: "stub",
         implementsInterface: ifaceName,
         entityName: ent,
@@ -1650,7 +1824,7 @@ function generateFeature(options) {
       const ucFiles = generateUseCase({
         name: ucName,
         feature: featureName,
-        targetDir: path7__default.default.join(targetDir, "useCases"),
+        targetDir: path2__default.default.join(targetDir, "useCases"),
         dependencies: options.includeInterface !== false ? [ifaceName] : [],
         inputProperties: [{ name: idParam, type: "string" }],
         outputProperties: [{ name: entVar, type: primaryEntity }],
@@ -1695,7 +1869,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path7__default.default.join(targetDir, "useCases"),
+            targetDir: path2__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: entVar, type: ent }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1728,7 +1902,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path7__default.default.join(targetDir, "useCases"),
+            targetDir: path2__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: idParam, type: "string" }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1761,7 +1935,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path7__default.default.join(targetDir, "useCases"),
+            targetDir: path2__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [
               { name: "page", type: "number", optional: true },
@@ -1805,7 +1979,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path7__default.default.join(targetDir, "useCases"),
+            targetDir: path2__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: entVar, type: ent }],
             outputProperties: [{ name: entVar, type: ent }],
@@ -1838,7 +2012,7 @@ function generateFeature(options) {
           const ucFiles = generateUseCase({
             name: ucName,
             feature: featureName,
-            targetDir: path7__default.default.join(targetDir, "useCases"),
+            targetDir: path2__default.default.join(targetDir, "useCases"),
             dependencies: deps,
             inputProperties: [{ name: idParam, type: "string" }],
             outputProperties: [{ name: "success", type: "boolean" }],
@@ -1875,7 +2049,7 @@ function generateFeature(options) {
       const ucFiles = generateUseCase({
         name: ucName,
         feature: featureName,
-        targetDir: path7__default.default.join(targetDir, "useCases"),
+        targetDir: path2__default.default.join(targetDir, "useCases"),
         dependencies: customUc.dependencies || [],
         inputProperties: customUc.inputProperties || [],
         outputProperties: customUc.outputProperties || [],
@@ -1907,8 +2081,8 @@ function generateFeature(options) {
     }
   }
   if (options.includeExpress !== false) {
-    const pxDir = path7__default.default.join(targetDir, "pxExpress");
-    const pxIndexPath = path7__default.default.join(pxDir, "index.ts");
+    const pxDir = path2__default.default.join(targetDir, "pxExpress");
+    const pxIndexPath = path2__default.default.join(pxDir, "index.ts");
     if (!files.some((f) => f.absolutePath === pxIndexPath)) {
       const pxIndexContent = renderTemplate(expressIndexTemplate, { routePath });
       files.push(
@@ -1934,13 +2108,14 @@ function generateFeature(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";
   }
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "What is the feature name?",
         placeholder: "e.g. users, auth, orders, billing",
         validate: (val) => {
@@ -1951,18 +2126,19 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
     ).trim();
   }
   const normalizedName = toCamelCase(name);
-  const defaultDir = path7__default.default.relative(projectRoot, path7__default.default.join(resolveFeaturesDir(projectRoot), normalizedName));
+  const baseFeaturesDir = resolveFeaturesDir(projectRoot, flags);
+  const defaultDir = path2__default.default.relative(projectRoot, path2__default.default.join(baseFeaturesDir, normalizedName));
   let targetDirRel = defaultDir;
-  if (!flags.yes && !flags.target) {
+  if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Target directory for the feature:",
         initialValue: defaultDir,
         defaultValue: defaultDir
       })
     ).trim();
   }
-  const targetDir = flags.target ? path7__default.default.resolve(projectRoot, flags.target) : path7__default.default.resolve(projectRoot, targetDirRel);
+  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);
   let includeExpress = flags.express !== void 0 ? Boolean(flags.express) : true;
   let routePath = `/${normalizedName}`;
   let includeDomain = true;
@@ -1977,14 +2153,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   const customUseCases = [];
   if (!flags.yes) {
     includeExpress = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Include Express Presentation layer (pxExpress routes & handlers)?",
         initialValue: true
       })
     );
     if (includeExpress) {
       routePath = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Express route prefix:",
           initialValue: `/${normalizedName}`,
           defaultValue: `/${normalizedName}`
@@ -1992,14 +2168,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       ).trim();
     }
     includeDomain = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Include Domain Entity/Entities?",
         initialValue: true
       })
     );
     if (includeDomain) {
       const domainInput = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Domain entity name(s) (comma-separated):",
           initialValue: defaultEntity,
           defaultValue: defaultEntity,
@@ -2018,21 +2194,21 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
     includeInterface = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: `Include Domain Repository interface(s) for ${entityNames.join(", ")}?`,
         initialValue: true
       })
     );
     if (includeInterface) {
       includeInfra = handleCancel(
-        await p4__namespace.confirm({
+        await p15__namespace.confirm({
           message: `Include Infrastructure Stub implementation(s) for ${entityNames.join(", ")}?`,
           initialValue: true
         })
       );
     }
     includeUseCase = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Include Domain Use Cases?",
         initialValue: true
       })
@@ -2046,7 +2222,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         { value: "delete", label: "Delete (Delete<Entity>)", hint: "DELETE /:id" }
       ];
       crudOperations = handleCancel(
-        await p4__namespace.multiselect({
+        await p15__namespace.multiselect({
           message: "Select standard CRUD use cases to generate:",
           options: crudChoices,
           initialValues: ["create", "read", "list", "update", "delete"],
@@ -2054,13 +2230,13 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         })
       );
       includeTests = handleCancel(
-        await p4__namespace.confirm({
+        await p15__namespace.confirm({
           message: "Generate Vitest unit tests for use cases?",
           initialValue: true
         })
       );
       const wantCustom = handleCancel(
-        await p4__namespace.confirm({
+        await p15__namespace.confirm({
           message: "Do you want to add any custom use cases to this feature?",
           initialValue: false
         })
@@ -2070,7 +2246,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         const availableIfaces = entityNames.map((e) => `I${e}Repository`);
         while (addMore) {
           const customName = handleCancel(
-            await p4__namespace.text({
+            await p15__namespace.text({
               message: "Custom Use Case name:",
               placeholder: "e.g. ResetPassword, VerifyEmail, AssignRole",
               validate: (v) => v && v.trim() ? void 0 : "Use Case name cannot be empty"
@@ -2080,7 +2256,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let selectedDeps = [];
           if (availableIfaces.length > 0) {
             selectedDeps = handleCancel(
-              await p4__namespace.multiselect({
+              await p15__namespace.multiselect({
                 message: `Select domain interfaces to inject into ${customUcName}:`,
                 options: availableIfaces.map((i) => ({ value: i, label: i })),
                 required: false
@@ -2089,7 +2265,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customInputProps = [];
           const hasInput = handleCancel(
-            await p4__namespace.confirm({
+            await p15__namespace.confirm({
               message: `Does ${customUcName} accept input arguments?`,
               initialValue: true
             })
@@ -2100,7 +2276,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customOutputProps = [];
           const hasCustomOutput = handleCancel(
-            await p4__namespace.confirm({
+            await p15__namespace.confirm({
               message: `Does ${customUcName} return custom output data?`,
               initialValue: false
             })
@@ -2110,7 +2286,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
               });
           }
           const customIncludeTest = handleCancel(
-            await p4__namespace.confirm({
+            await p15__namespace.confirm({
               message: `Generate Vitest unit test for ${customUcName}?`,
               initialValue: true
             })
@@ -2120,14 +2296,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let customHttpPath = `/${toKebabCase(customUcName)}`;
           if (includeExpress) {
             customCreateHttp = handleCancel(
-              await p4__namespace.confirm({
+              await p15__namespace.confirm({
                 message: `Generate a matching ExpressRoute HTTP handler for ${customUcName}?`,
                 initialValue: true
               })
             );
             if (customCreateHttp) {
               customHttpMethod = handleCancel(
-                await p4__namespace.select({
+                await p15__namespace.select({
                   message: "HTTP method for route:",
                   options: [
                     { value: "post", label: "POST" },
@@ -2140,7 +2316,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
                 })
               );
               customHttpPath = handleCancel(
-                await p4__namespace.text({
+                await p15__namespace.text({
                   message: "Route subpath (relative to feature prefix):",
                   initialValue: `/${toKebabCase(customUcName)}`,
                   defaultValue: `/${toKebabCase(customUcName)}`
@@ -2161,7 +2337,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
             validationFields: customInputProps
           });
           addMore = handleCancel(
-            await p4__namespace.confirm({
+            await p15__namespace.confirm({
               message: "Add another custom use case?",
               initialValue: false
             })
@@ -2170,7 +2346,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       }
     }
     includeDiProvider = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Generate / update feature DI provider (diProvider.ts)?",
         initialValue: true
       })
@@ -2182,8 +2358,8 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
   }
-  const s = p4__namespace.spinner();
-  s.start(`Generating feature '${pc13__default.default.cyan(normalizedName)}'...`);
+  const s = p15__namespace.spinner();
+  s.start(`Generating feature '${pc15__default.default.cyan(normalizedName)}'...`);
   const options = {
     name: normalizedName,
     projectRoot,
@@ -2203,9 +2379,207 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
     includeDiProvider
   };
   const files = generateFeature(options);
+  if (isRegistry) {
+    const registryPath = path2__default.default.join(targetDir, "registry.json");
+    if (!fs12__default.default.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);
-  p4__namespace.outro(pc13__default.default.green(`Feature '${normalizedName}' ready to use!`));
+  p15__namespace.outro(
+    pc15__default.default.green(
+      `\u2713 Feature '${normalizedName}' initialized in ${path2__default.default.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__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";
+
+@MakeInjectable
+export class ${pascalName} {
+  public static deps = { ${camelName}Engine: I${pascalName}Engine };
+  constructor(public readonly deps: DepsType<typeof ${pascalName}.deps>) {}
+}
+`;
+  fileDefs.push({
+    absolutePath: path2__default.default.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__default.default.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__default.default.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__default.default.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__default.default.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__default.default.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 p15__namespace.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__default.default.relative(projectRoot, path2__default.default.join(baseSharedDir, normalizedName));
+  let targetDirRel = defaultDir;
+  if (!flags.yes && !flags.target && !flags.dest) {
+    targetDirRel = handleCancel(
+      await p15__namespace.text({
+        message: "Target directory for the shared module:",
+        initialValue: defaultDir,
+        defaultValue: defaultDir
+      })
+    ).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);
+  let description = flags.description || "";
+  let includeStub = true;
+  if (!flags.yes) {
+    description = handleCancel(
+      await p15__namespace.text({
+        message: "Module description (optional):",
+        placeholder: "e.g. In-memory caching and Redis port abstraction",
+        initialValue: ""
+      })
+    ).trim();
+    includeStub = handleCancel(
+      await p15__namespace.confirm({
+        message: "Include stub implementation in infrastructure/?",
+        initialValue: true
+      })
+    );
+  }
+  const s = p15__namespace.spinner();
+  s.start(`Generating shared module '${pc15__default.default.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));
+  p15__namespace.outro(
+    pc15__default.default.green(
+      `\u2713 Shared module '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
+    )
+  );
 }
 async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2216,14 +2590,14 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p15__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2233,7 +2607,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2244,7 +2618,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let name = useCaseNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Use Case name:",
         placeholder: "e.g. CreateUser, GetUser, CancelOrder",
         validate: (v) => v && v.trim() ? void 0 : "Use Case name cannot be empty"
@@ -2260,7 +2634,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       label: i.name
     }));
     selectedDeps = handleCancel(
-      await p4__namespace.multiselect({
+      await p15__namespace.multiselect({
         message: "Select domain interfaces to inject into use case:",
         options: multiOptions,
         required: false
@@ -2275,7 +2649,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let httpPath = "/";
   if (!flags.yes) {
     const hasInput = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Does this use case accept input arguments?",
         initialValue: true
       })
@@ -2285,7 +2659,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     const hasCustomOutput = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Does this use case return custom output data?",
         initialValue: false
       })
@@ -2295,20 +2669,20 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     includeTest = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Generate Vitest unit test skeleton (.test.ts)?",
         initialValue: true
       })
     );
     createHttp = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Generate a matching ExpressRoute HTTP handler?",
         initialValue: false
       })
     );
     if (createHttp) {
       httpMethod = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "HTTP method for route:",
           options: [
             { value: "post", label: "POST" },
@@ -2321,7 +2695,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         })
       );
       httpPath = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Route subpath (relative to feature prefix):",
           initialValue: "/",
           defaultValue: "/"
@@ -2329,8 +2703,8 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       ).trim();
     }
   }
-  const s = p4__namespace.spinner();
-  s.start(`Generating use case '${pc13__default.default.cyan(ucName)}'...`);
+  const s = p15__namespace.spinner();
+  s.start(`Generating use case '${pc15__default.default.cyan(ucName)}'...`);
   const options = {
     name: ucName,
     feature,
@@ -2362,7 +2736,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   }
   s.stop("Use case generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc13__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
+  p15__namespace.outro(pc15__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
 }
 async function runDomainCommand(domainNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2373,14 +2747,14 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p15__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2390,7 +2764,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2401,7 +2775,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let name = domainNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Domain model / entity name:",
         placeholder: "e.g. User, Order, Product, Address",
         validate: (v) => v && v.trim() ? void 0 : "Domain name cannot be empty"
@@ -2413,7 +2787,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let properties = [];
   if (!flags.yes) {
     kind = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: "Select domain model type:",
         options: [
           { value: "interface", label: "TypeScript Interface (pure data structure)" },
@@ -2432,8 +2806,8 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       defaults: kind === "valueObject" ? [{ name: "value", type: "string" }] : defaultProps
     });
   }
-  const s = p4__namespace.spinner();
-  s.start(`Generating domain model '${pc13__default.default.cyan(entityName)}'...`);
+  const s = p15__namespace.spinner();
+  s.start(`Generating domain model '${pc15__default.default.cyan(entityName)}'...`);
   const options = {
     name: entityName,
     feature,
@@ -2446,7 +2820,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   const file = generateDomain(options);
   s.stop("Domain model generated successfully!");
   printGeneratedFiles([file], options.dryRun);
-  p4__namespace.outro(pc13__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+  p15__namespace.outro(pc15__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
 }
 async function runInfrastructureCommand(classNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2455,7 +2829,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let feature = flags.feature?.trim();
   if (!flags.yes && !flags.global && !flags.feature) {
     scope = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: "Where should this infrastructure implementation be placed?",
         options: [
           { value: "feature", label: "Feature-level (features/<feature>/infrastructure)" },
@@ -2470,14 +2844,14 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p15__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2487,7 +2861,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2500,7 +2874,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Infrastructure class name:",
         placeholder: "e.g. StubUserRepository, PostgresUserRepository, S3FileStorage",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -2519,7 +2893,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
           (i) => className.toLowerCase().includes(removeInterfacePrefix(i.name).toLowerCase())
         );
         const ifaceChoice = handleCancel(
-          await p4__namespace.select({
+          await p15__namespace.select({
             message: "Does this class implement a domain interface or abstract class?",
             options: [
               ...interfaces.map((i) => ({ value: i.name, label: i.name })),
@@ -2531,7 +2905,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         );
         if (ifaceChoice === "__custom__") {
           implementsInterface = handleCancel(
-            await p4__namespace.text({
+            await p15__namespace.text({
               message: "Enter interface or abstract class name:",
               placeholder: "e.g. IUserRepository, BaseStorageAdapter",
               validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2542,14 +2916,14 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         }
       } else {
         const wantImpl = handleCancel(
-          await p4__namespace.confirm({
+          await p15__namespace.confirm({
             message: "Does this class implement a domain interface or abstract class?",
             initialValue: false
           })
         );
         if (wantImpl) {
           implementsInterface = handleCancel(
-            await p4__namespace.text({
+            await p15__namespace.text({
               message: "Enter interface or abstract class name:",
               placeholder: "e.g. IUserRepository, BaseStorageAdapter",
               validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2569,7 +2943,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     const allInterfaces = listDomainInterfaces(projectRoot);
     if (allInterfaces.length > 0) {
       const ifaceChoice = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Does this class implement an interface or abstract class?",
           options: [
             ...allInterfaces.map((i) => ({ value: i.name, label: `${i.name} (${i.feature})` })),
@@ -2581,7 +2955,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       );
       if (ifaceChoice === "__custom__") {
         implementsInterface = handleCancel(
-          await p4__namespace.text({
+          await p15__namespace.text({
             message: "Enter interface or abstract class name:",
             placeholder: "e.g. IAuthRepository",
             validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2594,7 +2968,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   if (!flags.yes && !flags.kind) {
     kind = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: "Select implementation kind:",
         options: [
           { value: "stub", label: "In-Memory Stub (with in-memory store and test helper methods)" },
@@ -2605,7 +2979,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     );
     if (scope === "feature" && feature && implementsInterface) {
       registerInProvider = handleCancel(
-        await p4__namespace.confirm({
+        await p15__namespace.confirm({
           message: "Register this implementation in feature diProvider.ts?",
           initialValue: true
         })
@@ -2614,8 +2988,8 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   } else if (flags.yes && scope === "feature" && feature && implementsInterface) {
     registerInProvider = !flags.noProvider;
   }
-  const s = p4__namespace.spinner();
-  s.start(`Generating infrastructure class '${pc13__default.default.cyan(className)}'...`);
+  const s = p15__namespace.spinner();
+  s.start(`Generating infrastructure class '${pc15__default.default.cyan(className)}'...`);
   const files = [];
   const options = {
     name: className,
@@ -2630,7 +3004,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   const infraFile = generateInfrastructure(options);
   files.push(infraFile);
   if (registerInProvider && scope === "feature" && feature && implementsInterface) {
-    const featureDir = path7__default.default.join(resolveFeaturesDir(projectRoot), feature);
+    const featureDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feature);
     const providerFile = updateOrGenerateDiProvider(
       featureDir,
       feature,
@@ -2650,7 +3024,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   s.stop("Infrastructure class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc13__default.default.green(`Infrastructure class '${className}' created!`));
+  p15__namespace.outro(pc15__default.default.green(`Infrastructure class '${className}' created!`));
 }
 async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2661,14 +3035,14 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p15__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2678,7 +3052,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2689,7 +3063,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   let name = interfaceNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Domain interface name:",
         placeholder: "e.g. IUserRepository, IPaymentService",
         validate: (v) => v && v.trim() ? void 0 : "Interface name cannot be empty"
@@ -2707,7 +3081,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   if (!flags.yes) {
     if (existingEntities.length > 0) {
       const selectedEntity = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Select domain entity associated with this interface:",
           options: [
             ...existingEntities.map((e) => ({ value: e.name, label: e.name })),
@@ -2718,7 +3092,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       );
       if (selectedEntity === "__custom__") {
         entityName = handleCancel(
-          await p4__namespace.text({
+          await p15__namespace.text({
             message: "Enter entity name:",
             defaultValue: removeInterfacePrefix(ifaceName).replace(/Repository$|Service$/, "")
           })
@@ -2728,7 +3102,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     }
     kind = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: "Interface definition style:",
         options: [
           { value: "abstractClass", label: "Abstract Class (Recommended - acts as DI token & type)" },
@@ -2738,7 +3112,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     methodsPreset = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: "Method signature preset:",
         options: [
           { value: "crud", label: "Standard CRUD (GetById, List, Create, Update, Delete)" },
@@ -2748,22 +3122,22 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     generateStub = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Auto-generate Infrastructure Stub implementation?",
         initialValue: true
       })
     );
     if (generateStub) {
       registerInProvider = handleCancel(
-        await p4__namespace.confirm({
+        await p15__namespace.confirm({
           message: "Auto-register interface & stub in feature diProvider.ts?",
           initialValue: true
         })
       );
     }
   }
-  const s = p4__namespace.spinner();
-  s.start(`Generating interface '${pc13__default.default.cyan(ifaceName)}'...`);
+  const s = p15__namespace.spinner();
+  s.start(`Generating interface '${pc15__default.default.cyan(ifaceName)}'...`);
   const files = [];
   const options = {
     name: ifaceName,
@@ -2792,7 +3166,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
     files.push(stubFile);
   }
   if (registerInProvider && generateStub) {
-    const featureDir = path7__default.default.join(resolveFeaturesDir(projectRoot), feature);
+    const featureDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feature);
     const providerFile = updateOrGenerateDiProvider(
       featureDir,
       feature,
@@ -2812,7 +3186,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   }
   s.stop("Interface generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc13__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+  p15__namespace.outro(pc15__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
 }
 async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2823,14 +3197,14 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p15__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2840,7 +3214,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2851,7 +3225,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let name = handlerNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "HTTP Route Handler class name:",
         placeholder: "e.g. CreateUserHttp, GetUserHttp, HealthHttp",
         validate: (v) => v && v.trim() ? void 0 : "Handler name cannot be empty"
@@ -2870,7 +3244,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let validationFields = [];
   if (!flags.yes) {
     method = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: "HTTP Method:",
         options: [
           { value: "get", label: "GET" },
@@ -2884,7 +3258,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     );
     const defaultPath = method === "get" ? "/" : "/";
     subPath = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Route subpath (relative to feature prefix):",
         initialValue: defaultPath,
         defaultValue: defaultPath
@@ -2895,7 +3269,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       const ucOptions = useCases.map((u) => ({ value: u.name, label: u.name }));
       ucOptions.push({ value: "__none__", label: "None / Standalone Handler" });
       const chosenUc = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Connect this handler to a domain Use Case?",
           options: ucOptions,
           initialValue: ucOptions[0]?.value
@@ -2906,7 +3280,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     }
     includeValidation = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: "Include Zod inbound request validation?",
         initialValue: method !== "delete"
       })
@@ -2914,7 +3288,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     if (includeValidation) {
       const defaultSource = method === "get" ? "query" : "body";
       validationSource = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.select({
           message: "Validation data source:",
           options: [
             { value: "body", label: "req.body (for POST / PUT / PATCH payloads)" },
@@ -2928,8 +3302,8 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
         });
     }
   }
-  const s = p4__namespace.spinner();
-  s.start(`Generating HTTP handler '${pc13__default.default.cyan(className)}'...`);
+  const s = p15__namespace.spinner();
+  s.start(`Generating HTTP handler '${pc15__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -2947,7 +3321,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const files = generateHttpHandler(options);
   s.stop("HTTP handler generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc13__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+  p15__namespace.outro(pc15__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
 }
 function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
   const formattedDeps = dependencies.map((dep) => ({
@@ -2957,7 +3331,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((p17) => `${p17.name}: ${p17.type}`).join(", ") : "";
     return {
       name: m.name,
       isAsync,
@@ -2980,21 +3354,21 @@ function generateInjectable(options) {
   const className = toPascalCase(options.name);
   let targetDir = "";
   if (options.customPath) {
-    targetDir = path7__default.default.isAbsolute(options.customPath) ? options.customPath : path7__default.default.join(projectRoot, options.customPath);
+    targetDir = path2__default.default.isAbsolute(options.customPath) ? options.customPath : path2__default.default.join(projectRoot, options.customPath);
   } else if (options.location === "feature-service" && options.feature) {
-    targetDir = path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services");
+    targetDir = path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services");
   } else if (options.location === "feature-transformer" && options.feature) {
-    targetDir = path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress", "transformers");
+    targetDir = path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress", "transformers");
   } else if (options.location === "module") {
-    targetDir = path7__default.default.join(projectRoot, "modules", className);
+    targetDir = path2__default.default.join(projectRoot, "modules", className);
   } else {
-    targetDir = options.feature ? path7__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services") : path7__default.default.join(projectRoot, "shared", className.toLowerCase());
+    targetDir = options.feature ? path2__default.default.join(resolveFeaturesDir(projectRoot), options.feature, "services") : path2__default.default.join(projectRoot, "shared", className.toLowerCase());
   }
-  const filePath = path7__default.default.join(targetDir, `${className}.ts`);
+  const filePath = path2__default.default.join(targetDir, `${className}.ts`);
   let ifaceName;
   if (options.generateInterface) {
     ifaceName = `I${className}`;
-    const ifacePath = path7__default.default.join(targetDir, `${ifaceName}.ts`);
+    const ifacePath = path2__default.default.join(targetDir, `${ifaceName}.ts`);
     const ifaceContent = renderTemplate(injectableInterfaceTemplate, { ifaceName });
     files.push(
       writeFileSafely(ifacePath, ifaceContent, {
@@ -3027,7 +3401,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p15__namespace.text({
         message: "Injectable class name:",
         placeholder: "e.g. PasswordHasher, TokenService, UserTransformer",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -3040,7 +3414,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let customPath;
   if (!flags.yes) {
     location = handleCancel(
-      await p4__namespace.select({
+      await p15__namespace.select({
         message: "Select target architectural location:",
         options: [
           { value: "feature-service", label: "Feature Service (features/<feature>/services/)" },
@@ -3058,14 +3432,14 @@ async function runInjectableCommand(classNameArg, flags = {}) {
           const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
           featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
           const selected = handleCancel(
-            await p4__namespace.select({
+            await p15__namespace.select({
               message: "Select target feature:",
               options: featureOptions
             })
           );
           if (selected === "__custom__") {
             feature = handleCancel(
-              await p4__namespace.text({
+              await p15__namespace.text({
                 message: "Enter feature name:",
                 validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
               })
@@ -3075,7 +3449,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
           }
         } else {
           feature = handleCancel(
-            await p4__namespace.text({
+            await p15__namespace.text({
               message: "Enter target feature name:",
               validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
             })
@@ -3085,7 +3459,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
       feature = toCamelCase(feature);
     } else if (location === "custom") {
       customPath = handleCancel(
-        await p4__namespace.text({
+        await p15__namespace.text({
           message: "Enter destination directory path:",
           placeholder: "e.g. src/services or lib/utils",
           validate: (v) => v && v.trim() ? void 0 : "Path cannot be empty"
@@ -3096,14 +3470,14 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let generateInterface2 = false;
   if (!flags.yes) {
     generateInterface2 = handleCancel(
-      await p4__namespace.confirm({
+      await p15__namespace.confirm({
         message: `Generate abstract class interface (I${className}) as runtime DI token?`,
         initialValue: false
       })
     );
   }
-  const s = p4__namespace.spinner();
-  s.start(`Generating injectable '${pc13__default.default.cyan(className)}'...`);
+  const s = p15__namespace.spinner();
+  s.start(`Generating injectable '${pc15__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3117,12 +3491,12 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   const files = generateInjectable(options);
   s.stop("Injectable class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc13__default.default.green(`Injectable '${className}' created successfully!`));
+  p15__namespace.outro(pc15__default.default.green(`Injectable '${className}' created successfully!`));
 }
 async function runInteractiveMenu(flags = {}) {
   printBanner();
   const choice = handleCancel(
-    await p4__namespace.select({
+    await p15__namespace.select({
       message: "What would you like to create in your architecture?",
       options: [
         {
@@ -3130,6 +3504,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",
@@ -3167,6 +3546,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;
@@ -3199,6 +3581,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;
@@ -3219,21 +3604,172 @@ async function handleCreate(type, name, flags = {}) {
       await runInjectableCommand(name, flags);
       break;
     default:
-      p4__namespace.log.error(
-        pc13__default.default.red(
-          `Unknown component type: "${type}". Allowed types: feature, usecase, domain, infrastructure, interface, httpHandler, injectable.`
+      p15__namespace.log.error(
+        pc15__default.default.red(
+          `Unknown component type: "${type}". Allowed types: feature, shared, usecase, domain, infrastructure, interface, httpHandler, injectable.`
         )
       );
       process.exit(1);
   }
 }
+var importPrompts = {
+  select: p15__namespace.select,
+  text: p15__namespace.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__default.default.join(projectRoot, "src", folder);
+}
+function getExistingModuleDir(projectRoot, modType, modName) {
+  const folder = modType === "shared" ? "shared" : "features";
+  const inSrc = path2__default.default.join(projectRoot, "src", folder, modName);
+  if (fs12__default.default.existsSync(inSrc)) return inSrc;
+  const inRoot = path2__default.default.join(projectRoot, folder, modName);
+  if (fs12__default.default.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__default.default.relative(
+      projectRoot,
+      path2__default.default.join(baseDir, programmaticAlias)
+    );
+    p15__namespace.log.step(`Importing '${depName}' into '${displayDest}'...`);
+    await importModuleRecursive(depType, depName, programmaticAlias);
+    return;
+  }
+  const existingDir = getExistingModuleDir(projectRoot, depType, depName);
+  if (!existingDir) {
+    p15__namespace.log.info(`  \u21B3 Resolving required ${depType} dependency: ${pc15__default.default.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) {
+    p15__namespace.log.step(`\u2713 ${depType}/${depName} is up to date (reusing existing)`);
+    importedModules.add(`${depType}:${depName}`);
+    return;
+  }
+  if (flags.overwrite) {
+    p15__namespace.log.step(`Overwriting '${depType}/${depName}' with registry version (--overwrite)...`);
+    const baseDir = getModuleBaseDir(projectRoot, depType);
+    const targetDir = path2__default.default.join(baseDir, depName);
+    if (!flags.dryRun) {
+      if (existingDir !== targetDir) {
+        fs12__default.default.rmSync(existingDir, { recursive: true, force: true });
+      }
+      fs12__default.default.rmSync(targetDir, { recursive: true, force: true });
+    }
+    await importModuleRecursive(depType, depName, depName, { overwrite: true });
+    return;
+  }
+  if (flags.yes) {
+    p15__namespace.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") {
+    p15__namespace.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__default.default.relative(projectRoot, path2__default.default.join(baseDir, newName));
+    p15__namespace.log.step(`Importing '${depName}' into '${displayDest}'...`);
+    await importModuleRecursive(depType, depName, newName);
+    return;
+  }
+  if (choice === "overwrite") {
+    p15__namespace.log.step(`Overwriting '${depType}/${depName}' with registry version...`);
+    const baseDir = getModuleBaseDir(projectRoot, depType);
+    const targetDir = path2__default.default.join(baseDir, depName);
+    if (!flags.dryRun) {
+      if (existingDir !== targetDir) {
+        fs12__default.default.rmSync(existingDir, { recursive: true, force: true });
+      }
+      fs12__default.default.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 p4__namespace.select({
+      await importPrompts.select({
         message: "What kind of module would you like to import?",
         options: [
           {
@@ -3251,19 +3787,19 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
   if (type !== "shared" && type !== "feature") {
-    p4__namespace.log.error(pc13__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    p15__namespace.log.error(pc15__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
     process.exit(1);
   }
   const registryBase = getRegistryBase(projectRoot, flags.registry);
-  const s = p4__namespace.spinner();
-  s.start(`Connecting to registry at ${pc13__default.default.dim(registryBase)}...`);
+  const s = p15__namespace.spinner();
+  s.start(`Connecting to registry at ${pc15__default.default.dim(registryBase)}...`);
   let index;
   try {
     index = await fetchRegistryIndex(registryBase);
     s.stop("Registry index loaded.");
   } catch (err) {
-    s.stop(pc13__default.default.red("Failed to load registry index."));
-    p4__namespace.log.error(pc13__default.default.red(err.message || String(err)));
+    s.stop(pc15__default.default.red("Failed to load registry index."));
+    p15__namespace.log.error(pc15__default.default.red(err.message || String(err)));
     process.exit(1);
   }
   const availableList = type === "shared" ? index.shared : index.features;
@@ -3271,11 +3807,11 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   let name = nameArg?.trim();
   if (!name) {
     if (availableList.length === 0) {
-      p4__namespace.log.warn(`No ${type} modules available in the registry.`);
+      p15__namespace.log.warn(`No ${type} modules available in the registry.`);
       return;
     }
     name = handleCancel(
-      await p4__namespace.select({
+      await importPrompts.select({
         message: `Select a ${type} to import:`,
         options: availableList.map((item) => ({
           value: item.name,
@@ -3287,122 +3823,769 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   }
   if (!candidateNames.includes(name)) {
     const closest = findClosestMatch(name, candidateNames);
-    p4__namespace.log.error(pc13__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    p15__namespace.log.error(pc15__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
     if (closest) {
-      p4__namespace.log.info(pc13__default.default.yellow(`Did you mean '${pc13__default.default.cyan(closest)}'?`));
+      p15__namespace.log.info(pc15__default.default.yellow(`Did you mean '${pc15__default.default.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;
-    p4__namespace.log.step(`Importing ${modType}: ${pc13__default.default.cyan(modName)}...`);
+    p15__namespace.log.step(
+      `Importing ${modType}: ${pc15__default.default.cyan(targetName)}${targetName !== registryName ? pc15__default.default.dim(` (from ${registryName})`) : ""}...`
+    );
     let manifest;
     try {
-      manifest = await fetchModuleManifest(registryBase, modType, modName);
+      manifest = await fetchModuleManifest(registryBase, modType, registryName);
     } catch (err) {
-      p4__namespace.log.error(pc13__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
+      p15__namespace.log.error(pc15__default.default.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 = path7__default.default.join(projectRoot, "src", "shared", dep);
-      if (!fs3__default.default.existsSync(depPath) && !importedModules.has(`shared:${dep}`)) {
-        p4__namespace.log.info(`  \u21B3 Resolving required shared dependency: ${pc13__default.default.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 = path7__default.default.join(projectRoot, "src", "features", dep);
-      if (!fs3__default.default.existsSync(depPath) && !importedModules.has(`feature:${dep}`)) {
-        p4__namespace.log.info(`  \u21B3 Resolving required feature dependency: ${pc13__default.default.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 = path7__default.default.join(projectRoot, "src", folder, modName);
+    const targetDir = path2__default.default.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 = path7__default.default.join(targetDir, file);
-      if (fs3__default.default.existsSync(localFilePath) && !flags.overwrite) {
-        p4__namespace.log.warn(`  \u21B3 Skipping existing file: ${pc13__default.default.dim(path7__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`);
+      const remoteFilePath = `${folder}/${registryName}/${file}`;
+      const localFilePath = path2__default.default.join(targetDir, file);
+      if (fs12__default.default.existsSync(localFilePath) && !isOverwrite) {
+        p15__namespace.log.warn(
+          `  \u21B3 Skipping existing file: ${pc15__default.default.dim(path2__default.default.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) {
-        fs3__default.default.mkdirSync(path7__default.default.dirname(localFilePath), { recursive: true });
-        fs3__default.default.writeFileSync(localFilePath, content, "utf-8");
+        fs12__default.default.mkdirSync(path2__default.default.dirname(localFilePath), { recursive: true });
+        fs12__default.default.writeFileSync(localFilePath, content, "utf-8");
       }
-      const displayPath = path7__default.default.relative(projectRoot, localFilePath);
+      const displayPath = path2__default.default.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
-      p4__namespace.log.message(`  ${pc13__default.default.green("+")} ${displayPath}`);
+      p15__namespace.log.message(`  ${pc15__default.default.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) {
-      p4__namespace.log.info(`Required npm dependencies to install: ${pc13__default.default.cyan(missingNpm.join(", "))}`);
+      p15__namespace.log.info(`Required npm dependencies to install: ${pc15__default.default.cyan(missingNpm.join(", "))}`);
     } else {
       try {
         installNpmPackages(projectRoot, missingNpm);
       } catch (err) {
-        p4__namespace.log.warn(`Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(" ")}`);
+        p15__namespace.log.warn(`Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(" ")}`);
       }
     }
   }
   if (flags.dryRun) {
-    p4__namespace.log.info(pc13__default.default.yellow("Dry run complete: No files were written to disk."));
+    p15__namespace.log.info(pc15__default.default.yellow("Dry run complete: No files were written to disk."));
   } else {
-    p4__namespace.log.success(
-      pc13__default.default.green(
-        `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in src/${type === "shared" ? "shared" : "features"}/${name})`
+    const baseDir = getModuleBaseDir(projectRoot, type);
+    const displayTarget = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, name));
+    p15__namespace.log.success(
+      pc15__default.default.green(
+        `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in ${displayTarget})`
       )
     );
   }
 }
+function loadMasterIndex(projectRoot) {
+  const indexPath = path2__default.default.join(projectRoot, "index.json");
+  if (!fs12__default.default.existsSync(indexPath)) {
+    const initialIndex = { shared: [], features: [] };
+    fs12__default.default.writeFileSync(indexPath, JSON.stringify(initialIndex, null, 2) + "\n", "utf-8");
+    return initialIndex;
+  }
+  return JSON.parse(fs12__default.default.readFileSync(indexPath, "utf-8"));
+}
+function saveMasterIndex(projectRoot, index) {
+  const indexPath = path2__default.default.join(projectRoot, "index.json");
+  index.shared.sort((a, b) => a.name.localeCompare(b.name));
+  index.features.sort((a, b) => a.name.localeCompare(b.name));
+  fs12__default.default.writeFileSync(indexPath, JSON.stringify(index, null, 2) + "\n", "utf-8");
+}
+function discoverDiskModules(projectRoot) {
+  const results = [];
+  const sharedDir = resolveSharedDir(projectRoot);
+  if (fs12__default.default.existsSync(sharedDir)) {
+    const entries = fs12__default.default.readdirSync(sharedDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        results.push({ name: entry.name, type: "shared", dir: path2__default.default.join(sharedDir, entry.name) });
+      }
+    }
+  }
+  const featuresDir = resolveFeaturesDir(projectRoot);
+  if (fs12__default.default.existsSync(featuresDir)) {
+    const entries = fs12__default.default.readdirSync(featuresDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        results.push({ name: entry.name, type: "feature", dir: path2__default.default.join(featuresDir, entry.name) });
+      }
+    }
+  }
+  return results;
+}
+function checkGitStatusForDir(projectRoot, dirPath) {
+  try {
+    const relPath = path2__default.default.relative(projectRoot, dirPath);
+    const output = child_process.execSync(`git status --porcelain -- "${relPath}"`, {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8"
+    }).trim();
+    if (!output) {
+      return { hasChanges: false, filesCount: 0 };
+    }
+    const lines = output.split("\n").filter((l) => l.trim().length > 0);
+    return { hasChanges: true, filesCount: lines.length };
+  } catch {
+    return { hasChanges: false, filesCount: 0 };
+  }
+}
+function getRegistryDiff(projectRoot) {
+  const index = loadMasterIndex(projectRoot);
+  const diskModules = discoverDiskModules(projectRoot);
+  const diskMap = /* @__PURE__ */ new Map();
+  for (const mod of diskModules) {
+    diskMap.set(`${mod.type}:${mod.name}`, mod);
+  }
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const item of index.shared) {
+    allKeys.add(`shared:${item.name}`);
+  }
+  for (const item of index.features) {
+    allKeys.add(`feature:${item.name}`);
+  }
+  for (const mod of diskModules) {
+    allKeys.add(`${mod.type}:${mod.name}`);
+  }
+  const statuses = [];
+  for (const key of allKeys) {
+    const [typeStr, name] = key.split(":");
+    const type = typeStr;
+    const registeredEntry = (type === "shared" ? index.shared : index.features).find(
+      (e) => e.name === name
+    );
+    const isRegistered = Boolean(registeredEntry);
+    const diskInfo = diskMap.get(key);
+    const existsOnDisk = Boolean(diskInfo && fs12__default.default.existsSync(diskInfo.dir));
+    let hasUncommittedGitChanges = false;
+    let uncommittedFilesCount = 0;
+    let hasIntegrityDrift = false;
+    let localIntegrity;
+    if (existsOnDisk && diskInfo) {
+      const git = checkGitStatusForDir(projectRoot, diskInfo.dir);
+      hasUncommittedGitChanges = git.hasChanges;
+      uncommittedFilesCount = git.filesCount;
+      localIntegrity = computeDirectoryHash(diskInfo.dir);
+      if (isRegistered && registeredEntry?.integrity) {
+        hasIntegrityDrift = localIntegrity !== registeredEntry.integrity;
+      }
+    }
+    statuses.push({
+      name,
+      type,
+      isRegistered,
+      existsOnDisk,
+      hasUncommittedGitChanges,
+      uncommittedFilesCount,
+      hasIntegrityDrift,
+      localIntegrity,
+      registeredIntegrity: registeredEntry?.integrity
+    });
+  }
+  return statuses.sort((a, b) => a.type.localeCompare(b.type) || a.name.localeCompare(b.name));
+}
+async function registerModule(typeArg, nameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const index = loadMasterIndex(projectRoot);
+  let type = typeArg?.trim();
+  if (!type) {
+    type = handleCancel(
+      await p15__namespace.select({
+        message: "Module type to register:",
+        options: [
+          { value: "feature", label: "Feature" },
+          { value: "shared", label: "Shared Module" }
+        ]
+      })
+    );
+  }
+  const diskModules = discoverDiskModules(projectRoot).filter((m) => m.type === type);
+  const registeredNames = new Set((type === "shared" ? index.shared : index.features).map((m) => m.name));
+  const unregistered = diskModules.filter((m) => !registeredNames.has(m.name));
+  let name = nameArg?.trim();
+  if (!name) {
+    if (unregistered.length > 0) {
+      const opts = unregistered.map((m) => ({ value: m.name, label: m.name, hint: "unregistered on disk" }));
+      opts.push({ value: "__custom__", label: "\u270F\uFE0F Enter custom name...", hint: "" });
+      const choice = handleCancel(
+        await p15__namespace.select({
+          message: `Select a ${type} to register:`,
+          options: opts
+        })
+      );
+      if (choice === "__custom__") {
+        name = handleCancel(
+          await p15__namespace.text({
+            message: `Enter ${type} name:`,
+            validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
+          })
+        ).trim();
+      } else {
+        name = choice;
+      }
+    } else {
+      name = handleCancel(
+        await p15__namespace.text({
+          message: `Enter ${type} name to register:`,
+          validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
+        })
+      ).trim();
+    }
+  }
+  const folder = type === "shared" ? resolveSharedDir(projectRoot) : resolveFeaturesDir(projectRoot);
+  const modDir = path2__default.default.join(folder, name);
+  if (!fs12__default.default.existsSync(modDir)) {
+    p15__namespace.log.error(pc15__default.default.red(`Module directory does not exist: ${path2__default.default.relative(projectRoot, modDir)}`));
+    process.exit(1);
+  }
+  const files = getAllFiles(modDir);
+  const integrity = computeDirectoryHash(modDir, files);
+  const manifestPath = path2__default.default.join(modDir, "registry.json");
+  let manifest;
+  if (fs12__default.default.existsSync(manifestPath)) {
+    manifest = JSON.parse(fs12__default.default.readFileSync(manifestPath, "utf-8"));
+  } else {
+    manifest = {
+      name,
+      type,
+      description: `${name} ${type} module`,
+      version: "1.0.0",
+      dependencies: {
+        npm: [],
+        shared: [],
+        features: []
+      },
+      files: []
+    };
+  }
+  manifest.name = name;
+  manifest.type = type;
+  manifest.files = files;
+  manifest.integrity = integrity;
+  fs12__default.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  const targetList = type === "shared" ? index.shared : index.features;
+  const existingIdx = targetList.findIndex((item) => item.name === name);
+  if (existingIdx >= 0) {
+    targetList[existingIdx] = {
+      name,
+      description: manifest.description,
+      version: manifest.version,
+      integrity
+    };
+  } else {
+    targetList.push({
+      name,
+      description: manifest.description,
+      version: manifest.version,
+      integrity
+    });
+  }
+  saveMasterIndex(projectRoot, index);
+  p15__namespace.log.success(
+    pc15__default.default.green(
+      `\u2713 Module '${type}/${name}' registered in index.json (${files.length} files, ${integrity.slice(0, 18)}...)`
+    )
+  );
+}
+async function commitModule(typeArg, nameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  let type = typeArg?.trim();
+  if (!type) {
+    type = handleCancel(
+      await p15__namespace.select({
+        message: "Module type to commit:",
+        options: [
+          { value: "feature", label: "Feature" },
+          { value: "shared", label: "Shared Module" }
+        ]
+      })
+    );
+  }
+  let name = nameArg?.trim();
+  if (!name) {
+    const diskModules = discoverDiskModules(projectRoot).filter((m) => m.type === type);
+    const opts = diskModules.map((m) => {
+      const git = checkGitStatusForDir(projectRoot, m.dir);
+      return {
+        value: m.name,
+        label: m.name,
+        hint: git.hasChanges ? `${git.filesCount} uncommitted files` : "clean working tree"
+      };
+    });
+    name = handleCancel(
+      await p15__namespace.select({
+        message: `Select ${type} to commit:`,
+        options: opts
+      })
+    );
+  }
+  const folder = type === "shared" ? resolveSharedDir(projectRoot) : resolveFeaturesDir(projectRoot);
+  const modDir = path2__default.default.join(folder, name);
+  if (!fs12__default.default.existsSync(modDir)) {
+    p15__namespace.log.error(pc15__default.default.red(`Module directory does not exist: ${path2__default.default.relative(projectRoot, modDir)}`));
+    process.exit(1);
+  }
+  const relModDir = path2__default.default.relative(projectRoot, modDir);
+  const gitStatus = checkGitStatusForDir(projectRoot, modDir);
+  if (!gitStatus.hasChanges) {
+    p15__namespace.log.warn(pc15__default.default.yellow(`No uncommitted git changes found in '${type}/${name}'.`));
+    return;
+  }
+  let message = flags.message?.trim();
+  if (!message) {
+    message = handleCancel(
+      await p15__namespace.text({
+        message: `Commit message for ${type}/${name}:`,
+        placeholder: `e.g. feat(${name}): update use cases and dependencies`,
+        validate: (v) => v && v.trim() ? void 0 : "Commit message cannot be empty"
+      })
+    ).trim();
+  }
+  const s = p15__namespace.spinner();
+  s.start(`Committing '${type}/${name}' to git repository...`);
+  try {
+    child_process.execSync(`git add "${relModDir}"`, { cwd: projectRoot, stdio: ["ignore", "pipe", "pipe"] });
+    child_process.execSync(`git commit -m "${message.replace(/"/g, '\\"')}" -- "${relModDir}"`, {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    s.stop(`Changes for '${type}/${name}' committed to git.`);
+    p15__namespace.log.success(pc15__default.default.green(`\u2713 Committed '${type}/${name}': "${message}"`));
+  } catch (err) {
+    s.stop(pc15__default.default.red("Git commit failed."));
+    p15__namespace.log.error(pc15__default.default.red(err.message || String(err)));
+    process.exit(1);
+  }
+}
+async function registerModuleChanges(typeArg, nameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const index = loadMasterIndex(projectRoot);
+  let type = typeArg?.trim();
+  if (!type) {
+    type = handleCancel(
+      await p15__namespace.select({
+        message: "Module type to update:",
+        options: [
+          { value: "feature", label: "Feature" },
+          { value: "shared", label: "Shared Module" }
+        ]
+      })
+    );
+  }
+  let name = nameArg?.trim();
+  if (!name) {
+    const diskModules = discoverDiskModules(projectRoot).filter((m) => m.type === type);
+    const diffs = getRegistryDiff(projectRoot).filter((d) => d.type === type && d.isRegistered);
+    const opts = diskModules.map((m) => {
+      const d = diffs.find((item) => item.name === m.name);
+      return {
+        value: m.name,
+        label: m.name,
+        hint: d?.hasIntegrityDrift ? "drift detected (needs register)" : "up to date"
+      };
+    });
+    name = handleCancel(
+      await p15__namespace.select({
+        message: `Select ${type} to register changes:`,
+        options: opts
+      })
+    );
+  }
+  const folder = type === "shared" ? resolveSharedDir(projectRoot) : resolveFeaturesDir(projectRoot);
+  const modDir = path2__default.default.join(folder, name);
+  if (!fs12__default.default.existsSync(modDir)) {
+    p15__namespace.log.error(pc15__default.default.red(`Module directory does not exist: ${path2__default.default.relative(projectRoot, modDir)}`));
+    process.exit(1);
+  }
+  const files = getAllFiles(modDir);
+  const integrity = computeDirectoryHash(modDir, files);
+  const manifestPath = path2__default.default.join(modDir, "registry.json");
+  let manifest;
+  if (fs12__default.default.existsSync(manifestPath)) {
+    manifest = JSON.parse(fs12__default.default.readFileSync(manifestPath, "utf-8"));
+  } else {
+    manifest = {
+      name,
+      type,
+      description: `${name} ${type} module`,
+      version: "1.0.0",
+      dependencies: { npm: [], shared: [], features: [] },
+      files: []
+    };
+  }
+  manifest.files = files;
+  manifest.integrity = integrity;
+  if (flags.version) {
+    manifest.version = flags.version;
+  }
+  fs12__default.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  const targetList = type === "shared" ? index.shared : index.features;
+  const existingIdx = targetList.findIndex((item) => item.name === name);
+  if (existingIdx >= 0) {
+    targetList[existingIdx] = {
+      name,
+      description: manifest.description,
+      version: manifest.version,
+      integrity
+    };
+  } else {
+    targetList.push({
+      name,
+      description: manifest.description,
+      version: manifest.version,
+      integrity
+    });
+  }
+  saveMasterIndex(projectRoot, index);
+  p15__namespace.log.success(
+    pc15__default.default.green(`\u2713 Registered changes for '${type}/${name}' (new integrity: ${integrity.slice(0, 18)}...)`)
+  );
+}
+async function unregisterModule(typeArg, nameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const index = loadMasterIndex(projectRoot);
+  let type = typeArg?.trim();
+  if (!type) {
+    type = handleCancel(
+      await p15__namespace.select({
+        message: "Module type to unregister:",
+        options: [
+          { value: "feature", label: "Feature" },
+          { value: "shared", label: "Shared Module" }
+        ]
+      })
+    );
+  }
+  const registeredList = type === "shared" ? index.shared : index.features;
+  if (registeredList.length === 0) {
+    p15__namespace.log.warn(`No registered ${type} modules found in index.json.`);
+    return;
+  }
+  let name = nameArg?.trim();
+  if (!name) {
+    name = handleCancel(
+      await p15__namespace.select({
+        message: `Select ${type} to unregister from index.json:`,
+        options: registeredList.map((item) => ({
+          value: item.name,
+          label: item.name,
+          hint: item.description
+        }))
+      })
+    );
+  }
+  if (type === "shared") {
+    index.shared = index.shared.filter((item) => item.name !== name);
+  } else {
+    index.features = index.features.filter((item) => item.name !== name);
+  }
+  saveMasterIndex(projectRoot, index);
+  p15__namespace.log.success(
+    pc15__default.default.green(
+      `\u2713 Unregistered module '${type}/${name}' from index.json (source code retained on disk in ${type === "shared" ? "shared" : "features"}/${name})`
+    )
+  );
+}
+function diffRegistry(flags = {}) {
+  const projectRoot = findProjectRoot();
+  const diffs = getRegistryDiff(projectRoot);
+  p15__namespace.log.step(pc15__default.default.bold("\u{1F4CB} Mason Registry Diff & Status Summary"));
+  const unregistered = diffs.filter((d) => d.existsOnDisk && !d.isRegistered);
+  const uncommitted = diffs.filter((d) => d.existsOnDisk && d.hasUncommittedGitChanges);
+  const committedDrift = diffs.filter(
+    (d) => d.existsOnDisk && d.isRegistered && !d.hasUncommittedGitChanges && d.hasIntegrityDrift
+  );
+  const upToDate = diffs.filter(
+    (d) => d.existsOnDisk && d.isRegistered && !d.hasUncommittedGitChanges && !d.hasIntegrityDrift
+  );
+  const missing = diffs.filter((d) => !d.existsOnDisk && d.isRegistered);
+  if (unregistered.length > 0) {
+    p15__namespace.log.message(pc15__default.default.yellow(`
+\u{1F4E6} Unregistered Modules (${unregistered.length}):`));
+    for (const mod of unregistered) {
+      p15__namespace.log.message(`  ${pc15__default.default.red("\u25CF")} ${pc15__default.default.bold(`${mod.type}/${mod.name}`)} ${pc15__default.default.dim("(not registered in index.json)")}`);
+    }
+  }
+  if (uncommitted.length > 0) {
+    p15__namespace.log.message(pc15__default.default.yellow(`
+\u{1F4BE} Uncommitted Changes in Git (${uncommitted.length}):`));
+    for (const mod of uncommitted) {
+      p15__namespace.log.message(
+        `  ${pc15__default.default.yellow("\u25B2")} ${pc15__default.default.bold(`${mod.type}/${mod.name}`)} ${pc15__default.default.dim(`(${mod.uncommittedFilesCount} modified/untracked files)`)}`
+      );
+    }
+  }
+  if (committedDrift.length > 0) {
+    p15__namespace.log.message(pc15__default.default.cyan(`
+\u{1F680} Committed But Unregistered Changes (${committedDrift.length}):`));
+    for (const mod of committedDrift) {
+      p15__namespace.log.message(
+        `  ${pc15__default.default.cyan("\u25C6")} ${pc15__default.default.bold(`${mod.type}/${mod.name}`)} ${pc15__default.default.dim(
+          `local: ${mod.localIntegrity?.slice(0, 16)}... != registered: ${mod.registeredIntegrity?.slice(0, 16)}...`
+        )}`
+      );
+    }
+  }
+  if (missing.length > 0) {
+    p15__namespace.log.message(pc15__default.default.red(`
+\u26A0\uFE0F Missing on Disk (${missing.length}):`));
+    for (const mod of missing) {
+      p15__namespace.log.message(`  ${pc15__default.default.red("\u2715")} ${pc15__default.default.bold(`${mod.type}/${mod.name}`)} ${pc15__default.default.dim("(in index.json, but folder missing)")}`);
+    }
+  }
+  if (upToDate.length > 0) {
+    p15__namespace.log.message(pc15__default.default.green(`
+\u2713 Up to Date & Registered (${upToDate.length}):`));
+    for (const mod of upToDate) {
+      p15__namespace.log.message(`  ${pc15__default.default.green("\u2714")} ${mod.type}/${mod.name} ${pc15__default.default.dim(`(${mod.registeredIntegrity?.slice(0, 18)}...)`)}`);
+    }
+  }
+  p15__namespace.log.message("");
+}
+async function handleRegistry(actionArg, typeArg, nameArg, flags = {}) {
+  let action = actionArg?.trim().toLowerCase();
+  if (!action) {
+    action = handleCancel(
+      await p15__namespace.select({
+        message: "\u{1F3DB}\uFE0F  Mason Registry: What would you like to do?",
+        options: [
+          {
+            value: "diff",
+            label: "Inspect Diff & Status",
+            hint: "Summary of unregistered, uncommitted, and drifted modules"
+          },
+          {
+            value: "register",
+            label: "Register Module",
+            hint: "Add an existing module to index.json with integrity checksum"
+          },
+          {
+            value: "commit",
+            label: "Commit Changes",
+            hint: "Commit a module's working changes to git in the background"
+          },
+          {
+            value: "register-changes",
+            label: "Register Changes",
+            hint: "Update index.json & registry.json with latest checksums"
+          },
+          {
+            value: "unregister",
+            label: "Unregister Module",
+            hint: "Remove module from index.json (source code stays on disk)"
+          }
+        ]
+      })
+    );
+  }
+  switch (action) {
+    case "diff":
+    case "status":
+      diffRegistry(flags);
+      break;
+    case "register":
+      await registerModule(typeArg, nameArg, flags);
+      break;
+    case "commit":
+      await commitModule(typeArg, nameArg, flags);
+      break;
+    case "register-changes":
+    case "update":
+      await registerModuleChanges(typeArg, nameArg, flags);
+      break;
+    case "unregister":
+      await unregisterModule(typeArg, nameArg, flags);
+      break;
+    default:
+      p15__namespace.log.error(
+        pc15__default.default.red(
+          `Unknown registry action: "${action}". Valid actions: diff, register, commit, register-changes, unregister.`
+        )
+      );
+      process.exit(1);
+  }
+}
 
 // src/cli.ts
 function createCli() {
   const cli = cac.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) {
-      p4__namespace.log.error(
-        pc13__default.default.red(
+      p15__namespace.log.error(
+        pc15__default.default.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 p15__namespace.select({
+            message: "\u{1F3DB}\uFE0F  Mason Registry Maintainer: What would you like to do?",
+            options: [
+              {
+                value: "diff",
+                label: "Inspect Diff & Status",
+                hint: "Overview of unregistered, uncommitted, or drifted modules"
+              },
+              {
+                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: "register",
+                label: "Register Module",
+                hint: "Add a module to index.json with integrity checksum"
+              },
+              {
+                value: "commit",
+                label: "Commit Module Changes",
+                hint: "Commit working changes in a module to git"
+              },
+              {
+                value: "register_changes",
+                label: "Register Changes",
+                hint: "Recompute checksums and update index.json"
+              },
+              {
+                value: "unregister",
+                label: "Unregister Module",
+                hint: "Remove from index.json but keep source on disk"
+              },
+              {
+                value: "import",
+                label: "Import from Remote Registry",
+                hint: "Download a module from upstream"
+              }
+            ]
+          })
+        );
+        switch (choice2) {
+          case "diff":
+            await handleRegistry("diff", void 0, void 0, flags);
+            break;
+          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 "register":
+            await handleRegistry("register", void 0, void 0, flags);
+            break;
+          case "commit":
+            await handleRegistry("commit", void 0, void 0, flags);
+            break;
+          case "register_changes":
+            await handleRegistry("register-changes", void 0, void 0, flags);
+            break;
+          case "unregister":
+            await handleRegistry("unregister", void 0, void 0, flags);
+            break;
+          case "import":
+            await handleImport(void 0, void 0, flags);
+            break;
+        }
+        return;
+      }
       const choice = handleCancel(
-        await p4__namespace.select({
+        await p15__namespace.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."
+              hint: "Scaffold a new feature, shared module, use case, domain entity, etc."
             },
             {
               value: "import",
               label: "Import from registry",
               hint: "Download and link pre-built shared modules or features from the registry"
+            },
+            {
+              value: "registry",
+              label: "Registry management",
+              hint: "Inspect diff, register modules, or commit module changes"
             }
           ]
         })
       );
       if (choice === "create") {
         await handleCreate(void 0, void 0, flags);
+      } else if (choice === "registry") {
+        await handleRegistry(void 0, void 0, void 0, flags);
       } else {
         await handleImport(void 0, void 0, flags);
       }
@@ -3412,8 +4595,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) {
@@ -3430,8 +4613,28 @@ function createCli() {
       handleCliError(err);
     }
   });
+  cli.command(
+    "registry [action] [type] [name]",
+    "Registry & version management (diff, register, commit, register-changes, unregister)"
+  ).option("-m, --message <message>", "Commit message for 'commit' command").option("-y, --yes", "Accept defaults and skip interactive prompts").example("mason registry diff").example("mason registry register feature authn").example("mason registry commit shared hasher -m 'Add bcrypt engine'").example("mason registry register-changes shared hasher").example("mason registry unregister feature oldFeature").action(
+    async (action, type, name, flags = {}) => {
+      try {
+        await handleRegistry(action, type, name, flags);
+      } catch (err) {
+        handleCliError(err);
+      }
+    }
+  );
+  cli.command("diff", "Inspect registry status and diff (alias for 'mason registry diff')").allowUnknownOptions().action(async (flags = {}) => {
+    try {
+      await handleRegistry("diff", void 0, void 0, flags);
+    } catch (err) {
+      handleCliError(err);
+    }
+  });
   const createSubtypes = [
     "feature",
+    "shared",
     "usecase",
     "domain",
     "infrastructure",
@@ -3452,7 +4655,7 @@ function createCli() {
     });
   }
   cli.help();
-  cli.version("1.0.10");
+  cli.version("1.0.13");
   return cli;
 }
 function handleCliError(err) {
@@ -3460,7 +4663,7 @@ function handleCliError(err) {
     process.exit(0);
   }
   const message = err instanceof Error ? err.message : String(err);
-  p4__namespace.log.error(pc13__default.default.red(`Error: ${message}`));
+  p15__namespace.log.error(pc15__default.default.red(`Error: ${message}`));
   process.exit(1);
 }
 async function runCli(argv = process.argv) {
@@ -3470,6 +4673,7 @@ async function runCli(argv = process.argv) {
 
 exports.DEFAULT_REGISTRY_BASE = DEFAULT_REGISTRY_BASE;
 exports.PromptCancelledError = PromptCancelledError;
+exports.computeDirectoryHash = computeDirectoryHash;
 exports.concreteInfraTemplate = concreteInfraTemplate;
 exports.createCli = createCli;
 exports.detectPackageManager = detectPackageManager;
@@ -3484,6 +4688,7 @@ exports.fetchRegistryFile = fetchRegistryFile;
 exports.fetchRegistryIndex = fetchRegistryIndex;
 exports.findClosestMatch = findClosestMatch;
 exports.findInterfaceFile = findInterfaceFile;
+exports.findLocalRegistry = findLocalRegistry;
 exports.findProjectRoot = findProjectRoot;
 exports.generateConcreteInfraCode = generateConcreteInfraCode;
 exports.generateDomain = generateDomain;
@@ -3496,16 +4701,22 @@ exports.generateInjectable = generateInjectable;
 exports.generateInjectableCode = generateInjectableCode;
 exports.generateInterface = generateInterface;
 exports.generateInterfaceCode = generateInterfaceCode;
+exports.generateShared = generateShared;
 exports.generateStubCode = generateStubCode;
 exports.generateUseCase = generateUseCase;
 exports.generateUseCaseCode = generateUseCaseCode;
 exports.generateUseCaseTestCode = generateUseCaseTestCode;
+exports.getAllFiles = getAllFiles;
+exports.getConfiguredFeaturesDir = getConfiguredFeaturesDir;
+exports.getConfiguredSharedDir = getConfiguredSharedDir;
+exports.getEffectiveMode = getEffectiveMode;
 exports.getMissingNpmPackages = getMissingNpmPackages;
 exports.getRegistryBase = getRegistryBase;
 exports.getTemplatesDir = getTemplatesDir;
 exports.handleCancel = handleCancel;
 exports.handleCreate = handleCreate;
 exports.handleImport = handleImport;
+exports.handleRegistry = handleRegistry;
 exports.hbs = hbs;
 exports.httpHandlerTemplate = httpHandlerTemplate;
 exports.injectableInterfaceTemplate = injectableInterfaceTemplate;
@@ -3517,9 +4728,12 @@ exports.levenshteinDistance = levenshteinDistance;
 exports.listDomainEntities = listDomainEntities;
 exports.listDomainInterfaces = listDomainInterfaces;
 exports.listExistingFeatures = listExistingFeatures;
+exports.listExistingShared = listExistingShared;
 exports.listUseCases = listUseCases;
 exports.loadInterfaceHierarchy = loadInterfaceHierarchy;
+exports.loadMasonConfig = loadMasonConfig;
 exports.loadTemplate = loadTemplate;
+exports.normalizeRegistryUrl = normalizeRegistryUrl;
 exports.parseInterfaceMethodsAndImports = parseInterfaceMethodsAndImports;
 exports.printBanner = printBanner;
 exports.printGeneratedFiles = printGeneratedFiles;
@@ -3528,7 +4742,9 @@ exports.removeInterfacePrefix = removeInterfacePrefix;
 exports.renderTemplate = renderTemplate;
 exports.renderTemplateFile = renderTemplateFile;
 exports.resolveFeaturesDir = resolveFeaturesDir;
+exports.resolveSharedDir = resolveSharedDir;
 exports.runCli = runCli;
+exports.runSharedCommand = runSharedCommand;
 exports.stubInfraTemplate = stubInfraTemplate;
 exports.synthesizeCrudMethods = synthesizeCrudMethods;
 exports.toCamelCase = toCamelCase;