state/settings

The stream settings' state and rules, held once above the layout and read by the video, audio, and screen panels wherever a layout paints them.

State arrives through the message events the core posts on window: serverSettings (the server's settings payload, per key a value, allowed, min/max, default, locked, and overridden), effectiveCursorState, scalingDpiFollowed (the UI-scaling default the core re-derived), displayRefresh (the display's measured refresh, also window.displayRefreshRate, which the frame-rate slider offers as a stop of its own), and audioDeviceSelected. Changes go back as window.postMessage messages: settings (debounced key/value batches the core forwards to the server), mode, setScaleLocally, setManualResolution, resetResolutionToWindow, setAntiAliasing, and whatever the shared conditional-setting specs post. The transport is seeded from window.__SELKIES_STREAMING_MODE__, and a switch goes through the shared switchStreamMode.

Every value persists under a localStorage key from getPrefixedKey, which adds the _display2 suffix for per-display settings on a secondary display; the cores read the same keys. The cores also persist every value they are told to apply, so a stored key alone cannot tell a user's explicit pick from one the dashboard derived (HiDPI from the resolution mode) or applied from the server (paint-over). Those settings therefore carry an _explicit_choice marker beside their value and resolve through the shared specs of selkies-web-core/lib/conditional-settings.js, which honor pinned, locked, and operator-overridden server values: a derived write never pins them, and an unmarked stored echo is dropped once the ladder moves on.

InterfacesCopy Anchor Link

AudioDeviceCopy Anchor Link

Defined in: state/settings.ts:204

An audio device as the picker lists it.

PropertiesCopy Anchor Link

deviceIdCopy Anchor Link

deviceId: string;

Defined in: state/settings.ts:204

labelCopy Anchor Link

label: string;

Defined in: state/settings.ts:204

Type AliasesCopy Anchor Link

StreamSettingsCopy Anchor Link

type StreamSettings = ReturnType<typeof useStreamSettings>;

Defined in: state/settings.ts:842

What useStreamSettings returns.

VariablesCopy Anchor Link

RESOLUTION_PRESETSCopy Anchor Link

const RESOLUTION_PRESETS: string[];

Defined in: state/settings.ts:119

The presets the resolution menu offers.

WEBCAM_ENCODER_OPTIONSCopy Anchor Link

const WEBCAM_ENCODER_OPTIONS: string[];

Defined in: state/settings.ts:128

webcam_encoder values; labels come from displayLabel.

STREAMING_MODESCopy Anchor Link

const STREAMING_MODES: string[];

Defined in: state/settings.ts:169

The transports the mode menu offers.

FunctionsCopy Anchor Link

deriveDpi()Copy Anchor Link

function deriveDpi(manual): number;

Defined in: state/settings.ts:90

The default scaling_dpi, derived as the core derives it (lib/stream-density.js): from a manual resolution when one is set, since that framebuffer decides how large the desktop draws its UI and the local screen says nothing about it, and otherwise from the local display scaling (devicePixelRatio), so the remote desktop's fonts and UI match the local environment. A manual resolution is read off its shorter side -- an ultrawide is wide rather than dense -- and either density is snapped to the nearest option and clamped at both ends.

The ladder that governs the desktop is an operator override (which the server refuses to let clients clobber), then the stored pick, then this derived default; the cores send stored-else-derived on every connect.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

number

manualResolution()Copy Anchor Link

function manualResolution(serverSettings): object;

Defined in: state/settings.ts:105

The manual resolution in force, as the cores resolve it: a deployment that forces one and names its size wins, since the core takes the server's over the client's there; otherwise the stored pick, and zeroes for a session sized to its window.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

object

wCopy Anchor Link

w: number;

hCopy Anchor Link

h: number;

useConditionalSetting()Copy Anchor Link

function useConditionalSetting(
   spec, 
   serverSettings, 
   ctx, 
   deps, 
   read?
): readonly [any, Dispatch<any>];

Defined in: state/settings.ts:158

Drives a conditional setting: lazy init, then a re-resolve whenever the server settings or any dependency in deps changes (server sync and a dependency's re-derivation alike). The resolver honors explicit choices, so a re-resolve never clobbers a pinned value. Re-resolving writes state rather than deriving during render because the caller edits the value afterwards.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

readonly [any, Dispatch<any>]

A [value, setValue] pair.

settingsPoster()Copy Anchor Link

function settingsPoster(delay): (setting) => void;

Defined in: state/settings.ts:189

Trailing debounce of settings posts: a burst coalesces into one post carrying every setting changed in it, each at its last value, so a derived change never drops the one that caused it.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

(setting) => void

useStreamSettings()Copy Anchor Link

function useStreamSettings(): object;

Defined in: state/settings.ts:215

The stream settings' state and handlers. Server settings are seeded from the cached broadcast because the provider may mount after the core connects, and every value stays editable afterwards with localStorage taking precedence. Each conditional setting is one useConditionalSetting call over a shared spec: the hook owns init and server sync, and client-driven changes go through writeConditional.

ReturnsCopy Anchor Link

Everything the video, audio, and screen panels render from.

serverSettingsCopy Anchor Link

serverSettings: any;

renderableCopy Anchor Link

renderable: any;

isWebrtcCopy Anchor Link

isWebrtc: boolean;

showCopy Anchor Link

show: object;

show.streamModeCopy Anchor Link

streamMode: any;

show.encoderCopy Anchor Link

encoder: any = renderable.encoder;

show.webcamEncoderCopy Anchor Link

webcamEncoder: boolean;

show.fullColorCopy Anchor Link

fullColor: boolean;

show.tenBitCopy Anchor Link

tenBit: boolean;

show.framerateCopy Anchor Link

framerate: any = renderable.framerate;

show.rateControlCopy Anchor Link

rateControl: any;

show.bitrateCopy Anchor Link

bitrate: any;

show.crfCopy Anchor Link

crf: any;

show.turboCopy Anchor Link

turbo: any;

show.jpegQualityCopy Anchor Link

jpegQuality: any;

show.paintOverCopy Anchor Link

paintOver: any;

show.paintoverCrfCopy Anchor Link

paintoverCrf: any;

show.paintoverBurstCopy Anchor Link

paintoverBurst: any;

show.paintOverJpegCopy Anchor Link

paintOverJpeg: any;

show.cpuCopy Anchor Link

cpu: any;

show.cpuThreadingCopy Anchor Link

cpuThreading: any;

show.audioBitrateCopy Anchor Link

audioBitrate: any = renderable.audioBitrate;

show.hidpiCopy Anchor Link

hidpi: any;

show.forceAlignedCopy Anchor Link

forceAligned: any;

show.uiScalingCopy Anchor Link

uiScaling: any;

show.useBrowserCursorsCopy Anchor Link

useBrowserCursors: any = renderable.useBrowserCursors;

show.rawPointerMotionCopy Anchor Link

rawPointerMotion: any = renderable.rawPointerMotion;

show.macCmdAsCtrlCopy Anchor Link

macCmdAsCtrl: any = renderable.macCmdAsCtrl;

show.resolutionControlsCopy Anchor Link

resolutionControls: any;

show.videoPanelCopy Anchor Link

videoPanel: any = renderable.videoSettings;

show.audioPanelCopy Anchor Link

audioPanel: any = renderable.audioSettings;

show.screenPanelCopy Anchor Link

screenPanel: any = renderable.screenSettings;

streamModeCopy Anchor Link

streamMode: any;

setStreamModeCopy Anchor Link

setStreamMode: (mode) => Promise<void> = setStreamModeChoice;

Switches the transport (switchStreamMode); the core reloads into it.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

Promise<void>

encoderCopy Anchor Link

encoder: string;

encoderOptionsCopy Anchor Link

encoderOptions: string[] = encoderOptionsShown;

setEncoderCopy Anchor Link

setEncoder: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

webcamEncoderCopy Anchor Link

webcamEncoder: string;

webcamEncoderLockedCopy Anchor Link

webcamEncoderLocked: boolean = !!wceServer?.locked;

setWebcamEncoderCopy Anchor Link

setWebcamEncoder: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

videoFullColorCopy Anchor Link

videoFullColor: any;

toggleFullColorCopy Anchor Link

toggleFullColor: () => void;

ReturnsCopy Anchor Link

void

fullColorLockedCopy Anchor Link

fullColorLocked: boolean;

video10BitCopy Anchor Link

video10Bit: any;

toggle10BitCopy Anchor Link

toggle10Bit: () => void;

ReturnsCopy Anchor Link

void

tenBitLockedCopy Anchor Link

tenBitLocked: boolean;

framerateCopy Anchor Link

framerate: number;

framerateFollowsCopy Anchor Link

framerateFollows: boolean;

displayFramerateCopy Anchor Link

displayFramerate: number;

framerateStopsCopy Anchor Link

framerateStops: number[];

framerateIndexCopy Anchor Link

framerateIndex: number;

setFramerateIndexCopy Anchor Link

setFramerateIndex: (index) => void;

The display's own stop asks for the display's refresh wherever it moves.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

framerateFixedCopy Anchor Link

framerateFixed: boolean;

rateControlModeCopy Anchor Link

rateControlMode: any;

rateControlOptionsCopy Anchor Link

rateControlOptions: string[];

setRateControlModeCopy Anchor Link

setRateControlMode: (mode) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

videoBitRateCopy Anchor Link

videoBitRate: number;

videoBitrateChoicesCopy Anchor Link

videoBitrateChoices: number[];

The slider stops inside the server's ranges; a stored value between stops (a server default, a clamp) shows at the nearest one.

bitrateIndexCopy Anchor Link

bitrateIndex: number;

setVideoBitRateCopy Anchor Link

setVideoBitRate: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

bitrateFixedCopy Anchor Link

bitrateFixed: boolean;

videoCRFCopy Anchor Link

videoCRF: number;

videoCRFChoicesCopy Anchor Link

videoCRFChoices: number[];

crfIndexCopy Anchor Link

crfIndex: number;

setVideoCRFCopy Anchor Link

setVideoCRF: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

crfFixedCopy Anchor Link

crfFixed: boolean;

videoStreamingModeCopy Anchor Link

videoStreamingMode: any;

toggleTurboCopy Anchor Link

toggleTurbo: () => void;

ReturnsCopy Anchor Link

void

turboLockedCopy Anchor Link

turboLocked: boolean;

jpegQualityCopy Anchor Link

jpegQuality: number;

setJpegQualityCopy Anchor Link

setJpegQuality: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

jpegQualityRangeCopy Anchor Link

jpegQualityRange: object;

jpegQualityRange.minCopy Anchor Link

min: any;

jpegQualityRange.maxCopy Anchor Link

max: any;

jpegQualityFixedCopy Anchor Link

jpegQualityFixed: boolean;

usePaintOverQualityCopy Anchor Link

usePaintOverQuality: any;

togglePaintOverCopy Anchor Link

togglePaintOver: () => void;

ReturnsCopy Anchor Link

void

paintOverLockedCopy Anchor Link

paintOverLocked: boolean;

videoPaintoverCRFCopy Anchor Link

videoPaintoverCRF: number;

videoPaintoverCRFChoicesCopy Anchor Link

videoPaintoverCRFChoices: number[];

paintoverCrfIndexCopy Anchor Link

paintoverCrfIndex: number;

setVideoPaintoverCRFCopy Anchor Link

setVideoPaintoverCRF: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

paintoverCrfFixedCopy Anchor Link

paintoverCrfFixed: boolean;

videoPaintoverBurstFramesCopy Anchor Link

videoPaintoverBurstFrames: number;

setVideoPaintoverBurstFramesCopy Anchor Link

setVideoPaintoverBurstFrames: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

paintoverBurstRangeCopy Anchor Link

paintoverBurstRange: object;

paintoverBurstRange.minCopy Anchor Link

min: any;

paintoverBurstRange.maxCopy Anchor Link

max: any;

paintoverBurstFixedCopy Anchor Link

paintoverBurstFixed: boolean;

paintOverJpegQualityCopy Anchor Link

paintOverJpegQuality: number;

setPaintOverJpegQualityCopy Anchor Link

setPaintOverJpegQuality: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

paintOverJpegRangeCopy Anchor Link

paintOverJpegRange: object;

paintOverJpegRange.minCopy Anchor Link

min: any;

paintOverJpegRange.maxCopy Anchor Link

max: any;

paintOverJpegFixedCopy Anchor Link

paintOverJpegFixed: boolean;

useCpuCopy Anchor Link

useCpu: any;

toggleCpuCopy Anchor Link

toggleCpu: () => void;

ReturnsCopy Anchor Link

void

cpuLockedCopy Anchor Link

cpuLocked: boolean;

cpuEncodeThreadingCopy Anchor Link

cpuEncodeThreading: any;

toggleCpuThreadingCopy Anchor Link

toggleCpuThreading: () => void;

ReturnsCopy Anchor Link

void

cpuThreadingLockedCopy Anchor Link

cpuThreadingLocked: boolean;

audioBitRateCopy Anchor Link

audioBitRate: number;

audioBitrateChoicesCopy Anchor Link

audioBitrateChoices: number[];

setAudioBitRateCopy Anchor Link

setAudioBitRate: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

audioInputDevicesCopy Anchor Link

audioInputDevices: AudioDevice[];

audioOutputDevicesCopy Anchor Link

audioOutputDevices: AudioDevice[];

selectedInputDeviceIdCopy Anchor Link

selectedInputDeviceId: any;

selectedOutputDeviceIdCopy Anchor Link

selectedOutputDeviceId: any;

isOutputSelectionSupportedCopy Anchor Link

isOutputSelectionSupported: boolean;

audioDeviceErrorCopy Anchor Link

audioDeviceError: string;

isLoadingAudioDevicesCopy Anchor Link

isLoadingAudioDevices: boolean;

ensureAudioDevicesCopy Anchor Link

ensureAudioDevices: () => void;

Populates the audio device lists once. Enumerating labeled devices needs a getUserMedia grant, so this runs only when the audio panel is actually shown: merely opening the settings must not raise a microphone permission prompt.

Output selection is probed on the sink the active core plays through, HTMLMediaElement.setSinkId for the WebRTC core's video element and AudioContext.setSinkId for the WebSocket core, or where that is missing, as in Firefox, the media element that core then plays its context through; probing the wrong one would render a picker that does nothing.

ReturnsCopy Anchor Link

void

selectAudioDeviceCopy Anchor Link

selectAudioDevice: (context, deviceId) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

antiAliasingCopy Anchor Link

antiAliasing: boolean;

toggleAntiAliasingCopy Anchor Link

toggleAntiAliasing: () => void;

Anti-aliasing is client-only; the core persists antiAliasingEnabled itself.

ReturnsCopy Anchor Link

void

useBrowserCursorsCopy Anchor Link

useBrowserCursors: any;

toggleBrowserCursorsCopy Anchor Link

toggleBrowserCursors: () => void;

Propagates the new preference and lets the core, which owns persistence, report the effective (possibly multi-monitor-forced) value back. Derived from the displayed value: while multi-monitor forces the toggle on, the base preference may be off, and negating the base would silently persist the forced value over the user's real choice.

ReturnsCopy Anchor Link

void

rawPointerMotionCopy Anchor Link

rawPointerMotion: any;

toggleRawPointerMotionCopy Anchor Link

toggleRawPointerMotion: () => void;

ReturnsCopy Anchor Link

void

macCmdAsCtrlCopy Anchor Link

macCmdAsCtrl: any;

toggleMacCmdAsCtrlCopy Anchor Link

toggleMacCmdAsCtrl: () => void;

ReturnsCopy Anchor Link

void

hidpiEnabledCopy Anchor Link

hidpiEnabled: any;

toggleHidpiCopy Anchor Link

toggleHidpi: () => void;

An explicit toggle pins the choice; the core persists useCssScaling when it applies the message.

ReturnsCopy Anchor Link

void

hidpiDisabledReasonCopy Anchor Link

hidpiDisabledReason: string;

forceAlignedResolutionCopy Anchor Link

forceAlignedResolution: any;

toggleForceAlignedCopy Anchor Link

toggleForceAligned: () => void;

ReturnsCopy Anchor Link

void

selectedDpiCopy Anchor Link

selectedDpi: number;

dpiScalingChoicesCopy Anchor Link

dpiScalingChoices: object[];

setDpiCopy Anchor Link

setDpi: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

dpiDisabledCopy Anchor Link

dpiDisabled: boolean;

A single allowed stop, or an operator-set DPI, leaves nothing to change.

manualWidthCopy Anchor Link

manualWidth: string;

manualHeightCopy Anchor Link

manualHeight: string;

presetValueCopy Anchor Link

presetValue: string;

setManualWidthCopy Anchor Link

setManualWidth: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setManualHeightCopy Anchor Link

setManualHeight: (value) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setManualResolutionCopy Anchor Link

setManualResolution: () => void;

ReturnsCopy Anchor Link

void

choosePresetCopy Anchor Link

choosePreset: (preset) => void;

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

resetResolutionCopy Anchor Link

resetResolution: () => void;

Restores HiDPI and the UI scaling to their derived defaults on reset-to-window. Unlike the resolution-derived writes, which respect a pinned choice, a reset means "back to defaults", so the client's own pin is dropped even under an operator-explicit value: use_css_scaling overridden does not imply locked, and a kept pin would keep outranking the operator's value in the resolution ladder. Only a locked value, or for the scaling an operator override, leaves everything alone.

ReturnsCopy Anchor Link

void

scaleLocallyCopy Anchor Link

scaleLocally: boolean;

toggleScaleLocallyCopy Anchor Link

toggleScaleLocally: () => void;

The core persists scaleLocallyManual itself when it applies the message.

ReturnsCopy Anchor Link

void

writeConditional()Copy Anchor Link

function writeConditional(
   spec, 
   uiValue, 
   setValue, 
   opts?
): void;

Defined in: state/settings.ts:304

The one write path for conditional settings: optimistic setState, persistence only for an explicit choice (which pins it; a derived value keeps following), then propagation through the spec.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

toggleScaleLocally()Copy Anchor Link

function toggleScaleLocally(): void;

Defined in: state/settings.ts:570

The core persists scaleLocallyManual itself when it applies the message.

ReturnsCopy Anchor Link

void

toggleHidpi()Copy Anchor Link

function toggleHidpi(): void;

Defined in: state/settings.ts:577

An explicit toggle pins the choice; the core persists useCssScaling when it applies the message.

ReturnsCopy Anchor Link

void

setStreamModeChoice()Copy Anchor Link

function setStreamModeChoice(mode): Promise<void>;

Defined in: state/settings.ts:587

Switches the transport (switchStreamMode); the core reloads into it.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

Promise<void>

storeAndPost()Copy Anchor Link

function storeAndPost(
   key, 
   value, 
   setValue
): void;

Defined in: state/settings.ts:593

Stores a plain setting and posts it to the server.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

setFramerateIndex()Copy Anchor Link

function setFramerateIndex(index): void;

Defined in: state/settings.ts:624

The display's own stop asks for the display's refresh wherever it moves.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

deriveHidpiForResolution()Copy Anchor Link

function deriveHidpiForResolution(manual): void;

Defined in: state/settings.ts:640

Pairs the resolution mode with CSS scaling: HiDPI off when a manual or preset resolution is set, on when reset, as a derived (unpinned) write. An explicit toggle or a locked or overridden server value pins HiDPI and stops the resolution buttons from re-deriving it.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

deriveDpiForResolution()Copy Anchor Link

function deriveDpiForResolution(): void;

Defined in: state/settings.ts:651

A resolution the operator sets carries its own UI-scaling default, since the framebuffer asked for decides how large the desktop draws its UI. Not stored, so it stays a default: a stored pick, or a locked or operator-explicit server value, outranks it as it does at connect.

ReturnsCopy Anchor Link

void

applyManualResolution()Copy Anchor Link

function applyManualResolution(width, height): void;

Defined in: state/settings.ts:661

Applies a manual size: stores it, tells the core, and re-derives HiDPI and the UI scaling.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

void

resetResolution()Copy Anchor Link

function resetResolution(): void;

Defined in: state/settings.ts:699

Restores HiDPI and the UI scaling to their derived defaults on reset-to-window. Unlike the resolution-derived writes, which respect a pinned choice, a reset means "back to defaults", so the client's own pin is dropped even under an operator-explicit value: use_css_scaling overridden does not imply locked, and a kept pin would keep outranking the operator's value in the resolution ladder. Only a locked value, or for the scaling an operator override, leaves everything alone.

ReturnsCopy Anchor Link

void

toggleAntiAliasing()Copy Anchor Link

function toggleAntiAliasing(): void;

Defined in: state/settings.ts:722

Anti-aliasing is client-only; the core persists antiAliasingEnabled itself.

ReturnsCopy Anchor Link

void

framerateLabel()Copy Anchor Link

function framerateLabel(rate): number;

Defined in: ../../selkies-web-core/lib/display-refresh.js:191

A frame rate as the dashboards show it: to a hundredth, so 60000/1001 reads 59.94.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

number

displayLabel()Copy Anchor Link

function displayLabel(value): string;

Defined in: ../../selkies-web-core/lib/util.js:107

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

string

Its display label, or the value itself when it has none.

canPlayEncoder()Copy Anchor Link

function canPlayEncoder(encoder, webrtc): boolean;

Defined in: ../../selkies-web-core/lib/util.js:270

Whether this engine plays an encoder on a transport: canDecodeEncoder on WebSockets, canReceiveEncoder on WebRTC. A menu lists what it cannot play disabled and marked, so a missing option reads as the browser's limit and never as the server's.

ParametersCopy Anchor Link

ReturnsCopy Anchor Link

boolean