playcademy 0.9.0 → 0.11.0

package/dist/constants.d.ts

@@ -0,0 +1,40 @@
+/**
+ * HTTP server constants for CLI OAuth callback handling
+ */
+/** Port for the local callback server */
+declare const CALLBACK_PORT = 6175;
+/** Path for the OAuth callback endpoint */
+declare const CALLBACK_PATH = "/callback";
+/** Timeout for SSO authentication in milliseconds (30 seconds) */
+declare const SSO_AUTH_TIMEOUT_MS = 30000;
+
+/**
+ * Default port numbers for local development servers
+ */
+declare const DEFAULT_PORTS: {
+    /** Sandbox server (mock platform API) */
+    readonly SANDBOX: 4321;
+    /** Backend dev server (game backend with HMR) */
+    readonly BACKEND: 8788;
+};
+
+/**
+ * Config file names to search for
+ */
+declare const CONFIG_FILE_NAMES: string[];
+
+/**
+ * Base URLs for Playcademy platform environments
+ */
+declare const PLAYCADEMY_BASE_URLS: {
+    readonly staging: "https://hub.dev.playcademy.net";
+    readonly production: "https://hub.playcademy.com";
+};
+/**
+ * Game backend domain for deployed Workers
+ * Staging games use {slug}-staging.playcademy.gg
+ * Production games use {slug}.playcademy.gg
+ */
+declare const GAME_BACKEND_DOMAIN: "playcademy.gg";
+
+export { CALLBACK_PATH, CALLBACK_PORT, CONFIG_FILE_NAMES, DEFAULT_PORTS, GAME_BACKEND_DOMAIN, PLAYCADEMY_BASE_URLS, SSO_AUTH_TIMEOUT_MS };

package/dist/constants.js

@@ -0,0 +1,35 @@
+// src/constants/http-server.ts
+var CALLBACK_PORT = 6175;
+var CALLBACK_PATH = "/callback";
+var SSO_AUTH_TIMEOUT_MS = 3e4;
+
+// src/constants/ports.ts
+var DEFAULT_PORTS = {
+  /** Sandbox server (mock platform API) */
+  SANDBOX: 4321,
+  /** Backend dev server (game backend with HMR) */
+  BACKEND: 8788
+};
+
+// src/constants/timeback.ts
+var CONFIG_FILE_NAMES = [
+  "playcademy.config.js",
+  "playcademy.config.json",
+  "playcademy.config.mjs"
+];
+
+// src/constants/urls.ts
+var PLAYCADEMY_BASE_URLS = {
+  staging: "https://hub.dev.playcademy.net",
+  production: "https://hub.playcademy.com"
+};
+var GAME_BACKEND_DOMAIN = "playcademy.gg";
+export {
+  CALLBACK_PATH,
+  CALLBACK_PORT,
+  CONFIG_FILE_NAMES,
+  DEFAULT_PORTS,
+  GAME_BACKEND_DOMAIN,
+  PLAYCADEMY_BASE_URLS,
+  SSO_AUTH_TIMEOUT_MS
+};

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

@@ -0,0 +1,42 @@
+/**
+ * Constants for game backend workers
+ */
+
+/**
+ * Environment variable names required for game backend workers
+ */
+export const ENV_VARS = {
+    /** Game-specific API key for calling platform API */
+    PLAYCADEMY_API_KEY: 'PLAYCADEMY_API_KEY',
+    /** Game ID (UUID) */
+    GAME_ID: 'GAME_ID',
+    /** Platform API base URL */
+    PLAYCADEMY_BASE_URL: 'PLAYCADEMY_BASE_URL',
+} as const
+
+/**
+ * Built-in API routes
+ */
+export const ROUTES = {
+    /** Health check endpoint */
+    HEALTH: '/api/health',
+    /** Route index (lists available routes) */
+    INDEX: '/api',
+
+    /** TimeBack integration routes */
+    TIMEBACK: {
+        PROGRESS: '/api/integrations/timeback/progress',
+        SESSION_END: '/api/integrations/timeback/session-end',
+        AWARD_XP: '/api/integrations/timeback/award-xp',
+    },
+} as const
+
+/**
+ * Worker naming patterns
+ */
+export const WORKER_NAMING = {
+    /** Staging workers are prefixed to avoid namespace collisions */
+    STAGING_PREFIX: 'staging-',
+    /** Staging subdomain suffix */
+    STAGING_SUFFIX: '-staging',
+} as const

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

@@ -0,0 +1,108 @@
+/**
+ * Game Backend Entry Point
+ *
+ * This file is the main entry point for deployed game backends.
+ * It creates a Hono app and registers all enabled integration routes.
+ *
+ * Bundled with esbuild and deployed to Cloudflare Workers (or AWS Lambda).
+ * Config is injected at build time via esbuild's `define` option.
+ */
+
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+
+import { PlaycademyClient } from '@playcademy/sdk/server'
+
+import { ENV_VARS } from './constants'
+import { registerBuiltinRoutes } from './register-routes'
+
+import type { PlaycademyConfig } from '@playcademy/sdk/server'
+import type { HonoEnv } from './types'
+
+/**
+ * Config injected at build time by esbuild
+ *
+ * The `declare const` tells TypeScript "this exists at runtime, trust me."
+ * During bundling, esbuild's `define` option does literal text replacement:
+ *
+ * Example bundling:
+ *   Source:  if (PLAYCADEMY_CONFIG.integrations.timeback) { ... }
+ *   Define:  { 'PLAYCADEMY_CONFIG': JSON.stringify({ integrations: { timeback: {...} } }) }
+ *   Output:  if ({"integrations":{"timeback":{...}}}.integrations.timeback) { ... }
+ *
+ * This enables tree-shaking: if timeback is not configured, those code paths are removed.
+ * The bundled Worker only includes the routes that are actually enabled.
+ */
+declare const PLAYCADEMY_CONFIG: PlaycademyConfig & {
+    customRoutes?: Array<{ path: string; file: string }>
+}
+
+// XXX: Polyfill process global for SDK compatibility
+// SDK code may reference process.env without importing it
+// @ts-expect-error - Adding global for Worker environment
+globalThis.process = {
+    env: {}, // Populated per-request from Worker env bindings
+    cwd: () => '/',
+}
+
+const app = new Hono<HonoEnv>()
+
+// TODO: Harden CORS in production - restrict to trusted origins:
+// - Game's assetBundleBase (for hosted games)
+// - Game's externalUrl (for external games)
+// - Platform frontend domains (hub.playcademy.com, hub.dev.playcademy.net)
+// This would require passing game metadata through env bindings during deployment
+app.use(
+    '*',
+    cors({
+        origin: '*', // Permissive for now
+        allowMethods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+        allowHeaders: ['Content-Type', 'Authorization'],
+    }),
+)
+
+let sdkPromise: Promise<PlaycademyClient> | null = null
+
+app.use('*', async (c, next) => {
+    // Populate process.env from Worker bindings for SDK compatibility
+    globalThis.process.env = {
+        [ENV_VARS.PLAYCADEMY_API_KEY]: c.env.PLAYCADEMY_API_KEY,
+        [ENV_VARS.GAME_ID]: c.env.GAME_ID,
+        [ENV_VARS.PLAYCADEMY_BASE_URL]: c.env.PLAYCADEMY_BASE_URL,
+    }
+
+    // Set config for all routes
+    c.set('config', PLAYCADEMY_CONFIG)
+    c.set('customRoutes', PLAYCADEMY_CONFIG.customRoutes || [])
+
+    await next()
+})
+
+// Initialize SDK lazily on first request
+app.use('*', async (c, next) => {
+    if (!sdkPromise) {
+        sdkPromise = PlaycademyClient.init({
+            apiKey: c.env[ENV_VARS.PLAYCADEMY_API_KEY],
+            gameId: c.env[ENV_VARS.GAME_ID],
+            baseUrl: c.env[ENV_VARS.PLAYCADEMY_BASE_URL],
+            config: PLAYCADEMY_CONFIG,
+        })
+    }
+
+    c.set('sdk', await sdkPromise)
+    await 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)
+ * - 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)
+
+export default app

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

@@ -0,0 +1 @@
+export { registerBuiltinRoutes } from './register-routes'

package/dist/edge-play/src/polyfills.js

@@ -0,0 +1,54 @@
+/**
+ * Polyfills for Node.js modules in edge runtimes
+ *
+ * Provides minimal implementations to allow bundling.
+ * These should NOT be called at runtime (config is provided directly).
+ */
+
+const notAvailable = name => {
+    throw new Error(`${name} not available in Worker runtime - config should be provided directly`)
+}
+
+// fs exports
+export const existsSync = () => notAvailable('fs.existsSync')
+export const readdirSync = () => notAvailable('fs.readdirSync')
+export const statSync = () => notAvailable('fs.statSync')
+export const readFile = () => notAvailable('fs/promises.readFile')
+
+// path exports
+export const resolve = (...args) => args.join('/')
+export const dirname = p => p.split('/').slice(0, -1).join('/')
+export const parse = p => ({
+    dir: dirname(p),
+    name: p.split('/').pop(),
+    base: p.split('/').pop(),
+    ext: '',
+    root: '/',
+})
+export const join = (...args) => args.join('/')
+
+// os exports
+export const tmpdir = () => '/tmp'
+export const homedir = () => notAvailable('os.homedir')
+
+// Default export for 'process' module
+export default {
+    env: {
+        // These will be set by the Worker environment
+        // Cloudflare Workers uses env bindings, but we access via process.env
+        PLAYCADEMY_API_KEY: globalThis.PLAYCADEMY_API_KEY || '',
+        GAME_ID: globalThis.GAME_ID || '',
+        PLAYCADEMY_BASE_URL: globalThis.PLAYCADEMY_BASE_URL || '',
+    },
+    cwd: () => '/',
+}
+
+// Named export as well for compatibility
+export const process = {
+    env: {
+        PLAYCADEMY_API_KEY: globalThis.PLAYCADEMY_API_KEY || '',
+        GAME_ID: globalThis.GAME_ID || '',
+        PLAYCADEMY_BASE_URL: globalThis.PLAYCADEMY_BASE_URL || '',
+    },
+    cwd: () => '/',
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Route Registration Helper
+ *
+ * Conditionally registers built-in integration routes based on enabled integrations.
+ * Uses dynamic imports to enable tree-shaking (unused integrations are removed from bundle).
+ */
+
+import { ROUTES } from './constants'
+
+import type { Hono } from 'hono'
+import type { HonoEnv, Integrations } from './types'
+
+/**
+ * Registers all enabled built-in integration routes
+ *
+ * @param app - Hono application instance
+ * @param integrations - Enabled integrations from config
+ */
+export async function registerBuiltinRoutes(app: Hono<HonoEnv>, integrations?: Integrations) {
+    // Root page (always included)
+    const root = await import('./routes/root')
+    app.get('/', root.GET)
+
+    // Route discovery (always included)
+    const routesIndex = await import('./routes/index')
+    app.get(ROUTES.INDEX, routesIndex.GET)
+
+    // Health check (always included)
+    const health = await import('./routes/health')
+    app.get(ROUTES.HEALTH, health.GET)
+
+    // 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'),
+        ])
+
+        app.post(ROUTES.TIMEBACK.PROGRESS, progress.POST)
+        app.post(ROUTES.TIMEBACK.SESSION_END, sessionEnd.POST)
+        app.post(ROUTES.TIMEBACK.AWARD_XP, awardXp.POST)
+    }
+
+    // TODO: Auth integration
+    // TODO: Storage integration
+    // TODO: Realtime integration
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Health check endpoint
+ * Route: GET /api/health
+ * Always included in deployed backends
+ */
+
+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 sdk = c.get('sdk')
+
+    return c.json({
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+
+        // Environment check
+        env: {
+            hasApiKey: !!c.env.PLAYCADEMY_API_KEY,
+            hasGameId: !!c.env.GAME_ID,
+            hasBaseUrl: !!c.env.PLAYCADEMY_BASE_URL,
+        },
+
+        // Config presence
+        config: {
+            hasConfig: !!config,
+            hasIntegrations: !!config?.integrations,
+        },
+
+        // TimeBack status
+        timeback: {
+            enabled: !!config?.integrations?.timeback,
+            courseIdFetched: !!sdk?.timeback?.courseId,
+        },
+
+        // Custom routes info
+        customRoutes:
+            c.get('customRoutes')?.map(r => ({
+                path: r.path,
+                methods: r.methods,
+            })) || [],
+    })
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Route discovery endpoint
+ * Route: GET /api
+ * Always included - lists all available routes
+ */
+
+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']
+
+    if (config.integrations?.timeback) {
+        routes.push(
+            'POST /api/integrations/timeback/progress',
+            'POST /api/integrations/timeback/session-end',
+            'POST /api/integrations/timeback/award-xp',
+        )
+    }
+
+    // Add custom routes
+    for (const route of customRoutes) {
+        const methods = route.methods?.join(', ') || '*'
+        routes.push(`${methods} ${route.path}`)
+    }
+
+    return c.json({
+        name: config.name,
+        routes,
+    })
+}

package/dist/edge-play/src/routes/integrations/timeback/award-xp.ts

@@ -0,0 +1,87 @@
+import { verifyGameToken } from '@playcademy/sdk/server'
+
+import type { Context } from 'hono'
+import type { PlaycademyConfig, XPAwardMetadata } from '@playcademy/sdk/server'
+import type { HonoEnv } from '../../../types'
+
+/**
+ * TimeBack integration - Award XP to student
+ * Route: POST /api/integrations/timeback/award-xp
+ * Auto-generated when integrations.timeback is configured
+ *
+ * Flow:
+ * 1. Game frontend calls this route on deployed backend ({slug}.playcademy.gg/api/integrations/timeback/award-xp)
+ * 2. This route calls Playcademy platform API via SDK (hub.playcademy.net/api/timeback/award-xp)
+ * 3. Platform API sends 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.
+ */
+
+function getConfig(c: Context<HonoEnv>): PlaycademyConfig {
+    const config = c.get('config')
+    const timebackConfig = config?.integrations?.timeback
+    if (!timebackConfig) throw new Error('TimeBack integration not found')
+    return config
+}
+
+function enrichMetadata(
+    metadata: XPAwardMetadata,
+    config: PlaycademyConfig,
+    c: Context<HonoEnv>,
+): XPAwardMetadata {
+    const appName = metadata.appName || config?.name
+    const subject =
+        metadata.subject ||
+        config?.integrations?.timeback?.course?.defaultSubject ||
+        config?.integrations?.timeback?.course?.subjects?.[0]
+    const sensorUrl = metadata.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 { ...metadata, appName, subject, sensorUrl }
+}
+
+export async function POST(c: Context<HonoEnv>): Promise<Response> {
+    try {
+        // 1. Verify game token from frontend (calls platform API for verification)
+        const token = c.req.header('Authorization')?.replace('Bearer ', '')
+        if (!token) return c.json({ error: 'Unauthorized' }, 401)
+
+        const { user } = await verifyGameToken(token)
+
+        // 2. Ensure user has TimeBack integration
+        if (!user.timeback_id) {
+            return c.json({ error: 'User does not have TimeBack integration' }, 400)
+        }
+
+        // 3. Parse request body
+        const { xpAmount, metadata } = await c.req.json()
+
+        // 4. Get config and enrich metadata with required Caliper fields
+        const config = getConfig(c)
+
+        // 5. Enrich metadata with required Caliper fields
+        const enrichedMetadata = enrichMetadata(metadata, config, c)
+
+        // 6. Get SDK client from context (initialized once per Worker, reused across requests)
+        const sdk = c.get('sdk')
+
+        // 7. Award XP to student (SDK handles enrichment & Caliper events)
+        const result = await sdk.timeback.awardXP(user.timeback_id, xpAmount, enrichedMetadata)
+
+        return c.json(result)
+    } catch (error) {
+        console.error('[TimeBack Award XP] Error:', error)
+        return c.json(
+            {
+                error: 'Failed to award XP',
+                message: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            },
+            500,
+        )
+    }
+}

package/dist/edge-play/src/routes/integrations/timeback/progress.ts

@@ -0,0 +1,89 @@
+import { verifyGameToken } from '@playcademy/sdk/server'
+
+import type { Context } from 'hono'
+import type { PlaycademyConfig, ProgressData } from '@playcademy/sdk/server'
+import type { HonoEnv } from '../../../types'
+
+/**
+ * TimeBack integration - Record student progress
+ * Route: POST /api/integrations/timeback/progress
+ * Auto-generated when integrations.timeback is configured
+ *
+ * Flow:
+ * 1. Game frontend calls this route on deployed backend ({slug}.playcademy.gg/api/integrations/timeback/progress)
+ * 2. This route calls Playcademy platform API via SDK (hub.playcademy.net/api/timeback/progress)
+ * 3. Platform API sends 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.
+ */
+
+function getConfig(c: Context<HonoEnv>): PlaycademyConfig {
+    const config = c.get('config')
+    const timebackConfig = config?.integrations?.timeback
+    if (!timebackConfig) throw new Error('TimeBack integration not found')
+    return config
+}
+
+function enrichProgressData(
+    progressData: ProgressData,
+    config: PlaycademyConfig,
+    c: Context<HonoEnv>,
+): ProgressData {
+    const appName = progressData.appName || config?.name
+    const subject =
+        progressData.subject ||
+        config?.integrations?.timeback?.course?.defaultSubject ||
+        config?.integrations?.timeback?.course?.subjects?.[0]
+    const sensorUrl = progressData.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 { ...progressData, appName, subject, sensorUrl }
+}
+
+export async function POST(c: Context<HonoEnv>): Promise<Response> {
+    try {
+        // 1. Verify game token from frontend (calls platform API for verification)
+        const token = c.req.header('Authorization')?.replace('Bearer ', '')
+        if (!token) {
+            return c.json({ error: 'Unauthorized' }, 401)
+        }
+
+        const { user } = await verifyGameToken(token)
+
+        // 2. Ensure user has TimeBack integration
+        if (!user.timeback_id) {
+            return c.json({ error: 'User does not have TimeBack integration' }, 400)
+        }
+
+        // 3. Parse request body
+        const { progressData } = await c.req.json()
+
+        // 4. Get config and enrich progress data with required Caliper fields
+        const config = getConfig(c)
+
+        // 5. Enrich progress data with required Caliper fields
+        const enrichedProgressData = enrichProgressData(progressData, config, c)
+
+        // 5. Get SDK client from context (initialized once per Worker, reused across requests)
+        const sdk = c.get('sdk')
+
+        // 6. Record progress to TimeBack (SDK handles enrichment & Caliper events)
+        const result = await sdk.timeback.recordProgress(user.timeback_id, enrichedProgressData)
+
+        return c.json(result)
+    } catch (error) {
+        console.error('[TimeBack Progress] Error:', error)
+        return c.json(
+            {
+                error: 'Failed to record progress',
+                message: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            },
+            500,
+        )
+    }
+}

package/dist/edge-play/src/routes/integrations/timeback/session-end.ts

@@ -0,0 +1,89 @@
+import { verifyGameToken } from '@playcademy/sdk/server'
+
+import type { Context } from 'hono'
+import type { PlaycademyConfig, SessionData } from '@playcademy/sdk/server'
+import type { HonoEnv } from '../../../types'
+
+/**
+ * TimeBack integration - Record session end
+ * Route: POST /api/integrations/timeback/session-end
+ * 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
+ *
+ * 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.
+ */
+
+function getConfig(c: Context<HonoEnv>): PlaycademyConfig {
+    const config = c.get('config')
+    const timebackConfig = config?.integrations?.timeback
+    if (!timebackConfig) throw new Error('TimeBack integration not found')
+    return config
+}
+
+function enrichSessionData(
+    sessionData: SessionData,
+    config: PlaycademyConfig,
+    c: Context<HonoEnv>,
+): SessionData {
+    const appName = sessionData.appName || config?.name
+    const subject =
+        sessionData.subject ||
+        config?.integrations?.timeback?.course?.defaultSubject ||
+        config?.integrations?.timeback?.course?.subjects?.[0]
+    const sensorUrl = sessionData.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 }
+}
+
+export async function POST(c: Context<HonoEnv>): Promise<Response> {
+    try {
+        // 1. Verify game token from frontend (calls platform API for verification)
+        const token = c.req.header('Authorization')?.replace('Bearer ', '')
+        if (!token) {
+            return c.json({ error: 'Unauthorized' }, 401)
+        }
+
+        const { user } = await verifyGameToken(token)
+
+        // 2. Ensure user has TimeBack integration
+        if (!user.timeback_id) {
+            return c.json({ error: 'User does not have TimeBack integration' }, 400)
+        }
+
+        // 3. Parse request body
+        const { sessionData } = await c.req.json()
+
+        // 4. Get config and enrich session data with required Caliper fields
+        const config = getConfig(c)
+
+        // 5. Enrich session data with required Caliper fields
+        const enrichedSessionData = enrichSessionData(sessionData, 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)
+
+        return c.json(result)
+    } catch (error) {
+        console.error('[TimeBack Session End] Error:', error)
+        return c.json(
+            {
+                error: 'Failed to record session end',
+                message: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            },
+            500,
+        )
+    }
+}