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

@solid-stack/mason 1.0.13 → 1.0.14

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

Files changed (14) hide show

package/dist/bin.cjs +249 -844
package/dist/bin.cjs.map +1 -1
package/dist/bin.js +246 -841
package/dist/bin.js.map +1 -1
package/dist/cli.d.ts.map +1 -1
package/dist/index.cjs +250 -846
package/dist/index.cjs.map +1 -1
package/dist/index.d.ts +0 -1
package/dist/index.d.ts.map +1 -1
package/dist/index.js +248 -843
package/dist/index.js.map +1 -1
package/package.json +1 -1
package/dist/commands/registry.d.ts +0 -64
package/dist/commands/registry.d.ts.map +0 -1

package/dist/bin.cjs CHANGED Viewed

@@ -2,9 +2,9 @@
 'use strict';
 var cac = require('cac');
-var p15 = require('@clack/prompts');
-var pc15 = require('picocolors');
-var fs12 = require('fs');
+var p3 = require('@clack/prompts');
+var pc14 = require('picocolors');
+var fs9 = require('fs');
 var path2 = require('path');
 var url = require('url');
 var Handlebars = require('handlebars');
@@ -32,16 +32,16 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
-var p15__namespace = /*#__PURE__*/_interopNamespace(p15);
-var pc15__default = /*#__PURE__*/_interopDefault(pc15);
-var fs12__default = /*#__PURE__*/_interopDefault(fs12);
+var p3__namespace = /*#__PURE__*/_interopNamespace(p3);
+var pc14__default = /*#__PURE__*/_interopDefault(pc14);
+var fs9__default = /*#__PURE__*/_interopDefault(fs9);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 function writeFileSafely(absolutePath, content, options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
   const relPath = path2__default.default.relative(projectRoot, absolutePath).replace(/\\/g, "/");
-  const existedBefore = fs12__default.default.existsSync(absolutePath);
+  const existedBefore = fs9__default.default.existsSync(absolutePath);
   if (options.dryRun) {
     return {
       relativePath: relPath,
@@ -61,10 +61,10 @@ function writeFileSafely(absolutePath, content, options = {}) {
     };
   }
   const dir = path2__default.default.dirname(absolutePath);
-  if (!fs12__default.default.existsSync(dir)) {
-    fs12__default.default.mkdirSync(dir, { recursive: true });
+  if (!fs9__default.default.existsSync(dir)) {
+    fs9__default.default.mkdirSync(dir, { recursive: true });
   }
-  fs12__default.default.writeFileSync(absolutePath, content, "utf-8");
+  fs9__default.default.writeFileSync(absolutePath, content, "utf-8");
   return {
     relativePath: relPath,
     absolutePath,
@@ -76,17 +76,17 @@ function writeFileSafely(absolutePath, content, options = {}) {
 function printGeneratedFiles(files, isDryRun = false) {
   console.log("");
   if (isDryRun) {
-    p15__namespace.log.warn(pc15__default.default.yellow(pc15__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+    p3__namespace.log.warn(pc14__default.default.yellow(pc14__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
   }
   for (const f of files) {
     if (f.action === "created") {
-      p15__namespace.log.success(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(created)")}`);
+      p3__namespace.log.success(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(created)")}`);
     } else if (f.action === "overwritten") {
-      p15__namespace.log.warn(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(overwritten)")}`);
+      p3__namespace.log.warn(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(overwritten)")}`);
     } else if (f.action === "skipped") {
-      p15__namespace.log.info(`${pc15__default.default.dim(f.relativePath)} ${pc15__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
+      p3__namespace.log.info(`${pc14__default.default.dim(f.relativePath)} ${pc14__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
     } else {
-      p15__namespace.log.info(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(preview)")}`);
+      p3__namespace.log.info(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(preview)")}`);
     }
   }
 }
@@ -158,9 +158,9 @@ 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)) {
+    if (fs9__default.default.existsSync(configPath)) {
       try {
-        return JSON.parse(fs12__default.default.readFileSync(configPath, "utf-8"));
+        return JSON.parse(fs9__default.default.readFileSync(configPath, "utf-8"));
       } catch {
         return null;
       }
@@ -175,7 +175,7 @@ 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"))) {
+  if (fs9__default.default.existsSync(path2__default.default.join(projectRoot, "index.json")) && (fs9__default.default.existsSync(path2__default.default.join(projectRoot, "features")) || fs9__default.default.existsSync(path2__default.default.join(projectRoot, "shared"))) && !fs9__default.default.existsSync(path2__default.default.join(projectRoot, "src"))) {
     return "registry";
   }
   return "app";
@@ -191,7 +191,7 @@ function getConfiguredFeaturesDir(projectRoot, flags) {
   if (mode === "registry") {
     return path2__default.default.join(projectRoot, "features");
   }
-  if (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "src/features"))) {
+  if (fs9__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");
@@ -207,7 +207,7 @@ function getConfiguredSharedDir(projectRoot, flags) {
   if (mode === "registry") {
     return path2__default.default.join(projectRoot, "shared");
   }
-  if (fs12__default.default.existsSync(path2__default.default.join(projectRoot, "src/shared"))) {
+  if (fs9__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");
@@ -217,7 +217,7 @@ function getConfiguredSharedDir(projectRoot, flags) {
 function findProjectRoot(startDir = process.cwd()) {
   let current = path2__default.default.resolve(startDir);
   while (true) {
-    if (fs12__default.default.existsSync(path2__default.default.join(current, "package.json"))) {
+    if (fs9__default.default.existsSync(path2__default.default.join(current, "package.json"))) {
       return current;
     }
     const parent = path2__default.default.dirname(current);
@@ -235,9 +235,9 @@ function resolveSharedDir(projectRoot, flags) {
 }
 function listExistingFeatures(projectRoot) {
   const featuresDir = resolveFeaturesDir(projectRoot);
-  if (!fs12__default.default.existsSync(featuresDir)) return [];
+  if (!fs9__default.default.existsSync(featuresDir)) return [];
   try {
-    const entries = fs12__default.default.readdirSync(featuresDir, { withFileTypes: true });
+    const entries = fs9__default.default.readdirSync(featuresDir, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -248,9 +248,9 @@ function listDomainInterfaces(projectRoot, featureName) {
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs12__default.default.existsSync(domainDir)) continue;
+    if (!fs9__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs12__default.default.readdirSync(domainDir);
+      const files = fs9__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$/, "");
@@ -263,7 +263,7 @@ function listDomainInterfaces(projectRoot, featureName) {
             });
           } else {
             try {
-              const content = fs12__default.default.readFileSync(fullPath, "utf-8");
+              const content = fs9__default.default.readFileSync(fullPath, "utf-8");
               if (/export\s+(?:abstract\s+class|interface)\s+(\w+)/.test(content)) {
                 results.push({
                   name,
@@ -286,9 +286,9 @@ function listDomainEntities(projectRoot, featureName) {
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs12__default.default.existsSync(domainDir)) continue;
+    if (!fs9__default.default.existsSync(domainDir)) continue;
     try {
-      const files = fs12__default.default.readdirSync(domainDir);
+      const files = fs9__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$/, "");
@@ -311,9 +311,9 @@ function listUseCases(projectRoot, featureName) {
   const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const useCasesDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "useCases");
-    if (!fs12__default.default.existsSync(useCasesDir)) continue;
+    if (!fs9__default.default.existsSync(useCasesDir)) continue;
     try {
-      const files = fs12__default.default.readdirSync(useCasesDir);
+      const files = fs9__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$/, "");
@@ -345,29 +345,29 @@ hbs.registerHelper("join", (arr, sep) => {
 });
 var cachedTemplatesDir = null;
 function getTemplatesDir() {
-  if (cachedTemplatesDir && fs12__default.default.existsSync(cachedTemplatesDir)) {
+  if (cachedTemplatesDir && fs9__default.default.existsSync(cachedTemplatesDir)) {
     return cachedTemplatesDir;
   }
   const currentDir = typeof __dirname !== "undefined" ? __dirname : path2__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
   const cand1 = path2__default.default.resolve(currentDir, "../../templates");
-  if (fs12__default.default.existsSync(cand1)) {
+  if (fs9__default.default.existsSync(cand1)) {
     cachedTemplatesDir = cand1;
     return cand1;
   }
   const cand2 = path2__default.default.resolve(currentDir, "../templates");
-  if (fs12__default.default.existsSync(cand2)) {
+  if (fs9__default.default.existsSync(cand2)) {
     cachedTemplatesDir = cand2;
     return cand2;
   }
   const cand3 = path2__default.default.resolve(currentDir, "templates");
-  if (fs12__default.default.existsSync(cand3)) {
+  if (fs9__default.default.existsSync(cand3)) {
     cachedTemplatesDir = cand3;
     return cand3;
   }
   let curr = currentDir;
   while (true) {
     const candTemplates = path2__default.default.join(curr, "templates");
-    if (fs12__default.default.existsSync(candTemplates)) {
+    if (fs9__default.default.existsSync(candTemplates)) {
       cachedTemplatesDir = candTemplates;
       return candTemplates;
     }
@@ -380,7 +380,7 @@ function getTemplatesDir() {
 var templateCache = /* @__PURE__ */ new Map();
 function loadTemplate(relativePath) {
   const fullPath = path2__default.default.isAbsolute(relativePath) ? relativePath : path2__default.default.join(getTemplatesDir(), relativePath);
-  return fs12__default.default.readFileSync(fullPath, "utf-8");
+  return fs9__default.default.readFileSync(fullPath, "utf-8");
 }
 function renderTemplateFile(relativePath, context) {
   let compiled = templateCache.get(relativePath);
@@ -492,7 +492,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((p17) => `${p17.name}: ${p17.type}`).join("; ") : "";
+    const params = m.params && m.params.length > 0 ? m.params.map((p16) => `${p16.name}: ${p16.type}`).join("; ") : "";
     const returnType = m.returnType ? `Promise<${m.returnType}>` : "Promise<void>";
     return {
       name: m.name,
@@ -753,7 +753,7 @@ function parseInterfaceMethodsAndImports(content, targetIfaceName) {
   };
 }
 function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
-  if (customPath && fs12__default.default.existsSync(customPath)) {
+  if (customPath && fs9__default.default.existsSync(customPath)) {
     return { filePath: customPath, ifaceName };
   }
   const candidateNames = [
@@ -764,21 +764,21 @@ function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
   const features = featureName ? [featureName, ...listExistingFeatures(projectRoot).filter((f) => f !== featureName)] : listExistingFeatures(projectRoot);
   for (const feat of features) {
     const domainDir = path2__default.default.join(resolveFeaturesDir(projectRoot), feat, "domain");
-    if (!fs12__default.default.existsSync(domainDir)) continue;
+    if (!fs9__default.default.existsSync(domainDir)) continue;
     for (const cand of candidateNames) {
       const p1 = path2__default.default.join(domainDir, `${cand}.ts`);
-      if (fs12__default.default.existsSync(p1)) {
+      if (fs9__default.default.existsSync(p1)) {
         return { filePath: p1, ifaceName: cand, feature: feat };
       }
     }
   }
   for (const cand of candidateNames) {
     const p1 = path2__default.default.join(projectRoot, "domain", `${cand}.ts`);
-    if (fs12__default.default.existsSync(p1)) return { filePath: p1, ifaceName: cand };
+    if (fs9__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 };
+    if (fs9__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 };
+    if (fs9__default.default.existsSync(p32)) return { filePath: p32, ifaceName: cand };
   }
   return null;
 }
@@ -801,7 +801,7 @@ function loadInterfaceHierarchy(projectRoot, initialIfaceName, featureName, cust
   while (currentFile && !visited.has(currentFile)) {
     visited.add(currentFile);
     try {
-      const content = fs12__default.default.readFileSync(currentFile, "utf-8");
+      const content = fs9__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)) {
@@ -1073,22 +1073,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 p17 of [...inputProps, ...outputProps]) {
-    const rawType = p17.type.trim();
+  for (const p16 of [...inputProps, ...outputProps]) {
+    const rawType = p16.type.trim();
     const baseType = rawType.replace(/\[\]$/, "").trim();
     if (!primitiveTypes.has(baseType) && /^[A-Z][A-Za-z0-9_]*$/.test(baseType) && !dependencies.includes(baseType)) {
       domainTypesToImport.add(baseType);
     }
   }
-  const formattedInputProps = inputProps.map((p17) => ({
-    name: p17.name,
-    optional: p17.optional,
-    type: p17.optional && !p17.type.includes("undefined") ? `${p17.type} | undefined` : p17.type
+  const formattedInputProps = inputProps.map((p16) => ({
+    name: p16.name,
+    optional: p16.optional,
+    type: p16.optional && !p16.type.includes("undefined") ? `${p16.type} | undefined` : p16.type
   }));
-  const formattedOutputProps = outputProps.map((p17) => ({
-    name: p17.name,
-    optional: p17.optional,
-    type: p17.optional && !p17.type.includes("undefined") ? `${p17.type} | undefined` : p17.type
+  const formattedOutputProps = outputProps.map((p16) => ({
+    name: p16.name,
+    optional: p16.optional,
+    type: p16.optional && !p16.type.includes("undefined") ? `${p16.type} | undefined` : p16.type
   }));
   const formattedDeps = dependencies.map((dep) => ({
     key: toCamelCase(dep),
@@ -1275,7 +1275,7 @@ function generateHttpHandler(options) {
   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)) {
+  if (!fs9__default.default.existsSync(pxIndexPath)) {
     const featurePath = options.routePrefix || `/${options.feature.toLowerCase()}`;
     const pxIndexContent = renderTemplate(expressIndexTemplate, {
       routePath: featurePath
@@ -1312,8 +1312,8 @@ function updateOrGenerateDiProvider(featureDir, featureName, bindings = [], opti
   const providerPath = path2__default.default.join(featureDir, "diProvider.ts");
   const pascalFeature = toPascalCase(featureName);
   const providerModuleName = `${pascalFeature}Provider`;
-  if (fs12__default.default.existsSync(providerPath) && !options.overwrite) {
-    let content = fs12__default.default.readFileSync(providerPath, "utf-8");
+  if (fs9__default.default.existsSync(providerPath) && !options.overwrite) {
+    let content = fs9__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`;
@@ -1759,23 +1759,23 @@ var PromptCancelledError = class extends Error {
   }
 };
 function handleCancel(result) {
-  if (p15__namespace.isCancel(result)) {
-    p15__namespace.cancel("Operation cancelled.");
+  if (p3__namespace.isCancel(result)) {
+    p3__namespace.cancel("Operation cancelled.");
     throw new PromptCancelledError();
   }
   return result;
 }
 function printBanner() {
   console.log("");
-  p15__namespace.intro(pc15__default.default.bgCyan(pc15__default.default.black(" @solid-stack/mason ")));
+  p3__namespace.intro(pc14__default.default.bgCyan(pc14__default.default.black(" @solid-stack/mason ")));
 }
 async function promptProperties(options = {}) {
   const properties = options.defaults ? [...options.defaults] : [];
   if (properties.length > 0) {
-    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 summary = properties.map((p16) => `${p16.name}: ${p16.type}${p16.optional ? "?" : ""}`).join(", ");
+    p3__namespace.log.info(pc14__default.default.dim(`Pre-configured fields: ${summary}`));
     const addMore = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Would you like to add custom fields/properties?",
         initialValue: false
       })
@@ -1784,10 +1784,10 @@ async function promptProperties(options = {}) {
       return properties;
     }
   }
-  p15__namespace.log.info(pc15__default.default.cyan("Enter properties (leave name blank when finished):"));
+  p3__namespace.log.info(pc14__default.default.cyan("Enter properties (leave name blank when finished):"));
   while (true) {
     const name = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Property name (or press Enter to finish):",
         placeholder: "e.g. title, email, status"
       })
@@ -1796,7 +1796,7 @@ async function promptProperties(options = {}) {
       break;
     }
     const type = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: `Type for property "${name.trim()}":`,
         options: [
           { value: "string", label: "string" },
@@ -1813,7 +1813,7 @@ async function promptProperties(options = {}) {
     let finalType = type;
     if (type === "custom") {
       finalType = handleCancel(
-        await p15__namespace.text({
+        await p3__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"
@@ -1821,7 +1821,7 @@ async function promptProperties(options = {}) {
       );
     }
     const optional = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: `Is "${name.trim()}" optional?`,
         initialValue: false
       })
@@ -1831,8 +1831,8 @@ async function promptProperties(options = {}) {
       type: finalType.trim(),
       optional
     });
-    p15__namespace.log.success(
-      pc15__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
+    p3__namespace.log.success(
+      pc14__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
     );
   }
   return properties;
@@ -1848,7 +1848,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   }
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "What is the feature name?",
         placeholder: "e.g. users, auth, orders, billing",
         validate: (val) => {
@@ -1864,7 +1864,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Target directory for the feature:",
         initialValue: defaultDir,
         defaultValue: defaultDir
@@ -1886,14 +1886,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   const customUseCases = [];
   if (!flags.yes) {
     includeExpress = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Include Express Presentation layer (pxExpress routes & handlers)?",
         initialValue: true
       })
     );
     if (includeExpress) {
       routePath = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Express route prefix:",
           initialValue: `/${normalizedName}`,
           defaultValue: `/${normalizedName}`
@@ -1901,14 +1901,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       ).trim();
     }
     includeDomain = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Include Domain Entity/Entities?",
         initialValue: true
       })
     );
     if (includeDomain) {
       const domainInput = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Domain entity name(s) (comma-separated):",
           initialValue: defaultEntity,
           defaultValue: defaultEntity,
@@ -1927,21 +1927,21 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
     includeInterface = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: `Include Domain Repository interface(s) for ${entityNames.join(", ")}?`,
         initialValue: true
       })
     );
     if (includeInterface) {
       includeInfra = handleCancel(
-        await p15__namespace.confirm({
+        await p3__namespace.confirm({
           message: `Include Infrastructure Stub implementation(s) for ${entityNames.join(", ")}?`,
           initialValue: true
         })
       );
     }
     includeUseCase = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Include Domain Use Cases?",
         initialValue: true
       })
@@ -1955,7 +1955,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         { value: "delete", label: "Delete (Delete<Entity>)", hint: "DELETE /:id" }
       ];
       crudOperations = handleCancel(
-        await p15__namespace.multiselect({
+        await p3__namespace.multiselect({
           message: "Select standard CRUD use cases to generate:",
           options: crudChoices,
           initialValues: ["create", "read", "list", "update", "delete"],
@@ -1963,13 +1963,13 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         })
       );
       includeTests = handleCancel(
-        await p15__namespace.confirm({
+        await p3__namespace.confirm({
           message: "Generate Vitest unit tests for use cases?",
           initialValue: true
         })
       );
       const wantCustom = handleCancel(
-        await p15__namespace.confirm({
+        await p3__namespace.confirm({
           message: "Do you want to add any custom use cases to this feature?",
           initialValue: false
         })
@@ -1979,7 +1979,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         const availableIfaces = entityNames.map((e) => `I${e}Repository`);
         while (addMore) {
           const customName = handleCancel(
-            await p15__namespace.text({
+            await p3__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"
@@ -1989,7 +1989,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let selectedDeps = [];
           if (availableIfaces.length > 0) {
             selectedDeps = handleCancel(
-              await p15__namespace.multiselect({
+              await p3__namespace.multiselect({
                 message: `Select domain interfaces to inject into ${customUcName}:`,
                 options: availableIfaces.map((i) => ({ value: i, label: i })),
                 required: false
@@ -1998,7 +1998,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customInputProps = [];
           const hasInput = handleCancel(
-            await p15__namespace.confirm({
+            await p3__namespace.confirm({
               message: `Does ${customUcName} accept input arguments?`,
               initialValue: true
             })
@@ -2009,7 +2009,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customOutputProps = [];
           const hasCustomOutput = handleCancel(
-            await p15__namespace.confirm({
+            await p3__namespace.confirm({
               message: `Does ${customUcName} return custom output data?`,
               initialValue: false
             })
@@ -2019,7 +2019,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
               });
           }
           const customIncludeTest = handleCancel(
-            await p15__namespace.confirm({
+            await p3__namespace.confirm({
               message: `Generate Vitest unit test for ${customUcName}?`,
               initialValue: true
             })
@@ -2029,14 +2029,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let customHttpPath = `/${toKebabCase(customUcName)}`;
           if (includeExpress) {
             customCreateHttp = handleCancel(
-              await p15__namespace.confirm({
+              await p3__namespace.confirm({
                 message: `Generate a matching ExpressRoute HTTP handler for ${customUcName}?`,
                 initialValue: true
               })
             );
             if (customCreateHttp) {
               customHttpMethod = handleCancel(
-                await p15__namespace.select({
+                await p3__namespace.select({
                   message: "HTTP method for route:",
                   options: [
                     { value: "post", label: "POST" },
@@ -2049,7 +2049,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
                 })
               );
               customHttpPath = handleCancel(
-                await p15__namespace.text({
+                await p3__namespace.text({
                   message: "Route subpath (relative to feature prefix):",
                   initialValue: `/${toKebabCase(customUcName)}`,
                   defaultValue: `/${toKebabCase(customUcName)}`
@@ -2070,7 +2070,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
             validationFields: customInputProps
           });
           addMore = handleCancel(
-            await p15__namespace.confirm({
+            await p3__namespace.confirm({
               message: "Add another custom use case?",
               initialValue: false
             })
@@ -2079,7 +2079,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       }
     }
     includeDiProvider = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Generate / update feature DI provider (diProvider.ts)?",
         initialValue: true
       })
@@ -2091,8 +2091,8 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating feature '${pc15__default.default.cyan(normalizedName)}'...`);
+  const s = p3__namespace.spinner();
+  s.start(`Generating feature '${pc14__default.default.cyan(normalizedName)}'...`);
   const options = {
     name: normalizedName,
     projectRoot,
@@ -2114,7 +2114,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   const files = generateFeature(options);
   if (isRegistry) {
     const registryPath = path2__default.default.join(targetDir, "registry.json");
-    if (!fs12__default.default.existsSync(registryPath)) {
+    if (!fs9__default.default.existsSync(registryPath)) {
       const manifest = {
         name: toKebabCase(normalizedName),
         type: "feature",
@@ -2138,8 +2138,8 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   }
   s.stop("Feature scaffolded successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(
-    pc15__default.default.green(
+  p3__namespace.outro(
+    pc14__default.default.green(
       `\u2713 Feature '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2253,7 +2253,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   }
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "What is the shared module name?",
         placeholder: "e.g. hasher, time, uuid, cache, logger",
         validate: (val) => {
@@ -2269,7 +2269,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Target directory for the shared module:",
         initialValue: defaultDir,
         defaultValue: defaultDir
@@ -2281,21 +2281,21 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   let includeStub = true;
   if (!flags.yes) {
     description = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Module description (optional):",
         placeholder: "e.g. In-memory caching and Redis port abstraction",
         initialValue: ""
       })
     ).trim();
     includeStub = handleCancel(
-      await p15__namespace.confirm({
+      await p3__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 s = p3__namespace.spinner();
+  s.start(`Generating shared module '${pc14__default.default.cyan(normalizedName)}'...`);
   const files = generateShared({
     name: normalizedName,
     description,
@@ -2308,8 +2308,8 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   });
   s.stop("Shared module generated successfully!");
   printGeneratedFiles(files, Boolean(flags.dryRun));
-  p15__namespace.outro(
-    pc15__default.default.green(
+  p3__namespace.outro(
+    pc14__default.default.green(
       `\u2713 Shared module '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2323,14 +2323,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 p15__namespace.select({
+        await p3__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p3__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2340,7 +2340,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2351,7 +2351,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let name = useCaseNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__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"
@@ -2367,7 +2367,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       label: i.name
     }));
     selectedDeps = handleCancel(
-      await p15__namespace.multiselect({
+      await p3__namespace.multiselect({
         message: "Select domain interfaces to inject into use case:",
         options: multiOptions,
         required: false
@@ -2382,7 +2382,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let httpPath = "/";
   if (!flags.yes) {
     const hasInput = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Does this use case accept input arguments?",
         initialValue: true
       })
@@ -2392,7 +2392,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     const hasCustomOutput = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Does this use case return custom output data?",
         initialValue: false
       })
@@ -2402,20 +2402,20 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     includeTest = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Generate Vitest unit test skeleton (.test.ts)?",
         initialValue: true
       })
     );
     createHttp = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Generate a matching ExpressRoute HTTP handler?",
         initialValue: false
       })
     );
     if (createHttp) {
       httpMethod = handleCancel(
-        await p15__namespace.select({
+        await p3__namespace.select({
           message: "HTTP method for route:",
           options: [
             { value: "post", label: "POST" },
@@ -2428,7 +2428,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         })
       );
       httpPath = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Route subpath (relative to feature prefix):",
           initialValue: "/",
           defaultValue: "/"
@@ -2436,8 +2436,8 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       ).trim();
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating use case '${pc15__default.default.cyan(ucName)}'...`);
+  const s = p3__namespace.spinner();
+  s.start(`Generating use case '${pc14__default.default.cyan(ucName)}'...`);
   const options = {
     name: ucName,
     feature,
@@ -2469,7 +2469,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   }
   s.stop("Use case generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
+  p3__namespace.outro(pc14__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
 }
 async function runDomainCommand(domainNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2480,14 +2480,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 p15__namespace.select({
+        await p3__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p3__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2497,7 +2497,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2508,7 +2508,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let name = domainNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__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"
@@ -2520,7 +2520,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let properties = [];
   if (!flags.yes) {
     kind = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: "Select domain model type:",
         options: [
           { value: "interface", label: "TypeScript Interface (pure data structure)" },
@@ -2539,8 +2539,8 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       defaults: kind === "valueObject" ? [{ name: "value", type: "string" }] : defaultProps
     });
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating domain model '${pc15__default.default.cyan(entityName)}'...`);
+  const s = p3__namespace.spinner();
+  s.start(`Generating domain model '${pc14__default.default.cyan(entityName)}'...`);
   const options = {
     name: entityName,
     feature,
@@ -2553,7 +2553,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   const file = generateDomain(options);
   s.stop("Domain model generated successfully!");
   printGeneratedFiles([file], options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+  p3__namespace.outro(pc14__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
 }
 async function runInfrastructureCommand(classNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2562,7 +2562,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let feature = flags.feature?.trim();
   if (!flags.yes && !flags.global && !flags.feature) {
     scope = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: "Where should this infrastructure implementation be placed?",
         options: [
           { value: "feature", label: "Feature-level (features/<feature>/infrastructure)" },
@@ -2577,14 +2577,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 p15__namespace.select({
+        await p3__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p3__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2594,7 +2594,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2607,7 +2607,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Infrastructure class name:",
         placeholder: "e.g. StubUserRepository, PostgresUserRepository, S3FileStorage",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -2626,7 +2626,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
           (i) => className.toLowerCase().includes(removeInterfacePrefix(i.name).toLowerCase())
         );
         const ifaceChoice = handleCancel(
-          await p15__namespace.select({
+          await p3__namespace.select({
             message: "Does this class implement a domain interface or abstract class?",
             options: [
               ...interfaces.map((i) => ({ value: i.name, label: i.name })),
@@ -2638,7 +2638,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         );
         if (ifaceChoice === "__custom__") {
           implementsInterface = handleCancel(
-            await p15__namespace.text({
+            await p3__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"
@@ -2649,14 +2649,14 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         }
       } else {
         const wantImpl = handleCancel(
-          await p15__namespace.confirm({
+          await p3__namespace.confirm({
             message: "Does this class implement a domain interface or abstract class?",
             initialValue: false
           })
         );
         if (wantImpl) {
           implementsInterface = handleCancel(
-            await p15__namespace.text({
+            await p3__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"
@@ -2676,7 +2676,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     const allInterfaces = listDomainInterfaces(projectRoot);
     if (allInterfaces.length > 0) {
       const ifaceChoice = handleCancel(
-        await p15__namespace.select({
+        await p3__namespace.select({
           message: "Does this class implement an interface or abstract class?",
           options: [
             ...allInterfaces.map((i) => ({ value: i.name, label: `${i.name} (${i.feature})` })),
@@ -2688,7 +2688,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       );
       if (ifaceChoice === "__custom__") {
         implementsInterface = handleCancel(
-          await p15__namespace.text({
+          await p3__namespace.text({
             message: "Enter interface or abstract class name:",
             placeholder: "e.g. IAuthRepository",
             validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2701,7 +2701,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   if (!flags.yes && !flags.kind) {
     kind = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: "Select implementation kind:",
         options: [
           { value: "stub", label: "In-Memory Stub (with in-memory store and test helper methods)" },
@@ -2712,7 +2712,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     );
     if (scope === "feature" && feature && implementsInterface) {
       registerInProvider = handleCancel(
-        await p15__namespace.confirm({
+        await p3__namespace.confirm({
           message: "Register this implementation in feature diProvider.ts?",
           initialValue: true
         })
@@ -2721,8 +2721,8 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   } else if (flags.yes && scope === "feature" && feature && implementsInterface) {
     registerInProvider = !flags.noProvider;
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating infrastructure class '${pc15__default.default.cyan(className)}'...`);
+  const s = p3__namespace.spinner();
+  s.start(`Generating infrastructure class '${pc14__default.default.cyan(className)}'...`);
   const files = [];
   const options = {
     name: className,
@@ -2757,7 +2757,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   s.stop("Infrastructure class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Infrastructure class '${className}' created!`));
+  p3__namespace.outro(pc14__default.default.green(`Infrastructure class '${className}' created!`));
 }
 async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2768,14 +2768,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 p15__namespace.select({
+        await p3__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p3__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2785,7 +2785,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2796,7 +2796,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   let name = interfaceNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Domain interface name:",
         placeholder: "e.g. IUserRepository, IPaymentService",
         validate: (v) => v && v.trim() ? void 0 : "Interface name cannot be empty"
@@ -2814,7 +2814,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   if (!flags.yes) {
     if (existingEntities.length > 0) {
       const selectedEntity = handleCancel(
-        await p15__namespace.select({
+        await p3__namespace.select({
           message: "Select domain entity associated with this interface:",
           options: [
             ...existingEntities.map((e) => ({ value: e.name, label: e.name })),
@@ -2825,7 +2825,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       );
       if (selectedEntity === "__custom__") {
         entityName = handleCancel(
-          await p15__namespace.text({
+          await p3__namespace.text({
             message: "Enter entity name:",
             defaultValue: removeInterfacePrefix(ifaceName).replace(/Repository$|Service$/, "")
           })
@@ -2835,7 +2835,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     }
     kind = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: "Interface definition style:",
         options: [
           { value: "abstractClass", label: "Abstract Class (Recommended - acts as DI token & type)" },
@@ -2845,7 +2845,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     methodsPreset = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: "Method signature preset:",
         options: [
           { value: "crud", label: "Standard CRUD (GetById, List, Create, Update, Delete)" },
@@ -2855,22 +2855,22 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     generateStub = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Auto-generate Infrastructure Stub implementation?",
         initialValue: true
       })
     );
     if (generateStub) {
       registerInProvider = handleCancel(
-        await p15__namespace.confirm({
+        await p3__namespace.confirm({
           message: "Auto-register interface & stub in feature diProvider.ts?",
           initialValue: true
         })
       );
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating interface '${pc15__default.default.cyan(ifaceName)}'...`);
+  const s = p3__namespace.spinner();
+  s.start(`Generating interface '${pc14__default.default.cyan(ifaceName)}'...`);
   const files = [];
   const options = {
     name: ifaceName,
@@ -2919,7 +2919,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   }
   s.stop("Interface generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+  p3__namespace.outro(pc14__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
 }
 async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2930,14 +2930,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 p15__namespace.select({
+        await p3__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p15__namespace.text({
+          await p3__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2947,7 +2947,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p15__namespace.text({
+        await p3__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2958,7 +2958,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let name = handlerNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__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"
@@ -2977,7 +2977,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let validationFields = [];
   if (!flags.yes) {
     method = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: "HTTP Method:",
         options: [
           { value: "get", label: "GET" },
@@ -2991,7 +2991,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     );
     const defaultPath = method === "get" ? "/" : "/";
     subPath = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Route subpath (relative to feature prefix):",
         initialValue: defaultPath,
         defaultValue: defaultPath
@@ -3002,7 +3002,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 p15__namespace.select({
+        await p3__namespace.select({
           message: "Connect this handler to a domain Use Case?",
           options: ucOptions,
           initialValue: ucOptions[0]?.value
@@ -3013,7 +3013,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     }
     includeValidation = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: "Include Zod inbound request validation?",
         initialValue: method !== "delete"
       })
@@ -3021,7 +3021,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     if (includeValidation) {
       const defaultSource = method === "get" ? "query" : "body";
       validationSource = handleCancel(
-        await p15__namespace.select({
+        await p3__namespace.select({
           message: "Validation data source:",
           options: [
             { value: "body", label: "req.body (for POST / PUT / PATCH payloads)" },
@@ -3035,8 +3035,8 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
         });
     }
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating HTTP handler '${pc15__default.default.cyan(className)}'...`);
+  const s = p3__namespace.spinner();
+  s.start(`Generating HTTP handler '${pc14__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3054,7 +3054,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const files = generateHttpHandler(options);
   s.stop("HTTP handler generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+  p3__namespace.outro(pc14__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
 }
 function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
   const formattedDeps = dependencies.map((dep) => ({
@@ -3064,7 +3064,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((p17) => `${p17.name}: ${p17.type}`).join(", ") : "";
+    const params = m.params && m.params.length > 0 ? m.params.map((p16) => `${p16.name}: ${p16.type}`).join(", ") : "";
     return {
       name: m.name,
       isAsync,
@@ -3134,7 +3134,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p15__namespace.text({
+      await p3__namespace.text({
         message: "Injectable class name:",
         placeholder: "e.g. PasswordHasher, TokenService, UserTransformer",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -3147,7 +3147,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let customPath;
   if (!flags.yes) {
     location = handleCancel(
-      await p15__namespace.select({
+      await p3__namespace.select({
         message: "Select target architectural location:",
         options: [
           { value: "feature-service", label: "Feature Service (features/<feature>/services/)" },
@@ -3165,14 +3165,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 p15__namespace.select({
+            await p3__namespace.select({
               message: "Select target feature:",
               options: featureOptions
             })
           );
           if (selected === "__custom__") {
             feature = handleCancel(
-              await p15__namespace.text({
+              await p3__namespace.text({
                 message: "Enter feature name:",
                 validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
               })
@@ -3182,7 +3182,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
           }
         } else {
           feature = handleCancel(
-            await p15__namespace.text({
+            await p3__namespace.text({
               message: "Enter target feature name:",
               validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
             })
@@ -3192,7 +3192,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
       feature = toCamelCase(feature);
     } else if (location === "custom") {
       customPath = handleCancel(
-        await p15__namespace.text({
+        await p3__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"
@@ -3203,14 +3203,14 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let generateInterface2 = false;
   if (!flags.yes) {
     generateInterface2 = handleCancel(
-      await p15__namespace.confirm({
+      await p3__namespace.confirm({
         message: `Generate abstract class interface (I${className}) as runtime DI token?`,
         initialValue: false
       })
     );
   }
-  const s = p15__namespace.spinner();
-  s.start(`Generating injectable '${pc15__default.default.cyan(className)}'...`);
+  const s = p3__namespace.spinner();
+  s.start(`Generating injectable '${pc14__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3224,12 +3224,12 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   const files = generateInjectable(options);
   s.stop("Injectable class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p15__namespace.outro(pc15__default.default.green(`Injectable '${className}' created successfully!`));
+  p3__namespace.outro(pc14__default.default.green(`Injectable '${className}' created successfully!`));
 }
 async function runInteractiveMenu(flags = {}) {
   printBanner();
   const choice = handleCancel(
-    await p15__namespace.select({
+    await p3__namespace.select({
       message: "What would you like to create in your architecture?",
       options: [
         {
@@ -3337,8 +3337,8 @@ async function handleCreate(type, name, flags = {}) {
       await runInjectableCommand(name, flags);
       break;
     default:
-      p15__namespace.log.error(
-        pc15__default.default.red(
+      p3__namespace.log.error(
+        pc14__default.default.red(
           `Unknown component type: "${type}". Allowed types: feature, shared, usecase, domain, infrastructure, interface, httpHandler, injectable.`
         )
       );
@@ -3370,7 +3370,7 @@ 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"))) {
+    if (fs9__default.default.existsSync(candidate) && fs9__default.default.existsSync(path2__default.default.join(candidate, "index.json"))) {
       return candidate;
     }
     const parent = path2__default.default.dirname(current);
@@ -3392,9 +3392,9 @@ function getRegistryBase(projectRoot, override) {
     path2__default.default.join(process.cwd(), "mason.config.json")
   ];
   for (const configPath of configLocations) {
-    if (fs12__default.default.existsSync(configPath)) {
+    if (fs9__default.default.existsSync(configPath)) {
       try {
-        const config = JSON.parse(fs12__default.default.readFileSync(configPath, "utf-8"));
+        const config = JSON.parse(fs9__default.default.readFileSync(configPath, "utf-8"));
         if (config.registry && typeof config.registry === "string") {
           return normalizeRegistryUrl(config.registry.trim(), path2__default.default.dirname(configPath));
         }
@@ -3407,9 +3407,9 @@ function getRegistryBase(projectRoot, override) {
     path2__default.default.join(process.cwd(), "package.json")
   ];
   for (const pkgPath of pkgLocations) {
-    if (fs12__default.default.existsSync(pkgPath)) {
+    if (fs9__default.default.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs12__default.default.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs9__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));
         }
@@ -3453,10 +3453,10 @@ async function fetchRegistryFile(registryBase, relPath) {
     baseDir = url.fileURLToPath(baseDir);
   }
   const filePath = path2__default.default.resolve(baseDir, cleanRelPath);
-  if (!fs12__default.default.existsSync(filePath)) {
+  if (!fs9__default.default.existsSync(filePath)) {
     throw new Error(`Registry file not found at ${filePath}`);
   }
-  return fs12__default.default.promises.readFile(filePath, "utf-8");
+  return fs9__default.default.promises.readFile(filePath, "utf-8");
 }
 async function fetchRegistryIndex(registryBase) {
   const content = await fetchRegistryFile(registryBase, "index.json");
@@ -3518,26 +3518,26 @@ function findClosestMatch(target, candidates) {
   return null;
 }
 function detectPackageManager(projectRoot) {
-  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";
+  if (fs9__default.default.existsSync(path2__default.default.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs9__default.default.existsSync(path2__default.default.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (fs9__default.default.existsSync(path2__default.default.join(projectRoot, "bun.lockb")) || fs9__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 = path2__default.default.join(projectRoot, "package.json");
-  if (!fs12__default.default.existsSync(pkgJsonPath)) {
+  if (!fs9__default.default.existsSync(pkgJsonPath)) {
     return requiredPackages;
   }
   try {
-    const pkg = JSON.parse(fs12__default.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs9__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((p17) => {
-      const nameOnly = p17.startsWith("@") ? `@${p17.slice(1).split("@")[0] || ""}` : p17.split("@")[0] || p17;
+    return requiredPackages.filter((p16) => {
+      const nameOnly = p16.startsWith("@") ? `@${p16.slice(1).split("@")[0] || ""}` : p16.split("@")[0] || p16;
       return !installed.has(nameOnly);
     });
   } catch {
@@ -3562,15 +3562,15 @@ function installNpmPackages(projectRoot, packages, pm) {
       installCmd = `npm install ${packages.join(" ")}`;
       break;
   }
-  p15__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc15__default.default.cyan(packages.join(", "))}`);
+  p3__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc14__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 });
+  if (!fs9__default.default.existsSync(dir)) return [];
+  const entries = fs9__default.default.readdirSync(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const fullPath = path2__default.default.join(dir, entry.name);
@@ -3590,13 +3590,13 @@ function getAllFiles(dir, baseDir = dir) {
   return files.sort();
 }
 function computeDirectoryHash(dirPath, files) {
-  if (!fs12__default.default.existsSync(dirPath)) return "";
+  if (!fs9__default.default.existsSync(dirPath)) return "";
   const hash = crypto.createHash("sha256");
-  const fileList = (files ?? getAllFiles(dirPath)).sort();
+  const fileList = (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");
+    if (!fs9__default.default.existsSync(absolutePath)) continue;
+    const content = fs9__default.default.readFileSync(absolutePath, "utf8");
     const normalizedContent = content.replace(/\r\n/g, "\n");
     hash.update(relativePath);
     hash.update(normalizedContent);
@@ -3606,8 +3606,8 @@ function computeDirectoryHash(dirPath, files) {
 // src/commands/import.ts
 var importPrompts = {
-  select: p15__namespace.select,
-  text: p15__namespace.text
+  select: p3__namespace.select,
+  text: p3__namespace.text
 };
 function rewriteImports(content, aliasMap) {
   if (aliasMap.size === 0) return content;
@@ -3628,9 +3628,9 @@ function getModuleBaseDir(projectRoot, modType) {
 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;
+  if (fs9__default.default.existsSync(inSrc)) return inSrc;
   const inRoot = path2__default.default.join(projectRoot, folder, modName);
-  if (fs12__default.default.existsSync(inRoot)) return inRoot;
+  if (fs9__default.default.existsSync(inRoot)) return inRoot;
   return null;
 }
 function checkModuleExists(projectRoot, modType, modName) {
@@ -3648,13 +3648,13 @@ async function resolveDependency(depType, depName, aliasMap, projectRoot, flags,
       projectRoot,
       path2__default.default.join(baseDir, programmaticAlias)
     );
-    p15__namespace.log.step(`Importing '${depName}' into '${displayDest}'...`);
+    p3__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)}`);
+    p3__namespace.log.info(`  \u21B3 Resolving required ${depType} dependency: ${pc14__default.default.cyan(depName)}`);
     await importModuleRecursive(depType, depName, depName);
     return;
   }
@@ -3671,25 +3671,25 @@ async function resolveDependency(depType, depName, aliasMap, projectRoot, flags,
   }
   const localHash = computeDirectoryHash(existingDir);
   if (remoteIntegrity && localHash === remoteIntegrity) {
-    p15__namespace.log.step(`\u2713 ${depType}/${depName} is up to date (reusing existing)`);
+    p3__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)...`);
+    p3__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 });
+        fs9__default.default.rmSync(existingDir, { recursive: true, force: true });
       }
-      fs12__default.default.rmSync(targetDir, { recursive: true, force: true });
+      fs9__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}'`);
+    p3__namespace.log.info(`Using existing '${depType}/${depName}'`);
     importedModules.add(`${depType}:${depName}`);
     return;
   }
@@ -3713,7 +3713,7 @@ async function resolveDependency(depType, depName, aliasMap, projectRoot, flags,
     })
   );
   if (choice === "keep_existing" || choice === "use_existing") {
-    p15__namespace.log.step(`Skipping '${depType}/${depName}' (keeping existing)`);
+    p3__namespace.log.step(`Skipping '${depType}/${depName}' (keeping existing)`);
     importedModules.add(`${depType}:${depName}`);
     return;
   }
@@ -3738,19 +3738,19 @@ async function resolveDependency(depType, depName, aliasMap, projectRoot, flags,
     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}'...`);
+    p3__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...`);
+    p3__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 });
+        fs9__default.default.rmSync(existingDir, { recursive: true, force: true });
       }
-      fs12__default.default.rmSync(targetDir, { recursive: true, force: true });
+      fs9__default.default.rmSync(targetDir, { recursive: true, force: true });
     }
     await importModuleRecursive(depType, depName, depName, { overwrite: true });
     return;
@@ -3780,19 +3780,19 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
   if (type !== "shared" && type !== "feature") {
-    p15__namespace.log.error(pc15__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    p3__namespace.log.error(pc14__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
     process.exit(1);
   }
   const registryBase = getRegistryBase(projectRoot, flags.registry);
-  const s = p15__namespace.spinner();
-  s.start(`Connecting to registry at ${pc15__default.default.dim(registryBase)}...`);
+  const s = p3__namespace.spinner();
+  s.start(`Connecting to registry at ${pc14__default.default.dim(registryBase)}...`);
   let index;
   try {
     index = await fetchRegistryIndex(registryBase);
     s.stop("Registry index loaded.");
   } catch (err) {
-    s.stop(pc15__default.default.red("Failed to load registry index."));
-    p15__namespace.log.error(pc15__default.default.red(err.message || String(err)));
+    s.stop(pc14__default.default.red("Failed to load registry index."));
+    p3__namespace.log.error(pc14__default.default.red(err.message || String(err)));
     process.exit(1);
   }
   const availableList = type === "shared" ? index.shared : index.features;
@@ -3800,7 +3800,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   let name = nameArg?.trim();
   if (!name) {
     if (availableList.length === 0) {
-      p15__namespace.log.warn(`No ${type} modules available in the registry.`);
+      p3__namespace.log.warn(`No ${type} modules available in the registry.`);
       return;
     }
     name = handleCancel(
@@ -3816,9 +3816,9 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   }
   if (!candidateNames.includes(name)) {
     const closest = findClosestMatch(name, candidateNames);
-    p15__namespace.log.error(pc15__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    p3__namespace.log.error(pc14__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
     if (closest) {
-      p15__namespace.log.info(pc15__default.default.yellow(`Did you mean '${pc15__default.default.cyan(closest)}'?`));
+      p3__namespace.log.info(pc14__default.default.yellow(`Did you mean '${pc14__default.default.cyan(closest)}'?`));
     }
     process.exit(1);
   }
@@ -3828,14 +3828,14 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   async function importModuleRecursive(modType, registryName, targetName = registryName, options) {
     const modKey = `${modType}:${targetName}`;
     if (importedModules.has(modKey)) return;
-    p15__namespace.log.step(
-      `Importing ${modType}: ${pc15__default.default.cyan(targetName)}${targetName !== registryName ? pc15__default.default.dim(` (from ${registryName})`) : ""}...`
+    p3__namespace.log.step(
+      `Importing ${modType}: ${pc14__default.default.cyan(targetName)}${targetName !== registryName ? pc14__default.default.dim(` (from ${registryName})`) : ""}...`
     );
     let manifest;
     try {
       manifest = await fetchModuleManifest(registryBase, modType, registryName);
     } catch (err) {
-      p15__namespace.log.error(pc15__default.default.red(`Failed to fetch manifest for ${modType} '${registryName}': ${err.message}`));
+      p3__namespace.log.error(pc14__default.default.red(`Failed to fetch manifest for ${modType} '${registryName}': ${err.message}`));
       process.exit(1);
     }
     const aliasMap = /* @__PURE__ */ new Map();
@@ -3881,21 +3881,21 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       if (file === "registry.json") continue;
       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)`
+      if (fs9__default.default.existsSync(localFilePath) && !isOverwrite) {
+        p3__namespace.log.warn(
+          `  \u21B3 Skipping existing file: ${pc14__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
         );
         continue;
       }
       let content = await fetchRegistryFile(registryBase, remoteFilePath);
       content = rewriteImports(content, aliasMap);
       if (!flags.dryRun) {
-        fs12__default.default.mkdirSync(path2__default.default.dirname(localFilePath), { recursive: true });
-        fs12__default.default.writeFileSync(localFilePath, content, "utf-8");
+        fs9__default.default.mkdirSync(path2__default.default.dirname(localFilePath), { recursive: true });
+        fs9__default.default.writeFileSync(localFilePath, content, "utf-8");
       }
       const displayPath = path2__default.default.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
-      p15__namespace.log.message(`  ${pc15__default.default.green("+")} ${displayPath}`);
+      p3__namespace.log.message(`  ${pc14__default.default.green("+")} ${displayPath}`);
     }
     importedModules.add(modKey);
   }
@@ -3903,564 +3903,35 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   const missingNpm = getMissingNpmPackages(projectRoot, Array.from(requiredNpmPackages));
   if (missingNpm.length > 0) {
     if (flags.skipInstall || flags.dryRun) {
-      p15__namespace.log.info(`Required npm dependencies to install: ${pc15__default.default.cyan(missingNpm.join(", "))}`);
+      p3__namespace.log.info(`Required npm dependencies to install: ${pc14__default.default.cyan(missingNpm.join(", "))}`);
     } else {
       try {
         installNpmPackages(projectRoot, missingNpm);
       } catch (err) {
-        p15__namespace.log.warn(`Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(" ")}`);
+        p3__namespace.log.warn(`Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(" ")}`);
       }
     }
   }
   if (flags.dryRun) {
-    p15__namespace.log.info(pc15__default.default.yellow("Dry run complete: No files were written to disk."));
+    p3__namespace.log.info(pc14__default.default.yellow("Dry run complete: No files were written to disk."));
   } else {
     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(
+    p3__namespace.log.success(
+      pc14__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").option("--registry", "Run in registry mode").action(async (args, flags) => {
     if (args && args.length > 0) {
-      p15__namespace.log.error(
-        pc15__default.default.red(
+      p3__namespace.log.error(
+        pc14__default.default.red(
           `Unknown command: "${args.join(" ")}". Use --help to list available commands.`
         )
       );
@@ -4471,14 +3942,9 @@ function createCli() {
       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?",
+          await p3__namespace.select({
+            message: "\u{1F3DB}\uFE0F  Mason (Registry Mode): What would you like to scaffold?",
             options: [
-              {
-                value: "diff",
-                label: "Inspect Diff & Status",
-                hint: "Overview of unregistered, uncommitted, or drifted modules"
-              },
               {
                 value: "create_feature",
                 label: "Initialize New Feature",
@@ -4494,26 +3960,6 @@ function createCli() {
                 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",
@@ -4523,9 +3969,6 @@ function createCli() {
           })
         );
         switch (choice2) {
-          case "diff":
-            await handleRegistry("diff", void 0, void 0, flags);
-            break;
           case "create_feature":
             await handleCreate("feature", void 0, flags);
             break;
@@ -4535,18 +3978,6 @@ function createCli() {
           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;
@@ -4554,31 +3985,24 @@ function createCli() {
         return;
       }
       const choice = handleCancel(
-        await p15__namespace.select({
+        await p3__namespace.select({
           message: "\u{1F9F1} Mason: What would you like to do?",
           options: [
             {
               value: "create",
-              label: "Create local component",
+              label: "Create component",
               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);
       }
@@ -4606,25 +4030,6 @@ 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",
@@ -4648,7 +4053,7 @@ function createCli() {
     });
   }
   cli.help();
-  cli.version("1.0.13");
+  cli.version("1.0.14");
   return cli;
 }
 function handleCliError(err) {
@@ -4656,7 +4061,7 @@ function handleCliError(err) {
     process.exit(0);
   }
   const message = err instanceof Error ? err.message : String(err);
-  p15__namespace.log.error(pc15__default.default.red(`Error: ${message}`));
+  p3__namespace.log.error(pc14__default.default.red(`Error: ${message}`));
   process.exit(1);
 }
 async function runCli(argv = process.argv) {