@jbrowse/core 5.0.0-beta.10 → 5.0.0-beta.11

package/esm/configuration/plot.js

@@ -0,0 +1,142 @@
+import { getSnapshot, getType, isArrayType, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
+import { compareStructural } from 'mobx';
+import { getConfigurationSchemaMetadata } from './schemaRegistry.js';
+import { bareFormOf, shorthandTargets } from './schemaTypes.js';
+/**
+ * #api core/configuration
+ * The grammar's settings, by the slot name every display that has one gives
+ * it, and what each holds: what "Edit plot..." shows and an agent reads as a
+ * display's `plot`. A display's plot is the ones its config declares
+ * (`plotKeysOf`).
+ */
+export const PLOT_VOCABULARY = {
+    marks: 'the marks drawn in order, each a mark and an encoding',
+    transform: 'the steps run over the features before any mark',
+    facet: 'one section per value of a field',
+    rows: 'the rows: their field or order, labels, focus and tree',
+    rowColor: 'the colour of each row label',
+    color: 'the colour',
+    baseColor: 'the per-base layer over the reads',
+    arcColor: 'the colour of the arcs between mates',
+    ribbonColor: 'the colour of the ribbons between lanes',
+    laneLayers: 'the layers drawn over each lane',
+    scales: 'the axes, scales.y the value axis',
+    filter: 'the jexl: expressions a feature has to pass',
+    filterBy: 'the read flags and tags a read has to pass',
+};
+const LIFT_ID = 'plotLift';
+/**
+ * #api core/configuration
+ * The plot keys a display config declares.
+ */
+export function plotKeysOf(conf) {
+    const definition = getConfigurationSchemaMetadata(conf)?.definition ?? {};
+    return Object.keys(PLOT_VOCABULARY).filter(key => Object.hasOwn(definition, key));
+}
+// A one-member object a shorthand would write as a bare value prints as that
+// value, as a config file writes it: `color: "red"`, `facet: "strand"`.
+function folded(member, value) {
+    if (!isStateTreeNode(member) ||
+        typeof value !== 'object' ||
+        value === null ||
+        Array.isArray(value)) {
+        return value;
+    }
+    const meta = getConfigurationSchemaMetadata(member);
+    const entries = Object.entries(value);
+    if (!meta || meta.options.shorthandWith || entries.length !== 1) {
+        return value;
+    }
+    const [slot, bare] = entries[0];
+    const form = bareFormOf(bare);
+    return form && shorthandTargets(meta)[form] === slot ? bare : value;
+}
+/**
+ * #api core/configuration
+ * A display's plot as declared, defaults left off. A list sitting at a
+ * default it shares with no other display, a default plot's marks, shows its
+ * entries, since they are what is drawn.
+ */
+export function plotOf(conf) {
+    const snapshot = getSnapshot(conf);
+    const plot = {};
+    for (const key of plotKeysOf(conf)) {
+        const member = conf[key];
+        const value = snapshot[key] ??
+            (isStateTreeNode(member) &&
+                isArrayType(getType(member)) &&
+                member.length > 0
+                ? getSnapshot(member)
+                : undefined);
+        if (value !== undefined) {
+            plot[key] = folded(member, value);
+        }
+    }
+    return plot;
+}
+function checkKeys(draft, keys) {
+    const unknown = Object.keys(draft).filter(key => !keys.includes(key));
+    if (unknown.length > 0) {
+        throw new Error(`This display's plot is ${keys.join(', ')}, not ${unknown.join(', ')}`);
+    }
+}
+/**
+ * #api core/configuration
+ * The text as a plot, refusing a key the display's plot does not hold. The
+ * schema is the parser past this point.
+ */
+export function parsePlot(text, keys) {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`A plot is one JSON object of ${keys.join(', ')}`);
+    }
+    checkKeys(parsed, keys);
+    return parsed;
+}
+function merged(draft, current) {
+    const out = { ...current };
+    for (const [key, value] of Object.entries(draft)) {
+        if (value === null) {
+            delete out[key];
+        }
+        else if (value !== undefined) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/**
+ * #api core/configuration
+ * A draft as the display's config would hold it, through the schema's own
+ * lift and checks: a shorthand becomes its object, a default falls off, and
+ * what a config file is refused for throws, a key outside the plot included.
+ * The node is never attached, so nothing on the display is touched; a display
+ * reads its typed members off it. The draft is copied first, since MST
+ * freezes what it creates from.
+ */
+export function liftPlot(conf, draft) {
+    checkKeys(draft, plotKeysOf(conf));
+    return getType(conf).create({
+        displayId: LIFT_ID,
+        ...structuredClone(merged(draft, plotOf(conf))),
+    });
+}
+/**
+ * #api core/configuration
+ * What applying a draft writes: each setting whose lifted value differs from
+ * the plot, as the lifted value, and `null` for one it resets. A value
+ * spelled another way but lifting to the same setting writes nothing.
+ * Throws a refusal before anything is written.
+ */
+export function plotWrites(conf, draft) {
+    const current = plotOf(conf);
+    const lifted = plotOf(liftPlot(conf, draft));
+    const writes = {};
+    for (const [key, value] of Object.entries(draft)) {
+        if (value === undefined || compareStructural(lifted[key], current[key])) {
+            continue;
+        }
+        writes[key] = lifted[key] ?? null;
+    }
+    return writes;
+}

package/esm/pluggableElementTypes/DisplayType.d.ts

@@ -1,5 +1,6 @@
 import LazyStateModelElement from './LazyStateModelElement.ts';
 import type { AnyConfigurationSchemaType } from '../configuration/index.ts';
+import type { PlotExample } from '../configuration/plot.ts';
 import type { AnyReactComponentType } from '../util/index.ts';
 import type { IAnyModelType } from '@jbrowse/mobx-state-tree';
 export type DisplayEntry = Record<string, unknown>;
@@ -54,6 +55,11 @@ export default class DisplayType extends LazyStateModelElement {
     adapterCapabilities: readonly string[];
     retiredTypes: readonly RetiredDisplayType[];
     retiredState?: RetiredDisplayState;
+    /**
+     * Worked examples of this display's plot, which "Edit plot..." offers as
+     * buttons. Each has to pass the display's config schema.
+     */
+    plotExamples: readonly PlotExample[];
     constructor(stuff: {
         name: string;
         stateModel: IAnyModelType | (() => Promise<IAnyModelType>);
@@ -66,5 +72,6 @@ export default class DisplayType extends LazyStateModelElement {
         adapterCapabilities?: readonly string[];
         retiredTypes?: readonly RetiredDisplayType[];
         retiredState?: RetiredDisplayState;
+        plotExamples?: readonly PlotExample[];
     });
 }

package/esm/pluggableElementTypes/DisplayType.js

@@ -26,6 +26,11 @@ export default class DisplayType extends LazyStateModelElement {
     adapterCapabilities;
     retiredTypes;
     retiredState;
+    /**
+     * Worked examples of this display's plot, which "Edit plot..." offers as
+     * buttons. Each has to pass the display's config schema.
+     */
+    plotExamples;
     constructor(stuff) {
         super({
             ...stuff,
@@ -39,5 +44,6 @@ export default class DisplayType extends LazyStateModelElement {
         this.adapterCapabilities = stuff.adapterCapabilities ?? [];
         this.retiredTypes = stuff.retiredTypes ?? [];
         this.retiredState = stuff.retiredState;
+        this.plotExamples = stuff.plotExamples ?? [];
     }
 }

package/esm/pluggableElementTypes/WidgetType.d.ts

@@ -14,6 +14,11 @@ export default class WidgetType extends PluggableElementBase {
     ReactComponent: WidgetComponentType;
     stateModel: IAnyModelType;
     helpText?: React.ReactNode;
+    /**
+     * Closing the widget removes it from the session rather than hiding it, so
+     * what it holds stops riding along in every saved and shared session (#3538)
+     */
+    discardOnClose: boolean;
     constructor(stuff: {
         name: string;
         heading?: string;
@@ -22,6 +27,7 @@ export default class WidgetType extends PluggableElementBase {
         stateModel: IAnyModelType;
         ReactComponent: WidgetComponentType;
         helpText?: React.ReactNode;
+        discardOnClose?: boolean;
     });
 }
 export {};

package/esm/pluggableElementTypes/WidgetType.js

@@ -6,6 +6,11 @@ export default class WidgetType extends PluggableElementBase {
     ReactComponent;
     stateModel;
     helpText;
+    /**
+     * Closing the widget removes it from the session rather than hiding it, so
+     * what it holds stops riding along in every saved and shared session (#3538)
+     */
+    discardOnClose;
     constructor(stuff) {
         super(stuff);
         this.heading = stuff.heading;
@@ -14,5 +19,6 @@ export default class WidgetType extends PluggableElementBase {
         this.stateModel = stuff.stateModel;
         this.ReactComponent = stuff.ReactComponent;
         this.helpText = stuff.helpText;
+        this.discardOnClose = stuff.discardOnClose ?? false;
     }
 }

package/esm/pluggableElementTypes/index.js

@@ -9,15 +9,8 @@ export { default as ViewType } from './ViewType.js';
 export { default as DisplayType } from './DisplayType.js';
 export { default as InternetAccountType } from './InternetAccountType.js';
 export { default as RpcMethodType } from './RpcMethodType.js';
-// The two region-renaming bases, which nearly every RPC method that takes a
-// viewport wants — without them an external plugin deep-imports the file and
-// bundles its own copy, which is only harmless because RPC methods are keyed by
-// name (PluginManager.rpcMethods) and nothing does an instanceof.
 // `RpcMethodTypeWithFiltersAndRenameRegions` is deliberately not here: it pulls
-// in `renderers/util/serializableFilterChain`, and RFC-001 §9 deletes
-// `pluggableElementTypes/renderers/*` after the legacy renderer migration. This
-// barrel is served as ABI, so exporting it would pin a directory we intend to
-// remove.
+// in `renderers/util/serializableFilterChain`, and this barrel is served as ABI.
 export { default as RpcMethodTypeWithRenameRegion } from './RpcMethodTypeWithRenameRegion.js';
 export { default as RpcMethodTypeWithRenameRegions } from './RpcMethodTypeWithRenameRegions.js';
 export { default as AddTrackWorkflowType } from './AddTrackWorkflowType.js';

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

@@ -1,4 +1,5 @@
 import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type { Plot, PlotExample } from '../../configuration/plot.ts';
 import type { MenuItem } from '../../ui/index.ts';
 import type { RpcStatus } from '../../util/progress.ts';
 import type { UnappliedSetting } from '../../util/unknownSnapshotKeys.ts';
@@ -670,7 +671,7 @@ export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<
      * `installClearHoverOnViewportChange` calls.
      *
      * A display that STORES its hover owes an override; one that derives it
-     * from the live pointer (MAF, Hi-C, LD) owes nothing, and the default
+     * from the live pointer (Hi-C, LD) owes nothing, and the default
      * costs it nothing. Declared here so the clear can be installed for every
      * display rather than remembered per display — forgetting it is the
      * failure ARCHITECTURE.md's stored-hover section is about, and it used to
@@ -722,6 +723,61 @@ export declare const BaseDisplay: import("@jbrowse/mobx-state-tree").IModelType<
             error: string;
         }[];
     };
+} & {
+    /**
+     * #getter
+     * The grammar settings this display's config declares, by slot name
+     * (`PLOT_VOCABULARY`): what "Edit plot..." edits. Empty on a display
+     * with none, which then offers no editor.
+     */
+    readonly plotKeys: string[];
+    /**
+     * #getter
+     * Those settings as declared, defaults left off and a shorthand written
+     * as a config file writes it. An agent edits a `structuredClone` of it,
+     * checks it with `plotProblems` and hands it to `applyPlot`.
+     */
+    readonly plot: Plot;
+    /**
+     * #getter
+     * The worked examples this display type declares, which "Edit plot..."
+     * offers as buttons.
+     */
+    readonly plotExamples: readonly PlotExample[];
+    /**
+     * #getter
+     * This display type's page in the config reference, which lists every
+     * setting it takes.
+     */
+    readonly configDocsUrl: string;
+    /**
+     * #method
+     * A draft as the config would hold it, merged over `plot`, throwing what
+     * a config file would be refused for. Nothing on the display changes.
+     */
+    liftPlot(draft: Plot): AnyConfigurationModel;
+    /**
+     * #method
+     * What a draft would report once applied, throwing a refusal as
+     * `liftPlot` does. A display with a rule list over its settings
+     * overrides it; the draft still applies, and draws what it can.
+     */
+    plotProblems(draft: Plot): string[];
+    /**
+     * #method
+     * What applying a draft would write, by setting: the lifted value where
+     * it differs from `plot`, `null` where it resets one. Throws a refusal.
+     */
+    plotWrites(draft: Plot): Record<string, unknown>;
+} & {
+    /**
+     * #action
+     * Write a draft over `plot`: each setting it changes is replaced whole,
+     * so a member left out of an object goes back to its default, and `null`
+     * resets the setting. A draft the schema refuses, or naming a setting
+     * outside the plot, throws before anything is written.
+     */
+    applyPlot(draft: Plot): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
 export type BaseDisplayStateModel = typeof BaseDisplay;
 export type BaseDisplayModel = Instance<BaseDisplayStateModel>;

package/esm/pluggableElementTypes/models/BaseDisplayModel.js

@@ -1,5 +1,6 @@
 import { hasParent, isAlive, types } from '@jbrowse/mobx-state-tree';
-import { applyConfSettings, getConf } from '../../configuration/index.js';
+import { applyConfSettings, getConfigurationSchemaMetadata, getConf, setConf, } from '../../configuration/index.js';
+import { liftPlot as liftPlotDraft, plotKeysOf, plotOf, plotWrites as plotWritesOf, } from '../../configuration/plot.js';
 import { getContainingTrack, getEnv, statusFraction, statusMessageText, } from '../../util/index.js';
 import { ElementId } from '../../util/types/mst.js';
 import { displaySetterName } from '../../util/unknownSnapshotKeys.js';
@@ -198,7 +199,7 @@ function stateModelFactory() {
          * `installClearHoverOnViewportChange` calls.
          *
          * A display that STORES its hover owes an override; one that derives it
-         * from the live pointer (MAF, Hi-C, LD) owes nothing, and the default
+         * from the live pointer (Hi-C, LD) owes nothing, and the default
          * costs it nothing. Declared here so the clear can be installed for every
          * display rather than remembered per display — forgetting it is the
          * failure ARCHITECTURE.md's stored-hover section is about, and it used to
@@ -272,6 +273,87 @@ function stateModelFactory() {
             }
             return { applied, unapplied, failed };
         },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * The grammar settings this display's config declares, by slot name
+         * (`PLOT_VOCABULARY`): what "Edit plot..." edits. Empty on a display
+         * with none, which then offers no editor.
+         */
+        get plotKeys() {
+            return plotKeysOf(self.configuration);
+        },
+        /**
+         * #getter
+         * Those settings as declared, defaults left off and a shorthand written
+         * as a config file writes it. An agent edits a `structuredClone` of it,
+         * checks it with `plotProblems` and hands it to `applyPlot`.
+         */
+        get plot() {
+            return plotOf(self.configuration);
+        },
+        /**
+         * #getter
+         * The worked examples this display type declares, which "Edit plot..."
+         * offers as buttons.
+         */
+        get plotExamples() {
+            const { pluginManager } = getEnv(self);
+            return pluginManager.getDisplayType(self.type).plotExamples;
+        },
+        /**
+         * #getter
+         * This display type's page in the config reference, which lists every
+         * setting it takes.
+         */
+        get configDocsUrl() {
+            const name = getConfigurationSchemaMetadata(self.configuration)?.name;
+            return name
+                ? `https://jbrowse.org/jb2/docs/config/${name.toLowerCase()}/`
+                : 'https://jbrowse.org/jb2/docs/config_guide/';
+        },
+        /**
+         * #method
+         * A draft as the config would hold it, merged over `plot`, throwing what
+         * a config file would be refused for. Nothing on the display changes.
+         */
+        liftPlot(draft) {
+            return liftPlotDraft(self.configuration, draft);
+        },
+        /**
+         * #method
+         * What a draft would report once applied, throwing a refusal as
+         * `liftPlot` does. A display with a rule list over its settings
+         * overrides it; the draft still applies, and draws what it can.
+         */
+        plotProblems(draft) {
+            this.liftPlot(draft);
+            return [];
+        },
+        /**
+         * #method
+         * What applying a draft would write, by setting: the lifted value where
+         * it differs from `plot`, `null` where it resets one. Throws a refusal.
+         */
+        plotWrites(draft) {
+            return plotWritesOf(self.configuration, draft);
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         * Write a draft over `plot`: each setting it changes is replaced whole,
+         * so a member left out of an object goes back to its default, and `null`
+         * resets the setting. A draft the schema refuses, or naming a setting
+         * outside the plot, throws before anything is written.
+         */
+        applyPlot(draft) {
+            const { configuration } = self;
+            for (const [key, value] of Object.entries(self.plotWrites(draft))) {
+                setConf(configuration, key, value);
+            }
+        },
     }));
 }
 export const BaseDisplay = stateModelFactory();

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

@@ -29,7 +29,7 @@ declare const BaseViewModel: import("@jbrowse/mobx-state-tree").IModelType<{
      *
      * `ViewContainer` mounts a view's body only while an IntersectionObserver
      * says it is on screen, to hold the app under the WebGL2 context ceiling
-     * (`reference/GPU_CONTEXT_BUDGET.md`). A view below the fold therefore has
+     * (`reference/GPU_PORTABILITY.md`). A view below the fold therefore has
      * no canvas, so nothing ever calls `markCanvasDrawn` and the pre-first-paint
      * term of `displayPhase` pins every display in it at `loading` with nothing
      * left to resolve it — which parks `[data-app-phase="ready"]` for the whole
@@ -169,7 +169,7 @@ export declare const BaseViewModelWithDisplayedRegions: import("@jbrowse/mobx-st
      *
      * `ViewContainer` mounts a view's body only while an IntersectionObserver
      * says it is on screen, to hold the app under the WebGL2 context ceiling
-     * (`reference/GPU_CONTEXT_BUDGET.md`). A view below the fold therefore has
+     * (`reference/GPU_PORTABILITY.md`). A view below the fold therefore has
      * no canvas, so nothing ever calls `markCanvasDrawn` and the pre-first-paint
      * term of `displayPhase` pins every display in it at `loading` with nothing
      * left to resolve it — which parks `[data-app-phase="ready"]` for the whole

package/esm/pluggableElementTypes/models/BaseViewModel.js

@@ -54,7 +54,7 @@ const BaseViewModel = types
      *
      * `ViewContainer` mounts a view's body only while an IntersectionObserver
      * says it is on screen, to hold the app under the WebGL2 context ceiling
-     * (`reference/GPU_CONTEXT_BUDGET.md`). A view below the fold therefore has
+     * (`reference/GPU_PORTABILITY.md`). A view below the fold therefore has
      * no canvas, so nothing ever calls `markCanvasDrawn` and the pre-first-paint
      * term of `displayPhase` pins every display in it at `loading` with nothing
      * left to resolve it — which parks `[data-app-phase="ready"]` for the whole

package/esm/ui/JexlFilterDialog.d.ts

@@ -7,7 +7,7 @@ export interface JexlFilterExample {
 }
 /**
  * Editor for a display's jexl feature filters, for any display implementing
- * the two-tier {@link JexlFilterModel} contract. The Conditions tab shows each
+ * the {@link JexlFilterModel} contract. The Conditions tab shows each
  * line as rows of field, operator and value where it can, and as text where it
  * cannot; the Text tab is every line as text.
  *

package/esm/ui/JexlFilterDialog.js

@@ -6,7 +6,6 @@ import { Button, ListItemText, MenuItem, Tab, Tabs, TextField, } from '@mui/mate
 import { observer } from 'mobx-react';
 import { readConfObject } from '../configuration/readConfObject.js';
 import { addRow, describedColumns, readFilterRows, removeRow, replaceRow, resolveFields, stripJexlPrefix, writeFilterRows, } from '../util/jexlFilterRows.js';
-import { activeJexlFilters } from '../util/jexlFilters.js';
 import { ensureJexlPrefix } from '../util/jexlStrings.js';
 import { getContainingTrack } from '../util/mstUtils.js';
 import { makeStyles } from '../util/tss-react/index.js';
@@ -100,7 +99,7 @@ function withOneRow(state) {
 }
 /**
  * Editor for a display's jexl feature filters, for any display implementing
- * the two-tier {@link JexlFilterModel} contract. The Conditions tab shows each
+ * the {@link JexlFilterModel} contract. The Conditions tab shows each
  * line as rows of field, operator and value where it can, and as text where it
  * cannot; the Text tab is every line as text.
  *
@@ -116,7 +115,7 @@ const JexlFilterDialog = observer(function JexlFilterDialog({ model, handleClose
     const fieldList = fields instanceof Promise ? use(fields) : fields;
     const described = metadata && use(metadata);
     const [choices] = useState(() => resolveFields([...fieldList, ...describedColumns(described, fieldList)]));
-    const [state, setState] = useState(() => withOneRow(readFilterRows(activeJexlFilters(model), jexl, choices)));
+    const [state, setState] = useState(() => withOneRow(readFilterRows(model.configuredFilters(), jexl, choices)));
     const [tab, setTab] = useState('conditions');
     const [text, setText] = useState({ value: '', shown: '' });
     const textEdited = text.value !== text.shown;

package/esm/util/TimeTraveller.d.ts

@@ -9,10 +9,13 @@ declare const TimeTraveller: import("@jbrowse/mobx-state-tree").IModelType<{
 }, {
     history: unknown[];
     notTrackingUndo: boolean;
+    hasPendingRecord: boolean;
 } & {
     readonly canUndo: boolean;
     readonly canRedo: boolean;
 } & {
+    setHasPendingRecord(value: boolean): void;
+    flushPendingRecord(): void;
     stopTrackingUndo(): void;
     resumeTrackingUndo(): void;
     addUndoState(snapshot: unknown): void;

package/esm/util/TimeTraveller.js

@@ -14,13 +14,16 @@ const TimeTraveller = types
     .volatile(() => ({
     history: [],
     notTrackingUndo: false,
+    hasPendingRecord: false,
 }))
     .views(self => ({
     get canUndo() {
-        return self.undoIdx > 0 && !self.notTrackingUndo;
+        return ((self.undoIdx > 0 || self.hasPendingRecord) && !self.notTrackingUndo);
     },
     get canRedo() {
-        return self.undoIdx < self.history.length - 1 && !self.notTrackingUndo;
+        return (self.undoIdx < self.history.length - 1 &&
+            !self.hasPendingRecord &&
+            !self.notTrackingUndo);
     },
 }))
     .actions(self => {
@@ -93,7 +96,21 @@ const TimeTraveller = types
             skipNextUndoState = false;
         }
     }
+    let recordPending;
     return {
+        setHasPendingRecord(value) {
+            self.hasPendingRecord = value;
+        },
+        flushPendingRecord() {
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = undefined;
+            }
+            if (self.hasPendingRecord) {
+                self.hasPendingRecord = false;
+                recordPending?.();
+            }
+        },
         stopTrackingUndo() {
             self.notTrackingUndo = true;
         },
@@ -141,14 +158,17 @@ const TimeTraveller = types
             skipNextUndoState = false;
             self.history = [];
             self.undoIdx = -1;
+            self.hasPendingRecord = false;
             // read the target's current state rather than a snapshot captured per
             // change: any change inside the debounce window re-times it, so when it
             // does fire the two agree
             const record = () => {
+                this.setHasPendingRecord(false);
                 if (targetStore) {
                     this.addUndoState(getSnapshot(targetStore));
                 }
             };
+            recordPending = record;
             // onPatch, not onSnapshot: this only needs to know *that* the target
             // changed, and the snapshot is taken once per debounce window below.
             // onSnapshot would serialize the whole target on every single change to
@@ -178,17 +198,29 @@ const TimeTraveller = types
                         clearTimeout(debounceTimer);
                         debounceTimer = undefined;
                     }
+                    this.setHasPendingRecord(false);
                     return;
                 }
+                if (!self.hasPendingRecord) {
+                    this.setHasPendingRecord(true);
+                }
                 armRecording(record);
             });
             this.addUndoState(getSnapshot(targetStore));
         },
         undo() {
+            this.flushPendingRecord();
+            if (self.undoIdx <= 0) {
+                return;
+            }
             self.undoIdx--;
             applyHistoryState(self.undoIdx);
         },
         redo() {
+            this.flushPendingRecord();
+            if (self.undoIdx >= self.history.length - 1) {
+                return;
+            }
             self.undoIdx++;
             applyHistoryState(self.undoIdx);
         },

package/esm/util/baseDisplayConfig.d.ts

@@ -0,0 +1,8 @@
+/**
+ * #api core/util
+ * The base's entry for this display, hydrated, which a reset returns to and
+ * "is this the reader's" compares against: the config.json's, or the one a
+ * track the session owns was added with; empty in a session that keeps no
+ * base.
+ */
+export declare function baseDisplayConfig(self: object): Record<string, unknown>;

package/esm/util/baseDisplayConfig.js

@@ -0,0 +1,27 @@
+import { hasParent } from '@jbrowse/mobx-state-tree';
+import { getConf } from '../configuration/getConf.js';
+import { getContainingTrack, getSession } from './mstUtils.js';
+import { isSessionWithBaseTrackConfig } from './types/index.js';
+/**
+ * #api core/util
+ * The base's entry for this display, hydrated, which a reset returns to and
+ * "is this the reader's" compares against: the config.json's, or the one a
+ * track the session owns was added with; empty in a session that keeps no
+ * base.
+ */
+export function baseDisplayConfig(self) {
+    if (!hasParent(self)) {
+        return {};
+    }
+    const session = getSession(self);
+    if (!isSessionWithBaseTrackConfig(session)) {
+        return {};
+    }
+    const base = session.baseTrackConfig(getConf(getContainingTrack(self), 'trackId'));
+    const { displayId } = self
+        .configuration;
+    const displays = base?.displays;
+    return ((Array.isArray(displays)
+        ? displays.find(d => d.displayId === displayId)
+        : undefined) ?? {});
+}