@solid-stack/mason 1.0.14 → 1.0.16

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 var fs4 = require('fs');
 var path2 = require('path');
-var p4 = require('@clack/prompts');
+var p14 = require('@clack/prompts');
 var pc14 = require('picocolors');
 var url = require('url');
 var child_process = require('child_process');
@@ -33,7 +33,7 @@ function _interopNamespace(e) {
 
 var fs4__default = /*#__PURE__*/_interopDefault(fs4);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
-var p4__namespace = /*#__PURE__*/_interopNamespace(p4);
+var p14__namespace = /*#__PURE__*/_interopNamespace(p14);
 var pc14__default = /*#__PURE__*/_interopDefault(pc14);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 
@@ -141,17 +141,17 @@ function writeFileSafely(absolutePath, content, options = {}) {
 function printGeneratedFiles(files, isDryRun = false) {
   console.log("");
   if (isDryRun) {
-    p4__namespace.log.warn(pc14__default.default.yellow(pc14__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+    p14__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") {
-      p4__namespace.log.success(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(created)")}`);
+      p14__namespace.log.success(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(created)")}`);
     } else if (f.action === "overwritten") {
-      p4__namespace.log.warn(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(overwritten)")}`);
+      p14__namespace.log.warn(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(overwritten)")}`);
     } else if (f.action === "skipped") {
-      p4__namespace.log.info(`${pc14__default.default.dim(f.relativePath)} ${pc14__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
+      p14__namespace.log.info(`${pc14__default.default.dim(f.relativePath)} ${pc14__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
     } else {
-      p4__namespace.log.info(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(preview)")}`);
+      p14__namespace.log.info(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(preview)")}`);
     }
   }
 }
@@ -347,23 +347,23 @@ var PromptCancelledError = class extends Error {
   }
 };
 function handleCancel(result) {
-  if (p4__namespace.isCancel(result)) {
-    p4__namespace.cancel("Operation cancelled.");
+  if (p14__namespace.isCancel(result)) {
+    p14__namespace.cancel("Operation cancelled.");
     throw new PromptCancelledError();
   }
   return result;
 }
 function printBanner() {
   console.log("");
-  p4__namespace.intro(pc14__default.default.bgCyan(pc14__default.default.black(" @solid-stack/mason ")));
+  p14__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((p16) => `${p16.name}: ${p16.type}${p16.optional ? "?" : ""}`).join(", ");
-    p4__namespace.log.info(pc14__default.default.dim(`Pre-configured fields: ${summary}`));
+    p14__namespace.log.info(pc14__default.default.dim(`Pre-configured fields: ${summary}`));
     const addMore = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Would you like to add custom fields/properties?",
         initialValue: false
       })
@@ -372,10 +372,10 @@ async function promptProperties(options = {}) {
       return properties;
     }
   }
-  p4__namespace.log.info(pc14__default.default.cyan("Enter properties (leave name blank when finished):"));
+  p14__namespace.log.info(pc14__default.default.cyan("Enter properties (leave name blank when finished):"));
   while (true) {
     const name = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Property name (or press Enter to finish):",
         placeholder: "e.g. title, email, status"
       })
@@ -384,7 +384,7 @@ async function promptProperties(options = {}) {
       break;
     }
     const type = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: `Type for property "${name.trim()}":`,
         options: [
           { value: "string", label: "string" },
@@ -401,7 +401,7 @@ async function promptProperties(options = {}) {
     let finalType = type;
     if (type === "custom") {
       finalType = handleCancel(
-        await p4__namespace.text({
+        await p14__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"
@@ -409,7 +409,7 @@ async function promptProperties(options = {}) {
       );
     }
     const optional = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: `Is "${name.trim()}" optional?`,
         initialValue: false
       })
@@ -419,7 +419,7 @@ async function promptProperties(options = {}) {
       type: finalType.trim(),
       optional
     });
-    p4__namespace.log.success(
+    p14__namespace.log.success(
       pc14__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
     );
   }
@@ -642,7 +642,7 @@ function installNpmPackages(projectRoot, packages, pm) {
       installCmd = `npm install ${packages.join(" ")}`;
       break;
   }
-  p4__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc14__default.default.cyan(packages.join(", "))}`);
+  p14__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc14__default.default.cyan(packages.join(", "))}`);
   child_process.execSync(installCmd, {
     cwd: projectRoot,
     stdio: "inherit"
@@ -2115,7 +2115,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   }
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "What is the feature name?",
         placeholder: "e.g. users, auth, orders, billing",
         validate: (val) => {
@@ -2131,7 +2131,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Target directory for the feature:",
         initialValue: defaultDir,
         defaultValue: defaultDir
@@ -2153,14 +2153,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   const customUseCases = [];
   if (!flags.yes) {
     includeExpress = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Include Express Presentation layer (pxExpress routes & handlers)?",
         initialValue: true
       })
     );
     if (includeExpress) {
       routePath = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Express route prefix:",
           initialValue: `/${normalizedName}`,
           defaultValue: `/${normalizedName}`
@@ -2168,14 +2168,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       ).trim();
     }
     includeDomain = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Include Domain Entity/Entities?",
         initialValue: true
       })
     );
     if (includeDomain) {
       const domainInput = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Domain entity name(s) (comma-separated):",
           initialValue: defaultEntity,
           defaultValue: defaultEntity,
@@ -2194,21 +2194,21 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
     includeInterface = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: `Include Domain Repository interface(s) for ${entityNames.join(", ")}?`,
         initialValue: true
       })
     );
     if (includeInterface) {
       includeInfra = handleCancel(
-        await p4__namespace.confirm({
+        await p14__namespace.confirm({
           message: `Include Infrastructure Stub implementation(s) for ${entityNames.join(", ")}?`,
           initialValue: true
         })
       );
     }
     includeUseCase = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Include Domain Use Cases?",
         initialValue: true
       })
@@ -2222,7 +2222,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         { value: "delete", label: "Delete (Delete<Entity>)", hint: "DELETE /:id" }
       ];
       crudOperations = handleCancel(
-        await p4__namespace.multiselect({
+        await p14__namespace.multiselect({
           message: "Select standard CRUD use cases to generate:",
           options: crudChoices,
           initialValues: ["create", "read", "list", "update", "delete"],
@@ -2230,13 +2230,13 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         })
       );
       includeTests = handleCancel(
-        await p4__namespace.confirm({
+        await p14__namespace.confirm({
           message: "Generate Vitest unit tests for use cases?",
           initialValue: true
         })
       );
       const wantCustom = handleCancel(
-        await p4__namespace.confirm({
+        await p14__namespace.confirm({
           message: "Do you want to add any custom use cases to this feature?",
           initialValue: false
         })
@@ -2246,7 +2246,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
         const availableIfaces = entityNames.map((e) => `I${e}Repository`);
         while (addMore) {
           const customName = handleCancel(
-            await p4__namespace.text({
+            await p14__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"
@@ -2256,7 +2256,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let selectedDeps = [];
           if (availableIfaces.length > 0) {
             selectedDeps = handleCancel(
-              await p4__namespace.multiselect({
+              await p14__namespace.multiselect({
                 message: `Select domain interfaces to inject into ${customUcName}:`,
                 options: availableIfaces.map((i) => ({ value: i, label: i })),
                 required: false
@@ -2265,7 +2265,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customInputProps = [];
           const hasInput = handleCancel(
-            await p4__namespace.confirm({
+            await p14__namespace.confirm({
               message: `Does ${customUcName} accept input arguments?`,
               initialValue: true
             })
@@ -2276,7 +2276,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           }
           let customOutputProps = [];
           const hasCustomOutput = handleCancel(
-            await p4__namespace.confirm({
+            await p14__namespace.confirm({
               message: `Does ${customUcName} return custom output data?`,
               initialValue: false
             })
@@ -2286,7 +2286,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
               });
           }
           const customIncludeTest = handleCancel(
-            await p4__namespace.confirm({
+            await p14__namespace.confirm({
               message: `Generate Vitest unit test for ${customUcName}?`,
               initialValue: true
             })
@@ -2296,14 +2296,14 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
           let customHttpPath = `/${toKebabCase(customUcName)}`;
           if (includeExpress) {
             customCreateHttp = handleCancel(
-              await p4__namespace.confirm({
+              await p14__namespace.confirm({
                 message: `Generate a matching ExpressRoute HTTP handler for ${customUcName}?`,
                 initialValue: true
               })
             );
             if (customCreateHttp) {
               customHttpMethod = handleCancel(
-                await p4__namespace.select({
+                await p14__namespace.select({
                   message: "HTTP method for route:",
                   options: [
                     { value: "post", label: "POST" },
@@ -2316,7 +2316,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
                 })
               );
               customHttpPath = handleCancel(
-                await p4__namespace.text({
+                await p14__namespace.text({
                   message: "Route subpath (relative to feature prefix):",
                   initialValue: `/${toKebabCase(customUcName)}`,
                   defaultValue: `/${toKebabCase(customUcName)}`
@@ -2337,7 +2337,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
             validationFields: customInputProps
           });
           addMore = handleCancel(
-            await p4__namespace.confirm({
+            await p14__namespace.confirm({
               message: "Add another custom use case?",
               initialValue: false
             })
@@ -2346,7 +2346,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       }
     }
     includeDiProvider = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Generate / update feature DI provider (diProvider.ts)?",
         initialValue: true
       })
@@ -2358,7 +2358,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
       entityNames = [defaultEntity];
     }
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating feature '${pc14__default.default.cyan(normalizedName)}'...`);
   const options = {
     name: normalizedName,
@@ -2405,7 +2405,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   }
   s.stop("Feature scaffolded successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(
+  p14__namespace.outro(
     pc14__default.default.green(
       `\u2713 Feature '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
@@ -2520,7 +2520,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   }
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "What is the shared module name?",
         placeholder: "e.g. hasher, time, uuid, cache, logger",
         validate: (val) => {
@@ -2536,7 +2536,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   let targetDirRel = defaultDir;
   if (!flags.yes && !flags.target && !flags.dest) {
     targetDirRel = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Target directory for the shared module:",
         initialValue: defaultDir,
         defaultValue: defaultDir
@@ -2548,20 +2548,20 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   let includeStub = true;
   if (!flags.yes) {
     description = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Module description (optional):",
         placeholder: "e.g. In-memory caching and Redis port abstraction",
         initialValue: ""
       })
     ).trim();
     includeStub = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Include stub implementation in infrastructure/?",
         initialValue: true
       })
     );
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating shared module '${pc14__default.default.cyan(normalizedName)}'...`);
   const files = generateShared({
     name: normalizedName,
@@ -2575,7 +2575,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   });
   s.stop("Shared module generated successfully!");
   printGeneratedFiles(files, Boolean(flags.dryRun));
-  p4__namespace.outro(
+  p14__namespace.outro(
     pc14__default.default.green(
       `\u2713 Shared module '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
@@ -2590,14 +2590,14 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p14__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2607,7 +2607,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2618,7 +2618,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let name = useCaseNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__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"
@@ -2634,7 +2634,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       label: i.name
     }));
     selectedDeps = handleCancel(
-      await p4__namespace.multiselect({
+      await p14__namespace.multiselect({
         message: "Select domain interfaces to inject into use case:",
         options: multiOptions,
         required: false
@@ -2649,7 +2649,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   let httpPath = "/";
   if (!flags.yes) {
     const hasInput = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Does this use case accept input arguments?",
         initialValue: true
       })
@@ -2659,7 +2659,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     const hasCustomOutput = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Does this use case return custom output data?",
         initialValue: false
       })
@@ -2669,20 +2669,20 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         });
     }
     includeTest = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Generate Vitest unit test skeleton (.test.ts)?",
         initialValue: true
       })
     );
     createHttp = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Generate a matching ExpressRoute HTTP handler?",
         initialValue: false
       })
     );
     if (createHttp) {
       httpMethod = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "HTTP method for route:",
           options: [
             { value: "post", label: "POST" },
@@ -2695,7 +2695,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
         })
       );
       httpPath = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Route subpath (relative to feature prefix):",
           initialValue: "/",
           defaultValue: "/"
@@ -2703,7 +2703,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
       ).trim();
     }
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating use case '${pc14__default.default.cyan(ucName)}'...`);
   const options = {
     name: ucName,
@@ -2736,7 +2736,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   }
   s.stop("Use case generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc14__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
 }
 async function runDomainCommand(domainNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2747,14 +2747,14 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p14__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2764,7 +2764,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2775,7 +2775,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let name = domainNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__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"
@@ -2787,7 +2787,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   let properties = [];
   if (!flags.yes) {
     kind = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: "Select domain model type:",
         options: [
           { value: "interface", label: "TypeScript Interface (pure data structure)" },
@@ -2806,7 +2806,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
       defaults: kind === "valueObject" ? [{ name: "value", type: "string" }] : defaultProps
     });
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating domain model '${pc14__default.default.cyan(entityName)}'...`);
   const options = {
     name: entityName,
@@ -2820,7 +2820,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   const file = generateDomain(options);
   s.stop("Domain model generated successfully!");
   printGeneratedFiles([file], options.dryRun);
-  p4__namespace.outro(pc14__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
 }
 async function runInfrastructureCommand(classNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2829,7 +2829,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let feature = flags.feature?.trim();
   if (!flags.yes && !flags.global && !flags.feature) {
     scope = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: "Where should this infrastructure implementation be placed?",
         options: [
           { value: "feature", label: "Feature-level (features/<feature>/infrastructure)" },
@@ -2844,14 +2844,14 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p14__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -2861,7 +2861,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -2874,7 +2874,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Infrastructure class name:",
         placeholder: "e.g. StubUserRepository, PostgresUserRepository, S3FileStorage",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -2893,7 +2893,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
           (i) => className.toLowerCase().includes(removeInterfacePrefix(i.name).toLowerCase())
         );
         const ifaceChoice = handleCancel(
-          await p4__namespace.select({
+          await p14__namespace.select({
             message: "Does this class implement a domain interface or abstract class?",
             options: [
               ...interfaces.map((i) => ({ value: i.name, label: i.name })),
@@ -2905,7 +2905,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         );
         if (ifaceChoice === "__custom__") {
           implementsInterface = handleCancel(
-            await p4__namespace.text({
+            await p14__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"
@@ -2916,14 +2916,14 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
         }
       } else {
         const wantImpl = handleCancel(
-          await p4__namespace.confirm({
+          await p14__namespace.confirm({
             message: "Does this class implement a domain interface or abstract class?",
             initialValue: false
           })
         );
         if (wantImpl) {
           implementsInterface = handleCancel(
-            await p4__namespace.text({
+            await p14__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"
@@ -2943,7 +2943,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     const allInterfaces = listDomainInterfaces(projectRoot);
     if (allInterfaces.length > 0) {
       const ifaceChoice = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Does this class implement an interface or abstract class?",
           options: [
             ...allInterfaces.map((i) => ({ value: i.name, label: `${i.name} (${i.feature})` })),
@@ -2955,7 +2955,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
       );
       if (ifaceChoice === "__custom__") {
         implementsInterface = handleCancel(
-          await p4__namespace.text({
+          await p14__namespace.text({
             message: "Enter interface or abstract class name:",
             placeholder: "e.g. IAuthRepository",
             validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
@@ -2968,7 +2968,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   if (!flags.yes && !flags.kind) {
     kind = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: "Select implementation kind:",
         options: [
           { value: "stub", label: "In-Memory Stub (with in-memory store and test helper methods)" },
@@ -2979,7 +2979,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     );
     if (scope === "feature" && feature && implementsInterface) {
       registerInProvider = handleCancel(
-        await p4__namespace.confirm({
+        await p14__namespace.confirm({
           message: "Register this implementation in feature diProvider.ts?",
           initialValue: true
         })
@@ -2988,7 +2988,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   } else if (flags.yes && scope === "feature" && feature && implementsInterface) {
     registerInProvider = !flags.noProvider;
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating infrastructure class '${pc14__default.default.cyan(className)}'...`);
   const files = [];
   const options = {
@@ -3024,7 +3024,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   s.stop("Infrastructure class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc14__default.default.green(`Infrastructure class '${className}' created!`));
+  p14__namespace.outro(pc14__default.default.green(`Infrastructure class '${className}' created!`));
 }
 async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -3035,14 +3035,14 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p14__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -3052,7 +3052,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -3063,7 +3063,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   let name = interfaceNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Domain interface name:",
         placeholder: "e.g. IUserRepository, IPaymentService",
         validate: (v) => v && v.trim() ? void 0 : "Interface name cannot be empty"
@@ -3081,7 +3081,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   if (!flags.yes) {
     if (existingEntities.length > 0) {
       const selectedEntity = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Select domain entity associated with this interface:",
           options: [
             ...existingEntities.map((e) => ({ value: e.name, label: e.name })),
@@ -3092,7 +3092,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       );
       if (selectedEntity === "__custom__") {
         entityName = handleCancel(
-          await p4__namespace.text({
+          await p14__namespace.text({
             message: "Enter entity name:",
             defaultValue: removeInterfacePrefix(ifaceName).replace(/Repository$|Service$/, "")
           })
@@ -3102,7 +3102,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       }
     }
     kind = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: "Interface definition style:",
         options: [
           { value: "abstractClass", label: "Abstract Class (Recommended - acts as DI token & type)" },
@@ -3112,7 +3112,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     methodsPreset = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: "Method signature preset:",
         options: [
           { value: "crud", label: "Standard CRUD (GetById, List, Create, Update, Delete)" },
@@ -3122,21 +3122,21 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
       })
     );
     generateStub = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Auto-generate Infrastructure Stub implementation?",
         initialValue: true
       })
     );
     if (generateStub) {
       registerInProvider = handleCancel(
-        await p4__namespace.confirm({
+        await p14__namespace.confirm({
           message: "Auto-register interface & stub in feature diProvider.ts?",
           initialValue: true
         })
       );
     }
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating interface '${pc14__default.default.cyan(ifaceName)}'...`);
   const files = [];
   const options = {
@@ -3186,7 +3186,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   }
   s.stop("Interface generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc14__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
 }
 async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -3197,14 +3197,14 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
       featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
       const selected = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Select target feature:",
           options: featureOptions
         })
       );
       if (selected === "__custom__") {
         feature = handleCancel(
-          await p4__namespace.text({
+          await p14__namespace.text({
             message: "Enter feature name:",
             validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
           })
@@ -3214,7 +3214,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     } else {
       feature = handleCancel(
-        await p4__namespace.text({
+        await p14__namespace.text({
           message: "Enter target feature name:",
           validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
         })
@@ -3225,7 +3225,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let name = handlerNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__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"
@@ -3244,7 +3244,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   let validationFields = [];
   if (!flags.yes) {
     method = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: "HTTP Method:",
         options: [
           { value: "get", label: "GET" },
@@ -3258,7 +3258,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     );
     const defaultPath = method === "get" ? "/" : "/";
     subPath = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Route subpath (relative to feature prefix):",
         initialValue: defaultPath,
         defaultValue: defaultPath
@@ -3269,7 +3269,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       const ucOptions = useCases.map((u) => ({ value: u.name, label: u.name }));
       ucOptions.push({ value: "__none__", label: "None / Standalone Handler" });
       const chosenUc = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Connect this handler to a domain Use Case?",
           options: ucOptions,
           initialValue: ucOptions[0]?.value
@@ -3280,7 +3280,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
       }
     }
     includeValidation = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: "Include Zod inbound request validation?",
         initialValue: method !== "delete"
       })
@@ -3288,7 +3288,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     if (includeValidation) {
       const defaultSource = method === "get" ? "query" : "body";
       validationSource = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "Validation data source:",
           options: [
             { value: "body", label: "req.body (for POST / PUT / PATCH payloads)" },
@@ -3302,7 +3302,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
         });
     }
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating HTTP handler '${pc14__default.default.cyan(className)}'...`);
   const options = {
     name: className,
@@ -3321,7 +3321,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const files = generateHttpHandler(options);
   s.stop("HTTP handler generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc14__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
 }
 function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
   const formattedDeps = dependencies.map((dep) => ({
@@ -3401,7 +3401,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let name = classNameArg?.trim();
   if (!name) {
     name = handleCancel(
-      await p4__namespace.text({
+      await p14__namespace.text({
         message: "Injectable class name:",
         placeholder: "e.g. PasswordHasher, TokenService, UserTransformer",
         validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
@@ -3414,7 +3414,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let customPath;
   if (!flags.yes) {
     location = handleCancel(
-      await p4__namespace.select({
+      await p14__namespace.select({
         message: "Select target architectural location:",
         options: [
           { value: "feature-service", label: "Feature Service (features/<feature>/services/)" },
@@ -3432,14 +3432,14 @@ async function runInjectableCommand(classNameArg, flags = {}) {
           const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
           featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
           const selected = handleCancel(
-            await p4__namespace.select({
+            await p14__namespace.select({
               message: "Select target feature:",
               options: featureOptions
             })
           );
           if (selected === "__custom__") {
             feature = handleCancel(
-              await p4__namespace.text({
+              await p14__namespace.text({
                 message: "Enter feature name:",
                 validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
               })
@@ -3449,7 +3449,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
           }
         } else {
           feature = handleCancel(
-            await p4__namespace.text({
+            await p14__namespace.text({
               message: "Enter target feature name:",
               validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
             })
@@ -3459,7 +3459,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
       feature = toCamelCase(feature);
     } else if (location === "custom") {
       customPath = handleCancel(
-        await p4__namespace.text({
+        await p14__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"
@@ -3470,13 +3470,13 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   let generateInterface2 = false;
   if (!flags.yes) {
     generateInterface2 = handleCancel(
-      await p4__namespace.confirm({
+      await p14__namespace.confirm({
         message: `Generate abstract class interface (I${className}) as runtime DI token?`,
         initialValue: false
       })
     );
   }
-  const s = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Generating injectable '${pc14__default.default.cyan(className)}'...`);
   const options = {
     name: className,
@@ -3491,12 +3491,12 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   const files = generateInjectable(options);
   s.stop("Injectable class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p4__namespace.outro(pc14__default.default.green(`Injectable '${className}' created successfully!`));
+  p14__namespace.outro(pc14__default.default.green(`Injectable '${className}' created successfully!`));
 }
 async function runInteractiveMenu(flags = {}) {
   printBanner();
   const choice = handleCancel(
-    await p4__namespace.select({
+    await p14__namespace.select({
       message: "What would you like to create in your architecture?",
       options: [
         {
@@ -3604,7 +3604,7 @@ async function handleCreate(type, name, flags = {}) {
       await runInjectableCommand(name, flags);
       break;
     default:
-      p4__namespace.log.error(
+      p14__namespace.log.error(
         pc14__default.default.red(
           `Unknown component type: "${type}". Allowed types: feature, shared, usecase, domain, infrastructure, interface, httpHandler, injectable.`
         )
@@ -3613,8 +3613,8 @@ async function handleCreate(type, name, flags = {}) {
   }
 }
 var importPrompts = {
-  select: p4__namespace.select,
-  text: p4__namespace.text
+  select: p14__namespace.select,
+  text: p14__namespace.text
 };
 function rewriteImports(content, aliasMap) {
   if (aliasMap.size === 0) return content;
@@ -3643,126 +3643,6 @@ function getExistingModuleDir(projectRoot, modType, modName) {
 function checkModuleExists(projectRoot, modType, modName) {
   return getExistingModuleDir(projectRoot, modType, modName) !== null;
 }
-async function resolveDependency(depType, depName, aliasMap, projectRoot, flags, importModuleRecursive, importedModules, registryBase, index) {
-  const folder = depType === "shared" ? "shared" : "features";
-  const isAlreadyImportedThisRun = importedModules.has(`${depType}:${depName}`);
-  if (isAlreadyImportedThisRun) return;
-  const programmaticAlias = flags.alias?.[depName] || flags.alias?.[`${depType}/${depName}`];
-  if (programmaticAlias) {
-    aliasMap.set(`@/${folder}/${depName}/`, `@/${folder}/${programmaticAlias}/`);
-    const baseDir = getModuleBaseDir(projectRoot, depType);
-    const displayDest = path2__default.default.relative(
-      projectRoot,
-      path2__default.default.join(baseDir, programmaticAlias)
-    );
-    p4__namespace.log.step(`Importing '${depName}' into '${displayDest}'...`);
-    await importModuleRecursive(depType, depName, programmaticAlias);
-    return;
-  }
-  const existingDir = getExistingModuleDir(projectRoot, depType, depName);
-  if (!existingDir) {
-    p4__namespace.log.info(`  \u21B3 Resolving required ${depType} dependency: ${pc14__default.default.cyan(depName)}`);
-    await importModuleRecursive(depType, depName, depName);
-    return;
-  }
-  const entry = (depType === "shared" ? index?.shared : index?.features)?.find(
-    (item) => item.name === depName
-  );
-  let remoteIntegrity = entry?.integrity;
-  if (!remoteIntegrity) {
-    try {
-      const depManifest = await fetchModuleManifest(registryBase, depType, depName);
-      remoteIntegrity = depManifest.integrity;
-    } catch {
-    }
-  }
-  const localHash = computeDirectoryHash(existingDir);
-  if (remoteIntegrity && localHash === remoteIntegrity) {
-    p4__namespace.log.step(`\u2713 ${depType}/${depName} is up to date (reusing existing)`);
-    importedModules.add(`${depType}:${depName}`);
-    return;
-  }
-  if (flags.overwrite) {
-    p4__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) {
-        fs4__default.default.rmSync(existingDir, { recursive: true, force: true });
-      }
-      fs4__default.default.rmSync(targetDir, { recursive: true, force: true });
-    }
-    await importModuleRecursive(depType, depName, depName, { overwrite: true });
-    return;
-  }
-  if (flags.yes) {
-    p4__namespace.log.info(`Using existing '${depType}/${depName}'`);
-    importedModules.add(`${depType}:${depName}`);
-    return;
-  }
-  const choice = handleCancel(
-    await importPrompts.select({
-      message: `Local '${depType}/${depName}' differs from the registry version.`,
-      options: [
-        {
-          value: "keep_existing",
-          label: `Keep existing local version (Recommended)`
-        },
-        {
-          value: "rename",
-          label: "Import fresh copy under a new name (alias)"
-        },
-        {
-          value: "overwrite",
-          label: "Overwrite local version with registry version"
-        }
-      ]
-    })
-  );
-  if (choice === "keep_existing" || choice === "use_existing") {
-    p4__namespace.log.step(`Skipping '${depType}/${depName}' (keeping existing)`);
-    importedModules.add(`${depType}:${depName}`);
-    return;
-  }
-  if (choice === "rename") {
-    const newName = handleCancel(
-      await importPrompts.text({
-        message: "What should we name the new copy?",
-        placeholder: `${depName}-copy`,
-        validate(val) {
-          const v = val?.trim();
-          if (!v) return "Name cannot be empty";
-          if (v === depName) return `Name must be different from '${depName}'`;
-          if (!/^[a-zA-Z0-9_-]+$/.test(v)) {
-            return "Name can only contain alphanumeric characters, dashes, and underscores";
-          }
-          if (checkModuleExists(projectRoot, depType, v)) {
-            return `'${v}' already exists in ${folder}, please choose another name`;
-          }
-        }
-      })
-    ).trim();
-    aliasMap.set(`@/${folder}/${depName}/`, `@/${folder}/${newName}/`);
-    const baseDir = getModuleBaseDir(projectRoot, depType);
-    const displayDest = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, newName));
-    p4__namespace.log.step(`Importing '${depName}' into '${displayDest}'...`);
-    await importModuleRecursive(depType, depName, newName);
-    return;
-  }
-  if (choice === "overwrite") {
-    p4__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) {
-        fs4__default.default.rmSync(existingDir, { recursive: true, force: true });
-      }
-      fs4__default.default.rmSync(targetDir, { recursive: true, force: true });
-    }
-    await importModuleRecursive(depType, depName, depName, { overwrite: true });
-    return;
-  }
-}
 async function handleImport(typeArg, nameArg, flags = {}) {
   const projectRoot = findProjectRoot();
   let type = typeArg?.trim().toLowerCase();
@@ -3787,11 +3667,11 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
   if (type !== "shared" && type !== "feature") {
-    p4__namespace.log.error(pc14__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    p14__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 = p4__namespace.spinner();
+  const s = p14__namespace.spinner();
   s.start(`Connecting to registry at ${pc14__default.default.dim(registryBase)}...`);
   let index;
   try {
@@ -3799,7 +3679,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     s.stop("Registry index loaded.");
   } catch (err) {
     s.stop(pc14__default.default.red("Failed to load registry index."));
-    p4__namespace.log.error(pc14__default.default.red(err.message || String(err)));
+    p14__namespace.log.error(pc14__default.default.red(err.message || String(err)));
     process.exit(1);
   }
   const availableList = type === "shared" ? index.shared : index.features;
@@ -3807,7 +3687,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   let name = nameArg?.trim();
   if (!name) {
     if (availableList.length === 0) {
-      p4__namespace.log.warn(`No ${type} modules available in the registry.`);
+      p14__namespace.log.warn(`No ${type} modules available in the registry.`);
       return;
     }
     name = handleCancel(
@@ -3823,108 +3703,294 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   }
   if (!candidateNames.includes(name)) {
     const closest = findClosestMatch(name, candidateNames);
-    p4__namespace.log.error(pc14__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    p14__namespace.log.error(pc14__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
     if (closest) {
-      p4__namespace.log.info(pc14__default.default.yellow(`Did you mean '${pc14__default.default.cyan(closest)}'?`));
+      p14__namespace.log.info(pc14__default.default.yellow(`Did you mean '${pc14__default.default.cyan(closest)}'?`));
     }
     process.exit(1);
   }
-  const importedModules = /* @__PURE__ */ new Set();
-  const totalWrittenFiles = [];
-  const requiredNpmPackages = /* @__PURE__ */ new Set();
-  async function importModuleRecursive(modType, registryName, targetName = registryName, options) {
-    const modKey = `${modType}:${targetName}`;
-    if (importedModules.has(modKey)) return;
-    p4__namespace.log.step(
-      `Importing ${modType}: ${pc14__default.default.cyan(targetName)}${targetName !== registryName ? pc14__default.default.dim(` (from ${registryName})`) : ""}...`
-    );
+  const nodes = /* @__PURE__ */ new Map();
+  async function discoverGraph(modType, modName) {
+    const key = `${modType}:${modName}`;
+    if (nodes.has(key)) return;
     let manifest;
     try {
-      manifest = await fetchModuleManifest(registryBase, modType, registryName);
+      manifest = await fetchModuleManifest(registryBase, modType, modName);
     } catch (err) {
-      p4__namespace.log.error(pc14__default.default.red(`Failed to fetch manifest for ${modType} '${registryName}': ${err.message}`));
+      p14__namespace.log.error(pc14__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
       process.exit(1);
     }
-    const aliasMap = /* @__PURE__ */ new Map();
-    if (targetName !== registryName) {
-      const folder2 = modType === "shared" ? "shared" : "features";
-      aliasMap.set(`@/${folder2}/${registryName}/`, `@/${folder2}/${targetName}/`);
+    nodes.set(key, {
+      type: modType,
+      name: modName,
+      manifest
+    });
+    for (const dep of manifest.dependencies?.shared || []) {
+      await discoverGraph("shared", dep);
     }
-    const sharedDeps = manifest.dependencies?.shared || [];
-    for (const dep of sharedDeps) {
-      await resolveDependency(
-        "shared",
-        dep,
-        aliasMap,
-        projectRoot,
-        flags,
-        importModuleRecursive,
-        importedModules,
-        registryBase,
-        index
-      );
+    for (const dep of manifest.dependencies?.features || []) {
+      await discoverGraph("feature", dep);
     }
-    const featureDeps = manifest.dependencies?.features || [];
-    for (const dep of featureDeps) {
-      await resolveDependency(
-        "feature",
-        dep,
-        aliasMap,
-        projectRoot,
-        flags,
-        importModuleRecursive,
-        importedModules,
-        registryBase,
-        index
-      );
+  }
+  await discoverGraph(type, name);
+  const orderedKeys = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function buildTopologicalOrder(key) {
+    if (visited.has(key)) return;
+    if (visiting.has(key)) return;
+    visiting.add(key);
+    const node = nodes.get(key);
+    if (node) {
+      for (const dep of node.manifest.dependencies?.shared || []) {
+        buildTopologicalOrder(`shared:${dep}`);
+      }
+      for (const dep of node.manifest.dependencies?.features || []) {
+        buildTopologicalOrder(`feature:${dep}`);
+      }
+    }
+    visiting.delete(key);
+    visited.add(key);
+    orderedKeys.push(key);
+  }
+  const rootKey = `${type}:${name}`;
+  buildTopologicalOrder(rootKey);
+  const resolutions = /* @__PURE__ */ new Map();
+  const globalAliasMap = /* @__PURE__ */ new Map();
+  p14__namespace.log.step(`Importing ${type}: ${pc14__default.default.cyan(name)}...`);
+  for (const key of orderedKeys) {
+    const node = nodes.get(key);
+    const { type: modType, name: registryName, manifest } = node;
+    const folder = modType === "shared" ? "shared" : "features";
+    if (key === rootKey) {
+      const programmaticAlias2 = flags.alias?.[registryName] || flags.alias?.[`${modType}/${registryName}`];
+      const targetName = programmaticAlias2 || registryName;
+      if (targetName !== registryName) {
+        globalAliasMap.set(`@/${folder}/${registryName}/`, `@/${folder}/${targetName}/`);
+        globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${targetName}`);
+      }
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName,
+        action: flags.overwrite ? "overwrite" : "download",
+        manifest
+      });
+      continue;
+    }
+    const programmaticAlias = flags.alias?.[registryName] || flags.alias?.[`${modType}/${registryName}`];
+    if (programmaticAlias) {
+      globalAliasMap.set(`@/${folder}/${registryName}/`, `@/${folder}/${programmaticAlias}/`);
+      globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${programmaticAlias}`);
+      const baseDir = getModuleBaseDir(projectRoot, modType);
+      const displayDest = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, programmaticAlias));
+      p14__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: programmaticAlias,
+        action: "alias",
+        manifest
+      });
+      continue;
+    }
+    const existingDir = getExistingModuleDir(projectRoot, modType, registryName);
+    if (!existingDir) {
+      p14__namespace.log.info(`  \u21B3 Resolving required ${modType} dependency: ${pc14__default.default.cyan(registryName)}`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: registryName,
+        action: "download",
+        manifest
+      });
+      continue;
+    }
+    const entry = (modType === "shared" ? index.shared : index.features)?.find(
+      (item) => item.name === registryName
+    );
+    const remoteIntegrity = manifest.integrity || entry?.integrity;
+    const localHash = computeDirectoryHash(existingDir);
+    if (remoteIntegrity && localHash === remoteIntegrity) {
+      p14__namespace.log.step(`\u2713 ${modType}/${registryName} is up to date (reusing existing)`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: registryName,
+        action: "reuse",
+        manifest
+      });
+      continue;
+    }
+    if (flags.overwrite) {
+      p14__namespace.log.step(`Overwriting '${modType}/${registryName}' with registry version (--overwrite)...`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: registryName,
+        action: "overwrite",
+        manifest
+      });
+      continue;
+    }
+    if (flags.yes) {
+      p14__namespace.log.info(`Using existing '${modType}/${registryName}'`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: registryName,
+        action: "reuse",
+        manifest
+      });
+      continue;
     }
-    for (const pkg of manifest.dependencies?.npm || []) {
+    const choice = handleCancel(
+      await importPrompts.select({
+        message: `Local '${modType}/${registryName}' differs from the registry version.`,
+        options: [
+          {
+            value: "keep_existing",
+            label: `Keep existing local version (Recommended)`
+          },
+          {
+            value: "rename",
+            label: "Import fresh copy under a new name (alias)"
+          },
+          {
+            value: "overwrite",
+            label: "Overwrite local version with registry version"
+          }
+        ]
+      })
+    );
+    if (choice === "keep_existing" || choice === "use_existing") {
+      p14__namespace.log.step(`Skipping '${modType}/${registryName}' (keeping existing)`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: registryName,
+        action: "reuse",
+        manifest
+      });
+      continue;
+    }
+    if (choice === "rename") {
+      const newName = handleCancel(
+        await importPrompts.text({
+          message: "What should we name the new copy?",
+          placeholder: `${registryName}-copy`,
+          validate(val) {
+            const v = val?.trim();
+            if (!v) return "Name cannot be empty";
+            if (v === registryName) return `Name must be different from '${registryName}'`;
+            if (!/^[a-zA-Z0-9_-]+$/.test(v)) {
+              return "Name can only contain alphanumeric characters, dashes, and underscores";
+            }
+            if (checkModuleExists(projectRoot, modType, v)) {
+              return `'${v}' already exists in ${folder}, please choose another name`;
+            }
+          }
+        })
+      ).trim();
+      globalAliasMap.set(`@/${folder}/${registryName}/`, `@/${folder}/${newName}/`);
+      globalAliasMap.set(`@/${folder}/${registryName}`, `@/${folder}/${newName}`);
+      const baseDir = getModuleBaseDir(projectRoot, modType);
+      const displayDest = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, newName));
+      p14__namespace.log.step(`Importing '${registryName}' into '${displayDest}'...`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: newName,
+        action: "alias",
+        manifest
+      });
+      continue;
+    }
+    if (choice === "overwrite") {
+      p14__namespace.log.step(`Overwriting '${modType}/${registryName}' with registry version...`);
+      resolutions.set(key, {
+        type: modType,
+        registryName,
+        targetName: registryName,
+        action: "overwrite",
+        manifest
+      });
+      continue;
+    }
+  }
+  const totalWrittenFiles = [];
+  const requiredNpmPackages = /* @__PURE__ */ new Set();
+  for (const node of nodes.values()) {
+    for (const pkg of node.manifest.dependencies?.npm || []) {
       requiredNpmPackages.add(pkg);
     }
-    const folder = modType === "shared" ? "shared" : "features";
-    const targetDir = path2__default.default.join(getModuleBaseDir(projectRoot, modType), targetName);
-    const isOverwrite = Boolean(flags.overwrite || options?.overwrite);
-    for (const file of manifest.files || []) {
+  }
+  for (const key of orderedKeys) {
+    const res = resolutions.get(key);
+    if (res.action === "reuse") {
+      continue;
+    }
+    const folder = res.type === "shared" ? "shared" : "features";
+    const targetDir = path2__default.default.join(getModuleBaseDir(projectRoot, res.type), res.targetName);
+    const isOverwrite = Boolean(flags.overwrite || res.action === "overwrite");
+    if (key !== rootKey) {
+      p14__namespace.log.step(
+        `Importing ${res.type}: ${pc14__default.default.cyan(res.targetName)}${res.targetName !== res.registryName ? pc14__default.default.dim(` (from ${res.registryName})`) : ""}...`
+      );
+    }
+    if (res.action === "overwrite" && !flags.dryRun) {
+      const existingDir = getExistingModuleDir(projectRoot, res.type, res.targetName);
+      if (existingDir && existingDir !== targetDir) {
+        fs4__default.default.rmSync(existingDir, { recursive: true, force: true });
+      }
+      if (fs4__default.default.existsSync(targetDir)) {
+        fs4__default.default.rmSync(targetDir, { recursive: true, force: true });
+      }
+    }
+    for (const file of res.manifest.files || []) {
       if (file === "registry.json") continue;
-      const remoteFilePath = `${folder}/${registryName}/${file}`;
+      const remoteFilePath = `${folder}/${res.registryName}/${file}`;
       const localFilePath = path2__default.default.join(targetDir, file);
       if (fs4__default.default.existsSync(localFilePath) && !isOverwrite) {
-        p4__namespace.log.warn(
+        p14__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);
+      content = rewriteImports(content, globalAliasMap);
       if (!flags.dryRun) {
         fs4__default.default.mkdirSync(path2__default.default.dirname(localFilePath), { recursive: true });
         fs4__default.default.writeFileSync(localFilePath, content, "utf-8");
       }
       const displayPath = path2__default.default.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
-      p4__namespace.log.message(`  ${pc14__default.default.green("+")} ${displayPath}`);
+      p14__namespace.log.message(`  ${pc14__default.default.green("+")} ${displayPath}`);
     }
-    importedModules.add(modKey);
   }
-  await importModuleRecursive(type, name, name);
   const missingNpm = getMissingNpmPackages(projectRoot, Array.from(requiredNpmPackages));
   if (missingNpm.length > 0) {
     if (flags.skipInstall || flags.dryRun) {
-      p4__namespace.log.info(`Required npm dependencies to install: ${pc14__default.default.cyan(missingNpm.join(", "))}`);
+      p14__namespace.log.info(`Required npm dependencies to install: ${pc14__default.default.cyan(missingNpm.join(", "))}`);
     } else {
       try {
         installNpmPackages(projectRoot, missingNpm);
       } catch (err) {
-        p4__namespace.log.warn(`Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(" ")}`);
+        p14__namespace.log.warn(
+          `Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(
+            " "
+          )}`
+        );
       }
     }
   }
   if (flags.dryRun) {
-    p4__namespace.log.info(pc14__default.default.yellow("Dry run complete: No files were written to disk."));
+    p14__namespace.log.info(pc14__default.default.yellow("Dry run complete: No files were written to disk."));
   } else {
+    const rootRes = resolutions.get(rootKey);
     const baseDir = getModuleBaseDir(projectRoot, type);
-    const displayTarget = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, name));
-    p4__namespace.log.success(
+    const displayTarget = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, rootRes.targetName));
+    p14__namespace.log.success(
       pc14__default.default.green(
         `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in ${displayTarget})`
       )
@@ -3937,7 +4003,7 @@ 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) {
-      p4__namespace.log.error(
+      p14__namespace.log.error(
         pc14__default.default.red(
           `Unknown command: "${args.join(" ")}". Use --help to list available commands.`
         )
@@ -3949,7 +4015,7 @@ function createCli() {
       const mode = getEffectiveMode(projectRoot, flags);
       if (mode === "registry") {
         const choice2 = handleCancel(
-          await p4__namespace.select({
+          await p14__namespace.select({
             message: "\u{1F3DB}\uFE0F  Mason (Registry Mode): What would you like to scaffold?",
             options: [
               {
@@ -3992,7 +4058,7 @@ function createCli() {
         return;
       }
       const choice = handleCancel(
-        await p4__namespace.select({
+        await p14__namespace.select({
           message: "\u{1F9F1} Mason: What would you like to do?",
           options: [
             {
@@ -4060,7 +4126,7 @@ function createCli() {
     });
   }
   cli.help();
-  cli.version("1.0.14");
+  cli.version("1.0.16");
   return cli;
 }
 function handleCliError(err) {
@@ -4068,7 +4134,7 @@ function handleCliError(err) {
     process.exit(0);
   }
   const message = err instanceof Error ? err.message : String(err);
-  p4__namespace.log.error(pc14__default.default.red(`Error: ${message}`));
+  p14__namespace.log.error(pc14__default.default.red(`Error: ${message}`));
   process.exit(1);
 }
 async function runCli(argv = process.argv) {