playcademy 0.18.0 → 0.18.2

package/dist/utils.js

@@ -1529,13 +1529,10 @@ function buildQueueImportStatements(queueHandlers) {
   if (queueHandlers.length === 0) {
     return "// No queue handlers";
   }
-  return [
-    "import { createQueueRouter, registerQueueIngressRoute } from './entry/queue'",
-    ...queueHandlers.map((handler, index) => {
-      const normalizedFile = handler.file.replace(/^server\//, "").replace(/\\/g, "/");
-      return `import queueHandler${index} from '@game-server/${normalizedFile}'`;
-    })
-  ].join("\n");
+  return queueHandlers.map((handler, index) => {
+    const normalizedFile = handler.file.replace(/^server\//, "").replace(/\\/g, "/");
+    return `import queueHandler${index} from '@game-server/${normalizedFile}'`;
+  }).join("\n");
 }
 function buildQueueHandlerCode(queueHandlers) {
   if (queueHandlers.length === 0) {
@@ -1950,8 +1947,8 @@ function processConfigVariables(config) {
 }
 
 // src/lib/dev/server.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { join as join19 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { join as join20 } from "path";
 import { Log, LogLevel, Miniflare } from "miniflare";
 
 // ../edge-play/src/constants.ts
@@ -2027,14 +2024,14 @@ function readServerInfo(type, projectRoot) {
   return servers[0] || null;
 }
 async function isPortInUse(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer();
     server.once("error", () => {
-      resolve5(true);
+      resolve6(true);
     });
     server.once("listening", () => {
       server.close();
-      resolve5(false);
+      resolve6(false);
     });
     server.listen(port);
   });
@@ -2048,12 +2045,150 @@ async function waitForPort(port, timeoutMs = 5e3) {
 Stop the other server or specify a different port with --port <number>.`
       );
     }
-    await new Promise((resolve5) => setTimeout(resolve5, 100));
+    await new Promise((resolve6) => setTimeout(resolve6, 100));
   }
 }
 
 // src/lib/deploy/bundle.ts
-import { existsSync as existsSync8, readFileSync as readFileSync3 } from "node:fs";
+import { join as join14, relative as relative3 } from "node:path";
+
+// src/lib/dev/routes.ts
+init_file_loader();
+import { mkdir, writeFile } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join11, relative as relative2 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/lib/deploy/hash.ts
+init_file_loader();
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { resolve as resolve4 } from "path";
+async function hashFile(filePath) {
+  return new Promise((resolveHash, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolveHash(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+async function hashDirectory(dirPath, extensions) {
+  try {
+    const files = scanDirectory(dirPath, { extensions, allowMissing: true });
+    if (files.length === 0) {
+      return null;
+    }
+    files.sort();
+    const combinedHash = createHash("sha256");
+    for (const file of files) {
+      const filePath = resolve4(dirPath, file);
+      const fileHash = await hashFile(filePath);
+      combinedHash.update(`${file}:${fileHash}`);
+    }
+    return combinedHash.digest("hex");
+  } catch {
+    return null;
+  }
+}
+function hashContent(content) {
+  const contentStr = typeof content === "string" ? content : JSON.stringify(content);
+  return createHash("sha256").update(contentStr).digest("hex");
+}
+
+// src/lib/dev/routes.ts
+async function discoverRoutes(apiDir) {
+  const files = scanDirectory(apiDir, {
+    extensions: ["ts", "js"],
+    allowMissing: true
+  });
+  const routes = await Promise.all(
+    files.map(async (file) => {
+      const routePath = filePathToRoutePath(file);
+      const absolutePath = join11(apiDir, file);
+      const relativePath = relative2(getWorkspace(), absolutePath).replace(/\\/g, "/");
+      const methods = await detectExportedMethods(absolutePath);
+      return {
+        path: routePath,
+        file: relativePath,
+        absolutePath,
+        methods
+      };
+    })
+  );
+  return routes;
+}
+async function detectExportedMethods(filePath) {
+  try {
+    const importPath = await transpileRoute(filePath);
+    const specifier = pathToFileURL2(importPath).href;
+    const module = await import(specifier);
+    const methods = [];
+    if (module.GET) {
+      methods.push("GET");
+    }
+    if (module.POST) {
+      methods.push("POST");
+    }
+    if (module.PUT) {
+      methods.push("PUT");
+    }
+    if (module.PATCH) {
+      methods.push("PATCH");
+    }
+    if (module.DELETE) {
+      methods.push("DELETE");
+    }
+    return methods;
+  } catch {
+    return [];
+  }
+}
+function filePathToRoutePath(filePath) {
+  let routePath = filePath.replace(/\.(ts|js)$/, "");
+  if (routePath === "index" || routePath.endsWith("/index")) {
+    routePath = routePath.replace(/\/?index$/, "");
+  }
+  let urlPath = `/${routePath.replace(/\\/g, "/")}`;
+  urlPath = urlPath.replace(/\[\.\.\.([^\]]+)\]/g, ":$1{.*}");
+  urlPath = urlPath.replace(/\[([^\]]+)\]/g, ":$1");
+  urlPath = urlPath === "/" ? "/api" : `/api${urlPath}`;
+  return urlPath;
+}
+function isBun() {
+  return typeof Bun !== "undefined";
+}
+async function transpileRoute(filePath) {
+  if (isBun() || !filePath.endsWith(".ts")) {
+    return filePath;
+  }
+  const esbuild3 = await import("esbuild");
+  const result = await esbuild3.build({
+    entryPoints: [filePath],
+    write: false,
+    format: "esm",
+    platform: "node",
+    bundle: true,
+    // Bundle dependencies so route is self-contained
+    target: "node18",
+    external: ["hono"]
+    // Don't bundle Hono (provided by dev server)
+  });
+  if (!result.outputFiles?.[0]) {
+    throw new Error("Transpilation failed: no output");
+  }
+  const tempDir = join11(tmpdir2(), "playcademy-dev");
+  await mkdir(tempDir, { recursive: true });
+  const hash = hashContent(filePath).slice(0, 12);
+  const jsPath = join11(tempDir, `${hash}.mjs`);
+  await writeFile(jsPath, result.outputFiles[0].text);
+  return jsPath;
+}
+
+// src/lib/deploy/backend-runtime.ts
+import { existsSync as existsSync8 } from "node:fs";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
 import { join as join13 } from "node:path";
 
 // ../utils/src/path.ts
@@ -2309,193 +2444,266 @@ function getMonorepoRoot() {
 var isCompiledBinary = typeof IS_COMPILED_BINARY !== "undefined" && IS_COMPILED_BINARY;
 
 // src/lib/build/plugins.ts
+var TEXT_LOADER_PATTERNS = [
+  /edge-play\/src\/stub-entry\.ts$/,
+  /edge-play\/src\/routes\/root\.html$/,
+  /templates\/sample-route\.ts$/
+];
 function textLoaderPlugin() {
   return {
     name: "text-loader",
     setup(build2) {
-      build2.onLoad({ filter: /edge-play\/src\/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\/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");
-        return {
-          contents: `export default ${JSON.stringify(text)}`,
-          loader: "js"
-        };
-      });
-      build2.onLoad({ filter: /templates\/sample-route\.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"
-        };
-      });
+      for (const filter of TEXT_LOADER_PATTERNS) {
+        build2.onLoad({ filter }, 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"
+          };
+        });
+      }
     }
   };
 }
 
-// src/lib/dev/routes.ts
-init_file_loader();
-import { mkdir, writeFile } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join11, relative as relative2 } from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
+// src/lib/build/embed.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4, join as join12 } from "node:path";
 
-// src/lib/deploy/hash.ts
-import { createHash } from "crypto";
-init_file_loader();
-function hashContent(content) {
-  const contentStr = typeof content === "string" ? content : JSON.stringify(content);
-  return createHash("sha256").update(contentStr).digest("hex");
-}
+// src/version.ts
+var cliVersion = false ? "0.0.0-dev" : "0.18.2";
 
-// src/lib/dev/routes.ts
-async function discoverRoutes(apiDir) {
-  const files = scanDirectory(apiDir, {
-    extensions: ["ts", "js"],
-    allowMissing: true
-  });
-  const routes = await Promise.all(
-    files.map(async (file) => {
-      const routePath = filePathToRoutePath(file);
-      const absolutePath = join11(apiDir, file);
-      const relativePath = relative2(getWorkspace(), absolutePath).replace(/\\/g, "/");
-      const methods = await detectExportedMethods(absolutePath);
-      return {
-        path: routePath,
-        file: relativePath,
-        absolutePath,
-        methods
-      };
-    })
-  );
-  return routes;
-}
-async function detectExportedMethods(filePath) {
-  try {
-    const importPath = await transpileRoute(filePath);
-    const specifier = pathToFileURL2(importPath).href;
-    const module = await import(specifier);
-    const methods = [];
-    if (module.GET) {
-      methods.push("GET");
-    }
-    if (module.POST) {
-      methods.push("POST");
+// src/lib/build/embed.ts
+function writeFileTree(baseDir, files) {
+  for (const [relativePath, content] of Object.entries(files)) {
+    const fullPath = join12(baseDir, relativePath);
+    const dir = dirname4(fullPath);
+    if (!existsSync7(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
-    if (module.PUT) {
-      methods.push("PUT");
+    writeFileSync3(fullPath, content);
+  }
+}
+function createBundleExtractor(options) {
+  const { name, cacheSubdir, getBundle } = options;
+  const marker = `.${name}.ok`;
+  let cachedDir = null;
+  return () => {
+    if (cachedDir) {
+      return cachedDir;
     }
-    if (module.PATCH) {
-      methods.push("PATCH");
+    const bundle = getBundle();
+    if (!bundle) {
+      throw new Error(`${name}: embedded bundle is null (not available in dev mode)`);
     }
-    if (module.DELETE) {
-      methods.push("DELETE");
+    const dir = join12(cacheVersionDir(cliVersion), cacheSubdir);
+    const markerPath = join12(dir, marker);
+    if (!existsSync7(markerPath)) {
+      mkdirSync2(dir, { recursive: true });
+      writeFileTree(dir, bundle);
+      writeFileSync3(markerPath, `${cliVersion}
+`, "utf8");
     }
-    return methods;
+    cachedDir = dir;
+    return dir;
+  };
+}
+
+// src/lib/deploy/embedded-runtime.ts
+var EMBEDDED_BACKEND_RUNTIME = null;
+
+// src/lib/deploy/extract-runtime.ts
+var extractEmbeddedBackendRuntime = createBundleExtractor({
+  name: "embedded-backend-runtime",
+  cacheSubdir: "backend-runtime",
+  getBundle: () => EMBEDDED_BACKEND_RUNTIME
+});
+
+// src/lib/deploy/backend-runtime.ts
+var BACKEND_RUNTIME_ENTRY = "index.js";
+var BACKEND_RUNTIME_POLYFILLS = "polyfills.js";
+var BACKEND_RUNTIME_MANIFEST = "manifest.json";
+var DEV_RUNTIME_CACHE_DIR = "backend-runtime-dev";
+function createNodePolyfillAliases(polyfillsPath) {
+  return {
+    fs: polyfillsPath,
+    "fs/promises": polyfillsPath,
+    path: polyfillsPath,
+    os: polyfillsPath,
+    process: polyfillsPath,
+    "node:fs": polyfillsPath,
+    "node:fs/promises": polyfillsPath,
+    "node:path": polyfillsPath,
+    "node:os": polyfillsPath,
+    "node:process": polyfillsPath
+  };
+}
+var WORKSPACE_SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".mjs", ".cjs"];
+var RUNTIME_SOURCE_DIRS = [
+  "packages/edge-play/src",
+  "packages/sdk/src",
+  "packages/constants/src",
+  "packages/timeback/src",
+  "packages/types/src",
+  "packages/utils/src",
+  "packages/cloudflare/src",
+  "packages/logger/src"
+];
+async function getPackageVersion2(monorepoRoot, packageName) {
+  try {
+    const packageJson = JSON.parse(
+      await readFile2(join13(monorepoRoot, "packages", packageName, "package.json"), "utf8")
+    );
+    return packageJson.version ?? "0.0.0-dev";
   } catch {
-    return [];
+    return "0.0.0-dev";
   }
 }
-function filePathToRoutePath(filePath) {
-  let routePath = filePath.replace(/\.(ts|js)$/, "");
-  if (routePath === "index" || routePath.endsWith("/index")) {
-    routePath = routePath.replace(/\/?index$/, "");
-  }
-  let urlPath = `/${routePath.replace(/\\/g, "/")}`;
-  urlPath = urlPath.replace(/\[\.\.\.([^\]]+)\]/g, ":$1{.*}");
-  urlPath = urlPath.replace(/\[([^\]]+)\]/g, ":$1");
-  urlPath = urlPath === "/" ? "/api" : `/api${urlPath}`;
-  return urlPath;
+async function computeRuntimeInputFingerprint(monorepoRoot, sdkVersion) {
+  const entries = await Promise.all(
+    RUNTIME_SOURCE_DIRS.map(async (dir) => [
+      dir,
+      await hashDirectory(join13(monorepoRoot, dir), ["ts", "js", "json", "html"])
+    ])
+  );
+  return hashContent({ ...Object.fromEntries(entries), sdkVersion });
 }
-function isBun() {
-  return typeof Bun !== "undefined";
+async function getRuntimeBuildMetadata(monorepoRoot) {
+  const [cliVersion2, sdkVersion] = await Promise.all([
+    getPackageVersion2(monorepoRoot, "cli"),
+    getPackageVersion2(monorepoRoot, "sdk")
+  ]);
+  const inputFingerprint = await computeRuntimeInputFingerprint(monorepoRoot, sdkVersion);
+  return {
+    cliVersion: cliVersion2,
+    sdkVersion,
+    runtimeBuildId: inputFingerprint.slice(0, 12),
+    inputFingerprint,
+    entry: BACKEND_RUNTIME_ENTRY,
+    polyfills: BACKEND_RUNTIME_POLYFILLS
+  };
 }
-async function transpileRoute(filePath) {
-  if (isBun() || !filePath.endsWith(".ts")) {
-    return filePath;
+function resolveWorkspaceSourceImport(monorepoRoot, specifier) {
+  if (!specifier.startsWith("@playcademy/")) {
+    return null;
+  }
+  const pathParts = specifier.slice("@playcademy/".length).split("/");
+  const packageName = pathParts.shift();
+  if (!packageName) {
+    return null;
+  }
+  const basePath = join13(monorepoRoot, "packages", packageName, "src");
+  const targetPath = pathParts.length > 0 ? join13(basePath, ...pathParts) : join13(basePath, "index");
+  for (const extension of WORKSPACE_SOURCE_EXTENSIONS) {
+    const withExtension = `${targetPath}${extension}`;
+    if (existsSync8(withExtension)) {
+      return withExtension;
+    }
+  }
+  for (const extension of WORKSPACE_SOURCE_EXTENSIONS) {
+    const indexPath = join13(targetPath, `index${extension}`);
+    if (existsSync8(indexPath)) {
+      return indexPath;
+    }
   }
+  return null;
+}
+function createWorkspaceSourceResolverPlugin(monorepoRoot) {
+  return {
+    name: "playcademy-workspace-source-resolver",
+    setup(build2) {
+      build2.onResolve({ filter: /^@playcademy\// }, (args) => {
+        const resolved = resolveWorkspaceSourceImport(monorepoRoot, args.path);
+        return resolved ? { path: resolved } : null;
+      });
+    }
+  };
+}
+async function writeRuntimeManifest(outdir, manifest) {
+  await writeFile2(
+    join13(outdir, BACKEND_RUNTIME_MANIFEST),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+}
+async function buildBackendRuntime(outdir) {
+  const monorepoRoot = getMonorepoRoot();
+  const manifest = await getRuntimeBuildMetadata(monorepoRoot);
+  const runtimeEntry = join13(monorepoRoot, "packages", "edge-play", "src", "entry", "index.ts");
+  const polyfillsEntry = join13(monorepoRoot, "packages", "edge-play", "src", "polyfills.js");
   const esbuild3 = await import("esbuild");
-  const result = await esbuild3.build({
-    entryPoints: [filePath],
-    write: false,
-    format: "esm",
-    platform: "node",
+  await rm(outdir, { recursive: true, force: true });
+  await mkdir2(outdir, { recursive: true });
+  await esbuild3.build({
+    entryPoints: [runtimeEntry],
+    outfile: join13(outdir, BACKEND_RUNTIME_ENTRY),
     bundle: true,
-    // Bundle dependencies so route is self-contained
-    target: "node18",
-    external: ["hono"]
-    // Don't bundle Hono (provided by dev server)
+    format: "esm",
+    platform: "browser",
+    target: "es2022",
+    write: true,
+    sourcemap: false,
+    minify: false,
+    logLevel: "error",
+    alias: createNodePolyfillAliases(polyfillsEntry),
+    plugins: [textLoaderPlugin(), createWorkspaceSourceResolverPlugin(monorepoRoot)],
+    define: {
+      PLAYCADEMY_RUNTIME_CLI_VERSION: JSON.stringify(manifest.cliVersion),
+      PLAYCADEMY_RUNTIME_SDK_VERSION: JSON.stringify(manifest.sdkVersion),
+      PLAYCADEMY_RUNTIME_BUILD_ID: JSON.stringify(manifest.runtimeBuildId)
+    }
   });
-  if (!result.outputFiles?.[0]) {
-    throw new Error("Transpilation failed: no output");
-  }
-  const tempDir = join11(tmpdir2(), "playcademy-dev");
-  await mkdir(tempDir, { recursive: true });
-  const hash = hashContent(filePath).slice(0, 12);
-  const jsPath = join11(tempDir, `${hash}.mjs`);
-  await writeFile(jsPath, result.outputFiles[0].text);
-  return jsPath;
+  await copyFile(polyfillsEntry, join13(outdir, BACKEND_RUNTIME_POLYFILLS));
+  await writeRuntimeManifest(outdir, manifest);
+  return manifest;
 }
-
-// src/lib/deploy/extract-sources.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname4, join as join12 } from "node:path";
-
-// src/version.ts
-var cliVersion = false ? "0.0.0-dev" : "0.18.0";
-
-// src/lib/deploy/embedded-sources.ts
-var EMBEDDED_SOURCES = null;
-
-// src/lib/deploy/extract-sources.ts
-var EXTRACTION_MARKER = ".embedded-sources.ok";
-function writeTree(baseDir, files) {
-  for (const [relativePath, content] of Object.entries(files)) {
-    const fullPath = join12(baseDir, relativePath);
-    const dir = dirname4(fullPath);
-    if (!existsSync7(dir)) {
-      mkdirSync2(dir, { recursive: true });
-    }
-    writeFileSync3(fullPath, content);
+async function ensureDevBackendRuntime() {
+  const monorepoRoot = getMonorepoRoot();
+  const manifest = await getRuntimeBuildMetadata(monorepoRoot);
+  const runtimeDir = join13(
+    tmpdir3(),
+    DEV_RUNTIME_CACHE_DIR,
+    manifest.cliVersion,
+    manifest.inputFingerprint
+  );
+  if (!existsSync8(join13(runtimeDir, BACKEND_RUNTIME_MANIFEST))) {
+    await buildBackendRuntime(runtimeDir);
   }
+  return runtimeDir;
 }
-var cachedPaths = null;
-function extractEmbeddedSources() {
-  if (cachedPaths) {
-    return cachedPaths;
-  }
-  if (!EMBEDDED_SOURCES) {
-    throw new Error("extractEmbeddedSources called but EMBEDDED_SOURCES is null (dev mode)");
-  }
-  const cacheRoot = cacheVersionDir(cliVersion);
-  const edgePlaySrc = join12(cacheRoot, "edge-play", "src");
-  const constantsSrc = join12(cacheRoot, "constants", "src");
-  const markerPath = join12(cacheRoot, EXTRACTION_MARKER);
-  if (!existsSync7(markerPath)) {
-    mkdirSync2(cacheRoot, { recursive: true });
-    writeTree(edgePlaySrc, EMBEDDED_SOURCES.edgePlay);
-    writeTree(constantsSrc, EMBEDDED_SOURCES.constants);
-    writeFileSync3(markerPath, `${cliVersion}
-`, "utf8");
+async function readRuntimeManifest(runtimeDir) {
+  const content = await readFile2(join13(runtimeDir, BACKEND_RUNTIME_MANIFEST), "utf8");
+  return JSON.parse(content);
+}
+async function resolveBackendRuntimePaths() {
+  const workspace = getWorkspace();
+  const workspaceNodeModules = join13(workspace, "node_modules");
+  if (isCompiledBinary) {
+    const runtimeDir2 = extractEmbeddedBackendRuntime();
+    const manifest2 = await readRuntimeManifest(runtimeDir2);
+    const cliDepsRoot = join13(workspace, ".playcademy", "node_modules");
+    return {
+      runtimeDir: runtimeDir2,
+      runtimeEntry: join13(runtimeDir2, manifest2.entry),
+      polyfillsEntry: join13(runtimeDir2, manifest2.polyfills),
+      workspaceNodeModules,
+      cliDepsRoot,
+      manifest: manifest2
+    };
   }
-  cachedPaths = { edgePlaySrc, constantsSrc };
-  return cachedPaths;
+  const monorepoRoot = getMonorepoRoot();
+  const runtimeDir = await ensureDevBackendRuntime();
+  const manifest = await readRuntimeManifest(runtimeDir);
+  return {
+    runtimeDir,
+    runtimeEntry: join13(runtimeDir, manifest.entry),
+    polyfillsEntry: join13(runtimeDir, manifest.polyfills),
+    workspaceNodeModules,
+    cliDepsRoot: monorepoRoot,
+    manifest
+  };
 }
 
 // src/lib/deploy/bundle.ts
@@ -2503,153 +2711,134 @@ 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(join13(workspace, customRoutesDir));
+  const customRoutes = await discoverRoutes(join14(workspace, customRoutesDir));
   const customRouteData = customRoutes.map((r) => ({
     path: r.path,
     file: r.file,
-    // Use relative path (e.g., 'server/api/test.ts'), not absolute
+    // relative path (e.g., 'server/api/test.ts'), not absolute
     methods: r.methods
   }));
   return { customRouteData, customRoutesDir };
 }
-function resolveEmbeddedSourcePaths() {
-  const workspace = getWorkspace();
-  if (isCompiledBinary) {
-    const { edgePlaySrc: edgePlaySrc2, constantsSrc } = extractEmbeddedSources();
-    const constantsEntry2 = join13(constantsSrc, "index.ts");
-    const workspaceNodeModules2 = join13(workspace, "node_modules");
-    const playcademyNodeModules = join13(workspace, ".playcademy", "node_modules");
-    return {
-      isBuiltPackage: true,
-      edgePlaySrc: edgePlaySrc2,
-      constantsEntry: constantsEntry2,
-      workspaceNodeModules: workspaceNodeModules2,
-      cliDepsRoot: playcademyNodeModules
-    };
+function getForbiddenImportMessage(specifier) {
+  if (specifier === "@playcademy/sdk/server") {
+    return "Use `c.get('sdk')` instead of importing the server SDK directly.";
   }
-  const distDir = new URL(".", import.meta.url).pathname;
-  const embeddedEdgeSrc = join13(distDir, "edge-play", "src");
-  const isBuiltPackage = existsSync8(embeddedEdgeSrc);
-  const monorepoRoot = getMonorepoRoot();
-  const monorepoEdgeSrc = join13(monorepoRoot, "packages/edge-play/src");
-  const edgePlaySrc = isBuiltPackage ? embeddedEdgeSrc : monorepoEdgeSrc;
-  const cliPackageRoot = isBuiltPackage ? join13(distDir, "../../..") : join13(monorepoRoot, "packages/cli");
-  const cliDepsRoot = isBuiltPackage ? join13(cliPackageRoot, "node_modules") : monorepoRoot;
-  const workspaceNodeModules = join13(workspace, "node_modules");
-  const constantsEntry = isBuiltPackage ? join13(embeddedEdgeSrc, "..", "..", "constants", "src", "index.ts") : join13(monorepoRoot, "packages", "constants", "src", "index.ts");
+  if (specifier.startsWith("@playcademy/edge-play")) {
+    return "Built-in backend runtime helpers are internal to the CLI-owned runtime.";
+  }
+  return "CLI-owned backend runtime packages are not available to game backend code.";
+}
+function createForbiddenRuntimeImportsPlugin(workspace) {
   return {
-    isBuiltPackage,
-    edgePlaySrc,
-    constantsEntry,
-    workspaceNodeModules,
-    cliDepsRoot
+    name: "forbidden-backend-runtime-imports",
+    setup(build2) {
+      build2.onResolve(
+        {
+          filter: /^@playcademy\/(?:sdk\/server|edge-play(?:\/.*)?|constants(?:\/.*)?)$/
+        },
+        (args) => {
+          if (!args.importer) {
+            return null;
+          }
+          const importerPath = relative3(workspace, args.importer).replace(/\\/g, "/");
+          return {
+            errors: [
+              {
+                text: `Unsupported backend import "${args.path}" in ${importerPath}. ${getForbiddenImportMessage(args.path)} Use \`Context\`, \`c.env\`, \`c.get('sdk')\`, and \`c.get('playcademyUser')\` instead.`
+              }
+            ]
+          };
+        }
+      );
+    }
   };
 }
 function createEsbuildConfig(entryCode, paths, bundleConfig, customRoutesDir, options) {
   const workspace = getWorkspace();
-  const { edgePlaySrc, constantsEntry, workspaceNodeModules, cliDepsRoot } = paths;
+  const { runtimeEntry, polyfillsEntry, workspaceNodeModules, cliDepsRoot } = paths;
   return {
-    // ──── Input Configuration ────
+    // ──── Input: generated entry code, not a real file ────
+    // resolveDir = workspace so that bare specifiers in the generated code
+    // (e.g. '@game-api/save.ts') resolve relative to the user's project root.
     stdin: {
       contents: entryCode,
-      // Generated entry code with custom route imports
-      resolveDir: edgePlaySrc,
-      // Resolve relative imports from edge-play/src
+      resolveDir: workspace,
       loader: "ts"
-      // Treat input as TypeScript
     },
-    // ──── Output Configuration ────
+    // ──── Output configuration ────
     bundle: true,
-    // Bundle all dependencies into single file
     format: "esm",
-    // Output ES modules (required for Cloudflare Workers)
+    // Cloudflare Workers require ES modules
     platform: "browser",
-    // Workers use browser APIs, not Node.js
+    // Workers run in a browser-like environment, not Node.js
     target: "es2022",
-    // Modern JavaScript for Workers runtime
     write: false,
-    // Return code as string (don't write to disk)
+    // Return code as a string; the caller writes/uploads it
     sourcemap: options.sourcemap ? "inline" : false,
     minify: options.minify || false,
-    logLevel: "error",
-    // Only show errors (suppress warnings)
-    // ──── Module Resolution ────
-    // Tell esbuild where to find node_modules for bare imports
-    // Dev:       workspace node_modules + monorepo root (hoisted deps)
-    // Published: workspace node_modules + same (user's project)
-    // Binary:    workspace node_modules + .playcademy/node_modules (hono lives there)
+    logLevel: "silent",
+    // errors propagate as thrown exceptions; we don't want esbuild double-printing to stderr
+    // ──── Module resolution ────
+    // esbuild searches nodePaths in order for bare specifiers.
+    // workspaceNodeModules: game project's own deps (hono, etc. if user installed them)
+    // cliDepsRoot:          CLI-managed deps (.playcademy/node_modules in binary mode,
+    //                       monorepo root in dev mode) — where hono, @hono/node-server live
     nodePaths: [workspaceNodeModules, cliDepsRoot],
-    // ──── Build-time Constants ────
-    // Inject the Playcademy config as a global constant
-    // Code can access it via: const config = PLAYCADEMY_CONFIG
+    // ──── Build-time constants ────
+    // PLAYCADEMY_CONFIG is accessed as a global in the generated entry code and in
+    // the sealed runtime itself (passed to createBaseApp). It carries integrations
+    // config, route metadata, queue metadata, etc.
     define: {
       PLAYCADEMY_CONFIG: JSON.stringify(bundleConfig)
     },
-    // ──── Import Aliases ────
     alias: {
-      // ┌─ Workspace-only package resolution ─────────────────────────────┐
-      // │ @playcademy/constants is a workspace package that users don't   │
-      // │ install. We embed it in dist/ and alias imports to point there. │
-      // └─────────────────────────────────────────────────────────────────┘
-      "@playcademy/constants": constantsEntry,
-      // ┌─ Workspace-only edge-play package ──────────────────────────────┐
-      // │ @playcademy/edge-play is used in generated entry code for auth  │
-      // │ middleware. It's embedded in dist/ like constants.              │
-      // └─────────────────────────────────────────────────────────────────┘
-      "@playcademy/edge-play": edgePlaySrc,
-      // ┌─ User's custom routes ──────────────────────────────────────────┐
-      // │ @game-api is a virtual module that maps to the user's API dir.  │
-      // │ Example: import * as route from '@game-api/hello.ts'            │
-      // │ Resolves to: /user-project/server/api/hello.ts                  │
-      // └─────────────────────────────────────────────────────────────────┘
-      "@game-api": join13(workspace, customRoutesDir),
-      // ┌─ User's server lib directory ───────────────────────────────────┐
-      // │ @game-server is a virtual module for server utilities/config    │
-      // │ Example: import { getAuth } from '@game-server/lib/auth'        │
-      // │ Resolves to: /user-project/server/lib/auth.ts                   │
-      // └─────────────────────────────────────────────────────────────────┘
-      "@game-server": join13(workspace, "server"),
-      // ┌─ Node.js polyfills for Cloudflare Workers ──────────────────────┐
-      // │ Workers don't have fs, path, os, etc. Redirect to polyfills     │
-      // │ that throw helpful errors if user code tries to use them.       │
-      // └─────────────────────────────────────────────────────────────────┘
-      fs: join13(edgePlaySrc, "polyfills.js"),
-      "fs/promises": join13(edgePlaySrc, "polyfills.js"),
-      path: join13(edgePlaySrc, "polyfills.js"),
-      os: join13(edgePlaySrc, "polyfills.js"),
-      process: join13(edgePlaySrc, "polyfills.js")
+      // ┌─ Sealed backend runtime ────────────────────────────────────────────┐
+      // │ The pre-bundled artifact: edge-play + sdk/server + all internal     │
+      // │ @playcademy/* deps, zero external imports remaining. This alias     │
+      // │ is what enforces version isolation — game node_modules are ignored. │
+      // └─────────────────────────────────────────────────────────────────────┘
+      "@playcademy/backend-runtime": runtimeEntry,
+      // ┌─ Game's custom route files ─────────────────────────────────────────┐
+      // │ @game-api is a virtual module pointing to the game's API directory. │
+      // │ Example: import * as route from '@game-api/save.ts'                 │
+      // │ Resolves to: /user-project/server/api/save.ts                       │
+      // └─────────────────────────────────────────────────────────────────────┘
+      "@game-api": join14(workspace, customRoutesDir),
+      // ┌─ Game's server library directory ───────────────────────────────────┐
+      // │ @game-server is a virtual module for server-side utilities.         │
+      // │ Example: import { getAuth } from '@game-server/lib/auth'            │
+      // │ Resolves to: /user-project/server/lib/auth.ts                       │
+      // └─────────────────────────────────────────────────────────────────────┘
+      "@game-server": join14(workspace, "server"),
+      // ┌─ Node.js polyfills for Cloudflare Workers ──────────────────────────┐
+      // │ Workers don't have fs, path, os, process, etc. Redirect them to a   │
+      // │ polyfills stub bundled into the sealed runtime that throws a clear  │
+      // │ error if user code actually calls them at runtime.                  │
+      // └─────────────────────────────────────────────────────────────────────┘
+      ...createNodePolyfillAliases(polyfillsEntry)
     },
-    // ──── Build Plugins ────
-    plugins: [textLoaderPlugin()],
-    // Support Bun's 'with { type: "text" }' imports
-    // ──── External Dependencies ────
+    plugins: [createForbiddenRuntimeImportsPlugin(workspace)],
     external: []
-    // Bundle everything (no externals for Workers)
+    // Bundle everything — no externals allowed in Workers
   };
 }
-function loadEntryTemplate(paths) {
-  const entryPath = paths ? join13(paths.edgePlaySrc, "entry.ts") : join13(getMonorepoRoot(), "packages", "edge-play", "src", "entry.ts");
-  return readFileSync3(entryPath, "utf8");
-}
 async function bundleBackend(config, options = {}) {
   const esbuild3 = await import("esbuild");
   const { customRouteData, customRoutesDir } = await discoverCustomRoutes(config);
   const queueHandlers = discoverQueueHandlers();
   validateQueueHandlersConfig(config, queueHandlers);
-  const paths = resolveEmbeddedSourcePaths();
-  const entryTemplate = loadEntryTemplate(paths);
+  const paths = await resolveBackendRuntimePaths();
   const bundleConfig = {
     ...config,
     __routeMetadata: customRouteData,
     __queueMetadata: queueHandlers
   };
-  const hasAuth = Boolean(config.integrations?.auth);
   const entryCode = generateEntryCode(
     customRouteData,
     customRoutesDir,
     queueHandlers,
-    hasAuth,
-    entryTemplate
+    Boolean(config.integrations?.auth)
   );
   const buildConfig = createEsbuildConfig(
     entryCode,
@@ -2662,9 +2851,8 @@ async function bundleBackend(config, options = {}) {
   if (!result.outputFiles?.[0]) {
     throw new Error("Backend bundling failed: no output");
   }
-  const code = result.outputFiles[0].text;
   return {
-    code,
+    code: result.outputFiles[0].text,
     config,
     customRoutes: customRouteData
   };
@@ -2672,50 +2860,69 @@ async function bundleBackend(config, options = {}) {
 function buildCustomRouteImportStatements(customRoutes, customRoutesDir) {
   const normalizedRoutesDir = customRoutesDir.replace(/\\/g, "/").replace(/\/+/g, "/");
   const customRoutesPrefix = normalizedRoutesDir.endsWith("/") ? normalizedRoutesDir : `${normalizedRoutesDir}/`;
-  return customRoutes.map((route, i) => {
+  return customRoutes.map((route, index) => {
     const normalizedFile = route.file.replace(/\\/g, "/").replace(/\/+/g, "/");
     const importPath = normalizedFile.startsWith(customRoutesPrefix) ? normalizedFile.slice(customRoutesPrefix.length) : normalizedFile;
-    return `import * as customRoute${i} from '@game-api/${importPath}'`;
+    return `import * as customRoute${index} from '@game-api/${importPath}'`;
   }).join("\n");
 }
-function generateEntryCode(customRoutes, customRoutesDir, queueHandlers, hasAuth, entryTemplateInput = loadEntryTemplate()) {
-  const importStatements = customRoutes.length > 0 ? buildCustomRouteImportStatements(customRoutes, customRoutesDir) : "// No custom routes";
-  const queueImportStatements = buildQueueImportStatements(queueHandlers);
-  const withCustomRouteImports = entryTemplateInput.replace(
-    "// \u26A0\uFE0F BUILD_MARKER: CUSTOM_ROUTE_IMPORTS \u26A0\uFE0F",
-    importStatements
-  );
-  const withImports = withCustomRouteImports.replace(
-    "// \u26A0\uFE0F BUILD_MARKER: QUEUE_HANDLER_IMPORTS \u26A0\uFE0F",
-    queueImportStatements
-  );
-  const registrationStatements = customRoutes.length > 0 ? customRoutes.flatMap((route, i) => {
-    const methods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
-    return methods.map((method) => {
-      const methodLower = method.toLowerCase();
-      return `if (customRoute${i}.${method}) app.${methodLower}('${route.path}', customRoute${i}.${method})`;
-    });
-  }) : [];
-  const registrationCode = registrationStatements.length > 0 ? ["// Custom routes", ...registrationStatements, ""].join("\n") : "// No custom routes\n";
-  const withRoutes = withImports.replace("// \u26A0\uFE0F BUILD_MARKER: CUSTOM_ROUTES \u26A0\uFE0F", registrationCode);
-  const queueHandlerCode = buildQueueHandlerCode(queueHandlers);
-  const withQueueHandlers = withRoutes.replace(
-    "// \u26A0\uFE0F BUILD_MARKER: QUEUE_HANDLER \u26A0\uFE0F",
-    queueHandlerCode
-  );
-  const exportCode = buildWorkerExportCode(queueHandlers);
-  const withExport = withQueueHandlers.replace("// \u26A0\uFE0F BUILD_MARKER: WORKER_EXPORT \u26A0\uFE0F", exportCode);
-  const sessionMiddlewareStatements = hasAuth ? [
-    "import { createSessionMiddleware } from '@playcademy/edge-play'",
-    "import { getAuth } from '@game-server/lib/auth'",
-    "app.use('*', createSessionMiddleware(getAuth))"
-  ] : [];
-  const sessionMiddlewareCode = sessionMiddlewareStatements.join("\n");
-  const result = withExport.replace(
-    "// \u26A0\uFE0F BUILD_MARKER: SESSION_MIDDLEWARE \u26A0\uFE0F",
-    sessionMiddlewareCode
+function buildCustomRouteModuleCode(customRoutes) {
+  if (customRoutes.length === 0) {
+    return "const __customRoutes = []";
+  }
+  return [
+    "const __customRoutes = [",
+    ...customRoutes.map(
+      (route, index) => `    { path: ${JSON.stringify(route.path)}, module: customRoute${index} },`
+    ),
+    "]"
+  ].join("\n");
+}
+function generateEntryCode(customRoutes, customRoutesDir, queueHandlers, hasAuth = false) {
+  const runtimeImports = [
+    "createBaseApp",
+    "registerBuiltinRoutes",
+    "registerCustomRouteModules",
+    "registerTerminalHandlers"
+  ];
+  if (hasAuth) {
+    runtimeImports.push("createSessionMiddleware");
+  }
+  if (queueHandlers.length > 0) {
+    runtimeImports.push("createQueueRouter", "registerQueueIngressRoute");
+  }
+  const importBlocks = [
+    `import { ${runtimeImports.join(", ")} } from '@playcademy/backend-runtime'`
+  ];
+  if (hasAuth) {
+    importBlocks.push("import { getAuth } from '@game-server/lib/auth'");
+  }
+  if (customRoutes.length > 0) {
+    importBlocks.push(buildCustomRouteImportStatements(customRoutes, customRoutesDir));
+  }
+  if (queueHandlers.length > 0) {
+    importBlocks.push(buildQueueImportStatements(queueHandlers));
+  }
+  const body = [
+    "// PLAYCADEMY_CONFIG is injected at bundle time via esbuild define",
+    "const app = createBaseApp(PLAYCADEMY_CONFIG)",
+    ""
+  ];
+  if (hasAuth) {
+    body.push("app.use('*', createSessionMiddleware(getAuth))", "");
+  }
+  body.push(
+    "await registerBuiltinRoutes(app, PLAYCADEMY_CONFIG.integrations)",
+    "",
+    buildCustomRouteModuleCode(customRoutes),
+    "registerCustomRouteModules(app, __customRoutes)",
+    "",
+    buildQueueHandlerCode(queueHandlers),
+    "registerTerminalHandlers(app)",
+    "",
+    buildWorkerExportCode(queueHandlers)
   );
-  return result;
+  return [...importBlocks, "", ...body].join("\n");
 }
 
 // src/lib/init/prompts.ts
@@ -2729,8 +2936,8 @@ var authSchemaTemplate = loadTemplateString("auth/auth-schema.ts");
 var protectedRouteTemplate = loadTemplateString("api/sample-protected.ts");
 
 // src/lib/init/database.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join15 } from "node:path";
 var drizzleConfigTemplate = loadTemplateString("database/drizzle-config.ts");
 var dbSchemaExampleTemplate = loadTemplateString("database/db-schema-example.ts");
 var dbSchemaIndexTemplate = loadTemplateString("database/db-schema-index.ts");
@@ -2740,7 +2947,7 @@ var dbSeedTemplate = loadTemplateString("database/db-seed.ts");
 var packageTemplate = loadTemplateString("database/package.json");
 function hasDatabaseSetup() {
   const workspace = getWorkspace();
-  return DRIZZLE_CONFIG_FILES.some((filename) => existsSync9(join14(workspace, filename)));
+  return DRIZZLE_CONFIG_FILES.some((filename) => existsSync9(join15(workspace, filename)));
 }
 
 // src/lib/init/scaffold.ts
@@ -2762,17 +2969,17 @@ function hasBucketSetup(config) {
 
 // src/lib/init/types.ts
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join17, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname5, join as join18, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/lib/deploy/backend.ts
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 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 join16(projectPath, customRoutesDir);
 }
 function hasLocalCustomRoutes(projectPath, config) {
   const customRoutesDir = getCustomRoutesDirectory(projectPath, config);
@@ -2817,8 +3024,8 @@ function validateIntegrationSecrets(config, envSecrets) {
 
 // src/lib/init/tsconfig.ts
 init_file_loader();
-import { existsSync as existsSync11, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join17 } from "path";
 function hasAllRequiredIncludes(config) {
   if (!config.include) {
     return false;
@@ -2891,7 +3098,7 @@ function addToIncludeArrayPreservingComments(content) {
 }
 async function ensureTsconfigIncludes(workspace) {
   for (const filename of TSCONFIG_FILES) {
-    const configPath = join16(workspace, filename);
+    const configPath = join17(workspace, filename);
     if (existsSync11(configPath)) {
       try {
         const config = await loadFile(configPath, {
@@ -2903,7 +3110,7 @@ async function ensureTsconfigIncludes(workspace) {
             return filename;
           }
           try {
-            const rawContent = readFileSync5(configPath, "utf8");
+            const rawContent = readFileSync4(configPath, "utf8");
             const updatedContent = addToIncludeArrayPreservingComments(rawContent);
             if (updatedContent && updatedContent !== rawContent) {
               writeFileSync5(configPath, updatedContent);
@@ -2943,14 +3150,14 @@ function getDepVersions() {
     return { honoVersion: "^4.9.9", workersTypesVersion: "^4.20251011.0" };
   }
   try {
-    const pkgPath = resolve4(
+    const pkgPath = resolve5(
       dirname5(fileURLToPath2(import.meta.url)),
       "..",
       "..",
       "..",
       "package.json"
     );
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return {
       honoVersion: pkg.dependencies?.hono ?? "latest",
       workersTypesVersion: pkg.devDependencies?.["@cloudflare/workers-types"] ?? "latest"
@@ -2960,8 +3167,8 @@ function getDepVersions() {
   }
 }
 async function setupPlaycademyDependencies(workspace) {
-  const playcademyDir = join17(workspace, CLI_DIRECTORIES.WORKSPACE);
-  const playcademyPkgPath = join17(playcademyDir, "package.json");
+  const playcademyDir = join18(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyPkgPath = join18(playcademyDir, "package.json");
   const { honoVersion, workersTypesVersion } = getDepVersions();
   const playcademyPkg = {
     private: true,
@@ -3057,14 +3264,14 @@ async function ensurePlaycademyTypes(options = {}) {
     const bindingsStr = generateBindingsTypeString(features, queueBindings);
     const secretsStr = await generateSecretsTypeString(workspace, verbose);
     const hasAuth = Boolean(config.integrations?.auth);
-    const hasAuthFile = existsSync12(join17(workspace, "server/lib/auth.ts"));
+    const hasAuthFile = existsSync12(join18(workspace, "server/lib/auth.ts"));
     const authVariablesString = generateAuthVariablesString(hasAuth, hasAuthFile);
     let envContent = playcademyEnvTemplate.replace("{{BINDINGS}}", bindingsStr);
     envContent = envContent.replace("{{SECRETS}}", secretsStr);
     envContent = envContent.replace("{{AUTH_IMPORT}}", authVariablesString.authImport);
     envContent = envContent.replace("{{VARIABLES}}", authVariablesString.variables);
     envContent = envContent.replace("{{CONTEXT_VARS}}", authVariablesString.contextVars);
-    const envPath = join17(workspace, "playcademy-env.d.ts");
+    const envPath = join18(workspace, "playcademy-env.d.ts");
     writeFileSync6(envPath, envContent);
     if (verbose) {
       logger.success(`Generated <playcademy-env.d.ts>`);
@@ -3099,12 +3306,12 @@ import { blue as blue2, cyan as cyan3, green as green3, magenta, red as red3, ye
 
 // src/lib/init/engine/hooks.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7 } from "fs";
-import { rename, rm } from "fs/promises";
-import { dirname as dirname6, join as join18 } from "path";
+import { rename, rm as rm2 } from "fs/promises";
+import { dirname as dirname6, join as join19 } from "path";
 import JSZip from "jszip";
 async function godotAfterFetch({ destDir }) {
-  const addonsDir = join18(destDir, "addons");
-  const targetDir = join18(addonsDir, "playcademy");
+  const addonsDir = join19(destDir, "addons");
+  const targetDir = join19(addonsDir, "playcademy");
   let zipData;
   await runStep(
     "Downloading Playcademy Addon for Godot",
@@ -3132,7 +3339,7 @@ async function godotAfterFetch({ destDir }) {
         if (file.dir) {
           return;
         }
-        const extractPath = join18(destDir, relativePath);
+        const extractPath = join19(destDir, relativePath);
         extractPromises.push(
           file.async("nodebuffer").then((content) => {
             const dir = dirname6(extractPath);
@@ -3144,14 +3351,14 @@ async function godotAfterFetch({ destDir }) {
         );
       });
       await Promise.all(extractPromises);
-      const extractedRoot = join18(destDir, "playcademy", "addons", "playcademy");
+      const extractedRoot = join19(destDir, "playcademy", "addons", "playcademy");
       if (existsSync13(extractedRoot)) {
         if (existsSync13(targetDir)) {
-          await rm(targetDir, { recursive: true, force: true });
+          await rm2(targetDir, { recursive: true, force: true });
         }
         await rename(extractedRoot, targetDir);
-        const extractedParent = join18(destDir, "playcademy");
-        await rm(extractedParent, { recursive: true, force: true });
+        const extractedParent = join19(destDir, "playcademy");
+        await rm2(extractedParent, { recursive: true, force: true });
       }
     },
     "Playcademy Addon extracted",
@@ -3363,9 +3570,9 @@ async function startDevServer(options) {
   return { server: mf, port };
 }
 async function ensureDatabaseDirectory() {
-  const dbDir = join19(getWorkspace(), CLI_DIRECTORIES.DATABASE);
+  const dbDir = join20(getWorkspace(), CLI_DIRECTORIES.DATABASE);
   try {
-    await mkdir2(dbDir, { recursive: true });
+    await mkdir3(dbDir, { recursive: true });
   } catch (error) {
     throw new Error(`Failed to create database directory: ${getErrorMessage(error)}`, {
       cause: error
@@ -3374,9 +3581,9 @@ async function ensureDatabaseDirectory() {
   return dbDir;
 }
 async function ensureKvDirectory() {
-  const kvDir = join19(getWorkspace(), CLI_DIRECTORIES.KV);
+  const kvDir = join20(getWorkspace(), CLI_DIRECTORIES.KV);
   try {
-    await mkdir2(kvDir, { recursive: true });
+    await mkdir3(kvDir, { recursive: true });
   } catch (error) {
     throw new Error(`Failed to create KV directory: ${getErrorMessage(error)}`, {
       cause: error
@@ -3385,9 +3592,9 @@ async function ensureKvDirectory() {
   return kvDir;
 }
 async function ensureBucketDirectory() {
-  const bucketDir = join19(getWorkspace(), CLI_DIRECTORIES.BUCKET);
+  const bucketDir = join20(getWorkspace(), CLI_DIRECTORIES.BUCKET);
   try {
-    await mkdir2(bucketDir, { recursive: true });
+    await mkdir3(bucketDir, { recursive: true });
   } catch (error) {
     throw new Error(`Failed to create bucket directory: ${getErrorMessage(error)}`, {
       cause: error
@@ -3410,7 +3617,7 @@ async function writeBackendServerInfo(port) {
 }
 
 // src/lib/dev/reload.ts
-import { join as join20, relative as relative3 } from "path";
+import { join as join21, relative as relative4 } from "path";
 import chokidar from "chokidar";
 import { bold as bold6, cyan as cyan5, dim as dim4, green as green4 } from "colorette";
 function formatTime() {
@@ -3427,9 +3634,9 @@ function startHotReload(onReload, options = {}) {
   const customRoutesConfig = options.config?.integrations?.customRoutes;
   const customRoutesDir = typeof customRoutesConfig === "object" && customRoutesConfig.directory || DEFAULT_API_ROUTES_DIRECTORY;
   const watchPaths = [
-    join20(workspace, customRoutesDir),
-    join20(workspace, "playcademy.config.js"),
-    join20(workspace, "playcademy.config.json")
+    join21(workspace, customRoutesDir),
+    join21(workspace, "playcademy.config.js"),
+    join21(workspace, "playcademy.config.json")
   ];
   const watcher = chokidar.watch(watchPaths, {
     persistent: true,
@@ -3441,7 +3648,7 @@ function startHotReload(onReload, options = {}) {
   });
   const logSuccess = options.onSuccess || ((changedPath, eventType) => {
     if (changedPath) {
-      const relativePath = relative3(workspace, changedPath);
+      const relativePath = relative4(workspace, changedPath);
       const timestamp = dim4(formatTime());
       const brand = bold6(cyan5("[playcademy]"));
       const event = eventType === "changed" ? green4("reload") : green4(eventType || "reload");