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

package/esm/configuration/promotableResolve.js

@@ -1,117 +0,0 @@
-/**
- * @module
- * The read-time resolver behind `promotable` config slots — a small CSS cascade
- * for one slot: the track's own set value -> the session-wide default for its
- * display type -> the slot's `promotedBase`. `resolveSlotIn` is the whole of it;
- * `resolveConf` and the control builders in `promotableDefaults.ts` each read a
- * field off the `SlotResolution` it returns.
- *
- * Mechanism: `agent-docs/reference/DISPLAY_TYPE_DEFAULTS.md`. Two decisions this
- * file rests on: resolution is named at its call sites rather than folded into
- * `getConf` (ADR-046), and unset is the only inherit sentinel — so declaring
- * `promotedBase` is what makes a slot promotable (ADR-047, enforced by
- * `ConfigSlot`).
- *
- * Every comparison against a promoted or base value is `deepEqual`, never `===`:
- * an object-valued slot (`maybeFrozen`, e.g. alignments `colorBy`) reconstructs a
- * fresh value out of MST that is never `===` its stored twin, so `===` would read
- * it as permanently differing and no pin would ever light up.
- *
- * The gate a candidate value passes to count at all is `isUsableValue`, in
- * `slotShape.ts` — shared with `ConfigSlot`, which applies it to `promotedBase`
- * at construction so the tier this file falls back to is usable by construction.
- */
-import { deepEqual } from '../util/deepEqual.js';
-import { getSession } from '../util/mstUtils.js';
-import { getSlotDefinition } from './slotFacade.js';
-import { isUsableValue } from './slotShape.js';
-export function cascadeContextFor(self) {
-    return {
-        config: self.configuration,
-        displayType: self.type,
-        defaults: getSession(self),
-    };
-}
-/**
- * What the slot literally holds, unevaluated — a stray `jexl:` string yields the
- * raw string rather than running it. Both callers ask "is the slot set, and to
- * what kind of thing?", which has to be answerable with no feature context.
- *
- * Deliberately not `readConfObject`: for a promotable slot this is the whole
- * stored read, and both of that reader's extra behaviors are unwanted here — it
- * evaluates a `jexl:` string (which `isUsableValue` refuses anyway) and it
- * snapshots an MST-node value, which a `maybe*` slot never holds.
- */
-export function storedSlotValue(config, slot) {
-    return config[slot];
-}
-/**
- * Whether `value` could actually become this slot's promoted default — the same
- * `isUsableValue` gate the cascade puts both tiers through, asked ahead of time
- * about a value a caller is about to offer as a pin's on-value.
- *
- * Exists because a pin built over a value the gate refuses is inert in a way
- * nothing reports: `applyAndOfferDefault` writes it to the session store happily,
- * `resolveSlotIn` then drops it and every track keeps resolving to the tier
- * below, and `isPromotableDefault` compares the *raw* stored value, so the pin
- * draws outline forever while a dead key sits in the user's localStorage. See
- * `makePin`, which is the one caller.
- */
-export function isPromotableValue(config, slot, value) {
-    return isUsableValue(getSlotDefinition(config, slot), value);
-}
-// The whole three-tier cascade for one slot, in one place. `resolveConf` is the
-// public reader over it, and the control builders in `promotableDefaults.ts`
-// read a field off it.
-export function resolveSlot(self, slot) {
-    return resolveSlotIn(cascadeContextFor(self), slot);
-}
-// The cascade over explicit inputs. `resolveSlot` is the display-state spelling
-// of this and the one nearly every consumer wants; the direct form exists for
-// the config-only path (a track that isn't open has no display state — see
-// `CascadeContext`).
-export function resolveSlotIn(ctx, slot) {
-    const def = getSlotDefinition(ctx.config, slot);
-    // A plain slot would otherwise resolve silently wrong here — with no
-    // `promotedBase` every tier collapses to `undefined` — and, through a control
-    // builder, write a promoted default nothing ever reads. `getSlotDefinition`
-    // already throws on a slot name that doesn't exist at all.
-    //
-    // Declaring `promotedBase` is what makes a slot promotable, so its absence is
-    // the whole test; there is no separate flag that could disagree with it.
-    if (def.promotedBase === undefined) {
-        throw new Error(`config slot "${slot}" is not promotable`);
-    }
-    // the slot's CSS `initial`
-    const base = def.promotedBase;
-    // a session-wide fact, and `isPromotableDefault` (the pin's filled/outline
-    // state) reports on the session, not on one display's view of it
-    const promoted = ctx.defaults.getDisplayTypeDefault(ctx.displayType, slot);
-    const own = storedSlotValue(ctx.config, slot);
-    // A track is customized exactly when it holds a *usable* value — being unset
-    // is the inherit sentinel, so "set to something the slot could hold" is the
-    // whole test. Routing `own` through the same gate as a promoted default is
-    // what makes a malformed or stale own value (a saved `colorBy` naming a
-    // since-removed scheme) read as not-customized and degrade in lockstep,
-    // instead of reaching a consumer that trusts every value it sees.
-    const customized = isUsableValue(def, own);
-    const inheritedValue = isUsableValue(def, promoted) ? promoted : base;
-    // A customized value wins unconditionally, which is what makes the share bake
-    // sufficient on its own: a baked value lands in the track's config, so the
-    // recipient reads it as customized and their own promoted default never gets
-    // consulted. The one case a bake cannot cover is the sender sitting at `base`
-    // while the recipient has promoted something — nothing is baked (the value
-    // *is* base, and `stripDefault` drops it from the snapshot), so the recipient
-    // resolves it from their own cascade. That is accepted: a promoted default is
-    // personal and local, exactly like the theme a session is viewed in, and the
-    // alternative was a per-display `ignorePromotedDefaults` flag that also
-    // detached received tracks from the recipient's own pins for good.
-    const value = customized ? own : inheritedValue;
-    return {
-        base,
-        customized,
-        promoted,
-        inherited: !customized && !deepEqual(value, base),
-        value,
-    };
-}

package/esm/configuration/promotableSlots.d.ts

@@ -1,12 +0,0 @@
-import type { AnyConfigurationModel } from './types.ts';
-import type { IAnyType } from '@jbrowse/mobx-state-tree';
-/**
- * Takes a live config node *or* the schema type itself, for the reason
- * `getConfigurationSchemaDefinition` does: every resolver here holds a node,
- * while a caller enumerating registered display types
- * (`displayTypesWithPromotableSlots`) holds only `DisplayType.configSchema` and
- * has nothing to create a node from. Caching under whichever handle it was
- * given is safe — a schema registers both its outer `stripDefault` wrapper and
- * its inner model against the same slot table, so the two entries agree.
- */
-export declare function promotableSlotNames(configOrType: AnyConfigurationModel | IAnyType): ReadonlySet<string>;

package/esm/configuration/promotableSlots.js

@@ -1,45 +0,0 @@
-import { getType, isType } from '@jbrowse/mobx-state-tree';
-import { getConfigurationSchemaDefinition } from './schemaRegistry.js';
-import { isSlotDefinitionEntry } from './schemaTypes.js';
-// The `promotable` slot names of one config schema (includes slots inherited via
-// baseConfiguration — merged into the table at construction), cached by MST type
-// since a schema's slot table is fixed.
-//
-// Only the functions that genuinely *enumerate* promotable slots call this — the
-// worker-payload resolver, the badge diff, "clear every default", and
-// `assertNoPromotableSlots`. It is deliberately NOT on any read path:
-// `getConf` used to consult it on all ~1300 config reads in the repo to decide
-// whether to cascade, which cost a `getType` per read (measured at ~60% overhead
-// over `readConfObject`) to serve the ~15 promotable ones. `resolveConf` names
-// the cascade at the call site instead, so there is nothing to look up.
-//
-// Its own module, and a leaf one, because `ui/promotablePinCoverage.ts` wants
-// the slot names and nothing else: reaching them through a module that also held
-// `readConfObject` pulled jexl and the whole read path into the ui graph. See the
-// note on that export in `ui/index.ts`.
-const promotableSlotsByType = new WeakMap();
-/**
- * Takes a live config node *or* the schema type itself, for the reason
- * `getConfigurationSchemaDefinition` does: every resolver here holds a node,
- * while a caller enumerating registered display types
- * (`displayTypesWithPromotableSlots`) holds only `DisplayType.configSchema` and
- * has nothing to create a node from. Caching under whichever handle it was
- * given is safe — a schema registers both its outer `stripDefault` wrapper and
- * its inner model against the same slot table, so the two entries agree.
- */
-export function promotableSlotNames(configOrType) {
-    const type = isType(configOrType) ? configOrType : getType(configOrType);
-    const cached = promotableSlotsByType.get(type);
-    if (cached) {
-        return cached;
-    }
-    const names = new Set();
-    const table = getConfigurationSchemaDefinition(configOrType);
-    for (const [name, def] of Object.entries(table ?? {})) {
-        if (isSlotDefinitionEntry(def) && def.promotedBase !== undefined) {
-            names.add(name);
-        }
-    }
-    promotableSlotsByType.set(type, names);
-    return names;
-}

package/esm/configuration/slotShape.d.ts

@@ -1,12 +0,0 @@
-import type { ConfigSlotDefinition } from './configurationSlot.ts';
-/**
- * Whether a stored value could really be a value of this slot. An unusable value
- * is dropped by the cascade, so the getter, the pin and the badge all fall back
- * in lockstep.
- *
- * The `jexl:` check is the only place the subsystem handles a callback, and it
- * handles it by refusing it — a hand-edited config or default store is untyped,
- * and a callback string would otherwise reach a renderer as a literal value.
- * DISPLAY_TYPE_DEFAULTS.md §"No callbacks".
- */
-export declare function isUsableValue(def: ConfigSlotDefinition, value: unknown): boolean;

package/esm/configuration/slotShape.js

@@ -1,84 +0,0 @@
-/**
- * @module
- * The one gate a candidate value for a `promotable` slot has to pass. Shared,
- * deliberately, by the two places that ask the question:
- *
- *  - `promotableResolve.ts` at read time, for both cascade tiers — a session-wide
- *    promoted default and a track's own value out of an untyped saved snapshot;
- *  - `configurationSlot.ts` at construction, for the slot's own `promotedBase`.
- *
- * One implementation is what makes "the base is always a usable value" true by
- * construction rather than assumed: the resolver falls back to `promotedBase`
- * whenever a tier fails this gate, so a base that would itself fail has nowhere
- * left to fall.
- */
-import { getEnumerationValues } from '../util/mst-reflection.js';
-import { isCallbackValue } from './slotValueUtils.js';
-// Per-slot-type JS shape checks, for the slot types whose value needs more than
-// a `typeof` against `promotedBase`. Only the `maybe*` types appear, because
-// `ConfigSlot` rejects a `promotedBase` on anything else and this table is only
-// ever consulted for a promotable slot. Any type absent here (`maybeBoolean`,
-// `maybeColor`, `maybeFrozen`) falls through to the `promotedBase`-derived check
-// in `matchesSlotShape`.
-const SHAPE_CHECKS = {
-    // a bare `typeof value === 'number'` would admit `NaN`/`±Infinity`, which no
-    // slot legitimately holds
-    maybeNumber: value => Number.isFinite(value),
-    // a `maybeStringEnum` with no `model` can't be membership-checked; reject
-    // rather than admit any string. `def.model` is the author's plain enumeration
-    // (ConfigSlot adds the nullability), so this reads the real vocabulary.
-    maybeStringEnum: (value, def) => !!def.model &&
-        typeof value === 'string' &&
-        getEnumerationValues(def.model).includes(value),
-};
-/**
- * Whether `value` has a JS shape this slot could hold. Guards the untyped
- * session store / saved snapshot against garbage; not a full validation
- * (`validate` layers semantics on top).
- *
- * Module-private on purpose: `isUsableValue` is the gate, and this is only one
- * of its four checks. A caller reaching for the shape test alone would skip the
- * `jexl:` refusal and the slot's `validate` hook — the two checks that exist
- * precisely because a shape-valid value can still be unusable.
- *
- * Keyed off `promotedBase` because that is the only concrete specimen of the
- * slot's value space a promotable slot declares — `defaultValue` is always the
- * inherit sentinel, so keying off it would demand `typeof value === 'undefined'`.
- * A `promotedBase` checked against itself therefore only exercises the
- * `SHAPE_CHECKS` entries, which is exactly the half that can be authored wrong
- * (an enum member that isn't in the vocabulary, a non-finite number).
- *
- * Can't delegate to the slot's MST `model.is(value)`, which is too permissive
- * exactly where this guard matters — `slotShape.test.ts` pins the two cases.
- */
-function matchesSlotShape(def, value) {
-    const { promotedBase } = def;
-    const check = SHAPE_CHECKS[def.type];
-    return check
-        ? check(value, def)
-        : typeof promotedBase === 'object' && promotedBase !== null
-            ? // object/array slot (e.g. `colorBy`): match null-ness and array-ness —
-                // a bare `typeof` compare would admit `null` (typeof null === 'object')
-                // and an array against an object base
-                typeof value === 'object' &&
-                    value !== null &&
-                    Array.isArray(value) === Array.isArray(promotedBase)
-            : typeof value === typeof promotedBase;
-}
-/**
- * Whether a stored value could really be a value of this slot. An unusable value
- * is dropped by the cascade, so the getter, the pin and the badge all fall back
- * in lockstep.
- *
- * The `jexl:` check is the only place the subsystem handles a callback, and it
- * handles it by refusing it — a hand-edited config or default store is untyped,
- * and a callback string would otherwise reach a renderer as a literal value.
- * DISPLAY_TYPE_DEFAULTS.md §"No callbacks".
- */
-export function isUsableValue(def, value) {
-    const { validate } = def;
-    return (value !== undefined &&
-        !isCallbackValue(value) &&
-        matchesSlotShape(def, value) &&
-        (!validate || validate(value)));
-}

package/esm/ui/PinAdornment.d.ts

@@ -1,5 +0,0 @@
-import type { MenuItemPin } from './MenuTypes.ts';
-export declare function PinAdornment({ pin, disabled, }: {
-    pin: MenuItemPin;
-    disabled?: boolean;
-}): import("react").JSX.Element;

package/esm/ui/PinAdornment.js

@@ -1,67 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import PushPinIcon from '@mui/icons-material/PushPin';
-import PushPinOutlinedIcon from '@mui/icons-material/PushPinOutlined';
-import { ToggleButton, Tooltip } from '@mui/material';
-import { makeStyles } from '../util/tss-react/index.js';
-const useStyles = makeStyles()(theme => ({
-    // compact enough to sit inline with the value check: drop the default
-    // ToggleButton border/padding so it's ~icon-sized, but keep the selected
-    // background tint (an unmistakable on/off signal, unlike a hollow-vs-filled
-    // icon alone)
-    button: {
-        border: 0,
-        padding: theme.spacing(0.25),
-    },
-    // the Tooltip listens on this rather than on the button, which fires no
-    // events once the row disables it
-    wrapper: {
-        display: 'inline-flex',
-    },
-}));
-// A toggle pin sits on a checkbox row: the copy names the state the click
-// applies, and the fill mirrors the checkbox. A value pin's on-value IS what
-// the label says — a radio option ("Compact"), a size row whose caller folds
-// the value into the label ("Line width (2px)") — and there the fill means the
-// value is the promoted default, so a click clears it.
-//
-// The aria-label carries "of this type" wherever the tooltip does: it used to
-// stop at "for all open tracks", stating a wider blast radius than the control
-// has.
-function pinCopy(label, control) {
-    const { kind, active } = control;
-    return kind === 'toggle'
-        ? {
-            title: `Turn ${label} ${active ? 'off' : 'on'} for all open tracks of this type`,
-            ariaLabel: `turn ${label} ${active ? 'off' : 'on'} for all open tracks of this type`,
-        }
-        : active
-            ? {
-                title: `${label} is the default for all tracks of this type (click to clear)`,
-                ariaLabel: `clear the default for ${label} for all tracks of this type`,
-            }
-            : {
-                title: `Apply ${label} to all open tracks of this type`,
-                ariaLabel: `apply ${label} to all open tracks of this type`,
-            };
-}
-// Trailing pin for a promotable setting, drawn beside the value check from the
-// row's `pin` declaration (`menuItemAdornment` builds this; a row never
-// constructs it, which is what keeps MUI out of the eager menu-builder graph). A
-// ToggleButton (native button a11y + a clear selected tint) with a pin —
-// distinct from the value checkbox.
-//
-// One click writes the value into every open track of this display type and
-// raises a snackbar offering to keep it as the display type's default, so a
-// default takes two deliberate clicks (ADR-048). Always shown so the capability
-// is discoverable. stopPropagation keeps the click off the row value / menu
-// dismissal. "of this type" because a promoted default is scoped to the display
-// type (e.g. every LinearAlignmentsDisplay), not literally all tracks.
-export function PinAdornment({ pin, disabled, }) {
-    const { classes } = useStyles();
-    const { label, control } = pin;
-    const { title, ariaLabel } = pinCopy(label, control);
-    return (_jsx(Tooltip, { title: title, children: _jsx("span", { className: classes.wrapper, children: _jsx(ToggleButton, { className: classes.button, value: "default", disabled: disabled, selected: control.active, color: "primary", size: "small", "aria-label": ariaLabel, onChange: e => {
-                    e.stopPropagation();
-                    control.toggle();
-                }, children: control.active ? (_jsx(PushPinIcon, { fontSize: "small" })) : (_jsx(PushPinOutlinedIcon, { fontSize: "small" })) }) }) }));
-}

package/esm/ui/SvgGradientLegend.d.ts

@@ -1,26 +0,0 @@
-export interface GradientStop {
-    offset: string;
-    color: string;
-    opacity?: number;
-}
-export interface GradientLabel {
-    text: string;
-    position: 'start' | 'middle' | 'end';
-}
-export declare const GRADIENT_LEGEND_WIDTH = 120;
-export declare const GRADIENT_LEGEND_HEIGHT = 40;
-export declare const GRADIENT_LEGEND_SVG_AREA_WIDTH: number;
-export default function SvgGradientLegend({ gradientId, stops, labels, title, x, y, width, height, barWidth, barHeight, padding, fontSize, }: {
-    gradientId: string;
-    stops: GradientStop[];
-    labels: GradientLabel[];
-    title?: string;
-    x?: number;
-    y?: number;
-    width?: number;
-    height?: number;
-    barWidth?: number;
-    barHeight?: number;
-    padding?: number;
-    fontSize?: number;
-}): import("react").JSX.Element;

package/esm/ui/SvgGradientLegend.js

@@ -1,26 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/* eslint-disable react-refresh/only-export-components -- layout constants belong with this leaf SVG primitive; no component state to fast-refresh */
-import { svgSafeId } from '../svg/svgId.js';
-// Default box/bar geometry shared by the LD and Hi-C legends. Exported so
-// callers that size an outer container (an <svg> wrapper) or compute an offset
-// stay in lockstep with what this component draws.
-export const GRADIENT_LEGEND_WIDTH = 120;
-export const GRADIENT_LEGEND_HEIGHT = 40;
-// Horizontal space a display should reserve (via `svgLegendWidth()`) to park
-// this legend beside the plot in an SVG export: the bar itself plus a 10px
-// margin either side.
-export const GRADIENT_LEGEND_SVG_AREA_WIDTH = GRADIENT_LEGEND_WIDTH + 20;
-// Shared SVG color-ramp key: a rounded translucent box, a horizontal gradient
-// bar, and labels below it. Used by any display that colors by a continuous
-// scale (Hi-C contact counts, LD r²/D'). Renders a <g>; position via x/y.
-export default function SvgGradientLegend({ gradientId, stops, labels, title, x = 0, y = 0, width = GRADIENT_LEGEND_WIDTH, height = GRADIENT_LEGEND_HEIGHT, barWidth = 100, barHeight = 12, padding = 8, fontSize = 10, }) {
-    const titleGap = title ? fontSize + 4 : 0;
-    const barY = padding + titleGap;
-    const labelY = barY + barHeight + fontSize + 2;
-    const safeGradientId = svgSafeId(gradientId);
-    return (_jsxs("g", { transform: `translate(${x}, ${y})`, children: [_jsx("defs", { children: _jsx("linearGradient", { id: safeGradientId, x1: "0%", y1: "0%", x2: "100%", y2: "0%", children: stops.map(stop => (_jsx("stop", { offset: stop.offset, style: { stopColor: stop.color, stopOpacity: stop.opacity ?? 1 } }, stop.offset))) }) }), _jsx("rect", { x: 0, y: 0, width: width, height: height + titleGap, fill: "rgba(255,255,255,0.95)", stroke: "#ccc", strokeWidth: 1, rx: 4 }), title ? (_jsx("text", { x: padding, y: padding + fontSize, fontSize: fontSize, fill: "black", children: title })) : null, _jsx("rect", { x: padding, y: barY, width: barWidth, height: barHeight, fill: `url(#${safeGradientId})`, rx: 2 }), labels.map(label => (_jsx("text", { x: label.position === 'start'
-                    ? padding
-                    : label.position === 'middle'
-                        ? padding + barWidth / 2
-                        : padding + barWidth, y: labelY, fontSize: fontSize, fill: "black", textAnchor: label.position === 'start' ? undefined : label.position, children: label.text }, `${label.position}-${label.text}`)))] }));
-}

package/esm/ui/promotablePinCoverage.d.ts

@@ -1,58 +0,0 @@
-import type { ResolvableDisplay } from '../configuration/promotableResolve.ts';
-import type { MenuItem } from './MenuTypes.ts';
-import type { IAnyType } from '@jbrowse/mobx-state-tree';
-/**
- * The registered display types whose config schema declares a promotable slot,
- * sorted — the set a pin-coverage check has to reach, answered off the
- * `DisplayType`s themselves before anything is opened.
- *
- * The other half of the same gap `promotableSlotsWithoutPin` covers, and the
- * half that has no symptom at all: that function reports on a display it was
- * *given*, so a display type no fixture ever opens is not checked and does not
- * say so. Six display types declaring `showLegend` sat outside the check's
- * reach with nothing recording it.
- *
- * Takes the display types rather than a `PluginManager`, so core doesn't have
- * to name a plugin registry to answer a question about config schemas.
- */
-export declare function displayTypesWithPromotableSlots(displayTypes: readonly {
-    name: string;
-    configSchema: IAnyType;
-}[]): string[];
-/**
- * Every promotable slot some row of `items` carries a pin for, submenus
- * included.
- *
- * Reads `pin.control.slot` and nothing else. A raw `endAdornment` is
- * deliberately not counted: it is an arbitrary element (synteny's colour
- * swatch), so it cannot say which slot it promotes, and a pin built by hand
- * rather than through `makePin`/`makeTogglePin` is a thing to find, not to
- * accept.
- */
-export declare function pinnedSlots(items: MenuItem[]): Set<string>;
-/**
- * Rows whose pin is the wrong kind for the row, submenus included: a checkbox
- * row carrying a value pin, or a radio row carrying a toggle pin. Empty is the
- * healthy answer.
- *
- * The row builders type the option so this cannot happen through them; this
- * is for a `pin` written by hand as a literal, which the type system lets
- * through as the union. A checkbox row's pin has to be the toggle kind because
- * that is what a click beside a checkbox is read as — "turn this on for all" —
- * and a value pin there applies the row's *current* state instead, which
- * beside an unchecked box is a visible no-op. That shipped once (2026-09-07)
- * and was caught in a live session, not by a test; this is the test.
- */
-export declare function misKindedPins(items: MenuItem[]): string[];
-/**
- * A display's promotable slots that its own track menu offers no pin for,
- * sorted. Empty is the healthy answer.
- *
- * Takes the built menu rather than calling `trackMenuItems()` itself, because
- * what a menu contains depends on the display's current state — a row can be
- * gated on a rendering type (wiggle line width), on a parent toggle (the sashimi
- * options), or on data having arrived. A caller that wants the whole surface has
- * to drive the display into the states that reveal it, and that is a decision
- * this function should not make silently.
- */
-export declare function promotableSlotsWithoutPin(display: ResolvableDisplay, menuItems: MenuItem[]): string[];

package/esm/ui/promotablePinCoverage.js

@@ -1,124 +0,0 @@
-/**
- * @module
- * The read side of the promotable pin: given a display, which of its promotable
- * slots its track menu actually offers a pin for.
- *
- * This exists because the two halves of the feature are declared in different
- * places and nothing joins them. Declaring `promotedBase` is a **schema** fact
- * that travels down `baseConfiguration` to every subclass; the pin is a **menu**
- * fact, built by whichever `trackMenuItems()` happens to construct a row for that
- * slot. A display that inherits the slot and curates its own menu therefore ends
- * up with a promotable slot that has no pin anywhere — and since a promoted default
- * is keyed by *display type*, no other display's pin can write its key either, so
- * the slot resolves to `promotedBase` forever unless a track customizes it.
- *
- * Nothing throws, nothing renders differently, and the config docs go on
- * advertising the setting as having a session-wide default. The state was tracked
- * by hand in `agent-docs/reference/DISPLAY_TYPE_DEFAULTS.md` and drifted twice
- * before this was written — once gaining a row for a slot that had been deleted,
- * once missing a slot that had been added.
- *
- * `products/jbrowse-web/src/tests/PromotablePinCoverage.test.ts` is the guard: it
- * opens one display of every type that declares a promotable slot and holds the
- * result against a baseline.
- */
-import { promotableSlotNames } from '../configuration/promotableSlots.js';
-import { resolveSubMenu } from './MenuTypes.js';
-/**
- * The registered display types whose config schema declares a promotable slot,
- * sorted — the set a pin-coverage check has to reach, answered off the
- * `DisplayType`s themselves before anything is opened.
- *
- * The other half of the same gap `promotableSlotsWithoutPin` covers, and the
- * half that has no symptom at all: that function reports on a display it was
- * *given*, so a display type no fixture ever opens is not checked and does not
- * say so. Six display types declaring `showLegend` sat outside the check's
- * reach with nothing recording it.
- *
- * Takes the display types rather than a `PluginManager`, so core doesn't have
- * to name a plugin registry to answer a question about config schemas.
- */
-export function displayTypesWithPromotableSlots(displayTypes) {
-    return displayTypes
-        .filter(d => promotableSlotNames(d.configSchema).size > 0)
-        .map(d => d.name)
-        .sort((a, b) => a.localeCompare(b));
-}
-/**
- * Every promotable slot some row of `items` carries a pin for, submenus
- * included.
- *
- * Reads `pin.control.slot` and nothing else. A raw `endAdornment` is
- * deliberately not counted: it is an arbitrary element (synteny's colour
- * swatch), so it cannot say which slot it promotes, and a pin built by hand
- * rather than through `makePin`/`makeTogglePin` is a thing to find, not to
- * accept.
- */
-export function pinnedSlots(items) {
-    const found = new Set();
-    const walk = (list) => {
-        for (const item of list) {
-            if ('pin' in item && item.pin) {
-                found.add(item.pin.control.slot);
-            }
-            if ('subMenu' in item) {
-                walk(resolveSubMenu(item));
-            }
-        }
-    };
-    walk(items);
-    return found;
-}
-/**
- * Rows whose pin is the wrong kind for the row, submenus included: a checkbox
- * row carrying a value pin, or a radio row carrying a toggle pin. Empty is the
- * healthy answer.
- *
- * The row builders type the option so this cannot happen through them; this
- * is for a `pin` written by hand as a literal, which the type system lets
- * through as the union. A checkbox row's pin has to be the toggle kind because
- * that is what a click beside a checkbox is read as — "turn this on for all" —
- * and a value pin there applies the row's *current* state instead, which
- * beside an unchecked box is a visible no-op. That shipped once (2026-09-07)
- * and was caught in a live session, not by a test; this is the test.
- */
-export function misKindedPins(items) {
-    const found = [];
-    const walk = (list) => {
-        for (const item of list) {
-            if ('pin' in item && item.pin && 'type' in item) {
-                const { kind } = item.pin.control;
-                const wanted = item.type === 'checkbox'
-                    ? 'toggle'
-                    : item.type === 'radio'
-                        ? 'value'
-                        : undefined;
-                if (wanted && kind !== wanted) {
-                    found.push(`${item.pin.label}: ${kind} pin on a ${item.type} row`);
-                }
-            }
-            if ('subMenu' in item) {
-                walk(resolveSubMenu(item));
-            }
-        }
-    };
-    walk(items);
-    return found;
-}
-/**
- * A display's promotable slots that its own track menu offers no pin for,
- * sorted. Empty is the healthy answer.
- *
- * Takes the built menu rather than calling `trackMenuItems()` itself, because
- * what a menu contains depends on the display's current state — a row can be
- * gated on a rendering type (wiggle line width), on a parent toggle (the sashimi
- * options), or on data having arrived. A caller that wants the whole surface has
- * to drive the display into the states that reveal it, and that is a decision
- * this function should not make silently.
- */
-export function promotableSlotsWithoutPin(display, menuItems) {
-    const pinned = pinnedSlots(menuItems);
-    return [...promotableSlotNames(display.configuration)]
-        .filter(slot => !pinned.has(slot))
-        .sort((a, b) => a.localeCompare(b));
-}

package/esm/util/openDisplays.d.ts

@@ -1,23 +0,0 @@
-import type { ResolvableDisplay } from '../configuration/promotableResolve.ts';
-import type { AbstractSessionModel } from './types/index.ts';
-/**
- * #api core/util
- * Every display on an open track, across all open views — the reach of anything
- * that acts on "the tracks the user is looking at": a promoted default's "apply
- * to open tracks", and the share/export bake. One walk so those can't drift
- * apart.
- *
- * Recurses into composite views. A display nested in one resolves the cascade
- * like any other but was invisible to both callers, so the share/export bake
- * didn't bake its inherited values and a shared session containing a
- * breakpoint-split or synteny view rendered differently for the recipient.
- * `LGVSyntenyDisplay` is only ever reached through this branch, so don't flatten
- * the recursion away. `hasChildViews` names the one composite shape it does not
- * cover.
- *
- * A view holding neither (e.g. spreadsheet) drops out via the structural guards.
- * A view whose displays declare no promotable slot (e.g. dotplot, which does
- * hold tracks) is walked and contributes nothing — harmless, and cheaper than
- * asking each display whether it has anything to promote.
- */
-export declare function openPromotableDisplays(session: AbstractSessionModel): ResolvableDisplay[];