Child index for position label in Roku's built-in trickPlayBar component. The trickPlayBar is part of the Video node and doesn't expose child IDs, so we must access by index. Fallback search logic exists if Roku changes the structure. Defined at module level (BrighterScript const requirement) to provide immutability and enable reuse across multiple helper functions if needed.

Called by PlayerHostView BEFORE it clears the modal/overlay channels during its own teardown (prepareToLeaveMount, shared by the finished and Live TV stall paths). See the call site for why this has to run first. Abandon, not cancel: nothing should observe a result from a dialog that playback is walking away from regardless.

Returns the metadata in the response: main.bs's transport dispatcher calls roAppManager.SetNowPlayingContentMetaData() on the MAIN thread (roAppManager can't be created on the render thread, where this callFunc executes).

availSubtitleTrackIdx: Returns Roku's index for requested subtitle track

Check the the buffering has not hung

Check media segments and trigger appropriate actions based on current playback position

Checks if we need to display the Next Episode button

The state one shown error owns: the dialog slot, the text both tiers render, and the exit claim PlayerHostView reads. One place, because the three ways an error ends (acknowledged, superseded, abandoned by teardown) all have to leave exactly the same nothing behind. A claim outliving its dialog would gag the host's queue logic for the life of this player node. Every queue advance builds a fresh one (PlayerHostView.playCurrentQueueItem), so it cannot leak past that, which is the bound and not a reason to be sloppy about clearing it.

One exit path for both tiers, so the report and the alert cannot drift apart about what closing means.

Fetches the current + next episode (Limit 2) to decide whether the Next Episode button should be enabled. Render-thread promise; replaces the former GetNextEpisodeTask, a pure-fetch Task that existed only to move one fetchRes off the render thread (Phase-3a collapse; canonical example in docs/dev/promises.md).

findTrickPlayBarPositionLabel: Defensively finds the position text label in trickPlayBar

Tries multiple strategies to find the Label that displays seek position:

1. Expected child index (8) - fast path for current Roku OS
2. Search for FIRST Label child - position text comes before remaining time
3. Return invalid if not found - feature gracefully degrades

Forces playback to finished state for proper watched-status and auto-play. Triggers synchronous teardown (onState -> PlayerHostView.onPlayerStateChange -> destroy/ goBack -> onDestroy), invalidating all m. references. Callers must return immediately after.

getCurrentChapterIndex: Finds current chapter index

The media duration in seconds, or 0 when it is not known.

Falls back to content.length (which Jellyfin populates from mediaSource.RunTimeTicks) when Roku's own duration probe returns 0. This happens with live-transcoded progressive MKV: ffmpeg can't know the final duration while encoding, so it writes 0 into the MKV SegmentInfo header, and Roku's probe inherits that.

handleChapterListAction: Handles action to show chapter list

handleChapterSkipAction: Handles user command to skip chapters in playing video

handleHideAction: Handles action to hide OSD menu

handleItemSkipAction: Handles user command to skip items

handleShowAudioMenuAction: Handles action to show audio selection menu

handleShowSubtitleMenuAction: Handles action to show subtitle selection menu

handleShowVideoInfoPopupAction: Handles action to show video info popup

handleShowVideoSourceMenuAction: Handles action to show video source selection menu

handleTransport: Roku voice and remote-control transport handler. Reached through remoteDispatch.dispatchTransport (main.bs's voice roInputEvent branch, and the ws:// receiver) and PlayerHostView.handleTransport, which forwards to this player.

Returns { status: "" } per roInput.EventResponse(). Roku OS uses the status to render the appropriate HUD message. Codes used here:

• success / success.seek-start / success.seek-end: op completed (with bounds note)
• error.redundant: state already matches request (for example pause-while-paused)
• error.generic: op semantically unsupported in this context
• unhandled: command we don't recognize; lets Roku show "Command not available"

See https://github.com/rokudev/dev-doc, docs/DEVELOPER/media-playback/voice-controls/transport-controls.md

handleVideoPlayPauseAction: Handles action to either play or pause the video content

Remote "PreviousTrack": step back one queue item, symmetric with handleVoiceNextItem. error.generic at the head of the queue (no previous item): no chapter-back concept here.

Reuse the OSD itemNext code path so Live-TV channel advance, queue advance, and Episode-to-next-Episode all behave identically to pressing the on-screen Next button.

Hide the Next Episode notification

isTrackPickAgainstOldVersion: True when an audio or subtitle pick that needs a reload arrives while a version switch is still loading, and the pick must then be ignored.

The pickers list the tracks of the version that was playing until the new one delivers, so the picked index belongs to that version's streams, not the new one's. Reloading would either undo the switch or ask the new version for a track it may not have. Ignoring it lets the switch's run finish with the tracks it chose for the new version. The pick also rewrites no start point: the switch already mapped the position into the new version's timeline.

The playing item's OriginalLanguage (12.0+), for the "Original language" audio preference.

Called by PlayerHostView when this mount's live stream ends or stalls: how much of it played, for the restart rule (newLiveProgress in liveTv.bs).

Set caption url to server subtitle track and run the fetch task

Collapsed from LoadChannelListForQueueTask, a pure-fetch Task that existed only to move one fetchRes off the render thread (Phase-4 collapse; see docs/dev/promises.md). Fire-once per playback (guarded by m.channelListLoaded), so no seq guard is needed: a single .then can't race itself the way a hot re-fire would.

Only setup caption items if captions are allowed

Event handler for when audioIndex changes. For direct play: switches audio track directly using Roku's availableAudioTracks (no stop/reload needed since all tracks are in the container). For transcoded, or when the newly-selected stream exceeds the device's audio capability (for example, switching from stereo back to an 8ch track on a stereo Roku), must reload so the server transcodes the new selection.

onDestroy: Full teardown releasing all resources before component removal Called by PlayerHostView.destroyPlayer, on every remount and on the host's own teardown

Re-arms the next-episode check after a fetch that never produced a usable response, so a later "playing" transition retries it.

Handler for Next Episode notification action

Safety net: ensure focus isn't orphaned after notification dismissal animation completes

onOSDAction: Process action events from OSD to their respective handlers

Fires on any REAL resolution of the error dialog: the user pressing OK, or Back (result.cancelled, same as OK here: there's nothing to cancel back to). Either way, leave the play route.

A close driven by PLAYBACK TEARDOWN instead of the user must never reach this handler. abandonErrorDialog() below is how teardown clears the dialog without firing it, so this always means a real user action. Routing teardown through the ordinary result path was the old bug (playback-error-dialog-closed-by-teardown): the old raw Dialog's wasClosed observer could not tell "user pressed OK" from "code closed me", so a teardown-triggered close both delivered a result AND raced the teardown's own navigation. PlayerHostView.prepareToLeaveMount is the call site that matters: it abandons before it cancels, and the comment there says why the order matters.

When Video Player state changes

Handler for segment notification action

When Video Player state changes

Event handler for when selectedSubtitle changes

Called when Roku's trickPlayBar position text changes Parses the time string to get seek position and syncs our carousel This ensures carousel stays in sync with Roku's authoritative seek position

onVideoSourceChange: Handles video source switching from OSD Saves position, stops playback, re-selects audio for the new source's streams, and reloads video content with the new MediaSource ID.

A superseded error leaves the player alive and stopped. PARK it: clear the error state, hide the node, and stop treating it as a controllable player.

Not cosmetic. The Video node draws Roku's OWN buffering indicator (the internal retrievingBar / bufferingBar ProgressBars; bufferingBar is the one styled in init) and it keeps drawing after the stream stops: a black screen with a ring reading 0%, which is the app telling the user it is loading, forever. Hiding the node removes it and reveals the backdrop the host already set for this item.

The OSD goes with it. stateAllowsOSD() admits "stopped", so without the flag Up would open an OSD inside a hidden parent: a control surface that renders nothing and takes the focus Back needs. Parked there is nothing to control and Back is the only action, which is what the state actually is.

Undone in onState's playing branch, not here: the route back into playback is not this scope. A voice or remote-control play restarts a stopped node WITHOUT going through onVideoContentLoaded, which is the only other place that makes the player visible.

Pause and show the OSD in its paused state: what the Play key does to a playing video. Also PlayerHostView's when nobody answers the still-watching prompt, so a viewer who comes back finds the same paused player they would have left themselves.

What we know about WHAT was playing, for the Details rows. Read from the already-loaded content rather than re-derived: this runs on a failure path, so it must not be able to fail itself.

populateChapterMenu: ' Parse chapter data from API and appeand to chapter list menu

Close the live stream a load opened when no player will ever play it: the load failed, or it is being replaced by a load of the server's stream. Nothing reported its start, so the server has no session to release it with (endClosesLiveStream); a close by id does.

Lets go of the video load when this view goes away, releasing the Live TV live stream it opened exactly once (liveStreamHandoff.bs decides how, from the stage the load recorded).

Report playback to server

Report the end of this stream, once (classifyPlaybackEnd decides which report, if any). Every end needs one: the stop is also what stops the server's transcode and releases a Live TV live stream this session reported playing, which a terminal error would otherwise leave open until the server restarts, since onState ignores every later state (#988). A live stream that never reported its start is released by a close by id instead, and its stop then does not name it, so the stream is released exactly once (endClosesLiveStream). Once per stream, because a stop can also surface as finished, and the server records each report as its own "finished playing".

Called by PlayerHostView right before it restarts a Live TV channel whose stream stalled. Without it, each stall restart left the server one consumer holding the live stream (on a tuner-limited server, a tuner): measured on a Stick 4K against 12.1, where Back, voice "stop" and a channel switch from a playing channel all report their stop.

retryPlayback: Re-runs the content loader from the current position with updated task flags. Used by error handlers to retry without exiting the player.

30s end-slack matches the Roku transport-controls reference example for video: clamping shy of duration prevents the player from firing end-of-content immediately.

Determines if custom subtitles should be used for the current selection Custom subtitles should only be used for external subtitles when the user has enabled the setting

Called by PlayerHostView when a Live TV stream stalls and it will not restart the channel (it had not played healthily). The same cause as showLiveStreamStoppedError, plus the stop a stall needs (an ended stream has already stopped). Same shape as bufferCheck's stall error: the dialog claims the exit first, so the finished this stop can surface as is ignored by the host.

Called by PlayerHostView when it gives up on a Live TV channel that keeps ending without playing, which is a finished rather than an error, so nothing here would show one. The player reports no error code for it, so the cause is given in words, chosen by the host (liveGiveUpCauseKey in liveTv.bs).

Show the Next Episode notification with countdown text

The diagnostic readout behind [Details]. A plain report overlay: it owns no result contract (OverviewDialog self-closes), so the exit is driven by its closed field instead.

Show the playback error.

serverMessage is a message the SERVER already explained in words (the LoadVideoContentTask failures); when it is empty the cause is derived from the Video node's own errorCode. Either way the diagnostics come off the node, so a failure that never reached the player has fewer rows.

startVideoLoad: Start a run of the video load for the current item, on a NEW LoadVideoContentTask node, and declare the metadata fill onVideoContentLoaded resolves.

A new node every run because a run can start while the last one is still going: a second audio, subtitle or version pick before the first one's stream arrives, or the server-stream retry onVideoContentLoaded starts from inside a delivery. The same node would drop that launch, so the viewer's last pick was lost or the player stayed on its spinner (threading.md, "Relaunching and stopping a Task"). The run it replaces goes through releaseVideoLoad, never a bare STOP, because it may be opening a Live TV stream that only its answer names.

A new node starts with every field at its default, so this passes the full input set each time. The version is m.videoLoadMediaSourceId; the retry flags apply to one run only.

stateAllowsOSD: Check if current video state allows showing the OSD

reportPlayback's body. A separate function because reportPlayback is also the playback timer's fire observer, which must keep its one-argument signature.

The channel's playback start is opened before this player stops, and the player mounted next takes it (QueueManager.takePlaybackStart), so nothing this player does on its way out can end it.

Toggles visibility of custom subtitles and sets the caption renderer's player state

Feeds this mount's live progress from one position notification. A jump is logged because the step size that separates playing from a jump (LIVE_PROGRESS_MAX_STEP_MS) is a tuned value.

Skip an active media segment (intro/recap/etc.) if one is currently in-window. Returns true if a segment was skipped, false if no active segment.

Removes old subtitle lines and adds new subtitle lines

Update Next Episode countdown text

Updates trickplay carousel with index calculated from video position Snaps to thumbnail boundaries for cleaner UX