betterstart-cli 0.0.113 → 0.0.115

package/dist/cli.js

@@ -18,6 +18,8 @@ import {
   LOCAL_PROTOCOL_PATTERN,
   LOCKFILE_MAP,
   MAIN_CSS_CANDIDATES,
+  PROXY_CONVENTION_FILE_NAMES,
+  PROXY_FILE_NAME,
   R2_ENV_KEYS,
   RAILWAY_BUCKET_ENV_KEYS,
   REDACTED,
@@ -83,7 +85,7 @@ import {
   trimDotSlash,
   usesIdentifier,
   validateAdminNamespace
-} from "./chunk-PSDUGFMD.js";
+} from "./chunk-SG4U6EQY.js";
 
 // cli.ts
 import * as p66 from "@clack/prompts";
@@ -1227,31 +1229,31 @@ function collectInvalidSchemaFieldTypeErrors(fields, errors) {
 }
 
 // core-engine/schema/schema-reader/collect-slot-area-errors.ts
-function collectSlotAreaErrors(value, path112, errors) {
+function collectSlotAreaErrors(value, path113, errors) {
   if (!isRecord(value)) {
-    errors.push(`${path112} must be an object with a "fields" array.`);
+    errors.push(`${path113} must be an object with a "fields" array.`);
     return;
   }
   const fields = value.fields;
   if (!Array.isArray(fields)) {
-    errors.push(`${path112}.fields must be an array.`);
+    errors.push(`${path113}.fields must be an array.`);
     return;
   }
   for (const field of fields) {
-    walkSlot(field, `${path112}.fields.${field.name ?? "unnamed"}`, errors);
+    walkSlot(field, `${path113}.fields.${field.name ?? "unnamed"}`, errors);
   }
 }
 
 // core-engine/schema/schema-reader/collect-slot-layout-errors.ts
-function collectSlotLayoutErrors(value, path112, errors) {
+function collectSlotLayoutErrors(value, path113, errors) {
   if (!isRecord(value)) {
-    errors.push(`${path112} must be an object with "main" and/or "sidebar" field groups.`);
+    errors.push(`${path113} must be an object with "main" and/or "sidebar" field groups.`);
     return;
   }
   const validKeys = /* @__PURE__ */ new Set(["main", "sidebar"]);
   for (const key of Object.keys(value)) {
     if (!validKeys.has(key)) {
-      errors.push(`${path112} has unsupported key "${key}". Expected "main" or "sidebar".`);
+      errors.push(`${path113} has unsupported key "${key}". Expected "main" or "sidebar".`);
     }
   }
   const areas = [
@@ -1262,10 +1264,10 @@ function collectSlotLayoutErrors(value, path112, errors) {
   for (const [name, area] of areas) {
     if (area === void 0) continue;
     hasArea = true;
-    collectSlotAreaErrors(area, `${path112}.${name}`, errors);
+    collectSlotAreaErrors(area, `${path113}.${name}`, errors);
   }
   if (!hasArea) {
-    errors.push(`${path112} must define at least one of "main" or "sidebar".`);
+    errors.push(`${path113} must define at least one of "main" or "sidebar".`);
   }
 }
 
@@ -3707,7 +3709,7 @@ function buildEditsForSourceFile(sourceFile, filePath, plan) {
 }
 
 // core-engine/snapshots/ast-substitution/collect-preview-changes.ts
-function collectPreviewChanges(path112, beforeContent, afterContent) {
+function collectPreviewChanges(path113, beforeContent, afterContent) {
   const beforeLines = beforeContent.split("\n");
   const afterLines = afterContent.split("\n");
   const maxLength = Math.max(beforeLines.length, afterLines.length);
@@ -3719,7 +3721,7 @@ function collectPreviewChanges(path112, beforeContent, afterContent) {
       continue;
     }
     changes.push({
-      path: path112,
+      path: path113,
       line: index + 1,
       before: before.trim(),
       after: after.trim()
@@ -12350,9 +12352,9 @@ ${mappings}
 }
 
 // adapters/next/generators/actions/action-helpers/collect-read-select-fields.ts
-function collectReadSelectFields(fields, path112 = []) {
+function collectReadSelectFields(fields, path113 = []) {
   const matches = fields.flatMap((field) => {
-    const currentPath = [...path112, field.name];
+    const currentPath = [...path113, field.name];
     const matches2 = field.type === "select" ? [{ field, path: currentPath }] : [];
     if (field.fields) {
       matches2.push(...collectReadSelectFields(field.fields, currentPath));
@@ -17205,16 +17207,16 @@ function renderNestedFieldRenderer(request) {
 }
 
 // adapters/next/generators/form/field-jsx-nested/path-expression.ts
-function pathExpression(path112) {
-  return `\`${path112.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(".")}\``;
+function pathExpression(path113) {
+  return `\`${path113.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(".")}\``;
 }
 
 // adapters/next/generators/form/field-jsx-nested/path-name-prop.ts
-function pathNameProp(path112) {
-  if (path112.every((part) => typeof part === "string")) {
-    return `"${path112.map((part) => part).join(".")}"`;
+function pathNameProp(path113) {
+  if (path113.every((part) => typeof part === "string")) {
+    return `"${path113.map((part) => part).join(".")}"`;
   }
-  return `{${pathExpression(path112)}}`;
+  return `{${pathExpression(path113)}}`;
 }
 
 // adapters/next/templates/renderers/generators/form/field-jsx-nested/render-nested-object-list-field.ts
@@ -17272,17 +17274,17 @@ function renderNestedObjectListFieldRenderer(request) {
 function requiredLeafPaths(fields, prefix = []) {
   return fields.flatMap((field) => {
     if (field.hidden) return [];
-    const path112 = [...prefix, field.name];
+    const path113 = [...prefix, field.name];
     if ((field.type === "group" || field.type === "section") && field.fields?.length) {
-      return requiredLeafPaths(field.fields, path112);
+      return requiredLeafPaths(field.fields, path113);
     }
-    if (field.required) return [path112.join(".")];
+    if (field.required) return [path113.join(".")];
     return [];
   });
 }
 
 // adapters/next/generators/form/field-jsx-nested/render-nested-object-list-field.ts
-function renderNestedObjectListField(field, indent, label, path112, depth) {
+function renderNestedObjectListField(field, indent, label, path113, depth) {
   const singularLabel = singularize(label);
   const itemIndexVar = `${safeIdentifier(field.name, "nestedList")}Index${depth}`;
   const titlePath = findTitlePath(field.fields ?? []);
@@ -17292,7 +17294,7 @@ function renderNestedObjectListField(field, indent, label, path112, depth) {
     props: {
       indent,
       itemIndexVar,
-      pathString: path112.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join("."),
+      pathString: path113.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join("."),
       titlePathSuffix,
       singularLabel
     }
@@ -17301,7 +17303,7 @@ function renderNestedObjectListField(field, indent, label, path112, depth) {
     (child) => renderNestedField(
       child,
       `${indent}      `,
-      [...path112, { expression: itemIndexVar }, child.name],
+      [...path113, { expression: itemIndexVar }, child.name],
       depth + 1
     )
   ).filter(Boolean).join("\n");
@@ -17319,7 +17321,7 @@ ${indent}  validatePaths={${JSON.stringify(validatePaths)}}` : "";
     kind: "renderNestedObjectListFieldNestedObjectListFieldTemplate",
     props: {
       indent,
-      pathExpression: pathExpression(path112),
+      pathExpression: pathExpression(path113),
       stringify: JSON.stringify(label),
       stringifySerializedValue: JSON.stringify(singularLabel),
       defaultItem,
@@ -17358,10 +17360,10 @@ ${indent}/>`;
 }
 
 // adapters/next/generators/form/field-jsx-nested/render-text-input-field.ts
-function renderTextInputField(field, indent, label, nestedHint, path112) {
+function renderTextInputField(field, indent, label, nestedHint, path113) {
   return renderTextInputFieldFormFieldTemplate({
     indent,
-    pathNameProp: pathNameProp(path112),
+    pathNameProp: pathNameProp(path113),
     formItemProps: formItemProps(field),
     labelWithDescription: labelWithDescription(
       formLabel(field, label),
@@ -17373,11 +17375,11 @@ function renderTextInputField(field, indent, label, nestedHint, path112) {
 }
 
 // adapters/next/generators/form/field-jsx-nested/render-nested-field.ts
-function renderNestedField(field, indent, path112, depth) {
+function renderNestedField(field, indent, path113, depth) {
   const nestedLabel = field.label || field.name;
   const nestedHint = field.hint ? `<FormDescription>${field.hint}</FormDescription>` : "";
   if ((field.type === "group" || field.type === "section") && field.fields?.length) {
-    const groupFields = field.fields.map((child) => renderNestedField(child, `${indent}    `, [...path112, child.name], depth)).filter(Boolean).join("\n");
+    const groupFields = field.fields.map((child) => renderNestedField(child, `${indent}    `, [...path113, child.name], depth)).filter(Boolean).join("\n");
     if (!groupFields) return "";
     const heading = nestedLabel && nestedLabel !== field.name ? `${indent}<h3 className="text-base font-medium">${nestedLabel}</h3>
 ` : "";
@@ -17393,7 +17395,7 @@ function renderNestedField(field, indent, path112, depth) {
     });
   }
   if (field.type === "list" && field.fields?.length) {
-    return renderNestedObjectListField(field, indent, nestedLabel, path112, depth);
+    return renderNestedObjectListField(field, indent, nestedLabel, path113, depth);
   }
   if (field.type === "list") {
     const hideLabelProp = field.label ? "" : `
@@ -17404,7 +17406,7 @@ ${indent}  description={${JSON.stringify(field.hint)}}` : "";
       kind: "renderNestedFieldDynamicListFieldTemplate",
       props: {
         indent,
-        pathExpression: pathExpression(path112),
+        pathExpression: pathExpression(path113),
         nestedLabel,
         hideLabelProp,
         descriptionProp,
@@ -17418,7 +17420,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path112),
+        pathNameProp: pathNameProp(path113),
         formItemProps: formItemProps(field, "flex flex-row items-start space-x-3 space-y-0"),
         labelWithDescription: labelWithDescription(
           `<FormLabel>${nestedLabel}</FormLabel>`,
@@ -17434,7 +17436,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldDetailsTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path112),
+        pathNameProp: pathNameProp(path113),
         formItemProps: formItemProps(field),
         labelWithDescription: labelWithDescription(
           formLabel(field, nestedLabel),
@@ -17450,7 +17452,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldDetailsBranchTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path112),
+        pathNameProp: pathNameProp(path113),
         formItemProps: formItemProps(field),
         labelWithDescription: labelWithDescription(
           formLabel(field, nestedLabel),
@@ -17468,7 +17470,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldDetailsBranchBodyTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path112),
+        pathNameProp: pathNameProp(path113),
         formItemProps: formItemProps(field),
         labelWithDescription: labelWithDescription(
           formLabel(field, nestedLabel),
@@ -17481,13 +17483,13 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       }
     });
   }
-  return renderTextInputField(field, indent, nestedLabel, nestedHint, path112);
+  return renderTextInputField(field, indent, nestedLabel, nestedHint, path113);
 }
 
 // adapters/next/generators/form/field-jsx-nested/validation-trigger-expression.ts
 function validationTriggerExpression(basePath, requiredPaths) {
   if (requiredPaths.length === 0) return `\`${basePath}.\${expandedIndex}\` as never`;
-  const paths = requiredPaths.map((path112) => `\`${basePath}.\${expandedIndex}.${path112}\``).join(", ");
+  const paths = requiredPaths.map((path113) => `\`${basePath}.\${expandedIndex}.${path113}\``).join(", ");
   return `[${paths}] as never`;
 }
 
@@ -29263,8 +29265,8 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
 // adapters/next/commands/init/run-init-command-internal.ts
 import * as p61 from "@clack/prompts";
 import { execFileSync as execFileSync3 } from "child_process";
-import fs78 from "fs";
-import path91 from "path";
+import fs79 from "fs";
+import path92 from "path";
 
 // adapters/next/config/detect/detect-project.ts
 import fs52 from "fs";
@@ -33128,16 +33130,36 @@ function scaffoldOxfmt(cwd, linter, adminDir) {
   return { installed: true, skippedReason: null };
 }
 
+// adapters/next/init/scaffolders/proxy.ts
+import fs65 from "fs";
+import path78 from "path";
+function scaffoldProxy({ cwd, config }) {
+  const conventionDir = config.srcDir ? "src" : "";
+  for (const fileName of PROXY_CONVENTION_FILE_NAMES) {
+    const relPath2 = path78.join(conventionDir, fileName);
+    if (fs65.existsSync(path78.resolve(cwd, relPath2))) {
+      return { status: "existing", path: relPath2 };
+    }
+  }
+  const relPath = path78.join(conventionDir, PROXY_FILE_NAME);
+  const content = applyAdminNamespaceToContent(
+    readTemplate(PROXY_FILE_NAME),
+    config.frameworkConfig.next.namespace
+  );
+  safeWriteFile(path78.resolve(cwd, relPath), content);
+  return { status: "created", path: relPath };
+}
+
 // adapters/next/init/scaffolders/tailwind/scaffold-tailwind.ts
-import fs66 from "fs";
+import fs67 from "fs";
 
 // adapters/next/main-css.ts
-import fs65 from "fs";
-import path78 from "path";
+import fs66 from "fs";
+import path79 from "path";
 function findMainCss(cwd) {
   for (const candidate of MAIN_CSS_CANDIDATES) {
-    const filePath = path78.join(cwd, candidate);
-    if (fs65.existsSync(filePath)) return filePath;
+    const filePath = path79.join(cwd, candidate);
+    if (fs66.existsSync(filePath)) return filePath;
   }
   return void 0;
 }
@@ -33221,7 +33243,7 @@ function scaffoldTailwind(cwd, hasSrcDir, namespace = "admin") {
   if (!cssFile) {
     return { file: null, appended: false };
   }
-  let content = fs66.readFileSync(cssFile, "utf-8");
+  let content = fs67.readFileSync(cssFile, "utf-8");
   let changed = false;
   const sourceLines = getSourceLines(namespace, hasSrcDir);
   const missingLines = sourceLines.filter((sl) => !content.includes(sl));
@@ -33274,14 +33296,14 @@ ${renderAdminShadowInputUtility()}
     changed = true;
   }
   if (changed) {
-    fs66.writeFileSync(cssFile, content, "utf-8");
+    fs67.writeFileSync(cssFile, content, "utf-8");
   }
   return { file: cssFile, appended: changed };
 }
 
 // adapters/next/init/scaffolders/tsconfig/scaffold-tsconfig.ts
-import fs67 from "fs";
-import path79 from "path";
+import fs68 from "fs";
+import path80 from "path";
 
 // adapters/next/init/scaffolders/tsconfig/create-admin-path-aliases.ts
 function createAdminPathAliases(config) {
@@ -33305,14 +33327,14 @@ function createAdminPathAliases(config) {
 
 // adapters/next/init/scaffolders/tsconfig/scaffold-tsconfig.ts
 function scaffoldTsconfig(cwd, config) {
-  const tsconfigPath = path79.join(cwd, "tsconfig.json");
+  const tsconfigPath = path80.join(cwd, "tsconfig.json");
   const added = [];
   const skipped = [];
-  if (!fs67.existsSync(tsconfigPath)) {
+  if (!fs68.existsSync(tsconfigPath)) {
     skipped.push("tsconfig.json not found");
     return { added, skipped };
   }
-  const raw = fs67.readFileSync(tsconfigPath, "utf-8");
+  const raw = fs68.readFileSync(tsconfigPath, "utf-8");
   const stripped = toStrictJson(raw);
   let tsconfig;
   try {
@@ -33351,7 +33373,7 @@ function scaffoldTsconfig(cwd, config) {
   }
   compilerOptions.paths = paths;
   tsconfig.compilerOptions = compilerOptions;
-  fs67.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
+  fs68.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `, "utf-8");
   return { added, skipped };
 }
@@ -33596,25 +33618,25 @@ async function ensureVercelAuth(runner, cwd, options) {
 }
 
 // adapters/next/init/vercel/env-guard.ts
-import fs68 from "fs";
-import path80 from "path";
+import fs69 from "fs";
+import path81 from "path";
 function guardEnvLocal(cwd) {
-  const envPath = path80.join(cwd, ".env.local");
+  const envPath = path81.join(cwd, ".env.local");
   let original;
   try {
-    original = fs68.readFileSync(envPath, "utf-8");
+    original = fs69.readFileSync(envPath, "utf-8");
   } catch {
     original = void 0;
   }
   return {
     restore() {
       try {
-        const current = fs68.existsSync(envPath) ? fs68.readFileSync(envPath, "utf-8") : void 0;
+        const current = fs69.existsSync(envPath) ? fs69.readFileSync(envPath, "utf-8") : void 0;
         if (current === original) return;
         if (original === void 0) {
-          fs68.rmSync(envPath, { force: true });
+          fs69.rmSync(envPath, { force: true });
         } else {
-          fs68.writeFileSync(envPath, original);
+          fs69.writeFileSync(envPath, original);
         }
       } catch {
       }
@@ -33674,17 +33696,17 @@ function blobFailureMessage(reason) {
 import pc9 from "picocolors";
 
 // adapters/next/init/vercel/project/create-and-link-project.ts
-import fs70 from "fs";
-import path82 from "path";
+import fs71 from "fs";
+import path83 from "path";
 
 // adapters/next/init/vercel/project/read-linked-project-json.ts
-import fs69 from "fs";
-import path81 from "path";
+import fs70 from "fs";
+import path82 from "path";
 function readLinkedProjectJson(cwd) {
   try {
-    const projectJsonPath = path81.join(cwd, ".vercel", "project.json");
-    if (!fs69.existsSync(projectJsonPath)) return void 0;
-    return JSON.parse(fs69.readFileSync(projectJsonPath, "utf-8"));
+    const projectJsonPath = path82.join(cwd, ".vercel", "project.json");
+    if (!fs70.existsSync(projectJsonPath)) return void 0;
+    return JSON.parse(fs70.readFileSync(projectJsonPath, "utf-8"));
   } catch {
     return void 0;
   }
@@ -33755,7 +33777,7 @@ ${add.stderr}`)) continue;
     break;
   }
   try {
-    fs70.rmSync(path82.join(cwd, ".vercel", "project.json"), { force: true });
+    fs71.rmSync(path83.join(cwd, ".vercel", "project.json"), { force: true });
   } catch {
   }
   let link = await runVercel(
@@ -33872,12 +33894,12 @@ ${result.stderr}`
 }
 
 // adapters/next/init/vercel/env-pull.ts
-import fs71 from "fs";
+import fs72 from "fs";
 import os from "os";
-import path83 from "path";
+import path84 from "path";
 async function pullVercelEnvValue(runner, cwd, read, env, environment = "development") {
-  const tmpDir = fs71.mkdtempSync(path83.join(os.tmpdir(), "betterstart-vercel-"));
-  const tmpEnv = path83.join(tmpDir, ".env.pull");
+  const tmpDir = fs72.mkdtempSync(path84.join(os.tmpdir(), "betterstart-vercel-"));
+  const tmpEnv = path84.join(tmpDir, ".env.pull");
   try {
     const pull = await runVercel(
       runner,
@@ -33888,7 +33910,7 @@ async function pullVercelEnvValue(runner, cwd, read, env, environment = "develop
     return read(tmpEnv);
   } finally {
     try {
-      fs71.rmSync(tmpDir, { recursive: true, force: true });
+      fs72.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -34103,14 +34125,14 @@ ${deploy.stderr}`, DETAIL_MAX_LINES)
 }
 
 // adapters/next/init/vercel/deploy/ensure-vercel-json-framework.ts
-import fs72 from "fs";
-import path84 from "path";
+import fs73 from "fs";
+import path85 from "path";
 function ensureVercelJsonFramework(cwd) {
-  const vercelJsonPath = path84.join(cwd, "vercel.json");
-  if (fs72.existsSync(vercelJsonPath)) {
+  const vercelJsonPath = path85.join(cwd, "vercel.json");
+  if (fs73.existsSync(vercelJsonPath)) {
     return "exists";
   }
-  fs72.writeFileSync(
+  fs73.writeFileSync(
     vercelJsonPath,
     `${JSON.stringify({ $schema: "https://openapi.vercel.sh/vercel.json", framework: "nextjs" }, null, 2)}
 `,
@@ -34120,9 +34142,9 @@ function ensureVercelJsonFramework(cwd) {
 }
 
 // adapters/next/init/vercel/deploy/collect-deploy-env-vars.ts
-import path85 from "path";
+import path86 from "path";
 function collectDeployEnvVars(cwd, existingProductionKeys) {
-  const local = parseDotenvFile(path85.join(cwd, ".env.local"));
+  const local = parseDotenvFile(path86.join(cwd, ".env.local"));
   const vars = [];
   for (const [key, value] of local) {
     if (VERCEL_ENV_SYNC_SKIP_KEYS.has(key)) continue;
@@ -34520,8 +34542,8 @@ ${stderr}`;
 
 // adapters/next/commands/init/run-seed-script.ts
 import { spawn as spawn7 } from "child_process";
-import fs73 from "fs";
-import path86 from "path";
+import fs74 from "fs";
+import path87 from "path";
 
 // adapters/next/templates/renderers/commands/seed/build-seed-script.ts
 function renderBuildSeedScriptEnvFileTemplate({
@@ -34701,23 +34723,23 @@ function buildSeedScript(authBasePath = "/api/admin/auth") {
 
 // adapters/next/commands/init/run-seed-script.ts
 function runSeedScript(cwd, adminDir, authBasePath, envOverrides) {
-  const scriptsDir = path86.join(cwd, adminDir, "scripts");
-  const seedPath = path86.join(scriptsDir, "seed.ts");
-  if (!fs73.existsSync(scriptsDir)) {
-    fs73.mkdirSync(scriptsDir, { recursive: true });
+  const scriptsDir = path87.join(cwd, adminDir, "scripts");
+  const seedPath = path87.join(scriptsDir, "seed.ts");
+  if (!fs74.existsSync(scriptsDir)) {
+    fs74.mkdirSync(scriptsDir, { recursive: true });
   }
-  fs73.writeFileSync(seedPath, buildSeedScript(authBasePath), "utf-8");
+  fs74.writeFileSync(seedPath, buildSeedScript(authBasePath), "utf-8");
   const cleanup = () => {
     try {
-      fs73.unlinkSync(seedPath);
-      if (fs73.existsSync(scriptsDir) && fs73.readdirSync(scriptsDir).length === 0) {
-        fs73.rmdirSync(scriptsDir);
+      fs74.unlinkSync(seedPath);
+      if (fs74.existsSync(scriptsDir) && fs74.readdirSync(scriptsDir).length === 0) {
+        fs74.rmdirSync(scriptsDir);
       }
     } catch {
     }
   };
   return new Promise((resolve) => {
-    const tsxBin = path86.join(cwd, "node_modules", ".bin", "tsx");
+    const tsxBin = path87.join(cwd, "node_modules", ".bin", "tsx");
     const child = spawn7(tsxBin, [seedPath], {
       cwd,
       stdio: "pipe",
@@ -34787,12 +34809,12 @@ function formatAdminIdentity(admin) {
 }
 
 // adapters/next/commands/init/has-db-url.ts
-import fs74 from "fs";
-import path87 from "path";
+import fs75 from "fs";
+import path88 from "path";
 function hasDbUrl(cwd) {
-  const envPath = path87.join(cwd, ".env.local");
-  if (!fs74.existsSync(envPath)) return false;
-  const content = fs74.readFileSync(envPath, "utf-8");
+  const envPath = path88.join(cwd, ".env.local");
+  if (!fs75.existsSync(envPath)) return false;
+  const content = fs75.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
@@ -34854,8 +34876,8 @@ function readExistingDbUrl(cwd) {
 }
 
 // adapters/next/commands/init/remove-existing-admin-paths.ts
-import fs75 from "fs";
-import path88 from "path";
+import fs76 from "fs";
+import path89 from "path";
 
 // adapters/next/commands/init/normalize-namespace-for-removal.ts
 function normalizeNamespaceForRemoval(value) {
@@ -34883,16 +34905,16 @@ function removeExistingAdminPaths(cwd, namespaces) {
   const nukeFiles = [CONFIG_FILE_NAME, "ADMIN.md", "drizzle.config.ts"];
   let removed = 0;
   for (const dir of nukeDirs) {
-    const fullPath = path88.resolve(cwd, dir);
-    if (fs75.existsSync(fullPath)) {
-      fs75.rmSync(fullPath, { recursive: true, force: true });
+    const fullPath = path89.resolve(cwd, dir);
+    if (fs76.existsSync(fullPath)) {
+      fs76.rmSync(fullPath, { recursive: true, force: true });
       removed++;
     }
   }
   for (const file of nukeFiles) {
-    const fullPath = path88.resolve(cwd, file);
-    if (fs75.existsSync(fullPath)) {
-      fs75.unlinkSync(fullPath);
+    const fullPath = path89.resolve(cwd, file);
+    if (fs76.existsSync(fullPath)) {
+      fs76.unlinkSync(fullPath);
       removed++;
     }
   }
@@ -34930,12 +34952,12 @@ function renderInitBanner() {
 }
 
 // adapters/next/commands/init/resolve-force-init-namespaces.ts
-import fs77 from "fs";
-import path90 from "path";
+import fs78 from "fs";
+import path91 from "path";
 
 // adapters/next/commands/init/read-existing-config-namespace.ts
-import fs76 from "fs";
-import path89 from "path";
+import fs77 from "fs";
+import path90 from "path";
 
 // adapters/next/commands/init/read-namespace-from-config-source.ts
 function readNamespaceFromConfigSource(source) {
@@ -34945,11 +34967,11 @@ function readNamespaceFromConfigSource(source) {
 
 // adapters/next/commands/init/read-existing-config-namespace.ts
 async function readExistingConfigNamespace(cwd) {
-  const configPath = path89.resolve(cwd, CONFIG_FILE_NAME);
-  if (!fs76.existsSync(configPath)) {
+  const configPath = path90.resolve(cwd, CONFIG_FILE_NAME);
+  if (!fs77.existsSync(configPath)) {
     return;
   }
-  const sourceNamespace = readNamespaceFromConfigSource(fs76.readFileSync(configPath, "utf-8"));
+  const sourceNamespace = readNamespaceFromConfigSource(fs77.readFileSync(configPath, "utf-8"));
   if (sourceNamespace) {
     return sourceNamespace;
   }
@@ -34964,7 +34986,7 @@ async function readExistingConfigNamespace(cwd) {
 // adapters/next/commands/init/resolve-force-init-namespaces.ts
 async function resolveForceInitNamespaces(cwd, targetNamespace) {
   const namespaces = /* @__PURE__ */ new Set([validateAdminNamespace(targetNamespace)]);
-  const hasConfig = fs77.existsSync(path90.resolve(cwd, CONFIG_FILE_NAME));
+  const hasConfig = fs78.existsSync(path91.resolve(cwd, CONFIG_FILE_NAME));
   const existingNamespace = await readExistingConfigNamespace(cwd);
   if (existingNamespace) {
     namespaces.add(existingNamespace);
@@ -35255,7 +35277,7 @@ async function runInitCommandInternal(name, options, jsonContext) {
     exitInit("validation", message, "INVALID_OPTIONS");
   }
   let cwd = process.cwd();
-  let projectName = path91.basename(cwd);
+  let projectName = path92.basename(cwd);
   let forceMode = Boolean(options.force);
   let namespace = DEFAULT_ADMIN_NAMESPACE;
   if (options.namespace) {
@@ -35364,7 +35386,7 @@ async function runInitCommandInternal(name, options, jsonContext) {
       }
       pm = pmChoice;
     }
-    const displayName = freshProject.projectName === "." ? path91.basename(cwd) : freshProject.projectName;
+    const displayName = freshProject.projectName === "." ? path92.basename(cwd) : freshProject.projectName;
     projectName = displayName;
     const { bin, prefix } = createNextAppCommand();
     const cnaArgs = [
@@ -35402,10 +35424,10 @@ async function runInitCommandInternal(name, options, jsonContext) {
       );
       exitInit("project", createNextAppResult.error, "CREATE_NEXT_APP_FAILED");
     }
-    cwd = path91.resolve(cwd, freshProject.projectName);
-    const hasPackageJson = fs78.existsSync(path91.join(cwd, "package.json"));
+    cwd = path92.resolve(cwd, freshProject.projectName);
+    const hasPackageJson = fs79.existsSync(path92.join(cwd, "package.json"));
     const hasNextConfig = ["next.config.ts", "next.config.js", "next.config.mjs"].some(
-      (f) => fs78.existsSync(path91.join(cwd, f))
+      (f) => fs79.existsSync(path92.join(cwd, f))
     );
     if (!hasPackageJson || !hasNextConfig) {
       createNextAppSpinner.stop(`Failed to create Next.js app: ${displayName}`);
@@ -35730,6 +35752,8 @@ async function runInitCommandInternal(name, options, jsonContext) {
   scaffoldLayout({ cwd, config });
   s.message("API routes");
   scaffoldApiRoutes({ cwd, config });
+  s.message("Route protection");
+  const proxyResult = scaffoldProxy({ cwd, config });
   s.message("Linter");
   if (project2.linter.type === "none") {
     scaffoldOxfmt(cwd, project2.linter, config.paths.admin);
@@ -35740,11 +35764,16 @@ async function runInitCommandInternal(name, options, jsonContext) {
   if (nextConfigResult.status === "unsupported") {
     p61.log.warn("The Next.js config could not be updated automatically \u2014 review it manually.");
   }
-  const drizzleConfigPath = path91.join(cwd, "drizzle.config.ts");
-  if (!dbFiles.includes("drizzle.config.ts") && fs78.existsSync(drizzleConfigPath)) {
+  if (proxyResult.status === "existing") {
+    p61.log.warn(
+      `Existing ${proxyResult.path} left in place \u2014 add the admin session-cookie redirect to it so logged-out visitors never render the admin routes.`
+    );
+  }
+  const drizzleConfigPath = path92.join(cwd, "drizzle.config.ts");
+  if (!dbFiles.includes("drizzle.config.ts") && fs79.existsSync(drizzleConfigPath)) {
     if (forceMode) {
-      const { readNamespacedTemplate } = await import("./read-namespaced-template-TSATYQPP.js");
-      fs78.writeFileSync(
+      const { readNamespacedTemplate } = await import("./read-namespaced-template-D2CD4Q7U.js");
+      fs79.writeFileSync(
         drizzleConfigPath,
         readNamespacedTemplate("drizzle.config.ts", namespace),
         "utf-8"
@@ -35756,8 +35785,8 @@ async function runInitCommandInternal(name, options, jsonContext) {
         initialValue: true
       });
       if (!p61.isCancel(overwrite) && overwrite) {
-        const { readNamespacedTemplate } = await import("./read-namespaced-template-TSATYQPP.js");
-        fs78.writeFileSync(
+        const { readNamespacedTemplate } = await import("./read-namespaced-template-D2CD4Q7U.js");
+        fs79.writeFileSync(
           drizzleConfigPath,
           readNamespacedTemplate("drizzle.config.ts", namespace),
           "utf-8"
@@ -36174,7 +36203,7 @@ async function runInitCommand(name, options) {
 
 // adapters/next/commands/list-integrations.ts
 import * as p62 from "@clack/prompts";
-import path92 from "path";
+import path93 from "path";
 
 // adapters/next/integration-runtime/list-available-integrations.ts
 function listAvailableIntegrations() {
@@ -36183,7 +36212,7 @@ function listAvailableIntegrations() {
 
 // adapters/next/commands/list-integrations.ts
 async function runListIntegrationsCommand(options) {
-  const cwd = options.cwd ? path92.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path93.resolve(options.cwd) : process.cwd();
   if (options.json) {
     let installed2;
     try {
@@ -36219,7 +36248,7 @@ async function runListIntegrationsCommand(options) {
 
 // adapters/next/commands/list-presets.ts
 import * as p63 from "@clack/prompts";
-import path93 from "path";
+import path94 from "path";
 
 // adapters/next/preset-runtime/list-available-presets.ts
 function listAvailablePresets() {
@@ -36228,7 +36257,7 @@ function listAvailablePresets() {
 
 // adapters/next/commands/list-presets.ts
 async function runListPresetsCommand(options) {
-  const cwd = options.cwd ? path93.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path94.resolve(options.cwd) : process.cwd();
   if (options.json) {
     let installed2;
     try {
@@ -36261,13 +36290,13 @@ async function runListPresetsCommand(options) {
 }
 
 // adapters/next/commands/update-component/get-static-asset-component-entries.ts
-import fs79 from "fs";
-import path94 from "path";
+import fs80 from "fs";
+import path95 from "path";
 function getStaticAssetComponentEntries(assetDirectory) {
   const assetDir = resolveCliAssetPath("shared-assets", "react-admin", assetDirectory);
-  if (!fs79.existsSync(assetDir)) return [];
+  if (!fs80.existsSync(assetDir)) return [];
   const components = [];
-  for (const entry of fs79.readdirSync(assetDir, { withFileTypes: true })) {
+  for (const entry of fs80.readdirSync(assetDir, { withFileTypes: true })) {
     if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
       components.push({
         name: entry.name.replace(/\.(tsx|ts)$/, ""),
@@ -36279,12 +36308,12 @@ function getStaticAssetComponentEntries(assetDirectory) {
       continue;
     }
     const indexFile = ["index.tsx", "index.ts"].find(
-      (file) => fs79.existsSync(path94.join(assetDir, entry.name, file))
+      (file) => fs80.existsSync(path95.join(assetDir, entry.name, file))
     );
     if (indexFile) {
       components.push({
         name: entry.name,
-        file: path94.join(entry.name, indexFile)
+        file: path95.join(entry.name, indexFile)
       });
     }
   }
@@ -37987,6 +38016,12 @@ var TEMPLATE_REGISTRY = {
     base: "cwd",
     dependencies: ["admin-sidebar", "auth-session"]
   },
+  proxy: {
+    relPath: ({ config }) => config.srcDir ? "src/proxy.ts" : "proxy.ts",
+    displayPath: "proxy.ts",
+    content: () => readTemplate("proxy.ts"),
+    base: "cwd"
+  },
   "account-layout": {
     relPath: "app/(admin)/admin/(account)/layout.tsx",
     content: () => readTemplate("pages/account-layout.tsx"),
@@ -39032,28 +39067,28 @@ async function listInstallableChoices(cwd) {
 }
 
 // adapters/next/commands/menu-choices/list-schema-choices.ts
-import path95 from "path";
+import path96 from "path";
 async function listSchemaChoices(cwd) {
   const config = await resolveConfigOrExit(cwd);
   const paths = resolveProjectPaths(config);
-  return listSchemaNames(path95.join(cwd, ...paths.schemasDir.split("/")));
+  return listSchemaNames(path96.join(cwd, ...paths.schemasDir.split("/")));
 }
 
 // adapters/next/commands/remove-schema/run-remove-schema-command.ts
 import * as clack2 from "@clack/prompts";
-import path96 from "path";
+import path97 from "path";
 
 // core-engine/snapshots/store/delete-snapshot.ts
-import fs80 from "fs";
+import fs81 from "fs";
 function deleteSnapshot(cwd, scope) {
-  fs80.rmSync(scopeDir(cwd, scope), { recursive: true, force: true });
+  fs81.rmSync(scopeDir(cwd, scope), { recursive: true, force: true });
 }
 
 // core-engine/snapshots/store/write-tombstone.ts
-import fs81 from "fs";
+import fs82 from "fs";
 function writeTombstone(cwd, scope) {
-  fs81.mkdirSync(removedDir(cwd), { recursive: true });
-  fs81.writeFileSync(tombstonePath(cwd, scope), "", "utf-8");
+  fs82.mkdirSync(removedDir(cwd), { recursive: true });
+  fs82.writeFileSync(tombstonePath(cwd, scope), "", "utf-8");
 }
 
 // adapters/next/commands/remove-schema/cleanup-schema-empty-dirs.ts
@@ -39081,7 +39116,7 @@ function resolveSchemaOwnerForRemoval(cwd, schemaName) {
 // adapters/next/commands/remove-schema/run-remove-schema-command.ts
 async function runRemoveSchemaCommand(schemaName, options) {
   const owner = resolveSchemaOwnerForRemoval(
-    options.cwd ? path96.resolve(options.cwd) : process.cwd(),
+    options.cwd ? path97.resolve(options.cwd) : process.cwd(),
     schemaName
   );
   if (owner === "core") {
@@ -39094,7 +39129,7 @@ async function runRemoveSchemaCommand(schemaName, options) {
     clack2.log.error(`"${schemaName}" is owned by ${owner}. Remove the owning preset instead.`);
     process.exit(1);
   }
-  const cwd = options.cwd ? path96.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path97.resolve(options.cwd) : process.cwd();
   const config = await resolveConfigOrExit(cwd);
   const paths = resolveProjectPaths(config);
   const manifest = loadManifest(cwd, schemaName);
@@ -39130,7 +39165,7 @@ async function runRemoveSchemaCommand(schemaName, options) {
   }
   const loaded = (() => {
     try {
-      return loadSchema(path96.join(cwd, ...paths.schemasDir.split("/")), schemaName);
+      return loadSchema(path97.join(cwd, ...paths.schemasDir.split("/")), schemaName);
     } catch {
       return null;
     }
@@ -39175,7 +39210,7 @@ Schema JSON preserved.`
 
 // adapters/next/commands/remove.ts
 import * as p64 from "@clack/prompts";
-import path100 from "path";
+import path101 from "path";
 
 // adapters/next/init/scaffolders/dependencies/build-remove-args.ts
 function buildRemoveArgs(pm, deps, dev) {
@@ -39219,11 +39254,11 @@ async function removeDependenciesAsync({
 }
 
 // adapters/next/integration-runtime/find-blocking-integration-dependencies.ts
-import path98 from "path";
+import path99 from "path";
 
 // adapters/next/integration-runtime/schema-manifest-contains-mailchimp-imports.ts
-import fs82 from "fs";
-import path97 from "path";
+import fs83 from "fs";
+import path98 from "path";
 function schemaManifestContainsMailchimpImports(cwd, config, schemaName) {
   const manifest = loadManifest(cwd, schemaName);
   if (!manifest) {
@@ -39240,11 +39275,11 @@ function schemaManifestContainsMailchimpImports(cwd, config, schemaName) {
     ...manifest.skipped
   ]);
   return liveManifestPaths.some((filePath) => {
-    const fullPath = path97.join(cwd, ...filePath.split("/"));
-    if (!fs82.existsSync(fullPath) || !fs82.statSync(fullPath).isFile()) {
+    const fullPath = path98.join(cwd, ...filePath.split("/"));
+    if (!fs83.existsSync(fullPath) || !fs83.statSync(fullPath).isFile()) {
       return false;
     }
-    const content = fs82.readFileSync(fullPath, "utf-8");
+    const content = fs83.readFileSync(fullPath, "utf-8");
     return markers.some((marker) => content.includes(marker));
   });
 }
@@ -39253,7 +39288,7 @@ function schemaManifestContainsMailchimpImports(cwd, config, schemaName) {
 function findBlockingIntegrationDependencies(cwd, config, integrationId) {
   const blockers = [];
   const paths = resolveProjectPaths(config);
-  const schemasDir = path98.join(cwd, ...paths.schemasDir.split("/"));
+  const schemasDir = path99.join(cwd, ...paths.schemasDir.split("/"));
   const ownership = loadSchemaOwnershipIndex(cwd);
   for (const schemaName of listSchemaNames(schemasDir)) {
     if (ownership.schemas[schemaName] !== "user") {
@@ -39276,12 +39311,12 @@ function findBlockingIntegrationDependencies(cwd, config, integrationId) {
 }
 
 // adapters/next/integration-runtime/remove-email-templates-dir-if-empty.ts
-import fs83 from "fs";
+import fs84 from "fs";
 function removeEmailTemplatesDirIfEmpty(cwd, config) {
   const dir = getEmailTemplatesDir(cwd, config);
-  if (!fs83.existsSync(dir)) return;
-  if (fs83.readdirSync(dir).length === 0) {
-    fs83.rmdirSync(dir);
+  if (!fs84.existsSync(dir)) return;
+  if (fs84.readdirSync(dir).length === 0) {
+    fs84.rmdirSync(dir);
   }
 }
 
@@ -39446,8 +39481,8 @@ function findBlockingSchemaDependencies(cwd, config, ownedSchemas) {
 }
 
 // adapters/next/preset-runtime/remove-preset-schemas.ts
-import fs84 from "fs";
-import path99 from "path";
+import fs85 from "fs";
+import path100 from "path";
 
 // preset-engine/ownership/remove-schema-owner.ts
 function removeSchemaOwner(cwd, schemaName) {
@@ -39488,8 +39523,8 @@ function removePresetSchemas(cwd, config, manifest) {
       }
       deleteSnapshot(cwd, schemaName);
     }
-    const schemaPath = path99.posix.join(paths.schemasDir, `${schemaName}.json`);
-    const formsSchemaPath = path99.posix.join(paths.schemasDir, "forms", `${schemaName}.json`);
+    const schemaPath = path100.posix.join(paths.schemasDir, `${schemaName}.json`);
+    const formsSchemaPath = path100.posix.join(paths.schemasDir, "forms", `${schemaName}.json`);
     if (removePath(cwd, schemaPath)) {
       deletedPaths.push(schemaPath);
     }
@@ -39497,7 +39532,7 @@ function removePresetSchemas(cwd, config, manifest) {
       deletedPaths.push(formsSchemaPath);
     }
     if (hasTombstone(cwd, schemaName)) {
-      fs84.rmSync(betterstartDir(cwd, "snapshots", "_removed", schemaName), {
+      fs85.rmSync(betterstartDir(cwd, "snapshots", "_removed", schemaName), {
         force: true
       });
     }
@@ -39621,7 +39656,7 @@ async function runRemoveCommand(items, options) {
     );
     process.exit(1);
   }
-  const cwd = options.cwd ? path100.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path101.resolve(options.cwd) : process.cwd();
   const config = await resolveConfigOrExit(cwd);
   const pm = detectPackageManager(cwd);
   if (!options.force) {
@@ -39673,10 +39708,10 @@ async function runRemoveCommand(items, options) {
 
 // adapters/next/commands/seed/run-seed-command.ts
 import * as clack3 from "@clack/prompts";
-import fs85 from "fs";
-import path101 from "path";
+import fs86 from "fs";
+import path102 from "path";
 async function runSeedCommand(options) {
-  const cwd = options.cwd ? path101.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path102.resolve(options.cwd) : process.cwd();
   clack3.intro("BetterStart Seed");
   let config;
   try {
@@ -39752,15 +39787,15 @@ async function runSeedCommand(options) {
     }
     name = nameInput;
   }
-  const scriptsDir = path101.join(cwd, adminDir, "scripts");
-  const seedPath = path101.join(scriptsDir, "seed.ts");
-  if (!fs85.existsSync(scriptsDir)) {
-    fs85.mkdirSync(scriptsDir, { recursive: true });
+  const scriptsDir = path102.join(cwd, adminDir, "scripts");
+  const seedPath = path102.join(scriptsDir, "seed.ts");
+  if (!fs86.existsSync(scriptsDir)) {
+    fs86.mkdirSync(scriptsDir, { recursive: true });
   }
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
-  fs85.writeFileSync(seedPath, buildSeedScript(`${namespace.apiPath}/auth`), "utf-8");
+  fs86.writeFileSync(seedPath, buildSeedScript(`${namespace.apiPath}/auth`), "utf-8");
   const { execFile: execFile2 } = await import("child_process");
-  const tsxBin = path101.join(cwd, "node_modules", ".bin", "tsx");
+  const tsxBin = path102.join(cwd, "node_modules", ".bin", "tsx");
   const runSeed2 = (overwrite) => new Promise((resolve, reject) => {
     execFile2(
       tsxBin,
@@ -39798,7 +39833,7 @@ async function runSeedCommand(options) {
           `An admin account (${existingName}) already exists for ${email}. Replacing it needs a terminal.`
         );
         try {
-          fs85.unlinkSync(seedPath);
+          fs86.unlinkSync(seedPath);
         } catch {
         }
         process.exit(1);
@@ -39809,7 +39844,7 @@ async function runSeedCommand(options) {
       if (clack3.isCancel(overwrite) || !overwrite) {
         clack3.cancel("Seed cancelled.");
         try {
-          fs85.unlinkSync(seedPath);
+          fs86.unlinkSync(seedPath);
         } catch {
         }
         return;
@@ -39826,15 +39861,15 @@ async function runSeedCommand(options) {
     clack3.log.error(errMsg);
     clack3.log.info("You can run the seed script manually:");
     clack3.log.info(
-      `  SEED_EMAIL="${email}" SEED_PASSWORD="..." npx tsx ${path101.relative(cwd, seedPath)}`
+      `  SEED_EMAIL="${email}" SEED_PASSWORD="..." npx tsx ${path102.relative(cwd, seedPath)}`
     );
     clack3.outro("");
     process.exit(1);
   }
   try {
-    fs85.unlinkSync(seedPath);
-    if (fs85.existsSync(scriptsDir) && fs85.readdirSync(scriptsDir).length === 0) {
-      fs85.rmdirSync(scriptsDir);
+    fs86.unlinkSync(seedPath);
+    if (fs86.existsSync(scriptsDir) && fs86.readdirSync(scriptsDir).length === 0) {
+      fs86.rmdirSync(scriptsDir);
     }
   } catch {
   }
@@ -39843,18 +39878,18 @@ async function runSeedCommand(options) {
 
 // adapters/next/commands/uninstall/run-uninstall-command.ts
 import * as p65 from "@clack/prompts";
-import path103 from "path";
+import path104 from "path";
 import pc19 from "picocolors";
 
 // adapters/next/commands/uninstall/build-uninstall-plan.ts
-import fs90 from "fs";
-import path102 from "path";
+import fs91 from "fs";
+import path103 from "path";
 
 // adapters/next/commands/uninstall-cleaners/clean-css.ts
-import fs86 from "fs";
+import fs87 from "fs";
 function cleanCss(cssPath, namespace = "admin") {
-  if (!fs86.existsSync(cssPath)) return [];
-  const content = fs86.readFileSync(cssPath, "utf-8");
+  if (!fs87.existsSync(cssPath)) return [];
+  const content = fs87.readFileSync(cssPath, "utf-8");
   const lines = content.split("\n");
   const sourcePattern = new RegExp(`^@source\\s+"[^"]*(?:admin|${namespace})[^"]*";\\s*$`);
   const removed = [];
@@ -39868,15 +39903,15 @@ function cleanCss(cssPath, namespace = "admin") {
   }
   if (removed.length === 0) return [];
   const cleaned = kept.join("\n").replace(/\n{3,}/g, "\n\n");
-  fs86.writeFileSync(cssPath, cleaned, "utf-8");
+  fs87.writeFileSync(cssPath, cleaned, "utf-8");
   return removed;
 }
 
 // adapters/next/commands/uninstall-cleaners/clean-env-file.ts
-import fs87 from "fs";
+import fs88 from "fs";
 function cleanEnvFile(envPath) {
-  if (!fs87.existsSync(envPath)) return [];
-  const content = fs87.readFileSync(envPath, "utf-8");
+  if (!fs88.existsSync(envPath)) return [];
+  const content = fs88.readFileSync(envPath, "utf-8");
   const lines = content.split("\n");
   const removed = [];
   const kept = [];
@@ -39909,19 +39944,19 @@ function cleanEnvFile(envPath) {
   if (removed.length === 0) return [];
   const result = kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
   if (result === "") {
-    fs87.unlinkSync(envPath);
+    fs88.unlinkSync(envPath);
   } else {
-    fs87.writeFileSync(envPath, `${result}
+    fs88.writeFileSync(envPath, `${result}
 `, "utf-8");
   }
   return removed;
 }
 
 // adapters/next/commands/uninstall-cleaners/clean-tsconfig.ts
-import fs88 from "fs";
+import fs89 from "fs";
 function cleanTsconfig(tsconfigPath, aliasRoot = "@admin") {
-  if (!fs88.existsSync(tsconfigPath)) return [];
-  const raw = fs88.readFileSync(tsconfigPath, "utf-8");
+  if (!fs89.existsSync(tsconfigPath)) return [];
+  const raw = fs89.readFileSync(tsconfigPath, "utf-8");
   const stripped = toStrictJson(raw);
   let tsconfig;
   try {
@@ -39945,17 +39980,17 @@ function cleanTsconfig(tsconfigPath, aliasRoot = "@admin") {
     compilerOptions.paths = paths;
   }
   tsconfig.compilerOptions = compilerOptions;
-  fs88.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
+  fs89.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `, "utf-8");
   return removed;
 }
 
 // adapters/next/commands/uninstall/is-cli-created-oxc-config.ts
-import fs89 from "fs";
+import fs90 from "fs";
 function isCLICreatedOxcConfig(configPath) {
-  if (!fs89.existsSync(configPath)) return false;
+  if (!fs90.existsSync(configPath)) return false;
   try {
-    const content = JSON.parse(fs89.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs90.readFileSync(configPath, "utf-8"));
     return typeof content.$schema === "string" && content.$schema.includes("node_modules/ox") && Array.isArray(content.ignorePatterns) && content.ignorePatterns.includes("**/.betterstart/snapshots/**/files/**");
   } catch {
     return false;
@@ -39966,17 +40001,17 @@ function isCLICreatedOxcConfig(configPath) {
 function buildUninstallPlan(cwd, namespaceValue) {
   const steps = [];
   const namespace = resolveAdminNamespace(namespaceValue);
-  const hasSrc = fs90.existsSync(path102.join(cwd, "src"));
+  const hasSrc = fs91.existsSync(path103.join(cwd, "src"));
   const appBase = hasSrc ? "src/app" : "app";
   const dirs = [];
-  const adminDir = path102.join(cwd, namespace.segment);
-  const legacyAdminDir = path102.join(cwd, "admin");
-  const adminRouteGroup = path102.join(cwd, appBase, namespace.routeGroup);
-  const legacyAdminRouteGroup = path102.join(cwd, appBase, "(admin)");
-  if (fs90.existsSync(adminDir)) dirs.push(`${namespace.segment}/`);
-  if (namespace.segment !== "admin" && fs90.existsSync(legacyAdminDir)) dirs.push("admin/");
-  if (fs90.existsSync(adminRouteGroup)) dirs.push(`${appBase}/${namespace.routeGroup}/`);
-  if (namespace.segment !== "admin" && fs90.existsSync(legacyAdminRouteGroup))
+  const adminDir = path103.join(cwd, namespace.segment);
+  const legacyAdminDir = path103.join(cwd, "admin");
+  const adminRouteGroup = path103.join(cwd, appBase, namespace.routeGroup);
+  const legacyAdminRouteGroup = path103.join(cwd, appBase, "(admin)");
+  if (fs91.existsSync(adminDir)) dirs.push(`${namespace.segment}/`);
+  if (namespace.segment !== "admin" && fs91.existsSync(legacyAdminDir)) dirs.push("admin/");
+  if (fs91.existsSync(adminRouteGroup)) dirs.push(`${appBase}/${namespace.routeGroup}/`);
+  if (namespace.segment !== "admin" && fs91.existsSync(legacyAdminRouteGroup))
     dirs.push(`${appBase}/(admin)/`);
   if (dirs.length > 0) {
     steps.push({
@@ -39985,14 +40020,14 @@ function buildUninstallPlan(cwd, namespaceValue) {
       count: dirs.length,
       unit: dirs.length === 1 ? "directory" : "directories",
       execute() {
-        if (fs90.existsSync(adminDir)) fs90.rmSync(adminDir, { recursive: true, force: true });
-        if (fs90.existsSync(legacyAdminDir))
-          fs90.rmSync(legacyAdminDir, { recursive: true, force: true });
-        if (fs90.existsSync(adminRouteGroup)) {
-          fs90.rmSync(adminRouteGroup, { recursive: true, force: true });
+        if (fs91.existsSync(adminDir)) fs91.rmSync(adminDir, { recursive: true, force: true });
+        if (fs91.existsSync(legacyAdminDir))
+          fs91.rmSync(legacyAdminDir, { recursive: true, force: true });
+        if (fs91.existsSync(adminRouteGroup)) {
+          fs91.rmSync(adminRouteGroup, { recursive: true, force: true });
         }
-        if (fs90.existsSync(legacyAdminRouteGroup)) {
-          fs90.rmSync(legacyAdminRouteGroup, { recursive: true, force: true });
+        if (fs91.existsSync(legacyAdminRouteGroup)) {
+          fs91.rmSync(legacyAdminRouteGroup, { recursive: true, force: true });
         }
       }
     });
@@ -40000,18 +40035,18 @@ function buildUninstallPlan(cwd, namespaceValue) {
   const configFiles = [];
   const configPaths = [];
   const candidates = [
-    [CONFIG_FILE_NAME, path102.join(cwd, CONFIG_FILE_NAME)],
-    ["drizzle.config.ts", path102.join(cwd, "drizzle.config.ts")],
-    ["ADMIN.md", path102.join(cwd, "ADMIN.md")]
+    [CONFIG_FILE_NAME, path103.join(cwd, CONFIG_FILE_NAME)],
+    ["drizzle.config.ts", path103.join(cwd, "drizzle.config.ts")],
+    ["ADMIN.md", path103.join(cwd, "ADMIN.md")]
   ];
   for (const [label, fullPath] of candidates) {
-    if (fs90.existsSync(fullPath)) {
+    if (fs91.existsSync(fullPath)) {
       configFiles.push(label);
       configPaths.push(fullPath);
     }
   }
   for (const fileName of [".oxfmtrc.json", ".oxlintrc.json"]) {
-    const configPath = path102.join(cwd, fileName);
+    const configPath = path103.join(cwd, fileName);
     if (isCLICreatedOxcConfig(configPath)) {
       configFiles.push(`${fileName} (CLI-created)`);
       configPaths.push(configPath);
@@ -40025,14 +40060,14 @@ function buildUninstallPlan(cwd, namespaceValue) {
       unit: configFiles.length === 1 ? "file" : "files",
       execute() {
         for (const p67 of configPaths) {
-          if (fs90.existsSync(p67)) fs90.unlinkSync(p67);
+          if (fs91.existsSync(p67)) fs91.unlinkSync(p67);
         }
       }
     });
   }
-  const tsconfigPath = path102.join(cwd, "tsconfig.json");
-  if (fs90.existsSync(tsconfigPath)) {
-    const content = fs90.readFileSync(tsconfigPath, "utf-8");
+  const tsconfigPath = path103.join(cwd, "tsconfig.json");
+  if (fs91.existsSync(tsconfigPath)) {
+    const content = fs91.readFileSync(tsconfigPath, "utf-8");
     const aliasMatches = [
       ...content.match(/"@admin\//g) ?? [],
       ...content.match(new RegExp(`"${namespace.alias}/`, "g")) ?? []
@@ -40052,12 +40087,12 @@ function buildUninstallPlan(cwd, namespaceValue) {
   }
   const cssFile = findMainCss(cwd);
   if (cssFile) {
-    const cssContent = fs90.readFileSync(cssFile, "utf-8");
+    const cssContent = fs91.readFileSync(cssFile, "utf-8");
     const sourceLines = cssContent.split("\n").filter(
       (l) => new RegExp(`^@source\\s+"[^"]*(?:admin|${namespace.segment})[^"]*";\\s*$`).test(l)
     );
     if (sourceLines.length > 0) {
-      const relCss = path102.relative(cwd, cssFile);
+      const relCss = path103.relative(cwd, cssFile);
       steps.push({
         label: `CSS @source lines (${relCss})`,
         items: [`@source lines in ${relCss}`],
@@ -40069,9 +40104,9 @@ function buildUninstallPlan(cwd, namespaceValue) {
       });
     }
   }
-  const envPath = path102.join(cwd, ".env.local");
-  if (fs90.existsSync(envPath)) {
-    const envContent = fs90.readFileSync(envPath, "utf-8");
+  const envPath = path103.join(cwd, ".env.local");
+  if (fs91.existsSync(envPath)) {
+    const envContent = fs91.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({
@@ -40090,7 +40125,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
 
 // adapters/next/commands/uninstall/run-uninstall-command.ts
 async function runUninstallCommand(options) {
-  const cwd = options.cwd ? path103.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path104.resolve(options.cwd) : process.cwd();
   p65.intro(pc19.bgRed(pc19.white(" BetterStart Uninstall ")));
   let namespace = DEFAULT_ADMIN_NAMESPACE;
   try {
@@ -40134,8 +40169,8 @@ async function runUninstallCommand(options) {
 
 // adapters/next/commands/update-component/run-update-command.ts
 import * as clack8 from "@clack/prompts";
-import fs96 from "fs";
-import path109 from "path";
+import fs97 from "fs";
+import path110 from "path";
 
 // adapters/next/integration-runtime/sync-installed-integration-manifests.ts
 function syncInstalledIntegrationManifests(cwd, config) {
@@ -40165,63 +40200,63 @@ function applyNamespaceToTemplateEntry(entry, config, cwd) {
 }
 
 // adapters/next/commands/update-component/copy-namespaced-directory.ts
-import fs92 from "fs";
-import path104 from "path";
+import fs93 from "fs";
+import path105 from "path";
 import fsExtra from "fs-extra";
 
 // adapters/next/commands/update-component/write-namespaced-file.ts
-import fs91 from "fs";
+import fs92 from "fs";
 function writeNamespacedFile(srcPath, destPath, namespace) {
-  fs91.writeFileSync(
+  fs92.writeFileSync(
     destPath,
-    applyAdminNamespaceToContent(fs91.readFileSync(srcPath, "utf-8"), namespace),
+    applyAdminNamespaceToContent(fs92.readFileSync(srcPath, "utf-8"), namespace),
     "utf-8"
   );
 }
 
 // adapters/next/commands/update-component/copy-namespaced-directory.ts
 function copyNamespacedDirectory(srcDir, destDir, namespace) {
-  const entries = fs92.readdirSync(srcDir, { withFileTypes: true });
+  const entries = fs93.readdirSync(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const namespacedName = applyAdminNamespaceToPath(entry.name, namespace);
-    const srcPath = path104.join(srcDir, entry.name);
-    const destPath = path104.join(destDir, namespacedName);
+    const srcPath = path105.join(srcDir, entry.name);
+    const destPath = path105.join(destDir, namespacedName);
     if (entry.isDirectory()) {
       fsExtra.ensureDirSync(destPath);
       copyNamespacedDirectory(srcPath, destPath, namespace);
       continue;
     }
-    fsExtra.ensureDirSync(path104.dirname(destPath));
+    fsExtra.ensureDirSync(path105.dirname(destPath));
     writeNamespacedFile(srcPath, destPath, namespace);
   }
 }
 
 // adapters/next/commands/update-component/find-static-asset-file.ts
-import fs93 from "fs";
-import path105 from "path";
+import fs94 from "fs";
+import path106 from "path";
 function findStaticAssetFile(assetDir, componentName) {
-  if (!fs93.existsSync(assetDir)) return void 0;
+  if (!fs94.existsSync(assetDir)) return void 0;
   const isNestedComponentName = /[\\/]/.test(componentName);
-  const nestedComponentName = componentName.split(/[\\/]/).filter(Boolean).join(path105.sep);
-  if (isNestedComponentName && nestedComponentName && !path105.isAbsolute(componentName) && !nestedComponentName.split(path105.sep).includes("..")) {
+  const nestedComponentName = componentName.split(/[\\/]/).filter(Boolean).join(path106.sep);
+  if (isNestedComponentName && nestedComponentName && !path106.isAbsolute(componentName) && !nestedComponentName.split(path106.sep).includes("..")) {
     for (const extension of [".tsx", ".ts"]) {
       const relPath = `${nestedComponentName}${extension}`;
-      const filePath = path105.join(assetDir, relPath);
-      if (fs93.existsSync(filePath) && fs93.statSync(filePath).isFile()) {
+      const filePath = path106.join(assetDir, relPath);
+      if (fs94.existsSync(filePath) && fs94.statSync(filePath).isFile()) {
         return relPath;
       }
     }
   }
-  if (!isNestedComponentName && !componentName.includes("..") && !path105.isAbsolute(componentName)) {
+  if (!isNestedComponentName && !componentName.includes("..") && !path106.isAbsolute(componentName)) {
     for (const extension of [".tsx", ".ts"]) {
-      const relPath = path105.join(componentName, `index${extension}`);
-      const filePath = path105.join(assetDir, relPath);
-      if (fs93.existsSync(filePath) && fs93.statSync(filePath).isFile()) {
+      const relPath = path106.join(componentName, `index${extension}`);
+      const filePath = path106.join(assetDir, relPath);
+      if (fs94.existsSync(filePath) && fs94.statSync(filePath).isFile()) {
         return relPath;
       }
     }
   }
-  return fs93.readdirSync(assetDir, { withFileTypes: true }).find(
+  return fs94.readdirSync(assetDir, { withFileTypes: true }).find(
     (entry) => entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts")) && entry.name.replace(/\.(tsx|ts)$/, "") === componentName
   )?.name;
 }
@@ -40263,8 +40298,8 @@ function normalizeShadcnPresetOnly(value) {
 // adapters/next/commands/update-component/run-shadcn-preset-update.ts
 import * as clack6 from "@clack/prompts";
 import { execFileSync as execFileSync4 } from "child_process";
-import fs95 from "fs";
-import path108 from "path";
+import fs96 from "fs";
+import path109 from "path";
 
 // adapters/next/commands/update-component/create-admin-shadcn-components-json.ts
 function createAdminShadcnComponentsJson(config) {
@@ -40295,7 +40330,7 @@ function createAdminShadcnComponentsJson(config) {
 }
 
 // adapters/next/commands/update-component/get-host-project-files-to-restore.ts
-import path106 from "path";
+import path107 from "path";
 function getHostProjectFilesToRestore(cwd) {
   const hostRelativePaths = [
     "app/layout.tsx",
@@ -40309,17 +40344,17 @@ function getHostProjectFilesToRestore(cwd) {
     "app/globals.css",
     "src/app/globals.css"
   ];
-  return hostRelativePaths.map((relativePath) => path106.join(cwd, relativePath));
+  return hostRelativePaths.map((relativePath) => path107.join(cwd, relativePath));
 }
 
 // adapters/next/commands/update-component/resolve-local-shadcn-bin.ts
 import * as clack5 from "@clack/prompts";
-import fs94 from "fs";
-import path107 from "path";
+import fs95 from "fs";
+import path108 from "path";
 function resolveLocalShadcnBin(cwd) {
   const binName = process.platform === "win32" ? "shadcn.cmd" : "shadcn";
-  const shadcnBin = path107.join(cwd, "node_modules", ".bin", binName);
-  if (!fs94.existsSync(shadcnBin)) {
+  const shadcnBin = path108.join(cwd, "node_modules", ".bin", binName);
+  if (!fs95.existsSync(shadcnBin)) {
     clack5.cancel(
       `shadcn is not installed in this project. Run 'betterstart update-deps' and try again.`
     );
@@ -40336,22 +40371,22 @@ function runShadcnPresetUpdate({
   only
 }) {
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
-  const adminGlobalsPath = path108.join(cwd, config.paths.admin, namespace.globalsFile);
-  const componentsJsonPath = path108.join(cwd, "components.json");
+  const adminGlobalsPath = path109.join(cwd, config.paths.admin, namespace.globalsFile);
+  const componentsJsonPath = path109.join(cwd, "components.json");
   const shadcnBackupPath = `${componentsJsonPath}.bak`;
   const restoreAfterApplyPaths = [
     componentsJsonPath,
     shadcnBackupPath,
-    path108.join(cwd, config.paths.admin, "lib", "utils.ts"),
+    path109.join(cwd, config.paths.admin, "lib", "utils.ts"),
     ...getHostProjectFilesToRestore(cwd)
   ];
   if (!preset) {
     clack6.cancel("--shadcn-preset requires a preset code, preset name, or preset URL.");
     process.exit(1);
   }
-  if (!fs95.existsSync(adminGlobalsPath)) {
+  if (!fs96.existsSync(adminGlobalsPath)) {
     clack6.cancel(
-      `Admin globals file not found at ${path108.relative(cwd, adminGlobalsPath)}. Run 'betterstart update admin-globals' first.`
+      `Admin globals file not found at ${path109.relative(cwd, adminGlobalsPath)}. Run 'betterstart update admin-globals' first.`
     );
     process.exit(1);
   }
@@ -40361,10 +40396,10 @@ function runShadcnPresetUpdate({
     snapshot: captureFile(filePath)
   }));
   clack6.intro("BetterStart Shadcn Preset");
-  clack6.log.info(`Applying preset to ${path108.join(config.paths.admin, "components/ui")}`);
+  clack6.log.info(`Applying preset to ${path109.join(config.paths.admin, "components/ui")}`);
   let failed = false;
   try {
-    fs95.writeFileSync(
+    fs96.writeFileSync(
       componentsJsonPath,
       `${JSON.stringify(createAdminShadcnComponentsJson(config), null, 2)}
 `,
@@ -40417,7 +40452,7 @@ function validateShadcnPresetOptions(components, options) {
 
 // adapters/next/commands/update-component/run-update-command.ts
 async function runUpdateCommand(components, options) {
-  const cwd = options.cwd ? path109.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path110.resolve(options.cwd) : process.cwd();
   const normalizedOnly = normalizeShadcnPresetOnly(options.only);
   validateShadcnPresetOptions(components, options);
   if (options.json && !options.list) {
@@ -40478,8 +40513,8 @@ async function runUpdateCommand(components, options) {
     return;
   }
   const config = await resolveConfigOrExit(cwd);
-  const admin = path109.resolve(cwd, config.paths.admin);
-  if (!fs96.existsSync(admin)) {
+  const admin = path110.resolve(cwd, config.paths.admin);
+  if (!fs97.existsSync(admin)) {
     clack8.cancel(
       `Admin directory not found at ${config.paths.admin}. Run 'betterstart init' first.`
     );
@@ -40533,8 +40568,8 @@ async function runUpdateCommand(components, options) {
     }
     const { relPath, content } = applyNamespaceToTemplateEntry(entry, config, cwd);
     const baseDir = entry.base === "cwd" ? cwd : admin;
-    const destPath = path109.join(baseDir, relPath);
-    if (entry.preserveExisting && fs96.existsSync(destPath)) {
+    const destPath = path110.join(baseDir, relPath);
+    if (entry.preserveExisting && fs97.existsSync(destPath)) {
       clack8.log.info(`Preserved ${relPath}`);
       updatedTemplateNames.add(name);
       skipped++;
@@ -40543,8 +40578,8 @@ async function runUpdateCommand(components, options) {
     pendingWrites.push({
       displayPath: relPath,
       write: () => {
-        fsExtra2.ensureDirSync(path109.dirname(destPath));
-        fs96.writeFileSync(destPath, content, "utf-8");
+        fsExtra2.ensureDirSync(path110.dirname(destPath));
+        fs97.writeFileSync(destPath, content, "utf-8");
         clack8.log.success(`Updated ${relPath}`);
       }
     });
@@ -40575,20 +40610,20 @@ async function runUpdateCommand(components, options) {
     }
     const namespace = config.frameworkConfig.next.namespace;
     const namespacedAssetFile = applyAdminNamespaceToPath(assetFile, namespace);
-    const destPath = path109.join(admin, "components", assetDirectory, namespacedAssetFile);
+    const destPath = path110.join(admin, "components", assetDirectory, namespacedAssetFile);
     pendingWrites.push({
       displayPath: `components/${assetDirectory}/${namespacedAssetFile}`,
       write: () => {
-        fsExtra2.ensureDirSync(path109.dirname(destPath));
-        writeNamespacedFile(path109.join(assetDir, assetFile), destPath, namespace);
+        fsExtra2.ensureDirSync(path110.dirname(destPath));
+        writeNamespacedFile(path110.join(assetDir, assetFile), destPath, namespace);
         clack8.log.success(`Updated components/${assetDirectory}/${namespacedAssetFile}`);
       }
     });
     if (assetDirectory === "custom") {
-      const assetSubdir = path109.join(assetDir, name);
-      if (fs96.existsSync(assetSubdir) && fs96.statSync(assetSubdir).isDirectory()) {
+      const assetSubdir = path110.join(assetDir, name);
+      if (fs97.existsSync(assetSubdir) && fs97.statSync(assetSubdir).isDirectory()) {
         const namespacedName = applyAdminNamespaceToPath(name, namespace);
-        const destSubdir = path109.join(admin, "components", assetDirectory, namespacedName);
+        const destSubdir = path110.join(admin, "components", assetDirectory, namespacedName);
         pendingWrites.push({
           displayPath: `components/${assetDirectory}/${namespacedName}/ (template files)`,
           write: () => {
@@ -40623,19 +40658,19 @@ async function runUpdateCommand(components, options) {
       "content-editor"
     );
     const namespace = config.frameworkConfig.next.namespace;
-    const destBaseDir = path109.join(admin, "components", "custom", "content-editor");
-    if (!fs96.existsSync(srcBaseDir)) {
+    const destBaseDir = path110.join(admin, "components", "custom", "content-editor");
+    if (!fs97.existsSync(srcBaseDir)) {
       return false;
     }
     const dirsToCopy = [];
     for (const directory of TIPTAP_CONTENT_EDITOR_DIRECTORIES) {
-      const srcDir = path109.join(srcBaseDir, directory);
-      if (!fs96.existsSync(srcDir)) {
+      const srcDir = path110.join(srcBaseDir, directory);
+      if (!fs97.existsSync(srcDir)) {
         continue;
       }
       dirsToCopy.push({
         srcDir,
-        destDir: path109.join(destBaseDir, applyAdminNamespaceToPath(directory, namespace))
+        destDir: path110.join(destBaseDir, applyAdminNamespaceToPath(directory, namespace))
       });
     }
     if (dirsToCopy.length === 0) {
@@ -40649,7 +40684,7 @@ async function runUpdateCommand(components, options) {
           copyNamespacedDirectory(srcDir, destDir, namespace);
         }
         clack8.log.success("Updated components/custom/content-editor/tiptap-*/ (template files)");
-        removePath(admin, path109.join(admin, "components", "custom", "tiptap"));
+        removePath(admin, path110.join(admin, "components", "custom", "tiptap"));
       }
     });
     updatedStaticNames.add(key);
@@ -40746,7 +40781,7 @@ async function runUpdateCommand(components, options) {
 
 // adapters/next/commands/update-deps.ts
 import * as clack9 from "@clack/prompts";
-import path110 from "path";
+import path111 from "path";
 
 // adapters/next/integration-runtime/get-installed-integrations.ts
 function getInstalledIntegrations(config) {
@@ -40760,7 +40795,7 @@ function getInstalledPresets(config) {
 
 // adapters/next/commands/update-deps.ts
 async function runUpdateDepsCommand(options) {
-  const cwd = options.cwd ? path110.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path111.resolve(options.cwd) : process.cwd();
   clack9.intro("BetterStart Update Dependencies");
   const pm = detectPackageManager(cwd);
   clack9.log.info(`Package manager: ${pm}`);
@@ -40795,25 +40830,25 @@ async function runUpdateDepsCommand(options) {
 
 // adapters/next/commands/update-styles.ts
 import * as clack10 from "@clack/prompts";
-import fs97 from "fs";
-import path111 from "path";
+import fs98 from "fs";
+import path112 from "path";
 async function runUpdateStylesCommand(options) {
-  const cwd = options.cwd ? path111.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path112.resolve(options.cwd) : process.cwd();
   clack10.intro("BetterStart Update Styles");
   const config = await resolveConfigOrExit(cwd);
   const adminDir = config.paths.admin;
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
-  const targetPath = path111.join(cwd, adminDir, namespace.globalsFile);
-  if (!fs97.existsSync(targetPath)) {
-    clack10.cancel(`${namespace.globalsFile} not found at ${path111.relative(cwd, targetPath)}`);
+  const targetPath = path112.join(cwd, adminDir, namespace.globalsFile);
+  if (!fs98.existsSync(targetPath)) {
+    clack10.cancel(`${namespace.globalsFile} not found at ${path112.relative(cwd, targetPath)}`);
     process.exit(1);
   }
-  fs97.writeFileSync(
+  fs98.writeFileSync(
     targetPath,
     applyAdminNamespaceToContent(readTemplate("admin-globals.css"), namespace.segment),
     "utf-8"
   );
-  clack10.log.success(`Updated ${path111.relative(cwd, targetPath)}`);
+  clack10.log.success(`Updated ${path112.relative(cwd, targetPath)}`);
   clack10.outro("Styles updated");
 }