create-morax 2.0.2 → 2.0.4

package/dist/index.js

@@ -4,10 +4,36 @@
 import pc29 from "picocolors";
 
 // src/core/runner.ts
-import path35 from "path";
+import path36 from "path";
 import { spinner as spinner20 } from "@clack/prompts";
 import pc28 from "picocolors";
 
+// src/utils/cleanBunLock.ts
+import fsPromises from "fs/promises";
+import path from "path";
+var BUN_LOCK_NAMES = ["bun.lock", "bun.lockb"];
+async function removeBunLockfiles(...targetDirs) {
+  for (const dir of targetDirs) {
+    if (!dir) continue;
+    const pathsToCheck = [
+      dir,
+      path.join(dir, "apps"),
+      path.join(dir, "apps", "web")
+    ];
+    for (const targetPath of pathsToCheck) {
+      for (const lockFileName of BUN_LOCK_NAMES) {
+        try {
+          await fsPromises.rm(path.join(targetPath, lockFileName), {
+            force: true,
+            recursive: true
+          });
+        } catch {
+        }
+      }
+    }
+  }
+}
+
 // src/core/startcli.ts
 import gradient from "gradient-string";
 import pc from "picocolors";
@@ -44,7 +70,7 @@ function startCli() {
 // src/core/preflight.ts
 import ora from "ora";
 import pc3 from "picocolors";
-import fsPromises from "fs/promises";
+import fsPromises2 from "fs/promises";
 
 // src/utils/exec.ts
 import { exec, spawn } from "child_process";
@@ -52,14 +78,18 @@ import { promisify } from "util";
 import pc2 from "picocolors";
 var execAsync = promisify(exec);
 async function runCommand(command, options = {}) {
-  const isSilent = options.silent ?? false;
+  const isSilent = options.silent ?? true;
   if (!isSilent) {
     console.log(pc2.cyan(`> ${command}`));
   }
   try {
     const { stdout, stderr } = await execAsync(command, {
       cwd: options.cwd,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
+      env: {
+        ...process.env,
+        NODE_NO_WARNINGS: "1",
+        NODE_OPTIONS: `${process.env.NODE_OPTIONS || ""} --no-deprecation`.trim()
+      }
     });
     if (!isSilent) {
       if (stdout && stdout.trim()) {
@@ -88,11 +118,15 @@ ${error.stderr.trim()}`;
 function runInteractiveCommand(command, args, cwd) {
   return new Promise((resolve, reject) => {
     const fullCommand = args.length > 0 ? `${command} ${args.join(" ")}` : command;
-    const child = spawn(fullCommand, [], {
+    const child = spawn(fullCommand, {
       cwd,
       stdio: "inherit",
       shell: true,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
+      env: {
+        ...process.env,
+        NODE_NO_WARNINGS: "1",
+        NODE_OPTIONS: `${process.env.NODE_OPTIONS || ""} --no-deprecation`.trim()
+      }
     });
     child.on("close", (code) => {
       if (code === 0) {
@@ -179,7 +213,7 @@ async function runPreflightChecks() {
     color: "cyan"
   }).start();
   await sleep(150);
-  let bunVersion = null;
+  let bunVersion = "";
   try {
     const { stdout } = await runCommand("bun --version", { silent: true });
     bunVersion = stdout.trim();
@@ -192,9 +226,19 @@ async function runPreflightChecks() {
     });
   } catch {
     bunSpinner.stopAndPersist({
-      symbol: warn,
-      text: `Verifying Bun runtime. ${pc3.yellow("Not found")} (optional).`
+      symbol: cross,
+      text: "Verifying Bun runtime. Not found."
     });
+    console.log(
+      "\n" + pc3.red(
+        "\u2716 Error: Bun is required to scaffold and execute high-performance Morax apps.\n"
+      ) + pc3.cyan("  \u2022 Install Bun:   https://bun.sh\n") + pc3.cyan(
+        '  \u2022 Windows:       powershell -c "irm bun.sh/install.ps1 | iex"\n'
+      ) + pc3.cyan(
+        "  \u2022 macOS / Linux: curl -fsSL https://bun.sh/install | bash\n"
+      )
+    );
+    process.exit(1);
   }
   const dockerSpinner = ora({
     text: "Verifying Docker installation...",
@@ -247,7 +291,7 @@ async function runPreflightChecks() {
 }
 async function checkTargetDirectory(projectPath, name) {
   try {
-    const files = await fsPromises.readdir(projectPath);
+    const files = await fsPromises2.readdir(projectPath);
     if (files.length > 0) {
       console.log(
         "\n" + pc3.red(
@@ -313,8 +357,8 @@ import { select as select2 } from "@clack/prompts";
 // src/modules/packages/db/drizzle.ts
 import { select, spinner } from "@clack/prompts";
 import pc5 from "picocolors";
-import fsPromises2 from "fs/promises";
-import path from "path";
+import fsPromises3 from "fs/promises";
+import path2 from "path";
 async function promptDrizzle() {
   const dialectChoice = await select({
     message: "Which database dialect would you like to use with Drizzle?",
@@ -379,15 +423,15 @@ async function promptDrizzle() {
   return { dialect };
 }
 async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none", postgresProvider = "docker", neonMode = "serverless") {
-  const dbDir = path.join(projectPath, "packages", "db");
-  const srcDir = path.join(dbDir, "src");
-  const schemaDir = path.join(srcDir, "schema");
-  const seedDir = path.join(srcDir, "seed");
-  await fsPromises2.mkdir(schemaDir, { recursive: true });
-  await fsPromises2.mkdir(seedDir, { recursive: true });
+  const dbDir = path2.join(projectPath, "packages", "db");
+  const srcDir = path2.join(dbDir, "src");
+  const schemaDir = path2.join(srcDir, "schema");
+  const seedDir = path2.join(srcDir, "seed");
+  await fsPromises3.mkdir(schemaDir, { recursive: true });
+  await fsPromises3.mkdir(seedDir, { recursive: true });
   await runCommand("pnpm init", { cwd: dbDir, silent: true });
-  const dbPackagePath = path.join(dbDir, "package.json");
-  const dbPackageRaw = await fsPromises2.readFile(dbPackagePath, "utf8");
+  const dbPackagePath = path2.join(dbDir, "package.json");
+  const dbPackageRaw = await fsPromises3.readFile(dbPackagePath, "utf8");
   const dbPkg = JSON.parse(dbPackageRaw);
   const providerLabel = dialect === "sqlite" ? "SQLite" : postgresProvider === "neon" ? `PostgreSQL (Neon ${neonMode === "pool" ? "Pool" : "Serverless"})` : "PostgreSQL (Docker)";
   dbPkg.name = "@repo/db";
@@ -427,7 +471,7 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
   delete dbPkg.keywords;
   delete dbPkg.author;
   delete dbPkg.license;
-  await fsPromises2.writeFile(
+  await fsPromises3.writeFile(
     dbPackagePath,
     JSON.stringify(dbPkg, null, 2),
     "utf8"
@@ -442,35 +486,35 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
     },
     include: ["src/**/*", "drizzle.config.ts"]
   };
-  await fsPromises2.writeFile(
-    path.join(dbDir, "tsconfig.json"),
+  await fsPromises3.writeFile(
+    path2.join(dbDir, "tsconfig.json"),
     JSON.stringify(tsconfigContent, null, 2),
     "utf8"
   );
   if (dialect === "sqlite") {
     await runCommand("pnpm add drizzle-orm@rc @libsql/client dotenv", {
       cwd: dbDir,
-      silent: false
+      silent: true
     });
   } else if (postgresProvider === "neon") {
     await runCommand(
       "pnpm add drizzle-orm@rc @neondatabase/serverless dotenv",
       {
         cwd: dbDir,
-        silent: false
+        silent: true
       }
     );
   } else {
     await runCommand("pnpm add drizzle-orm@rc pg dotenv @types/pg", {
       cwd: dbDir,
-      silent: false
+      silent: true
     });
   }
   await runCommand(
     "pnpm add -D drizzle-kit@rc @types/node tsx typescript@latest",
     {
       cwd: dbDir,
-      silent: false
+      silent: true
     }
   );
   const envVar = dialect === "sqlite" ? "DB_FILE_NAME" : "DATABASE_URL";
@@ -499,8 +543,8 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
     "});",
     ""
   ].join("\n");
-  await fsPromises2.writeFile(
-    path.join(dbDir, "drizzle.config.ts"),
+  await fsPromises3.writeFile(
+    path2.join(dbDir, "drizzle.config.ts"),
     drizzleConfigContent,
     "utf8"
   );
@@ -542,8 +586,8 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
       ""
     ].join("\n");
   }
-  await fsPromises2.writeFile(
-    path.join(schemaDir, "index.ts"),
+  await fsPromises3.writeFile(
+    path2.join(schemaDir, "index.ts"),
     schemaContent,
     "utf8"
   );
@@ -653,8 +697,8 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
       ""
     ].join("\n");
   }
-  await fsPromises2.writeFile(
-    path.join(srcDir, "client.ts"),
+  await fsPromises3.writeFile(
+    path2.join(srcDir, "client.ts"),
     clientContent,
     "utf8"
   );
@@ -672,8 +716,8 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
     "export * from 'drizzle-orm';",
     ""
   ].join("\n");
-  await fsPromises2.writeFile(
-    path.join(srcDir, "index.ts"),
+  await fsPromises3.writeFile(
+    path2.join(srcDir, "index.ts"),
     indexContent,
     "utf8"
   );
@@ -725,14 +769,14 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
     "});",
     ""
   ].join("\n");
-  await fsPromises2.writeFile(
-    path.join(seedDir, "seed.ts"),
+  await fsPromises3.writeFile(
+    path2.join(seedDir, "seed.ts"),
     seedScriptContent,
     "utf8"
   );
   const seedIndexContent = ["export { seed } from './seed.js';", ""].join("\n");
-  await fsPromises2.writeFile(
-    path.join(seedDir, "index.ts"),
+  await fsPromises3.writeFile(
+    path2.join(seedDir, "index.ts"),
     seedIndexContent,
     "utf8"
   );
@@ -745,8 +789,8 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
     "*.db-journal",
     ""
   ].join("\n");
-  await fsPromises2.writeFile(
-    path.join(dbDir, ".gitignore"),
+  await fsPromises3.writeFile(
+    path2.join(dbDir, ".gitignore"),
     gitignoreContent,
     "utf8"
   );
@@ -773,16 +817,16 @@ async function setupDrizzle(projectPath, dialect = "postgresql", linter = "none"
     "- `pnpm db:check` \u2014 Check migration history and verify consistency.",
     ""
   ].filter(Boolean).join("\n");
-  await fsPromises2.writeFile(
-    path.join(dbDir, "README.md"),
+  await fsPromises3.writeFile(
+    path2.join(dbDir, "README.md"),
     readmeContent,
     "utf8"
   );
 }
 async function runDrizzleSetup(projectPath, dialect = "postgresql", linter = "none", postgresProvider = "docker", neonMode = "serverless") {
-  const packagesDir = path.join(projectPath, "packages");
+  const packagesDir = path2.join(projectPath, "packages");
   try {
-    await fsPromises2.access(packagesDir);
+    await fsPromises3.access(packagesDir);
   } catch {
     return;
   }
@@ -1043,43 +1087,17 @@ ${pc6.bold("Database commands (packages/db - Drizzle ORM):")}
 }
 
 // src/standalone/react-runner.ts
-import path5 from "path";
+import path6 from "path";
 import { spinner as spinner4 } from "@clack/prompts";
 import pc9 from "picocolors";
 
 // src/modules/apps/web/react.ts
 import pc7 from "picocolors";
-import fsPromises3 from "fs/promises";
-import path2 from "path";
-import { spawn as spawn2 } from "child_process";
+import fsPromises4 from "fs/promises";
+import path3 from "path";
 import { confirm, spinner as spinner2, text as text2 } from "@clack/prompts";
-function runInteractiveCommand2(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const fullCommand = args.length > 0 ? `${command} ${args.join(" ")}` : command;
-    const child = spawn2(fullCommand, [], {
-      cwd,
-      stdio: "inherit",
-      shell: true,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(
-          new Error(
-            `Command "${command} ${args.join(" ")}" exited with code ${code}`
-          )
-        );
-      }
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
 async function setupReact(projectPath, isMonorepo = true) {
-  const appsDir = isMonorepo ? path2.join(projectPath, "apps") : path2.dirname(projectPath);
+  const appsDir = isMonorepo ? path3.join(projectPath, "apps") : path3.dirname(projectPath);
   console.log(pc7.magentaBright("\n\u{1F537} IMPORTANT INSTRUCTIONS:"));
   console.log(
     pc7.magentaBright(
@@ -1101,14 +1119,14 @@ async function setupReact(projectPath, isMonorepo = true) {
   );
   let beforeDirs = [];
   try {
-    beforeDirs = await fsPromises3.readdir(appsDir);
+    beforeDirs = await fsPromises4.readdir(appsDir);
   } catch {
   }
   try {
-    await runInteractiveCommand2("pnpm", ["create", "vite@latest"], appsDir);
+    await runInteractiveCommand("bunx", ["create-vite@latest"], appsDir);
     let afterDirs = [];
     try {
-      afterDirs = await fsPromises3.readdir(appsDir);
+      afterDirs = await fsPromises4.readdir(appsDir);
     } catch {
     }
     const newDirs = afterDirs.filter((d) => !beforeDirs.includes(d));
@@ -1116,17 +1134,18 @@ async function setupReact(projectPath, isMonorepo = true) {
     if (newDirs.length > 0) {
       createdDirName = newDirs[0];
     }
-    const webDir = path2.join(appsDir, createdDirName);
+    const webDir = path3.join(appsDir, createdDirName);
     try {
-      await fsPromises3.access(webDir);
+      await fsPromises4.access(webDir);
     } catch {
       throw new Error(
         `Vite React application directory "apps/${createdDirName}" was not found. Please ensure you complete the Vite installation.`
       );
     }
-    const pkgPath = path2.join(webDir, "package.json");
+    await removeBunLockfiles(webDir, projectPath);
+    const pkgPath = path3.join(webDir, "package.json");
     try {
-      const pkgRaw = await fsPromises3.readFile(pkgPath, "utf8");
+      const pkgRaw = await fsPromises4.readFile(pkgPath, "utf8");
       const pkg = JSON.parse(pkgRaw);
       if (isMonorepo) {
         pkg.name = "web";
@@ -1136,7 +1155,7 @@ async function setupReact(projectPath, isMonorepo = true) {
           onlyBuiltDependencies: ["esbuild"]
         };
       }
-      await fsPromises3.writeFile(pkgPath, JSON.stringify(pkg, null, 2), "utf8");
+      await fsPromises4.writeFile(pkgPath, JSON.stringify(pkg, null, 2), "utf8");
     } catch {
     }
     const aliasSpinner = spinner2();
@@ -1147,12 +1166,12 @@ async function setupReact(projectPath, isMonorepo = true) {
         silent: true
       });
       const tsconfigPaths = [
-        path2.join(webDir, "tsconfig.json"),
-        path2.join(webDir, "tsconfig.app.json")
+        path3.join(webDir, "tsconfig.json"),
+        path3.join(webDir, "tsconfig.app.json")
       ];
       for (const tsPath of tsconfigPaths) {
         try {
-          let content = await fsPromises3.readFile(tsPath, "utf8");
+          let content = await fsPromises4.readFile(tsPath, "utf8");
           if (content.includes('"compilerOptions"')) {
             if (!content.includes('"paths"')) {
               content = content.replace(
@@ -1163,7 +1182,7 @@ async function setupReact(projectPath, isMonorepo = true) {
       "@/*": ["./src/*"]
     },`
               );
-              await fsPromises3.writeFile(tsPath, content, "utf8");
+              await fsPromises4.writeFile(tsPath, content, "utf8");
             }
           } else {
             content = content.replace(
@@ -1176,14 +1195,14 @@ async function setupReact(projectPath, isMonorepo = true) {
     }
   },`
             );
-            await fsPromises3.writeFile(tsPath, content, "utf8");
+            await fsPromises4.writeFile(tsPath, content, "utf8");
           }
         } catch {
         }
       }
-      const viteConfigPath = path2.join(webDir, "vite.config.ts");
+      const viteConfigPath = path3.join(webDir, "vite.config.ts");
       try {
-        let content = await fsPromises3.readFile(viteConfigPath, "utf8");
+        let content = await fsPromises4.readFile(viteConfigPath, "utf8");
         if (!content.includes("import path from 'path'")) {
           content = "import path from 'path';\n" + content;
         }
@@ -1198,7 +1217,7 @@ async function setupReact(projectPath, isMonorepo = true) {
   }`
           );
         }
-        await fsPromises3.writeFile(viteConfigPath, content, "utf8");
+        await fsPromises4.writeFile(viteConfigPath, content, "utf8");
       } catch {
       }
       aliasSpinner.stop(
@@ -1242,9 +1261,9 @@ async function setupReact(projectPath, isMonorepo = true) {
           silent: true
         });
         s.message("Configuring Vite plugins and Tailwind CSS imports...");
-        const viteConfigPath = path2.join(webDir, "vite.config.ts");
+        const viteConfigPath = path3.join(webDir, "vite.config.ts");
         try {
-          let content = await fsPromises3.readFile(viteConfigPath, "utf8");
+          let content = await fsPromises4.readFile(viteConfigPath, "utf8");
           const hasReactCompiler = content.includes("reactCompilerPreset") || content.includes("@rolldown/plugin-babel") || content.includes("babel({");
           if (hasReactCompiler) {
             content = [
@@ -1271,7 +1290,7 @@ async function setupReact(projectPath, isMonorepo = true) {
               "});",
               ""
             ].join("\n");
-            await fsPromises3.writeFile(viteConfigPath, content, "utf8");
+            await fsPromises4.writeFile(viteConfigPath, content, "utf8");
           } else if (!content.includes("@tailwindcss/vite")) {
             content = "import tailwindcss from '@tailwindcss/vite';\n" + content;
             if (content.includes("plugins: [react()]")) {
@@ -1290,13 +1309,13 @@ async function setupReact(projectPath, isMonorepo = true) {
                 "$1\n    tailwindcss(),\n  $2"
               );
             }
-            await fsPromises3.writeFile(viteConfigPath, content, "utf8");
+            await fsPromises4.writeFile(viteConfigPath, content, "utf8");
           }
         } catch {
         }
-        const indexCssPath = path2.join(webDir, "src", "index.css");
+        const indexCssPath = path3.join(webDir, "src", "index.css");
         try {
-          await fsPromises3.writeFile(
+          await fsPromises4.writeFile(
             indexCssPath,
             '@import "tailwindcss";\n',
             "utf8"
@@ -1330,7 +1349,7 @@ async function setupReact(projectPath, isMonorepo = true) {
         handleCancel(enteredPreset);
         presetCode = enteredPreset.trim();
       }
-      const args = ["dlx", "shadcn@latest", "init"];
+      const args = ["shadcn@latest", "init"];
       if (presetCode) {
         args.push("--preset", presetCode);
       }
@@ -1338,7 +1357,8 @@ async function setupReact(projectPath, isMonorepo = true) {
       console.log(
         pc7.cyan("\nStarting interactive shadcn UI initialization...")
       );
-      await runInteractiveCommand2("pnpm", args, webDir);
+      await runInteractiveCommand("bunx", args, webDir);
+      await removeBunLockfiles(webDir, projectPath);
       console.log(
         pc7.green(
           isMonorepo ? `
@@ -1362,8 +1382,8 @@ async function setupReact(projectPath, isMonorepo = true) {
 // src/modules/git/git.ts
 import { confirm as confirm2, spinner as spinner3 } from "@clack/prompts";
 import pc8 from "picocolors";
-import fsPromises4 from "fs/promises";
-import path3 from "path";
+import fsPromises5 from "fs/promises";
+import path4 from "path";
 async function promptGit() {
   return await confirm2({
     message: "Do you want to initialize a local Git repository?",
@@ -1408,8 +1428,8 @@ async function gitInit(projectPath) {
     "Thumbs.db",
     ""
   ].join("\n");
-  await fsPromises4.writeFile(
-    path3.join(projectPath, ".gitignore"),
+  await fsPromises5.writeFile(
+    path4.join(projectPath, ".gitignore"),
     gitignore,
     "utf8"
   );
@@ -1436,10 +1456,10 @@ Error details: ${error.message || error}`));
 }
 
 // src/modules/workspace/readme.ts
-import fsPromises5 from "fs/promises";
-import path4 from "path";
+import fsPromises6 from "fs/promises";
+import path5 from "path";
 async function setupReadme(projectPath, workspaceName, options = {}) {
-  const readmePath = path4.join(projectPath, "README.md");
+  const readmePath = path5.join(projectPath, "README.md");
   let dockerDocs = [];
   if (options.hasDocker) {
     if (options.hasDockerScripts) {
@@ -1558,14 +1578,15 @@ async function setupReadme(projectPath, workspaceName, options = {}) {
     "*Generated with love by [Morax Scaffolder CLI](https://github.com/Elitedv/morax).*",
     ""
   ].join("\n");
-  await fsPromises5.writeFile(readmePath, readmeContent, "utf8");
+  await fsPromises6.writeFile(readmePath, readmeContent, "utf8");
 }
 
 // src/standalone/react-runner.ts
 async function runReactScaffolder(name, projectPath) {
   const finalProjectPath = await setupReact(projectPath, false);
-  await setupReadme(finalProjectPath, path5.basename(finalProjectPath));
+  await setupReadme(finalProjectPath, path6.basename(finalProjectPath));
   await runGitSetup(finalProjectPath);
+  await removeBunLockfiles(finalProjectPath);
   const installSpinner = spinner4();
   installSpinner.start("Running final package installation...");
   try {
@@ -1578,67 +1599,46 @@ async function runReactScaffolder(name, projectPath) {
     console.error(pc9.red(`
 Error details: ${error.message || error}`));
   }
-  endCli(path5.basename(finalProjectPath), finalProjectPath);
+  endCli(path6.basename(finalProjectPath), finalProjectPath);
 }
 
 // src/standalone/next-runner.ts
-import path8 from "path";
+import path9 from "path";
 import { spinner as spinner5 } from "@clack/prompts";
 import pc12 from "picocolors";
 
 // src/modules/apps/web/nextjs.ts
 import { confirm as confirm3 } from "@clack/prompts";
 import pc10 from "picocolors";
-import fsPromises6 from "fs/promises";
-import path6 from "path";
-import { spawn as spawn3 } from "child_process";
-function runInteractiveCommand3(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const fullCommand = args.length > 0 ? `${command} ${args.join(" ")}` : command;
-    const child = spawn3(fullCommand, [], {
-      cwd,
-      stdio: "inherit",
-      shell: true,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Command "${fullCommand}" exited with code ${code}`));
-      }
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
+import fsPromises7 from "fs/promises";
+import path7 from "path";
 async function setupNextjs(projectPath, isMonorepo = true) {
-  const appsDir = isMonorepo ? path6.join(projectPath, "apps") : path6.dirname(projectPath);
-  const targetName = isMonorepo ? "web" : path6.basename(projectPath);
-  const webDir = path6.join(appsDir, targetName);
+  const appsDir = isMonorepo ? path7.join(projectPath, "apps") : path7.dirname(projectPath);
+  const targetName = isMonorepo ? "web" : path7.basename(projectPath);
+  const webDir = path7.join(appsDir, targetName);
   try {
-    await fsPromises6.rm(webDir, { recursive: true, force: true });
+    await fsPromises7.rm(webDir, { recursive: true, force: true });
   } catch {
   }
   console.log(pc10.cyan("\nStarting interactive Next.js application setup..."));
-  await runInteractiveCommand3(
-    "pnpm",
-    ["dlx", "create-next-app@latest", targetName],
+  await runInteractiveCommand(
+    "bunx",
+    ["create-next-app@latest", targetName],
     appsDir
   );
+  await removeBunLockfiles(webDir, projectPath);
   if (isMonorepo) {
     try {
-      await fsPromises6.rm(path6.join(webDir, ".git"), {
+      await fsPromises7.rm(path7.join(webDir, ".git"), {
         recursive: true,
         force: true
       });
     } catch {
     }
   }
-  const webPkgPath = path6.join(webDir, "package.json");
+  const webPkgPath = path7.join(webDir, "package.json");
   try {
-    const webPkgRaw = await fsPromises6.readFile(webPkgPath, "utf8");
+    const webPkgRaw = await fsPromises7.readFile(webPkgPath, "utf8");
     const webPkg = JSON.parse(webPkgRaw);
     if (isMonorepo) {
       webPkg.name = "web";
@@ -1648,7 +1648,7 @@ async function setupNextjs(projectPath, isMonorepo = true) {
         onlyBuiltDependencies: ["sharp"]
       };
     }
-    await fsPromises6.writeFile(
+    await fsPromises7.writeFile(
       webPkgPath,
       JSON.stringify(webPkg, null, 2),
       "utf8"
@@ -1661,52 +1661,28 @@ async function setupNextjs(projectPath, isMonorepo = true) {
 // src/modules/apps/web/shadcn.ts
 import { confirm as confirm4 } from "@clack/prompts";
 import pc11 from "picocolors";
-import fsPromises7 from "fs/promises";
-import path7 from "path";
-import { spawn as spawn4 } from "child_process";
+import fsPromises8 from "fs/promises";
+import path8 from "path";
 async function promptShadcn() {
   return await confirm4({
     message: "Do you want to setup shadcn UI in your Next.js website (apps/web)?",
     initialValue: true
   });
 }
-function runInteractiveCommand4(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn4(command, args, {
-      cwd,
-      stdio: "inherit",
-      shell: true,
-      env: { ...process.env, NODE_NO_WARNINGS: "1" }
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(
-          new Error(
-            `Command "${command} ${args.join(" ")}" exited with code ${code}`
-          )
-        );
-      }
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
 async function setupShadcn(projectPath, isMonorepo = true) {
-  const webDir = isMonorepo ? path7.join(projectPath, "apps", "web") : projectPath;
+  const webDir = isMonorepo ? path8.join(projectPath, "apps", "web") : projectPath;
   console.log(pc11.cyan("\nStarting interactive shadcn UI initialization..."));
-  await runInteractiveCommand4(
-    "pnpm",
-    ["dlx", "shadcn@latest", "init", "--template", "next"],
+  await runInteractiveCommand(
+    "bunx",
+    ["shadcn@latest", "init", "--template", "next"],
     webDir
   );
+  await removeBunLockfiles(webDir, projectPath);
 }
 async function runShadcnSetup(projectPath, isMonorepo = true) {
-  const webDir = isMonorepo ? path7.join(projectPath, "apps", "web") : projectPath;
+  const webDir = isMonorepo ? path8.join(projectPath, "apps", "web") : projectPath;
   try {
-    await fsPromises7.access(webDir);
+    await fsPromises8.access(webDir);
   } catch {
     return;
   }
@@ -1734,8 +1710,9 @@ async function runShadcnSetup(projectPath, isMonorepo = true) {
 async function runNextScaffolder(name, projectPath) {
   const finalProjectPath = await setupNextjs(projectPath, false);
   await runShadcnSetup(finalProjectPath, false);
-  await setupReadme(finalProjectPath, path8.basename(finalProjectPath));
+  await setupReadme(finalProjectPath, path9.basename(finalProjectPath));
   await runGitSetup(finalProjectPath);
+  await removeBunLockfiles(finalProjectPath);
   const installSpinner = spinner5();
   installSpinner.start("Running final package installation...");
   try {
@@ -1748,20 +1725,20 @@ async function runNextScaffolder(name, projectPath) {
     console.error(pc12.red(`
 Error details: ${error.message || error}`));
   }
-  endCli(path8.basename(finalProjectPath), finalProjectPath);
+  endCli(path9.basename(finalProjectPath), finalProjectPath);
 }
 
 // src/modules/workspace/directories.ts
 import { spinner as spinner6 } from "@clack/prompts";
-import fsPromises9 from "fs/promises";
-import path10 from "path";
+import fsPromises10 from "fs/promises";
+import path11 from "path";
 import pc13 from "picocolors";
 
 // src/modules/workspace/config.ts
-import fsPromises8 from "fs/promises";
-import path9 from "path";
+import fsPromises9 from "fs/promises";
+import path10 from "path";
 async function generateWorkspaceConfig(name, directories, projectPath) {
-  await fsPromises8.mkdir(projectPath, { recursive: true });
+  await fsPromises9.mkdir(projectPath, { recursive: true });
   const defaultOnlyBuiltDeps = [
     "esbuild",
     "@biomejs/biome",
@@ -1779,14 +1756,14 @@ async function generateWorkspaceConfig(name, directories, projectPath) {
     ),
     ""
   ].join("\n");
-  await fsPromises8.writeFile(
-    path9.join(projectPath, "pnpm-workspace.yaml"),
+  await fsPromises9.writeFile(
+    path10.join(projectPath, "pnpm-workspace.yaml"),
     workspaceYamlContent,
     "utf8"
   );
   await runCommand("pnpm init", { cwd: projectPath, silent: true });
-  const packageJsonPath = path9.join(projectPath, "package.json");
-  const packageJsonRaw = await fsPromises8.readFile(packageJsonPath, "utf8");
+  const packageJsonPath = path10.join(projectPath, "package.json");
+  const packageJsonRaw = await fsPromises9.readFile(packageJsonPath, "utf8");
   const pkg = JSON.parse(packageJsonRaw);
   pkg.name = name;
   pkg.description = "High-performance monorepo workspace generated by Morax";
@@ -1801,15 +1778,12 @@ async function generateWorkspaceConfig(name, directories, projectPath) {
   } catch {
     pkg.packageManager = "pnpm@latest";
   }
-  pkg.pnpm = {
-    onlyBuiltDependencies: defaultOnlyBuiltDeps
-  };
   pkg.workspaces = directories.map((dir) => `${dir}/*`);
   pkg.scripts = {
     dev: "pnpm -r --parallel dev"
   };
   delete pkg.main;
-  await fsPromises8.writeFile(
+  await fsPromises9.writeFile(
     packageJsonPath,
     JSON.stringify(pkg, null, 2),
     "utf8"
@@ -1819,10 +1793,10 @@ async function generateWorkspaceConfig(name, directories, projectPath) {
 // src/modules/workspace/directories.ts
 async function createDirectories(directories, projectPath) {
   for (const dir of directories) {
-    const dirPath = path10.join(projectPath, dir);
-    await fsPromises9.mkdir(dirPath, { recursive: true });
-    await fsPromises9.writeFile(
-      path10.join(dirPath, ".gitkeep"),
+    const dirPath = path11.join(projectPath, dir);
+    await fsPromises10.mkdir(dirPath, { recursive: true });
+    await fsPromises10.writeFile(
+      path11.join(dirPath, ".gitkeep"),
       `# Placeholder to ensure git tracks the empty ${dir}/ folder
 `,
       "utf8"
@@ -1851,11 +1825,11 @@ import { multiselect as multiselect2, select as select4, spinner as spinner7 } f
 import pc14 from "picocolors";
 
 // src/modules/workspace/docs.ts
-import fsPromises10 from "fs/promises";
-import path11 from "path";
+import fsPromises11 from "fs/promises";
+import path12 from "path";
 async function setupProjectDocs(projectPath, options) {
-  const docsDir = path11.join(projectPath, "docs");
-  await fsPromises10.mkdir(docsDir, { recursive: true });
+  const docsDir = path12.join(projectPath, "docs");
+  await fsPromises11.mkdir(docsDir, { recursive: true });
   const {
     projectName,
     hasServer,
@@ -1913,8 +1887,8 @@ async function setupProjectDocs(projectPath, options) {
     "Internal workspace dependencies are linked using pnpm workspace protocols (`workspace:*`).",
     ""
   ].join("\n");
-  await fsPromises10.writeFile(
-    path11.join(docsDir, "ARCHITECTURE.md"),
+  await fsPromises11.writeFile(
+    path12.join(docsDir, "ARCHITECTURE.md"),
     architectureMd,
     "utf8"
   );
@@ -1952,7 +1926,7 @@ async function setupProjectDocs(projectPath, options) {
       "```",
       ""
     ].join("\n");
-    await fsPromises10.writeFile(path11.join(docsDir, "DATABASE.md"), dbMd, "utf8");
+    await fsPromises11.writeFile(path12.join(docsDir, "DATABASE.md"), dbMd, "utf8");
   }
   if (hasServer) {
     const serverMd = [
@@ -1975,8 +1949,8 @@ async function setupProjectDocs(projectPath, options) {
       "```",
       ""
     ].join("\n");
-    await fsPromises10.writeFile(
-      path11.join(docsDir, "SERVER.md"),
+    await fsPromises11.writeFile(
+      path12.join(docsDir, "SERVER.md"),
       serverMd,
       "utf8"
     );
@@ -2011,7 +1985,7 @@ async function setupProjectDocs(projectPath, options) {
       "2. Update the corresponding schema in `packages/env/src/schema/*.ts`.",
       ""
     ].join("\n");
-    await fsPromises10.writeFile(path11.join(docsDir, "ENV.md"), envMd, "utf8");
+    await fsPromises11.writeFile(path12.join(docsDir, "ENV.md"), envMd, "utf8");
   }
   if (hasDocker) {
     const dockerMd = [
@@ -2059,8 +2033,8 @@ async function setupProjectDocs(projectPath, options) {
       "Docker Compose automatically loads root variables using `--env-file .env`.",
       ""
     ].join("\n");
-    await fsPromises10.writeFile(
-      path11.join(docsDir, "DOCKER.md"),
+    await fsPromises11.writeFile(
+      path12.join(docsDir, "DOCKER.md"),
       dockerMd,
       "utf8"
     );
@@ -2082,7 +2056,7 @@ async function setupProjectDocs(projectPath, options) {
       "```",
       ""
     ].join("\n");
-    await fsPromises10.writeFile(path11.join(docsDir, "WEB.md"), webMd, "utf8");
+    await fsPromises11.writeFile(path12.join(docsDir, "WEB.md"), webMd, "utf8");
   }
   if (hasAuth) {
     const authMd = [
@@ -2125,13 +2099,13 @@ async function setupProjectDocs(projectPath, options) {
       "- `verification`: Email verification and password reset tokens",
       ""
     ].join("\n");
-    await fsPromises10.writeFile(path11.join(docsDir, "AUTH.md"), authMd, "utf8");
+    await fsPromises11.writeFile(path12.join(docsDir, "AUTH.md"), authMd, "utf8");
   }
 }
 
 // src/modules/workspace/agents.ts
-import fsPromises11 from "fs/promises";
-import path12 from "path";
+import fsPromises12 from "fs/promises";
+import path13 from "path";
 function generateClaudeMd(options) {
   const {
     projectName,
@@ -2321,21 +2295,21 @@ function generateAgentsMd(options) {
 async function setupAgentDocs(projectPath, options) {
   const claudeContent = generateClaudeMd(options);
   const agentsContent = generateAgentsMd(options);
-  await fsPromises11.writeFile(
-    path12.join(projectPath, "CLAUDE.md"),
+  await fsPromises12.writeFile(
+    path13.join(projectPath, "CLAUDE.md"),
     claudeContent,
     "utf8"
   );
-  await fsPromises11.writeFile(
-    path12.join(projectPath, "AGENTS.md"),
+  await fsPromises12.writeFile(
+    path13.join(projectPath, "AGENTS.md"),
     agentsContent,
     "utf8"
   );
 }
 
 // src/modules/workspace/license.ts
-import fsPromises12 from "fs/promises";
-import path13 from "path";
+import fsPromises13 from "fs/promises";
+import path14 from "path";
 function getLicenseText(licenseType, year, author) {
   switch (licenseType) {
     case "MIT":
@@ -2464,19 +2438,19 @@ For more information, please refer to <https://unlicense.org>
 async function setupLicense(projectPath, licenseType, author) {
   const year = (/* @__PURE__ */ new Date()).getFullYear();
   const licenseContent = getLicenseText(licenseType, year, author);
-  await fsPromises12.writeFile(
-    path13.join(projectPath, "LICENSE"),
+  await fsPromises13.writeFile(
+    path14.join(projectPath, "LICENSE"),
     licenseContent,
     "utf8"
   );
 }
 
 // src/modules/workspace/scripts.ts
-import fsPromises13 from "fs/promises";
-import path14 from "path";
+import fsPromises14 from "fs/promises";
+import path15 from "path";
 async function setupDockerScripts(projectPath, options = {}) {
-  const scriptsDir = path14.join(projectPath, "scripts");
-  await fsPromises13.mkdir(scriptsDir, { recursive: true });
+  const scriptsDir = path15.join(projectPath, "scripts");
+  await fsPromises14.mkdir(scriptsDir, { recursive: true });
   const hasPostgres = !!options.postgres;
   const hasRedis = !!options.redis;
   const validActions = ["infra-up", "infra-down"];
@@ -2528,8 +2502,8 @@ async function setupDockerScripts(projectPath, options = {}) {
     "esac",
     ""
   );
-  await fsPromises13.writeFile(
-    path14.join(scriptsDir, "command.sh"),
+  await fsPromises14.writeFile(
+    path15.join(scriptsDir, "command.sh"),
     shellLines.join("\n"),
     { encoding: "utf8", mode: 493 }
   );
@@ -2647,8 +2621,8 @@ async function promptAndSetupExtras(projectPath, options) {
 // src/modules/skills/index.ts
 import { confirm as confirm5 } from "@clack/prompts";
 import pc15 from "picocolors";
-import fsPromises14 from "fs/promises";
-import path15 from "path";
+import fsPromises15 from "fs/promises";
+import path16 from "path";
 async function promptSkills() {
   const result = await confirm5({
     message: "Install AI Agent Skills (skills.sh)?",
@@ -2658,31 +2632,31 @@ async function promptSkills() {
   return result;
 }
 async function moveRulesToAgentRoot(projectPath) {
-  const targetRulesDir = path15.join(projectPath, ".agents", "rules");
+  const targetRulesDir = path16.join(projectPath, ".agents", "rules");
   const sourceCandidates = [
-    path15.join(projectPath, ".agents", "skills", "rules"),
-    path15.join(projectPath, ".agent", "skills", "rules"),
-    path15.join(projectPath, ".agent", "rules")
+    path16.join(projectPath, ".agents", "skills", "rules"),
+    path16.join(projectPath, ".agent", "skills", "rules"),
+    path16.join(projectPath, ".agent", "rules")
   ];
   let moved = false;
   for (const sourceDir of sourceCandidates) {
     try {
-      await fsPromises14.access(sourceDir);
+      await fsPromises15.access(sourceDir);
     } catch {
       continue;
     }
-    await fsPromises14.mkdir(targetRulesDir, { recursive: true });
+    await fsPromises15.mkdir(targetRulesDir, { recursive: true });
     try {
-      const entries = await fsPromises14.readdir(sourceDir);
+      const entries = await fsPromises15.readdir(sourceDir);
       for (const entry of entries) {
-        const srcPath = path15.join(sourceDir, entry);
-        const destPath = path15.join(targetRulesDir, entry);
-        await fsPromises14.cp(srcPath, destPath, {
+        const srcPath = path16.join(sourceDir, entry);
+        const destPath = path16.join(targetRulesDir, entry);
+        await fsPromises15.cp(srcPath, destPath, {
           recursive: true,
           force: true
         });
       }
-      await fsPromises14.rm(sourceDir, { recursive: true, force: true });
+      await fsPromises15.rm(sourceDir, { recursive: true, force: true });
       moved = true;
     } catch (err) {
       console.log(
@@ -2693,17 +2667,17 @@ async function moveRulesToAgentRoot(projectPath) {
       );
     }
   }
-  const agentDir = path15.join(projectPath, ".agent");
+  const agentDir = path16.join(projectPath, ".agent");
   try {
-    const remaining = await fsPromises14.readdir(agentDir);
+    const remaining = await fsPromises15.readdir(agentDir);
     if (remaining.length === 0) {
-      await fsPromises14.rm(agentDir, { recursive: true, force: true });
+      await fsPromises15.rm(agentDir, { recursive: true, force: true });
     } else if (remaining.length === 1 && remaining[0] === "skills") {
-      const skillsRemaining = await fsPromises14.readdir(
-        path15.join(agentDir, "skills")
+      const skillsRemaining = await fsPromises15.readdir(
+        path16.join(agentDir, "skills")
       );
       if (skillsRemaining.length === 0) {
-        await fsPromises14.rm(agentDir, { recursive: true, force: true });
+        await fsPromises15.rm(agentDir, { recursive: true, force: true });
       }
     }
   } catch {
@@ -2734,22 +2708,22 @@ async function installSkills(projectPath) {
     );
   }
   await moveRulesToAgentRoot(projectPath);
-  const claudeDir = path15.join(projectPath, ".claude");
+  const claudeDir = path16.join(projectPath, ".claude");
   try {
-    await fsPromises14.rm(claudeDir, { recursive: true, force: true });
+    await fsPromises15.rm(claudeDir, { recursive: true, force: true });
   } catch {
   }
-  const gitignorePath = path15.join(projectPath, ".gitignore");
+  const gitignorePath = path16.join(projectPath, ".gitignore");
   try {
     let gitignoreContent = "";
     try {
-      gitignoreContent = await fsPromises14.readFile(gitignorePath, "utf8");
+      gitignoreContent = await fsPromises15.readFile(gitignorePath, "utf8");
     } catch {
       gitignoreContent = "";
     }
     if (!gitignoreContent.includes(".agents")) {
       const entry = gitignoreContent ? "\n# AI Agent Skills & Tooling\n.agents/\n.agent/\n" : "# AI Agent Skills & Tooling\n.agents/\n.agent/\n";
-      await fsPromises14.appendFile(gitignorePath, entry, "utf8");
+      await fsPromises15.appendFile(gitignorePath, entry, "utf8");
     }
   } catch {
   }
@@ -2762,8 +2736,8 @@ async function promptAndInstallSkills(projectPath) {
 }
 
 // src/modules/workspace/env.ts
-import fsPromises15 from "fs/promises";
-import path16 from "path";
+import fsPromises16 from "fs/promises";
+import path17 from "path";
 async function setupRootEnv(projectPath, options = {}) {
   const envLines = [
     "# ==============================================================================",
@@ -2838,13 +2812,13 @@ async function setupRootEnv(projectPath, options = {}) {
     }
   }
   const envContent = envLines.join("\n");
-  await fsPromises15.writeFile(
-    path16.join(projectPath, ".env"),
+  await fsPromises16.writeFile(
+    path17.join(projectPath, ".env"),
     envContent,
     "utf8"
   );
-  await fsPromises15.writeFile(
-    path16.join(projectPath, ".env.example"),
+  await fsPromises16.writeFile(
+    path17.join(projectPath, ".env.example"),
     envContent,
     "utf8"
   );
@@ -2853,15 +2827,21 @@ async function setupRootEnv(projectPath, options = {}) {
 // src/modules/git/husky.ts
 import { confirm as confirm6, spinner as spinner8 } from "@clack/prompts";
 import pc16 from "picocolors";
-import fsPromises16 from "fs/promises";
-import path17 from "path";
+import fsPromises17 from "fs/promises";
+import path18 from "path";
 async function setupHusky(projectPath) {
-  await runCommand("pnpm add -D -E husky -w", { cwd: projectPath });
-  await runCommand("pnpm exec husky init", { cwd: projectPath });
-  const preCommitPath = path17.join(projectPath, ".husky", "pre-commit");
+  await runCommand("pnpm add -D -E husky -w", {
+    cwd: projectPath,
+    silent: true
+  });
+  await runCommand("pnpm exec husky init", {
+    cwd: projectPath,
+    silent: true
+  });
+  const preCommitPath = path18.join(projectPath, ".husky", "pre-commit");
   let hookContent = "";
   try {
-    hookContent = await fsPromises16.readFile(preCommitPath, "utf8");
+    hookContent = await fsPromises17.readFile(preCommitPath, "utf8");
   } catch {
     hookContent = "pnpm test";
   }
@@ -2869,9 +2849,9 @@ async function setupHusky(projectPath) {
   if (!hookContent.includes("git add .")) {
     hookContent = hookContent.trim() + "\ngit add .\n";
   }
-  await fsPromises16.writeFile(preCommitPath, hookContent, "utf8");
+  await fsPromises17.writeFile(preCommitPath, hookContent, "utf8");
   try {
-    await fsPromises16.chmod(preCommitPath, 493);
+    await fsPromises17.chmod(preCommitPath, 493);
   } catch {
   }
 }
@@ -2893,8 +2873,8 @@ Error details: ${error.message || error}`));
 // src/modules/git/lefthook.ts
 import { spinner as spinner9 } from "@clack/prompts";
 import pc17 from "picocolors";
-import fsPromises17 from "fs/promises";
-import path18 from "path";
+import fsPromises18 from "fs/promises";
+import path19 from "path";
 async function setupLefthook(projectPath, hasFormatter, hasLinter) {
   await runCommand("pnpm add -D lefthook -w", {
     cwd: projectPath,
@@ -2924,17 +2904,17 @@ async function setupLefthook(projectPath, hasFormatter, hasLinter) {
     ...commands,
     ""
   ].join("\n");
-  await fsPromises17.writeFile(
-    path18.join(projectPath, "lefthook.yml"),
+  await fsPromises18.writeFile(
+    path19.join(projectPath, "lefthook.yml"),
     lefthookConfig,
     "utf8"
   );
-  const rootPackagePath = path18.join(projectPath, "package.json");
-  const rootPackageRaw = await fsPromises17.readFile(rootPackagePath, "utf8");
+  const rootPackagePath = path19.join(projectPath, "package.json");
+  const rootPackageRaw = await fsPromises18.readFile(rootPackagePath, "utf8");
   const rootPkg = JSON.parse(rootPackageRaw);
   rootPkg.scripts = rootPkg.scripts || {};
   rootPkg.scripts.prepare = "lefthook install";
-  await fsPromises17.writeFile(
+  await fsPromises18.writeFile(
     rootPackagePath,
     JSON.stringify(rootPkg, null, 2),
     "utf8"
@@ -2962,8 +2942,8 @@ Error details: ${error.message || error}`));
 // src/modules/quality/biome.ts
 import { spinner as spinner10 } from "@clack/prompts";
 import pc18 from "picocolors";
-import fsPromises18 from "fs/promises";
-import path19 from "path";
+import fsPromises19 from "fs/promises";
+import path20 from "path";
 async function setupBiome(projectPath, options) {
   await runCommand("pnpm add -D -E @biomejs/biome -w", {
     cwd: projectPath,
@@ -2992,8 +2972,8 @@ async function setupBiome(projectPath, options) {
       }
     }
   };
-  await fsPromises18.writeFile(
-    path19.join(projectPath, "biome.json"),
+  await fsPromises19.writeFile(
+    path20.join(projectPath, "biome.json"),
     JSON.stringify(biomeConfig, null, 2),
     "utf8"
   );
@@ -3004,8 +2984,8 @@ async function setupBiome(projectPath, options) {
     });
   } catch {
   }
-  const rootPackagePath = path19.join(projectPath, "package.json");
-  const rootPackageRaw = await fsPromises18.readFile(rootPackagePath, "utf8");
+  const rootPackagePath = path20.join(projectPath, "package.json");
+  const rootPackageRaw = await fsPromises19.readFile(rootPackagePath, "utf8");
   const rootPkg = JSON.parse(rootPackageRaw);
   rootPkg.scripts = rootPkg.scripts || {};
   if (options.linter) {
@@ -3018,7 +2998,7 @@ async function setupBiome(projectPath, options) {
   if (options.linter && options.formatter) {
     rootPkg.scripts.check = "biome check --write .";
   }
-  await fsPromises18.writeFile(
+  await fsPromises19.writeFile(
     rootPackagePath,
     JSON.stringify(rootPkg, null, 2),
     "utf8"
@@ -3042,8 +3022,8 @@ Error details: ${error.message || error}`));
 // src/modules/quality/oxlint.ts
 import { spinner as spinner11 } from "@clack/prompts";
 import pc19 from "picocolors";
-import fsPromises19 from "fs/promises";
-import path20 from "path";
+import fsPromises20 from "fs/promises";
+import path21 from "path";
 async function setupOxlint(projectPath) {
   await runCommand("pnpm add -D -E oxlint -w", {
     cwd: projectPath,
@@ -3060,19 +3040,19 @@ async function setupOxlint(projectPath) {
       "no-debugger": "error"
     }
   };
-  await fsPromises19.writeFile(
-    path20.join(projectPath, ".oxlintrc.json"),
+  await fsPromises20.writeFile(
+    path21.join(projectPath, ".oxlintrc.json"),
     JSON.stringify(oxlintConfig, null, 2),
     "utf8"
   );
-  const rootPackagePath = path20.join(projectPath, "package.json");
-  const rootPackageContent = await fsPromises19.readFile(rootPackagePath, "utf8");
+  const rootPackagePath = path21.join(projectPath, "package.json");
+  const rootPackageContent = await fsPromises20.readFile(rootPackagePath, "utf8");
   const rootPkg = JSON.parse(rootPackageContent);
   rootPkg.scripts = {
     ...rootPkg.scripts || {},
     lint: "oxlint ."
   };
-  await fsPromises19.writeFile(
+  await fsPromises20.writeFile(
     rootPackagePath,
     JSON.stringify(rootPkg, null, 2),
     "utf8"
@@ -3097,10 +3077,13 @@ Error details: ${error.message || error}`));
 // src/modules/quality/prettier.ts
 import { confirm as confirm7, spinner as spinner12 } from "@clack/prompts";
 import pc20 from "picocolors";
-import fsPromises20 from "fs/promises";
-import path21 from "path";
+import fsPromises21 from "fs/promises";
+import path22 from "path";
 async function setupPrettier(projectPath) {
-  await runCommand("pnpm add -D -E prettier -w", { cwd: projectPath });
+  await runCommand("pnpm add -D -E prettier -w", {
+    cwd: projectPath,
+    silent: true
+  });
   const prettierConfig = {
     semi: true,
     singleQuote: true,
@@ -3108,8 +3091,8 @@ async function setupPrettier(projectPath) {
     tabWidth: 2,
     printWidth: 80
   };
-  await fsPromises20.writeFile(
-    path21.join(projectPath, ".prettierrc"),
+  await fsPromises21.writeFile(
+    path22.join(projectPath, ".prettierrc"),
     JSON.stringify(prettierConfig, null, 2),
     "utf8"
   );
@@ -3121,19 +3104,19 @@ async function setupPrettier(projectPath) {
     "pnpm-lock.yaml",
     ""
   ].join("\n");
-  await fsPromises20.writeFile(
-    path21.join(projectPath, ".prettierignore"),
+  await fsPromises21.writeFile(
+    path22.join(projectPath, ".prettierignore"),
     prettierIgnore,
     "utf8"
   );
-  const rootPackagePath = path21.join(projectPath, "package.json");
-  const rootPackageRaw = await fsPromises20.readFile(rootPackagePath, "utf8");
+  const rootPackagePath = path22.join(projectPath, "package.json");
+  const rootPackageRaw = await fsPromises21.readFile(rootPackagePath, "utf8");
   const pkg = JSON.parse(rootPackageRaw);
   pkg.scripts = {
     ...pkg.scripts || {},
     format: "prettier --write ."
   };
-  await fsPromises20.writeFile(
+  await fsPromises21.writeFile(
     rootPackagePath,
     JSON.stringify(pkg, null, 2),
     "utf8"
@@ -3157,14 +3140,14 @@ Error details: ${error.message || error}`));
 // src/modules/packages/typescript.ts
 import { spinner as spinner13 } from "@clack/prompts";
 import pc21 from "picocolors";
-import fsPromises21 from "fs/promises";
-import path22 from "path";
+import fsPromises22 from "fs/promises";
+import path23 from "path";
 async function setupTypescript(projectPath) {
-  const tsDir = path22.join(projectPath, "packages", "typescript");
-  await fsPromises21.mkdir(tsDir, { recursive: true });
+  const tsDir = path23.join(projectPath, "packages", "typescript");
+  await fsPromises22.mkdir(tsDir, { recursive: true });
   await runCommand("pnpm init", { cwd: tsDir, silent: true });
-  const tsPackagePath = path22.join(tsDir, "package.json");
-  const tsPackageRaw = await fsPromises21.readFile(tsPackagePath, "utf8");
+  const tsPackagePath = path23.join(tsDir, "package.json");
+  const tsPackageRaw = await fsPromises22.readFile(tsPackagePath, "utf8");
   const tsPkg = JSON.parse(tsPackageRaw);
   tsPkg.name = "@config/typescript";
   tsPkg.version = "1.0.0";
@@ -3175,7 +3158,7 @@ async function setupTypescript(projectPath) {
   delete tsPkg.keywords;
   delete tsPkg.author;
   delete tsPkg.license;
-  await fsPromises21.writeFile(
+  await fsPromises22.writeFile(
     tsPackagePath,
     JSON.stringify(tsPkg, null, 2),
     "utf8"
@@ -3194,16 +3177,16 @@ async function setupTypescript(projectPath) {
       isolatedModules: true
     }
   };
-  await fsPromises21.writeFile(
-    path22.join(tsDir, "tsconfig.json"),
+  await fsPromises22.writeFile(
+    path23.join(tsDir, "tsconfig.json"),
     JSON.stringify(tsconfigContent, null, 2),
     "utf8"
   );
 }
 async function runTypescriptSetup(projectPath) {
-  const packagesDir = path22.join(projectPath, "packages");
+  const packagesDir = path23.join(projectPath, "packages");
   try {
-    await fsPromises21.access(packagesDir);
+    await fsPromises22.access(packagesDir);
   } catch {
     return;
   }
@@ -3225,14 +3208,14 @@ Error details: ${error.message || error}`));
 }
 
 // src/modules/apps/server/index.ts
-import fsPromises28 from "fs/promises";
-import path31 from "path";
+import fsPromises29 from "fs/promises";
+import path32 from "path";
 import { spinner as spinner16 } from "@clack/prompts";
 import pc24 from "picocolors";
 
 // src/modules/apps/server/frameworks/express/index.ts
-import fsPromises22 from "fs/promises";
-import path23 from "path";
+import fsPromises23 from "fs/promises";
+import path24 from "path";
 
 // src/modules/apps/server/frameworks/express/package.ts
 function getExpressDependencies() {
@@ -3398,13 +3381,13 @@ function renderExpressBunTemplate(hasDb) {
 // src/modules/apps/server/frameworks/express/index.ts
 async function setupExpress(options) {
   const { projectPath, runtime, linter, orm } = options;
-  const serverDir = path23.join(projectPath, "apps", "server");
-  const srcDir = path23.join(serverDir, "src");
+  const serverDir = path24.join(projectPath, "apps", "server");
+  const srcDir = path24.join(serverDir, "src");
   const hasDb = orm !== "none";
-  await fsPromises22.mkdir(srcDir, { recursive: true });
+  await fsPromises23.mkdir(srcDir, { recursive: true });
   await runCommand("pnpm init", { cwd: serverDir, silent: true });
-  const serverPackagePath = path23.join(serverDir, "package.json");
-  const serverPackageRaw = await fsPromises22.readFile(serverPackagePath, "utf8");
+  const serverPackagePath = path24.join(serverDir, "package.json");
+  const serverPackageRaw = await fsPromises23.readFile(serverPackagePath, "utf8");
   const serverPkg = JSON.parse(serverPackageRaw);
   serverPkg.name = "server";
   serverPkg.version = "1.0.0";
@@ -3424,7 +3407,7 @@ async function setupExpress(options) {
   delete serverPkg.keywords;
   delete serverPkg.author;
   delete serverPkg.license;
-  await fsPromises22.writeFile(
+  await fsPromises23.writeFile(
     serverPackagePath,
     JSON.stringify(serverPkg, null, 2),
     "utf8"
@@ -3437,8 +3420,8 @@ async function setupExpress(options) {
     },
     include: ["src/**/*"]
   };
-  await fsPromises22.writeFile(
-    path23.join(serverDir, "tsconfig.json"),
+  await fsPromises23.writeFile(
+    path24.join(serverDir, "tsconfig.json"),
     JSON.stringify(tsconfigContent, null, 2),
     "utf8"
   );
@@ -3453,32 +3436,32 @@ async function setupExpress(options) {
     "});",
     ""
   ].join("\n");
-  await fsPromises22.writeFile(
-    path23.join(serverDir, "tsdown.config.ts"),
+  await fsPromises23.writeFile(
+    path24.join(serverDir, "tsdown.config.ts"),
     tsdownConfigContent,
     "utf8"
   );
   const deps = getExpressDependencies();
   await runCommand(`pnpm add ${deps.join(" ")}`, {
     cwd: serverDir,
-    silent: false
+    silent: true
   });
   const devDeps = getExpressDevDependencies(runtime);
   await runCommand(`pnpm add -D ${devDeps.join(" ")}`, {
     cwd: serverDir,
-    silent: false
+    silent: true
   });
   const indexTsContent = runtime === "bun" ? renderExpressBunTemplate(hasDb) : renderExpressNodeTemplate(hasDb);
-  await fsPromises22.writeFile(
-    path23.join(srcDir, "index.ts"),
+  await fsPromises23.writeFile(
+    path24.join(srcDir, "index.ts"),
     indexTsContent,
     "utf8"
   );
 }
 
 // src/modules/apps/server/frameworks/hono/index.ts
-import fsPromises23 from "fs/promises";
-import path24 from "path";
+import fsPromises24 from "fs/promises";
+import path25 from "path";
 
 // src/modules/apps/server/frameworks/hono/package.ts
 function getHonoDependencies(runtime) {
@@ -3649,13 +3632,13 @@ function renderHonoBunTemplate(hasDb) {
 // src/modules/apps/server/frameworks/hono/index.ts
 async function setupHono(options) {
   const { projectPath, runtime, linter, orm } = options;
-  const serverDir = path24.join(projectPath, "apps", "server");
-  const srcDir = path24.join(serverDir, "src");
+  const serverDir = path25.join(projectPath, "apps", "server");
+  const srcDir = path25.join(serverDir, "src");
   const hasDb = orm !== "none";
-  await fsPromises23.mkdir(srcDir, { recursive: true });
+  await fsPromises24.mkdir(srcDir, { recursive: true });
   await runCommand("pnpm init", { cwd: serverDir, silent: true });
-  const serverPackagePath = path24.join(serverDir, "package.json");
-  const serverPackageRaw = await fsPromises23.readFile(serverPackagePath, "utf8");
+  const serverPackagePath = path25.join(serverDir, "package.json");
+  const serverPackageRaw = await fsPromises24.readFile(serverPackagePath, "utf8");
   const serverPkg = JSON.parse(serverPackageRaw);
   serverPkg.name = "server";
   serverPkg.version = "1.0.0";
@@ -3675,7 +3658,7 @@ async function setupHono(options) {
   delete serverPkg.keywords;
   delete serverPkg.author;
   delete serverPkg.license;
-  await fsPromises23.writeFile(
+  await fsPromises24.writeFile(
     serverPackagePath,
     JSON.stringify(serverPkg, null, 2),
     "utf8"
@@ -3688,8 +3671,8 @@ async function setupHono(options) {
     },
     include: ["src/**/*"]
   };
-  await fsPromises23.writeFile(
-    path24.join(serverDir, "tsconfig.json"),
+  await fsPromises24.writeFile(
+    path25.join(serverDir, "tsconfig.json"),
     JSON.stringify(tsconfigContent, null, 2),
     "utf8"
   );
@@ -3704,24 +3687,24 @@ async function setupHono(options) {
     "});",
     ""
   ].join("\n");
-  await fsPromises23.writeFile(
-    path24.join(serverDir, "tsdown.config.ts"),
+  await fsPromises24.writeFile(
+    path25.join(serverDir, "tsdown.config.ts"),
     tsdownConfigContent,
     "utf8"
   );
   const deps = getHonoDependencies(runtime);
   await runCommand(`pnpm add ${deps.join(" ")}`, {
     cwd: serverDir,
-    silent: false
+    silent: true
   });
   const devDeps = getHonoDevDependencies(runtime);
   await runCommand(`pnpm add -D ${devDeps.join(" ")}`, {
     cwd: serverDir,
-    silent: false
+    silent: true
   });
   const indexTsContent = runtime === "bun" ? renderHonoBunTemplate(hasDb) : renderHonoNodeTemplate(hasDb);
-  await fsPromises23.writeFile(
-    path24.join(srcDir, "index.ts"),
+  await fsPromises24.writeFile(
+    path25.join(srcDir, "index.ts"),
     indexTsContent,
     "utf8"
   );
@@ -3782,13 +3765,13 @@ async function promptServerDeployment(framework) {
 }
 
 // src/modules/apps/server/deployment/docker/index.ts
-import path27 from "path";
+import path28 from "path";
 import { spinner as spinner14 } from "@clack/prompts";
 import pc22 from "picocolors";
 
 // src/modules/apps/server/deployment/docker/express-docker.ts
-import fsPromises24 from "fs/promises";
-import path25 from "path";
+import fsPromises25 from "fs/promises";
+import path26 from "path";
 function getExpressDockerfile(runtime) {
   if (runtime === "bun") {
     return [
@@ -3854,8 +3837,8 @@ function getExpressDockerfile(runtime) {
 }
 async function setupExpressDocker(serverDir, runtime) {
   const dockerfileContent = getExpressDockerfile(runtime);
-  await fsPromises24.writeFile(
-    path25.join(serverDir, "Dockerfile"),
+  await fsPromises25.writeFile(
+    path26.join(serverDir, "Dockerfile"),
     dockerfileContent,
     "utf8"
   );
@@ -3866,16 +3849,16 @@ async function setupExpressDocker(serverDir, runtime) {
     ".env.local",
     ""
   ].join("\n");
-  await fsPromises24.writeFile(
-    path25.join(serverDir, ".dockerignore"),
+  await fsPromises25.writeFile(
+    path26.join(serverDir, ".dockerignore"),
     dockerignoreContent,
     "utf8"
   );
 }
 
 // src/modules/apps/server/deployment/docker/hono-docker.ts
-import fsPromises25 from "fs/promises";
-import path26 from "path";
+import fsPromises26 from "fs/promises";
+import path27 from "path";
 function getHonoDockerfile(runtime) {
   if (runtime === "bun") {
     return [
@@ -3941,8 +3924,8 @@ function getHonoDockerfile(runtime) {
 }
 async function setupHonoDocker(serverDir, runtime) {
   const dockerfileContent = getHonoDockerfile(runtime);
-  await fsPromises25.writeFile(
-    path26.join(serverDir, "Dockerfile"),
+  await fsPromises26.writeFile(
+    path27.join(serverDir, "Dockerfile"),
     dockerfileContent,
     "utf8"
   );
@@ -3953,8 +3936,8 @@ async function setupHonoDocker(serverDir, runtime) {
     ".env.local",
     ""
   ].join("\n");
-  await fsPromises25.writeFile(
-    path26.join(serverDir, ".dockerignore"),
+  await fsPromises26.writeFile(
+    path27.join(serverDir, ".dockerignore"),
     dockerignoreContent,
     "utf8"
   );
@@ -3963,7 +3946,7 @@ async function setupHonoDocker(serverDir, runtime) {
 // src/modules/apps/server/deployment/docker/index.ts
 async function setupDockerDeployment(options) {
   const { projectPath, framework, runtime } = options;
-  const serverDir = path27.join(projectPath, "apps", "server");
+  const serverDir = path28.join(projectPath, "apps", "server");
   const frameworkLabel = framework === "express" ? "Express" : "Hono";
   const runtimeLabel = runtime === "bun" ? "Bun" : "Node.js";
   const s = spinner14();
@@ -3988,13 +3971,13 @@ async function setupDockerDeployment(options) {
 }
 
 // src/modules/apps/server/deployment/vercel/index.ts
-import path30 from "path";
+import path31 from "path";
 import { spinner as spinner15 } from "@clack/prompts";
 import pc23 from "picocolors";
 
 // src/modules/apps/server/deployment/vercel/express-vercel.ts
-import fsPromises26 from "fs/promises";
-import path28 from "path";
+import fsPromises27 from "fs/promises";
+import path29 from "path";
 async function setupExpressVercel(serverDir, _runtime) {
   const vercelConfig = {
     version: 2,
@@ -4011,16 +3994,16 @@ async function setupExpressVercel(serverDir, _runtime) {
       }
     ]
   };
-  await fsPromises26.writeFile(
-    path28.join(serverDir, "vercel.json"),
+  await fsPromises27.writeFile(
+    path29.join(serverDir, "vercel.json"),
     JSON.stringify(vercelConfig, null, 2),
     "utf8"
   );
 }
 
 // src/modules/apps/server/deployment/vercel/hono-vercel.ts
-import fsPromises27 from "fs/promises";
-import path29 from "path";
+import fsPromises28 from "fs/promises";
+import path30 from "path";
 async function setupHonoVercel(serverDir, runtime) {
   const vercelConfig = {
     version: 2,
@@ -4037,8 +4020,8 @@ async function setupHonoVercel(serverDir, runtime) {
       }
     ]
   };
-  await fsPromises27.writeFile(
-    path29.join(serverDir, "vercel.json"),
+  await fsPromises28.writeFile(
+    path30.join(serverDir, "vercel.json"),
     JSON.stringify(vercelConfig, null, 2),
     "utf8"
   );
@@ -4047,9 +4030,9 @@ async function setupHonoVercel(serverDir, runtime) {
       cwd: serverDir,
       silent: true
     });
-    const indexTsPath = path29.join(serverDir, "src", "index.ts");
+    const indexTsPath = path30.join(serverDir, "src", "index.ts");
     try {
-      let content = await fsPromises27.readFile(indexTsPath, "utf8");
+      let content = await fsPromises28.readFile(indexTsPath, "utf8");
       if (!content.includes("@hono/node-server")) {
         content = "import { getRequestListener } from '@hono/node-server';\n" + content;
       }
@@ -4059,7 +4042,7 @@ async function setupHonoVercel(serverDir, runtime) {
           "export default process.env.VERCEL\n  ? getRequestListener(app.fetch)\n  : {\n      port,\n      fetch: app.fetch,\n    };"
         );
       }
-      await fsPromises27.writeFile(indexTsPath, content, "utf8");
+      await fsPromises28.writeFile(indexTsPath, content, "utf8");
     } catch {
     }
   }
@@ -4068,7 +4051,7 @@ async function setupHonoVercel(serverDir, runtime) {
 // src/modules/apps/server/deployment/vercel/index.ts
 async function setupVercelDeployment(options) {
   const { projectPath, framework, runtime } = options;
-  const serverDir = path30.join(projectPath, "apps", "server");
+  const serverDir = path31.join(projectPath, "apps", "server");
   const frameworkLabel = framework === "express" ? "Express" : "Hono";
   const s = spinner15();
   s.start(
@@ -4102,9 +4085,9 @@ async function setupServerDeployment(options) {
 
 // src/modules/apps/server/index.ts
 async function runServerSetup(projectPath, framework, linter = "none", orm = "none", runtime = "node") {
-  const appsDir = path31.join(projectPath, "apps");
+  const appsDir = path32.join(projectPath, "apps");
   try {
-    await fsPromises28.access(appsDir);
+    await fsPromises29.access(appsDir);
   } catch {
     return;
   }
@@ -4175,8 +4158,8 @@ async function addWeb(projectPath) {
 }
 
 // src/modules/packages/env/index.ts
-import fsPromises29 from "fs/promises";
-import path32 from "path";
+import fsPromises30 from "fs/promises";
+import path33 from "path";
 import { confirm as confirm8, spinner as spinner17 } from "@clack/prompts";
 import pc25 from "picocolors";
 
@@ -4540,13 +4523,13 @@ async function promptEnv() {
 }
 async function addDependencyToPackage(pkgJsonPath, depName, depVersion) {
   try {
-    const raw = await fsPromises29.readFile(pkgJsonPath, "utf8");
+    const raw = await fsPromises30.readFile(pkgJsonPath, "utf8");
     const pkg = JSON.parse(raw);
     pkg.dependencies = {
       ...pkg.dependencies || {},
       [depName]: depVersion
     };
-    await fsPromises29.writeFile(
+    await fsPromises30.writeFile(
       pkgJsonPath,
       JSON.stringify(pkg, null, 2),
       "utf8"
@@ -4555,11 +4538,11 @@ async function addDependencyToPackage(pkgJsonPath, depName, depVersion) {
   }
 }
 async function updateDbForEnv(projectPath, dialect) {
-  const dbDir = path32.join(projectPath, "packages", "db");
-  const clientFile = path32.join(dbDir, "src", "client.ts");
-  const drizzleConfigFile = path32.join(dbDir, "drizzle.config.ts");
+  const dbDir = path33.join(projectPath, "packages", "db");
+  const clientFile = path33.join(dbDir, "src", "client.ts");
+  const drizzleConfigFile = path33.join(dbDir, "drizzle.config.ts");
   try {
-    const content = await fsPromises29.readFile(clientFile, "utf8");
+    const content = await fsPromises30.readFile(clientFile, "utf8");
     let newContent = "";
     if (content.includes("drizzle-orm/libsql")) {
       newContent = [
@@ -4617,7 +4600,7 @@ async function updateDbForEnv(projectPath, dialect) {
       ].join("\n");
     }
     if (newContent) {
-      await fsPromises29.writeFile(clientFile, newContent, "utf8");
+      await fsPromises30.writeFile(clientFile, newContent, "utf8");
     }
   } catch {
   }
@@ -4639,14 +4622,14 @@ async function updateDbForEnv(projectPath, dialect) {
       "});",
       ""
     ].join("\n");
-    await fsPromises29.writeFile(drizzleConfigFile, newDrizzleConfig, "utf8");
+    await fsPromises30.writeFile(drizzleConfigFile, newDrizzleConfig, "utf8");
   } catch {
   }
 }
 async function updateServerEntryForEnv(projectPath) {
-  const indexFile = path32.join(projectPath, "apps", "server", "src", "index.ts");
+  const indexFile = path33.join(projectPath, "apps", "server", "src", "index.ts");
   try {
-    let content = await fsPromises29.readFile(indexFile, "utf8");
+    let content = await fsPromises30.readFile(indexFile, "utf8");
     if (!content.includes("@repo/env")) {
       content = "import { env } from '@repo/env';\n" + content;
     }
@@ -4662,7 +4645,7 @@ async function updateServerEntryForEnv(projectPath) {
       /app\.use\('\*', cors\(\)\);/,
       "app.use('*', cors({ origin: env.server.CORS_ORIGIN }));"
     );
-    await fsPromises29.writeFile(indexFile, content, "utf8");
+    await fsPromises30.writeFile(indexFile, content, "utf8");
   } catch {
   }
 }
@@ -4677,13 +4660,13 @@ async function setupEnvPackage(options) {
     webFramework
   } = options;
   const hasWebEnv = webFramework !== "skip" || Boolean(hasAuth);
-  const envDir = path32.join(projectPath, "packages", "env");
-  const srcDir = path32.join(envDir, "src");
-  const schemaDir = path32.join(srcDir, "schema");
-  await fsPromises29.mkdir(schemaDir, { recursive: true });
+  const envDir = path33.join(projectPath, "packages", "env");
+  const srcDir = path33.join(envDir, "src");
+  const schemaDir = path33.join(srcDir, "schema");
+  await fsPromises30.mkdir(schemaDir, { recursive: true });
   const pkgContent = getEnvPackageJson(options);
-  await fsPromises29.writeFile(
-    path32.join(envDir, "package.json"),
+  await fsPromises30.writeFile(
+    path33.join(envDir, "package.json"),
     JSON.stringify(pkgContent, null, 2),
     "utf8"
   );
@@ -4695,56 +4678,56 @@ async function setupEnvPackage(options) {
     },
     include: ["src/**/*"]
   };
-  await fsPromises29.writeFile(
-    path32.join(envDir, "tsconfig.json"),
+  await fsPromises30.writeFile(
+    path33.join(envDir, "tsconfig.json"),
     JSON.stringify(tsconfig, null, 2),
     "utf8"
   );
   const createEnvCode = renderCreateEnvTemplate();
-  await fsPromises29.writeFile(
-    path32.join(srcDir, "create-env.ts"),
+  await fsPromises30.writeFile(
+    path33.join(srcDir, "create-env.ts"),
     createEnvCode,
     "utf8"
   );
   if (hasDb) {
     const dbCode = renderDbEnvTemplate(options);
-    await fsPromises29.writeFile(path32.join(schemaDir, "db.ts"), dbCode, "utf8");
+    await fsPromises30.writeFile(path33.join(schemaDir, "db.ts"), dbCode, "utf8");
   }
   if (hasDocker) {
     const dockerCode = renderDockerEnvTemplate(options);
-    await fsPromises29.writeFile(
-      path32.join(schemaDir, "docker.ts"),
+    await fsPromises30.writeFile(
+      path33.join(schemaDir, "docker.ts"),
       dockerCode,
       "utf8"
     );
   }
   if (hasServer || hasDb) {
     const serverCode = renderServerEnvTemplate(options);
-    await fsPromises29.writeFile(
-      path32.join(schemaDir, "server.ts"),
+    await fsPromises30.writeFile(
+      path33.join(schemaDir, "server.ts"),
       serverCode,
       "utf8"
     );
   }
   if (hasAuth) {
     const authCode = renderAuthEnvTemplate(options);
-    await fsPromises29.writeFile(
-      path32.join(schemaDir, "auth.ts"),
+    await fsPromises30.writeFile(
+      path33.join(schemaDir, "auth.ts"),
       authCode,
       "utf8"
     );
   }
   if (hasWebEnv) {
     const webCode = renderWebEnvTemplate(options);
-    await fsPromises29.writeFile(path32.join(schemaDir, "web.ts"), webCode, "utf8");
+    await fsPromises30.writeFile(path33.join(schemaDir, "web.ts"), webCode, "utf8");
   }
   const checkCode = renderCheckEnvTemplate(options);
-  await fsPromises29.writeFile(path32.join(srcDir, "check.ts"), checkCode, "utf8");
+  await fsPromises30.writeFile(path33.join(srcDir, "check.ts"), checkCode, "utf8");
   const indexCode = renderIndexEnvTemplate(options);
-  await fsPromises29.writeFile(path32.join(srcDir, "index.ts"), indexCode, "utf8");
+  await fsPromises30.writeFile(path33.join(srcDir, "index.ts"), indexCode, "utf8");
   if (hasDb) {
     await addDependencyToPackage(
-      path32.join(projectPath, "packages", "db", "package.json"),
+      path33.join(projectPath, "packages", "db", "package.json"),
       "@repo/env",
       "workspace:*"
     );
@@ -4752,7 +4735,7 @@ async function setupEnvPackage(options) {
   }
   if (hasServer) {
     await addDependencyToPackage(
-      path32.join(projectPath, "apps", "server", "package.json"),
+      path33.join(projectPath, "apps", "server", "package.json"),
       "@repo/env",
       "workspace:*"
     );
@@ -4760,21 +4743,21 @@ async function setupEnvPackage(options) {
   }
   if (hasAuth) {
     await addDependencyToPackage(
-      path32.join(projectPath, "packages", "auth", "package.json"),
+      path33.join(projectPath, "packages", "auth", "package.json"),
       "@repo/env",
       "workspace:*"
     );
   }
   if (webFramework !== "skip") {
-    const appsDir = path32.join(projectPath, "apps");
+    const appsDir = path33.join(projectPath, "apps");
     try {
-      const entries = await fsPromises29.readdir(appsDir, {
+      const entries = await fsPromises30.readdir(appsDir, {
         withFileTypes: true
       });
       for (const entry of entries) {
         if (entry.isDirectory() && entry.name !== "server") {
           await addDependencyToPackage(
-            path32.join(appsDir, entry.name, "package.json"),
+            path33.join(appsDir, entry.name, "package.json"),
             "@repo/env",
             "workspace:*"
           );
@@ -4803,8 +4786,8 @@ Error details: ${error.message || error}`));
 }
 
 // src/modules/packages/auth/index.ts
-import fsPromises30 from "fs/promises";
-import path33 from "path";
+import fsPromises31 from "fs/promises";
+import path34 from "path";
 import { confirm as confirm9, spinner as spinner18 } from "@clack/prompts";
 import pc26 from "picocolors";
 async function promptAuth() {
@@ -4820,11 +4803,11 @@ async function setupAuth(options) {
   const s = spinner18();
   s.start("Configuring shared Better Auth package (@repo/auth)...");
   try {
-    const authDir = path33.join(projectPath, "packages", "auth");
-    const authSrcDir = path33.join(authDir, "src");
-    await fsPromises30.mkdir(authSrcDir, { recursive: true });
-    const authLibDir = path33.join(authSrcDir, "lib");
-    await fsPromises30.mkdir(authLibDir, { recursive: true });
+    const authDir = path34.join(projectPath, "packages", "auth");
+    const authSrcDir = path34.join(authDir, "src");
+    await fsPromises31.mkdir(authSrcDir, { recursive: true });
+    const authLibDir = path34.join(authSrcDir, "lib");
+    await fsPromises31.mkdir(authLibDir, { recursive: true });
     const authPkg = {
       name: "@repo/auth",
       version: "1.0.0",
@@ -4860,8 +4843,8 @@ async function setupAuth(options) {
         typescript: "^5.7.3"
       }
     };
-    await fsPromises30.writeFile(
-      path33.join(authDir, "package.json"),
+    await fsPromises31.writeFile(
+      path34.join(authDir, "package.json"),
       JSON.stringify(authPkg, null, 2),
       "utf8"
     );
@@ -4873,8 +4856,8 @@ async function setupAuth(options) {
       },
       include: ["src/**/*"]
     };
-    await fsPromises30.writeFile(
-      path33.join(authDir, "tsconfig.json"),
+    await fsPromises31.writeFile(
+      path34.join(authDir, "tsconfig.json"),
       JSON.stringify(tsconfig, null, 2),
       "utf8"
     );
@@ -4918,8 +4901,8 @@ async function setupAuth(options) {
       `export const isProduction = ${isProdExpr};`,
       ""
     );
-    await fsPromises30.writeFile(
-      path33.join(authLibDir, "origins.ts"),
+    await fsPromises31.writeFile(
+      path34.join(authLibDir, "origins.ts"),
       originsLibLines.join("\n"),
       "utf8"
     );
@@ -4989,8 +4972,8 @@ async function setupAuth(options) {
       "export type Auth = typeof auth;",
       ""
     );
-    await fsPromises30.writeFile(
-      path33.join(authLibDir, "auth.ts"),
+    await fsPromises31.writeFile(
+      path34.join(authLibDir, "auth.ts"),
       authLibLines.join("\n"),
       "utf8"
     );
@@ -5001,8 +4984,8 @@ async function setupAuth(options) {
       "export { origins, trustedOrigins, isProduction } from './lib/origins.js';",
       ""
     ].join("\n");
-    await fsPromises30.writeFile(
-      path33.join(authSrcDir, "origins.ts"),
+    await fsPromises31.writeFile(
+      path34.join(authSrcDir, "origins.ts"),
       originsReexport,
       "utf8"
     );
@@ -5015,14 +4998,14 @@ async function setupAuth(options) {
       "export { origins, trustedOrigins, isProduction } from './lib/origins.js';",
       ""
     ].join("\n");
-    await fsPromises30.writeFile(
-      path33.join(authSrcDir, "index.ts"),
+    await fsPromises31.writeFile(
+      path34.join(authSrcDir, "index.ts"),
       authIndexContent,
       "utf8"
     );
-    const dbDir = path33.join(projectPath, "packages", "db");
-    const schemaDir = path33.join(dbDir, "src", "schema");
-    await fsPromises30.mkdir(schemaDir, { recursive: true });
+    const dbDir = path34.join(projectPath, "packages", "db");
+    const schemaDir = path34.join(dbDir, "src", "schema");
+    await fsPromises31.mkdir(schemaDir, { recursive: true });
     let authSchemaContent;
     if (isSqlite) {
       authSchemaContent = [
@@ -5145,43 +5128,43 @@ async function setupAuth(options) {
         ""
       ].join("\n");
     }
-    await fsPromises30.writeFile(
-      path33.join(schemaDir, "auth.ts"),
+    await fsPromises31.writeFile(
+      path34.join(schemaDir, "auth.ts"),
       authSchemaContent,
       "utf8"
     );
-    const schemaIndexPath = path33.join(schemaDir, "index.ts");
+    const schemaIndexPath = path34.join(schemaDir, "index.ts");
     try {
-      const existing = await fsPromises30.readFile(schemaIndexPath, "utf8");
+      const existing = await fsPromises31.readFile(schemaIndexPath, "utf8");
       if (!existing.includes("from './auth.js'") && !existing.includes("from './auth'")) {
         const updated = `${existing}
 export * from './auth.js';
 `;
-        await fsPromises30.writeFile(schemaIndexPath, updated, "utf8");
+        await fsPromises31.writeFile(schemaIndexPath, updated, "utf8");
       }
     } catch {
     }
     if (hasServer && serverFramework !== "none") {
-      const serverDir = path33.join(projectPath, "apps", "server");
-      const serverPkgPath = path33.join(serverDir, "package.json");
+      const serverDir = path34.join(projectPath, "apps", "server");
+      const serverPkgPath = path34.join(serverDir, "package.json");
       try {
-        const rawPkg = await fsPromises30.readFile(serverPkgPath, "utf8");
+        const rawPkg = await fsPromises31.readFile(serverPkgPath, "utf8");
         const pkg = JSON.parse(rawPkg);
         pkg.dependencies = pkg.dependencies || {};
         pkg.dependencies["@repo/auth"] = "workspace:*";
         if (serverFramework === "express") {
           pkg.dependencies["better-auth"] = "^1.1.21";
         }
-        await fsPromises30.writeFile(
+        await fsPromises31.writeFile(
           serverPkgPath,
           JSON.stringify(pkg, null, 2),
           "utf8"
         );
       } catch {
       }
-      const serverIndexPath = path33.join(serverDir, "src", "index.ts");
+      const serverIndexPath = path34.join(serverDir, "src", "index.ts");
       try {
-        let content = await fsPromises30.readFile(serverIndexPath, "utf8");
+        let content = await fsPromises31.readFile(serverIndexPath, "utf8");
         if (serverFramework === "express") {
           if (!content.includes("@repo/auth")) {
             content = content.replace(
@@ -5196,7 +5179,7 @@ export * from './auth.js';
               "app.use(express.json());",
               "// Mount Better Auth endpoints (/api/auth/*)\napp.all('/api/auth/*', toNodeHandler(auth));\n\napp.use(express.json());"
             );
-            await fsPromises30.writeFile(serverIndexPath, content, "utf8");
+            await fsPromises31.writeFile(serverIndexPath, content, "utf8");
           }
         } else if (serverFramework === "hono") {
           if (!content.includes("@repo/auth")) {
@@ -5212,7 +5195,7 @@ export * from './auth.js';
               "const app = new Hono();",
               "const app = new Hono();\n\n// Mount Better Auth API handler\napp.on(['POST', 'GET'], '/api/auth/**', (c) => {\n  return auth.handler(c.req.raw);\n});"
             );
-            await fsPromises30.writeFile(serverIndexPath, content, "utf8");
+            await fsPromises31.writeFile(serverIndexPath, content, "utf8");
           }
         }
       } catch {
@@ -5226,11 +5209,11 @@ export * from './auth.js';
       ""
     ].join("\n");
     for (const envFileName of [".env", ".env.example"]) {
-      const envFilePath = path33.join(projectPath, envFileName);
+      const envFilePath = path34.join(projectPath, envFileName);
       try {
-        const raw = await fsPromises30.readFile(envFilePath, "utf8");
+        const raw = await fsPromises31.readFile(envFilePath, "utf8");
         if (!raw.includes("BETTER_AUTH_SECRET")) {
-          await fsPromises30.appendFile(
+          await fsPromises31.appendFile(
             envFilePath,
             `
 ${envLinesToAdd}`,
@@ -5255,8 +5238,8 @@ Error details: ${error.message || error}`));
 // src/modules/docker/index.ts
 import { spinner as spinner19 } from "@clack/prompts";
 import pc27 from "picocolors";
-import fsPromises31 from "fs/promises";
-import path34 from "path";
+import fsPromises32 from "fs/promises";
+import path35 from "path";
 async function setupDocker(projectPath, options) {
   if (!options.postgres && !options.redis) {
     return;
@@ -5264,8 +5247,8 @@ async function setupDocker(projectPath, options) {
   const s = spinner19();
   s.start("Configuring root Docker infrastructure in docker/...");
   try {
-    const dockerDir = path34.join(projectPath, "docker");
-    await fsPromises31.mkdir(dockerDir, { recursive: true });
+    const dockerDir = path35.join(projectPath, "docker");
+    await fsPromises32.mkdir(dockerDir, { recursive: true });
     const safeName = options.projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
     const services = [];
     const volumes = [];
@@ -5327,8 +5310,8 @@ async function setupDocker(projectPath, options) {
       volumes.join("\n"),
       ""
     ].join("\n");
-    await fsPromises31.writeFile(
-      path34.join(dockerDir, "docker-compose.yml"),
+    await fsPromises32.writeFile(
+      path35.join(dockerDir, "docker-compose.yml"),
       composeContent,
       "utf8"
     );
@@ -5354,7 +5337,7 @@ async function runWorkspaceScaffolder(options = {}) {
   await runPreflightChecks();
   const isMonorepo = !options.react && !options.next;
   const name = await promptWorkspaceName(isMonorepo);
-  const projectPath = path35.join(process.cwd(), name);
+  const projectPath = path36.join(process.cwd(), name);
   await checkTargetDirectory(projectPath, name);
   if (options.react) {
     await runReactScaffolder(name, projectPath);
@@ -5501,6 +5484,7 @@ async function runWorkspaceScaffolder(options = {}) {
     }
   });
   await promptAndInstallSkills(projectPath);
+  await removeBunLockfiles(projectPath);
   const s = spinner20();
   s.start("Running final workspace package installation...");
   try {
@@ -5528,6 +5512,8 @@ Error details: ${error.message || error}`));
 }
 
 // src/index.ts
+process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS || ""} --no-deprecation`.trim();
+process.env.NODE_NO_WARNINGS = "1";
 async function main() {
   const isReactOnly = process.argv.includes("--react") || process.argv.includes("-r");
   const isNextOnly = process.argv.includes("--nextjs") || process.argv.includes("--next") || process.argv.includes("-n");