@betterstart/cli 0.1.40 → 0.1.42

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
 import { Command as Command9 } from "commander";
 
 // src/commands/generate.ts
-import path28 from "path";
+import path30 from "path";
 import { Command } from "commander";
 
 // src/config/resolver.ts
@@ -159,6 +159,9 @@ function getManyToManyFields(fields) {
 }
 
 // src/core/field-helpers/form-fields.ts
+function isMultiStepForm(schema) {
+  return Array.isArray(schema.steps) && schema.steps.length > 0;
+}
 function getAllFormSchemaFields(schema) {
   const flatten = (fields) => {
     return fields.flatMap((field) => {
@@ -171,6 +174,22 @@ function getAllFormSchemaFields(schema) {
   if (schema.steps) return schema.steps.flatMap((step) => flatten(step.fields));
   return [];
 }
+function getStepFieldNames(step) {
+  const names = [];
+  const collect = (fields) => {
+    for (const field of fields) {
+      if (field.hidden) continue;
+      if (field.type === "dynamicFields") continue;
+      if (field.type === "group" && field.fields) {
+        collect(field.fields);
+      } else if (field.name) {
+        names.push(field.name);
+      }
+    }
+  };
+  collect(step.fields);
+  return names;
+}
 function hasDynamicFields(schema) {
   const check = (fields) => {
     for (const f of fields) {
@@ -1927,7 +1946,11 @@ export async function export${pascal}SubmissionsJSON(): Promise<string> {
   return { files: [path6.relative(cwd, filePath)] };
 }
 
-// src/generators/form-pipeline/form-component.ts
+// src/generators/form-pipeline/form-component-multistep.ts
+import fs8 from "fs";
+import path8 from "path";
+
+// src/generators/form-pipeline/form-component-shared.ts
 import fs7 from "fs";
 import path7 from "path";
 
@@ -2225,23 +2248,31 @@ function toTypeScriptType(field, mode = "output") {
   }
 }
 
-// src/generators/form-pipeline/form-component.ts
+// src/generators/form-pipeline/form-component-shared.ts
+function resolveUiImport(cwd, componentName) {
+  const locations = ["components/ui", "src/components/ui"];
+  for (const loc of locations) {
+    if (fs7.existsSync(path7.join(cwd, loc, `${componentName}.tsx`)) || fs7.existsSync(path7.join(cwd, loc, `${componentName}.ts`))) {
+      return `@/components/ui/${componentName}`;
+    }
+  }
+  return `@cms/components/ui/${componentName}`;
+}
 function escapeJsx(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function generateFormComponent(schema, cwd, cmsDir, options) {
-  const formName = schema.name;
-  const pascal = toPascalCase(formName);
-  const fields = getAllFormSchemaFields(schema);
-  const kebab = toKebabCase(formName);
-  const filePath = path7.join(cwd, cmsDir, "components", "forms", `${kebab}-form.tsx`);
-  const dir = path7.dirname(filePath);
-  if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
-  if (fs7.existsSync(filePath) && !options.force) {
-    return { files: [path7.relative(cwd, filePath)] };
-  }
-  const zodFields = fields.filter((f) => f.name).map((f) => `  ${f.name}: ${formFieldToZodType(f)}`).join(",\n");
-  const defaults = fields.filter((f) => f.name).map((f) => {
+function flattenFormFields(fields) {
+  return fields.flatMap((field) => {
+    if (field.type === "dynamicFields") return [];
+    if (field.type === "group" && field.fields) return flattenFormFields(field.fields);
+    return field.type === "group" ? [] : [field];
+  });
+}
+function buildZodFields(fields) {
+  return fields.filter((f) => f.name).map((f) => `  ${f.name}: ${formFieldToZodType(f)}`).join(",\n");
+}
+function buildDefaultValues(fields) {
+  return fields.filter((f) => f.name).map((f) => {
     if (f.type === "checkbox") return `    ${f.name}: false`;
     if (f.type === "number") return `    ${f.name}: undefined`;
     if (f.type === "multiselect" || f.type === "list") return `    ${f.name}: []`;
@@ -2249,108 +2280,43 @@ function generateFormComponent(schema, cwd, cmsDir, options) {
     if (f.defaultValue !== void 0) return `    ${f.name}: '${f.defaultValue}'`;
     return `    ${f.name}: ''`;
   }).join(",\n");
-  const listFields = fields.filter(
-    (f) => f.name && f.type === "list" && f.fields && f.fields.length > 0
-  );
-  const hasListFields = listFields.length > 0;
-  const fieldArrayDecls = listFields.map(
+}
+function buildFieldArrayDecls(listFields) {
+  return listFields.map(
     (f) => `  const ${f.name}FieldArray = useFieldArray({ control: form.control, name: '${f.name}' })`
   ).join("\n");
-  const fieldJSX = fields.filter((f) => f.name && !f.hidden).map((f) => generateFieldJSX(f)).join("\n\n");
-  const submitText = schema.submitButtonText || "Submit";
-  const successMessage = escapeJsx(schema.successMessage || "Form submitted successfully!");
-  const rhfImport = hasListFields ? `import { useFieldArray, useForm } from 'react-hook-form'` : `import { useForm } from 'react-hook-form'`;
-  const fieldArraySetup = hasListFields ? `
-${fieldArrayDecls}
-` : "";
-  const content = `'use client'
-
-import { zodResolver } from '@hookform/resolvers/zod'
-import { useState } from 'react'
-${rhfImport}
-import { z } from 'zod/v3'
-import { create${pascal}Submission } from '@cms/actions/${kebab}-form'
-import { Button } from '@cms/components/ui/button'
-import {
-  Form,
-  FormControl,
-  FormDescription,
-  FormField,
-  FormItem,
-  FormLabel,
-  FormMessage,
-} from '@cms/components/ui/form'
-import { Input } from '@cms/components/ui/input'
-import { Textarea } from '@cms/components/ui/textarea'
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@cms/components/ui/select'
-
-const formSchema = z.object({
-${zodFields}
-})
-
-type FormValues = z.infer<typeof formSchema>
-
-export function ${pascal}Form() {
-  const [submitted, setSubmitted] = useState(false)
-  const [submitting, setSubmitting] = useState(false)
-
-  const form = useForm<FormValues>({
-    resolver: zodResolver(formSchema),
-    defaultValues: {
-${defaults}
-    },
-  })
-${fieldArraySetup}
-  async function onSubmit(values: FormValues) {
-    setSubmitting(true)
-    try {
-      const result = await create${pascal}Submission(values)
-      if (result.success) {
-        setSubmitted(true)
-      } else {
-        form.setError('root', { message: result.error || 'Something went wrong' })
-      }
-    } catch {
-      form.setError('root', { message: 'Something went wrong. Please try again.' })
-    } finally {
-      setSubmitting(false)
+}
+function buildWatchDecls(fields) {
+  const watchFields = /* @__PURE__ */ new Set();
+  for (const f of fields) {
+    if (f.showWhen) {
+      watchFields.add(f.showWhen.field);
     }
   }
-
-  if (submitted) {
-    return (
-      <div className="rounded-lg border p-6 text-center">
-        <h3 className="text-lg font-semibold">Thank you!</h3>
-        <p className="mt-2 text-muted-foreground">${successMessage}</p>
-      </div>
-    )
-  }
-
-  return (
-    <Form {...form}>
-      <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
-${fieldJSX}
-
-        {form.formState.errors.root && (
-          <p className="text-sm text-destructive">{form.formState.errors.root.message}</p>
-        )}
-
-        <Button type="submit" disabled={submitting}>
-          {submitting ? 'Submitting...' : '${submitText}'}
-        </Button>
-      </form>
-    </Form>
-  )
+  if (watchFields.size === 0) return { setup: "", hasWatch: false };
+  const decls = Array.from(watchFields).map((wf) => `  const ${wf}Value = form.watch('${wf}')`).join("\n");
+  return { setup: `
+${decls}
+`, hasWatch: true };
 }
-`;
-  fs7.writeFileSync(filePath, content, "utf-8");
-  return { files: [path7.relative(cwd, filePath)] };
+function getListFields(fields) {
+  return fields.filter(
+    (f) => f.name && f.type === "list" && f.fields && f.fields.length > 0
+  );
+}
+function wrapShowWhen(field, jsx) {
+  if (!field.showWhen) return jsx;
+  const watchVar = `${field.showWhen.field}Value`;
+  const { value } = field.showWhen;
+  if (Array.isArray(value)) {
+    const vals = value.map((v) => `'${v}'`).join(", ");
+    return `        {[${vals}].includes(${watchVar} as string) && (
+${jsx}
+        )}`;
+  }
+  return `        {${watchVar} === '${value}' && (
+${jsx}
+        )}`;
 }
 function generateFieldJSX(field) {
   const name = field.name || "";
@@ -2427,36 +2393,15 @@ ${optionItems}
           )}
         />`;
     case "email":
-      return generateTextFieldJSX(
-        name,
-        label,
-        placeholder || "email@example.com",
-        hintJSX,
-        requiredStar,
-        "email"
-      );
+      return generateTextFieldJSX(name, label, placeholder || "email@example.com", hintJSX, requiredStar, "email");
     case "number":
       return generateTextFieldJSX(name, label, placeholder, hintJSX, requiredStar, "number");
     case "date":
       return generateTextFieldJSX(name, label, placeholder, hintJSX, requiredStar, "date");
     case "url":
-      return generateTextFieldJSX(
-        name,
-        label,
-        placeholder || "https://",
-        hintJSX,
-        requiredStar,
-        "url"
-      );
+      return generateTextFieldJSX(name, label, placeholder || "https://", hintJSX, requiredStar, "url");
     case "phone":
-      return generateTextFieldJSX(
-        name,
-        label,
-        placeholder || "+1 (555) 000-0000",
-        hintJSX,
-        requiredStar,
-        "tel"
-      );
+      return generateTextFieldJSX(name, label, placeholder || "+1 (555) 000-0000", hintJSX, requiredStar, "tel");
     case "file":
     case "upload":
       return generateTextFieldJSX(name, label, placeholder, hintJSX, requiredStar, "file");
@@ -2557,9 +2502,402 @@ ${nestedFieldsJSX}
         </div>`;
 }
 
+// src/generators/form-pipeline/form-component-multistep.ts
+function generateMultiStepForm(schema, cwd, cmsDir, options) {
+  const formName = schema.name;
+  const pascal = toPascalCase(formName);
+  const kebab = toKebabCase(formName);
+  const steps = schema.steps;
+  const filePath = path8.join(cwd, cmsDir, "components", "forms", `${kebab}-form.tsx`);
+  const dir = path8.dirname(filePath);
+  if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+  if (fs8.existsSync(filePath) && !options.force) {
+    return { files: [path8.relative(cwd, filePath)] };
+  }
+  const allFields = getAllFormSchemaFields(schema);
+  const zodFields = buildZodFields(allFields);
+  const defaults = buildDefaultValues(allFields);
+  const listFields = getListFields(allFields);
+  const hasListFields = listFields.length > 0;
+  const { setup: watchSetup } = buildWatchDecls(allFields);
+  const rhfImport = hasListFields ? `import { useFieldArray, useForm } from 'react-hook-form'` : `import { useForm } from 'react-hook-form'`;
+  const fieldArraySetup = hasListFields ? `
+${buildFieldArrayDecls(listFields)}
+` : "";
+  const stepsConst = buildStepsConstant(steps, schema);
+  const stepContentBlocks = steps.map((step, index) => {
+    const stepFields = flattenFormFields(step.fields);
+    const fieldsJSX = stepFields.filter((f) => f.name && !f.hidden).map((f) => wrapShowWhen(f, generateFieldJSX(f))).join("\n\n");
+    return `          {currentStep === ${index} && (
+            <>
+${fieldsJSX}
+            </>
+          )}`;
+  }).join("\n");
+  const submitText = schema.submitButtonText || "Submit";
+  const successMessage = escapeJsx(schema.successMessage || "Form submitted successfully!");
+  const buttonImport = resolveUiImport(cwd, "button");
+  const formImport = resolveUiImport(cwd, "form");
+  const inputImport = resolveUiImport(cwd, "input");
+  const textareaImport = resolveUiImport(cwd, "textarea");
+  const selectImport = resolveUiImport(cwd, "select");
+  const progressImport = resolveUiImport(cwd, "progress");
+  const content = buildComponentSource({
+    pascal,
+    kebab,
+    rhfImport,
+    buttonImport,
+    formImport,
+    inputImport,
+    textareaImport,
+    selectImport,
+    progressImport,
+    zodFields,
+    defaults,
+    stepsConst,
+    fieldArraySetup,
+    watchSetup,
+    stepContentBlocks,
+    submitText,
+    successMessage
+  });
+  fs8.writeFileSync(filePath, content, "utf-8");
+  return { files: [path8.relative(cwd, filePath)] };
+}
+function buildStepsConstant(steps, schema) {
+  const entries = steps.map((step) => {
+    const fieldNames = getStepFieldNames(step);
+    const fieldsStr = fieldNames.map((n) => `'${n}'`).join(", ");
+    const desc = step.description ? `, description: '${escapeQuotes(step.description)}'` : "";
+    return `  { name: '${step.name}', label: '${escapeQuotes(step.label)}'${desc}, fields: [${fieldsStr}] }`;
+  });
+  return `const STEPS = [
+${entries.join(",\n")}
+]`;
+}
+function escapeQuotes(str) {
+  return str.replace(/'/g, "\\'");
+}
+function buildComponentSource(p7) {
+  return `'use client'
+
+import { zodResolver } from '@hookform/resolvers/zod'
+import { Check, ChevronLeft, ChevronRight } from 'lucide-react'
+import { useState } from 'react'
+${p7.rhfImport}
+import { z } from 'zod/v3'
+import { create${p7.pascal}Submission } from '@cms/actions/${p7.kebab}-form'
+import { Button } from '${p7.buttonImport}'
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '${p7.formImport}'
+import { Input } from '${p7.inputImport}'
+import { Progress } from '${p7.progressImport}'
+import { Textarea } from '${p7.textareaImport}'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '${p7.selectImport}'
+
+const formSchema = z.object({
+${p7.zodFields}
+})
+
+type FormValues = z.infer<typeof formSchema>
+
+${p7.stepsConst}
+
+export function ${p7.pascal}Form() {
+  const [currentStep, setCurrentStep] = useState(0)
+  const [completedSteps, setCompletedSteps] = useState<Set<number>>(new Set())
+  const [submitted, setSubmitted] = useState(false)
+  const [submitting, setSubmitting] = useState(false)
+
+  const form = useForm<FormValues>({
+    resolver: zodResolver(formSchema),
+    mode: 'onTouched',
+    defaultValues: {
+${p7.defaults}
+    },
+  })
+${p7.fieldArraySetup}${p7.watchSetup}
+  async function handleNext() {
+    const isValid = await form.trigger(
+      STEPS[currentStep].fields as (keyof FormValues)[]
+    )
+    if (isValid) {
+      setCompletedSteps((prev) => new Set(prev).add(currentStep))
+      setCurrentStep((prev) => prev + 1)
+    }
+  }
+
+  function handleBack() {
+    setCurrentStep((prev) => prev - 1)
+  }
+
+  function handleStepClick(index: number) {
+    if (index < currentStep || completedSteps.has(index)) {
+      setCurrentStep(index)
+    }
+  }
+
+  async function onSubmit(values: FormValues) {
+    setSubmitting(true)
+    try {
+      const result = await create${p7.pascal}Submission(values)
+      if (result.success) {
+        setSubmitted(true)
+      } else {
+        form.setError('root', { message: result.error || 'Something went wrong' })
+      }
+    } catch {
+      form.setError('root', { message: 'Something went wrong. Please try again.' })
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  if (submitted) {
+    return (
+      <div className="rounded-lg border p-6 text-center">
+        <h3 className="text-lg font-semibold">Thank you!</h3>
+        <p className="mt-2 text-muted-foreground">${p7.successMessage}</p>
+      </div>
+    )
+  }
+
+  return (
+    <Form {...form}>
+      <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-8">
+        {/* Mobile step indicator */}
+        <div className="md:hidden space-y-2">
+          <p className="text-sm text-muted-foreground">
+            Step {currentStep + 1} of {STEPS.length} &mdash; {STEPS[currentStep].label}
+          </p>
+          <Progress value={((currentStep + 1) / STEPS.length) * 100} />
+        </div>
+
+        {/* Desktop step indicator */}
+        <nav className="hidden md:flex items-center justify-center" aria-label="Form progress">
+          {STEPS.map((step, index) => (
+            <div key={step.name} className="flex items-center">
+              <button
+                type="button"
+                onClick={() => handleStepClick(index)}
+                disabled={index > currentStep && !completedSteps.has(index)}
+                aria-current={index === currentStep ? 'step' : undefined}
+                className={\`flex h-8 w-8 items-center justify-center rounded-full text-sm font-medium transition-colors \${
+                  completedSteps.has(index)
+                    ? 'bg-primary text-primary-foreground cursor-pointer'
+                    : index === currentStep
+                      ? 'border-2 border-primary text-primary'
+                      : 'border-2 border-muted text-muted-foreground'
+                }\`}
+              >
+                {completedSteps.has(index) ? (
+                  <Check className="h-4 w-4" />
+                ) : (
+                  index + 1
+                )}
+              </button>
+              {index < STEPS.length - 1 && (
+                <div
+                  className={\`h-0.5 w-8 mx-1 \${
+                    completedSteps.has(index) ? 'bg-primary' : 'bg-muted'
+                  }\`}
+                />
+              )}
+            </div>
+          ))}
+        </nav>
+
+        {/* Step header */}
+        <div>
+          <h3 className="text-lg font-semibold">{STEPS[currentStep].label}</h3>
+          {'description' in STEPS[currentStep] && STEPS[currentStep].description && (
+            <p className="text-sm text-muted-foreground mt-1">{STEPS[currentStep].description}</p>
+          )}
+        </div>
+
+        {/* Step content */}
+        <div key={currentStep} className="animate-in fade-in duration-300 space-y-6">
+${p7.stepContentBlocks}
+        </div>
+
+        {form.formState.errors.root && (
+          <p className="text-sm text-destructive">{form.formState.errors.root.message}</p>
+        )}
+
+        {/* Navigation */}
+        <div className="flex justify-between">
+          <Button
+            type="button"
+            variant="outline"
+            onClick={handleBack}
+            disabled={currentStep === 0}
+          >
+            <ChevronLeft className="mr-2 h-4 w-4" />
+            Back
+          </Button>
+          {currentStep < STEPS.length - 1 ? (
+            <Button type="button" onClick={handleNext}>
+              Next
+              <ChevronRight className="ml-2 h-4 w-4" />
+            </Button>
+          ) : (
+            <Button type="submit" disabled={submitting}>
+              {submitting ? 'Submitting...' : '${p7.submitText}'}
+            </Button>
+          )}
+        </div>
+      </form>
+    </Form>
+  )
+}
+`;
+}
+
+// src/generators/form-pipeline/form-component-single.ts
+import fs9 from "fs";
+import path9 from "path";
+function generateSingleStepForm(schema, cwd, cmsDir, options) {
+  const formName = schema.name;
+  const pascal = toPascalCase(formName);
+  const fields = getAllFormSchemaFields(schema);
+  const kebab = toKebabCase(formName);
+  const filePath = path9.join(cwd, cmsDir, "components", "forms", `${kebab}-form.tsx`);
+  const dir = path9.dirname(filePath);
+  if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
+  if (fs9.existsSync(filePath) && !options.force) {
+    return { files: [path9.relative(cwd, filePath)] };
+  }
+  const zodFields = buildZodFields(fields);
+  const defaults = buildDefaultValues(fields);
+  const listFields = getListFields(fields);
+  const hasListFields = listFields.length > 0;
+  const { setup: watchSetup } = buildWatchDecls(fields);
+  const fieldJSX = fields.filter((f) => f.name && !f.hidden).map((f) => wrapShowWhen(f, generateFieldJSX(f))).join("\n\n");
+  const submitText = schema.submitButtonText || "Submit";
+  const successMessage = escapeJsx(schema.successMessage || "Form submitted successfully!");
+  const rhfImport = hasListFields ? `import { useFieldArray, useForm } from 'react-hook-form'` : `import { useForm } from 'react-hook-form'`;
+  const fieldArraySetup = hasListFields ? `
+${buildFieldArrayDecls(listFields)}
+` : "";
+  const buttonImport = resolveUiImport(cwd, "button");
+  const formImport = resolveUiImport(cwd, "form");
+  const inputImport = resolveUiImport(cwd, "input");
+  const textareaImport = resolveUiImport(cwd, "textarea");
+  const selectImport = resolveUiImport(cwd, "select");
+  const content = `'use client'
+
+import { zodResolver } from '@hookform/resolvers/zod'
+import { useState } from 'react'
+${rhfImport}
+import { z } from 'zod/v3'
+import { create${pascal}Submission } from '@cms/actions/${kebab}-form'
+import { Button } from '${buttonImport}'
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '${formImport}'
+import { Input } from '${inputImport}'
+import { Textarea } from '${textareaImport}'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '${selectImport}'
+
+const formSchema = z.object({
+${zodFields}
+})
+
+type FormValues = z.infer<typeof formSchema>
+
+export function ${pascal}Form() {
+  const [submitted, setSubmitted] = useState(false)
+  const [submitting, setSubmitting] = useState(false)
+
+  const form = useForm<FormValues>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+${defaults}
+    },
+  })
+${fieldArraySetup}${watchSetup}
+  async function onSubmit(values: FormValues) {
+    setSubmitting(true)
+    try {
+      const result = await create${pascal}Submission(values)
+      if (result.success) {
+        setSubmitted(true)
+      } else {
+        form.setError('root', { message: result.error || 'Something went wrong' })
+      }
+    } catch {
+      form.setError('root', { message: 'Something went wrong. Please try again.' })
+    } finally {
+      setSubmitting(false)
+    }
+  }
+
+  if (submitted) {
+    return (
+      <div className="rounded-lg border p-6 text-center">
+        <h3 className="text-lg font-semibold">Thank you!</h3>
+        <p className="mt-2 text-muted-foreground">${successMessage}</p>
+      </div>
+    )
+  }
+
+  return (
+    <Form {...form}>
+      <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+${fieldJSX}
+
+        {form.formState.errors.root && (
+          <p className="text-sm text-destructive">{form.formState.errors.root.message}</p>
+        )}
+
+        <Button type="submit" disabled={submitting}>
+          {submitting ? 'Submitting...' : '${submitText}'}
+        </Button>
+      </form>
+    </Form>
+  )
+}
+`;
+  fs9.writeFileSync(filePath, content, "utf-8");
+  return { files: [path9.relative(cwd, filePath)] };
+}
+
+// src/generators/form-pipeline/form-component.ts
+function generateFormComponent(schema, cwd, cmsDir, options) {
+  if (isMultiStepForm(schema) && schema.steps.length > 1) {
+    return generateMultiStepForm(schema, cwd, cmsDir, options);
+  }
+  return generateSingleStepForm(schema, cwd, cmsDir, options);
+}
+
 // src/generators/form-pipeline/form-database.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path10 from "path";
 function findTableEnd(content, startIndex) {
   let depth = 0;
   let inString = false;
@@ -2614,8 +2952,8 @@ ${fieldDefs}${customFieldsCol}
   updatedAt: timestamp({ precision: 3, mode: 'string' }).default(sql\`CURRENT_TIMESTAMP\`).notNull()
 })
 `;
-  const filePath = path8.join(cwd, dbSchemaPath);
-  let content = fs8.readFileSync(filePath, "utf-8");
+  const filePath = path10.join(cwd, dbSchemaPath);
+  let content = fs10.readFileSync(filePath, "utf-8");
   const pgCoreMatch = content.match(/import\s+\{([^}]+)\}\s+from\s+['"]drizzle-orm\/pg-core['"]/);
   if (pgCoreMatch) {
     const existing = new Set(
@@ -2651,23 +2989,23 @@ ${match}`
   }
   content += `
 ${tableSchema}`;
-  fs8.writeFileSync(filePath, content, "utf-8");
+  fs10.writeFileSync(filePath, content, "utf-8");
   return { files: [dbSchemaPath] };
 }
 
 // src/generators/form-pipeline/form-hook.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path11 from "path";
 function generateFormHook(schema, cwd, hooksDir, options) {
   const formName = schema.name;
   const pascal = toPascalCase(formName);
   const camel = toCamelCase(formName);
   const kebab = toKebabCase(formName);
-  const filePath = path9.join(cwd, hooksDir, `use-${kebab}-form.ts`);
-  const dir = path9.dirname(filePath);
-  if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
-  if (fs9.existsSync(filePath) && !options.force) {
-    return { files: [path9.relative(cwd, filePath)] };
+  const filePath = path11.join(cwd, hooksDir, `use-${kebab}-form.ts`);
+  const dir = path11.dirname(filePath);
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  if (fs11.existsSync(filePath) && !options.force) {
+    return { files: [path11.relative(cwd, filePath)] };
   }
   const successMsg = (schema.successMessage || "Form submitted successfully").replace(/'/g, "\\'");
   const content = `import {
@@ -2773,8 +3111,8 @@ export function useExport${pascal}SubmissionsJSON() {
   })
 }
 `;
-  fs9.writeFileSync(filePath, content, "utf-8");
-  return { files: [path9.relative(cwd, filePath)] };
+  fs11.writeFileSync(filePath, content, "utf-8");
+  return { files: [path11.relative(cwd, filePath)] };
 }
 
 // src/generators/form-pipeline/pipeline.ts
@@ -2840,8 +3178,8 @@ function runFormPipeline(schema, cwd, config, options = {}) {
 }
 
 // src/generators/actions/entity-actions.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path12 from "path";
 
 // src/generators/actions/action-helpers.ts
 function generateFieldMapping(field, source = "input") {
@@ -2980,9 +3318,9 @@ ${blocks.join("\n\n")}
 
 // src/generators/actions/entity-actions.ts
 function generateActions(schema, cwd, actionsDir, options = {}) {
-  const absActionsDir = path10.join(cwd, actionsDir);
-  const filePath = path10.join(absActionsDir, `${schema.name}.ts`);
-  if (fs10.existsSync(filePath) && !options.force) {
+  const absActionsDir = path12.join(cwd, actionsDir);
+  const filePath = path12.join(absActionsDir, `${schema.name}.ts`);
+  if (fs12.existsSync(filePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -3468,20 +3806,20 @@ export async function bulkUpdate${Plural}SortOrder(
   }
 }${m2mHelpers}
 `;
-  if (!fs10.existsSync(absActionsDir)) {
-    fs10.mkdirSync(absActionsDir, { recursive: true });
+  if (!fs12.existsSync(absActionsDir)) {
+    fs12.mkdirSync(absActionsDir, { recursive: true });
   }
-  fs10.writeFileSync(filePath, content, "utf-8");
-  return { files: [path10.join(actionsDir, `${schema.name}.ts`)] };
+  fs12.writeFileSync(filePath, content, "utf-8");
+  return { files: [path12.join(actionsDir, `${schema.name}.ts`)] };
 }
 
 // src/generators/actions/single-actions.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path13 from "path";
 function generateSingleActions(schema, cwd, actionsDir, options = {}) {
-  const absActionsDir = path11.join(cwd, actionsDir);
-  const filePath = path11.join(absActionsDir, `${schema.name}.ts`);
-  if (fs11.existsSync(filePath) && !options.force) {
+  const absActionsDir = path13.join(cwd, actionsDir);
+  const filePath = path13.join(absActionsDir, `${schema.name}.ts`);
+  if (fs13.existsSync(filePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -3604,24 +3942,24 @@ ${upsertMappings},${singleHasHtmlOutput ? "\n" + singleHtmlOutputFields.map((f)
   }
 }
 `;
-  if (!fs11.existsSync(absActionsDir)) {
-    fs11.mkdirSync(absActionsDir, { recursive: true });
+  if (!fs13.existsSync(absActionsDir)) {
+    fs13.mkdirSync(absActionsDir, { recursive: true });
   }
-  fs11.writeFileSync(filePath, content, "utf-8");
-  return { files: [path11.join(actionsDir, `${schema.name}.ts`)] };
+  fs13.writeFileSync(filePath, content, "utf-8");
+  return { files: [path13.join(actionsDir, `${schema.name}.ts`)] };
 }
 
 // src/generators/cache.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path14 from "path";
 function loadAllSchemas(cwd, schemasDir) {
-  const dir = path12.join(cwd, schemasDir);
-  if (!fs12.existsSync(dir)) return [];
-  const files = fs12.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const dir = path14.join(cwd, schemasDir);
+  if (!fs14.existsSync(dir)) return [];
+  const files = fs14.readdirSync(dir).filter((f) => f.endsWith(".json"));
   const seen = /* @__PURE__ */ new Map();
   for (const file of files) {
     if (file === "schema.json") continue;
-    const content = fs12.readFileSync(path12.join(dir, file), "utf-8");
+    const content = fs14.readFileSync(path14.join(dir, file), "utf-8");
     const schema = JSON.parse(content);
     if (!schema.name) continue;
     seen.set(schema.name, schema);
@@ -3811,27 +4149,27 @@ export * from './revalidate'
 `;
 }
 function generateCache(_schema, cwd, cmsDir, _options = {}) {
-  const cacheDir = path12.join(cwd, cmsDir, "lib", "cache");
-  const schemasDir = path12.join(cmsDir, "schemas");
+  const cacheDir = path14.join(cwd, cmsDir, "lib", "cache");
+  const schemasDir = path14.join(cmsDir, "schemas");
   const schemas = loadAllSchemas(cwd, schemasDir);
   const configs = schemas.map(buildCacheConfig).sort((a, b) => a.name.localeCompare(b.name));
-  if (!fs12.existsSync(cacheDir)) {
-    fs12.mkdirSync(cacheDir, { recursive: true });
+  if (!fs14.existsSync(cacheDir)) {
+    fs14.mkdirSync(cacheDir, { recursive: true });
   }
   const files = [];
-  fs12.writeFileSync(path12.join(cacheDir, "tags.ts"), generateTags(configs), "utf-8");
-  files.push(path12.join(cmsDir, "lib", "cache", "tags.ts"));
-  fs12.writeFileSync(
-    path12.join(cacheDir, "cached-queries.ts"),
+  fs14.writeFileSync(path14.join(cacheDir, "tags.ts"), generateTags(configs), "utf-8");
+  files.push(path14.join(cmsDir, "lib", "cache", "tags.ts"));
+  fs14.writeFileSync(
+    path14.join(cacheDir, "cached-queries.ts"),
     generateCachedQueries(configs),
     "utf-8"
   );
-  files.push(path12.join(cmsDir, "lib", "cache", "cached-queries.ts"));
-  fs12.writeFileSync(path12.join(cacheDir, "revalidate.ts"), generateRevalidate(configs), "utf-8");
-  files.push(path12.join(cmsDir, "lib", "cache", "revalidate.ts"));
-  const customQueriesPath = path12.join(cacheDir, "cached-queries-custom.ts");
-  if (!fs12.existsSync(customQueriesPath)) {
-    fs12.writeFileSync(
+  files.push(path14.join(cmsDir, "lib", "cache", "cached-queries.ts"));
+  fs14.writeFileSync(path14.join(cacheDir, "revalidate.ts"), generateRevalidate(configs), "utf-8");
+  files.push(path14.join(cmsDir, "lib", "cache", "revalidate.ts"));
+  const customQueriesPath = path14.join(cacheDir, "cached-queries-custom.ts");
+  if (!fs14.existsSync(customQueriesPath)) {
+    fs14.writeFileSync(
       customQueriesPath,
       `/**
  * Custom cached query functions (not auto-generated)
@@ -3842,16 +4180,16 @@ export {}
 `,
       "utf-8"
     );
-    files.push(path12.join(cmsDir, "lib", "cache", "cached-queries-custom.ts"));
+    files.push(path14.join(cmsDir, "lib", "cache", "cached-queries-custom.ts"));
   }
-  fs12.writeFileSync(path12.join(cacheDir, "index.ts"), generateIndex(), "utf-8");
-  files.push(path12.join(cmsDir, "lib", "cache", "index.ts"));
+  fs14.writeFileSync(path14.join(cacheDir, "index.ts"), generateIndex(), "utf-8");
+  files.push(path14.join(cmsDir, "lib", "cache", "index.ts"));
   return { files };
 }
 
 // src/generators/columns/generate-columns.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path16 from "path";
 
 // src/generators/columns/column-defs.ts
 function isSortableColumn(column) {
@@ -4469,12 +4807,12 @@ function truncateStr(str: string, maxLength: number): string {
 }
 
 // src/generators/columns/custom-cell.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs15 from "fs";
+import path15 from "path";
 function createCustomCellComponent(schema, componentName, cwd, pagesDir, options) {
-  const cellsDir = path13.join(cwd, pagesDir, schema.name, "cells");
-  const componentFilePath = path13.join(cellsDir, `${componentName}.tsx`);
-  if (fs13.existsSync(componentFilePath) && !options.force) return;
+  const cellsDir = path15.join(cwd, pagesDir, schema.name, "cells");
+  const componentFilePath = path15.join(cellsDir, `${componentName}.tsx`);
+  if (fs15.existsSync(componentFilePath) && !options.force) return;
   const singular = singularize(schema.name);
   const Singular = toPascalCase(singular);
   const content = `import type { ${Singular}Data } from '@cms/actions/${schema.name}'
@@ -4491,17 +4829,17 @@ export function ${componentName}({ data }: ${componentName}Props) {
   )
 }
 `;
-  if (!fs13.existsSync(cellsDir)) {
-    fs13.mkdirSync(cellsDir, { recursive: true });
+  if (!fs15.existsSync(cellsDir)) {
+    fs15.mkdirSync(cellsDir, { recursive: true });
   }
-  fs13.writeFileSync(componentFilePath, content, "utf-8");
+  fs15.writeFileSync(componentFilePath, content, "utf-8");
 }
 
 // src/generators/columns/generate-columns.ts
 function generateColumns2(schema, cwd, pagesDir, options = {}) {
-  const entityDir = path14.join(cwd, pagesDir, schema.name);
-  const columnsFilePath = path14.join(entityDir, "columns.tsx");
-  if (fs14.existsSync(columnsFilePath) && !options.force) {
+  const entityDir = path16.join(cwd, pagesDir, schema.name);
+  const columnsFilePath = path16.join(entityDir, "columns.tsx");
+  if (fs16.existsSync(columnsFilePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -4643,22 +4981,22 @@ ${restColDefs}` : ""},
 ${actionsColumn}
 ]
 `;
-  if (!fs14.existsSync(entityDir)) {
-    fs14.mkdirSync(entityDir, { recursive: true });
+  if (!fs16.existsSync(entityDir)) {
+    fs16.mkdirSync(entityDir, { recursive: true });
   }
-  fs14.writeFileSync(columnsFilePath, content, "utf-8");
+  fs16.writeFileSync(columnsFilePath, content, "utf-8");
   return {
-    files: [path14.join(pagesDir, schema.name, "columns.tsx")]
+    files: [path16.join(pagesDir, schema.name, "columns.tsx")]
   };
 }
 
 // src/generators/create-page.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path17 from "path";
 function generateCreatePage(schema, cwd, pagesDir, options = {}) {
-  const newDir = path15.join(cwd, pagesDir, schema.name, "new");
-  const pageFilePath = path15.join(newDir, "page.tsx");
-  if (fs15.existsSync(pageFilePath) && !options.force) {
+  const newDir = path17.join(cwd, pagesDir, schema.name, "new");
+  const pageFilePath = path17.join(newDir, "page.tsx");
+  if (fs17.existsSync(pageFilePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -4685,18 +5023,18 @@ export default async function Create${Singular}Page() {
   )
 }
 `;
-  if (!fs15.existsSync(newDir)) {
-    fs15.mkdirSync(newDir, { recursive: true });
+  if (!fs17.existsSync(newDir)) {
+    fs17.mkdirSync(newDir, { recursive: true });
   }
-  fs15.writeFileSync(pageFilePath, content, "utf-8");
+  fs17.writeFileSync(pageFilePath, content, "utf-8");
   return {
-    files: [path15.join(pagesDir, schema.name, "new", "page.tsx")]
+    files: [path17.join(pagesDir, schema.name, "new", "page.tsx")]
   };
 }
 
 // src/generators/database.ts
-import fs16 from "fs";
-import path16 from "path";
+import fs18 from "fs";
+import path18 from "path";
 function getFieldModifiers(field, needsSql) {
   const modifiers = [];
   if (field.primaryKey) {
@@ -4877,11 +5215,11 @@ function findTableEnd2(content, startIndex) {
   return content.length;
 }
 function generateDatabase(schema, cwd, schemaDir, options = {}) {
-  const schemaFilePath = path16.join(cwd, schemaDir);
+  const schemaFilePath = path18.join(cwd, schemaDir);
   const files = [];
   let content = "";
-  if (fs16.existsSync(schemaFilePath)) {
-    content = fs16.readFileSync(schemaFilePath, "utf-8");
+  if (fs18.existsSync(schemaFilePath)) {
+    content = fs18.readFileSync(schemaFilePath, "utf-8");
   }
   const variableName = toCamelCase(schema.name);
   if (content.includes(`export const ${variableName} =`) && !options.force) {
@@ -4921,11 +5259,11 @@ ${junctionDefs[i]}`;
     }
   }
   updated = mergeImports(updated, requiredImports, needsSql.value);
-  const dir = path16.dirname(schemaFilePath);
-  if (!fs16.existsSync(dir)) {
-    fs16.mkdirSync(dir, { recursive: true });
+  const dir = path18.dirname(schemaFilePath);
+  if (!fs18.existsSync(dir)) {
+    fs18.mkdirSync(dir, { recursive: true });
   }
-  fs16.writeFileSync(schemaFilePath, updated, "utf-8");
+  fs18.writeFileSync(schemaFilePath, updated, "utf-8");
   files.push(schemaDir);
   return {
     files,
@@ -4935,12 +5273,12 @@ ${junctionDefs[i]}`;
 }
 
 // src/generators/edit-page.ts
-import fs17 from "fs";
-import path17 from "path";
+import fs19 from "fs";
+import path19 from "path";
 function generateEditPage(schema, cwd, pagesDir, options = {}) {
-  const editDir = path17.join(cwd, pagesDir, schema.name, "[id]", "edit");
-  const pageFilePath = path17.join(editDir, "page.tsx");
-  if (fs17.existsSync(pageFilePath) && !options.force) {
+  const editDir = path19.join(cwd, pagesDir, schema.name, "[id]", "edit");
+  const pageFilePath = path19.join(editDir, "page.tsx");
+  if (fs19.existsSync(pageFilePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -4979,18 +5317,18 @@ export default async function Edit${Singular}Page({ params }: PageProps) {
   )
 }
 `;
-  if (!fs17.existsSync(editDir)) {
-    fs17.mkdirSync(editDir, { recursive: true });
+  if (!fs19.existsSync(editDir)) {
+    fs19.mkdirSync(editDir, { recursive: true });
   }
-  fs17.writeFileSync(pageFilePath, content, "utf-8");
+  fs19.writeFileSync(pageFilePath, content, "utf-8");
   return {
-    files: [path17.join(pagesDir, schema.name, "[id]", "edit", "page.tsx")]
+    files: [path19.join(pagesDir, schema.name, "[id]", "edit", "page.tsx")]
   };
 }
 
 // src/generators/form/form-entity.ts
-import fs18 from "fs";
-import path18 from "path";
+import fs20 from "fs";
+import path20 from "path";
 
 // src/generators/form/zod-schema.ts
 function getFormFieldType(field) {
@@ -5788,7 +6126,7 @@ function generateDefaultValue(f) {
   }
   return `      ${f.name}: initialData?.${f.name} ?? ''`;
 }
-function buildZodFields(flatFields) {
+function buildZodFields2(flatFields) {
   return flatFields.filter((f) => f.type !== "tabs").flatMap((f) => {
     const defs = [];
     const zodType = getZodType(f);
@@ -5800,7 +6138,7 @@ function buildZodFields(flatFields) {
     return defs;
   }).join(",\n");
 }
-function buildDefaultValues(flatFields) {
+function buildDefaultValues2(flatFields) {
   return flatFields.filter((f) => f.type !== "tabs").flatMap((f) => {
     const defs = [generateDefaultValue(f)];
     if (f.hasIcon) defs.push(`      ${f.name}Icon: initialData?.${f.name}Icon ?? ''`);
@@ -5887,9 +6225,9 @@ function buildUiImports(ctx) {
 
 // src/generators/form/form-entity.ts
 function generateForm(schema, cwd, pagesDir, options = {}) {
-  const entityDir = path18.join(cwd, pagesDir, schema.name);
-  const formFilePath = path18.join(entityDir, `${schema.name}-form.tsx`);
-  if (fs18.existsSync(formFilePath) && !options.force) {
+  const entityDir = path20.join(cwd, pagesDir, schema.name);
+  const formFilePath = path20.join(entityDir, `${schema.name}-form.tsx`);
+  if (fs20.existsSync(formFilePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -5943,8 +6281,8 @@ function generateForm(schema, cwd, pagesDir, options = {}) {
   const hasList = hasFieldType(schema.fields, "list");
   const hasNestedList = listFieldsWithNested.length > 0;
   const hasSimpleList = hasList && flatFields.some((f) => f.type === "list" && (!f.fields || f.fields.length === 0));
-  const zodFields = buildZodFields(flatFields);
-  const defaultValues = buildDefaultValues(flatFields);
+  const zodFields = buildZodFields2(flatFields);
+  const defaultValues = buildDefaultValues2(flatFields);
   const formFieldsJSX = allFormFields.filter((f) => !(hasDraft && f.name === "published")).map((f) => {
     if (f.type === "tabs" && f.tabs) {
       const tabsList = f.tabs.map((t) => `            <TabsTrigger value="${t.name}">${t.label}</TabsTrigger>`).join("\n");
@@ -6145,22 +6483,22 @@ ${hasDraft ? `            <Button
   )
 }
 `;
-  if (!fs18.existsSync(entityDir)) {
-    fs18.mkdirSync(entityDir, { recursive: true });
+  if (!fs20.existsSync(entityDir)) {
+    fs20.mkdirSync(entityDir, { recursive: true });
   }
-  fs18.writeFileSync(formFilePath, content, "utf-8");
+  fs20.writeFileSync(formFilePath, content, "utf-8");
   return {
-    files: [path18.join(pagesDir, schema.name, `${schema.name}-form.tsx`)]
+    files: [path20.join(pagesDir, schema.name, `${schema.name}-form.tsx`)]
   };
 }
 
 // src/generators/form/form-single.ts
-import fs19 from "fs";
-import path19 from "path";
+import fs21 from "fs";
+import path21 from "path";
 function generateSingleForm(schema, cwd, pagesDir, options = {}) {
-  const entityDir = path19.join(cwd, pagesDir, schema.name);
-  const formFilePath = path19.join(entityDir, `${schema.name}-form.tsx`);
-  if (fs19.existsSync(formFilePath) && !options.force) {
+  const entityDir = path21.join(cwd, pagesDir, schema.name);
+  const formFilePath = path21.join(entityDir, `${schema.name}-form.tsx`);
+  if (fs21.existsSync(formFilePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -6212,8 +6550,8 @@ function generateSingleForm(schema, cwd, pagesDir, options = {}) {
   const hasList = hasFieldType(schema.fields, "list");
   const hasNestedList = listFieldsWithNested.length > 0;
   const hasSimpleList = hasList && flatFields.some((f) => f.type === "list" && (!f.fields || f.fields.length === 0));
-  const zodFields = buildZodFields(flatFields);
-  const defaultValues = buildDefaultValues(flatFields);
+  const zodFields = buildZodFields2(flatFields);
+  const defaultValues = buildDefaultValues2(flatFields);
   const formFieldsJSX = allFormFields.map((f) => {
     if (f.type === "tabs" && f.tabs) {
       const tabsList = f.tabs.map((t) => `            <TabsTrigger value="${t.name}">${t.label}</TabsTrigger>`).join("\n");
@@ -6363,21 +6701,21 @@ ${formFieldsJSX}
   )
 }
 `;
-  if (!fs19.existsSync(entityDir)) {
-    fs19.mkdirSync(entityDir, { recursive: true });
+  if (!fs21.existsSync(entityDir)) {
+    fs21.mkdirSync(entityDir, { recursive: true });
   }
-  fs19.writeFileSync(formFilePath, content, "utf-8");
+  fs21.writeFileSync(formFilePath, content, "utf-8");
   return {
-    files: [path19.join(pagesDir, schema.name, `${schema.name}-form.tsx`)]
+    files: [path21.join(pagesDir, schema.name, `${schema.name}-form.tsx`)]
   };
 }
 
 // src/generators/hook.ts
-import fs20 from "fs";
-import path20 from "path";
+import fs22 from "fs";
+import path22 from "path";
 function generateHook(schema, cwd, hooksDir, options = {}) {
   const hookFileName = `use-${schema.name}.ts`;
-  const hookFilePath = path20.join(cwd, hooksDir, hookFileName);
+  const hookFilePath = path22.join(cwd, hooksDir, hookFileName);
   const singular = singularize(schema.name);
   const plural = pluralize(schema.name);
   const Singular = toPascalCase(singular);
@@ -6387,7 +6725,7 @@ function generateHook(schema, cwd, hooksDir, options = {}) {
   const hasHtmlOutput = dbFields.some(
     (f) => (f.type === "richtext" || f.type === "markdown") && f.output === "html"
   );
-  if (fs20.existsSync(hookFilePath) && !options.force) {
+  if (fs22.existsSync(hookFilePath) && !options.force) {
     return { files: [], hookName: `use${Plural}` };
   }
   const hasFilters = schema.filters && schema.filters.length > 0;
@@ -6462,22 +6800,22 @@ export function use${Plural}(
 }
 ${singularHook}${slugHook}${distinctHooks}
 `;
-  const dir = path20.dirname(hookFilePath);
-  if (!fs20.existsSync(dir)) {
-    fs20.mkdirSync(dir, { recursive: true });
+  const dir = path22.dirname(hookFilePath);
+  if (!fs22.existsSync(dir)) {
+    fs22.mkdirSync(dir, { recursive: true });
   }
-  fs20.writeFileSync(hookFilePath, content, "utf-8");
+  fs22.writeFileSync(hookFilePath, content, "utf-8");
   return {
-    files: [path20.join(hooksDir, hookFileName)],
+    files: [path22.join(hooksDir, hookFileName)],
     hookName: `use${Plural}`
   };
 }
 function generateSingleHook(schema, cwd, hooksDir, options = {}) {
   const hookFileName = `use-${schema.name}.ts`;
-  const hookFilePath = path20.join(cwd, hooksDir, hookFileName);
+  const hookFilePath = path22.join(cwd, hooksDir, hookFileName);
   const singular = singularize(schema.name);
   const Singular = toPascalCase(singular);
-  if (fs20.existsSync(hookFilePath) && !options.force) {
+  if (fs22.existsSync(hookFilePath) && !options.force) {
     return { files: [], hookName: `use${Singular}` };
   }
   const content = `import {
@@ -6494,20 +6832,20 @@ export function use${Singular}(): UseQueryResult<${Singular}Data | null, Error>
   })
 }
 `;
-  const dir = path20.dirname(hookFilePath);
-  if (!fs20.existsSync(dir)) {
-    fs20.mkdirSync(dir, { recursive: true });
+  const dir = path22.dirname(hookFilePath);
+  if (!fs22.existsSync(dir)) {
+    fs22.mkdirSync(dir, { recursive: true });
   }
-  fs20.writeFileSync(hookFilePath, content, "utf-8");
+  fs22.writeFileSync(hookFilePath, content, "utf-8");
   return {
-    files: [path20.join(hooksDir, hookFileName)],
+    files: [path22.join(hooksDir, hookFileName)],
     hookName: `use${Singular}`
   };
 }
 
 // src/generators/navigation.ts
-import fs21 from "fs";
-import path21 from "path";
+import fs23 from "fs";
+import path23 from "path";
 function parseNavigationFile2(content) {
   const iconImportMatch = content.match(/import\s*\{([^}]+)\}\s*from\s*['"]lucide-react['"]/);
   const iconImports = iconImportMatch ? iconImportMatch[1].split(",").map((s) => s.trim()).filter((s) => s && s !== "LucideIcon") : [];
@@ -6610,14 +6948,14 @@ function appendItem2(lines, item, isLast) {
   lines.push(`  }${isLast ? "" : ","}`);
 }
 function updateNavigation(schema, cwd, cmsDir, options = {}) {
-  const navFilePath = path21.join(cwd, cmsDir, "data", "navigation.ts");
+  const navFilePath = path23.join(cwd, cmsDir, "data", "navigation.ts");
   if (schema.name === "settings") {
     return { files: [] };
   }
   let items = [];
   let iconImports = [];
-  if (fs21.existsSync(navFilePath)) {
-    const content = fs21.readFileSync(navFilePath, "utf-8");
+  if (fs23.existsSync(navFilePath)) {
+    const content = fs23.readFileSync(navFilePath, "utf-8");
     const parsed = parseNavigationFile2(content);
     items = parsed.items;
     iconImports = parsed.iconImports;
@@ -6654,24 +6992,24 @@ function updateNavigation(schema, cwd, cmsDir, options = {}) {
     iconImports.push(schema.icon);
   }
   iconImports.sort();
-  const dir = path21.dirname(navFilePath);
-  if (!fs21.existsSync(dir)) {
-    fs21.mkdirSync(dir, { recursive: true });
+  const dir = path23.dirname(navFilePath);
+  if (!fs23.existsSync(dir)) {
+    fs23.mkdirSync(dir, { recursive: true });
   }
   const code = generateNavigationCode2(items, iconImports);
-  fs21.writeFileSync(navFilePath, code, "utf-8");
+  fs23.writeFileSync(navFilePath, code, "utf-8");
   return {
-    files: [path21.join(cmsDir, "data", "navigation.ts")]
+    files: [path23.join(cmsDir, "data", "navigation.ts")]
   };
 }
 
 // src/generators/page.ts
-import fs22 from "fs";
-import path22 from "path";
+import fs24 from "fs";
+import path24 from "path";
 function generatePage2(schema, cwd, pagesDir, options = {}) {
-  const entityDir = path22.join(cwd, pagesDir, schema.name);
-  const pageFilePath = path22.join(entityDir, "page.tsx");
-  if (fs22.existsSync(pageFilePath) && !options.force) {
+  const entityDir = path24.join(cwd, pagesDir, schema.name);
+  const pageFilePath = path24.join(entityDir, "page.tsx");
+  if (fs24.existsSync(pageFilePath) && !options.force) {
     return { files: [] };
   }
   const plural = pluralize(schema.name);
@@ -6697,27 +7035,27 @@ export default function ${Plural}Page() {
   )
 }
 `;
-  if (!fs22.existsSync(entityDir)) {
-    fs22.mkdirSync(entityDir, { recursive: true });
+  if (!fs24.existsSync(entityDir)) {
+    fs24.mkdirSync(entityDir, { recursive: true });
   }
-  fs22.writeFileSync(pageFilePath, content, "utf-8");
+  fs24.writeFileSync(pageFilePath, content, "utf-8");
   return {
-    files: [path22.join(pagesDir, schema.name, "page.tsx")]
+    files: [path24.join(pagesDir, schema.name, "page.tsx")]
   };
 }
 
 // src/generators/page-content.ts
-import fs23 from "fs";
-import path23 from "path";
+import fs25 from "fs";
+import path25 from "path";
 function generatePageContent2(schema, cwd, pagesDir, options = {}) {
-  const entityDir = path23.join(cwd, pagesDir, schema.name);
+  const entityDir = path25.join(cwd, pagesDir, schema.name);
   const singular = singularize(schema.name);
   const plural = pluralize(schema.name);
   const Singular = toPascalCase(singular);
   const Plural = toPascalCase(plural);
   const fileName = `${toKebabCase(plural)}-page-content.tsx`;
-  const filePath = path23.join(entityDir, fileName);
-  if (fs23.existsSync(filePath) && !options.force) {
+  const filePath = path25.join(entityDir, fileName);
+  if (fs25.existsSync(filePath) && !options.force) {
     return { files: [] };
   }
   const hasCreate = schema.actions?.create ?? false;
@@ -6970,22 +7308,22 @@ ${searchLogic}${deleteLogic}
   )
 }
 `;
-  if (!fs23.existsSync(entityDir)) {
-    fs23.mkdirSync(entityDir, { recursive: true });
+  if (!fs25.existsSync(entityDir)) {
+    fs25.mkdirSync(entityDir, { recursive: true });
   }
-  fs23.writeFileSync(filePath, content, "utf-8");
+  fs25.writeFileSync(filePath, content, "utf-8");
   return {
-    files: [path23.join(pagesDir, schema.name, fileName)]
+    files: [path25.join(pagesDir, schema.name, fileName)]
   };
 }
 
 // src/generators/single-page.ts
-import fs24 from "fs";
-import path24 from "path";
+import fs26 from "fs";
+import path26 from "path";
 function generateSinglePage(schema, cwd, pagesDir, options = {}) {
-  const entityDir = path24.join(cwd, pagesDir, schema.name);
-  const pageFilePath = path24.join(entityDir, "page.tsx");
-  if (fs24.existsSync(pageFilePath) && !options.force) {
+  const entityDir = path26.join(cwd, pagesDir, schema.name);
+  const pageFilePath = path26.join(entityDir, "page.tsx");
+  if (fs26.existsSync(pageFilePath) && !options.force) {
     return { files: [] };
   }
   const singular = singularize(schema.name);
@@ -7008,20 +7346,20 @@ export default async function ${PageName}Page() {
   )
 }
 `;
-  if (!fs24.existsSync(entityDir)) {
-    fs24.mkdirSync(entityDir, { recursive: true });
+  if (!fs26.existsSync(entityDir)) {
+    fs26.mkdirSync(entityDir, { recursive: true });
   }
-  fs24.writeFileSync(pageFilePath, content, "utf-8");
+  fs26.writeFileSync(pageFilePath, content, "utf-8");
   return {
-    files: [path24.join(pagesDir, schema.name, "page.tsx")]
+    files: [path26.join(pagesDir, schema.name, "page.tsx")]
   };
 }
 
 // src/generators/table.ts
-import fs25 from "fs";
-import path25 from "path";
+import fs27 from "fs";
+import path27 from "path";
 function generateTable2(schema, cwd, pagesDir, options = {}) {
-  const entityDir = path25.join(cwd, pagesDir, schema.name);
+  const entityDir = path27.join(cwd, pagesDir, schema.name);
   const singular = singularize(schema.name);
   const plural = pluralize(schema.name);
   const Singular = toPascalCase(singular);
@@ -7029,8 +7367,8 @@ function generateTable2(schema, cwd, pagesDir, options = {}) {
   const camelPlural = toCamelCase(plural);
   const camelSingular = toCamelCase(singular);
   const tableFileName = `${toKebabCase(plural)}-table.tsx`;
-  const tableFilePath = path25.join(entityDir, tableFileName);
-  if (fs25.existsSync(tableFilePath) && !options.force) {
+  const tableFilePath = path27.join(entityDir, tableFileName);
+  if (fs27.existsSync(tableFilePath) && !options.force) {
     return { files: [] };
   }
   const hasFilters = schema.filters && schema.filters.length > 0;
@@ -7394,12 +7732,12 @@ export function ${Plural}Table<TValue>({ columns, selectedIds, setSelectedIds, $
   )
 }
 `;
-  if (!fs25.existsSync(entityDir)) {
-    fs25.mkdirSync(entityDir, { recursive: true });
+  if (!fs27.existsSync(entityDir)) {
+    fs27.mkdirSync(entityDir, { recursive: true });
   }
-  fs25.writeFileSync(tableFilePath, content, "utf-8");
+  fs27.writeFileSync(tableFilePath, content, "utf-8");
   return {
-    files: [path25.join(pagesDir, schema.name, tableFileName)]
+    files: [path27.join(pagesDir, schema.name, tableFileName)]
   };
 }
 
@@ -7557,13 +7895,13 @@ function runSinglePipeline(schema, cwd, config, options = {}) {
 
 // src/generators/post-generate.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import fs27 from "fs";
-import path27 from "path";
+import fs29 from "fs";
+import path29 from "path";
 
 // src/utils/package-manager.ts
 import { execFileSync } from "child_process";
-import fs26 from "fs";
-import path26 from "path";
+import fs28 from "fs";
+import path28 from "path";
 var LOCKFILE_MAP = {
   "pnpm-lock.yaml": "pnpm",
   "package-lock.json": "npm",
@@ -7572,18 +7910,18 @@ var LOCKFILE_MAP = {
   "bun.lock": "bun"
 };
 function detectPackageManager(cwd) {
-  let dir = path26.resolve(cwd);
-  const root = path26.parse(dir).root;
+  let dir = path28.resolve(cwd);
+  const root = path28.parse(dir).root;
   while (dir !== root) {
     for (const [lockfile, pm] of Object.entries(LOCKFILE_MAP)) {
-      if (fs26.existsSync(path26.join(dir, lockfile))) {
+      if (fs28.existsSync(path28.join(dir, lockfile))) {
         return pm;
       }
     }
-    const pkgPath = path26.join(dir, "package.json");
-    if (fs26.existsSync(pkgPath)) {
+    const pkgPath = path28.join(dir, "package.json");
+    if (fs28.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs28.readFileSync(pkgPath, "utf-8"));
         if (typeof pkg.packageManager === "string") {
           const name = pkg.packageManager.split("@")[0];
           if (name === "pnpm" || name === "npm" || name === "yarn" || name === "bun") {
@@ -7593,7 +7931,7 @@ function detectPackageManager(cwd) {
       } catch {
       }
     }
-    dir = path26.dirname(dir);
+    dir = path28.dirname(dir);
   }
   return "npm";
 }
@@ -7624,9 +7962,9 @@ function createNextAppCommand(pm) {
 
 // src/generators/post-generate.ts
 function loadEnvFile(cwd) {
-  const envPath = path27.join(cwd, ".env.local");
-  if (!fs27.existsSync(envPath)) return;
-  const content = fs27.readFileSync(envPath, "utf-8");
+  const envPath = path29.join(cwd, ".env.local");
+  if (!fs29.existsSync(envPath)) return;
+  const content = fs29.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -7656,10 +7994,10 @@ function runPmScript(pm, script, cwd) {
   }
 }
 function hasPkgScript(cwd, script) {
-  const pkgPath = path27.join(cwd, "package.json");
-  if (!fs27.existsSync(pkgPath)) return false;
+  const pkgPath = path29.join(cwd, "package.json");
+  if (!fs29.existsSync(pkgPath)) return false;
   try {
-    const pkg = JSON.parse(fs27.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs29.readFileSync(pkgPath, "utf-8"));
     const scripts = pkg.scripts;
     return !!scripts?.[script];
   } catch {
@@ -7686,7 +8024,7 @@ function runPostGenerate(cwd, schemaName, options = {}) {
       console.log(ok ? "  Database schema synced" : "  Database push failed (run db:push manually)");
     } else {
       console.log("\n  Running drizzle-kit push...");
-      const drizzleBin = path27.join(cwd, "node_modules", ".bin", "drizzle-kit");
+      const drizzleBin = path29.join(cwd, "node_modules", ".bin", "drizzle-kit");
       try {
         execFileSync2(drizzleBin, ["push", "--force"], { cwd, stdio: "inherit" });
         result.dbPush = "success";
@@ -7705,7 +8043,7 @@ function runPostGenerate(cwd, schemaName, options = {}) {
     result.lintFix = ok ? "success" : "failed";
     console.log(ok ? "  Code formatted" : "  Lint fix had issues (run lint:fix manually)");
   } else {
-    const biomeBin = path27.join(cwd, "node_modules", ".bin", "biome");
+    const biomeBin = path29.join(cwd, "node_modules", ".bin", "biome");
     try {
       execFileSync2(biomeBin, ["check", "--write", "."], { cwd, stdio: "pipe" });
       result.lintFix = "success";
@@ -7728,7 +8066,7 @@ function runPostGenerate(cwd, schemaName, options = {}) {
 // src/commands/generate.ts
 var generateCommand = new Command("generate").alias("g").description("Generate entity or form from a JSON schema").argument("<schema>", "Schema name (e.g. posts, categories, contact)").option("-f, --force", "Overwrite existing generated files", false).option("--skip-migration", "Skip running db:push after generation", false).option("--cwd <path>", "Project root path").action(
   async (schemaName, options) => {
-    const cwd = options.cwd ? path28.resolve(options.cwd) : process.cwd();
+    const cwd = options.cwd ? path30.resolve(options.cwd) : process.cwd();
     console.log("\n  BetterStart Generator\n");
     let config;
     try {
@@ -7737,7 +8075,7 @@ var generateCommand = new Command("generate").alias("g").description("Generate e
       console.error(`  Error loading config: ${err instanceof Error ? err.message : String(err)}`);
       process.exit(1);
     }
-    const schemasDir = path28.join(cwd, config.paths?.schemas ?? "./cms/schemas");
+    const schemasDir = path30.join(cwd, config.paths?.schemas ?? "./cms/schemas");
     console.log(`  Project root: ${cwd}`);
     console.log(`  Loading schema: ${schemaName}.json
 `);
@@ -7749,7 +8087,7 @@ var generateCommand = new Command("generate").alias("g").description("Generate e
         console.error(`  ${err.message}`);
         console.error(
           `
-  Create a schema file at: ${path28.join(schemasDir, `${schemaName}.json`)}`
+  Create a schema file at: ${path30.join(schemasDir, `${schemaName}.json`)}`
         );
       } else {
         console.error(
@@ -7842,8 +8180,8 @@ var generateCommand = new Command("generate").alias("g").description("Generate e
 
 // src/commands/init.ts
 import { execFileSync as execFileSync4, spawn as spawn2 } from "child_process";
-import fs38 from "fs";
-import path43 from "path";
+import fs40 from "fs";
+import path45 from "path";
 import * as p4 from "@clack/prompts";
 import { Command as Command3 } from "commander";
 import pc2 from "picocolors";
@@ -7986,21 +8324,21 @@ async function promptProject(defaultName) {
 }
 
 // src/init/scaffolders/api-routes.ts
-import path30 from "path";
+import path32 from "path";
 
 // src/utils/fs.ts
-import fs28 from "fs";
-import path29 from "path";
+import fs30 from "fs";
+import path31 from "path";
 import fse from "fs-extra";
 function ensureDir(dirPath) {
   fse.ensureDirSync(dirPath);
 }
 function safeWriteFile(filePath, content, force = false) {
-  if (!force && fs28.existsSync(filePath)) {
+  if (!force && fs30.existsSync(filePath)) {
     return false;
   }
-  ensureDir(path29.dirname(filePath));
-  fs28.writeFileSync(filePath, content, "utf-8");
+  ensureDir(path31.dirname(filePath));
+  fs30.writeFileSync(filePath, content, "utf-8");
   return true;
 }
 
@@ -8094,21 +8432,21 @@ export async function POST(request: NextRequest) {
 // src/init/scaffolders/api-routes.ts
 function scaffoldApiRoutes({ cwd, config }) {
   const created = [];
-  const apiDir = path30.resolve(cwd, config.paths.api);
+  const apiDir = path32.resolve(cwd, config.paths.api);
   function write(relPath, content) {
-    const fullPath = path30.join(apiDir, relPath);
-    ensureDir(path30.dirname(fullPath));
+    const fullPath = path32.join(apiDir, relPath);
+    ensureDir(path32.dirname(fullPath));
     if (safeWriteFile(fullPath, content)) {
-      created.push(path30.join(config.paths.api, relPath));
+      created.push(path32.join(config.paths.api, relPath));
     }
   }
-  write(path30.join("auth", "[...all]", "route.ts"), authRouteTemplate());
-  write(path30.join("upload", "route.ts"), uploadRouteTemplate());
+  write(path32.join("auth", "[...all]", "route.ts"), authRouteTemplate());
+  write(path32.join("upload", "route.ts"), uploadRouteTemplate());
   return created;
 }
 
 // src/init/scaffolders/auth.ts
-import path31 from "path";
+import path33 from "path";
 
 // src/init/templates/lib/auth/auth.ts
 function authTemplate() {
@@ -8227,11 +8565,11 @@ export async function requireRole(allowedRoles: UserRole[]): Promise<User> {
 // src/init/scaffolders/auth.ts
 function scaffoldAuth({ cwd, config }) {
   const created = [];
-  const authDir = path31.resolve(cwd, config.paths.cms, "lib", "auth");
+  const authDir = path33.resolve(cwd, config.paths.cms, "lib", "auth");
   function write(filename, content) {
-    const fullPath = path31.join(authDir, filename);
+    const fullPath = path33.join(authDir, filename);
     if (safeWriteFile(fullPath, content)) {
-      created.push(path31.join(config.paths.cms, "lib", "auth", filename));
+      created.push(path33.join(config.paths.cms, "lib", "auth", filename));
     }
   }
   write("auth.ts", authTemplate());
@@ -8241,51 +8579,51 @@ function scaffoldAuth({ cwd, config }) {
 }
 
 // src/init/scaffolders/base.ts
-import fs29 from "fs";
-import path32 from "path";
+import fs31 from "fs";
+import path34 from "path";
 function scaffoldBase({ cwd, config }) {
   const created = [];
   const cmsDirs = [
     config.paths.cms,
     config.paths.schemas,
-    path32.join(config.paths.cms, "db"),
-    path32.join(config.paths.cms, "db", "migrations"),
-    path32.join(config.paths.cms, "lib", "auth"),
-    path32.join(config.paths.cms, "lib", "actions"),
-    path32.join(config.paths.cms, "lib", "cache"),
-    path32.join(config.paths.cms, "lib", "markdown"),
-    path32.join(config.paths.cms, "lib", "emails"),
-    path32.join(config.paths.cms, "lib"),
-    path32.join(config.paths.cms, "hooks"),
-    path32.join(config.paths.cms, "components", "ui"),
-    path32.join(config.paths.cms, "components", "form"),
-    path32.join(config.paths.cms, "components", "data-table"),
-    path32.join(config.paths.cms, "components", "layout"),
-    path32.join(config.paths.cms, "components", "shared"),
-    path32.join(config.paths.cms, "types"),
-    path32.join(config.paths.cms, "utils"),
-    path32.join(config.paths.cms, "data")
+    path34.join(config.paths.cms, "db"),
+    path34.join(config.paths.cms, "db", "migrations"),
+    path34.join(config.paths.cms, "lib", "auth"),
+    path34.join(config.paths.cms, "lib", "actions"),
+    path34.join(config.paths.cms, "lib", "cache"),
+    path34.join(config.paths.cms, "lib", "markdown"),
+    path34.join(config.paths.cms, "lib", "emails"),
+    path34.join(config.paths.cms, "lib"),
+    path34.join(config.paths.cms, "hooks"),
+    path34.join(config.paths.cms, "components", "ui"),
+    path34.join(config.paths.cms, "components", "form"),
+    path34.join(config.paths.cms, "components", "data-table"),
+    path34.join(config.paths.cms, "components", "layout"),
+    path34.join(config.paths.cms, "components", "shared"),
+    path34.join(config.paths.cms, "types"),
+    path34.join(config.paths.cms, "utils"),
+    path34.join(config.paths.cms, "data")
   ];
   for (const dir of cmsDirs) {
-    ensureDir(path32.resolve(cwd, dir));
+    ensureDir(path34.resolve(cwd, dir));
   }
   const appDirs = [config.paths.pages, config.paths.login, config.paths.api];
   for (const dir of appDirs) {
-    ensureDir(path32.resolve(cwd, dir));
+    ensureDir(path34.resolve(cwd, dir));
   }
   const configContent = generateConfigFile(config);
-  if (safeWriteFile(path32.resolve(cwd, "cms.config.ts"), configContent)) {
+  if (safeWriteFile(path34.resolve(cwd, "cms.config.ts"), configContent)) {
     created.push("cms.config.ts");
   }
   const cmsDoc = generateCmsDoc(config, {});
-  if (safeWriteFile(path32.resolve(cwd, "CMS.md"), cmsDoc)) {
+  if (safeWriteFile(path34.resolve(cwd, "CMS.md"), cmsDoc)) {
     created.push("CMS.md");
   }
   return created;
 }
 function regenerateCmsDoc(cwd, config, options) {
   const content = generateCmsDoc(config, options);
-  fs29.writeFileSync(path32.resolve(cwd, "CMS.md"), content, "utf-8");
+  fs31.writeFileSync(path34.resolve(cwd, "CMS.md"), content, "utf-8");
 }
 function generateConfigFile(config) {
   return `import { defineConfig } from '@betterstart/cli'
@@ -8439,8 +8777,8 @@ Edit \`cms.config.ts\` to customize paths, database provider, and features.`);
 }
 
 // src/init/scaffolders/biome.ts
-import fs30 from "fs";
-import path33 from "path";
+import fs32 from "fs";
+import path35 from "path";
 function scaffoldBiome(cwd, linter) {
   if (linter.type !== "none") {
     return {
@@ -8448,8 +8786,8 @@ function scaffoldBiome(cwd, linter) {
       skippedReason: `${linter.type} already configured (${linter.configFile})`
     };
   }
-  const configPath = path33.join(cwd, "biome.json");
-  if (fs30.existsSync(configPath)) {
+  const configPath = path35.join(cwd, "biome.json");
+  if (fs32.existsSync(configPath)) {
     return { installed: false, skippedReason: "biome.json already exists" };
   }
   const config = {
@@ -8500,52 +8838,52 @@ function scaffoldBiome(cwd, linter) {
       ]
     }
   };
-  fs30.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+  fs32.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
   return { installed: true, skippedReason: null };
 }
 
 // src/init/scaffolders/components.ts
-import path35 from "path";
-import fs32 from "fs-extra";
+import path37 from "path";
+import fs34 from "fs-extra";
 
 // src/utils/detect.ts
-import fs31 from "fs";
-import path34 from "path";
+import fs33 from "fs";
+import path36 from "path";
 var NEXT_CONFIG_FILES = ["next.config.ts", "next.config.js", "next.config.mjs"];
 function detectProjectName(cwd) {
-  const pkgPath = path34.join(cwd, "package.json");
-  if (fs31.existsSync(pkgPath)) {
+  const pkgPath = path36.join(cwd, "package.json");
+  if (fs33.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs31.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs33.readFileSync(pkgPath, "utf-8"));
       if (typeof pkg.name === "string" && pkg.name.length > 0) {
         return formatProjectName(pkg.name);
       }
     } catch {
     }
   }
-  return formatProjectName(path34.basename(cwd));
+  return formatProjectName(path36.basename(cwd));
 }
 function formatProjectName(name) {
   const base = name.includes("/") ? name.split("/").pop() : name;
   return base.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
 }
 function detectProject(cwd) {
-  const isExisting = NEXT_CONFIG_FILES.some((f) => fs31.existsSync(path34.join(cwd, f)));
-  const hasSrcDir = fs31.existsSync(path34.join(cwd, "src"));
-  const hasTypeScript = fs31.existsSync(path34.join(cwd, "tsconfig.json")) || fs31.existsSync(path34.join(cwd, "tsconfig.app.json"));
+  const isExisting = NEXT_CONFIG_FILES.some((f) => fs33.existsSync(path36.join(cwd, f)));
+  const hasSrcDir = fs33.existsSync(path36.join(cwd, "src"));
+  const hasTypeScript = fs33.existsSync(path36.join(cwd, "tsconfig.json")) || fs33.existsSync(path36.join(cwd, "tsconfig.app.json"));
   const hasTailwind = detectTailwind(cwd);
   const linter = detectLinter(cwd);
   const conflicts = [];
   if (isExisting) {
-    if (fs31.existsSync(path34.join(cwd, "cms"))) {
+    if (fs33.existsSync(path36.join(cwd, "cms"))) {
       conflicts.push("cms/ directory already exists");
     }
-    if (fs31.existsSync(path34.join(cwd, "cms.config.ts"))) {
+    if (fs33.existsSync(path36.join(cwd, "cms.config.ts"))) {
       conflicts.push("cms.config.ts already exists");
     }
     const appBase = hasSrcDir ? "src/app" : "app";
-    if (fs31.existsSync(path34.join(cwd, appBase, "(cms)"))) {
+    if (fs33.existsSync(path36.join(cwd, appBase, "(cms)"))) {
       conflicts.push(`${appBase}/(cms)/ route group already exists`);
     }
     if (hasTsconfigCmsAliases(cwd)) {
@@ -8572,19 +8910,19 @@ var ESLINT_CONFIG_FILES = [
 ];
 function detectLinter(cwd) {
   for (const f of BIOME_CONFIG_FILES) {
-    if (fs31.existsSync(path34.join(cwd, f))) {
+    if (fs33.existsSync(path36.join(cwd, f))) {
       return { type: "biome", configFile: f };
     }
   }
   for (const f of ESLINT_CONFIG_FILES) {
-    if (fs31.existsSync(path34.join(cwd, f))) {
+    if (fs33.existsSync(path36.join(cwd, f))) {
       return { type: "eslint", configFile: f };
     }
   }
-  const pkgPath = path34.join(cwd, "package.json");
-  if (fs31.existsSync(pkgPath)) {
+  const pkgPath = path36.join(cwd, "package.json");
+  if (fs33.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs31.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs33.readFileSync(pkgPath, "utf-8"));
       if (pkg.eslintConfig) {
         return { type: "eslint", configFile: "package.json (eslintConfig)" };
       }
@@ -8595,14 +8933,14 @@ function detectLinter(cwd) {
 }
 function detectTailwind(cwd) {
   const cssFiles = ["globals.css", "app.css", "index.css"].flatMap((f) => [
-    path34.join(cwd, "src", "app", f),
-    path34.join(cwd, "app", f),
-    path34.join(cwd, "src", f),
-    path34.join(cwd, f)
+    path36.join(cwd, "src", "app", f),
+    path36.join(cwd, "app", f),
+    path36.join(cwd, "src", f),
+    path36.join(cwd, f)
   ]);
   for (const cssFile of cssFiles) {
-    if (fs31.existsSync(cssFile)) {
-      const content = fs31.readFileSync(cssFile, "utf-8");
+    if (fs33.existsSync(cssFile)) {
+      const content = fs33.readFileSync(cssFile, "utf-8");
       if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'") || content.includes("@theme")) {
         return true;
       }
@@ -8610,8 +8948,8 @@ function detectTailwind(cwd) {
   }
   const postcssFiles = ["postcss.config.js", "postcss.config.mjs", "postcss.config.cjs"];
   for (const f of postcssFiles) {
-    if (fs31.existsSync(path34.join(cwd, f))) {
-      const content = fs31.readFileSync(path34.join(cwd, f), "utf-8");
+    if (fs33.existsSync(path36.join(cwd, f))) {
+      const content = fs33.readFileSync(path36.join(cwd, f), "utf-8");
       if (content.includes("tailwindcss") || content.includes("@tailwindcss")) {
         return true;
       }
@@ -8620,20 +8958,20 @@ function detectTailwind(cwd) {
   return false;
 }
 function hasTsconfigCmsAliases(cwd) {
-  const tsconfigPath = path34.join(cwd, "tsconfig.json");
-  if (!fs31.existsSync(tsconfigPath)) return false;
+  const tsconfigPath = path36.join(cwd, "tsconfig.json");
+  if (!fs33.existsSync(tsconfigPath)) return false;
   try {
-    const content = fs31.readFileSync(tsconfigPath, "utf-8");
+    const content = fs33.readFileSync(tsconfigPath, "utf-8");
     return content.includes("@cms/");
   } catch {
     return false;
   }
 }
 function hasEnvBetterstartVars(cwd) {
-  const envPath = path34.join(cwd, ".env.local");
-  if (!fs31.existsSync(envPath)) return false;
+  const envPath = path36.join(cwd, ".env.local");
+  if (!fs33.existsSync(envPath)) return false;
   try {
-    const content = fs31.readFileSync(envPath, "utf-8");
+    const content = fs33.readFileSync(envPath, "utf-8");
     return content.includes("BETTERSTART_");
   } catch {
     return false;
@@ -11332,12 +11670,12 @@ export function addToMailchimpAudience(email: string): void {
 
 // src/init/scaffolders/components.ts
 function scaffoldComponents({ cwd, config }) {
-  const cms = path35.resolve(cwd, config.paths.cms);
+  const cms = path37.resolve(cwd, config.paths.cms);
   const created = [];
   function write(relPath, content) {
-    const fullPath = path35.join(cms, relPath);
+    const fullPath = path37.join(cms, relPath);
     if (safeWriteFile(fullPath, content)) {
-      created.push(path35.join(config.paths.cms, relPath));
+      created.push(path37.join(config.paths.cms, relPath));
     }
   }
   write("cms-globals.css", cmsGlobalsCssTemplate());
@@ -11386,18 +11724,18 @@ function scaffoldComponents({ cwd, config }) {
 }
 function copyUiTemplates(cwd, config) {
   const created = [];
-  const destDir = path35.resolve(cwd, config.paths.cms, "components", "ui");
+  const destDir = path37.resolve(cwd, config.paths.cms, "components", "ui");
   const cliRoot = findCliRoot();
-  const srcDir = path35.join(cliRoot, "templates", "ui");
-  if (!fs32.existsSync(srcDir)) {
+  const srcDir = path37.join(cliRoot, "templates", "ui");
+  if (!fs34.existsSync(srcDir)) {
     return created;
   }
-  const files = fs32.readdirSync(srcDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".ts"));
+  const files = fs34.readdirSync(srcDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".ts"));
   for (const file of files) {
-    const destPath = path35.join(destDir, file);
-    if (!fs32.existsSync(destPath)) {
-      fs32.copyFileSync(path35.join(srcDir, file), destPath);
-      created.push(path35.join(config.paths.cms, "components", "ui", file));
+    const destPath = path37.join(destDir, file);
+    if (!fs34.existsSync(destPath)) {
+      fs34.copyFileSync(path37.join(srcDir, file), destPath);
+      created.push(path37.join(config.paths.cms, "components", "ui", file));
     }
   }
   return created;
@@ -11405,25 +11743,25 @@ function copyUiTemplates(cwd, config) {
 function copyTiptapTemplates(cwd, config) {
   const created = [];
   const cliRoot = findCliRoot();
-  const srcDir = path35.join(cliRoot, "templates", "tiptap");
-  const destDir = path35.resolve(cwd, config.paths.cms, "components", "ui", "tiptap");
-  if (!fs32.existsSync(srcDir)) {
+  const srcDir = path37.join(cliRoot, "templates", "tiptap");
+  const destDir = path37.resolve(cwd, config.paths.cms, "components", "ui", "tiptap");
+  if (!fs34.existsSync(srcDir)) {
     return created;
   }
   copyDirRecursive(srcDir, destDir, config.paths.cms, created);
   return created;
 }
 function copyDirRecursive(src, dest, cmsPrefix, created) {
-  fs32.ensureDirSync(dest);
-  const entries = fs32.readdirSync(src, { withFileTypes: true });
+  fs34.ensureDirSync(dest);
+  const entries = fs34.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path35.join(src, entry.name);
-    const destPath = path35.join(dest, entry.name);
+    const srcPath = path37.join(src, entry.name);
+    const destPath = path37.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath, cmsPrefix, created);
-    } else if (!fs32.existsSync(destPath)) {
-      fs32.copyFileSync(srcPath, destPath);
-      const relFromCms = path35.relative(path35.resolve(dest, "..", "..", "..", ".."), destPath);
+    } else if (!fs34.existsSync(destPath)) {
+      fs34.copyFileSync(srcPath, destPath);
+      const relFromCms = path37.relative(path37.resolve(dest, "..", "..", "..", ".."), destPath);
       created.push(relFromCms);
     }
   }
@@ -11431,35 +11769,35 @@ function copyDirRecursive(src, dest, cmsPrefix, created) {
 function copySchemaMetaschema(cwd, config) {
   const created = [];
   const cliRoot = findCliRoot();
-  const srcPath = path35.join(cliRoot, "templates", "schema.json");
-  const destPath = path35.resolve(cwd, config.paths.schemas, "schema.json");
-  if (fs32.existsSync(srcPath) && !fs32.existsSync(destPath)) {
-    fs32.ensureDirSync(path35.dirname(destPath));
-    fs32.copyFileSync(srcPath, destPath);
-    created.push(path35.join(config.paths.schemas, "schema.json"));
+  const srcPath = path37.join(cliRoot, "templates", "schema.json");
+  const destPath = path37.resolve(cwd, config.paths.schemas, "schema.json");
+  if (fs34.existsSync(srcPath) && !fs34.existsSync(destPath)) {
+    fs34.ensureDirSync(path37.dirname(destPath));
+    fs34.copyFileSync(srcPath, destPath);
+    created.push(path37.join(config.paths.schemas, "schema.json"));
   }
   return created;
 }
 function findCliRoot() {
   let dir = new URL(".", import.meta.url).pathname;
   for (let i = 0; i < 5; i++) {
-    const pkgPath = path35.join(dir, "package.json");
-    if (fs32.existsSync(pkgPath)) {
+    const pkgPath = path37.join(dir, "package.json");
+    if (fs34.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs32.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf-8"));
         if (pkg.name === "@betterstart/cli") {
           return dir;
         }
       } catch {
       }
     }
-    dir = path35.dirname(dir);
+    dir = path37.dirname(dir);
   }
-  return path35.resolve(new URL(".", import.meta.url).pathname, "..", "..");
+  return path37.resolve(new URL(".", import.meta.url).pathname, "..", "..");
 }
 
 // src/init/scaffolders/database.ts
-import path36 from "path";
+import path38 from "path";
 
 // src/init/templates/db/client.ts
 function dbClientTemplate() {
@@ -11570,16 +11908,16 @@ export const formSettings = pgTable(
 // src/init/scaffolders/database.ts
 function scaffoldDatabase({ cwd, config }) {
   const created = [];
-  const dbDir = path36.resolve(cwd, config.paths.cms, "db");
+  const dbDir = path38.resolve(cwd, config.paths.cms, "db");
   function write(filename, content) {
-    const fullPath = path36.join(dbDir, filename);
+    const fullPath = path38.join(dbDir, filename);
     if (safeWriteFile(fullPath, content)) {
-      created.push(path36.join(config.paths.cms, "db", filename));
+      created.push(path38.join(config.paths.cms, "db", filename));
     }
   }
   write("client.ts", dbClientTemplate());
   write("schema.ts", dbSchemaTemplate());
-  const drizzleConfigPath = path36.resolve(cwd, "drizzle.config.ts");
+  const drizzleConfigPath = path38.resolve(cwd, "drizzle.config.ts");
   if (safeWriteFile(drizzleConfigPath, drizzleConfigTemplate())) {
     created.push("drizzle.config.ts");
   }
@@ -11751,11 +12089,11 @@ import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 
 // src/utils/env.ts
-import fs33 from "fs";
-import path37 from "path";
+import fs35 from "fs";
+import path39 from "path";
 function appendEnvVars(cwd, sections, overwrite) {
-  const envPath = path37.join(cwd, ".env.local");
-  let existing = fs33.existsSync(envPath) ? fs33.readFileSync(envPath, "utf-8") : "";
+  const envPath = path39.join(cwd, ".env.local");
+  let existing = fs35.existsSync(envPath) ? fs35.readFileSync(envPath, "utf-8") : "";
   const existingKeys = new Set(
     existing.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#")).map((line) => line.split("=")[0]?.trim()).filter(Boolean)
   );
@@ -11799,7 +12137,7 @@ function appendEnvVars(cwd, sections, overwrite) {
     const header = existing.trim() ? "" : "# ============================================\n# BetterStart CMS\n# ============================================\n";
     const content = existing.trim() ? `${existing.trimEnd()}
 ${lines.join("\n")}` : header + lines.join("\n");
-    fs33.writeFileSync(envPath, content);
+    fs35.writeFileSync(envPath, content);
   }
   return { added, skipped, updated };
 }
@@ -11878,7 +12216,7 @@ function scaffoldEnv(cwd, options) {
 }
 
 // src/init/scaffolders/layout.ts
-import path38 from "path";
+import path40 from "path";
 
 // src/init/templates/pages/authenticated-layout.ts
 function authenticatedLayoutTemplate() {
@@ -12765,30 +13103,30 @@ export function UsersTable<TValue>({ columns }: UsersTableProps<TValue>) {
 function scaffoldLayout({ cwd, config }) {
   const created = [];
   function write(relPath, content) {
-    const fullPath = path38.resolve(cwd, relPath);
-    ensureDir(path38.dirname(fullPath));
+    const fullPath = path40.resolve(cwd, relPath);
+    ensureDir(path40.dirname(fullPath));
     if (safeWriteFile(fullPath, content)) {
       created.push(relPath);
     }
   }
-  const cmsDir = path38.dirname(config.paths.pages);
-  write(path38.join(cmsDir, "layout.tsx"), cmsLayoutTemplate());
-  write(path38.join(config.paths.pages, "layout.tsx"), authenticatedLayoutTemplate());
-  write(path38.join(config.paths.login, "page.tsx"), loginPageTemplate());
-  write(path38.join(config.paths.login, "login-form.tsx"), loginFormTemplate());
-  write(path38.join(config.paths.pages, "page.tsx"), dashboardPageTemplate());
-  const usersDir = path38.join(config.paths.pages, "users");
-  write(path38.join(usersDir, "page.tsx"), usersPageTemplate());
-  write(path38.join(usersDir, "users-table.tsx"), usersTableTemplate());
-  write(path38.join(usersDir, "columns.tsx"), usersColumnsTemplate());
-  write(path38.join(usersDir, "create-user-dialog.tsx"), createUserDialogTemplate());
-  write(path38.join(usersDir, "edit-role-dialog.tsx"), editRoleDialogTemplate());
+  const cmsDir = path40.dirname(config.paths.pages);
+  write(path40.join(cmsDir, "layout.tsx"), cmsLayoutTemplate());
+  write(path40.join(config.paths.pages, "layout.tsx"), authenticatedLayoutTemplate());
+  write(path40.join(config.paths.login, "page.tsx"), loginPageTemplate());
+  write(path40.join(config.paths.login, "login-form.tsx"), loginFormTemplate());
+  write(path40.join(config.paths.pages, "page.tsx"), dashboardPageTemplate());
+  const usersDir = path40.join(config.paths.pages, "users");
+  write(path40.join(usersDir, "page.tsx"), usersPageTemplate());
+  write(path40.join(usersDir, "users-table.tsx"), usersTableTemplate());
+  write(path40.join(usersDir, "columns.tsx"), usersColumnsTemplate());
+  write(path40.join(usersDir, "create-user-dialog.tsx"), createUserDialogTemplate());
+  write(path40.join(usersDir, "edit-role-dialog.tsx"), editRoleDialogTemplate());
   return created;
 }
 
 // src/init/scaffolders/preset.ts
-import fs34 from "fs";
-import path39 from "path";
+import fs36 from "fs";
+import path41 from "path";
 
 // src/init/templates/presets/blog-categories.ts
 function blogCategoriesSchema() {
@@ -13193,15 +13531,15 @@ function scaffoldPreset({
     generatedFiles: [],
     errors: []
   };
-  const schemasDir = path39.join(cwd, config.paths?.schemas ?? "./cms/schemas");
+  const schemasDir = path41.join(cwd, config.paths?.schemas ?? "./cms/schemas");
   const presetSchemas = getPresetSchemas(preset);
   for (const ps of presetSchemas) {
-    const filePath = path39.join(schemasDir, ps.filename);
-    const dir = path39.dirname(filePath);
-    if (!fs34.existsSync(dir)) {
-      fs34.mkdirSync(dir, { recursive: true });
+    const filePath = path41.join(schemasDir, ps.filename);
+    const dir = path41.dirname(filePath);
+    if (!fs36.existsSync(dir)) {
+      fs36.mkdirSync(dir, { recursive: true });
     }
-    fs34.writeFileSync(filePath, ps.content, "utf-8");
+    fs36.writeFileSync(filePath, ps.content, "utf-8");
     result.schemas.push(ps.filename);
   }
   for (const ps of presetSchemas) {
@@ -13242,8 +13580,8 @@ function scaffoldPreset({
 }
 
 // src/init/scaffolders/tailwind.ts
-import fs35 from "fs";
-import path40 from "path";
+import fs37 from "fs";
+import path42 from "path";
 var SOURCE_LINES = ['@source "../cms/**/*.{ts,tsx}";', '@source "./(cms)/**/*.{ts,tsx}";'];
 var SOURCE_LINES_SRC = ['@source "../../cms/**/*.{ts,tsx}";', '@source "./(cms)/**/*.{ts,tsx}";'];
 var CMS_THEME_BLOCK = `
@@ -13298,8 +13636,8 @@ function findMainCss(cwd) {
     "globals.css"
   ];
   for (const candidate of candidates) {
-    const filePath = path40.join(cwd, candidate);
-    if (fs35.existsSync(filePath)) {
+    const filePath = path42.join(cwd, candidate);
+    if (fs37.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -13310,7 +13648,7 @@ function scaffoldTailwind(cwd, hasSrcDir) {
   if (!cssFile) {
     return { file: null, appended: false };
   }
-  let content = fs35.readFileSync(cssFile, "utf-8");
+  let content = fs37.readFileSync(cssFile, "utf-8");
   let changed = false;
   const sourceLines = hasSrcDir ? SOURCE_LINES_SRC : SOURCE_LINES;
   const missingLines = sourceLines.filter((sl) => !content.includes(sl));
@@ -13362,14 +13700,14 @@ ${CMS_THEME_BLOCK}
     }
   }
   if (changed) {
-    fs35.writeFileSync(cssFile, content, "utf-8");
+    fs37.writeFileSync(cssFile, content, "utf-8");
   }
   return { file: cssFile, appended: changed };
 }
 
 // src/init/scaffolders/tsconfig.ts
-import fs36 from "fs";
-import path41 from "path";
+import fs38 from "fs";
+import path43 from "path";
 function stripJsonComments(input) {
   let result = "";
   let i = 0;
@@ -13419,14 +13757,14 @@ var CMS_PATH_ALIASES = {
   "@cms/cache/*": ["./cms/lib/cache/*"]
 };
 function scaffoldTsconfig(cwd) {
-  const tsconfigPath = path41.join(cwd, "tsconfig.json");
+  const tsconfigPath = path43.join(cwd, "tsconfig.json");
   const added = [];
   const skipped = [];
-  if (!fs36.existsSync(tsconfigPath)) {
+  if (!fs38.existsSync(tsconfigPath)) {
     skipped.push("tsconfig.json not found");
     return { added, skipped };
   }
-  const raw = fs36.readFileSync(tsconfigPath, "utf-8");
+  const raw = fs38.readFileSync(tsconfigPath, "utf-8");
   const stripped = stripJsonComments(raw).replace(/,\s*([\]}])/g, "$1");
   let tsconfig;
   try {
@@ -13447,14 +13785,14 @@ function scaffoldTsconfig(cwd) {
   }
   compilerOptions.paths = paths;
   tsconfig.compilerOptions = compilerOptions;
-  fs36.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
+  fs38.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `, "utf-8");
   return { added, skipped };
 }
 
 // src/commands/seed.ts
-import fs37 from "fs";
-import path42 from "path";
+import fs39 from "fs";
+import path44 from "path";
 import * as clack from "@clack/prompts";
 import { Command as Command2 } from "commander";
 function buildSeedScript() {
@@ -13573,7 +13911,7 @@ main().catch((err) => {
 `;
 }
 var seedCommand = new Command2("seed").description("Create the initial admin user").option("--cwd <path>", "Project root path").action(async (options) => {
-  const cwd = options.cwd ? path42.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path44.resolve(options.cwd) : process.cwd();
   clack.intro("BetterStart Seed");
   let config;
   try {
@@ -13613,14 +13951,14 @@ var seedCommand = new Command2("seed").description("Create the initial admin use
     clack.cancel("Cancelled.");
     process.exit(0);
   }
-  const scriptsDir = path42.join(cwd, cmsDir, "scripts");
-  const seedPath = path42.join(scriptsDir, "seed.ts");
-  if (!fs37.existsSync(scriptsDir)) {
-    fs37.mkdirSync(scriptsDir, { recursive: true });
+  const scriptsDir = path44.join(cwd, cmsDir, "scripts");
+  const seedPath = path44.join(scriptsDir, "seed.ts");
+  if (!fs39.existsSync(scriptsDir)) {
+    fs39.mkdirSync(scriptsDir, { recursive: true });
   }
-  fs37.writeFileSync(seedPath, buildSeedScript(), "utf-8");
+  fs39.writeFileSync(seedPath, buildSeedScript(), "utf-8");
   const { execFile } = await import("child_process");
-  const tsxBin = path42.join(cwd, "node_modules", ".bin", "tsx");
+  const tsxBin = path44.join(cwd, "node_modules", ".bin", "tsx");
   const runSeed2 = (overwrite) => new Promise((resolve, reject) => {
     execFile(
       tsxBin,
@@ -13659,7 +13997,7 @@ var seedCommand = new Command2("seed").description("Create the initial admin use
       if (clack.isCancel(overwrite) || !overwrite) {
         clack.cancel("Seed cancelled.");
         try {
-          fs37.unlinkSync(seedPath);
+          fs39.unlinkSync(seedPath);
         } catch {
         }
         process.exit(0);
@@ -13676,15 +14014,15 @@ var seedCommand = new Command2("seed").description("Create the initial admin use
     clack.log.error(errMsg);
     clack.log.info("You can run the seed script manually:");
     clack.log.info(
-      `  SEED_EMAIL="${email}" SEED_PASSWORD="..." npx tsx ${path42.relative(cwd, seedPath)}`
+      `  SEED_EMAIL="${email}" SEED_PASSWORD="..." npx tsx ${path44.relative(cwd, seedPath)}`
     );
     clack.outro("");
     process.exit(1);
   }
   try {
-    fs37.unlinkSync(seedPath);
-    if (fs37.existsSync(scriptsDir) && fs37.readdirSync(scriptsDir).length === 0) {
-      fs37.rmdirSync(scriptsDir);
+    fs39.unlinkSync(seedPath);
+    if (fs39.existsSync(scriptsDir) && fs39.readdirSync(scriptsDir).length === 0) {
+      fs39.rmdirSync(scriptsDir);
     }
   } catch {
   }
@@ -13715,16 +14053,16 @@ var initCommand = new Command3("init").description("Scaffold CMS into a new or e
         const nukeFiles = ["cms.config.ts", "CMS.md", "drizzle.config.ts"];
         let nuked = 0;
         for (const dir of nukeDirs) {
-          const fullPath = path43.resolve(cwd, dir);
-          if (fs38.existsSync(fullPath)) {
-            fs38.rmSync(fullPath, { recursive: true, force: true });
+          const fullPath = path45.resolve(cwd, dir);
+          if (fs40.existsSync(fullPath)) {
+            fs40.rmSync(fullPath, { recursive: true, force: true });
             nuked++;
           }
         }
         for (const file of nukeFiles) {
-          const fullPath = path43.resolve(cwd, file);
-          if (fs38.existsSync(fullPath)) {
-            fs38.unlinkSync(fullPath);
+          const fullPath = path45.resolve(cwd, file);
+          if (fs40.existsSync(fullPath)) {
+            fs40.unlinkSync(fullPath);
             nuked++;
           }
         }
@@ -13771,7 +14109,7 @@ var initCommand = new Command3("init").description("Scaffold CMS into a new or e
         }
         pm = pmChoice;
       }
-      const displayName = projectPrompt.projectName === "." ? path43.basename(cwd) : projectPrompt.projectName;
+      const displayName = projectPrompt.projectName === "." ? path45.basename(cwd) : projectPrompt.projectName;
       const { bin, prefix } = createNextAppCommand(pm);
       const cnaArgs = [
         ...prefix,
@@ -13803,10 +14141,10 @@ var initCommand = new Command3("init").description("Scaffold CMS into a new or e
         );
         process.exit(1);
       }
-      cwd = path43.resolve(cwd, projectPrompt.projectName);
-      const hasPackageJson = fs38.existsSync(path43.join(cwd, "package.json"));
+      cwd = path45.resolve(cwd, projectPrompt.projectName);
+      const hasPackageJson = fs40.existsSync(path45.join(cwd, "package.json"));
       const hasNextConfig = ["next.config.ts", "next.config.js", "next.config.mjs"].some(
-        (f) => fs38.existsSync(path43.join(cwd, f))
+        (f) => fs40.existsSync(path45.join(cwd, f))
       );
       if (!hasPackageJson || !hasNextConfig) {
         p4.log.error(
@@ -13907,11 +14245,11 @@ var initCommand = new Command3("init").description("Scaffold CMS into a new or e
     s.stop("");
     process.stdout.write("\x1B[2A\x1B[J");
     p4.note(noteLines.join("\n"), "Scaffolded CMS");
-    const drizzleConfigPath = path43.join(cwd, "drizzle.config.ts");
-    if (!dbFiles.includes("drizzle.config.ts") && fs38.existsSync(drizzleConfigPath)) {
+    const drizzleConfigPath = path45.join(cwd, "drizzle.config.ts");
+    if (!dbFiles.includes("drizzle.config.ts") && fs40.existsSync(drizzleConfigPath)) {
       if (options.force) {
         const { drizzleConfigTemplate: drizzleConfigTemplate2 } = await import("./drizzle-config-EDKOEZ6G.js");
-        fs38.writeFileSync(drizzleConfigPath, drizzleConfigTemplate2(), "utf-8");
+        fs40.writeFileSync(drizzleConfigPath, drizzleConfigTemplate2(), "utf-8");
         p4.log.success("Updated drizzle.config.ts");
       } else if (!options.yes) {
         const overwrite = await p4.confirm({
@@ -13920,7 +14258,7 @@ var initCommand = new Command3("init").description("Scaffold CMS into a new or e
         });
         if (!p4.isCancel(overwrite) && overwrite) {
           const { drizzleConfigTemplate: drizzleConfigTemplate2 } = await import("./drizzle-config-EDKOEZ6G.js");
-          fs38.writeFileSync(drizzleConfigPath, drizzleConfigTemplate2(), "utf-8");
+          fs40.writeFileSync(drizzleConfigPath, drizzleConfigTemplate2(), "utf-8");
           p4.log.success("Updated drizzle.config.ts");
         }
       }
@@ -13953,15 +14291,15 @@ var initCommand = new Command3("init").description("Scaffold CMS into a new or e
     {
       const entityNames = [];
       const formNames = [];
-      const schemasDir = path43.join(cwd, config.paths.schemas);
-      const formsDir = path43.join(schemasDir, "forms");
-      if (fs38.existsSync(schemasDir)) {
-        for (const f of fs38.readdirSync(schemasDir)) {
+      const schemasDir = path45.join(cwd, config.paths.schemas);
+      const formsDir = path45.join(schemasDir, "forms");
+      if (fs40.existsSync(schemasDir)) {
+        for (const f of fs40.readdirSync(schemasDir)) {
           if (f.endsWith(".json")) entityNames.push(f.replace(".json", ""));
         }
       }
-      if (fs38.existsSync(formsDir)) {
-        for (const f of fs38.readdirSync(formsDir)) {
+      if (fs40.existsSync(formsDir)) {
+        for (const f of fs40.readdirSync(formsDir)) {
           if (f.endsWith(".json")) formNames.push(f.replace(".json", ""));
         }
       }
@@ -14140,9 +14478,9 @@ function isValidDbUrl(url) {
   return url.startsWith("postgres://") || url.startsWith("postgresql://");
 }
 function readExistingDbUrl(cwd) {
-  const envPath = path43.join(cwd, ".env.local");
-  if (!fs38.existsSync(envPath)) return void 0;
-  const content = fs38.readFileSync(envPath, "utf-8");
+  const envPath = path45.join(cwd, ".env.local");
+  if (!fs40.existsSync(envPath)) return void 0;
+  const content = fs40.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
@@ -14165,9 +14503,9 @@ function maskDbUrl(url) {
   }
 }
 function hasDbUrl(cwd) {
-  const envPath = path43.join(cwd, ".env.local");
-  if (!fs38.existsSync(envPath)) return false;
-  const content = fs38.readFileSync(envPath, "utf-8");
+  const envPath = path45.join(cwd, ".env.local");
+  if (!fs40.existsSync(envPath)) return false;
+  const content = fs40.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
@@ -14181,23 +14519,23 @@ function hasDbUrl(cwd) {
   return false;
 }
 function runSeed(cwd, cmsDir, email, password4, overwrite = false) {
-  const scriptsDir = path43.join(cwd, cmsDir, "scripts");
-  const seedPath = path43.join(scriptsDir, "seed.ts");
-  if (!fs38.existsSync(scriptsDir)) {
-    fs38.mkdirSync(scriptsDir, { recursive: true });
+  const scriptsDir = path45.join(cwd, cmsDir, "scripts");
+  const seedPath = path45.join(scriptsDir, "seed.ts");
+  if (!fs40.existsSync(scriptsDir)) {
+    fs40.mkdirSync(scriptsDir, { recursive: true });
   }
-  fs38.writeFileSync(seedPath, buildSeedScript(), "utf-8");
+  fs40.writeFileSync(seedPath, buildSeedScript(), "utf-8");
   const cleanup = () => {
     try {
-      fs38.unlinkSync(seedPath);
-      if (fs38.existsSync(scriptsDir) && fs38.readdirSync(scriptsDir).length === 0) {
-        fs38.rmdirSync(scriptsDir);
+      fs40.unlinkSync(seedPath);
+      if (fs40.existsSync(scriptsDir) && fs40.readdirSync(scriptsDir).length === 0) {
+        fs40.rmdirSync(scriptsDir);
       }
     } catch {
     }
   };
   return new Promise((resolve) => {
-    const tsxBin = path43.join(cwd, "node_modules", ".bin", "tsx");
+    const tsxBin = path45.join(cwd, "node_modules", ".bin", "tsx");
     const child = spawn2(tsxBin, [seedPath], {
       cwd,
       stdio: "pipe",
@@ -14262,7 +14600,7 @@ ${stderr}`;
 }
 function runDrizzlePush(cwd) {
   return new Promise((resolve) => {
-    const drizzleBin = path43.join(cwd, "node_modules", ".bin", "drizzle-kit");
+    const drizzleBin = path45.join(cwd, "node_modules", ".bin", "drizzle-kit");
     const child = spawn2(drizzleBin, ["push", "--force"], {
       cwd,
       stdio: "pipe",
@@ -14283,8 +14621,8 @@ function runDrizzlePush(cwd) {
 }
 
 // src/commands/remove.ts
-import fs39 from "fs";
-import path44 from "path";
+import fs41 from "fs";
+import path46 from "path";
 import readline from "readline";
 import { Command as Command4 } from "commander";
 function findTableEnd3(content, startIndex) {
@@ -14315,8 +14653,8 @@ function findTableEnd3(content, startIndex) {
   return content.length;
 }
 function removeTableFromSchema(schemaFilePath, name) {
-  if (!fs39.existsSync(schemaFilePath)) return false;
-  let content = fs39.readFileSync(schemaFilePath, "utf-8");
+  if (!fs41.existsSync(schemaFilePath)) return false;
+  let content = fs41.readFileSync(schemaFilePath, "utf-8");
   const variableName = toCamelCase(name);
   let changed = false;
   if (content.includes(`export const ${variableName} =`)) {
@@ -14344,13 +14682,13 @@ function removeTableFromSchema(schemaFilePath, name) {
   }
   if (changed) {
     content = content.replace(/\n{3,}/g, "\n\n");
-    fs39.writeFileSync(schemaFilePath, content, "utf-8");
+    fs41.writeFileSync(schemaFilePath, content, "utf-8");
   }
   return changed;
 }
 function removeFromNavigation(navFilePath, name) {
-  if (!fs39.existsSync(navFilePath)) return false;
-  const content = fs39.readFileSync(navFilePath, "utf-8");
+  if (!fs41.existsSync(navFilePath)) return false;
+  const content = fs41.readFileSync(navFilePath, "utf-8");
   const href = `/cms/${name}`;
   if (!content.includes(`'${href}'`)) return false;
   const lines = content.split("\n");
@@ -14381,7 +14719,7 @@ function removeFromNavigation(navFilePath, name) {
   if (startLine === -1 || endLine === -1) return false;
   lines.splice(startLine, endLine - startLine + 1);
   const updated = lines.join("\n").replace(/,\s*,/g, ",").replace(/\[\s*,/, "[");
-  fs39.writeFileSync(navFilePath, updated, "utf-8");
+  fs41.writeFileSync(navFilePath, updated, "utf-8");
   return true;
 }
 async function promptConfirm(message) {
@@ -14397,7 +14735,7 @@ async function promptConfirm(message) {
   });
 }
 var removeCommand = new Command4("remove").alias("rm").description("Remove all generated files for an entity or form").argument("<schema>", "Schema name to remove (e.g. posts, categories, contact)").option("-f, --force", "Skip confirmation prompt", false).option("--cwd <path>", "Project root path").action(async (schemaName, options) => {
-  const cwd = options.cwd ? path44.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path46.resolve(options.cwd) : process.cwd();
   console.log("\n  BetterStart Remove\n");
   let config;
   try {
@@ -14410,34 +14748,34 @@ var removeCommand = new Command4("remove").alias("rm").description("Remove all g
   const pagesDir = config.paths?.pages ?? "./src/app/(cms)/cms/(authenticated)";
   const kebabName = toKebabCase(schemaName);
   const targets = [];
-  const entityPagesDir = path44.join(cwd, pagesDir, schemaName);
-  if (fs39.existsSync(entityPagesDir)) {
+  const entityPagesDir = path46.join(cwd, pagesDir, schemaName);
+  if (fs41.existsSync(entityPagesDir)) {
     targets.push({
       path: entityPagesDir,
-      label: `${path44.join(pagesDir, schemaName)}/`,
+      label: `${path46.join(pagesDir, schemaName)}/`,
       isDir: true
     });
   }
-  const actionsFile = path44.join(cwd, cmsDir, "lib", "actions", `${kebabName}.ts`);
-  if (fs39.existsSync(actionsFile)) {
+  const actionsFile = path46.join(cwd, cmsDir, "lib", "actions", `${kebabName}.ts`);
+  if (fs41.existsSync(actionsFile)) {
     targets.push({
       path: actionsFile,
-      label: path44.join(cmsDir, "lib", "actions", `${kebabName}.ts`),
+      label: path46.join(cmsDir, "lib", "actions", `${kebabName}.ts`),
       isDir: false
     });
   }
-  const hookFile = path44.join(cwd, cmsDir, "hooks", `use-${kebabName}.ts`);
-  if (fs39.existsSync(hookFile)) {
+  const hookFile = path46.join(cwd, cmsDir, "hooks", `use-${kebabName}.ts`);
+  if (fs41.existsSync(hookFile)) {
     targets.push({
       path: hookFile,
-      label: path44.join(cmsDir, "hooks", `use-${kebabName}.ts`),
+      label: path46.join(cmsDir, "hooks", `use-${kebabName}.ts`),
       isDir: false
     });
   }
-  const schemaFilePath = path44.join(cwd, cmsDir, "db", "schema.ts");
-  const hasTable = fs39.existsSync(schemaFilePath) && fs39.readFileSync(schemaFilePath, "utf-8").includes(`export const ${toCamelCase(schemaName)} =`);
-  const navFilePath = path44.join(cwd, cmsDir, "data", "navigation.ts");
-  const hasNavEntry = fs39.existsSync(navFilePath) && fs39.readFileSync(navFilePath, "utf-8").includes(`'/cms/${schemaName}'`);
+  const schemaFilePath = path46.join(cwd, cmsDir, "db", "schema.ts");
+  const hasTable = fs41.existsSync(schemaFilePath) && fs41.readFileSync(schemaFilePath, "utf-8").includes(`export const ${toCamelCase(schemaName)} =`);
+  const navFilePath = path46.join(cwd, cmsDir, "data", "navigation.ts");
+  const hasNavEntry = fs41.existsSync(navFilePath) && fs41.readFileSync(navFilePath, "utf-8").includes(`'/cms/${schemaName}'`);
   if (targets.length === 0 && !hasTable && !hasNavEntry) {
     console.log(`  No generated files found for: ${schemaName}`);
     return;
@@ -14447,10 +14785,10 @@ var removeCommand = new Command4("remove").alias("rm").description("Remove all g
     console.log(`    ${t.isDir ? "[dir]" : "     "} ${t.label}`);
   }
   if (hasTable) {
-    console.log(`    [edit] ${path44.join(cmsDir, "db", "schema.ts")} (remove table)`);
+    console.log(`    [edit] ${path46.join(cmsDir, "db", "schema.ts")} (remove table)`);
   }
   if (hasNavEntry) {
-    console.log(`    [edit] ${path44.join(cmsDir, "data", "navigation.ts")} (remove entry)`);
+    console.log(`    [edit] ${path46.join(cmsDir, "data", "navigation.ts")} (remove entry)`);
   }
   if (!options.force) {
     console.log("");
@@ -14463,19 +14801,19 @@ var removeCommand = new Command4("remove").alias("rm").description("Remove all g
   console.log("");
   for (const t of targets) {
     if (t.isDir) {
-      fs39.rmSync(t.path, { recursive: true, force: true });
+      fs41.rmSync(t.path, { recursive: true, force: true });
     } else {
-      fs39.unlinkSync(t.path);
+      fs41.unlinkSync(t.path);
     }
     console.log(`  Removed: ${t.label}`);
   }
   if (hasTable) {
     removeTableFromSchema(schemaFilePath, schemaName);
-    console.log(`  Cleaned: ${path44.join(cmsDir, "db", "schema.ts")}`);
+    console.log(`  Cleaned: ${path46.join(cmsDir, "db", "schema.ts")}`);
   }
   if (hasNavEntry) {
     removeFromNavigation(navFilePath, schemaName);
-    console.log(`  Cleaned: ${path44.join(cmsDir, "data", "navigation.ts")}`);
+    console.log(`  Cleaned: ${path46.join(cmsDir, "data", "navigation.ts")}`);
   }
   console.log("\n  Removal complete!");
   console.log("\n  Note: You may need to manually:");
@@ -14487,14 +14825,14 @@ var removeCommand = new Command4("remove").alias("rm").description("Remove all g
 
 // src/commands/setup-r2.ts
 import { execFileSync as execFileSync5, spawnSync } from "child_process";
-import fs40 from "fs";
+import fs42 from "fs";
 import os from "os";
-import path45 from "path";
+import path47 from "path";
 import * as p5 from "@clack/prompts";
 import { Command as Command5 } from "commander";
 import pc3 from "picocolors";
 var setupR2Command = new Command5("setup-r2").description("Create a Cloudflare R2 bucket and configure storage env vars").option("--cwd <path>", "Project root path").option("--bucket <name>", "Bucket name (skips prompt)").action(async (options) => {
-  const cwd = options.cwd ? path45.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path47.resolve(options.cwd) : process.cwd();
   p5.intro(pc3.bgCyan(pc3.black(" BetterStart \u2014 R2 Storage Setup ")));
   const s = p5.spinner();
   s.start("Looking for wrangler CLI");
@@ -14686,8 +15024,8 @@ var setupR2Command = new Command5("setup-r2").description("Create a Cloudflare R
   p5.outro("Done! Your CMS can now upload files to R2.");
 });
 function findWrangler(cwd) {
-  const localBin = path45.join(cwd, "node_modules", ".bin", "wrangler");
-  if (fs40.existsSync(localBin)) return { bin: localBin, prefix: [] };
+  const localBin = path47.join(cwd, "node_modules", ".bin", "wrangler");
+  if (fs42.existsSync(localBin)) return { bin: localBin, prefix: [] };
   const result = spawnSync("which", ["wrangler"], { stdio: "pipe", timeout: 5e3 });
   if (result.status === 0) {
     const found = result.stdout?.toString().trim();
@@ -14719,11 +15057,11 @@ function extractAccountId(ref, cwd) {
 }
 function readWranglerToken() {
   const candidates = [
-    path45.join(os.homedir(), "Library", "Preferences", ".wrangler", "config", "default.toml"),
+    path47.join(os.homedir(), "Library", "Preferences", ".wrangler", "config", "default.toml"),
     // macOS
-    path45.join(os.homedir(), ".config", ".wrangler", "config", "default.toml"),
+    path47.join(os.homedir(), ".config", ".wrangler", "config", "default.toml"),
     // Linux
-    path45.join(os.homedir(), ".wrangler", "config", "default.toml")
+    path47.join(os.homedir(), ".wrangler", "config", "default.toml")
     // fallback
   ];
   if (process.env.WRANGLER_CONFIG_PATH) {
@@ -14731,13 +15069,13 @@ function readWranglerToken() {
   }
   if (process.env.XDG_CONFIG_HOME) {
     candidates.unshift(
-      path45.join(process.env.XDG_CONFIG_HOME, ".wrangler", "config", "default.toml")
+      path47.join(process.env.XDG_CONFIG_HOME, ".wrangler", "config", "default.toml")
     );
   }
   for (const configPath of candidates) {
-    if (!fs40.existsSync(configPath)) continue;
+    if (!fs42.existsSync(configPath)) continue;
     try {
-      const content = fs40.readFileSync(configPath, "utf-8");
+      const content = fs42.readFileSync(configPath, "utf-8");
       const match = content.match(/^oauth_token\s*=\s*"([^"]+)"/m);
       if (match) return match[1];
     } catch {
@@ -14769,14 +15107,14 @@ async function enablePublicDomain(accountId, bucketName, token) {
 }
 
 // src/commands/uninstall.ts
-import fs42 from "fs";
-import path46 from "path";
+import fs44 from "fs";
+import path48 from "path";
 import * as p6 from "@clack/prompts";
 import { Command as Command6 } from "commander";
 import pc4 from "picocolors";
 
 // src/commands/uninstall-cleaners.ts
-import fs41 from "fs";
+import fs43 from "fs";
 function stripJsonComments2(input) {
   let result = "";
   let i = 0;
@@ -14810,8 +15148,8 @@ function stripJsonComments2(input) {
   return result;
 }
 function cleanTsconfig(tsconfigPath) {
-  if (!fs41.existsSync(tsconfigPath)) return [];
-  const raw = fs41.readFileSync(tsconfigPath, "utf-8");
+  if (!fs43.existsSync(tsconfigPath)) return [];
+  const raw = fs43.readFileSync(tsconfigPath, "utf-8");
   const stripped = stripJsonComments2(raw).replace(/,\s*([\]}])/g, "$1");
   let tsconfig;
   try {
@@ -14835,13 +15173,13 @@ function cleanTsconfig(tsconfigPath) {
     compilerOptions.paths = paths;
   }
   tsconfig.compilerOptions = compilerOptions;
-  fs41.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
+  fs43.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `, "utf-8");
   return removed;
 }
 function cleanCss(cssPath) {
-  if (!fs41.existsSync(cssPath)) return [];
-  const content = fs41.readFileSync(cssPath, "utf-8");
+  if (!fs43.existsSync(cssPath)) return [];
+  const content = fs43.readFileSync(cssPath, "utf-8");
   const lines = content.split("\n");
   const sourcePattern = /^@source\s+"[^"]*cms[^"]*";\s*$/;
   const removed = [];
@@ -14855,12 +15193,12 @@ function cleanCss(cssPath) {
   }
   if (removed.length === 0) return [];
   const cleaned = kept.join("\n").replace(/\n{3,}/g, "\n\n");
-  fs41.writeFileSync(cssPath, cleaned, "utf-8");
+  fs43.writeFileSync(cssPath, cleaned, "utf-8");
   return removed;
 }
 function cleanEnvFile(envPath) {
-  if (!fs41.existsSync(envPath)) return [];
-  const content = fs41.readFileSync(envPath, "utf-8");
+  if (!fs43.existsSync(envPath)) return [];
+  const content = fs43.readFileSync(envPath, "utf-8");
   const lines = content.split("\n");
   const removed = [];
   const kept = [];
@@ -14893,9 +15231,9 @@ function cleanEnvFile(envPath) {
   if (removed.length === 0) return [];
   const result = kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
   if (result === "") {
-    fs41.unlinkSync(envPath);
+    fs43.unlinkSync(envPath);
   } else {
-    fs41.writeFileSync(envPath, `${result}
+    fs43.writeFileSync(envPath, `${result}
 `, "utf-8");
   }
   return removed;
@@ -14921,15 +15259,15 @@ function findMainCss2(cwd) {
     "globals.css"
   ];
   for (const candidate of candidates) {
-    const filePath = path46.join(cwd, candidate);
-    if (fs42.existsSync(filePath)) return filePath;
+    const filePath = path48.join(cwd, candidate);
+    if (fs44.existsSync(filePath)) return filePath;
   }
   return void 0;
 }
 function isCLICreatedBiome(biomePath) {
-  if (!fs42.existsSync(biomePath)) return false;
+  if (!fs44.existsSync(biomePath)) return false;
   try {
-    const content = JSON.parse(fs42.readFileSync(biomePath, "utf-8"));
+    const content = JSON.parse(fs44.readFileSync(biomePath, "utf-8"));
     return content.$schema?.includes("biomejs.dev") && content.formatter?.indentStyle === "space" && content.javascript?.formatter?.quoteStyle === "single" && Array.isArray(content.files?.ignore) && content.files.ignore.includes(".next");
   } catch {
     return false;
@@ -14937,13 +15275,13 @@ function isCLICreatedBiome(biomePath) {
 }
 function buildUninstallPlan(cwd) {
   const steps = [];
-  const hasSrc = fs42.existsSync(path46.join(cwd, "src"));
+  const hasSrc = fs44.existsSync(path48.join(cwd, "src"));
   const appBase = hasSrc ? "src/app" : "app";
   const dirs = [];
-  const cmsDir = path46.join(cwd, "cms");
-  const cmsRouteGroup = path46.join(cwd, appBase, "(cms)");
-  if (fs42.existsSync(cmsDir)) dirs.push("cms/");
-  if (fs42.existsSync(cmsRouteGroup)) dirs.push(`${appBase}/(cms)/`);
+  const cmsDir = path48.join(cwd, "cms");
+  const cmsRouteGroup = path48.join(cwd, appBase, "(cms)");
+  if (fs44.existsSync(cmsDir)) dirs.push("cms/");
+  if (fs44.existsSync(cmsRouteGroup)) dirs.push(`${appBase}/(cms)/`);
   if (dirs.length > 0) {
     steps.push({
       label: "CMS directories",
@@ -14951,25 +15289,25 @@ function buildUninstallPlan(cwd) {
       count: dirs.length,
       unit: dirs.length === 1 ? "directory" : "directories",
       execute() {
-        if (fs42.existsSync(cmsDir)) fs42.rmSync(cmsDir, { recursive: true, force: true });
-        if (fs42.existsSync(cmsRouteGroup)) fs42.rmSync(cmsRouteGroup, { recursive: true, force: true });
+        if (fs44.existsSync(cmsDir)) fs44.rmSync(cmsDir, { recursive: true, force: true });
+        if (fs44.existsSync(cmsRouteGroup)) fs44.rmSync(cmsRouteGroup, { recursive: true, force: true });
       }
     });
   }
   const configFiles = [];
   const configPaths = [];
   const candidates = [
-    ["cms.config.ts", path46.join(cwd, "cms.config.ts")],
-    ["drizzle.config.ts", path46.join(cwd, "drizzle.config.ts")],
-    ["CMS.md", path46.join(cwd, "CMS.md")]
+    ["cms.config.ts", path48.join(cwd, "cms.config.ts")],
+    ["drizzle.config.ts", path48.join(cwd, "drizzle.config.ts")],
+    ["CMS.md", path48.join(cwd, "CMS.md")]
   ];
   for (const [label, fullPath] of candidates) {
-    if (fs42.existsSync(fullPath)) {
+    if (fs44.existsSync(fullPath)) {
       configFiles.push(label);
       configPaths.push(fullPath);
     }
   }
-  const biomePath = path46.join(cwd, "biome.json");
+  const biomePath = path48.join(cwd, "biome.json");
   if (isCLICreatedBiome(biomePath)) {
     configFiles.push("biome.json (CLI-created)");
     configPaths.push(biomePath);
@@ -14982,14 +15320,14 @@ function buildUninstallPlan(cwd) {
       unit: configFiles.length === 1 ? "file" : "files",
       execute() {
         for (const p7 of configPaths) {
-          if (fs42.existsSync(p7)) fs42.unlinkSync(p7);
+          if (fs44.existsSync(p7)) fs44.unlinkSync(p7);
         }
       }
     });
   }
-  const tsconfigPath = path46.join(cwd, "tsconfig.json");
-  if (fs42.existsSync(tsconfigPath)) {
-    const content = fs42.readFileSync(tsconfigPath, "utf-8");
+  const tsconfigPath = path48.join(cwd, "tsconfig.json");
+  if (fs44.existsSync(tsconfigPath)) {
+    const content = fs44.readFileSync(tsconfigPath, "utf-8");
     const aliasMatches = content.match(/"@cms\//g);
     if (aliasMatches && aliasMatches.length > 0) {
       const aliasCount = aliasMatches.length;
@@ -15006,10 +15344,10 @@ function buildUninstallPlan(cwd) {
   }
   const cssFile = findMainCss2(cwd);
   if (cssFile) {
-    const cssContent = fs42.readFileSync(cssFile, "utf-8");
+    const cssContent = fs44.readFileSync(cssFile, "utf-8");
     const sourceLines = cssContent.split("\n").filter((l) => /^@source\s+"[^"]*cms[^"]*";\s*$/.test(l));
     if (sourceLines.length > 0) {
-      const relCss = path46.relative(cwd, cssFile);
+      const relCss = path48.relative(cwd, cssFile);
       steps.push({
         label: `CSS @source lines (${relCss})`,
         items: [`@source lines in ${relCss}`],
@@ -15021,9 +15359,9 @@ function buildUninstallPlan(cwd) {
       });
     }
   }
-  const envPath = path46.join(cwd, ".env.local");
-  if (fs42.existsSync(envPath)) {
-    const envContent = fs42.readFileSync(envPath, "utf-8");
+  const envPath = path48.join(cwd, ".env.local");
+  if (fs44.existsSync(envPath)) {
+    const envContent = fs44.readFileSync(envPath, "utf-8");
     const bsVars = envContent.split("\n").filter((l) => l.trim().match(/^BETTERSTART_\w+=/)).map((l) => l.split("=")[0]);
     if (bsVars.length > 0) {
       steps.push({
@@ -15040,7 +15378,7 @@ function buildUninstallPlan(cwd) {
   return steps;
 }
 var uninstallCommand = new Command6("uninstall").description("Remove all CMS files and undo modifications made by betterstart init").option("-f, --force", "Skip all confirmation prompts", false).option("--cwd <path>", "Project root path").action(async (options) => {
-  const cwd = options.cwd ? path46.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path48.resolve(options.cwd) : process.cwd();
   p6.intro(pc4.bgRed(pc4.white(" BetterStart Uninstall ")));
   const steps = buildUninstallPlan(cwd);
   if (steps.length === 0) {
@@ -15077,11 +15415,11 @@ var uninstallCommand = new Command6("uninstall").description("Remove all CMS fil
 });
 
 // src/commands/update-deps.ts
-import path47 from "path";
+import path49 from "path";
 import * as clack2 from "@clack/prompts";
 import { Command as Command7 } from "commander";
 var updateDepsCommand = new Command7("update-deps").description("Install or update all CMS dependencies").option("--cwd <path>", "Project root path").action(async (options) => {
-  const cwd = options.cwd ? path47.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path49.resolve(options.cwd) : process.cwd();
   clack2.intro("BetterStart Update Dependencies");
   const pm = detectPackageManager(cwd);
   clack2.log.info(`Package manager: ${pm}`);
@@ -15106,22 +15444,22 @@ var updateDepsCommand = new Command7("update-deps").description("Install or upda
 });
 
 // src/commands/update-styles.ts
-import fs43 from "fs";
-import path48 from "path";
+import fs45 from "fs";
+import path50 from "path";
 import * as clack3 from "@clack/prompts";
 import { Command as Command8 } from "commander";
 var updateStylesCommand = new Command8("update-styles").description("Replace cms-globals.css with the latest version from the CLI").option("--cwd <path>", "Project root path").action(async (options) => {
-  const cwd = options.cwd ? path48.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path50.resolve(options.cwd) : process.cwd();
   clack3.intro("BetterStart Update Styles");
   const config = await resolveConfig(cwd);
   const cmsDir = config.paths?.cms ?? "./cms";
-  const targetPath = path48.join(cwd, cmsDir, "cms-globals.css");
-  if (!fs43.existsSync(targetPath)) {
-    clack3.cancel(`cms-globals.css not found at ${path48.relative(cwd, targetPath)}`);
+  const targetPath = path50.join(cwd, cmsDir, "cms-globals.css");
+  if (!fs45.existsSync(targetPath)) {
+    clack3.cancel(`cms-globals.css not found at ${path50.relative(cwd, targetPath)}`);
     process.exit(1);
   }
-  fs43.writeFileSync(targetPath, cmsGlobalsCssTemplate(), "utf-8");
-  clack3.log.success(`Updated ${path48.relative(cwd, targetPath)}`);
+  fs45.writeFileSync(targetPath, cmsGlobalsCssTemplate(), "utf-8");
+  clack3.log.success(`Updated ${path50.relative(cwd, targetPath)}`);
   clack3.outro("Styles updated");
 });