Skip to main content

JBrowseReactCircularGenomeViewSessionModel

Auto-generated @jbrowse/mobx-state-tree API for the current JBrowse release — see pluggable elements for concepts. View source.

The shared EmbeddedSessionMixin plus this product's tracks mixin and its single CircularView. Both are spelled out here rather than passed to a shared factory because types.compose cannot infer through a generic — see EmbeddedSessionMixin.

The tracks mixin is the session-tracks one, the same the linear embed uses. The plainer TracksManagerSessionMixin sends addTrackConf on to jbrowse.addTrackConf, which the embedded root config model does not have — so a host adding a track after mount got a TypeError, and there was no other door: this product's whole track set had to be decided at build time.

Members a composed model contributes are listed here too, so these tables are the whole surface.

Properties

MemberDescriptionDefined by
view
view: pluginManager.getViewType('CircularView').stateModel		JBrowseReactCircularGenomeViewSessionModel
id
id: ElementId		BaseSessionModel
name
name: types.string		BaseSessionModel
focusedViewId
focusedViewId: types.maybe(types.string)		used to keep track of which view is in focusBaseSessionModel
highlights
highlights: types.stripDefault(
        types.array(types.frozen<HighlightType>()),
        [],
      )
translucent bands over genomic regions; every view draws the ones on its own assembliesBaseSessionModel
highlightsVisible
highlightsVisible: types.stripDefault(types.boolean, true)		BaseSessionModel
heldForMissingPlugins
heldForMissingPlugins: types.stripDefault(
        types.frozen<HeldNode[] | undefined>(),
        undefined,
      )
views, tracks, displays and widgets pruneUnbuildableNodes took out of the tree because this build has no plugin for their type, each with the anchor that puts it back. Nothing in the session reads its contents, and pruneUnbuildableNodes defines their structure.

It is a declared property because MST drops undeclared snapshot keys without error. Without this declaration the held nodes survive the prune and are then discarded when setSession builds the tree, while every unit test of the prune still passes. heldNodesSurviveTheSession.test.ts tests that they survive.		BaseSessionModel
drawerPosition
drawerPosition: types.optional(
        types.enumeration<DrawerPosition>('DrawerPosition', [
          ...drawerPositions,
        ]),
        storedDrawerPosition,
      )
DrawerWidgetSessionMixin
drawerWidth
drawerWidth: types.stripDefault(
        types.refinement(types.integer, width => width >= minDrawerWidth),
        384,
      )
DrawerWidgetSessionMixin
widgets
widgets: types.stripDefault(types.map(widgetStateModelType), {})		DrawerWidgetSessionMixin
activeWidgets
activeWidgets: types.stripDefault(
        types.map(types.safeReference(widgetStateModelType)),
        {},
      )
DrawerWidgetSessionMixin
minimized
minimized: types.stripDefault(types.boolean, false)		DrawerWidgetSessionMixin
connectionInstances
connectionInstances: types.stripDefault(
        types.array(pluginManager.pluggableMstType('connection', 'stateModel')),
        [],
      )
ConnectionManagementSessionMixin
connectionTrackConfigs
connectionTrackConfigs: types.stripDefault(
        types.frozen<Record<string, ConnectionTrackConfigEntry>>(),
        {},
      )
Persisted configs of connection tracks the user has opened, keyed by trackId. Unlike connectionInstances (stripped from snapshots, holds the whole fetched hub), this holds only the tracks in use, so an open connection track resolves synchronously on session load without re-establishing the connection.ConnectionManagementSessionMixin
sessionTracks
sessionTracks: types.stripDefault(
        types.array(pluginManager.pluggableConfigSchemaType('track')),
        [],
      )
Tracks the session added, each entry the base its edits (trackConfigDeltas) diff against, as a config.json entry is for a config track.SessionTracksManagerSessionMixin
trackConfigDeltas
trackConfigDeltas: types.stripDefault(
        types.frozen<Record<string, PlainTrackConfig>>(),
        {},
      )
Per-track config overrides, keyed by trackId, stored as a delta against the base config (the sessionTracks or jbrowse.tracks entry) rather than a full copy — so a later change to an untouched field of the base still flows through (see trackConfigDelta.ts). A null member resets a slot the base sets. An admin's edits land here too, and reach jbrowse.tracks only through promoteTrackConfigDeltas. Frozen (not a typed track array) on purpose: a typed create() would fill defaults, erasing the "unset vs default" distinction the delta merge relies on.

stripDefault for the reason every other persisted prop beside it has it: without it the empty map is written into every snapshot and every share link, so a session that never overrode a track still ships "trackConfigDeltas":{}. It was the one prop added since that convention without it.		SessionTracksManagerSessionMixin

Volatiles

MemberDescriptionDefined by
selection
selection: undefined as unknown		this is the globally "selected" object. can be anything. code that wants to deal with this should examine it to see what kind of thing it is.BaseSessionModel
hovered
hovered: undefined as unknown		this is the globally "hovered" object. can be anything. code that wants to deal with this should examine it to see what kind of thing it is.BaseSessionModel
queueOfDialogs
queueOfDialogs: [] as [DialogComponentType, Record<string, unknown>][]
BaseSessionModel
preferencesOverrides
preferencesOverrides: observable.map<string, unknown>(undefined, {
        deep: false,
      })
runtime user-preference overrides keyed by preference id, resolved by getPreference against the configuration.preferences admin defaults. Empty here (config-only); products that let users edit preferences load and persist these via localStorage. A runtime override map layered over config defaults, kept off the snapshot since prefs are local UI.

An observable.map (not a plain object reassigned wholesale) so each preference is its own tracked key: writing one (setScrollZoom) can't invalidate a reader of another. A single spread-replaced object made every setter wake every reader, so toggling scroll-to-zoom re-fetched every track.

deep: false keeps an object-valued preference a plain object rather than a MobX Proxy, which V8's structured-clone serializer rejects. The map still notifies per key on set, so shallow values lose no reactivity — and nothing can mutate a preference in place, because setPreferenceOverride freezes what it stores.		BaseSessionModel
snackbarMessages
snackbarMessages: observable.array<SnackbarMessage>()		SnackbarModel
errorDialog
errorDialog: undefined as ErrorDialogState | undefined		the error currently shown in the stack-trace dialog. Kept off the dialog queue so it can stack on top of an already-open dialog (e.g. the one whose action raised the error) instead of waiting behind itSnackbarModel
poppedOut
poppedOut: false		true while the visible widget is shown in a modal dialog instead of the drawer. Volatile because a restored session that opened straight into a modal, with no drawer behind it, is disorientingDrawerWidgetSessionMixin
modalWidgets
modalWidgets: false		set by a host with no room for a drawer column beside its views (a phone), so every widget shows in a modal insteadDrawerWidgetSessionMixin
sessionThemeMode
sessionThemeMode: undefined as PaletteMode | undefined		EmbeddedSessionThemeMixin
editableTrackConfigs
editableTrackConfigs: new Map<string, EditableTrackConfig>()		Per-track private working copies, keyed by trackId. A plain Map — not observable, not persisted — mirroring the pluginManager hydration cache: it holds the live MST config node a shown track's in-place quick-edits mutate, so the shared frozen base is never touched. See ADR-032.

Not evicted: it's a pure memoization cache, bounded by the count of distinct tracks shown this session (each entry a lazily-hydrated config node), holding no authoritative state — the persisted delta is the source of truth, and reset/programmatic edits keep a retained copy in sync. Retention is volatile RAM only (never serialized), so it's not worth a reference-counted prune at every track-removal path.

Each entry carries the resolved config it mirrors, so a delta or base replaced from outside this mixin invalidates it — see getEditableTrackConfig.		SessionTracksManagerSessionMixin

Getters

MemberDescriptionDefined by
views
(ModelInstanceTypeProps<_OverrideProps<_OverrideProps<_OverrideProps<Omit<Omit<…>, never>, _OverrideProps<...>>, { ...; }>, { ...; }>> & ... 29 more ... & IStateTreeNode<...>)[]
JBrowseReactCircularGenomeViewSessionModel
viewTitleBars
boolean		An embedded view is drawn with no title bar above it, so its menu lives in the view's own controls.EmbeddedSessionMixin
version
string		EmbeddedSessionMixin
assemblyNames
string[]		EmbeddedSessionMixin
assemblyManager
ModelInstanceTypeProps<…> & {…} & {…} & {…} & {…} & {…} & {…} & IStateTreeNode<…>
EmbeddedSessionMixin
root
TypeOrStateTreeNodeToStateTreeNode<ROOT_MODEL_TYPE>		BaseSessionModel
jbrowse
any		BaseSessionModel
rpcManager
RpcManager		BaseSessionModel
configuration
Instance<JB_CONFIG_SCHEMA>		BaseSessionModel
adminMode
boolean		BaseSessionModel
textSearchManager
TextSearchManager		BaseSessionModel
assemblies
(ConfigNodeProps<…> & ConfigNodeActions & ConfigNodeBrand<...>)[]
BaseSessionModel
DialogComponent
DialogComponentType		BaseSessionModel
DialogProps
Record<string, unknown>		BaseSessionModel
animationMode
AnimationMode		resolved feature-layout animation mode (never undefined)BaseSessionModel
scrollZoom
boolean		resolved scroll-to-zoom preference. Global and personal (never shared in a session snapshot); every wheel-zoom view reads this single value.BaseSessionModel
numberGrouping
boolean		resolved thousand-separator preference. Read for display in the Preferences dialog; the formatter itself reads a plain module variable set at startup in each realm (see setNumberGrouping), because worker- built strings can't see a main-thread observable.BaseSessionModel
snackbarMessageSet
Map<string, SnackbarMessage>		SnackbarModel
visibleWidget
Widget | undefined		DrawerWidgetSessionMixin
drawerVisible
boolean		whether the drawer column is on screen: there is something to show, it is not minimized to the FAB, and it is not currently a modal instead.

A getter rather than each host's own &&, because the hosts drifted -- the app shell tested poppedOut and the embedded view did not, so the day a popout button reaches the embedded drawer header it would render the modal and the drawer at once.		DrawerWidgetSessionMixin
modalWidgetVisible
boolean		whether the visible widget shows in a modal: popped out of the drawer, or on a host with no room for oneDrawerWidgetSessionMixin
connections
(ConfigNodeProps<…> & ConfigNodeActions & ConfigNodeBrand<...>)[]
ConnectionManagementSessionMixin
themeOptions
SerializableThemeArgs		Serializable theme description (the canonical themeOptions contract shared with the app-core/web sessions). This is what crosses the RPC worker boundary — e.g. the canvas display reads getSession(self).themeOptions in its rpcProps so worker-baked colors (CDS frames, stroke fallback) honor the config theme slot.EmbeddedSessionThemeMixin
palette
JBrowsePalette		Every color JBrowse renders, resolved to plain strings and free of any UI toolkit. This is what rendering reads. See the canonical ThemeManagerSessionMixin getter of the same name.EmbeddedSessionThemeMixin
styleTheme
JBrowseStyleTheme		The palette plus the sizing tokens makeStyles reads. See the canonical ThemeManagerSessionMixin getter of the same name.EmbeddedSessionThemeMixin
theme
Theme		Resolved MUI theme, mirroring the product's ThemeProvider. Lets headless/RPC consumers derive theme-dependent state without a mounted component. Shares its colors with palette by construction.EmbeddedSessionThemeMixin
trackBasesById
Map<string, AnyConfigurationModel>		Each track's base by trackId: its sessionTracks entry, else its config.json entry. Rebuilt when either list changes, never on an edit.SessionTracksManagerSessionMixin
tracks
AnyConfigurationModel[]		Session tracks first, then the config tracks, each with its edits. An edit copies the list of bases and lays each delta at its track's position, so past that copy it costs the count of edited tracks.SessionTracksManagerSessionMixin
promotableTrackIds
string[]		The edited tracks promoteTrackConfigDeltas can write: those whose base is a config.json entry. A session track's delta has no file to go to.SessionTracksManagerSessionMixin

Methods

MemberDescriptionDefined by
getPreferenceDefault
(key: string) => unknown		the admin/embedder configuration.preferences value for a key, ignoring any runtime override — i.e. what a reset falls back to. Exposed rather than inlined because "differs from the default" is a question the Preferences reset diff asks about settings this map doesn't hold (see defaultUseWorkspaces).BaseSessionModel
getPreference
(key: string) => unknown		resolved value of a user preference: a runtime override if the user set one, otherwise the admin/embedder configuration.preferences default. The override map is empty unless the product loads it (web/desktop).BaseSessionModel
getPreferenceChanges
() => TrackConfigChange[]		every scalar preference override that currently differs from its config/admin default, as { path, from, to } rows whose path is the override's own key. A scalar pref (animationMode, scrollZoom) whose override equals the default is omitted, since reverting it is a no-op.BaseSessionModel
getReferringMultiple
(trackIds: string[]) => Map<string, ReferringNode[]>		Walk the tree once and map each requested trackId to the nodes holding a types.reference that resolves to it (a view's track entry, a config editor widget). Track configs are matched by trackId, not identity, so a frozen base and its hydrated MST node compare equal.ReferenceManagementSessionMixin
getReferring
(trackId: string) => ReferringNode[]		The nodes currently referring to trackId (see getReferringMultiple).ReferenceManagementSessionMixin
getTrackListMenuItems
(config: AnyConfigurationModel, view?: TrackActionView | undefined) => MenuItem[]
flattened menu items for use in hierarchical track selectorTrackMenuSessionMixin
getTrackActionMenuItems
({ config, view, }: { config: AnyConfigurationModel; view?: TrackActionView | undefined; }) => MenuItem[]
TrackMenuSessionMixin
getActiveThemeOptions
(_name?: string | undefined) => ThemeOptions | undefined		Raw ThemeOptions for the active theme, which every view's SVG export threads into each display's renderSvg as a configTheme and rebuilds outside React. The config slot is the whole answer here because it is the whole of an embedded product's theming: no picker, no allThemes, and it is what setThemeMode writes and palette resolves from. name is accepted and ignored — the app session's counterpart looks a named preset up in allThemes().EmbeddedSessionThemeMixin
withTrackEdits
(base: AnyConfigurationModel) => AnyConfigurationModel		base with its delta (trackConfigDeltas) merged over it, or base itself by identity when it has none, which keeps the hydration cache warm.SessionTracksManagerSessionMixin
baseTrackConfig
(trackId: string) => PlainTrackConfig | undefined		The entry trackId edits over, hydrated: the one the session added it with, or its config.json entry. What a display's "is this arranged" and "reset" compare its live config against. Per-id reactive, like getTrackById.SessionTracksManagerSessionMixin
getEditableTrackConfig
(trackId: string, schemaType: IAnyType) => AnyConfigurationModel | undefined
The config node trackId resolves to: a live node as it stands, otherwise a private working copy of its current frozen (base+delta) config, so a shown track's in-place quick-edits (setSlot) mutate this copy and never the shared frozen base (see ADR-032). Called by TrackConfigurationReference during lazy hydration.

Cached against the resolved config it was built from, not by trackId alone. A write this mixin makes re-stamps the entry, so the copy an edit is still being typed into is never swapped out mid-keystroke; a delta or base replaced from outside — an undo's applySnapshot on the session, a session restore, a session track deleted and added again under its id — cannot, so the next read rebuilds the copy from what now resolves. Per-id reactive on the node rather than the config, so a display reading its config does not recompute when its own working copy is persisted. Per schema type as well, since an id re-added under another track type resolves through that type's reference.		SessionTracksManagerSessionMixin
getTrackConfigChanges
(trackId: string) => TrackConfigChange[]		The overridden slots for trackId (empty when it has no delta): each changed setting's path, its base/default value and the edited value. Drives the "view changes" dialog opened from the edited badge.SessionTracksManagerSessionMixin
isTrackOverride
(trackId: string) => boolean		Whether trackId carries an edit over its base config, which drives the "Reset track settings" item and the edited badge. Changed slots, not mere presence in trackConfigDeltas: a delta can hold only content-free display stubs, which must not read as an override.SessionTracksManagerSessionMixin
getTrackById
(id: string) => AnyConfigurationModel | undefined		Config for one trackId — a track, assembly sequence, or connection track — or undefined. Per-id reactive: every display resolves its config through this (via TrackConfigurationReference) and subscribes only to its own id, so one track's settings edit doesn't re-render the others.TracksManagerSessionMixin
getTracksById
() => Record<string, AnyConfigurationModel>		Every track config the session can resolve, keyed by trackId. Prefer the per-id reactive getTrackById(id): this map is rebuilt over every track on the first read after any edit, and reading it subscribes the caller to all of them. Kept for plugins that look up ids in a non-reactive context.TracksManagerSessionMixin

Actions

MemberDescriptionDefined by
addView
<…>(typeName: N, initialState?: NoInfer<…> | undefined) => ModelInstanceTypeProps<…> & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & IStateTreeNode<…>
replaces view in this caseJBrowseReactCircularGenomeViewSessionModel
removeView
() => void		does nothingJBrowseReactCircularGenomeViewSessionModel
launchView
(typeName: string, initialState?: any) => Promise<…>		addView, async to satisfy the AbstractViewContainer contractJBrowseReactCircularGenomeViewSessionModel
setSelection
(thing: unknown) => void		set the global selection, i.e. the globally-selected object. can be a feature, a view, just about anything

A feature is unwrapped on the way in, so app state never holds a jexlFeatureProxy. isFeature accepts a proxy, but on one id is a data field rather than the method the Feature type promises — every consumer doing isFeature(selection) ? selection.id() : … would throw.		BaseSessionModel
clearSelection
() => void		clears the global selectionBaseSessionModel
setHovered
(thing: unknown) => void		BaseSessionModel
setHighlightsVisible
(arg: boolean) => void		BaseSessionModel
addHighlight
(highlight: HighlightType) => void		an identical entry is not added twice, so a spec launched again does not stack its bands. Adding shows the bands again, since a highlight made while they are off would otherwise read as nothing happeningBaseSessionModel
removeHighlight
(highlight: HighlightType) => void		BaseSessionModel
updateHighlight
(old: HighlightType, updates: Partial<HighlightType>) => void		BaseSessionModel
setHighlights
(highlights: HighlightType[]) => void		BaseSessionModel
setPreferenceOverride
(key: string, value: unknown) => void		set a runtime user-preference override (see getPreference). Mutates volatile state; products persist these to localStorage. An undefined value deletes the key (rather than leaving a phantom entry that getPreference reads as absent) so the store never holds dead keys.BaseSessionModel
clearPreferenceOverrides
() => void		clear every runtime preference override at once, so each falls back to its config/admin default. Backs the Preferences dialog "Reset to defaults" button.BaseSessionModel
clearPreferenceOverride
(key: string) => void		clear a single runtime preference override (see getPreference) so it falls back to its config/admin default. Backs the per-entry reset in the Preferences dialog "Reset to defaults" confirmation.BaseSessionModel
setScrollZoom
(flag: boolean) => void		set the global scroll-to-zoom preference (see the scrollZoom getter)BaseSessionModel
setName
(str: string) => void		BaseSessionModel
setFocusedViewId
(viewId: string | undefined) => void		undefined is "no view is focused", which the property has always been able to hold (types.maybe) and this had no way to spell. Nothing cleared it on teardown as a result: a view that was focused when it left the session left its id behind, and since every consumer compares focusedViewId === view.id, the id matched nothing, the focus ring vanished with nothing to say why, and the dead id persisted into a saved or shared session. takeOut clears it now.BaseSessionModel
removeActiveDialog
() => void		BaseSessionModel
queueDialog
(doneCallback: DoneCallback) => void		BaseSessionModel
removeDialog
(entry: [DialogComponentType, Record<string, unknown>]) => void		BaseSessionModel
notify
(message: string, level?: NotificationLevel | undefined, action?: SnackAction | SnackAction[] | undefined) => void
SnackbarModel
notifyError
(errorMessage: string, error?: unknown, extra?: unknown, action?: SnackAction | undefined) => void
SnackbarModel
setErrorDialog
(state: ErrorDialogState | undefined) => void		SnackbarModel
pushSnackbarMessage
(message: string, level?: NotificationLevel | undefined, actions?: SnackAction[] | undefined) => void
SnackbarModel
popSnackbarMessage
() => SnackbarMessage | undefined		SnackbarModel
removeSnackbarMessage
(message: string) => void		SnackbarModel
setDrawerPosition
(arg: DrawerPosition) => void		DrawerWidgetSessionMixin
updateDrawerWidth
(drawerWidth: number, availableWidth?: number) => number		DrawerWidgetSessionMixin
resizeDrawer
(distance: number, availableWidth?: number) => number		DrawerWidgetSessionMixin
addWidget
(typeName: string, id: string, initialState?: any, conf?: unknown) => any
DrawerWidgetSessionMixin
showWidget
(widget: any) => void		DrawerWidgetSessionMixin
hideWidget
(widget: any) => void		DrawerWidgetSessionMixin
minimizeWidgetDrawer
() => void		DrawerWidgetSessionMixin
showWidgetDrawer
() => void		DrawerWidgetSessionMixin
popoutWidget
() => void		show the visible widget in a modal dialog, freeing the drawer columnDrawerWidgetSessionMixin
returnWidgetToDrawer
() => void		DrawerWidgetSessionMixin
setModalWidgets
(flag: boolean) => void		DrawerWidgetSessionMixin
hideAllWidgets
() => void		DrawerWidgetSessionMixin
closeModalWidget
() => void		the modal's close button: a popped-out widget goes back to the drawer, and with no drawer to go back to the widget closesDrawerWidgetSessionMixin
openWidget
(typeName: string, id: string, initialState?: any, conf?: unknown) => any
adds the widget, replacing one with the same id, and shows itDrawerWidgetSessionMixin
editConfiguration
(configuration: AnyConfigurationModel | { trackId: string; }, opts?: { expandedDisplayId?: string | undefined; } | undefined) => void
opens a configuration editor to configure the given thing, and sets the current task to be configuring itDrawerWidgetSessionMixin
makeConnection
(configuration: AnyConfigurationModel, initialSnapshot?: object) => any
ConnectionManagementSessionMixin
breakConnection
(configuration: AnyConfigurationModel) => void		Remove a live connection instance. Tolerant of an already-dormant connection (its instance is stripped from the session on reload). Leaves persisted open-track configs alone — the connect() error path calls this and the user's already-open tracks must survive a transient failure. Full removal goes through deleteConnection.ConnectionManagementSessionMixin
teardownConnection
(configuration: AnyConfigurationModel) => void		Close every track a connection contributed — the live instance's tracks plus any persisted open-track configs (a dormant connection, never expanded this session, still renders its opened tracks from connectionTrackConfigs) — from all views/widgets, drop the live instance, and drop the persisted configs. The session is left as if the connection had never loaded.ConnectionManagementSessionMixin
deleteConnection
(configuration: AnyConfigurationModel) => any		Fully remove a connection: tear down its tracks and live instance, then delete its config.ConnectionManagementSessionMixin
addConnectionConf
(connectionConf: AnyConfiguration) => any		Adds to the config, not the session: jbrowse.connections, which every visitor to this instance loads. jbrowse-web overrides this so a non-admin's connection lands in sessionConnections instead — see WebSessionConnectionsMixin, whose addSessionConnectionConf is what to call when you mean the session specifically rather than "wherever this user's edits go".

Applications without that override (Desktop, the embedded products) have only this one destination, and it is the right one there: their config and session are saved as a single document.		ConnectionManagementSessionMixin
clearConnections
() => void		ConnectionManagementSessionMixin
captureConnectionTrack
(trackId: string) => void		Snapshot a just-opened connection track's config into connectionTrackConfigs so it survives session reload. No-op if the track isn't connection-provided or is already captured (edits go through updateConnectionTrackConfig).ConnectionManagementSessionMixin
updateConnectionTrackConfig
(trackConf: Record<string, unknown> & { trackId: string; }) => void
Persist an edit to an opened connection track. The full config is stored (not a delta): the connection's fetched "base" isn't present at load, so only a complete config resolves synchronously.ConnectionManagementSessionMixin
setConnectionTrackConfig
(trackId: string, connectionId: string, config: Record<string, unknown>) => void
Upsert one opened connection track's persisted config.ConnectionManagementSessionMixin
pruneConnectionTrackConfig
(trackId: string) => void		Drop a connection track's persisted config once no open view still references it, so the session doesn't accumulate closed tracks.ConnectionManagementSessionMixin
hydrateConnection
(connectionId: string) => void		Lazily establish a single connection by id if it isn't already live; the track selector calls it when the connection's category is expanded. Fetches without launching a view or showing a success snackbar; already-open tracks keep rendering from connectionTrackConfigs meanwhile. Idempotent.ConnectionManagementSessionMixin
dereferenceTrack
(trackId: string, referring: ReferringNode[]) => void		Remove trackId from every view referring to it and close any config editor widget open on it. Runs immediately: the walk that produced referring has finished, so mutating those views here is safe.ReferenceManagementSessionMixin
setThemeMode
(mode: PaletteMode) => void		Switch the session to light or dark, leaving the host's configured colours alone. themeOptions carries the mode to the renderer, so labels drawn in the worker follow it, and palette is derived from the same args, so React-drawn elements follow it too. An embedder who sets only a React-side palette leaves the worker-drawn labels in the old mode.

This used to write palette.mode into the config theme slot, which meant merging at two levels to avoid discarding the brand the host had passed to createViewState. Mode is its own axis now, so there is nothing to merge and nothing to discard.		EmbeddedSessionThemeMixin
addSessionTrackConf
(trackConf: AnyConfiguration) => AnyConfigurationModel | undefined
Add a track config to this session: it lands in sessionTracks, travels with the session when it is saved or shared, and never reaches the config.json the server hands every visitor.

The default destination. Everything that is not an Add-track workflow wants this one, whoever is looking — a session spec's sessionTracks, a URL's &sessionTracks=, and every track a feature stands up on the user's behalf. Mirrors addSessionConnectionConf in the connections mixins.

Returns the entry, which is the track's base: edit the track through updateTrackConfiguration or a display's setConf, not the entry.		SessionTracksManagerSessionMixin
publishTrackConf
(trackConf: AnyConfiguration) => any		Publish a track config to the shared catalog if this user can, and fall back to their session if they cannot: an admin's goes to jbrowse.tracks, which the admin server writes back into the config.json every visitor is served; everyone else's goes to sessionTracks.

Call it only from the "Add track" workflows, where an admin adding a track means to add it for the whole site. For a track a feature creates on the user's behalf (a search result, a computed consensus, a reconstruction's segment labels), one admin click on this publishes it to every visitor, and each later click publishes another copy, because the per-launch trackId prevents deduplication. Use addSessionTrackConf above for those.

An admin's track still goes to the session when it names an assembly the config.json does not carry: a session spec's assembly, a MAF sample's genome, or a comparative view's synthesized pair. The Add-track widget takes its assembly from the containing view, so an admin adding a track in such a view passes a name no visitor can resolve. Publishing it would write an entry the server sends to every visitor and no visitor can draw. Adding it to the session keeps the track usable and writes no dangling entry; a snackbar names the assembly that caused the fallback.

The snackbar names the assembly and not the track, so a batch produces one message: pushSnackbarMessage dedupes on the exact text, and BulkAddTracksWorkflow publishes in a loop. Including the track name would show one snackbar per file to an admin adding thirty. The assembly is all the admin needs to act on.		SessionTracksManagerSessionMixin
addTrackConf
(trackConf: AnyConfiguration) => AnyConfigurationModel | undefined
Deprecated alias of addSessionTrackConf. Call that, or publishTrackConf.SessionTracksManagerSessionMixin
updateTrackConfiguration
(trackConf: PlainTrackConfig) => void		Persist an edited track config as a delta (trackConfigDeltas) against its base, the sessionTracks or config.json entry — only the changed slots — so the edits persist, are shared, undo and reset, while changes to untouched fields of the base still flow through. An admin's edit is a delta like anyone's: it reaches the config.json the server hands every visitor only through promoteTrackConfigDeltas. An opened connection track defers to the base mixin, which routes it to connectionTrackConfigs.SessionTracksManagerSessionMixin
promoteTrackConfigDeltas
(trackId?: string | undefined) => void		Write this session's track edits into the base configs — the config.json an admin server hands every visitor — and drop the deltas they were held in. One track's, or every track's when trackId is omitted, of promotableTrackIds: a session track's edits stay in the session. An admin's alone: anyone else's base is the in-memory copy of a file they cannot write.SessionTracksManagerSessionMixin
resetTrackConfiguration
(trackId: string) => void		Drop a track's delta (trackConfigDeltas) so it reverts to its base, the sessionTracks or jbrowse.tracks entry. Unlike deleteTrackConf this does not dereference the track from open views — the base config re-resolves in place, so an open track stays open and simply reverts.SessionTracksManagerSessionMixin
deleteTrackConf
(trackConf: AnyConfigurationModel) => (PluggableConfigNode & IStateTreeNode<PluggableConfigSchemaType>)[] | undefined
SessionTracksManagerSessionMixin