musora-content-services 2.94.8 → 2.95.0

package/src/services/gamification/awards.ts

@@ -8,32 +8,12 @@ import { globalConfig } from '../config'
 
 const baseUrl = `/api/gamification`
 
-export interface Award {
-  id: number
-  user_id: number
-  completed_at: string // ISO-8601 timestamp
-  completion_data: {
-    message?: string
-    message_certificate?: string
-    content_title?: string
-    completed_at?: Date
-    days_user_practiced?: number
-    practice_minutes?: number
-    [key: string]: any
-  }
-  award_id: number
-  type: string
-  title: string
-  badge: string
-}
-
 export interface Certificate {
-  id: number
+  award_id: string
   user_name: string
   user_id: number
-  completed_at: string // ISO-8601 timestamp
+  completed_at: string
   message: string
-  award_id: number
   type: string
   title: string
   musora_logo: string
@@ -52,72 +32,123 @@ export interface Certificate {
 }
 
 /**
- * Get awards for a specific user.
+ * Fetch certificate data for a completed award with all images converted to base64.
+ * Returns certificate information ready for rendering in a PDF or image format.
+ * All image URLs (logos, signatures, ribbons) are converted to base64 strings for offline use.
  *
- * NOTE: needs error handling for the response from http client
- * (Alexandre: I'm doing it in a different branch/PR: https://github.com/railroadmedia/musora-content-services/pull/349)
- * NOTE: This function still expects brand because FE passes the argument. It is ignored for now
+ * @param {string} awardId - Unique Sanity award ID
  *
- * @param {number|null} [userId] - The user ID. If not provided, the authenticated user is used instead.
- * @param {string|null} [_brand] - The brand to fetch the awards for.
- * @param {number|null} [page=1] - Page attribute for pagination
- * @param {number|null} [limit=5] - Limit how many items to return
- * @returns {Promise<PaginatedResponse<Award>>} - The awards for the user.
- * @throws {HttpError} - If the HTTP request fails.
- */
-export async function fetchAwardsForUser(
-  userId?: number,
-  _brand?: string,
-  page: number = 1,
-  limit: number = 5
-): Promise<PaginatedResponse<Award>> {
-  if (!userId) {
-    userId = Number.parseInt(globalConfig.sessionConfig.userId)
-  }
-
-  const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
-  const response = await httpClient.get<PaginatedResponse<Award>>(
-    `${baseUrl}/v1/users/${userId}/awards?limit=${limit}&page=${page}`
-  )
-
-  return response
-}
-
-/**
- * Get award progress for the guided course lesson for the authorized user.
+ * @returns {Promise<Certificate>} Certificate object with base64-encoded images:
+ *   - award_id {string} - Sanity award ID
+ *   - user_name {string} - User's display name
+ *   - user_id {number} - User's ID
+ *   - completed_at {string} - ISO timestamp of completion
+ *   - message {string} - Certificate message for display
+ *   - type {string} - Award type (e.g., 'content-award')
+ *   - title {string} - Award title/name
+ *   - musora_logo {string} - URL to Musora logo
+ *   - musora_logo_64 {string} - Base64-encoded Musora logo
+ *   - musora_bg_logo {string} - URL to Musora background logo
+ *   - musora_bg_logo_64 {string} - Base64-encoded background logo
+ *   - brand_logo {string} - URL to brand logo
+ *   - brand_logo_64 {string} - Base64-encoded brand logo
+ *   - ribbon_image {string} - URL to ribbon decoration
+ *   - ribbon_image_64 {string} - Base64-encoded ribbon image
+ *   - award_image {string} - URL to award image
+ *   - award_image_64 {string} - Base64-encoded award image
+ *   - instructor_name {string} - Instructor's name
+ *   - instructor_signature {string|undefined} - URL to signature (if available)
+ *   - instructor_signature_64 {string|undefined} - Base64-encoded signature
  *
- * NOTE: needs error handling for the response from http client
- * (Alexandre: I'm doing it in a different branch/PR: https://github.com/railroadmedia/musora-content-services/pull/349)
- * NOTE: This function still expects brand because FE passes the argument. It is ignored for now
+ * @throws {Error} If award is not found or not completed
  *
- * @param {number} guidedCourseLessonId - The guided course lesson Id
- * @returns {Promise<Award>} - The award data for a given award and given user.
- * @throws {HttpError} - If the HTTP request fails.
- */
-export async function getAwardDataForGuidedContent(guidedCourseLessonId: number): Promise<Award> {
-  const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
-  const response = await httpClient.get<Award>(
-    `${baseUrl}/v1/users/guided_course_award/${guidedCourseLessonId}`
-  )
-
-  return response
-}
-
-/**
- * Get certificate data for a completed user award
+ * @platform Web only - This function uses browser-only APIs (FileReader, Blob).
+ * For React Native implementation, see the React Native section below.
+ *
+ * @example Generate certificate PDF (Web)
+ * const cert = await fetchCertificate('abc-123')
+ * generatePDF({
+ *   userName: cert.user_name,
+ *   awardTitle: cert.title,
+ *   completedAt: new Date(cert.completed_at).toLocaleDateString(),
+ *   message: cert.message,
+ *   brandLogo: `data:image/png;base64,${cert.brand_logo_64}`,
+ *   signature: cert.instructor_signature_64
+ *     ? `data:image/png;base64,${cert.instructor_signature_64}`
+ *     : null
+ * })
  *
- * NOTE: needs error handling for the response from http client
- * (Alexandre: I'm doing it in a different branch/PR: https://github.com/railroadmedia/musora-content-services/pull/349)
- * NOTE: This function still expects brand because FE passes the argument. It is ignored for now
+ * @example Display certificate preview (Web)
+ * const cert = await fetchCertificate(awardId)
+ * return (
+ *   <CertificatePreview
+ *     userName={cert.user_name}
+ *     awardTitle={cert.title}
+ *     message={cert.message}
+ *     awardImage={`data:image/png;base64,${cert.award_image_64}`}
+ *     instructorName={cert.instructor_name}
+ *     signature={cert.instructor_signature_64}
+ *   />
+ * )
  *
- * @param {number} userAwardId - The user award progress id
- * @returns {Promise<Certificate>} - The certificate data for the completed user award.
- * @throws {HttpError} - If the HTTP request fails.
+ * @example React Native Implementation
+ * // This function is NOT compatible with React Native due to FileReader/Blob APIs.
+ * // For React Native, implement certificate generation using:
+ * //
+ * // 1. Use react-native-blob-util for base64 image conversion:
+ * //    import ReactNativeBlobUtil from 'react-native-blob-util'
+ * //    const base64 = await ReactNativeBlobUtil.fetch('GET', imageUrl)
+ * //      .then(res => res.base64())
+ * //
+ * // 2. Use react-native-html-to-pdf for PDF generation:
+ * //    import RNHTMLtoPDF from 'react-native-html-to-pdf'
+ * //    const pdf = await RNHTMLtoPDF.convert({
+ * //      html: certificateHtmlTemplate,
+ * //      fileName: `certificate-${awardId}`,
+ * //      directory: 'Documents',
+ * //    })
+ * //
+ * // 3. Build certificate data using getContentAwards() or getCompletedAwards()
+ * //    which ARE React Native compatible, then handle image conversion
+ * //    and PDF generation in your RN app layer.
  */
-export async function fetchCertificate(userAwardId: number): Promise<Certificate> {
-  const httpClient = new HttpClient(globalConfig.baseUrl, globalConfig.sessionConfig.token)
-  const response = await httpClient.get<Certificate>(
-    `${baseUrl}/v1/users/certificate/${userAwardId}`
-  )
-  return response
+export async function fetchCertificate(awardId: string): Promise<Certificate> {
+  const { buildCertificateData } = await import('../awards/internal/certificate-builder')
+  const { urlMapToBase64 } = await import('../awards/internal/image-utils')
+
+  const certData = await buildCertificateData(awardId)
+
+  const imageMap = {
+    ribbon_image_64: certData.ribbonImage,
+    award_image_64: certData.awardImage,
+    musora_bg_logo_64: certData.musoraBgLogo,
+    brand_logo_64: certData.brandLogo,
+    musora_logo_64: certData.musoraLogo,
+    ...(certData.instructorSignature && { instructor_signature_64: certData.instructorSignature })
+  }
+
+  const base64Images = await urlMapToBase64(imageMap)
+
+  return {
+    award_id: awardId,
+    user_name: certData.userName,
+    user_id: certData.userId,
+    completed_at: certData.completedAt,
+    message: certData.certificateMessage,
+    type: certData.awardType,
+    title: certData.awardTitle,
+    musora_logo: certData.musoraLogo,
+    musora_logo_64: base64Images.musora_logo_64,
+    musora_bg_logo: certData.musoraBgLogo,
+    musora_bg_logo_64: base64Images.musora_bg_logo_64,
+    brand_logo: certData.brandLogo,
+    brand_logo_64: base64Images.brand_logo_64,
+    ribbon_image: certData.ribbonImage,
+    ribbon_image_64: base64Images.ribbon_image_64,
+    award_image: certData.awardImage,
+    award_image_64: base64Images.award_image_64,
+    instructor_name: certData.instructorName,
+    instructor_signature: certData.instructorSignature,
+    instructor_signature_64: base64Images.instructor_signature_64
+  }
 }

package/src/services/progress-events.js

@@ -0,0 +1,58 @@
+/**
+ * @module ProgressEvents
+ */
+
+/**
+ * @typedef {Object} ProgressSavedEvent
+ * @property {number} userId - User ID
+ * @property {number} contentId - Railcontent ID of the content item
+ * @property {number} progressPercent - Completion percentage (0-100)
+ * @property {string} progressStatus - Progress state (started, completed)
+ * @property {boolean} bubble - Whether to bubble the event up to parent content
+ * @property {string|null} collectionType - Collection type (learning-path, guided-course, etc.)
+ * @property {number|null} collectionId - Collection ID if within a collection context
+ * @property {number|null} resumeTimeSeconds - Resume position in seconds for video content
+ * @property {number} timestamp - Unix timestamp when the event occurred
+ */
+
+/**
+ * @callback ProgressSavedListener
+ * @param {ProgressSavedEvent} event - The progress event data
+ * @returns {void}
+ */
+
+const listeners = new Set()
+
+/**
+ * @param {ProgressSavedListener} listener - Function called when progress is saved
+ * @returns {function(): void} Cleanup function to unregister the listener
+ *
+ * @example Listen for progress updates
+ * const cleanup = onProgressSaved((event) => {
+ *   console.log(`Content ${event.contentId}: ${event.progressPercent}%`)
+ *   if (event.state === 'completed') {
+ *     showCompletionAnimation()
+ *   }
+ * })
+ *
+ * // Later, when no longer needed:
+ * cleanup()
+ */
+export function onProgressSaved(listener) {
+  listeners.add(listener)
+  return () => listeners.delete(listener)
+}
+
+/**
+ * @param {ProgressSavedEvent} event - The progress event to emit
+ * @returns {void}
+ */
+export function emitProgressSaved(event) {
+  listeners.forEach(listener => {
+    try {
+      listener(event)
+    } catch (error) {
+      console.error('Error in progressSaved listener:', error)
+    }
+  })
+}

package/src/services/progress-row/method-card.js

@@ -10,6 +10,11 @@ import { COLLECTION_TYPE } from '../sync/models/ContentProgress'
 
 export async function getMethodCard(brand) {
   const introVideo = await fetchMethodV2IntroVideo(brand)
+
+  if (!introVideo) {
+    return null
+  }
+
   const introVideoProgressState = await getProgressState(introVideo?.id)
 
   const activeLearningPath = await getActivePath(brand)
@@ -48,9 +53,11 @@ export async function getMethodCard(brand) {
     const allCompleted = learningPath?.todays_lessons.every(
       (lesson) => lesson.progressStatus === 'completed'
     )
+
     const anyCompleted = learningPath?.todays_lessons.some(
       (lesson) => lesson.progressStatus === 'completed'
     )
+
     const noneCompleted = learningPath?.todays_lessons.every(
       (lesson) => lesson.progressStatus !== 'completed'
     )
@@ -58,6 +65,13 @@ export async function getMethodCard(brand) {
     const nextIncompleteLesson = learningPath?.todays_lessons.find(
       (lesson) => lesson.progressStatus !== 'completed'
     )
+
+    // get the first incomplete lesson from upcoming and next learning path lessons
+    const nextLesson = [
+      ...learningPath?.upcoming_lessons,
+      ...learningPath?.next_learning_path_lessons,
+    ]?.find((lesson) => lesson.progressStatus !== 'completed')
+
     let ctaText, action
     if (noneCompleted) {
       ctaText = 'Start Session'
@@ -66,18 +80,19 @@ export async function getMethodCard(brand) {
       ctaText = 'Continue Session'
       action = getMethodActionCTA(nextIncompleteLesson)
     } else if (allCompleted) {
-      ctaText = learningPath.next_lesson ? 'Start Next Lesson' : 'Browse Lessons'
-      action = learningPath.next_lesson
-        ? getMethodActionCTA(learningPath.next_lesson)
+      ctaText = nextLesson ? 'Start Next Lesson' : 'Browse Lessons'
+      action = nextLesson
+        ? getMethodActionCTA(nextLesson)
         : {
-            type: 'lessons',
-            brand: brand,
+            type: 'method',
+            brand,
           }
     }
 
     let maxProgressTimestamp = Math.max(
       ...learningPath?.children.map((lesson) => lesson.progressTimestamp)
     )
+
     if (!maxProgressTimestamp) {
       maxProgressTimestamp = learningPath.active_learning_path_created_at
     }

package/src/services/sanity.js

@@ -838,7 +838,7 @@ export async function fetchAllFilterOptions(
 
     return coachId
       ? `brand == '${brand}' && status == "published" && references(*[_type=='instructor' && railcontent_id == ${coachId}]._id) ${filterWithoutOption || ''} ${term ? ` && (title match "${term}" || album match "${term}" || artist->name match "${term}" || genre[]->name match "${term}")` : ''}`
-      : `_type == '${contentType}' && brand == "${brand}"${includeStatusFilter ? statusFilter : ''}${style && excludeFilter !== 'style' ? ` && '${style}' in genre[]->name` : ''}${artist && excludeFilter !== 'artist' ? ` && artist->name == '${artist}'` : ''} ${progressFilter} ${filterWithoutOption || ''} ${term ? ` && (title match "${term}" || album match "${term}" || artist->name match "${term}" || genre[]->name match "${term}")` : ''}`
+      : `_type == '${contentType}' && brand == "${brand}"${includeStatusFilter ? statusFilter : ''}${style && excludeFilter !== 'style' ? ` && '${style}' in genre[]->name` : ''}${artist && excludeFilter !== 'artist' ? ` && artist->name == "${artist}"` : ''} ${progressFilter} ${filterWithoutOption || ''} ${term ? ` && (title match "${term}" || album match "${term}" || artist->name match "${term}" || genre[]->name match "${term}")` : ''}`
   }
 
   const metaData = processMetadata(brand, contentType, true)

package/src/services/sync/fetch.ts

@@ -31,10 +31,12 @@ type SyncPushSuccessResponse = SyncResponseBase & {
 }
 type SyncPushFetchFailureResponse = SyncResponseBase & {
   ok: false,
+  failureType: 'fetch'
   isRetryable: boolean
 }
 type SyncPushFailureResponse = SyncResponseBase & {
   ok: false,
+  failureType: 'error'
   originalError: Error
 }
 
@@ -69,12 +71,14 @@ type SyncPullSuccessResponse = SyncResponseBase & {
   token: SyncToken
   previousToken: SyncToken | null
 }
-type SyncPullFailureResponse = SyncResponseBase & {
+type SyncPullFetchFailureResponse = SyncResponseBase & {
   ok: false,
+  failureType: 'fetch'
   isRetryable: boolean
 }
-type SyncPullFetchFailureResponse = SyncResponseBase & {
+type SyncPullFailureResponse = SyncResponseBase & {
   ok: false,
+  failureType: 'error'
   originalError: Error
 }
 export interface SyncResponseBase {
@@ -146,6 +150,7 @@ export function handlePull(callback: (session: BaseSessionProvider) => Request)
     } catch (e) {
       return {
         ok: false,
+        failureType: 'error',
         originalError: e as Error
       }
     }
@@ -153,6 +158,7 @@ export function handlePull(callback: (session: BaseSessionProvider) => Request)
     if (response.ok === false) {
       return {
         ok: false,
+        failureType: 'fetch',
         isRetryable: (response.status >= 500 && response.status < 504) || response.status === 429 || response.status === 408
       }
     }
@@ -192,6 +198,7 @@ export function handlePush(callback: (session: BaseSessionProvider) => Request)
     } catch (e) {
       return {
         ok: false,
+        failureType: 'error',
         originalError: e as Error
       }
     }
@@ -199,6 +206,7 @@ export function handlePush(callback: (session: BaseSessionProvider) => Request)
     if (response.ok === false) {
       return {
         ok: false,
+        failureType: 'fetch',
         isRetryable: (response.status >= 500 && response.status < 504) || response.status === 429 || response.status === 408
       }
     }

package/src/services/sync/manager.ts

@@ -12,6 +12,7 @@ import { SyncConcurrencySafetyMechanism } from './concurrency-safety'
 import { SyncTelemetry } from './telemetry/index'
 import { inBoundary } from './errors/boundary'
 import createStoresFromConfig from './store-configs'
+import { contentProgressObserver } from '../awards/internal/content-progress-observer'
 
 export default class SyncManager {
   private static counter = 0
@@ -120,11 +121,16 @@ export default class SyncManager {
       })
     })
 
+    contentProgressObserver.start(this.database).catch(error => {
+      this.telemetry.error('[SyncManager] Failed to start contentProgressObserver', error)
+    })
+
     const teardown = async () => {
       this.telemetry.debug('[SyncManager] Tearing down')
       this.runScope.abort()
       this.strategyMap.forEach(({ strategies }) => strategies.forEach(strategy => strategy.stop()))
       this.safetyMap.forEach(({ mechanisms }) => mechanisms.forEach(mechanism => mechanism()))
+      contentProgressObserver.stop()
       this.retry.stop()
       this.context.stop()
       await this.database.write(() => this.database.unsafeResetDatabase())

package/src/services/sync/models/ContentProgress.ts

@@ -2,7 +2,6 @@ import BaseModel from './Base'
 import { SYNC_TABLES } from '../schema'
 
 export enum COLLECTION_TYPE {
-  SKILL_PACK = 'skill-pack',
   LEARNING_PATH = 'learning-path-v2',
   PLAYLIST = 'playlist',
 }
@@ -18,7 +17,7 @@ export default class ContentProgress extends BaseModel<{
   collection_id: number | null
   state: STATE
   progress_percent: number
-  resume_time_seconds: number
+  resume_time_seconds: number | null
 }> {
   static table = SYNC_TABLES.CONTENT_PROGRESS
 
@@ -41,7 +40,7 @@ export default class ContentProgress extends BaseModel<{
     return (this._getRaw('collection_id') as number) || null
   }
   get resume_time_seconds() {
-    return this._getRaw('resume_time_seconds') as number
+    return (this._getRaw('resume_time_seconds') as number) || null
   }
 
   set content_id(value: number) {
@@ -54,7 +53,7 @@ export default class ContentProgress extends BaseModel<{
     this._setRaw('state', value)
   }
   set progress_percent(value: number) {
-    this._setRaw('progress_percent', value)
+    this._setRaw('progress_percent', Math.min(100, Math.max(0, value)))
   }
   set collection_type(value: COLLECTION_TYPE | null) {
     this._setRaw('collection_type', value)
@@ -62,8 +61,8 @@ export default class ContentProgress extends BaseModel<{
   set collection_id(value: number | null) {
     this._setRaw('collection_id', value)
   }
-  set resume_time_seconds(value: number) {
-    this._setRaw('resume_time_seconds', value)
+  set resume_time_seconds(value: number | null) {
+    this._setRaw('resume_time_seconds', value !== null ? Math.max(0, value) : null)
   }
 
 }

package/src/services/sync/models/UserAwardProgress.ts

@@ -0,0 +1,55 @@
+import BaseModel from './Base'
+import { SYNC_TABLES } from '../schema'
+import type { CompletionData } from '../../awards/types'
+
+export default class UserAwardProgress extends BaseModel<{
+  award_id: string
+  progress_percentage: number
+  completed_at: number | null
+  progress_data: string | null
+  completion_data: string | null
+}> {
+  static table = SYNC_TABLES.USER_AWARD_PROGRESS
+
+  get award_id() {
+    return this._getRaw('award_id') as string
+  }
+
+  get progress_percentage() {
+    return this._getRaw('progress_percentage') as number
+  }
+
+  get completed_at() {
+    return this._getRaw('completed_at') as number | null
+  }
+
+  get progress_data() {
+    const raw = this._getRaw('progress_data') as string | null
+    return raw ? JSON.parse(raw) : null
+  }
+
+  get completion_data(): CompletionData | null {
+    const raw = this._getRaw('completion_data') as string | null
+    return raw ? JSON.parse(raw) : null
+  }
+
+  set award_id(value: string) {
+    this._setRaw('award_id', value)
+  }
+
+  set progress_percentage(value: number) {
+    this._setRaw('progress_percentage', value)
+  }
+
+  set completed_at(value: number | null) {
+    this._setRaw('completed_at', value)
+  }
+
+  set progress_data(value: any) {
+    this._setRaw('progress_data', value ? JSON.stringify(value) : null)
+  }
+
+  set completion_data(value: CompletionData | null) {
+    this._setRaw('completion_data', value ? JSON.stringify(value) : null)
+  }
+}

package/src/services/sync/models/index.ts

@@ -1,4 +1,5 @@
 export { default as ContentLike } from './ContentLike'
 export { default as ContentProgress } from './ContentProgress'
 export { default as Practice } from './Practice'
+export { default as UserAwardProgress } from './UserAwardProgress'
 export { default as PracticeDayNote } from './PracticeDayNote'

package/src/services/sync/repositories/content-progress.ts

@@ -4,25 +4,31 @@ import ContentProgress, { COLLECTION_TYPE, STATE } from '../models/ContentProgre
 export default class ProgressRepository extends SyncRepository<ContentProgress> {
   // null collection only
   async startedIds(limit?: number) {
-    return this.queryAll(
+    return this.queryAllIds(...[
       Q.where('collection_type', null),
       Q.where('collection_id', null),
 
       Q.where('state', STATE.STARTED),
       Q.sortBy('updated_at', 'desc'),
-      Q.take(limit || Infinity)
-    )
+
+      ...(limit ? [Q.take(limit)] : []),
+    ])
   }
 
   // null collection only
   async completedIds(limit?: number) {
-    return this.queryAllIds(
+    return this.queryAllIds(...[
+      Q.where('collection_type', null),
+      Q.where('collection_id', null),
+
       Q.where('state', STATE.COMPLETED),
       Q.sortBy('updated_at', 'desc'),
-      Q.take(limit || Infinity)
-    )
+
+      ...(limit ? [Q.take(limit)] : []),
+    ])
   }
 
+  //this _specifically_ needs to get content_ids from ALL collection_types (including null)
   async completedByContentIds(contentIds: number[]) {
     return this.queryAll(
       Q.where('content_id', Q.oneOf(contentIds)),
@@ -85,15 +91,11 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     contentId: number,
     { collection }: { collection?: { type: COLLECTION_TYPE; id: number } | null } = {}
   ) {
-    const clauses = [Q.where('content_id', contentId)]
-    if (typeof collection != 'undefined') {
-      clauses.push(
-        ...[
-          Q.where('collection_type', collection?.type ?? null),
-          Q.where('collection_id', collection?.id ?? null),
-        ]
-      )
-    }
+    const clauses = [
+      Q.where('content_id', contentId),
+      Q.where('collection_type', collection?.type ?? null),
+      Q.where('collection_id', collection?.id ?? null),
+    ]
 
     return await this.queryOne(...clauses)
   }
@@ -102,15 +104,11 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     contentIds: number[],
     collection: { type: COLLECTION_TYPE; id: number } | null = null
   ) {
-    const clauses = [Q.where('content_id', Q.oneOf(contentIds))]
-    if (typeof collection != 'undefined') {
-      clauses.push(
-        ...[
-          Q.where('collection_type', collection?.type ?? null),
-          Q.where('collection_id', collection?.id ?? null),
-        ]
-      )
-    }
+    const clauses = [
+      Q.where('content_id', Q.oneOf(contentIds)),
+      Q.where('collection_type', collection?.type ?? null),
+      Q.where('collection_id', collection?.id ?? null),
+    ]
 
     return await this.queryAll(...clauses)
   }
@@ -118,7 +116,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
   recordProgress(contentId: number, collection: { type: COLLECTION_TYPE; id: number } | null, progressPct: number, resumeTime?: number) {
     const id = ProgressRepository.generateId(contentId, collection)
 
-    return this.upsertOne(id, (r) => {
+    const result = this.upsertOne(id, (r) => {
       r.content_id = contentId
       r.collection_type = collection?.type ?? null
       r.collection_id = collection?.id ?? null
@@ -130,6 +128,30 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
         r.resume_time_seconds = Math.floor(resumeTime)
       }
     })
+
+    // Emit event AFTER database write completes
+    result.then(() => {
+      return Promise.all([
+        import('../../progress-events'),
+        import('../../config')
+      ])
+    }).then(([progressEventsModule, { globalConfig }]) => {
+      progressEventsModule.emitProgressSaved({
+        userId: Number(globalConfig.railcontentConfig?.userId) || 0,
+        contentId,
+        progressPercent: progressPct,
+        progressStatus: progressPct === 100 ? STATE.COMPLETED : STATE.STARTED,
+        bubble: true,
+        collectionType: collection?.type ?? null,
+        collectionId: collection?.id ?? null,
+        resumeTimeSeconds: resumeTime ?? null,
+        timestamp: Date.now()
+      })
+    }).catch(error => {
+      console.error('Failed to emit progress saved event:', error)
+    })
+
+    return result
   }
 
   recordProgresses(