musora-content-services 2.162.0 → 2.163.0

package/.agent/decisions/2026-05-19-content-progress-ts-part-2.md

@@ -0,0 +1,53 @@
+---
+date: 2026-05-19
+branch: refactor/content-progress-ts-part-2
+pr: https://github.com/railroadmedia/musora-content-services/pull/978
+status: open
+tags: [[chore]]
+---
+
+# Split progress module into typed sub-modules with Progress namespace
+
+## Context
+
+`src/services/progress/index.ts` started as a flat file during the initial migration of `contentProgress.js` to TypeScript. As the migration continued it became clear the file would grow significantly, mixing query helpers, read operations, collection queries, and shared types. Naming also conflicted with the legacy JS exports still living in `contentProgress.js` during the transition.
+
+## Decision
+
+Split `progress/index.ts` into focused sub-modules:
+
+- `state.ts` — point queries for progress state, playback position, last interacted
+- `collections.ts` — bulk queries (allStarted, allCompleted, allStartedOrCompleted)
+- `types.ts` — shared interfaces (GetAllQueryOptions, QueryMetadata, StartedOrCompletedOptions)
+- `internal/queries.ts` — private DB helpers (getById, getByIds, getByRecordIds)
+
+`index.ts` becomes a 5-line file that spreads both modules into a `Progress` namespace object:
+
+```ts
+export const Progress = { ...state, ...collections }
+```
+
+**Naming convention: nouns for reads, verbs for writes.**
+Query functions drop their `get`/`find`/`getAll` prefixes since the namespace provides context (`Progress.state`, `Progress.allStarted`). Write operations not yet migrated will keep verb names when they land (`Progress.recordWatchSession`, `Progress.markCompleted`).
+
+`resumeTimeByIds` was renamed to `playbackPositionByIds` — `resumeTime` read as a verb phrase in camelCase and was semantically ambiguous.
+
+`navigate-to.ts` updated to consume `Progress.*` instead of named imports from the old flat index.
+
+## Alternatives Considered
+
+**Drop `get` prefix only (standalone names):** Rejected because `findIncompleteLesson` has a `find` prefix with semantic meaning (sync local search, not a DB fetch). Mixing bare nouns with `find*` names produces an inconsistent surface. The namespace approach sidesteps the verb question entirely.
+
+**Nested read/write namespace (`Progress.get.*` / `Progress.set.*`):** Cleaner separation on paper but adds nesting for what is currently a read-only module. The simpler convention (nouns=reads, verbs=writes in flat namespace) was chosen to avoid premature structure.
+
+## Process Notes
+
+- `getByIds` and `getById` in `internal/queries.ts` originally had `collection` as the second parameter. The user's linter moved it to last as an optional param — this required updating all call sites in `state.ts` and cascading arg-order fixes in navigate-to.ts and tests.
+- LSP diagnostics repeatedly fired false positives after the param reorder, claiming `string` was not assignable to `CollectionParameter`. `npx tsc --noEmit` was consistently the source of truth — all those diagnostics were stale cache.
+- `findIncompleteLesson` param order was changed by the linter to `(progressOnItems, contentType, currentContentId?)` — both `navigate-to.ts` and the test file required arg-order updates.
+
+## Consequences
+
+- External callers import `Progress` and call `Progress.state(id)`, `Progress.allStarted()`, etc. — no ambiguity with `contentProgress.js` exports during the remaining migration
+- Write operations remain in `contentProgress.js` until a follow-up PR migrates them into the `Progress` namespace with verb names
+- The `internal/` directory convention signals private helpers not intended for direct import outside the progress module

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.163.0](https://github.com/railroadmedia/musora-content-services/compare/v2.162.1...v2.163.0) (2026-06-04)
+
+
+### Features
+
+* add need access logic branch for LPs ([#993](https://github.com/railroadmedia/musora-content-services/issues/993)) ([1d935aa](https://github.com/railroadmedia/musora-content-services/commit/1d935aaf147b45cd01bc1d438424f5322991aa69))
+* **TP-1195:** optimize live event loading ([#971](https://github.com/railroadmedia/musora-content-services/issues/971)) ([8daa616](https://github.com/railroadmedia/musora-content-services/commit/8daa6160c5bc1ee005093719beef1dd9e83ac3c8))
+
+
+### Bug Fixes
+
+* dont set resume-time to null ([#992](https://github.com/railroadmedia/musora-content-services/issues/992)) ([d7f0f3e](https://github.com/railroadmedia/musora-content-services/commit/d7f0f3e6aab53dcb332a9c149dd0a33f95bc1d75))
+
+### [2.162.1](https://github.com/railroadmedia/musora-content-services/compare/v2.162.0...v2.162.1) (2026-06-04)
+
 ## [2.162.0](https://github.com/railroadmedia/musora-content-services/compare/v2.161.4...v2.162.0) (2026-06-03)
 
 

package/package.json

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

package/src/contentTypeConfig.js

@@ -695,7 +695,9 @@ export let contentTypeConfig = {
     }`,
   ],
   'new-and-scheduled': {
-    fields: ['show_in_new_feed', isLiveField()],
+    fields: [
+      'show_in_new_feed',
+    ],
     includeChildFields: true,
   },
 }

package/src/index.d.ts

@@ -177,7 +177,8 @@ import {
 	likePost,
 	search,
 	unlikePost,
-	updatePost
+	updatePost,
+	whoLikedPost
 } from './services/forums/posts.ts';
 
 import {
@@ -494,6 +495,11 @@ import {
 	updateUserPractice
 } from './services/userActivity.js';
 
+import {
+	whoLikedComment,
+	whoLikedContent
+} from './services/whoLiked.ts';
+
 import {
 	 default as EventsAPI 
 } from './services/eventsAPI';
@@ -847,6 +853,9 @@ declare module 'musora-content-services' {
 		userOnboardingForBrand,
 		verifyImageSRC,
 		verifyLocalDataContext,
+		whoLikedComment,
+		whoLikedContent,
+		whoLikedPost,
 	}
 }
 

package/src/index.js

@@ -181,7 +181,8 @@ import {
 	likePost,
 	search,
 	unlikePost,
-	updatePost
+	updatePost,
+	whoLikedPost
 } from './services/forums/posts.ts';
 
 import {
@@ -498,6 +499,11 @@ import {
 	updateUserPractice
 } from './services/userActivity.js';
 
+import {
+	whoLikedComment,
+	whoLikedContent
+} from './services/whoLiked.ts';
+
 export {
 	PermissionsAdapter,
 	PermissionsV1Adapter,
@@ -846,6 +852,9 @@ export {
 	userOnboardingForBrand,
 	verifyImageSRC,
 	verifyLocalDataContext,
+	whoLikedComment,
+	whoLikedContent,
+	whoLikedPost,
 };
 
 export default EventsAPI

package/src/lib/sanity/decorators/examples.ts

@@ -212,7 +212,7 @@ export async function navigateToParallelWithProgress() {
 
   const items = navigateRows as ContentWithNavAndProgress[]
   const decorators: FieldDecoratorAsync<ContentWithNavAndProgress>[] = [
-    navigateToDecorator as FieldDecoratorAsync<ContentWithNavAndProgress>,
+    navigateToDecorator() as FieldDecoratorAsync<ContentWithNavAndProgress>,
     {
       field: 'progress_percent',
       compute: (item) => fetchProgress(item.id),

package/src/lib/sanity/decorators/navigate-to.ts

@@ -1,15 +1,10 @@
 import { decorateAllAsync, type Decoratable, type FieldDecoratorAsync } from './base'
-import {
-  findIncompleteLesson,
-  getLastInteractedOf,
-  getProgressState,
-  getProgressStateByIds,
-} from '../../../services/contentProgress.js'
 import {
   COLLECTION_TYPE,
   CollectionParameter,
   STATE,
 } from '../../../services/sync/models/ContentProgress'
+import { Progress } from '@/services/progress'
 
 export const NAVIGATE_TO_FIELD = 'navigateTo' as const
 
@@ -18,7 +13,7 @@ const NAVIGABLE_TYPES = [
   'guided-course',
   'course-collection',
   'song-tutorial',
-  'learning-path-v2',
+  COLLECTION_TYPE.LEARNING_PATH,
   'skill-pack',
 ] as const
 
@@ -68,38 +63,66 @@ function buildNavigateTo(
   }
 }
 
-async function computeNavigateTo(content: NavigateToDecoratable): Promise<NavigateTo | null> {
+interface NavigateContext {
+  states: Map<number, string>
+}
+
+async function prefetchStates(items: NavigateToDecoratable[]): Promise<NavigateContext> {
+  const ids = new Set<number>()
+  for (const item of items) {
+    if (!item || !NAVIGABLE_TYPES.includes(item.type as (typeof NAVIGABLE_TYPES)[number])) continue
+    ids.add(item.id)
+    for (const child of item.children ?? []) {
+      ids.add(child.id)
+      if (TWO_DEPTH_TYPES.includes(item.type)) {
+        for (const grandchild of child.children ?? []) {
+          ids.add(grandchild.id)
+        }
+      }
+    }
+  }
+  if (ids.size === 0) return { states: new Map() }
+  const states = await Progress.stateByIds(Array.from(ids))
+  return { states }
+}
+
+async function computeNavigateTo(
+  content: NavigateToDecoratable,
+  ctx?: NavigateContext
+): Promise<NavigateTo | null> {
   if (!NAVIGABLE_TYPES.includes(content.type as (typeof NAVIGABLE_TYPES)[number])) return null
 
   const children = content.children
   if (!children || children.length === 0) return null
 
-  const contentState = await getProgressState(content.id)
+  const contentState = ctx?.states.get(content.id) ?? (await Progress.state(content.id))
   if (contentState !== STATE.STARTED) {
     const firstChild = children[0]
     const childNav = TWO_DEPTH_TYPES.includes(content.type)
-      ? await computeNavigateTo(firstChild)
+      ? await computeNavigateTo(firstChild, ctx)
       : null
     return buildNavigateTo(firstChild, childNav)
   }
 
   const childrenIds = children.map((c) => c.id)
   const childrenById = new Map(children.map((c) => [c.id, c]))
-  const childrenStates = (await getProgressStateByIds(childrenIds)) as Map<number, STATE>
-  const lastInteractedId = (await getLastInteractedOf(childrenIds)) as number
+  const childrenStates = ctx
+    ? new Map(childrenIds.map((id) => [id, ctx.states.get(id) ?? '']))
+    : await Progress.stateByIds(childrenIds)
+  const lastInteractedId = await Progress.lastInteractedOf(childrenIds)
 
   if (COURSE_FLOW_TYPES.includes(content.type)) {
     const lastInteractedStatus = childrenStates.get(lastInteractedId)
     const targetId =
       lastInteractedStatus === STATE.STARTED
         ? lastInteractedId
-        : findIncompleteLesson(childrenStates, lastInteractedId, content.type)
+        : Progress.incompleteLesson(childrenStates, content.type, lastInteractedId)
     const target = childrenById.get(targetId)
     return target ? buildNavigateTo(target) : null
   }
 
   if (GUIDED_FLOW_TYPES.includes(content.type)) {
-    const targetId = findIncompleteLesson(childrenStates, lastInteractedId, content.type)
+    const targetId = Progress.incompleteLesson(childrenStates, content.type, lastInteractedId)
     const target = childrenById.get(targetId)
     return target ? buildNavigateTo(target) : null
   }
@@ -107,21 +130,21 @@ async function computeNavigateTo(content: NavigateToDecoratable): Promise<Naviga
   if (TWO_DEPTH_TYPES.includes(content.type)) {
     const lastChild = childrenById.get(lastInteractedId)
     if (!lastChild) return null
-    const childNav = await computeNavigateTo(lastChild)
+    const childNav = await computeNavigateTo(lastChild, ctx)
     return buildNavigateTo(lastChild, childNav)
   }
 
   return null
 }
 
-export const navigateToDecorator: FieldDecoratorAsync<
-  NavigateToDecoratable,
-  typeof NAVIGATE_TO_FIELD,
-  NavigateTo | null
-> = {
-  field: NAVIGATE_TO_FIELD,
-  compute: computeNavigateTo,
-  recurse: false,
+export function navigateToDecorator(
+  ctx?: NavigateContext
+): FieldDecoratorAsync<NavigateToDecoratable, typeof NAVIGATE_TO_FIELD, NavigateTo | null> {
+  return {
+    field: NAVIGATE_TO_FIELD,
+    compute: (item) => computeNavigateTo(item, ctx),
+    recurse: false,
+  }
 }
 
 export function decorateNavigateTo<T extends NavigateToDecoratable>(
@@ -130,10 +153,12 @@ export function decorateNavigateTo<T extends NavigateToDecoratable>(
 export function decorateNavigateTo<T extends NavigateToDecoratable>(
   items: T
 ): Promise<WithNavigateTo<T>>
-export function decorateNavigateTo<T extends NavigateToDecoratable>(
+export async function decorateNavigateTo<T extends NavigateToDecoratable>(
   items: T | T[]
 ): Promise<WithNavigateTo<T> | WithNavigateTo<T>[]> {
-  return decorateAllAsync(items as NavigateToDecoratable, [navigateToDecorator]) as Promise<
+  const list = Array.isArray(items) ? items : [items]
+  const ctx = await prefetchStates(list)
+  return decorateAllAsync(items as NavigateToDecoratable, [navigateToDecorator(ctx)]) as Promise<
     WithNavigateTo<T> | WithNavigateTo<T>[]
   >
 }

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

@@ -222,7 +222,7 @@ export async function resetAllLearningPaths() {
  * @param {number} learningPathId - The learning path ID
  * @returns {Promise<Object>} Learning path with enriched lesson data
  */
-export async function getEnrichedLearningPath(learningPathId) {
+export async function getEnrichedLearningPath(learningPathId: number) {
   let response = (await addContextToLearningPaths(
     fetchByRailContentId,
     learningPathId,

package/src/services/contentProgress.js

@@ -841,7 +841,7 @@ export function filterOutLearningPathsForDuplication(progresses, collection) {
 
 export async function duplicateProgressForIds(entries) {
   return Promise.all(Object.entries(entries).map(([id, pct]) => {
-    return saveContentProgress(parseInt(id), null, pct, null, { skipPush: true, accessedDirectly: false })
+    return saveContentProgress(parseInt(id), null, pct, undefined, { skipPush: true, accessedDirectly: false })
   }))
 }
 

package/src/services/forums/posts.ts

@@ -3,7 +3,7 @@
  */
 import { HttpClient } from '../../infrastructure/http/HttpClient'
 import { globalConfig } from '../config.js'
-import { ForumPost } from './types'
+import { ForumPost, WhoLikedParams, WhoLikedResponse } from './types'
 import { PaginatedResponse } from '../api/types'
 import { markThreadAsRead } from './threads'
 
@@ -128,6 +128,33 @@ export async function likePost(postId: number, brand: string): Promise<void> {
   })
 }
 
+/**
+ * Fetch the list of users who liked a forum post.
+ *
+ * @param {number} postId - The ID of the post.
+ * @param {string} brand - The brand context (e.g., "drumeo", "singeo").
+ * @param {WhoLikedParams} [params] - Optional pagination parameters.
+ * @returns {Promise<WhoLikedResponse>} - A promise that resolves to the paginated list of likers.
+ * @throws {HttpError} - If the request fails.
+ */
+export async function whoLikedPost(
+  postId: number,
+  brand: string,
+  params: WhoLikedParams = {}
+): Promise<WhoLikedResponse> {
+  const httpClient = new HttpClient(globalConfig.baseUrl)
+  const queryObj: Record<string, string> = {
+    brand,
+    ...Object.fromEntries(
+      Object.entries({ page: 1, limit: 20, ...params })
+        .filter(([_, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => [k, String(v)])
+    ),
+  }
+  const query = new URLSearchParams(queryObj).toString()
+  return httpClient.get<WhoLikedResponse>(`${baseUrl}/v1/posts/${postId}/likes?${query}`)
+}
+
 /**
  * Unlike a forum post.
  *

package/src/services/forums/types.ts

@@ -1,3 +1,26 @@
+export interface WhoLikedParams {
+  page?: number
+  limit?: number
+}
+
+export interface Liker {
+  user_id: number
+  display_name: string
+  profile_picture_url: string | null
+  access_level: string
+  liked_at: string
+  liked_at_diff: string | null
+}
+
+export interface WhoLikedResponse {
+  data: Liker[]
+  meta: {
+    total: number
+    current_page: number
+    last_page: number
+  }
+}
+
 export interface ForumUser {
   id: number
   display_name: string

package/src/services/permissions/PermissionsV2Adapter.ts

@@ -19,6 +19,7 @@ import {
 } from './permissions'
 import {arrayToRawRepresentation, arrayToStringRepresentation} from '../../filterBuilder.js'
 import {basicMembershipTier, plusMembershipTier} from "../../contentTypeConfig";
+import { COLLECTION_TYPE } from '../sync/models/ContentProgress'
 
 /**
  * V2 Permissions Adapter for the new permissions system.
@@ -55,6 +56,9 @@ export class PermissionsV2Adapter extends PermissionsAdapter {
 
     // Content with no permissions is accessible to all
     if (contentPermissions.size === 0) {
+      if (content?.type === COLLECTION_TYPE.LEARNING_PATH && content?.children?.length) {
+        return content.children.every(child => child.need_access)
+      }
       return false
     }
 

package/src/services/progress/collections.ts

@@ -0,0 +1,33 @@
+import { db } from '../sync'
+import { ProgressQueryOptions, StartedOrCompletedOptions } from './types'
+
+const SIXTY_DAYS_IN_SECONDS = 60 * 24 * 60 * 60
+
+const defaultQueryOptions: ProgressQueryOptions = {
+  onlyIds: true,
+  include: {
+    aLaCarte: true,
+    learningPaths: false,
+  },
+}
+
+export const allStarted = async (limit: number | null = null, options?: ProgressQueryOptions) =>
+  db.contentProgress.started(limit, options ?? defaultQueryOptions)
+
+export const allCompleted = async (limit: number | null = null, options?: ProgressQueryOptions) =>
+  db.contentProgress.completed(limit, options ?? defaultQueryOptions)
+
+export const allCompletedByIds = async (contentIds: number[]) =>
+  db.contentProgress.completedByContentIds(contentIds)
+
+export const allStartedOrCompleted = async (
+  limit?: number,
+  options: StartedOrCompletedOptions = {}
+) =>
+  db.contentProgress
+    .startedOrCompleted({
+      ...options,
+      limit,
+      updatedAfter: Math.floor(Date.now() / 1000) - SIXTY_DAYS_IN_SECONDS,
+    })
+    .then((r) => r.data)

package/src/services/progress/index.ts

@@ -0,0 +1,6 @@
+import * as state from './state'
+import * as collections from './collections'
+
+export const Progress = { ...state, ...collections }
+
+export type { ProgressContentFilter, ProgressQueryOptions, StartedOrCompletedOptions } from './types'

package/src/services/progress/internal/queries.ts

@@ -0,0 +1,43 @@
+import { db } from '../../sync'
+import { CollectionParameter } from '../../sync/models/ContentProgress'
+
+export const getByIds = async <V>(
+  contentIds: number[],
+  dataKey: string,
+  defaultValue: V,
+  collection?: CollectionParameter
+): Promise<Map<number, V>> => {
+  if (contentIds.length === 0) return new Map()
+
+  const progress = new Map(contentIds.map((id) => [id, defaultValue]))
+  await db.contentProgress.getSomeProgressByContentIds(contentIds, collection).then((r) => {
+    r.data.forEach((p) => {
+      progress.set(p.content_id, p[dataKey] ?? defaultValue)
+    })
+  })
+  return progress
+}
+
+export const getById = async <V>(
+  contentId: number,
+  dataKey: string,
+  defaultValue: V,
+  collection?: CollectionParameter
+): Promise<V> => {
+  if (!contentId) return defaultValue
+  return db.contentProgress
+    .getOneProgressByContentId(contentId, collection)
+    .then((r) => r.data?.[dataKey] ?? defaultValue)
+}
+
+export const getByRecordIds = async <V>(ids: string[], dataKey: string, defaultValue: V) => {
+  const progress = Object.fromEntries(ids.map((id) => [id, defaultValue]))
+
+  await db.contentProgress.getSomeProgressByRecordIds(ids).then((r) => {
+    r.data.forEach((p) => {
+      progress[p.id] = p[dataKey] ?? defaultValue
+    })
+  })
+
+  return progress
+}

package/src/services/progress/state.ts

@@ -0,0 +1,50 @@
+import { db } from '../sync'
+import { COLLECTION_TYPE, CollectionParameter } from '../sync/models/ContentProgress'
+import { getById, getByIds, getByRecordIds } from './internal/queries'
+
+export const state = async (contentId: number, collection?: CollectionParameter) =>
+  getById(contentId, 'state', '', collection)
+
+export const stateByIds = async (contentIds: number[], collection?: CollectionParameter) =>
+  getByIds(contentIds, 'state', '', collection)
+
+export const stateByRecordIds = async (ids: string[]) => getByRecordIds(ids, 'state', '')
+
+export const playbackPositionByIds = async (contentIds: number[], collection?: CollectionParameter) =>
+  getByIds(contentIds, 'resume_time_seconds', 0, collection)
+
+export const playbackPositionByRecordIds = async (ids: string[]) =>
+  getByRecordIds(ids, 'resume_time_seconds', 0)
+
+export const lastInteractedOf = (
+  contentIds: number[],
+  collection?: CollectionParameter
+): Promise<number | undefined> =>
+  db.contentProgress
+    .mostRecentlyUpdatedId(contentIds, collection)
+    .then((r) => (r.data ? parseInt(r.data, 10) : undefined))
+
+export const incompleteLesson = (
+  progressOnItems: Map<number, string>,
+  contentType: string,
+  currentContentId?: number
+): number | null | undefined => {
+  const ids = Array.from(progressOnItems.keys())
+  const getProgress = (id: number) => progressOnItems.get(id)
+
+  if (contentType === 'guided-course' || contentType === COLLECTION_TYPE.LEARNING_PATH) {
+    return ids.find((id) => getProgress(id) !== 'completed') || ids.at(0)
+  }
+
+  const currentIndex = ids.indexOf(Number(currentContentId))
+  const startIndex = currentIndex === -1 ? 0 : currentIndex + 1
+
+  for (let i = startIndex; i < ids.length; i++) {
+    const id = ids[i]
+    if (getProgress(id) !== 'completed') {
+      return id
+    }
+  }
+
+  return ids[0]
+}

package/src/services/progress/types.ts

@@ -0,0 +1,16 @@
+export interface ProgressContentFilter {
+  aLaCarte?: boolean
+  learningPaths?: boolean
+}
+
+export interface ProgressQueryOptions {
+  onlyIds?: boolean
+  include?: ProgressContentFilter
+}
+
+export interface StartedOrCompletedOptions {
+  brand?: string
+  contentTypes?: string[]
+  parentId?: number
+  include?: ProgressContentFilter
+}

package/src/services/sanity.js

@@ -1193,13 +1193,11 @@ export async function fetchLiveEvent(brand, forcedContentId = null) {
     default:
       break
   }
-  let startDateTemp = new Date()
-  let endDateTemp = new Date()
 
-  startDateTemp = new Date(
-    startDateTemp.setMinutes(startDateTemp.getMinutes() + LIVE_EXTRA_MINUTES)
-  )
-  endDateTemp = new Date(endDateTemp.setMinutes(endDateTemp.getMinutes() - LIVE_EXTRA_MINUTES))
+  const now = new Date()
+
+  const startOfYesterday = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - 1)).toISOString()
+  const endOfTomorrow = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 2)).toISOString()
 
   const liveEventFields = getLiveFields().concat(
     `'event_coach_calendar_id': coalesce(calendar_id, '${defaultCalendarID}')`
@@ -1212,15 +1210,25 @@ export async function fetchLiveEvent(brand, forcedContentId = null) {
       : `status == 'scheduled'
       && (brand == '${brand}' || live_global_event == true)
       && defined(live_event_start_time)
-      && live_event_start_time <= '${getSanityDate(startDateTemp, false)}'
-      && live_event_end_time >= '${getSanityDate(endDateTemp, false)}'`
+      && live_event_start_time >= '${startOfYesterday}'
+      && live_event_start_time < '${endOfTomorrow}'`
 
   const filter = await new FilterBuilder(baseFilter, { bypassPermissions: true }).buildFilter()
 
-  // This query finds the first scheduled event (sorted by start_time) that ends after now()
-  const query = `*[${filter}]{${fieldsString}} | order(live_event_start_time)[0...1]`
+  const events = await fetchSanity(
+    `*[${filter}]{${fieldsString}} | order(live_event_start_time asc)`,
+    true,
+    { processNeedAccess: false }
+  )
 
-  return await fetchSanity(query, false, { processNeedAccess: true })
+  const clientNow = new Date()
+  const windowStart = new Date(clientNow.getTime() - LIVE_EXTRA_MINUTES * 60000).toISOString()
+  const windowEnd = new Date(clientNow.getTime() + LIVE_EXTRA_MINUTES * 60000).toISOString()
+
+  return events?.find(event =>
+    event.live_event_end_time >= windowStart &&
+    event.live_event_start_time <= windowEnd
+  ) ?? null
 }
 
 /**
@@ -1667,8 +1675,8 @@ function contentResultsDecorator(results, fieldName, callback) {
           processChildren(contentItem)
         })
       } else {
-        result[fieldName] = callback(result)
         processChildren(result)
+        result[fieldName] = callback(result)
       }
     })
   } else if (results.entity && Array.isArray(results.entity)) {
@@ -1705,8 +1713,8 @@ function contentResultsDecorator(results, fieldName, callback) {
       }
     })
   } else {
+    processChildren(results)
     results[fieldName] = callback(results)
-    processChildren(results) // this on was always true
   }
 
   return results
@@ -2224,7 +2232,14 @@ export async function fetchScheduledAndNewReleases(
     return []
   }
 
-  return reorderScheduledAndNewReleases(r, limit)
+  const reordered = reorderScheduledAndNewReleases(r, limit)
+  const computedNow = new Date()
+  return reordered.map(item => ({
+    ...item,
+    isLive: item.live_event_start_time && item.live_event_end_time
+      ? new Date(item.live_event_start_time) <= computedNow && new Date(item.live_event_end_time) >= computedNow
+      : false,
+  }))
 }
 
 function reorderScheduledAndNewReleases(r, limit) {