playcademy 0.14.21 → 0.14.23

package/dist/index.js

@@ -2196,10 +2196,15 @@ function getAddDevDependencyCommand(pm, packageName) {
 }
 
 // src/constants/api.ts
+import { join as join3 } from "node:path";
+
+// src/constants/server.ts
 import { join as join2 } from "node:path";
-var DEFAULT_API_ROUTES_DIRECTORY = join2("server", "api");
 var SERVER_ROOT_DIRECTORY = "server";
-var SERVER_LIB_DIRECTORY = join2("server", "lib");
+var SERVER_LIB_DIRECTORY = join2(SERVER_ROOT_DIRECTORY, "lib");
+
+// src/constants/api.ts
+var DEFAULT_API_ROUTES_DIRECTORY = join3(SERVER_ROOT_DIRECTORY, "api");
 var AUTH_API_SUBDIRECTORY = "auth";
 var SAMPLE_API_SUBDIRECTORY = "sample";
 var SAMPLE_CUSTOM_FILENAME = "custom.ts";
@@ -2340,12 +2345,20 @@ var ENV_FILES = [
   // Overrides all (highest priority)
 ];
 var ENV_EXAMPLE_FILE = ".env.example";
+var TSCONFIG_JSON = "tsconfig.json";
+var TSCONFIG_APP_JSON = "tsconfig.app.json";
 var TSCONFIG_FILES = [
-  "tsconfig.app.json",
+  TSCONFIG_APP_JSON,
   // Modern tooling (try first)
-  "tsconfig.json"
+  TSCONFIG_JSON
   // Standard (fallback)
 ];
+var TSCONFIG_REQUIRED_INCLUDES = [
+  "playcademy-env.d.ts",
+  // Generated type definitions
+  "server"
+  // Server-side code
+];
 
 // src/constants/bucket.ts
 var BUCKET_ALWAYS_SKIP = [".git", ".DS_Store", ".gitignore", ...ENV_FILES];
@@ -2363,8 +2376,8 @@ var CLOUDFLARE_BINDINGS = {
 var MINIFLARE_D1_DIRECTORY = "miniflare-D1DatabaseObject";
 
 // src/constants/database.ts
-import { join as join3 } from "path";
-var DEFAULT_DATABASE_DIRECTORY = join3("server", "db");
+import { join as join4 } from "path";
+var DEFAULT_DATABASE_DIRECTORY = join4("server", "db");
 var SCHEMA_SUBDIRECTORY = "schema";
 var DB_FILES = {
   /** Index file name */
@@ -2381,7 +2394,7 @@ var DB_FILES = {
 var DRIZZLE_CONFIG_FILES = ["drizzle.config.ts", "drizzle.config.js"];
 
 // src/constants/godot.ts
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 var GODOT_PROJECT_FILE = "project.godot";
 var GODOT_EXPORT_PRESETS_FILE = "export_presets.cfg";
 var GODOT_WEB_PLATFORM = 'platform="Web"';
@@ -2389,13 +2402,13 @@ var GODOT_BUILD_DIRECTORIES = {
   /** Root build directory (cleared before each export) */
   ROOT: "build",
   /** Web export subdirectory */
-  WEB: join4("build", "web")
+  WEB: join5("build", "web")
 };
 var GODOT_BUILD_OUTPUTS = {
   /** Exported web build entry point */
-  INDEX_HTML: join4("build", "web", "index.html"),
+  INDEX_HTML: join5("build", "web", "index.html"),
   /** Packaged zip file (created by Godot export) */
-  ZIP: join4("build", "web_playcademy.zip")
+  ZIP: join5("build", "web_playcademy.zip")
 };
 var GODOT_EXECUTABLE_PATTERNS = {
   /** macOS app bundle suffix */
@@ -2418,17 +2431,17 @@ var CALLBACK_PATH = "/callback";
 var SSO_AUTH_TIMEOUT_MS = 3e4;
 
 // src/constants/paths.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var WORKSPACE_NAME = ".playcademy";
 var CLI_DIRECTORIES = {
   /** Root directory for CLI artifacts in workspace */
   WORKSPACE: WORKSPACE_NAME,
   /** Database directory within workspace */
-  DATABASE: join5(WORKSPACE_NAME, "db"),
+  DATABASE: join6(WORKSPACE_NAME, "db"),
   /** KV storage directory within workspace */
-  KV: join5(WORKSPACE_NAME, "kv"),
+  KV: join6(WORKSPACE_NAME, "kv"),
   /** Bucket storage directory within workspace */
-  BUCKET: join5(WORKSPACE_NAME, "bucket")
+  BUCKET: join6(WORKSPACE_NAME, "bucket")
 };
 var CLI_USER_DIRECTORIES = {
   /** User config directory for auth, games store, etc. */
@@ -2436,7 +2449,7 @@ var CLI_USER_DIRECTORIES = {
 };
 var CLI_DEFAULT_OUTPUTS = {
   /** Default worker bundle output for debug command */
-  WORKER_BUNDLE: join5(WORKSPACE_NAME, "worker-bundle.js")
+  WORKER_BUNDLE: join6(WORKSPACE_NAME, "worker-bundle.js")
 };
 var CLI_FILES = {
   /** Auth store file in user config directory */
@@ -2471,7 +2484,7 @@ import { PlaycademyClient } from "@playcademy/sdk/internal";
 // src/lib/auth/storage.ts
 import { access, mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/lib/core/context.ts
 import { existsSync as existsSync3 } from "fs";
@@ -3501,10 +3514,10 @@ function getWebBaseUrl(apiBaseUrl) {
 
 // src/lib/auth/storage.ts
 function getAuthPath() {
-  return join6(homedir(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.AUTH_STORE);
+  return join7(homedir(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.AUTH_STORE);
 }
 async function ensureAuthDir() {
-  const authDir = join6(homedir(), CLI_USER_DIRECTORIES.CONFIG);
+  const authDir = join7(homedir(), CLI_USER_DIRECTORIES.CONFIG);
   await mkdir(authDir, { recursive: true });
 }
 function createEmptyEnvironmentProfiles() {
@@ -3737,7 +3750,7 @@ function formatErrorAndExit(error, code = 1) {
 // src/lib/secrets/env.ts
 init_file_loader();
 import { existsSync as existsSync4, writeFileSync } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function parseEnvFile(contents) {
   const secrets = {};
   for (const line of contents.split("\n")) {
@@ -3773,13 +3786,13 @@ async function readEnvFile(workspace) {
   return secrets;
 }
 function getLoadedEnvFiles(workspace) {
-  return ENV_FILES.filter((filename) => existsSync4(join7(workspace, filename)));
+  return ENV_FILES.filter((filename) => existsSync4(join8(workspace, filename)));
 }
 function hasEnvFile(workspace) {
-  return ENV_FILES.some((filename) => existsSync4(join7(workspace, filename)));
+  return ENV_FILES.some((filename) => existsSync4(join8(workspace, filename)));
 }
 async function updateEnvExample(workspace, lines) {
-  const envExamplePath = join7(workspace, ENV_EXAMPLE_FILE);
+  const envExamplePath = join8(workspace, ENV_EXAMPLE_FILE);
   let existing = "";
   if (existsSync4(envExamplePath)) {
     const loaded = await loadFile(envExamplePath);
@@ -5281,12 +5294,12 @@ async function getGameFromConfig(client) {
 
 // src/lib/core/gitignore.ts
 import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
-import { join as join8, sep } from "path";
+import { join as join9, sep } from "path";
 function normalizeGitignoreEntry(entry) {
   return entry.replace(/^\/+/, "").replace(/\/+$/, "");
 }
 function loadGitignorePatterns(directory) {
-  const gitignorePath = join8(directory, ".gitignore");
+  const gitignorePath = join9(directory, ".gitignore");
   if (!existsSync6(gitignorePath)) {
     return [];
   }
@@ -5327,12 +5340,12 @@ function isIgnoredByGitignore(filePath, patterns) {
 // src/lib/core/import.ts
 import { mkdtempSync, rmSync } from "fs";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { pathToFileURL } from "url";
 import * as esbuild from "esbuild";
 async function importTypescriptFile(filePath, bundleOptions) {
-  const tempDir = mkdtempSync(join9(tmpdir(), "playcademy-import-"));
-  const outFile = join9(tempDir, "bundle.mjs");
+  const tempDir = mkdtempSync(join10(tmpdir(), "playcademy-import-"));
+  const outFile = join10(tempDir, "bundle.mjs");
   try {
     await esbuild.build({
       entryPoints: [filePath],
@@ -5411,11 +5424,11 @@ import { bold as bold4, cyan as cyan2 } from "colorette";
 
 // src/lib/init/scaffold.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12, resolve as resolve5 } from "path";
+import { join as join13, resolve as resolve5 } from "path";
 
 // src/lib/init/auth.ts
 import { existsSync as existsSync7, mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var authTemplate = loadTemplateString("auth/auth.ts");
 var authCatchAllTemplate = loadTemplateString("auth/auth-catch-all.ts");
 var authSchemaTemplate = loadTemplateString("auth/auth-schema.ts");
@@ -5457,28 +5470,28 @@ function generateAuthConfig(strategies, gameName) {
   return authContent;
 }
 function scaffoldAuthConfig(workspace, authContent) {
-  const libDir = join10(workspace, SERVER_LIB_DIRECTORY);
+  const libDir = join11(workspace, SERVER_LIB_DIRECTORY);
   if (!existsSync7(libDir)) {
     mkdirSync(libDir, { recursive: true });
   }
-  writeFileSync3(join10(libDir, AUTH_CONFIG_FILE), authContent);
+  writeFileSync3(join11(libDir, AUTH_CONFIG_FILE), authContent);
 }
 function scaffoldAuthRoutes(workspace) {
-  const apiDir = join10(workspace, DEFAULT_API_ROUTES_DIRECTORY);
-  const authApiDir = join10(apiDir, AUTH_API_SUBDIRECTORY);
+  const apiDir = join11(workspace, DEFAULT_API_ROUTES_DIRECTORY);
+  const authApiDir = join11(apiDir, AUTH_API_SUBDIRECTORY);
   if (!existsSync7(authApiDir)) {
     mkdirSync(authApiDir, { recursive: true });
   }
-  writeFileSync3(join10(authApiDir, "[...all].ts"), authCatchAllTemplate);
+  writeFileSync3(join11(authApiDir, "[...all].ts"), authCatchAllTemplate);
 }
 function scaffoldAuthSchema(workspace) {
-  const dbDir = join10(workspace, DEFAULT_DATABASE_DIRECTORY);
-  const schemaDir = join10(dbDir, SCHEMA_SUBDIRECTORY);
+  const dbDir = join11(workspace, DEFAULT_DATABASE_DIRECTORY);
+  const schemaDir = join11(dbDir, SCHEMA_SUBDIRECTORY);
   if (!existsSync7(schemaDir)) {
     mkdirSync(schemaDir, { recursive: true });
   }
-  writeFileSync3(join10(schemaDir, "auth.ts"), authSchemaTemplate);
-  const schemaIndexPath = join10(schemaDir, DB_FILES.SCHEMA_INDEX);
+  writeFileSync3(join11(schemaDir, "auth.ts"), authSchemaTemplate);
+  const schemaIndexPath = join11(schemaDir, DB_FILES.SCHEMA_INDEX);
   if (existsSync7(schemaIndexPath)) {
     const existing = readFileSync4(schemaIndexPath, "utf-8");
     if (!existing.includes("export * from './auth'")) {
@@ -5489,12 +5502,12 @@ function scaffoldAuthSchema(workspace) {
   }
 }
 function scaffoldProtectedExample(workspace) {
-  const apiDir = join10(workspace, DEFAULT_API_ROUTES_DIRECTORY);
-  const sampleDir = join10(apiDir, SAMPLE_API_SUBDIRECTORY);
+  const apiDir = join11(workspace, DEFAULT_API_ROUTES_DIRECTORY);
+  const sampleDir = join11(apiDir, SAMPLE_API_SUBDIRECTORY);
   if (!existsSync7(sampleDir)) {
     mkdirSync(sampleDir, { recursive: true });
   }
-  writeFileSync3(join10(sampleDir, "protected.ts"), protectedRouteTemplate);
+  writeFileSync3(join11(sampleDir, "protected.ts"), protectedRouteTemplate);
 }
 function updateEnvForAuth(workspace, strategies) {
   const envLines = [];
@@ -5536,7 +5549,7 @@ async function scaffoldAuthSetup(options = {}) {
   return packagesUpdated;
 }
 async function setupPackageJson(workspace) {
-  const pkgPath = join10(workspace, "package.json");
+  const pkgPath = join11(workspace, "package.json");
   const authDeps = {
     "@playcademy/better-auth": PLAYCADEMY_AUTH_VERSION,
     "better-auth": BETTER_AUTH_VERSION
@@ -5557,18 +5570,18 @@ async function setupPackageJson(workspace) {
 }
 function hasAuthSetup() {
   const workspace = getWorkspace();
-  const authPath = join10(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
+  const authPath = join11(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
   return existsSync7(authPath);
 }
 
 // src/lib/init/database.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // package.json
 var package_default2 = {
   name: "playcademy",
-  version: "0.14.20",
+  version: "0.14.22",
   type: "module",
   exports: {
     ".": {
@@ -5659,25 +5672,25 @@ async function scaffoldDatabaseSetup(options) {
   await runStep(
     "Configuring database...",
     async () => {
-      const dbDir = join11(workspace, DEFAULT_DATABASE_DIRECTORY);
-      const schemaDir = join11(dbDir, SCHEMA_SUBDIRECTORY);
+      const dbDir = join12(workspace, DEFAULT_DATABASE_DIRECTORY);
+      const schemaDir = join12(dbDir, SCHEMA_SUBDIRECTORY);
       if (!existsSync8(dbDir)) {
         mkdirSync2(dbDir, { recursive: true });
       }
       if (!existsSync8(schemaDir)) {
         mkdirSync2(schemaDir, { recursive: true });
       }
-      const exampleSchemaPath = join11(schemaDir, DB_FILES.EXAMPLE_SCHEMA);
+      const exampleSchemaPath = join12(schemaDir, DB_FILES.EXAMPLE_SCHEMA);
       writeFileSync4(exampleSchemaPath, dbSchemaExampleTemplate);
-      const schemaIndexPath = join11(schemaDir, DB_FILES.SCHEMA_INDEX);
+      const schemaIndexPath = join12(schemaDir, DB_FILES.SCHEMA_INDEX);
       writeFileSync4(schemaIndexPath, dbSchemaIndexTemplate);
-      const dbIndexPath = join11(dbDir, DB_FILES.INDEX);
+      const dbIndexPath = join12(dbDir, DB_FILES.INDEX);
       writeFileSync4(dbIndexPath, dbIndexTemplate);
-      const dbTypesPath = join11(dbDir, DB_FILES.TYPES);
+      const dbTypesPath = join12(dbDir, DB_FILES.TYPES);
       writeFileSync4(dbTypesPath, dbTypesTemplate);
-      const dbSeedPath = join11(dbDir, DB_FILES.SEED);
+      const dbSeedPath = join12(dbDir, DB_FILES.SEED);
       writeFileSync4(dbSeedPath, dbSeedTemplate);
-      const drizzleConfigPath = join11(workspace, DRIZZLE_CONFIG_FILES[0]);
+      const drizzleConfigPath = join12(workspace, DRIZZLE_CONFIG_FILES[0]);
       writeFileSync4(drizzleConfigPath, drizzleConfigTemplate);
       packagesUpdated = await setupPackageJson2(workspace, options.gameName);
     },
@@ -5686,7 +5699,7 @@ async function scaffoldDatabaseSetup(options) {
   return packagesUpdated;
 }
 async function setupPackageJson2(workspace, gameName) {
-  const pkgPath = join11(workspace, "package.json");
+  const pkgPath = join12(workspace, "package.json");
   const dbDeps = {
     "drizzle-orm": "^0.42.0",
     "better-sqlite3": "^12.0.0"
@@ -5728,7 +5741,7 @@ async function setupPackageJson2(workspace, gameName) {
 }
 function hasDatabaseSetup() {
   const workspace = getWorkspace();
-  return DRIZZLE_CONFIG_FILES.some((filename) => existsSync8(join11(workspace, filename)));
+  return DRIZZLE_CONFIG_FILES.some((filename) => existsSync8(join12(workspace, filename)));
 }
 
 // src/lib/init/scaffold.ts
@@ -5739,7 +5752,7 @@ var sampleBucketRouteTemplate = loadTemplateString("api/sample-bucket.ts");
 var playcademyGitignoreTemplate = loadTemplateString("playcademy-gitignore");
 async function scaffoldApiDirectory(apiDirectory, sampleRoutes) {
   const apiPath = resolve5(getWorkspace(), apiDirectory);
-  const samplePath = join12(apiPath, "sample");
+  const samplePath = join13(apiPath, "sample");
   if (!existsSync9(apiPath)) {
     mkdirSync3(apiPath, { recursive: true });
   }
@@ -5747,7 +5760,7 @@ async function scaffoldApiDirectory(apiDirectory, sampleRoutes) {
     mkdirSync3(samplePath, { recursive: true });
   }
   for (const route of sampleRoutes) {
-    writeFileSync5(join12(samplePath, route.filename), route.template, "utf-8");
+    writeFileSync5(join13(samplePath, route.filename), route.template, "utf-8");
   }
 }
 async function scaffoldSampleFileIfMissing(config, sampleFilename, template) {
@@ -5763,7 +5776,7 @@ async function scaffoldSampleFileIfMissing(config, sampleFilename, template) {
   }
   await scaffoldApiDirectory(customRoutesDir, [{ filename: sampleFilename, template }]);
   logger.success(
-    `Created sample route: <${join12(customRoutesDir, SAMPLE_API_SUBDIRECTORY, sampleFilename)}>`
+    `Created sample route: <${join13(customRoutesDir, SAMPLE_API_SUBDIRECTORY, sampleFilename)}>`
   );
   return true;
 }
@@ -5776,11 +5789,11 @@ function validateApiDirectoryDoesNotExist(value) {
 }
 function ensurePlaycademyGitignore() {
   const workspace = getWorkspace();
-  const playcademyDir = join12(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyDir = join13(workspace, CLI_DIRECTORIES.WORKSPACE);
   if (!existsSync9(playcademyDir)) {
     mkdirSync3(playcademyDir, { recursive: true });
   }
-  const gitignorePath = join12(playcademyDir, ".gitignore");
+  const gitignorePath = join13(playcademyDir, ".gitignore");
   writeFileSync5(gitignorePath, playcademyGitignoreTemplate);
 }
 async function scaffoldIntegrations(gameName, options) {
@@ -6095,16 +6108,16 @@ function hasBucketSetup(config) {
 init_file_loader();
 import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync12, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname4, join as join15 } from "path";
+import { dirname as dirname4, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/deploy/backend.ts
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function getCustomRoutesDirectory(projectPath, config) {
   const customRoutes = config?.integrations?.customRoutes;
   const customRoutesDir = typeof customRoutes === "object" && customRoutes.directory || DEFAULT_API_ROUTES_DIRECTORY;
-  return join13(projectPath, customRoutesDir);
+  return join14(projectPath, customRoutesDir);
 }
 function hasLocalCustomRoutes(projectPath, config) {
   const customRoutesDir = getCustomRoutesDirectory(projectPath, config);
@@ -6121,7 +6134,7 @@ async function hasBackendChanged(previousHash, currentHash) {
 }
 async function getDirectorySize(dirPath) {
   const { stat: stat2, readdir } = await import("node:fs/promises");
-  const { join: join49 } = await import("node:path");
+  const { join: join50 } = await import("node:path");
   if (!existsSync10(dirPath)) {
     return null;
   }
@@ -6130,7 +6143,7 @@ async function getDirectorySize(dirPath) {
   async function calculateSize(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join49(dir, entry.name);
+      const fullPath = join50(dir, entry.name);
       if (entry.isDirectory()) {
         await calculateSize(fullPath);
       } else if (entry.isFile()) {
@@ -6149,15 +6162,22 @@ async function getDirectorySize(dirPath) {
 // src/lib/init/tsconfig.ts
 init_file_loader();
 import { existsSync as existsSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join14 } from "path";
-function hasPlaycademyEnv(config) {
-  return config.include?.includes("playcademy-env.d.ts") ?? false;
+import { join as join15 } from "path";
+function hasAllRequiredIncludes(config) {
+  if (!config.include) return false;
+  return TSCONFIG_REQUIRED_INCLUDES.every((entry) => config.include.includes(entry));
+}
+function getMissingIncludes(config) {
+  if (!config.include) return [...TSCONFIG_REQUIRED_INCLUDES];
+  return TSCONFIG_REQUIRED_INCLUDES.filter((entry) => !config.include.includes(entry));
 }
-function addPlaycademyEnv(config) {
+function addRequiredIncludes(config) {
   if (!config.include) {
     config.include = [];
   }
-  config.include.push("playcademy-env.d.ts");
+  for (const entry of getMissingIncludes(config)) {
+    config.include.push(entry);
+  }
 }
 function updateExistingIncludeArray(content) {
   const includeRegex = /"include"\s*:\s*\[([^\]]*)\]/;
@@ -6167,20 +6187,24 @@ function updateExistingIncludeArray(content) {
   }
   const fullMatch = match[0];
   const arrayContents = match[1];
-  if (arrayContents.includes("playcademy-env.d.ts")) {
+  const missingEntries = TSCONFIG_REQUIRED_INCLUDES.filter(
+    (entry) => !arrayContents.includes(entry)
+  );
+  if (missingEntries.length === 0) {
     return content;
   }
   const trimmedContents = arrayContents.trim();
-  const newEntry = '"playcademy-env.d.ts"';
+  const newEntries = missingEntries.map((entry) => `"${entry}"`);
   let newArrayContents;
   if (trimmedContents === "") {
-    newArrayContents = newEntry;
+    newArrayContents = newEntries.join(", ");
   } else if (arrayContents.includes("\n")) {
-    newArrayContents = `${arrayContents},
-        ${newEntry}
+    const entriesStr = newEntries.map((e) => `
+        ${e}`).join(",");
+    newArrayContents = `${arrayContents},${entriesStr}
     `;
   } else {
-    newArrayContents = `${trimmedContents}, ${newEntry}`;
+    newArrayContents = `${trimmedContents}, ${newEntries.join(", ")}`;
   }
   const newIncludeArray = `"include": [${newArrayContents}]`;
   return content.replace(fullMatch, newIncludeArray);
@@ -6195,9 +6219,10 @@ function addNewIncludeProperty(content) {
   const insertPosition = closingBraceMatch.index;
   const beforeClosing = content.slice(0, insertPosition).trim();
   const needsComma = beforeClosing.endsWith("]") || beforeClosing.endsWith("}") || beforeClosing.endsWith('"');
+  const entriesStr = TSCONFIG_REQUIRED_INCLUDES.map((e) => `"${e}"`).join(", ");
   const comma = needsComma ? "," : "";
   const includeEntry = `${comma}
-${propertyIndent}"include": ["playcademy-env.d.ts"]`;
+${propertyIndent}"include": [${entriesStr}]`;
   const updatedContent = content.slice(0, insertPosition) + includeEntry + content.slice(insertPosition);
   return updatedContent;
 }
@@ -6206,7 +6231,7 @@ function addToIncludeArrayPreservingComments(content) {
 }
 async function ensureTsconfigIncludes(workspace) {
   for (const filename of TSCONFIG_FILES) {
-    const configPath = join14(workspace, filename);
+    const configPath = join15(workspace, filename);
     if (!existsSync11(configPath)) {
       continue;
     }
@@ -6216,10 +6241,10 @@ async function ensureTsconfigIncludes(workspace) {
         stripComments: true
       });
       if (!config) continue;
-      if (config.references && filename !== "tsconfig.json") {
+      if (config.references && filename !== TSCONFIG_JSON) {
         continue;
       }
-      if (hasPlaycademyEnv(config)) {
+      if (hasAllRequiredIncludes(config)) {
         return filename;
       }
       try {
@@ -6231,7 +6256,7 @@ async function ensureTsconfigIncludes(workspace) {
         }
       } catch {
       }
-      addPlaycademyEnv(config);
+      addRequiredIncludes(config);
       writeFileSync6(configPath, JSON.stringify(config, null, 4) + "\n");
       return filename;
     } catch {
@@ -6256,8 +6281,8 @@ function hasAnyBackend(features) {
   return Object.values(features).some(Boolean);
 }
 async function setupPlaycademyDependencies(workspace) {
-  const playcademyDir = join15(workspace, CLI_DIRECTORIES.WORKSPACE);
-  const playcademyPkgPath = join15(playcademyDir, "package.json");
+  const playcademyDir = join16(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyPkgPath = join16(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";
@@ -6342,14 +6367,14 @@ async function ensurePlaycademyTypes(options = {}) {
     const bindingsStr = generateBindingsTypeString(features);
     const secretsStr = await generateSecretsTypeString(workspace, verbose);
     const hasAuth = !!config.integrations?.auth;
-    const hasAuthFile = existsSync12(join15(workspace, "server/lib/auth.ts"));
+    const hasAuthFile = existsSync12(join16(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 = join15(workspace, "playcademy-env.d.ts");
+    const envPath = join16(workspace, "playcademy-env.d.ts");
     writeFileSync7(envPath, envContent);
     if (verbose) {
       logger.success(`Generated <playcademy-env.d.ts>`);
@@ -6367,10 +6392,10 @@ async function ensurePlaycademyTypes(options = {}) {
 
 // src/lib/init/gitignore.ts
 import { existsSync as existsSync13, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var rootGitignoreTemplate = loadTemplateString("gitignore");
 function ensureRootGitignore(workspace = getWorkspace()) {
-  const gitignorePath = join16(workspace, ".gitignore");
+  const gitignorePath = join17(workspace, ".gitignore");
   if (!existsSync13(gitignorePath)) {
     writeFileSync8(gitignorePath, rootGitignoreTemplate);
     return;
@@ -6532,7 +6557,7 @@ var integrationChangeDetectors = {
 import { existsSync as existsSync14 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 // src/lib/deploy/hash.ts
 init_file_loader();
@@ -6573,10 +6598,10 @@ function hashContent(content) {
 
 // src/lib/games/storage.ts
 function getGamesStorePath() {
-  return join17(homedir2(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.GAMES_STORE);
+  return join18(homedir2(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.GAMES_STORE);
 }
 async function ensureConfigDir() {
-  const configDir = join17(homedir2(), CLI_USER_DIRECTORIES.CONFIG);
+  const configDir = join18(homedir2(), CLI_USER_DIRECTORIES.CONFIG);
   await mkdir2(configDir, { recursive: true });
 }
 async function loadGameStore() {
@@ -6720,12 +6745,12 @@ async function saveDeploymentState(game, backendMetadata, context2) {
 
 // src/lib/dev/backend.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } 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 existsSync15(join18(workspace, customRoutesDir));
+  return existsSync15(join19(workspace, customRoutesDir));
 }
 function needsBackend(config) {
   return !!config?.integrations || hasCustomRoutes(config);
@@ -6818,7 +6843,7 @@ function displayRegisteredRoutes(integrations, customRoutes = []) {
 }
 
 // src/lib/dev/reload.ts
-import { join as join19, relative } from "path";
+import { join as join20, relative } from "path";
 import chokidar from "chokidar";
 import { bold as bold5, cyan as cyan3, dim as dim5, green as green2 } from "colorette";
 function formatTime() {
@@ -6835,9 +6860,9 @@ function startHotReload(onReload, options = {}) {
   const customRoutesConfig = options.config?.integrations?.customRoutes;
   const customRoutesDir = typeof customRoutesConfig === "object" && customRoutesConfig.directory || DEFAULT_API_ROUTES_DIRECTORY;
   const watchPaths = [
-    join19(workspace, customRoutesDir),
-    join19(workspace, "playcademy.config.js"),
-    join19(workspace, "playcademy.config.json")
+    join20(workspace, customRoutesDir),
+    join20(workspace, "playcademy.config.js"),
+    join20(workspace, "playcademy.config.json")
   ];
   const watcher = chokidar.watch(watchPaths, {
     persistent: true,
@@ -6880,7 +6905,7 @@ function startHotReload(onReload, options = {}) {
 init_file_loader();
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join20, relative as relative2 } from "path";
+import { join as join21, relative as relative2 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function discoverRoutes(apiDir) {
   const files = scanDirectory(apiDir, {
@@ -6890,8 +6915,8 @@ async function discoverRoutes(apiDir) {
   const routes = await Promise.all(
     files.map(async (file) => {
       const routePath = filePathToRoutePath(file);
-      const absolutePath = join20(apiDir, file);
-      const relativePath = relative2(getWorkspace(), absolutePath);
+      const absolutePath = join21(apiDir, file);
+      const relativePath = relative2(getWorkspace(), absolutePath).replace(/\\/g, "/");
       const methods = await detectExportedMethods(absolutePath);
       return {
         path: routePath,
@@ -6952,10 +6977,10 @@ async function transpileRoute(filePath) {
   if (!result.outputFiles?.[0]) {
     throw new Error("Transpilation failed: no output");
   }
-  const tempDir = join20(tmpdir2(), "playcademy-dev");
+  const tempDir = join21(tmpdir2(), "playcademy-dev");
   await mkdir3(tempDir, { recursive: true });
   const hash = hashContent(filePath).slice(0, 12);
-  const jsPath = join20(tempDir, `${hash}.mjs`);
+  const jsPath = join21(tempDir, `${hash}.mjs`);
   await writeFile3(jsPath, result.outputFiles[0].text);
   return jsPath;
 }
@@ -6981,14 +7006,14 @@ async function registerCustomRoutes(app, routes) {
 // src/lib/dev/server.ts
 init_src();
 import { mkdir as mkdir4 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { Log, LogLevel, Miniflare } from "miniflare";
 
 // ../utils/src/port.ts
 import { existsSync as existsSync16, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "node:fs";
 import { createServer } from "node:net";
 import { homedir as homedir3 } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 async function isPortAvailableOnHost(port, host) {
   return new Promise((resolve11) => {
     const server = createServer();
@@ -7027,11 +7052,11 @@ async function findAvailablePort(startPort = 4321) {
 }
 function getRegistryPath() {
   const home = homedir3();
-  const dir = join21(home, ".playcademy");
+  const dir = join22(home, ".playcademy");
   if (!existsSync16(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
-  return join21(dir, ".proc");
+  return join22(dir, ".proc");
 }
 function readRegistry() {
   const registryPath = getRegistryPath();
@@ -7122,7 +7147,7 @@ function cleanupServerInfo(type, projectRoot, pid) {
 
 // src/lib/deploy/bundle.ts
 import { existsSync as existsSync17 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // ../edge-play/src/entry.ts
 var entry_default = "/**\n * Game Backend Entry Point\n *\n * This file is the main entry point for deployed game backends.\n * It creates a Hono app and registers all enabled integration routes.\n *\n * Bundled with esbuild and deployed to Cloudflare Workers (or AWS Lambda).\n * Config is injected at build time via esbuild's `define` option.\n *\n * DO NOT REMOVE any code wrapped by \u26A0\uFE0F BUILD_MARKER: <marker> \u26A0\uFE0F\n */\n\nimport { Hono } from 'hono'\n\nimport {\n    registerApiNotFoundHandler,\n    registerAssetFallback,\n    registerCors,\n    registerEnvSetup,\n    registerPlaycademyUser,\n    registerSdkInit,\n} from './entry/middleware'\nimport { setupProcessGlobal } from './entry/setup'\nimport { registerBuiltinRoutes } from './register-routes'\n\nimport type { RuntimeConfig } from './entry/types'\nimport type { HonoEnv } from './types'\n\n// DO NOT REMOVE THE BELOW COMMENT\n// \u26A0\uFE0F BUILD_MARKER: CUSTOM_ROUTE_IMPORTS \u26A0\uFE0F\n\n/**\n * Config injected at build time by esbuild\n *\n * The `declare const` tells TypeScript \"this exists at runtime, trust me.\"\n * During bundling, esbuild's `define` option does literal text replacement:\n *\n * Example bundling:\n *   Source:  if (PLAYCADEMY_CONFIG.integrations.timeback) { ... }\n *   Define:  { 'PLAYCADEMY_CONFIG': JSON.stringify({ integrations: { timeback: {...} } }) }\n *   Output:  if ({\"integrations\":{\"timeback\":{...}}}.integrations.timeback) { ... }\n *\n * This enables tree-shaking: if timeback is not configured, those code paths are removed.\n * The bundled Worker only includes the routes that are actually enabled.\n */\ndeclare const PLAYCADEMY_CONFIG: RuntimeConfig\n\n// Setup process global polyfill for SDK compatibility\nsetupProcessGlobal()\n\n// Create Hono app\nconst app = new Hono<HonoEnv>()\n\n// Register middleware\nregisterCors(app)\nregisterEnvSetup(app, PLAYCADEMY_CONFIG)\nregisterSdkInit(app, PLAYCADEMY_CONFIG)\nregisterPlaycademyUser(app)\n\n// DO NOT REMOVE THE BELOW COMMENT\n// \u26A0\uFE0F BUILD_MARKER: SESSION_MIDDLEWARE \u26A0\uFE0F\n\n// Register built-in integration routes based on enabled integrations\n// This function conditionally imports and registers routes like:\n// - GET /api (always included)\n// - GET /api/health (always included)\n// - POST /api/integrations/timeback/end-activity (if timeback enabled)\n//\n// Uses dynamic imports for tree-shaking: if an integration is not enabled,\n// its route code is completely removed from the bundle.\nawait registerBuiltinRoutes(app, PLAYCADEMY_CONFIG.integrations)\n\n// DO NOT REMOVE THE BELOW COMMENT\n// \u26A0\uFE0F BUILD_MARKER: CUSTOM_ROUTES \u26A0\uFE0F\n\n// Register API 404 handler\n// Returns JSON error for unmatched /api/* routes\n// Must be registered after all API routes\nregisterApiNotFoundHandler(app)\n\n// Register static asset fallback handler\n// Serves frontend assets from Workers Assets binding\n// MUST be registered last as it uses a wildcard GET route (app.get('*', ...))\n//\n// In production: Serves frontend assets from Workers Assets binding\n// In local dev: Returns 404 (Vite serves the frontend separately)\nregisterAssetFallback(app)\n\nexport default app\n";
@@ -7397,7 +7422,7 @@ async function discoverCustomRoutes(config) {
   const workspace = getWorkspace();
   const customRoutesConfig = config.integrations?.customRoutes;
   const customRoutesDir = typeof customRoutesConfig === "object" && customRoutesConfig.directory || DEFAULT_API_ROUTES_DIRECTORY;
-  const customRoutes = await discoverRoutes(join22(workspace, customRoutesDir));
+  const customRoutes = await discoverRoutes(join23(workspace, customRoutesDir));
   const customRouteData = customRoutes.map((r) => ({
     path: r.path,
     file: r.file,
@@ -7409,15 +7434,15 @@ async function discoverCustomRoutes(config) {
 function resolveEmbeddedSourcePaths() {
   const workspace = getWorkspace();
   const distDir = new URL(".", import.meta.url).pathname;
-  const embeddedEdgeSrc = join22(distDir, "edge-play", "src");
+  const embeddedEdgeSrc = join23(distDir, "edge-play", "src");
   const isBuiltPackage = existsSync17(embeddedEdgeSrc);
   const monorepoRoot = getMonorepoRoot();
-  const monorepoEdgeSrc = join22(monorepoRoot, "packages/edge-play/src");
+  const monorepoEdgeSrc = join23(monorepoRoot, "packages/edge-play/src");
   const edgePlaySrc = isBuiltPackage ? embeddedEdgeSrc : monorepoEdgeSrc;
-  const cliPackageRoot = isBuiltPackage ? join22(distDir, "../../..") : join22(monorepoRoot, "packages/cli");
-  const cliNodeModules = isBuiltPackage ? join22(cliPackageRoot, "node_modules") : monorepoRoot;
-  const workspaceNodeModules = join22(workspace, "node_modules");
-  const constantsEntry = isBuiltPackage ? join22(embeddedEdgeSrc, "..", "..", "constants", "src", "index.ts") : join22(monorepoRoot, "packages", "constants", "src", "index.ts");
+  const cliPackageRoot = isBuiltPackage ? join23(distDir, "../../..") : join23(monorepoRoot, "packages/cli");
+  const cliNodeModules = isBuiltPackage ? join23(cliPackageRoot, "node_modules") : monorepoRoot;
+  const workspaceNodeModules = join23(workspace, "node_modules");
+  const constantsEntry = isBuiltPackage ? join23(embeddedEdgeSrc, "..", "..", "constants", "src", "index.ts") : join23(monorepoRoot, "packages", "constants", "src", "index.ts");
   return {
     isBuiltPackage,
     edgePlaySrc,
@@ -7482,22 +7507,22 @@ function createEsbuildConfig(entryCode, paths, bundleConfig, customRoutesDir, op
       // │ Example: import * as route from '@game-api/hello.ts'            │
       // │ Resolves to: /user-project/server/api/hello.ts                  │
       // └─────────────────────────────────────────────────────────────────┘
-      "@game-api": join22(workspace, customRoutesDir),
+      "@game-api": join23(workspace, customRoutesDir),
       // ┌─ User's server lib directory ───────────────────────────────────┐
       // │ @game-server is a virtual module for server utilities/config    │
       // │ Example: import { getAuth } from '@game-server/lib/auth'        │
       // │ Resolves to: /user-project/server/lib/auth.ts                   │
       // └─────────────────────────────────────────────────────────────────┘
-      "@game-server": join22(workspace, "server"),
+      "@game-server": join23(workspace, "server"),
       // ┌─ Node.js polyfills for Cloudflare Workers ──────────────────────┐
       // │ Workers don't have fs, path, os, etc. Redirect to polyfills     │
       // │ that throw helpful errors if user code tries to use them.       │
       // └─────────────────────────────────────────────────────────────────┘
-      fs: join22(edgePlaySrc, "polyfills.js"),
-      "fs/promises": join22(edgePlaySrc, "polyfills.js"),
-      path: join22(edgePlaySrc, "polyfills.js"),
-      os: join22(edgePlaySrc, "polyfills.js"),
-      process: join22(edgePlaySrc, "polyfills.js")
+      fs: join23(edgePlaySrc, "polyfills.js"),
+      "fs/promises": join23(edgePlaySrc, "polyfills.js"),
+      path: join23(edgePlaySrc, "polyfills.js"),
+      os: join23(edgePlaySrc, "polyfills.js"),
+      process: join23(edgePlaySrc, "polyfills.js")
     },
     // ──── Build Plugins ────
     plugins: [textLoaderPlugin()],
@@ -7665,7 +7690,7 @@ async function startDevServer(options) {
   return { server: mf, port };
 }
 async function ensureDatabaseDirectory() {
-  const dbDir = join23(getWorkspace(), CLI_DIRECTORIES.DATABASE);
+  const dbDir = join24(getWorkspace(), CLI_DIRECTORIES.DATABASE);
   try {
     await mkdir4(dbDir, { recursive: true });
   } catch (error) {
@@ -7674,7 +7699,7 @@ async function ensureDatabaseDirectory() {
   return dbDir;
 }
 async function ensureKvDirectory() {
-  const kvDir = join23(getWorkspace(), CLI_DIRECTORIES.KV);
+  const kvDir = join24(getWorkspace(), CLI_DIRECTORIES.KV);
   try {
     await mkdir4(kvDir, { recursive: true });
   } catch (error) {
@@ -7683,7 +7708,7 @@ async function ensureKvDirectory() {
   return kvDir;
 }
 async function ensureBucketDirectory() {
-  const bucketDir = join23(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join24(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   try {
     await mkdir4(bucketDir, { recursive: true });
   } catch (error) {
@@ -8012,13 +8037,13 @@ function displayDeploymentDiff(options) {
 // src/lib/deploy/godot.ts
 import { execSync as execSync5 } from "child_process";
 import { existsSync as existsSync18, mkdirSync as mkdirSync5, readFileSync as readFileSync10, rmSync as rmSync2 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import { confirm as confirm2, select as select2 } from "@inquirer/prompts";
 function isGodotProject() {
-  return existsSync18(join24(getWorkspace(), GODOT_PROJECT_FILE));
+  return existsSync18(join25(getWorkspace(), GODOT_PROJECT_FILE));
 }
 function hasWebExportPreset() {
-  const presetsPath = join24(getWorkspace(), GODOT_EXPORT_PRESETS_FILE);
+  const presetsPath = join25(getWorkspace(), GODOT_EXPORT_PRESETS_FILE);
   if (!existsSync18(presetsPath)) {
     return { configured: false };
   }
@@ -8074,7 +8099,7 @@ async function findGodotExecutable() {
       const apps = result.split("\n").filter(Boolean);
       for (const appPath of apps) {
         if (seenAppBundles.has(appPath)) continue;
-        const executable = join24(appPath, GODOT_EXECUTABLE_PATTERNS.MACOS_APP_EXECUTABLE);
+        const executable = join25(appPath, GODOT_EXECUTABLE_PATTERNS.MACOS_APP_EXECUTABLE);
         const appName = appPath.split("/").pop() || "Godot";
         foundExecutables.push({ path: executable, label: appName });
       }
@@ -8136,11 +8161,11 @@ async function findGodotExecutable() {
 async function runGodotExport(godotPath, presetName, outputPath) {
   const root = getWorkspace();
   try {
-    const buildDir = join24(root, GODOT_BUILD_DIRECTORIES.ROOT);
+    const buildDir = join25(root, GODOT_BUILD_DIRECTORIES.ROOT);
     if (existsSync18(buildDir)) {
       rmSync2(buildDir, { recursive: true, force: true });
     }
-    mkdirSync5(join24(root, GODOT_BUILD_DIRECTORIES.WEB), { recursive: true });
+    mkdirSync5(join25(root, GODOT_BUILD_DIRECTORIES.WEB), { recursive: true });
     await runStep(
       `Exporting project using "${presetName}" preset`,
       async () => {
@@ -8196,7 +8221,7 @@ async function handleGodotBuildPrompt() {
     logger.newLine();
     return null;
   }
-  if (existsSync18(join24(getWorkspace(), GODOT_BUILD_OUTPUTS.ZIP))) {
+  if (existsSync18(join25(getWorkspace(), GODOT_BUILD_OUTPUTS.ZIP))) {
     return GODOT_BUILD_OUTPUTS.ZIP;
   }
   logger.warn("Expected zip file not found, using build directory");
@@ -8209,10 +8234,10 @@ import { confirm as confirm3, input as input2, select as select3 } from "@inquir
 
 // src/lib/deploy/build-discovery.ts
 init_file_loader();
-import { join as join25, relative as relative3 } from "path";
+import { join as join26, relative as relative3 } from "path";
 function findSingleBuildZip() {
   const workspace = getWorkspace();
-  const playcademyDir = join25(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyDir = join26(workspace, CLI_DIRECTORIES.WORKSPACE);
   const zipFiles = findFilesByExtension(playcademyDir, "zip");
   if (zipFiles.length === 1) {
     return zipFiles[0] ? relative3(workspace, zipFiles[0]) : null;
@@ -8223,7 +8248,7 @@ function findSingleBuildZip() {
 // src/lib/deploy/schema.ts
 import { existsSync as existsSync19 } from "fs";
 import { createRequire } from "module";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 async function getDatabaseDirectory() {
   try {
     const config = await loadConfig();
@@ -8251,7 +8276,7 @@ async function getSchemaInfo(previousSchemaSnapshot) {
     return null;
   }
   const dbDirectory = await getDatabaseDirectory();
-  const schemaPath = join26(workspace, dbDirectory, SCHEMA_SUBDIRECTORY, DB_FILES.SCHEMA_INDEX);
+  const schemaPath = join27(workspace, dbDirectory, SCHEMA_SUBDIRECTORY, DB_FILES.SCHEMA_INDEX);
   if (!existsSync19(schemaPath)) {
     return null;
   }
@@ -8630,7 +8655,7 @@ function reportCancellation() {
 
 // src/lib/deploy/preparation.ts
 import { stat } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 
 // ../data/src/domains/game/helpers.ts
 var isHostedGame = (game) => {
@@ -9278,8 +9303,8 @@ async function analyzeChanges(context2) {
         const bundle = await bundleBackend(context2.fullConfig);
         const bundleHash = hashContent(bundle.code);
         const [serverSize, dbSize] = await Promise.all([
-          getDirectorySize(join27(projectPath, SERVER_ROOT_DIRECTORY)),
-          getDirectorySize(join27(projectPath, DEFAULT_DATABASE_DIRECTORY))
+          getDirectorySize(join28(projectPath, SERVER_ROOT_DIRECTORY)),
+          getDirectorySize(join28(projectPath, DEFAULT_DATABASE_DIRECTORY))
         ]);
         context2.currentBackendBundleHash = bundleHash;
         context2.currentBackendSize = bundle.code.length;
@@ -9402,7 +9427,7 @@ function hasOptionalFieldsMissing(missing) {
 // src/lib/deploy/steps.ts
 import { existsSync as existsSync21 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
-import { basename as basename2, join as join28, resolve as resolve8 } from "path";
+import { basename as basename2, join as join29, resolve as resolve8 } from "path";
 
 // src/lib/deploy/stub.ts
 import * as esbuild2 from "esbuild";
@@ -9619,8 +9644,8 @@ async function deployGame(context2, shouldUploadBuild, shouldDeployBackend) {
       secrets: Object.keys(deploymentPrep.secrets).length > 0 ? deploymentPrep.secrets : void 0
     };
     const [serverSize, dbSize] = await Promise.all([
-      getDirectorySize(join28(context2.projectPath, SERVER_ROOT_DIRECTORY)),
-      getDirectorySize(join28(context2.projectPath, DEFAULT_DATABASE_DIRECTORY))
+      getDirectorySize(join29(context2.projectPath, SERVER_ROOT_DIRECTORY)),
+      getDirectorySize(join29(context2.projectPath, DEFAULT_DATABASE_DIRECTORY))
     ]);
     backendMetadata = {
       backendBundleHash: hashContent(bundle.code),
@@ -9681,7 +9706,7 @@ async function deployGame(context2, shouldUploadBuild, shouldDeployBackend) {
 
 // src/lib/db/path.ts
 import { copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync6, readdirSync as readdirSync2, unlinkSync } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var DB_DIRECTORY = CLI_DIRECTORIES.DATABASE;
 var INITIAL_DB_NAME = CLI_FILES.INITIAL_DATABASE;
 var ensureDirectoryExists = (dir) => {
@@ -9690,11 +9715,11 @@ var ensureDirectoryExists = (dir) => {
   }
 };
 var findMiniflareDatabase = (dbDir) => {
-  const miniflareDir = join29(dbDir, MINIFLARE_D1_DIRECTORY);
+  const miniflareDir = join30(dbDir, MINIFLARE_D1_DIRECTORY);
   if (!existsSync22(miniflareDir)) return null;
   const sqliteFiles = readdirSync2(miniflareDir).filter((file) => file.endsWith(".sqlite"));
   if (sqliteFiles.length === 0) return null;
-  return join29(miniflareDir, sqliteFiles[0]);
+  return join30(miniflareDir, sqliteFiles[0]);
 };
 var migrateInitialDbToTarget = (initialPath, targetPath) => {
   if (!existsSync22(initialPath)) return;
@@ -9702,7 +9727,7 @@ var migrateInitialDbToTarget = (initialPath, targetPath) => {
   unlinkSync(initialPath);
 };
 function getDevDbPath() {
-  const initialDbPath = join29(DB_DIRECTORY, INITIAL_DB_NAME);
+  const initialDbPath = join30(DB_DIRECTORY, INITIAL_DB_NAME);
   ensureDirectoryExists(DB_DIRECTORY);
   const miniflareDbPath = findMiniflareDatabase(DB_DIRECTORY);
   if (miniflareDbPath) {
@@ -9766,10 +9791,10 @@ async function bundleSeedWorker(seedFilePath, projectPath) {
 // src/lib/db/reset.ts
 import { execSync as execSync6 } from "child_process";
 import { rmSync as rmSync3 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 async function resetDatabase(workspace, mf, options = { debug: false }) {
   const { debug } = options;
-  const dbDir = join30(workspace, CLI_DIRECTORIES.DATABASE);
+  const dbDir = join31(workspace, CLI_DIRECTORIES.DATABASE);
   await runStep(
     "Resetting database...",
     async () => {
@@ -10028,7 +10053,7 @@ import { dim as dim7 } from "colorette";
 
 // src/lib/bucket/collect.ts
 import { readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join31, relative as relative4, sep as sep2 } from "path";
+import { join as join32, relative as relative4, sep as sep2 } from "path";
 function shouldSkipFile(filePath, baseDir, gitignorePatterns) {
   const relativePath = relative4(baseDir, filePath);
   const pathParts = relativePath.split(sep2);
@@ -10043,7 +10068,7 @@ function collectFiles(directory, baseDir, gitignorePatterns) {
   try {
     const entries = readdirSync3(directory, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join31(directory, entry.name);
+      const fullPath = join32(directory, entry.name);
       if (shouldSkipFile(fullPath, baseDir, gitignorePatterns)) {
         continue;
       }
@@ -10783,11 +10808,11 @@ async function addPlaycademySdk() {
 initCommand.addCommand(configCommand);
 
 // src/commands/login.ts
+import { userInfo } from "os";
 import { input as input3, password, select as select4 } from "@inquirer/prompts";
 import { bold as bold8, dim as dim8, whiteBright } from "colorette";
 import { Command as Command3 } from "commander";
 import open from "open";
-init_file_loader();
 var loginCommand = new Command3("login").description("Authenticate with Playcademy").option("-e, --email <email>", "Email address (for email/password auth)").option("-p, --password <password>", "Password (for email/password auth)").option("--sso", "Use Timeback SSO authentication").option("--env <environment>", "Environment to login to (staging or production)").action(async (options) => {
   const { email, password: password2, sso, env } = options;
   const environment = ensureEnvironment(env);
@@ -10844,10 +10869,9 @@ var loginCommand = new Command3("login").description("Authenticate with Playcade
     const apiKeyResult = await runStep(
       "Creating API key for CLI usage",
       async () => {
-        const pkg = await loadPackageJson({ required: false });
-        const nameVersion = pkg ? getPackageNameVersionFromData(pkg) : `${getCurrentDirectoryName("playcademy-cli")}@0.0.0`;
+        const username = userInfo().username.substring(0, 32);
         const result = await client.auth.apiKeys.create({
-          name: nameVersion,
+          name: username,
           expiresIn: null,
           // No expiration
           permissions: {
@@ -10911,10 +10935,9 @@ async function handleSsoLogin(environment, profileName) {
     const apiKeyResult = await runStep(
       "Creating API key for CLI usage",
       async () => {
-        const pkg = await loadPackageJson({ required: false });
-        const nameVersion = pkg ? getPackageNameVersionFromData(pkg) : `${getCurrentDirectoryName("playcademy-cli")}@0.0.0`;
+        const username = userInfo().username.substring(0, 32);
         const response = await client.auth.apiKeys.create({
-          name: nameVersion,
+          name: username,
           expiresIn: null,
           permissions: {
             games: ["read", "write", "delete"],
@@ -11575,7 +11598,7 @@ import { Command as Command17 } from "commander";
 // src/commands/auth/add.ts
 init_file_loader();
 import { writeFileSync as writeFileSync13 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 import { bold as bold10 } from "colorette";
 import { Command as Command15 } from "commander";
 var addAuthCommand = new Command15("add").description("Add an authentication provider to your project").argument("<provider>", "Provider to add: email | github | google").addHelpText(
@@ -11613,7 +11636,7 @@ Examples:
     logger.highlight(`Add ${providerDisplayName} Authentication`);
     logger.newLine();
     const workspace = getWorkspace();
-    const authPath = join32(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
+    const authPath = join33(workspace, SERVER_LIB_DIRECTORY, AUTH_CONFIG_FILE);
     let authContent = await loadFile(authPath);
     if (!authContent) {
       logger.error("Authentication configuration not found");
@@ -11891,7 +11914,7 @@ async function runDbInit() {
 
 // src/commands/db/reset.ts
 import { existsSync as existsSync23 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 import { confirm as confirm8, input as input7 } from "@inquirer/prompts";
 import { bold as bold11, redBright as redBright4, underline as underline3 } from "colorette";
 import { Miniflare as Miniflare2 } from "miniflare";
@@ -11970,7 +11993,7 @@ async function runDbResetRemote(options) {
 }
 async function runDbResetLocal(options) {
   const workspace = getWorkspace();
-  const dbDir = join33(workspace, CLI_DIRECTORIES.DATABASE);
+  const dbDir = join34(workspace, CLI_DIRECTORIES.DATABASE);
   logger.newLine();
   if (!existsSync23(dbDir)) {
     logger.warn("No database found to reset");
@@ -12032,7 +12055,7 @@ async function runDbReset(options = {}) {
 
 // src/commands/db/seed.ts
 import { existsSync as existsSync24 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 import { confirm as confirm9, input as input8 } from "@inquirer/prompts";
 import { bold as bold12, redBright as redBright5, underline as underline4 } from "colorette";
 import { Miniflare as Miniflare3 } from "miniflare";
@@ -12152,12 +12175,12 @@ async function runDbSeedRemote(seedFile, options) {
 }
 async function runDbSeedLocal(seedFile, options) {
   const workspace = getWorkspace();
-  const dbDir = join34(workspace, CLI_DIRECTORIES.DATABASE);
+  const dbDir = join35(workspace, CLI_DIRECTORIES.DATABASE);
   const config = await loadConfig();
   const hasBucket = hasBucketSetup(config);
   const hasKV = hasKVSetup(config);
-  const bucketDir = hasBucket ? join34(workspace, CLI_DIRECTORIES.BUCKET) : void 0;
-  const kvDir = hasKV ? join34(workspace, CLI_DIRECTORIES.KV) : void 0;
+  const bucketDir = hasBucket ? join35(workspace, CLI_DIRECTORIES.BUCKET) : void 0;
+  const kvDir = hasKV ? join35(workspace, CLI_DIRECTORIES.KV) : void 0;
   if (bucketDir) {
     const { mkdir: mkdir5 } = await import("fs/promises");
     await mkdir5(bucketDir, { recursive: true });
@@ -12199,7 +12222,7 @@ async function runDbSeedLocal(seedFile, options) {
 async function runDbSeed(options = {}) {
   const workspace = getWorkspace();
   try {
-    const seedFile = options.file ? join34(workspace, options.file) : join34(workspace, DEFAULT_DATABASE_DIRECTORY, DB_FILES.SEED);
+    const seedFile = options.file ? join35(workspace, options.file) : join35(workspace, DEFAULT_DATABASE_DIRECTORY, DB_FILES.SEED);
     if (!existsSync24(seedFile)) {
       logger.newLine();
       logger.error(`Seed file not found: ${seedFile}`);
@@ -12252,7 +12275,7 @@ dbCommand.command("diff").description("Show schema changes since last deployment
 import { Command as Command19 } from "commander";
 
 // src/commands/kv/clear.ts
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { confirm as confirm10 } from "@inquirer/prompts";
 import { Miniflare as Miniflare4 } from "miniflare";
 async function runKVClear(options = {}) {
@@ -12285,7 +12308,7 @@ async function runKVClear(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join35(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join36(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare4({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12356,7 +12379,7 @@ async function runKVClear(options = {}) {
 }
 
 // src/commands/kv/delete.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 import { Miniflare as Miniflare5 } from "miniflare";
 async function runKVDelete(key, options = {}) {
   try {
@@ -12397,7 +12420,7 @@ async function runKVDelete(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join36(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join37(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare5({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12433,7 +12456,7 @@ async function runKVDelete(key, options = {}) {
 }
 
 // src/commands/kv/get.ts
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { Miniflare as Miniflare6 } from "miniflare";
 async function runKVGet(key, options = {}) {
   try {
@@ -12474,7 +12497,7 @@ async function runKVGet(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join37(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join38(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare6({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12603,7 +12626,7 @@ async function runKVInit() {
 }
 
 // src/commands/kv/inspect.ts
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 import { Miniflare as Miniflare7 } from "miniflare";
 async function runKVInspect(key, options = {}) {
   try {
@@ -12644,7 +12667,7 @@ async function runKVInspect(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join38(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join39(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare7({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12730,7 +12753,7 @@ async function runKVInspect(key, options = {}) {
 }
 
 // src/commands/kv/list.ts
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 import { Miniflare as Miniflare8 } from "miniflare";
 async function runKVList(options = {}) {
   try {
@@ -12762,7 +12785,7 @@ async function runKVList(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join39(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join40(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare8({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12809,7 +12832,7 @@ async function runKVList(options = {}) {
 
 // src/commands/kv/seed.ts
 init_file_loader();
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import { confirm as confirm11 } from "@inquirer/prompts";
 import { Miniflare as Miniflare9 } from "miniflare";
 async function runKVSeed(seedFile, options = {}) {
@@ -12875,7 +12898,7 @@ async function runKVSeed(seedFile, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join40(workspace, CLI_DIRECTORIES.KV);
+    const kvDir = join41(workspace, CLI_DIRECTORIES.KV);
     const mf = new Miniflare9({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -12955,7 +12978,7 @@ async function runKVSeed(seedFile, options = {}) {
 
 // src/commands/kv/set.ts
 init_file_loader();
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 import { Miniflare as Miniflare10 } from "miniflare";
 async function runKVSet(key, value, options = {}) {
   try {
@@ -13025,7 +13048,7 @@ async function runKVSet(key, value, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join41(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join42(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare10({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -13061,7 +13084,7 @@ async function runKVSet(key, value, options = {}) {
 }
 
 // src/commands/kv/stats.ts
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 import { Miniflare as Miniflare11 } from "miniflare";
 async function runKVStats(options = {}) {
   try {
@@ -13093,7 +13116,7 @@ async function runKVStats(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join42(getWorkspace(), CLI_DIRECTORIES.KV);
+    const kvDir = join43(getWorkspace(), CLI_DIRECTORIES.KV);
     const mf = new Miniflare11({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
       kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
@@ -13210,7 +13233,7 @@ import { Command as Command20 } from "commander";
 
 // src/commands/bucket/bulk.ts
 import { existsSync as existsSync25, statSync as statSync3 } from "fs";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 import { Miniflare as Miniflare12 } from "miniflare";
 async function runBucketBulkRemote(directory, options) {
   const environment = ensureEnvironment(options.env);
@@ -13272,7 +13295,7 @@ async function runBucketBulkLocal(directory, options) {
     outputDryRunResults(files, totalSize, options.prefix, options.json, options.raw);
     return;
   }
-  const bucketDir = join43(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join44(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare12({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -13351,7 +13374,7 @@ async function runBucketBulk(directory, options = {}) {
 }
 
 // src/commands/bucket/delete.ts
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 import { Miniflare as Miniflare13 } from "miniflare";
 async function runBucketDeleteRemote(key, options) {
   const environment = ensureEnvironment(options.env);
@@ -13407,7 +13430,7 @@ async function runBucketDeleteLocal(key, options) {
     }
     process.exit(1);
   }
-  const bucketDir = join44(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join45(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare13({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -13470,7 +13493,7 @@ async function runBucketDelete(key, options = {}) {
 
 // src/commands/bucket/get.ts
 import { writeFileSync as writeFileSync14 } from "fs";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 import { Miniflare as Miniflare14 } from "miniflare";
 async function runBucketGetRemote(key, options) {
   const environment = ensureEnvironment(options.env);
@@ -13563,7 +13586,7 @@ async function runBucketGetLocal(key, options) {
     }
     process.exit(1);
   }
-  const bucketDir = join45(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join46(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare14({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -13718,7 +13741,7 @@ async function runBucketInit() {
 }
 
 // src/commands/bucket/list.ts
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 import { Miniflare as Miniflare15 } from "miniflare";
 async function runBucketListRemote(options) {
   const environment = ensureEnvironment(options.env);
@@ -13785,7 +13808,7 @@ async function runBucketListLocal(options) {
     }
     process.exit(1);
   }
-  const bucketDir = join46(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join47(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare15({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -13869,7 +13892,7 @@ function formatBytes2(bytes) {
 
 // src/commands/bucket/put.ts
 import { readFileSync as readFileSync13, statSync as statSync4 } from "fs";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 import { Miniflare as Miniflare16 } from "miniflare";
 async function runBucketPutRemote(key, filePath, options) {
   const environment = ensureEnvironment(options.env);
@@ -13954,7 +13977,7 @@ async function runBucketPutLocal(key, filePath, options) {
     }
     process.exit(1);
   }
-  const bucketDir = join47(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join48(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   const mf = new Miniflare16({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
     r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
@@ -14892,7 +14915,7 @@ import { Command as Command38 } from "commander";
 
 // src/commands/debug/bundle.ts
 import { writeFileSync as writeFileSync15 } from "fs";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 import { Command as Command37 } from "commander";
 var bundleCommand = new Command37("bundle").description("Bundle and inspect the project 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 {
@@ -14922,7 +14945,7 @@ var bundleCommand = new Command37("bundle").description("Bundle and inspect the
       }),
       (result) => `Bundled ${formatSize(result.code.length)}`
     );
-    const outputPath = join48(workspace, options.output);
+    const outputPath = join49(workspace, options.output);
     writeFileSync15(outputPath, bundle.code, "utf-8");
     logger.success(`Bundle saved to ${options.output}`);
     logger.newLine();