playcademy 0.14.19 → 0.14.21

package/dist/templates/api/sample-route-with-db.ts.template

@@ -1,7 +1,7 @@
 /**
  * Sample API route with database
  *
- * This route will be available at: https://<your-game-slug>.playcademy.gg/api/hello
+ * This route will be available at: https://<your-project-slug>.playcademy.gg/api/hello
  */
 
 import { desc } from 'drizzle-orm'

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

@@ -3,7 +3,7 @@
  * Calling your backend from your frontend:
  * ─────────────────────────────────────────────────────────────────
  *
- * In your game's frontend, use the Playcademy SDK client to call
+ * In your project's frontend, use the Playcademy SDK client to call
  * your custom backend routes:
  *
  * ```typescript
@@ -32,7 +32,7 @@
 /**
  * Sample API route
  *
- * This route will be available at: https://<your-game-slug>.playcademy.gg/api/hello
+ * This route will be available at: https://<your-project-slug>.playcademy.gg/api/hello
  */
 
 /**
@@ -40,7 +40,7 @@
  */
 export async function GET(c: Context): Promise<Response> {
     return c.json({
-        message: 'Hello from your game backend!',
+        message: 'Hello from your project backend!',
         timestamp: new Date().toISOString(),
     })
 }
@@ -59,8 +59,8 @@ export async function POST(c: Context): Promise<Response> {
 
 /**
  * Environment variables available via c.env:
- * - c.env.PLAYCADEMY_API_KEY - Game-scoped API key for calling Playcademy APIs
- * - c.env.GAME_ID - Your game's unique ID
+ * - c.env.PLAYCADEMY_API_KEY - Project-scoped API key for calling Playcademy APIs
+ * - c.env.GAME_ID - Your project's unique ID
  * - c.env.PLAYCADEMY_BASE_URL - Playcademy platform URL
  *
  * Access the SDK client:

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

@@ -15,7 +15,7 @@ export const user = sqliteTable('user', {
     updatedAt: integer('updatedAt', { mode: 'timestamp' }).notNull(),
 
     // Platform linkage: Links this user to a Playcademy platform identity
-    // When users launch the game from Playcademy, their platform identity
+    // When users launch your project from Playcademy, their platform identity
     // is verified and linked to a Better Auth session via this field
     playcademyUserId: text('playcademy_user_id').unique(),
 })

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

@@ -27,8 +27,8 @@ export function getAuth(c: Context) {
     const secret = getAuthSecret(c)
 
     // CUSTOMIZABLE: Configure trusted origins for CORS
-    // These origins are allowed to make cross-origin requests to your game's auth endpoints.
-    // Add your deployed game URLs here when you deploy to staging or production.
+    // These origins are allowed to make cross-origin requests to your project's auth endpoints.
+    // Add your deployed project URLs here when you deploy to staging or production.
     const trustedOrigins = [
         'http://localhost:5173', // Local development
         // 'https://{{GAME_SLUG}}-staging.playcademy.gg', // Staging deployment

package/dist/templates/database/db-schema-example.ts.template

@@ -2,7 +2,7 @@
  * Example Schema
  *
  * Define your database tables here using Drizzle ORM.
- * This is a starter example - customize for your game's needs.
+ * This is a starter example - customize for your project's needs.
  */
 
 import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core'

package/dist/utils.d.ts

@@ -1,8 +1,23 @@
-import { OrganizationConfig, CourseConfig, ComponentConfig, ResourceConfig, ComponentResourceConfig } from '@playcademy/timeback/types';
+import { CourseConfig, OrganizationConfig, ComponentConfig, ResourceConfig, ComponentResourceConfig } from '@playcademy/timeback/types';
 import { Miniflare } from 'miniflare';
 import * as chokidar from 'chokidar';
+import { PackageManager } from '@playcademy/utils/package-manager';
 import * as esbuild from 'esbuild';
 
+/**
+ * Minimal course configuration for TimeBack integration (used in user-facing config).
+ *
+ * NOTE: Per-course overrides (title, courseCode, level, metadata) are defined
+ * in @playcademy/sdk/server as TimebackCourseConfigWithOverrides.
+ * This base type only includes the minimal required fields.
+ *
+ * For totalXp, use metadata.metrics.totalXp (aligns with upstream TimeBack structure).
+ */
+type TimebackCourseConfig = {
+    subject: string;
+    grade: number;
+};
+
 /**
  * @fileoverview Server SDK Type Definitions
  *
@@ -11,20 +26,50 @@ import * as esbuild from 'esbuild';
  */
 
 /**
- * TimeBack integration configuration for Playcademy config file
+ * Base configuration for TimeBack integration (shared across all courses).
+ * References upstream TimeBack types from @playcademy/timeback.
+ *
+ * All fields are optional and support template variables: {grade}, {subject}, {gameSlug}
  */
-interface TimebackIntegrationConfig {
-    /** Organization overrides */
+interface TimebackBaseConfig {
+    /** Organization configuration (shared across all courses) */
     organization?: Partial<OrganizationConfig>;
-    /** Course configuration (subjects and grades REQUIRED) */
-    course: CourseConfig;
-    /** Component overrides */
+    /** Course defaults (can be overridden per-course) */
+    course?: Partial<CourseConfig>;
+    /** Component defaults */
     component?: Partial<ComponentConfig>;
-    /** Resource overrides */
+    /** Resource defaults */
     resource?: Partial<ResourceConfig>;
-    /** Component-Resource link overrides */
+    /** ComponentResource defaults */
     componentResource?: Partial<ComponentResourceConfig>;
 }
+/**
+ * Extended course configuration that merges TimebackCourseConfig with per-course overrides.
+ * Used in playcademy.config.* to allow per-course customization.
+ */
+interface TimebackCourseConfigWithOverrides extends TimebackCourseConfig {
+    title?: string;
+    courseCode?: string;
+    level?: string;
+    metadata?: CourseConfig['metadata'];
+    totalXp?: number | null;
+    masterableUnits?: number | null;
+}
+/**
+ * TimeBack integration configuration for Playcademy config file.
+ *
+ * Supports two levels of customization:
+ * 1. `base`: Shared defaults for all courses (organization, course, component, resource, componentResource)
+ * 2. Per-course overrides in the `courses` array (title, courseCode, level, gradingScheme, metadata)
+ *
+ * Template variables ({grade}, {subject}, {gameSlug}) can be used in string fields.
+ */
+interface TimebackIntegrationConfig {
+    /** Multi-grade course configuration (array of grade/subject/totalXp with optional per-course overrides) */
+    courses: TimebackCourseConfigWithOverrides[];
+    /** Optional base configuration (shared across all courses, can be overridden per-course) */
+    base?: TimebackBaseConfig;
+}
 /**
  * Custom API routes integration
  */
@@ -45,7 +90,7 @@ interface DatabaseIntegration {
  */
 interface IntegrationsConfig {
     /** TimeBack integration (optional) */
-    timeback?: TimebackIntegrationConfig;
+    timeback?: TimebackIntegrationConfig | null;
     /** Custom API routes (optional) */
     customRoutes?: CustomRoutesIntegration | boolean;
     /** Database (optional) */
@@ -116,6 +161,14 @@ declare function findConfigPath(configPath?: string): Promise<string>;
  * Load Playcademy configuration from file
  */
 declare function loadConfig(configPath?: string): Promise<PlaycademyConfig>;
+/**
+ * Load Playcademy configuration and set the CLI workspace to the config's directory
+ * This ensures that all relative paths (like server/) are resolved from the config location.
+ *
+ * Use this in CLI commands that need workspace-relative paths to work correctly
+ * when the user runs commands from a subdirectory (e.g., client/).
+ */
+declare function loadConfigAndSetWorkspace(configPath?: string): Promise<PlaycademyConfig>;
 /**
  * Validate configuration structure
  */
@@ -147,6 +200,26 @@ interface HotReloadOptions {
  */
 declare function startHotReload(onReload: () => Promise<void>, options?: HotReloadOptions): chokidar.FSWatcher;
 
+/**
+ * Configuration utilities for environment variables and API endpoints
+ */
+type Environment = 'staging' | 'production';
+
+/**
+ * Global CLI context for storing options that apply to all commands
+ */
+
+interface CliContext {
+    profile?: string;
+    workspace?: string;
+    environment?: Environment;
+    packageManager?: PackageManager;
+}
+/**
+ * Set the CLI context (called from the main program after parsing global options)
+ */
+declare function setCliContext(ctx: CliContext): void;
+
 /**
  * Import utilities for Node-safe TypeScript file loading
  */
@@ -187,4 +260,4 @@ declare function importTypescriptFile(filePath: string, bundleOptions?: Partial<
  */
 declare function importTypescriptDefault(filePath: string, bundleOptions?: Partial<esbuild.BuildOptions>): Promise<unknown>;
 
-export { findConfigPath as findPlaycademyConfigPath, importTypescriptDefault, importTypescriptFile, loadConfig as loadPlaycademyConfig, startDevServer as startPlaycademyDevServer, startHotReload as startPlaycademyHotReload, validateConfig as validatePlaycademyConfig };
+export { findConfigPath as findPlaycademyConfigPath, importTypescriptDefault, importTypescriptFile, loadConfig as loadPlaycademyConfig, loadConfigAndSetWorkspace as loadPlaycademyConfigAndSetWorkspace, setCliContext as setPlaycademyCliContext, startDevServer as startPlaycademyDevServer, startHotReload as startPlaycademyHotReload, validateConfig as validatePlaycademyConfig };

package/dist/utils.js

@@ -1733,7 +1733,6 @@ var package_default = {
     sharp: "^0.34.2",
     typedoc: "^0.28.5",
     "typedoc-plugin-markdown": "^4.7.0",
-    "typedoc-vitepress-theme": "^1.1.2",
     "typescript-eslint": "^8.30.1",
     "yocto-spinner": "^0.2.2"
   },
@@ -1899,7 +1898,7 @@ var CLI_DEFAULT_OUTPUTS = {
 var DEFAULT_PORTS = {
   /** Sandbox server (mock platform API) */
   SANDBOX: 4321,
-  /** Backend dev server (game backend with HMR) */
+  /** Backend dev server (project backend with HMR) */
   BACKEND: 8788
 };
 
@@ -1945,6 +1944,68 @@ var CORE_GAME_UUIDS = {
   PLAYGROUND: "00000000-0000-0000-0000-000000000001"
 };
 
+// ../utils/src/package-manager.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { join as join5 } from "path";
+function isCommandAvailable(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync2(join5(cwd, "bun.lock")) || existsSync2(join5(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync2(join5(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync2(join5(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync2(join5(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return detectByCommandAvailability();
+}
+function detectByCommandAvailability() {
+  if (isCommandAvailable("bun")) {
+    return "bun";
+  }
+  if (isCommandAvailable("pnpm")) {
+    return "pnpm";
+  }
+  if (isCommandAvailable("yarn")) {
+    return "yarn";
+  }
+  return "npm";
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "bun":
+      return "bun install";
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn install";
+    case "npm":
+    default:
+      return "npm install";
+  }
+}
+
+// src/lib/core/context.ts
+var context = {};
+function setCliContext(ctx) {
+  context = { ...context, ...ctx };
+}
+function getWorkspace() {
+  return context.workspace || process.cwd();
+}
+
 // src/lib/core/logger.ts
 import {
   blue,
@@ -2549,7 +2610,7 @@ import colors2 from "yoctocolors-cjs";
 
 // src/lib/core/error.ts
 import { bold, dim, redBright } from "colorette";
-import { ApiError, extractApiErrorInfo } from "@playcademy/sdk";
+import { ApiError, extractApiErrorInfo } from "@playcademy/sdk/internal";
 function isConfigError(error) {
   return error !== null && typeof error === "object" && "name" in error && error.name === "ConfigError" && "message" in error;
 }
@@ -2661,12 +2722,20 @@ function customTransform(text) {
   return result;
 }
 function formatTable(data, title) {
+  const ANSI_REGEX = /\u001B\[[0-9;]*m/g;
+  const stripAnsi2 = (value) => value.replace(ANSI_REGEX, "");
+  const visibleLength = (value) => stripAnsi2(value).length;
+  const padCell = (value, width) => {
+    const length = visibleLength(value);
+    if (length >= width) return value;
+    return value + " ".repeat(width - length);
+  };
   if (data.length === 0) return;
   const keys = Object.keys(data[0]);
   const rows = data.map((item) => keys.map((key) => String(item[key] ?? "")));
   const widths = keys.map((key, i) => {
-    const headerWidth = key.length;
-    const dataWidth = Math.max(...rows.map((row) => row[i].length));
+    const headerWidth = visibleLength(key);
+    const dataWidth = Math.max(...rows.map((row) => visibleLength(row[i])));
     return Math.max(headerWidth, dataWidth);
   });
   const totalWidth = widths.reduce((sum, w) => sum + w + 3, -1);
@@ -2682,11 +2751,11 @@ function formatTable(data, title) {
     console.log(titleRow);
     console.log(titleSeparator);
   }
-  const header = "\u2502 " + keys.map((key, i) => key.padEnd(widths[i])).join(" \u2502 ") + " \u2502";
+  const header = "\u2502 " + keys.map((key, i) => padCell(key, widths[i])).join(" \u2502 ") + " \u2502";
   console.log(header);
   console.log(separator);
   rows.forEach((row) => {
-    const dataRow = "\u2502 " + row.map((cell, i) => cell.padEnd(widths[i])).join(" \u2502 ") + " \u2502";
+    const dataRow = "\u2502 " + row.map((cell, i) => padCell(cell, widths[i])).join(" \u2502 ") + " \u2502";
     console.log(dataRow);
   });
   console.log(bottomBorder);
@@ -2902,7 +2971,7 @@ async function findConfigPath(configPath) {
     }
     return result2.path;
   }
-  const result = await findFile2(CONFIG_FILE_NAMES);
+  const result = await findFile2(CONFIG_FILE_NAMES, { searchUp: true, maxLevels: 3 });
   if (!result) {
     throw new ConfigError(
       "No Playcademy config file found in this directory or any parent directory",
@@ -2920,6 +2989,10 @@ async function loadConfigFile(path2) {
   return module.default || module;
 }
 async function loadConfig(configPath) {
+  const result = await loadConfigWithPath(configPath);
+  return result.config;
+}
+async function loadConfigWithPath(configPath) {
   try {
     const actualPath = configPath ? resolve2(configPath) : await findConfigPath();
     const config = await loadConfigFile(actualPath);
@@ -2931,7 +3004,11 @@ async function loadConfig(configPath) {
       );
     }
     validateConfig(config);
-    return processConfigVariables(config);
+    return {
+      config: processConfigVariables(config),
+      configPath: actualPath,
+      configDir: dirname2(actualPath)
+    };
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
@@ -2944,6 +3021,11 @@ async function loadConfig(configPath) {
     );
   }
 }
+async function loadConfigAndSetWorkspace(configPath) {
+  const result = await loadConfigWithPath(configPath);
+  setCliContext({ workspace: result.configDir });
+  return result.config;
+}
 function validateConfig(config) {
   if (!config || typeof config !== "object") {
     throw new ConfigError("Configuration must be an object");
@@ -2974,61 +3056,114 @@ function validateConfig(config) {
         );
       }
       const tb = integrations.timeback;
-      if (!tb.course) {
-        throw new ConfigError(
-          'TimeBack integration requires a "course" configuration',
-          "integrations.timeback.course",
-          'Add timeback.course with subjects and grades: timeback: { course: { subjects: ["Math"], grades: [3, 4, 5] } }'
-        );
-      }
-      if (typeof tb.course !== "object") {
+      if (!tb.courses) {
         throw new ConfigError(
-          'The "integrations.timeback.course" field must be an object',
-          "integrations.timeback.course",
-          'Change to an object: course: { subjects: ["Math"], grades: [3, 4, 5] }'
+          'TimeBack integration requires a "courses" array',
+          "integrations.timeback.courses",
+          'Add timeback.courses array: timeback: { courses: [{ subject: "Math", grade: 3 }] }'
         );
       }
-      const course = tb.course;
-      if (!course.subjects || !Array.isArray(course.subjects) || course.subjects.length === 0) {
+      if (!Array.isArray(tb.courses)) {
         throw new ConfigError(
-          "TimeBack course requires at least one subject",
-          "integrations.timeback.course.subjects",
-          'Add subjects array: subjects: ["Math"], or subjects: ["Reading", "Writing"]'
+          'The "integrations.timeback.courses" field must be an array',
+          "integrations.timeback.courses",
+          'Change to an array: courses: [{ subject: "Math", grade: 3 }]'
         );
       }
-      if (!course.grades || !Array.isArray(course.grades) || course.grades.length === 0) {
+      if (tb.courses.length === 0) {
         throw new ConfigError(
-          "TimeBack course requires at least one grade level",
-          "integrations.timeback.course.grades",
-          "Add grades array: grades: [3, 4, 5], or grades: [9, 10, 11, 12]"
+          "TimeBack courses array cannot be empty",
+          "integrations.timeback.courses",
+          'Add at least one course: courses: [{ subject: "Math", grade: 3 }]'
         );
       }
-      if (tb.organization) {
-        if (typeof tb.organization !== "object") {
+      tb.courses.forEach((course, idx) => {
+        if (typeof course !== "object" || course === null) {
           throw new ConfigError(
-            'The "integrations.timeback.organization" field must be an object',
-            "integrations.timeback.organization",
-            'Change to an object: organization: { name: "My School", type: "school" }'
+            `Course at index ${idx} must be an object`,
+            `integrations.timeback.courses[${idx}]`,
+            'Each course must have subject and grade: { subject: "Math", grade: 3 }'
           );
         }
-        const org = tb.organization;
-        if (org.type) {
-          const validOrgTypes = [
-            "department",
-            "school",
-            "district",
-            "local",
-            "state",
-            "national"
-          ];
-          if (!validOrgTypes.includes(org.type)) {
+        const courseObj = course;
+        if (typeof courseObj.subject !== "string") {
+          throw new ConfigError(
+            `Course at index ${idx} is missing required "subject" field`,
+            `integrations.timeback.courses[${idx}].subject`,
+            'Add subject string: { subject: "Math", grade: 3 }'
+          );
+        }
+        if (typeof courseObj.grade !== "number") {
+          throw new ConfigError(
+            `Course at index ${idx} is missing required "grade" field`,
+            `integrations.timeback.courses[${idx}].grade`,
+            'Add grade number: { subject: "Math", grade: 3 }'
+          );
+        }
+        const stringOverrides = ["title", "courseCode", "level", "gradingScheme"];
+        stringOverrides.forEach((field) => {
+          if (courseObj[field] !== void 0 && typeof courseObj[field] !== "string") {
             throw new ConfigError(
-              `Invalid organization type: "${org.type}"`,
-              "integrations.timeback.organization.type",
-              `Use one of: ${validOrgTypes.join(", ")}. Example: type: "school"`
+              `Course at index ${idx} has invalid "${field}" field (must be a string)`,
+              `integrations.timeback.courses[${idx}].${field}`,
+              `${field} must be a string if provided`
             );
           }
+        });
+        if (courseObj.metadata !== void 0 && typeof courseObj.metadata !== "object") {
+          throw new ConfigError(
+            `Course at index ${idx} has invalid "metadata" field (must be an object)`,
+            `integrations.timeback.courses[${idx}].metadata`,
+            "metadata must be an object if provided"
+          );
+        }
+      });
+      if (tb.base) {
+        if (typeof tb.base !== "object") {
+          throw new ConfigError(
+            'The "integrations.timeback.base" field must be an object',
+            "integrations.timeback.base",
+            "Change to an object: base: { organization: { ... }, course: { ... } }"
+          );
         }
+        const base = tb.base;
+        if (base.organization) {
+          if (typeof base.organization !== "object") {
+            throw new ConfigError(
+              'The "integrations.timeback.base.organization" field must be an object',
+              "integrations.timeback.base.organization",
+              'Change to an object: organization: { name: "My School", type: "school" }'
+            );
+          }
+          const org = base.organization;
+          if (org.type) {
+            const validOrgTypes = [
+              "department",
+              "school",
+              "district",
+              "local",
+              "state",
+              "national"
+            ];
+            if (!validOrgTypes.includes(org.type)) {
+              throw new ConfigError(
+                `Invalid organization type: "${org.type}"`,
+                "integrations.timeback.base.organization.type",
+                `Use one of: ${validOrgTypes.join(", ")}. Example: type: "school"`
+              );
+            }
+          }
+        }
+        const baseSections = ["course", "component", "resource", "componentResource"];
+        baseSections.forEach((section) => {
+          if (base[section] !== void 0 && typeof base[section] !== "object") {
+            throw new ConfigError(
+              `The "integrations.timeback.base.${section}" field must be an object`,
+              `integrations.timeback.base.${section}`,
+              `Change to an object: ${section}: { ... }`
+            );
+          }
+        });
       }
     }
   }
@@ -3061,10 +3196,10 @@ import { join as join15 } from "path";
 import { Log, LogLevel, Miniflare } from "miniflare";
 
 // ../utils/src/port.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createServer } from "node:net";
 import { homedir } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function isPortAvailableOnHost(port, host) {
   return new Promise((resolve4) => {
     const server = createServer();
@@ -3103,15 +3238,15 @@ async function findAvailablePort(startPort = 4321) {
 }
 function getRegistryPath() {
   const home = homedir();
-  const dir = join5(home, ".playcademy");
-  if (!existsSync2(dir)) {
+  const dir = join6(home, ".playcademy");
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  return join5(dir, ".proc");
+  return join6(dir, ".proc");
 }
 function readRegistry() {
   const registryPath = getRegistryPath();
-  if (!existsSync2(registryPath)) {
+  if (!existsSync3(registryPath)) {
     return {};
   }
   try {
@@ -3148,66 +3283,7 @@ function readServerInfo(type, projectRoot) {
 }
 
 // src/lib/core/client.ts
-import { PlaycademyClient } from "@playcademy/sdk";
-
-// ../utils/src/package-manager.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { join as join6 } from "path";
-function isCommandAvailable(command) {
-  try {
-    execSync(`command -v ${command}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function detectPackageManager(cwd = process.cwd()) {
-  if (existsSync3(join6(cwd, "bun.lock")) || existsSync3(join6(cwd, "bun.lockb"))) {
-    return "bun";
-  }
-  if (existsSync3(join6(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (existsSync3(join6(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (existsSync3(join6(cwd, "package-lock.json"))) {
-    return "npm";
-  }
-  return detectByCommandAvailability();
-}
-function detectByCommandAvailability() {
-  if (isCommandAvailable("bun")) {
-    return "bun";
-  }
-  if (isCommandAvailable("pnpm")) {
-    return "pnpm";
-  }
-  if (isCommandAvailable("yarn")) {
-    return "yarn";
-  }
-  return "npm";
-}
-function getInstallCommand(pm) {
-  switch (pm) {
-    case "bun":
-      return "bun install";
-    case "pnpm":
-      return "pnpm install";
-    case "yarn":
-      return "yarn install";
-    case "npm":
-    default:
-      return "npm install";
-  }
-}
-
-// src/lib/core/context.ts
-var context = {};
-function getWorkspace() {
-  return context.workspace || process.cwd();
-}
+import { PlaycademyClient } from "@playcademy/sdk/internal";
 
 // src/lib/core/errors.ts
 function getErrorMessage(error) {
@@ -3913,7 +3989,7 @@ import { join as join11 } from "path";
 // package.json
 var package_default2 = {
   name: "playcademy",
-  version: "0.14.18",
+  version: "0.14.20",
   type: "module",
   exports: {
     ".": {
@@ -4295,7 +4371,7 @@ async function startDevServer(options) {
   const config = providedConfig ?? await loadConfig();
   await ensurePlaycademyTypes();
   const hasSandboxTimebackCreds = !!process.env.TIMEBACK_API_CLIENT_ID;
-  const devConfig = config.integrations?.timeback && !hasSandboxTimebackCreds ? { ...config, integrations: { ...config.integrations, timeback: void 0 } } : config;
+  const devConfig = config.integrations?.timeback && !hasSandboxTimebackCreds ? { ...config, integrations: { ...config.integrations, timeback: null } } : config;
   const bundle = await bundleBackend(devConfig, {
     sourcemap: false,
     minify: false
@@ -4459,6 +4535,8 @@ export {
   importTypescriptDefault,
   importTypescriptFile,
   loadConfig as loadPlaycademyConfig,
+  loadConfigAndSetWorkspace as loadPlaycademyConfigAndSetWorkspace,
+  setCliContext as setPlaycademyCliContext,
   startDevServer as startPlaycademyDevServer,
   startHotReload as startPlaycademyHotReload,
   validateConfig as validatePlaycademyConfig