playcademy 0.14.12 → 0.14.13

package/dist/db.d.ts

@@ -75,6 +75,17 @@ declare function resetDatabase(workspace: string, mf: Miniflare, options?: {
     debug?: boolean;
 }): Promise<void>;
 
+/**
+ * Environment context passed to seed functions
+ */
+interface SeedContext {
+    env: {
+        DB: unknown;
+        BUCKET?: unknown;
+        secrets?: Record<string, string>;
+    };
+}
+
 /**
  * Database Seed Utilities
  *
@@ -87,19 +98,17 @@ declare function resetDatabase(workspace: string, mf: Miniflare, options?: {
  * Bundles all deps for portability.
  */
 declare function importSeedModule(seedPath: string): Promise<{
-    seed?: (c: {
-        env: {
-            DB: unknown;
-        };
-    }) => Promise<void>;
+    seed?: (c: SeedContext) => Promise<void>;
 }>;
+declare function getBucket(mf: Miniflare): Promise<unknown | null>;
 /**
- * Execute a seed file against a Miniflare D1 instance
+ * Execute a seed file against a Miniflare instance
  *
  * @param seedFilePath - Path to seed file
- * @param mf - Miniflare instance with D1 database
+ * @param mf - Miniflare instance with D1 database (and optionally bucket/secrets)
+ * @param envSecrets - Environment secrets from .env file
  */
-declare function executeSeedFile(seedFilePath: string, mf: Miniflare): Promise<void>;
+declare function executeSeedFile(seedFilePath: string, mf: Miniflare, envSecrets?: Record<string, string>): Promise<void>;
 
-export { bundleSeedWorker, executeSeedFile, getDevDbPath as getPath, importSeedModule, resetDatabase };
+export { bundleSeedWorker, executeSeedFile, getBucket, getDevDbPath as getPath, importSeedModule, resetDatabase };
 export type { SeedWorkerBundle };

package/dist/db.js

@@ -2938,7 +2938,14 @@ async function resetDatabase(workspace, mf, options = { debug: false }) {
 async function importSeedModule(seedPath) {
   return await importTypescriptFile(seedPath);
 }
-async function executeSeedFile(seedFilePath, mf) {
+async function getBucket(mf) {
+  try {
+    return await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+  } catch {
+    return null;
+  }
+}
+async function executeSeedFile(seedFilePath, mf, envSecrets = {}) {
   const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
   const seedModule = await importSeedModule(seedFilePath);
   if (typeof seedModule.seed !== "function") {
@@ -2951,9 +2958,16 @@ async function executeSeedFile(seedFilePath, mf) {
     logger.newLine();
     process.exit(1);
   }
+  const bucket = await getBucket(mf);
+  const hasSecrets = Object.keys(envSecrets).length > 0;
   await runStep(
     "Seeding database...",
-    async () => seedModule.seed?.({ env: { DB: d1 } }),
+    async () => {
+      const env = { DB: d1 };
+      if (bucket) env.BUCKET = bucket;
+      if (hasSecrets) env.secrets = envSecrets;
+      return seedModule.seed?.({ env });
+    },
     "Database seeded successfully!"
   );
   logger.newLine();
@@ -2961,6 +2975,7 @@ async function executeSeedFile(seedFilePath, mf) {
 export {
   bundleSeedWorker,
   executeSeedFile,
+  getBucket,
   getDevDbPath as getPath,
   importSeedModule,
   resetDatabase

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

@@ -177,8 +177,9 @@ async function serveFromR2(c: Context<HonoEnv>, bucket: R2Bucket): Promise<Respo
         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',
+                // Use 1-hour caching - balances performance with update propagation
+                // (Godot and other engines use non-hashed filenames)
+                'Cache-Control': key === 'index.html' ? 'no-cache' : 'public, max-age=3600',
                 ETag: object.etag,
             },
         })

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

@@ -0,0 +1,140 @@
+/**
+ * Stub Worker for Static-Only Games
+ *
+ * Minimal worker that serves static assets with CORS headers.
+ * Used for games that don't have custom backend routes.
+ *
+ * Features:
+ * - Serves files from Workers Assets or R2 bucket binding
+ * - Supports hybrid deployment strategy (small files via Assets, large files via R2)
+ * - Adds CORS headers for cross-origin manifest fetching
+ * - Handles OPTIONS preflight requests
+ * - Returns 404 for /api/* routes (no backend deployed)
+ * - Supports SPA routing (falls back to index.html)
+ */
+
+type AssetsFetcher = { fetch(request: Request): Promise<Response> }
+type R2Bucket = { get(key: string): Promise<R2Object | null> }
+type R2Object = { body: ReadableStream; httpMetadata?: { contentType?: string }; etag: string }
+
+interface Env {
+    ASSETS: AssetsFetcher | R2Bucket
+}
+
+/**
+ * Detect if ASSETS binding is an R2 bucket or Workers Assets Fetcher
+ */
+function isR2Bucket(assets: AssetsFetcher | R2Bucket): assets is R2Bucket {
+    return 'get' in assets && typeof assets.get === 'function' && !('fetch' in assets)
+}
+
+/**
+ * Serve from Workers Assets (default for files <25MB)
+ */
+async function serveFromAssets(request: Request, assets: AssetsFetcher): Promise<Response> {
+    const response = await assets.fetch(request)
+
+    if (response.status !== 404) {
+        // Add CORS headers
+        const modifiedResponse = new Response(response.body, response)
+        modifiedResponse.headers.set('Access-Control-Allow-Origin', '*')
+        modifiedResponse.headers.set('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')
+        return modifiedResponse
+    }
+
+    // SPA routing: if not a file request, try index.html
+    const path = new URL(request.url).pathname
+    if (path.includes('.')) {
+        return response // File request not found
+    }
+
+    const indexUrl = new URL(request.url)
+    indexUrl.pathname = '/index.html'
+    const indexResponse = await assets.fetch(new Request(indexUrl.toString()))
+
+    // Add CORS headers to index.html response
+    const modifiedResponse = new Response(indexResponse.body, indexResponse)
+    modifiedResponse.headers.set('Access-Control-Allow-Origin', '*')
+    modifiedResponse.headers.set('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')
+    return modifiedResponse
+}
+
+/**
+ * Serve from R2 bucket (for large files like Godot WASM)
+ */
+async function serveFromR2(request: Request, bucket: R2Bucket): Promise<Response> {
+    const path = new URL(request.url).pathname
+    const key = path === '/' ? 'index.html' : path.slice(1)
+
+    const object = await bucket.get(key)
+
+    if (object) {
+        return new Response(object.body, {
+            headers: {
+                'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
+                // Use 1-hour caching - balances performance with update propagation
+                // (Godot and other engines use non-hashed filenames)
+                'Cache-Control': key === 'index.html' ? 'no-cache' : 'public, max-age=3600',
+                ETag: object.etag,
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, HEAD, OPTIONS',
+            },
+        })
+    }
+
+    // SPA routing: if not a file request, try index.html
+    if (path.includes('.')) {
+        return new Response('Not Found', { status: 404 })
+    }
+
+    const indexObject = await bucket.get('index.html')
+    if (indexObject) {
+        return new Response(indexObject.body, {
+            headers: {
+                'Content-Type': 'text/html',
+                'Cache-Control': 'no-cache',
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, HEAD, OPTIONS',
+            },
+        })
+    }
+
+    return new Response('Not Found', { status: 404 })
+}
+
+export default {
+    async fetch(request: Request, env: Env): Promise<Response> {
+        try {
+            const url = new URL(request.url)
+
+            // Handle CORS preflight
+            if (request.method === 'OPTIONS') {
+                const headers = new Headers()
+                headers.set('Access-Control-Allow-Origin', '*')
+                headers.set('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')
+                const reqHeaders = request.headers.get('Access-Control-Request-Headers')
+                if (reqHeaders) {
+                    headers.set('Access-Control-Allow-Headers', reqHeaders)
+                }
+                headers.set('Access-Control-Max-Age', '86400')
+                return new Response(null, { status: 204, headers })
+            }
+
+            // No backend routes available
+            if (url.pathname.startsWith('/api/')) {
+                return new Response('No backend deployed', { status: 404 })
+            }
+
+            // Serve static assets (auto-detect Workers Assets vs R2)
+            if (!env.ASSETS) {
+                return new Response('ASSETS binding not configured', { status: 500 })
+            }
+
+            return isR2Bucket(env.ASSETS)
+                ? await serveFromR2(request, env.ASSETS)
+                : await serveFromAssets(request, env.ASSETS)
+        } catch (error) {
+            return new Response('Error: ' + (error as Error).message, { status: 500 })
+        }
+    },
+}

package/dist/index.js

@@ -5680,7 +5680,7 @@ function getDevDbPath() {
 
 // src/lib/db/bundle-seed.ts
 async function bundleSeedWorker(seedFilePath, projectPath) {
-  const esbuild2 = await import("esbuild");
+  const esbuild3 = await import("esbuild");
   const entryCode = `
         import { seed } from '${seedFilePath}'
         
@@ -5718,7 +5718,7 @@ async function bundleSeedWorker(seedFilePath, projectPath) {
     sourcemap: false,
     logLevel: "error"
   };
-  const result = await esbuild2.build(buildConfig);
+  const result = await esbuild3.build(buildConfig);
   if (!result.outputFiles?.[0]) {
     throw new Error("Seed worker bundling failed: no output");
   }
@@ -5770,7 +5770,14 @@ init_core();
 async function importSeedModule(seedPath) {
   return await importTypescriptFile(seedPath);
 }
-async function executeSeedFile(seedFilePath, mf) {
+async function getBucket(mf) {
+  try {
+    return await mf.getR2Bucket(CLOUDFLARE_BINDINGS.BUCKET);
+  } catch {
+    return null;
+  }
+}
+async function executeSeedFile(seedFilePath, mf, envSecrets = {}) {
   const d1 = await mf.getD1Database(CLOUDFLARE_BINDINGS.DB);
   const seedModule = await importSeedModule(seedFilePath);
   if (typeof seedModule.seed !== "function") {
@@ -5783,9 +5790,16 @@ async function executeSeedFile(seedFilePath, mf) {
     logger.newLine();
     process.exit(1);
   }
+  const bucket = await getBucket(mf);
+  const hasSecrets = Object.keys(envSecrets).length > 0;
   await runStep(
     "Seeding database...",
-    async () => seedModule.seed?.({ env: { DB: d1 } }),
+    async () => {
+      const env = { DB: d1 };
+      if (bucket) env.BUCKET = bucket;
+      if (hasSecrets) env.secrets = envSecrets;
+      return seedModule.seed?.({ env });
+    },
     "Database seeded successfully!"
   );
   logger.newLine();
@@ -6031,8 +6045,16 @@ init_constants2();
 function textLoaderPlugin() {
   return {
     name: "text-loader",
-    setup(build2) {
-      build2.onLoad({ filter: /edge-play\/src\/entry\.ts$/ }, async (args) => {
+    setup(build3) {
+      build3.onLoad({ filter: /edge-play\/src\/entry\.ts$/ }, async (args) => {
+        const fs2 = await import("fs/promises");
+        const text5 = await fs2.readFile(args.path, "utf8");
+        return {
+          contents: `export default ${JSON.stringify(text5)}`,
+          loader: "js"
+        };
+      });
+      build3.onLoad({ filter: /edge-play\/src\/stub-entry\.ts$/ }, async (args) => {
         const fs2 = await import("fs/promises");
         const text5 = await fs2.readFile(args.path, "utf8");
         return {
@@ -6040,7 +6062,7 @@ function textLoaderPlugin() {
           loader: "js"
         };
       });
-      build2.onLoad({ filter: /edge-play\/src\/routes\/root\.html$/ }, async (args) => {
+      build3.onLoad({ filter: /edge-play\/src\/routes\/root\.html$/ }, async (args) => {
         const fs2 = await import("fs/promises");
         const text5 = await fs2.readFile(args.path, "utf8");
         return {
@@ -6048,7 +6070,7 @@ function textLoaderPlugin() {
           loader: "js"
         };
       });
-      build2.onLoad({ filter: /templates\/sample-route\.ts$/ }, async (args) => {
+      build3.onLoad({ filter: /templates\/sample-route\.ts$/ }, async (args) => {
         const fs2 = await import("fs/promises");
         const text5 = await fs2.readFile(args.path, "utf8");
         return {
@@ -6162,8 +6184,8 @@ async function transpileRoute(filePath) {
   if (isBun() || !filePath.endsWith(".ts")) {
     return filePath;
   }
-  const esbuild2 = await import("esbuild");
-  const result = await esbuild2.build({
+  const esbuild3 = await import("esbuild");
+  const result = await esbuild3.build({
     entryPoints: [filePath],
     write: false,
     format: "esm",
@@ -6319,7 +6341,7 @@ function createEsbuildConfig(entryCode, paths, bundleConfig, customRoutesDir, op
   };
 }
 async function bundleBackend(config, options = {}) {
-  const esbuild2 = await import("esbuild");
+  const esbuild3 = await import("esbuild");
   const { customRouteData, customRoutesDir } = await discoverCustomRoutes(config);
   const bundleConfig = {
     ...config,
@@ -6335,7 +6357,7 @@ async function bundleBackend(config, options = {}) {
     customRoutesDir,
     options
   );
-  const result = await esbuild2.build(buildConfig);
+  const result = await esbuild3.build(buildConfig);
   if (!result.outputFiles?.[0]) {
     throw new Error("Backend bundling failed: no output");
   }
@@ -6618,14 +6640,14 @@ function formatDelta(bytes) {
   return `${arrow} ${value.toFixed(2)} ${unit}`;
 }
 function displayDeploymentDiff(options) {
-  const { diff, noChanges, build: build2, backend, integrations } = options;
+  const { diff, noChanges, build: build3, backend, integrations } = options;
   if (noChanges) {
     logger.remark("No changes detected");
     logger.newLine();
     return;
   }
   const hasConfigChanges = Object.keys(diff).length > 0;
-  const buildChanged = build2?.changed === true;
+  const buildChanged = build3?.changed === true;
   const backendChanged = backend?.changed === true;
   const forceBackend = backend?.forced;
   const schemaStatementCount = backend?.schemaStatementCount;
@@ -6661,8 +6683,8 @@ function displayDeploymentDiff(options) {
   }
   if (buildChanged) {
     logger.bold("Frontend", 1);
-    const previousSize = build2?.previousSize;
-    const currentSize = build2?.currentSize;
+    const previousSize = build3?.previousSize;
+    const currentSize = build3?.currentSize;
     if (previousSize !== void 0 && currentSize !== void 0) {
       logger.sizeChange("Build", previousSize, currentSize, formatSize, formatDelta, 2);
     } else if (currentSize !== void 0) {
@@ -7123,8 +7145,11 @@ function scaffoldProtectedExample(workspace) {
   writeFileSync3(join14(sampleDir, "protected.ts"), protectedRouteTemplate);
 }
 function updateEnvForAuth(workspace, strategies) {
-  if (strategies.length === 0) return;
   const envLines = [];
+  envLines.push("# Better Auth (required)");
+  envLines.push("# Generate with: openssl rand -base64 32");
+  envLines.push("BETTER_AUTH_SECRET=your_secret_here");
+  envLines.push("");
   if (strategies.includes("github")) {
     envLines.push("# GitHub OAuth (for standalone auth)");
     envLines.push("GITHUB_CLIENT_ID=your_github_client_id");
@@ -7137,9 +7162,7 @@ function updateEnvForAuth(workspace, strategies) {
     envLines.push("GOOGLE_CLIENT_SECRET=your_google_client_secret");
     envLines.push("");
   }
-  if (envLines.length > 0) {
-    updateEnvExample(workspace, envLines);
-  }
+  updateEnvExample(workspace, envLines);
 }
 async function scaffoldAuthSetup(options = {}) {
   const workspace = getWorkspace();
@@ -7195,7 +7218,7 @@ import { join as join15 } from "path";
 // package.json
 var package_default2 = {
   name: "playcademy",
-  version: "0.14.11",
+  version: "0.14.12",
   type: "module",
   exports: {
     ".": {
@@ -9398,6 +9421,35 @@ import { existsSync as existsSync20 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
 import { basename as basename2, join as join24, resolve as resolve8 } from "path";
 
+// src/lib/deploy/stub.ts
+import * as esbuild2 from "esbuild";
+
+// ../edge-play/src/stub-entry.ts
+var stub_entry_default = "/**\n * Stub Worker for Static-Only Games\n *\n * Minimal worker that serves static assets with CORS headers.\n * Used for games that don't have custom backend routes.\n *\n * Features:\n * - Serves files from Workers Assets or R2 bucket binding\n * - Supports hybrid deployment strategy (small files via Assets, large files via R2)\n * - Adds CORS headers for cross-origin manifest fetching\n * - Handles OPTIONS preflight requests\n * - Returns 404 for /api/* routes (no backend deployed)\n * - Supports SPA routing (falls back to index.html)\n */\n\ntype AssetsFetcher = { fetch(request: Request): Promise<Response> }\ntype R2Bucket = { get(key: string): Promise<R2Object | null> }\ntype R2Object = { body: ReadableStream; httpMetadata?: { contentType?: string }; etag: string }\n\ninterface Env {\n    ASSETS: AssetsFetcher | R2Bucket\n}\n\n/**\n * Detect if ASSETS binding is an R2 bucket or Workers Assets Fetcher\n */\nfunction isR2Bucket(assets: AssetsFetcher | R2Bucket): assets is R2Bucket {\n    return 'get' in assets && typeof assets.get === 'function' && !('fetch' in assets)\n}\n\n/**\n * Serve from Workers Assets (default for files <25MB)\n */\nasync function serveFromAssets(request: Request, assets: AssetsFetcher): Promise<Response> {\n    const response = await assets.fetch(request)\n\n    if (response.status !== 404) {\n        // Add CORS headers\n        const modifiedResponse = new Response(response.body, response)\n        modifiedResponse.headers.set('Access-Control-Allow-Origin', '*')\n        modifiedResponse.headers.set('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')\n        return modifiedResponse\n    }\n\n    // SPA routing: if not a file request, try index.html\n    const path = new URL(request.url).pathname\n    if (path.includes('.')) {\n        return response // File request not found\n    }\n\n    const indexUrl = new URL(request.url)\n    indexUrl.pathname = '/index.html'\n    const indexResponse = await assets.fetch(new Request(indexUrl.toString()))\n\n    // Add CORS headers to index.html response\n    const modifiedResponse = new Response(indexResponse.body, indexResponse)\n    modifiedResponse.headers.set('Access-Control-Allow-Origin', '*')\n    modifiedResponse.headers.set('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')\n    return modifiedResponse\n}\n\n/**\n * Serve from R2 bucket (for large files like Godot WASM)\n */\nasync function serveFromR2(request: Request, bucket: R2Bucket): Promise<Response> {\n    const path = new URL(request.url).pathname\n    const key = path === '/' ? 'index.html' : path.slice(1)\n\n    const object = await bucket.get(key)\n\n    if (object) {\n        return new Response(object.body, {\n            headers: {\n                'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',\n                // Use 1-hour caching - balances performance with update propagation\n                // (Godot and other engines use non-hashed filenames)\n                'Cache-Control': key === 'index.html' ? 'no-cache' : 'public, max-age=3600',\n                ETag: object.etag,\n                'Access-Control-Allow-Origin': '*',\n                'Access-Control-Allow-Methods': 'GET, HEAD, OPTIONS',\n            },\n        })\n    }\n\n    // SPA routing: if not a file request, try index.html\n    if (path.includes('.')) {\n        return new Response('Not Found', { status: 404 })\n    }\n\n    const indexObject = await bucket.get('index.html')\n    if (indexObject) {\n        return new Response(indexObject.body, {\n            headers: {\n                'Content-Type': 'text/html',\n                'Cache-Control': 'no-cache',\n                'Access-Control-Allow-Origin': '*',\n                'Access-Control-Allow-Methods': 'GET, HEAD, OPTIONS',\n            },\n        })\n    }\n\n    return new Response('Not Found', { status: 404 })\n}\n\nexport default {\n    async fetch(request: Request, env: Env): Promise<Response> {\n        try {\n            const url = new URL(request.url)\n\n            // Handle CORS preflight\n            if (request.method === 'OPTIONS') {\n                const headers = new Headers()\n                headers.set('Access-Control-Allow-Origin', '*')\n                headers.set('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')\n                const reqHeaders = request.headers.get('Access-Control-Request-Headers')\n                if (reqHeaders) {\n                    headers.set('Access-Control-Allow-Headers', reqHeaders)\n                }\n                headers.set('Access-Control-Max-Age', '86400')\n                return new Response(null, { status: 204, headers })\n            }\n\n            // No backend routes available\n            if (url.pathname.startsWith('/api/')) {\n                return new Response('No backend deployed', { status: 404 })\n            }\n\n            // Serve static assets (auto-detect Workers Assets vs R2)\n            if (!env.ASSETS) {\n                return new Response('ASSETS binding not configured', { status: 500 })\n            }\n\n            return isR2Bucket(env.ASSETS)\n                ? await serveFromR2(request, env.ASSETS)\n                : await serveFromAssets(request, env.ASSETS)\n        } catch (error) {\n            return new Response('Error: ' + (error as Error).message, { status: 500 })\n        }\n    },\n}\n";
+
+// src/lib/deploy/stub.ts
+var stubEntryTemplate = stub_entry_default.toString();
+async function bundleStubWorker() {
+  const result = await esbuild2.build({
+    stdin: {
+      contents: stubEntryTemplate,
+      loader: "ts"
+    },
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "es2022",
+    write: false,
+    minify: false,
+    sourcemap: false,
+    logLevel: "error"
+  });
+  if (!result.outputFiles?.[0]) {
+    throw new Error("Failed to bundle stub worker");
+  }
+  return result.outputFiles[0].text;
+}
+
 // src/lib/deploy/utils.ts
 init_src2();
 function getDeploymentId(gameSlug) {
@@ -9601,6 +9653,17 @@ async function deployGame(context2, shouldUploadBuild, shouldDeployBackend) {
       deployedSecrets: deploymentPrep.secretKeys,
       deployedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
+  } else if (buildFile && !shouldDeployBackend) {
+    const stubCode = await runStep(
+      "Bundling stub worker",
+      async () => bundleStubWorker(),
+      "Stub worker bundled",
+      { silent: true }
+    );
+    backendBundle = {
+      code: stubCode,
+      config: fullConfig || { name: "stub" }
+    };
   }
   let game;
   if (buildFile) {
@@ -11721,6 +11784,7 @@ async function runDbResetRemote(options) {
 async function runDbResetLocal(options) {
   const workspace = getWorkspace();
   const dbDir = join30(workspace, CLI_DIRECTORIES.DATABASE);
+  logger.newLine();
   if (!existsSync23(dbDir)) {
     logger.warn("No database found to reset");
     logger.newLine();
@@ -11905,10 +11969,37 @@ async function runDbSeedRemote(seedFile, options) {
 async function runDbSeedLocal(seedFile, options) {
   const workspace = getWorkspace();
   const dbDir = join31(workspace, CLI_DIRECTORIES.DATABASE);
+  const config = await loadConfig();
+  const hasBucket = hasBucketSetup(config);
+  const hasKV = hasKVSetup(config);
+  const bucketDir = hasBucket ? join31(workspace, CLI_DIRECTORIES.BUCKET) : void 0;
+  const kvDir = hasKV ? join31(workspace, CLI_DIRECTORIES.KV) : void 0;
+  if (bucketDir) {
+    const { mkdir: mkdir5 } = await import("fs/promises");
+    await mkdir5(bucketDir, { recursive: true });
+  }
+  if (kvDir) {
+    const { mkdir: mkdir5 } = await import("fs/promises");
+    await mkdir5(kvDir, { recursive: true });
+  }
+  const envSecrets = await readEnvFile(workspace);
+  const bindings = {};
+  for (const [key, value] of Object.entries(envSecrets)) {
+    bindings[`secrets_${key}`] = value;
+  }
   const mf = new Miniflare3({
     modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    bindings,
     d1Databases: [CLOUDFLARE_BINDINGS.DB],
     d1Persist: dbDir,
+    ...hasBucket && {
+      r2Buckets: [CLOUDFLARE_BINDINGS.BUCKET],
+      r2Persist: bucketDir
+    },
+    ...hasKV && {
+      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+      kvPersist: kvDir
+    },
     compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
   });
   logger.newLine();
@@ -11916,7 +12007,7 @@ async function runDbSeedLocal(seedFile, options) {
     await resetDatabase(workspace, mf, { debug: options.debug });
   }
   try {
-    await executeSeedFile(seedFile, mf);
+    await executeSeedFile(seedFile, mf, envSecrets);
   } finally {
     await mf.dispose();
   }
@@ -13569,7 +13660,6 @@ async function runBucketListLocal(options) {
       logger.newLine();
       return;
     }
-    logger.success(`Found ${files.length} file${files.length === 1 ? "" : "s"}`);
     if (options.prefix) {
       logger.data("Prefix", options.prefix, 1);
     }
@@ -14954,6 +15044,7 @@ export {
   getAuthenticatedEnvironments,
   getBaseUrl,
   getBestUnit,
+  getBucket,
   getBucketKey,
   getCallbackUrl,
   getCliContext,

package/dist/templates/api/sample-database.ts.template

@@ -7,7 +7,7 @@
 
 import { desc } from 'drizzle-orm'
 
-import { getDb, schema } from '../../../db'
+import { getDb, schema } from 'db'
 
 /**
  * GET /api/sample/database

package/dist/templates/auth/auth.ts.template

@@ -11,10 +11,20 @@ import { playcademy } from '@playcademy/better-auth/server'
 
 import { getDb } from '../../db'
 
-import type { Context } from 'hono'
+function getAuthSecret(c: Context): string {
+    const secret = c.env.secrets?.BETTER_AUTH_SECRET
+    if (!secret) {
+        throw new Error(
+            'BETTER_AUTH_SECRET is required. ' +
+            'Set it locally in .env or deploy with: playcademy secret set BETTER_AUTH_SECRET <value>'
+        )
+    }
+    return secret
+}
 
 export function getAuth(c: Context) {
     const db = getDb(c.env.DB)
+    const secret = getAuthSecret(c)
 
     // CUSTOMIZABLE: Configure trusted origins for CORS
     // These origins are allowed to make cross-origin requests to your game's auth endpoints.
@@ -31,6 +41,8 @@ export function getAuth(c: Context) {
             usePlural: false,
         }),
 
+        secret,
+
         trustedOrigins,
 {{EMAIL_AND_PASSWORD}}{{SOCIAL_PROVIDERS}}
         // REQUIRED: Platform integration

package/dist/utils.js

@@ -3521,6 +3521,14 @@ function textLoaderPlugin() {
           loader: "js"
         };
       });
+      build2.onLoad({ filter: /edge-play\/src\/stub-entry\.ts$/ }, async (args) => {
+        const fs2 = await import("fs/promises");
+        const text = await fs2.readFile(args.path, "utf8");
+        return {
+          contents: `export default ${JSON.stringify(text)}`,
+          loader: "js"
+        };
+      });
       build2.onLoad({ filter: /edge-play\/src\/routes\/root\.html$/ }, async (args) => {
         const fs2 = await import("fs/promises");
         const text = await fs2.readFile(args.path, "utf8");
@@ -3829,7 +3837,7 @@ import { join as join8 } from "path";
 // package.json
 var package_default2 = {
   name: "playcademy",
-  version: "0.14.11",
+  version: "0.14.12",
   type: "module",
   exports: {
     ".": {

package/dist/version.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "playcademy",
-  version: "0.14.11",
+  version: "0.14.12",
   type: "module",
   exports: {
     ".": {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "playcademy",
-    "version": "0.14.12",
+    "version": "0.14.13",
     "type": "module",
     "exports": {
         ".": {