playcademy 0.14.28 → 0.14.30

package/dist/cli.js

@@ -0,0 +1,3637 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../utils/src/package-json.ts
+function getPackageNameFromData(pkg, fallback = "unknown-package") {
+  return pkg?.name || fallback;
+}
+function getPackageVersionFromData(pkg, fallback = "0.0.0") {
+  return pkg?.version || fallback;
+}
+function getPackageNameVersionFromData(pkg) {
+  const name = getPackageNameFromData(pkg);
+  const version2 = getPackageVersionFromData(pkg);
+  return `${name}@${version2}`;
+}
+function hasDependencyInData(pkg, packageName) {
+  if (!pkg) return false;
+  return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName] || pkg.peerDependencies?.[packageName]);
+}
+var init_package_json = __esm({
+  "../utils/src/package-json.ts"() {
+    "use strict";
+  }
+});
+
+// ../utils/src/file-loader.ts
+var file_loader_exports = {};
+__export(file_loader_exports, {
+  findFile: () => findFile,
+  findFilesByExtension: () => findFilesByExtension,
+  getCurrentDirectoryName: () => getCurrentDirectoryName,
+  getFileExtension: () => getFileExtension,
+  getPackageField: () => getPackageField,
+  getPackageName: () => getPackageName,
+  getPackageNameVersion: () => getPackageNameVersion,
+  getPackageVersion: () => getPackageVersion,
+  hasDependency: () => hasDependency,
+  loadFile: () => loadFile,
+  loadModule: () => loadModule,
+  loadPackageJson: () => loadPackageJson,
+  scanDirectory: () => scanDirectory
+});
+import { existsSync, readdirSync, statSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname, parse, resolve } from "path";
+function findFilePath(filename, startDir, maxLevels = 3) {
+  const filenames = Array.isArray(filename) ? filename : [filename];
+  let currentDir2 = resolve(startDir);
+  let levelsSearched = 0;
+  while (levelsSearched <= maxLevels) {
+    for (const fname of filenames) {
+      const filePath = resolve(currentDir2, fname);
+      if (existsSync(filePath)) {
+        return {
+          path: filePath,
+          dir: currentDir2,
+          filename: fname
+        };
+      }
+    }
+    if (levelsSearched >= maxLevels) {
+      break;
+    }
+    const parentDir = dirname(currentDir2);
+    if (parentDir === currentDir2) {
+      break;
+    }
+    const parsed = parse(currentDir2);
+    if (parsed.root === currentDir2) {
+      break;
+    }
+    currentDir2 = parentDir;
+    levelsSearched++;
+  }
+  return null;
+}
+async function loadFile(filename, options = {}) {
+  const {
+    cwd = process.cwd(),
+    required = false,
+    searchUp = false,
+    maxLevels = 3,
+    parseJson = false,
+    stripComments = false
+  } = options;
+  let fileResult;
+  if (searchUp) {
+    fileResult = findFilePath(filename, cwd, maxLevels);
+  } else {
+    const filenames = Array.isArray(filename) ? filename : [filename];
+    fileResult = null;
+    for (const fname of filenames) {
+      const filePath = resolve(cwd, fname);
+      if (existsSync(filePath)) {
+        fileResult = {
+          path: filePath,
+          dir: cwd,
+          filename: fname
+        };
+        break;
+      }
+    }
+  }
+  if (!fileResult) {
+    if (required) {
+      const fileList = Array.isArray(filename) ? filename.join(" or ") : filename;
+      const message = searchUp ? `${fileList} not found in ${cwd} or up to ${maxLevels} parent directories` : `${fileList} not found at ${cwd}`;
+      throw new Error(message);
+    }
+    return null;
+  }
+  try {
+    let content = await readFile(fileResult.path, "utf-8");
+    if (parseJson) {
+      if (stripComments) {
+        content = stripJsonComments(content);
+      }
+      return JSON.parse(content);
+    }
+    return content;
+  } catch (error) {
+    throw new Error(
+      `Failed to load ${fileResult.filename} from ${fileResult.path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function findFile(filename, options = {}) {
+  const { cwd = process.cwd(), searchUp = false, maxLevels = 3 } = options;
+  if (searchUp) {
+    return findFilePath(filename, cwd, maxLevels);
+  }
+  const filenames = Array.isArray(filename) ? filename : [filename];
+  for (const fname of filenames) {
+    const filePath = resolve(cwd, fname);
+    if (existsSync(filePath)) {
+      return {
+        path: filePath,
+        dir: cwd,
+        filename: fname
+      };
+    }
+  }
+  return null;
+}
+async function loadPackageJson(options = {}) {
+  return loadFile("package.json", { ...options, parseJson: true });
+}
+async function getPackageName(options) {
+  const pkg = await loadPackageJson(options);
+  const cwd = options?.cwd || process.cwd();
+  const parts = cwd.split(/[/\\]/);
+  const dirName = parts[parts.length - 1] || "unknown-package";
+  return getPackageNameFromData(pkg, dirName);
+}
+async function getPackageVersion(options) {
+  const pkg = await loadPackageJson(options);
+  return getPackageVersionFromData(pkg);
+}
+async function getPackageField(field, options) {
+  const pkg = await loadPackageJson(options);
+  return pkg?.[field];
+}
+async function hasDependency(packageName, options) {
+  const pkg = await loadPackageJson(options);
+  return hasDependencyInData(pkg, packageName);
+}
+async function getPackageNameVersion(options) {
+  const pkg = await loadPackageJson(options);
+  if (!pkg) {
+    throw new Error("No package.json found");
+  }
+  return getPackageNameVersionFromData(pkg);
+}
+function getCurrentDirectoryName(fallback = "unknown-directory") {
+  const cwd = process.cwd();
+  const dirName = cwd.split("/").pop();
+  return dirName || fallback;
+}
+function getFileExtension(path2) {
+  return path2.split(".").pop()?.toLowerCase();
+}
+function stripJsonComments(jsonc) {
+  let result = jsonc.replace(/\/\*[\s\S]*?\*\//g, "");
+  result = result.replace(/\/\/.*/g, "");
+  return result;
+}
+async function loadModule(filename, options = {}) {
+  const { cwd = process.cwd(), required = false, searchUp = false, maxLevels = 3 } = options;
+  let fileResult;
+  if (searchUp) {
+    fileResult = findFilePath(filename, cwd, maxLevels);
+  } else {
+    const filenames = Array.isArray(filename) ? filename : [filename];
+    fileResult = null;
+    for (const fname of filenames) {
+      const filePath = resolve(cwd, fname);
+      if (existsSync(filePath)) {
+        fileResult = {
+          path: filePath,
+          dir: cwd,
+          filename: fname
+        };
+        break;
+      }
+    }
+  }
+  if (!fileResult) {
+    if (required) {
+      const fileList = Array.isArray(filename) ? filename.join(" or ") : filename;
+      const message = searchUp ? `${fileList} not found in ${cwd} or up to ${maxLevels} parent directories` : `${fileList} not found at ${cwd}`;
+      throw new Error(message);
+    }
+    return null;
+  }
+  try {
+    const ext = getFileExtension(fileResult.filename);
+    if (ext === "js" || ext === "mjs" || ext === "cjs") {
+      const module = await import(fileResult.path);
+      return module.default || module;
+    } else {
+      throw new Error(`Unsupported module type: ${ext} (only .js, .mjs, .cjs supported)`);
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to load module ${fileResult.filename} from ${fileResult.path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function scanDirectory(dir, options = {}) {
+  const { extensions, allowMissing = false } = options;
+  const files = [];
+  if (!existsSync(dir)) {
+    if (allowMissing) return [];
+    throw new Error(`Directory not found: ${dir}`);
+  }
+  function scan(currentDir2, basePath = "") {
+    try {
+      const entries = readdirSync(currentDir2);
+      for (const entry of entries) {
+        const fullPath = resolve(currentDir2, entry);
+        const relativePath = basePath ? `${basePath}/${entry}` : entry;
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          scan(fullPath, relativePath);
+        } else if (stat.isFile()) {
+          if (extensions) {
+            const ext = getFileExtension(entry);
+            if (!ext || !extensions.includes(ext)) {
+              continue;
+            }
+          }
+          files.push(relativePath);
+        }
+      }
+    } catch {
+    }
+  }
+  scan(dir);
+  return files;
+}
+function findFilesByExtension(dir, extension) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const ext = extension.toLowerCase().replace(/^\./, "");
+  const files = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = resolve(dir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isFile()) {
+        const fileExt = getFileExtension(entry);
+        if (fileExt === ext) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+var init_file_loader = __esm({
+  "../utils/src/file-loader.ts"() {
+    "use strict";
+    init_package_json();
+  }
+});
+
+// src/lib/core/error.ts
+import { bold as bold2, dim as dim2, redBright } from "colorette";
+import { ApiError, extractApiErrorInfo } from "@playcademy/sdk/internal";
+
+// src/lib/core/logger.ts
+import {
+  blue,
+  blueBright,
+  bold,
+  cyan,
+  dim,
+  gray,
+  green,
+  greenBright,
+  red,
+  underline,
+  yellow,
+  yellowBright
+} from "colorette";
+import { colorize } from "json-colorizer";
+function customTransform(text) {
+  let result = text;
+  result = result.replace(/`([^`]+)`/g, (_, code) => greenBright(code));
+  result = result.replace(/<<([^>]+)>>/g, (_, url) => blueBright(underline(url)));
+  result = result.replace(/<([^>]+)>/g, (_, path2) => blueBright(path2));
+  return result;
+}
+function formatTable(data, title) {
+  const ANSI_REGEX = /\u001B\[[0-9;]*m/g;
+  const stripAnsi2 = (value) => value.replace(ANSI_REGEX, "");
+  const visibleLength = (value) => stripAnsi2(value).length;
+  const padCell = (value, width) => {
+    const length = visibleLength(value);
+    if (length >= width) return value;
+    return value + " ".repeat(width - length);
+  };
+  if (data.length === 0) return;
+  const keys = Object.keys(data[0]);
+  const rows = data.map((item) => keys.map((key) => String(item[key] ?? "")));
+  const widths = keys.map((key, i) => {
+    const headerWidth = visibleLength(key);
+    const dataWidth = Math.max(...rows.map((row) => visibleLength(row[i])));
+    return Math.max(headerWidth, dataWidth);
+  });
+  const totalWidth = widths.reduce((sum, w) => sum + w + 3, -1);
+  const separator = "\u251C" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u253C") + "\u2524";
+  const topBorder = "\u250C" + "\u2500".repeat(totalWidth) + "\u2510";
+  const titleSeparator = "\u251C" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u252C") + "\u2524";
+  const bottomBorder = "\u2514" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u2534") + "\u2518";
+  console.log(topBorder);
+  if (title) {
+    const titleText = bold(title);
+    const titlePadding = totalWidth - title.length - 1;
+    const titleRow = "\u2502 " + titleText + " ".repeat(titlePadding) + "\u2502";
+    console.log(titleRow);
+    console.log(titleSeparator);
+  }
+  const header = "\u2502 " + keys.map((key, i) => padCell(key, widths[i])).join(" \u2502 ") + " \u2502";
+  console.log(header);
+  console.log(separator);
+  rows.forEach((row) => {
+    const dataRow = "\u2502 " + row.map((cell, i) => padCell(cell, widths[i])).join(" \u2502 ") + " \u2502";
+    console.log(dataRow);
+  });
+  console.log(bottomBorder);
+}
+var logger = {
+  table: (data, title) => {
+    formatTable(data, title);
+  },
+  /**
+   * Info message - general information
+   */
+  info: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${blue("\u2139")} ${bold(customTransform(message))}`);
+  },
+  /**
+   * Admonition - highlighted note/tip/warning box (Docusaurus-style)
+   */
+  admonition: (type, title, lines, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    const configs = {
+      note: { color: green },
+      tip: { color: cyan },
+      info: { color: blue },
+      warning: { color: yellow }
+    };
+    const { color: color2 } = configs[type];
+    console.log(`${spaces}${color2("\u250C\u2500")} ${bold(color2(title.toUpperCase()))}`);
+    if (lines && lines.length > 0) {
+      lines.forEach((line) => {
+        console.log(`${spaces}${color2("\u2502")} ${customTransform(line)}`);
+      });
+    }
+    console.log(`${spaces}${color2("\u2514\u2500")}`);
+  },
+  /**
+   * Dim message - less important information
+   */
+  dim: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${dim(customTransform(message))}`);
+  },
+  /**
+   * Success message - operation completed successfully
+   */
+  success: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${green("\u2714")} ${bold(customTransform(message))}`);
+  },
+  remark: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${bold(yellowBright("\u2726"))} ${bold(customTransform(message))}`);
+  },
+  /**
+   * Error message - operation failed
+   */
+  error: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.error(`${spaces}${red("\u2716")} ${customTransform(message)}`);
+  },
+  bold: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${bold(customTransform(message))}`);
+  },
+  /**
+   * Warning message - something to be aware of
+   */
+  warn: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.warn(`${spaces}${yellow("\u26A0")} ${bold(customTransform(message))}`);
+  },
+  /**
+   * Debug message - only shown when DEBUG env var is set
+   */
+  debug: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    if (process.env.DEBUG) {
+      console.log(gray("[DEBUG]"), `${spaces}${message}`);
+    }
+  },
+  /**
+   * Step message - shows progress through a process
+   */
+  step: (step, total, message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(spaces + cyan(`[${step}/${total}]`), customTransform(message));
+  },
+  /**
+   * Highlighted message - draws attention
+   */
+  highlight: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(bold(`${spaces}${cyan(customTransform(message))}`));
+  },
+  /**
+   * Aside message - for side information
+   */
+  aside: (message, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${bold(customTransform(message))}`);
+  },
+  /**
+   * Data display - for structured data output
+   */
+  data: (label, value, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    if (value !== void 0) {
+      console.log(`${spaces}${dim(label + ":")} ${bold(value)}`);
+    } else {
+      console.log(`${spaces}${dim(label)}`);
+    }
+  },
+  /**
+   * Size change display - shows old size → new size with delta
+   * @param label - The label for the size change (e.g., 'Build', 'Bundle')
+   * @param previousSize - Previous size in bytes
+   * @param currentSize - Current size in bytes
+   * @param formatSize - Function to format size in bytes
+   * @param formatDelta - Function to format size delta
+   * @param indent - Indentation level
+   */
+  sizeChange: (label, previousSize, currentSize, formatSize, formatDelta, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    const oldSize = formatSize(previousSize);
+    const newSize = formatSize(currentSize);
+    const delta = dim(`(${formatDelta(currentSize - previousSize)})`);
+    const value = `${red(oldSize)} \u2192 ${green(newSize)}  ${delta}`;
+    console.log(`${spaces}${dim(label + ":")} ${bold(value)}`);
+  },
+  /**
+   * JSON output - pretty-printed JSON
+   */
+  json: (data, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    const jsonString = colorize(JSON.stringify(data, null, 2));
+    jsonString.split("\n").forEach((line) => {
+      console.log(`${spaces}${line}`);
+    });
+  },
+  /**
+   * New line
+   */
+  newLine: () => {
+    console.log();
+  },
+  /**
+   * Raw output - no formatting, useful for ASCII art or pre-formatted text
+   */
+  raw: (text, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${text}`);
+  },
+  customRaw: (text, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${customTransform(text)}`);
+  },
+  /**
+   * Display a configuration error with helpful suggestions
+   */
+  configError: (error, indent = 0) => {
+    formatError(error, indent);
+  }
+};
+
+// src/lib/core/error.ts
+function isConfigError(error) {
+  return error !== null && typeof error === "object" && "name" in error && error.name === "ConfigError" && "message" in error;
+}
+function extractEmbeddedJson(message) {
+  const jsonMatch = message.match(/(\{.+\})$/);
+  if (!jsonMatch) {
+    return { cleanMessage: message };
+  }
+  try {
+    const json = JSON.parse(jsonMatch[1]);
+    const cleanMessage = message.slice(0, jsonMatch.index).trim();
+    return { cleanMessage, json };
+  } catch {
+    return { cleanMessage: message };
+  }
+}
+function cleanMessageSuffix(message) {
+  let cleaned = message.replace(/:\s*\d{3}\s*$/, "").trim();
+  if (cleaned.endsWith(":")) {
+    cleaned = cleaned.slice(0, -1).trim();
+  }
+  return cleaned;
+}
+function removeStatusPrefix(message, statusCode) {
+  if (message.startsWith(`${statusCode} `)) {
+    return message.slice(`${statusCode} `.length);
+  }
+  return message;
+}
+function displayApiError(error, indent) {
+  const spaces = "  ".repeat(indent);
+  const errorInfo = extractApiErrorInfo(error);
+  if (!errorInfo) {
+    console.error(`${spaces}${redBright("\u2716")} ${bold2(error.message)}`);
+    if (process.env.DEBUG && error.details) {
+      console.error("");
+      logger.json(error.details, indent + 1);
+    }
+    return;
+  }
+  const statusCode = errorInfo.status;
+  let displayMessage = errorInfo.statusText;
+  displayMessage = removeStatusPrefix(displayMessage, statusCode);
+  const { cleanMessage, json: embeddedJson } = extractEmbeddedJson(displayMessage);
+  displayMessage = cleanMessageSuffix(cleanMessage);
+  let errorCode;
+  if (error.details && typeof error.details === "object") {
+    const details = error.details;
+    if ("code" in details && typeof details.code === "string") {
+      errorCode = details.code;
+    }
+  }
+  let errorHeader = "API Error";
+  if (errorCode) {
+    errorHeader += ` ${redBright(`[${errorCode}]`)}`;
+  }
+  errorHeader += `: ${displayMessage} ${redBright(`[${statusCode}]`)}`;
+  console.error(`${spaces}${redBright("\u2716")} ${bold2(errorHeader)}`);
+  if (process.env.DEBUG) {
+    const detailsToShow = embeddedJson || error.details || errorInfo.details;
+    if (detailsToShow) {
+      console.error("");
+      logger.json(detailsToShow, indent + 1);
+    }
+  }
+}
+function displayConfigError(error, indent) {
+  const spaces = "  ".repeat(indent);
+  console.error(`${spaces}${redBright("\u2716")} ${bold2(error.message)}`);
+  if (error.field) {
+    console.error(`${spaces}  ${dim2("Field:")} ${error.field}`);
+  }
+  if (error.suggestion) {
+    console.error(`${spaces}  ${dim2("Fix:")} ${error.suggestion}`);
+  }
+}
+function displayGenericError(error, indent) {
+  const spaces = "  ".repeat(indent);
+  console.error(`${spaces}${redBright("\u2716")} ${bold2(error.message)}`);
+  if (error.stack && process.env.DEBUG) {
+    console.error(`${spaces}  ${dim2("Stack:")}`);
+    console.error(
+      error.stack.split("\n").slice(1).map((line) => `${spaces}    ${dim2(line)}`).join("\n")
+    );
+  }
+}
+function formatError(error, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  if (error instanceof ApiError) {
+    displayApiError(error, indent);
+    return;
+  }
+  if (isConfigError(error)) {
+    displayConfigError(error, indent);
+    return;
+  }
+  if (error instanceof Error) {
+    displayGenericError(error, indent);
+    return;
+  }
+  console.error(`${spaces}${redBright("\u2716")} ${bold2(String(error))}`);
+}
+function setupGlobalErrorHandlers() {
+  let sigintReceived = false;
+  process.on("SIGINT", () => {
+    if (sigintReceived) {
+      process.exit(130);
+    }
+    sigintReceived = true;
+    setImmediate(() => {
+      if (sigintReceived) {
+        process.exit(130);
+      }
+    });
+  });
+  const isExitPromptError = (error) => {
+    return error instanceof Error && error.name === "ExitPromptError" && error.message.includes("force closed the prompt");
+  };
+  process.on("uncaughtException", (error) => {
+    if (isExitPromptError(error)) {
+      process.exit(0);
+    }
+    console.error(error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isExitPromptError(reason)) {
+      process.exit(0);
+    }
+    console.error(reason);
+    process.exit(1);
+  });
+}
+
+// src/lib/init/run.ts
+import { execSync as execSync5 } from "child_process";
+import { writeFileSync as writeFileSync10 } from "fs";
+import { resolve as resolve7 } from "path";
+import { confirm as confirm4 } from "@inquirer/prompts";
+
+// ../utils/src/ansi.ts
+var colors = {
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var styles = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m"
+};
+var cursor = {
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  up: (n) => `\x1B[${n}A`,
+  down: (n) => `\x1B[${n}B`,
+  forward: (n) => `\x1B[${n}C`,
+  back: (n) => `\x1B[${n}D`,
+  clearLine: "\x1B[K",
+  clearScreen: "\x1B[2J",
+  home: "\x1B[H"
+};
+function color(text, colorCode) {
+  return `${colorCode}${text}${styles.reset}`;
+}
+function dim3(text) {
+  return color(text, styles.dim);
+}
+function bold3(text) {
+  return color(text, styles.bold);
+}
+var isInteractive = typeof process !== "undefined" && process.stdout?.isTTY && !process.env.CI && process.env.TERM !== "dumb";
+function stripAnsi(text) {
+  return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+// ../utils/src/spinner.ts
+import { stdout } from "process";
+var SPINNER_FRAMES = [
+  10251,
+  10265,
+  10297,
+  10296,
+  10300,
+  10292,
+  10278,
+  10279,
+  10247,
+  10255
+].map((code) => String.fromCodePoint(code));
+var CHECK_MARK = String.fromCodePoint(10004);
+var CROSS_MARK = String.fromCodePoint(10006);
+var SPINNER_INTERVAL = 80;
+var Spinner = class {
+  tasks = /* @__PURE__ */ new Map();
+  frameIndex = 0;
+  intervalId = null;
+  renderCount = 0;
+  previousLineCount = 0;
+  printedTasks = /* @__PURE__ */ new Set();
+  indent;
+  constructor(taskIds, texts, options) {
+    this.indent = options?.indent ?? 0;
+    taskIds.forEach((id, index) => {
+      this.tasks.set(id, {
+        text: texts[index] || "",
+        status: "pending"
+      });
+    });
+  }
+  start() {
+    if (isInteractive) {
+      stdout.write(cursor.hide);
+      this.render();
+      this.intervalId = setInterval(() => {
+        this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+        this.render();
+      }, SPINNER_INTERVAL);
+    }
+  }
+  updateTask(taskId, status, finalText) {
+    const task = this.tasks.get(taskId);
+    if (task) {
+      task.status = status;
+      if (finalText) task.finalText = finalText;
+      if (!isInteractive) {
+        this.renderNonInteractive(taskId, task);
+      }
+    }
+  }
+  renderNonInteractive(taskId, task) {
+    const key = `${taskId}-${task.status}`;
+    if (this.printedTasks.has(key)) return;
+    this.printedTasks.add(key);
+    const indentStr = "  ".repeat(this.indent);
+    let line = "";
+    switch (task.status) {
+      case "running":
+        line = `${indentStr}[RUNNING] ${stripAnsi(task.text)}`;
+        break;
+      case "success":
+        line = `${indentStr}[SUCCESS] ${stripAnsi(task.finalText || task.text)}`;
+        break;
+      case "error":
+        line = `${indentStr}[ERROR] Failed: ${stripAnsi(task.text)}`;
+        break;
+    }
+    console.log(line);
+  }
+  render() {
+    if (this.previousLineCount > 0) {
+      stdout.write(cursor.up(this.previousLineCount));
+    }
+    const spinner = SPINNER_FRAMES[this.frameIndex];
+    const indentStr = "  ".repeat(this.indent);
+    const visibleTasks = Array.from(this.tasks.values()).filter(
+      (task) => task.status !== "pending"
+    );
+    for (const task of visibleTasks) {
+      stdout.write(`\r${cursor.clearLine}`);
+      let line = "";
+      switch (task.status) {
+        case "running":
+          line = `${indentStr}${colors.blue}${spinner}${styles.reset} ${task.text}`;
+          break;
+        case "success":
+          line = `${indentStr}${colors.green}${CHECK_MARK}${styles.reset} ${task.finalText || task.text}`;
+          break;
+        case "error":
+          line = `${indentStr}${colors.red}${CROSS_MARK}${styles.reset} Failed: ${task.text}`;
+          break;
+      }
+      console.log(line);
+    }
+    this.previousLineCount = visibleTasks.length;
+    this.renderCount++;
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (isInteractive) {
+      this.render();
+      stdout.write(cursor.show);
+    } else {
+      this.tasks.forEach((task, taskId) => {
+        if (task.status !== "pending") {
+          this.renderNonInteractive(taskId, task);
+        }
+      });
+    }
+  }
+};
+
+// ../utils/src/log.ts
+function formatDuration(ms) {
+  const duration = ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(2)}s`;
+  return bold3(dim3(`[${duration}]`));
+}
+async function runStep(text, action, successText, options) {
+  const effectiveAction = action ?? (async () => void 0);
+  const hasAction = action !== void 0;
+  const indent = options?.indent ?? 0;
+  const spinner = new Spinner(["task"], [text], { indent });
+  if (!options?.silent) {
+    spinner.start();
+    spinner.updateTask("task", "running");
+  }
+  const startTime = performance.now();
+  try {
+    const result = await effectiveAction();
+    if (options?.silent) {
+      return result;
+    }
+    const duration = performance.now() - startTime;
+    let finalSuccessText;
+    if (typeof successText === "function") {
+      finalSuccessText = successText(result);
+    } else {
+      finalSuccessText = successText ?? text;
+    }
+    finalSuccessText = bold3(finalSuccessText);
+    if (hasAction) {
+      const durationText = formatDuration(duration);
+      finalSuccessText = `${finalSuccessText} ${durationText}`;
+    }
+    spinner.updateTask("task", "success", finalSuccessText);
+    spinner.stop();
+    return result;
+  } catch (error) {
+    if (!options?.silent) {
+      spinner.updateTask("task", "error");
+      spinner.stop();
+    }
+    console.error("");
+    if (error && typeof error === "object" && "exitCode" in error && typeof error.exitCode === "number") {
+      console.error(`  Exit Code: ${error.exitCode}`);
+      const stdout2 = error.stdout?.toString().trim();
+      const stderr = error.stderr?.toString().trim();
+      const indent2 = (str) => str.split("\n").map((line) => `    ${line}`).join("\n");
+      if (stdout2) console.error(`  Stdout:
+ ${indent2(stdout2)}`);
+      if (stderr) console.error(`  Stderr:
+ ${indent2(stderr)}`);
+    } else {
+      console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    console.error("");
+    throw error;
+  }
+}
+
+// ../utils/src/string.ts
+function pluralize(count, singular, plural) {
+  return count === 1 ? singular : plural || `${singular}s`;
+}
+
+// ../utils/src/pure/index.ts
+init_package_json();
+
+// ../utils/src/slug.ts
+function generateSlug(text) {
+  return text.toString().toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+
+// src/lib/init/run.ts
+init_file_loader();
+
+// ../utils/src/package-manager.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { join } from "path";
+function isCommandAvailable(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync2(join(cwd, "bun.lock")) || existsSync2(join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync2(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync2(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync2(join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return detectByCommandAvailability();
+}
+function detectByCommandAvailability() {
+  if (isCommandAvailable("bun")) {
+    return "bun";
+  }
+  if (isCommandAvailable("pnpm")) {
+    return "pnpm";
+  }
+  if (isCommandAvailable("yarn")) {
+    return "yarn";
+  }
+  return "npm";
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "bun":
+      return "bun install";
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn install";
+    case "npm":
+    default:
+      return "npm install";
+  }
+}
+function getRunCommand(pm, script) {
+  switch (pm) {
+    case "bun":
+      return `bun run ${script}`;
+    case "pnpm":
+      return `pnpm run ${script}`;
+    case "yarn":
+      return `yarn run ${script}`;
+    case "npm":
+    default:
+      return `npm run ${script}`;
+  }
+}
+function getAddDevDependencyCommand(pm, packageName) {
+  switch (pm) {
+    case "bun":
+      return `bun add -D ${packageName}`;
+    case "pnpm":
+      return `pnpm add -D ${packageName}`;
+    case "yarn":
+      return `yarn add -D ${packageName}`;
+    case "npm":
+    default:
+      return `npm install --save-dev ${packageName}`;
+  }
+}
+
+// src/constants/api.ts
+import { join as join3 } from "node:path";
+
+// src/constants/server.ts
+import { join as join2 } from "node:path";
+var SERVER_ROOT_DIRECTORY = "server";
+var SERVER_LIB_DIRECTORY = join2(SERVER_ROOT_DIRECTORY, "lib");
+
+// src/constants/api.ts
+var DEFAULT_API_ROUTES_DIRECTORY = join3(SERVER_ROOT_DIRECTORY, "api");
+var AUTH_API_SUBDIRECTORY = "auth";
+var SAMPLE_API_SUBDIRECTORY = "sample";
+var SAMPLE_CUSTOM_FILENAME = "custom.ts";
+var SAMPLE_DATABASE_FILENAME = "database.ts";
+var SAMPLE_KV_FILENAME = "kv.ts";
+var SAMPLE_BUCKET_FILENAME = "bucket.ts";
+
+// ../../package.json
+var package_default = {
+  name: "playcademy",
+  devDependencies: {
+    "@aws-sdk/client-s3": "^3.787.0",
+    "@eslint/js": "^9.24.0",
+    "@ianvs/prettier-plugin-sort-imports": "^4.4.2",
+    "@pulumi/pulumi": "^3.195.0",
+    "@types/bun": "latest",
+    commander: "^14.0.0",
+    eslint: "^9.24.0",
+    globals: "^16.0.0",
+    husky: "^9.1.7",
+    jscodeshift: "^17.3.0",
+    "lint-staged": "^15.5.1",
+    prettier: "3.5.3",
+    "prettier-plugin-svelte": "^3.3.3",
+    rimraf: "^6.0.1",
+    sharp: "^0.34.2",
+    typedoc: "^0.28.5",
+    "typedoc-plugin-markdown": "^4.7.0",
+    "typescript-eslint": "^8.30.1",
+    "yocto-spinner": "^0.2.2"
+  },
+  peerDependencies: {
+    typescript: "^5"
+  },
+  private: true,
+  scripts: {
+    build: "bun run scripts/build.ts",
+    "build:types": "bun tsc -b packages/data",
+    clean: "bun scripts/clean.ts && bun i",
+    "docs:commit": "bun scripts/docs-commit.ts",
+    dev: "bunx sst dev",
+    "dev:reset": "sst shell -- bun run scripts/dev-reset.ts",
+    "db:reseed": "sst shell -- bun run scripts/dev-reseed-db.ts",
+    "db:sync": "sst shell -- bun run scripts/dev-sync-db.ts",
+    "db:studio": "sst shell -- bun run --filter @playcademy/data studio",
+    "upload-games": "sst shell -- bun run scripts/upload-games.ts",
+    "upload-items": "sst shell -- bun run scripts/upload-items.ts",
+    "upload-sprites": "sst shell -- bun run scripts/upload-sprites.ts",
+    "upload-static-assets": "sst shell -- bun run scripts/upload-static-assets.ts",
+    "upload:all": "sst shell -- bun run scripts/upload-all.ts",
+    "sync-engine-assets": "bun scripts/sync-engine-assets.ts",
+    "sync-vite-templates": "bun scripts/sync-vite-templates.ts",
+    "sync-godot-template": "bun scripts/sync-godot-template.ts",
+    "sync:all": "bun scripts/sync-all.ts",
+    cf: "sst shell -- bun scripts/setup-cloudflare-dispatch.ts",
+    "list-s3-bucket": "sst shell -- bun scripts/list-s3-bucket.ts",
+    doctor: "bunx sst shell -- bun scripts/doctor.ts",
+    format: "bun run --filter '*' format",
+    lint: "bun run --filter '*' lint",
+    prepare: "husky",
+    sort: "bunx sort-package-json **/package.json",
+    test: "bun test",
+    "test:unit": "bun scripts/test-unit.ts",
+    "test:integration": "bun scripts/test-integration.ts",
+    "test:watch": "bun test --watch",
+    "docker:relay": "bun run scripts/docker-relay.ts",
+    "debug:leaderboard-notifications": "bunx sst shell -- bun scripts/debug/leaderboard-notifications.ts",
+    "timeback:caliper": "sst shell -- bun scripts/caliper-cli.ts",
+    notify: "NODE_ENV=productionbunx sst shell -- bun scripts/notifications-cli.ts"
+  },
+  type: "module",
+  workspaces: {
+    packages: [
+      "apps/*",
+      "packages/*",
+      "games/*",
+      "templates/*"
+    ],
+    catalog: {
+      sst: "^3.14.11",
+      dedent: "^1.6.0",
+      typescript: "^5.7.2",
+      vite: "^6.3.5",
+      eslint: "^9.24.0",
+      prettier: "3.5.3",
+      "@types/bun": "latest",
+      jose: "^5.2.3",
+      zod: "^3.25.53",
+      "better-auth": "1.3.33"
+    },
+    catalogs: {
+      svelte: {
+        svelte: "^5.23.1",
+        "@sveltejs/adapter-auto": "^6.0.0",
+        "@sveltejs/kit": "^2.16.0",
+        "@sveltejs/vite-plugin-svelte": "^5.0.3",
+        "svelte-check": "^4.2.1",
+        "prettier-plugin-svelte": "^3.3.3",
+        "eslint-plugin-svelte": "^3.0.0"
+      },
+      database: {
+        "drizzle-orm": "^0.42.0",
+        "drizzle-kit": "^0.31.0",
+        "drizzle-zod": "^0.7.1"
+      },
+      aws: {
+        "@aws-sdk/client-s3": "^3.787.0",
+        "@aws-sdk/s3-request-presigner": "^3.787.0"
+      },
+      linting: {
+        "typescript-eslint": "^8.30.1",
+        "@eslint/js": "^9.24.0",
+        "eslint-config-prettier": "^10.0.1"
+      }
+    }
+  }
+};
+
+// src/constants/auth.ts
+var BETTER_AUTH_VERSION = package_default.workspaces.catalog["better-auth"];
+var PLAYCADEMY_AUTH_VERSION = "latest";
+var AUTH_CONFIG_FILE = "auth.ts";
+
+// src/constants/config.ts
+var ENV_FILES = [
+  ".env",
+  // Loaded first
+  ".env.development",
+  // Overrides .env
+  ".env.local"
+  // Overrides all (highest priority)
+];
+var ENV_EXAMPLE_FILE = ".env.example";
+var TSCONFIG_JSON = "tsconfig.json";
+var TSCONFIG_APP_JSON = "tsconfig.app.json";
+var TSCONFIG_FILES = [
+  TSCONFIG_APP_JSON,
+  // Modern tooling (try first)
+  TSCONFIG_JSON
+  // Standard (fallback)
+];
+var TSCONFIG_REQUIRED_INCLUDES = [
+  "playcademy-env.d.ts",
+  // Generated type definitions
+  "server"
+  // Server-side code
+];
+
+// src/constants/bucket.ts
+var BUCKET_ALWAYS_SKIP = [".git", ".DS_Store", ".gitignore", ...ENV_FILES];
+
+// src/constants/database.ts
+import { join as join4 } from "path";
+var DEFAULT_DATABASE_DIRECTORY = join4("server", "db");
+var SCHEMA_SUBDIRECTORY = "schema";
+var DB_FILES = {
+  /** Index file name */
+  INDEX: "index.ts",
+  /** Seed file name */
+  SEED: "seed.ts",
+  /** Types file name */
+  TYPES: "types.ts",
+  /** Schema index file name */
+  SCHEMA_INDEX: "index.ts",
+  /** Example schema file name */
+  EXAMPLE_SCHEMA: "example.ts"
+};
+var DRIZZLE_CONFIG_FILES = ["drizzle.config.ts", "drizzle.config.js"];
+
+// src/constants/engine.ts
+var TEMPLATE_REPOS = {
+  VITE: "vitejs/vite/packages/create-vite",
+  SUPERBUILDERS: "superbuilders"
+};
+var DEFAULT_TEMPLATE_REF = "main";
+var GODOT_ADDON_URL = "https://enginetoolin-production-sharedengineassetsbucketbucket-odxfwvez.s3.us-east-1.amazonaws.com/godot/assets/playcademy.zip";
+var TEMPLATE_RENAME_FILES = {
+  _gitignore: ".gitignore",
+  _npmrc: ".npmrc",
+  _env: ".env"
+};
+
+// src/constants/godot.ts
+import { join as join5 } from "node:path";
+var GODOT_PROJECT_FILE = "project.godot";
+var GODOT_BUILD_DIRECTORIES = {
+  /** Root build directory (cleared before each export) */
+  ROOT: "build",
+  /** Web export subdirectory */
+  WEB: join5("build", "web")
+};
+var GODOT_BUILD_OUTPUTS = {
+  /** Exported web build entry point */
+  INDEX_HTML: join5("build", "web", "index.html"),
+  /** Packaged zip file (created by Godot export) */
+  ZIP: join5("build", "web_playcademy.zip")
+};
+
+// src/constants/paths.ts
+import { join as join6 } from "path";
+var WORKSPACE_NAME = ".playcademy";
+var CLI_DIRECTORIES = {
+  /** Root directory for CLI artifacts in workspace */
+  WORKSPACE: WORKSPACE_NAME,
+  /** Database directory within workspace */
+  DATABASE: join6(WORKSPACE_NAME, "db"),
+  /** KV storage directory within workspace */
+  KV: join6(WORKSPACE_NAME, "kv"),
+  /** Bucket storage directory within workspace */
+  BUCKET: join6(WORKSPACE_NAME, "bucket")
+};
+var CLI_DEFAULT_OUTPUTS = {
+  /** Default worker bundle output for debug command */
+  WORKER_BUNDLE: join6(WORKSPACE_NAME, "worker-bundle.js")
+};
+
+// src/constants/timeback.ts
+var CONFIG_FILE_NAMES = [
+  "playcademy.config.js",
+  "playcademy.config.json",
+  "playcademy.config.mjs"
+];
+
+// ../constants/src/overworld.ts
+var ITEM_SLUGS = {
+  /** Primary platform currency */
+  PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
+  /** Experience points currency */
+  PLAYCADEMY_XP: "PLAYCADEMY_XP",
+  /** Core platform badges */
+  FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
+  EARLY_ADOPTER_BADGE: "EARLY_ADOPTER_BADGE",
+  FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
+  /** Example items */
+  COMMON_SWORD: "COMMON_SWORD",
+  SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
+  SMALL_BACKPACK: "SMALL_BACKPACK",
+  /** Placeable items */
+  LAVA_LAMP: "LAVA_LAMP",
+  BOOMBOX: "BOOMBOX",
+  CABIN_BED: "CABIN_BED"
+};
+var CURRENCIES = {
+  /** Primary platform currency slug */
+  PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
+  /** Experience points slug */
+  XP: ITEM_SLUGS.PLAYCADEMY_XP
+};
+var BADGES = {
+  FOUNDING_MEMBER: ITEM_SLUGS.FOUNDING_MEMBER_BADGE,
+  EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
+  FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
+};
+
+// src/constants/urls.ts
+var DOCS_URL = "https://docs.dev.playcademy.net/platform";
+
+// src/lib/core/client.ts
+import { PlaycademyClient } from "@playcademy/sdk/internal";
+
+// src/lib/core/context.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+var context = {};
+var cache = {
+  packageManager: null
+};
+function setCliContext(ctx) {
+  context = { ...context, ...ctx };
+}
+function getWorkspace() {
+  return context.workspace || process.cwd();
+}
+function getPackageManager() {
+  if (cache.packageManager) return cache.packageManager;
+  cache.packageManager = detectPackageManager(getWorkspace());
+  return cache.packageManager;
+}
+function hasPackageJson(dir) {
+  return existsSync3(resolve2(dir || getWorkspace(), "package.json"));
+}
+
+// src/lib/core/gitignore.ts
+function normalizeGitignoreEntry(entry) {
+  return entry.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
+// src/lib/core/import.ts
+import * as esbuild from "esbuild";
+
+// src/lib/secrets/env.ts
+init_file_loader();
+import { existsSync as existsSync4, writeFileSync } from "fs";
+import { join as join7 } from "path";
+function parseEnvFile(contents) {
+  const secrets = {};
+  for (const line of contents.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      if (!key || !value) {
+        continue;
+      }
+      const unquoted = value.replace(/^["']|["']$/g, "");
+      secrets[key] = unquoted;
+    }
+  }
+  return secrets;
+}
+async function readEnvFile(workspace) {
+  let secrets = {};
+  for (const filename of ENV_FILES) {
+    try {
+      const contents = await loadFile(filename, { cwd: workspace, searchUp: false });
+      if (contents) {
+        const fileSecrets = parseEnvFile(contents);
+        secrets = { ...secrets, ...fileSecrets };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return secrets;
+}
+function getLoadedEnvFiles(workspace) {
+  return ENV_FILES.filter((filename) => existsSync4(join7(workspace, filename)));
+}
+function hasEnvFile(workspace) {
+  return ENV_FILES.some((filename) => existsSync4(join7(workspace, filename)));
+}
+async function updateEnvExample(workspace, lines) {
+  const envExamplePath = join7(workspace, ENV_EXAMPLE_FILE);
+  let existing = "";
+  if (existsSync4(envExamplePath)) {
+    const loaded = await loadFile(envExamplePath);
+    if (!loaded) {
+      throw new Error(`Failed to load ${ENV_EXAMPLE_FILE} file`);
+    }
+    existing = loaded;
+    const existingKeys = /* @__PURE__ */ new Set();
+    for (const line of existing.split("\n")) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+      if (match?.[1]) {
+        existingKeys.add(match[1]);
+      }
+    }
+    const linesToAdd = [];
+    for (const line of lines) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+      if (match?.[1]) {
+        if (!existingKeys.has(match[1])) {
+          linesToAdd.push(line);
+        }
+      } else {
+        linesToAdd.push(line);
+      }
+    }
+    if (linesToAdd.every((line) => !line.match(/^([A-Z_][A-Z0-9_]*)=/))) {
+      return;
+    }
+    const content = linesToAdd.join("\n");
+    writeFileSync(envExamplePath, existing + "\n" + content + "\n");
+  } else {
+    const content = lines.join("\n");
+    writeFileSync(envExamplePath, content + "\n");
+  }
+}
+
+// src/lib/config/loader.ts
+init_file_loader();
+import { dirname as dirname2, resolve as resolve3 } from "path";
+var ConfigError = class extends Error {
+  constructor(message, field, suggestion) {
+    super(message);
+    this.field = field;
+    this.suggestion = suggestion;
+    this.name = "ConfigError";
+  }
+  /**
+   * Format a user-friendly error message with the field and suggestion
+   */
+  toString() {
+    let msg = `Configuration Error: ${this.message}`;
+    if (this.field) {
+      msg += `
+  Field: ${this.field}`;
+    }
+    if (this.suggestion) {
+      msg += `
+  Suggestion: ${this.suggestion}`;
+    }
+    return msg;
+  }
+};
+async function findConfigPath(configPath) {
+  const { findFile: findFile2 } = await Promise.resolve().then(() => (init_file_loader(), file_loader_exports));
+  if (configPath) {
+    const fullPath = resolve3(configPath);
+    const result2 = await findFile2(fullPath, { cwd: dirname2(fullPath), searchUp: false });
+    if (!result2) {
+      throw new ConfigError(
+        `Config file not found: ${fullPath}`,
+        void 0,
+        "Check the path is correct and the file exists"
+      );
+    }
+    return result2.path;
+  }
+  const envPath = process.env.PLAYCADEMY_CONFIG_PATH;
+  if (envPath) {
+    const candidate = resolve3(envPath);
+    const result2 = await findFile2(candidate, { cwd: dirname2(candidate) });
+    if (!result2) {
+      throw new ConfigError(
+        `Config file not found: ${candidate}`,
+        "PLAYCADEMY_CONFIG_PATH",
+        "Check that the environment variable points to a valid config file"
+      );
+    }
+    return result2.path;
+  }
+  const result = await findFile2(CONFIG_FILE_NAMES, { searchUp: true, maxLevels: 3 });
+  if (!result) {
+    throw new ConfigError(
+      "No Playcademy config file found in this directory or any parent directory",
+      void 0,
+      `Run 'playcademy init' to create a config file, or manually create one of: ${CONFIG_FILE_NAMES.join(", ")}`
+    );
+  }
+  return result.path;
+}
+async function loadConfigFile(path2) {
+  if (path2.endsWith(".json")) {
+    return await loadFile(path2, { required: true, parseJson: true });
+  }
+  const module = await import(`${path2}?t=${Date.now()}`);
+  return module.default || module;
+}
+async function loadConfig(configPath) {
+  const result = await loadConfigWithPath(configPath);
+  return result.config;
+}
+async function loadConfigWithPath(configPath) {
+  try {
+    const actualPath = configPath ? resolve3(configPath) : await findConfigPath();
+    const config = await loadConfigFile(actualPath);
+    if (!config || typeof config !== "object") {
+      throw new ConfigError(
+        "Config file must export or contain a valid configuration object",
+        void 0,
+        actualPath?.endsWith(".json") ? "Check that your JSON file contains a valid object" : 'Make sure your .js file has: export default { name: "...", ... }'
+      );
+    }
+    validateConfig(config);
+    return {
+      config: processConfigVariables(config),
+      configPath: actualPath,
+      configDir: dirname2(actualPath)
+    };
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw error;
+    }
+    const errorMsg = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
+    throw new ConfigError(
+      `Failed to load config file`,
+      void 0,
+      `Check your config file syntax. Error details: ${errorMsg}`
+    );
+  }
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new ConfigError("Configuration must be an object");
+  }
+  const cfg = config;
+  if (!cfg.name || typeof cfg.name !== "string") {
+    throw new ConfigError(
+      'Your config file is missing a "name" field',
+      "name",
+      'Add a name property to your config: name: "My App Name"'
+    );
+  }
+  if (cfg.integrations) {
+    if (typeof cfg.integrations !== "object") {
+      throw new ConfigError(
+        'The "integrations" field must be an object',
+        "integrations",
+        "Change integrations to an object: integrations: { timeback: { ... } }"
+      );
+    }
+    const integrations = cfg.integrations;
+    if (integrations.timeback) {
+      if (typeof integrations.timeback !== "object") {
+        throw new ConfigError(
+          'The "integrations.timeback" field must be an object',
+          "integrations.timeback",
+          "Change timeback to an object: timeback: { course: { ... } }"
+        );
+      }
+      const tb = integrations.timeback;
+      if (!tb.courses) {
+        throw new ConfigError(
+          'TimeBack integration requires a "courses" array',
+          "integrations.timeback.courses",
+          'Add timeback.courses array: timeback: { courses: [{ subject: "Math", grade: 3 }] }'
+        );
+      }
+      if (!Array.isArray(tb.courses)) {
+        throw new ConfigError(
+          'The "integrations.timeback.courses" field must be an array',
+          "integrations.timeback.courses",
+          'Change to an array: courses: [{ subject: "Math", grade: 3 }]'
+        );
+      }
+      if (tb.courses.length === 0) {
+        throw new ConfigError(
+          "TimeBack courses array cannot be empty",
+          "integrations.timeback.courses",
+          'Add at least one course: courses: [{ subject: "Math", grade: 3 }]'
+        );
+      }
+      tb.courses.forEach((course, idx) => {
+        if (typeof course !== "object" || course === null) {
+          throw new ConfigError(
+            `Course at index ${idx} must be an object`,
+            `integrations.timeback.courses[${idx}]`,
+            'Each course must have subject and grade: { subject: "Math", grade: 3 }'
+          );
+        }
+        const courseObj = course;
+        if (typeof courseObj.subject !== "string") {
+          throw new ConfigError(
+            `Course at index ${idx} is missing required "subject" field`,
+            `integrations.timeback.courses[${idx}].subject`,
+            'Add subject string: { subject: "Math", grade: 3 }'
+          );
+        }
+        if (typeof courseObj.grade !== "number") {
+          throw new ConfigError(
+            `Course at index ${idx} is missing required "grade" field`,
+            `integrations.timeback.courses[${idx}].grade`,
+            'Add grade number: { subject: "Math", grade: 3 }'
+          );
+        }
+        const stringOverrides = ["title", "courseCode", "level", "gradingScheme"];
+        stringOverrides.forEach((field) => {
+          if (courseObj[field] !== void 0 && typeof courseObj[field] !== "string") {
+            throw new ConfigError(
+              `Course at index ${idx} has invalid "${field}" field (must be a string)`,
+              `integrations.timeback.courses[${idx}].${field}`,
+              `${field} must be a string if provided`
+            );
+          }
+        });
+        if (courseObj.metadata !== void 0 && typeof courseObj.metadata !== "object") {
+          throw new ConfigError(
+            `Course at index ${idx} has invalid "metadata" field (must be an object)`,
+            `integrations.timeback.courses[${idx}].metadata`,
+            "metadata must be an object if provided"
+          );
+        }
+      });
+      if (tb.base) {
+        if (typeof tb.base !== "object") {
+          throw new ConfigError(
+            'The "integrations.timeback.base" field must be an object',
+            "integrations.timeback.base",
+            "Change to an object: base: { organization: { ... }, course: { ... } }"
+          );
+        }
+        const base = tb.base;
+        if (base.organization) {
+          if (typeof base.organization !== "object") {
+            throw new ConfigError(
+              'The "integrations.timeback.base.organization" field must be an object',
+              "integrations.timeback.base.organization",
+              'Change to an object: organization: { name: "My School", type: "school" }'
+            );
+          }
+          const org = base.organization;
+          if (org.type) {
+            const validOrgTypes = [
+              "department",
+              "school",
+              "district",
+              "local",
+              "state",
+              "national"
+            ];
+            if (!validOrgTypes.includes(org.type)) {
+              throw new ConfigError(
+                `Invalid organization type: "${org.type}"`,
+                "integrations.timeback.base.organization.type",
+                `Use one of: ${validOrgTypes.join(", ")}. Example: type: "school"`
+              );
+            }
+          }
+        }
+        const baseSections = ["course", "component", "resource", "componentResource"];
+        baseSections.forEach((section) => {
+          if (base[section] !== void 0 && typeof base[section] !== "object") {
+            throw new ConfigError(
+              `The "integrations.timeback.base.${section}" field must be an object`,
+              `integrations.timeback.base.${section}`,
+              `Change to an object: ${section}: { ... }`
+            );
+          }
+        });
+      }
+    }
+  }
+}
+function processConfigVariables(config) {
+  const processed = JSON.parse(JSON.stringify(config));
+  const processValue = (value) => {
+    if (typeof value === "string") {
+      return value.replace(/\$\{([^}]+)\}/g, (_, varName) => process.env[varName] || "").replace(/process\.env\.([A-Z_]+)/g, (_, varName) => process.env[varName] || "");
+    }
+    if (Array.isArray(value)) {
+      return value.map(processValue);
+    }
+    if (value && typeof value === "object") {
+      const obj = value;
+      const result = {};
+      for (const [key, val] of Object.entries(obj)) {
+        result[key] = processValue(val);
+      }
+      return result;
+    }
+    return value;
+  };
+  return processValue(processed);
+}
+
+// ../timeback/dist/constants.js
+var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var init_auth = () => {
+};
+var PLAYCADEMY_BASE_URLS2;
+var init_domains = __esm2(() => {
+  PLAYCADEMY_BASE_URLS2 = {
+    production: "https://hub.playcademy.net",
+    staging: "https://hub.dev.playcademy.net"
+  };
+});
+var init_env_vars = () => {
+};
+var ITEM_SLUGS2;
+var CURRENCIES2;
+var BADGES2;
+var init_overworld = __esm2(() => {
+  ITEM_SLUGS2 = {
+    PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
+    PLAYCADEMY_XP: "PLAYCADEMY_XP",
+    FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
+    EARLY_ADOPTER_BADGE: "EARLY_ADOPTER_BADGE",
+    FIRST_GAME_BADGE: "FIRST_GAME_BADGE",
+    COMMON_SWORD: "COMMON_SWORD",
+    SMALL_HEALTH_POTION: "SMALL_HEALTH_POTION",
+    SMALL_BACKPACK: "SMALL_BACKPACK",
+    LAVA_LAMP: "LAVA_LAMP",
+    BOOMBOX: "BOOMBOX",
+    CABIN_BED: "CABIN_BED"
+  };
+  CURRENCIES2 = {
+    PRIMARY: ITEM_SLUGS2.PLAYCADEMY_CREDITS,
+    XP: ITEM_SLUGS2.PLAYCADEMY_XP
+  };
+  BADGES2 = {
+    FOUNDING_MEMBER: ITEM_SLUGS2.FOUNDING_MEMBER_BADGE,
+    EARLY_ADOPTER: ITEM_SLUGS2.EARLY_ADOPTER_BADGE,
+    FIRST_GAME: ITEM_SLUGS2.FIRST_GAME_BADGE
+  };
+});
+var TIMEBACK_ORG_SOURCED_ID = "PLAYCADEMY";
+var TIMEBACK_ORG_NAME = "Playcademy Studios";
+var TIMEBACK_ORG_TYPE = "department";
+var TIMEBACK_COURSE_DEFAULTS;
+var TIMEBACK_RESOURCE_DEFAULTS;
+var TIMEBACK_COMPONENT_DEFAULTS;
+var TIMEBACK_COMPONENT_RESOURCE_DEFAULTS;
+var init_timeback = __esm2(() => {
+  TIMEBACK_COURSE_DEFAULTS = {
+    gradingScheme: "STANDARD",
+    level: {
+      elementary: "Elementary",
+      middle: "Middle",
+      high: "High",
+      ap: "AP"
+    },
+    goals: {
+      dailyXp: 50,
+      dailyLessons: 3
+    },
+    metrics: {
+      totalXp: 1e3,
+      totalLessons: 50
+    }
+  };
+  TIMEBACK_RESOURCE_DEFAULTS = {
+    vendorId: "playcademy",
+    roles: ["primary"],
+    importance: "primary",
+    metadata: {
+      type: "interactive",
+      toolProvider: "Playcademy",
+      instructionalMethod: "exploratory",
+      language: "en-US"
+    }
+  };
+  TIMEBACK_COMPONENT_DEFAULTS = {
+    sortOrder: 1,
+    prerequisiteCriteria: "ALL"
+  };
+  TIMEBACK_COMPONENT_RESOURCE_DEFAULTS = {
+    sortOrder: 1,
+    lessonType: "quiz"
+  };
+});
+var init_workers = () => {
+};
+var init_src = __esm2(() => {
+  init_auth();
+  init_domains();
+  init_env_vars();
+  init_overworld();
+  init_timeback();
+  init_workers();
+});
+var TIMEBACK_API_URLS;
+var TIMEBACK_AUTH_URLS;
+var CALIPER_API_URLS;
+var ONEROSTER_ENDPOINTS;
+var CALIPER_ENDPOINTS;
+var CALIPER_CONSTANTS;
+var TIMEBACK_EVENT_TYPES;
+var TIMEBACK_ACTIONS;
+var TIMEBACK_TYPES;
+var ACTIVITY_METRIC_TYPES;
+var TIME_METRIC_TYPES;
+var TIMEBACK_SUBJECTS;
+var TIMEBACK_GRADE_LEVELS;
+var TIMEBACK_GRADE_LEVEL_LABELS;
+var CALIPER_SUBJECTS;
+var ONEROSTER_STATUS;
+var SCORE_STATUS;
+var ENV_VARS;
+var HTTP_DEFAULTS;
+var AUTH_DEFAULTS;
+var CACHE_DEFAULTS;
+var CONFIG_DEFAULTS;
+var PLAYCADEMY_DEFAULTS;
+var RESOURCE_DEFAULTS;
+var HTTP_STATUS;
+var ERROR_NAMES;
+var init_constants = __esm2(() => {
+  init_src();
+  TIMEBACK_API_URLS = {
+    production: "https://api.alpha-1edtech.ai",
+    staging: "https://api.staging.alpha-1edtech.com"
+  };
+  TIMEBACK_AUTH_URLS = {
+    production: "https://prod-beyond-timeback-api-2-idp.auth.us-east-1.amazoncognito.com",
+    staging: "https://alpha-auth-development-idp.auth.us-west-2.amazoncognito.com"
+  };
+  CALIPER_API_URLS = {
+    production: "https://caliper.alpha-1edtech.ai",
+    staging: "https://caliper-staging.alpha-1edtech.com"
+  };
+  ONEROSTER_ENDPOINTS = {
+    organizations: "/ims/oneroster/rostering/v1p2/orgs",
+    courses: "/ims/oneroster/rostering/v1p2/courses",
+    courseComponents: "/ims/oneroster/rostering/v1p2/courses/components",
+    resources: "/ims/oneroster/resources/v1p2/resources",
+    componentResources: "/ims/oneroster/rostering/v1p2/courses/component-resources",
+    classes: "/ims/oneroster/rostering/v1p2/classes",
+    enrollments: "/ims/oneroster/rostering/v1p2/enrollments",
+    assessmentLineItems: "/ims/oneroster/gradebook/v1p2/assessmentLineItems",
+    assessmentResults: "/ims/oneroster/gradebook/v1p2/assessmentResults",
+    users: "/ims/oneroster/rostering/v1p2/users"
+  };
+  CALIPER_ENDPOINTS = {
+    events: "/caliper/event",
+    validate: "/caliper/event/validate"
+  };
+  CALIPER_CONSTANTS = {
+    context: "http://purl.imsglobal.org/ctx/caliper/v1p2",
+    profile: "TimebackProfile",
+    dataVersion: "http://purl.imsglobal.org/ctx/caliper/v1p2"
+  };
+  TIMEBACK_EVENT_TYPES = {
+    activityEvent: "ActivityEvent",
+    timeSpentEvent: "TimeSpentEvent"
+  };
+  TIMEBACK_ACTIONS = {
+    completed: "Completed",
+    spentTime: "SpentTime"
+  };
+  TIMEBACK_TYPES = {
+    user: "TimebackUser",
+    activityContext: "TimebackActivityContext",
+    activityMetricsCollection: "TimebackActivityMetricsCollection",
+    timeSpentMetricsCollection: "TimebackTimeSpentMetricsCollection"
+  };
+  ACTIVITY_METRIC_TYPES = {
+    totalQuestions: "totalQuestions",
+    correctQuestions: "correctQuestions",
+    xpEarned: "xpEarned",
+    masteredUnits: "masteredUnits"
+  };
+  TIME_METRIC_TYPES = {
+    active: "active",
+    inactive: "inactive",
+    waste: "waste",
+    unknown: "unknown",
+    antiPattern: "anti-pattern"
+  };
+  TIMEBACK_SUBJECTS = [
+    "Math",
+    "FastMath",
+    "Science",
+    "Social Studies",
+    "Language",
+    "Reading",
+    "Vocabulary",
+    "Writing"
+  ];
+  TIMEBACK_GRADE_LEVELS = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
+  TIMEBACK_GRADE_LEVEL_LABELS = {
+    "-1": "pre-k",
+    "0": "kindergarten",
+    "1": "1st grade",
+    "2": "2nd grade",
+    "3": "3rd grade",
+    "4": "4th grade",
+    "5": "5th grade",
+    "6": "6th grade",
+    "7": "7th grade",
+    "8": "8th grade",
+    "9": "9th grade",
+    "10": "10th grade",
+    "11": "11th grade",
+    "12": "12th grade",
+    "13": "AP"
+  };
+  CALIPER_SUBJECTS = {
+    Reading: "Reading",
+    Language: "Language",
+    Vocabulary: "Vocabulary",
+    SocialStudies: "Social Studies",
+    Writing: "Writing",
+    Science: "Science",
+    FastMath: "FastMath",
+    Math: "Math",
+    None: "None"
+  };
+  ONEROSTER_STATUS = {
+    active: "active",
+    toBeDeleted: "tobedeleted"
+  };
+  SCORE_STATUS = {
+    exempt: "exempt",
+    fullyGraded: "fully graded",
+    notSubmitted: "not submitted",
+    partiallyGraded: "partially graded",
+    submitted: "submitted"
+  };
+  ENV_VARS = {
+    clientId: "TIMEBACK_CLIENT_ID",
+    clientSecret: "TIMEBACK_CLIENT_SECRET",
+    baseUrl: "TIMEBACK_BASE_URL",
+    environment: "TIMEBACK_ENVIRONMENT",
+    vendorResourceId: "TIMEBACK_VENDOR_RESOURCE_ID",
+    launchBaseUrl: "GAME_URL"
+  };
+  HTTP_DEFAULTS = {
+    timeout: 3e4,
+    retries: 3,
+    retryBackoffBase: 2
+  };
+  AUTH_DEFAULTS = {
+    tokenCacheDuration: 5e4
+  };
+  CACHE_DEFAULTS = {
+    defaultTTL: 10 * 60 * 1e3,
+    defaultMaxSize: 500,
+    defaultName: "TimebackCache",
+    studentTTL: 10 * 60 * 1e3,
+    studentMaxSize: 500,
+    assessmentTTL: 30 * 60 * 1e3,
+    assessmentMaxSize: 200,
+    enrollmentTTL: 5 * 1e3,
+    enrollmentMaxSize: 100
+  };
+  CONFIG_DEFAULTS = {
+    fileNames: ["timeback.config.js", "timeback.config.json"]
+  };
+  PLAYCADEMY_DEFAULTS = {
+    organization: TIMEBACK_ORG_SOURCED_ID,
+    launchBaseUrls: PLAYCADEMY_BASE_URLS2
+  };
+  RESOURCE_DEFAULTS = {
+    organization: {
+      name: TIMEBACK_ORG_NAME,
+      type: TIMEBACK_ORG_TYPE
+    },
+    course: {
+      gradingScheme: TIMEBACK_COURSE_DEFAULTS.gradingScheme,
+      level: TIMEBACK_COURSE_DEFAULTS.level,
+      metadata: {
+        goals: TIMEBACK_COURSE_DEFAULTS.goals,
+        metrics: TIMEBACK_COURSE_DEFAULTS.metrics
+      }
+    },
+    component: TIMEBACK_COMPONENT_DEFAULTS,
+    resource: TIMEBACK_RESOURCE_DEFAULTS,
+    componentResource: TIMEBACK_COMPONENT_RESOURCE_DEFAULTS
+  };
+  HTTP_STATUS = {
+    CLIENT_ERROR_MIN: 400,
+    CLIENT_ERROR_MAX: 500,
+    SERVER_ERROR_MIN: 500
+  };
+  ERROR_NAMES = {
+    timebackAuth: "TimebackAuthError",
+    timebackApi: "TimebackApiError",
+    timebackConfig: "TimebackConfigError",
+    timebackSdk: "TimebackSDKError"
+  };
+});
+init_constants();
+
+// src/lib/templates/loader.ts
+import { existsSync as existsSync5, readFileSync } from "fs";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+import { fileURLToPath } from "url";
+var currentDir = dirname3(fileURLToPath(import.meta.url));
+function loadTemplateString(filename) {
+  const filenamesToTry = filename.endsWith(".template") ? [filename] : [filename, `${filename}.template`];
+  const candidatePaths = filenamesToTry.flatMap((name) => [
+    // Dev (TS sources): ../../templates from src/lib/templates
+    resolve4(currentDir, "../../templates", name),
+    // Bundled build (single-file output): templates relative to dist root
+    resolve4(currentDir, "templates", name)
+  ]);
+  for (const candidate of candidatePaths) {
+    if (existsSync5(candidate)) {
+      return readFileSync(candidate, "utf-8");
+    }
+  }
+  throw new Error(`Template not found: ${filename}. Searched: ${candidatePaths.join(", ")}`);
+}
+
+// src/lib/config/generator.ts
+function loadTemplate(filename) {
+  return loadTemplateString(`config/${filename}`);
+}
+function generateJsConfig(options) {
+  const {
+    name,
+    description,
+    emoji,
+    customRoutesDirectory,
+    databaseDirectory,
+    auth,
+    kv,
+    bucket,
+    timebackCourses
+  } = options;
+  let template = loadTemplate("playcademy.config.js.template");
+  template = template.replace("{{APP_NAME}}", name);
+  const descriptionLine = description ? `
+    description: '${description}',` : "";
+  template = template.replace("{{APP_DESCRIPTION}}", descriptionLine);
+  const emojiLine = emoji ? `
+    emoji: '${emoji}',` : "";
+  template = template.replace("{{APP_EMOJI}}", emojiLine);
+  const integrationsParts = [];
+  if (customRoutesDirectory) {
+    integrationsParts.push(`        customRoutes: { directory: '${customRoutesDirectory}' }`);
+  }
+  if (databaseDirectory) {
+    integrationsParts.push(`        database: { directory: '${databaseDirectory}' }`);
+  }
+  if (auth) {
+    integrationsParts.push(`        auth: true`);
+  }
+  if (kv) {
+    integrationsParts.push(`        kv: true`);
+  }
+  if (bucket) {
+    integrationsParts.push(`        bucket: true`);
+  }
+  if (timebackCourses && timebackCourses.length > 0) {
+    let coursesJson = JSON.stringify(timebackCourses, null, 12).split("\n").map((line) => `        ${line}`).join("\n").trim();
+    coursesJson = coursesJson.replace(
+      /"totalXp": null(,?)/g,
+      '"totalXp": null$1 // TODO: Set total XP before running `playcademy timeback setup`'
+    );
+    coursesJson = coursesJson.replace(
+      /"masterableUnits": null(,?)/g,
+      '"masterableUnits": null$1 // TODO: Set masterable units before running `playcademy timeback setup`'
+    );
+    const timebackBlock = `        timeback: {
+            courses: ${coursesJson}
+        }`;
+    integrationsParts.push(timebackBlock);
+  }
+  if (integrationsParts.length > 0) {
+    const integrationsContent = integrationsParts.join(",\n");
+    let integrationsTemplate = loadTemplate("integrations-config.js.template");
+    integrationsTemplate = integrationsTemplate.replace(
+      "{{INTEGRATIONS_CONTENT}}",
+      integrationsContent
+    );
+    template = template.replace("{{INTEGRATIONS_CONFIG}}", integrationsTemplate);
+  } else {
+    template = template.replace("{{INTEGRATIONS_CONFIG}}", "");
+  }
+  return template;
+}
+function generateJsonConfig(options) {
+  const {
+    name,
+    description,
+    emoji,
+    customRoutesDirectory,
+    databaseDirectory,
+    auth,
+    kv,
+    bucket,
+    timebackCourses
+  } = options;
+  let template = loadTemplate("playcademy.config.json.template");
+  template = template.replace("{{APP_NAME}}", name);
+  const descriptionLine = description ? `,
+    "description": "${description}"` : "";
+  template = template.replace("{{APP_DESCRIPTION}}", descriptionLine);
+  const emojiLine = emoji ? `,
+    "emoji": "${emoji}"` : "";
+  template = template.replace("{{APP_EMOJI}}", emojiLine);
+  const integrationsConfig = {};
+  if (customRoutesDirectory) {
+    integrationsConfig.customRoutes = { directory: customRoutesDirectory };
+  }
+  if (databaseDirectory) {
+    integrationsConfig.database = { directory: databaseDirectory };
+  }
+  if (auth) {
+    integrationsConfig.auth = true;
+  }
+  if (kv) {
+    integrationsConfig.kv = true;
+  }
+  if (bucket) {
+    integrationsConfig.bucket = true;
+  }
+  if (timebackCourses && timebackCourses.length > 0) {
+    integrationsConfig.timeback = {
+      courses: timebackCourses
+    };
+  }
+  if (Object.keys(integrationsConfig).length > 0) {
+    const integrationsJson = JSON.stringify(integrationsConfig, null, 4).split("\n").join("\n    ");
+    template = template.replace(
+      "{{INTEGRATIONS_CONFIG}}",
+      `,
+    "integrations": ${integrationsJson}`
+    );
+  } else {
+    template = template.replace("{{INTEGRATIONS_CONFIG}}", "");
+  }
+  return template;
+}
+
+// src/lib/config/writer.ts
+import { execSync as execSync2 } from "child_process";
+async function formatConfigWithPrettier(configPath) {
+  try {
+    const pm = getPackageManager();
+    const execCommand = pm === "bun" ? "bunx" : "npx";
+    execSync2(`${execCommand} prettier --write ${configPath}`, {
+      stdio: "ignore",
+      // Silent
+      timeout: 5e3
+      // Don't hang
+    });
+  } catch {
+  }
+}
+
+// src/lib/init/display.ts
+function displaySuccessMessage(context2) {
+  logger.newLine();
+  const nextSteps = [];
+  const pm = getPackageManager();
+  const isVite = context2.engineType === "vite";
+  const isGodot = context2.engineType === "godot";
+  nextSteps.push(`1. Review your config file: <${context2.configFileName}>`);
+  if (context2.hasDatabase) {
+    nextSteps.push(`3. Review schema: <db/schema/index.ts>`);
+    nextSteps.push("4. Start dev server: `playcademy dev`");
+    nextSteps.push(`5. Push your schema: \`${getRunCommand(pm, "db:push")}\``);
+  }
+  if (context2.hasAuth) {
+    const stepNum = context2.hasDatabase ? "6" : "2";
+    nextSteps.push(`${stepNum}. Review auth config: <server/lib/auth.ts>`);
+  }
+  if (isVite) {
+    const buildExample = getRunCommand(pm, "build");
+    const buildStepNum = nextSteps.length + 1;
+    nextSteps.push(`${buildStepNum}. Build your app: \`${buildExample}\``);
+  }
+  if (isGodot) {
+    const stepNum = nextSteps.length + 1;
+    nextSteps.push(`${stepNum}. Open in Godot Editor`);
+  }
+  if (context2.apiDirectory) {
+    const stepNum = nextSteps.length + 1;
+    nextSteps.push(`${stepNum}. Customize API routes: <${context2.apiDirectory}>`);
+  }
+  if (context2.timebackConfig) {
+    const stepNum = nextSteps.length + 1;
+    nextSteps.push(`${stepNum}. Set up TimeBack: \`playcademy timeback setup\``);
+  }
+  const deployStep = nextSteps.length + 1;
+  nextSteps.push(`${deployStep}. Deploy: \`playcademy deploy\``);
+  nextSteps.push("");
+  nextSteps.push(`Learn more: <<${DOCS_URL}>>`);
+  logger.admonition("tip", "Next Steps", nextSteps);
+  logger.newLine();
+}
+
+// src/lib/init/engine/fetch.ts
+import { readdirSync as readdirSync2, renameSync } from "fs";
+import { join as join8 } from "path";
+import { downloadTemplate } from "giget";
+function renameSpecialFiles(destDir) {
+  const files = readdirSync2(destDir, { withFileTypes: true });
+  for (const file of files) {
+    const newName = TEMPLATE_RENAME_FILES[file.name];
+    if (newName) {
+      const oldPath = join8(destDir, file.name);
+      const newPath = join8(destDir, newName);
+      renameSync(oldPath, newPath);
+    }
+    if (file.isDirectory()) {
+      renameSpecialFiles(join8(destDir, file.name));
+    }
+  }
+}
+async function fetchTemplate(template, destDir) {
+  const { source } = template;
+  const ref = source.ref || DEFAULT_TEMPLATE_REF;
+  const templateSource = `github:${source.location}#${ref}`;
+  try {
+    await downloadTemplate(templateSource, {
+      dir: destDir,
+      force: true,
+      forceClean: false
+    });
+    renameSpecialFiles(destDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to fetch template from GitHub: ${message}
+Source: ${templateSource}`
+    );
+  }
+}
+
+// src/lib/init/engine/prompts.ts
+import { select } from "@inquirer/prompts";
+import { cyan as cyan3, magenta as magenta2, yellow as yellow3 } from "colorette";
+
+// src/lib/init/engine/registry.ts
+import { blue as blue2, cyan as cyan2, green as green2, magenta, red as red2, yellow as yellow2 } from "colorette";
+
+// src/lib/init/engine/hooks.ts
+import { existsSync as existsSync6, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { rename, rm } from "fs/promises";
+import { dirname as dirname4, join as join9 } from "path";
+import JSZip from "jszip";
+var godotAfterFetch = async ({ destDir }) => {
+  const addonsDir = join9(destDir, "addons");
+  const targetDir = join9(addonsDir, "playcademy");
+  let zipData;
+  await runStep(
+    "Downloading Playcademy Addon for Godot",
+    async () => {
+      const response = await fetch(GODOT_ADDON_URL);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to download addon: ${response.status} ${response.statusText}`
+        );
+      }
+      zipData = await response.arrayBuffer();
+    },
+    "Playcademy Addon downloaded",
+    { silent: true }
+  );
+  await runStep(
+    "Extracting Playcademy Addon",
+    async () => {
+      const zip = await JSZip.loadAsync(zipData);
+      if (!existsSync6(addonsDir)) {
+        mkdirSync(addonsDir, { recursive: true });
+      }
+      const extractPromises = [];
+      zip.forEach((relativePath, file) => {
+        if (file.dir) return;
+        const extractPath = join9(destDir, relativePath);
+        extractPromises.push(
+          file.async("nodebuffer").then((content) => {
+            const dir = dirname4(extractPath);
+            if (!existsSync6(dir)) {
+              mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync2(extractPath, content);
+          })
+        );
+      });
+      await Promise.all(extractPromises);
+      const extractedRoot = join9(destDir, "playcademy", "addons", "playcademy");
+      if (existsSync6(extractedRoot)) {
+        if (existsSync6(targetDir)) {
+          await rm(targetDir, { recursive: true, force: true });
+        }
+        await rename(extractedRoot, targetDir);
+        const extractedParent = join9(destDir, "playcademy");
+        await rm(extractedParent, { recursive: true, force: true });
+      }
+    },
+    "Playcademy Addon extracted",
+    { silent: true }
+  );
+};
+
+// src/lib/init/engine/registry.ts
+var viteFrameworks = [
+  {
+    id: "vanilla",
+    display: "Vanilla",
+    color: yellow2,
+    templates: [
+      {
+        id: "vanilla-ts",
+        display: "TypeScript",
+        color: blue2,
+        description: "Vanilla TypeScript starter",
+        source: { location: `${TEMPLATE_REPOS.VITE}/template-vanilla-ts` }
+      }
+    ]
+  },
+  {
+    id: "react",
+    display: "React",
+    color: cyan2,
+    templates: [
+      {
+        id: "react-ts",
+        display: "TypeScript",
+        color: blue2,
+        description: "React with TypeScript",
+        source: { location: `${TEMPLATE_REPOS.VITE}/template-react-ts` }
+      }
+    ]
+  },
+  {
+    id: "vue",
+    display: "Vue",
+    color: green2,
+    templates: [
+      {
+        id: "vue-ts",
+        display: "TypeScript",
+        color: blue2,
+        description: "Vue 3 with TypeScript",
+        source: { location: `${TEMPLATE_REPOS.VITE}/template-vue-ts` }
+      }
+    ]
+  },
+  {
+    id: "svelte",
+    display: "Svelte",
+    color: red2,
+    templates: [
+      {
+        id: "svelte-ts",
+        display: "TypeScript",
+        color: blue2,
+        description: "Svelte with TypeScript",
+        source: { location: `${TEMPLATE_REPOS.VITE}/template-svelte-ts` }
+      }
+    ]
+  }
+];
+var godotFrameworks = [
+  {
+    id: "godot",
+    display: "Godot 4",
+    color: magenta,
+    templates: [
+      {
+        id: "godot-4",
+        display: "Godot 4 with Playcademy SDK",
+        color: magenta,
+        description: "Godot 4 with Playcademy addon",
+        source: { location: `${TEMPLATE_REPOS.SUPERBUILDERS}/godot-template` },
+        afterFetch: godotAfterFetch
+      }
+    ]
+  }
+];
+var engines = {
+  vite: { type: "vite", frameworks: viteFrameworks },
+  godot: { type: "godot", frameworks: godotFrameworks }
+};
+
+// src/lib/init/engine/prompts.ts
+async function promptForEngine() {
+  return select({
+    message: "Select a project type:",
+    choices: [
+      {
+        value: "vite",
+        name: `${cyan3("Vite")}`
+      },
+      {
+        value: "godot",
+        name: `${magenta2("Godot")}`
+      },
+      {
+        value: "none",
+        name: `${yellow3("None")}`
+      }
+    ]
+  });
+}
+async function promptForFramework(engine) {
+  const config = engines[engine];
+  if (!config || config.frameworks.length === 0) {
+    return null;
+  }
+  if (config.frameworks.length === 1) {
+    return config.frameworks[0];
+  }
+  return select({
+    message: "Select a framework:",
+    choices: config.frameworks.map((fw) => ({
+      value: fw,
+      name: fw.color(fw.display)
+    }))
+  });
+}
+async function promptForTemplate(framework) {
+  if (framework.templates.length === 1) {
+    return framework.templates[0];
+  }
+  return select({
+    message: "Select a variant:",
+    choices: framework.templates.map((t) => ({
+      value: t,
+      name: t.color(t.display)
+    }))
+  });
+}
+
+// src/lib/deploy/godot.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync } from "fs";
+import { join as join10 } from "path";
+import { confirm, select as select2 } from "@inquirer/prompts";
+function isGodotProject() {
+  return existsSync7(join10(getWorkspace(), GODOT_PROJECT_FILE));
+}
+
+// src/lib/init/vite.ts
+init_file_loader();
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import path from "node:path";
+var viteConfigTemplate = loadTemplateString("config/vite-config.ts");
+async function findViteConfig() {
+  const workspace = getWorkspace();
+  const result = await findFile(
+    ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"],
+    { cwd: workspace }
+  );
+  return result?.path ?? null;
+}
+function isPluginConfigured(configPath) {
+  const content = readFileSync3(configPath, "utf-8");
+  return content.includes("@playcademy/vite-plugin") || content.includes("playcademy(");
+}
+async function addVitePlugin(options = {}) {
+  const { install = false } = options;
+  const workspace = getWorkspace();
+  const pkgPath = path.join(workspace, "package.json");
+  const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+  const hasPlugin = pkg.dependencies?.["@playcademy/vite-plugin"] || pkg.devDependencies?.["@playcademy/vite-plugin"];
+  if (hasPlugin) {
+    return false;
+  }
+  if (install) {
+    const pm = detectPackageManager(workspace);
+    const command = getAddDevDependencyCommand(pm, "@playcademy/vite-plugin");
+    try {
+      await runStep(
+        "Installing @playcademy/vite-plugin...",
+        async () => {
+          execSync3(command, {
+            cwd: workspace,
+            stdio: ["ignore", "ignore", "ignore"]
+          });
+        },
+        "Installed @playcademy/vite-plugin"
+      );
+    } catch (error) {
+      throw new Error(`Failed to install @playcademy/vite-plugin: ${error}`);
+    }
+  } else {
+    if (!pkg.devDependencies) pkg.devDependencies = {};
+    pkg.devDependencies["@playcademy/vite-plugin"] = "latest";
+    writeFileSync3(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  }
+  return true;
+}
+async function updateViteConfig(configPath) {
+  let content = readFileSync3(configPath, "utf-8");
+  if (!content.includes("@playcademy/vite-plugin")) {
+    const importMatch = content.match(/import .+ from ['"]vite['"]/);
+    if (importMatch) {
+      const importIndex = importMatch.index + importMatch[0].length;
+      content = content.slice(0, importIndex) + `
+import { playcademy } from '@playcademy/vite-plugin'` + content.slice(importIndex);
+    } else {
+      content = `import { playcademy } from '@playcademy/vite-plugin'
+
+` + content;
+    }
+  }
+  if (!content.includes("playcademy()")) {
+    const pluginsMatch = content.match(/plugins:\s*\[/);
+    if (pluginsMatch) {
+      const pluginsIndex = pluginsMatch.index + pluginsMatch[0].length;
+      content = content.slice(0, pluginsIndex) + `playcademy(),` + content.slice(pluginsIndex);
+    } else {
+      const defineConfigMatch = content.match(/defineConfig\(\{/);
+      if (defineConfigMatch) {
+        const configIndex = defineConfigMatch.index + defineConfigMatch[0].length;
+        content = content.slice(0, configIndex) + `
+    plugins: [playcademy()],` + content.slice(configIndex);
+      }
+    }
+  }
+  writeFileSync3(configPath, content);
+  await formatConfigWithPrettier(configPath);
+}
+
+// src/lib/init/engine/detect.ts
+async function detectExistingEngine() {
+  if (isGodotProject()) {
+    return "godot";
+  }
+  if (await findViteConfig()) {
+    return "vite";
+  }
+  return null;
+}
+
+// src/lib/init/engine/index.ts
+async function selectEngineTemplate() {
+  const engine = await promptForEngine();
+  if (engine === "none") {
+    return null;
+  }
+  const framework = await promptForFramework(engine);
+  if (!framework) {
+    return null;
+  }
+  const template = await promptForTemplate(framework);
+  return { engine, framework, template };
+}
+async function applyEngineSelection(selection, destDir, options = {}) {
+  const { engine, framework, template } = selection;
+  const hookOptions = {
+    engine,
+    destDir,
+    ...options
+  };
+  if (template.beforeFetch) {
+    await template.beforeFetch(hookOptions);
+  }
+  await fetchTemplate(template, destDir);
+  if (template.afterFetch) {
+    await template.afterFetch(hookOptions);
+  }
+  return {
+    engine,
+    framework,
+    template,
+    destDir
+  };
+}
+
+// src/lib/init/gitignore.ts
+import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
+var rootGitignoreTemplate = loadTemplateString("gitignore");
+function ensureRootGitignore(workspace = getWorkspace()) {
+  const gitignorePath = join11(workspace, ".gitignore");
+  if (!existsSync8(gitignorePath)) {
+    writeFileSync4(gitignorePath, rootGitignoreTemplate);
+    return;
+  }
+  const existingContent = readFileSync4(gitignorePath, "utf-8");
+  const existingNormalized = new Set(
+    existingContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map(normalizeGitignoreEntry)
+  );
+  const templateLines = rootGitignoreTemplate.split("\n");
+  const entriesToAdd = [];
+  for (const line of templateLines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (existingNormalized.has(normalizeGitignoreEntry(trimmed))) continue;
+    entriesToAdd.push(trimmed);
+  }
+  if (entriesToAdd.length === 0) return;
+  const hasTrailingNewline = existingContent.endsWith("\n");
+  const prefix = hasTrailingNewline ? "\n" : "\n\n";
+  const header = "# Generated by Playcademy\n";
+  const newEntries = entriesToAdd.join("\n");
+  writeFileSync4(gitignorePath, existingContent + prefix + header + newEntries + "\n");
+}
+
+// src/lib/init/project.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+import { confirm as confirm2, input, select as select3 } from "@inquirer/prompts";
+async function promptForProjectDirectory(projectDir) {
+  let dir = projectDir;
+  if (dir === void 0) {
+    const choice = await select3({
+      message: "Where do you want to create the project?",
+      choices: [
+        { value: ".", name: "Current directory" },
+        { value: "new", name: "New directory" }
+      ]
+    });
+    if (choice === "new") {
+      dir = await input({
+        message: "Directory name:"
+      });
+    } else {
+      dir = ".";
+    }
+  }
+  if (dir === ".") {
+    return {
+      targetDir: process.cwd(),
+      needsCreation: false,
+      cancelled: false
+    };
+  }
+  const targetDir = resolve5(process.cwd(), dir);
+  if (existsSync9(targetDir)) {
+    logger.admonition("warning", "Directory Exists", [`Directory "${dir}" already exists.`]);
+    logger.newLine();
+    const shouldContinue = await confirm2({
+      message: "Continue and initialize in existing directory?",
+      default: false
+    });
+    if (!shouldContinue) {
+      logger.newLine();
+      logger.remark("Cancelled");
+      logger.newLine();
+      return {
+        targetDir,
+        needsCreation: false,
+        cancelled: true
+      };
+    }
+    return {
+      targetDir,
+      needsCreation: false,
+      cancelled: false
+    };
+  }
+  return {
+    targetDir,
+    needsCreation: true,
+    cancelled: false
+  };
+}
+function createProjectDirectory(info) {
+  if (info.needsCreation) {
+    mkdirSync3(info.targetDir, { recursive: true });
+  }
+  if (info.targetDir !== process.cwd()) {
+    setCliContext({ workspace: info.targetDir });
+    process.chdir(info.targetDir);
+  }
+}
+
+// src/lib/init/prompts.ts
+import { checkbox, confirm as confirm3, input as input2, select as select4 } from "@inquirer/prompts";
+import { bold as bold4, cyan as cyan4 } from "colorette";
+
+// src/lib/init/scaffold.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
+import { join as join14, resolve as resolve6 } from "path";
+
+// src/lib/init/auth.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join12 } from "path";
+var authTemplate = loadTemplateString("auth/auth.ts");
+var authCatchAllTemplate = loadTemplateString("auth/auth-catch-all.ts");
+var authSchemaTemplate = loadTemplateString("auth/auth-schema.ts");
+var protectedRouteTemplate = loadTemplateString("api/sample-protected.ts");
+function generateAuthConfig(strategies, appName) {
+  let authContent = authTemplate;
+  const slug = appName ? generateSlug(appName) : "my-app";
+  authContent = authContent.replace("{{APP_SLUG}}", slug);
+  const emailConfig = strategies.includes("email") ? `
+        // CUSTOMIZABLE: Email/password authentication
+        emailAndPassword: {
+            enabled: true,
+        },` : "";
+  authContent = authContent.replace("{{EMAIL_AND_PASSWORD}}", emailConfig);
+  const socialProviders = [];
+  if (strategies.includes("github")) {
+    socialProviders.push(
+      `            github: {
+                clientId: c.env.secrets?.GITHUB_CLIENT_ID || '',
+                clientSecret: c.env.secrets?.GITHUB_CLIENT_SECRET || '',
+            }`
+    );
+  }
+  if (strategies.includes("google")) {
+    socialProviders.push(
+      `            google: {
+                clientId: c.env.secrets?.GOOGLE_CLIENT_ID || '',
+                clientSecret: c.env.secrets?.GOOGLE_CLIENT_SECRET || '',
+            }`
+    );
+  }
+  const socialProvidersConfig = socialProviders.length > 0 ? `
+        // CUSTOMIZABLE: Social auth providers
+        socialProviders: {
+` + socialProviders.join(",\n") + `
+        },
+` : "";
+  authContent = authContent.replace("{{SOCIAL_PROVIDERS}}", socialProvidersConfig);
+  return authContent;
+}
+function scaffoldAuthConfig(workspace, authContent) {
+  const libDir = join12(workspace, SERVER_LIB_DIRECTORY);
+  if (!existsSync10(libDir)) {
+    mkdirSync4(libDir, { recursive: true });
+  }
+  writeFileSync5(join12(libDir, AUTH_CONFIG_FILE), authContent);
+}
+function scaffoldAuthRoutes(workspace) {
+  const apiDir = join12(workspace, DEFAULT_API_ROUTES_DIRECTORY);
+  const authApiDir = join12(apiDir, AUTH_API_SUBDIRECTORY);
+  if (!existsSync10(authApiDir)) {
+    mkdirSync4(authApiDir, { recursive: true });
+  }
+  writeFileSync5(join12(authApiDir, "[...all].ts"), authCatchAllTemplate);
+}
+function scaffoldAuthSchema(workspace) {
+  const dbDir = join12(workspace, DEFAULT_DATABASE_DIRECTORY);
+  const schemaDir = join12(dbDir, SCHEMA_SUBDIRECTORY);
+  if (!existsSync10(schemaDir)) {
+    mkdirSync4(schemaDir, { recursive: true });
+  }
+  writeFileSync5(join12(schemaDir, "auth.ts"), authSchemaTemplate);
+  const schemaIndexPath = join12(schemaDir, DB_FILES.SCHEMA_INDEX);
+  if (existsSync10(schemaIndexPath)) {
+    const existing = readFileSync5(schemaIndexPath, "utf-8");
+    if (!existing.includes("export * from './auth'")) {
+      writeFileSync5(schemaIndexPath, existing + "\nexport * from './auth'\n");
+    }
+  } else {
+    writeFileSync5(schemaIndexPath, "export * from './auth'\n");
+  }
+}
+function scaffoldProtectedExample(workspace) {
+  const apiDir = join12(workspace, DEFAULT_API_ROUTES_DIRECTORY);
+  const sampleDir = join12(apiDir, SAMPLE_API_SUBDIRECTORY);
+  if (!existsSync10(sampleDir)) {
+    mkdirSync4(sampleDir, { recursive: true });
+  }
+  writeFileSync5(join12(sampleDir, "protected.ts"), protectedRouteTemplate);
+}
+function updateEnvForAuth(workspace, strategies) {
+  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");
+    envLines.push("GITHUB_CLIENT_SECRET=your_github_client_secret");
+    envLines.push("");
+  }
+  if (strategies.includes("google")) {
+    envLines.push("# Google OAuth (for standalone auth)");
+    envLines.push("GOOGLE_CLIENT_ID=your_google_client_id");
+    envLines.push("GOOGLE_CLIENT_SECRET=your_google_client_secret");
+    envLines.push("");
+  }
+  updateEnvExample(workspace, envLines);
+}
+async function scaffoldAuthSetup(options = {}) {
+  const workspace = getWorkspace();
+  const { strategies = [], appName } = options;
+  let packagesUpdated = false;
+  await runStep(
+    "Configuring authentication...",
+    async () => {
+      const authContent = generateAuthConfig(strategies, appName);
+      scaffoldAuthConfig(workspace, authContent);
+      scaffoldAuthRoutes(workspace);
+      scaffoldAuthSchema(workspace);
+      scaffoldProtectedExample(workspace);
+      packagesUpdated = await setupPackageJson(workspace);
+      updateEnvForAuth(workspace, strategies);
+    },
+    "Authentication configured"
+  );
+  return packagesUpdated;
+}
+async function setupPackageJson(workspace) {
+  const pkgPath = join12(workspace, "package.json");
+  const authDeps = {
+    "@playcademy/better-auth": PLAYCADEMY_AUTH_VERSION,
+    "better-auth": BETTER_AUTH_VERSION
+  };
+  if (existsSync10(pkgPath)) {
+    await runStep(
+      "Updating package.json deps",
+      async () => {
+        const existing = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+        existing.dependencies = { ...existing.dependencies, ...authDeps };
+        writeFileSync5(pkgPath, JSON.stringify(existing, null, 2) + "\n");
+      },
+      "Updated package.json deps"
+    );
+    return true;
+  }
+  return false;
+}
+
+// src/lib/init/database.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13 } from "path";
+
+// package.json with { type: 'json' }
+var package_default2 = {
+  name: "playcademy",
+  version: "0.14.29",
+  type: "module",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.js"
+    },
+    "./cli": {
+      types: "./dist/cli.d.ts",
+      import: "./dist/cli.js",
+      require: "./dist/cli.js"
+    },
+    "./db": {
+      types: "./dist/db.d.ts",
+      import: "./dist/db.js",
+      require: "./dist/db.js"
+    },
+    "./utils": {
+      import: "./dist/utils.js",
+      types: "./dist/utils.d.ts"
+    },
+    "./constants": {
+      import: "./dist/constants.js",
+      types: "./dist/constants.d.ts"
+    },
+    "./types": {
+      types: "./dist/index.d.ts"
+    },
+    "./version": {
+      import: "./dist/version.js",
+      types: "./dist/version.d.ts"
+    }
+  },
+  main: "./dist/index.js",
+  module: "./dist/index.js",
+  bin: {
+    playcademy: "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build.ts",
+    dev: "PLAYCADEMY_BASE_URL=http://localhost:5174 bun src/index.ts",
+    pub: "bun publish.ts"
+  },
+  dependencies: {
+    "@inquirer/prompts": "^7.8.6",
+    "@playcademy/sdk": "workspace:*",
+    chokidar: "^4.0.3",
+    colorette: "^2.0.20",
+    commander: "^14.0.1",
+    dedent: "catalog:",
+    "drizzle-kit": "^0.31.5",
+    "drizzle-orm": "^0.44.6",
+    esbuild: "^0.25.10",
+    giget: "^2.0.0",
+    hono: "^4.9.9",
+    "json-colorizer": "^3.0.1",
+    jszip: "^3.10.1",
+    miniflare: "^4.20251008.0",
+    open: "^10.2.0"
+  },
+  devDependencies: {
+    "@cloudflare/workers-types": "^4.20251011.0",
+    "@playcademy/constants": "workspace:*",
+    "@playcademy/data": "workspace:*",
+    "@playcademy/edge-play": "workspace:*",
+    "@playcademy/timeback": "workspace:*",
+    "@playcademy/utils": "workspace:*",
+    "@types/bun": "latest",
+    bumpp: "^10.2.3",
+    rollup: "^4.50.2",
+    "rollup-plugin-dts": "^6.2.3"
+  },
+  peerDependencies: {
+    typescript: "^5"
+  }
+};
+
+// src/version.ts
+var version = package_default2.version;
+
+// src/lib/init/database.ts
+var drizzleConfigTemplate = loadTemplateString("database/drizzle-config.ts");
+var dbSchemaExampleTemplate = loadTemplateString("database/db-schema-example.ts");
+var dbSchemaIndexTemplate = loadTemplateString("database/db-schema-index.ts");
+var dbIndexTemplate = loadTemplateString("database/db-index.ts");
+var dbTypesTemplate = loadTemplateString("database/db-types.ts");
+var dbSeedTemplate = loadTemplateString("database/db-seed.ts");
+var packageTemplate = loadTemplateString("database/package.json");
+async function scaffoldDatabaseSetup(options) {
+  const workspace = getWorkspace();
+  let packagesUpdated = false;
+  await runStep(
+    "Configuring database...",
+    async () => {
+      const dbDir = join13(workspace, DEFAULT_DATABASE_DIRECTORY);
+      const schemaDir = join13(dbDir, SCHEMA_SUBDIRECTORY);
+      if (!existsSync11(dbDir)) {
+        mkdirSync5(dbDir, { recursive: true });
+      }
+      if (!existsSync11(schemaDir)) {
+        mkdirSync5(schemaDir, { recursive: true });
+      }
+      const exampleSchemaPath = join13(schemaDir, DB_FILES.EXAMPLE_SCHEMA);
+      writeFileSync6(exampleSchemaPath, dbSchemaExampleTemplate);
+      const schemaIndexPath = join13(schemaDir, DB_FILES.SCHEMA_INDEX);
+      writeFileSync6(schemaIndexPath, dbSchemaIndexTemplate);
+      const dbIndexPath = join13(dbDir, DB_FILES.INDEX);
+      writeFileSync6(dbIndexPath, dbIndexTemplate);
+      const dbTypesPath = join13(dbDir, DB_FILES.TYPES);
+      writeFileSync6(dbTypesPath, dbTypesTemplate);
+      const dbSeedPath = join13(dbDir, DB_FILES.SEED);
+      writeFileSync6(dbSeedPath, dbSeedTemplate);
+      const drizzleConfigPath = join13(workspace, DRIZZLE_CONFIG_FILES[0]);
+      writeFileSync6(drizzleConfigPath, drizzleConfigTemplate);
+      packagesUpdated = await setupPackageJson2(workspace, options.appName);
+    },
+    "Database configured"
+  );
+  return packagesUpdated;
+}
+async function setupPackageJson2(workspace, appName) {
+  const pkgPath = join13(workspace, "package.json");
+  const dbDeps = {
+    "drizzle-orm": "^0.42.0",
+    "better-sqlite3": "^12.0.0"
+  };
+  const dbDevDeps = {
+    playcademy: `^${version}`,
+    "drizzle-kit": "^0.30.0",
+    "@types/better-sqlite3": "^7.6.0",
+    tsx: "^4.20.6"
+  };
+  const dbScripts = {
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:push": "drizzle-kit push",
+    "db:studio": "drizzle-kit studio",
+    "db:seed": "playcademy db seed",
+    "db:reset": "playcademy db reset"
+  };
+  if (existsSync11(pkgPath)) {
+    await runStep(
+      "Updating package.json deps",
+      async () => {
+        const existing = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+        existing.dependencies = { ...existing.dependencies, ...dbDeps };
+        existing.devDependencies = { ...existing.devDependencies, ...dbDevDeps };
+        existing.scripts = { ...existing.scripts, ...dbScripts };
+        writeFileSync6(pkgPath, JSON.stringify(existing, null, 2) + "\n");
+      },
+      "Updated package.json deps"
+    );
+    return true;
+  } else {
+    const slugifiedName = generateSlug(appName);
+    const packageContent = packageTemplate.replace("{{APP_NAME}}", slugifiedName).replace("{{PLAYCADEMY_VERSION}}", version);
+    writeFileSync6(pkgPath, packageContent);
+    logger.success("Created package.json");
+    return true;
+  }
+}
+function hasDatabaseSetup() {
+  const workspace = getWorkspace();
+  return DRIZZLE_CONFIG_FILES.some((filename) => existsSync11(join13(workspace, filename)));
+}
+
+// src/lib/init/scaffold.ts
+var sampleCustomRouteTemplate = loadTemplateString("api/sample-custom.ts");
+var sampleDatabaseRouteTemplate = loadTemplateString("api/sample-database.ts");
+var sampleKvRouteTemplate = loadTemplateString("api/sample-kv.ts");
+var sampleBucketRouteTemplate = loadTemplateString("api/sample-bucket.ts");
+var playcademyGitignoreTemplate = loadTemplateString("playcademy-gitignore");
+async function scaffoldApiDirectory(apiDirectory, sampleRoutes) {
+  const apiPath = resolve6(getWorkspace(), apiDirectory);
+  const samplePath = join14(apiPath, "sample");
+  if (!existsSync12(apiPath)) {
+    mkdirSync6(apiPath, { recursive: true });
+  }
+  if (!existsSync12(samplePath)) {
+    mkdirSync6(samplePath, { recursive: true });
+  }
+  for (const route of sampleRoutes) {
+    writeFileSync7(join14(samplePath, route.filename), route.template, "utf-8");
+  }
+}
+function validateApiDirectoryDoesNotExist(value) {
+  const dirPath = resolve6(getWorkspace(), value.trim());
+  if (existsSync12(dirPath)) {
+    return `Directory "${value.trim()}" already exists. Please choose a different name or remove the existing directory.`;
+  }
+  return true;
+}
+function ensurePlaycademyGitignore() {
+  const workspace = getWorkspace();
+  const playcademyDir = join14(workspace, CLI_DIRECTORIES.WORKSPACE);
+  if (!existsSync12(playcademyDir)) {
+    mkdirSync6(playcademyDir, { recursive: true });
+  }
+  const gitignorePath = join14(playcademyDir, ".gitignore");
+  writeFileSync7(gitignorePath, playcademyGitignoreTemplate);
+}
+async function scaffoldIntegrations(appName, options) {
+  const { customRoutes, database, auth, kv, bucket } = options;
+  let depsAdded = false;
+  ensurePlaycademyGitignore();
+  if (customRoutes) {
+    const sampleRoutes = [
+      // Always include basic custom route example
+      { filename: SAMPLE_CUSTOM_FILENAME, template: sampleCustomRouteTemplate }
+    ];
+    if (database) {
+      sampleRoutes.push({
+        filename: SAMPLE_DATABASE_FILENAME,
+        template: sampleDatabaseRouteTemplate
+      });
+    }
+    if (kv) {
+      sampleRoutes.push({ filename: SAMPLE_KV_FILENAME, template: sampleKvRouteTemplate });
+    }
+    if (bucket) {
+      sampleRoutes.push({
+        filename: SAMPLE_BUCKET_FILENAME,
+        template: sampleBucketRouteTemplate
+      });
+    }
+    await scaffoldApiDirectory(customRoutes.directory, sampleRoutes);
+  }
+  if (database) {
+    const dbDepsAdded = await scaffoldDatabaseSetup({ appName });
+    if (dbDepsAdded) depsAdded = true;
+  }
+  if (auth) {
+    const authDepsAdded = await scaffoldAuthSetup({ ...auth, appName });
+    if (authDepsAdded) depsAdded = true;
+  }
+  return depsAdded;
+}
+function addPlaycademySdk() {
+  const pkgPath = resolve6(getWorkspace(), "package.json");
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+  const hasSdk = pkg.dependencies?.["@playcademy/sdk"] || pkg.devDependencies?.["@playcademy/sdk"];
+  if (hasSdk) {
+    return false;
+  }
+  if (!pkg.dependencies) pkg.dependencies = {};
+  pkg.dependencies["@playcademy/sdk"] = "latest";
+  writeFileSync7(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  return true;
+}
+
+// src/lib/init/prompts.ts
+async function promptForProjectInfo() {
+  const name = await input2({
+    message: "App name:",
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return "App name is required";
+      }
+      return true;
+    }
+  });
+  const description = await input2({
+    message: "App description (optional):",
+    default: ""
+  });
+  const emoji = await input2({
+    message: "App emoji (optional):",
+    default: "\u{1F3AE}"
+  });
+  return { name, description, emoji };
+}
+async function promptForTimeBackIntegration(options) {
+  if (!options?.skipConfirm) {
+    const wantsTimeback = await confirm3({
+      message: "TimeBack?",
+      default: false
+    });
+    if (!wantsTimeback) {
+      return null;
+    }
+  }
+  const subjects = await checkbox({
+    message: "Select subjects:",
+    choices: TIMEBACK_SUBJECTS.map((subject) => ({
+      value: subject,
+      name: subject
+    })),
+    instructions: ` ${bold4("(Press ")}${cyan4("<space>")}${bold4(" to select and ")}${cyan4("<enter>")}${bold4(" to proceed)")}`,
+    validate: (selected) => {
+      if (!selected || selected.length === 0) {
+        return "At least one subject is required";
+      }
+      return true;
+    }
+  });
+  let primarySubject;
+  if (subjects.length === 1) {
+    primarySubject = subjects[0];
+  } else {
+    primarySubject = await select4({
+      message: "Primary subject (for multi-grade courses):",
+      choices: subjects.map((subject) => ({
+        value: subject,
+        name: subject
+      }))
+    });
+  }
+  const grades = await checkbox({
+    message: "Select grade levels:",
+    choices: TIMEBACK_GRADE_LEVELS.map((grade) => ({
+      value: grade,
+      name: TIMEBACK_GRADE_LEVEL_LABELS[grade.toString()]
+    })),
+    instructions: ` ${bold4("(Press ")}${cyan4("<space>")}${bold4(" to select and ")}${cyan4("<enter>")}${bold4(" to proceed)")}`,
+    validate: (selected) => {
+      if (!selected || selected.length === 0) {
+        return "At least one grade level is required";
+      }
+      return true;
+    }
+  });
+  const courses = [];
+  for (const grade of grades) {
+    courses.push({
+      subject: primarySubject,
+      grade,
+      totalXp: null,
+      masterableUnits: null
+    });
+  }
+  return courses;
+}
+async function promptForDatabase() {
+  const wantsDatabase = await confirm3({
+    message: "Database?",
+    default: false
+  });
+  if (!wantsDatabase) {
+    return null;
+  }
+  const directory = await input2({
+    message: "Database directory:",
+    default: DEFAULT_DATABASE_DIRECTORY,
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return "Directory name is required";
+      }
+      return true;
+    }
+  });
+  return { directory };
+}
+async function promptForAuthStrategies() {
+  const strategies = await checkbox({
+    message: "Strategies (optional):",
+    choices: [
+      { value: "platform", name: "Platform", checked: true },
+      { value: "email", name: "Email/password" },
+      { value: "github", name: "GitHub OAuth" },
+      { value: "google", name: "Google OAuth" }
+    ],
+    instructions: ` ${bold4("(Press ")}${cyan4("<space>")}${bold4(" to select and ")}${cyan4("<enter>")}${bold4(" to proceed)")}`,
+    validate: (selected) => {
+      if (!selected.some((s) => s.value === "platform")) {
+        return "Platform auth is included by default (cannot be deselected)";
+      }
+      return true;
+    }
+  });
+  return strategies.filter((s) => s !== "platform");
+}
+async function promptForAuth() {
+  const wantsAuth = await confirm3({
+    message: "Authentication?",
+    default: false
+  });
+  if (!wantsAuth) {
+    logger.newLine();
+    return null;
+  }
+  const strategies = await promptForAuthStrategies();
+  return { strategies };
+}
+async function promptForKV() {
+  const wantsKV = await confirm3({
+    message: "KV storage?",
+    default: false
+  });
+  return wantsKV;
+}
+async function promptForBucket() {
+  const wantsBucket = await confirm3({
+    message: "Bucket storage?",
+    default: false
+  });
+  return wantsBucket;
+}
+async function promptForCustomRoutes(requiresRoutes = false) {
+  let wantsCustomRoutes = requiresRoutes;
+  if (!requiresRoutes) {
+    wantsCustomRoutes = await confirm3({
+      message: "Custom API routes?",
+      default: false
+    });
+  }
+  if (!wantsCustomRoutes) {
+    return null;
+  }
+  const directory = await input2({
+    message: "API routes directory:",
+    default: DEFAULT_API_ROUTES_DIRECTORY,
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return "Directory name is required";
+      }
+      return validateApiDirectoryDoesNotExist(value);
+    }
+  });
+  return { directory };
+}
+async function promptForIntegrations() {
+  const timeback = await promptForTimeBackIntegration();
+  logger.newLine();
+  const database = await promptForDatabase();
+  logger.newLine();
+  const auth = database ? await promptForAuth() : null;
+  if (auth) logger.newLine();
+  const kv = await promptForKV();
+  logger.newLine();
+  const bucket = await promptForBucket();
+  logger.newLine();
+  const customRoutes = await promptForCustomRoutes(!!database || !!auth || kv || bucket);
+  return {
+    timeback,
+    database,
+    auth,
+    kv,
+    bucket,
+    customRoutes
+  };
+}
+async function selectConfigFormat(hasPackageJson2) {
+  if (hasPackageJson2) {
+    return "js";
+  }
+  const formatChoice = await select4({
+    message: "Which config format would you like to use?",
+    choices: [
+      { value: "json", name: "JSON (playcademy.config.json)" },
+      { value: "js", name: "JavaScript (playcademy.config.js)" }
+    ],
+    default: "json"
+  });
+  return formatChoice;
+}
+
+// src/lib/init/types.ts
+init_file_loader();
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync15, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname5, join as join17 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/lib/deploy/backend.ts
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join15 } 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);
+}
+function hasLocalCustomRoutes(projectPath, config) {
+  const customRoutesDir = getCustomRoutesDirectory(projectPath, config);
+  return existsSync13(customRoutesDir);
+}
+
+// src/lib/init/bucket.ts
+function hasBucketSetup(config) {
+  return !!config.integrations?.bucket;
+}
+
+// src/lib/init/kv.ts
+function hasKVSetup(config) {
+  return !!config.integrations?.kv;
+}
+
+// src/lib/init/tsconfig.ts
+init_file_loader();
+import { existsSync as existsSync14, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
+import { join as join16 } from "path";
+function hasAllRequiredIncludes(config) {
+  if (!config.include) return false;
+  return TSCONFIG_REQUIRED_INCLUDES.every((entry) => config.include.includes(entry));
+}
+function getMissingIncludes(config) {
+  if (!config.include) return [...TSCONFIG_REQUIRED_INCLUDES];
+  return TSCONFIG_REQUIRED_INCLUDES.filter((entry) => !config.include.includes(entry));
+}
+function addRequiredIncludes(config) {
+  if (!config.include) {
+    config.include = [];
+  }
+  for (const entry of getMissingIncludes(config)) {
+    config.include.push(entry);
+  }
+}
+function updateExistingIncludeArray(content) {
+  const includeRegex = /"include"\s*:\s*\[([^\]]*)\]/;
+  const match = content.match(includeRegex);
+  if (!match || !match[1]) {
+    return null;
+  }
+  const fullMatch = match[0];
+  const arrayContents = match[1];
+  const missingEntries = TSCONFIG_REQUIRED_INCLUDES.filter(
+    (entry) => !arrayContents.includes(entry)
+  );
+  if (missingEntries.length === 0) {
+    return content;
+  }
+  const trimmedContents = arrayContents.trim();
+  const newEntries = missingEntries.map((entry) => `"${entry}"`);
+  let newArrayContents;
+  if (trimmedContents === "") {
+    newArrayContents = newEntries.join(", ");
+  } else if (arrayContents.includes("\n")) {
+    const entriesStr = newEntries.map((e) => `
+        ${e}`).join(",");
+    newArrayContents = `${arrayContents},${entriesStr}
+    `;
+  } else {
+    newArrayContents = `${trimmedContents}, ${newEntries.join(", ")}`;
+  }
+  const newIncludeArray = `"include": [${newArrayContents}]`;
+  return content.replace(fullMatch, newIncludeArray);
+}
+function addNewIncludeProperty(content) {
+  const closingBraceMatch = content.match(/\n(\s*)\}(\s*)$/);
+  if (!closingBraceMatch || closingBraceMatch.index === void 0) {
+    return null;
+  }
+  const propertyMatch = content.match(/\n(\s+)"/);
+  const propertyIndent = propertyMatch ? propertyMatch[1] : "    ";
+  const insertPosition = closingBraceMatch.index;
+  const beforeClosing = content.slice(0, insertPosition).trim();
+  const needsComma = beforeClosing.endsWith("]") || beforeClosing.endsWith("}") || beforeClosing.endsWith('"');
+  const entriesStr = TSCONFIG_REQUIRED_INCLUDES.map((e) => `"${e}"`).join(", ");
+  const comma = needsComma ? "," : "";
+  const includeEntry = `${comma}
+${propertyIndent}"include": [${entriesStr}]`;
+  const updatedContent = content.slice(0, insertPosition) + includeEntry + content.slice(insertPosition);
+  return updatedContent;
+}
+function addToIncludeArrayPreservingComments(content) {
+  return updateExistingIncludeArray(content) || addNewIncludeProperty(content);
+}
+async function ensureTsconfigIncludes(workspace) {
+  for (const filename of TSCONFIG_FILES) {
+    const configPath = join16(workspace, filename);
+    if (!existsSync14(configPath)) {
+      continue;
+    }
+    try {
+      const config = await loadFile(configPath, {
+        parseJson: true,
+        stripComments: true
+      });
+      if (!config) continue;
+      if (config.references && filename !== TSCONFIG_JSON) {
+        continue;
+      }
+      if (hasAllRequiredIncludes(config)) {
+        return filename;
+      }
+      try {
+        const rawContent = readFileSync8(configPath, "utf-8");
+        const updatedContent = addToIncludeArrayPreservingComments(rawContent);
+        if (updatedContent && updatedContent !== rawContent) {
+          writeFileSync8(configPath, updatedContent);
+          return filename;
+        }
+      } catch {
+      }
+      addRequiredIncludes(config);
+      writeFileSync8(configPath, JSON.stringify(config, null, 4) + "\n");
+      return filename;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/lib/init/types.ts
+var playcademyEnvTemplate = loadTemplateString("playcademy-env.d.ts");
+function detectBackendFeatures(workspace, config) {
+  return {
+    hasDB: hasDatabaseSetup(),
+    hasKV: hasKVSetup(config),
+    hasBucket: hasBucketSetup(config),
+    hasRoutes: hasLocalCustomRoutes(workspace, config),
+    hasSecrets: hasEnvFile(workspace)
+  };
+}
+function hasAnyBackend(features) {
+  return Object.values(features).some(Boolean);
+}
+async function setupPlaycademyDependencies(workspace) {
+  const playcademyDir = join17(workspace, CLI_DIRECTORIES.WORKSPACE);
+  const playcademyPkgPath = join17(playcademyDir, "package.json");
+  const __dirname = dirname5(fileURLToPath2(import.meta.url));
+  const cliPkg = await loadPackageJson({ cwd: __dirname, searchUp: true, required: true });
+  const workersTypesVersion = cliPkg?.devDependencies?.["@cloudflare/workers-types"] || "latest";
+  const honoVersion = cliPkg?.dependencies?.hono || "latest";
+  const playcademyPkg = {
+    private: true,
+    dependencies: { hono: honoVersion },
+    devDependencies: { "@cloudflare/workers-types": workersTypesVersion }
+  };
+  writeFileSync9(playcademyPkgPath, JSON.stringify(playcademyPkg, null, 4) + "\n");
+  const pm = detectPackageManager(workspace);
+  const installCmd = getInstallCommand(pm);
+  execSync4(installCmd, {
+    cwd: playcademyDir,
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+}
+function generateBindingsTypeString(features) {
+  const bindings = [];
+  if (features.hasKV) bindings.push("        KV: KVNamespace");
+  if (features.hasDB) bindings.push("        DB: D1Database");
+  if (features.hasBucket) bindings.push("        BUCKET: R2Bucket");
+  return bindings.length > 0 ? "\n" + bindings.join("\n") : "";
+}
+function generateAuthVariablesString(hasAuth, hasAuthFile) {
+  const authImport = hasAuthFile ? "\nimport type { UserInfo } from './node_modules/@playcademy/sdk/dist/types.d.ts'\nimport type { User } from './server/lib/auth'" : "\nimport type { UserInfo } from './node_modules/@playcademy/sdk/dist/types.d.ts'";
+  const variableFields = ["        playcademyUser?: UserInfo"];
+  if (hasAuth && hasAuthFile) {
+    variableFields.push("        user?: User");
+  }
+  return {
+    authImport,
+    variables: `
+
+    interface PlaycademyVariables {
+${variableFields.join("\n")}
+    }`,
+    contextVars: "; Variables: PlaycademyVariables"
+  };
+}
+async function generateSecretsTypeString(workspace, verbose = false) {
+  try {
+    const envSecrets = await readEnvFile(workspace);
+    const secretKeys = Object.keys(envSecrets);
+    if (secretKeys.length === 0) {
+      if (verbose) logger.success("No secrets in <.env> files");
+      return "\n        secrets: Record<string, string>";
+    }
+    if (verbose) {
+      const loadedFiles = getLoadedEnvFiles(workspace);
+      const fileList = loadedFiles.map((f) => `<${f}>`).join(", ");
+      logger.success(
+        `Loaded ${secretKeys.length} ${pluralize(secretKeys.length, "secret")} from ${fileList}`
+      );
+    }
+    const secretTypes = secretKeys.map((key) => `            ${key}: string`).join("\n");
+    return `
+        secrets: {
+${secretTypes}
+            [key: string]: string
+        }`;
+  } catch {
+    return "\n        secrets: Record<string, string>";
+  }
+}
+async function ensurePlaycademyTypes(options = {}) {
+  const { verbose = false } = options;
+  try {
+    const workspace = getWorkspace();
+    const config = await loadConfig();
+    const features = detectBackendFeatures(workspace, config);
+    if (!hasAnyBackend(features)) {
+      if (verbose) {
+        logger.dim("No backend functionality detected");
+      }
+      return;
+    }
+    await setupPlaycademyDependencies(workspace);
+    if (verbose) {
+      logger.success(`Installed packages in <${CLI_DIRECTORIES.WORKSPACE}>`);
+    }
+    const bindingsStr = generateBindingsTypeString(features);
+    const secretsStr = await generateSecretsTypeString(workspace, verbose);
+    const hasAuth = !!config.integrations?.auth;
+    const hasAuthFile = existsSync15(join17(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");
+    writeFileSync9(envPath, envContent);
+    if (verbose) {
+      logger.success(`Generated <playcademy-env.d.ts>`);
+    }
+    const tsConfigFilename = await ensureTsconfigIncludes(workspace);
+    if (verbose) {
+      logger.success(`Updated <${tsConfigFilename}>`);
+    }
+  } catch (error) {
+    logger.warn(
+      `Failed to generate TypeScript types: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/lib/init/run.ts
+var motd = `
+            _______   ___       _______   ___ ___ 
+           |   _   | |   |     |   _   | |   Y   |
+           |.  1   | |.  |     |.  3   | |   4   |
+           |.  ____| |.  |___  |.  _   |  \\_   _/ 
+           |:  |     |:  2   | |:  |   |   |:  |  
+           |::.|     |::.. . | |::.|:. |   |::.|  
+           \`---'     \`-------' \`--- ---'   \`---'
+  _______   _______   ______     _______   ___ ___   ___ ___ 
+ |   _   | |   _   | |   _  \\   |   _   | |   Y   | |   Y   |
+ |.  5___| |.  7   | |.  |   \\  |.  9___| |.  1   | |   2   |
+ |.  |___  |.  _   | |.  |    \\ |.  __)_  |. \\_/  |  \\_   _/ 
+ |:  6   | |:  |   | |:  8    / |:  0   | |:  |   |   |:  |  
+ |::.. . | |::.|:. | |::.. . /  |::.. . | |::.|:. |   |::.|  
+ \`-------' \`--- ---' \`------'   \`-------' \`--- ---'   \`---'  
+                                                             
+`;
+async function runInit(options = {}) {
+  logger.raw(motd);
+  try {
+    const dirInfo = await promptForProjectDirectory(options.projectDir);
+    if (dirInfo.cancelled) {
+      return;
+    }
+    const engineSelection = await detectExistingEngine() ? null : await selectEngineTemplate();
+    const existingConfig = await findFile(CONFIG_FILE_NAMES, {
+      searchUp: false,
+      maxLevels: 0
+    });
+    if (existingConfig && !options.force) {
+      const relativePath = `./${existingConfig.path.split("/").pop()}`;
+      logger.admonition("warning", "Already Initialized", [
+        `Configuration file already exists: ${relativePath}`
+      ]);
+      logger.newLine();
+      const shouldOverwrite = await confirm4({
+        message: "Do you want to overwrite it?",
+        default: false
+      });
+      if (!shouldOverwrite) {
+        logger.newLine();
+        logger.remark("Nothing to do");
+        logger.newLine();
+        return;
+      }
+    }
+    let configFormat;
+    if (engineSelection?.engine === "godot") {
+      configFormat = "json";
+    } else if (engineSelection?.engine === "vite") {
+      configFormat = "js";
+    } else {
+      configFormat = await selectConfigFormat(hasPackageJson());
+    }
+    const configFileName = configFormat === "json" ? "playcademy.config.json" : "playcademy.config.js";
+    logger.newLine();
+    logger.highlight("Project Information");
+    logger.newLine();
+    const projectInfo = await promptForProjectInfo();
+    logger.newLine();
+    logger.highlight("Integrations");
+    logger.newLine();
+    const {
+      timeback: timebackConfig,
+      database,
+      auth,
+      kv,
+      bucket,
+      customRoutes
+    } = await promptForIntegrations();
+    logger.newLine();
+    await runStep(
+      "Setting up project",
+      async () => {
+        createProjectDirectory(dirInfo);
+        if (engineSelection) {
+          await applyEngineSelection(engineSelection, getWorkspace());
+        }
+        let depsAdded = false;
+        const hasPackageJsonFile = hasPackageJson();
+        if (hasPackageJsonFile) {
+          ensureRootGitignore();
+        }
+        if (hasPackageJsonFile) {
+          const sdkAdded = addPlaycademySdk();
+          if (sdkAdded) depsAdded = true;
+        }
+        if (engineSelection?.engine === "vite") {
+          const viteConfigPath = await findViteConfig();
+          if (viteConfigPath && !isPluginConfigured(viteConfigPath)) {
+            await updateViteConfig(viteConfigPath);
+            const vitePluginAdded = await addVitePlugin();
+            if (vitePluginAdded) depsAdded = true;
+          }
+        }
+        if (customRoutes || database || auth) {
+          const scaffoldOptions = { customRoutes, database, auth, kv, bucket };
+          const scaffoldDepsAdded = await scaffoldIntegrations(
+            projectInfo.name,
+            scaffoldOptions
+          );
+          if (scaffoldDepsAdded) depsAdded = true;
+        }
+        if (depsAdded) {
+          const pm = detectPackageManager(getWorkspace());
+          const installCmd = getInstallCommand(pm);
+          execSync5(installCmd, {
+            cwd: getWorkspace(),
+            stdio: ["ignore", "ignore", "ignore"]
+          });
+        }
+      },
+      "Project configured"
+    );
+    const configContent = configFormat === "js" ? generateJsConfig({
+      name: projectInfo.name,
+      description: projectInfo.description,
+      emoji: projectInfo.emoji,
+      customRoutesDirectory: customRoutes?.directory ?? void 0,
+      databaseDirectory: database?.directory ?? void 0,
+      auth: !!auth,
+      kv: kv ?? void 0,
+      bucket: bucket ?? void 0,
+      timebackCourses: timebackConfig ?? void 0
+    }) : generateJsonConfig({
+      name: projectInfo.name,
+      description: projectInfo.description,
+      emoji: projectInfo.emoji,
+      customRoutesDirectory: customRoutes?.directory ?? void 0,
+      databaseDirectory: database?.directory ?? void 0,
+      auth: !!auth,
+      kv: kv ?? void 0,
+      bucket: bucket ?? void 0,
+      timebackCourses: timebackConfig ?? void 0
+    });
+    const configPath = resolve7(getWorkspace(), configFileName);
+    writeFileSync10(configPath, configContent, "utf-8");
+    await formatConfigWithPrettier(configPath);
+    if (database || auth || kv || bucket) {
+      await ensurePlaycademyTypes();
+      logger.newLine();
+    }
+    displaySuccessMessage({
+      configFileName,
+      apiDirectory: customRoutes?.directory ?? null,
+      hasDatabase: !!database,
+      hasAuth: !!auth,
+      timebackConfig,
+      engineType: engineSelection?.engine ?? null
+    });
+  } catch (error) {
+    logger.newLine();
+    throw error;
+  }
+}
+export {
+  runInit,
+  setupGlobalErrorHandlers
+};