@mars-stack/cli 4.0.1 → 5.0.0

package/dist/index.js

@@ -44,8 +44,8 @@ var init_logger = __esm({
 });
 
 // src/utils/rollback.ts
-import fs4 from "fs-extra";
-import path4 from "path";
+import fs5 from "fs-extra";
+import path5 from "path";
 import os from "os";
 function createRollbackContext() {
   const manifest = {
@@ -53,15 +53,15 @@ function createRollbackContext() {
     filesModified: [],
     depsInstalled: []
   };
-  const backupDir = path4.join(os.tmpdir(), `mars-rollback-${Date.now()}`);
+  const backupDir = path5.join(os.tmpdir(), `mars-rollback-${Date.now()}`);
   function trackCreatedFile(filePath) {
     manifest.filesCreated.push(filePath);
   }
   async function trackModifiedFile(filePath) {
-    if (!await fs4.pathExists(filePath)) return;
-    await fs4.ensureDir(backupDir);
-    const backupPath = path4.join(backupDir, `${manifest.filesModified.length}-${path4.basename(filePath)}`);
-    await fs4.copy(filePath, backupPath);
+    if (!await fs5.pathExists(filePath)) return;
+    await fs5.ensureDir(backupDir);
+    const backupPath = path5.join(backupDir, `${manifest.filesModified.length}-${path5.basename(filePath)}`);
+    await fs5.copy(filePath, backupPath);
     manifest.filesModified.push({ path: filePath, backup: backupPath });
   }
   function trackInstalledDep(depName) {
@@ -70,13 +70,13 @@ function createRollbackContext() {
   async function rollback() {
     for (const filePath of manifest.filesCreated.reverse()) {
       try {
-        await fs4.remove(filePath);
+        await fs5.remove(filePath);
       } catch {
       }
     }
     for (const { path: originalPath, backup } of manifest.filesModified) {
       try {
-        await fs4.copy(backup, originalPath, { overwrite: true });
+        await fs5.copy(backup, originalPath, { overwrite: true });
       } catch {
       }
     }
@@ -86,9 +86,9 @@ function createRollbackContext() {
     await cleanupBackups();
   }
   async function cleanupBackups() {
-    if (await fs4.pathExists(backupDir)) {
+    if (await fs5.pathExists(backupDir)) {
       try {
-        await fs4.remove(backupDir);
+        await fs5.remove(backupDir);
       } catch {
       }
     }
@@ -108,15 +108,15 @@ var init_rollback = __esm({
 });
 
 // src/utils/dependencies.ts
-import fs5 from "fs-extra";
-import path5 from "path";
+import fs6 from "fs-extra";
+import path6 from "path";
 async function addDependencies(projectRoot, deps, dev = false) {
-  const pkgPath = path5.join(projectRoot, "package.json");
-  if (!await fs5.pathExists(pkgPath)) return;
-  const pkg = await fs5.readJson(pkgPath);
+  const pkgPath = path6.join(projectRoot, "package.json");
+  if (!await fs6.pathExists(pkgPath)) return;
+  const pkg = await fs6.readJson(pkgPath);
   const key = dev ? "devDependencies" : "dependencies";
   pkg[key] = { ...pkg[key], ...deps };
-  await fs5.writeJson(pkgPath, pkg, { spaces: 2 });
+  await fs6.writeJson(pkgPath, pkg, { spaces: 2 });
 }
 var init_dependencies = __esm({
   "src/utils/dependencies.ts"() {
@@ -125,12 +125,12 @@ var init_dependencies = __esm({
 });
 
 // src/utils/routes.ts
-import fs6 from "fs-extra";
-import path6 from "path";
+import fs7 from "fs-extra";
+import path7 from "path";
 async function registerRoute(projectRoot, key, routePath, ctx) {
-  const routesFile = path6.join(projectRoot, "src", "config", "routes.ts");
-  if (!await fs6.pathExists(routesFile)) return;
-  let content = await fs6.readFile(routesFile, "utf-8");
+  const routesFile = path7.join(projectRoot, "src", "config", "routes.ts");
+  if (!await fs7.pathExists(routesFile)) return;
+  let content = await fs7.readFile(routesFile, "utf-8");
   if (content.includes(`${key}:`)) return;
   if (ctx) {
     await ctx.trackModifiedFile(routesFile);
@@ -140,7 +140,7 @@ async function registerRoute(projectRoot, key, routePath, ctx) {
     `  ${key}: '${routePath}',
 } as const;`
   );
-  await fs6.writeFile(routesFile, content);
+  await fs7.writeFile(routesFile, content);
 }
 var init_routes = __esm({
   "src/utils/routes.ts"() {
@@ -153,11 +153,11 @@ var blog_exports = {};
 __export(blog_exports, {
   generateBlog: () => generateBlog
 });
-import fs7 from "fs-extra";
-import path7 from "path";
+import fs8 from "fs-extra";
+import path8 from "path";
 async function generateBlog(projectRoot) {
-  const featureDir = path7.join(projectRoot, "src", "features", "blog");
-  if (await fs7.pathExists(featureDir)) {
+  const featureDir = path8.join(projectRoot, "src", "features", "blog");
+  if (await fs8.pathExists(featureDir)) {
     log.error("Blog feature already exists at src/features/blog/");
     return;
   }
@@ -178,10 +178,10 @@ async function generateBlog(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path7.join(projectRoot, filePath);
+      const fullPath = path8.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs7.ensureDir(path7.dirname(fullPath));
-      await fs7.writeFile(fullPath, content);
+      await fs8.ensureDir(path8.dirname(fullPath));
+      await fs8.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, {
@@ -208,12 +208,12 @@ async function generateBlog(projectRoot) {
   }
 }
 async function setConfigFlag(projectRoot, ctx) {
-  const configPath = path7.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs7.pathExists(configPath)) return;
+  const configPath = path8.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs8.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs7.readFile(configPath, "utf-8");
+  const content = await fs8.readFile(configPath, "utf-8");
   const updated = content.replace(/blog:\s*false/, "blog: true");
-  await fs7.writeFile(configPath, updated);
+  await fs8.writeFile(configPath, updated);
 }
 function schemas() {
   return `${STAMP}
@@ -732,11 +732,11 @@ var dark_mode_exports = {};
 __export(dark_mode_exports, {
   generateDarkMode: () => generateDarkMode
 });
-import fs8 from "fs-extra";
-import path8 from "path";
+import fs9 from "fs-extra";
+import path9 from "path";
 async function generateDarkMode(projectRoot) {
-  const featureDir = path8.join(projectRoot, "src", "features", "dark-mode");
-  if (await fs8.pathExists(featureDir)) {
+  const featureDir = path9.join(projectRoot, "src", "features", "dark-mode");
+  if (await fs9.pathExists(featureDir)) {
     log.error("Dark mode feature already exists at src/features/dark-mode/");
     return;
   }
@@ -751,10 +751,10 @@ async function generateDarkMode(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path8.join(projectRoot, filePath);
+      const fullPath = path9.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs8.ensureDir(path8.dirname(fullPath));
-      await fs8.writeFile(fullPath, content);
+      await fs9.ensureDir(path9.dirname(fullPath));
+      await fs9.writeFile(fullPath, content);
       count++;
     }
     await wireLayout(projectRoot, ctx);
@@ -784,18 +784,18 @@ async function generateDarkMode(projectRoot) {
   }
 }
 async function setConfigFlag2(projectRoot, ctx) {
-  const configPath = path8.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs8.pathExists(configPath)) return;
+  const configPath = path9.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs9.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs8.readFile(configPath, "utf-8");
+  const content = await fs9.readFile(configPath, "utf-8");
   const updated = content.replace(/darkMode:\s*false/, "darkMode: true");
-  await fs8.writeFile(configPath, updated);
+  await fs9.writeFile(configPath, updated);
 }
 async function wireLayout(projectRoot, ctx) {
-  const layoutPath = path8.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs8.pathExists(layoutPath)) return;
+  const layoutPath = path9.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs9.pathExists(layoutPath)) return;
   await ctx.trackModifiedFile(layoutPath);
-  let content = await fs8.readFile(layoutPath, "utf-8");
+  let content = await fs9.readFile(layoutPath, "utf-8");
   if (!content.includes("getThemeScript")) {
     content = `import { getThemeScript } from '@/features/dark-mode';
 ${content}`;
@@ -809,13 +809,13 @@ ${content}`;
       "$1\n      <head>\n        <script dangerouslySetInnerHTML={{ __html: getThemeScript() }} />\n      </head>\n$2"
     );
   }
-  await fs8.writeFile(layoutPath, content);
+  await fs9.writeFile(layoutPath, content);
 }
 async function wireProviders(projectRoot, ctx) {
-  const providersPath = path8.join(projectRoot, "src", "app", "providers.tsx");
-  if (!await fs8.pathExists(providersPath)) return;
+  const providersPath = path9.join(projectRoot, "src", "app", "providers.tsx");
+  if (!await fs9.pathExists(providersPath)) return;
   await ctx.trackModifiedFile(providersPath);
-  let content = await fs8.readFile(providersPath, "utf-8");
+  let content = await fs9.readFile(providersPath, "utf-8");
   if (content.includes("ThemeProvider")) return;
   content = insertImportAfterDirectives(
     content,
@@ -834,13 +834,13 @@ async function wireProviders(projectRoot, ctx) {
   );`;
     }
   );
-  await fs8.writeFile(providersPath, content);
+  await fs9.writeFile(providersPath, content);
 }
 async function wireProtectedNav(projectRoot, ctx) {
-  const navPath = path8.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
-  if (!await fs8.pathExists(navPath)) return;
+  const navPath = path9.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
+  if (!await fs9.pathExists(navPath)) return;
   await ctx.trackModifiedFile(navPath);
-  let content = await fs8.readFile(navPath, "utf-8");
+  let content = await fs9.readFile(navPath, "utf-8");
   if (content.includes("ThemeToggleSimple")) return;
   content = insertImportAfterDirectives(
     content,
@@ -855,19 +855,19 @@ async function wireProtectedNav(projectRoot, ctx) {
     /(<div className="border-t border-border-default px-4 py-3">\s*\n\s*<UserMenu \/>)/,
     '$1\n              <div className="mt-2">\n                <ThemeToggleSimple />\n              </div>'
   );
-  await fs8.writeFile(navPath, content);
+  await fs9.writeFile(navPath, content);
 }
 async function wireTailwindDarkMode(projectRoot, ctx) {
-  const globalsPath = path8.join(projectRoot, "src", "styles", "globals.css");
-  if (!await fs8.pathExists(globalsPath)) return;
+  const globalsPath = path9.join(projectRoot, "src", "styles", "globals.css");
+  if (!await fs9.pathExists(globalsPath)) return;
   await ctx.trackModifiedFile(globalsPath);
-  let content = await fs8.readFile(globalsPath, "utf-8");
+  let content = await fs9.readFile(globalsPath, "utf-8");
   if (content.includes("@custom-variant dark")) return;
   content = content.replace(
     /@import 'tailwindcss';/,
     "@import 'tailwindcss';\n@custom-variant dark (&:where(.dark, .dark *));"
   );
-  await fs8.writeFile(globalsPath, content);
+  await fs9.writeFile(globalsPath, content);
 }
 function themeProvider() {
   return `${STAMP2}
@@ -1147,19 +1147,19 @@ var init_dark_mode = __esm({
 });
 
 // src/utils/prisma.ts
-import fs9 from "fs-extra";
-import path9 from "path";
+import fs10 from "fs-extra";
+import path10 from "path";
 async function addUserRelation(projectRoot, field, ctx) {
-  const authPath = path9.join(projectRoot, "prisma", "schema", "auth.prisma");
-  if (!await fs9.pathExists(authPath)) return;
+  const authPath = path10.join(projectRoot, "prisma", "schema", "auth.prisma");
+  if (!await fs10.pathExists(authPath)) return;
   await ctx.trackModifiedFile(authPath);
-  let content = await fs9.readFile(authPath, "utf-8");
+  let content = await fs10.readFile(authPath, "utf-8");
   if (content.includes(field)) return;
   const insertBefore = "  @@index([email])";
   content = content.replace(insertBefore, `  ${field}
 
 ${insertBefore}`);
-  await fs9.writeFile(authPath, content);
+  await fs10.writeFile(authPath, content);
 }
 var init_prisma = __esm({
   "src/utils/prisma.ts"() {
@@ -1172,11 +1172,11 @@ var notifications_exports = {};
 __export(notifications_exports, {
   generateNotifications: () => generateNotifications
 });
-import fs10 from "fs-extra";
-import path10 from "path";
+import fs11 from "fs-extra";
+import path11 from "path";
 async function generateNotifications(projectRoot) {
-  const featureDir = path10.join(projectRoot, "src", "features", "notifications");
-  if (await fs10.pathExists(featureDir)) {
+  const featureDir = path11.join(projectRoot, "src", "features", "notifications");
+  if (await fs11.pathExists(featureDir)) {
     log.error("Notifications feature already exists at src/features/notifications/");
     return;
   }
@@ -1199,10 +1199,10 @@ async function generateNotifications(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path10.join(projectRoot, filePath);
+      const fullPath = path11.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs10.ensureDir(path10.dirname(fullPath));
-      await fs10.writeFile(fullPath, content);
+      await fs11.ensureDir(path11.dirname(fullPath));
+      await fs11.writeFile(fullPath, content);
       count++;
     }
     await addUserRelation(projectRoot, "notifications Notification[]", ctx);
@@ -1229,10 +1229,10 @@ async function generateNotifications(projectRoot) {
   }
 }
 async function wireProtectedNav2(projectRoot, ctx) {
-  const navPath = path10.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
-  if (!await fs10.pathExists(navPath)) return;
+  const navPath = path11.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
+  if (!await fs11.pathExists(navPath)) return;
   await ctx.trackModifiedFile(navPath);
-  let content = await fs10.readFile(navPath, "utf-8");
+  let content = await fs11.readFile(navPath, "utf-8");
   if (content.includes("NotificationBell")) return;
   content = insertImportAfterDirectives(
     content,
@@ -1243,15 +1243,15 @@ async function wireProtectedNav2(projectRoot, ctx) {
     /(<div className="flex items-center gap-3">)\s*\n(\s*)(<div className="hidden md:block">)/,
     "$1\n$2<NotificationBell />\n$2$3"
   );
-  await fs10.writeFile(navPath, content);
+  await fs11.writeFile(navPath, content);
 }
 async function setConfigFlag3(projectRoot, ctx) {
-  const configPath = path10.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs10.pathExists(configPath)) return;
+  const configPath = path11.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs11.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs10.readFile(configPath, "utf-8");
+  const content = await fs11.readFile(configPath, "utf-8");
   const updated = content.replace(/notifications:\s*false/, "notifications: true");
-  await fs10.writeFile(configPath, updated);
+  await fs11.writeFile(configPath, updated);
 }
 function prismaSchema() {
   return `// Generated by mars generate notifications (notifications@${GENERATOR_VERSION3})
@@ -1847,11 +1847,11 @@ var analytics_exports = {};
 __export(analytics_exports, {
   generateAnalytics: () => generateAnalytics
 });
-import fs11 from "fs-extra";
-import path11 from "path";
+import fs12 from "fs-extra";
+import path12 from "path";
 async function generateAnalytics(projectRoot) {
-  const featureDir = path11.join(projectRoot, "src", "features", "analytics");
-  if (await fs11.pathExists(featureDir)) {
+  const featureDir = path12.join(projectRoot, "src", "features", "analytics");
+  if (await fs12.pathExists(featureDir)) {
     log.error("Analytics feature already exists at src/features/analytics/");
     return;
   }
@@ -1866,10 +1866,10 @@ async function generateAnalytics(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path11.join(projectRoot, filePath);
+      const fullPath = path12.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs11.ensureDir(path11.dirname(fullPath));
-      await fs11.writeFile(fullPath, content);
+      await fs12.ensureDir(path12.dirname(fullPath));
+      await fs12.writeFile(fullPath, content);
       count++;
     }
     await wireProviders2(projectRoot, ctx);
@@ -1900,10 +1900,10 @@ async function generateAnalytics(projectRoot) {
   }
 }
 async function wireProviders2(projectRoot, ctx) {
-  const providersPath = path11.join(projectRoot, "src", "app", "providers.tsx");
-  if (!await fs11.pathExists(providersPath)) return;
+  const providersPath = path12.join(projectRoot, "src", "app", "providers.tsx");
+  if (!await fs12.pathExists(providersPath)) return;
   await ctx.trackModifiedFile(providersPath);
-  let content = await fs11.readFile(providersPath, "utf-8");
+  let content = await fs12.readFile(providersPath, "utf-8");
   if (content.includes("AnalyticsProvider")) return;
   content = insertImportAfterDirectives(
     content,
@@ -1918,8 +1918,8 @@ async function wireProviders2(projectRoot, ctx) {
   );`;
     }
   );
-  await fs11.writeFile(providersPath, content);
-  const written = await fs11.readFile(providersPath, "utf-8");
+  await fs12.writeFile(providersPath, content);
+  const written = await fs12.readFile(providersPath, "utf-8");
   if (!written.includes("AnalyticsProvider")) {
     throw new Error(
       "wireProviders: AnalyticsProvider was not inserted into providers.tsx \u2014 the return statement pattern did not match. Review the template file structure."
@@ -1927,12 +1927,12 @@ async function wireProviders2(projectRoot, ctx) {
   }
 }
 async function setConfigFlag4(projectRoot, ctx) {
-  const configPath = path11.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs11.pathExists(configPath)) return;
+  const configPath = path12.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs12.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs11.readFile(configPath, "utf-8");
+  const content = await fs12.readFile(configPath, "utf-8");
   const updated = content.replace(/analytics:\s*false/, "analytics: true");
-  await fs11.writeFile(configPath, updated);
+  await fs12.writeFile(configPath, updated);
 }
 function types3() {
   return `${STAMP4}
@@ -2291,11 +2291,11 @@ var command_palette_exports = {};
 __export(command_palette_exports, {
   generateCommandPalette: () => generateCommandPalette
 });
-import fs12 from "fs-extra";
-import path12 from "path";
+import fs13 from "fs-extra";
+import path13 from "path";
 async function generateCommandPalette(projectRoot) {
-  const featureDir = path12.join(projectRoot, "src", "features", "command-palette");
-  if (await fs12.pathExists(featureDir)) {
+  const featureDir = path13.join(projectRoot, "src", "features", "command-palette");
+  if (await fs13.pathExists(featureDir)) {
     log.error("Command palette feature already exists at src/features/command-palette/");
     return;
   }
@@ -2313,10 +2313,10 @@ async function generateCommandPalette(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path12.join(projectRoot, filePath);
+      const fullPath = path13.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs12.ensureDir(path12.dirname(fullPath));
-      await fs12.writeFile(fullPath, content);
+      await fs13.ensureDir(path13.dirname(fullPath));
+      await fs13.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, { cmdk: "^1.0.0" });
@@ -2339,9 +2339,9 @@ async function generateCommandPalette(projectRoot) {
   }
 }
 async function wireLayout2(projectRoot, ctx) {
-  const layoutPath = path12.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs12.pathExists(layoutPath)) return;
-  let content = await fs12.readFile(layoutPath, "utf-8");
+  const layoutPath = path13.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs13.pathExists(layoutPath)) return;
+  let content = await fs13.readFile(layoutPath, "utf-8");
   if (content.includes("CommandPalette")) return;
   await ctx.trackModifiedFile(layoutPath);
   content = `import { CommandPalette } from '@/features/command-palette';
@@ -2350,15 +2350,15 @@ ${content}`;
     /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
     "$1$2\n$1<CommandPalette />"
   );
-  await fs12.writeFile(layoutPath, content);
+  await fs13.writeFile(layoutPath, content);
 }
 async function setConfigFlag5(projectRoot, ctx) {
-  const configPath = path12.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs12.pathExists(configPath)) return;
+  const configPath = path13.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs13.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs12.readFile(configPath, "utf-8");
+  const content = await fs13.readFile(configPath, "utf-8");
   const updated = content.replace(/commandPalette:\s*false/, "commandPalette: true");
-  await fs12.writeFile(configPath, updated);
+  await fs13.writeFile(configPath, updated);
 }
 function types4() {
   return `${STAMP5}
@@ -2774,11 +2774,11 @@ var onboarding_exports = {};
 __export(onboarding_exports, {
   generateOnboarding: () => generateOnboarding
 });
-import fs13 from "fs-extra";
-import path13 from "path";
+import fs14 from "fs-extra";
+import path14 from "path";
 async function generateOnboarding(projectRoot) {
-  const featureDir = path13.join(projectRoot, "src", "features", "onboarding");
-  if (await fs13.pathExists(featureDir)) {
+  const featureDir = path14.join(projectRoot, "src", "features", "onboarding");
+  if (await fs14.pathExists(featureDir)) {
     log.error("Onboarding feature already exists at src/features/onboarding/");
     return;
   }
@@ -2800,10 +2800,10 @@ async function generateOnboarding(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path13.join(projectRoot, filePath);
+      const fullPath = path14.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs13.ensureDir(path13.dirname(fullPath));
-      await fs13.writeFile(fullPath, content);
+      await fs14.ensureDir(path14.dirname(fullPath));
+      await fs14.writeFile(fullPath, content);
       count++;
     }
     await addUserRelation(projectRoot, "onboardingProgress OnboardingProgress?", ctx);
@@ -2831,7 +2831,7 @@ async function generateOnboarding(projectRoot) {
   }
 }
 async function patchDashboardWithOnboardingRedirect(projectRoot, ctx) {
-  const dashboardPath = path13.join(
+  const dashboardPath = path14.join(
     projectRoot,
     "src",
     "app",
@@ -2839,9 +2839,9 @@ async function patchDashboardWithOnboardingRedirect(projectRoot, ctx) {
     "dashboard",
     "page.tsx"
   );
-  if (!await fs13.pathExists(dashboardPath)) return;
+  if (!await fs14.pathExists(dashboardPath)) return;
   await ctx.trackModifiedFile(dashboardPath);
-  let content = await fs13.readFile(dashboardPath, "utf-8");
+  let content = await fs14.readFile(dashboardPath, "utf-8");
   if (content.includes("isOnboardingComplete")) return;
   const redirectImport = `import { redirect } from 'next/navigation';
 `;
@@ -2876,27 +2876,27 @@ async function patchDashboardWithOnboardingRedirect(projectRoot, ctx) {
 `;
     content = content.slice(0, insertAt) + redirectBlock + content.slice(insertAt);
   }
-  await fs13.writeFile(dashboardPath, content);
+  await fs14.writeFile(dashboardPath, content);
 }
 async function patchProxyWithOnboardingRoute(projectRoot, ctx) {
-  const proxyPath = path13.join(projectRoot, "src", "proxy.ts");
-  if (!await fs13.pathExists(proxyPath)) return;
+  const proxyPath = path14.join(projectRoot, "src", "proxy.ts");
+  if (!await fs14.pathExists(proxyPath)) return;
   await ctx.trackModifiedFile(proxyPath);
-  let content = await fs13.readFile(proxyPath, "utf-8");
+  let content = await fs14.readFile(proxyPath, "utf-8");
   if (content.includes("routes.onboarding")) return;
   content = content.replace(
     /const protectedRoutes = \[([^\]]*)\]/,
     "const protectedRoutes = [$1, routes.onboarding]"
   );
-  await fs13.writeFile(proxyPath, content);
+  await fs14.writeFile(proxyPath, content);
 }
 async function setConfigFlag6(projectRoot, ctx) {
-  const configPath = path13.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs13.pathExists(configPath)) return;
+  const configPath = path14.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs14.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs13.readFile(configPath, "utf-8");
+  const content = await fs14.readFile(configPath, "utf-8");
   const updated = content.replace(/onboarding:\s*false/, "onboarding: true");
-  await fs13.writeFile(configPath, updated);
+  await fs14.writeFile(configPath, updated);
 }
 function prismaSchema2() {
   return `// Generated by mars generate onboarding (onboarding@${GENERATOR_VERSION6})
@@ -3423,11 +3423,11 @@ var search_exports = {};
 __export(search_exports, {
   generateSearch: () => generateSearch
 });
-import fs14 from "fs-extra";
-import path14 from "path";
+import fs15 from "fs-extra";
+import path15 from "path";
 async function generateSearch(projectRoot) {
-  const featureDir = path14.join(projectRoot, "src", "features", "search");
-  if (await fs14.pathExists(featureDir)) {
+  const featureDir = path15.join(projectRoot, "src", "features", "search");
+  if (await fs15.pathExists(featureDir)) {
     log.error("Search feature already exists at src/features/search/");
     return;
   }
@@ -3447,10 +3447,10 @@ async function generateSearch(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path14.join(projectRoot, filePath);
+      const fullPath = path15.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs14.ensureDir(path14.dirname(fullPath));
-      await fs14.writeFile(fullPath, content);
+      await fs15.ensureDir(path15.dirname(fullPath));
+      await fs15.writeFile(fullPath, content);
       count++;
     }
     await wireProtectedNav3(projectRoot, ctx);
@@ -3478,9 +3478,9 @@ async function generateSearch(projectRoot) {
   }
 }
 async function wireProtectedNav3(projectRoot, ctx) {
-  const navPath = path14.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
-  if (!await fs14.pathExists(navPath)) return;
-  let content = await fs14.readFile(navPath, "utf-8");
+  const navPath = path15.join(projectRoot, "src", "app", "(protected)", "layout.tsx");
+  if (!await fs15.pathExists(navPath)) return;
+  let content = await fs15.readFile(navPath, "utf-8");
   if (content.includes("NavSearch")) return;
   await ctx.trackModifiedFile(navPath);
   content = insertImportAfterDirectives(
@@ -3492,15 +3492,15 @@ async function wireProtectedNav3(projectRoot, ctx) {
     /(<div className="flex items-center gap-3">)\s*\n(\s*)(<)/,
     "$1\n$2<NavSearch />\n$2$3"
   );
-  await fs14.writeFile(navPath, content);
+  await fs15.writeFile(navPath, content);
 }
 async function setConfigFlag7(projectRoot, ctx) {
-  const configPath = path14.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs14.pathExists(configPath)) return;
+  const configPath = path15.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs15.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs14.readFile(configPath, "utf-8");
+  const content = await fs15.readFile(configPath, "utf-8");
   const updated = content.replace(/search:\s*false/, "search: true");
-  await fs14.writeFile(configPath, updated);
+  await fs15.writeFile(configPath, updated);
 }
 function types6() {
   return `${STAMP7}
@@ -3854,11 +3854,11 @@ var realtime_exports = {};
 __export(realtime_exports, {
   generateRealtime: () => generateRealtime
 });
-import fs15 from "fs-extra";
-import path15 from "path";
+import fs16 from "fs-extra";
+import path16 from "path";
 async function generateRealtime(projectRoot) {
-  const featureDir = path15.join(projectRoot, "src", "features", "realtime");
-  if (await fs15.pathExists(featureDir)) {
+  const featureDir = path16.join(projectRoot, "src", "features", "realtime");
+  if (await fs16.pathExists(featureDir)) {
     log.error("Realtime feature already exists at src/features/realtime/");
     return;
   }
@@ -3875,10 +3875,10 @@ async function generateRealtime(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path15.join(projectRoot, filePath);
+      const fullPath = path16.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs15.ensureDir(path15.dirname(fullPath));
-      await fs15.writeFile(fullPath, content);
+      await fs16.ensureDir(path16.dirname(fullPath));
+      await fs16.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag8(projectRoot, ctx);
@@ -3903,12 +3903,12 @@ async function generateRealtime(projectRoot) {
   }
 }
 async function setConfigFlag8(projectRoot, ctx) {
-  const configPath = path15.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs15.pathExists(configPath)) return;
+  const configPath = path16.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs16.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs15.readFile(configPath, "utf-8");
+  const content = await fs16.readFile(configPath, "utf-8");
   const updated = content.replace(/realtime:\s*false/, "realtime: true");
-  await fs15.writeFile(configPath, updated);
+  await fs16.writeFile(configPath, updated);
 }
 function types7() {
   return `${STAMP8}
@@ -4217,11 +4217,11 @@ var ai_exports = {};
 __export(ai_exports, {
   generateAI: () => generateAI
 });
-import fs16 from "fs-extra";
-import path16 from "path";
+import fs17 from "fs-extra";
+import path17 from "path";
 async function generateAI(projectRoot) {
-  const featureDir = path16.join(projectRoot, "src", "features", "ai");
-  if (await fs16.pathExists(featureDir)) {
+  const featureDir = path17.join(projectRoot, "src", "features", "ai");
+  if (await fs17.pathExists(featureDir)) {
     log.error("AI feature already exists at src/features/ai/");
     return;
   }
@@ -4244,10 +4244,10 @@ async function generateAI(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path16.join(projectRoot, filePath);
+      const fullPath = path17.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs16.ensureDir(path16.dirname(fullPath));
-      await fs16.writeFile(fullPath, content);
+      await fs17.ensureDir(path17.dirname(fullPath));
+      await fs17.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, {
@@ -4275,12 +4275,12 @@ async function generateAI(projectRoot) {
   }
 }
 async function setConfigFlag9(projectRoot, ctx) {
-  const configPath = path16.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs16.pathExists(configPath)) return;
+  const configPath = path17.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs17.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs16.readFile(configPath, "utf-8");
+  const content = await fs17.readFile(configPath, "utf-8");
   const updated = content.replace(/ai:\s*false/, "ai: true");
-  await fs16.writeFile(configPath, updated);
+  await fs17.writeFile(configPath, updated);
 }
 function types8() {
   return `${STAMP9}
@@ -4875,15 +4875,15 @@ export { ChatInput } from './ChatInput';
 `;
 }
 async function wireProtectedNav4(projectRoot, ctx) {
-  const layoutPath = path16.join(
+  const layoutPath = path17.join(
     projectRoot,
     "src",
     "app",
     "(protected)",
     "layout.tsx"
   );
-  if (!await fs16.pathExists(layoutPath)) return;
-  let content = await fs16.readFile(layoutPath, "utf-8");
+  if (!await fs17.pathExists(layoutPath)) return;
+  let content = await fs17.readFile(layoutPath, "utf-8");
   if (content.includes("routes.ai") || content.includes("label: 'AI'")) return;
   await ctx.trackModifiedFile(layoutPath);
   const insertion = `  if (appConfig.features.ai) {
@@ -4902,7 +4902,7 @@ async function wireProtectedNav4(projectRoot, ctx) {
       "// AI nav link added by mars generate ai\n"
     );
   }
-  await fs16.writeFile(layoutPath, content);
+  await fs17.writeFile(layoutPath, content);
 }
 function aiPage() {
   return `${STAMP9}
@@ -4991,11 +4991,11 @@ var cookie_consent_exports = {};
 __export(cookie_consent_exports, {
   generateCookieConsent: () => generateCookieConsent
 });
-import fs17 from "fs-extra";
-import path17 from "path";
+import fs18 from "fs-extra";
+import path18 from "path";
 async function generateCookieConsent(projectRoot) {
-  const featureDir = path17.join(projectRoot, "src", "features", "cookie-consent");
-  if (await fs17.pathExists(featureDir)) {
+  const featureDir = path18.join(projectRoot, "src", "features", "cookie-consent");
+  if (await fs18.pathExists(featureDir)) {
     log.error("Cookie consent feature already exists at src/features/cookie-consent/");
     return;
   }
@@ -5011,10 +5011,10 @@ async function generateCookieConsent(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path17.join(projectRoot, filePath);
+      const fullPath = path18.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs17.ensureDir(path17.dirname(fullPath));
-      await fs17.writeFile(fullPath, content);
+      await fs18.ensureDir(path18.dirname(fullPath));
+      await fs18.writeFile(fullPath, content);
       count++;
     }
     await wireLayout3(projectRoot, ctx);
@@ -5039,9 +5039,9 @@ async function generateCookieConsent(projectRoot) {
   }
 }
 async function wireLayout3(projectRoot, ctx) {
-  const layoutPath = path17.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs17.pathExists(layoutPath)) return;
-  let content = await fs17.readFile(layoutPath, "utf-8");
+  const layoutPath = path18.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs18.pathExists(layoutPath)) return;
+  let content = await fs18.readFile(layoutPath, "utf-8");
   if (content.includes("CookieConsentBanner")) return;
   await ctx.trackModifiedFile(layoutPath);
   content = `import { CookieConsentBanner } from '@/features/cookie-consent';
@@ -5050,15 +5050,15 @@ ${content}`;
     /(\s*)(<Providers>[\s\S]*?<\/Providers>)/,
     "$1$2\n$1<CookieConsentBanner />"
   );
-  await fs17.writeFile(layoutPath, content);
+  await fs18.writeFile(layoutPath, content);
 }
 async function setConfigFlag10(projectRoot, ctx) {
-  const configPath = path17.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs17.pathExists(configPath)) return;
+  const configPath = path18.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs18.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs17.readFile(configPath, "utf-8");
+  const content = await fs18.readFile(configPath, "utf-8");
   const updated = content.replace(/cookieConsent:\s*false/, "cookieConsent: true");
-  await fs17.writeFile(configPath, updated);
+  await fs18.writeFile(configPath, updated);
 }
 function types9() {
   return `${STAMP10}
@@ -5343,11 +5343,11 @@ var coming_soon_exports = {};
 __export(coming_soon_exports, {
   generateComingSoon: () => generateComingSoon
 });
-import fs18 from "fs-extra";
-import path18 from "path";
+import fs19 from "fs-extra";
+import path19 from "path";
 async function generateComingSoon(projectRoot) {
-  const featureDir = path18.join(projectRoot, "src", "features", "coming-soon");
-  if (await fs18.pathExists(featureDir)) {
+  const featureDir = path19.join(projectRoot, "src", "features", "coming-soon");
+  if (await fs19.pathExists(featureDir)) {
     log.error("Coming soon feature already exists at src/features/coming-soon/");
     return;
   }
@@ -5364,10 +5364,10 @@ async function generateComingSoon(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path18.join(projectRoot, filePath);
+      const fullPath = path19.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs18.ensureDir(path18.dirname(fullPath));
-      await fs18.writeFile(fullPath, content);
+      await fs19.ensureDir(path19.dirname(fullPath));
+      await fs19.writeFile(fullPath, content);
       count++;
     }
     await registerRoute(projectRoot, "comingSoon", "/coming-soon", ctx);
@@ -5389,12 +5389,12 @@ async function generateComingSoon(projectRoot) {
   }
 }
 async function setConfigFlag11(projectRoot, ctx) {
-  const configPath = path18.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs18.pathExists(configPath)) return;
+  const configPath = path19.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs19.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs18.readFile(configPath, "utf-8");
+  const content = await fs19.readFile(configPath, "utf-8");
   const updated = content.replace(/comingSoon:\s*false/, "comingSoon: true");
-  await fs18.writeFile(configPath, updated);
+  await fs19.writeFile(configPath, updated);
 }
 function types10() {
   return `${STAMP11}
@@ -5582,11 +5582,11 @@ var sentry_exports = {};
 __export(sentry_exports, {
   generateSentry: () => generateSentry
 });
-import fs19 from "fs-extra";
-import path19 from "path";
+import fs20 from "fs-extra";
+import path20 from "path";
 async function generateSentry(projectRoot) {
-  const featureDir = path19.join(projectRoot, "src", "features", "sentry");
-  if (await fs19.pathExists(featureDir)) {
+  const featureDir = path20.join(projectRoot, "src", "features", "sentry");
+  if (await fs20.pathExists(featureDir)) {
     log.error("Sentry feature already exists at src/features/sentry/");
     return;
   }
@@ -5602,10 +5602,10 @@ async function generateSentry(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path19.join(projectRoot, filePath);
+      const fullPath = path20.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs19.ensureDir(path19.dirname(fullPath));
-      await fs19.writeFile(fullPath, content);
+      await fs20.ensureDir(path20.dirname(fullPath));
+      await fs20.writeFile(fullPath, content);
       count++;
     }
     await addDependencies(projectRoot, { "@sentry/nextjs": "^8.0.0" });
@@ -5631,9 +5631,9 @@ async function generateSentry(projectRoot) {
   }
 }
 async function wireRootLayout(projectRoot, ctx) {
-  const layoutPath = path19.join(projectRoot, "src", "app", "layout.tsx");
-  if (!await fs19.pathExists(layoutPath)) return;
-  let content = await fs19.readFile(layoutPath, "utf-8");
+  const layoutPath = path20.join(projectRoot, "src", "app", "layout.tsx");
+  if (!await fs20.pathExists(layoutPath)) return;
+  let content = await fs20.readFile(layoutPath, "utf-8");
   if (content.includes("ErrorBoundary")) return;
   await ctx.trackModifiedFile(layoutPath);
   content = `import { ErrorBoundary } from '@/features/sentry';
@@ -5642,15 +5642,15 @@ ${content}`;
     /(<Providers>)\{children\}(<\/Providers>)/,
     "$1<ErrorBoundary>{children}</ErrorBoundary>$2"
   );
-  await fs19.writeFile(layoutPath, content);
+  await fs20.writeFile(layoutPath, content);
 }
 async function setConfigFlag12(projectRoot, ctx) {
-  const configPath = path19.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs19.pathExists(configPath)) return;
+  const configPath = path20.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs20.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs19.readFile(configPath, "utf-8");
+  const content = await fs20.readFile(configPath, "utf-8");
   const updated = content.replace(/sentry:\s*false/, "sentry: true");
-  await fs19.writeFile(configPath, updated);
+  await fs20.writeFile(configPath, updated);
 }
 function types11() {
   return `${STAMP12}
@@ -5795,11 +5795,11 @@ var feature_flags_exports = {};
 __export(feature_flags_exports, {
   generateFeatureFlags: () => generateFeatureFlags
 });
-import fs20 from "fs-extra";
-import path20 from "path";
+import fs21 from "fs-extra";
+import path21 from "path";
 async function generateFeatureFlags(projectRoot) {
-  const featureDir = path20.join(projectRoot, "src", "features", "feature-flags");
-  if (await fs20.pathExists(featureDir)) {
+  const featureDir = path21.join(projectRoot, "src", "features", "feature-flags");
+  if (await fs21.pathExists(featureDir)) {
     log.error("Feature flags feature already exists at src/features/feature-flags/");
     return;
   }
@@ -5818,10 +5818,10 @@ async function generateFeatureFlags(projectRoot) {
     };
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path20.join(projectRoot, filePath);
+      const fullPath = path21.join(projectRoot, filePath);
       ctx.trackCreatedFile(fullPath);
-      await fs20.ensureDir(path20.dirname(fullPath));
-      await fs20.writeFile(fullPath, content);
+      await fs21.ensureDir(path21.dirname(fullPath));
+      await fs21.writeFile(fullPath, content);
       count++;
     }
     await setConfigFlag13(projectRoot, ctx);
@@ -5841,12 +5841,12 @@ async function generateFeatureFlags(projectRoot) {
   }
 }
 async function setConfigFlag13(projectRoot, ctx) {
-  const configPath = path20.join(projectRoot, "src", "config", "app.config.ts");
-  if (!await fs20.pathExists(configPath)) return;
+  const configPath = path21.join(projectRoot, "src", "config", "app.config.ts");
+  if (!await fs21.pathExists(configPath)) return;
   await ctx.trackModifiedFile(configPath);
-  const content = await fs20.readFile(configPath, "utf-8");
+  const content = await fs21.readFile(configPath, "utf-8");
   const updated = content.replace(/featureFlags:\s*false/, "featureFlags: true");
-  await fs20.writeFile(configPath, updated);
+  await fs21.writeFile(configPath, updated);
 }
 function types12() {
   return `${STAMP13}
@@ -6113,8 +6113,8 @@ function getCliVersion() {
 
 // src/commands/create.ts
 init_logger();
-import fs22 from "fs-extra";
-import path22 from "path";
+import fs23 from "fs-extra";
+import path23 from "path";
 import os3 from "os";
 import ora from "ora";
 import pc2 from "picocolors";
@@ -6540,9 +6540,50 @@ async function promptTheme() {
 
 // src/generators/scaffold.ts
 init_logger();
+import fs4 from "fs-extra";
+import path4 from "path";
+import { generateBrandCss } from "@mars-stack/ui/utils";
+
+// src/utils/fingerprint.ts
+import { createHash } from "crypto";
 import fs3 from "fs-extra";
 import path3 from "path";
-import { generateBrandCss } from "@mars-stack/ui/utils";
+init_logger();
+async function checksumFile(filePath) {
+  const content = await fs3.readFile(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+var PLUMBING_FILES_TO_CHECKSUM = [
+  "scripts/ensure-db.mjs",
+  "src/middleware.ts",
+  "src/app/(auth)/sign-in/page.tsx",
+  "src/app/(auth)/register/page.tsx",
+  "src/app/(auth)/verify/page.tsx",
+  "src/lib/mars.ts"
+];
+async function writeScaffoldFingerprint(projectDir) {
+  try {
+    const checksums = {};
+    for (const relativePath of PLUMBING_FILES_TO_CHECKSUM) {
+      const fullPath = path3.join(projectDir, relativePath);
+      if (await fs3.pathExists(fullPath)) {
+        checksums[relativePath] = await checksumFile(fullPath);
+      }
+    }
+    const fingerprint = {
+      schemaVersion: 1,
+      cliVersion: getCliVersion(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      template: "default",
+      checksums
+    };
+    const marsDir = path3.join(projectDir, ".mars");
+    await fs3.ensureDir(marsDir);
+    await fs3.writeJson(path3.join(marsDir, "scaffold.json"), fingerprint, { spaces: 2 });
+  } catch (error) {
+    log.warn("Could not write .mars/scaffold.json \u2014 scaffold continues without fingerprint.");
+  }
+}
 
 // src/generators/app-config.ts
 function escapeQuotes(value) {
@@ -6725,17 +6766,17 @@ var IGNORED_FILES = [
 async function copyTemplateFiles(templateDir, targetDir) {
   let fileCount = 0;
   async function walkAndCopy(src, dest) {
-    const entries = await fs3.readdir(src, { withFileTypes: true });
+    const entries = await fs4.readdir(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path3.join(src, entry.name);
-      const destPath = path3.join(dest, entry.name);
+      const srcPath = path4.join(src, entry.name);
+      const destPath = path4.join(dest, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.includes(entry.name)) continue;
-        await fs3.ensureDir(destPath);
+        await fs4.ensureDir(destPath);
         await walkAndCopy(srcPath, destPath);
       } else {
         if (IGNORED_FILES.includes(entry.name)) continue;
-        await fs3.copy(srcPath, destPath);
+        await fs4.copy(srcPath, destPath);
         fileCount++;
       }
     }
@@ -6746,19 +6787,19 @@ async function copyTemplateFiles(templateDir, targetDir) {
 function resolveMarsPackageRange(packageName, templateDir) {
   const shortName = packageName.replace("@mars-stack/", "");
   const candidates = [
-    path3.resolve(templateDir, "..", "packages", shortName, "package.json"),
-    path3.resolve(templateDir, "..", "..", "packages", shortName, "package.json")
+    path4.resolve(templateDir, "..", "packages", shortName, "package.json"),
+    path4.resolve(templateDir, "..", "..", "packages", shortName, "package.json")
   ];
   for (const candidate of candidates) {
-    if (fs3.existsSync(candidate)) {
-      const pkg = fs3.readJsonSync(candidate);
+    if (fs4.existsSync(candidate)) {
+      const pkg = fs4.readJsonSync(candidate);
       if (typeof pkg.version === "string") {
         const [major, minor] = pkg.version.split(".");
         return `^${major}.${minor}.0`;
       }
     }
   }
-  const templatePkg = fs3.readJsonSync(path3.join(templateDir, "package.json"));
+  const templatePkg = fs4.readJsonSync(path4.join(templateDir, "package.json"));
   const existing = templatePkg.dependencies?.[packageName];
   if (existing && existing !== "*") {
     if (/^[\^~>=]/.test(existing)) return existing;
@@ -6769,8 +6810,8 @@ function resolveMarsPackageRange(packageName, templateDir) {
 }
 function generatePackageJson(config) {
   const templateDir = getTemplatePath();
-  const templatePkg = path3.join(templateDir, "package.json");
-  const pkg = fs3.readJsonSync(templatePkg);
+  const templatePkg = path4.join(templateDir, "package.json");
+  const pkg = fs4.readJsonSync(templatePkg);
   pkg.name = config.name;
   pkg.version = "0.1.0";
   pkg.private = true;
@@ -6920,8 +6961,9 @@ dist/
 .env.development.local
 .env.test
 
-# local database
-.mars/
+# local database (keep scaffold.json for project metadata)
+.mars/*
+!.mars/scaffold.json
 
 # misc
 .DS_Store
@@ -6971,9 +7013,9 @@ async function pruneDisabledFeatures(features, targetDir) {
     const flagValue = features[feature];
     if (flagValue !== false) continue;
     for (const relativePath of paths) {
-      const fullPath = path3.join(targetDir, relativePath);
-      if (await fs3.pathExists(fullPath)) {
-        await fs3.remove(fullPath);
+      const fullPath = path4.join(targetDir, relativePath);
+      if (await fs4.pathExists(fullPath)) {
+        await fs4.remove(fullPath);
         log.step(`Pruned disabled feature path: ${relativePath}`);
       }
     }
@@ -6982,43 +7024,44 @@ async function pruneDisabledFeatures(features, targetDir) {
     }
   }
   if (relationsToRemove.length > 0) {
-    const authPath = path3.join(targetDir, "prisma", "schema", "auth.prisma");
-    if (await fs3.pathExists(authPath)) {
-      let content = await fs3.readFile(authPath, "utf-8");
+    const authPath = path4.join(targetDir, "prisma", "schema", "auth.prisma");
+    if (await fs4.pathExists(authPath)) {
+      let content = await fs4.readFile(authPath, "utf-8");
       for (const field of relationsToRemove) {
         content = content.replace(new RegExp(`\\s*${field}\\s+\\S+.*\\n`, "g"), "\n");
       }
-      await fs3.writeFile(authPath, content);
+      await fs4.writeFile(authPath, content);
     }
   }
 }
 async function scaffoldProject(targetDir, config) {
   const templateDir = getTemplatePath();
-  if (!await fs3.pathExists(templateDir)) {
+  if (!await fs4.pathExists(templateDir)) {
     throw new Error(`Template directory not found: ${templateDir}`);
   }
-  await fs3.ensureDir(targetDir);
+  await fs4.ensureDir(targetDir);
   const fileCount = await copyTemplateFiles(templateDir, targetDir);
   await pruneDisabledFeatures(config.features, targetDir);
-  await fs3.writeFile(path3.join(targetDir, "package.json"), generatePackageJson(config));
-  await fs3.writeFile(
-    path3.join(targetDir, "src", "config", "app.config.ts"),
+  await fs4.writeFile(path4.join(targetDir, "package.json"), generatePackageJson(config));
+  await fs4.writeFile(
+    path4.join(targetDir, "src", "config", "app.config.ts"),
     generateAppConfig(config)
   );
-  await fs3.writeFile(path3.join(targetDir, "docker-compose.yml"), generateDockerCompose(config));
-  await fs3.writeFile(path3.join(targetDir, "src", "app", "layout.tsx"), generateLayout(config));
-  await fs3.writeFile(path3.join(targetDir, ".env"), generateEnvFile(config));
-  await fs3.writeFile(path3.join(targetDir, ".env.example"), generateEnvExample(config));
-  await fs3.writeFile(path3.join(targetDir, ".gitignore"), generateGitignore());
+  await fs4.writeFile(path4.join(targetDir, "docker-compose.yml"), generateDockerCompose(config));
+  await fs4.writeFile(path4.join(targetDir, "src", "app", "layout.tsx"), generateLayout(config));
+  await fs4.writeFile(path4.join(targetDir, ".env"), generateEnvFile(config));
+  await fs4.writeFile(path4.join(targetDir, ".env.example"), generateEnvExample(config));
+  await fs4.writeFile(path4.join(targetDir, ".gitignore"), generateGitignore());
   await patchGlobalsCssForScaffoldedProject(targetDir, config);
   await generateBrandCssForProject(targetDir, config);
+  await writeScaffoldFingerprint(targetDir);
   return { fileCount };
 }
 async function generateBrandCssForProject(targetDir, config) {
-  const brandPath = path3.join(targetDir, "src", "styles", "brand.css");
-  if (!await fs3.pathExists(brandPath)) return;
+  const brandPath = path4.join(targetDir, "src", "styles", "brand.css");
+  if (!await fs4.pathExists(brandPath)) return;
   const css = generateBrandCss(config.theme.primaryColor);
-  await fs3.writeFile(brandPath, css);
+  await fs4.writeFile(brandPath, css);
 }
 var VALID_DESIGN_DIRECTIONS = [
   "modern-saas",
@@ -7028,9 +7071,9 @@ var VALID_DESIGN_DIRECTIONS = [
   "dashboard"
 ];
 async function patchGlobalsCssForScaffoldedProject(targetDir, config) {
-  const globalsPath = path3.join(targetDir, "src", "styles", "globals.css");
-  if (!await fs3.pathExists(globalsPath)) return;
-  let content = await fs3.readFile(globalsPath, "utf-8");
+  const globalsPath = path4.join(targetDir, "src", "styles", "globals.css");
+  if (!await fs4.pathExists(globalsPath)) return;
+  let content = await fs4.readFile(globalsPath, "utf-8");
   content = content.replace(
     '@source "../../../node_modules/@mars-stack/ui/dist/**/*.js";',
     '@source "../../node_modules/@mars-stack/ui/dist/**/*.js";'
@@ -7049,7 +7092,7 @@ async function patchGlobalsCssForScaffoldedProject(targetDir, config) {
 ${newImport}`
     );
   }
-  await fs3.writeFile(globalsPath, content);
+  await fs4.writeFile(globalsPath, content);
 }
 
 // src/generators/generate-selected.ts
@@ -7165,13 +7208,13 @@ async function generateSelectedFeatures(projectRoot, features) {
 }
 
 // src/utils/telemetry.ts
-import fs21 from "fs-extra";
-import path21 from "path";
+import fs22 from "fs-extra";
+import path22 from "path";
 import os2 from "os";
-var RC_PATH = path21.join(os2.homedir(), ".marsrc");
+var RC_PATH = path22.join(os2.homedir(), ".marsrc");
 function isTelemetryEnabled() {
   try {
-    const config = fs21.readJsonSync(RC_PATH);
+    const config = fs22.readJsonSync(RC_PATH);
     return config.enabled === true;
   } catch {
     return false;
@@ -7180,16 +7223,16 @@ function isTelemetryEnabled() {
 function enableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = true;
-  fs21.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs22.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function disableTelemetry() {
   const config = loadOrCreateConfig();
   config.enabled = false;
-  fs21.writeJsonSync(RC_PATH, config, { spaces: 2 });
+  fs22.writeJsonSync(RC_PATH, config, { spaces: 2 });
 }
 function loadOrCreateConfig() {
   try {
-    return fs21.readJsonSync(RC_PATH);
+    return fs22.readJsonSync(RC_PATH);
   } catch {
     return { enabled: false, anonymousId: crypto.randomUUID() };
   }
@@ -7209,13 +7252,13 @@ function trackEvent(event, properties) {
     },
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const logPath = path21.join(os2.homedir(), ".mars-telemetry.log");
-  fs21.appendFile(logPath, JSON.stringify(payload) + "\n").catch(() => {
+  const logPath = path22.join(os2.homedir(), ".mars-telemetry.log");
+  fs22.appendFile(logPath, JSON.stringify(payload) + "\n").catch(() => {
   });
 }
 
 // src/commands/create.ts
-var RC_PATH2 = path22.join(os3.homedir(), ".marsrc");
+var RC_PATH2 = path23.join(os3.homedir(), ".marsrc");
 var PROJECT_NAME_REGEX = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
 var MAX_PROJECT_NAME_LENGTH = 214;
 async function createCommand(projectName, options) {
@@ -7242,8 +7285,8 @@ async function createCommand(projectName, options) {
   const projectInfo = useDefaults ? getDefaultProjectInfo(projectName) : await promptProjectInfo(projectName);
   if (!projectInfo) return;
   const targetDir = resolveProjectPath(projectInfo.name);
-  if (await fs22.pathExists(targetDir)) {
-    const entries = await fs22.readdir(targetDir);
+  if (await fs23.pathExists(targetDir)) {
+    const entries = await fs23.readdir(targetDir);
     if (entries.length > 0) {
       log.error(`Directory "${projectInfo.name}" already exists and is not empty.`);
       return;
@@ -7284,7 +7327,7 @@ async function createCommand(projectName, options) {
       log.info("Scaffolding cancelled.");
       process.exit(0);
     }
-    if (!fs22.pathExistsSync(RC_PATH2)) {
+    if (!fs23.pathExistsSync(RC_PATH2)) {
       const { telemetryOptIn } = await prompts5(
         {
           type: "confirm",
@@ -7323,10 +7366,10 @@ async function createCommand(projectName, options) {
   } catch (err) {
     spinner.fail("Failed to scaffold project");
     log.error(err instanceof Error ? err.message : String(err));
-    if (await fs22.pathExists(targetDir)) {
+    if (await fs23.pathExists(targetDir)) {
       const cleanupSpinner = ora("Cleaning up...").start();
       try {
-        await fs22.remove(targetDir);
+        await fs23.remove(targetDir);
         cleanupSpinner.succeed("Cleaned up partial scaffold");
       } catch {
         cleanupSpinner.warn(`Could not clean up ${targetDir}. You may need to remove it manually.`);
@@ -7341,8 +7384,8 @@ function countEnabled(flags) {
 
 // src/commands/doctor.ts
 init_logger();
-import fs23 from "fs-extra";
-import path23 from "path";
+import fs24 from "fs-extra";
+import path24 from "path";
 import { execSync } from "child_process";
 function commandExists(cmd) {
   try {
@@ -7362,12 +7405,12 @@ function getVersion(cmd) {
 async function checkForUpgrades() {
   log.blank();
   log.title("Upgrade Check");
-  const packageJsonPath = path23.join(process.cwd(), "package.json");
-  if (!fs23.pathExistsSync(packageJsonPath)) {
+  const packageJsonPath = path24.join(process.cwd(), "package.json");
+  if (!fs24.pathExistsSync(packageJsonPath)) {
     log.warn("No package.json found \u2014 skipping upgrade check.");
     return;
   }
-  const packageJson = fs23.readJsonSync(packageJsonPath);
+  const packageJson = fs24.readJsonSync(packageJsonPath);
   const deps = packageJson.dependencies ?? {};
   const devDeps = packageJson.devDependencies ?? {};
   const currentRaw = deps["@mars-stack/core"] ?? devDeps["@mars-stack/core"];
@@ -7429,25 +7472,25 @@ async function doctorCommand(options) {
     },
     {
       name: "package.json exists",
-      check: () => fs23.pathExistsSync(path23.join(process.cwd(), "package.json"))
+      check: () => fs24.pathExistsSync(path24.join(process.cwd(), "package.json"))
     },
     {
       name: ".env file exists",
-      check: () => fs23.pathExistsSync(path23.join(process.cwd(), ".env"))
+      check: () => fs24.pathExistsSync(path24.join(process.cwd(), ".env"))
     },
     {
       name: "Prisma schema exists",
-      check: () => fs23.pathExistsSync(path23.join(process.cwd(), "prisma", "schema")) || fs23.pathExistsSync(path23.join(process.cwd(), "prisma", "schema.prisma"))
+      check: () => fs24.pathExistsSync(path24.join(process.cwd(), "prisma", "schema")) || fs24.pathExistsSync(path24.join(process.cwd(), "prisma", "schema.prisma"))
     },
     {
       name: "node_modules installed",
-      check: () => fs23.pathExistsSync(path23.join(process.cwd(), "node_modules"))
+      check: () => fs24.pathExistsSync(path24.join(process.cwd(), "node_modules"))
     },
     {
       name: "DATABASE_URL set",
       check: () => {
         try {
-          const envContent = fs23.readFileSync(path23.join(process.cwd(), ".env"), "utf-8");
+          const envContent = fs24.readFileSync(path24.join(process.cwd(), ".env"), "utf-8");
           const match = envContent.match(/^DATABASE_URL=(.+)$/m);
           return match ? match[1] !== "" : false;
         } catch {
@@ -7459,7 +7502,7 @@ async function doctorCommand(options) {
       name: "JWT_SECRET set",
       check: () => {
         try {
-          const envContent = fs23.readFileSync(path23.join(process.cwd(), ".env"), "utf-8");
+          const envContent = fs24.readFileSync(path24.join(process.cwd(), ".env"), "utf-8");
           const match = envContent.match(/^JWT_SECRET=(.+)$/m);
           if (!match || !match[1]) return false;
           return match[1].length >= 32 ? true : "set but too short (need >=32 chars)";
@@ -7504,16 +7547,16 @@ async function doctorCommand(options) {
 
 // src/commands/add.ts
 init_logger();
-import fs25 from "fs-extra";
-import path25 from "path";
+import fs26 from "fs-extra";
+import path26 from "path";
 import pc3 from "picocolors";
 
 // src/utils/doc-updater.ts
-import fs24 from "fs-extra";
-import path24 from "path";
+import fs25 from "fs-extra";
+import path25 from "path";
 async function appendToDbSchema(projectDir, modelName, fields) {
-  const filePath = path24.join(projectDir, "docs", "generated", "db-schema.md");
-  if (!await fs24.pathExists(filePath)) return;
+  const filePath = path25.join(projectDir, "docs", "generated", "db-schema.md");
+  if (!await fs25.pathExists(filePath)) return;
   const entry = [
     "",
     `### ${modelName}`,
@@ -7523,12 +7566,12 @@ async function appendToDbSchema(projectDir, modelName, fields) {
     ...fields.map((f) => `| ${f} |  |`),
     ""
   ].join("\n");
-  await fs24.appendFile(filePath, entry);
+  await fs25.appendFile(filePath, entry);
 }
 async function updateQualityScore(projectDir, domain, grade) {
-  const filePath = path24.join(projectDir, "docs", "QUALITY_SCORE.md");
-  if (!await fs24.pathExists(filePath)) return;
-  const content = await fs24.readFile(filePath, "utf-8");
+  const filePath = path25.join(projectDir, "docs", "QUALITY_SCORE.md");
+  if (!await fs25.pathExists(filePath)) return;
+  const content = await fs25.readFile(filePath, "utf-8");
   const pattern = new RegExp(`^\\|\\s*${escapeRegex(domain)}\\s*\\|`, "m");
   if (pattern.test(content)) {
     const updated = content.replace(pattern, (match) => {
@@ -7536,11 +7579,11 @@ async function updateQualityScore(projectDir, domain, grade) {
       parts[2] = ` ${grade} `;
       return parts.join("|");
     });
-    await fs24.writeFile(filePath, updated);
+    await fs25.writeFile(filePath, updated);
   } else {
     const row = `| ${domain} | ${grade} |  |
 `;
-    await fs24.appendFile(filePath, row);
+    await fs25.appendFile(filePath, row);
   }
 }
 function escapeRegex(str) {
@@ -7551,8 +7594,8 @@ function escapeRegex(str) {
 init_rollback();
 function ensureInProject() {
   const cwd = process.cwd();
-  const configPath = path25.join(cwd, "src", "config", "app.config.ts");
-  if (!fs25.pathExistsSync(configPath)) {
+  const configPath = path26.join(cwd, "src", "config", "app.config.ts");
+  if (!fs26.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7578,15 +7621,98 @@ function pluralize(word) {
   return word + "s";
 }
 function stripBrackets(segment) {
-  return segment.replace(/[\[\]]/g, "");
+  return segment.replace(/[\[\]\.]/g, "");
+}
+function parseDynamicParams(routePath) {
+  const segments = routePath.split("/").filter(Boolean);
+  const params = [];
+  for (const segment of segments) {
+    if (/^\[/.test(segment)) {
+      const catchAll = /^\[\.\.\./.test(segment);
+      const name = segment.replace(/^\[(?:\.\.\.)?/, "").replace(/\]$/, "");
+      params.push({ name, catchAll });
+    }
+  }
+  return params;
+}
+function buildPageContent(pageName, dynamicParams) {
+  const hasParams = dynamicParams.length > 0;
+  if (!hasParams) {
+    return `import { Card, CardHeader, CardBody } from '@mars-stack/ui';
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: '${pageName}',
+};
+
+export default function ${pageName}Page() {
+  return (
+    <div className="mx-auto max-w-4xl space-y-6 p-6">
+      <div>
+        <h1 className="text-4xl font-bold text-text-primary mb-4">${pageName}</h1>
+        <p className="text-base text-text-secondary mb-4">
+          Description goes here.
+        </p>
+      </div>
+
+      <Card>
+        <CardHeader>
+          <h2 className="text-lg font-semibold text-text-primary">${pageName}</h2>
+        </CardHeader>
+        <CardBody>
+          {/* Content */}
+        </CardBody>
+      </Card>
+    </div>
+  );
+}
+`;
+  }
+  const paramFields = dynamicParams.map((p) => `${p.name}: ${p.catchAll ? "string[]" : "string"}`).join("; ");
+  const destructuredNames = dynamicParams.map((p) => p.name).join(", ");
+  return `import { Card, CardHeader, CardBody } from '@mars-stack/ui';
+import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: '${pageName}',
+};
+
+interface Props {
+  params: Promise<{ ${paramFields} }>;
+}
+
+export default async function ${pageName}Page({ params }: Props) {
+  const { ${destructuredNames} } = await params;
+
+  return (
+    <div className="mx-auto max-w-4xl space-y-6 p-6">
+      <div>
+        <h1 className="text-4xl font-bold text-text-primary mb-4">{${dynamicParams[0].name}}</h1>
+        <p className="text-base text-text-secondary mb-4">
+          Description goes here.
+        </p>
+      </div>
+
+      <Card>
+        <CardHeader>
+          <h2 className="text-lg font-semibold text-text-primary">${pageName}</h2>
+        </CardHeader>
+        <CardBody>
+          {/* Content */}
+        </CardBody>
+      </Card>
+    </div>
+  );
+}
+`;
 }
 async function addFeatureCommand(name) {
   const root = ensureInProject();
   const kebab = toKebab(name);
   const pascal = toPascal(name);
   const camel = toCamel(name);
-  const featureDir = path25.join(root, "src", "features", kebab);
-  if (await fs25.pathExists(featureDir)) {
+  const featureDir = path26.join(root, "src", "features", kebab);
+  if (await fs26.pathExists(featureDir)) {
     log.error(`Feature "${kebab}" already exists at src/features/${kebab}/`);
     return;
   }
@@ -7651,9 +7777,9 @@ export type Update${pascal}Input = z.infer<typeof ${camel}Schemas.update>;
     ctx.trackCreatedFile(featureDir);
     let count = 0;
     for (const [filePath, content] of Object.entries(files)) {
-      const fullPath = path25.join(featureDir, filePath);
-      await fs25.ensureDir(path25.dirname(fullPath));
-      await fs25.writeFile(fullPath, content);
+      const fullPath = path26.join(featureDir, filePath);
+      await fs26.ensureDir(path26.dirname(fullPath));
+      await fs26.writeFile(fullPath, content);
       count++;
     }
     await ctx.commit();
@@ -7674,42 +7800,15 @@ async function addPageCommand(routePath, options) {
   const root = ensureInProject();
   const cleanPath = routePath.startsWith("/") ? routePath.slice(1) : routePath;
   const group = options.protected ? "(protected)" : "(public)";
-  const pageDir = path25.join(root, "src", "app", group, cleanPath);
-  if (await fs25.pathExists(path25.join(pageDir, "page.tsx"))) {
+  const pageDir = path26.join(root, "src", "app", group, cleanPath);
+  if (await fs26.pathExists(path26.join(pageDir, "page.tsx"))) {
     log.error(`Page already exists at src/app/${group}/${cleanPath}/page.tsx`);
     return;
   }
   const lastSegment = cleanPath.split("/").pop() || "page";
   const pageName = toPascal(stripBrackets(lastSegment));
-  const pageContent = `import { Card, CardHeader, CardBody } from '@mars-stack/ui';
-import type { Metadata } from 'next';
-
-export const metadata: Metadata = {
-  title: '${pageName}',
-};
-
-export default function ${pageName}Page() {
-  return (
-    <div className="mx-auto max-w-4xl space-y-6 p-6">
-      <div>
-        <h1 className="text-4xl font-bold text-text-primary mb-4">${pageName}</h1>
-        <p className="text-base text-text-secondary mb-4">
-          Description goes here.
-        </p>
-      </div>
-
-      <Card>
-        <CardHeader>
-          <h2 className="text-lg font-semibold text-text-primary">${pageName}</h2>
-        </CardHeader>
-        <CardBody>
-          {/* Content */}
-        </CardBody>
-      </Card>
-    </div>
-  );
-}
-`;
+  const dynamicParams = parseDynamicParams(cleanPath);
+  const pageContent = buildPageContent(pageName, dynamicParams);
   const loadingContent = `import { Spinner } from '@mars-stack/ui';
 
 export default function Loading() {
@@ -7723,9 +7822,9 @@ export default function Loading() {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(pageDir);
-    await fs25.ensureDir(pageDir);
-    await fs25.writeFile(path25.join(pageDir, "page.tsx"), pageContent);
-    await fs25.writeFile(path25.join(pageDir, "loading.tsx"), loadingContent);
+    await fs26.ensureDir(pageDir);
+    await fs26.writeFile(path26.join(pageDir, "page.tsx"), pageContent);
+    await fs26.writeFile(path26.join(pageDir, "loading.tsx"), loadingContent);
     await ctx.commit();
     log.success(`Created page at ${pc3.bold(`src/app/${group}/${cleanPath}/`)}`);
     trackEvent("add", { type: "page" });
@@ -7742,9 +7841,9 @@ async function addModelCommand(name) {
   const pascal = toPascal(name);
   const camel = toCamel(name);
   const kebab = toKebab(name);
-  const schemaDir = path25.join(root, "prisma", "schema");
-  const schemaFile = path25.join(schemaDir, `${kebab}.prisma`);
-  if (await fs25.pathExists(schemaFile)) {
+  const schemaDir = path26.join(root, "prisma", "schema");
+  const schemaFile = path26.join(schemaDir, `${kebab}.prisma`);
+  if (await fs26.pathExists(schemaFile)) {
     log.error(`Schema file already exists: prisma/schema/${kebab}.prisma`);
     return;
   }
@@ -7762,8 +7861,8 @@ async function addModelCommand(name) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(schemaFile);
-    await fs25.ensureDir(schemaDir);
-    await fs25.writeFile(schemaFile, content);
+    await fs26.ensureDir(schemaDir);
+    await fs26.writeFile(schemaFile, content);
     await ctx.commit();
     log.success(`Created model ${pc3.bold(pascal)} at prisma/schema/${kebab}.prisma`);
     trackEvent("add", { type: "model" });
@@ -7785,9 +7884,9 @@ async function addEmailCommand(name) {
   const kebab = toKebab(name);
   const pascal = toPascal(name);
   const camel = toCamel(name);
-  const templatesDir = path25.join(root, "src", "lib", "core", "email", "templates");
-  const filePath = path25.join(templatesDir, `${kebab}-email.ts`);
-  if (await fs25.pathExists(filePath)) {
+  const templatesDir = path26.join(root, "src", "lib", "core", "email", "templates");
+  const filePath = path26.join(templatesDir, `${kebab}-email.ts`);
+  if (await fs26.pathExists(filePath)) {
     log.error(`Email template already exists: src/lib/core/email/templates/${kebab}-email.ts`);
     return;
   }
@@ -7831,25 +7930,25 @@ export function ${functionName}({ appName, actionUrl, userName }: ${pascal}Email
 }
 `;
   const ctx = createRollbackContext();
-  const indexPath = path25.join(templatesDir, "index.ts");
+  const indexPath = path26.join(templatesDir, "index.ts");
   try {
     ctx.trackCreatedFile(filePath);
-    if (await fs25.pathExists(indexPath)) {
+    if (await fs26.pathExists(indexPath)) {
       await ctx.trackModifiedFile(indexPath);
     } else {
       ctx.trackCreatedFile(indexPath);
     }
-    await fs25.ensureDir(templatesDir);
-    await fs25.writeFile(filePath, content);
+    await fs26.ensureDir(templatesDir);
+    await fs26.writeFile(filePath, content);
     const exportLine = `export { ${functionName} } from './${kebab}-email';
 `;
-    if (await fs25.pathExists(indexPath)) {
-      const existing = await fs25.readFile(indexPath, "utf-8");
+    if (await fs26.pathExists(indexPath)) {
+      const existing = await fs26.readFile(indexPath, "utf-8");
       if (!existing.includes(functionName)) {
-        await fs25.appendFile(indexPath, exportLine);
+        await fs26.appendFile(indexPath, exportLine);
       }
     } else {
-      await fs25.writeFile(indexPath, exportLine);
+      await fs26.writeFile(indexPath, exportLine);
     }
     await ctx.commit();
     log.success(`Created email template ${pc3.bold(kebab)} at src/lib/core/email/templates/${kebab}-email.ts`);
@@ -7872,10 +7971,10 @@ async function addComponentCommand(name, options) {
     log.error(`Invalid type "${type}". Use: ${validTypes.join(", ")}`);
     return;
   }
-  const dir = type === "primitive" ? path25.join(root, "src", "components", "primitives") : path25.join(root, "src", "components", "patterns");
-  await fs25.ensureDir(dir);
-  const filePath = path25.join(dir, `${pascal}.tsx`);
-  if (await fs25.pathExists(filePath)) {
+  const dir = type === "primitive" ? path26.join(root, "src", "components", "primitives") : path26.join(root, "src", "components", "patterns");
+  await fs26.ensureDir(dir);
+  const filePath = path26.join(dir, `${pascal}.tsx`);
+  if (await fs26.pathExists(filePath)) {
     log.error(`Component already exists: ${pascal}.tsx`);
     return;
   }
@@ -7924,9 +8023,9 @@ export function ${pascal}({ children, className }: ${pascal}Props) {
   const ctx = createRollbackContext();
   try {
     ctx.trackCreatedFile(filePath);
-    await fs25.writeFile(filePath, content);
+    await fs26.writeFile(filePath, content);
     await ctx.commit();
-    log.success(`Created ${type} component ${pc3.bold(pascal)} at ${path25.relative(root, filePath)}`);
+    log.success(`Created ${type} component ${pc3.bold(pascal)} at ${path26.relative(root, filePath)}`);
     trackEvent("add", { type: "component", componentType: type });
     log.blank();
     log.warn(`Remember to add the export to the barrel file:`);
@@ -7941,14 +8040,14 @@ export function ${pascal}({ children, className }: ${pascal}Props) {
 // src/commands/configure.ts
 init_logger();
 import { execSync as execSync2 } from "child_process";
-import fs26 from "fs-extra";
-import path26 from "path";
+import fs27 from "fs-extra";
+import path27 from "path";
 import pc4 from "picocolors";
 import prompts6 from "prompts";
 function ensureInProject2() {
   const cwd = process.cwd();
-  const configPath = path26.join(cwd, "src", "config", "app.config.ts");
-  if (!fs26.pathExistsSync(configPath)) {
+  const configPath = path27.join(cwd, "src", "config", "app.config.ts");
+  if (!fs27.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -7962,8 +8061,8 @@ var PROVIDER_DEPENDENCIES = {
   "storage:s3": ["@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner"]
 };
 function updateAppConfig(projectDir, serviceKey, provider, featureKey) {
-  const configPath = path26.join(projectDir, "src", "config", "app.config.ts");
-  let content = fs26.readFileSync(configPath, "utf-8");
+  const configPath = path27.join(projectDir, "src", "config", "app.config.ts");
+  let content = fs27.readFileSync(configPath, "utf-8");
   if (serviceKey === "auth") {
     const boolValue = provider === "google" ? "true" : "false";
     const featureRegex = new RegExp(`(googleOAuth\\s*:\\s*)(?:true|false)`);
@@ -7978,10 +8077,10 @@ function updateAppConfig(projectDir, serviceKey, provider, featureKey) {
       content = content.replace(featureRegex, `$1true`);
     }
   }
-  fs26.writeFileSync(configPath, content);
+  fs27.writeFileSync(configPath, content);
 }
 function detectPackageManager(projectDir) {
-  if (fs26.existsSync(path26.join(projectDir, "yarn.lock"))) return "yarn";
+  if (fs27.existsSync(path27.join(projectDir, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function installDependencies(projectDir, deps) {
@@ -8091,15 +8190,15 @@ async function configureCommand(service) {
     log.step(`Manually set ${pc4.bold(`services.${serviceConfig.configKey}.provider`)} to ${pc4.bold(`'${provider}'`)} in ${pc4.dim("src/config/app.config.ts")}`);
   }
   if (selectedProvider.envVars.length > 0) {
-    const envPath = path26.join(root, ".env");
-    if (await fs26.pathExists(envPath)) {
-      const envContent = await fs26.readFile(envPath, "utf-8");
+    const envPath = path27.join(root, ".env");
+    if (await fs27.pathExists(envPath)) {
+      const envContent = await fs27.readFile(envPath, "utf-8");
       const missingVars = selectedProvider.envVars.filter(
         (v) => !envContent.includes(v)
       );
       if (missingVars.length > 0) {
         const additions = missingVars.map((v) => `${v}=""`).join("\n");
-        await fs26.appendFile(envPath, `
+        await fs27.appendFile(envPath, `
 # ${selectedService} (${provider})
 ${additions}
 `);
@@ -8128,15 +8227,15 @@ ${additions}
 
 // src/commands/deploy.ts
 init_logger();
-import fs27 from "fs-extra";
-import path27 from "path";
+import fs28 from "fs-extra";
+import path28 from "path";
 import { execSync as execSync3 } from "child_process";
 import pc5 from "picocolors";
 import prompts7 from "prompts";
 function ensureInProject3() {
   const cwd = process.cwd();
-  const configPath = path27.join(cwd, "src", "config", "app.config.ts");
-  if (!fs27.pathExistsSync(configPath)) {
+  const configPath = path28.join(cwd, "src", "config", "app.config.ts");
+  if (!fs28.pathExistsSync(configPath)) {
     log.error("Not inside a MARS project. Run this command from the project root.");
     process.exit(1);
   }
@@ -8175,8 +8274,8 @@ async function deployCommand() {
       return;
     }
   }
-  const vercelDir = path27.join(root, ".vercel");
-  if (!fs27.existsSync(vercelDir)) {
+  const vercelDir = path28.join(root, ".vercel");
+  if (!fs28.existsSync(vercelDir)) {
     log.step("Linking project to Vercel...");
     try {
       execSync3("vercel link", { cwd: root, stdio: "inherit" });
@@ -8193,8 +8292,8 @@ async function deployCommand() {
   log.blank();
   const requiredVars = ["JWT_SECRET", "DATABASE_URL"];
   log.step(`Core: ${pc5.dim(requiredVars.join(", "))}`);
-  const configPath = path27.join(root, "src", "config", "app.config.ts");
-  const configContent = await fs27.readFile(configPath, "utf-8");
+  const configPath = path28.join(root, "src", "config", "app.config.ts");
+  const configContent = await fs28.readFile(configPath, "utf-8");
   if (configContent.includes("email: { provider: 'sendgrid'")) {
     log.step(`Email (SendGrid): ${pc5.dim("SENDGRID_API_KEY, SENDGRID_FROM_EMAIL")}`);
   } else if (configContent.includes("email: { provider: 'resend'")) {
@@ -8255,8 +8354,8 @@ async function deployCommand() {
 
 // src/commands/upgrade.ts
 init_logger();
-import fs28 from "fs-extra";
-import path28 from "path";
+import fs29 from "fs-extra";
+import path29 from "path";
 import { execSync as execSync4 } from "child_process";
 var MARS_PACKAGES = ["@mars-stack/core", "@mars-stack/ui"];
 var CHANGELOG_URL = "https://github.com/greaveselliott/mars/blob/main/CHANGELOG.md";
@@ -8279,7 +8378,7 @@ function readCurrentVersion(packageJson, packageName) {
   return version ? version.replace(/^[\^~]/, "") : null;
 }
 function detectPackageManager2(projectDir) {
-  if (fs28.pathExistsSync(path28.join(projectDir, "yarn.lock"))) {
+  if (fs29.pathExistsSync(path29.join(projectDir, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -8343,101 +8442,104 @@ function updatePackageJsonVersions(packageJsonPath, packageJson, versions) {
   if (updated.length > 0) {
     packageJson.dependencies = deps;
     packageJson.devDependencies = devDeps;
-    fs28.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
+    fs29.writeJsonSync(packageJsonPath, packageJson, { spaces: 2 });
   }
   return updated;
 }
-function upgradeCommand(program2) {
-  program2.command("upgrade").description(
-    "Upgrade @mars-stack/core, @mars-stack/ui, and @mars-stack/cli to the latest versions"
-  ).option("--dry-run", "Show what would be updated without making changes").action(async (options) => {
-    log.title("MARS Upgrade");
-    const projectDir = process.cwd();
-    const packageJsonPath = path28.join(projectDir, "package.json");
-    if (!fs28.pathExistsSync(packageJsonPath)) {
-      log.error(
-        "No package.json found. Are you in a Mars project directory?"
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const packageJson = fs28.readJsonSync(packageJsonPath);
-    const hasMarsPackage = MARS_PACKAGES.some(
-      (name) => readCurrentVersion(packageJson, name) !== null
+async function runUpgrade(options) {
+  log.title("MARS Upgrade");
+  const projectDir = process.cwd();
+  const packageJsonPath = path29.join(projectDir, "package.json");
+  if (!fs29.pathExistsSync(packageJsonPath)) {
+    log.error(
+      "No package.json found. Are you in a Mars project directory?"
     );
-    if (!hasMarsPackage) {
-      log.error(
-        "No @mars-stack packages found in dependencies. This does not appear to be a Mars project."
-      );
-      process.exitCode = 1;
-      return;
-    }
-    log.step("Checking for updates...");
-    const versions = await gatherVersionInfo(packageJson);
-    const registryErrors = versions.filter(
-      (v) => v.current !== null && v.latest === null
+    process.exitCode = 1;
+    return;
+  }
+  const packageJson = fs29.readJsonSync(packageJsonPath);
+  const hasMarsPackage = MARS_PACKAGES.some(
+    (name) => readCurrentVersion(packageJson, name) !== null
+  );
+  if (!hasMarsPackage) {
+    log.error(
+      "No @mars-stack packages found in dependencies. This does not appear to be a Mars project."
     );
-    if (registryErrors.length > 0) {
-      log.warn(
-        "Could not reach the npm registry for some packages. Check your network connection."
-      );
-    }
-    printVersionTable(versions);
-    const updatesAvailable = versions.some((v) => v.updateAvailable);
-    if (!updatesAvailable) {
-      log.success("All Mars packages are up to date.");
-      return;
-    }
-    if (options.dryRun) {
-      log.info("Dry run \u2014 no changes were made.");
-      log.info(`Run ${`mars upgrade`} without --dry-run to apply updates.`);
-      return;
-    }
-    log.step("Updating package.json...");
-    const updated = updatePackageJsonVersions(
-      packageJsonPath,
-      packageJson,
-      versions
+    process.exitCode = 1;
+    return;
+  }
+  log.step("Checking for updates...");
+  const versions = await gatherVersionInfo(packageJson);
+  const registryErrors = versions.filter(
+    (v) => v.current !== null && v.latest === null
+  );
+  if (registryErrors.length > 0) {
+    log.warn(
+      "Could not reach the npm registry for some packages. Check your network connection."
     );
-    for (const change of updated) {
-      log.success(change);
-    }
-    const pm = detectPackageManager2(projectDir);
-    const installCmd = getInstallCommand(pm);
-    log.blank();
-    log.step(`Running ${installCmd}...`);
-    try {
-      execSync4(installCmd, {
-        cwd: projectDir,
-        stdio: "inherit"
-      });
-    } catch {
-      log.error(`${installCmd} failed. You may need to run it manually.`);
-      process.exitCode = 1;
-      return;
-    }
-    log.blank();
-    log.step("Running mars doctor to verify...");
-    try {
-      execSync4("npx mars doctor", {
-        cwd: projectDir,
-        stdio: "inherit"
-      });
-    } catch {
-      log.warn(
-        "mars doctor reported issues. Review the output above."
-      );
-    }
-    log.blank();
-    log.title("Upgrade Summary");
-    for (const change of updated) {
-      log.success(change);
-    }
-    log.blank();
-    log.info(`Changelog: ${CHANGELOG_URL}`);
-    log.info(
-      "Review the changelog for any breaking changes or migration notes."
+  }
+  printVersionTable(versions);
+  const updatesAvailable = versions.some((v) => v.updateAvailable);
+  if (!updatesAvailable) {
+    log.success("All Mars packages are up to date.");
+    return;
+  }
+  if (options?.dryRun) {
+    log.info("Dry run \u2014 no changes were made.");
+    log.info(`Run ${`mars upgrade`} without --dry-run to apply updates.`);
+    return;
+  }
+  log.step("Updating package.json...");
+  const updated = updatePackageJsonVersions(
+    packageJsonPath,
+    packageJson,
+    versions
+  );
+  for (const change of updated) {
+    log.success(change);
+  }
+  const pm = detectPackageManager2(projectDir);
+  const installCmd = getInstallCommand(pm);
+  log.blank();
+  log.step(`Running ${installCmd}...`);
+  try {
+    execSync4(installCmd, {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+  } catch {
+    log.error(`${installCmd} failed. You may need to run it manually.`);
+    process.exitCode = 1;
+    return;
+  }
+  log.blank();
+  log.step("Running mars doctor to verify...");
+  try {
+    execSync4("npx mars doctor", {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+  } catch {
+    log.warn(
+      "mars doctor reported issues. Review the output above."
     );
+  }
+  log.blank();
+  log.title("Upgrade Summary");
+  for (const change of updated) {
+    log.success(change);
+  }
+  log.blank();
+  log.info(`Changelog: ${CHANGELOG_URL}`);
+  log.info(
+    "Review the changelog for any breaking changes or migration notes."
+  );
+}
+function upgradeCommand(program2) {
+  program2.command("upgrade").description(
+    "Upgrade @mars-stack/core, @mars-stack/ui, and @mars-stack/cli to the latest versions"
+  ).option("--dry-run", "Show what would be updated without making changes").action(async (options) => {
+    await runUpgrade(options);
   });
 }
 
@@ -8457,10 +8559,7 @@ init_sentry();
 init_feature_flags();
 init_logger();
 var program = new Command();
-program.name("mars").description("MARS CLI: scaffold, configure, and maintain SaaS apps").version(getCliVersion()).option("-v, --verbose", "Enable verbose output for debugging");
-function isVerbose() {
-  return program.opts().verbose === true;
-}
+program.name("mars").description("MARS CLI: scaffold, configure, and maintain SaaS apps").version(getCliVersion(), "-v, --version", "Print the current mars CLI version").option("-u, --upgrade", "Upgrade Mars packages to latest versions");
 program.command("create").description("Create a new MARS project").argument("[name]", "Project name (kebab-case)").option("--defaults", "Skip prompts, use default configuration").action(async (name, options) => {
   await createCommand(name, options);
 });
@@ -8541,8 +8640,17 @@ program.command("telemetry").description("Manage anonymous usage telemetry").arg
     log.error("Usage: mars telemetry <enable|disable>");
   }
 });
-program.parse();
-export {
-  isVerbose
-};
+program.hook("preAction", (thisCommand) => {
+  const globalOpts = program.opts();
+  if (globalOpts.upgrade && thisCommand !== program) {
+    log.error('Cannot combine --upgrade with other commands. Use "mars -u" or "mars upgrade" alone.');
+    process.exit(1);
+  }
+});
+await program.parseAsync();
+var opts = program.opts();
+if (opts.upgrade && program.args.length === 0) {
+  await runUpgrade();
+  process.exit(0);
+}
 //# sourceMappingURL=index.js.map