playcademy 0.13.22 → 0.14.0

package/dist/index.js

@@ -2130,10 +2130,43 @@ var init_config = __esm({
   }
 });
 
+// src/constants/bucket.ts
+var BUCKET_ALWAYS_SKIP;
+var init_bucket = __esm({
+  "src/constants/bucket.ts"() {
+    "use strict";
+    init_config();
+    BUCKET_ALWAYS_SKIP = [".git", ".DS_Store", ".gitignore", ...ENV_FILES];
+  }
+});
+
+// src/constants/cloudflare.ts
+var CLOUDFLARE_COMPATIBILITY_DATE, CLOUDFLARE_BINDINGS, MINIFLARE_D1_DIRECTORY;
+var init_cloudflare = __esm({
+  "src/constants/cloudflare.ts"() {
+    "use strict";
+    CLOUDFLARE_COMPATIBILITY_DATE = "2024-01-01";
+    CLOUDFLARE_BINDINGS = {
+      /** R2 bucket binding name */
+      BUCKET: "BUCKET",
+      /** KV namespace binding name */
+      KV: "KV",
+      /** D1 database binding name */
+      DB: "DB"
+    };
+    MINIFLARE_D1_DIRECTORY = "miniflare-D1DatabaseObject";
+  }
+});
+
 // src/constants/database.ts
+var DEFAULT_DATABASE_DIRECTORY, SCHEMA_SUBDIRECTORY, SCHEMA_INDEX_FILE, DEFAULT_SEED_FILE_NAME;
 var init_database = __esm({
   "src/constants/database.ts"() {
     "use strict";
+    DEFAULT_DATABASE_DIRECTORY = "db";
+    SCHEMA_SUBDIRECTORY = "schema";
+    SCHEMA_INDEX_FILE = "index.ts";
+    DEFAULT_SEED_FILE_NAME = "seed.ts";
   }
 });
 
@@ -2337,11 +2370,12 @@ var init_urls = __esm({
 });
 
 // src/constants/index.ts
-var CLOUDFLARE_COMPATIBILITY_DATE;
 var init_constants = __esm({
   "src/constants/index.ts"() {
     "use strict";
     init_api();
+    init_bucket();
+    init_cloudflare();
     init_config();
     init_database();
     init_http_server();
@@ -2349,7 +2383,6 @@ var init_constants = __esm({
     init_ports();
     init_timeback();
     init_urls();
-    CLOUDFLARE_COMPATIBILITY_DATE = "2024-01-01";
   }
 });
 
@@ -2800,6 +2833,68 @@ var init_storage = __esm({
   }
 });
 
+// src/lib/core/client.ts
+import { PlaycademyClient } from "@playcademy/sdk";
+async function createClient() {
+  const profile = await getCurrentProfile();
+  const baseUrl = getBaseUrl();
+  const client = new PlaycademyClient({
+    baseUrl,
+    token: profile?.token
+  });
+  if (profile?.token && profile?.tokenType) {
+    client.setToken(profile.token, profile.tokenType);
+  }
+  return client;
+}
+async function requireAuthenticatedClient() {
+  const profile = await getCurrentProfile();
+  const environment = getEnvironment();
+  if (!profile) {
+    logger.newLine();
+    logger.admonition("warning", "Login Required", [
+      `You are not logged into ${environment}.`,
+      environment === "production" ? `Run \`playcademy login --env ${environment}\` to authenticate.` : "Run `playcademy login` to authenticate."
+    ]);
+    logger.newLine();
+    process.exit(1);
+  }
+  const client = await createClient();
+  return client;
+}
+var init_client = __esm({
+  "src/lib/core/client.ts"() {
+    "use strict";
+    init_storage();
+    init_logger();
+    init_config2();
+  }
+});
+
+// src/lib/core/errors.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return "Unknown error";
+}
+function logAndExit(error, logger2, options = {}) {
+  const { code = 1, prefix } = options;
+  const message = getErrorMessage(error);
+  const fullMessage = prefix ? `${prefix}: ${message}` : message;
+  logger2.newLine();
+  logger2.error(fullMessage);
+  logger2.newLine();
+  process.exit(code);
+}
+var init_errors = __esm({
+  "src/lib/core/errors.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/config/loader.ts
 import { dirname as dirname2, resolve as resolve3 } from "path";
 async function findConfigPath(configPath) {
@@ -3135,68 +3230,6 @@ var init_constants3 = __esm({
   }
 });
 
-// src/lib/core/game.ts
-function getSlugFromConfig(config) {
-  return generateSlug(config.name);
-}
-async function ensureGameExists(client, config) {
-  const slug = getSlugFromConfig(config);
-  let game = await runStep(
-    `Checking for game "${slug}"`,
-    async () => {
-      try {
-        return await client.games.fetch(slug);
-      } catch {
-        return null;
-      }
-    },
-    (result) => result ? "Found existing game" : "Game not found"
-  );
-  if (!game) {
-    game = await runStep(
-      `Creating game metadata for "${slug}"`,
-      () => client.dev.games.upsert(slug, {
-        displayName: config.name,
-        platform: config.platform ?? "web",
-        gameType: config.gameType ?? "hosted",
-        metadata: {
-          ...config.description && { description: config.description },
-          ...config.emoji && { emoji: config.emoji }
-        },
-        ...config.gameType === "external" && config.externalUrl && {
-          externalUrl: config.externalUrl
-        }
-      }),
-      "Game metadata created"
-    );
-  }
-  return game;
-}
-async function getGameFromConfig(client) {
-  const config = await runStep("Loading configuration", loadConfig, "Configuration loaded");
-  const slug = getSlugFromConfig(config);
-  const game = await runStep(
-    `Finding game "${slug}"`,
-    async () => {
-      try {
-        return await client.games.fetch(slug);
-      } catch {
-        throw new Error(`Game "${slug}" not found`);
-      }
-    },
-    "Game found"
-  );
-  return { game, config };
-}
-var init_game = __esm({
-  "src/lib/core/game.ts"() {
-    "use strict";
-    init_src();
-    init_slug();
-    init_config3();
-  }
-});
-
 // src/lib/config/timeback-derive.ts
 function generateCourseCode(slug) {
   return slug.split("-").slice(0, 2).map((word) => word.substring(0, 3).toUpperCase()).join("-");
@@ -3622,81 +3655,131 @@ var init_config3 = __esm({
   }
 });
 
-// src/lib/core/client.ts
-import { PlaycademyClient } from "@playcademy/sdk";
-async function createClient() {
-  const profile = await getCurrentProfile();
-  const baseUrl = getBaseUrl();
-  const client = new PlaycademyClient({
-    baseUrl,
-    token: profile?.token
-  });
-  if (profile?.token && profile?.tokenType) {
-    client.setToken(profile.token, profile.tokenType);
-  }
-  return client;
+// src/lib/core/game.ts
+function getSlugFromConfig(config) {
+  return generateSlug(config.name);
 }
-async function requireAuthenticatedClient() {
-  const profile = await getCurrentProfile();
-  const environment = getEnvironment();
-  if (!profile) {
-    logger.newLine();
-    logger.admonition("warning", "Login Required", [
-      `You are not logged into ${environment}.`,
-      environment === "production" ? `Run \`playcademy login --env ${environment}\` to authenticate.` : "Run `playcademy login` to authenticate."
-    ]);
-    logger.newLine();
-    process.exit(1);
+async function ensureGameExists(client, config) {
+  const slug = getSlugFromConfig(config);
+  let game = await runStep(
+    `Checking for game "${slug}"`,
+    async () => {
+      try {
+        return await client.games.fetch(slug);
+      } catch {
+        return null;
+      }
+    },
+    (result) => result ? "Found existing game" : "Game not found"
+  );
+  if (!game) {
+    game = await runStep(
+      `Creating game metadata for "${slug}"`,
+      () => client.dev.games.upsert(slug, {
+        displayName: config.name,
+        platform: config.platform ?? "web",
+        gameType: config.gameType ?? "hosted",
+        metadata: {
+          ...config.description && { description: config.description },
+          ...config.emoji && { emoji: config.emoji }
+        },
+        ...config.gameType === "external" && config.externalUrl && {
+          externalUrl: config.externalUrl
+        }
+      }),
+      "Game metadata created"
+    );
   }
-  const client = await createClient();
-  return client;
+  return game;
 }
-var init_client = __esm({
-  "src/lib/core/client.ts"() {
+async function getGameFromConfig(client) {
+  const config = await runStep("Loading configuration", loadConfig, "Configuration loaded");
+  const slug = getSlugFromConfig(config);
+  const game = await runStep(
+    `Finding game "${slug}"`,
+    async () => {
+      try {
+        return await client.games.fetch(slug);
+      } catch {
+        throw new Error(`Game "${slug}" not found`);
+      }
+    },
+    "Game found"
+  );
+  return { game, config };
+}
+var init_game = __esm({
+  "src/lib/core/game.ts"() {
     "use strict";
-    init_storage();
-    init_logger();
-    init_config2();
+    init_src();
+    init_slug();
+    init_config3();
   }
 });
 
-// src/lib/core/errors.ts
-function getErrorMessage(error) {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  if (error && typeof error === "object" && "message" in error) {
-    return String(error.message);
-  }
-  return "Unknown error";
-}
-function logAndExit(error, logger2, options = {}) {
-  const { code = 1, prefix } = options;
-  const message = getErrorMessage(error);
-  const fullMessage = prefix ? `${prefix}: ${message}` : message;
-  logger2.newLine();
-  logger2.error(fullMessage);
-  logger2.newLine();
-  process.exit(code);
+// src/lib/core/gitignore.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join4, sep } from "path";
+function normalizeGitignoreEntry(entry) {
+  return entry.replace(/^\/+/, "").replace(/\/+$/, "");
 }
-var init_errors = __esm({
-  "src/lib/core/errors.ts"() {
-    "use strict";
+function loadGitignorePatterns(directory) {
+  const gitignorePath = join4(directory, ".gitignore");
+  if (!existsSync5(gitignorePath)) {
+    return [];
   }
-});
-
-// src/lib/core/import.ts
-import { mkdtempSync, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-import { pathToFileURL } from "url";
-import * as esbuild from "esbuild";
-async function importTypescriptFile(filePath, bundleOptions) {
-  const tempDir = mkdtempSync(join4(tmpdir(), "playcademy-import-"));
-  const outFile = join4(tempDir, "bundle.mjs");
   try {
-    await esbuild.build({
-      entryPoints: [filePath],
-      outfile: outFile,
+    const content = readFileSync3(gitignorePath, "utf-8");
+    return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+function matchesGitignorePattern(filePath, pattern) {
+  if (pattern.endsWith("/")) {
+    const dirPattern = pattern.slice(0, -1);
+    if (filePath.includes(dirPattern + sep) || filePath === dirPattern) {
+      return true;
+    }
+  }
+  if (pattern.includes("*")) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+    if (regex.test(filePath)) {
+      return true;
+    }
+  }
+  if (filePath === pattern || filePath.includes(sep + pattern) || filePath.endsWith(pattern)) {
+    return true;
+  }
+  return false;
+}
+function isIgnoredByGitignore(filePath, patterns) {
+  for (const pattern of patterns) {
+    if (matchesGitignorePattern(filePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+var init_gitignore = __esm({
+  "src/lib/core/gitignore.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/core/import.ts
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join as join5 } from "path";
+import { pathToFileURL } from "url";
+import * as esbuild from "esbuild";
+async function importTypescriptFile(filePath, bundleOptions) {
+  const tempDir = mkdtempSync(join5(tmpdir(), "playcademy-import-"));
+  const outFile = join5(tempDir, "bundle.mjs");
+  try {
+    await esbuild.build({
+      entryPoints: [filePath],
+      outfile: outFile,
       bundle: true,
       platform: "node",
       format: "esm",
@@ -3724,6 +3807,57 @@ var init_import = __esm({
   }
 });
 
+// src/lib/core/mime.ts
+function getContentType(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  const types = {
+    // Images
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    // Audio
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    m4a: "audio/mp4",
+    // Video
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime",
+    // Documents
+    pdf: "application/pdf",
+    txt: "text/plain",
+    md: "text/markdown",
+    // Web
+    html: "text/html",
+    htm: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    mjs: "application/javascript",
+    json: "application/json",
+    xml: "application/xml",
+    // Archives
+    zip: "application/zip",
+    gz: "application/gzip",
+    tar: "application/x-tar",
+    // Fonts
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf"
+  };
+  return types[ext || ""] || "application/octet-stream";
+}
+var init_mime2 = __esm({
+  "src/lib/core/mime.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/core/index.ts
 var core_exports = {};
 __export(core_exports, {
@@ -3733,6 +3867,7 @@ __export(core_exports, {
   getApiUrl: () => getApiUrl,
   getBaseUrl: () => getBaseUrl,
   getCliContext: () => getCliContext,
+  getContentType: () => getContentType,
   getEnvironment: () => getEnvironment,
   getErrorMessage: () => getErrorMessage,
   getGameFromConfig: () => getGameFromConfig,
@@ -3744,9 +3879,13 @@ __export(core_exports, {
   hasPackageJson: () => hasPackageJson,
   importTypescriptDefault: () => importTypescriptDefault,
   importTypescriptFile: () => importTypescriptFile,
+  isIgnoredByGitignore: () => isIgnoredByGitignore,
+  loadGitignorePatterns: () => loadGitignorePatterns,
   logAndExit: () => logAndExit,
   logger: () => logger,
+  matchesGitignorePattern: () => matchesGitignorePattern,
   normalizeEnvironment: () => normalizeEnvironment,
+  normalizeGitignoreEntry: () => normalizeGitignoreEntry,
   requireAuthenticatedClient: () => requireAuthenticatedClient,
   setCliContext: () => setCliContext
 });
@@ -3758,8 +3897,10 @@ var init_core = __esm({
     init_context();
     init_errors();
     init_game();
+    init_gitignore();
     init_import();
     init_logger();
+    init_mime2();
   }
 });
 
@@ -3790,7 +3931,7 @@ import { program } from "commander";
 
 // src/commands/init/index.ts
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync9 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
 import { resolve as resolve10 } from "path";
 
 // ../../node_modules/@inquirer/core/dist/esm/lib/errors.js
@@ -4586,19 +4727,166 @@ function getCallbackUrl() {
   return `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
 }
 
+// src/lib/bucket/bulk.ts
+init_src();
+init_core();
+import { readFileSync as readFileSync4 } from "fs";
+import { dim as dim3 } from "colorette";
+
+// src/lib/bucket/collect.ts
+init_constants2();
+init_core();
+init_core();
+import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join6, relative, sep as sep2 } from "path";
+function shouldSkipFile(filePath, baseDir, gitignorePatterns) {
+  const relativePath = relative(baseDir, filePath);
+  const pathParts = relativePath.split(sep2);
+  const alwaysSkip = BUCKET_ALWAYS_SKIP;
+  for (const part of pathParts) {
+    if (alwaysSkip.includes(part)) return true;
+  }
+  return isIgnoredByGitignore(relativePath, gitignorePatterns);
+}
+function collectFiles(directory, baseDir, gitignorePatterns) {
+  const files = [];
+  try {
+    const entries = readdirSync2(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join6(directory, entry.name);
+      if (shouldSkipFile(fullPath, baseDir, gitignorePatterns)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        files.push(...collectFiles(fullPath, baseDir, gitignorePatterns));
+      } else if (entry.isFile()) {
+        const stats = statSync2(fullPath);
+        files.push({
+          absolutePath: fullPath,
+          relativePath: relative(baseDir, fullPath),
+          size: stats.size
+        });
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+function getBucketKey(relativePath, prefix) {
+  const key = relativePath.replace(/\\/g, "/");
+  return prefix ? `${prefix}/${key}` : key;
+}
+
+// src/lib/bucket/bulk.ts
+function collectBulkFiles(directory) {
+  const gitignorePatterns = loadGitignorePatterns(directory);
+  const files = collectFiles(directory, directory, gitignorePatterns);
+  const totalSize = files.reduce((sum, file) => sum + file.size, 0);
+  return { files, totalSize };
+}
+function outputDryRunResults(files, totalSize, prefix, json, raw) {
+  if (json) {
+    logger.json({
+      files: files.map((f) => ({
+        path: f.relativePath,
+        key: getBucketKey(f.relativePath, prefix),
+        size: f.size
+      })),
+      totalFiles: files.length,
+      totalSize
+    });
+    return;
+  }
+  if (raw) {
+    for (const file of files) {
+      logger.raw(getBucketKey(file.relativePath, prefix));
+    }
+    return;
+  }
+  logger.remark(`Files to upload ${dim3(`[${files.length}]`)}`);
+  logger.newLine();
+  for (const file of files) {
+    logger.data(getBucketKey(file.relativePath, prefix), formatBytes(file.size), 1);
+  }
+  logger.newLine();
+  logger.data("Total", `${files.length} files (${formatBytes(totalSize)})`, 0);
+  logger.newLine();
+}
+function outputUploadResults(uploaded, totalSize, environment, prefix, json, raw) {
+  if (json) {
+    logger.json({
+      success: true,
+      uploaded,
+      totalSize,
+      environment,
+      prefix
+    });
+    return;
+  }
+  if (raw) {
+    logger.raw(`Uploaded files`);
+    return;
+  }
+  if (environment || prefix) {
+    logger.newLine();
+    if (environment) logger.data("Environment", environment, 1);
+    if (prefix) logger.data("Prefix", prefix, 1);
+  }
+  logger.newLine();
+}
+async function uploadFilesRemote(files, gameSlug, prefix, uploadFn) {
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+  await runStep(
+    `Uploading ${files.length} files ${dim3(`[${formatBytes(totalSize)}]`)}`,
+    async () => {
+      for (const file of files) {
+        const fileBuffer = readFileSync4(file.absolutePath);
+        const contentType = getContentType(file.absolutePath);
+        const key = getBucketKey(file.relativePath, prefix);
+        await uploadFn(gameSlug, key, fileBuffer, contentType);
+      }
+    },
+    `Uploaded ${files.length} files ${dim3(`[${formatBytes(totalSize)}]`)}`
+  );
+  return files.length;
+}
+async function uploadFilesLocal(files, prefix, uploadFn) {
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+  await runStep(
+    `Uploading ${files.length} files ${dim3(`[${formatBytes(totalSize)}]`)}`,
+    async () => {
+      for (const file of files) {
+        const fileBuffer = readFileSync4(file.absolutePath);
+        const contentType = getContentType(file.absolutePath);
+        const key = getBucketKey(file.relativePath, prefix);
+        await uploadFn(key, new Uint8Array(fileBuffer).buffer, contentType);
+      }
+    },
+    `Uploaded ${files.length} files ${dim3(`[${formatBytes(totalSize)}]`)}`
+  );
+  return files.length;
+}
+
 // src/lib/index.ts
 init_config3();
 init_core();
 
 // src/lib/db/path.ts
 init_constants2();
-import { copyFileSync, existsSync as existsSync5, mkdirSync, readdirSync as readdirSync2, unlinkSync } from "fs";
-import { join as join5 } from "path";
+import { copyFileSync, existsSync as existsSync6, mkdirSync, readdirSync as readdirSync3, unlinkSync } from "fs";
+import { join as join7 } from "path";
 import Database from "better-sqlite3";
 var DB_DIRECTORY = CLI_DIRECTORIES.DATABASE;
 var INITIAL_DB_NAME = CLI_FILES.INITIAL_DATABASE;
 var ensureDirectoryExists = (dir) => {
-  if (!existsSync5(dir)) {
+  if (!existsSync6(dir)) {
     mkdirSync(dir, { recursive: true });
   }
 };
@@ -4607,79 +4895,150 @@ var createEmptyDatabase = (path2) => {
   db.close();
 };
 var findMiniflareDatabase = (dbDir) => {
-  const miniflareDir = join5(dbDir, "miniflare-D1DatabaseObject");
-  if (!existsSync5(miniflareDir)) return null;
-  const sqliteFiles = readdirSync2(miniflareDir).filter((file) => file.endsWith(".sqlite"));
+  const miniflareDir = join7(dbDir, MINIFLARE_D1_DIRECTORY);
+  if (!existsSync6(miniflareDir)) return null;
+  const sqliteFiles = readdirSync3(miniflareDir).filter((file) => file.endsWith(".sqlite"));
   if (sqliteFiles.length === 0) return null;
-  return join5(miniflareDir, sqliteFiles[0]);
+  return join7(miniflareDir, sqliteFiles[0]);
 };
 var migrateInitialDbToTarget = (initialPath, targetPath) => {
-  if (!existsSync5(initialPath)) return;
+  if (!existsSync6(initialPath)) return;
   copyFileSync(initialPath, targetPath);
   unlinkSync(initialPath);
 };
 function getDevDbPath() {
-  const initialDbPath = join5(DB_DIRECTORY, INITIAL_DB_NAME);
+  const initialDbPath = join7(DB_DIRECTORY, INITIAL_DB_NAME);
   ensureDirectoryExists(DB_DIRECTORY);
   const miniflareDbPath = findMiniflareDatabase(DB_DIRECTORY);
   if (miniflareDbPath) {
     migrateInitialDbToTarget(initialDbPath, miniflareDbPath);
     return miniflareDbPath;
   }
-  if (!existsSync5(initialDbPath)) {
+  if (!existsSync6(initialDbPath)) {
     createEmptyDatabase(initialDbPath);
   }
   return initialDbPath;
 }
 
+// src/lib/db/bundle-seed.ts
+async function bundleSeedWorker(seedFilePath, projectPath) {
+  const esbuild2 = await import("esbuild");
+  const entryCode = `
+        import { seed } from '${seedFilePath}'
+        
+        export default {
+            async fetch(req, env, ctx) {
+                try {
+                    // Create Hono-like context
+                    const c = { env, ctx, req }
+                    await seed(c)
+                    return Response.json({ success: true })
+                } catch (error) {
+                    return Response.json({ 
+                        success: false, 
+                        error: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : undefined,
+                    }, 500)
+                }
+            }
+        }
+    `;
+  const buildConfig = {
+    stdin: {
+      contents: entryCode,
+      resolveDir: projectPath,
+      loader: "ts"
+    },
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "esnext",
+    external: [],
+    // Bundle everything for self-contained worker
+    write: false,
+    minify: false,
+    sourcemap: false,
+    logLevel: "error"
+  };
+  const result = await esbuild2.build(buildConfig);
+  if (!result.outputFiles?.[0]) {
+    throw new Error("Seed worker bundling failed: no output");
+  }
+  const code = result.outputFiles[0].text;
+  return {
+    code,
+    size: code.length
+  };
+}
+
 // src/lib/db/reset.ts
-init_log();
+init_src();
 init_package_manager();
+init_constants2();
 init_core();
 import { execSync as execSync2 } from "child_process";
-import Database2 from "better-sqlite3";
-function resetDatabase() {
-  const dbPath = getDevDbPath();
-  const sqlite = new Database2(dbPath);
-  const TURN_FOREIGN_KEYS_OFF_SQL = "PRAGMA foreign_keys = OFF";
-  const TURN_FOREIGN_KEYS_ON_SQL = "PRAGMA foreign_keys = ON";
-  const DROP_ALL_USER_TABLES_SQL = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
-  const DROP_TABLE_SQL = (tableName) => `DROP TABLE IF EXISTS ${tableName}`;
-  runStep(
-    "Dropping all tables",
+import { rmSync as rmSync2 } from "fs";
+import { join as join8 } from "path";
+async function resetDatabase(workspace, mf, options = { debug: false }) {
+  const { debug } = options;
+  const dbDir = join8(workspace, CLI_DIRECTORIES.DATABASE);
+  await runStep(
+    "Resetting database...",
     async () => {
-      sqlite.prepare(TURN_FOREIGN_KEYS_OFF_SQL).run();
-      const tables = sqlite.prepare(DROP_ALL_USER_TABLES_SQL).all();
-      for (const table of tables) {
-        sqlite.prepare(DROP_TABLE_SQL(table.name)).run();
+      rmSync2(dbDir, { recursive: true, force: true });
+      try {
+        const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
+        await d1.exec("SELECT 1");
+      } catch {
+        logger.error("Database recreation failed");
+        logger.newLine();
+        process.exit(1);
       }
-      sqlite.prepare(TURN_FOREIGN_KEYS_ON_SQL).run();
+      const pm = getPackageManager();
+      const pushCommand = getRunCommand(pm, "db:push");
+      execSync2(pushCommand, {
+        cwd: workspace,
+        stdio: debug ? ["inherit", "inherit", "inherit"] : ["inherit", "ignore", "ignore"]
+      });
     },
-    "Dropped all tables"
+    "Database reset"
   );
-  try {
-    const pm = getPackageManager();
-    const pushCommand = getRunCommand(pm, "db:push");
-    runStep(
-      "Pushing schema",
-      async () => {
-        execSync2(pushCommand, { stdio: ["inherit", "ignore", "inherit"] });
-      },
-      "Pushed schema"
-    );
-    return sqlite;
-  } catch (error) {
-    logger.error(`Failed to push schema: ${getErrorMessage(error)}`);
+}
+
+// src/lib/db/seed.ts
+init_src();
+init_constants2();
+init_core();
+async function importSeedModule(seedPath) {
+  return await importTypescriptFile(seedPath);
+}
+async function executeSeedFile(seedFilePath, mf) {
+  const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
+  const seedModule = await importSeedModule(seedFilePath);
+  if (typeof seedModule.seed !== "function") {
+    logger.error("Seed file must export a seed function");
+    logger.newLine();
+    logger.admonition("warning", "Invalid Seed File", [
+      `Expected: \`export async function seed(c: Context) { ... }\``,
+      `Found in: <${seedFilePath}>`
+    ]);
+    logger.newLine();
     process.exit(1);
   }
+  await runStep(
+    "Seeding database...",
+    async () => seedModule.seed?.({ env: { DB: d1 } }),
+    "Database seeded successfully!"
+  );
+  logger.newLine();
 }
 
 // src/lib/deploy/backend.ts
 init_src();
 init_constants2();
 init_core();
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join18 } from "node:path";
 
 // src/lib/init/bucket.ts
 function hasBucketSetup(config) {
@@ -4692,14 +5051,15 @@ init_slug();
 init_core();
 init_logger();
 init_loader2();
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join9 } from "path";
 var drizzleConfigTemplate = loadTemplateString("database/drizzle-config.ts");
 var dbSchemaUsersTemplate = loadTemplateString("database/db-schema-users.ts");
 var dbSchemaScoresTemplate = loadTemplateString("database/db-schema-scores.ts");
 var dbSchemaIndexTemplate = loadTemplateString("database/db-schema-index.ts");
 var dbIndexTemplate = loadTemplateString("database/db-index.ts");
 var dbTypesTemplate = loadTemplateString("database/db-types.ts");
+var dbSeedTemplate = loadTemplateString("database/db-seed.ts");
 var packageTemplate = loadTemplateString("database/package.json");
 async function scaffoldDatabaseSetup(options) {
   const workspace = getWorkspace();
@@ -4707,25 +5067,27 @@ async function scaffoldDatabaseSetup(options) {
   await runStep(
     "Configuring database...",
     async () => {
-      const dbDir = join6(workspace, "db");
-      const schemaDir = join6(dbDir, "schema");
-      if (!existsSync6(dbDir)) {
+      const dbDir = join9(workspace, "db");
+      const schemaDir = join9(dbDir, "schema");
+      if (!existsSync7(dbDir)) {
         mkdirSync2(dbDir, { recursive: true });
       }
-      if (!existsSync6(schemaDir)) {
+      if (!existsSync7(schemaDir)) {
         mkdirSync2(schemaDir, { recursive: true });
       }
-      const usersSchemaPath = join6(schemaDir, "users.ts");
+      const usersSchemaPath = join9(schemaDir, "users.ts");
       writeFileSync2(usersSchemaPath, dbSchemaUsersTemplate);
-      const scoresSchemaPath = join6(schemaDir, "scores.ts");
+      const scoresSchemaPath = join9(schemaDir, "scores.ts");
       writeFileSync2(scoresSchemaPath, dbSchemaScoresTemplate);
-      const schemaIndexPath = join6(schemaDir, "index.ts");
+      const schemaIndexPath = join9(schemaDir, "index.ts");
       writeFileSync2(schemaIndexPath, dbSchemaIndexTemplate);
-      const dbIndexPath = join6(dbDir, "index.ts");
+      const dbIndexPath = join9(dbDir, "index.ts");
       writeFileSync2(dbIndexPath, dbIndexTemplate);
-      const dbTypesPath = join6(dbDir, "types.ts");
+      const dbTypesPath = join9(dbDir, "types.ts");
       writeFileSync2(dbTypesPath, dbTypesTemplate);
-      const drizzleConfigPath = join6(workspace, "drizzle.config.ts");
+      const dbSeedPath = join9(dbDir, "seed.ts");
+      writeFileSync2(dbSeedPath, dbSeedTemplate);
+      const drizzleConfigPath = join9(workspace, "drizzle.config.ts");
       writeFileSync2(drizzleConfigPath, drizzleConfigTemplate);
       packagesUpdated = await setupPackageJson(workspace, options.gameName);
     },
@@ -4734,7 +5096,7 @@ async function scaffoldDatabaseSetup(options) {
   return packagesUpdated;
 }
 async function setupPackageJson(workspace, gameName) {
-  const pkgPath = join6(workspace, "package.json");
+  const pkgPath = join9(workspace, "package.json");
   const dbDeps = {
     "drizzle-orm": "^0.42.0",
     "better-sqlite3": "^12.0.0"
@@ -4748,13 +5110,13 @@ async function setupPackageJson(workspace, gameName) {
     "db:generate": "drizzle-kit generate",
     "db:push": "drizzle-kit push",
     "db:studio": "drizzle-kit studio",
-    "db:seed": "tsx db/seed.ts"
+    "db:seed": "playcademy db seed"
   };
-  if (existsSync6(pkgPath)) {
+  if (existsSync7(pkgPath)) {
     await runStep(
       "Updating package.json deps",
       async () => {
-        const existing = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+        const existing = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         existing.dependencies = { ...existing.dependencies, ...dbDeps };
         existing.devDependencies = { ...existing.devDependencies, ...dbDevDeps };
         existing.scripts = { ...existing.scripts, ...dbScripts };
@@ -4773,9 +5135,9 @@ async function setupPackageJson(workspace, gameName) {
 }
 function hasDatabaseSetup() {
   const workspace = getWorkspace();
-  const drizzleConfigPath = join6(workspace, "drizzle.config.ts");
-  const drizzleConfigJsPath = join6(workspace, "drizzle.config.js");
-  return existsSync6(drizzleConfigPath) || existsSync6(drizzleConfigJsPath);
+  const drizzleConfigPath = join9(workspace, "drizzle.config.ts");
+  const drizzleConfigJsPath = join9(workspace, "drizzle.config.js");
+  return existsSync7(drizzleConfigPath) || existsSync7(drizzleConfigJsPath);
 }
 
 // src/lib/init/kv.ts
@@ -4912,8 +5274,8 @@ var integrationChangeDetectors = {
 };
 
 // src/lib/deploy/bundle.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join11 } 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\nimport { Hono } from 'hono'\n\nimport { registerCors, registerEnvSetup, registerSdkInit } 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/**\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)\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\nexport default app\n";
@@ -4936,6 +5298,9 @@ var isDevelopment = () => {
 var isInteractiveTTY = () => {
   return typeof process !== "undefined" && Boolean(process.stdout && process.stdout.isTTY);
 };
+var isSilent = () => {
+  return typeof process !== "undefined" && process.env.LOG_SILENT === "true";
+};
 var detectOutputFormat = () => {
   if (isBrowser()) {
     return "browser";
@@ -5056,6 +5421,7 @@ var getMinimumLogLevel = () => {
   return isProduction() ? "info" : "debug";
 };
 var shouldLog = (level) => {
+  if (isSilent()) return false;
   const minLevel = getMinimumLogLevel();
   return levelPriority[level] >= levelPriority[minLevel];
 };
@@ -5176,7 +5542,7 @@ init_file_loader();
 init_core();
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join7, relative } from "path";
+import { join as join10, relative as relative2 } from "path";
 
 // src/lib/deploy/hash.ts
 init_file_loader();
@@ -5224,8 +5590,8 @@ async function discoverRoutes(apiDir) {
   const routes = await Promise.all(
     files.map(async (file) => {
       const routePath = filePathToRoutePath(file);
-      const absolutePath = join7(apiDir, file);
-      const relativePath = relative(getWorkspace(), absolutePath);
+      const absolutePath = join10(apiDir, file);
+      const relativePath = relative2(getWorkspace(), absolutePath);
       const methods = await detectExportedMethods(absolutePath);
       return {
         path: routePath,
@@ -5285,10 +5651,10 @@ async function transpileRoute(filePath) {
   if (!result.outputFiles?.[0]) {
     throw new Error("Transpilation failed: no output");
   }
-  const tempDir = join7(tmpdir2(), "playcademy-dev");
+  const tempDir = join10(tmpdir2(), "playcademy-dev");
   await mkdir2(tempDir, { recursive: true });
   const hash = hashContent(filePath).slice(0, 12);
-  const jsPath = join7(tempDir, `${hash}.mjs`);
+  const jsPath = join10(tempDir, `${hash}.mjs`);
   await writeFile2(jsPath, result.outputFiles[0].text);
   return jsPath;
 }
@@ -5316,7 +5682,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(join8(workspace, customRoutesDir));
+  const customRoutes = await discoverRoutes(join11(workspace, customRoutesDir));
   const customRouteData = customRoutes.map((r) => ({
     path: r.path,
     file: r.file,
@@ -5328,15 +5694,15 @@ async function discoverCustomRoutes(config) {
 function resolveEmbeddedSourcePaths() {
   const workspace = getWorkspace();
   const distDir = new URL(".", import.meta.url).pathname;
-  const embeddedEdgeSrc = join8(distDir, "edge-play", "src");
-  const isBuiltPackage = existsSync7(embeddedEdgeSrc);
+  const embeddedEdgeSrc = join11(distDir, "edge-play", "src");
+  const isBuiltPackage = existsSync8(embeddedEdgeSrc);
   const monorepoRoot = getMonorepoRoot();
-  const monorepoEdgeSrc = join8(monorepoRoot, "packages/edge-play/src");
+  const monorepoEdgeSrc = join11(monorepoRoot, "packages/edge-play/src");
   const edgePlaySrc = isBuiltPackage ? embeddedEdgeSrc : monorepoEdgeSrc;
-  const cliPackageRoot = isBuiltPackage ? join8(distDir, "../../..") : join8(monorepoRoot, "packages/cli");
-  const cliNodeModules = isBuiltPackage ? join8(cliPackageRoot, "node_modules") : monorepoRoot;
-  const workspaceNodeModules = join8(workspace, "node_modules");
-  const constantsEntry = isBuiltPackage ? join8(embeddedEdgeSrc, "..", "..", "constants", "src", "index.ts") : join8(monorepoRoot, "packages", "constants", "src", "index.ts");
+  const cliPackageRoot = isBuiltPackage ? join11(distDir, "../../..") : join11(monorepoRoot, "packages/cli");
+  const cliNodeModules = isBuiltPackage ? join11(cliPackageRoot, "node_modules") : monorepoRoot;
+  const workspaceNodeModules = join11(workspace, "node_modules");
+  const constantsEntry = isBuiltPackage ? join11(embeddedEdgeSrc, "..", "..", "constants", "src", "index.ts") : join11(monorepoRoot, "packages", "constants", "src", "index.ts");
   return {
     isBuiltPackage,
     edgePlaySrc,
@@ -5396,16 +5762,16 @@ 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": join8(workspace, customRoutesDir),
+      "@game-api": join11(workspace, customRoutesDir),
       // ┌─ 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: join8(edgePlaySrc, "polyfills.js"),
-      "fs/promises": join8(edgePlaySrc, "polyfills.js"),
-      path: join8(edgePlaySrc, "polyfills.js"),
-      os: join8(edgePlaySrc, "polyfills.js"),
-      process: join8(edgePlaySrc, "polyfills.js")
+      fs: join11(edgePlaySrc, "polyfills.js"),
+      "fs/promises": join11(edgePlaySrc, "polyfills.js"),
+      path: join11(edgePlaySrc, "polyfills.js"),
+      os: join11(edgePlaySrc, "polyfills.js"),
+      process: join11(edgePlaySrc, "polyfills.js")
     },
     // ──── Build Plugins ────
     plugins: [textLoaderPlugin()],
@@ -5468,10 +5834,12 @@ function generateEntryCode(customRoutes, customRoutesDir) {
 }
 
 // src/lib/deploy/schema.ts
+init_constants2();
+init_config3();
 init_core();
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { createRequire } from "module";
-import { join as join14 } from "path";
+import { join as join17 } from "path";
 
 // src/lib/init/prompts.ts
 init_constants3();
@@ -5483,8 +5851,8 @@ import { bold as bold3, cyan as cyan2 } from "colorette";
 init_constants2();
 init_core();
 init_loader2();
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join9, resolve as resolve6 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join12, resolve as resolve6 } from "path";
 var sampleCustomRouteTemplate = loadTemplateString("api/sample-custom.ts");
 var sampleDatabaseRouteTemplate = loadTemplateString("api/sample-database.ts");
 var sampleKvRouteTemplate = loadTemplateString("api/sample-kv.ts");
@@ -5492,31 +5860,31 @@ var sampleBucketRouteTemplate = loadTemplateString("api/sample-bucket.ts");
 var playcademyGitignoreTemplate = loadTemplateString("playcademy-gitignore");
 async function scaffoldApiDirectory(apiDirectory, sampleRoutes) {
   const apiPath = resolve6(getWorkspace(), apiDirectory);
-  const samplePath = join9(apiPath, "sample");
-  if (!existsSync8(apiPath)) {
+  const samplePath = join12(apiPath, "sample");
+  if (!existsSync9(apiPath)) {
     mkdirSync3(apiPath, { recursive: true });
   }
-  if (!existsSync8(samplePath)) {
+  if (!existsSync9(samplePath)) {
     mkdirSync3(samplePath, { recursive: true });
   }
   for (const route of sampleRoutes) {
-    writeFileSync3(join9(samplePath, route.filename), route.template, "utf-8");
+    writeFileSync3(join12(samplePath, route.filename), route.template, "utf-8");
   }
 }
 function validateApiDirectoryDoesNotExist(value) {
   const dirPath = resolve6(getWorkspace(), value.trim());
-  if (existsSync8(dirPath)) {
+  if (existsSync9(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 = join9(workspace, CLI_DIRECTORIES.WORKSPACE);
-  if (!existsSync8(playcademyDir)) {
+  const playcademyDir = join12(workspace, CLI_DIRECTORIES.WORKSPACE);
+  if (!existsSync9(playcademyDir)) {
     mkdirSync3(playcademyDir, { recursive: true });
   }
-  const gitignorePath = join9(playcademyDir, ".gitignore");
+  const gitignorePath = join12(playcademyDir, ".gitignore");
   writeFileSync3(gitignorePath, playcademyGitignoreTemplate);
 }
 async function scaffoldIntegrations(gameName, options) {
@@ -5772,14 +6140,14 @@ init_loader();
 init_core();
 import { execSync as execSync3 } from "child_process";
 import { writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname4, join as join12 } from "path";
+import { dirname as dirname4, join as join15 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/secrets/env.ts
 init_file_loader();
 init_constants2();
-import { existsSync as existsSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join13 } from "path";
 function parseEnvFile(contents) {
   const secrets = {};
   for (const line of contents.split("\n")) {
@@ -5815,10 +6183,10 @@ async function readEnvFile(workspace) {
   return secrets;
 }
 function getLoadedEnvFiles(workspace) {
-  return ENV_FILES.filter((filename) => existsSync9(join10(workspace, filename)));
+  return ENV_FILES.filter((filename) => existsSync10(join13(workspace, filename)));
 }
 function hasEnvFile(workspace) {
-  return ENV_FILES.some((filename) => existsSync9(join10(workspace, filename)));
+  return ENV_FILES.some((filename) => existsSync10(join13(workspace, filename)));
 }
 
 // src/lib/init/types.ts
@@ -5827,8 +6195,8 @@ init_loader2();
 // src/lib/init/tsconfig.ts
 init_file_loader();
 init_constants2();
-import { existsSync as existsSync10, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join14 } from "path";
 function hasPlaycademyEnv(config) {
   return config.include?.includes("playcademy-env.d.ts") ?? false;
 }
@@ -5885,8 +6253,8 @@ function addToIncludeArrayPreservingComments(content) {
 }
 async function ensureTsconfigIncludes(workspace) {
   for (const filename of TSCONFIG_FILES) {
-    const configPath = join11(workspace, filename);
-    if (!existsSync10(configPath)) {
+    const configPath = join14(workspace, filename);
+    if (!existsSync11(configPath)) {
       continue;
     }
     try {
@@ -5902,7 +6270,7 @@ async function ensureTsconfigIncludes(workspace) {
         return filename;
       }
       try {
-        const rawContent = readFileSync4(configPath, "utf-8");
+        const rawContent = readFileSync6(configPath, "utf-8");
         const updatedContent = addToIncludeArrayPreservingComments(rawContent);
         if (updatedContent && updatedContent !== rawContent) {
           writeFileSync4(configPath, updatedContent);
@@ -5935,8 +6303,8 @@ function hasAnyBackend(features) {
   return Object.values(features).some(Boolean);
 }
 async function setupPlaycademyDependencies(workspace) {
-  const playcademyDir = join12(workspace, CLI_DIRECTORIES.WORKSPACE);
-  const playcademyPkgPath = join12(playcademyDir, "package.json");
+  const playcademyDir = join15(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyPkgPath = join15(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";
@@ -6006,7 +6374,7 @@ async function ensurePlaycademyTypes(options = {}) {
     const secretsStr = await generateSecretsTypeString(workspace, verbose);
     let envContent = playcademyEnvTemplate.replace("{{BINDINGS}}", bindingsStr);
     envContent = envContent.replace("{{SECRETS}}", secretsStr);
-    const envPath = join12(workspace, "playcademy-env.d.ts");
+    const envPath = join15(workspace, "playcademy-env.d.ts");
     writeFileSync5(envPath, envContent);
     if (verbose) {
       logger.success(`Generated <playcademy-env.d.ts>`);
@@ -6026,19 +6394,16 @@ async function ensurePlaycademyTypes(options = {}) {
 // src/lib/init/gitignore.ts
 init_core();
 init_loader2();
-import { existsSync as existsSync11, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
 var rootGitignoreTemplate = loadTemplateString("gitignore");
-function normalizeGitignoreEntry(entry) {
-  return entry.replace(/^\/+/, "").replace(/\/+$/, "");
-}
 function ensureRootGitignore(workspace = getWorkspace()) {
-  const gitignorePath = join13(workspace, ".gitignore");
-  if (!existsSync11(gitignorePath)) {
+  const gitignorePath = join16(workspace, ".gitignore");
+  if (!existsSync12(gitignorePath)) {
     writeFileSync6(gitignorePath, rootGitignoreTemplate);
     return;
   }
-  const existingContent = readFileSync5(gitignorePath, "utf-8");
+  const existingContent = readFileSync7(gitignorePath, "utf-8");
   const existingNormalized = new Set(
     existingContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map(normalizeGitignoreEntry)
   );
@@ -6059,6 +6424,18 @@ function ensureRootGitignore(workspace = getWorkspace()) {
 }
 
 // src/lib/deploy/schema.ts
+async function getDatabaseDirectory() {
+  try {
+    const config = await loadConfig();
+    const dbIntegration = config.integrations?.database;
+    if (!dbIntegration || dbIntegration === true) {
+      return DEFAULT_DATABASE_DIRECTORY;
+    }
+    return dbIntegration.directory ?? DEFAULT_DATABASE_DIRECTORY;
+  } catch {
+    return DEFAULT_DATABASE_DIRECTORY;
+  }
+}
 function getDrizzleKitApiExports() {
   const require2 = createRequire(import.meta.url);
   const drizzleKitApi = require2("drizzle-kit/api");
@@ -6073,8 +6450,9 @@ async function getSchemaInfo(previousSchemaSnapshot) {
   if (!hasDatabaseSetup()) {
     return null;
   }
-  const schemaPath = join14(workspace, "db/schema/index.ts");
-  if (!existsSync12(schemaPath)) {
+  const dbDirectory = await getDatabaseDirectory();
+  const schemaPath = join17(workspace, dbDirectory, SCHEMA_SUBDIRECTORY, SCHEMA_INDEX_FILE);
+  if (!existsSync13(schemaPath)) {
     return null;
   }
   try {
@@ -6157,11 +6535,11 @@ var CUSTOM_ROUTES_EXTENSIONS_WITH_DOT = [".ts", ".js", ".mjs", ".cjs"];
 function getCustomRoutesDirectory(projectPath, config) {
   const customRoutes = config?.integrations?.customRoutes;
   const customRoutesDir = typeof customRoutes === "object" && customRoutes.directory || DEFAULT_API_ROUTES_DIRECTORY;
-  return join15(projectPath, customRoutesDir);
+  return join18(projectPath, customRoutesDir);
 }
 function hasLocalCustomRoutes(projectPath, config) {
   const customRoutesDir = getCustomRoutesDirectory(projectPath, config);
-  return existsSync13(customRoutesDir);
+  return existsSync14(customRoutesDir);
 }
 async function getCustomRoutesHash(projectPath, config) {
   const customRoutesDir = getCustomRoutesDirectory(projectPath, config);
@@ -6169,16 +6547,16 @@ async function getCustomRoutesHash(projectPath, config) {
 }
 async function getCustomRoutesSize(projectPath, config) {
   const { stat: stat3, readdir } = await import("node:fs/promises");
-  const { join: join37 } = await import("node:path");
+  const { join: join41 } = await import("node:path");
   const customRoutesDir = getCustomRoutesDirectory(projectPath, config);
-  if (!existsSync13(customRoutesDir)) {
+  if (!existsSync14(customRoutesDir)) {
     return null;
   }
   let totalSize = 0;
   async function calculateDirSize(dir) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join37(dir, entry.name);
+      const fullPath = join41(dir, entry.name);
       if (entry.isDirectory()) {
         await calculateDirSize(fullPath);
       } else if (entry.isFile()) {
@@ -6372,7 +6750,7 @@ async function loadDeployConfig(configPath) {
 // src/lib/deploy/diff.ts
 init_string();
 init_logger();
-import { dim as dim3, green as green2, red as red2 } from "colorette";
+import { dim as dim4, green as green2, red as red2 } from "colorette";
 function calculateConfigDiff(existingGame, newConfig) {
   const diff = {};
   if (existingGame.displayName !== newConfig.displayName) {
@@ -6489,7 +6867,7 @@ function displayDeploymentDiff(options) {
       const oldSize = formatSize(previousSize);
       const newSize = formatSize(currentSize);
       const maxWidth = Math.max(oldSize.length, newSize.length);
-      const delta = dim3(`(${formatDelta(currentSize - previousSize)})`);
+      const delta = dim4(`(${formatDelta(currentSize - previousSize)})`);
       buildInfo = `${red2(oldSize.padEnd(maxWidth))} \u2192 ${green2(newSize.padEnd(maxWidth))}  ${delta}`;
     } else if (currentSize !== void 0) {
       buildInfo = green2(formatSize(currentSize));
@@ -6509,7 +6887,7 @@ function displayDeploymentDiff(options) {
         const oldSize = formatSize(previousSize);
         const newSize = formatSize(currentSize);
         const maxWidth = Math.max(oldSize.length, newSize.length);
-        const delta = dim3(`(${formatDelta(currentSize - previousSize)})`);
+        const delta = dim4(`(${formatDelta(currentSize - previousSize)})`);
         routesInfo = `${red2(oldSize.padEnd(maxWidth))} \u2192 ${green2(newSize.padEnd(maxWidth))}  ${delta}`;
       } else if (currentSize !== void 0) {
         routesInfo = green2(formatSize(currentSize));
@@ -6523,12 +6901,12 @@ function displayDeploymentDiff(options) {
       const currentSize = backend?.currentBundleSize;
       let bundleInfo;
       if (forceBackend && !backendChanged) {
-        bundleInfo = dim3("(forced)");
+        bundleInfo = dim4("(forced)");
       } else if (previousSize !== void 0 && currentSize !== void 0) {
         const oldSize = formatSize(previousSize);
         const newSize = formatSize(currentSize);
         const maxWidth = Math.max(oldSize.length, newSize.length);
-        const delta = dim3(`(${formatDelta(currentSize - previousSize)})`);
+        const delta = dim4(`(${formatDelta(currentSize - previousSize)})`);
         bundleInfo = `${red2(oldSize.padEnd(maxWidth))} \u2192 ${green2(newSize.padEnd(maxWidth))}  ${delta}`;
       } else if (currentSize !== void 0) {
         bundleInfo = green2(formatSize(currentSize));
@@ -6590,19 +6968,19 @@ init_context();
 init_logger();
 import { stat } from "node:fs/promises";
 import { confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
-import { dim as dim4 } from "colorette";
+import { dim as dim5 } from "colorette";
 
 // src/lib/deploy/build-discovery.ts
 init_file_loader();
 init_constants2();
 init_core();
-import { join as join16, relative as relative2 } from "path";
+import { join as join19, relative as relative3 } from "path";
 function findSingleBuildZip() {
   const workspace = getWorkspace();
-  const playcademyDir = join16(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyDir = join19(workspace, CLI_DIRECTORIES.WORKSPACE);
   const zipFiles = findFilesByExtension(playcademyDir, "zip");
   if (zipFiles.length === 1) {
-    return zipFiles[0] ? relative2(workspace, zipFiles[0]) : null;
+    return zipFiles[0] ? relative3(workspace, zipFiles[0]) : null;
   }
   return null;
 }
@@ -6635,14 +7013,14 @@ function hasOptionalFieldsMissing(missing) {
 
 // src/lib/deploy/validate.ts
 init_logger();
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { resolve as resolve7 } from "path";
 function validateBuildPath(path2) {
   if (!path2.trim()) {
     return "Build path is required";
   }
   const resolvedPath = resolve7(path2.trim());
-  if (!existsSync14(resolvedPath)) {
+  if (!existsSync15(resolvedPath)) {
     return `Build path not found: ${path2.trim()}`;
   }
   return true;
@@ -6740,8 +7118,8 @@ async function promptForMissingConfig(context2) {
     const gameType = await select2({
       message: "Game type:",
       choices: [
-        { value: "hosted", name: `Hosted ${dim4("[Upload a game build]")}` },
-        { value: "external", name: `External ${dim4("[Link to an external URL]")}` }
+        { value: "hosted", name: `Hosted ${dim5("[Upload a game build]")}` },
+        { value: "external", name: `External ${dim5("[Link to an external URL]")}` }
       ]
     });
     config.gameType = gameType;
@@ -7449,22 +7827,22 @@ init_context();
 
 // src/lib/games/storage.ts
 init_constants2();
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } 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 join17 } from "node:path";
+import { join as join20 } from "node:path";
 function getGamesStorePath() {
-  return join17(homedir2(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.GAMES_STORE);
+  return join20(homedir2(), CLI_USER_DIRECTORIES.CONFIG, CLI_FILES.GAMES_STORE);
 }
 async function ensureConfigDir() {
-  const configDir = join17(homedir2(), CLI_USER_DIRECTORIES.CONFIG);
+  const configDir = join20(homedir2(), CLI_USER_DIRECTORIES.CONFIG);
   await mkdir3(configDir, { recursive: true });
 }
 async function loadGameStore() {
   try {
     await ensureConfigDir();
     const storePath = getGamesStorePath();
-    if (existsSync15(storePath)) {
+    if (existsSync16(storePath)) {
       const content = await readFile3(storePath, "utf-8");
       return JSON.parse(content);
     }
@@ -7733,7 +8111,7 @@ async function calculateDeploymentPlan(context2, changes) {
 // src/lib/deploy/steps.ts
 init_src();
 init_logger();
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
 import { basename as basename2, resolve as resolve8 } from "path";
 function prepareGameMetadata(config) {
@@ -7753,7 +8131,7 @@ function prepareGameMetadata(config) {
 }
 async function prepareBuildFile(buildPath) {
   const resolvedPath = resolve8(buildPath);
-  if (resolvedPath.endsWith(".zip") && existsSync16(resolvedPath)) {
+  if (resolvedPath.endsWith(".zip") && existsSync17(resolvedPath)) {
     const buffer = await readFile4(resolvedPath);
     const uint8Array = new Uint8Array(buffer);
     const blob = new Blob([uint8Array], { type: "application/zip" });
@@ -7971,20 +8349,20 @@ async function saveDeploymentState(game, backendDeployment, context2) {
 // src/lib/dev/backend.ts
 init_constants2();
 init_core();
-import { existsSync as existsSync17 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { join as join21 } 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 existsSync17(join18(workspace, customRoutesDir));
+  return existsSync18(join21(workspace, customRoutesDir));
 }
 function needsBackend(config) {
   return !!config?.integrations || hasCustomRoutes(config);
 }
 
 // src/lib/dev/display.ts
-import { dim as dim5 } from "colorette";
+import { dim as dim6 } from "colorette";
 
 // ../edge-play/src/register-routes.ts
 init_constants4();
@@ -8068,16 +8446,16 @@ function displayRegisteredRoutes(integrations, customRoutes = []) {
   const maxPathLength = Math.max(...sortedRoutes.map((r) => r.path.length));
   sortedRoutes.forEach((route) => {
     const paddedPath = route.path.padEnd(maxPathLength + 2, " ");
-    logger.customRaw(`<${paddedPath}> ${dim5(route.method)}`, 1);
+    logger.customRaw(`<${paddedPath}> ${dim6(route.method)}`, 1);
   });
 }
 
 // src/lib/dev/reload.ts
 init_constants2();
 init_core();
-import { join as join19, relative as relative3 } from "path";
+import { join as join22, relative as relative4 } from "path";
 import chokidar from "chokidar";
-import { bold as bold4, cyan as cyan3, dim as dim6, green as green3 } from "colorette";
+import { bold as bold4, cyan as cyan3, dim as dim7, green as green3 } from "colorette";
 function formatTime() {
   const now = /* @__PURE__ */ new Date();
   let hours = now.getHours();
@@ -8092,9 +8470,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")
+    join22(workspace, customRoutesDir),
+    join22(workspace, "playcademy.config.js"),
+    join22(workspace, "playcademy.config.json")
   ];
   const watcher = chokidar.watch(watchPaths, {
     persistent: true,
@@ -8106,11 +8484,11 @@ function startHotReload(onReload, options = {}) {
   });
   const logSuccess = options.onSuccess || ((changedPath, eventType) => {
     if (changedPath) {
-      const relativePath = relative3(workspace, changedPath);
-      const timestamp5 = dim6(formatTime());
+      const relativePath = relative4(workspace, changedPath);
+      const timestamp5 = dim7(formatTime());
       const brand = bold4(cyan3("[playcademy]"));
       const event = eventType === "changed" ? green3("reload") : green3(eventType || "reload");
-      console.log(`${timestamp5} ${brand} ${event} ${dim6(relativePath)}`);
+      console.log(`${timestamp5} ${brand} ${event} ${dim7(relativePath)}`);
     } else {
       logger.success("Reloaded");
     }
@@ -8136,14 +8514,14 @@ function startHotReload(onReload, options = {}) {
 // src/lib/dev/server.ts
 init_src2();
 import { mkdir as mkdir4 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join24 } from "path";
 import { Log, LogLevel, Miniflare } from "miniflare";
 
 // ../utils/src/port.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
 import { createServer as createServer2 } from "node:net";
 import { homedir as homedir3 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join23 } from "node:path";
 async function isPortAvailableOnHost(port, host) {
   return new Promise((resolve11) => {
     const server = createServer2();
@@ -8182,19 +8560,19 @@ async function findAvailablePort(startPort = 4321) {
 }
 function getRegistryPath() {
   const home = homedir3();
-  const dir = join20(home, ".playcademy");
-  if (!existsSync18(dir)) {
+  const dir = join23(home, ".playcademy");
+  if (!existsSync19(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
-  return join20(dir, ".proc");
+  return join23(dir, ".proc");
 }
 function readRegistry() {
   const registryPath = getRegistryPath();
-  if (!existsSync18(registryPath)) {
+  if (!existsSync19(registryPath)) {
     return {};
   }
   try {
-    const content = readFileSync6(registryPath, "utf-8");
+    const content = readFileSync8(registryPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -8326,11 +8704,11 @@ async function startDevServer(options) {
       }
     ],
     bindings,
-    d1Databases: hasDatabase ? ["DB"] : [],
+    d1Databases: hasDatabase ? [CLOUDFLARE_BINDINGS.DB] : [],
     d1Persist: dbDir,
-    kvNamespaces: hasKV ? ["KV"] : [],
+    kvNamespaces: hasKV ? [CLOUDFLARE_BINDINGS.KV] : [],
     kvPersist: kvDir,
-    r2Buckets: hasBucket ? ["BUCKET"] : [],
+    r2Buckets: hasBucket ? [CLOUDFLARE_BINDINGS.BUCKET] : [],
     r2Persist: bucketDir,
     compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
   });
@@ -8341,7 +8719,7 @@ async function startDevServer(options) {
   return { server: mf, port };
 }
 async function ensureDatabaseDirectory() {
-  const dbDir = join21(getWorkspace(), CLI_DIRECTORIES.DATABASE);
+  const dbDir = join24(getWorkspace(), CLI_DIRECTORIES.DATABASE);
   try {
     await mkdir4(dbDir, { recursive: true });
   } catch (error) {
@@ -8350,7 +8728,7 @@ async function ensureDatabaseDirectory() {
   return dbDir;
 }
 async function ensureKvDirectory() {
-  const kvDir = join21(getWorkspace(), CLI_DIRECTORIES.KV);
+  const kvDir = join24(getWorkspace(), CLI_DIRECTORIES.KV);
   try {
     await mkdir4(kvDir, { recursive: true });
   } catch (error) {
@@ -8359,7 +8737,7 @@ async function ensureKvDirectory() {
   return kvDir;
 }
 async function ensureBucketDirectory() {
-  const bucketDir = join21(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join24(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   try {
     await mkdir4(bucketDir, { recursive: true });
   } catch (error) {
@@ -8368,7 +8746,7 @@ async function ensureBucketDirectory() {
   return bucketDir;
 }
 async function initializeDatabase(mf) {
-  const d1 = await mf.getD1Database("DB");
+  const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
   await d1.exec("SELECT 1");
 }
 async function writeBackendServerInfo(port) {
@@ -8595,7 +8973,6 @@ var initCommand = new Command2("init").description("Initialize a playcademy.conf
       },
       "Project configured"
     );
-    logger.newLine();
     const configContent = configFormat === "js" ? generateJsConfig({
       name: gameInfo.name,
       description: gameInfo.description,
@@ -8633,7 +9010,7 @@ var initCommand = new Command2("init").description("Initialize a playcademy.conf
 });
 async function addPlaycademySdk() {
   const pkgPath = resolve10(getWorkspace(), "package.json");
-  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
   const hasSdk = pkg.dependencies?.["@playcademy/sdk"] || pkg.devDependencies?.["@playcademy/sdk"];
   if (hasSdk) {
     return false;
@@ -8650,7 +9027,7 @@ init_src();
 init_file_loader();
 init_constants2();
 import { input as input3, password, select as select3 } from "@inquirer/prompts";
-import { bold as bold5, dim as dim7, whiteBright } from "colorette";
+import { bold as bold5, dim as dim8, whiteBright } from "colorette";
 import { Command as Command3 } from "commander";
 import open from "open";
 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) => {
@@ -8666,10 +9043,10 @@ var loginCommand = new Command3("login").description("Authenticate with Playcade
     logger.admonition("note", "Hello again", [
       bold5("You're already logged in"),
       "",
-      dim7("Email: ") + bold5(email2),
-      dim7("Environment: ") + bold5(environment),
-      dim7("Profile: ") + bold5(profileName),
-      ...otherProfile ? [dim7("Other Profile: ") + bold5(otherEnv)] : []
+      dim8("Email: ") + bold5(email2),
+      dim8("Environment: ") + bold5(environment),
+      dim8("Profile: ") + bold5(profileName),
+      ...otherProfile ? [dim8("Other Profile: ") + bold5(otherEnv)] : []
     ]);
     logger.newLine();
     return;
@@ -9507,139 +9884,329 @@ async function runDbInit() {
 
 // src/commands/db/reset.ts
 init_src();
-import { spawn } from "child_process";
-import { existsSync as existsSync19, rmSync as rmSync2 } from "fs";
-import { join as join22 } from "path";
-import { confirm as confirm6 } from "@inquirer/prompts";
+import { existsSync as existsSync20 } from "fs";
+import { join as join25 } from "path";
+import { confirm as confirm6, input as input7 } from "@inquirer/prompts";
+import { bold as bold6, redBright, underline as underline3 } from "colorette";
 import { Miniflare as Miniflare2 } from "miniflare";
 init_constants2();
-async function runDbReset() {
-  try {
-    const workspace = getWorkspace();
-    const dbDir = join22(workspace, CLI_DIRECTORIES.DATABASE);
-    if (!existsSync19(dbDir)) {
-      logger.warn("No database found to reset");
-      logger.newLine();
-      logger.remark("Nothing to do");
-      logger.newLine();
-      return;
-    }
+async function runDbResetRemote(options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     logger.newLine();
-    if (isServerRunning("backend", workspace)) {
-      logger.admonition("warning", "Stop Dev Server First", [
-        "The development server must be stopped before resetting the database.",
-        "Stop the server (Ctrl+C) and run this command again to ensure a clean reset."
-      ]);
-      logger.newLine();
-      process.exit(1);
-    }
-    const shouldReset = await confirm6({
-      message: "This will delete all local database data. Continue?",
-      default: false
-    });
-    if (!shouldReset) {
-      logger.newLine();
-      logger.remark("Nothing to do");
-      logger.newLine();
-      return;
-    }
-    runStep(
-      "Deleting database...",
-      async () => {
-        rmSync2(dbDir, { recursive: true, force: true });
-      },
-      "Database deleted"
-    );
+    logger.admonition("warning", "Deploy First", [
+      `Deploy your game before resetting remote database: \`playcademy deploy\``
+    ]);
     logger.newLine();
-    if (!hasDatabaseSetup()) {
-      logger.remark("No drizzle config found, skipping schema setup");
-      logger.newLine();
-      return;
-    }
-    await loadConfig();
-    try {
-      const mf = new Miniflare2({
-        modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-        d1Databases: ["DB"],
-        d1Persist: dbDir,
-        compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-      });
-      const d1 = await mf.getD1Database("DB");
-      await d1.exec("SELECT 1");
-      await mf.dispose();
-    } catch {
-      logger.newLine();
-      logger.error("Database recreation failed");
-      logger.newLine();
-      process.exit(1);
-    }
-    const exitCode = await runStep(
-      "Database recreating...",
-      async () => {
-        const exitCode2 = await new Promise((resolve11) => {
-          const child = spawn("npx", ["drizzle-kit", "push", "--force"], {
-            cwd: workspace,
-            stdio: ["ignore", "ignore", "inherit"],
-            // stdin: ignore, stdout: ignore, stderr: inherit
-            env: process.env
-          });
-          child.on("close", (code) => resolve11(code || 0));
-          child.on("error", () => resolve11(1));
-        });
-        return exitCode2;
-      },
-      "Database recreated"
-    );
-    if (exitCode !== 0) {
-      logger.newLine();
-      logger.error("Schema push failed");
-      process.exit(exitCode ?? 1);
-    }
+    process.exit(1);
+  }
+  const game = await client.games.fetch(deployedGame.gameId);
+  logger.newLine();
+  logger.admonition("warning", "DESTRUCTIVE OPERATION", [
+    `Are you sure you want to ${redBright(underline3(bold6("DELETE ALL DATA")))} in your ${environment} database?`,
+    `All tables will be dropped and recreated from schema.`,
+    `This action is irreversible and ${underline3(bold6("cannot be undone"))}.`
+  ]);
+  logger.newLine();
+  const confirmed = await confirm6({
+    message: "Are you sure you want to reset this database? This cannot be undone.",
+    default: false
+  });
+  if (!confirmed) {
     logger.newLine();
-    logger.success("Database reset complete!");
+    logger.remark("Cancelled");
     logger.newLine();
+    return;
+  }
+  const slugConfirmation = await input7({
+    message: `Type the game slug "${game.slug}" to confirm:`,
+    validate: (value) => {
+      if (value !== game.slug) {
+        return `Slug does not match. Please type exactly: ${game.slug}`;
+      }
+      return true;
+    }
+  });
+  if (slugConfirmation !== game.slug) {
+    logger.newLine();
+    logger.remark("Cancelled");
+    logger.newLine();
+    return;
+  }
+  logger.newLine();
+  const schema = await getSchemaInfo();
+  if (!schema) {
+    logger.error("Failed to generate schema. Make sure your database schema directory exists.");
+    logger.newLine();
+    process.exit(1);
+  }
+  const result = await runStep(
+    `Resetting ${environment} database`,
+    async () => {
+      return client.dev.games.database.reset(game.slug, schema);
+    },
+    `${capitalize(environment)} database reset`
+  );
+  if (!result.schemaPushed) {
+    logger.admonition("warning", "Failed to recreate schema", [
+      "During reset, the schema was not successfully pushed to your database.",
+      "Please retry the `db reset` command; if the problem persists, contact support."
+    ]);
+    logger.newLine();
+    process.exit(1);
+  }
+  logger.newLine();
+  logger.success("Database reset complete!");
+  logger.newLine();
+}
+async function runDbResetLocal(options) {
+  const workspace = getWorkspace();
+  const dbDir = join25(workspace, CLI_DIRECTORIES.DATABASE);
+  if (!existsSync20(dbDir)) {
+    logger.warn("No database found to reset");
+    logger.newLine();
+    logger.remark("Nothing to do");
+    logger.newLine();
+    return;
+  }
+  logger.newLine();
+  if (isServerRunning("backend", workspace)) {
+    logger.admonition("warning", "Stop Dev Server First", [
+      "The development server must be stopped before resetting the database.",
+      "Stop the server (Ctrl+C) and run this command again to ensure a clean reset."
+    ]);
+    logger.newLine();
+    process.exit(1);
+  }
+  const shouldReset = await confirm6({
+    message: "This will delete all local database data. Continue?",
+    default: false
+  });
+  if (!shouldReset) {
+    logger.newLine();
+    logger.remark("Nothing to do");
+    logger.newLine();
+    return;
+  }
+  if (!hasDatabaseSetup()) {
+    logger.remark("No drizzle config found, skipping schema setup");
+    logger.newLine();
+    return;
+  }
+  const mf = new Miniflare2({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    d1Databases: [CLOUDFLARE_BINDINGS.DB],
+    d1Persist: dbDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    logger.newLine();
+    await resetDatabase(workspace, mf, { debug: options.debug });
+  } finally {
+    await mf.dispose();
+  }
+  logger.newLine();
+}
+async function runDbReset(options = {}) {
+  try {
+    if (options.remote) {
+      await runDbResetRemote(options);
+    } else {
+      await runDbResetLocal(options);
+    }
   } catch (error) {
     logAndExit(error, logger, { prefix: "Failed to reset database" });
   }
 }
 
 // src/commands/db/seed.ts
-init_package_manager();
-import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync20 } from "fs";
-import { join as join23 } from "path";
-async function runDbSeed(options) {
+init_src();
+init_constants2();
+import { existsSync as existsSync21 } from "fs";
+import { join as join26 } from "path";
+import { confirm as confirm7, input as input8 } from "@inquirer/prompts";
+import { bold as bold7, redBright as redBright2, underline as underline4 } from "colorette";
+import { Miniflare as Miniflare3 } from "miniflare";
+async function runDbResetRemote2(gameSlug, environment) {
+  const client = await requireAuthenticatedClient();
+  const schema = await getSchemaInfo();
+  if (!schema) {
+    logger.error("Failed to generate schema. Make sure your database schema directory exists.");
+    logger.newLine();
+    process.exit(1);
+  }
+  const result = await runStep(
+    `Resetting ${environment} database`,
+    async () => {
+      return client.dev.games.database.reset(gameSlug, schema);
+    },
+    `${capitalize(environment)} database reset`
+  );
+  if (!result.schemaPushed) {
+    logger.admonition("warning", "Failed to recreate schema", [
+      "Schema was not successfully pushed after reset.",
+      "Please retry the command."
+    ]);
+    logger.newLine();
+    process.exit(1);
+  }
+}
+async function runDbSeedRemote(seedFile, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
   const workspace = getWorkspace();
-  try {
-    if (options.reset) {
-      resetDatabase();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
+    logger.newLine();
+    logger.admonition("warning", "Deploy First", [
+      `Deploy your game before seeding remote database: \`playcademy deploy\``
+    ]);
+    logger.newLine();
+    process.exit(1);
+  }
+  const game = await client.games.fetch(deployedGame.gameId);
+  const willReset = options.reset !== false;
+  logger.newLine();
+  if (willReset) {
+    logger.admonition("warning", "Remote Database Seeding", [
+      `Are you sure you want to ${redBright2(underline4(bold7("DELETE ALL DATA")))} in your ${environment} database?`,
+      `This action is irreversible and ${underline4(bold7("cannot be undone"))}.`,
+      `Run this command with \`--no-reset\` if you want to seed without resetting.`
+    ]);
+  } else {
+    logger.admonition("warning", "Remote Database Seeding", [
+      `Are you sure you want to seed your ${environment} database?`,
+      `If existing data is present, this may produce unpredictable results.`,
+      "Proceed with caution."
+    ]);
+  }
+  logger.newLine();
+  if (willReset) {
+    const confirmed = await confirm7({
+      message: "Are you sure you want to reset and seed this database? This cannot be undone.",
+      default: false
+    });
+    if (!confirmed) {
+      logger.newLine();
+      logger.remark("Cancelled");
       logger.newLine();
+      return;
     }
-    if (options.file) {
-      const seedPath = join23(workspace, options.file);
-      if (!existsSync20(seedPath)) {
-        logger.error(`Seed file not found: ${options.file}`);
-        logger.newLine();
-        process.exit(1);
+    const slugConfirmation = await input8({
+      message: `Type the game slug "${game.slug}" to confirm:`,
+      validate: (value) => {
+        if (value !== game.slug) {
+          return `Slug does not match. Please type exactly: ${game.slug}`;
+        }
+        return true;
       }
-      const pm2 = getPackageManager();
-      const tsxCommand = getRunCommand(pm2, `tsx ${seedPath}`);
-      execSync5(tsxCommand, { cwd: workspace, stdio: "inherit" });
+    });
+    if (slugConfirmation !== game.slug) {
+      logger.newLine();
+      logger.remark("Cancelled");
+      logger.newLine();
+      return;
+    }
+  } else {
+    const shouldSeed = await confirm7({
+      message: `Seed ${environment} database for ${game.slug}?`,
+      default: false
+    });
+    if (!shouldSeed) {
+      logger.newLine();
+      logger.remark("Cancelled");
+      logger.newLine();
       return;
     }
-    const pm = getPackageManager();
-    const seedCommand = getRunCommand(pm, "db:seed");
-    execSync5(seedCommand, { cwd: workspace, stdio: "inherit" });
+  }
+  logger.newLine();
+  if (willReset) {
+    await runDbResetRemote2(game.slug, environment);
+  }
+  let bundle;
+  await runStep(
+    "Bundling seed task",
+    async () => {
+      bundle = await bundleSeedWorker(seedFile, workspace);
+    },
+    "Seed task bundled"
+  );
+  await runStep(
+    `Seeding ${environment} database`,
+    async () => {
+      await client.dev.games.deploy.seed(game.slug, bundle.code, environment);
+    },
+    `${environment.charAt(0).toUpperCase() + environment.slice(1)} database seeded`
+  );
+  logger.newLine();
+}
+async function runDbSeedLocal(seedFile, options) {
+  const workspace = getWorkspace();
+  const dbDir = join26(workspace, CLI_DIRECTORIES.DATABASE);
+  const mf = new Miniflare3({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    d1Databases: [CLOUDFLARE_BINDINGS.DB],
+    d1Persist: dbDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  logger.newLine();
+  if (options.reset !== false) {
+    await resetDatabase(workspace, mf, { debug: options.debug });
+  }
+  try {
+    await executeSeedFile(seedFile, mf);
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runDbSeed(options = {}) {
+  const workspace = getWorkspace();
+  try {
+    const seedFile = options.file ? join26(workspace, options.file) : join26(workspace, DEFAULT_DATABASE_DIRECTORY, DEFAULT_SEED_FILE_NAME);
+    if (!existsSync21(seedFile)) {
+      logger.newLine();
+      logger.error(`Seed file not found: ${seedFile}`);
+      logger.newLine();
+      logger.admonition("tip", "Create Seed File", [
+        "Run `playcademy db init` to scaffold database with seed file",
+        `Or create ${seedFile} with: \`export async function seed(c: Context) { ... }\``
+      ]);
+      logger.newLine();
+      process.exit(1);
+    }
+    if (options.remote) {
+      await runDbSeedRemote(seedFile, options);
+    } else {
+      await runDbSeedLocal(seedFile, options);
+    }
   } catch (error) {
-    logAndExit(error, logger, { prefix: "Failed to run seed" });
+    logger.newLine();
+    logger.error(
+      `Failed to seed database: ${error instanceof Error ? error.message : String(error)}`
+    );
+    logger.newLine();
+    process.exit(1);
   }
 }
 
 // src/commands/db/index.ts
 var dbCommand = new Command14("db").description("Database management commands");
 dbCommand.command("init").description("Add database to your project").action(runDbInit);
-dbCommand.command("reset").description("Reset local development database (deletes data and recreates with schema)").action(runDbReset);
-dbCommand.command("seed [file]").description("Seed local database with initial data").option("-r, --reset", "Reset database before seeding").action((file, options) => runDbSeed({ file, reset: options.reset }));
+dbCommand.command("reset").description("Reset database").option("--remote", "Reset remote deployed database").option("--env <environment>", "Environment: staging (default) or production").option("--debug", "Enable debug mode").action(
+  (options) => runDbReset({ debug: options.debug, remote: options.remote, env: options.env })
+);
+dbCommand.command("seed [file]").description("Seed database with initial data").option("--no-reset", "Skip database reset before seeding").option("--remote", "Seed remote deployed database").option("--debug", "Enable debug mode").option("--env <environment>", "Environment: staging (default) or production").action(
+  (file, options) => runDbSeed({
+    file,
+    reset: options.reset,
+    remote: options.remote,
+    env: options.env,
+    debug: options.debug
+  })
+);
 dbCommand.command("diff").description("Show schema changes since last deployment").action(runDbDiff);
 
 // src/commands/kv/index.ts
@@ -9648,9 +10215,9 @@ import { Command as Command15 } from "commander";
 // src/commands/kv/clear.ts
 init_string();
 init_constants2();
-import { join as join24 } from "path";
-import { confirm as confirm7 } from "@inquirer/prompts";
-import { Miniflare as Miniflare3 } from "miniflare";
+import { join as join27 } from "path";
+import { confirm as confirm8 } from "@inquirer/prompts";
+import { Miniflare as Miniflare4 } from "miniflare";
 async function runKVClear(options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -9681,15 +10248,15 @@ async function runKVClear(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join24(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare3({
+    const kvDir = join27(getWorkspace(), CLI_DIRECTORIES.KV);
+    const mf = new Miniflare4({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       const listResult = await kv.list();
       const keyCount = listResult.keys?.length || 0;
       if (keyCount === 0) {
@@ -9711,7 +10278,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 confirm7({
+        const confirmed = await confirm8({
           message: "Are you sure you want to clear all keys?",
           default: false
         });
@@ -9753,8 +10320,8 @@ async function runKVClear(options = {}) {
 
 // src/commands/kv/delete.ts
 init_constants2();
-import { join as join25 } from "path";
-import { Miniflare as Miniflare4 } from "miniflare";
+import { join as join28 } from "path";
+import { Miniflare as Miniflare5 } from "miniflare";
 async function runKVDelete(key, options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -9794,15 +10361,15 @@ async function runKVDelete(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join25(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare4({
+    const kvDir = join28(getWorkspace(), CLI_DIRECTORIES.KV);
+    const mf = new Miniflare5({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       await kv.delete(key);
       if (options.json) {
         logger.json({
@@ -9831,8 +10398,8 @@ async function runKVDelete(key, options = {}) {
 
 // src/commands/kv/get.ts
 init_constants2();
-import { join as join26 } from "path";
-import { Miniflare as Miniflare5 } from "miniflare";
+import { join as join29 } from "path";
+import { Miniflare as Miniflare6 } from "miniflare";
 async function runKVGet(key, options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -9872,15 +10439,15 @@ async function runKVGet(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join26(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare5({
+    const kvDir = join29(getWorkspace(), CLI_DIRECTORIES.KV);
+    const mf = new Miniflare6({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       const value = await kv.get(key);
       if (value === null) {
         if (!options.raw && !options.json) {
@@ -9937,7 +10504,7 @@ async function runKVGet(key, options = {}) {
 
 // src/commands/kv/init.ts
 init_constants2();
-import { input as input7 } from "@inquirer/prompts";
+import { input as input9 } from "@inquirer/prompts";
 init_writer();
 init_loader2();
 var sampleCustomRouteTemplate3 = loadTemplateString("api/sample-custom.ts");
@@ -9970,7 +10537,7 @@ async function runKVInit() {
     logger.success("Added KV integration to config");
     logger.newLine();
     if (!hasLocalCustomRoutes(getWorkspace(), config)) {
-      const apiDirectory = await input7({
+      const apiDirectory = await input9({
         message: "  \u2514\u2500 API routes directory:",
         default: DEFAULT_API_ROUTES_DIRECTORY,
         validate: (value) => {
@@ -10011,8 +10578,8 @@ async function runKVInit() {
 
 // src/commands/kv/inspect.ts
 init_constants2();
-import { join as join27 } from "path";
-import { Miniflare as Miniflare6 } from "miniflare";
+import { join as join30 } from "path";
+import { Miniflare as Miniflare7 } from "miniflare";
 async function runKVInspect(key, options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -10052,15 +10619,15 @@ async function runKVInspect(key, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join27(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare6({
+    const kvDir = join30(getWorkspace(), CLI_DIRECTORIES.KV);
+    const mf = new Miniflare7({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       const value = await kv.get(key);
       if (value === null) {
         const metadata2 = {
@@ -10140,8 +10707,8 @@ async function runKVInspect(key, options = {}) {
 // src/commands/kv/list.ts
 init_string();
 init_constants2();
-import { join as join28 } from "path";
-import { Miniflare as Miniflare7 } from "miniflare";
+import { join as join31 } from "path";
+import { Miniflare as Miniflare8 } from "miniflare";
 async function runKVList(options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -10172,15 +10739,15 @@ async function runKVList(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join28(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare7({
+    const kvDir = join31(getWorkspace(), CLI_DIRECTORIES.KV);
+    const mf = new Miniflare8({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       const listResult = await kv.list();
       const keyNames = listResult.keys?.map((k) => k.name) || [];
       if (options.json) {
@@ -10221,9 +10788,9 @@ async function runKVList(options = {}) {
 init_file_loader();
 init_string();
 init_constants2();
-import { join as join29 } from "path";
-import { confirm as confirm8 } from "@inquirer/prompts";
-import { Miniflare as Miniflare8 } from "miniflare";
+import { join as join32 } from "path";
+import { confirm as confirm9 } from "@inquirer/prompts";
+import { Miniflare as Miniflare9 } from "miniflare";
 async function runKVSeed(seedFile, options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -10287,15 +10854,15 @@ async function runKVSeed(seedFile, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join29(workspace, CLI_DIRECTORIES.KV);
-    const mf = new Miniflare8({
+    const kvDir = join32(workspace, CLI_DIRECTORIES.KV);
+    const mf = new Miniflare9({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       const keysToSeed = Object.keys(seedData);
       if (!options.force && !options.replace && !options.raw && !options.json) {
         const existingKeys = [];
@@ -10310,7 +10877,7 @@ async function runKVSeed(seedFile, options = {}) {
             `${existingKeys.length} ${pluralize(existingKeys.length, "key")} will be overwritten`
           );
           logger.newLine();
-          const confirmed = await confirm8({
+          const confirmed = await confirm9({
             message: "Continue seeding?",
             default: false
           });
@@ -10368,8 +10935,8 @@ async function runKVSeed(seedFile, options = {}) {
 // src/commands/kv/set.ts
 init_file_loader();
 init_constants2();
-import { join as join30 } from "path";
-import { Miniflare as Miniflare9 } from "miniflare";
+import { join as join33 } from "path";
+import { Miniflare as Miniflare10 } from "miniflare";
 async function runKVSet(key, value, options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -10438,15 +11005,15 @@ async function runKVSet(key, value, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join30(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare9({
+    const kvDir = join33(getWorkspace(), CLI_DIRECTORIES.KV);
+    const mf = new Miniflare10({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       await kv.put(key, valueToSet);
       if (options.json) {
         logger.json({
@@ -10476,8 +11043,8 @@ async function runKVSet(key, value, options = {}) {
 // src/commands/kv/stats.ts
 init_string();
 init_constants2();
-import { join as join31 } from "path";
-import { Miniflare as Miniflare10 } from "miniflare";
+import { join as join34 } from "path";
+import { Miniflare as Miniflare11 } from "miniflare";
 async function runKVStats(options = {}) {
   try {
     if (!options.raw && !options.json) {
@@ -10508,15 +11075,15 @@ async function runKVStats(options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join31(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare10({
+    const kvDir = join34(getWorkspace(), CLI_DIRECTORIES.KV);
+    const mf = new Miniflare11({
       modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: ["KV"],
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
       kvPersist: kvDir,
       compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
     try {
-      const kv = await mf.getKVNamespace("KV");
+      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
       const listResult = await kv.list();
       const keys = listResult.keys || [];
       let totalSize = 0;
@@ -10623,87 +11190,246 @@ kvCommand.command("seed <file>").description("Seed KV namespace with key-value p
 // src/commands/bucket/index.ts
 import { Command as Command16 } from "commander";
 
-// src/commands/bucket/delete.ts
+// src/commands/bucket/bulk.ts
 init_constants2();
-import { join as join32 } from "path";
-import { Miniflare as Miniflare11 } from "miniflare";
-async function runBucketDelete(key, options = {}) {
-  try {
+import { existsSync as existsSync22, statSync as statSync3 } from "fs";
+import { join as join35 } from "path";
+import { Miniflare as Miniflare12 } from "miniflare";
+async function runBucketBulkRemote(directory, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        `Deploy your game before accessing remote bucket: \`playcademy deploy\``
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote bucket operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("warning", "Coming Soon", [
-          "Remote bucket support is on the roadmap and will be available soon.",
-          "For now, bucket commands only work with local development storage."
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  const { files, totalSize } = collectBulkFiles(directory);
+  if (files.length === 0) {
+    if (!options.raw && !options.json) {
+      logger.warn("No files found to upload");
+      logger.newLine();
     }
-    if (!key) {
-      if (!options.raw && !options.json) {
-        logger.error("File key is required");
-        logger.newLine();
-        logger.admonition("tip", "Usage", ["`playcademy bucket delete <key>`"]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(0);
+  }
+  if (options.dryRun) {
+    outputDryRunResults(files, totalSize, options.prefix, options.json, options.raw);
+    return;
+  }
+  const game = await client.games.fetch(deployedGame.gameId);
+  const uploaded = await uploadFilesRemote(
+    files,
+    game.slug,
+    options.prefix,
+    client.dev.games.bucket.put.bind(client.dev.games.bucket)
+  );
+  outputUploadResults(uploaded, totalSize, environment, options.prefix, options.json, options.raw);
+}
+async function runBucketBulkLocal(directory, options) {
+  const config = await loadConfig();
+  if (!hasBucketSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("Bucket storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy bucket init` to enable bucket storage"
+      ]);
+      logger.newLine();
     }
-    const config = await loadConfig();
-    if (!hasBucketSetup(config)) {
+    process.exit(1);
+  }
+  const { files, totalSize } = collectBulkFiles(directory);
+  if (files.length === 0) {
+    if (!options.raw && !options.json) {
+      logger.warn("No files found to upload");
+      logger.newLine();
+    }
+    process.exit(0);
+  }
+  if (options.dryRun) {
+    outputDryRunResults(files, totalSize, options.prefix, options.json, options.raw);
+    return;
+  }
+  const bucketDir = join35(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const mf = new Miniflare12({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
+    r2Persist: bucketDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const bucket = await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+    const uploaded = await uploadFilesLocal(
+      files,
+      options.prefix,
+      async (key, content, contentType) => {
+        await bucket.put(key, content, {
+          httpMetadata: {
+            contentType
+          }
+        });
+      }
+    );
+    outputUploadResults(
+      uploaded,
+      totalSize,
+      void 0,
+      options.prefix,
+      options.json,
+      options.raw
+    );
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runBucketBulk(directory, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
+    }
+    if (!existsSync22(directory)) {
       if (!options.raw && !options.json) {
-        logger.error("Bucket storage is not configured");
+        logger.error(`Directory not found: ${directory}`);
         logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy bucket init` to enable bucket storage"
-        ]);
+      }
+      process.exit(1);
+    }
+    const stats = statSync3(directory);
+    if (!stats.isDirectory()) {
+      if (!options.raw && !options.json) {
+        logger.error(`Not a directory: ${directory}`);
         logger.newLine();
       }
       process.exit(1);
     }
-    const bucketDir = join32(getWorkspace(), CLI_DIRECTORIES.BUCKET);
-    const mf = new Miniflare11({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      r2Buckets: ["BUCKET"],
-      r2Persist: bucketDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+    if (options.remote) {
+      await runBucketBulkRemote(directory, options);
+    } else {
+      await runBucketBulkLocal(directory, options);
+    }
+  } catch (error) {
+    if (!options.raw && !options.json) {
+      logger.error(
+        `Failed to bulk upload: ${error instanceof Error ? error.message : String(error)}`
+      );
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/bucket/delete.ts
+init_constants2();
+import { join as join36 } from "path";
+import { Miniflare as Miniflare13 } from "miniflare";
+async function runBucketDeleteRemote(key, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
+    if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        `Deploy your game before accessing remote bucket: \`playcademy deploy\``
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const game = await client.games.fetch(deployedGame.gameId);
+  await client.dev.games.bucket.delete(game.slug, key);
+  if (options.json) {
+    logger.json({
+      success: true,
+      key,
+      message: "File deleted successfully"
     });
-    try {
-      const bucket = await mf.getR2Bucket("BUCKET");
-      const object = await bucket.get(key);
-      if (!object) {
-        if (!options.raw && !options.json) {
-          logger.warn(`File '${key}' not found`);
-          logger.newLine();
-          logger.admonition("tip", "Hint", [
-            "Use `playcademy bucket list` to see all available files"
-          ]);
-          logger.newLine();
-        }
-        process.exit(1);
-      }
-      await bucket.delete(key);
-      if (options.json) {
-        logger.json({
-          success: true,
-          key,
-          message: "File deleted successfully"
-        });
-        return;
-      }
-      if (options.raw) {
-        logger.raw(`Deleted ${key}`);
-        return;
+    return;
+  }
+  if (options.raw) {
+    logger.raw(`Deleted ${key}`);
+    return;
+  }
+  logger.newLine();
+  logger.success(`Deleted '${key}' from ${environment}`);
+  logger.newLine();
+}
+async function runBucketDeleteLocal(key, options) {
+  if (!key) {
+    if (!options.raw && !options.json) {
+      logger.error("File key is required");
+      logger.newLine();
+      logger.admonition("tip", "Usage", ["`playcademy bucket delete <key>`"]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  if (!hasBucketSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("Bucket storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy bucket init` to enable bucket storage"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const bucketDir = join36(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const mf = new Miniflare13({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
+    r2Persist: bucketDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const bucket = await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+    const object = await bucket.get(key);
+    if (!object) {
+      if (!options.raw && !options.json) {
+        logger.warn(`File '${key}' not found`);
+        logger.newLine();
+        logger.admonition("tip", "Hint", [
+          "Use `playcademy bucket list` to see all available files"
+        ]);
+        logger.newLine();
       }
-      logger.success(`Deleted '${key}'`);
+      process.exit(1);
+    }
+    await bucket.delete(key);
+    if (options.json) {
+      logger.json({
+        success: true,
+        key,
+        message: "File deleted successfully"
+      });
+      return;
+    }
+    if (options.raw) {
+      logger.raw(`Deleted ${key}`);
+      return;
+    }
+    logger.success(`Deleted '${key}'`);
+    logger.newLine();
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runBucketDelete(key, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
       logger.newLine();
-    } finally {
-      await mf.dispose();
+    }
+    if (options.remote) {
+      await runBucketDeleteRemote(key, options);
+    } else {
+      await runBucketDeleteLocal(key, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -10719,108 +11445,171 @@ async function runBucketDelete(key, options = {}) {
 // src/commands/bucket/get.ts
 init_constants2();
 import { writeFileSync as writeFileSync10 } from "fs";
-import { join as join33 } from "path";
-import { Miniflare as Miniflare12 } from "miniflare";
-async function runBucketGet(key, options = {}) {
-  try {
+import { join as join37 } from "path";
+import { Miniflare as Miniflare14 } from "miniflare";
+async function runBucketGetRemote(key, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        `Deploy your game before accessing remote bucket: \`playcademy deploy\``
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
+    process.exit(1);
+  }
+  const game = await client.games.fetch(deployedGame.gameId);
+  let arrayBuffer;
+  try {
+    arrayBuffer = await client.dev.games.bucket.get(game.slug, key);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("not found")) {
       if (!options.raw && !options.json) {
+        logger.warn(`File '${key}' not found in ${environment}`);
         logger.newLine();
-        logger.warn("Remote bucket operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote bucket support is on the roadmap and will be available soon.",
-          "For now, bucket commands only work with local development storage."
+        logger.admonition("note", "Hint", [
+          `Use \`playcademy bucket list --remote\` to see all available files`
         ]);
         logger.newLine();
       }
       process.exit(1);
     }
-    if (!key) {
+    throw error;
+  }
+  if (options.json) {
+    logger.json({
+      key,
+      size: arrayBuffer.byteLength,
+      message: "Use --output to save file"
+    });
+    return;
+  }
+  if (options.output) {
+    writeFileSync10(options.output, Buffer.from(arrayBuffer));
+    if (!options.raw) {
+      logger.newLine();
+      logger.success(`Downloaded '${key}' from ${environment} to '${options.output}'`);
+      logger.newLine();
+      logger.data("Size", `${arrayBuffer.byteLength} bytes`, 1);
+      logger.newLine();
+    }
+    return;
+  }
+  if (options.raw) {
+    process.stdout.write(Buffer.from(arrayBuffer));
+    return;
+  }
+  logger.newLine();
+  logger.success(`File: ${key}`);
+  logger.newLine();
+  logger.data("Size", `${arrayBuffer.byteLength} bytes`, 1);
+  logger.data("Environment", environment, 1);
+  logger.newLine();
+  logger.admonition("note", "Download File", [
+    `Use \`playcademy bucket get ${key} --output path/to/file --remote\` to download`
+  ]);
+  logger.newLine();
+}
+async function runBucketGetLocal(key, options) {
+  if (!key) {
+    if (!options.raw && !options.json) {
+      logger.error("File key is required");
+      logger.newLine();
+      logger.admonition("note", "Usage", [
+        "`playcademy bucket get <key> --output path/to/file`"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  if (!hasBucketSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("Bucket storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy bucket init` to enable bucket storage"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const bucketDir = join37(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const mf = new Miniflare14({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
+    r2Persist: bucketDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const bucket = await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+    const object = await bucket.get(key);
+    if (!object) {
       if (!options.raw && !options.json) {
-        logger.error("File key is required");
+        logger.warn(`Failed to get object: File '${key}' not found`);
         logger.newLine();
-        logger.admonition("tip", "Usage", ["`playcademy bucket get <key> --output <file>`"]);
+        logger.admonition("tip", "Hint", [
+          "Use `playcademy bucket list` to see all available files"
+        ]);
         logger.newLine();
       }
       process.exit(1);
     }
-    const config = await loadConfig();
-    if (!hasBucketSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("Bucket storage is not configured");
+    if (options.json) {
+      const metadata = {
+        key: object.key,
+        size: object.size,
+        uploaded: object.uploaded.toISOString(),
+        httpMetadata: object.httpMetadata,
+        customMetadata: object.customMetadata
+      };
+      logger.json(metadata);
+      return;
+    }
+    if (options.output) {
+      const buffer = await object.arrayBuffer();
+      writeFileSync10(options.output, Buffer.from(buffer));
+      if (!options.raw) {
+        logger.success(`Downloaded '${key}' to '${options.output}'`);
         logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy bucket init` to enable bucket storage"
-        ]);
+        logger.data("Size", `${object.size} bytes`, 1);
+        logger.data("Content-Type", object.httpMetadata?.contentType || "unknown", 1);
         logger.newLine();
       }
-      process.exit(1);
+      return;
     }
-    const bucketDir = join33(getWorkspace(), CLI_DIRECTORIES.BUCKET);
-    const mf = new Miniflare12({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      r2Buckets: ["BUCKET"],
-      r2Persist: bucketDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const bucket = await mf.getR2Bucket("BUCKET");
-      const object = await bucket.get(key);
-      if (!object) {
-        if (!options.raw && !options.json) {
-          logger.warn(`File '${key}' not found`);
-          logger.newLine();
-          logger.admonition("tip", "Hint", [
-            "Use `playcademy bucket list` to see all available files"
-          ]);
-          logger.newLine();
-        }
-        process.exit(1);
-      }
-      if (options.json) {
-        const metadata = {
-          key: object.key,
-          size: object.size,
-          uploaded: object.uploaded.toISOString(),
-          httpMetadata: object.httpMetadata,
-          customMetadata: object.customMetadata
-        };
-        logger.json(metadata);
-        return;
-      }
-      if (options.output) {
-        const buffer = await object.arrayBuffer();
-        writeFileSync10(options.output, Buffer.from(buffer));
-        if (!options.raw) {
-          logger.success(`Downloaded '${key}' to '${options.output}'`);
-          logger.newLine();
-          logger.data("Size", `${object.size} bytes`, 1);
-          logger.data("Content-Type", object.httpMetadata?.contentType || "unknown", 1);
-          logger.newLine();
-        }
-        return;
-      }
-      if (options.raw) {
-        const text5 = await object.text();
-        logger.raw(text5);
-        return;
-      }
-      logger.success(`File: ${key}`);
-      logger.newLine();
-      logger.data("Size", `${object.size} bytes`, 1);
-      logger.data("Content-Type", object.httpMetadata?.contentType || "unknown", 1);
-      logger.data("Uploaded", new Date(object.uploaded).toLocaleString(), 1);
-      logger.newLine();
-      logger.admonition("tip", "Download File", [
-        `Use \`playcademy bucket get ${key} --output <file>\` to download`
-      ]);
+    if (options.raw) {
+      const text5 = await object.text();
+      logger.raw(text5);
+      return;
+    }
+    logger.success(`File: ${key}`);
+    logger.newLine();
+    logger.data("Size", `${object.size} bytes`, 1);
+    logger.data("Content-Type", object.httpMetadata?.contentType || "unknown", 1);
+    logger.data("Uploaded", new Date(object.uploaded).toLocaleString(), 1);
+    logger.newLine();
+    logger.admonition("note", "Download File", [
+      `Use \`playcademy bucket get ${key} --output path/to/file\` to download`
+    ]);
+    logger.newLine();
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runBucketGet(key, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
       logger.newLine();
-    } finally {
-      await mf.dispose();
+    }
+    if (options.remote) {
+      await runBucketGetRemote(key, options);
+    } else {
+      await runBucketGetLocal(key, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -10835,7 +11624,7 @@ async function runBucketGet(key, options = {}) {
 
 // src/commands/bucket/init.ts
 init_constants2();
-import { input as input8 } from "@inquirer/prompts";
+import { input as input10 } from "@inquirer/prompts";
 init_writer();
 init_loader2();
 var sampleCustomRouteTemplate4 = loadTemplateString("api/sample-custom.ts");
@@ -10868,7 +11657,7 @@ async function runBucketInit() {
     logger.success("Added bucket integration to config");
     logger.newLine();
     if (!hasLocalCustomRoutes(getWorkspace(), config)) {
-      const apiDirectory = await input8({
+      const apiDirectory = await input10({
         message: "  \u2514\u2500 API routes directory:",
         default: DEFAULT_API_ROUTES_DIRECTORY,
         validate: (value) => {
@@ -10909,94 +11698,140 @@ async function runBucketInit() {
 
 // src/commands/bucket/list.ts
 init_constants2();
-import { join as join34 } from "path";
-import { Miniflare as Miniflare13 } from "miniflare";
-async function runBucketList(options = {}) {
-  try {
+import { join as join38 } from "path";
+import { Miniflare as Miniflare15 } from "miniflare";
+async function runBucketListRemote(options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        `Deploy your game before accessing remote bucket: \`playcademy deploy\``
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote bucket operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote bucket support is on the roadmap and will be available soon.",
-          "For now, bucket commands only work with local development storage."
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  const game = await client.games.fetch(deployedGame.gameId);
+  const files = await client.dev.games.bucket.list(game.slug, options.prefix);
+  if (options.json) {
+    logger.json(files);
+    return;
+  }
+  if (options.raw) {
+    for (const file of files) {
+      logger.raw(file.key);
     }
-    const config = await loadConfig();
-    if (!hasBucketSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("Bucket storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy bucket init` to enable bucket storage"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    return;
+  }
+  if (!options.raw && !options.json) {
+    logger.newLine();
+  }
+  if (files.length === 0) {
+    logger.remark("No files found in remote bucket");
+    if (options.prefix) {
+      logger.newLine();
+      logger.data("Prefix", options.prefix, 1);
     }
-    const bucketDir = join34(getWorkspace(), CLI_DIRECTORIES.BUCKET);
-    const mf = new Miniflare13({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      r2Buckets: ["BUCKET"],
-      r2Persist: bucketDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const bucket = await mf.getR2Bucket("BUCKET");
-      const listed = await bucket.list({ prefix: options.prefix });
-      const files = listed.objects;
-      if (options.json) {
-        const fileData = files.map((obj) => ({
-          key: obj.key,
-          size: obj.size,
-          uploaded: obj.uploaded.toISOString()
-        }));
-        logger.json(fileData);
-        return;
-      }
-      if (options.raw) {
-        for (const file of files) {
-          logger.raw(file.key);
-        }
-        return;
-      }
-      if (files.length === 0) {
-        logger.remark("No files found in bucket");
-        if (options.prefix) {
-          logger.newLine();
-          logger.data("Prefix", options.prefix, 1);
-        }
-        logger.newLine();
-        return;
+    logger.newLine();
+    return;
+  }
+  logger.success(`Found ${files.length} file${files.length === 1 ? "" : "s"} in ${environment}`);
+  if (options.prefix) {
+    logger.data("Prefix", options.prefix, 1);
+  }
+  logger.newLine();
+  logger.table(
+    files.map((file) => ({
+      Key: file.key,
+      Size: formatBytes2(file.size),
+      Uploaded: new Date(file.uploaded).toLocaleString()
+    }))
+  );
+  logger.newLine();
+}
+async function runBucketListLocal(options) {
+  const config = await loadConfig();
+  if (!hasBucketSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("Bucket storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy bucket init` to enable bucket storage"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const bucketDir = join38(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const mf = new Miniflare15({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
+    r2Persist: bucketDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const bucket = await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+    const listed = await bucket.list({ prefix: options.prefix });
+    const files = listed.objects;
+    if (options.json) {
+      const fileData = files.map((obj) => ({
+        key: obj.key,
+        size: obj.size,
+        uploaded: obj.uploaded.toISOString()
+      }));
+      logger.json(fileData);
+      return;
+    }
+    if (options.raw) {
+      for (const file of files) {
+        logger.raw(file.key);
       }
-      logger.success(`Found ${files.length} file${files.length === 1 ? "" : "s"}`);
+      return;
+    }
+    if (files.length === 0) {
+      logger.remark("No files found in bucket");
       if (options.prefix) {
+        logger.newLine();
         logger.data("Prefix", options.prefix, 1);
       }
       logger.newLine();
-      logger.table(
-        files.map((obj) => ({
-          Key: obj.key,
-          Size: formatBytes(obj.size),
-          Uploaded: new Date(obj.uploaded).toLocaleString()
-        }))
-      );
+      return;
+    }
+    logger.success(`Found ${files.length} file${files.length === 1 ? "" : "s"}`);
+    if (options.prefix) {
+      logger.data("Prefix", options.prefix, 1);
+    }
+    logger.newLine();
+    logger.table(
+      files.map((obj) => ({
+        Key: obj.key,
+        Size: formatBytes2(obj.size),
+        Uploaded: new Date(obj.uploaded).toLocaleString()
+      }))
+    );
+    logger.newLine();
+    if (listed.truncated) {
+      logger.admonition("info", "Truncated Results", [
+        "The list was truncated. Use --prefix to narrow down results."
+      ]);
       logger.newLine();
-      if (listed.truncated) {
-        logger.admonition("info", "Truncated Results", [
-          "The list was truncated. Use --prefix to narrow down results."
-        ]);
-        logger.newLine();
-      }
-    } finally {
-      await mf.dispose();
+    }
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runBucketList(options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
+    }
+    if (options.remote) {
+      await runBucketListRemote(options);
+    } else {
+      await runBucketListLocal(options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -11008,7 +11843,7 @@ async function runBucketList(options = {}) {
     process.exit(1);
   }
 }
-function formatBytes(bytes) {
+function formatBytes2(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
   const sizes = ["B", "KB", "MB", "GB"];
@@ -11018,94 +11853,137 @@ function formatBytes(bytes) {
 
 // src/commands/bucket/put.ts
 init_constants2();
-import { readFileSync as readFileSync8, statSync as statSync2 } from "fs";
-import { join as join35 } from "path";
-import { Miniflare as Miniflare14 } from "miniflare";
-async function runBucketPut(key, filePath, options = {}) {
+import { readFileSync as readFileSync10, statSync as statSync4 } from "fs";
+import { join as join39 } from "path";
+import { Miniflare as Miniflare16 } from "miniflare";
+async function runBucketPutRemote(key, filePath, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
+    if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        `Deploy your game before accessing remote bucket: \`playcademy deploy\``
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  let fileBuffer;
+  let fileSize;
   try {
+    fileBuffer = readFileSync10(filePath);
+    fileSize = statSync4(filePath).size;
+  } catch {
     if (!options.raw && !options.json) {
+      logger.error(`File not found: ${filePath}`);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote bucket operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote bucket support is on the roadmap and will be available soon.",
-          "For now, bucket commands only work with local development storage."
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  const game = await client.games.fetch(deployedGame.gameId);
+  const contentType = getContentType(filePath);
+  await client.dev.games.bucket.put(game.slug, key, fileBuffer, contentType);
+  if (options.json) {
+    logger.json({
+      success: true,
+      key,
+      size: fileSize,
+      uploaded: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return;
+  }
+  if (options.raw) {
+    logger.raw(`Uploaded ${key}`);
+    return;
+  }
+  logger.newLine();
+  logger.success(`Uploaded '${filePath}' to '${key}' in ${environment}`);
+  logger.newLine();
+  logger.data("Size", `${fileSize} bytes`, 1);
+  logger.data("Content-Type", contentType, 1);
+  logger.newLine();
+}
+async function runBucketPutLocal(key, filePath, options) {
+  if (!key || !filePath) {
+    if (!options.raw && !options.json) {
+      logger.error("File key and path are required");
+      logger.newLine();
+      logger.admonition("tip", "Usage", ["`playcademy bucket put <key> <file>`"]);
+      logger.newLine();
     }
-    if (!key || !filePath) {
-      if (!options.raw && !options.json) {
-        logger.error("File key and path are required");
-        logger.newLine();
-        logger.admonition("tip", "Usage", ["`playcademy bucket put <key> <file>`"]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  if (!hasBucketSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("Bucket storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy bucket init` to enable bucket storage"
+      ]);
+      logger.newLine();
     }
-    const config = await loadConfig();
-    if (!hasBucketSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("Bucket storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy bucket init` to enable bucket storage"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  let fileBuffer;
+  let fileSize;
+  try {
+    fileBuffer = readFileSync10(filePath);
+    fileSize = statSync4(filePath).size;
+  } catch {
+    if (!options.raw && !options.json) {
+      logger.error(`File not found: ${filePath}`);
+      logger.newLine();
     }
-    let fileBuffer;
-    let fileSize;
-    try {
-      fileBuffer = readFileSync8(filePath);
-      fileSize = statSync2(filePath).size;
-    } catch {
-      if (!options.raw && !options.json) {
-        logger.error(`File not found: ${filePath}`);
-        logger.newLine();
+    process.exit(1);
+  }
+  const bucketDir = join39(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const mf = new Miniflare16({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
+    r2Persist: bucketDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const bucket = await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+    await bucket.put(key, new Uint8Array(fileBuffer).buffer, {
+      httpMetadata: {
+        contentType: getContentType(filePath)
       }
-      process.exit(1);
-    }
-    const bucketDir = join35(getWorkspace(), CLI_DIRECTORIES.BUCKET);
-    const mf = new Miniflare14({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      r2Buckets: ["BUCKET"],
-      r2Persist: bucketDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
     });
-    try {
-      const bucket = await mf.getR2Bucket("BUCKET");
-      await bucket.put(key, new Uint8Array(fileBuffer).buffer, {
-        httpMetadata: {
-          contentType: getContentType(filePath)
-        }
+    if (options.json) {
+      logger.json({
+        success: true,
+        key,
+        size: fileSize,
+        uploaded: (/* @__PURE__ */ new Date()).toISOString()
       });
-      if (options.json) {
-        logger.json({
-          success: true,
-          key,
-          size: fileSize,
-          uploaded: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        return;
-      }
-      if (options.raw) {
-        logger.raw(`Uploaded ${key}`);
-        return;
-      }
-      logger.success(`Uploaded '${filePath}' to '${key}'`);
-      logger.newLine();
-      logger.data("Size", `${fileSize} bytes`, 1);
-      logger.data("Content-Type", getContentType(filePath), 1);
+      return;
+    }
+    if (options.raw) {
+      logger.raw(`Uploaded ${key}`);
+      return;
+    }
+    logger.success(`Uploaded '${filePath}' to '${key}'`);
+    logger.newLine();
+    logger.data("Size", `${fileSize} bytes`, 1);
+    logger.data("Content-Type", getContentType(filePath), 1);
+    logger.newLine();
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runBucketPut(key, filePath, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
       logger.newLine();
-    } finally {
-      await mf.dispose();
+    }
+    if (options.remote) {
+      await runBucketPutRemote(key, filePath, options);
+    } else {
+      await runBucketPutLocal(key, filePath, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -11117,58 +11995,44 @@ async function runBucketPut(key, filePath, options = {}) {
     process.exit(1);
   }
 }
-function getContentType(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  const types = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    svg: "image/svg+xml",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    ogg: "audio/ogg",
-    mp4: "video/mp4",
-    webm: "video/webm",
-    pdf: "application/pdf",
-    json: "application/json",
-    txt: "text/plain",
-    html: "text/html",
-    css: "text/css",
-    js: "application/javascript"
-  };
-  return types[ext || ""] || "application/octet-stream";
-}
 
 // src/commands/bucket/index.ts
 var bucketCommand = new Command16("bucket").description("Manage bucket storage integration").action(() => {
   bucketCommand.help();
 });
 bucketCommand.command("init").description("Add bucket storage integration to your project").action(runBucketInit);
-bucketCommand.command("list").alias("ls").description("List files in local bucket").option("--prefix <prefix>", "Filter files by key prefix").option("--raw", "Output file keys one per line, no formatting").option("--json", "Output as JSON array").option("--remote", "Use remote bucket (not yet implemented)").option(
+bucketCommand.command("list").alias("ls").description("List files in bucket").option("--prefix <prefix>", "Filter files by key prefix").option("--raw", "Output file keys one per line, no formatting").option("--json", "Output as JSON array").option("--remote", "Use remote bucket instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runBucketList);
-bucketCommand.command("get <key>").description("Download a file from local bucket").option("-o, --output <path>", "Output file path (required for binary files)").option("--raw", "Output file content to stdout").option("--json", "Output metadata as JSON").option("--remote", "Use remote bucket (not yet implemented)").option(
+bucketCommand.command("get <key>").description("Download a file from bucket").option("-o, --output <path>", "Output file path (required for binary files)").option("--raw", "Output file content to stdout").option("--json", "Output metadata as JSON").option("--remote", "Use remote bucket instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runBucketGet);
-bucketCommand.command("put <key> <file>").description("Upload a file to local bucket").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--remote", "Use remote bucket (not yet implemented)").option(
+bucketCommand.command("put <key> <file>").description("Upload a file to bucket").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--remote", "Use remote bucket instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runBucketPut);
-bucketCommand.command("delete <key>").alias("del").alias("rm").description("Delete a file from local bucket").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--remote", "Use remote bucket (not yet implemented)").option(
+bucketCommand.command("delete <key>").alias("del").alias("rm").description("Delete a file from bucket").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--remote", "Use remote bucket instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runBucketDelete);
+bucketCommand.command("bulk <directory>").description(
+  "Upload directory contents to bucket (preserves subdirectory structure, strips source directory name)"
+).option(
+  "--prefix <prefix>",
+  "Prefix for all uploaded keys (use to include source dir: --prefix assets)"
+).option("--dry-run", "Show what would be uploaded without uploading").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--remote", "Use remote bucket instead of local").option(
+  "--env <environment>",
+  "Environment to use with --remote: staging (default) or production"
+).action(runBucketBulk);
 
 // src/commands/secret/index.ts
 import { Command as Command20 } from "commander";
 
 // src/commands/secret/delete.ts
 init_src();
-import { confirm as confirm9 } from "@inquirer/prompts";
+import { confirm as confirm10 } from "@inquirer/prompts";
 import { Command as Command17 } from "commander";
 var deleteCommand2 = new Command17("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;
@@ -11188,7 +12052,7 @@ var deleteCommand2 = new Command17("delete").description("Delete a game secret")
     }
     const game = await client.games.fetch(deployedGame.gameId);
     if (!options.force) {
-      const confirmed = await confirm9({
+      const confirmed = await confirm10({
         message: `Delete secret "${key}" from "${game.slug}" in ${environment}?`,
         default: false
       });
@@ -11354,7 +12218,7 @@ async function listProfilesAction() {
 var listCommand3 = new Command22("list").alias("ls").description("List all stored authentication profiles").action(listProfilesAction);
 
 // src/commands/profiles/remove.ts
-import { bold as bold6 } from "colorette";
+import { bold as bold8 } from "colorette";
 import { Command as Command23 } from "commander";
 var removeCommand = new Command23("remove").alias("rm").description('Remove an authentication profile (defaults to "default")').argument("[name]", "Profile name to remove", "default").option("--env <environment>", "Environment to remove profile from (staging or production)").action(async (name, options) => {
   const { env } = options;
@@ -11370,7 +12234,7 @@ var removeCommand = new Command23("remove").alias("rm").description('Remove an a
     }
     await removeProfile(environment, name);
     logger.admonition("note", "Removed!", [
-      `Profile ${bold6(name)} removed from ${environment}`,
+      `Profile ${bold8(name)} removed from ${environment}`,
       environment === "production" ? `To re-authenticate run \`playcademy login --env ${environment}\`` : "To re-authenticate run `playcademy login`"
     ]);
     logger.newLine();
@@ -11381,7 +12245,7 @@ var removeCommand = new Command23("remove").alias("rm").description('Remove an a
 
 // src/commands/profiles/reset.ts
 init_string();
-import { confirm as confirm10 } from "@inquirer/prompts";
+import { confirm as confirm11 } from "@inquirer/prompts";
 import { Command as Command24 } from "commander";
 var resetCommand = new Command24("reset").description(
   "Remove all authentication profiles across all environments (requires confirmation)"
@@ -11419,7 +12283,7 @@ var resetCommand = new Command24("reset").description(
         logger.newLine();
       }
     }
-    const confirmed = await confirm10({
+    const confirmed = await confirm11({
       message: "Are you sure you want to remove all profiles?",
       default: false
     });
@@ -11469,7 +12333,7 @@ import { Command as Command31 } from "commander";
 
 // src/commands/timeback/cleanup.ts
 init_src();
-import { confirm as confirm11 } from "@inquirer/prompts";
+import { confirm as confirm12 } from "@inquirer/prompts";
 import { Command as Command26 } from "commander";
 var cleanupCommand = new Command26("cleanup").description("Remove TimeBack integration for your game").option(
   "--env <environment>",
@@ -11493,7 +12357,7 @@ var cleanupCommand = new Command26("cleanup").description("Remove TimeBack integ
       return;
     }
     displayCleanupWarning(integration, game.displayName, logger);
-    const confirmed = await confirm11({
+    const confirmed = await confirm12({
       message: "Are you sure you want to remove TimeBack integration?",
       default: false
     });
@@ -11669,7 +12533,7 @@ var setupCommand = new Command28("setup").description("Set up TimeBack integrati
 // src/commands/timeback/update.ts
 init_src();
 init_string();
-import { confirm as confirm12 } from "@inquirer/prompts";
+import { confirm as confirm13 } from "@inquirer/prompts";
 import { green as green4, red as red3 } from "colorette";
 import { Command as Command29 } from "commander";
 var updateCommand = new Command29("update").description("Update TimeBack integration configuration for your game").option("--verbose, -v", "Output detailed information").option(
@@ -11750,7 +12614,7 @@ var updateCommand = new Command29("update").description("Update TimeBack integra
       logger.data(change.label, `${red3(change.current)} \u2192 ${green4(change.next)}`, 1);
     }
     logger.newLine();
-    const confirmed = await confirm12({
+    const confirmed = await confirm13({
       message: `Update ${changeDetails.length} ${pluralize(changeDetails.length, "field")} in TimeBack?`,
       default: false
     });
@@ -11857,7 +12721,7 @@ import { Command as Command33 } from "commander";
 init_src();
 init_constants2();
 import { writeFileSync as writeFileSync11 } from "fs";
-import { join as join36 } from "path";
+import { join as join40 } from "path";
 import { Command as Command32 } from "commander";
 var bundleCommand = new Command32("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 {
@@ -11887,7 +12751,7 @@ var bundleCommand = new Command32("bundle").description("Bundle and inspect the
       }),
       (result) => `Bundled ${formatSize(result.code.length)}`
     );
-    const outputPath = join36(workspace, options.output);
+    const outputPath = join40(workspace, options.output);
     writeFileSync11(outputPath, bundle.code, "utf-8");
     logger.success(`Bundle saved to ${options.output}`);
     logger.newLine();
@@ -11963,9 +12827,12 @@ export {
   REQUIRED_FIELDS,
   analyzeChanges,
   bundleBackend,
+  bundleSeedWorker,
   calculateConfigDiff,
   calculateDeploymentPlan,
   checkTimebackSetup,
+  collectBulkFiles,
+  collectFiles,
   compareIntegrationKeys,
   confirmDeploymentPlan,
   createClient,
@@ -11990,7 +12857,9 @@ export {
   ensurePlaycademyGitignore,
   ensurePlaycademyTypes,
   ensureRootGitignore,
+  executeSeedFile,
   findConfigPath,
+  formatBytes,
   formatSize,
   generateEntryCode,
   generateJsConfig,
@@ -12001,8 +12870,10 @@ export {
   getBackendSize,
   getBaseUrl,
   getBestUnit,
+  getBucketKey,
   getCallbackUrl,
   getCliContext,
+  getContentType,
   getCurrentProfile,
   getCustomRoutesDirectory,
   getCustomRoutesHash,
@@ -12040,18 +12911,25 @@ export {
   hashContent,
   hashDirectory,
   hashFile,
+  importSeedModule,
   importTypescriptDefault,
   importTypescriptFile,
   integrationChangeDetectors,
+  isIgnoredByGitignore,
   listProfiles,
   loadAuthStore,
   loadConfig,
   loadDeployConfig,
   loadGameStore,
+  loadGitignorePatterns,
   logAndExit,
   logger,
+  matchesGitignorePattern,
   needsBackend,
   normalizeEnvironment,
+  normalizeGitignoreEntry,
+  outputDryRunResults,
+  outputUploadResults,
   prepareDeploymentContext,
   processConfigVariables,
   promptForGameInfo,
@@ -12078,11 +12956,14 @@ export {
   selectConfigFormat,
   selectEnvironment,
   setCliContext,
+  shouldSkipFile,
   startCallbackServer,
   startDevServer,
   startHotReload,
   timebackChangeDetector,
   updateConfigFile,
+  uploadFilesLocal,
+  uploadFilesRemote,
   validateApiDirectoryDoesNotExist,
   validateBuildPath,
   validateConfig,