musora-content-services 2.112.1 → 2.113.0

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(rg:*)",
+      "Bash(npm run lint:*)"
+    ],
+    "deny": []
+  }
+}

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.113.0](https://github.com/railroadmedia/musora-content-services/compare/v2.112.2...v2.113.0) (2026-01-08)
+
+
+### Features
+
+* **BEH-1491:** proper card ordering (and hiding) on progress row ([#686](https://github.com/railroadmedia/musora-content-services/issues/686)) ([e519c35](https://github.com/railroadmedia/musora-content-services/commit/e519c352ac5e8d09a910b89fa03baf31490da102))
+
+### [2.112.2](https://github.com/railroadmedia/musora-content-services/compare/v2.112.1...v2.112.2) (2026-01-08)
+
+
+### Bug Fixes
+
+* changes lesson type mapping ([#690](https://github.com/railroadmedia/musora-content-services/issues/690)) ([af4dda9](https://github.com/railroadmedia/musora-content-services/commit/af4dda9e03eecfd49a341d2c1aea8afcf217e233))
+* **T3PS-1187:** award progress optimizations ([#689](https://github.com/railroadmedia/musora-content-services/issues/689)) ([5d063b8](https://github.com/railroadmedia/musora-content-services/commit/5d063b8227e9ee5c70c30bc31263296bfcb4aa63))
+
 ### [2.112.1](https://github.com/railroadmedia/musora-content-services/compare/v2.112.0...v2.112.1) (2026-01-07)
 
 ## [2.112.0](https://github.com/railroadmedia/musora-content-services/compare/v2.111.5...v2.112.0) (2026-01-07)

package/README.md

@@ -54,12 +54,43 @@ the `excludeFromGeneratedIndex` array inside the service file.
 
 ## Publishing Package Updates
 
-To publish a new version to NPM run, 
+To publish a new version to NPM run,
 
 ```bash
 ./publish.sh
 ```
 
+## NPM reauthentication
+
+If you see this error displayed when publishing, you need to reauthenticate:
+
+```bash
+npm notice Publishing to https://registry.npmjs.org/ with tag latest and default access
+npm notice Access token expired or revoked. Please try logging in again.
+npm ERR! code E404
+npm ERR! 404 Not Found - PUT https://registry.npmjs.org/musora-content-services - Not found
+npm ERR! 404
+npm ERR! 404  'musora-content-services@2.99.6' is not in this registry.
+npm ERR! 404
+npm ERR! 404 Note that you can also install from a
+npm ERR! 404 tarball, folder, http url, or git url.
+```
+
+Use the shared musora_dev account in 1password ("NPM Access Token For musora_dev") 
+and update this value as `npmAccessToken` in the railenvironment credentials file.
+
+Alternatively, request your own account or renew your own token.
+Update railenvironment credentials file with your new account details
+
+```bash
+npmUserName=
+npmPassword=
+npmAccessToken=
+```
+
+Either restart the manager container (`docker restart railenvironmentdocker_manager`) 
+or run `./usr/local/bin/setup-npm.sh` inside the container to update the `~/.npmrc` file.
+
 ## Symlinking 
 
 To link this package to the MWP repo for local development run,  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "2.112.1",
+  "version": "2.113.0",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",

package/src/index.d.ts

@@ -9,6 +9,7 @@ import {
 	getAwardStatistics,
 	getCompletedAwards,
 	getContentAwards,
+	getContentAwardsByIds,
 	getInProgressAwards,
 	resetAllAwards
 } from './services/awards/award-query.js';
@@ -265,6 +266,7 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
+	fetchContentTypeCounts,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -495,6 +497,7 @@ declare module 'musora-content-services' {
 		fetchCommunityGuidelines,
 		fetchContentPageUserData,
 		fetchContentRows,
+		fetchContentTypeCounts,
 		fetchCustomerPayments,
 		fetchEnrollmentPageMetadata,
 		fetchFollowedThreads,
@@ -582,6 +585,7 @@ declare module 'musora-content-services' {
 		getAwardStatistics,
 		getCompletedAwards,
 		getContentAwards,
+		getContentAwardsByIds,
 		getContentRows,
 		getDailySession,
 		getEnrichedLearningPath,

package/src/index.js

@@ -13,6 +13,7 @@ import {
 	getAwardStatistics,
 	getCompletedAwards,
 	getContentAwards,
+	getContentAwardsByIds,
 	getInProgressAwards,
 	resetAllAwards
 } from './services/awards/award-query.js';
@@ -269,6 +270,7 @@ import {
 	fetchComingSoon,
 	fetchCommentModContentData,
 	fetchContentRows,
+	fetchContentTypeCounts,
 	fetchHierarchy,
 	fetchLearningPathHierarchy,
 	fetchLeaving,
@@ -494,6 +496,7 @@ export {
 	fetchCommunityGuidelines,
 	fetchContentPageUserData,
 	fetchContentRows,
+	fetchContentTypeCounts,
 	fetchCustomerPayments,
 	fetchEnrollmentPageMetadata,
 	fetchFollowedThreads,
@@ -581,6 +584,7 @@ export {
 	getAwardStatistics,
 	getCompletedAwards,
 	getContentAwards,
+	getContentAwardsByIds,
 	getContentRows,
 	getDailySession,
 	getEnrichedLearningPath,

package/src/services/awards/award-query.js

@@ -6,6 +6,7 @@
  *
  * **Query Functions** (read-only):
  * - `getContentAwards(contentId)` - Get awards for a learning path/course
+ * - `getContentAwardsByIds(contentIds)` - Get awards for multiple content items (batch optimized)
  * - `getCompletedAwards(brand)` - Get user's earned awards
  * - `getInProgressAwards(brand)` - Get awards user is working toward
  * - `getAwardStatistics(brand)` - Get aggregate award stats
@@ -121,30 +122,17 @@ export async function getContentAwards(contentId) {
       }
     }
 
-    const { definitions, progress } = await db.userAwardProgress.getAwardsForContent(contentId)
+    const data = await db.userAwardProgress.getAwardsForContent(contentId)
 
-    const awards = definitions.map(def => {
-      const userProgress = progress.get(def._id)
-      const completionData = enhanceCompletionData(userProgress?.completion_data)
-
-      return {
-        awardId: def._id,
-        awardTitle: def.name,
-        badge: def.badge,
-        award: def.award,
-        brand: def.brand,
-        instructorName: def.instructor_name,
-        progressPercentage: userProgress?.progress_percentage ?? 0,
-        isCompleted: userProgress ? UserAwardProgressRepository.isCompleted(userProgress) : false,
-        completedAt: userProgress?.completed_at,
-        completionData
-      }
-    })
+    const awards = data && data.definitions.length !== 0
+      ? defineAwards(data)
+      : []
 
     return {
-      hasAwards: true,
-      awards
+      hasAwards: awards.length > 0,
+      awards,
     }
+
   } catch (error) {
     console.error(`Failed to get award status for content ${contentId}:`, error)
     return {
@@ -154,6 +142,98 @@ export async function getContentAwards(contentId) {
   }
 }
 
+/**
+ * @param {number[]} contentIds - Array of Railcontent IDs to fetch awards for
+ * @returns {Promise<Object.<number, ContentAwardsResponse>>} Object mapping content IDs to their award data
+ *
+ * @description
+ * Returns awards for multiple content items at once. More efficient than calling
+ * `getContentAwards()` multiple times. Returns an object where keys are content IDs
+ * and values are the same structure as `getContentAwards()`.
+ *
+ * Content IDs without awards will have `{ hasAwards: false, awards: [] }` in the result.
+ *
+ * Returns empty object `{}` on error (never throws).
+ *
+ * @example
+ * const learningPathIds = [12345, 67890, 11111]
+ * const awardsMap = await getContentAwardsByIds(learningPathIds)
+ *
+ * learningPathIds.forEach(id => {
+ *   const { hasAwards, awards } = awardsMap[id] || { hasAwards: false, awards: [] }
+ *   if (hasAwards) {
+ *     console.log(`Learning path ${id} has ${awards.length} award(s)`)
+ *   }
+ * })
+ *
+ * @example
+ * function CourseListWithAwards({ courseIds }) {
+ *   const [awardsMap, setAwardsMap] = useState({})
+ *
+ *   useEffect(() => {
+ *     getContentAwardsByIds(courseIds).then(setAwardsMap)
+ *   }, [courseIds])
+ *
+ *   return courseIds.map(courseId => {
+ *     const { hasAwards, awards } = awardsMap[courseId] || { hasAwards: false, awards: [] }
+ *     return (
+ *       <CourseCard key={courseId} courseId={courseId}>
+ *         {hasAwards && <AwardBadge award={awards[0]} />}
+ *       </CourseCard>
+ *     )
+ *   })
+ * }
+ */
+export async function getContentAwardsByIds(contentIds) {
+  try {
+    if (!Array.isArray(contentIds) || contentIds.length === 0) {
+      return {}
+    }
+
+    const awardsDataMap = await db.userAwardProgress.getAwardsForContentMany(contentIds)
+
+    const result = {}
+
+    contentIds.forEach(contentId => {
+      const data = awardsDataMap.get(contentId) // {definitions, progress}
+
+      const awards = data && data.definitions.length !== 0
+        ? defineAwards(data)
+        : []
+
+      result[contentId] = {
+        hasAwards: awards.length > 0,
+        awards,
+      }
+    })
+
+    return result
+  } catch (error) {
+    console.error(`Failed to get award status for content IDs ${contentIds}:`, error)
+    return {}
+  }
+}
+
+function defineAwards(data) {
+  return data.definitions.map(def => {
+    const userProgress = data.progress.get(def._id)
+    const completionData = enhanceCompletionData(userProgress?.completion_data)
+
+    return {
+      awardId: def._id,
+      awardTitle: def.name,
+      badge: def.badge,
+      award: def.award,
+      brand: def.brand,
+      instructorName: def.instructor_name,
+      progressPercentage: userProgress?.progress_percentage ?? 0,
+      isCompleted: userProgress ? UserAwardProgressRepository.isCompleted(userProgress) : false,
+      completedAt: userProgress?.completed_at,
+      completionData
+    }
+  })
+}
+
 /**
  * @param {string} [brand=null] - Brand to filter by (drumeo, pianote, guitareo, singeo), or null for all brands
  * @param {AwardPaginationOptions} [options={}] - Optional pagination and filtering

package/src/services/awards/internal/award-definitions.js

@@ -60,6 +60,23 @@ class AwardDefinitionsService {
       .filter(Boolean)
   }
 
+  /** @returns {Promise<Map<number, import('./types').AwardDefinition[]>>} */
+  async getByContentIds(contentIds) {
+    if (this.shouldRefresh()) {
+      await this.fetchFromSanity()
+    }
+
+    return new Map(
+      contentIds.map(contentId => {
+        const awardIds = this.contentIndex.get(contentId) || []
+        const definitions = awardIds
+          .map(id => this.definitions.get(id))
+          .filter(Boolean)
+        return [contentId, definitions]
+      })
+    )
+  }
+
   /** @returns {Promise<boolean>} */
   async hasAwards(contentId) {
     if (this.shouldRefresh()) {

package/src/services/content-org/learning-paths.ts

@@ -20,6 +20,7 @@ import { getToday } from "../dateUtils.js";
 
 const BASE_PATH: string = `/api/content-org`
 const LEARNING_PATHS_PATH = `${BASE_PATH}/v1/user/learning-paths`
+const LEARNING_PATH_LESSON = 'learning-path-lesson-v2'
 
 interface ActiveLearningPathResponse {
   user_id: number
@@ -119,7 +120,7 @@ export async function resetAllLearningPaths() {
  * @returns {Promise<Object>} Learning path with enriched lesson data
  */
 export async function getEnrichedLearningPath(learningPathId) {
-  const response = (await addContextToLearningPaths(
+  let response = (await addContextToLearningPaths(
     fetchByRailContentId,
     learningPathId,
     COLLECTION_TYPE.LEARNING_PATH,
@@ -134,11 +135,13 @@ export async function getEnrichedLearningPath(learningPathId) {
       addNavigateTo: true,
     }
   )) as any
+  // add awards to LP parents only
+  response = await addContextToLearningPaths(() => response, {addAwards:true})
   if (!response) return response
 
   response.children = mapContentToParent(
     response.children,
-    COLLECTION_TYPE.LEARNING_PATH,
+    LEARNING_PATH_LESSON,
     learningPathId
   )
   return response
@@ -150,7 +153,7 @@ export async function getEnrichedLearningPath(learningPathId) {
  * @returns {Promise<Object>} Learning paths with enriched lesson data
  */
 export async function getEnrichedLearningPaths(learningPathIds: number[]) {
-  const response = (await addContextToLearningPaths(
+  let response = (await addContextToLearningPaths(
     fetchByRailContentIds,
     learningPathIds,
     COLLECTION_TYPE.LEARNING_PATH,
@@ -165,12 +168,15 @@ export async function getEnrichedLearningPaths(learningPathIds: number[]) {
       addNavigateTo: true,
     }
   )) as any
+  // add awards to LP parents only
+  response = await addContextToLearningPaths(() => response, {addAwards:true})
+
   if (!response) return response
 
   response.forEach((learningPath) => {
     learningPath.children = mapContentToParent(
       learningPath.children,
-      COLLECTION_TYPE.LEARNING_PATH,
+      LEARNING_PATH_LESSON,
       learningPath.id
     )
   })
@@ -197,6 +203,7 @@ export async function getLearningPathLessonsByIds(contentIds, learningPathId) {
  * @param parentContentId
  */
 export function mapContentToParent(lessons, parentContentType, parentContentId) {
+  if (!lessons) return lessons
   return lessons.map((lesson: any) => {
     return { ...lesson, type: parentContentType, parent_id: parentContentId }
   })

package/src/services/contentAggregator.js

@@ -10,6 +10,7 @@ import {
 import { isContentLikedByIds } from './contentLikes'
 import { fetchLikeCount } from './railcontent'
 import {COLLECTION_TYPE} from "./sync/models/ContentProgress";
+import {getContentAwardsByIds} from "./awards/award-query.js";
 
 /**
  * Combine sanity data with BE contextual data.
@@ -73,6 +74,7 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     addProgressTimestamp = false,
     addResumeTimeSeconds = false,
     addNavigateTo = false,
+    addAwards = false,
   } = options
 
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
@@ -91,12 +93,14 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     isLikedData,
     resumeTimeData,
     navigateToData,
+    awards,
   ] = await Promise.all([ //for now assume these all return `collection = {type, id}`. it will be so when watermelon here
     addProgressPercentage || addProgressStatus || addProgressTimestamp
       ? getProgressDataByIds(ids, collection) : Promise.resolve(null),
     addIsLiked ? isContentLikedByIds(ids, collection) : Promise.resolve(null),
     addResumeTimeSeconds ? getResumeTimeSecondsByIds(ids, collection) : Promise.resolve(null),
     addNavigateTo ? getNavigateTo(items, collection) : Promise.resolve(null),
+    addAwards ? getContentAwardsByIds(ids) : Promise.resolve(null),
   ])
 
   const addContext = async (item) => ({
@@ -108,6 +112,7 @@ export async function addContextToContent(dataPromise, ...dataArgs) {
     ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(item.id) } : {}),
     ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[item.id] } : {}),
     ...(addNavigateTo ? { navigateTo: navigateToData?.[item.id] } : {}),
+    ...(addAwards ? { awards: awards?.[item.id].awards || [] } : {}),
   })
 
   return await processItems(data, addContext, dataField, isDataAnArray, dataField_includeParent)
@@ -163,6 +168,7 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
     addLikeCount = false,
     addResumeTimeSeconds = false,
     addNavigateTo = false,
+    addAwards = false,
   } = options
 
   const dataParam = lastArg === options ? dataArgs.slice(0, -1) : dataArgs
@@ -189,12 +195,14 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
     isLikedData,
     resumeTimeData,
     navigateToData,
+    awards,
   ] = await Promise.all([
     addProgressPercentage || addProgressStatus || addProgressTimestamp
       ? getProgressDataByIdsAndCollections(ids) : Promise.resolve(null),
     addIsLiked ? isContentLikedByIds(justIds) : Promise.resolve(null),
     addResumeTimeSeconds ? getResumeTimeSecondsByIdsAndCollections(ids) : Promise.resolve(null),
     addNavigateTo ? getNavigateToForMethod(items) : Promise.resolve(null),
+    addAwards ? getContentAwardsByIds(justIds) : Promise.resolve(null),
   ])
 
   const addContext = async (item) => {
@@ -208,6 +216,7 @@ export async function addContextToLearningPaths(dataPromise, ...dataArgs) {
       ...(addLikeCount && ids.length === 1 ? { likeCount: await fetchLikeCount(itemId) } : {}),
       ...(addResumeTimeSeconds ? { resumeTime: resumeTimeData?.[itemId] } : {}),
       ...(addNavigateTo ? { navigateTo: navigateToData?.[itemId] } : {}),
+      ...(addAwards ? { awards: awards?.[itemId].awards || [] } : {}),
     }
 
     // Enrich intro_video if it exists and flag is set

package/src/services/contentProgress.js

@@ -467,7 +467,7 @@ export async function contentStatusReset(contentId, collection = null, {skipPush
   return resetStatus(contentId, collection, {skipPush})
 }
 
-async function saveContentProgress(contentId, collection, progress, currentSeconds, {skipPush = false, hideFromProgressRow = false} = {}) {
+async function saveContentProgress(contentId, collection, progress, currentSeconds, {skipPush = false, fromLearningPath = false} = {}) {
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
 
   // filter out contentIds that are setting progress lower than existing
@@ -482,12 +482,14 @@ async function saveContentProgress(contentId, collection, progress, currentSecon
     collection,
     progress,
     currentSeconds,
-    {skipPush: true, hideFromProgressRow}
+    {skipPush: true, fromLearningPath}
   )
   // note - previous implementation explicitly did not trickle progress to children here
   // (only to siblings/parents via le bubbles)
 
+  // skip bubbling if progress hasnt changed
   if (progress === currentProgress) {
+    if (!skipPush) db.contentProgress.requestPushUnsynced()
     return
   }
 
@@ -561,45 +563,6 @@ async function setStartedOrCompletedStatus(contentId, collection, isCompleted, {
   return response
 }
 
-// we cannot simply pass LP id with self collection, because we do not have a-la-carte LP's set up yet,
-//   and we need each lesson to bubble to its parent outside of LP
-async function duplicateLearningPathProgressToExternalContents(ids, collection, hierarchy, {skipPush = false} = {}) {
-  // filter out LPs. we dont want to duplicate to LP's while we dont have a-la-cart LP's set up.
-  let filteredIds = Object.fromEntries(
-    Object.entries(ids).filter(([id]) => {
-      return hierarchy.parents[parseInt(id)] !== null
-    })
-  )
-
-  const extProgresses = await getProgressDataByIds(Object.keys(filteredIds), null)
-
-  // overwrite if LP progress greater, unless LP progress was reset to 0
-  filteredIds = Object.entries(filteredIds).filter(([id, pct]) => {
-    const extPct = extProgresses[id]?.progress
-    return (pct !== 0)
-      ? pct > extPct
-      : false
-  })
-
-  // each handles its own bubbling.
-  // skipPush on all but last to avoid multiple push requests
-  filteredIds.forEach(([id, pct], index) => {
-    let skip = true
-    if (index === filteredIds.length - 1) {
-      skip = skipPush
-    }
-    saveContentProgress(parseInt(id), null, pct, null, {skipPush: skip, hideFromProgressRow: true})
-  })
-}
-
-async function getHierarchy(contentId, collection) {
-  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
-    return await fetchLearningPathHierarchy(contentId, collection)
-  } else {
-    return await fetchHierarchy(contentId)
-  }
-}
-
 async function setStartedOrCompletedStatusMany(contentIds, collection, isCompleted, {skipPush = false} = {}) {
   const isLP = collection?.type === COLLECTION_TYPE.LEARNING_PATH
   const progress = isCompleted ? 100 : 0
@@ -651,6 +614,7 @@ async function resetStatus(contentId, collection = null, {skipPush = false} = {}
 
   const progress = 0
   const response = await db.contentProgress.eraseProgress(contentId, collection, {skipPush: true})
+
   const hierarchy = await getHierarchy(contentId, collection)
 
   let progresses = {
@@ -670,6 +634,45 @@ async function resetStatus(contentId, collection = null, {skipPush = false} = {}
   return response
 }
 
+// we cannot simply pass LP id with self collection, because we do not have a-la-carte LP's set up yet,
+//   and we need each lesson to bubble to its parent outside of LP
+async function duplicateLearningPathProgressToExternalContents(ids, collection, hierarchy, {skipPush = false} = {}) {
+  // filter out LPs. we dont want to duplicate to LP's while we dont have a-la-cart LP's set up.
+  let filteredIds = Object.fromEntries(
+    Object.entries(ids).filter(([id]) => {
+      return hierarchy.parents[parseInt(id)] !== null
+    })
+  )
+
+  const extProgresses = await getProgressDataByIds(Object.keys(filteredIds), null)
+
+  // overwrite if LP progress greater, unless LP progress was reset to 0
+  filteredIds = Object.entries(filteredIds).filter(([id, pct]) => {
+    const extPct = extProgresses[id]?.progress
+    return (pct !== 0)
+      ? pct > extPct
+      : false
+  })
+
+  // each handles its own bubbling.
+  // skipPush on all but last to avoid multiple push requests
+  filteredIds.forEach(([id, pct], index) => {
+    let skip = true
+    if (index === filteredIds.length - 1) {
+      skip = skipPush
+    }
+    saveContentProgress(parseInt(id), null, pct, null, {skipPush: skip, fromLearningPath: true})
+  })
+}
+
+async function getHierarchy(contentId, collection) {
+  if (collection && collection.type === COLLECTION_TYPE.LEARNING_PATH) {
+    return await fetchLearningPathHierarchy(contentId, collection)
+  } else {
+    return await fetchHierarchy(contentId)
+  }
+}
+
 // agnostic to collection - makes returned data structure simpler,
 // as long as callers remember to pass collection where needed
 function trickleProgress(hierarchy, contentId, _collection, progress) {

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

@@ -107,7 +107,8 @@ export async function getMethodCard(brand) {
     )
 
     if (!maxProgressTimestamp) {
-      maxProgressTimestamp = learningPath.active_learning_path_created_at
+      // active LP created_at is stored in seconds, so *1000 to match rest of cards
+      maxProgressTimestamp = learningPath.active_learning_path_created_at * 1000
     }
 
     return {

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

@@ -29,6 +29,7 @@ export default class ContentProgress extends BaseModel<{
   state: STATE
   progress_percent: number
   resume_time_seconds: number | null
+  last_interacted_a_la_carte: number | null
 }> {
   static table = SYNC_TABLES.CONTENT_PROGRESS
 
@@ -53,8 +54,8 @@ export default class ContentProgress extends BaseModel<{
   get resume_time_seconds() {
     return (this._getRaw('resume_time_seconds') as number) || null
   }
-  get hide_from_progress_row() {
-    return this._getRaw('hide_from_progress_row') as boolean
+  get last_interacted_a_la_carte() {
+    return this._getRaw('last_interacted_a_la_carte') as number
   }
 
   set content_id(value: number) {
@@ -90,8 +91,8 @@ export default class ContentProgress extends BaseModel<{
     throwIfNotNullableNumber(value)
     this._setRaw('resume_time_seconds', value !== null ? throwIfOutsideRange(value, 0, 65535) : value)
   }
-  set hide_from_progress_row(value: boolean) {
-    this._setRaw('hide_from_progress_row', value)
+  set last_interacted_a_la_carte(value: number) {
+    this._setRaw('last_interacted_a_la_carte', value)
   }
 
 }

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

@@ -62,7 +62,7 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
       Q.where('collection_type', COLLECTION_TYPE.SELF),
       Q.where('collection_id', COLLECTION_ID_SELF),
 
-      Q.where('hide_from_progress_row', false),
+      Q.where('last_interacted_a_la_carte', Q.notEq(null)),
 
       Q.or(Q.where('state', STATE.STARTED), Q.where('state', STATE.COMPLETED)),
       Q.sortBy('updated_at', 'desc'),
@@ -135,9 +135,13 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
     }
   }
 
-  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number, {skipPush = false, hideFromProgressRow = false} = {}) {
+  recordProgress(contentId: number, collection: CollectionParameter | null, progressPct: number, resumeTime?: number, {skipPush = false, fromLearningPath = false} = {}) {
     const id = ProgressRepository.generateId(contentId, collection)
 
+    if (collection?.type === COLLECTION_TYPE.LEARNING_PATH) {
+      fromLearningPath = true
+    }
+
     const result = this.upsertOne(id, (r) => {
       r.content_id = contentId
       r.collection_type = collection?.type ?? COLLECTION_TYPE.SELF
@@ -149,7 +153,10 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
         r.resume_time_seconds = Math.floor(resumeTime)
       }
 
-      r.hide_from_progress_row = hideFromProgressRow
+      if (!fromLearningPath) {
+        r.last_interacted_a_la_carte = Date.now()
+      }
+
     }, { skipPush })
 
     // Emit event AFTER database write completes
@@ -180,8 +187,11 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
   recordProgressMany(
     contentProgresses: Record<string, number>, // Accept plain object
     collection: CollectionParameter | null,
-    { tentative = true, skipPush = false, hideFromProgressRow = false }: { tentative?: boolean; skipPush?: boolean; hideFromProgressRow?: boolean } = {}
+    { tentative = true, skipPush = false, fromLearningPath = false }: { tentative?: boolean; skipPush?: boolean; fromLearningPath?: boolean } = {}
   ) {
+    if (collection?.type === COLLECTION_TYPE.LEARNING_PATH) {
+      fromLearningPath = true
+    }
 
     const data = Object.fromEntries(
       Object.entries(contentProgresses).map(([contentId, progressPct]) => [
@@ -193,7 +203,9 @@ export default class ProgressRepository extends SyncRepository<ContentProgress>
 
           r.progress_percent = progressPct
 
-          r.hide_from_progress_row = hideFromProgressRow
+          if (!fromLearningPath) {
+            r.last_interacted_a_la_carte = Date.now()
+          }
         },
       ])
     )

package/src/services/sync/repositories/user-award-progress.ts

@@ -63,6 +63,13 @@ export default class UserAwardProgressRepository extends SyncRepository<UserAwar
     return this.readOne(awardId)
   }
 
+  async getByAwardIds(awardIds: string[]) {
+    if (awardIds.length === 0) {
+      return { data: [] }
+    }
+    return this.readSome(awardIds)
+  }
+
   async hasCompletedAward(awardId: string): Promise<boolean> {
     const result = await this.readOne(awardId)
     if (!result.data) return false
@@ -121,16 +128,58 @@ export default class UserAwardProgressRepository extends SyncRepository<UserAwar
     const awardIds = definitions.map(d => d._id)
     const progressMap = new Map<string, ModelSerialized<UserAwardProgress>>()
 
-    for (const awardId of awardIds) {
-      const result = await this.getByAwardId(awardId)
-      if (result.data) {
-        progressMap.set(awardId, result.data)
-      }
+    const progressResults = await this.getByAwardIds(awardIds)
+    for (const progress of progressResults.data) {
+      progressMap.set(progress.award_id, progress)
     }
 
     return { definitions, progress: progressMap }
   }
 
+  async getAwardsForContentMany(contentIds: number[]): Promise<Map<number, {
+    definitions: AwardDefinition[]
+    progress: Map<string, ModelSerialized<UserAwardProgress>>
+  }>> {
+    const { awardDefinitions } = await import('../../awards/internal/award-definitions')
+
+    const contentToDefinitionsMap = await awardDefinitions.getByContentIds(contentIds)
+
+    const allAwardIds = new Set<string>()
+    contentToDefinitionsMap.forEach(definitions => {
+      definitions.forEach(d => allAwardIds.add(d._id))
+    })
+
+    const progressResults = await this.getByAwardIds(Array.from(allAwardIds))
+    const globalProgressMap = new Map<string, ModelSerialized<UserAwardProgress>>()
+    for (const progress of progressResults.data) {
+      globalProgressMap.set(progress.award_id, progress)
+    }
+
+    const resultMap = new Map<number, {
+      definitions: AwardDefinition[]
+      progress: Map<string, ModelSerialized<UserAwardProgress>>
+    }>()
+
+    contentIds.forEach(contentId => {
+      const definitions = contentToDefinitionsMap.get(contentId) || []
+      const contentProgressMap = new Map<string, ModelSerialized<UserAwardProgress>>()
+
+      definitions.forEach(def => {
+        const progress = globalProgressMap.get(def._id)
+        if (progress) {
+          contentProgressMap.set(def._id, progress)
+        }
+      })
+
+      resultMap.set(contentId, {
+        definitions,
+        progress: contentProgressMap
+      })
+    })
+
+    return resultMap
+  }
+
   async deleteAllAwards() {
     const allProgress = await this.getAll()
     const ids = allProgress.data.map(p => p.id)

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

@@ -26,7 +26,7 @@ const contentProgressTable = tableSchema({
     { name: 'state', type: 'string', isIndexed: true },
     { name: 'progress_percent', type: 'number' },
     { name: 'resume_time_seconds', type: 'number', isOptional: true },
-    { name: 'hide_from_progress_row', type: 'boolean'},
+    { name: 'last_interacted_a_la_carte', type: 'number', isOptional: true },
     { name: 'created_at', type: 'number' },
     { name: 'updated_at', type: 'number', isIndexed: true }
   ]