playcademy 0.14.7 → 0.14.9

package/dist/edge-play/src/entry/middleware.ts

@@ -10,8 +10,8 @@ import { PlaycademyClient, verifyGameToken } from '@playcademy/sdk/server'
 
 import { populateProcessEnv, reconstructSecrets } from './setup'
 
-import type { Hono } from 'hono'
-import type { HonoEnv } from '../types'
+import type { Context, Hono } from 'hono'
+import type { AssetsFetcher, HonoEnv } from '../types'
 import type { RuntimeConfig } from './types'
 
 /**
@@ -124,12 +124,97 @@ export function registerApiNotFoundHandler(app: Hono<HonoEnv>): void {
     })
 }
 
+/**
+ * Detect if ASSETS binding is an R2 bucket or Workers Assets Fetcher
+ * Returns true for R2Bucket, false for AssetsFetcher
+ */
+function isR2AssetsBinding(assets: AssetsFetcher | R2Bucket): assets is R2Bucket {
+    // R2Bucket has .get() method, Fetcher has .fetch() method
+    return 'get' in assets && typeof assets.get === 'function' && !('fetch' in assets)
+}
+
+/**
+ * Serve assets from Workers Assets binding (Fetcher)
+ * Default strategy for games with files <25MB
+ */
+async function serveFromWorkersAssets(
+    c: Context<HonoEnv>,
+    assets: AssetsFetcher,
+): Promise<Response> {
+    // Try to fetch the requested asset
+    const response = await assets.fetch(c.req.raw)
+
+    // If found, return it
+    if (response.status !== 404) {
+        return response
+    }
+
+    // If not found and it's a file request (has extension), return 404
+    const path = new URL(c.req.url).pathname
+    if (path.includes('.')) {
+        return response
+    }
+
+    // Otherwise, fall back to index.html for SPA routing
+    const indexUrl = new URL(c.req.url)
+    indexUrl.pathname = '/index.html'
+
+    return await assets.fetch(new Request(indexUrl.toString()))
+}
+
+/**
+ * Serve assets from R2 bucket binding
+ * Fallback strategy for games with large files (≥25MB) like Godot WASM
+ */
+async function serveFromR2(c: Context<HonoEnv>, bucket: R2Bucket): Promise<Response> {
+    const path = new URL(c.req.url).pathname
+    const key = path === '/' ? 'index.html' : path.slice(1)
+
+    // Try to fetch the requested asset
+    const object = await bucket.get(key)
+
+    if (object) {
+        return new Response(object.body, {
+            headers: {
+                'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
+                'Cache-Control':
+                    key === 'index.html' ? 'no-cache' : 'public, max-age=31536000, immutable',
+                ETag: object.etag,
+            },
+        })
+    }
+
+    // If not found and it's a file request (has extension), return 404
+    if (path.includes('.')) {
+        return c.json({ error: 'Not Found', message: 'Asset not found', path }, 404)
+    }
+
+    // Otherwise, fall back to index.html for SPA routing
+    const indexObject = await bucket.get('index.html')
+
+    if (indexObject) {
+        return new Response(indexObject.body, {
+            headers: {
+                'Content-Type': 'text/html',
+                'Cache-Control': 'no-cache',
+            },
+        })
+    }
+
+    return c.json({ error: 'Not Found', message: 'Asset not found', path }, 404)
+}
+
 /**
  * Register asset fallback handler
  *
- * Serves static assets from Workers Assets binding.
+ * Serves static assets from either Workers Assets or R2 bucket binding.
+ * Automatically detects which binding type is present and routes accordingly.
  * MUST be registered last as it's a catch-all for non-API routes.
  *
+ * Supports two deployment strategies:
+ * - Workers Assets (default): For games with files <25MB
+ * - R2 Bucket (fallback): For games with large files like Godot WASM
+ *
  * SPA Routing Support:
  * - First tries to fetch the requested path (e.g., /assets/main.js)
  * - If 404 and NOT an API route, falls back to /index.html
@@ -148,24 +233,8 @@ export function registerAssetFallback(app: Hono<HonoEnv>): void {
             )
         }
 
-        // Try to fetch the requested asset
-        const response = await c.env.ASSETS.fetch(c.req.raw)
-
-        // If found, return it
-        if (response.status !== 404) {
-            return response
-        }
-
-        // If not found and it's a file request (has extension), return 404
-        const path = new URL(c.req.url).pathname
-        if (path.includes('.')) {
-            return response
-        }
-
-        // Otherwise, fall back to index.html for predictable routing
-        const indexUrl = new URL(c.req.url)
-        indexUrl.pathname = '/index.html'
-
-        return await c.env.ASSETS.fetch(new Request(indexUrl.toString()))
+        return isR2AssetsBinding(c.env.ASSETS)
+            ? await serveFromR2(c, c.env.ASSETS)
+            : await serveFromWorkersAssets(c, c.env.ASSETS)
     })
 }

package/dist/edge-play/src/types.ts

@@ -10,6 +10,12 @@
 import type { PlaycademyClient, PlaycademyConfig } from '@playcademy/sdk/server'
 import type { RouteMetadata } from './entry/types'
 
+/**
+ * Workers Assets Fetcher binding
+ * Standard Cloudflare binding for serving static assets
+ */
+export type AssetsFetcher = { fetch(request: Request): Promise<Response> }
+
 /**
  * Enabled integrations from playcademy.config.js
  */
@@ -37,8 +43,12 @@ export interface ServerEnv {
     /** Game-specific secrets (optional) */
     secrets?: Record<string, string>
 
-    /** Workers Assets binding for static files (Cloudflare-specific) */
-    ASSETS?: { fetch(request: Request): Promise<Response> }
+    /**
+     * Frontend assets binding (Cloudflare-specific)
+     * - AssetsFetcher: Workers Assets binding (default for files <25MB)
+     * - R2Bucket: R2 bucket binding (fallback for large files like Godot WASM)
+     */
+    ASSETS?: AssetsFetcher | R2Bucket
 
     /** KV namespace binding (optional, Cloudflare-specific) */
     KV?: KVNamespace