@playcademy/vite-plugin 0.1.37 → 0.1.40

package/dist/index.js

@@ -41140,7 +41140,8 @@ var serverState = {
   sandbox: null,
   backend: null,
   viteServer: null,
-  currentMode: "platform"
+  currentMode: "platform",
+  timebackRoleOverride: null
 };
 function hasActiveServers() {
   return !!(serverState.backend || serverState.sandbox);
@@ -41157,6 +41158,12 @@ function getViteServerRef() {
 function setViteServerRef(server) {
   serverState.viteServer = server;
 }
+function getTimebackRoleOverride() {
+  return serverState.timebackRoleOverride;
+}
+function setTimebackRoleOverride(role) {
+  serverState.timebackRoleOverride = role;
+}
 
 // src/server/cleanup.ts
 async function cleanupServers() {
@@ -41176,73 +41183,12 @@ async function cleanupServers() {
   }
 }
 
-// src/server/lifecycle.ts
-var shutdownHandlersRegistered = false;
-function setupProcessShutdownHandlers() {
-  if (shutdownHandlersRegistered)
-    return;
-  shutdownHandlersRegistered = true;
-  let isShuttingDown = false;
-  const shutdown = async () => {
-    if (isShuttingDown)
-      return;
-    isShuttingDown = true;
-    await cleanupServers();
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}
-
-// src/server/mode-switcher.ts
-var import_picocolors7 = __toESM(require_picocolors(), 1);
-// package.json
-var package_default = {
-  name: "@playcademy/vite-plugin",
-  version: "0.1.36",
-  type: "module",
-  exports: {
-    ".": {
-      import: "./dist/index.js",
-      types: "./dist/index.d.ts"
-    }
-  },
-  main: "dist/index.js",
-  module: "dist/index.js",
-  files: [
-    "dist"
-  ],
-  scripts: {
-    build: "rm -rf dist && bun build.ts",
-    docs: "typedoc --skipErrorChecking",
-    pub: "bun publish.ts"
-  },
-  dependencies: {
-    archiver: "^7.0.1",
-    picocolors: "^1.1.1",
-    playcademy: "workspace:*"
-  },
-  devDependencies: {
-    "@inquirer/prompts": "^7.8.6",
-    "@playcademy/sandbox": "workspace:*",
-    "@types/archiver": "^6.0.3",
-    "@types/bun": "latest"
-  },
-  peerDependencies: {
-    typescript: "^5",
-    vite: "^5 || ^6"
-  }
-};
-
-// src/lib/backend/server.ts
-import {
-  loadPlaycademyConfigAndSetWorkspace as loadConfigAndSetWorkspace,
-  startPlaycademyDevServer,
-  startPlaycademyHotReload
-} from "playcademy/utils";
-
-// src/lib/logging/adapter.ts
+// src/server/hotkeys/cycle-timeback-role.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
+
+// src/types/internal.ts
+var TIMEBACK_ROLES = ["student", "parent", "teacher", "administrator"];
+// src/server/hotkeys/cycle-timeback-role.ts
 function formatTimestamp() {
   const now = new Date;
   const hours = now.getHours();
@@ -41250,117 +41196,32 @@ function formatTimestamp() {
   const seconds = now.getSeconds().toString().padStart(2, "0");
   const ampm = hours >= 12 ? "PM" : "AM";
   const displayHours = hours % 12 || 12;
-  return import_picocolors2.dim(`${displayHours}:${minutes}:${seconds} ${ampm}`);
-}
-function createLoggerAdapter(prefix) {
-  const formattedPrefix = import_picocolors2.dim(`(${prefix})`);
-  const label = import_picocolors2.cyan(import_picocolors2.bold("[playcademy]"));
-  return {
-    info: (msg) => console.log(`${formatTimestamp()} ${label} ${formattedPrefix} ${msg}`),
-    warn: (msg) => console.warn(`${formatTimestamp()} ${label} ${formattedPrefix} ${msg}`),
-    error: (msg) => console.error(`${formatTimestamp()} ${label} ${formattedPrefix} ${msg}`)
-  };
-}
-// src/lib/logging/utils.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
-function printBanner(viteConfig, servers, projectInfo, pluginVersion) {
-  const INDENT = " ".repeat(2);
-  viteConfig.logger.info("");
-  viteConfig.logger.info(`${INDENT}${import_picocolors3.green(import_picocolors3.bold("PLAYCADEMY"))} ${import_picocolors3.green(`v${pluginVersion}`)}`);
-  viteConfig.logger.info("");
-  viteConfig.logger.info(`${INDENT}${import_picocolors3.green("➜")}  ${import_picocolors3.bold("Game:")}     ${import_picocolors3.cyan(projectInfo.slug)}`);
-  viteConfig.logger.info(`${INDENT}${import_picocolors3.green("➜")}  ${import_picocolors3.bold("Sandbox:")}  ${import_picocolors3.cyan(`http://localhost:${import_picocolors3.bold(servers.sandbox.toString())}/api`)}`);
-  if (servers.backend) {
-    const backendUrl = servers.vite ? `http://localhost:${import_picocolors3.bold(servers.vite.toString())}/api ${import_picocolors3.dim(`(via ${servers.backend})`)}` : `http://localhost:${import_picocolors3.bold(servers.backend.toString())}/api`;
-    viteConfig.logger.info(`${INDENT}${import_picocolors3.green("➜")}  ${import_picocolors3.bold("Backend:")}  ${import_picocolors3.cyan(backendUrl)}`);
-  }
-  if (servers.realtime) {
-    viteConfig.logger.info(`${INDENT}${import_picocolors3.green("➜")}  ${import_picocolors3.bold("Realtime:")} ${import_picocolors3.cyan(`ws://localhost:${import_picocolors3.bold(servers.realtime.toString())}`)}`);
-  }
-  viteConfig.logger.info("");
-}
-// src/lib/backend/hot-reload.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
-function formatChangedPath(changedPath) {
-  if (!changedPath)
-    return;
-  if (changedPath.includes("/api/")) {
-    return changedPath.substring(changedPath.indexOf("/api/"));
+  return import_picocolors2.default.dim(`${displayHours}:${minutes}:${seconds} ${ampm}`);
+}
+function cycleTimebackRole(logger) {
+  const currentRole = getTimebackRoleOverride() ?? "student";
+  const currentIndex = TIMEBACK_ROLES.indexOf(currentRole);
+  const nextIndex = (currentIndex + 1) % TIMEBACK_ROLES.length;
+  const nextRole = TIMEBACK_ROLES[nextIndex];
+  setTimebackRoleOverride(nextRole);
+  logger.info(`${formatTimestamp()} ${import_picocolors2.default.cyan(import_picocolors2.default.bold("[playcademy]"))} ${import_picocolors2.default.dim("(timeback)")} ${import_picocolors2.default.red(currentRole)} → ${import_picocolors2.default.green(nextRole)}`);
+  if (getViteServerRef()) {
+    getViteServerRef()?.ws.send({ type: "full-reload", path: "*" });
+  } else {
+    logger.warn(`${formatTimestamp()} ${import_picocolors2.default.red(import_picocolors2.bold("[playcademy]"))} ${import_picocolors2.dim("(timeback)")} ${import_picocolors2.yellow("Cannot cycle TimeBack role: no Vite server reference")}`);
   }
-  return changedPath;
-}
-function createHotReloadCallbacks(viteConfig) {
-  return {
-    onSuccess: (changedPath) => {
-      const relativePath = formatChangedPath(changedPath);
-      if (relativePath) {
-        viteConfig.logger.info(`${import_picocolors4.dim("(backend)")} ${import_picocolors4.green("hmr update")} ${import_picocolors4.dim(relativePath)}`, { timestamp: true });
-      } else {
-        viteConfig.logger.info("backend reloaded", { timestamp: true });
-      }
-    },
-    onError: (error) => {
-      viteConfig.logger.error(`backend reload failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  };
 }
+var cycleTimebackRoleHotkey = (options) => ({
+  key: "t",
+  description: "cycle TimeBack role",
+  action: () => cycleTimebackRole(options.viteConfig.logger)
+});
+
+// src/server/hotkeys/recreate-database.ts
+var import_picocolors7 = __toESM(require_picocolors(), 1);
 
-// src/lib/backend/server.ts
-async function tryLoadConfig(viteConfig, configPath) {
-  try {
-    return await loadConfigAndSetWorkspace(configPath);
-  } catch (error) {
-    if (error instanceof Error && !error.message.includes("Could not find")) {
-      viteConfig.logger.warn(`Could not load playcademy.config.js: ${error.message}`);
-    }
-    return null;
-  }
-}
-function needsCliDevServer(config) {
-  return !!config.integrations;
-}
-async function startServer(options) {
-  const { port, config, platformUrl } = options;
-  return startPlaycademyDevServer({
-    port,
-    config,
-    quiet: true,
-    platformUrl,
-    customLogger: createLoggerAdapter("backend")
-  });
-}
-function setupHotReload(serverRef, options) {
-  const watcher = startPlaycademyHotReload(async () => {
-    await serverRef.current.server.dispose();
-    serverRef.current = await startServer(options);
-  }, createHotReloadCallbacks(options.viteConfig));
-  return () => watcher.close();
-}
-async function setupCliDevServer(options) {
-  const { preferredPort, viteConfig, platformUrl, configPath } = options;
-  const config = await tryLoadConfig(viteConfig, configPath);
-  if (!config)
-    return null;
-  if (!needsCliDevServer(config))
-    return null;
-  try {
-    const port = await findAvailablePort(preferredPort);
-    const serverOptions = { port, config, platformUrl, viteConfig };
-    const serverRef = { current: await startServer(serverOptions) };
-    const stopHotReload = setupHotReload(serverRef, serverOptions);
-    return {
-      server: serverRef.current.server,
-      port: serverRef.current.port,
-      stopHotReload,
-      cleanup: () => cleanupServerInfo("backend", viteConfig.root, process.pid)
-    };
-  } catch (error) {
-    viteConfig.logger.error(`Failed to start game backend: ${error instanceof Error ? error.message : String(error)}`);
-    return null;
-  }
-}
 // src/lib/sandbox/server.ts
-var import_picocolors5 = __toESM(require_picocolors(), 1);
+var import_picocolors6 = __toESM(require_picocolors(), 1);
 import { DEFAULT_PORTS as DEFAULT_PORTS2 } from "playcademy/constants";
 
 // ../sandbox/dist/server.js
@@ -50427,8 +50288,8 @@ function assembleStyles() {
   styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
   Object.defineProperties(styles, {
     rgbToAnsi256: {
-      value(red, green3, blue2) {
-        if (red === green3 && green3 === blue2) {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
           if (red < 8) {
             return 16;
           }
@@ -50437,7 +50298,7 @@ function assembleStyles() {
           }
           return Math.round((red - 8) / 247 * 24) + 232;
         }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green3 / 255 * 5) + Math.round(blue2 / 255 * 5);
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
       },
       enumerable: false
     },
@@ -50473,24 +50334,24 @@ function assembleStyles() {
           return 90 + (code - 8);
         }
         let red;
-        let green3;
-        let blue2;
+        let green;
+        let blue;
         if (code >= 232) {
           red = ((code - 232) * 10 + 8) / 255;
-          green3 = red;
-          blue2 = red;
+          green = red;
+          blue = red;
         } else {
           code -= 16;
           const remainder = code % 36;
           red = Math.floor(code / 36) / 5;
-          green3 = Math.floor(remainder / 6) / 5;
-          blue2 = remainder % 6 / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
         }
-        const value = Math.max(red, green3, blue2) * 2;
+        const value = Math.max(red, green, blue) * 2;
         if (value === 0) {
           return 30;
         }
-        let result = 30 + (Math.round(blue2) << 2 | Math.round(green3) << 1 | Math.round(red));
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
         if (value === 2) {
           result += 60;
         }
@@ -50499,7 +50360,7 @@ function assembleStyles() {
       enumerable: false
     },
     rgbToAnsi: {
-      value: (red, green3, blue2) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green3, blue2)),
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
       enumerable: false
     },
     hexToAnsi: {
@@ -55966,7 +55827,7 @@ var init_api = __esm(() => {
       ANSI_BACKGROUND_OFFSET = 10;
       wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
       wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-      wrapAnsi16m = (offset = 0) => (red, green3, blue2) => `\x1B[${38 + offset};2;${red};${green3};${blue2}m`;
+      wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
       styles = {
         modifier: {
           reset: [0, 0],
@@ -162180,8 +162041,8 @@ var require_colorette = __commonJS2((exports) => {
   var createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors4 : Object.keys(colors4).reduce((colors5, key) => ({ ...colors5, [key]: String }), {});
   var {
     reset,
-    bold: bold22,
-    dim: dim22,
+    bold: bold2,
+    dim: dim2,
     italic,
     underline,
     inverse,
@@ -162189,11 +162050,11 @@ var require_colorette = __commonJS2((exports) => {
     strikethrough,
     black,
     red,
-    green: green3,
-    yellow,
-    blue: blue2,
+    green,
+    yellow: yellow2,
+    blue,
     magenta,
-    cyan: cyan3,
+    cyan,
     white,
     gray,
     bgBlack,
@@ -162239,15 +162100,15 @@ var require_colorette = __commonJS2((exports) => {
   exports.bgYellowBright = bgYellowBright;
   exports.black = black;
   exports.blackBright = blackBright;
-  exports.blue = blue2;
+  exports.blue = blue;
   exports.blueBright = blueBright;
-  exports.bold = bold22;
+  exports.bold = bold2;
   exports.createColors = createColors;
-  exports.cyan = cyan3;
+  exports.cyan = cyan;
   exports.cyanBright = cyanBright;
-  exports.dim = dim22;
+  exports.dim = dim2;
   exports.gray = gray;
-  exports.green = green3;
+  exports.green = green;
   exports.greenBright = greenBright;
   exports.hidden = hidden;
   exports.inverse = inverse;
@@ -162262,7 +162123,7 @@ var require_colorette = __commonJS2((exports) => {
   exports.underline = underline;
   exports.white = white;
   exports.whiteBright = whiteBright;
-  exports.yellow = yellow;
+  exports.yellow = yellow2;
   exports.yellowBright = yellowBright;
 });
 var require_dist22 = __commonJS2((exports) => {
@@ -175287,6 +175148,7 @@ var config = {
 };
 process.env.BETTER_AUTH_SECRET = config.auth.betterAuthSecret;
 process.env.GAME_JWT_SECRET = config.auth.gameJwtSecret;
+process.env.PUBLIC_IS_LOCAL = "true";
 var RequestError = class extends Error {
   constructor(message3, options) {
     super(message3, options);
@@ -175822,9 +175684,9 @@ var serve = (options, listeningListener) => {
   });
   return server;
 };
-var package_default2 = {
+var package_default = {
   name: "@playcademy/sandbox",
-  version: "0.1.11",
+  version: "0.2.3",
   description: "Local development server for Playcademy game development",
   type: "module",
   exports: {
@@ -177412,7 +177274,7 @@ var colorStatus = async (status) => {
   }
   return `${status}`;
 };
-async function log3(fn, prefix2, method, path4, status = 0, elapsed) {
+async function log(fn, prefix2, method, path4, status = 0, elapsed) {
   const out2 = prefix2 === "<--" ? `${prefix2} ${method} ${path4}` : `${prefix2} ${method} ${path4} ${await colorStatus(status)} ${elapsed}`;
   fn(out2);
 }
@@ -177420,10 +177282,10 @@ var logger2 = (fn = console.log) => {
   return async function logger2(c3, next) {
     const { method, url } = c3.req;
     const path4 = url.slice(url.indexOf("/", 8));
-    await log3(fn, "<--", method, path4);
+    await log(fn, "<--", method, path4);
     const start2 = Date.now();
     await next();
-    await log3(fn, "-->", method, path4, c3.res.status, time(start2));
+    await log(fn, "-->", method, path4, c3.res.status, time(start2));
   };
 };
 var entityKind = Symbol.for("drizzle:entityKind");
@@ -189928,7 +189790,7 @@ var createLogger2 = () => {
     log: performLog2
   };
 };
-var log32 = createLogger2();
+var log3 = createLogger2();
 async function deleteTimebackResources(client2, courseId) {
   const sourcedIds = deriveSourcedIds(courseId);
   const { fetchTimebackConfig: fetchTimebackConfig2 } = await Promise.resolve().then(() => (init_verify5(), exports_verify));
@@ -189976,7 +189838,7 @@ async function deleteTimebackResources(client2, courseId) {
       lessonType: config2.componentResource.lessonType
     })
   ]);
-  log32.info("[TimeBack] Resources soft-deleted", { courseId });
+  log3.info("[TimeBack] Resources soft-deleted", { courseId });
 }
 init_verify5();
 async function createCourse(client2, config2) {
@@ -189996,12 +189858,12 @@ async function createCourse(client2, config2) {
     if (!response.sourcedIdPairs?.allocatedSourcedId) {
       throw new Error("Course created but TimeBack did not return allocatedSourcedId");
     }
-    log32.info("[TimeBack] Course created", {
+    log3.info("[TimeBack] Course created", {
       courseId: response.sourcedIdPairs.allocatedSourcedId
     });
     return response.sourcedIdPairs.allocatedSourcedId;
   } catch (error2) {
-    log32.error("[TimeBack] Failed to create course", {
+    log3.error("[TimeBack] Failed to create course", {
       title: config2.course.title,
       error: error2
     });
@@ -190020,9 +189882,9 @@ async function createComponent(client2, config2, sourcedIds) {
       prerequisiteCriteria: config2.component.prerequisiteCriteria
     };
     await client2.oneroster.courseComponents.create({ courseComponent: componentData });
-    log32.info("[TimeBack] Component created", { componentId: sourcedIds.component });
+    log3.info("[TimeBack] Component created", { componentId: sourcedIds.component });
   } catch (error2) {
-    log32.error("[TimeBack] Failed to create component", {
+    log3.error("[TimeBack] Failed to create component", {
       componentId: sourcedIds.component,
       error: error2
     });
@@ -190042,11 +189904,11 @@ async function createResource(client2, config2, sourcedIds) {
       importance: config2.resource.importance,
       metadata: config2.resource.metadata
     };
-    log32.debug("[TimeBack] Creating resource", { resourceId: sourcedIds.resource });
+    log3.debug("[TimeBack] Creating resource", { resourceId: sourcedIds.resource });
     await client2.oneroster.resources.create({ resource: resourceData });
-    log32.info("[TimeBack] Resource created", { resourceId: sourcedIds.resource });
+    log3.info("[TimeBack] Resource created", { resourceId: sourcedIds.resource });
   } catch (error2) {
-    log32.error("[TimeBack] Failed to create resource", {
+    log3.error("[TimeBack] Failed to create resource", {
       resourceId: sourcedIds.resource,
       error: error2
     });
@@ -190064,17 +189926,17 @@ async function createComponentResourceLink(client2, config2, sourcedIds) {
       sortOrder: config2.componentResource.sortOrder,
       lessonType: config2.componentResource.lessonType
     };
-    log32.debug("[TimeBack] Creating component-resource link", {
+    log3.debug("[TimeBack] Creating component-resource link", {
       componentResourceId: sourcedIds.componentResource
     });
     await client2.oneroster.componentResources.create({
       componentResource: componentResourceData
     });
-    log32.info("[TimeBack] Component-resource link created", {
+    log3.info("[TimeBack] Component-resource link created", {
       componentResourceId: sourcedIds.componentResource
     });
   } catch (error2) {
-    log32.error("[TimeBack] Failed to create component-resource link", {
+    log3.error("[TimeBack] Failed to create component-resource link", {
       componentResourceId: sourcedIds.componentResource,
       error: error2
     });
@@ -190098,7 +189960,7 @@ async function setupTimebackResources(client2, config2, options) {
       ...verboseData && { verboseData }
     };
   } catch (error2) {
-    log32.error("[TimeBack] Setup failed", { error: error2 });
+    log3.error("[TimeBack] Setup failed", { error: error2 });
     throw error2;
   }
 }
@@ -190117,9 +189979,9 @@ async function updateCourse(client2, config2, courseId) {
       metadata: config2.course.metadata
     };
     await client2.oneroster.courses.update(courseId, courseData);
-    log32.info("[TimeBack] Course updated", { courseId });
+    log3.info("[TimeBack] Course updated", { courseId });
   } catch (error2) {
-    log32.error("[TimeBack] Failed to update course", {
+    log3.error("[TimeBack] Failed to update course", {
       courseId,
       error: error2
     });
@@ -190138,9 +190000,9 @@ async function updateComponent(client2, config2, sourcedIds) {
       prerequisiteCriteria: config2.component.prerequisiteCriteria
     };
     await client2.oneroster.courseComponents.update(sourcedIds.component, componentData);
-    log32.info("[TimeBack] Component updated", { componentId: sourcedIds.component });
+    log3.info("[TimeBack] Component updated", { componentId: sourcedIds.component });
   } catch (error2) {
-    log32.error("[TimeBack] Failed to update component", {
+    log3.error("[TimeBack] Failed to update component", {
       componentId: sourcedIds.component,
       error: error2
     });
@@ -190161,9 +190023,9 @@ async function updateResource(client2, config2, resourceId) {
       metadata: config2.resource.metadata
     };
     await client2.oneroster.resources.update(resourceId, resourceData);
-    log32.info("[TimeBack] Resource updated", { resourceId });
+    log3.info("[TimeBack] Resource updated", { resourceId });
   } catch (error2) {
-    log32.error("[TimeBack] Failed to update resource", {
+    log3.error("[TimeBack] Failed to update resource", {
       resourceId,
       error: error2
     });
@@ -190182,11 +190044,11 @@ async function updateComponentResourceLink(client2, config2, sourcedIds) {
       lessonType: config2.componentResource.lessonType
     };
     await client2.oneroster.componentResources.update(sourcedIds.componentResource, componentResourceData);
-    log32.info("[TimeBack] Component-resource link updated", {
+    log3.info("[TimeBack] Component-resource link updated", {
       componentResourceId: sourcedIds.componentResource
     });
   } catch (error2) {
-    log32.error("[TimeBack] Failed to update component-resource link", {
+    log3.error("[TimeBack] Failed to update component-resource link", {
       componentResourceId: sourcedIds.componentResource,
       error: error2
     });
@@ -190355,7 +190217,7 @@ async function request({
         lastError = error2;
         if (attempt < retries) {
           const delay = Math.pow(HTTP_DEFAULTS.retryBackoffBase, attempt) * 1000;
-          log32.warn(`[TimebackClient] Request failed, retrying in ${delay}ms`, {
+          log3.warn(`[TimebackClient] Request failed, retrying in ${delay}ms`, {
             attempt: attempt + 1,
             maxRetries: retries,
             status: res.status,
@@ -190387,7 +190249,7 @@ async function request({
       lastError = error2 instanceof Error ? error2 : new Error(String(error2));
       if (attempt < retries) {
         const delay = Math.pow(HTTP_DEFAULTS.retryBackoffBase, attempt) * 1000;
-        log32.warn(`[TimebackClient] Network error, retrying in ${delay}ms`, {
+        log3.warn(`[TimebackClient] Network error, retrying in ${delay}ms`, {
           attempt: attempt + 1,
           maxRetries: retries,
           error: lastError.message,
@@ -190410,11 +190272,158 @@ async function requestCaliper(options) {
   });
 }
 init_constants();
+function createCaliperNamespace(client2) {
+  const urls = createOneRosterUrls(client2.getBaseUrl());
+  const caliper = {
+    emit: async (event, sensorUrl) => {
+      const envelope = {
+        sensor: sensorUrl,
+        sendTime: new Date().toISOString(),
+        dataVersion: CALIPER_CONSTANTS.dataVersion,
+        data: [event]
+      };
+      return client2["requestCaliper"](CALIPER_ENDPOINTS.events, "POST", envelope);
+    },
+    emitBatch: async (events, sensorUrl) => {
+      if (events.length === 0)
+        return;
+      const envelope = {
+        sensor: sensorUrl,
+        sendTime: new Date().toISOString(),
+        dataVersion: CALIPER_CONSTANTS.dataVersion,
+        data: events
+      };
+      return client2["requestCaliper"](CALIPER_ENDPOINTS.events, "POST", envelope);
+    },
+    emitActivityEvent: async (data) => {
+      const event = {
+        "@context": CALIPER_CONSTANTS.context,
+        id: `urn:uuid:${crypto.randomUUID()}`,
+        type: TIMEBACK_EVENT_TYPES.activityEvent,
+        eventTime: new Date().toISOString(),
+        profile: CALIPER_CONSTANTS.profile,
+        actor: {
+          id: urls.user(data.studentId),
+          type: TIMEBACK_TYPES.user,
+          email: data.studentEmail
+        },
+        action: TIMEBACK_ACTIONS.completed,
+        object: {
+          id: caliper.buildActivityUrl(data),
+          type: TIMEBACK_TYPES.activityContext,
+          subject: data.subject,
+          app: {
+            name: data.appName
+          },
+          activity: {
+            name: data.activityName
+          },
+          course: { id: urls.course(data.courseId), name: data.activityName },
+          process: false
+        },
+        generated: {
+          id: `urn:timeback:metrics:activity-completion-${crypto.randomUUID()}`,
+          type: TIMEBACK_TYPES.activityMetricsCollection,
+          attempt: data.attemptNumber || 1,
+          items: [
+            ...data.totalQuestions !== undefined ? [
+              {
+                type: ACTIVITY_METRIC_TYPES.totalQuestions,
+                value: data.totalQuestions
+              }
+            ] : [],
+            ...data.correctQuestions !== undefined ? [
+              {
+                type: ACTIVITY_METRIC_TYPES.correctQuestions,
+                value: data.correctQuestions
+              }
+            ] : [],
+            ...data.xpEarned !== undefined ? [{ type: ACTIVITY_METRIC_TYPES.xpEarned, value: data.xpEarned }] : [],
+            ...data.masteredUnits !== undefined ? [
+              {
+                type: ACTIVITY_METRIC_TYPES.masteredUnits,
+                value: data.masteredUnits
+              }
+            ] : []
+          ],
+          ...data.extensions ? { extensions: data.extensions } : {}
+        }
+      };
+      return caliper.emit(event, data.sensorUrl);
+    },
+    emitTimeSpentEvent: async (data) => {
+      const event = {
+        "@context": CALIPER_CONSTANTS.context,
+        id: `urn:uuid:${crypto.randomUUID()}`,
+        type: TIMEBACK_EVENT_TYPES.timeSpentEvent,
+        eventTime: new Date().toISOString(),
+        profile: CALIPER_CONSTANTS.profile,
+        actor: {
+          id: urls.user(data.studentId),
+          type: TIMEBACK_TYPES.user,
+          email: data.studentEmail
+        },
+        action: TIMEBACK_ACTIONS.spentTime,
+        object: {
+          id: caliper.buildActivityUrl(data),
+          type: TIMEBACK_TYPES.activityContext,
+          subject: data.subject,
+          app: {
+            name: data.appName
+          },
+          activity: {
+            name: data.activityName
+          },
+          course: { id: urls.course(data.courseId), name: data.activityName },
+          process: false
+        },
+        generated: {
+          id: `urn:timeback:metrics:time-spent-${crypto.randomUUID()}`,
+          type: TIMEBACK_TYPES.timeSpentMetricsCollection,
+          items: [
+            { type: TIME_METRIC_TYPES.active, value: data.activeTimeSeconds },
+            ...data.inactiveTimeSeconds !== undefined ? [
+              {
+                type: TIME_METRIC_TYPES.inactive,
+                value: data.inactiveTimeSeconds
+              }
+            ] : [],
+            ...data.wasteTimeSeconds !== undefined ? [{ type: TIME_METRIC_TYPES.waste, value: data.wasteTimeSeconds }] : []
+          ]
+        }
+      };
+      return caliper.emit(event, data.sensorUrl);
+    },
+    buildActivityUrl: (data) => {
+      const base = data.sensorUrl.replace(/\/$/, "");
+      return `${base}/activities/${data.courseId}/${data.activityId}/${crypto.randomUUID()}`;
+    }
+  };
+  return caliper;
+}
+function createEduBridgeNamespace(client2) {
+  const enrollments = {
+    listByUser: async (userId) => {
+      const response = await client2["request"](`/edubridge/enrollments/user/${userId}`, "GET");
+      return response.data;
+    }
+  };
+  const analytics = {
+    getEnrollmentFacts: async (enrollmentId) => {
+      return client2["request"](`/edubridge/analytics/enrollment/${enrollmentId}`, "GET");
+    }
+  };
+  return {
+    enrollments,
+    analytics
+  };
+}
+init_constants();
 function logTimebackError(operation, error2, context) {
   const errorMessage = error2 instanceof Error ? error2.message : String(error2);
   if (error2 instanceof TimebackApiError) {
     const imsError = error2.details;
-    log32.error(`[TimeBack ${operation}] ${errorMessage}`, {
+    log3.error(`[TimeBack ${operation}] ${errorMessage}`, {
       ...context,
       status: error2.status,
       imsx_codeMajor: imsError?.imsx_codeMajor,
@@ -190425,7 +190434,7 @@ function logTimebackError(operation, error2, context) {
       console.error(`[TimeBack Error during ${operation}] Full details:`, JSON.stringify(error2.details, null, 2));
     }
   } else {
-    log32.error(`[TimeBack ${operation}] ${errorMessage}`, context);
+    log3.error(`[TimeBack ${operation}] ${errorMessage}`, context);
   }
 }
 function createOneRosterNamespace(client2) {
@@ -190624,153 +190633,6 @@ function createOneRosterNamespace(client2) {
   };
 }
 init_constants();
-function createCaliperNamespace(client2) {
-  const urls = createOneRosterUrls(client2.getBaseUrl());
-  const caliper = {
-    emit: async (event, sensorUrl) => {
-      const envelope = {
-        sensor: sensorUrl,
-        sendTime: new Date().toISOString(),
-        dataVersion: CALIPER_CONSTANTS.dataVersion,
-        data: [event]
-      };
-      return client2["requestCaliper"](CALIPER_ENDPOINTS.events, "POST", envelope);
-    },
-    emitBatch: async (events, sensorUrl) => {
-      if (events.length === 0)
-        return;
-      const envelope = {
-        sensor: sensorUrl,
-        sendTime: new Date().toISOString(),
-        dataVersion: CALIPER_CONSTANTS.dataVersion,
-        data: events
-      };
-      return client2["requestCaliper"](CALIPER_ENDPOINTS.events, "POST", envelope);
-    },
-    emitActivityEvent: async (data) => {
-      const event = {
-        "@context": CALIPER_CONSTANTS.context,
-        id: `urn:uuid:${crypto.randomUUID()}`,
-        type: TIMEBACK_EVENT_TYPES.activityEvent,
-        eventTime: new Date().toISOString(),
-        profile: CALIPER_CONSTANTS.profile,
-        actor: {
-          id: urls.user(data.studentId),
-          type: TIMEBACK_TYPES.user,
-          email: data.studentEmail
-        },
-        action: TIMEBACK_ACTIONS.completed,
-        object: {
-          id: caliper.buildActivityUrl(data),
-          type: TIMEBACK_TYPES.activityContext,
-          subject: data.subject,
-          app: {
-            name: data.appName
-          },
-          activity: {
-            name: data.activityName
-          },
-          course: { id: urls.course(data.courseId), name: data.activityName },
-          process: false
-        },
-        generated: {
-          id: `urn:timeback:metrics:activity-completion-${crypto.randomUUID()}`,
-          type: TIMEBACK_TYPES.activityMetricsCollection,
-          attempt: data.attemptNumber || 1,
-          items: [
-            ...data.totalQuestions !== undefined ? [
-              {
-                type: ACTIVITY_METRIC_TYPES.totalQuestions,
-                value: data.totalQuestions
-              }
-            ] : [],
-            ...data.correctQuestions !== undefined ? [
-              {
-                type: ACTIVITY_METRIC_TYPES.correctQuestions,
-                value: data.correctQuestions
-              }
-            ] : [],
-            ...data.xpEarned !== undefined ? [{ type: ACTIVITY_METRIC_TYPES.xpEarned, value: data.xpEarned }] : [],
-            ...data.masteredUnits !== undefined ? [
-              {
-                type: ACTIVITY_METRIC_TYPES.masteredUnits,
-                value: data.masteredUnits
-              }
-            ] : []
-          ],
-          ...data.extensions ? { extensions: data.extensions } : {}
-        }
-      };
-      return caliper.emit(event, data.sensorUrl);
-    },
-    emitTimeSpentEvent: async (data) => {
-      const event = {
-        "@context": CALIPER_CONSTANTS.context,
-        id: `urn:uuid:${crypto.randomUUID()}`,
-        type: TIMEBACK_EVENT_TYPES.timeSpentEvent,
-        eventTime: new Date().toISOString(),
-        profile: CALIPER_CONSTANTS.profile,
-        actor: {
-          id: urls.user(data.studentId),
-          type: TIMEBACK_TYPES.user,
-          email: data.studentEmail
-        },
-        action: TIMEBACK_ACTIONS.spentTime,
-        object: {
-          id: caliper.buildActivityUrl(data),
-          type: TIMEBACK_TYPES.activityContext,
-          subject: data.subject,
-          app: {
-            name: data.appName
-          },
-          activity: {
-            name: data.activityName
-          },
-          course: { id: urls.course(data.courseId), name: data.activityName },
-          process: false
-        },
-        generated: {
-          id: `urn:timeback:metrics:time-spent-${crypto.randomUUID()}`,
-          type: TIMEBACK_TYPES.timeSpentMetricsCollection,
-          items: [
-            { type: TIME_METRIC_TYPES.active, value: data.activeTimeSeconds },
-            ...data.inactiveTimeSeconds !== undefined ? [
-              {
-                type: TIME_METRIC_TYPES.inactive,
-                value: data.inactiveTimeSeconds
-              }
-            ] : [],
-            ...data.wasteTimeSeconds !== undefined ? [{ type: TIME_METRIC_TYPES.waste, value: data.wasteTimeSeconds }] : []
-          ]
-        }
-      };
-      return caliper.emit(event, data.sensorUrl);
-    },
-    buildActivityUrl: (data) => {
-      const base = data.sensorUrl.replace(/\/$/, "");
-      return `${base}/activities/${data.courseId}/${data.activityId}/${crypto.randomUUID()}`;
-    }
-  };
-  return caliper;
-}
-function createEduBridgeNamespace(client2) {
-  const enrollments = {
-    listByUser: async (userId) => {
-      const response = await client2["request"](`/edubridge/enrollments/user/${userId}`, "GET");
-      return response.data;
-    }
-  };
-  const analytics = {
-    getEnrollmentFacts: async (enrollmentId) => {
-      return client2["request"](`/edubridge/analytics/enrollment/${enrollmentId}`, "GET");
-    }
-  };
-  return {
-    enrollments,
-    analytics
-  };
-}
-init_constants();
 init_constants();
 
 class TimebackCache {
@@ -190792,7 +190654,7 @@ class TimebackCache {
     }
     if (Date.now() > entry.expiresAt) {
       this.delete(key);
-      log32.debug(`[${this.name}] Cache entry expired`, { key });
+      log3.debug(`[${this.name}] Cache entry expired`, { key });
       this.misses++;
       return;
     }
@@ -190807,7 +190669,7 @@ class TimebackCache {
     }
     this.cache.set(key, { value, expiresAt });
     this._updateAccessOrder(key);
-    log32.debug(`[${this.name}] Cache entry set`, {
+    log3.debug(`[${this.name}] Cache entry set`, {
       key,
       expiresAt: new Date(expiresAt).toISOString()
     });
@@ -190822,7 +190684,7 @@ class TimebackCache {
   clear() {
     this.cache.clear();
     this.accessOrder = [];
-    log32.debug(`[${this.name}] Cache cleared`);
+    log3.debug(`[${this.name}] Cache cleared`);
   }
   size() {
     return this.cache.size;
@@ -190845,7 +190707,7 @@ class TimebackCache {
       this.delete(key);
     }
     if (expiredKeys.length > 0) {
-      log32.debug(`[${this.name}] Cleaned up expired entries`, {
+      log3.debug(`[${this.name}] Cleaned up expired entries`, {
         count: expiredKeys.length
       });
     }
@@ -190870,7 +190732,7 @@ class TimebackCache {
       return;
     const oldestKey = this.accessOrder[0];
     this.delete(oldestKey);
-    log32.debug(`[${this.name}] Evicted LRU entry`, { key: oldestKey });
+    log3.debug(`[${this.name}] Evicted LRU entry`, { key: oldestKey });
   }
 }
 
@@ -190930,7 +190792,7 @@ class TimebackCacheManager {
     this.assessmentLineItemCache.clear();
     this.resourceMasteryCache.clear();
     this.enrollmentCache.clear();
-    log32.info("[TimebackCacheManager] All caches cleared");
+    log3.info("[TimebackCacheManager] All caches cleared");
   }
   getStats() {
     return {
@@ -190945,7 +190807,7 @@ class TimebackCacheManager {
     this.assessmentLineItemCache.cleanup();
     this.resourceMasteryCache.cleanup();
     this.enrollmentCache.cleanup();
-    log32.debug("[TimebackCacheManager] Cache cleanup completed");
+    log3.debug("[TimebackCacheManager] Cache cleanup completed");
   }
 }
 init_constants();
@@ -190966,7 +190828,7 @@ class MasteryTracker {
     }
     const masterableUnits = await this.resolveMasterableUnits(resourceId);
     if (!masterableUnits || masterableUnits <= 0) {
-      log32.warn("[MasteryTracker] No masterableUnits configured for course", {
+      log3.warn("[MasteryTracker] No masterableUnits configured for course", {
         courseId,
         resourceId
       });
@@ -190974,7 +190836,7 @@ class MasteryTracker {
     }
     const facts = await this.fetchEnrollmentAnalyticsFacts(studentId, courseId);
     if (!facts) {
-      log32.warn("[MasteryTracker] Unable to retrieve analytics for mastery-based completion", {
+      log3.warn("[MasteryTracker] Unable to retrieve analytics for mastery-based completion", {
         studentId,
         courseId
       });
@@ -191014,13 +190876,13 @@ class MasteryTracker {
           appName
         }
       });
-      log32.info("[MasteryTracker] Created mastery completion entry", {
+      log3.info("[MasteryTracker] Created mastery completion entry", {
         studentId,
         lineItemId,
         resultId
       });
     } catch (error2) {
-      log32.error("[MasteryTracker] Failed to create mastery completion entry", {
+      log3.error("[MasteryTracker] Failed to create mastery completion entry", {
         studentId,
         lineItemId,
         error: error2
@@ -191045,7 +190907,7 @@ class MasteryTracker {
       this.cacheManager.setResourceMasterableUnits(resourceId, masterableUnits ?? null);
       return masterableUnits;
     } catch (error2) {
-      log32.error("[MasteryTracker] Failed to fetch resource metadata for mastery config", {
+      log3.error("[MasteryTracker] Failed to fetch resource metadata for mastery config", {
         resourceId,
         error: error2
       });
@@ -191058,7 +190920,7 @@ class MasteryTracker {
       const enrollments = await this.edubridgeNamespace.enrollments.listByUser(studentId);
       const enrollment = enrollments.find((e2) => e2.course.id === courseId);
       if (!enrollment) {
-        log32.warn("[MasteryTracker] Enrollment not found for student/course", {
+        log3.warn("[MasteryTracker] Enrollment not found for student/course", {
           studentId,
           courseId
         });
@@ -191067,7 +190929,7 @@ class MasteryTracker {
       const analytics = await this.edubridgeNamespace.analytics.getEnrollmentFacts(enrollment.id);
       return analytics.facts;
     } catch (error2) {
-      log32.error("[MasteryTracker] Failed to load enrollment analytics facts", {
+      log3.error("[MasteryTracker] Failed to load enrollment analytics facts", {
         studentId,
         courseId,
         error: error2
@@ -191190,7 +191052,7 @@ class ProgressRecorder {
     if (score !== undefined) {
       await this.createGradebookEntry(actualLineItemId, studentId, currentAttemptNumber, score, totalQuestions, correctQuestions, calculatedXp, masteredUnits, scoreStatus, inProgress, progressData.appName);
     } else {
-      log32.warn("[ProgressRecorder] Score not provided, skipping gradebook entry", {
+      log3.warn("[ProgressRecorder] Score not provided, skipping gradebook entry", {
         studentId,
         activityId,
         attemptNumber: currentAttemptNumber
@@ -191237,13 +191099,13 @@ class ProgressRecorder {
   }
   calculateXpForProgress(progressData, totalQuestions, correctQuestions, xpEarned, isFirstAttempt) {
     if (xpEarned !== undefined) {
-      log32.debug("[ProgressRecorder] Using provided XP", { xpEarned });
+      log3.debug("[ProgressRecorder] Using provided XP", { xpEarned });
       return xpEarned;
     }
     if (progressData.sessionDurationSeconds && totalQuestions && correctQuestions) {
       const accuracy = correctQuestions / totalQuestions;
       const calculatedXp = calculateXp(progressData.sessionDurationSeconds, accuracy, isFirstAttempt);
-      log32.debug("[ProgressRecorder] Calculated XP", {
+      log3.debug("[ProgressRecorder] Calculated XP", {
         durationSeconds: progressData.sessionDurationSeconds,
         accuracy,
         isFirstAttempt,
@@ -191325,7 +191187,7 @@ class ProgressRecorder {
       sensorUrl: progressData.sensorUrl,
       extensions: extensions || progressData.extensions
     }).catch((error2) => {
-      log32.error("[ProgressRecorder] Failed to emit activity event", { error: error2 });
+      log3.error("[ProgressRecorder] Failed to emit activity event", { error: error2 });
     });
   }
 }
@@ -195371,7 +195233,7 @@ class StudentResolver {
       if (error2 instanceof TimebackAuthenticationError || error2 instanceof StudentNotFoundError || error2 instanceof TimebackError) {
         throw error2;
       }
-      log32.error("[StudentResolver] Failed to find student by email", {
+      log3.error("[StudentResolver] Failed to find student by email", {
         email,
         error: error2
       });
@@ -195395,7 +195257,7 @@ class StudentResolver {
       this.cacheStudent(email, studentId, studentData);
       return studentData;
     } catch (error2) {
-      log32.error("[StudentResolver] Failed to fetch student by ID, using fallback", {
+      log3.error("[StudentResolver] Failed to fetch student by ID, using fallback", {
         studentId,
         error: error2,
         errorMessage: error2 instanceof Error ? error2.message : String(error2),
@@ -195446,7 +195308,7 @@ class TimebackClient {
     this.sessionRecorder = new SessionRecorder(this.studentResolver, this.caliper);
     if (this.credentials) {
       this._ensureAuthenticated().catch((error2) => {
-        log32.error("[TimebackClient] Auto-authentication failed", { error: error2 });
+        log3.error("[TimebackClient] Auto-authentication failed", { error: error2 });
       });
     }
   }
@@ -195506,11 +195368,11 @@ class TimebackClient {
       };
       const tokenData = await getTimebackTokenResponse(authConfig);
       this.setToken(tokenData.access_token, tokenData.expires_in);
-      log32.debug("[TimebackClient] Authentication successful", {
+      log3.debug("[TimebackClient] Authentication successful", {
         expiresIn: tokenData.expires_in
       });
     } catch (error2) {
-      log32.error("[TimebackClient] Authentication failed", { error: error2 });
+      log3.error("[TimebackClient] Authentication failed", { error: error2 });
       const errorMessage = error2 instanceof Error ? error2.message : String(error2);
       throw new TimebackAuthenticationError(`TimeBack authentication failed: ${errorMessage}. Verify that your client credentials are correct and not expired. Environment: ${this.baseUrl}.`);
     }
@@ -196216,6 +196078,68 @@ function buildResourceMetadata({
   }
   return metadata2;
 }
+init_src();
+async function fetchEnrollmentsForUser(timebackId) {
+  const db = getDatabase();
+  const isLocal = process.env.PUBLIC_IS_LOCAL === "true";
+  if (isLocal) {
+    const allIntegrations = await db.query.gameTimebackIntegrations.findMany();
+    return allIntegrations.map((integration) => ({
+      gameId: integration.gameId,
+      grade: integration.grade,
+      subject: integration.subject,
+      courseId: integration.courseId
+    }));
+  }
+  log2.debug("[timeback-enrollments] Fetching student enrollments from TimeBack", { timebackId });
+  try {
+    const client2 = await getTimebackClient();
+    const classes = await client2.getEnrollments(timebackId);
+    const courseIds = classes.map((cls) => cls.courseId).filter((id) => Boolean(id));
+    if (courseIds.length === 0) {
+      return [];
+    }
+    const integrations = await db.query.gameTimebackIntegrations.findMany({
+      where: inArray(gameTimebackIntegrations.courseId, courseIds)
+    });
+    return integrations.map((integration) => ({
+      gameId: integration.gameId,
+      grade: integration.grade,
+      subject: integration.subject,
+      courseId: integration.courseId
+    }));
+  } catch (error2) {
+    log2.warn("[timeback-enrollments] Failed to fetch TimeBack enrollments:", {
+      error: error2,
+      timebackId
+    });
+    return [];
+  }
+}
+async function fetchUserRole(timebackId) {
+  log2.debug("[timeback] Fetching user role from TimeBack", { timebackId });
+  try {
+    const client2 = await getTimebackClient();
+    const user = await client2.oneroster.users.get(timebackId);
+    const primaryRole = user.roles.find((r22) => r22.roleType === "primary");
+    const role = primaryRole?.role ?? user.roles[0]?.role ?? "student";
+    log2.debug("[timeback] Resolved user role", { timebackId, role });
+    return role;
+  } catch (error2) {
+    log2.warn("[timeback] Failed to fetch user role, defaulting to student:", {
+      error: error2,
+      timebackId
+    });
+    return "student";
+  }
+}
+async function fetchUserTimebackData(timebackId) {
+  const [role, enrollments] = await Promise.all([
+    fetchUserRole(timebackId),
+    fetchEnrollmentsForUser(timebackId)
+  ]);
+  return { role, enrollments };
+}
 var AchievementCompletionType;
 ((AchievementCompletionType2) => {
   AchievementCompletionType2["TIME_PLAYED_SESSION"] = "time_played_session";
@@ -199521,20 +199445,44 @@ var logger3 = {
   warn: (msg) => getLogger().warn(msg),
   error: (msg) => getLogger().error(msg)
 };
-function detectTimebackCourses() {
-  const coursePattern = /^SANDBOX_TIMEBACK_COURSE_(\d+)_([A-Z_]+)$/i;
-  const courses = [];
-  for (const [key, value] of Object.entries(process.env)) {
-    const match2 = key.match(coursePattern);
-    if (match2 && value) {
-      const gradeStr = match2[1];
-      const subjectStr = match2[2];
-      const grade = parseInt(gradeStr, 10);
-      const subject = subjectStr.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-      courses.push({ grade, subject, courseId: value });
+function resolveStudentId(studentId) {
+  if (!studentId)
+    return null;
+  if (studentId === "mock")
+    return `mock-student-${crypto.randomUUID().slice(0, 8)}`;
+  return studentId;
+}
+function getAdminTimebackId() {
+  return resolveStudentId(config.timeback.studentId);
+}
+async function seedTimebackIntegrations(db, gameId, courses) {
+  const now2 = new Date;
+  let seededCount = 0;
+  for (const course of courses) {
+    const courseId = course.courseId || `mock-${course.subject.toLowerCase()}-g${course.grade}`;
+    try {
+      const existing = await db.query.gameTimebackIntegrations.findFirst({
+        where: (table14, { and: and3, eq: eq3 }) => and3(eq3(table14.gameId, gameId), eq3(table14.grade, course.grade), eq3(table14.subject, course.subject))
+      });
+      if (existing) {
+        continue;
+      }
+      await db.insert(gameTimebackIntegrations).values({
+        gameId,
+        courseId,
+        grade: course.grade,
+        subject: course.subject,
+        totalXp: course.totalXp ?? 1000,
+        lastVerifiedAt: now2
+      });
+      seededCount++;
+    } catch (error2) {
+      console.error(`❌ Error seeding TimeBack integration for ${course.subject}:${course.grade}:`, error2);
     }
   }
-  return courses;
+  if (seededCount > 0) {
+    logger3.info(`\uD83D\uDCDA Seeded ${seededCount} TimeBack integration(s)`);
+  }
 }
 async function seedCoreGames(db) {
   const now2 = new Date;
@@ -199560,28 +199508,6 @@ async function seedCoreGames(db) {
       console.error(`Error seeding core game '${gameData.slug}':`, error2);
     }
   }
-  if (hasTimebackCredentials()) {
-    const courses = detectTimebackCourses();
-    if (courses.length > 0) {
-      for (const course of courses) {
-        try {
-          await db.insert(gameTimebackIntegrations).values({
-            id: crypto.randomUUID(),
-            gameId: CORE_GAME_UUIDS.PLAYGROUND,
-            courseId: course.courseId,
-            grade: course.grade,
-            subject: course.subject,
-            totalXp: null,
-            lastVerifiedAt: null,
-            createdAt: now2,
-            updatedAt: now2
-          }).onConflictDoNothing();
-        } catch (error2) {
-          console.error(`Error seeding TimeBack integration for playground (${course.subject} grade ${course.grade}):`, error2);
-        }
-      }
-    }
-  }
 }
 async function seedCurrentProjectGame(db, project) {
   const now2 = new Date;
@@ -199591,6 +199517,9 @@ async function seedCurrentProjectGame(db, project) {
     });
     if (existingGame) {
       logger3.info(`\uD83C\uDFAE Game "${project.displayName}" (${project.slug}) already exists`);
+      if (project.timebackCourses && project.timebackCourses.length > 0) {
+        await seedTimebackIntegrations(db, existingGame.id, project.timebackCourses);
+      }
       return existingGame;
     }
     const gameRecord = {
@@ -199610,23 +199539,11 @@ async function seedCurrentProjectGame(db, project) {
       updatedAt: now2
     };
     const [newGame] = await db.insert(games).values(gameRecord).returning();
-    if (hasTimebackCredentials()) {
-      const courses = detectTimebackCourses();
-      if (courses.length > 0) {
-        for (const course of courses) {
-          await db.insert(gameTimebackIntegrations).values({
-            id: crypto.randomUUID(),
-            gameId: newGame.id,
-            courseId: course.courseId,
-            grade: course.grade,
-            subject: course.subject,
-            totalXp: null,
-            lastVerifiedAt: null,
-            createdAt: now2,
-            updatedAt: now2
-          }).onConflictDoNothing();
-        }
-      }
+    if (!newGame) {
+      throw new Error("Failed to create game record");
+    }
+    if (project.timebackCourses && project.timebackCourses.length > 0) {
+      await seedTimebackIntegrations(db, newGame.id, project.timebackCourses);
     }
     return newGame;
   } catch (error2) {
@@ -199686,10 +199603,11 @@ async function seedSpriteTemplates(db) {
 }
 async function seedDemoData(db) {
   try {
+    const adminTimebackId = getAdminTimebackId();
     for (const [role, user] of Object.entries(DEMO_USERS)) {
       const userValues = {
         ...user,
-        timebackId: role === "admin" && config.timeback.studentId ? config.timeback.studentId : null
+        timebackId: role === "admin" ? adminTimebackId : null
       };
       await db.insert(users).values(userValues).onConflictDoNothing();
     }
@@ -205052,9 +204970,11 @@ async function getUserMe(ctx) {
     const timebackAccount = await db.query.accounts.findFirst({
       where: and(eq(accounts.userId, user.id), eq(accounts.providerId, "timeback"))
     });
+    const timeback3 = userData.timebackId ? await fetchUserTimebackData(userData.timebackId) : undefined;
     return {
       ...userData,
-      hasTimebackAccount: !!timebackAccount
+      hasTimebackAccount: !!timebackAccount,
+      timeback: timeback3
     };
   } catch (error2) {
     if (error2 instanceof ApiError)
@@ -209165,7 +209085,7 @@ async function getPlayerCharacter(ctx) {
     throw ApiError.unauthorized("Login required");
   try {
     const db = getDatabase();
-    const pc2 = await db.query.playerCharacters.findFirst({
+    const pc3 = await db.query.playerCharacters.findFirst({
       where: eq(playerCharacters.userId, user.id),
       with: {
         accessories: {
@@ -209175,7 +209095,7 @@ async function getPlayerCharacter(ctx) {
         }
       }
     });
-    return pc2 ?? null;
+    return pc3 ?? null;
   } catch (error2) {
     log2.error("Error fetching player character", { error: error2 });
     throw ApiError.internal("Failed to get player character", error2);
@@ -209191,7 +209111,7 @@ async function getPlayerCharacterById(ctx) {
   }
   try {
     const db = getDatabase();
-    const pc2 = await db.query.playerCharacters.findFirst({
+    const pc3 = await db.query.playerCharacters.findFirst({
       where: eq(playerCharacters.userId, userId),
       with: {
         accessories: {
@@ -209201,7 +209121,7 @@ async function getPlayerCharacterById(ctx) {
         }
       }
     });
-    return pc2 ?? null;
+    return pc3 ?? null;
   } catch (error2) {
     log2.error("Error fetching player character by ID", { userId, error: error2 });
     throw ApiError.internal("Failed to get player character", error2);
@@ -210436,48 +210356,12 @@ async function getStudentEnrollments(ctx) {
   if (!timebackId) {
     throw ApiError.badRequest("Missing timebackId parameter");
   }
-  const db = getDatabase();
-  const isLocal = process.env.PUBLIC_IS_LOCAL === "true";
-  if (isLocal) {
-    log2.debug("[API] Local mode: returning all integrations as mock enrollments", {
-      userId: user.id,
-      timebackId
-    });
-    const allIntegrations = await db.query.gameTimebackIntegrations.findMany();
-    const enrollments2 = allIntegrations.map((integration) => ({
-      gameId: integration.gameId,
-      grade: integration.grade,
-      subject: integration.subject,
-      courseId: integration.courseId
-    }));
-    log2.info("[API] Retrieved mock enrollments (local mode)", {
-      userId: user.id,
-      timebackId,
-      enrollmentCount: enrollments2.length
-    });
-    return { enrollments: enrollments2 };
-  }
   log2.debug("[API] Getting student enrollments", { userId: user.id, timebackId });
-  const client2 = await getTimebackClient();
-  const classes = await client2.getEnrollments(timebackId);
-  const courseIds = classes.map((cls) => cls.courseId).filter((id) => Boolean(id));
-  if (courseIds.length === 0) {
-    return { enrollments: [] };
-  }
-  const integrations = await db.query.gameTimebackIntegrations.findMany({
-    where: inArray(gameTimebackIntegrations.courseId, courseIds)
-  });
-  const enrollments = integrations.map((integration) => ({
-    gameId: integration.gameId,
-    grade: integration.grade,
-    subject: integration.subject,
-    courseId: integration.courseId
-  }));
+  const enrollments = await fetchEnrollmentsForUser(timebackId);
   log2.info("[API] Retrieved student enrollments", {
     userId: user.id,
     timebackId,
-    totalClasses: classes.length,
-    mappedEnrollments: enrollments.length
+    enrollmentCount: enrollments.length
   });
   return { enrollments };
 }
@@ -210985,8 +210869,8 @@ function registerRoutes(app) {
     return c3.json({ error: "Not Found", message: `Route ${c3.req.path} not found` }, 404);
   });
 }
-var version3 = package_default2.version;
-async function startServer2(port, project, options = {}) {
+var version3 = package_default.version;
+async function startServer(port, project, options = {}) {
   const processedOptions = processServerOptions(port, options);
   const db = await setupServerDatabase(processedOptions, project);
   const app = createApp(db, {
@@ -211008,17 +210892,71 @@ async function startServer2(port, project, options = {}) {
   };
 }
 
+// src/lib/logging/adapter.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+function formatTimestamp2() {
+  const now2 = new Date;
+  const hours = now2.getHours();
+  const minutes = now2.getMinutes().toString().padStart(2, "0");
+  const seconds = now2.getSeconds().toString().padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const displayHours = hours % 12 || 12;
+  return import_picocolors3.dim(`${displayHours}:${minutes}:${seconds} ${ampm}`);
+}
+function createLoggerAdapter(prefix2) {
+  const formattedPrefix = import_picocolors3.dim(`(${prefix2})`);
+  const label = import_picocolors3.cyan(import_picocolors3.bold("[playcademy]"));
+  return {
+    info: (msg) => console.log(`${formatTimestamp2()} ${label} ${formattedPrefix} ${msg}`),
+    warn: (msg) => console.warn(`${formatTimestamp2()} ${label} ${formattedPrefix} ${msg}`),
+    error: (msg) => console.error(`${formatTimestamp2()} ${label} ${formattedPrefix} ${msg}`)
+  };
+}
+// src/lib/logging/utils.ts
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+function printBanner(viteConfig, servers, projectInfo, pluginVersion) {
+  const INDENT = " ".repeat(2);
+  viteConfig.logger.info("");
+  viteConfig.logger.info(`${INDENT}${import_picocolors4.green(import_picocolors4.bold("PLAYCADEMY"))} ${import_picocolors4.green(`v${pluginVersion}`)}`);
+  viteConfig.logger.info("");
+  viteConfig.logger.info(`${INDENT}${import_picocolors4.green("➜")}  ${import_picocolors4.bold("Game:")}     ${import_picocolors4.cyan(projectInfo.slug)}`);
+  viteConfig.logger.info(`${INDENT}${import_picocolors4.green("➜")}  ${import_picocolors4.bold("Sandbox:")}  ${import_picocolors4.cyan(`http://localhost:${import_picocolors4.bold(servers.sandbox.toString())}/api`)}`);
+  if (servers.backend) {
+    const backendUrl = servers.vite ? `http://localhost:${import_picocolors4.bold(servers.vite.toString())}/api ${import_picocolors4.dim(`(via ${servers.backend})`)}` : `http://localhost:${import_picocolors4.bold(servers.backend.toString())}/api`;
+    viteConfig.logger.info(`${INDENT}${import_picocolors4.green("➜")}  ${import_picocolors4.bold("Backend:")}  ${import_picocolors4.cyan(backendUrl)}`);
+  }
+  if (servers.realtime) {
+    viteConfig.logger.info(`${INDENT}${import_picocolors4.green("➜")}  ${import_picocolors4.bold("Realtime:")} ${import_picocolors4.cyan(`ws://localhost:${import_picocolors4.bold(servers.realtime.toString())}`)}`);
+  }
+  viteConfig.logger.info("");
+}
 // src/lib/sandbox/project-info.ts
 import fs6 from "node:fs";
 import path5 from "node:path";
 import { loadPlaycademyConfig } from "playcademy/utils";
-async function extractProjectInfo(viteConfig) {
+function extractTimebackCourses(config2, timebackOptions) {
+  const courses = config2?.integrations?.timeback?.courses;
+  if (!courses || courses.length === 0)
+    return;
+  return courses.map((course) => {
+    const key = `${course.subject}:${course.grade}`;
+    const overrideId = timebackOptions?.courses?.[key];
+    const courseId = overrideId && overrideId !== "mock" ? overrideId : undefined;
+    return {
+      subject: course.subject,
+      grade: course.grade,
+      courseId,
+      totalXp: course.totalXp,
+      masterableUnits: course.masterableUnits
+    };
+  });
+}
+async function extractProjectInfo(viteConfig, timebackOptions) {
   const projectRoot = viteConfig.root;
   const directoryName = path5.basename(projectRoot);
-  let configName;
+  let config2 = null;
   try {
-    const config2 = await loadPlaycademyConfig();
-    configName = config2?.name;
+    config2 = await loadPlaycademyConfig();
   } catch {}
   let packageJson = {};
   try {
@@ -211028,7 +210966,7 @@ async function extractProjectInfo(viteConfig) {
       packageJson = JSON.parse(packageJsonContent);
     }
   } catch {}
-  const name3 = configName || (typeof packageJson.name === "string" ? packageJson.name : "");
+  const name3 = config2?.name || packageJson.name || "";
   let slug = name3;
   if (slug.includes("/")) {
     slug = slug.split("/")[1] || slug;
@@ -211040,12 +210978,21 @@ async function extractProjectInfo(viteConfig) {
   return {
     slug,
     displayName,
-    version: (typeof packageJson.version === "string" ? packageJson.version : null) || "dev",
-    description: typeof packageJson.description === "string" ? packageJson.description : undefined
+    version: packageJson.version || "dev",
+    description: packageJson.description,
+    timebackCourses: extractTimebackCourses(config2, timebackOptions)
   };
 }
 
 // src/lib/sandbox/timeback.ts
+var import_picocolors5 = __toESM(require_picocolors(), 1);
+function getEffectiveTimebackId(timeback) {
+  if (timeback?.timebackId)
+    return timeback.timebackId;
+  if (timeback?.courses && Object.keys(timeback.courses).length > 0)
+    return "mock";
+  return;
+}
 function detectTimebackOptions() {
   if (process.env.TIMEBACK_LOCAL === "true") {
     return {
@@ -211070,16 +211017,60 @@ function detectTimebackOptions() {
   }
   return;
 }
+function hasTimebackCredentials2() {
+  const config2 = detectTimebackOptions();
+  if (!config2)
+    return false;
+  if (config2.mode === "local") {
+    return !!(config2.onerosterApiUrl && config2.caliperApiUrl);
+  }
+  return !!(config2.onerosterApiUrl && config2.clientId && config2.clientSecret && config2.authUrl);
+}
+function validateTimebackConfig(viteConfig, timeback) {
+  if (!timeback?.courses)
+    return;
+  const realCourses = Object.entries(timeback.courses).filter(([, value]) => value !== "mock");
+  if (realCourses.length > 0 && !hasTimebackCredentials2()) {
+    const courseList = realCourses.map(([key]) => key).join(", ");
+    viteConfig.logger.warn("");
+    viteConfig.logger.warn(import_picocolors5.default.yellow(`⚠️  TimeBack: Real course IDs for ${import_picocolors5.default.bold(courseList)} but credentials missing.`));
+    viteConfig.logger.warn(import_picocolors5.default.dim(`   Required: TIMEBACK_API_CLIENT_ID, TIMEBACK_API_CLIENT_SECRET, TIMEBACK_API_AUTH_URL, TIMEBACK_ONEROSTER_API_URL`));
+    viteConfig.logger.warn(import_picocolors5.default.dim(`   Or use 'mock' for local testing.`));
+    viteConfig.logger.warn("");
+  }
+}
+function generateTimebackJson(timeback) {
+  if (!timeback?.courses || Object.keys(timeback.courses).length === 0) {
+    return;
+  }
+  const enrollments = [];
+  for (const [key, value] of Object.entries(timeback.courses)) {
+    const parts2 = key.split(":");
+    const subject = parts2[0];
+    const gradeStr = parts2[1];
+    const grade = gradeStr ? parseInt(gradeStr, 10) : NaN;
+    if (!subject || isNaN(grade))
+      continue;
+    const courseId = value === "mock" ? `mock-${subject.toLowerCase()}-g${grade}` : value;
+    enrollments.push({ subject, grade, courseId });
+  }
+  if (enrollments.length === 0) {
+    return;
+  }
+  const roleOverride = getTimebackRoleOverride();
+  const role = roleOverride ?? timeback.role ?? "student";
+  return JSON.stringify({ role, enrollments });
+}
 
 // src/lib/sandbox/server.ts
 function printSandboxInfo(viteConfig, apiPort, realtimePort, projectInfo, realtimeEnabled) {
   viteConfig.logger.info("");
-  viteConfig.logger.info(`  ${import_picocolors5.default.green(import_picocolors5.default.bold("PLAYCADEMY"))} ${import_picocolors5.default.green(`v${version3}`)}`);
+  viteConfig.logger.info(`  ${import_picocolors6.default.green(import_picocolors6.default.bold("PLAYCADEMY"))} ${import_picocolors6.default.green(`v${version3}`)}`);
   viteConfig.logger.info("");
-  viteConfig.logger.info(`  ${import_picocolors5.default.green("➜")}  ${import_picocolors5.default.bold("Game:")}     ${import_picocolors5.default.cyan(projectInfo.slug)}`);
-  viteConfig.logger.info(`  ${import_picocolors5.default.green("➜")}  ${import_picocolors5.default.bold("Sandbox:")}  ${import_picocolors5.default.cyan(`http://localhost:${import_picocolors5.default.bold(apiPort.toString())}/api`)}`);
+  viteConfig.logger.info(`  ${import_picocolors6.default.green("➜")}  ${import_picocolors6.default.bold("Game:")}     ${import_picocolors6.default.cyan(projectInfo.slug)}`);
+  viteConfig.logger.info(`  ${import_picocolors6.default.green("➜")}  ${import_picocolors6.default.bold("Sandbox:")}  ${import_picocolors6.default.cyan(`http://localhost:${import_picocolors6.default.bold(apiPort.toString())}/api`)}`);
   if (realtimeEnabled) {
-    viteConfig.logger.info(`  ${import_picocolors5.default.green("➜")}  ${import_picocolors5.default.bold("Realtime:")} ${import_picocolors5.default.cyan(`ws://localhost:${import_picocolors5.default.bold(realtimePort.toString())}`)}`);
+    viteConfig.logger.info(`  ${import_picocolors6.default.green("➜")}  ${import_picocolors6.default.bold("Realtime:")} ${import_picocolors6.default.cyan(`ws://localhost:${import_picocolors6.default.bold(realtimePort.toString())}`)}`);
   }
   viteConfig.logger.info("");
 }
@@ -211094,7 +211085,9 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
     databasePath,
     realtimeEnabled = false,
     realtimePort,
-    logLevel = "info"
+    logLevel = "info",
+    timebackId,
+    timebackOptions
   } = options;
   if (!autoStart || viteConfig.command !== "serve") {
     const baseUrl = customUrl ?? `http://localhost:${DEFAULT_PORTS2.SANDBOX}`;
@@ -211120,11 +211113,17 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
   try {
     const sandboxPort = await findAvailablePort(DEFAULT_PORTS2.SANDBOX);
     const baseUrl = `http://localhost:${sandboxPort}`;
-    const projectInfo = await extractProjectInfo(viteConfig);
-    const timebackOptions = detectTimebackOptions();
+    const projectInfo = await extractProjectInfo(viteConfig, timebackOptions);
+    let sandboxTimebackOptions = detectTimebackOptions();
+    if (timebackId) {
+      sandboxTimebackOptions = {
+        ...sandboxTimebackOptions,
+        studentId: timebackId
+      };
+    }
     const finalRealtimePort = realtimePort ?? await findAvailablePort(sandboxPort + 1);
     const realtimeUrl = `ws://localhost:${finalRealtimePort}`;
-    const server = await startServer2(sandboxPort, projectInfo, {
+    const server = await startServer(sandboxPort, projectInfo, {
       verbose,
       quiet,
       seed,
@@ -211133,7 +211132,7 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
       recreateDb,
       logLevel,
       realtime: { enabled: realtimeEnabled, port: finalRealtimePort },
-      timeback: timebackOptions,
+      timeback: sandboxTimebackOptions,
       logger: createLoggerAdapter("sandbox")
     });
     writeServerInfo("sandbox", {
@@ -211162,7 +211161,7 @@ async function startSandbox(viteConfig, autoStart = true, options = {}) {
       }
     };
   } catch (error2) {
-    viteConfig.logger.error(import_picocolors5.default.red(`[Playcademy] Failed to start sandbox: ${error2}`));
+    viteConfig.logger.error(import_picocolors6.default.red(`[Playcademy] Failed to start sandbox: ${error2}`));
     return {
       baseUrl: `http://localhost:${DEFAULT_PORTS2.SANDBOX}`,
       realtimeUrl: "ws://localhost:4322",
@@ -211387,16 +211386,13 @@ var shell_with_corner_badge_default = `<!doctype html>
     <head>
         <meta charset="UTF-8" />
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <title>Playcademy - Development</title>
+        <title>Playcademy Dev</title>
         <link rel="preconnect" href="https://fonts.googleapis.com" />
         <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
         <link href="https://fonts.googleapis.com/css2?family=VT323&display=swap" rel="stylesheet" />
+        <script type="module" src="/@vite/client"></script>
         <script type="importmap">
-            {
-                "imports": {
-                    "@playcademy/sdk": "https://esm.sh/@playcademy/sdk@latest"
-                }
-            }
+            { "imports": { "@playcademy/sdk": "https://esm.sh/@playcademy/sdk@latest" } }
         </script>
         <style>
             * {
@@ -211404,14 +211400,11 @@ var shell_with_corner_badge_default = `<!doctype html>
                 padding: 0;
                 box-sizing: border-box;
             }
-
             body {
-                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
                 height: 100vh;
                 overflow: hidden;
             }
-
-            .dev-badge {
+            #badge {
                 position: fixed;
                 top: 0.5rem;
                 left: 0.5rem;
@@ -211426,202 +211419,144 @@ var shell_with_corner_badge_default = `<!doctype html>
                 letter-spacing: 0.05em;
                 transition: background 0.2s ease;
             }
-
-            .dev-badge.offline {
+            #badge.offline {
                 background: rgba(211, 47, 47, 0.9);
             }
-
-            .dev-badge-status {
-                font-size: 0.7rem;
-            }
-
-            .dev-badge-status:not(:empty) {
-                margin-left: 0.5rem;
-            }
-
-            .game-container {
-                width: 100vw;
-                height: 100vh;
-                position: relative;
-                overflow: hidden;
-            }
-
-            .game-frame {
+            #frame {
                 position: absolute;
                 inset: 0;
                 border: none;
                 width: 100%;
                 height: 100%;
             }
-
-            .error {
-                position: absolute;
-                inset: 0;
-                display: flex;
-                flex-direction: column;
-                align-items: center;
-                justify-content: center;
-                color: #d32f2f;
-                background-color: #ffebee;
-            }
-
             .hidden {
                 display: none;
             }
         </style>
     </head>
     <body>
-        <div class="dev-badge" id="devBadge">
-            PLAYCADEMY<span class="dev-badge-status" id="badgeStatus"></span>
-        </div>
-
-        <div class="game-container">
-            <div class="error hidden" id="error">
-                <div>❌ Failed to load game</div>
-                <div
-                    style="margin-top: 0.5rem; font-size: 0.9rem; opacity: 0.8"
-                    id="errorMessage"
-                ></div>
-            </div>
-
-            <iframe class="game-frame hidden" id="gameFrame" src="/"></iframe>
-        </div>
+        <div id="badge">PLAYCADEMY</div>
+        <iframe id="frame" class="hidden"></iframe>
 
         <script type="module">
             import { MessageEvents, messaging } from '@playcademy/sdk'
 
-            const devBadge = document.getElementById('devBadge')
-            const badgeStatus = document.getElementById('badgeStatus')
-            const loading = document.getElementById('loading')
-            const error = document.getElementById('error')
-            const errorMessage = document.getElementById('errorMessage')
-            const gameFrame = document.getElementById('gameFrame')
+            // Config (injected by vite plugin)
+            const CONFIG = {
+                sandboxUrl: '{{SANDBOX_URL}}',
+                gameId: '{{GAME_ID}}',
+                gameUrl: '{{GAME_URL}}' || undefined,
+                realtimeUrl: '{{REALTIME_URL}}',
+                timebackJson: '{{TIMEBACK_DATA}}',
+            }
 
-            const logIfDebug = (...args) => {
-                if (window.PLAYCADEMY_DEBUG) {
-                    console.log('[PlaycademyDevShell]', ...args)
+            // Parse timeback data (role + enrollments)
+            const timeback = (() => {
+                try {
+                    return JSON.parse(CONFIG.timebackJson)
+                } catch {
+                    return null
                 }
-            }
+            })()
 
-            logIfDebug('[PlaycademyDevShell] Initialized')
+            // Elements
+            const badge = document.getElementById('badge')
+            const frame = document.getElementById('frame')
 
-            async function checkSandboxConnection() {
+            // Debug logging
+            const log = (...args) => window.PLAYCADEMY_DEBUG && console.log('[DevShell]', ...args)
+
+            // Check sandbox connection
+            async function checkSandbox() {
                 try {
-                    const response = await fetch('{{SANDBOX_URL}}/api/users/me', {
-                        headers: {
-                            Authorization: 'Bearer sandbox-demo-token',
-                        },
+                    const res = await fetch(\`\${CONFIG.sandboxUrl}/api/users/me\`, {
+                        headers: { Authorization: 'Bearer sandbox-demo-token' },
                     })
-
-                    if (response.ok) {
-                        badgeStatus.textContent = ''
-                        devBadge.classList.remove('offline')
-                        logIfDebug('[PlaycademyDevShell] Sandbox API connection successful')
-                    } else {
-                        throw new Error('Sandbox API not available')
-                    }
-                } catch (err) {
-                    logIfDebug('[PlaycademyDevShell] Sandbox connection failed:', err)
-                    badgeStatus.textContent = ' ⚠️'
-                    devBadge.classList.add('offline')
+                    if (!res.ok) throw new Error('Sandbox unavailable')
+                    badge.classList.remove('offline')
+                    log('Sandbox connected')
+                    return true
+                } catch (e) {
+                    badge.classList.add('offline')
+                    badge.textContent = 'PLAYCADEMY ⚠️'
+                    log('Sandbox failed:', e)
+                    return false
                 }
             }
 
-            // Load the game iframe
-            function loadGame() {
-                let handshakeInterval = null
-                let handshakeTimeout = null
-
-                const initPayload = {
-                    baseUrl: '{{SANDBOX_URL}}',
-                    gameUrl: '{{GAME_URL}}' || undefined,
+            // Init handshake with game iframe
+            function initHandshake(timebackData) {
+                const payload = {
+                    baseUrl: CONFIG.sandboxUrl,
+                    gameUrl: CONFIG.gameUrl,
+                    gameId: CONFIG.gameId,
+                    realtimeUrl: CONFIG.realtimeUrl,
                     token: 'sandbox-demo-token',
-                    gameId: '{{GAME_ID}}',
-                    realtimeUrl: '{{REALTIME_URL}}',
+                    timeback: timebackData,
                 }
 
-                const sendInit = () => {
-                    if (!gameFrame.contentWindow) return
-
-                    messaging.send(MessageEvents.INIT, initPayload, {
-                        target: gameFrame.contentWindow,
-                        origin: '*',
-                    })
-                }
+                let interval, timeout
 
-                const stopHandshake = () => {
-                    if (handshakeInterval) {
-                        clearInterval(handshakeInterval)
-                        handshakeInterval = null
-                    }
-                    if (handshakeTimeout) {
-                        clearTimeout(handshakeTimeout)
-                        handshakeTimeout = null
+                const send = () => {
+                    if (frame.contentWindow) {
+                        messaging.send(MessageEvents.INIT, payload, {
+                            target: frame.contentWindow,
+                            origin: '*',
+                        })
                     }
                 }
 
-                gameFrame.onload = () => {
-                    gameFrame.classList.remove('hidden')
-
-                    logIfDebug('[PlaycademyDevShell] Game iframe loaded, beginning init handshake')
-
-                    // Begin handshake: send immediately, then every 300ms
-                    sendInit()
-                    handshakeInterval = setInterval(sendInit, 300)
-
-                    // Stop handshake after 10 seconds
-                    handshakeTimeout = setTimeout(() => {
-                        stopHandshake()
-                        logIfDebug('[PlaycademyDevShell] Init handshake timeout reached')
-                    }, 10000)
+                const stop = () => {
+                    clearInterval(interval)
+                    clearTimeout(timeout)
                 }
 
-                gameFrame.onerror = () => {
-                    loading.classList.add('hidden')
-                    error.classList.remove('hidden')
-                    errorMessage.textContent = 'Game iframe failed to load'
-                    logIfDebug('[PlaycademyDevShell] Game iframe failed to load')
-                    stopHandshake()
+                frame.onload = () => {
+                    frame.classList.remove('hidden')
+                    log('Frame loaded, starting handshake')
+                    send()
+                    interval = setInterval(send, 300)
+                    timeout = setTimeout(() => {
+                        stop()
+                        log('Handshake timeout')
+                    }, 10000)
                 }
 
-                // Listen for READY message to stop handshake
                 messaging.listen(MessageEvents.READY, () => {
-                    logIfDebug('[PlaycademyDevShell] Received READY from game, stopping handshake')
-                    stopHandshake()
+                    stop()
+                    log('Game ready')
                 })
 
-                gameFrame.src = '/'
+                frame.src = '/'
             }
 
-            window.addEventListener('message', event => {
-                if (event.source === gameFrame.contentWindow) {
-                    const { type, ...payload } = event.data || {}
-                    if (type && type.startsWith('PLAYCADEMY_')) {
-                        logIfDebug(
-                            '[PlaycademyDevShell] Received message from game:',
-                            type,
-                            payload,
-                        )
-                        // Bridge the message to the local context using CustomEvent
-                        messaging.send(type, payload)
-                    }
+            // Bridge messages from game to shell context
+            window.addEventListener('message', e => {
+                if (e.source !== frame.contentWindow) return
+                const { type, ...payload } = e.data || {}
+                if (type?.startsWith('PLAYCADEMY_')) {
+                    log('Message:', type, payload)
+                    messaging.send(type, payload)
                 }
             })
 
-            // Initialize
-            checkSandboxConnection()
-            loadGame()
+            // Start
+            checkSandbox().then(() => initHandshake(timeback))
         </script>
     </body>
 </html>
+
+
+
 `;
 
 // src/server/middleware.ts
-function generateLoaderHTML(sandboxUrl, gameId, realtimeUrl, showBadge, gameUrl) {
-  const shell = showBadge ? shell_with_corner_badge_default : shell_no_badge_default;
-  return shell.replace(/{{SANDBOX_URL}}/g, sandboxUrl).replace(/{{GAME_ID}}/g, gameId).replace(/{{REALTIME_URL}}/g, realtimeUrl).replace(/{{GAME_URL}}/g, gameUrl || "");
+function generateLoaderHTML(sandboxUrl, gameId, realtimeUrl, options, gameUrl) {
+  const shell = options.showBadge ? shell_with_corner_badge_default : shell_no_badge_default;
+  const timebackJson = generateTimebackJson(options.timeback) ?? "null";
+  return shell.replace(/{{SANDBOX_URL}}/g, sandboxUrl).replace(/{{GAME_ID}}/g, gameId).replace(/{{REALTIME_URL}}/g, realtimeUrl).replace(/{{GAME_URL}}/g, gameUrl || "").replace(/{{TIMEBACK_DATA}}/g, timebackJson);
 }
-function devServerMiddleware(server, sandbox, gameUrl, showBadge) {
+function devServerMiddleware(server, sandbox, gameUrl, options) {
   server.middlewares.use("/", (req, res, next) => {
     if (getCurrentMode() !== "platform") {
       next();
@@ -211633,8 +211568,7 @@ function devServerMiddleware(server, sandbox, gameUrl, showBadge) {
         next();
       } else {
         res.setHeader("Content-Type", "text/html");
-        const gameId = sandbox.project?.slug;
-        res.end(generateLoaderHTML(sandbox.baseUrl, gameId ?? "", sandbox.realtimeUrl, showBadge, gameUrl));
+        res.end(generateLoaderHTML(sandbox.baseUrl, sandbox.project?.slug ?? "", sandbox.realtimeUrl, options, gameUrl));
       }
       return;
     }
@@ -211642,6 +211576,190 @@ function devServerMiddleware(server, sandbox, gameUrl, showBadge) {
   });
 }
 
+// src/server/hotkeys/recreate-database.ts
+var { bold: bold4, cyan: cyan3, dim: dim4, green: green2, red, yellow: yellow2 } = import_picocolors7.default;
+function formatTimestamp3() {
+  const now2 = new Date;
+  const hours = now2.getHours();
+  const minutes = now2.getMinutes().toString().padStart(2, "0");
+  const seconds = now2.getSeconds().toString().padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const displayHours = hours % 12 || 12;
+  return dim4(`${displayHours}:${minutes}:${seconds} ${ampm}`);
+}
+async function recreateSandboxDatabase(options) {
+  const currentMode = getCurrentMode();
+  const viteServer = getViteServerRef();
+  if (!viteServer) {
+    options.viteConfig.logger.error(`${formatTimestamp3()} ${red(bold4("[playcademy]"))} ${dim4("(sandbox)")} ${red("Cannot recreate sandbox database: no Vite server reference")}`);
+    return;
+  }
+  if (currentMode !== "platform") {
+    options.viteConfig.logger.warn(`${formatTimestamp3()} ${yellow2(bold4("[playcademy]"))} ${dim4("(sandbox)")} ${yellow2("can only recreate sandbox database in platform mode (m + enter)")}`);
+    return;
+  }
+  options.viteConfig.logger.info(`${formatTimestamp3()} ${cyan3(bold4("[playcademy]"))} ${dim4("(sandbox)")} recreating database...`);
+  if (serverState.sandbox) {
+    serverState.sandbox.cleanup();
+    serverState.sandbox = null;
+  }
+  await new Promise((resolve2) => setTimeout(resolve2, 100));
+  const sandbox = await startSandbox(options.viteConfig, options.platformModeOptions.startSandbox, {
+    verbose: options.platformModeOptions.verbose,
+    logLevel: options.platformModeOptions.logLevel,
+    customUrl: options.platformModeOptions.sandboxUrl,
+    quiet: true,
+    recreateDb: true,
+    seed: options.platformModeOptions.seed,
+    memoryOnly: options.platformModeOptions.memoryOnly,
+    databasePath: options.platformModeOptions.databasePath,
+    realtimeEnabled: options.platformModeOptions.realtimeEnabled,
+    realtimePort: options.platformModeOptions.realtimePort,
+    timebackId: getEffectiveTimebackId(options.platformModeOptions.timeback)
+  });
+  serverState.sandbox = sandbox;
+  if (sandbox.project && serverState.backend) {
+    const gameUrl = `http://localhost:${serverState.backend.port}`;
+    devServerMiddleware(viteServer, sandbox, gameUrl, {
+      showBadge: options.platformModeOptions.showBadge,
+      timeback: options.platformModeOptions.timeback
+    });
+  }
+  options.viteConfig.logger.info(`${formatTimestamp3()} ${cyan3(bold4("[playcademy]"))} ${dim4("(sandbox)")} ${green2("database recreated")}`);
+}
+var recreateDatabaseHotkey = (options) => ({
+  key: "d",
+  description: "recreate sandbox database",
+  action: () => recreateSandboxDatabase(options)
+});
+
+// src/server/hotkeys/toggle-mode.ts
+var import_picocolors10 = __toESM(require_picocolors(), 1);
+// package.json
+var package_default2 = {
+  name: "@playcademy/vite-plugin",
+  version: "0.1.40",
+  type: "module",
+  exports: {
+    ".": {
+      import: "./dist/index.js",
+      types: "./dist/index.d.ts"
+    }
+  },
+  main: "dist/index.js",
+  module: "dist/index.js",
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "rm -rf dist && bun build.ts",
+    docs: "typedoc --skipErrorChecking",
+    pub: "bun publish.ts"
+  },
+  dependencies: {
+    archiver: "^7.0.1",
+    picocolors: "^1.1.1",
+    playcademy: "workspace:*"
+  },
+  devDependencies: {
+    "@inquirer/prompts": "^7.8.6",
+    "@playcademy/sandbox": "workspace:*",
+    "@types/archiver": "^6.0.3",
+    "@types/bun": "latest"
+  },
+  peerDependencies: {
+    typescript: "^5",
+    vite: "^5 || ^6"
+  }
+};
+
+// src/lib/backend/server.ts
+import {
+  loadPlaycademyConfigAndSetWorkspace as loadConfigAndSetWorkspace,
+  startPlaycademyDevServer,
+  startPlaycademyHotReload
+} from "playcademy/utils";
+
+// src/lib/backend/hot-reload.ts
+var import_picocolors8 = __toESM(require_picocolors(), 1);
+function formatChangedPath(changedPath) {
+  if (!changedPath)
+    return;
+  if (changedPath.includes("/api/")) {
+    return changedPath.substring(changedPath.indexOf("/api/"));
+  }
+  return changedPath;
+}
+function createHotReloadCallbacks(viteConfig) {
+  return {
+    onSuccess: (changedPath) => {
+      const relativePath = formatChangedPath(changedPath);
+      if (relativePath) {
+        viteConfig.logger.info(`${import_picocolors8.dim("(backend)")} ${import_picocolors8.green("hmr update")} ${import_picocolors8.dim(relativePath)}`, { timestamp: true });
+      } else {
+        viteConfig.logger.info("backend reloaded", { timestamp: true });
+      }
+    },
+    onError: (error2) => {
+      viteConfig.logger.error(`backend reload failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    }
+  };
+}
+
+// src/lib/backend/server.ts
+async function tryLoadConfig(viteConfig, configPath) {
+  try {
+    return await loadConfigAndSetWorkspace(configPath);
+  } catch (error2) {
+    if (error2 instanceof Error && !error2.message.includes("Could not find")) {
+      viteConfig.logger.warn(`Could not load playcademy.config.js: ${error2.message}`);
+    }
+    return null;
+  }
+}
+function needsCliDevServer(config2) {
+  return !!config2.integrations;
+}
+async function startServer2(options) {
+  const { port, config: config2, platformUrl } = options;
+  return startPlaycademyDevServer({
+    port,
+    config: config2,
+    quiet: true,
+    platformUrl,
+    customLogger: createLoggerAdapter("backend")
+  });
+}
+function setupHotReload(serverRef, options) {
+  const watcher = startPlaycademyHotReload(async () => {
+    await serverRef.current.server.dispose();
+    serverRef.current = await startServer2(options);
+  }, createHotReloadCallbacks(options.viteConfig));
+  return () => watcher.close();
+}
+async function setupCliDevServer(options) {
+  const { preferredPort, viteConfig, platformUrl, configPath } = options;
+  const config2 = await tryLoadConfig(viteConfig, configPath);
+  if (!config2)
+    return null;
+  if (!needsCliDevServer(config2))
+    return null;
+  try {
+    const port = await findAvailablePort(preferredPort);
+    const serverOptions = { port, config: config2, platformUrl, viteConfig };
+    const serverRef = { current: await startServer2(serverOptions) };
+    const stopHotReload = setupHotReload(serverRef, serverOptions);
+    return {
+      server: serverRef.current.server,
+      port: serverRef.current.port,
+      stopHotReload,
+      cleanup: () => cleanupServerInfo("backend", viteConfig.root, process.pid)
+    };
+  } catch (error2) {
+    viteConfig.logger.error(`Failed to start game backend: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    return null;
+  }
+}
 // src/server/platform-mode.ts
 async function configurePlatformMode(server, viteConfig, options) {
   const sandbox = await startSandbox(viteConfig, options.startSandbox, {
@@ -211654,7 +211772,9 @@ async function configurePlatformMode(server, viteConfig, options) {
     memoryOnly: options.memoryOnly,
     databasePath: options.databasePath,
     realtimeEnabled: options.realtimeEnabled,
-    realtimePort: options.realtimePort
+    realtimePort: options.realtimePort,
+    timebackId: getEffectiveTimebackId(options.timeback),
+    timebackOptions: options.timeback
   });
   serverState.sandbox = sandbox;
   const backend = await setupCliDevServer({
@@ -211665,25 +211785,29 @@ async function configurePlatformMode(server, viteConfig, options) {
   });
   serverState.backend = backend;
   if (sandbox.project) {
+    validateTimebackConfig(viteConfig, options.timeback);
     const gameUrl = backend ? `http://localhost:${backend.port}` : undefined;
-    devServerMiddleware(server, sandbox, gameUrl, options.showBadge);
+    devServerMiddleware(server, sandbox, gameUrl, {
+      showBadge: options.showBadge,
+      timeback: options.timeback
+    });
   }
   server.httpServer?.once("listening", () => {
     setTimeout(async () => {
-      const projectInfo = await extractProjectInfo(viteConfig);
+      const projectInfo = await extractProjectInfo(viteConfig, options.timeback);
       const vitePort = server.config.server.port;
       printBanner(viteConfig, {
         sandbox: sandbox.port,
         backend: backend?.port,
         realtime: sandbox.realtimePort,
         vite: vitePort
-      }, projectInfo, package_default.version);
+      }, projectInfo, package_default2.version);
     }, 100);
   });
 }
 
 // src/server/standalone-mode.ts
-var import_picocolors6 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 async function configureStandaloneMode(server, viteConfig, options) {
   const backend = await setupCliDevServer({
     preferredPort: options.preferredPort,
@@ -211699,32 +211823,32 @@ async function configureStandaloneMode(server, viteConfig, options) {
   server.httpServer?.once("listening", () => {
     setTimeout(() => {
       viteConfig.logger.info("");
-      viteConfig.logger.info(`  ${import_picocolors6.default.green(import_picocolors6.default.bold("PLAYCADEMY"))} ${import_picocolors6.default.green(`v${package_default.version}`)}`);
+      viteConfig.logger.info(`  ${import_picocolors9.default.green(import_picocolors9.default.bold("PLAYCADEMY"))} ${import_picocolors9.default.green(`v${package_default2.version}`)}`);
       viteConfig.logger.info("");
-      viteConfig.logger.info(`  ${import_picocolors6.default.green("➜")}  ${import_picocolors6.default.bold("Backend:")}  ${import_picocolors6.default.cyan(`http://localhost:${backend.port}`)}`);
-      viteConfig.logger.info(`  ${import_picocolors6.default.green("➜")}  ${import_picocolors6.default.bold("Sandbox:")}  ${import_picocolors6.default.cyan("Disabled")}`);
+      viteConfig.logger.info(`  ${import_picocolors9.default.green("➜")}  ${import_picocolors9.default.bold("Backend:")}  ${import_picocolors9.default.cyan(`http://localhost:${backend.port}`)}`);
+      viteConfig.logger.info(`  ${import_picocolors9.default.green("➜")}  ${import_picocolors9.default.bold("Sandbox:")}  ${import_picocolors9.default.cyan("Disabled")}`);
       viteConfig.logger.info("");
     }, 100);
   });
 }
 
-// src/server/mode-switcher.ts
-var { bold: bold3, cyan: cyan3, dim: dim4, green: green3, red } = import_picocolors7.default;
-function formatTimestamp2() {
+// src/server/hotkeys/toggle-mode.ts
+var { bold: bold5, cyan: cyan4, dim: dim6, green: green4, red: red2 } = import_picocolors10.default;
+function formatTimestamp4() {
   const now2 = new Date;
   const hours = now2.getHours();
   const minutes = now2.getMinutes().toString().padStart(2, "0");
   const seconds = now2.getSeconds().toString().padStart(2, "0");
   const ampm = hours >= 12 ? "PM" : "AM";
   const displayHours = hours % 12 || 12;
-  return dim4(`${displayHours}:${minutes}:${seconds} ${ampm}`);
+  return dim6(`${displayHours}:${minutes}:${seconds} ${ampm}`);
 }
 async function toggleMode(options) {
   const currentMode = getCurrentMode();
   const newMode = currentMode === "platform" ? "standalone" : "platform";
   const viteServer = getViteServerRef();
   if (!viteServer) {
-    options.viteConfig.logger.error(`${formatTimestamp2()} ${red(bold3("[playcademy]"))} ${red("Cannot toggle mode: no Vite server reference")}`);
+    options.viteConfig.logger.error(`${formatTimestamp4()} ${red2(bold5("[playcademy]"))} ${red2("Cannot toggle mode: no Vite server reference")}`);
     return;
   }
   await cleanupServers();
@@ -211738,56 +211862,39 @@ async function toggleMode(options) {
   } else {
     await configurePlatformMode(viteServer, options.viteConfig, options.platformModeOptions);
   }
-  options.viteConfig.logger.info(`${formatTimestamp2()} ${cyan3(bold3("[playcademy]"))} ${green3("switched to")} ${green3(bold3(newMode))} ${green3("mode")}`);
+  options.viteConfig.logger.info(`${formatTimestamp4()} ${cyan4(bold5("[playcademy]"))} ${green4("switched to")} ${green4(bold5(newMode))} ${green4("mode")}`);
 }
+var toggleModeHotkey = (options) => ({
+  key: "m",
+  description: "toggle platform/standalone mode",
+  action: () => toggleMode(options)
+});
 
-// src/server/recreate-sandbox-database.ts
-var import_picocolors8 = __toESM(require_picocolors(), 1);
-var { bold: bold4, cyan: cyan4, dim: dim5, green: green4, red: red2, yellow } = import_picocolors8.default;
-function formatTimestamp3() {
-  const now2 = new Date;
-  const hours = now2.getHours();
-  const minutes = now2.getMinutes().toString().padStart(2, "0");
-  const seconds = now2.getSeconds().toString().padStart(2, "0");
-  const ampm = hours >= 12 ? "PM" : "AM";
-  const displayHours = hours % 12 || 12;
-  return dim5(`${displayHours}:${minutes}:${seconds} ${ampm}`);
+// src/server/hotkeys/index.ts
+function getHotkeys(options) {
+  return [
+    toggleModeHotkey(options),
+    recreateDatabaseHotkey(options),
+    cycleTimebackRoleHotkey(options)
+  ];
 }
-async function recreateSandboxDatabase(options) {
-  const currentMode = getCurrentMode();
-  const viteServer = getViteServerRef();
-  if (!viteServer) {
-    options.viteConfig.logger.error(`${formatTimestamp3()} ${red2(bold4("[playcademy]"))} ${dim5("(sandbox)")} ${red2("Cannot recreate sandbox database: no Vite server reference")}`);
-    return;
-  }
-  if (currentMode !== "platform") {
-    options.viteConfig.logger.warn(`${formatTimestamp3()} ${yellow(bold4("[playcademy]"))} ${dim5("(sandbox)")} ${yellow("can only recreate sandbox database in platform mode (m + enter)")}`);
+
+// src/server/lifecycle.ts
+var shutdownHandlersRegistered = false;
+function setupProcessShutdownHandlers() {
+  if (shutdownHandlersRegistered)
     return;
-  }
-  options.viteConfig.logger.info(`${formatTimestamp3()} ${cyan4(bold4("[playcademy]"))} ${dim5("(sandbox)")} recreating database...`);
-  if (serverState.sandbox) {
-    serverState.sandbox.cleanup();
-    serverState.sandbox = null;
-  }
-  await new Promise((resolve2) => setTimeout(resolve2, 100));
-  const sandbox = await startSandbox(options.viteConfig, options.platformModeOptions.startSandbox, {
-    verbose: options.platformModeOptions.verbose,
-    logLevel: options.platformModeOptions.logLevel,
-    customUrl: options.platformModeOptions.sandboxUrl,
-    quiet: true,
-    recreateDb: true,
-    seed: options.platformModeOptions.seed,
-    memoryOnly: options.platformModeOptions.memoryOnly,
-    databasePath: options.platformModeOptions.databasePath,
-    realtimeEnabled: options.platformModeOptions.realtimeEnabled,
-    realtimePort: options.platformModeOptions.realtimePort
-  });
-  serverState.sandbox = sandbox;
-  if (sandbox.project && serverState.backend) {
-    const gameUrl = `http://localhost:${serverState.backend.port}`;
-    devServerMiddleware(viteServer, sandbox, gameUrl, options.platformModeOptions.showBadge);
-  }
-  options.viteConfig.logger.info(`${formatTimestamp3()} ${cyan4(bold4("[playcademy]"))} ${dim5("(sandbox)")} ${green4("database recreated")}`);
+  shutdownHandlersRegistered = true;
+  let isShuttingDown = false;
+  const shutdown = async () => {
+    if (isShuttingDown)
+      return;
+    isShuttingDown = true;
+    await cleanupServers();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
 }
 
 // src/hooks/configure-server.ts
@@ -211816,7 +211923,8 @@ async function configureServerHook(server, context) {
     realtimePort: context.options.realtimePort,
     showBadge: context.options.showBadge,
     preferredBackendPort: preferredPort,
-    configPath: context.options.configPath
+    configPath: context.options.configPath,
+    timeback: context.options.timeback
   };
   if (context.options.mode === "standalone") {
     await configureStandaloneMode(server, context.viteConfig, {
@@ -211833,26 +211941,10 @@ async function configureServerHook(server, context) {
         ...options,
         customShortcuts: [
           ...options?.customShortcuts || [],
-          {
-            key: "m",
-            description: "toggle platform/standalone mode",
-            action: async () => {
-              await toggleMode({
-                viteConfig: context.viteConfig,
-                platformModeOptions
-              });
-            }
-          },
-          {
-            key: "d",
-            description: "recreate sandbox database",
-            action: async () => {
-              await recreateSandboxDatabase({
-                viteConfig: context.viteConfig,
-                platformModeOptions
-              });
-            }
-          }
+          ...getHotkeys({
+            viteConfig: context.viteConfig,
+            platformModeOptions
+          })
         ]
       });
     };
@@ -211900,7 +211992,8 @@ function resolveOptions(options) {
     databasePath: sandboxOptions.databasePath,
     realtimeEnabled: realtimeOptions.enabled ?? false,
     realtimePort: realtimeOptions.port,
-    showBadge: shellOptions.showBadge ?? true
+    showBadge: shellOptions.showBadge ?? true,
+    timeback: options.timeback
   };
 }
 function createPluginContext(options) {