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

package/esm/configuration/getConf.d.ts

@@ -1,5 +1,4 @@
-import type { ResolvableDisplay } from './promotableResolve.ts';
-import type { AnyConfigurationModel, AnyConfigurationSnapshot, ConfigurationSchemaForModel, ConfigurationSlotName, ConfigurationSlotValue, ConfigurationSlotValueResolved } from './types.ts';
+import type { AnyConfigurationModel, AnyConfigurationSnapshot, ConfigurationSchemaForModel, ConfigurationSlotName, ConfigurationSlotValue } from './types.ts';
 /**
  * #api core/configuration
  * Reads a configuration value from a state model that has a `.configuration`
@@ -12,12 +11,6 @@ import type { AnyConfigurationModel, AnyConfigurationSnapshot, ConfigurationSche
  * It does not consult the session and has no per-slot behavior; what you read is
  * what the track stores.
  *
- * A `promotable` slot read this way therefore yields the raw stored value,
- * `undefined` included — that `undefined` is the cascade's inherit sentinel, and
- * `resolveConf` is what turns it into a real value. The read type keeps the
- * `undefined` on purpose, so reaching for the wrong reader is a compile error
- * rather than a silent one.
- *
  * @param model - object containing a 'configuration' member
  * @param slotPaths - array of paths to read
  * @param args - extra arguments e.g. for a feature callback,
@@ -29,29 +22,6 @@ export declare function getConf(model: {
 export declare function getConf<CONFMODEL extends AnyConfigurationModel, SLOT extends ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>> | string[] = ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>>>(model: {
     configuration: CONFMODEL;
 }, slotPath: SLOT, args?: Record<string, unknown>): SLOT extends string ? ConfigurationSlotValue<ConfigurationSchemaForModel<CONFMODEL>, SLOT> : any;
-/**
- * #api core/configuration
- * Reads a `promotable` slot through the display-type-default cascade — the
- * track's own value, else the session-wide promoted default for this display
- * type, else the slot's `promotedBase`. Always yields a real value, never the
- * `undefined` inherit sentinel, so a display's value getter is
- * `get displayMode(): DisplayMode { return resolveConf(self, 'displayMode') }`
- * with no post-guard and no cast.
- *
- * Separate from `getConf` rather than folded into it, deliberately: resolution
- * consults the session, so it is main-thread only and throws on a detached node.
- * Folding it in was built and reverted — ADR-046.
- *
- * Throws if `slot` isn't promotable — the cascade has nothing to say about a
- * plain slot, and `getConf` is what you want there.
- *
- * Takes no jexl `args`, unlike `getConf`: a promotable slot cannot hold a
- * callback (see `SlotResolution`), so there is no per-feature context to supply.
- *
- * @param model - the display state model (needs the session + display type)
- * @param slot - the promotable slot to resolve
- */
-export declare function resolveConf<CONFMODEL extends AnyConfigurationModel, SLOT extends ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>> = ConfigurationSlotName<ConfigurationSchemaForModel<CONFMODEL>>>(model: ResolvableDisplay<CONFMODEL>, slot: SLOT): ConfigurationSlotValueResolved<ConfigurationSchemaForModel<CONFMODEL>, SLOT>;
 /**
  * #api core/configuration
  * Write counterpart to `getConf`: sets a slot on a state model that has a
@@ -75,9 +45,9 @@ export declare function resolveConf<CONFMODEL extends AnyConfigurationModel, SLO
  * `HostChecksSlotNames` pins each one.
  *
  * A wrong *value* type still throws at runtime (MST type-checks the assignment)
- * rather than at compile time. `value` is deliberately `unknown` because the
- * inherit sentinel (`undefined`/`null`) is a legitimate write on every
- * promotable slot, which the declared slot value type doesn't include.
+ * rather than at compile time. `value` is deliberately `unknown` because
+ * `undefined` is a legitimate write — it resets a slot to its schema default —
+ * and the declared slot value type doesn't include it.
  *
  * @param model - object containing a 'configuration' member
  * @param slotName - the slot to write

package/esm/configuration/getConf.js

@@ -1,42 +1,7 @@
-import { resolveSlot } from './promotableResolve.js';
 import { readConfObject } from './readConfObject.js';
 export function getConf(model, slotPath, args = {}) {
     return readConfObject(model.configuration, slotPath, args);
 }
-/**
- * #api core/configuration
- * Reads a `promotable` slot through the display-type-default cascade — the
- * track's own value, else the session-wide promoted default for this display
- * type, else the slot's `promotedBase`. Always yields a real value, never the
- * `undefined` inherit sentinel, so a display's value getter is
- * `get displayMode(): DisplayMode { return resolveConf(self, 'displayMode') }`
- * with no post-guard and no cast.
- *
- * Separate from `getConf` rather than folded into it, deliberately: resolution
- * consults the session, so it is main-thread only and throws on a detached node.
- * Folding it in was built and reverted — ADR-046.
- *
- * Throws if `slot` isn't promotable — the cascade has nothing to say about a
- * plain slot, and `getConf` is what you want there.
- *
- * Takes no jexl `args`, unlike `getConf`: a promotable slot cannot hold a
- * callback (see `SlotResolution`), so there is no per-feature context to supply.
- *
- * @param model - the display state model (needs the session + display type)
- * @param slot - the promotable slot to resolve
- */
-export function resolveConf(
-// the display state node itself, not just its `.configuration`: the cascade
-// keys the session-wide tier on `type` and reaches the session through the
-// node. Asking for that shape is what keeps this cast-free — hand it a bare
-// config holder and tsc names the missing members instead of failing at the
-// first read. `ResolvableDisplay<CONFMODEL>`, never
-// `ResolvableDisplay & { configuration: CONFMODEL }`: the intersection
-// re-widens the slot names to `string` (see `ResolvableDisplay`)
-model, slot) {
-    // the resolution is `unknown`, which the declared return type can't infer
-    return resolveSlot(model, slot).value;
-}
 /**
  * #api core/configuration
  * Write counterpart to `getConf`: sets a slot on a state model that has a
@@ -60,9 +25,9 @@ model, slot) {
  * `HostChecksSlotNames` pins each one.
  *
  * A wrong *value* type still throws at runtime (MST type-checks the assignment)
- * rather than at compile time. `value` is deliberately `unknown` because the
- * inherit sentinel (`undefined`/`null`) is a legitimate write on every
- * promotable slot, which the declared slot value type doesn't include.
+ * rather than at compile time. `value` is deliberately `unknown` because
+ * `undefined` is a legitimate write — it resets a slot to its schema default —
+ * and the declared slot value type doesn't include it.
  *
  * @param model - object containing a 'configuration' member
  * @param slotName - the slot to write

package/esm/configuration/index.d.ts

@@ -7,13 +7,12 @@ export { FormatAboutConfigSchemaFactory } from './formatAboutConfigSchema.ts';
 export { DEFAULT_FORMAT_DETAILS_DEPTH, FormatDetailsConfigSchemaFactory, } from './formatDetailsConfigSchema.ts';
 export { mergeFormatCallbacks } from './mergeFormatCallbacks.ts';
 export { readConfObject, readConfSlot, readConfigValue, } from './readConfObject.ts';
-export { getConf, resolveConf, setConf } from './getConf.ts';
+export { getConf, setConf } from './getConf.ts';
+export { fillLocations } from './fillLocations.ts';
 export { expandTabixShorthand, tabixIndexSnapshot } from './tabixShorthand.ts';
 export { tabixIndexFields } from './tabixIndexFields.ts';
 export { evaluateJexl, isCallbackValue } from './slotValueUtils.ts';
 export { toCallbackValue, toFixedValue } from './configurationSlot.ts';
 export { getSlotDefinition, isConfigurationSlot, makeSlotFacade, preProcessSlotValues, slotChoices, } from './slotFacade.ts';
 export type { SlotFacade } from './slotFacade.ts';
-export type { ResolvableDisplay } from './promotableResolve.ts';
-export { clearPromotedDefaults, getDisplayTypeDefaultChanges, isSlotCustomized, makePin, makeTogglePin, getConfigSnapshotWithPromotables, getTrackConfigWithPromotables, } from './promotableDefaults.ts';
-export type { Pin, ResolvedConfigSnapshot, TogglePin, TrackConfigWithPromotables, ValuePin, } from './promotableDefaults.ts';
+export { fullConfSnapshot } from './fullConfSnapshot.ts';

package/esm/configuration/index.js

@@ -10,10 +10,11 @@ export { FormatAboutConfigSchemaFactory } from './formatAboutConfigSchema.js';
 export { DEFAULT_FORMAT_DETAILS_DEPTH, FormatDetailsConfigSchemaFactory, } from './formatDetailsConfigSchema.js';
 export { mergeFormatCallbacks } from './mergeFormatCallbacks.js';
 export { readConfObject, readConfSlot, readConfigValue, } from './readConfObject.js';
-export { getConf, resolveConf, setConf } from './getConf.js';
+export { getConf, setConf } from './getConf.js';
+export { fillLocations } from './fillLocations.js';
 export { expandTabixShorthand, tabixIndexSnapshot } from './tabixShorthand.js';
 export { tabixIndexFields } from './tabixIndexFields.js';
 export { evaluateJexl, isCallbackValue } from './slotValueUtils.js';
 export { toCallbackValue, toFixedValue } from './configurationSlot.js';
 export { getSlotDefinition, isConfigurationSlot, makeSlotFacade, preProcessSlotValues, slotChoices, } from './slotFacade.js';
-export { clearPromotedDefaults, getDisplayTypeDefaultChanges, isSlotCustomized, makePin, makeTogglePin, getConfigSnapshotWithPromotables, getTrackConfigWithPromotables, } from './promotableDefaults.js';
+export { fullConfSnapshot } from './fullConfSnapshot.js';

package/esm/configuration/schemaRegistry.d.ts

@@ -17,8 +17,7 @@ export declare function isRegisteredConfigurationSchema(type: IAnyType): boolean
  * The slot/sub-schema/constant table for a config (includes slots merged in from
  * `baseConfiguration` at schema construction). Undefined when the argument isn't
  * a registered configuration schema. The single accessor for "what are this
- * config's slots?" — shared by the slot facade, promotable defaults, and
- * `fullConfSnapshot`.
+ * config's slots?" — shared by the slot facade and `fullConfSnapshot`.
  *
  * Takes a live node *or* the schema type itself. Every in-tree reader holds a
  * node, which is why the `getType` hop is here; a caller enumerating registered

package/esm/configuration/schemaRegistry.js

@@ -28,8 +28,7 @@ export function isRegisteredConfigurationSchema(type) {
  * The slot/sub-schema/constant table for a config (includes slots merged in from
  * `baseConfiguration` at schema construction). Undefined when the argument isn't
  * a registered configuration schema. The single accessor for "what are this
- * config's slots?" — shared by the slot facade, promotable defaults, and
- * `fullConfSnapshot`.
+ * config's slots?" — shared by the slot facade and `fullConfSnapshot`.
  *
  * Takes a live node *or* the schema type itself. Every in-tree reader holds a
  * node, which is why the `getType` hop is here; a caller enumerating registered

package/esm/configuration/slotFacade.d.ts

@@ -32,20 +32,6 @@ export interface SlotFacade {
     type: ConfigSlotType;
     contextVariable: string[];
     defaultValue: unknown;
-    /**
-     * For a `promotable` slot, the value its unset state resolves to when nothing
-     * is promoted (see `promotableResolve.ts`). Undefined on a plain slot, whose
-     * `defaultValue` is already the concrete value.
-     *
-     * Here because a promotable slot's `defaultValue` is always the `undefined`
-     * inherit sentinel, so an editor rendering `defaultValue` for an unset slot
-     * shows nothing at all — for a `maybeBoolean` that reads as a concrete
-     * `false`, which is wrong for every slot whose base is `true`. The editor
-     * still cannot see the *session* tier of the cascade (its target is often a
-     * detached config node), so this is the honest answer it can give: what unset
-     * means with nothing promoted.
-     */
-    promotedBase?: unknown;
     /** enum choices, present only for `stringEnum`/`maybeStringEnum` slots */
     choices?: string[];
     pluginManager: PluginManager;
@@ -54,8 +40,7 @@ export interface SlotFacade {
      * Whether the slot holds a non-default value. Each slot is `stripDefault`-
      * wrapped, so an at-default slot is omitted from the config snapshot — the
      * same signal the persistence/delta layer uses (robust for map/array slots
-     * where a live-value `deepEqual` against the plain default would misfire). For
-     * a promotable slot, "non-default" means customized rather than inheriting.
+     * where a live-value `deepEqual` against the plain default would misfire).
      */
     readonly modified: boolean;
     set: (val: unknown) => void;

package/esm/configuration/slotFacade.js

@@ -66,14 +66,13 @@ export function getSlotDefinition(node, slotName) {
 }
 export function makeSlotFacade(node, slotName) {
     const definition = getSlotDefinition(node, slotName);
-    const { type, description = '', defaultValue, promotedBase, contextVariable = [], } = definition;
+    const { type, description = '', defaultValue, contextVariable = [], } = definition;
     return {
         name: slotName,
         description,
         type,
         contextVariable,
         defaultValue,
-        promotedBase,
         choices: slotChoices(definition),
         pluginManager: getEnv(node).pluginManager,
         get value() {

package/esm/configuration/tabixShorthand.js

@@ -1,3 +1,4 @@
+import { fillLocations } from './fillLocations.js';
 /**
  * The `index` half of a tabix-indexed adapter's shorthand snapshot: given
  * `{ uri, baseUri?, csi? }`, where the index file sits and what kind it is.
@@ -36,10 +37,9 @@ export function tabixIndexSnapshot(snap) {
  */
 export function expandTabixShorthand(snap, locationKey) {
     return snap.uri
-        ? {
-            ...snap,
+        ? fillLocations(snap, {
             [locationKey]: { uri: snap.uri, baseUri: snap.baseUri },
             index: tabixIndexSnapshot(snap),
-        }
+        })
         : snap;
 }

package/esm/configuration/types.d.ts

@@ -23,7 +23,7 @@ export type ConfigurationSlotName<SCHEMA> = SCHEMA extends undefined ? never : S
  * every value left `unknown`.
  *
  * Names are the whole point of it. A slot value can be its own type, a `jexl:`
- * callback string, or (for a promotable slot) absent, and nothing here tries to
+ * callback string, or (for a `maybe*` slot) absent, and nothing here tries to
  * check that; a *name* the schema does not declare is dropped on the way in
  * without a word, so `preferance` is a setting that reads as applied and never
  * applies. Against an object literal — which is how an embedder writes one —
@@ -34,11 +34,6 @@ export type ConfigurationSnapshot<SCHEMA> = SCHEMA extends undefined ? never : S
 } & {
     [K in GetExplicitIdentifier<SCHEMA>]?: string;
 } & (GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSnapshot<GetBase<SCHEMA>> : unknown) : unknown;
-type SlotValueResolvedFromDef<DEF> = DEF extends {
-    promotedBase: undefined;
-} ? SlotValueRawFromDef<DEF> : DEF extends {
-    promotedBase: unknown;
-} ? Exclude<SlotValueRawFromDef<DEF>, undefined> : SlotValueRawFromDef<DEF>;
 /**
  * The value each builtin slot `type` reads as — the type-level twin of
  * `slotTypes` in `configurationSlot.ts`, which is the same list as MST models.
@@ -66,9 +61,8 @@ interface SlotValueByType {
      * only add cast ceremony on values that are legitimately dynamic.
      *
      * Stated here rather than left to the `defaultValue` fallback, which reaches
-     * `any` for these only by accident: it lands there because no `frozen` slot in
-     * the repo happens to default to a scalar, and a promotable slot's default is
-     * always the `undefined` sentinel.
+     * `any` for these only by accident: no `frozen` slot in the repo happens to
+     * default to a scalar.
      */
     frozen: any;
     maybeFrozen: any;
@@ -106,11 +100,6 @@ type SlotValueRawFromDef<DEF> = DEF extends AnyConfigurationSchemaType ? AnyConf
 } ? [V] extends [boolean] ? boolean : [V] extends [string] ? string : [V] extends [number] ? number : any : any;
 /** what a raw read (`getConf` / `readConfObject`) of this slot yields */
 export type ConfigurationSlotValue<SCHEMA, K extends string> = SCHEMA extends ConfigurationSchemaType<infer D, any> ? K extends keyof D ? SlotValueRawFromDef<D[K]> : GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSlotValue<GetBase<SCHEMA>, K> : any : any;
-/**
- * what `resolveConf` yields: the same, minus the inherit sentinel on a
- * promotable slot — the cascade always produces a real value.
- */
-export type ConfigurationSlotValueResolved<SCHEMA, K extends string> = SCHEMA extends ConfigurationSchemaType<infer D, any> ? K extends keyof D ? SlotValueResolvedFromDef<D[K]> : GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSlotValueResolved<GetBase<SCHEMA>, K> : any : any;
 /**
  * Naming convention for config types, paired per schema:
  * - `XConfigSchema` is the MST IType (the schema itself). Use it for
@@ -154,8 +143,7 @@ export type ConfigModelForFields<FIELDS extends ConfigurationSchemaDefinition, B
  * ```
  *
  * Worth a named type because the widened form has **no symptom** — a mixin host
- * cast to `AnyConfigurationModel`, or to the `ResolvableDisplay & { … }`
- * intersection that re-widens, compiles and runs and checks nothing. Every
+ * cast to `AnyConfigurationModel` compiles and runs and checks nothing. Every
  * misspelled slot name below it typechecks, and a misspelled *read* returns
  * `undefined` with no diagnostic at any layer, so only a sabotage or this
  * assertion tells the two apart.

package/esm/data_adapters/CytobandAdapter/configSchema.js

@@ -1,4 +1,4 @@
-import { ConfigurationSchema } from '../../configuration/index.js';
+import { ConfigurationSchema, fillLocations, } from '../../configuration/index.js';
 /**
  * #config CytobandAdapter
  *
@@ -55,13 +55,12 @@ const configSchema = ConfigurationSchema('CytobandAdapter', {
     preProcessSnapshot: snap => {
         // populate from just snap.uri
         return snap.uri
-            ? {
-                ...snap,
+            ? fillLocations(snap, {
                 cytobandLocation: {
                     uri: snap.uri,
                     baseUri: snap.baseUri,
                 },
-            }
+            })
             : snap;
     },
 });

package/esm/pluggableElementTypes/DisplayType.d.ts

@@ -7,9 +7,11 @@ export default class DisplayType extends LazyStateModelElement {
     configSchema: AnyConfigurationSchemaType;
     ReactComponent: AnyReactComponentType;
     /**
-     * The track type the display is associated with
+     * The track type the display attaches to, or several: a display that reads
+     * a field any feature adapter serves (the Manhattan plot's `score`) belongs
+     * to every track type whose adapters serve it.
      */
-    trackType: string;
+    trackType: string | string[];
     /**
      * The view type the display is associated with
      */
@@ -21,7 +23,7 @@ export default class DisplayType extends LazyStateModelElement {
     constructor(stuff: {
         name: string;
         stateModel: IAnyModelType | (() => Promise<IAnyModelType>);
-        trackType: string;
+        trackType: string | string[];
         viewType: string;
         displayName?: string;
         configSchema: AnyConfigurationSchemaType;

package/esm/pluggableElementTypes/DisplayType.js

@@ -4,7 +4,9 @@ export default class DisplayType extends LazyStateModelElement {
     configSchema;
     ReactComponent;
     /**
-     * The track type the display is associated with
+     * The track type the display attaches to, or several: a display that reads
+     * a field any feature adapter serves (the Manhattan plot's `score`) belongs
+     * to every track type whose adapters serve it.
      */
     trackType;
     /**

package/esm/pluggableElementTypes/models/BaseTrackModel.d.ts

@@ -95,6 +95,22 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
      * a shown track always has at least one display
      */
     readonly activeDisplay: DisplayModel & import("@jbrowse/mobx-state-tree").IStateTreeNode<IType<unknown, unknown, DisplayModel>>;
+    /**
+     * #getter
+     * the configured displays the CONTAINING VIEW can draw, which is the set
+     * `replaceDisplay` will accept
+     *
+     * `configuration.displays` is not that set: baseTrackConfig injects one
+     * entry per display type registered for the track TYPE, across every
+     * view type, so a VariantTrack carries a ChordVariantDisplay a linear
+     * view cannot draw. The track menu's own "Display types" submenu has
+     * always filtered them; this exposes the same list to code, because the
+     * alternative is every caller re-deriving it from the plugin manager.
+     */
+    readonly compatibleDisplays: (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
+        setSubschema(slotName: string, data: Record<string, unknown>): any;
+        setSlot(slotName: string, value: unknown): void;
+    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<AnyConfigurationSchemaType>)[];
     /**
      * #getter
      */
@@ -195,6 +211,20 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
      * stops changing.
      */
     afterAttach(): void;
+} & {
+    /**
+     * #action
+     * The awaitable sibling of `replaceDisplay`: loads the target display's
+     * state model, then swaps to it carrying whatever settings the outgoing
+     * display can hand over.
+     *
+     * `replaceDisplay` stays a plain sync action and ASSERTS the model is
+     * loaded, and every display state model in this tree is a dynamic import
+     * until something shows one — so a caller that has not already shown the
+     * target needs this. Named like `launchTrack`, which is the same problem
+     * one level up.
+     */
+    launchDisplay(displayId: string): Promise<void>;
 } & {
     /**
      * #getter

package/esm/pluggableElementTypes/models/BaseTrackModel.js

@@ -156,6 +156,21 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
         get activeDisplay() {
             return self.displays[0];
         },
+        /**
+         * #getter
+         * the configured displays the CONTAINING VIEW can draw, which is the set
+         * `replaceDisplay` will accept
+         *
+         * `configuration.displays` is not that set: baseTrackConfig injects one
+         * entry per display type registered for the track TYPE, across every
+         * view type, so a VariantTrack carries a ChordVariantDisplay a linear
+         * view cannot draw. The track menu's own "Display types" submenu has
+         * always filtered them; this exposes the same list to code, because the
+         * alternative is every caller re-deriving it from the plugin manager.
+         */
+        get compatibleDisplays() {
+            return getCompatibleDisplays(self);
+        },
         /**
          * #getter
          */
@@ -350,6 +365,28 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
                 void releaseAdapterSession(rpcManager, retained);
             });
         },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         * The awaitable sibling of `replaceDisplay`: loads the target display's
+         * state model, then swaps to it carrying whatever settings the outgoing
+         * display can hand over.
+         *
+         * `replaceDisplay` stays a plain sync action and ASSERTS the model is
+         * loaded, and every display state model in this tree is a dynamic import
+         * until something shows one — so a caller that has not already shown the
+         * target needs this. Named like `launchTrack`, which is the same problem
+         * one level up.
+         */
+        async launchDisplay(displayId) {
+            const displays = self.configuration.displays;
+            const { type } = getDisplayConf(displays, displayId);
+            await pm.resolveDisplayTypeRecord(type)?.loadStateModel();
+            if (isAlive(self)) {
+                self.replaceDisplay(self.activeDisplay.configuration.displayId, displayId, self.activeDisplay.getPortableSettings?.(displayId) ?? {});
+            }
+        },
     }))
         .views(self => ({
         /**
@@ -430,7 +467,7 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
         trackMenuItems() {
             const menuItems = self.displays.flatMap(d => d.trackMenuItems());
             const shownId = self.activeDisplay.configuration.displayId;
-            const compatDisp = getCompatibleDisplays(self);
+            const compatDisp = self.compatibleDisplays;
             return [
                 ...menuItems,
                 ...(compatDisp.length > 1 && shownId
@@ -451,24 +488,15 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
                                     // being replaced, so leaving the menu up would keep a
                                     // list of items built against a destroyed MST node
                                     keepMenuOpen: false,
-                                    // the chosen display's state model may still be a dynamic
-                                    // import away, so load it before swapping — replaceDisplay
-                                    // itself stays a plain sync action
+                                    // launchDisplay, because the chosen display's state
+                                    // model may still be a dynamic import away
                                     onClick: () => {
                                         if (d.displayId !== shownId) {
-                                            void (async () => {
-                                                try {
-                                                    await pm
-                                                        .resolveDisplayTypeRecord(d.type)
-                                                        ?.loadStateModel();
-                                                    if (isAlive(self)) {
-                                                        self.replaceDisplay(shownId, d.displayId, self.activeDisplay.getPortableSettings?.(d.displayId) ?? {});
-                                                    }
-                                                }
-                                                catch (e) {
-                                                    getSession(self).notifyError(`${e}`, e);
-                                                }
-                                            })();
+                                            void self
+                                                .launchDisplay(d.displayId)
+                                                .catch((e) => {
+                                                getSession(self).notifyError(`${e}`, e);
+                                            });
                                         }
                                     },
                                 };

package/esm/rpc/RpcRegistry.d.ts

@@ -1,11 +1,12 @@
 import type { FeatureDensity } from '../data_adapters/BaseAdapter/featureDensity.ts';
+import type { CoreEncodeFeaturesArgs, EncodedFeaturesResult } from '../util/markEncodingTypes.ts';
 import type { StatusCallback } from '../util/progress.ts';
 import type { UnwrapRpcResult } from '../util/rpc.ts';
 import type { Feature, SimpleFeatureSerialized } from '../util/simpleFeature.ts';
 import type { StopToken } from '../util/stopToken.ts';
 import type { NoAssemblyRegion } from '../util/types/data.ts';
 import type { RpcResult } from './RpcServer.ts';
-import type { ByteEstimateScope } from './byteBudget.ts';
+import type { ByteEstimateScope, RegionTooLargeResult } from './byteBudget.ts';
 export interface RegionLike {
     refName: string;
     start: number;
@@ -44,6 +45,11 @@ export interface RpcRegistry {
         return: Feature[];
         wire: SimpleFeatureSerialized[];
     };
+    CoreEncodeFeatures: {
+        args: CoreEncodeFeaturesArgs;
+        return: EncodedFeaturesResult | RegionTooLargeResult;
+        transferables: EncodedFeaturesResult;
+    };
     CoreGetRegionByteEstimate: {
         args: {
             adapterConfig: Record<string, unknown>;

package/esm/rpc/coreRpcMethods.d.ts

@@ -2,6 +2,7 @@ export { default as CoreGetRefNames } from './methods/CoreGetRefNames.ts';
 export { default as CoreGetMetadata } from './methods/CoreGetMetadata.ts';
 export { default as CoreGetInfo } from './methods/CoreGetInfo.ts';
 export { default as CoreGetFeatures } from './methods/CoreGetFeatures.ts';
+export { default as CoreEncodeFeatures } from './methods/CoreEncodeFeatures.ts';
 export { default as CoreGetSequence } from './methods/CoreGetSequence.ts';
 export { default as CoreFreeResources } from './methods/CoreFreeResources.ts';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.ts';

package/esm/rpc/coreRpcMethods.js

@@ -2,6 +2,7 @@ export { default as CoreGetRefNames } from './methods/CoreGetRefNames.js';
 export { default as CoreGetMetadata } from './methods/CoreGetMetadata.js';
 export { default as CoreGetInfo } from './methods/CoreGetInfo.js';
 export { default as CoreGetFeatures } from './methods/CoreGetFeatures.js';
+export { default as CoreEncodeFeatures } from './methods/CoreEncodeFeatures.js';
 export { default as CoreGetSequence } from './methods/CoreGetSequence.js';
 export { default as CoreFreeResources } from './methods/CoreFreeResources.js';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.js';

package/esm/rpc/methods/CoreEncodeFeatures.d.ts

@@ -0,0 +1,15 @@
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.ts';
+import type { EncodedFeaturesResult } from '../../util/markEncoding.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * Fetch a region's features once, run the shared transform steps over them,
+ * then each layer's own, and evaluate the layer's encoding over what is left
+ * in the worker, where the `Feature` objects are, filling the lanes its shape
+ * reads. The colours come back packed, the scale tables resolved, and the
+ * main thread reads the same table for its legend that the colours were
+ * drawn from.
+ */
+export default class CoreEncodeFeatures extends RpcMethodTypeWithRenameRegion<'CoreEncodeFeatures'> {
+    name: 'CoreEncodeFeatures';
+    execute(args: RpcExecuteArgs<'CoreEncodeFeatures'>): Promise<import("../byteBudget.ts").RegionTooLargeResult | import("../RpcServer.ts").RpcResult<EncodedFeaturesResult>>;
+}

package/esm/rpc/methods/CoreEncodeFeatures.js

@@ -0,0 +1,62 @@
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.js';
+import { runTransforms } from '../../util/featureTransforms.js';
+import { rpcResult } from '../../util/librpc.js';
+import { encodeFeatures, encodedChannelTransferables, } from '../../util/markEncoding.js';
+import { createProgressReporter, updateStatus } from '../../util/progress.js';
+import { checkStopTokenThrottled, createStopTokenChecker, } from '../../util/stopToken.js';
+import { measureRegionBytes } from '../byteBudget.js';
+/**
+ * Fetch a region's features once, run the shared transform steps over them,
+ * then each layer's own, and evaluate the layer's encoding over what is left
+ * in the worker, where the `Feature` objects are, filling the lanes its shape
+ * reads. The colours come back packed, the scale tables resolved, and the
+ * main thread reads the same table for its legend that the colours were
+ * drawn from.
+ */
+export default class CoreEncodeFeatures extends RpcMethodTypeWithRenameRegion {
+    name = 'CoreEncodeFeatures';
+    async execute(args) {
+        const { sessionId, adapterConfig, sequenceAdapter, region, layers: requested, transform = [], filters = [], byteLimit, stopToken, statusCallback, } = args;
+        const { pluginManager } = this;
+        const stopTokenCheck = createStopTokenChecker(stopToken);
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            pluginManager,
+            sessionId,
+            adapterConfig,
+            sequenceAdapter,
+        });
+        const { bytes, tooLarge } = await measureRegionBytes({
+            dataAdapter,
+            regions: [region],
+            byteLimit,
+            stopToken,
+            statusCallback,
+            stopTokenCheck,
+        });
+        if (tooLarge) {
+            return tooLarge;
+        }
+        const fetched = await updateStatus('Downloading features', statusCallback, () => dataAdapter.getFeaturesArray(region, { statusCallback, stopToken }));
+        checkStopTokenThrottled(stopTokenCheck);
+        const { jexl } = pluginManager;
+        const shared = runTransforms(fetched, [
+            ...filters.map(expr => ({ type: 'filter', expr })),
+            ...transform,
+        ], jexl);
+        const layers = requested.map(({ encoding, lanes, transform: own }) => {
+            const features = own ? runTransforms(shared, own, jexl) : shared;
+            return encodeFeatures(features, encoding, lanes, {
+                jexl,
+                report: createProgressReporter({
+                    label: 'Encoding features',
+                    total: features.length,
+                    statusCallback,
+                    stopTokenCheck,
+                }),
+            });
+        });
+        const result = { layers, bytes };
+        return rpcResult(result, layers.flatMap(l => encodedChannelTransferables(l)));
+    }
+}

package/esm/svg/svgId.d.ts

@@ -5,7 +5,7 @@
  * Injective but NOT idempotent — escaping the marker is what buys injectivity,
  * so a second pass re-escapes the `~`s the first one wrote. Apply it exactly
  * once, at the place that emits both the id and the reference to it
- * (`SvgClipRect` and `SvgGradientLegend` already do; a hand-rolled `<clipPath>`
+ * (`SvgClipRect` and `SvgColorLegend` already do; a hand-rolled `<clipPath>`
  * must). Double-applying is harmless to correctness — the id and its `url()`
  * still agree, since both are derived from one call — but it produces noisy ids
  * for no reason.

package/esm/svg/svgId.js

@@ -34,7 +34,7 @@ const UNSAFE_ID_CHAR = /[^\w.:-]/g;
  * Injective but NOT idempotent — escaping the marker is what buys injectivity,
  * so a second pass re-escapes the `~`s the first one wrote. Apply it exactly
  * once, at the place that emits both the id and the reference to it
- * (`SvgClipRect` and `SvgGradientLegend` already do; a hand-rolled `<clipPath>`
+ * (`SvgClipRect` and `SvgColorLegend` already do; a hand-rolled `<clipPath>`
  * must). Double-applying is harmless to correctness — the id and its `url()`
  * still agree, since both are derived from one call — but it produces noisy ids
  * for no reason.