@jbrowse/core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/util/thresholdScale.js

@@ -0,0 +1,112 @@
+import { categoricalPalette } from '../ui/colors.js';
+import { NO_VALUE_LABEL } from './categoricalField.js';
+import { MISCONFIGURED_COLOR, NO_CATEGORY_COLOR } from './color/index.js';
+import { groupKeyComparator, valueText } from './groupKeys.js';
+import { numericValue } from './numericValue.js';
+/**
+ * #api
+ * A domain written as strings — the shared `domain` slot is a `stringArray` —
+ * read back as the numbers it names. A member that is not a number reads NaN,
+ * which every comparison against it declines.
+ */
+export function numericDomain(domain) {
+    return domain.map(Number);
+}
+/**
+ * #api
+ * A threshold scale's cut points as {@link thresholdIndex} walks them: the
+ * numbers the domain names, ascending. Cuts written high to low, as p-value
+ * thresholds often are, left the middle interval unreachable, the walk stopping
+ * at the first cut a value is under.
+ */
+export function thresholdCuts(domain) {
+    return numericDomain(domain)
+        .filter(cut => Number.isFinite(cut))
+        .sort((a, b) => a - b);
+}
+/**
+ * #api
+ * The bin a value falls in: how many of the ascending cut points it is at or
+ * past, so a palette with one more entry than the domain paints it as
+ * `palette[thresholdIndex(value, domain)]`. A value that is not a finite
+ * number is in no bin and answers -1.
+ */
+export function thresholdIndex(value, domain) {
+    const v = numericValue(value);
+    if (!Number.isFinite(v)) {
+        return -1;
+    }
+    let i = 0;
+    while (i < domain.length && v >= domain[i]) {
+        i++;
+    }
+    return i;
+}
+/**
+ * #api
+ * The colour of each interval, in order: the declared palette, and the
+ * default categorical palette where it runs out.
+ */
+export function thresholdPalette(bins, palette = []) {
+    return Array.from({ length: bins }, (_, i) => palette[i] ?? categoricalPalette[i % categoricalPalette.length]);
+}
+/**
+ * #api
+ * What a threshold scale's bins are called in a key, one label per palette
+ * entry: `< a` below the first cut, `a – b` between two, `≥ b` past the last.
+ */
+export function thresholdLabels(domain) {
+    if (domain.length === 0) {
+        return ['any value'];
+    }
+    return [
+        `< ${domain[0]}`,
+        ...domain.slice(1).map((cut, i) => `${domain[i]} – ${cut}`),
+        `≥ ${domain.at(-1)}`,
+    ];
+}
+/**
+ * #api
+ * The key a value holding text that is no number files under on a threshold
+ * scale, painted the misconfiguration grey rather than passing for a missing
+ * value.
+ */
+export const NOT_A_NUMBER_LABEL = '(not a number)';
+// A VCF's `AF=.` arrives as `[undefined]`, which is no value rather than text
+// that fails to parse.
+function isMissing(value) {
+    return Array.isArray(value)
+        ? value.every(v => v === undefined || v === null)
+        : valueText(value) === '';
+}
+/**
+ * #api
+ * A threshold scale read the way every categorical channel reads its field: a
+ * value files under the label of the bin it falls in, a feature with no value
+ * under `''`, and text that is no number under {@link NOT_A_NUMBER_LABEL}.
+ * The bins are the whole domain, so a key lists each one.
+ */
+export function thresholdField(field, { domain = [], range = [], } = {}) {
+    const cuts = thresholdCuts(domain);
+    const labels = thresholdLabels(cuts);
+    const palette = thresholdPalette(labels.length, range);
+    const colorOf = new Map(labels.map((label, i) => [label, palette[i]]));
+    return {
+        field,
+        domain: labels,
+        closed: true,
+        key: value => {
+            if (isMissing(value)) {
+                return '';
+            }
+            const bin = thresholdIndex(value, cuts);
+            return bin < 0 ? NOT_A_NUMBER_LABEL : labels[bin];
+        },
+        compare: groupKeyComparator([...labels, NOT_A_NUMBER_LABEL]),
+        label: key => (key === '' ? NO_VALUE_LABEL : key),
+        sectionLabel: key => `${field}: ${key === '' ? 'none' : key}`,
+        color: key => key === ''
+            ? NO_CATEGORY_COLOR
+            : (colorOf.get(key) ?? MISCONFIGURED_COLOR),
+    };
+}

package/esm/util/timeGate.d.ts

@@ -5,8 +5,8 @@
  *
  * `Date.now()` costs ~40ns, invisible until the loop is a 666k-read pileup —
  * there it measured ~28ms per gated callsite, and the alignments worker has two
- * of them (the progress emit in `createProgressReporter` and the stop-token
- * check in `checkStopTokenThrottled`). Both previously read the clock per call, on the
+ * of them (the progress emit in `createProgressReporter` and the yield in
+ * `createAbortBreakpoint`). Both previously read the clock per call, on the
  * documented reasoning that it was negligible next to the per-item work; at
  * this item count it measurably isn't.
  *
@@ -18,9 +18,8 @@
  * measure a low rate and hold a stride of 1, gating on time alone as before,
  * while a millions-of-calls loop thins itself out.
  *
- * `intervalMs` is per call rather than fixed at construction: it was added for
- * `checkStopTokenThrottled`, whose (since-deleted) sync-XHR probe backed off
- * linearly over a long loop. Both current callers pass a constant.
+ * `intervalMs` is per call rather than fixed at construction; both current
+ * callers pass a constant.
  */
 export declare function createTimeGate(): (intervalMs: number) => boolean;
 export type TimeGate = ReturnType<typeof createTimeGate>;

package/esm/util/timeGate.js

@@ -24,8 +24,8 @@ const STRIDE_GROWTH_LIMIT = 8;
  *
  * `Date.now()` costs ~40ns, invisible until the loop is a 666k-read pileup —
  * there it measured ~28ms per gated callsite, and the alignments worker has two
- * of them (the progress emit in `createProgressReporter` and the stop-token
- * check in `checkStopTokenThrottled`). Both previously read the clock per call, on the
+ * of them (the progress emit in `createProgressReporter` and the yield in
+ * `createAbortBreakpoint`). Both previously read the clock per call, on the
  * documented reasoning that it was negligible next to the per-item work; at
  * this item count it measurably isn't.
  *
@@ -37,9 +37,8 @@ const STRIDE_GROWTH_LIMIT = 8;
  * measure a low rate and hold a stride of 1, gating on time alone as before,
  * while a millions-of-calls loop thins itself out.
  *
- * `intervalMs` is per call rather than fixed at construction: it was added for
- * `checkStopTokenThrottled`, whose (since-deleted) sync-XHR probe backed off
- * linearly over a long loop. Both current callers pass a constant.
+ * `intervalMs` is per call rather than fixed at construction; both current
+ * callers pass a constant.
  */
 export function createTimeGate() {
     let stride = 1;

package/esm/util/trackConfigDelta.d.ts

@@ -12,18 +12,18 @@
  *   - `diffTrackConfig(base, edited)` — the minimal delta
  *   - `mergeTrackConfig(base, delta)` — reconstruct the effective config
  *
- * Deliberate limitation (no tombstones): a delta records adds/changes only, not
- * deletions. If a user *resets* a slot the admin had customized (base has it,
- * edited omits it), the delta can't express "drop below the admin value", so the
- * field keeps following the base across a reload. This keeps the merge trivial
- * and the shared JSON free of deletion sentinels, and following the admin value
- * is a defensible outcome.
- *
- * What it is NOT free to conflate is a removal with a reset. Both diff to an
- * empty delta, and `SessionTracks.updateTrackConfiguration` used to read that as
- * "the edit netted back to the base" and revert the track's working copy — which
- * undid a removal on screen 400ms after it landed. That branch now keeps the
- * working copy; see the comment there.
+ * A delta is a JSON Merge Patch (RFC 7396) over the base, so a `null` member is
+ * a reset: the merge removes the member and the schema's default applies. That
+ * is ADR-146's spelling of a reset, and the diff writes one wherever the base
+ * sets a member the edited config lacks — a slot put back to its default, or a
+ * list emptied, since `stripDefault` drops both from a snapshot. Where the edit
+ * left a whole namespace at its default, the nulls land on the members the base
+ * set inside it rather than on the namespace, so a member the admin adds there
+ * later still flows through. The inference
+ * is exact only because both sides are post-`stripDefault` snapshots: a member
+ * the admin wrote at its default is absent from both, where a `null` for it
+ * would block a later admin value. As in RFC 7396, a delta cannot set a member
+ * to a literal `null`; null and absent are one state.
  *
  * `displays` is merged by `displayId` so an edit to one display doesn't pin the
  * others. Nested config objects (e.g. `adapter`) recurse. Any other array (value
@@ -42,18 +42,22 @@ type Json = string | number | boolean | null | undefined | Json[] | {
     [key: string]: Json;
 };
 /**
- * Minimal delta of `edited` against `base`. Both are plain config snapshots
- * (post-stripDefault). Records adds/changes only; see the module note on the
- * no-tombstone limitation. Always retains `trackId` so the delta is
- * self-identifying.
+ * Minimal delta of `edited` against `base`, both post-stripDefault snapshots. A
+ * member `base` sets and `edited` lacks is a `null` (see the module note).
+ * Always retains `trackId` so the delta is self-identifying.
  */
 export declare function diffTrackConfig(base: Record<string, unknown>, edited: Record<string, unknown>): Record<string, unknown>;
 /**
  * Reconstruct the effective config by layering `delta` over the live `base`.
- * Inverse of `diffTrackConfig` on the add/change path (see module note).
+ * A `null` removes the member it names, and one naming something the base no
+ * longer has is dropped, so no `null` member reaches the config a track
+ * hydrates from.
  */
 export declare function mergeTrackConfig(base: Record<string, unknown>, delta: Record<string, unknown>): Record<string, unknown>;
-/** A single overridden slot: the dotted `path`, its base `from` and edited `to`. */
+/**
+ * A single overridden slot: the dotted `path`, its base `from` and edited `to`,
+ * which is `undefined` for a reset.
+ */
 export interface TrackConfigChange {
     /**
      * Where the setting lives. A producer that wants a friendlier heading sets

package/esm/util/trackConfigDelta.js

@@ -12,18 +12,18 @@
  *   - `diffTrackConfig(base, edited)` — the minimal delta
  *   - `mergeTrackConfig(base, delta)` — reconstruct the effective config
  *
- * Deliberate limitation (no tombstones): a delta records adds/changes only, not
- * deletions. If a user *resets* a slot the admin had customized (base has it,
- * edited omits it), the delta can't express "drop below the admin value", so the
- * field keeps following the base across a reload. This keeps the merge trivial
- * and the shared JSON free of deletion sentinels, and following the admin value
- * is a defensible outcome.
- *
- * What it is NOT free to conflate is a removal with a reset. Both diff to an
- * empty delta, and `SessionTracks.updateTrackConfiguration` used to read that as
- * "the edit netted back to the base" and revert the track's working copy — which
- * undid a removal on screen 400ms after it landed. That branch now keeps the
- * working copy; see the comment there.
+ * A delta is a JSON Merge Patch (RFC 7396) over the base, so a `null` member is
+ * a reset: the merge removes the member and the schema's default applies. That
+ * is ADR-146's spelling of a reset, and the diff writes one wherever the base
+ * sets a member the edited config lacks — a slot put back to its default, or a
+ * list emptied, since `stripDefault` drops both from a snapshot. Where the edit
+ * left a whole namespace at its default, the nulls land on the members the base
+ * set inside it rather than on the namespace, so a member the admin adds there
+ * later still flows through. The inference
+ * is exact only because both sides are post-`stripDefault` snapshots: a member
+ * the admin wrote at its default is absent from both, where a `null` for it
+ * would block a later admin value. As in RFC 7396, a delta cannot set a member
+ * to a literal `null`; null and absent are one state.
  *
  * `displays` is merged by `displayId` so an edit to one display doesn't pin the
  * others. Nested config objects (e.g. `adapter`) recurse. Any other array (value
@@ -49,10 +49,14 @@ function isDisplayArray(v) {
         v.length > 0 &&
         v.every(e => isPlainObject(e) && typeof e.displayId === 'string'));
 }
-// Sentinel returned by diffValue when a value is unchanged, so callers can tell
-// "no delta" apart from a legitimate `undefined` slot value.
 const UNCHANGED = Symbol('unchanged');
 function diffValue(base, edited) {
+    if (edited == null) {
+        if (base == null) {
+            return UNCHANGED;
+        }
+        return isPlainObject(base) ? diffValue(base, {}) : null;
+    }
     if (deepEqual(base, edited)) {
         return UNCHANGED;
     }
@@ -65,13 +69,10 @@ function diffValue(base, edited) {
             if (baseDisplay) {
                 const d = diffValue(baseDisplay, editedDisplay);
                 if (d !== UNCHANGED) {
-                    // always re-key the delta entry by displayId so merge can realign it
                     out.push({ ...d, displayId: id });
                 }
             }
             else {
-                // a display present only in the edited config (e.g. an added display):
-                // carry it whole
                 out.push(editedDisplay);
             }
         }
@@ -79,25 +80,20 @@ function diffValue(base, edited) {
     }
     if (isPlainObject(edited) && isPlainObject(base)) {
         const out = {};
-        for (const [k, v] of Object.entries(edited)) {
-            const d = diffValue(base[k], v);
+        for (const k of new Set([...Object.keys(base), ...Object.keys(edited)])) {
+            const d = diffValue(base[k], edited[k]);
             if (d !== UNCHANGED) {
                 out[k] = d;
             }
         }
-        // an object whose only difference from base is dropped keys (a reset the
-        // delta can't express, see module note) yields no adds/changes: treat it as
-        // unchanged rather than emitting a content-free entry
         return Object.keys(out).length > 0 ? out : UNCHANGED;
     }
-    // scalar, or an object/array replacing a scalar (or a value array): replace
     return edited;
 }
 /**
- * Minimal delta of `edited` against `base`. Both are plain config snapshots
- * (post-stripDefault). Records adds/changes only; see the module note on the
- * no-tombstone limitation. Always retains `trackId` so the delta is
- * self-identifying.
+ * Minimal delta of `edited` against `base`, both post-stripDefault snapshots. A
+ * member `base` sets and `edited` lacks is a `null` (see the module note).
+ * Always retains `trackId` so the delta is self-identifying.
  */
 export function diffTrackConfig(base, edited) {
     const d = diffValue(base, edited);
@@ -106,34 +102,40 @@ export function diffTrackConfig(base, edited) {
     return { ...delta, trackId };
 }
 function mergeValue(base, delta) {
-    if (isDisplayArray(delta) && isDisplayArray(base)) {
+    if (isDisplayArray(delta)) {
+        const baseDisplays = isDisplayArray(base) ? base : [];
         const deltaById = new Map(delta.map(d => [d.displayId, d]));
-        const merged = base.map(baseDisplay => {
+        const merged = baseDisplays.map(baseDisplay => {
             const d = deltaById.get(baseDisplay.displayId);
             return d ? mergeValue(baseDisplay, d) : baseDisplay;
         });
-        // displays present only in the delta (added by the user) append after base
-        const baseIds = new Set(base.map(d => d.displayId));
+        const baseIds = new Set(baseDisplays.map(d => d.displayId));
         for (const d of delta) {
             if (!baseIds.has(d.displayId)) {
-                merged.push(d);
+                merged.push(mergeValue(undefined, d));
             }
         }
         return merged;
     }
-    if (isPlainObject(delta) && isPlainObject(base)) {
-        const out = { ...base };
+    if (isPlainObject(delta)) {
+        const out = isPlainObject(base) ? { ...base } : {};
         for (const [k, v] of Object.entries(delta)) {
-            out[k] = mergeValue(base[k], v);
+            if (v === null) {
+                delete out[k];
+            }
+            else {
+                out[k] = mergeValue(out[k], v);
+            }
         }
         return out;
     }
-    // scalar / value array / type mismatch: delta wins
     return delta;
 }
 /**
  * Reconstruct the effective config by layering `delta` over the live `base`.
- * Inverse of `diffTrackConfig` on the add/change path (see module note).
+ * A `null` removes the member it names, and one naming something the base no
+ * longer has is dropped, so no `null` member reaches the config a track
+ * hydrates from.
  */
 export function mergeTrackConfig(base, delta) {
     return mergeValue(base, delta);
@@ -172,7 +174,7 @@ function walkDelta(base, delta, path, out, identityKeys = IDENTITY_KEYS) {
         }
     }
     else {
-        out.push({ path, from: base, to: delta });
+        out.push({ path, from: base, to: delta ?? undefined });
     }
 }
 /**

package/esm/util/tracks.d.ts

@@ -223,6 +223,7 @@ export declare function guessTrackType(adapterType: string, model?: IAnyStateTre
 export interface LooseTrackInput {
     uri: string;
     index?: string;
+    baseUri?: string;
     [key: string]: unknown;
 }
 /**
@@ -383,6 +384,31 @@ export declare function viewDisplayNames(pluginManager: PluginManager, viewType:
  *   so the pickers agree on it.
  */
 export declare function viewCanDisplayTrack(pluginManager: PluginManager, viewDisplays: Set<string>, trackType: string): boolean;
+/**
+ * The tracks a view can be offered: those that support every assembly it
+ * displays, and that declare a display it can draw. The track selector's tree
+ * and every other picker that opens a track into a view read this one answer,
+ * or one of them offers a track the next hides.
+ */
+export declare function filterTracks(tracks: AnyConfigurationModel[], self: {
+    view?: IStateTreeNode & {
+        type: string;
+    };
+    assemblyNames: string[];
+}): AnyConfigurationModel[];
+/**
+ * Every track config a view can be offered, each assembly's sequence track
+ * first and then {@link filterTracks} over the list handed in. The track
+ * selector's tree and the close-up dialog are both this, so a track one
+ * offers and the other hides would have to be a difference in the assemblies
+ * they were asked about.
+ */
+export declare function offeredTracks(tracks: AnyConfigurationModel[], self: {
+    view?: IStateTreeNode & {
+        type: string;
+    };
+    assemblyNames: string[];
+}): AnyConfigurationModel[];
 export declare function pickDisplayForView({ declaredDisplays, requestedType, trackDisplayTypes, viewDisplayTypes, preferredDisplayTypes, }: {
     declaredDisplays: DisplayConfSnapshot[];
     requestedType: string | undefined;
@@ -447,10 +473,7 @@ export declare function allSessionTracks(session: {
     connectionInstances?: {
         tracks: AnyConfigurationModel[];
     }[];
-}): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-    setSubschema(slotName: string, data: Record<string, unknown>): any;
-    setSlot(slotName: string, value: unknown): void;
-} & IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
+}): AnyConfigurationModel[];
 /**
  * The session's annotation for `assemblyName`, as trackIds: what a view opened
  * on another genome starts with. Only FeatureTracks, not everything configured

package/esm/util/tracks.js

@@ -8,13 +8,14 @@ export { getFileName } from './getFileName.js';
 // it. `fetchContext.ts` takes it from mstUtils instead, which is what keeps the
 // configuration schemas this file pulls in out of the fetch harness's graph.
 export { getRpcSessionId } from './parentWalk.js';
-import { getParent, getSnapshot, hasParent, isAlive, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
+import { getParent, getSnapshot, getType, hasParent, isAlive, isModelType, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
 import { observable, runInAction, untracked } from 'mobx';
 import { readConfObject } from '../configuration/index.js';
 import { getFileHandle, storeFileHandle, verifyPermission, } from './fileHandleStore.js';
 import { getFileName } from './getFileName.js';
 import { getContainingView, getEnv, getSession, objectHash, } from './mstUtils.js';
 import { isViewModel } from './types/index.js';
+import { setterOnlyMessage, unknownKeysMessage } from './unknownSnapshotKeys.js';
 // Deliberately uncached. This used to memoize on a permanent WeakMap keyed by
 // track, but every caller reads it from inside a reactive getter or autorun: the
 // memo meant the reaction never subscribed to the config, so editing
@@ -405,9 +406,10 @@ export function guessTrackType(adapterType, model, file) {
  * the caller can ask for a full config instead.
  */
 export function guessTrackConf(input, pluginManager, assemblyName) {
-    const { uri, index, ...extra } = typeof input === 'string' ? { uri: input } : input;
+    const { uri, index, baseUri, ...extra } = typeof input === 'string' ? { uri: input } : input;
+    const base = baseUri ? { baseUri } : {};
     return {
-        ...guessTrackConfForLocation({ uri, locationType: 'UriLocation' }, index ? { uri: index, locationType: 'UriLocation' } : undefined, pluginManager, assemblyName),
+        ...guessTrackConfForLocation({ uri, locationType: 'UriLocation', ...base }, index ? { uri: index, locationType: 'UriLocation', ...base } : undefined, pluginManager, assemblyName),
         ...extra,
     };
 }
@@ -501,6 +503,43 @@ export function getTrackName(conf, session) {
         : (conf.trackId ?? '');
     return trackName || trackId;
 }
+// The first-show path spreads the same settings into the display's `create()`
+// snapshot, so a DECLARED PROP (`resolution` on the wiggle displays) has
+// already landed by the time applyDisplaySettings reports it took no slot.
+// Only a declared prop: MST restores nothing else from a snapshot, so a
+// volatile or a getter of the same name (`scrollTop`) did not land and the
+// caller has to hear about it.
+function didNotLand(unapplied, display) {
+    const type = display ? getType(display) : undefined;
+    const props = type && isModelType(type) ? Object.keys(type.properties) : [];
+    return unapplied.filter(entry => !props.includes(entry.key));
+}
+function notifySettingsReport(session, trackId, displayType, unapplied, failed) {
+    const label = `${displayType} for track "${trackId}"`;
+    const keys = (of) => of.map(entry => entry.key);
+    const setterOnly = unapplied.filter(e => e.reason === 'setter-only');
+    const unknown = unapplied.filter(e => e.reason !== 'setter-only');
+    if (unknown.length) {
+        session.notifyError(unknownKeysMessage(label, keys(unknown)));
+    }
+    if (setterOnly.length) {
+        session.notifyError(setterOnlyMessage(label, keys(setterOnly)));
+    }
+    if (failed.length) {
+        session.notifyError(`Track "${trackId}" rejected ${failed.map(f => `${f.key}: ${f.error}`).join('; ')}`);
+    }
+}
+// `type` picks a display for a new track and means nothing to a shown one.
+function restyleShown(self, trackId, found, { type: _type, ...settings }) {
+    const track = found;
+    if (Object.keys(settings).length && track.applyDisplaySettings) {
+        const report = track.applyDisplaySettings(settings);
+        // no `didNotLand` here: this path spreads no snapshot, so every entry
+        // applyDisplaySettings reports really did write nothing
+        notifySettingsReport(getSession(self), trackId, track.activeDisplay.type, report.unapplied, report.failed);
+    }
+    return found;
+}
 /**
  * Which display a track opens with in a given view, and the display config that
  * display must use: `{ type, conf }`, or undefined when the view supports none
@@ -564,6 +603,74 @@ export function viewCanDisplayTrack(pluginManager, viewDisplays, trackType) {
             .getTrackType(trackType)
             .displayTypes.some(d => viewDisplays.has(d.name)));
 }
+/**
+ * Whether every name in `subset` appears in `superset`. An absent superset
+ * contains nothing; an absent subset is contained by anything.
+ */
+function containsAll(superset = [], subset = []) {
+    const s = new Set(superset);
+    return subset.every(x => s.has(x));
+}
+/**
+ * The tracks a view can be offered: those that support every assembly it
+ * displays, and that declare a display it can draw. The track selector's tree
+ * and every other picker that opens a track into a view read this one answer,
+ * or one of them offers a track the next hides.
+ */
+export function filterTracks(tracks, self) {
+    const { view } = self;
+    if (!view) {
+        return [];
+    }
+    const { assemblyManager } = getSession(view);
+    const { pluginManager } = getEnv(view);
+    const canonical = (names) => canonicalAssemblyNames(names, assemblyManager);
+    const viewAssemblyNames = canonical(self.assemblyNames);
+    const viewDisplays = viewDisplayNames(pluginManager, view.type);
+    return tracks.filter(c => {
+        const trackAssemblyNames = readConfObject(c, 'assemblyNames');
+        return (
+        // a view that declares no assemblies (one still initializing) constrains
+        // nothing; otherwise the track must cover every one of them
+        (viewAssemblyNames.length === 0 ||
+            containsAll(trackAssemblyNames && canonical(trackAssemblyNames), viewAssemblyNames)) &&
+            viewCanDisplayTrack(pluginManager, viewDisplays, c.type));
+    });
+}
+/**
+ * The assembly's own sequence track, when the view can draw one. It is in no
+ * track list — the config lives on the assembly (see {@link getConfAssemblyNames}
+ * on why a sequence track's assembly is positional) — so a picker that walks
+ * `session.tracks` alone cannot offer the track most views open first.
+ */
+function refSeqTrackConf(assemblyName, view) {
+    const { assemblyManager } = getSession(view);
+    const { pluginManager } = getEnv(view);
+    const conf = assemblyManager.get(assemblyName)?.configuration.sequence;
+    // the same display-compatibility question filterTracks asks of every other
+    // track, so a view that cannot draw a sequence is not offered one
+    return conf &&
+        viewCanDisplayTrack(pluginManager, viewDisplayNames(pluginManager, view.type), conf.type)
+        ? conf
+        : undefined;
+}
+/**
+ * Every track config a view can be offered, each assembly's sequence track
+ * first and then {@link filterTracks} over the list handed in. The track
+ * selector's tree and the close-up dialog are both this, so a track one
+ * offers and the other hides would have to be a difference in the assemblies
+ * they were asked about.
+ */
+export function offeredTracks(tracks, self) {
+    const { view, assemblyNames } = self;
+    if (!view) {
+        return [];
+    }
+    return [
+        ...assemblyNames.map(name => refSeqTrackConf(name, view)),
+        ...filterTracks(tracks, self),
+    ].filter(conf => conf !== undefined);
+}
 export function pickDisplayForView({ declaredDisplays, requestedType, trackDisplayTypes, viewDisplayTypes, preferredDisplayTypes = new Set(), }) {
     const supported = new Set(viewDisplayTypes);
     // A requested type is CHECKED, not taken on faith. It used to pass straight
@@ -634,6 +741,9 @@ function resolveTrackDisplayChoice(self, trackId, displayInitialSnapshot, inline
         throw new Error(`Could not resolve identifier "${trackId}"`);
     }
     const confSnapshot = structuredClone(isStateTreeNode(rawConf) ? getSnapshot(rawConf) : rawConf);
+    // `& { type: string }` because `rawConf` unions a live node with a loose
+    // `Record<string, unknown>`, and the node's `type: string` widens back to
+    // `unknown` across that union
     const conf = pluginManager.evaluateExtensionPoint('Core-preProcessTrackConfig', confSnapshot);
     const trackType = pluginManager.getTrackType(conf.type);
     // Validate only a conf that is not already in the tree. `configSchema.create`
@@ -706,7 +816,7 @@ inlineConf) {
     const session = getSession(self);
     const found = self.tracks.find(t => t.configuration.trackId === trackId);
     if (found) {
-        return found;
+        return restyleShown(self, trackId, found, displayInitialSnapshot);
     }
     // Single choke point for all "open a track" paths — errors surface as
     // snackbars. Config is validated before the push so the open set never holds
@@ -756,47 +866,10 @@ inlineConf) {
         // reference can resolve. Slots only, deliberately: this is the
         // declarative surface, and `allowSetters` stays off so a spec key cannot
         // reach internal display actions.
-        //
-        // `type` is dropped first because this function already consumed it
-        // (pickDisplayForView above), and only `failed` — a key whose write threw —
-        // is notified: `unapplied` here also holds the MST display props the
-        // snapshot spread above already applied, so notifying on it would report a
-        // correct call as broken. A throwing slot value used to reach the outer
-        // catch and raise a snackbar; per-key catching kept the track intact but
-        // took the message away with it.
         const displaySettings = Object.fromEntries(Object.entries(displayInitialSnapshot).filter(([key]) => key !== 'type'));
         const report = track.applyDisplaySettings(displaySettings);
-        // A key that reached NOTHING, told apart from the ones `unapplied` holds
-        // legitimately. `unapplied` means "not a config slot", which covers both an
-        // MST display prop the snapshot spread above already applied and a
-        // misspelling that did nothing at all — so reporting the list wholesale
-        // called a correct spec broken, and reporting none of it let
-        // `{ trackId, colorSchem: 'x' }` load a plausible track with the setting
-        // silently missing. The display's own model type says which is which.
-        // Asked of the display NODE, not of its model type: `type.properties` sees
-        // declared props and misses everything else a key can legitimately reach —
-        // a volatile the snapshot spread above just set (`resolution` on the GC
-        // content display is one) reads as unreached and gets reported over a
-        // correct call.
-        // `unapplied` holds three kinds of entry, and only one of them means the
-        // key did nothing at all: applyDisplaySettings annotates `type` and the
-        // "a setter exists, pass allowSetters" case in parentheses, and pushes a
-        // BARE key when the display has neither a slot nor a setter for it. So the
-        // bare ones are the candidates, and the node itself settles the rest — the
-        // snapshot spread above may already have landed the key as a prop or a
-        // volatile, which is what `resolution` on the GC content display is.
         const drawn = track.displays[0];
-        const reachedNothing = drawn
-            ? report.unapplied.filter(entry => !entry.includes(' (') && !(entry in drawn))
-            : [];
-        if (reachedNothing.length > 0) {
-            session.notifyError(`Track "${trackId}" ignored ${reachedNothing.join(', ')}: neither a setting the ${displayType} accepts nor one of its properties`);
-        }
-        if (report.failed.length) {
-            session.notifyError(`Track "${trackId}" rejected ${report.failed
-                .map(f => `${f.key}: ${f.error}`)
-                .join('; ')}`);
-        }
+        notifySettingsReport(session, trackId, displayType, didNotLand(report.unapplied, drawn), report.failed);
         // if this track came from a connection, persist its config so it survives
         // reload without re-establishing the connection (no-op otherwise)
         session.captureConnectionTrack?.(trackId);
@@ -840,7 +913,7 @@ export async function launchTrackGeneric(self, trackId, initialSnapshot = {}, di
     const session = getSession(self);
     const found = self.tracks.find(t => t.configuration.trackId === trackId);
     if (found) {
-        return found;
+        return restyleShown(self, trackId, found, displayInitialSnapshot);
     }
     try {
         const { picked } = resolveTrackDisplayChoice(self, trackId, displayInitialSnapshot, inlineConf);