playcademy 0.11.4 → 0.11.6

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

@@ -13,15 +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',
 
+    /** Health check endpoint */
+    HEALTH: '/api/health',
+
     /** TimeBack integration routes */
     TIMEBACK: {
-        PROGRESS: `/api${TIMEBACK_ROUTES.PROGRESS}`,
-        SESSION_END: `/api${TIMEBACK_ROUTES.SESSION_END}`,
-        AWARD_XP: `/api${TIMEBACK_ROUTES.AWARD_XP}`,
+        END_ACTIVITY: `/api${TIMEBACK_ROUTES.END_ACTIVITY}`,
     },
 } as const

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

@@ -97,7 +97,7 @@ 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,

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

@@ -19,11 +19,7 @@ export async function GET(c: Context<HonoEnv>): Promise<Response> {
 
     // Add TimeBack routes if configured
     if (config.integrations?.timeback) {
-        routes.push(
-            `POST ${ROUTES.TIMEBACK.PROGRESS}`,
-            `POST ${ROUTES.TIMEBACK.SESSION_END}`,
-            `POST ${ROUTES.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,
             },