playcademy 0.11.3 → 0.11.5

package/dist/edge-play/src/constants.ts

@@ -13,11 +13,14 @@ export { WORKER_ENV_VARS as ENV_VARS, WORKER_NAMING }
  * Built-in API routes
  */
 export const ROUTES = {
-    /** Health check endpoint */
-    HEALTH: '/api/health',
     /** Route index (lists available routes) */
     INDEX: '/api',
 
-    /** TimeBack integration routes (imported from @playcademy/constants) */
-    TIMEBACK: TIMEBACK_ROUTES,
+    /** Health check endpoint */
+    HEALTH: '/api/health',
+
+    /** TimeBack integration routes */
+    TIMEBACK: {
+        END_ACTIVITY: `/api${TIMEBACK_ROUTES.END_ACTIVITY}`,
+    },
 } as const

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

@@ -97,12 +97,12 @@ app.use('*', async (c, next) => {
  * Register built-in integration routes based on enabled integrations
  *
  * This function conditionally imports and registers routes like:
- * - POST /api/integrations/timeback/progress (if timeback enabled)
+ * - POST /api/integrations/timeback/end-activity (if timeback enabled)
  * - GET /api/health (always included)
  *
  * Uses dynamic imports for tree-shaking: if an integration is not enabled,
  * its route code is completely removed from the bundle.
  */
-registerBuiltinRoutes(app, PLAYCADEMY_CONFIG.integrations)
+await registerBuiltinRoutes(app, PLAYCADEMY_CONFIG.integrations)
 
 export default app

package/dist/edge-play/src/index.ts

@@ -1 +1,2 @@
 export { registerBuiltinRoutes } from './register-routes'
+export { ROUTES } from './constants'

package/dist/edge-play/src/register-routes.ts

@@ -31,15 +31,12 @@ export async function registerBuiltinRoutes(app: Hono<HonoEnv>, integrations?: I
 
     // TimeBack integration
     if (integrations?.timeback) {
-        const [progress, sessionEnd, awardXp] = await Promise.all([
-            import('./routes/integrations/timeback/progress'),
-            import('./routes/integrations/timeback/session-end'),
-            import('./routes/integrations/timeback/award-xp'),
+        const [endActivity] = await Promise.all([
+            import('./routes/integrations/timeback/end-activity'),
+            // ... other routes
         ])
-
-        app.post(ROUTES.TIMEBACK.PROGRESS, progress.POST)
-        app.post(ROUTES.TIMEBACK.SESSION_END, sessionEnd.POST)
-        app.post(ROUTES.TIMEBACK.AWARD_XP, awardXp.POST)
+        app.post(ROUTES.TIMEBACK.END_ACTIVITY, endActivity.POST)
+        // ... other routes
     }
 
     // TODO: Auth integration

package/dist/edge-play/src/routes/index.ts

@@ -2,22 +2,24 @@
  * Route discovery endpoint
  * Route: GET /api
  * Always included - lists all available routes
+ *
+ * NOTE: This pulls from the actual ROUTES constants used for registration,
+ * ensuring the advertised routes match what's actually deployed.
  */
 
+import { ROUTES } from '../constants'
+
 import type { Context } from 'hono'
 import type { HonoEnv } from '../types'
 
 export async function GET(c: Context<HonoEnv>): Promise<Response> {
     const config = c.get('config')
     const customRoutes = c.get('customRoutes') || []
-    const routes: string[] = ['GET /api', 'GET /api/health']
+    const routes: string[] = [`GET ${ROUTES.INDEX}`, `GET ${ROUTES.HEALTH}`]
 
+    // Add TimeBack routes if configured
     if (config.integrations?.timeback) {
-        routes.push(
-            'POST /api/integrations/timeback/progress',
-            'POST /api/integrations/timeback/session-end',
-            'POST /api/integrations/timeback/award-xp',
-        )
+        routes.push(`POST ${ROUTES.TIMEBACK.END_ACTIVITY}`)
     }
 
     // Add custom routes

package/dist/edge-play/src/routes/integrations/timeback/{session-end.ts → end-activity.ts}

@@ -1,18 +1,19 @@
 import { verifyGameToken } from '@playcademy/sdk/server'
 
 import type { Context } from 'hono'
-import type { PlaycademyConfig, SessionData } from '@playcademy/sdk/server'
+import type { PlaycademyConfig } from '@playcademy/sdk/server'
+import type { ActivityData } from '@playcademy/timeback/types'
 import type { HonoEnv } from '../../../types'
 
 /**
- * TimeBack integration - Record session end
- * Route: POST /api/integrations/timeback/session-end
+ * TimeBack integration - End activity and submit results
+ * Route: POST /api/integrations/timeback/end-activity
  * Auto-generated when integrations.timeback is configured
  *
  * Flow:
- * 1. Game frontend calls this route on deployed backend ({slug}.playcademy.gg/api/integrations/timeback/session-end)
- * 2. This route calls Playcademy platform API via SDK (hub.playcademy.net/api/timeback/session-end)
- * 3. Platform API sends Caliper events to TimeBack
+ * 1. Game frontend calls this route on deployed backend ({slug}.playcademy.gg/api/integrations/timeback/end-activity)
+ * 2. This route calls Playcademy platform API via SDK (hub.playcademy.net/api/timeback/end-activity)
+ * 3. Platform API sends both ActivityEvent and TimeSpent Caliper events to TimeBack
  *
  * This acts as a secure proxy - game developers don't need TimeBack credentials or
  * their own backend infrastructure. The SDK handles config enrichment and metadata.
@@ -25,23 +26,23 @@ function getConfig(c: Context<HonoEnv>): PlaycademyConfig {
     return config
 }
 
-function enrichSessionData(
-    sessionData: SessionData,
+function enrichActivityData(
+    activityData: ActivityData,
     config: PlaycademyConfig,
     c: Context<HonoEnv>,
-): SessionData {
-    const appName = sessionData.appName || config?.name
+): ActivityData {
+    const appName = activityData.appName || config?.name
     const subject =
-        sessionData.subject ||
+        activityData.subject ||
         config?.integrations?.timeback?.course?.defaultSubject ||
         config?.integrations?.timeback?.course?.subjects?.[0]
-    const sensorUrl = sessionData.sensorUrl || new URL(c.req.url).origin
+    const sensorUrl = activityData.sensorUrl || new URL(c.req.url).origin
 
     if (!appName) throw new Error('App name is required')
     if (!subject) throw new Error('Subject is required')
     if (!sensorUrl) throw new Error('Sensor URL is required')
 
-    return { ...sessionData, appName, subject, sensorUrl }
+    return { ...activityData, appName, subject, sensorUrl }
 }
 
 export async function POST(c: Context<HonoEnv>): Promise<Response> {
@@ -52,7 +53,7 @@ export async function POST(c: Context<HonoEnv>): Promise<Response> {
             return c.json({ error: 'Unauthorized' }, 401)
         }
 
-        const { user } = await verifyGameToken(token)
+        const { user } = await verifyGameToken(token, { baseUrl: c.env.PLAYCADEMY_BASE_URL })
 
         // 2. Ensure user has TimeBack integration
         if (!user.timeback_id) {
@@ -60,26 +61,43 @@ export async function POST(c: Context<HonoEnv>): Promise<Response> {
         }
 
         // 3. Parse request body
-        const { sessionData } = await c.req.json()
+        const { activityData, scoreData, timingData, xpEarned } = await c.req.json()
 
-        // 4. Get config and enrich session data with required Caliper fields
-        const config = getConfig(c)
+        // 4. Validate required fields
+        if (!activityData?.activityId) {
+            return c.json({ error: 'activityId is required' }, 400)
+        }
+        if (
+            typeof scoreData?.correctQuestions !== 'number' ||
+            typeof scoreData?.totalQuestions !== 'number'
+        ) {
+            return c.json({ error: 'correctQuestions and totalQuestions are required' }, 400)
+        }
+        if (typeof timingData?.durationSeconds !== 'number') {
+            return c.json({ error: 'durationSeconds is required' }, 400)
+        }
 
-        // 5. Enrich session data with required Caliper fields
-        const enrichedSessionData = enrichSessionData(sessionData, config, c)
+        // 5. Get config and enrich activity data with required Caliper fields
+        const config = getConfig(c)
+        const enrichedActivityData = enrichActivityData(activityData, config, c)
 
         // 6. Get SDK client from context (initialized once per Worker, reused across requests)
         const sdk = c.get('sdk')
 
-        // 7. Record session timing to TimeBack (SDK handles enrichment & Caliper events)
-        const result = await sdk.timeback.recordSessionEnd(user.timeback_id, enrichedSessionData)
+        // 7. End activity (SDK calculates XP server-side with attempt tracking)
+        const result = await sdk.timeback.endActivity(user.timeback_id, {
+            activityData: enrichedActivityData,
+            scoreData,
+            timingData,
+            xpEarned,
+        })
 
         return c.json(result)
     } catch (error) {
-        console.error('[TimeBack Session End] Error:', error)
+        console.error('[TimeBack End Activity] Error:', error)
         return c.json(
             {
-                error: 'Failed to record session end',
+                error: 'Failed to end activity',
                 message: error instanceof Error ? error.message : String(error),
                 stack: error instanceof Error ? error.stack : undefined,
             },