@playcademy/sandbox 0.3.17-beta.3 → 0.3.17-beta.5

package/dist/cli.js

@@ -440,7 +440,7 @@ var init_timeback2 = __esm(() => {
 });
 
 // ../constants/src/workers.ts
-var WORKER_NAMING, SECRETS_PREFIX = "secrets_";
+var WORKER_NAMING, SECRETS_PREFIX = "secrets_", CLOUDFLARE_COMPATIBILITY_DATE = "2025-10-11";
 var init_workers = __esm(() => {
   WORKER_NAMING = {
     STAGING_PREFIX: "staging-",
@@ -1310,7 +1310,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.3.17-beta.3",
+    version: "0.3.17-beta.5",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -23744,13 +23744,11 @@ var init_dedent = __esm(() => {
 });
 
 // ../cloudflare/src/core/namespaces/workers.ts
-var DEFAULT_COMPATIBILITY_DATE;
 var init_workers2 = __esm(() => {
   init_dedent();
   init_src2();
   init_assets();
   init_multipart();
-  DEFAULT_COMPATIBILITY_DATE = new Date().toISOString().slice(0, 10);
 });
 
 // ../cloudflare/src/core/namespaces/index.ts
@@ -23772,10 +23770,9 @@ var init_core = __esm(() => {
 });
 
 // ../cloudflare/src/playcademy/constants.ts
-var CUSTOM_DOMAINS_KV_NAME = "cademy-custom-domains", QUEUE_NAME_PREFIX = "playcademy", DEFAULT_COMPATIBILITY_DATE2, GAME_WORKER_DOMAIN_PRODUCTION, GAME_WORKER_DOMAIN_STAGING;
+var CUSTOM_DOMAINS_KV_NAME = "cademy-custom-domains", QUEUE_NAME_PREFIX = "playcademy", GAME_WORKER_DOMAIN_PRODUCTION, GAME_WORKER_DOMAIN_STAGING;
 var init_constants2 = __esm(() => {
   init_src();
-  DEFAULT_COMPATIBILITY_DATE2 = new Date().toISOString().slice(0, 10);
   GAME_WORKER_DOMAIN_PRODUCTION = GAME_WORKER_DOMAINS.production;
   GAME_WORKER_DOMAIN_STAGING = GAME_WORKER_DOMAINS.staging;
 });
@@ -26479,6 +26476,7 @@ class DeployService {
     try {
       result = await this.timeStep("Cloudflare deploy", () => cf.deploy(deploymentId, request.code, env, {
         ...deploymentOptions,
+        compatibilityDate: request.compatibilityDate ?? CLOUDFLARE_COMPATIBILITY_DATE,
         compatibilityFlags: request.compatibilityFlags,
         existingResources: activeDeployment?.resources ?? undefined,
         assetsPath: frontendAssetsPath,
@@ -26580,6 +26578,7 @@ var logger3;
 var init_deploy_service = __esm(() => {
   init_drizzle_orm();
   init_playcademy();
+  init_src();
   init_tables_index();
   init_src2();
   init_config2();
@@ -26648,447 +26647,533 @@ var init_developer_service = __esm(() => {
   logger4 = log.scope("DeveloperService");
 });
 
-// ../api-core/src/services/game.service.ts
-class GameService {
-  deps;
-  static MANIFEST_FETCH_TIMEOUT_MS = 5000;
-  static MAX_FETCH_ERROR_MESSAGE_LENGTH = 512;
-  constructor(deps) {
-    this.deps = deps;
-  }
-  static getManifestHost(manifestUrl) {
-    try {
-      return new URL(manifestUrl).host;
-    } catch {
-      return manifestUrl;
-    }
+// ../utils/src/fns.ts
+function sleep(ms) {
+  if (ms <= 0) {
+    return Promise.resolve();
   }
-  static getFetchErrorMessage(error) {
-    let raw;
-    if (error instanceof Error) {
-      raw = error.message;
-    } else if (typeof error === "string") {
-      raw = error;
-    }
-    if (!raw) {
-      return;
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ../api-core/src/services/game.service.ts
+var logger5, inFlightManifestFetches, GameService;
+var init_game_service = __esm(() => {
+  init_drizzle_orm();
+  init_tables_index();
+  init_src2();
+  init_errors();
+  init_deployment_util();
+  logger5 = log.scope("GameService");
+  inFlightManifestFetches = new Map;
+  GameService = class GameService {
+    deps;
+    static MANIFEST_FETCH_ATTEMPT_TIMEOUT_MS = 1e4;
+    static MANIFEST_FETCH_MAX_RETRIES = 2;
+    static MANIFEST_FETCH_RETRY_BACKOFF_MS = [250, 750];
+    static MANIFEST_CACHE_TTL_SECONDS = 60;
+    static MANIFEST_CACHE_KEY_PREFIX = "game:manifest";
+    static MAX_FETCH_ERROR_MESSAGE_LENGTH = 512;
+    constructor(deps) {
+      this.deps = deps;
+    }
+    static getManifestHost(manifestUrl) {
+      try {
+        return new URL(manifestUrl).host;
+      } catch {
+        return manifestUrl;
+      }
     }
-    const normalized = raw.replace(/\s+/g, " ").trim();
-    if (!normalized) {
-      return;
+    static getFetchErrorMessage(error) {
+      let raw;
+      if (error instanceof Error) {
+        raw = error.message;
+      } else if (typeof error === "string") {
+        raw = error;
+      }
+      if (!raw) {
+        return;
+      }
+      const normalized = raw.replace(/\s+/g, " ").trim();
+      if (!normalized) {
+        return;
+      }
+      return normalized.slice(0, GameService.MAX_FETCH_ERROR_MESSAGE_LENGTH);
     }
-    return normalized.slice(0, GameService.MAX_FETCH_ERROR_MESSAGE_LENGTH);
-  }
-  static isRetryableStatus(status) {
-    return status === 429 || status >= 500;
-  }
-  async list(caller) {
-    const db2 = this.deps.db;
-    const isAdmin = caller?.role === "admin";
-    const isDeveloper = caller?.role === "developer";
-    let whereClause;
-    if (isAdmin) {
-      whereClause = undefined;
-    } else if (isDeveloper && caller?.id) {
-      whereClause = or(ne(games.visibility, "internal"), eq(games.developerId, caller.id));
-    } else {
-      whereClause = ne(games.visibility, "internal");
+    static isRetryableStatus(status) {
+      return status === 429 || status >= 500;
     }
-    return db2.query.games.findMany({
-      where: whereClause,
-      orderBy: [desc(games.createdAt)]
-    });
-  }
-  async listManageable(user) {
-    this.validateDeveloperStatus(user);
-    const db2 = this.deps.db;
-    return db2.query.games.findMany({
-      where: user.role === "admin" ? undefined : eq(games.developerId, user.id),
-      orderBy: [desc(games.createdAt)]
-    });
-  }
-  async getSubjects() {
-    const db2 = this.deps.db;
-    const integrations = await db2.query.gameTimebackIntegrations.findMany({
-      columns: { gameId: true, subject: true },
-      orderBy: [asc(gameTimebackIntegrations.createdAt)]
-    });
-    const subjectMap = {};
-    for (const integration of integrations) {
-      if (!(integration.gameId in subjectMap)) {
-        subjectMap[integration.gameId] = integration.subject;
+    static getRetryBackoffMs(attemptIndex) {
+      const backoff = GameService.MANIFEST_FETCH_RETRY_BACKOFF_MS;
+      if (backoff.length === 0) {
+        return 0;
       }
+      return backoff[Math.min(attemptIndex, backoff.length - 1)] ?? 0;
     }
-    return subjectMap;
-  }
-  async getById(gameId, caller) {
-    const db2 = this.deps.db;
-    const game = await db2.query.games.findFirst({
-      where: eq(games.id, gameId)
-    });
-    if (!game) {
-      throw new NotFoundError("Game", gameId);
+    static normalizeDeploymentUrl(deploymentUrl) {
+      return deploymentUrl.replace(/\/$/, "");
     }
-    this.enforceVisibility(game, caller, gameId);
-    return game;
-  }
-  async getBySlug(slug, caller) {
-    const db2 = this.deps.db;
-    const game = await db2.query.games.findFirst({
-      where: eq(games.slug, slug)
-    });
-    if (!game) {
-      throw new NotFoundError("Game", slug);
+    static getManifestCacheKey(deploymentUrl) {
+      return `${GameService.MANIFEST_CACHE_KEY_PREFIX}:${deploymentUrl}`;
     }
-    this.enforceVisibility(game, caller, slug);
-    return game;
-  }
-  async getManifest(gameId, caller) {
-    const game = await this.getById(gameId, caller);
-    if (game.gameType !== "hosted" || !game.deploymentUrl) {
-      throw new BadRequestError("Game does not have a deployment manifest");
-    }
-    const deploymentUrl = game.deploymentUrl;
-    const manifestUrl = `${deploymentUrl.replace(/\/$/, "")}/playcademy.manifest.json`;
-    const manifestHost = GameService.getManifestHost(manifestUrl);
-    const startedAt = Date.now();
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), GameService.MANIFEST_FETCH_TIMEOUT_MS);
-    function buildDetails(fetchOutcome, manifestErrorKind, extra = {}) {
-      return {
-        manifestUrl,
-        manifestHost,
-        deploymentUrl,
-        fetchOutcome,
-        retryCount: 0,
-        durationMs: Date.now() - startedAt,
-        manifestErrorKind,
-        ...extra
-      };
+    async list(caller) {
+      const db2 = this.deps.db;
+      const isAdmin = caller?.role === "admin";
+      const isDeveloper = caller?.role === "developer";
+      let whereClause;
+      if (isAdmin) {
+        whereClause = undefined;
+      } else if (isDeveloper && caller?.id) {
+        whereClause = or(ne(games.visibility, "internal"), eq(games.developerId, caller.id));
+      } else {
+        whereClause = ne(games.visibility, "internal");
+      }
+      return db2.query.games.findMany({
+        where: whereClause,
+        orderBy: [desc(games.createdAt)]
+      });
     }
-    let response;
-    try {
-      response = await fetch(manifestUrl, {
-        method: "GET",
-        headers: {
-          Accept: "application/json"
-        },
-        signal: controller.signal
+    async listManageable(user) {
+      this.validateDeveloperStatus(user);
+      const db2 = this.deps.db;
+      return db2.query.games.findMany({
+        where: user.role === "admin" ? undefined : eq(games.developerId, user.id),
+        orderBy: [desc(games.createdAt)]
       });
-    } catch (error) {
-      clearTimeout(timeout);
-      const fetchErrorMessage = GameService.getFetchErrorMessage(error);
-      const details = buildDetails("network_error", "temporary", fetchErrorMessage ? { fetchErrorMessage } : {});
-      logger5.error("Failed to fetch game manifest", {
-        gameId,
-        manifestUrl,
-        error,
-        details
+    }
+    async getSubjects() {
+      const db2 = this.deps.db;
+      const integrations = await db2.query.gameTimebackIntegrations.findMany({
+        columns: { gameId: true, subject: true },
+        orderBy: [asc(gameTimebackIntegrations.createdAt)]
       });
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new TimeoutError("Timed out loading game manifest", details);
+      const subjectMap = {};
+      for (const integration of integrations) {
+        if (!(integration.gameId in subjectMap)) {
+          subjectMap[integration.gameId] = integration.subject;
+        }
       }
-      throw new ServiceUnavailableError("Failed to load game manifest", details);
-    } finally {
-      clearTimeout(timeout);
+      return subjectMap;
     }
-    if (!response.ok) {
-      const resolvedManifestUrl = response.url || manifestUrl;
-      const resolvedManifestHost = GameService.getManifestHost(resolvedManifestUrl);
-      const manifestErrorKind = GameService.isRetryableStatus(response.status) ? "temporary" : "permanent";
-      const details = buildDetails("bad_status", manifestErrorKind, {
-        manifestUrl: resolvedManifestUrl,
-        manifestHost: resolvedManifestHost,
-        status: response.status,
-        contentType: response.headers.get("content-type") ?? undefined,
-        cfRay: response.headers.get("cf-ray") ?? undefined,
-        redirected: response.redirected,
-        ...response.redirected ? {
-          originalManifestUrl: manifestUrl,
-          originalManifestHost: manifestHost
-        } : {}
-      });
-      const message = `Failed to fetch manifest: ${response.status} ${response.statusText}`;
-      logger5.error("Game manifest returned non-ok response", {
-        gameId,
-        manifestUrl,
-        status: response.status,
-        details
+    async getById(gameId, caller) {
+      const db2 = this.deps.db;
+      const game = await db2.query.games.findFirst({
+        where: eq(games.id, gameId)
       });
-      if (manifestErrorKind === "temporary") {
-        throw new ServiceUnavailableError(message, details);
+      if (!game) {
+        throw new NotFoundError("Game", gameId);
       }
-      throw new BadRequestError(message, details);
+      this.enforceVisibility(game, caller, gameId);
+      return game;
     }
-    try {
-      return await response.json();
-    } catch (error) {
-      const resolvedManifestUrl = response.url || manifestUrl;
-      const resolvedManifestHost = GameService.getManifestHost(resolvedManifestUrl);
-      const details = buildDetails("invalid_body", "permanent", {
-        manifestUrl: resolvedManifestUrl,
-        manifestHost: resolvedManifestHost,
-        status: response.status,
-        contentType: response.headers.get("content-type") ?? undefined,
-        cfRay: response.headers.get("cf-ray") ?? undefined,
-        redirected: response.redirected,
-        ...response.redirected ? {
-          originalManifestUrl: manifestUrl,
-          originalManifestHost: manifestHost
-        } : {}
-      });
-      logger5.error("Failed to parse game manifest", {
-        gameId,
-        manifestUrl,
-        error,
-        details
+    async getBySlug(slug, caller) {
+      const db2 = this.deps.db;
+      const game = await db2.query.games.findFirst({
+        where: eq(games.slug, slug)
       });
-      throw new BadRequestError("Failed to parse game manifest", details);
-    }
-  }
-  enforceVisibility(game, caller, lookupIdentifier) {
-    if (game.visibility !== "internal") {
-      return;
-    }
-    const isAdmin = caller?.role === "admin";
-    const isOwner = caller?.id != null && caller.id === game.developerId;
-    if (!isAdmin && !isOwner) {
-      throw new NotFoundError("Game", lookupIdentifier);
-    }
-  }
-  async upsertBySlug(slug, data, user) {
-    const db2 = this.deps.db;
-    const existingGame = await db2.query.games.findFirst({
-      where: eq(games.slug, slug)
-    });
-    const isUpdate = Boolean(existingGame);
-    const gameId = existingGame?.id ?? crypto.randomUUID();
-    if (isUpdate) {
-      await this.validateDeveloperAccess(user, gameId);
-    } else {
-      this.validateDeveloperStatus(user);
-    }
-    const gameDataForDb = {
-      displayName: data.displayName,
-      platform: data.platform,
-      metadata: data.metadata,
-      mapElementId: data.mapElementId,
-      gameType: data.gameType,
-      ...data.visibility && { visibility: data.visibility },
-      externalUrl: data.externalUrl || null,
-      updatedAt: new Date
-    };
-    let gameResponse;
-    if (isUpdate) {
-      const [updatedGame] = await db2.update(games).set(gameDataForDb).where(eq(games.id, gameId)).returning();
-      if (!updatedGame) {
-        logger5.error("Game update returned no rows", { gameId, slug });
-        throw new InternalError("DB update failed to return result for existing game");
-      }
-      gameResponse = updatedGame;
-    } else {
-      const insertData = {
-        ...gameDataForDb,
-        id: gameId,
-        slug,
-        developerId: user.id,
-        metadata: data.metadata || {},
-        version: data.gameType === "external" ? "external" : "",
-        deploymentUrl: null,
-        createdAt: new Date
-      };
-      const [createdGame] = await db2.insert(games).values(insertData).returning();
-      if (!createdGame) {
-        logger5.error("Game insert returned no rows", { slug, developerId: user.id });
-        throw new InternalError("DB insert failed to return result for new game");
+      if (!game) {
+        throw new NotFoundError("Game", slug);
       }
-      gameResponse = createdGame;
+      this.enforceVisibility(game, caller, slug);
+      return game;
     }
-    if (data.mapElementId) {
-      try {
-        await db2.update(mapElements).set({
-          interactionType: "game_entry",
-          gameId: gameResponse.id
-        }).where(eq(mapElements.id, data.mapElementId));
-      } catch (mapError) {
-        logger5.warn("Failed to update map element", {
-          mapElementId: data.mapElementId,
-          error: mapError
+    async getManifest(gameId, caller) {
+      const game = await this.getById(gameId, caller);
+      if (game.gameType !== "hosted" || !game.deploymentUrl) {
+        throw new BadRequestError("Game does not have a deployment manifest");
+      }
+      const deploymentUrl = GameService.normalizeDeploymentUrl(game.deploymentUrl);
+      const cacheKey2 = GameService.getManifestCacheKey(deploymentUrl);
+      const cached = await this.deps.cache.get(cacheKey2);
+      if (cached) {
+        return cached;
+      }
+      const inFlight = inFlightManifestFetches.get(deploymentUrl);
+      if (inFlight) {
+        return inFlight;
+      }
+      const promise = this.fetchManifestFromOrigin({ gameId, deploymentUrl }).then(async (manifest) => {
+        try {
+          await this.deps.cache.set(cacheKey2, manifest, GameService.MANIFEST_CACHE_TTL_SECONDS);
+        } catch (cacheError) {
+          logger5.warn("Failed to cache game manifest", {
+            gameId,
+            deploymentUrl,
+            cacheKey: cacheKey2,
+            error: cacheError
+          });
+        }
+        return manifest;
+      }).finally(() => {
+        inFlightManifestFetches.delete(deploymentUrl);
+      });
+      inFlightManifestFetches.set(deploymentUrl, promise);
+      return promise;
+    }
+    async fetchManifestFromOrigin(args2) {
+      const { gameId, deploymentUrl } = args2;
+      const manifestUrl = `${deploymentUrl}/playcademy.manifest.json`;
+      const manifestHost = GameService.getManifestHost(manifestUrl);
+      const startedAt = Date.now();
+      const maxAttempts = GameService.MANIFEST_FETCH_MAX_RETRIES + 1;
+      for (let attempt = 0;attempt < maxAttempts; attempt++) {
+        const isLastAttempt = attempt === maxAttempts - 1;
+        const outcome = await this.attemptManifestFetch({
+          manifestUrl,
+          manifestHost,
+          deploymentUrl,
+          startedAt,
+          retryCount: attempt
+        });
+        if (outcome.kind === "success") {
+          return outcome.manifest;
+        }
+        if (!outcome.retryable || isLastAttempt) {
+          logger5.error("Failed to fetch game manifest", {
+            gameId,
+            manifestUrl,
+            attempt: attempt + 1,
+            maxAttempts,
+            retryable: outcome.retryable,
+            details: outcome.details,
+            throwable: outcome.throwable,
+            cause: outcome.cause
+          });
+          throw outcome.throwable;
+        }
+        const backoffMs = GameService.getRetryBackoffMs(attempt);
+        logger5.warn("Retrying game manifest fetch after transient failure", {
+          gameId,
+          manifestUrl,
+          attempt: attempt + 1,
+          maxAttempts,
+          backoffMs,
+          details: outcome.details,
+          cause: outcome.cause
         });
+        await sleep(backoffMs);
       }
+      throw new InternalError("Exhausted manifest fetch retries without result");
     }
-    logger5.info("Upserted game", {
-      gameId: gameResponse.id,
-      slug: gameResponse.slug,
-      operation: isUpdate ? "update" : "create",
-      displayName: gameResponse.displayName
-    });
-    return gameResponse;
-  }
-  async delete(gameId, user) {
-    await this.validateDeveloperAccess(user, gameId);
-    const db2 = this.deps.db;
-    const gameToDelete = await db2.query.games.findFirst({
-      where: eq(games.id, gameId),
-      columns: { id: true, slug: true, displayName: true }
-    });
-    if (!gameToDelete?.slug) {
-      throw new NotFoundError("Game", gameId);
-    }
-    const activeDeployment = await db2.query.gameDeployments.findFirst({
-      where: and(eq(gameDeployments.gameId, gameId), eq(gameDeployments.isActive, true)),
-      columns: { deploymentId: true, provider: true, resources: true }
-    });
-    const customHostnames = await db2.select({
-      hostname: gameCustomHostnames.hostname,
-      cloudflareId: gameCustomHostnames.cloudflareId,
-      environment: gameCustomHostnames.environment
-    }).from(gameCustomHostnames).where(eq(gameCustomHostnames.gameId, gameId));
-    const result = await db2.delete(games).where(eq(games.id, gameId)).returning({ id: games.id });
-    if (result.length === 0) {
-      throw new NotFoundError("Game", gameId);
-    }
-    logger5.info("Deleted game", {
-      gameId: result[0].id,
-      slug: gameToDelete.slug,
-      hadActiveDeployment: Boolean(activeDeployment),
-      customDomainsCount: customHostnames.length
-    });
-    this.deps.alerts.notifyGameDeletion({
-      slug: gameToDelete.slug,
-      displayName: gameToDelete.displayName,
-      developer: { id: user.id, email: user.email }
-    }).catch((error) => {
-      logger5.warn("Failed to send deletion alert", { error });
-    });
-    if (activeDeployment?.provider === "cloudflare" && this.deps.cloudflare) {
+    async attemptManifestFetch(args2) {
+      const { manifestUrl, manifestHost, deploymentUrl, startedAt, retryCount } = args2;
+      function buildDetails(fetchOutcome, manifestErrorKind, extra = {}) {
+        return {
+          manifestUrl,
+          manifestHost,
+          deploymentUrl,
+          fetchOutcome,
+          retryCount,
+          durationMs: Date.now() - startedAt,
+          manifestErrorKind,
+          ...extra
+        };
+      }
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), GameService.MANIFEST_FETCH_ATTEMPT_TIMEOUT_MS);
+      let response;
       try {
-        await this.deps.cloudflare.delete(activeDeployment.deploymentId, {
-          deleteBindings: true,
-          resources: activeDeployment.resources ?? undefined,
-          customDomains: customHostnames.length > 0 ? customHostnames : undefined,
-          gameSlug: gameToDelete.slug
-        });
-        logger5.info("Cleaned up Cloudflare resources", {
-          gameId,
-          deploymentId: activeDeployment.deploymentId,
-          customDomainsDeleted: customHostnames.length
+        response = await fetch(manifestUrl, {
+          method: "GET",
+          headers: {
+            Accept: "application/json"
+          },
+          signal: controller.signal
         });
-      } catch (cfError) {
-        logger5.warn("Failed to cleanup Cloudflare resources", {
-          gameId,
-          deploymentId: activeDeployment.deploymentId,
-          error: cfError
+      } catch (error) {
+        const fetchErrorMessage = GameService.getFetchErrorMessage(error);
+        const details = buildDetails("network_error", "temporary", fetchErrorMessage ? { fetchErrorMessage } : {});
+        const throwable = error instanceof Error && error.name === "AbortError" ? new TimeoutError("Timed out loading game manifest", details) : new ServiceUnavailableError("Failed to load game manifest", details);
+        return { kind: "failure", retryable: true, throwable, details, cause: error };
+      } finally {
+        clearTimeout(timeout);
+      }
+      if (!response.ok) {
+        const resolvedManifestUrl = response.url || manifestUrl;
+        const resolvedManifestHost = GameService.getManifestHost(resolvedManifestUrl);
+        const manifestErrorKind = GameService.isRetryableStatus(response.status) ? "temporary" : "permanent";
+        const details = buildDetails("bad_status", manifestErrorKind, {
+          manifestUrl: resolvedManifestUrl,
+          manifestHost: resolvedManifestHost,
+          status: response.status,
+          contentType: response.headers.get("content-type") ?? undefined,
+          cfRay: response.headers.get("cf-ray") ?? undefined,
+          redirected: response.redirected,
+          ...response.redirected ? {
+            originalManifestUrl: manifestUrl,
+            originalManifestHost: manifestHost
+          } : {}
         });
+        const message = `Failed to fetch manifest: ${response.status} ${response.statusText}`;
+        const throwable = manifestErrorKind === "temporary" ? new ServiceUnavailableError(message, details) : new BadRequestError(message, details);
+        return {
+          kind: "failure",
+          retryable: manifestErrorKind === "temporary",
+          throwable,
+          details
+        };
       }
       try {
-        const deletedKeyId = await this.deps.deleteApiKeyByName(getGameWorkerApiKeyName(gameToDelete.slug), user.id);
-        if (deletedKeyId) {
-          logger5.info("Cleaned up API key for deleted game", {
-            gameId,
-            slug: gameToDelete.slug,
-            keyId: deletedKeyId
+        const manifest = await response.json();
+        return { kind: "success", manifest };
+      } catch (error) {
+        const resolvedManifestUrl = response.url || manifestUrl;
+        const resolvedManifestHost = GameService.getManifestHost(resolvedManifestUrl);
+        const details = buildDetails("invalid_body", "permanent", {
+          manifestUrl: resolvedManifestUrl,
+          manifestHost: resolvedManifestHost,
+          status: response.status,
+          contentType: response.headers.get("content-type") ?? undefined,
+          cfRay: response.headers.get("cf-ray") ?? undefined,
+          redirected: response.redirected,
+          ...response.redirected ? {
+            originalManifestUrl: manifestUrl,
+            originalManifestHost: manifestHost
+          } : {}
+        });
+        return {
+          kind: "failure",
+          retryable: false,
+          throwable: new BadRequestError("Failed to parse game manifest", details),
+          details,
+          cause: error
+        };
+      }
+    }
+    enforceVisibility(game, caller, lookupIdentifier) {
+      if (game.visibility !== "internal") {
+        return;
+      }
+      const isAdmin = caller?.role === "admin";
+      const isOwner = caller?.id != null && caller.id === game.developerId;
+      if (!isAdmin && !isOwner) {
+        throw new NotFoundError("Game", lookupIdentifier);
+      }
+    }
+    async upsertBySlug(slug, data, user) {
+      const db2 = this.deps.db;
+      const existingGame = await db2.query.games.findFirst({
+        where: eq(games.slug, slug)
+      });
+      const isUpdate = Boolean(existingGame);
+      const gameId = existingGame?.id ?? crypto.randomUUID();
+      if (isUpdate) {
+        await this.validateDeveloperAccess(user, gameId);
+      } else {
+        this.validateDeveloperStatus(user);
+      }
+      const gameDataForDb = {
+        displayName: data.displayName,
+        platform: data.platform,
+        metadata: data.metadata,
+        mapElementId: data.mapElementId,
+        gameType: data.gameType,
+        ...data.visibility && { visibility: data.visibility },
+        externalUrl: data.externalUrl || null,
+        updatedAt: new Date
+      };
+      let gameResponse;
+      if (isUpdate) {
+        const [updatedGame] = await db2.update(games).set(gameDataForDb).where(eq(games.id, gameId)).returning();
+        if (!updatedGame) {
+          logger5.error("Game update returned no rows", { gameId, slug });
+          throw new InternalError("DB update failed to return result for existing game");
+        }
+        gameResponse = updatedGame;
+      } else {
+        const insertData = {
+          ...gameDataForDb,
+          id: gameId,
+          slug,
+          developerId: user.id,
+          metadata: data.metadata || {},
+          version: data.gameType === "external" ? "external" : "",
+          deploymentUrl: null,
+          createdAt: new Date
+        };
+        const [createdGame] = await db2.insert(games).values(insertData).returning();
+        if (!createdGame) {
+          logger5.error("Game insert returned no rows", { slug, developerId: user.id });
+          throw new InternalError("DB insert failed to return result for new game");
+        }
+        gameResponse = createdGame;
+      }
+      if (data.mapElementId) {
+        try {
+          await db2.update(mapElements).set({
+            interactionType: "game_entry",
+            gameId: gameResponse.id
+          }).where(eq(mapElements.id, data.mapElementId));
+        } catch (mapError) {
+          logger5.warn("Failed to update map element", {
+            mapElementId: data.mapElementId,
+            error: mapError
           });
         }
-      } catch (keyError) {
-        logger5.warn("Failed to cleanup API key", { gameId, error: keyError });
       }
+      logger5.info("Upserted game", {
+        gameId: gameResponse.id,
+        slug: gameResponse.slug,
+        operation: isUpdate ? "update" : "create",
+        displayName: gameResponse.displayName
+      });
+      return gameResponse;
     }
-    return {
-      slug: gameToDelete.slug,
-      displayName: gameToDelete.displayName
-    };
-  }
-  async validateOwnership(user, gameId) {
-    if (user.role === "admin") {
-      const gameExists = await this.deps.db.query.games.findFirst({
+    async delete(gameId, user) {
+      await this.validateDeveloperAccess(user, gameId);
+      const db2 = this.deps.db;
+      const gameToDelete = await db2.query.games.findFirst({
         where: eq(games.id, gameId),
-        columns: { id: true }
+        columns: { id: true, slug: true, displayName: true }
       });
-      if (!gameExists) {
+      if (!gameToDelete?.slug) {
         throw new NotFoundError("Game", gameId);
       }
-      return;
+      const activeDeployment = await db2.query.gameDeployments.findFirst({
+        where: and(eq(gameDeployments.gameId, gameId), eq(gameDeployments.isActive, true)),
+        columns: { deploymentId: true, provider: true, resources: true }
+      });
+      const customHostnames = await db2.select({
+        hostname: gameCustomHostnames.hostname,
+        cloudflareId: gameCustomHostnames.cloudflareId,
+        environment: gameCustomHostnames.environment
+      }).from(gameCustomHostnames).where(eq(gameCustomHostnames.gameId, gameId));
+      const result = await db2.delete(games).where(eq(games.id, gameId)).returning({ id: games.id });
+      if (result.length === 0) {
+        throw new NotFoundError("Game", gameId);
+      }
+      logger5.info("Deleted game", {
+        gameId: result[0].id,
+        slug: gameToDelete.slug,
+        hadActiveDeployment: Boolean(activeDeployment),
+        customDomainsCount: customHostnames.length
+      });
+      this.deps.alerts.notifyGameDeletion({
+        slug: gameToDelete.slug,
+        displayName: gameToDelete.displayName,
+        developer: { id: user.id, email: user.email }
+      }).catch((error) => {
+        logger5.warn("Failed to send deletion alert", { error });
+      });
+      if (activeDeployment?.provider === "cloudflare" && this.deps.cloudflare) {
+        try {
+          await this.deps.cloudflare.delete(activeDeployment.deploymentId, {
+            deleteBindings: true,
+            resources: activeDeployment.resources ?? undefined,
+            customDomains: customHostnames.length > 0 ? customHostnames : undefined,
+            gameSlug: gameToDelete.slug
+          });
+          logger5.info("Cleaned up Cloudflare resources", {
+            gameId,
+            deploymentId: activeDeployment.deploymentId,
+            customDomainsDeleted: customHostnames.length
+          });
+        } catch (cfError) {
+          logger5.warn("Failed to cleanup Cloudflare resources", {
+            gameId,
+            deploymentId: activeDeployment.deploymentId,
+            error: cfError
+          });
+        }
+        try {
+          const deletedKeyId = await this.deps.deleteApiKeyByName(getGameWorkerApiKeyName(gameToDelete.slug), user.id);
+          if (deletedKeyId) {
+            logger5.info("Cleaned up API key for deleted game", {
+              gameId,
+              slug: gameToDelete.slug,
+              keyId: deletedKeyId
+            });
+          }
+        } catch (keyError) {
+          logger5.warn("Failed to cleanup API key", { gameId, error: keyError });
+        }
+      }
+      return {
+        slug: gameToDelete.slug,
+        displayName: gameToDelete.displayName
+      };
     }
-    const db2 = this.deps.db;
-    const gameOwnership = await db2.query.games.findFirst({
-      where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
-      columns: { id: true }
-    });
-    if (!gameOwnership) {
-      const gameExists = await db2.query.games.findFirst({
-        where: eq(games.id, gameId),
+    async validateOwnership(user, gameId) {
+      if (user.role === "admin") {
+        const gameExists = await this.deps.db.query.games.findFirst({
+          where: eq(games.id, gameId),
+          columns: { id: true }
+        });
+        if (!gameExists) {
+          throw new NotFoundError("Game", gameId);
+        }
+        return;
+      }
+      const db2 = this.deps.db;
+      const gameOwnership = await db2.query.games.findFirst({
+        where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
         columns: { id: true }
       });
-      if (!gameExists) {
-        throw new NotFoundError("Game", gameId);
+      if (!gameOwnership) {
+        const gameExists = await db2.query.games.findFirst({
+          where: eq(games.id, gameId),
+          columns: { id: true }
+        });
+        if (!gameExists) {
+          throw new NotFoundError("Game", gameId);
+        }
+        throw new AccessDeniedError("You do not own this game");
       }
-      throw new AccessDeniedError("You do not own this game");
     }
-  }
-  async validateDeveloperAccess(user, gameId) {
-    this.validateDeveloperStatus(user);
-    if (user.role === "admin") {
-      const gameExists = await this.deps.db.query.games.findFirst({
-        where: eq(games.id, gameId),
+    async validateDeveloperAccess(user, gameId) {
+      this.validateDeveloperStatus(user);
+      if (user.role === "admin") {
+        const gameExists = await this.deps.db.query.games.findFirst({
+          where: eq(games.id, gameId),
+          columns: { id: true }
+        });
+        if (!gameExists) {
+          throw new NotFoundError("Game", gameId);
+        }
+        return;
+      }
+      const db2 = this.deps.db;
+      const existingGame = await db2.query.games.findFirst({
+        where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
         columns: { id: true }
       });
-      if (!gameExists) {
+      if (!existingGame) {
         throw new NotFoundError("Game", gameId);
       }
-      return;
-    }
-    const db2 = this.deps.db;
-    const existingGame = await db2.query.games.findFirst({
-      where: and(eq(games.id, gameId), eq(games.developerId, user.id)),
-      columns: { id: true }
-    });
-    if (!existingGame) {
-      throw new NotFoundError("Game", gameId);
     }
-  }
-  async validateDeveloperAccessBySlug(user, slug) {
-    this.validateDeveloperStatus(user);
-    const db2 = this.deps.db;
-    if (user.role === "admin") {
-      const game2 = await db2.query.games.findFirst({
-        where: eq(games.slug, slug)
+    async validateDeveloperAccessBySlug(user, slug) {
+      this.validateDeveloperStatus(user);
+      const db2 = this.deps.db;
+      if (user.role === "admin") {
+        const game2 = await db2.query.games.findFirst({
+          where: eq(games.slug, slug)
+        });
+        if (!game2) {
+          throw new NotFoundError("Game", slug);
+        }
+        return game2;
+      }
+      const game = await db2.query.games.findFirst({
+        where: and(eq(games.slug, slug), eq(games.developerId, user.id))
       });
-      if (!game2) {
+      if (!game) {
         throw new NotFoundError("Game", slug);
       }
-      return game2;
-    }
-    const game = await db2.query.games.findFirst({
-      where: and(eq(games.slug, slug), eq(games.developerId, user.id))
-    });
-    if (!game) {
-      throw new NotFoundError("Game", slug);
-    }
-    return game;
-  }
-  validateDeveloperStatus(user) {
-    if (user.role === "admin") {
-      return;
+      return game;
     }
-    if (user.developerStatus !== "approved") {
-      const status = user.developerStatus || "none";
-      if (status === "pending") {
-        throw new AccessDeniedError("Developer application is pending approval. You will be notified when approved.");
-      } else {
-        throw new AccessDeniedError("Developer status required. Apply for developer access to create and manage games.");
+    validateDeveloperStatus(user) {
+      if (user.role === "admin") {
+        return;
+      }
+      if (user.developerStatus !== "approved") {
+        const status = user.developerStatus || "none";
+        if (status === "pending") {
+          throw new AccessDeniedError("Developer application is pending approval. You will be notified when approved.");
+        } else {
+          throw new AccessDeniedError("Developer status required. Apply for developer access to create and manage games.");
+        }
       }
     }
-  }
-}
-var logger5;
-var init_game_service = __esm(() => {
-  init_drizzle_orm();
-  init_tables_index();
-  init_src2();
-  init_errors();
-  init_deployment_util();
-  logger5 = log.scope("GameService");
+  };
 });
 
 // ../api-core/src/services/factory/game.ts
@@ -27097,6 +27182,7 @@ function createGameServices(deps) {
   const game = new GameService({
     db: db2,
     alerts,
+    cache,
     cloudflare,
     deleteApiKeyByName: auth2.deleteApiKeyByName.bind(auth2)
   });
@@ -28914,7 +29000,8 @@ class SeedService {
         PLAYCADEMY_BASE_URL: ""
       }, {
         bindings: { d1: [deploymentId], r2: [], kv: [] },
-        keepAssets: false
+        keepAssets: false,
+        compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
       });
       logger14.info("Worker deployed", { seedDeploymentId, url: result.url });
       if (secrets && Object.keys(secrets).length > 0) {
@@ -29044,6 +29131,7 @@ class SeedService {
 }
 var logger14;
 var init_seed_service = __esm(() => {
+  init_src();
   init_setup2();
   init_src2();
   init_config2();
@@ -93152,6 +93240,7 @@ var init_schemas2 = __esm(() => {
     code: exports_external.string().optional(),
     codeUploadToken: exports_external.string().optional(),
     config: exports_external.unknown().optional(),
+    compatibilityDate: exports_external.string().optional(),
     compatibilityFlags: exports_external.array(exports_external.string()).optional(),
     bindings: exports_external.object({
       database: exports_external.array(exports_external.string()).optional(),