How far ahead a reader can still resolve a bare 12h time by comparing it to the clock. Dropping the suffix asserts "the nearest clock face showing these digits", which stops being the time we meant once the meridian comes back around: at 13:00 a 23-hour runtime ends at 12:00 pm, the same half of the day, so the suffix rule alone would omit it and "Ends at 12:00" would read as noon today. Past this horizon the suffix always earns its place.

The app's Scene node, cached on first use.

Reaching the scene means walking up from m.top, so every caller that needed it had grown its own copy of this three-line cache. m is per-component-scope, so the cache is per component, which is what we want: each component resolves the scene once and reuses it.

Check if a specific value is inside of an array

Computes a broadcast program's elapsed-time percentage. Programs are live broadcasts, not streamed media, so "progress" is wall-clock elapsed, not UserData.PlayedPercentage. Returns 0 (not 100) for finished programs because JRPoster only cleanly removes the VideoProgressBar child when playedPercentage = 0.

A number from a field that may be a float, an integer, a string, or absent.

The FLOAT-PRESERVING counterpart to mediaNumber, and the distinction matters in both directions. mediaNumber truncates to a 32-bit Integer, which is right for Height / Channels / SampleRate and wrong for two kinds of field:

• Fractional ones (frame rates, completion percentages), where truncating destroys the figure outright.
• Large ones (a byte count passes 2^31 at ~2.1 GB, and RunTimeTicks for a three-hour film is ~1.08e11), where truncating overflows.

Every caller today passes a media field, so this covers what actually reaches it in practice. An unhandled type (roSGNode, roDateTime, a function) would still fault on return value as float rather than fall back to 0.0.

displayToast: Display a transient toast notification via the scene-level Toast component.

Filters an array of nodes, excluding any whose nodeKey value appears in excludeArray

The one way to render a time the reader will read off against an on-screen clock: the "Ends at" value in ItemDetails and in the playback OSD. Bare when the half of the day is inferable, suffixed when it isn't, so the same end time reads identically on both screens.

convert iso date string to a human readable date string eg. "March 13th, 2014"

Format time as 12 or 24 hour format based on system clock setting The app's clock (Clock.bs) does not use this; it formats times shown on screens and in dialogs

Returns the full-screen view currently on top: the router-mounted view tracked on m.global.activeRoutedView. The whole app is routed: pre-login, content, and playback are all router views in JRScene's outlet. Callers use it to resolve "what's on screen".

Returns the current API version from global state with a safe default of 2. Works in both class and non-class contexts (components, namespaces, functions). This is the single source of truth for reading m.global.server.apiVersion.

Returns "am"/"pm" only when the suffix disambiguates the time against the current clock, empty string otherwise (and always empty on a 24h clock).

Why this exists: the clock the reader compares against renders bare in 12h mode: "10:32", never "10:32 pm" (see Clock.bs, used by both the overhang and the playback OSD). A time measured against that clock therefore doesn't need a meridian either, unless it crosses noon or midnight, or sits beyond the horizon above. Those are the cases the reader can't infer at a glance. Only for now-anchored times; see getTimePeriod() for absolute ones.

getFirstVideoStream: Finds the first video stream in MediaStreams array MediaStreams[0] is not always a video stream - it could be subtitle or audio

getGlobalSplashScreenSetting: Gets the global splash screen setting from registry or default

Reads from global registry first. If not found (user never changed it), reads default from settings.json (single source of truth). Works before user login since global settings are device-wide.

Converts a Jellyfin audio stream index to a Roku audioTrack Track identifier. For MKV direct play, Roku exposes tracks using 1-based MKV track numbers that include ALL track types (video, audio, subtitle). Jellyfin's stream Index is 0-based and also counts all track types, so Roku Track = Jellyfin Index + 1.

When availableAudioTracks is provided (populated by Roku during active playback), matches by language with ordinal disambiguation: among same-language Jellyfin streams (in original order), find the position N of the chosen index, then return the Nth same-language Roku track. This avoids returning the wrong track when multiple streams share a language (for example main + commentary, both English: issue #500). Falls back to Index + 1 mapping when availableAudioTracks is not available or no ordinal match can be found (for example before playback starts or for non-MKV containers).

Returns "am" or "pm" for 12h clock, empty string for 24h. Use for times the reader has no on-screen reference for: a broadcast range that may be hours or days away. For a time anchored to "now", prefer formatDisambiguatedTime().

Search string array for search value. Return if it's found

take an incomplete url string and use it to make educated guesses about the complete url. then tests these guesses to see if it can find a jf server returns the url of the server it found, or an empty string

injectApiParams: Pure function to inject default image parameters and version-specific fields Separated from ApiClient for testability without network I/O

True only for a real boolean true.

value = true faults &h18 on a non-boolean operand, so the TYPE has to be established before the comparison. A field the server omitted dereferences to Invalid, which is exactly the case a bare if stream.IsAnamorphic would fault on. ParseJson yields an unboxed "Boolean" and an AA literal a boxed "roBoolean". Both are real booleans, so both have to pass.

Lives here, beside isValid / mediaNumber / textOrEmpty, because it is the same kind of thing: a coercion for a field that may not be there. It used to live in fallbackFont.bs, which meant reaching it from anywhere else imported a module about fonts to get a boolean guard. That was enough friction that the playback report grew a byte-identical private copy rather than pay it.

isChainValid: Returns whether or not all the properties in the passed property chain are valid. Stops evaluating at first found false value

accepts the raw json string of /system/info/public and returns a boolean indicating if ProductName is "Jellyfin Server"

Returns true if the string is a loopback, such as 'localhost' or '127.0.0.1'

Returns whether or not passed value is valid

Returns whether or not passed value is valid and not empty Accepts a string, or any countable type (arrays and lists)

Walk to the deepest focused descendant. Dialog helpers capture this before presenting, so closing can restore focus exactly where the user left it (source/utils/dialogs.bs presentOverlayDialog -> returnFocusTo).

A numeric field from a Jellyfin media object, as an integer.

Jellyfin's numeric fields (Height, Width, Channels, BitRate, Level) arrive as integers from ParseJson, but the app has always handled them arriving as strings too. isWithinH264HardwareCeiling (Height and Width) and buildPlaybackInfoPostData in source/api/items.bs (the audio stream's Channels and the transcoding profile's MaxAudioChannels) still carry their own inline copies of this coercion. This is that coercion, once.

Returns 0 for anything missing or non-numeric, so callers can compare without a validity check first: a stream that does not report a height has no height, and 0 is the honest reading of that for every comparison the report makes.

The type names below were measured, not reasoned, and the same integer reports three different names depending on where it came from. On a Stick 4K (Roku OS 15.3.4):

type(2) -> "Integer" an unboxed literal type(parsed.someInt) -> "Integer" read out of an AA from ParseJson type(aa.someInt) -> "roInteger" boxed, read out of an AA literal type(node.someIntField) -> "roInt" read off a SceneGraph node field

(The ParseJson row, and the AA-literal and node rows again, measured 2026-10-11 on a Stick 4K, including an AA read back through an assocarray node field.)

All three are listed because this function is handed all three: MediaStream fields arrive from ParseJson ("Integer") or read back through a node field ("roInt"), user settings arrive from a JellyfinUserSettings node, and callers and specs pass literals, an AA literal among them ("roInteger"). Enumerating only the plausible-looking names is what produced the bug this function was extracted to fix: type(x) = "Integer" against a node field is always false, so GetBitRateLimit discarded every user-set bitrate limit and silently substituted Roku's hardware ceiling.

Not for byte counts. The return type is a 32-bit Integer, so anything above 2,147,483,647 overflows, and MediaSourceInfo.Size is a byte count, which passes that at ~2.1 GB. Every other numeric media field (Height, Width, Channels, BitRate, Level, SampleRate, BitDepth) is comfortably inside the range. Format sizes from the raw value in floating point instead.

True when two times fall in opposite halves of the day, that is, one of them is on the far side of noon or midnight from the other. This is exactly when a 12h time needs an am/pm suffix to be readable against the other: same half means the suffix carries no information. Hours are 0-23 local. Injected (rather than read from roDateTime) so this stays unit-testable.

Returns an array from a url = [ url, proto, host, port, subdir+params ] If port or subdir are not found, an empty string will be added to the array Proto must be declared or array will be empty

The MediaSource this playback is actually using, off the cached /PlaybackInfo response.

One definition because two surfaces describe the same streams (the playback-info report in PlayerHostView and the playback-error Details readout in VideoPlayerView), and two copies of "which source are we describing" is exactly how they would come to disagree about one stream.

MediaSources[0] is correct rather than merely convenient: the app asks the server for ONE source (the selected mediaSourceId), so the response carries the one that was negotiated for this play session, not a menu to pick from.

Maps a Jellyfin server version string to an API version integer used by the SDK dispatcher. V1: Covers pre-10.9 servers (10.7.x, 10.8.x): uses /Users/{userId}/ path prefix V2: Covers 10.9+ servers: endpoints moved to top-level, userId passed as query param Returns 1 if serverVersion is empty/invalid (safe fallback to legacy paths)

resolveSplashScreen: Resolves whether to show the splash screen on User Select screen

Checks JellyRock global setting. If "disabled", never shows splash. Otherwise follows server branding configuration. Ensures a valid boolean is always returned.

Restore focus to a view's saved descendant (lastFocus) if it's still valid, else focus the view root. The canonical focus-restore rule shared by the JRScreen lifecycle bridge (onScreenShown / handleFocus) and main.bs's side-panel handlers. No-op on an invalid view.

Maps a selected content item to its route: a named-route arg { name, params } for sgRouter.navigateTo. Pure (no router call) so it can live here in commonly-imported misc.bs; the routed view that owns the selection calls navigateTo itself (passing the rich node as context to avoid a re-fetch). Returns invalid for items that are not view navigation (a Chapter starts playback); the caller handles those via the playback path (quickPlayNode).

Converts seconds to a human readable timestamp. Used for progress bar during playback eg. 3661 seconds = "01:01:01"

Takes an array of data, shuffles the order, then returns the array uses the Fisher-Yates shuffling algorithm

startLoadingSpinner: Start a loading spinner and attach it to the main JRScene. Displays an invisible ProgressDialog node by default to disable keypresses while loading.

Text from a field that may not exist.

toString() faults with a Type Mismatch on Invalid, because it falls through to Str(), so it can only be used where the value is known to be present. Optional fields (most of a Jellyfin MediaStream, every field a newer server added) need this instead: absent reads as "", which is what a caller building display text out of them wants anyway.

Converts ticks to number of minutes eg. 3661 totalSeconds = 61

convert value to boolean and return value

this is the "educated guess" logic for inferServerUrl that generates a list of complete url's as candidates for the tests in inferServerUrl. takes an incomplete url as an arg and returns a list of extrapolated full urls.

Returns whether or not a version number (for example 10.7.7) is greater or equal to some minimum version allowed (for example 10.8.0)