playcademy 0.14.6 → 0.14.7-alpha.1

package/dist/index.js

@@ -5194,7 +5194,7 @@ async function hasBackendChanged(previousHash, currentHash) {
 }
 async function getDirectorySize(dirPath) {
   const { stat: stat2, readdir } = await import("node:fs/promises");
-  const { join: join45 } = await import("node:path");
+  const { join: join46 } = await import("node:path");
   if (!existsSync8(dirPath)) {
     return null;
   }
@@ -5203,7 +5203,7 @@ async function getDirectorySize(dirPath) {
   async function calculateSize(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join45(dir, entry.name);
+      const fullPath = join46(dir, entry.name);
       if (entry.isDirectory()) {
         await calculateSize(fullPath);
       } else if (entry.isFile()) {
@@ -5255,10 +5255,10 @@ init_src();
 init_file_loader();
 init_package_manager();
 init_constants2();
-import { execSync as execSync6 } from "child_process";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync12 } from "fs";
+import { execSync as execSync7 } from "child_process";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
 import { resolve as resolve10 } from "path";
-import { confirm as confirm4 } from "@inquirer/prompts";
+import { confirm as confirm5 } from "@inquirer/prompts";
 import { Command as Command2 } from "commander";
 
 // src/lib/auth/index.ts
@@ -6777,25 +6777,207 @@ function displayDeploymentDiff(options) {
   }
 }
 
+// src/lib/deploy/godot.ts
+init_src();
+init_core();
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync10, mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
+import { join as join13 } from "path";
+import { confirm, select } from "@inquirer/prompts";
+function isGodotProject() {
+  return existsSync10(join13(getWorkspace(), "project.godot"));
+}
+function hasWebExportPreset() {
+  const presetsPath = join13(getWorkspace(), "export_presets.cfg");
+  if (!existsSync10(presetsPath)) {
+    return { configured: false };
+  }
+  try {
+    const content = readFileSync5(presetsPath, "utf-8");
+    const lines = content.split("\n");
+    const webPlatformIndex = lines.findIndex((line) => line.trim() === 'platform="Web"');
+    if (webPlatformIndex === -1) {
+      return { configured: false };
+    }
+    for (let i = webPlatformIndex - 1; i >= 0; i--) {
+      const line = lines[i]?.trim();
+      if (!line) continue;
+      if (line.startsWith("name=")) {
+        const match = line.match(/name="(.+?)"/);
+        if (match?.[1]) {
+          return { configured: true, presetName: match[1] };
+        }
+      }
+      if (line.startsWith("[preset.")) break;
+    }
+    return { configured: false };
+  } catch {
+    return { configured: false };
+  }
+}
+async function findGodotExecutable() {
+  const platform = process.platform;
+  const foundExecutables = [];
+  const seenAppBundles = /* @__PURE__ */ new Set();
+  try {
+    const whichCmd = platform === "win32" ? "where godot 2>nul" : "which godot 2>/dev/null";
+    const result = execSync4(whichCmd, { stdio: "pipe", encoding: "utf-8" });
+    const paths = result.trim().split("\n").filter(Boolean);
+    for (const path4 of paths) {
+      if (platform === "darwin" && path4.includes(".app/")) {
+        const appPath = path4.split(".app/")[0] + ".app";
+        const appName = appPath.split("/").pop() || "Godot";
+        foundExecutables.push({ path: path4, label: appName });
+        seenAppBundles.add(appPath);
+      } else {
+        foundExecutables.push({ path: path4, label: path4 });
+      }
+    }
+  } catch {
+  }
+  if (platform === "darwin") {
+    try {
+      const result = execSync4(
+        'mdfind "kMDItemKind == Application && kMDItemDisplayName == Godot*"',
+        { stdio: "pipe", encoding: "utf-8" }
+      );
+      const apps = result.split("\n").filter(Boolean);
+      for (const appPath of apps) {
+        if (seenAppBundles.has(appPath)) continue;
+        const executable = join13(appPath, "Contents/MacOS/Godot");
+        const appName = appPath.split("/").pop() || "Godot";
+        foundExecutables.push({ path: executable, label: appName });
+      }
+    } catch {
+    }
+  }
+  if (platform === "linux") {
+    try {
+      execSync4("flatpak list 2>/dev/null | grep org.godotengine.Godot", { stdio: "pipe" });
+      foundExecutables.push({
+        path: "flatpak run org.godotengine.Godot",
+        label: "Godot (flatpak)"
+      });
+    } catch {
+    }
+    try {
+      execSync4("snap list 2>/dev/null | grep godot", { stdio: "pipe" });
+      foundExecutables.push({ path: "snap run godot", label: "Godot (snap)" });
+    } catch {
+    }
+  }
+  if (platform === "win32") {
+    const programFiles = [process.env["ProgramFiles"], process.env["ProgramFiles(x86)"]].filter(
+      Boolean
+    );
+    for (const baseDir of programFiles) {
+      try {
+        const result = execSync4(`dir /s /b "${baseDir}\\*godot*.exe" 2>nul`, {
+          stdio: "pipe",
+          encoding: "utf-8",
+          timeout: 5e3
+        });
+        const exes = result.split("\r\n").filter(Boolean);
+        for (const exePath of exes) {
+          const fileName = exePath.split("\\").pop() || "godot.exe";
+          foundExecutables.push({ path: exePath, label: fileName });
+        }
+      } catch {
+      }
+    }
+  }
+  if (foundExecutables.length === 0) return null;
+  if (foundExecutables.length === 1) return foundExecutables[0].path;
+  return await select({
+    message: "Preferred Godot installation?",
+    choices: foundExecutables.map((exe) => ({
+      value: exe.path,
+      name: exe.label
+    }))
+  });
+}
+async function runGodotExport(godotPath, presetName, outputPath) {
+  const root = getWorkspace();
+  try {
+    mkdirSync2(join13(root, "build", "web"), { recursive: true });
+    await runStep(
+      `Exporting project using "${presetName}" preset`,
+      async () => {
+        execSync4(
+          `cd "${root}" && "${godotPath}" --headless --export-release "${presetName}" "${outputPath}"`,
+          { stdio: "ignore" }
+        );
+      },
+      "Godot export complete"
+    );
+    return true;
+  } catch {
+    logger.error("Godot export failed");
+    logger.newLine();
+    logger.admonition("tip", "Common Issues", [
+      "Export templates not installed for your Godot version",
+      "Web export preset not properly configured",
+      "Godot version mismatch with project"
+    ]);
+    logger.newLine();
+    return false;
+  }
+}
+async function handleGodotBuildPrompt() {
+  if (!isGodotProject()) return null;
+  const shouldExport = await confirm({ message: "Export Godot project?" });
+  if (!shouldExport) return null;
+  const godotPath = await findGodotExecutable();
+  if (!godotPath) {
+    logger.error("Godot executable not found");
+    return null;
+  }
+  const webExport = hasWebExportPreset();
+  if (!webExport.configured) {
+    logger.error("Web export preset not configured");
+    logger.newLine();
+    logger.admonition("tip", "Configure Web Export", [
+      "1. Open project in Godot Editor",
+      "2. Go to Project \u2192 Export...",
+      "3. Add Web preset"
+    ]);
+    logger.newLine();
+    return null;
+  }
+  const success = await runGodotExport(godotPath, webExport.presetName, "build/web/index.html");
+  if (!success) {
+    logger.error("Export failed. Please export manually or provide zip file.");
+    logger.newLine();
+    return null;
+  }
+  const zipPath = "build/web_playcademy.zip";
+  if (existsSync10(join13(getWorkspace(), zipPath))) {
+    return zipPath;
+  }
+  logger.warn("Expected zip file not found, using build directory");
+  logger.newLine();
+  return "build/web";
+}
+
 // src/lib/deploy/interaction.ts
 init_storage();
 init_context();
 init_logger();
-import { confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
+import { confirm as confirm3, input as input2, select as select3 } from "@inquirer/prompts";
 
 // src/lib/init/prompts.ts
 init_constants3();
 init_constants2();
 init_core();
-import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import { checkbox, confirm as confirm2, input, select as select2 } from "@inquirer/prompts";
 import { bold as bold4, cyan as cyan2 } from "colorette";
 
 // src/lib/init/scaffold.ts
 init_constants2();
 init_core();
 init_loader2();
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join15, resolve as resolve6 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join16, resolve as resolve6 } from "path";
 
 // src/lib/init/auth.ts
 init_log();
@@ -6804,8 +6986,8 @@ init_constants2();
 init_core();
 init_env();
 init_loader2();
-import { existsSync as existsSync10, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join14 } from "path";
 var authTemplate = loadTemplateString("auth/auth.ts");
 var authCatchAllTemplate = loadTemplateString("auth/auth-catch-all.ts");
 var authSchemaTemplate = loadTemplateString("auth/auth-schema.ts");
@@ -6847,30 +7029,30 @@ function generateAuthConfig(strategies, gameName) {
   return authContent;
 }
 function scaffoldAuthConfig(workspace, authContent) {
-  const libDir = join13(workspace, SERVER_LIB_DIRECTORY);
-  if (!existsSync10(libDir)) {
-    mkdirSync2(libDir, { recursive: true });
+  const libDir = join14(workspace, SERVER_LIB_DIRECTORY);
+  if (!existsSync11(libDir)) {
+    mkdirSync3(libDir, { recursive: true });
   }
-  writeFileSync3(join13(libDir, AUTH_CONFIG_FILE), authContent);
+  writeFileSync3(join14(libDir, AUTH_CONFIG_FILE), authContent);
 }
 function scaffoldAuthRoutes(workspace) {
-  const apiDir = join13(workspace, DEFAULT_API_ROUTES_DIRECTORY);
-  const authApiDir = join13(apiDir, AUTH_API_SUBDIRECTORY);
-  if (!existsSync10(authApiDir)) {
-    mkdirSync2(authApiDir, { recursive: true });
+  const apiDir = join14(workspace, DEFAULT_API_ROUTES_DIRECTORY);
+  const authApiDir = join14(apiDir, AUTH_API_SUBDIRECTORY);
+  if (!existsSync11(authApiDir)) {
+    mkdirSync3(authApiDir, { recursive: true });
   }
-  writeFileSync3(join13(authApiDir, "[...all].ts"), authCatchAllTemplate);
+  writeFileSync3(join14(authApiDir, "[...all].ts"), authCatchAllTemplate);
 }
 function scaffoldAuthSchema(workspace) {
-  const dbDir = join13(workspace, DEFAULT_DATABASE_DIRECTORY);
-  const schemaDir = join13(dbDir, SCHEMA_SUBDIRECTORY);
-  if (!existsSync10(schemaDir)) {
-    mkdirSync2(schemaDir, { recursive: true });
-  }
-  writeFileSync3(join13(schemaDir, "auth.ts"), authSchemaTemplate);
-  const schemaIndexPath = join13(schemaDir, SCHEMA_INDEX_FILE);
-  if (existsSync10(schemaIndexPath)) {
-    const existing = readFileSync5(schemaIndexPath, "utf-8");
+  const dbDir = join14(workspace, DEFAULT_DATABASE_DIRECTORY);
+  const schemaDir = join14(dbDir, SCHEMA_SUBDIRECTORY);
+  if (!existsSync11(schemaDir)) {
+    mkdirSync3(schemaDir, { recursive: true });
+  }
+  writeFileSync3(join14(schemaDir, "auth.ts"), authSchemaTemplate);
+  const schemaIndexPath = join14(schemaDir, SCHEMA_INDEX_FILE);
+  if (existsSync11(schemaIndexPath)) {
+    const existing = readFileSync6(schemaIndexPath, "utf-8");
     if (!existing.includes("export * from './auth'")) {
       writeFileSync3(schemaIndexPath, existing + "\nexport * from './auth'\n");
     }
@@ -6879,12 +7061,12 @@ function scaffoldAuthSchema(workspace) {
   }
 }
 function scaffoldProtectedExample(workspace) {
-  const apiDir = join13(workspace, DEFAULT_API_ROUTES_DIRECTORY);
-  const sampleDir = join13(apiDir, SAMPLE_API_SUBDIRECTORY);
-  if (!existsSync10(sampleDir)) {
-    mkdirSync2(sampleDir, { recursive: true });
+  const apiDir = join14(workspace, DEFAULT_API_ROUTES_DIRECTORY);
+  const sampleDir = join14(apiDir, SAMPLE_API_SUBDIRECTORY);
+  if (!existsSync11(sampleDir)) {
+    mkdirSync3(sampleDir, { recursive: true });
   }
-  writeFileSync3(join13(sampleDir, "protected.ts"), protectedRouteTemplate);
+  writeFileSync3(join14(sampleDir, "protected.ts"), protectedRouteTemplate);
 }
 function updateEnvForAuth(workspace, strategies) {
   if (strategies.length === 0) return;
@@ -6925,16 +7107,16 @@ async function scaffoldAuthSetup(options = {}) {
   return packagesUpdated;
 }
 async function setupPackageJson(workspace) {
-  const pkgPath = join13(workspace, "package.json");
+  const pkgPath = join14(workspace, "package.json");
   const authDeps = {
     "@playcademy/better-auth": PLAYCADEMY_AUTH_VERSION,
     "better-auth": BETTER_AUTH_VERSION
   };
-  if (existsSync10(pkgPath)) {
+  if (existsSync11(pkgPath)) {
     await runStep(
       "Updating package.json deps",
       async () => {
-        const existing = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+        const existing = JSON.parse(readFileSync6(pkgPath, "utf-8"));
         existing.dependencies = { ...existing.dependencies, ...authDeps };
         writeFileSync3(pkgPath, JSON.stringify(existing, null, 2) + "\n");
       },
@@ -6946,20 +7128,20 @@ async function setupPackageJson(workspace) {
 }
 function hasAuthSetup() {
   const workspace = getWorkspace();
-  const authPath = join13(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
-  return existsSync10(authPath);
+  const authPath = join14(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
+  return existsSync11(authPath);
 }
 
 // src/lib/init/database.ts
 init_log();
 init_slug();
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join15 } from "path";
 
 // package.json
 var package_default2 = {
   name: "playcademy",
-  version: "0.14.5",
+  version: "0.14.7",
   type: "module",
   exports: {
     ".": {
@@ -7054,27 +7236,27 @@ async function scaffoldDatabaseSetup(options) {
   await runStep(
     "Configuring database...",
     async () => {
-      const dbDir = join14(workspace, "db");
-      const schemaDir = join14(dbDir, "schema");
-      if (!existsSync11(dbDir)) {
-        mkdirSync3(dbDir, { recursive: true });
+      const dbDir = join15(workspace, "db");
+      const schemaDir = join15(dbDir, "schema");
+      if (!existsSync12(dbDir)) {
+        mkdirSync4(dbDir, { recursive: true });
       }
-      if (!existsSync11(schemaDir)) {
-        mkdirSync3(schemaDir, { recursive: true });
+      if (!existsSync12(schemaDir)) {
+        mkdirSync4(schemaDir, { recursive: true });
       }
-      const usersSchemaPath = join14(schemaDir, "users.ts");
+      const usersSchemaPath = join15(schemaDir, "users.ts");
       writeFileSync4(usersSchemaPath, dbSchemaUsersTemplate);
-      const scoresSchemaPath = join14(schemaDir, "scores.ts");
+      const scoresSchemaPath = join15(schemaDir, "scores.ts");
       writeFileSync4(scoresSchemaPath, dbSchemaScoresTemplate);
-      const schemaIndexPath = join14(schemaDir, "index.ts");
+      const schemaIndexPath = join15(schemaDir, "index.ts");
       writeFileSync4(schemaIndexPath, dbSchemaIndexTemplate);
-      const dbIndexPath = join14(dbDir, "index.ts");
+      const dbIndexPath = join15(dbDir, "index.ts");
       writeFileSync4(dbIndexPath, dbIndexTemplate);
-      const dbTypesPath = join14(dbDir, "types.ts");
+      const dbTypesPath = join15(dbDir, "types.ts");
       writeFileSync4(dbTypesPath, dbTypesTemplate);
-      const dbSeedPath = join14(dbDir, "seed.ts");
+      const dbSeedPath = join15(dbDir, "seed.ts");
       writeFileSync4(dbSeedPath, dbSeedTemplate);
-      const drizzleConfigPath = join14(workspace, "drizzle.config.ts");
+      const drizzleConfigPath = join15(workspace, "drizzle.config.ts");
       writeFileSync4(drizzleConfigPath, drizzleConfigTemplate);
       packagesUpdated = await setupPackageJson2(workspace, options.gameName);
     },
@@ -7083,7 +7265,7 @@ async function scaffoldDatabaseSetup(options) {
   return packagesUpdated;
 }
 async function setupPackageJson2(workspace, gameName) {
-  const pkgPath = join14(workspace, "package.json");
+  const pkgPath = join15(workspace, "package.json");
   const dbDeps = {
     "drizzle-orm": "^0.42.0",
     "better-sqlite3": "^12.0.0"
@@ -7102,11 +7284,11 @@ async function setupPackageJson2(workspace, gameName) {
     "db:seed": "playcademy db seed",
     "db:reset": "playcademy db reset"
   };
-  if (existsSync11(pkgPath)) {
+  if (existsSync12(pkgPath)) {
     await runStep(
       "Updating package.json deps",
       async () => {
-        const existing = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+        const existing = JSON.parse(readFileSync7(pkgPath, "utf-8"));
         existing.dependencies = { ...existing.dependencies, ...dbDeps };
         existing.devDependencies = { ...existing.devDependencies, ...dbDevDeps };
         existing.scripts = { ...existing.scripts, ...dbScripts };
@@ -7125,9 +7307,9 @@ async function setupPackageJson2(workspace, gameName) {
 }
 function hasDatabaseSetup() {
   const workspace = getWorkspace();
-  const drizzleConfigPath = join14(workspace, "drizzle.config.ts");
-  const drizzleConfigJsPath = join14(workspace, "drizzle.config.js");
-  return existsSync11(drizzleConfigPath) || existsSync11(drizzleConfigJsPath);
+  const drizzleConfigPath = join15(workspace, "drizzle.config.ts");
+  const drizzleConfigJsPath = join15(workspace, "drizzle.config.js");
+  return existsSync12(drizzleConfigPath) || existsSync12(drizzleConfigJsPath);
 }
 
 // src/lib/init/scaffold.ts
@@ -7138,15 +7320,15 @@ var sampleBucketRouteTemplate = loadTemplateString("api/sample-bucket.ts");
 var playcademyGitignoreTemplate = loadTemplateString("playcademy-gitignore");
 async function scaffoldApiDirectory(apiDirectory, sampleRoutes) {
   const apiPath = resolve6(getWorkspace(), apiDirectory);
-  const samplePath = join15(apiPath, "sample");
-  if (!existsSync12(apiPath)) {
-    mkdirSync4(apiPath, { recursive: true });
+  const samplePath = join16(apiPath, "sample");
+  if (!existsSync13(apiPath)) {
+    mkdirSync5(apiPath, { recursive: true });
   }
-  if (!existsSync12(samplePath)) {
-    mkdirSync4(samplePath, { recursive: true });
+  if (!existsSync13(samplePath)) {
+    mkdirSync5(samplePath, { recursive: true });
   }
   for (const route of sampleRoutes) {
-    writeFileSync5(join15(samplePath, route.filename), route.template, "utf-8");
+    writeFileSync5(join16(samplePath, route.filename), route.template, "utf-8");
   }
 }
 async function scaffoldSampleFileIfMissing(config, sampleFilename, template) {
@@ -7157,29 +7339,29 @@ async function scaffoldSampleFileIfMissing(config, sampleFilename, template) {
     SAMPLE_API_SUBDIRECTORY,
     sampleFilename
   );
-  if (existsSync12(sampleFilePath)) {
+  if (existsSync13(sampleFilePath)) {
     return false;
   }
   await scaffoldApiDirectory(customRoutesDir, [{ filename: sampleFilename, template }]);
   logger.success(
-    `Created sample route: <${join15(customRoutesDir, SAMPLE_API_SUBDIRECTORY, sampleFilename)}>`
+    `Created sample route: <${join16(customRoutesDir, SAMPLE_API_SUBDIRECTORY, sampleFilename)}>`
   );
   return true;
 }
 function validateApiDirectoryDoesNotExist(value) {
   const dirPath = resolve6(getWorkspace(), value.trim());
-  if (existsSync12(dirPath)) {
+  if (existsSync13(dirPath)) {
     return `Directory "${value.trim()}" already exists. Please choose a different name or remove the existing directory.`;
   }
   return true;
 }
 function ensurePlaycademyGitignore() {
   const workspace = getWorkspace();
-  const playcademyDir = join15(workspace, CLI_DIRECTORIES.WORKSPACE);
-  if (!existsSync12(playcademyDir)) {
-    mkdirSync4(playcademyDir, { recursive: true });
+  const playcademyDir = join16(workspace, CLI_DIRECTORIES.WORKSPACE);
+  if (!existsSync13(playcademyDir)) {
+    mkdirSync5(playcademyDir, { recursive: true });
   }
-  const gitignorePath = join15(playcademyDir, ".gitignore");
+  const gitignorePath = join16(playcademyDir, ".gitignore");
   writeFileSync5(gitignorePath, playcademyGitignoreTemplate);
 }
 async function scaffoldIntegrations(gameName, options) {
@@ -7242,7 +7424,7 @@ async function promptForGameInfo() {
 }
 async function promptForTimeBackIntegration(options) {
   if (!options?.skipConfirm) {
-    const wantsTimeback = await confirm({
+    const wantsTimeback = await confirm2({
       message: "TimeBack?",
       default: false
     });
@@ -7266,7 +7448,7 @@ async function promptForTimeBackIntegration(options) {
   });
   let defaultSubject;
   if (subjects.length > 1) {
-    defaultSubject = await select({
+    defaultSubject = await select2({
       message: "Default subject:",
       choices: subjects.map((subject) => ({
         value: subject,
@@ -7295,7 +7477,7 @@ async function promptForTimeBackIntegration(options) {
   };
 }
 async function promptForDatabase() {
-  const wantsDatabase = await confirm({
+  const wantsDatabase = await confirm2({
     message: "Database?",
     default: false
   });
@@ -7334,7 +7516,7 @@ async function promptForAuthStrategies() {
   return strategies.filter((s) => s !== "platform");
 }
 async function promptForAuth() {
-  const wantsAuth = await confirm({
+  const wantsAuth = await confirm2({
     message: "Authentication?",
     default: false
   });
@@ -7345,14 +7527,14 @@ async function promptForAuth() {
   return { strategies };
 }
 async function promptForKV() {
-  const wantsKV = await confirm({
+  const wantsKV = await confirm2({
     message: "KV storage?",
     default: false
   });
   return wantsKV;
 }
 async function promptForBucket() {
-  const wantsBucket = await confirm({
+  const wantsBucket = await confirm2({
     message: "Bucket storage?",
     default: false
   });
@@ -7361,7 +7543,7 @@ async function promptForBucket() {
 async function promptForCustomRoutes(requiresRoutes = false) {
   let wantsCustomRoutes = requiresRoutes;
   if (!requiresRoutes) {
-    wantsCustomRoutes = await confirm({
+    wantsCustomRoutes = await confirm2({
       message: "Custom API routes?",
       default: false
     });
@@ -7406,7 +7588,7 @@ async function selectConfigFormat(hasPackageJson2) {
   if (hasPackageJson2) {
     return "js";
   }
-  const formatChoice = await select({
+  const formatChoice = await select2({
     message: "Which config format would you like to use?",
     choices: [
       { value: "json", name: "JSON (playcademy.config.json)" },
@@ -7493,9 +7675,9 @@ init_constants2();
 init_loader();
 init_core();
 init_backend();
-import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync14, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname4, join as join17 } from "path";
+import { execSync as execSync5 } from "child_process";
+import { existsSync as existsSync15, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname4, join as join18 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/secrets/index.ts
@@ -7507,8 +7689,8 @@ init_loader2();
 // src/lib/init/tsconfig.ts
 init_file_loader();
 init_constants2();
-import { existsSync as existsSync13, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { join as join17 } from "path";
 function hasPlaycademyEnv(config) {
   return config.include?.includes("playcademy-env.d.ts") ?? false;
 }
@@ -7565,8 +7747,8 @@ function addToIncludeArrayPreservingComments(content) {
 }
 async function ensureTsconfigIncludes(workspace) {
   for (const filename of TSCONFIG_FILES) {
-    const configPath = join16(workspace, filename);
-    if (!existsSync13(configPath)) {
+    const configPath = join17(workspace, filename);
+    if (!existsSync14(configPath)) {
       continue;
     }
     try {
@@ -7582,7 +7764,7 @@ async function ensureTsconfigIncludes(workspace) {
         return filename;
       }
       try {
-        const rawContent = readFileSync7(configPath, "utf-8");
+        const rawContent = readFileSync8(configPath, "utf-8");
         const updatedContent = addToIncludeArrayPreservingComments(rawContent);
         if (updatedContent && updatedContent !== rawContent) {
           writeFileSync6(configPath, updatedContent);
@@ -7615,8 +7797,8 @@ function hasAnyBackend(features) {
   return Object.values(features).some(Boolean);
 }
 async function setupPlaycademyDependencies(workspace) {
-  const playcademyDir = join17(workspace, CLI_DIRECTORIES.WORKSPACE);
-  const playcademyPkgPath = join17(playcademyDir, "package.json");
+  const playcademyDir = join18(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyPkgPath = join18(playcademyDir, "package.json");
   const __dirname2 = dirname4(fileURLToPath2(import.meta.url));
   const cliPkg = await loadPackageJson({ cwd: __dirname2, searchUp: true, required: true });
   const workersTypesVersion = cliPkg?.devDependencies?.["@cloudflare/workers-types"] || "latest";
@@ -7629,7 +7811,7 @@ async function setupPlaycademyDependencies(workspace) {
   writeFileSync7(playcademyPkgPath, JSON.stringify(playcademyPkg, null, 4) + "\n");
   const pm = detectPackageManager(workspace);
   const installCmd = getInstallCommand(pm);
-  execSync4(installCmd, {
+  execSync5(installCmd, {
     cwd: playcademyDir,
     stdio: ["ignore", "ignore", "ignore"]
   });
@@ -7701,14 +7883,14 @@ async function ensurePlaycademyTypes(options = {}) {
     const bindingsStr = generateBindingsTypeString(features);
     const secretsStr = await generateSecretsTypeString(workspace, verbose);
     const hasAuth = !!config.integrations?.auth;
-    const hasAuthFile = existsSync14(join17(workspace, "server/lib/auth.ts"));
+    const hasAuthFile = existsSync15(join18(workspace, "server/lib/auth.ts"));
     const authVariablesString = generateAuthVariablesString(hasAuth, hasAuthFile);
     let envContent = playcademyEnvTemplate.replace("{{BINDINGS}}", bindingsStr);
     envContent = envContent.replace("{{SECRETS}}", secretsStr);
     envContent = envContent.replace("{{AUTH_IMPORT}}", authVariablesString.authImport);
     envContent = envContent.replace("{{VARIABLES}}", authVariablesString.variables);
     envContent = envContent.replace("{{CONTEXT_VARS}}", authVariablesString.contextVars);
-    const envPath = join17(workspace, "playcademy-env.d.ts");
+    const envPath = join18(workspace, "playcademy-env.d.ts");
     writeFileSync7(envPath, envContent);
     if (verbose) {
       logger.success(`Generated <playcademy-env.d.ts>`);
@@ -7727,16 +7909,16 @@ async function ensurePlaycademyTypes(options = {}) {
 // src/lib/init/gitignore.ts
 init_core();
 init_loader2();
-import { existsSync as existsSync15, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { join as join19 } from "path";
 var rootGitignoreTemplate = loadTemplateString("gitignore");
 function ensureRootGitignore(workspace = getWorkspace()) {
-  const gitignorePath = join18(workspace, ".gitignore");
-  if (!existsSync15(gitignorePath)) {
+  const gitignorePath = join19(workspace, ".gitignore");
+  if (!existsSync16(gitignorePath)) {
     writeFileSync8(gitignorePath, rootGitignoreTemplate);
     return;
   }
-  const existingContent = readFileSync8(gitignorePath, "utf-8");
+  const existingContent = readFileSync9(gitignorePath, "utf-8");
   const existingNormalized = new Set(
     existingContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map(normalizeGitignoreEntry)
   );
@@ -7763,8 +7945,8 @@ init_package_manager();
 init_writer();
 init_core();
 init_loader2();
-import { execSync as execSync5 } from "child_process";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "node:fs";
+import { execSync as execSync6 } from "child_process";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
 import path2 from "node:path";
 var viteConfigTemplate = loadTemplateString("config/vite-config.ts");
 async function findViteConfig() {
@@ -7780,7 +7962,7 @@ async function isVitePluginInstalled() {
   return hasDependency("@playcademy/vite-plugin", { cwd: workspace });
 }
 function isPluginConfigured(configPath) {
-  const content = readFileSync9(configPath, "utf-8");
+  const content = readFileSync10(configPath, "utf-8");
   return content.includes("@playcademy/vite-plugin") || content.includes("playcademy(");
 }
 async function installVitePlugin() {
@@ -7791,7 +7973,7 @@ async function installVitePlugin() {
     await runStep(
       "Installing @playcademy/vite-plugin...",
       async () => {
-        execSync5(command, {
+        execSync6(command, {
           cwd: workspace,
           stdio: ["ignore", "ignore", "ignore"]
         });
@@ -7808,7 +7990,7 @@ function createViteConfig() {
   writeFileSync9(configPath, viteConfigTemplate);
 }
 async function updateViteConfig(configPath) {
-  let content = readFileSync9(configPath, "utf-8");
+  let content = readFileSync10(configPath, "utf-8");
   if (!content.includes("@playcademy/vite-plugin")) {
     const importMatch = content.match(/import .+ from ['"]vite['"]/);
     if (importMatch) {
@@ -7846,10 +8028,10 @@ init_backend();
 init_file_loader();
 init_constants2();
 init_core();
-import { join as join19, relative as relative3 } from "path";
+import { join as join20, relative as relative3 } from "path";
 function findSingleBuildZip() {
   const workspace = getWorkspace();
-  const playcademyDir = join19(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyDir = join20(workspace, CLI_DIRECTORIES.WORKSPACE);
   const zipFiles = findFilesByExtension(playcademyDir, "zip");
   if (zipFiles.length === 1) {
     return zipFiles[0] ? relative3(workspace, zipFiles[0]) : null;
@@ -7861,9 +8043,9 @@ function findSingleBuildZip() {
 init_constants2();
 init_config3();
 init_core();
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { createRequire } from "module";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 async function getDatabaseDirectory() {
   try {
     const config = await loadConfig();
@@ -7891,8 +8073,8 @@ async function getSchemaInfo(previousSchemaSnapshot) {
     return null;
   }
   const dbDirectory = await getDatabaseDirectory();
-  const schemaPath = join20(workspace, dbDirectory, SCHEMA_SUBDIRECTORY, SCHEMA_INDEX_FILE);
-  if (!existsSync16(schemaPath)) {
+  const schemaPath = join21(workspace, dbDirectory, SCHEMA_SUBDIRECTORY, SCHEMA_INDEX_FILE);
+  if (!existsSync17(schemaPath)) {
     return null;
   }
   try {
@@ -7928,14 +8110,14 @@ async function getSchemaStatementCount(previousSchemaSnapshot) {
 
 // src/lib/deploy/validate.ts
 init_logger();
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { resolve as resolve7 } from "path";
 function validateBuildPath(path4) {
   if (!path4.trim()) {
     return "Build path is required";
   }
   const resolvedPath = resolve7(path4.trim());
-  if (!existsSync17(resolvedPath)) {
+  if (!existsSync18(resolvedPath)) {
     return `Build path not found: ${path4.trim()}`;
   }
   return true;
@@ -7978,7 +8160,7 @@ async function selectEnvironment(options) {
     logger.remark(`Deploying to ${environment}`, 1);
   } else if (authenticatedEnvs.length === 2 && !options.dryRun) {
     logger.newLine();
-    environment = await select2({
+    environment = await select3({
       message: "Select deployment environment:",
       choices: [
         { value: "staging", name: "Staging (hub.dev.playcademy.net)" },
@@ -8005,6 +8187,11 @@ async function promptForMissingConfig(context2) {
     });
   }
   if (needsBuildPath) {
+    const godotBuildPath = await handleGodotBuildPrompt();
+    if (godotBuildPath) {
+      config.buildPath = godotBuildPath;
+      return true;
+    }
     const savedBuildPath = context2.deployedGameInfo?.buildPath;
     const discoveredBuildZip = findSingleBuildZip();
     const defaultBuildPath = discoveredBuildZip || savedBuildPath;
@@ -8019,7 +8206,7 @@ async function promptForMissingConfig(context2) {
 async function confirmDeploymentPlan(plan, context2) {
   const { config } = context2;
   if (plan.action === "deploy-new") {
-    const shouldDeploy = await confirm2({
+    const shouldDeploy = await confirm3({
       message: "Deploy this game?",
       default: true
     });
@@ -8087,7 +8274,7 @@ async function confirmDeploymentPlan(plan, context2) {
         currentKeys: context2.currentSecretKeys
       }
     });
-    const shouldDeploy = await confirm2({
+    const shouldDeploy = await confirm3({
       message: `Update ${config.displayName}?`,
       default: true
     });
@@ -8269,7 +8456,7 @@ function reportCancellation() {
 
 // src/lib/deploy/preparation.ts
 import { stat } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 
 // ../data/src/domains/game/helpers.ts
 var isHostedGame = (game) => {
@@ -8720,22 +8907,22 @@ init_context();
 
 // src/lib/games/storage.ts
 init_constants2();
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function getGamesStorePath() {
-  return join21(homedir2(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.GAMES_STORE);
+  return join22(homedir2(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.GAMES_STORE);
 }
 async function ensureConfigDir() {
-  const configDir = join21(homedir2(), CLI_USER_DIRECTORIES.CONFIG);
+  const configDir = join22(homedir2(), CLI_USER_DIRECTORIES.CONFIG);
   await mkdir3(configDir, { recursive: true });
 }
 async function loadGameStore() {
   try {
     await ensureConfigDir();
     const storePath = getGamesStorePath();
-    if (existsSync18(storePath)) {
+    if (existsSync19(storePath)) {
       const content = await readFile3(storePath, "utf-8");
       return JSON.parse(content);
     }
@@ -9029,8 +9216,8 @@ async function analyzeChanges(context2) {
         const bundle = await bundleBackend(context2.fullConfig);
         const bundleHash = hashContent(bundle.code);
         const [serverSize, dbSize] = await Promise.all([
-          getDirectorySize(join22(projectPath, "server")),
-          getDirectorySize(join22(projectPath, "db"))
+          getDirectorySize(join23(projectPath, "server")),
+          getDirectorySize(join23(projectPath, "db"))
         ]);
         context2.currentBackendBundleHash = bundleHash;
         context2.currentBackendSize = bundle.code.length;
@@ -9153,9 +9340,9 @@ function hasOptionalFieldsMissing(missing) {
 // src/lib/deploy/steps.ts
 init_src();
 init_logger();
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
-import { basename as basename2, join as join23, resolve as resolve8 } from "path";
+import { basename as basename2, join as join24, resolve as resolve8 } from "path";
 
 // src/lib/deploy/utils.ts
 init_src2();
@@ -9178,7 +9365,7 @@ function prepareGameMetadata(config) {
 }
 async function prepareBuildFile(buildPath) {
   const resolvedPath = resolve8(buildPath);
-  if (resolvedPath.endsWith(".zip") && existsSync19(resolvedPath)) {
+  if (resolvedPath.endsWith(".zip") && existsSync20(resolvedPath)) {
     const buffer = await readFile4(resolvedPath);
     const uint8Array = new Uint8Array(buffer);
     const blob = new Blob([uint8Array], { type: "application/zip" });
@@ -9345,8 +9532,8 @@ async function deployGame(context2, shouldUploadBuild, shouldDeployBackend) {
     };
     const { getDirectorySize: getDirectorySize2 } = await Promise.resolve().then(() => (init_backend(), backend_exports));
     const [serverSize, dbSize] = await Promise.all([
-      getDirectorySize2(join23(context2.projectPath, "server")),
-      getDirectorySize2(join23(context2.projectPath, "db"))
+      getDirectorySize2(join24(context2.projectPath, "server")),
+      getDirectorySize2(join24(context2.projectPath, "db"))
     ]);
     backendMetadata = {
       backendBundleHash: hashContent(bundle.code),
@@ -9398,13 +9585,13 @@ async function deployGame(context2, shouldUploadBuild, shouldDeployBackend) {
 // src/lib/dev/backend.ts
 init_constants2();
 init_core();
-import { existsSync as existsSync20 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { join as join25 } from "path";
 function hasCustomRoutes(config) {
   const workspace = getWorkspace();
   const customRoutesConfig = config?.integrations?.customRoutes;
   const customRoutesDir = typeof customRoutesConfig === "object" && customRoutesConfig.directory || DEFAULT_API_ROUTES_DIRECTORY;
-  return existsSync20(join24(workspace, customRoutesDir));
+  return existsSync21(join25(workspace, customRoutesDir));
 }
 function needsBackend(config) {
   return !!config?.integrations || hasCustomRoutes(config);
@@ -9502,7 +9689,7 @@ function displayRegisteredRoutes(integrations, customRoutes = []) {
 // src/lib/dev/reload.ts
 init_constants2();
 init_core();
-import { join as join25, relative as relative4 } from "path";
+import { join as join26, relative as relative4 } from "path";
 import chokidar from "chokidar";
 import { bold as bold5, cyan as cyan3, dim as dim7, green as green3 } from "colorette";
 function formatTime() {
@@ -9519,9 +9706,9 @@ function startHotReload(onReload, options = {}) {
   const customRoutesConfig = options.config?.integrations?.customRoutes;
   const customRoutesDir = typeof customRoutesConfig === "object" && customRoutesConfig.directory || DEFAULT_API_ROUTES_DIRECTORY;
   const watchPaths = [
-    join25(workspace, customRoutesDir),
-    join25(workspace, "playcademy.config.js"),
-    join25(workspace, "playcademy.config.json")
+    join26(workspace, customRoutesDir),
+    join26(workspace, "playcademy.config.js"),
+    join26(workspace, "playcademy.config.json")
   ];
   const watcher = chokidar.watch(watchPaths, {
     persistent: true,
@@ -9563,14 +9750,14 @@ function startHotReload(onReload, options = {}) {
 // src/lib/dev/server.ts
 init_src2();
 import { mkdir as mkdir4 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 import { Log, LogLevel, Miniflare } from "miniflare";
 
 // ../utils/src/port.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync10 } from "node:fs";
 import { createServer as createServer2 } from "node:net";
 import { homedir as homedir3 } from "node:os";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 async function isPortAvailableOnHost(port, host) {
   return new Promise((resolve11) => {
     const server = createServer2();
@@ -9609,19 +9796,19 @@ async function findAvailablePort(startPort = 4321) {
 }
 function getRegistryPath() {
   const home = homedir3();
-  const dir = join26(home, ".playcademy");
-  if (!existsSync21(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = join27(home, ".playcademy");
+  if (!existsSync22(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
-  return join26(dir, ".proc");
+  return join27(dir, ".proc");
 }
 function readRegistry() {
   const registryPath = getRegistryPath();
-  if (!existsSync21(registryPath)) {
+  if (!existsSync22(registryPath)) {
     return {};
   }
   try {
-    const content = readFileSync10(registryPath, "utf-8");
+    const content = readFileSync11(registryPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -9796,7 +9983,7 @@ async function startDevServer(options) {
   return { server: mf, port };
 }
 async function ensureDatabaseDirectory() {
-  const dbDir = join27(getWorkspace(), CLI_DIRECTORIES.DATABASE);
+  const dbDir = join28(getWorkspace(), CLI_DIRECTORIES.DATABASE);
   try {
     await mkdir4(dbDir, { recursive: true });
   } catch (error) {
@@ -9805,7 +9992,7 @@ async function ensureDatabaseDirectory() {
   return dbDir;
 }
 async function ensureKvDirectory() {
-  const kvDir = join27(getWorkspace(), CLI_DIRECTORIES.KV);
+  const kvDir = join28(getWorkspace(), CLI_DIRECTORIES.KV);
   try {
     await mkdir4(kvDir, { recursive: true });
   } catch (error) {
@@ -9814,7 +10001,7 @@ async function ensureKvDirectory() {
   return kvDir;
 }
 async function ensureBucketDirectory() {
-  const bucketDir = join27(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join28(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   try {
     await mkdir4(bucketDir, { recursive: true });
   } catch (error) {
@@ -10107,7 +10294,7 @@ init_file_loader();
 init_constants2();
 import { writeFileSync as writeFileSync11 } from "fs";
 import { resolve as resolve9 } from "path";
-import { confirm as confirm3 } from "@inquirer/prompts";
+import { confirm as confirm4 } from "@inquirer/prompts";
 import { Command } from "commander";
 var configCommand = new Command("config").description("Create playcademy.config file").option("-f, --force", "Overwrite existing config file if it exists").action(async (options) => {
   try {
@@ -10122,7 +10309,7 @@ var configCommand = new Command("config").description("Create playcademy.config
         `Configuration file already exists: ${relativePath}`
       ]);
       logger.newLine();
-      const shouldOverwrite = await confirm3({
+      const shouldOverwrite = await confirm4({
         message: "Do you want to overwrite it?",
         default: false
       });
@@ -10196,7 +10383,7 @@ var initCommand = new Command2("init").description("Initialize a playcademy.conf
         `Configuration file already exists: ${relativePath}`
       ]);
       logger.newLine();
-      const shouldOverwrite = await confirm4({
+      const shouldOverwrite = await confirm5({
         message: "Do you want to overwrite it?",
         default: false
       });
@@ -10248,7 +10435,7 @@ var initCommand = new Command2("init").description("Initialize a playcademy.conf
         if (depsAdded) {
           const pm = detectPackageManager(getWorkspace());
           const installCmd = getInstallCommand(pm);
-          execSync6(installCmd, {
+          execSync7(installCmd, {
             cwd: getWorkspace(),
             stdio: ["ignore", "ignore", "ignore"]
           });
@@ -10298,7 +10485,7 @@ var initCommand = new Command2("init").description("Initialize a playcademy.conf
 });
 async function addPlaycademySdk() {
   const pkgPath = resolve10(getWorkspace(), "package.json");
-  const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
   const hasSdk = pkg.dependencies?.["@playcademy/sdk"] || pkg.devDependencies?.["@playcademy/sdk"];
   if (hasSdk) {
     return false;
@@ -10314,7 +10501,7 @@ initCommand.addCommand(configCommand);
 init_src();
 init_file_loader();
 init_constants2();
-import { input as input3, password, select as select3 } from "@inquirer/prompts";
+import { input as input3, password, select as select4 } from "@inquirer/prompts";
 import { bold as bold6, dim as dim8, whiteBright } from "colorette";
 import { Command as Command3 } from "commander";
 import open from "open";
@@ -10341,7 +10528,7 @@ var loginCommand = new Command3("login").description("Authenticate with Playcade
   }
   const hasEmailPassword = email || password2;
   const explicitMethod = sso ? "sso" : hasEmailPassword ? "email" : null;
-  const authMethod = explicitMethod || await select3({
+  const authMethod = explicitMethod || await select4({
     message: "Choose authentication method:",
     choices: [
       { value: "email", name: "Email/Password" },
@@ -10653,7 +10840,7 @@ import { Command as Command9 } from "commander";
 // src/commands/games/delete.ts
 init_src();
 init_string();
-import { confirm as confirm5, input as input4, select as select4 } from "@inquirer/prompts";
+import { confirm as confirm6, input as input4, select as select5 } from "@inquirer/prompts";
 import { Command as Command7 } from "commander";
 var deleteCommand = new Command7("delete").alias("rm").alias("remove").description("Delete a game").argument("[slug]", "Game slug to delete").option("-f, --force", "Skip confirmation prompt").option("--env <environment>", "Environment to delete game from (staging or production)").action(async (slug, options) => {
   const { env } = options;
@@ -10675,7 +10862,7 @@ var deleteCommand = new Command7("delete").alias("rm").alias("remove").descripti
     logger.newLine();
     let game;
     if (!slug) {
-      const selectedSlug = await select4({
+      const selectedSlug = await select5({
         message: "Select a game to delete:",
         choices: games2.map((g) => ({
           value: g.slug,
@@ -10690,7 +10877,7 @@ var deleteCommand = new Command7("delete").alias("rm").alias("remove").descripti
       }
     }
     if (!options.force) {
-      const confirmed = await confirm5({
+      const confirmed = await confirm6({
         message: "Are you sure you want to delete this game? This cannot be undone.",
         default: false
       });
@@ -11076,7 +11263,7 @@ import { Command as Command16 } from "commander";
 init_file_loader();
 init_constants2();
 import { writeFileSync as writeFileSync13 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { bold as bold7 } from "colorette";
 import { Command as Command14 } from "commander";
 var addAuthCommand = new Command14("add").description("Add an authentication provider to your project").argument("<provider>", "Provider to add: email | github | google").addHelpText(
@@ -11114,7 +11301,7 @@ Examples:
     logger.highlight(`Add ${providerDisplayName} Authentication`);
     logger.newLine();
     const workspace = getWorkspace();
-    const authPath = join28(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
+    const authPath = join29(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
     let authContent = await loadFile(authPath);
     if (!authContent) {
       logger.error("Authentication configuration not found");
@@ -11169,7 +11356,7 @@ Examples:
 
 // src/commands/auth/init.ts
 init_constants2();
-import { confirm as confirm6 } from "@inquirer/prompts";
+import { confirm as confirm7 } from "@inquirer/prompts";
 import { Command as Command15 } from "commander";
 init_writer();
 init_backend();
@@ -11193,7 +11380,7 @@ var initAuthCommand = new Command15("init").description("Add authentication to y
         "Authentication requires a database to store user sessions."
       ]);
       logger.newLine();
-      const shouldCreateDb = await confirm6({
+      const shouldCreateDb = await confirm7({
         message: "Create database?",
         default: true
       });
@@ -11400,9 +11587,9 @@ async function runDbInit() {
 
 // src/commands/db/reset.ts
 init_src();
-import { existsSync as existsSync22 } from "fs";
-import { join as join29 } from "path";
-import { confirm as confirm7, input as input7 } from "@inquirer/prompts";
+import { existsSync as existsSync23 } from "fs";
+import { join as join30 } from "path";
+import { confirm as confirm8, input as input7 } from "@inquirer/prompts";
 import { bold as bold8, redBright as redBright2, underline as underline3 } from "colorette";
 import { Miniflare as Miniflare2 } from "miniflare";
 init_constants2();
@@ -11427,7 +11614,7 @@ async function runDbResetRemote(options) {
     `This action is irreversible and ${underline3(bold8("cannot be undone"))}.`
   ]);
   logger.newLine();
-  const confirmed = await confirm7({
+  const confirmed = await confirm8({
     message: "Are you sure you want to reset this database? This cannot be undone.",
     default: false
   });
@@ -11481,8 +11668,8 @@ async function runDbResetRemote(options) {
 }
 async function runDbResetLocal(options) {
   const workspace = getWorkspace();
-  const dbDir = join29(workspace, CLI_DIRECTORIES.DATABASE);
-  if (!existsSync22(dbDir)) {
+  const dbDir = join30(workspace, CLI_DIRECTORIES.DATABASE);
+  if (!existsSync23(dbDir)) {
     logger.warn("No database found to reset");
     logger.newLine();
     logger.remark("Nothing to do");
@@ -11499,7 +11686,7 @@ async function runDbResetLocal(options) {
   }
   if (!options.force) {
     logger.newLine();
-    const shouldReset = await confirm7({
+    const shouldReset = await confirm8({
       message: "This will delete all local database data. Continue?",
       default: false
     });
@@ -11544,9 +11731,9 @@ async function runDbReset(options = {}) {
 // src/commands/db/seed.ts
 init_src();
 init_constants2();
-import { existsSync as existsSync23 } from "fs";
-import { join as join30 } from "path";
-import { confirm as confirm8, input as input8 } from "@inquirer/prompts";
+import { existsSync as existsSync24 } from "fs";
+import { join as join31 } from "path";
+import { confirm as confirm9, input as input8 } from "@inquirer/prompts";
 import { bold as bold9, redBright as redBright3, underline as underline4 } from "colorette";
 import { Miniflare as Miniflare3 } from "miniflare";
 async function runDbResetRemote2(gameSlug, environment) {
@@ -11604,7 +11791,7 @@ async function runDbSeedRemote(seedFile, options) {
   }
   logger.newLine();
   if (willReset) {
-    const confirmed = await confirm8({
+    const confirmed = await confirm9({
       message: "Are you sure you want to reset and seed this database? This cannot be undone.",
       default: false
     });
@@ -11631,7 +11818,7 @@ async function runDbSeedRemote(seedFile, options) {
       return;
     }
   } else {
-    const shouldSeed = await confirm8({
+    const shouldSeed = await confirm9({
       message: `Seed ${environment} database for ${game.slug}?`,
       default: false
     });
@@ -11665,7 +11852,7 @@ async function runDbSeedRemote(seedFile, options) {
 }
 async function runDbSeedLocal(seedFile, options) {
   const workspace = getWorkspace();
-  const dbDir = join30(workspace, CLI_DIRECTORIES.DATABASE);
+  const dbDir = join31(workspace, CLI_DIRECTORIES.DATABASE);
   const mf = new Miniflare3({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     d1Databases: [CLOUDFLARE_BINDINGS.DB],
@@ -11685,8 +11872,8 @@ async function runDbSeedLocal(seedFile, options) {
 async function runDbSeed(options = {}) {
   const workspace = getWorkspace();
   try {
-    const seedFile = options.file ? join30(workspace, options.file) : join30(workspace, DEFAULT_DATABASE_DIRECTORY, DEFAULT_SEED_FILE_NAME);
-    if (!existsSync23(seedFile)) {
+    const seedFile = options.file ? join31(workspace, options.file) : join31(workspace, DEFAULT_DATABASE_DIRECTORY, DEFAULT_SEED_FILE_NAME);
+    if (!existsSync24(seedFile)) {
       logger.newLine();
       logger.error(`Seed file not found: ${seedFile}`);
       logger.newLine();
@@ -11740,8 +11927,8 @@ import { Command as Command18 } from "commander";
 // src/commands/kv/clear.ts
 init_string();
 init_constants2();
-import { join as join31 } from "path";
-import { confirm as confirm9 } from "@inquirer/prompts";
+import { join as join32 } from "path";
+import { confirm as confirm10 } from "@inquirer/prompts";
 import { Miniflare as Miniflare4 } from "miniflare";
 async function runKVClear(options = {}) {
   try {
@@ -11773,7 +11960,7 @@ async function runKVClear(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join31(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join32(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare4({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -11803,7 +11990,7 @@ async function runKVClear(options = {}) {
       if (!options.force && !options.raw && !options.json) {
         logger.warn(`This will delete ${keyCount} ${pluralize(keyCount, "key")}`);
         logger.newLine();
-        const confirmed = await confirm9({
+        const confirmed = await confirm10({
           message: "Are you sure you want to clear all keys?",
           default: false
         });
@@ -11845,7 +12032,7 @@ async function runKVClear(options = {}) {
 
 // src/commands/kv/delete.ts
 init_constants2();
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 import { Miniflare as Miniflare5 } from "miniflare";
 async function runKVDelete(key, options = {}) {
   try {
@@ -11886,7 +12073,7 @@ async function runKVDelete(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join32(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join33(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare5({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -11923,7 +12110,7 @@ async function runKVDelete(key, options = {}) {
 
 // src/commands/kv/get.ts
 init_constants2();
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 import { Miniflare as Miniflare6 } from "miniflare";
 async function runKVGet(key, options = {}) {
   try {
@@ -11964,7 +12151,7 @@ async function runKVGet(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join33(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join34(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare6({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12098,7 +12285,7 @@ async function runKVInit() {
 
 // src/commands/kv/inspect.ts
 init_constants2();
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 import { Miniflare as Miniflare7 } from "miniflare";
 async function runKVInspect(key, options = {}) {
   try {
@@ -12139,7 +12326,7 @@ async function runKVInspect(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join34(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join35(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare7({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12227,7 +12414,7 @@ async function runKVInspect(key, options = {}) {
 // src/commands/kv/list.ts
 init_string();
 init_constants2();
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { Miniflare as Miniflare8 } from "miniflare";
 async function runKVList(options = {}) {
   try {
@@ -12259,7 +12446,7 @@ async function runKVList(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join35(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join36(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare8({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12308,8 +12495,8 @@ async function runKVList(options = {}) {
 init_file_loader();
 init_string();
 init_constants2();
-import { join as join36 } from "path";
-import { confirm as confirm10 } from "@inquirer/prompts";
+import { join as join37 } from "path";
+import { confirm as confirm11 } from "@inquirer/prompts";
 import { Miniflare as Miniflare9 } from "miniflare";
 async function runKVSeed(seedFile, options = {}) {
   try {
@@ -12374,7 +12561,7 @@ async function runKVSeed(seedFile, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join36(workspace, CLI_DIRECTORIES.KV);
+    const kvDir = join37(workspace, CLI_DIRECTORIES.KV);
     const mf = new Miniflare9({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12397,7 +12584,7 @@ async function runKVSeed(seedFile, options = {}) {
             `${existingKeys.length} ${pluralize(existingKeys.length, "key")} will be overwritten`
           );
           logger.newLine();
-          const confirmed = await confirm10({
+          const confirmed = await confirm11({
             message: "Continue seeding?",
             default: false
           });
@@ -12455,7 +12642,7 @@ async function runKVSeed(seedFile, options = {}) {
 // src/commands/kv/set.ts
 init_file_loader();
 init_constants2();
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { Miniflare as Miniflare10 } from "miniflare";
 async function runKVSet(key, value, options = {}) {
   try {
@@ -12525,7 +12712,7 @@ async function runKVSet(key, value, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join37(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join38(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare10({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12563,7 +12750,7 @@ async function runKVSet(key, value, options = {}) {
 // src/commands/kv/stats.ts
 init_string();
 init_constants2();
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 import { Miniflare as Miniflare11 } from "miniflare";
 async function runKVStats(options = {}) {
   try {
@@ -12595,7 +12782,7 @@ async function runKVStats(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join38(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join39(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare11({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12712,8 +12899,8 @@ import { Command as Command19 } from "commander";
 
 // src/commands/bucket/bulk.ts
 init_constants2();
-import { existsSync as existsSync24, statSync as statSync3 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync25, statSync as statSync3 } from "fs";
+import { join as join40 } from "path";
 import { Miniflare as Miniflare12 } from "miniflare";
 async function runBucketBulkRemote(directory, options) {
   const environment = ensureEnvironment(options.env);
@@ -12775,7 +12962,7 @@ async function runBucketBulkLocal(directory, options) {
     outputDryRunResults(files, totalSize, options.prefix, options.json, options.raw);
     return;
   }
-  const bucketDir = join39(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join40(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare12({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -12812,7 +12999,7 @@ async function runBucketBulk(directory, options = {}) {
     if (!options.raw && !options.json) {
       logger.newLine();
     }
-    if (!existsSync24(directory)) {
+    if (!existsSync25(directory)) {
       if (!options.raw && !options.json) {
         logger.error(`Directory not found: ${directory}`);
         logger.newLine();
@@ -12845,7 +13032,7 @@ async function runBucketBulk(directory, options = {}) {
 
 // src/commands/bucket/delete.ts
 init_constants2();
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import { Miniflare as Miniflare13 } from "miniflare";
 async function runBucketDeleteRemote(key, options) {
   const environment = ensureEnvironment(options.env);
@@ -12901,7 +13088,7 @@ async function runBucketDeleteLocal(key, options) {
     }
     process.exit(1);
   }
-  const bucketDir = join40(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join41(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare13({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -12965,7 +13152,7 @@ async function runBucketDelete(key, options = {}) {
 // src/commands/bucket/get.ts
 init_constants2();
 import { writeFileSync as writeFileSync14 } from "fs";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 import { Miniflare as Miniflare14 } from "miniflare";
 async function runBucketGetRemote(key, options) {
   const environment = ensureEnvironment(options.env);
@@ -13058,7 +13245,7 @@ async function runBucketGetLocal(key, options) {
     }
     process.exit(1);
   }
-  const bucketDir = join41(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join42(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare14({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -13218,7 +13405,7 @@ async function runBucketInit() {
 
 // src/commands/bucket/list.ts
 init_constants2();
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 import { Miniflare as Miniflare15 } from "miniflare";
 async function runBucketListRemote(options) {
   const environment = ensureEnvironment(options.env);
@@ -13285,7 +13472,7 @@ async function runBucketListLocal(options) {
     }
     process.exit(1);
   }
-  const bucketDir = join42(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join43(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare15({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -13370,8 +13557,8 @@ function formatBytes2(bytes) {
 
 // src/commands/bucket/put.ts
 init_constants2();
-import { readFileSync as readFileSync12, statSync as statSync4 } from "fs";
-import { join as join43 } from "path";
+import { readFileSync as readFileSync13, statSync as statSync4 } from "fs";
+import { join as join44 } from "path";
 import { Miniflare as Miniflare16 } from "miniflare";
 async function runBucketPutRemote(key, filePath, options) {
   const environment = ensureEnvironment(options.env);
@@ -13390,7 +13577,7 @@ async function runBucketPutRemote(key, filePath, options) {
   let fileBuffer;
   let fileSize;
   try {
-    fileBuffer = readFileSync12(filePath);
+    fileBuffer = readFileSync13(filePath);
     fileSize = statSync4(filePath).size;
   } catch {
     if (!options.raw && !options.json) {
@@ -13447,7 +13634,7 @@ async function runBucketPutLocal(key, filePath, options) {
   let fileBuffer;
   let fileSize;
   try {
-    fileBuffer = readFileSync12(filePath);
+    fileBuffer = readFileSync13(filePath);
     fileSize = statSync4(filePath).size;
   } catch {
     if (!options.raw && !options.json) {
@@ -13456,7 +13643,7 @@ async function runBucketPutLocal(key, filePath, options) {
     }
     process.exit(1);
   }
-  const bucketDir = join43(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join44(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare16({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -13598,7 +13785,7 @@ async function runDomainAdd(hostname, options) {
 }
 
 // src/commands/domain/delete.ts
-import { confirm as confirm11 } from "@inquirer/prompts";
+import { confirm as confirm12 } from "@inquirer/prompts";
 async function runDomainDelete(hostname, options) {
   try {
     logger.newLine();
@@ -13607,7 +13794,7 @@ async function runDomainDelete(hostname, options) {
     const config = await loadConfig();
     const slug = getSlugFromConfig(config);
     if (!options.force) {
-      const shouldDelete = await confirm11({
+      const shouldDelete = await confirm12({
         message: `Delete custom domain ${hostname}?`,
         default: false
       });
@@ -13751,7 +13938,7 @@ import { Command as Command24 } from "commander";
 
 // src/commands/secret/delete.ts
 init_src();
-import { confirm as confirm12 } from "@inquirer/prompts";
+import { confirm as confirm13 } from "@inquirer/prompts";
 import { Command as Command21 } from "commander";
 var deleteCommand2 = new Command21("delete").description("Delete a game secret").argument("<key>", "Secret key to delete").option("--env <environment>", "Environment (staging or production)").option("-f, --force", "Skip confirmation").action(async (key, options) => {
   const { env } = options;
@@ -13771,7 +13958,7 @@ var deleteCommand2 = new Command21("delete").description("Delete a game secret")
     }
     const game = await client.games.fetch(deployedGame.gameId);
     if (!options.force) {
-      const confirmed = await confirm12({
+      const confirmed = await confirm13({
         message: `Delete secret "${key}" from "${game.slug}" in ${environment}?`,
         default: false
       });
@@ -13965,7 +14152,7 @@ var removeCommand = new Command27("remove").alias("rm").description('Remove an a
 
 // src/commands/profiles/reset.ts
 init_string();
-import { confirm as confirm13 } from "@inquirer/prompts";
+import { confirm as confirm14 } from "@inquirer/prompts";
 import { Command as Command28 } from "commander";
 var resetCommand = new Command28("reset").description(
   "Remove all authentication profiles across all environments (requires confirmation)"
@@ -14003,7 +14190,7 @@ var resetCommand = new Command28("reset").description(
         logger.newLine();
       }
     }
-    const confirmed = await confirm13({
+    const confirmed = await confirm14({
       message: "Are you sure you want to remove all profiles?",
       default: false
     });
@@ -14053,7 +14240,7 @@ import { Command as Command35 } from "commander";
 
 // src/commands/timeback/cleanup.ts
 init_src();
-import { confirm as confirm14 } from "@inquirer/prompts";
+import { confirm as confirm15 } from "@inquirer/prompts";
 import { Command as Command30 } from "commander";
 var cleanupCommand = new Command30("cleanup").description("Remove TimeBack integration for your game").option(
   "--env <environment>",
@@ -14077,7 +14264,7 @@ var cleanupCommand = new Command30("cleanup").description("Remove TimeBack integ
       return;
     }
     displayCleanupWarning(integration, game.displayName, logger);
-    const confirmed = await confirm14({
+    const confirmed = await confirm15({
       message: "Are you sure you want to remove TimeBack integration?",
       default: false
     });
@@ -14248,7 +14435,7 @@ var setupCommand = new Command32("setup").description("Set up TimeBack integrati
 // src/commands/timeback/update.ts
 init_src();
 init_string();
-import { confirm as confirm15 } from "@inquirer/prompts";
+import { confirm as confirm16 } from "@inquirer/prompts";
 import { green as green4, red as red4 } from "colorette";
 import { Command as Command33 } from "commander";
 var updateCommand = new Command33("update").description("Update TimeBack integration configuration for your game").option("--verbose, -v", "Output detailed information").option(
@@ -14329,7 +14516,7 @@ var updateCommand = new Command33("update").description("Update TimeBack integra
       logger.data(change.label, `${red4(change.current)} \u2192 ${green4(change.next)}`, 1);
     }
     logger.newLine();
-    const confirmed = await confirm15({
+    const confirmed = await confirm16({
       message: `Update ${changeDetails.length} ${pluralize(changeDetails.length, "field")} in TimeBack?`,
       default: false
     });
@@ -14436,7 +14623,7 @@ import { Command as Command37 } from "commander";
 init_src();
 init_constants2();
 import { writeFileSync as writeFileSync15 } from "fs";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 import { Command as Command36 } from "commander";
 var bundleCommand = new Command36("bundle").description("Bundle and inspect the game backend worker code (for debugging)").option("-o, --output <path>", "Output file path", CLI_DEFAULT_OUTPUTS.WORKER_BUNDLE).option("--minify", "Minify the output").option("--sourcemap", "Include source maps").action(async (options) => {
   try {
@@ -14466,7 +14653,7 @@ var bundleCommand = new Command36("bundle").description("Bundle and inspect the
       }),
       (result) => `Bundled ${formatSize(result.code.length)}`
     );
-    const outputPath = join44(workspace, options.output);
+    const outputPath = join45(workspace, options.output);
     writeFileSync15(outputPath, bundle.code, "utf-8");
     logger.success(`Bundle saved to ${options.output}`);
     logger.newLine();
@@ -14515,7 +14702,7 @@ import { Command as Command38 } from "commander";
 // src/commands/vite/init.ts
 init_package_manager();
 import path3 from "node:path";
-import { confirm as confirm16 } from "@inquirer/prompts";
+import { confirm as confirm17 } from "@inquirer/prompts";
 import { dim as dim9, underline as underline7 } from "colorette";
 async function runViteInit() {
   try {
@@ -14525,7 +14712,7 @@ async function runViteInit() {
     if (!existingViteConfig) {
       logger.warn("No vite config file found in your project");
       logger.newLine();
-      const shouldCreate = await confirm16({
+      const shouldCreate = await confirm17({
         message: "Would you like to create a new vite.config.ts?",
         default: true
       });
@@ -14687,6 +14874,7 @@ export {
   getWebBaseUrl,
   getWorkspace,
   handleDomainNotFound,
+  handleGodotBuildPrompt,
   handleIntegrationConfigChanges,
   hasAuthSetup,
   hasBackendChanged,
@@ -14699,6 +14887,7 @@ export {
   hasOptionalFieldsMissing,
   hasPackageJson,
   hasSchemaChanged,
+  hasWebExportPreset,
   hashContent,
   hashDirectory,
   hashFile,
@@ -14707,6 +14896,7 @@ export {
   importTypescriptFile,
   installVitePlugin,
   integrationChangeDetectors,
+  isGodotProject,
   isIgnoredByGitignore,
   isNotFoundError,
   isPluginConfigured,