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

package/esm/Session/SessionTracks.js

@@ -1,26 +1,20 @@
 import { readConfObject } from '@jbrowse/core/configuration';
 import { diffTrackConfig, flattenTrackConfigDelta, mergeTrackConfig, } from '@jbrowse/core/util';
 import { expandLooseTrackConfig } from '@jbrowse/core/util/tracks';
-import { applySnapshot, getSnapshot, isStateTreeNode, types, } from '@jbrowse/mobx-state-tree';
+import { applySnapshot, getSnapshot, types } from '@jbrowse/mobx-state-tree';
 import { compareStructural } from 'mobx';
 import { TracksManagerSessionMixin } from './Tracks.js';
+import { hydratedTrackForm } from './hydratedForms.js';
 import { assertNotReaddedDifferently } from './readdedTrackConf.js';
 import { assertTrackConfOutlivesItsAssemblies } from './temporaryAssemblyTracks.js';
-// jbrowse.tracks holds frozen plain objects (app-core, web/desktop) or MST
-// config nodes (product-core, embedded react views); the delta math reads both
-// as plain track configs. Single site for that documented cast — per-node
-// normalization still happens in toPlainConfig.
+// jbrowse.tracks holds frozen plain objects in every product; single site for
+// the cast from its loose frozen type.
 function baseTracks(self) {
     return self.jbrowse.tracks;
 }
-// A delta must not be stored unless it records a real user edit, or it would
-// flip isTrackOverride (edited badge + Reset menu) on with nothing actually
-// overridden. Two ways an empty edit slips past a key count: diffTrackConfig
-// always retains the self-identifying trackId, and a base config that omits
-// `displays` diffs against the hydrated snapshot's injected {type, displayId}
-// display stubs to yield `{trackId, displays: [...stubs]}` — nonzero keys but no
-// changed slot. flattenTrackConfigDelta (which drops identity keys and empty
-// display stubs) is the honest test of whether any real setting changed.
+// Not a key count: every delta keeps its trackId, and one can hold nothing but
+// content-free display stubs. A stored delta lights the edited badge, so only a
+// changed slot — a reset included — counts.
 function deltaHasChanges(base, delta) {
     return flattenTrackConfigDelta(base, delta).length > 0;
 }
@@ -52,42 +46,20 @@ function withoutDelta(deltas, trackId) {
  * #stateModel SessionTracksManagerSessionMixin
  */
 export function SessionTracksManagerSessionMixin(pluginManager) {
-    // A jbrowse.tracks base entry and a shown track's persisted snapshot are in
-    // two different config "normal forms". A base (app-core web/desktop) is the
-    // raw config-file object: shorthand `uri`, no injected display stubs. But a
-    // shown track's snapshot comes from a live hydrated config node, so it is
-    // post-preProcessSnapshot: the `uri` shorthand is expanded to
-    // bamLocation/index, `baseUri` is propagated into those locations, and a
-    // {type, displayId} stub is injected per compatible display type. Diffing or
-    // merging across those two forms makes every expanded/injected field read as
-    // a user edit — pinning whole adapters and content-free display stubs into
-    // deltas, and defeating the delta's purpose (a later admin adapter-URL fix
-    // would then be masked by the pinned copy). Normalize a base to the hydrated
-    // form by running it through the same track schema, so diff/merge compare
-    // like with like and cancel everything untouched. Memoized per frozen-base
-    // identity (stable until a jbrowse.tracks write). A base that is already an
-    // MST config node (product-core embedded views) is snapshotted directly — it
-    // is already in the hydrated form.
-    //
-    // The isStateTreeNode/getSnapshot casts are load-bearing, don't "simplify"
-    // them: our MST fork types `isStateTreeNode`'s parameter as a state-tree node
-    // (not `unknown`), so `base` (a plain interface) must widen through `unknown`
-    // to be passed, and `getSnapshot` of that returns `unknown`.
+    // A base is the raw config-file object — shorthand `uri`, no display stubs —
+    // while a working copy's snapshot is hydrated. Diffing or merging across the
+    // two reads every expanded field as an edit, pinning whole adapters into the
+    // delta, and every member one form has and the other lacks as a reset. So
+    // both sides go through the same schema first; a base is memoized per
+    // frozen-base identity, which is stable until a jbrowse.tracks write.
+    const hydrate = hydratedTrackForm(pluginManager);
     const canonicalBaseCache = new WeakMap();
     function toPlainConfig(base) {
-        const node = base;
-        if (isStateTreeNode(node)) {
-            return getSnapshot(node);
-        }
         const cached = canonicalBaseCache.get(base);
         if (cached) {
             return cached;
         }
-        const schema = pluginManager.pluggableConfigSchemaType('track');
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- tsc7 sees getSnapshot here as unknown (eslint's TS6 service disagrees; see header note)
-        /* oxlint-disable typescript/no-unnecessary-type-assertion */
-        const hydrated = getSnapshot(schema.create(base, { pluginManager }));
-        /* oxlint-enable typescript/no-unnecessary-type-assertion */
+        const hydrated = hydrate(base);
         canonicalBaseCache.set(base, hydrated);
         return hydrated;
     }
@@ -106,9 +78,10 @@ export function SessionTracksManagerSessionMixin(pluginManager) {
          * Per-track config overrides for a non-admin, keyed by trackId, stored as a
          * *delta* against the admin-owned base config (jbrowse.tracks entry) rather
          * than a full copy — so a later admin change to an untouched field still
-         * flows through (see trackConfigDelta.ts). Frozen (not a typed track array)
-         * on purpose: a typed create() would fill defaults, erasing the "unset vs
-         * default" distinction the delta merge relies on.
+         * flows through (see trackConfigDelta.ts). A `null` member resets a slot
+         * the base sets. Frozen (not a typed track array) on purpose: a typed
+         * create() would fill defaults, erasing the "unset vs default"
+         * distinction the delta merge relies on.
          *
          * `stripDefault` for the reason every other persisted prop beside it has
          * it: without it the empty map is written into every snapshot and every
@@ -147,10 +120,9 @@ export function SessionTracksManagerSessionMixin(pluginManager) {
         // Both keys have stable identity until they actually change: a track's
         // delta only when that track is edited, and the base only on a
         // jbrowse.tracks write. This relies on a base config never mutating in
-        // place: app-core's frozen array replaces the entry (new identity) on
-        // updateTrackConf, and product-core's MST-node bases have no edit path at
-        // all (no updateTrackConf; embedded sessions are adminMode:false). If an
-        // in-place base edit is ever added, key this cache on base content too.
+        // place: the frozen array replaces the entry (new identity) on
+        // updateTrackConf. If an in-place base edit is ever added, key this cache
+        // on base content too.
         const mergeCache = new WeakMap();
         return {
             /**
@@ -267,13 +239,10 @@ export function SessionTracksManagerSessionMixin(pluginManager) {
         // the node identity (existing observers just update); no-op in admin mode
         // or for a track that was never edited (no working copy).
         //
-        // Through toPlainConfig like every other read of a base in this file, not
-        // the raw entry: in product-core's embedded sessions a base IS a live MST
-        // config node, and applySnapshot wants a snapshot — handing it a node
-        // reads nested nodes back out where plain objects belong. (For a frozen
-        // base the two agree, since applySnapshot re-runs the same
-        // preProcessSnapshot that toPlainConfig hydrates through, so this only
-        // makes that reliance explicit.)
+        // Through toPlainConfig like every other read of a base in this file. The
+        // raw entry would do the same, since applySnapshot re-runs the
+        // preProcessSnapshot toPlainConfig hydrates through; this makes that
+        // reliance explicit.
         function revertEditableTrackConfig(trackId) {
             const entry = self.editableTrackConfigs.get(trackId);
             const base = baseTracks(self).find(t => t.trackId === trackId);
@@ -293,26 +262,16 @@ export function SessionTracksManagerSessionMixin(pluginManager) {
         }
         // Single writer for trackConfigDeltas (pass undefined to clear). Clearing
         // also reverts the working copy, which is what makes a Reset visible in an
-        // open view — except where the caller says the working copy IS the edit
-        // that produced the empty delta (`revertWorkingCopy: false`), where
-        // reverting undoes it.
-        function writeDelta(trackId, delta, { revertWorkingCopy = true } = {}) {
+        // open view.
+        function writeDelta(trackId, delta) {
             self.trackConfigDeltas = delta
                 ? { ...self.trackConfigDeltas, [trackId]: delta }
                 : withoutDelta(self.trackConfigDeltas, trackId);
-            if (!delta && revertWorkingCopy) {
+            if (!delta) {
                 revertEditableTrackConfig(trackId);
             }
             stampEditableTrackConfig(trackId);
         }
-        // Whether `trackConf` is the working copy's own current state — i.e. this
-        // update came from the track's live `setSlot` edits rather than from the
-        // config editor's separate temporary node. `syncEditableTrackConfig` below
-        // asks the same question the other way round.
-        function isWorkingCopyState(trackId, trackConf) {
-            const entry = self.editableTrackConfigs.get(trackId);
-            return !!entry && compareStructural(getSnapshot(entry.node), trackConf);
-        }
         // Push a *programmatic* update (the config editor's Apply, or any
         // updateTrackConfiguration not driven by this node's own live edits) into
         // the working copy. When the node IS the edit source its snapshot already
@@ -388,31 +347,29 @@ export function SessionTracksManagerSessionMixin(pluginManager) {
              * config.json every visitor is served; everyone else's goes to
              * `sessionTracks`.
              *
-             * **Only the "Add track" workflows.** Those are where an admin adding a
-             * track means to add it for the whole site. A track a feature stands up
-             * on the user's behalf — a search result, a computed consensus, a
-             * reconstruction's segment labels — is not a catalog entry, and one
-             * admin click on this publishes it to every visitor, again on the next
-             * click, with a per-launch trackId that defeats the dedupe.
-             * `addSessionTrackConf` above is the destination for those.
+             * **Call it only from the "Add track" workflows**, where an admin
+             * adding a track means to add it for the whole site. For a track a
+             * feature creates on the user's behalf (a search result, a computed
+             * consensus, a reconstruction's segment labels), one admin click on
+             * this publishes it to every visitor, and each later click publishes
+             * another copy, because the per-launch trackId prevents deduplication.
+             * Use `addSessionTrackConf` above for those.
              *
              * An admin's track still goes to the session when it names an assembly
-             * the config.json does not carry — a session spec's, a MAF sample's own
-             * genome, a comparative view's synthesized pair. The Add-track widget
-             * takes its assembly from the containing view, so an admin adding a
-             * track while looking at one of those arrives here with a name no
-             * visitor can resolve, and publishing it writes an entry the server
-             * hands everyone and nobody can draw. The session is the one
-             * destination where that track works, so the click keeps working and
-             * the dangling entry is never written; a snackbar says which assembly
-             * moved it.
+             * the config.json does not carry: a session spec's assembly, a MAF
+             * sample's genome, or a comparative view's synthesized pair. The
+             * Add-track widget takes its assembly from the containing view, so an
+             * admin adding a track in such a view passes a name no visitor can
+             * resolve. Publishing it would write an entry the server sends to every
+             * visitor and no visitor can draw. Adding it to the session keeps the
+             * track usable and writes no dangling entry; a snackbar names the
+             * assembly that caused the fallback.
              *
-             * **The snackbar names the assembly and not the track**, which is what
-             * lets a batch collapse to one message: `pushSnackbarMessage` dedupes on
-             * the exact text, and `BulkAddTracksWorkflow` publishes in a loop, so
-             * interpolating the track name stacked one identical-but-for-a-name
-             * toast per file over an admin adding thirty. The assembly is the whole
-             * of what an admin has to act on anyway.
+             * **The snackbar names the assembly and not the track**, so a batch
+             * produces one message: `pushSnackbarMessage` dedupes on the exact
+             * text, and `BulkAddTracksWorkflow` publishes in a loop. Including the
+             * track name would show one snackbar per file to an admin adding
+             * thirty. The assembly is all the admin needs to act on.
              */
             publishTrackConf(trackConf) {
                 if (!self.adminMode) {
@@ -460,11 +417,8 @@ export function SessionTracksManagerSessionMixin(pluginManager) {
                     : self.sessionTracks.findIndex(t => t.trackId === trackId);
                 if (base) {
                     const plainBase = toPlainConfig(base);
-                    const delta = diffTrackConfig(plainBase, trackConf);
-                    // an edit that nets back to the base carries no changed slots: clear
-                    // any prior override (implicit reset) instead of pinning a
-                    // content-free delta; skip a no-op write when there's nothing to
-                    // clear, so the tracks getter doesn't needlessly churn identity
+                    const delta = diffTrackConfig(plainBase, hydrate(trackConf));
+                    // an edit that nets back to the base clears any prior override
                     if (deltaHasChanges(plainBase, delta)) {
                         // Two views showing the same track each run BaseTrackModel's
                         // persist reaction against the shared config node, so a single edit
@@ -480,24 +434,7 @@ export function SessionTracksManagerSessionMixin(pluginManager) {
                         syncEditableTrackConfig(trackId, trackConf);
                     }
                     else if (trackId in self.trackConfigDeltas) {
-                        // An empty delta is two different situations and only one of them
-                        // is a reset. `diffTrackConfig` records adds and changes, never
-                        // deletions (its module note), so *unsetting* a slot the admin
-                        // base sets diffs to nothing exactly as netting back to the base
-                        // does — and reverting the working copy then undid the edit ~400ms
-                        // after the user watched it land. The reachable case is a size
-                        // row's reset, whose whole job is to unset a slot an admin
-                        // `config.json` declares.
-                        //
-                        // The removal still doesn't survive a reload, which is the
-                        // tombstone-free delta's documented limitation; what it no longer
-                        // does is undo itself on screen. Only the working-copy-driven path
-                        // skips the revert: the config editor edits a separate temporary
-                        // node, so there the revert is the only thing that moves the open
-                        // track back to the base.
-                        writeDelta(trackId, undefined, {
-                            revertWorkingCopy: !isWorkingCopyState(trackId, trackConf),
-                        });
+                        writeDelta(trackId, undefined);
                     }
                 }
                 else if (sessionIdx !== -1) {

package/esm/Session/Themes.d.ts

@@ -1,5 +1,5 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
-import type { SerializableThemeArgs, ThemeMap } from '@jbrowse/core/ui';
+import type { SerializableThemeArgs, ThemeMap } from '@jbrowse/core/ui/theme';
 import type { IAnyStateTreeNode, Instance } from '@jbrowse/mobx-state-tree';
 import type { ThemeOptions } from '@mui/material';
 /**
@@ -54,15 +54,14 @@ export declare function ThemeManagerSessionMixin(_pluginManager: PluginManager):
      * view's SVG export threads into each display's `renderSvg`, which
      * rebuilds the theme via `createJBrowseTheme` outside React context.
      *
-     * The `default` entry is spliced with the config `theme` slot, because
-     * the preset is only half of what that entry means — the picker calls it
-     * "Default (from config)" and `resolvePalette` merges the two for every
-     * other consumer. Returning the bare preset made `view.exportSvg()`
-     * silently drop a host's configured palette: a config setting
-     * `primary.main` drew `#123456` on screen and exported the stock
-     * `#0D233F`, with the export dialog reporting the theme it had not used.
-     * Every other named theme is a fixed preset that ignores config, which is
-     * the distinction this ternary keeps.
+     * The `default` entry is merged with the config `theme` slot, because
+     * the picker labels it "Default (from config)" and `resolvePalette`
+     * merges the preset with the slot for every other consumer. The bare
+     * preset would make `view.exportSvg()` drop a host's configured
+     * palette: a config setting `primary.main` would draw `#123456` on
+     * screen and export the stock `#0D233F`, while the export dialog named
+     * the default theme. Every other named theme is a fixed preset that
+     * ignores config.
      */
     getActiveThemeOptions(name?: string): (ThemeOptions & {
         name?: string;

package/esm/Session/Themes.js

@@ -1,7 +1,7 @@
 import { getConf, setConf } from '@jbrowse/core/configuration';
-import { createJBrowseThemeFromArgs, defaultThemes } from '@jbrowse/core/ui';
 import { resolvePalette } from '@jbrowse/core/ui/palette';
 import { resolveStyleTheme } from '@jbrowse/core/ui/styleTheme';
+import { createJBrowseThemeFromArgs, defaultThemes, } from '@jbrowse/core/ui/theme';
 import { localStorageGetItem, localStorageSetItem } from '@jbrowse/core/util';
 import { addDisposer, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
@@ -96,15 +96,14 @@ export function ThemeManagerSessionMixin(_pluginManager) {
              * view's SVG export threads into each display's `renderSvg`, which
              * rebuilds the theme via `createJBrowseTheme` outside React context.
              *
-             * The `default` entry is spliced with the config `theme` slot, because
-             * the preset is only half of what that entry means — the picker calls it
-             * "Default (from config)" and `resolvePalette` merges the two for every
-             * other consumer. Returning the bare preset made `view.exportSvg()`
-             * silently drop a host's configured palette: a config setting
-             * `primary.main` drew `#123456` on screen and exported the stock
-             * `#0D233F`, with the export dialog reporting the theme it had not used.
-             * Every other named theme is a fixed preset that ignores config, which is
-             * the distinction this ternary keeps.
+             * The `default` entry is merged with the config `theme` slot, because
+             * the picker labels it "Default (from config)" and `resolvePalette`
+             * merges the preset with the slot for every other consumer. The bare
+             * preset would make `view.exportSvg()` drop a host's configured
+             * palette: a config setting `primary.main` would draw `#123456` on
+             * screen and export the stock `#0D233F`, while the export dialog named
+             * the default theme. Every other named theme is a fixed preset that
+             * ignores config.
              */
             getActiveThemeOptions(name) {
                 const all = this.allThemes();

package/esm/Session/TrackMenu.d.ts

@@ -4,25 +4,6 @@ import type { BaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
 import type { MenuItem } from '@jbrowse/core/ui';
 import type { DialogComponentType } from '@jbrowse/core/util';
 import type { TrackActionView } from '@jbrowse/core/util/types';
-type TrackCopySnapshot = {
-    trackId: string;
-    name: string;
-    category?: unknown;
-    displays?: {
-        type: string;
-        displayId: string;
-    }[];
-} & Record<string, unknown>;
-/**
- * Clone a track config for "Copy track": snapshots the config, appends a unique
- * timestamp suffix to trackId (so it doesn't collide with the original), tags
- * " (copy)" on the name, and regenerates each displayId to the canonical
- * `${trackId}-${type}` form baseTrackConfig auto-injects — keeping them unique
- * (displayId is a types.identifier, so a collision would crash MST).
- */
-export declare function copyTrackSnapshot(config: BaseTrackConfig, opts: {
-    clearCategory: boolean;
-}): TrackCopySnapshot;
 interface TrackActionSession<C> {
     editConfiguration: (config: AnyConfigurationModel | {
         trackId: string;
@@ -65,18 +46,12 @@ export declare function trackActionItems<C extends {
     isSessionOverride?: boolean;
     makeCopy: () => C;
 }): MenuItem[];
-interface SessionWithDialog {
+export interface SessionWithDialog {
     queueDialog: (cb: (done: () => void) => [DialogComponentType, Record<string, unknown>]) => void;
 }
 type TrackConfig = AnyConfigurationModel | Record<string, unknown>;
 /** "About track" menu item, shared by every product's track menu */
 export declare function aboutTrackMenuItem(session: SessionWithDialog, config: TrackConfig): MenuItem;
-/**
- * plugin-contributed per-track items (`Core-extraTrackMenuItems`), surfaced in
- * both the hierarchical selector and the in-view label menu so plugins reach
- * every track menu consistently
- */
-export declare function pluginExtraTrackItems(pluginManager: PluginManager, session: SessionWithDialog, config: AnyConfigurationModel, view?: TrackActionView): MenuItem[];
 /**
  * flattened track menu (About + raw actions) for the hierarchical track selector
  */

package/esm/Session/TrackMenu.js

@@ -1,33 +1,14 @@
 import { lazy } from 'react';
 import { InfoIcon } from '@jbrowse/core/ui/Icons';
-import { buildExtraTrackMenuItems } from '@jbrowse/core/ui/buildExtraTrackMenuItems';
 import { namesTemporaryAssembly } from '@jbrowse/core/util';
-import { getSnapshot, isStateTreeNode, types } from '@jbrowse/mobx-state-tree';
+import { types } from '@jbrowse/mobx-state-tree';
 import DeleteIcon from '@mui/icons-material/Delete';
 import CopyIcon from '@mui/icons-material/FileCopy';
 import OpenInNewIcon from '@mui/icons-material/OpenInNew';
 import SettingsIcon from '@mui/icons-material/Settings';
 import SettingsBackupRestoreIcon from '@mui/icons-material/SettingsBackupRestore';
+import { pluginExtraTrackItems } from './pluginExtraTrackItems.js';
 const AboutDialog = lazy(() => import('../ui/AboutDialog.js'));
-/**
- * Clone a track config for "Copy track": snapshots the config, appends a unique
- * timestamp suffix to trackId (so it doesn't collide with the original), tags
- * " (copy)" on the name, and regenerates each displayId to the canonical
- * `${trackId}-${type}` form baseTrackConfig auto-injects — keeping them unique
- * (displayId is a types.identifier, so a collision would crash MST).
- */
-export function copyTrackSnapshot(config, opts) {
-    const snap = structuredClone(isStateTreeNode(config) ? getSnapshot(config) : config);
-    snap.trackId += `-${Date.now()}`;
-    snap.name += ' (copy)';
-    if (opts.clearCategory) {
-        snap.category = undefined;
-    }
-    for (const d of snap.displays ?? []) {
-        d.displayId = `${snap.trackId}-${d.type}`;
-    }
-    return snap;
-}
 /**
  * The shared Settings / Copy / Copy-and-open / Delete track actions. Each
  * product supplies `makeCopy` (its own session-track/category rules) and
@@ -123,18 +104,6 @@ export function aboutTrackMenuItem(session, config) {
         },
     };
 }
-/**
- * plugin-contributed per-track items (`Core-extraTrackMenuItems`), surfaced in
- * both the hierarchical selector and the in-view label menu so plugins reach
- * every track menu consistently
- */
-export function pluginExtraTrackItems(pluginManager, session, config, view) {
-    return buildExtraTrackMenuItems(pluginManager, {
-        session: session,
-        config,
-        view,
-    });
-}
 /**
  * flattened track menu (About + raw actions) for the hierarchical track selector
  */

package/esm/Session/TrackMenuSessionMixin.js

@@ -1,6 +1,7 @@
 import { types } from '@jbrowse/mobx-state-tree';
 import { asSession } from '../siblingCast.js';
-import { aboutTrackMenuItem, pluginExtraTrackItems, trackListMenuItems, } from './TrackMenu.js';
+import { aboutTrackMenuItem, trackListMenuItems } from './TrackMenu.js';
+import { pluginExtraTrackItems } from './pluginExtraTrackItems.js';
 /**
  * #stateModel TrackMenuSessionMixin
  *

package/esm/Session/Tracks.d.ts

@@ -8,6 +8,7 @@ export declare function TracksManagerSessionMixin(pluginManager: PluginManager):
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
     name: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
     focusedViewId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+    highlights: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<import("@jbrowse/core/util/highlights").HighlightType, import("@jbrowse/core/util/highlights").HighlightType, import("@jbrowse/core/util/highlights").HighlightType>>, [undefined]>;
     highlightsVisible: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     heldForMissingPlugins: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<import("../pruneUnbuildableNodes.ts").HeldNode[] | undefined, import("../pruneUnbuildableNodes.ts").HeldNode[] | undefined, import("../pruneUnbuildableNodes.ts").HeldNode[] | undefined>, [undefined]>;
 }, never>, never>, {
@@ -509,10 +510,7 @@ export declare function TracksManagerSessionMixin(pluginManager: PluginManager):
             }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>) | undefined;
             readonly assemblyNamesList: string[];
             readonly configuredAssemblyNames: Set<string>;
-            readonly assemblyList: (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<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
+            readonly assemblyList: AnyConfigurationModel[];
             readonly rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
         } & {
             settleAssemblyResolution(assemblyName: string): Promise<void>;
@@ -1301,10 +1299,7 @@ export declare function TracksManagerSessionMixin(pluginManager: PluginManager):
             }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>) | undefined;
             readonly assemblyNamesList: string[];
             readonly configuredAssemblyNames: Set<string>;
-            readonly assemblyList: (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<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
+            readonly assemblyList: AnyConfigurationModel[];
             readonly rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
         } & {
             settleAssemblyResolution(assemblyName: string): Promise<void>;
@@ -1604,10 +1599,7 @@ export declare function TracksManagerSessionMixin(pluginManager: PluginManager):
 } & {
     readonly jbrowse: any;
     readonly rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
-    readonly configuration: 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<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>;
+    readonly configuration: import("@jbrowse/core/configuration").ConfigNodeProps<any> & import("@jbrowse/core/configuration").ConfigNodeActions & import("@jbrowse/core/configuration").ConfigNodeBrand<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>;
     readonly adminMode: boolean;
     readonly textSearchManager: import("@jbrowse/core/TextSearch/TextSearchManager").default;
 } & {
@@ -1628,7 +1620,10 @@ export declare function TracksManagerSessionMixin(pluginManager: PluginManager):
     clearSelection(): void;
     setHovered(thing: unknown): void;
     setHighlightsVisible(arg: boolean): void;
-    revealHighlights(): void;
+    addHighlight(highlight: import("@jbrowse/core/util/highlights").HighlightType): void;
+    removeHighlight(highlight: import("@jbrowse/core/util/highlights").HighlightType): void;
+    updateHighlight(old: import("@jbrowse/core/util/highlights").HighlightType, updates: Partial<import("@jbrowse/core/util/highlights").HighlightType>): void;
+    setHighlights(highlights: import("@jbrowse/core/util/highlights").HighlightType[]): void;
     setPreferenceOverride(key: string, value: unknown): void;
     clearPreferenceOverrides(): void;
     clearPreferenceOverride(key: string): void;

package/esm/Session/copyTrackSnapshot.d.ts

@@ -0,0 +1,21 @@
+import type { BaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
+type TrackCopySnapshot = {
+    trackId: string;
+    name: string;
+    category?: unknown;
+    displays?: {
+        type: string;
+        displayId: string;
+    }[];
+} & Record<string, unknown>;
+/**
+ * Clone a track config for "Copy track": snapshots the config, appends a unique
+ * timestamp suffix to trackId (so it doesn't collide with the original), tags
+ * " (copy)" on the name, and regenerates each displayId to the canonical
+ * `${trackId}-${type}` form baseTrackConfig auto-injects — keeping them unique
+ * (displayId is a types.identifier, so a collision would crash MST).
+ */
+export declare function copyTrackSnapshot(config: BaseTrackConfig, opts: {
+    clearCategory: boolean;
+}): TrackCopySnapshot;
+export {};

package/esm/Session/copyTrackSnapshot.js

@@ -0,0 +1,20 @@
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * Clone a track config for "Copy track": snapshots the config, appends a unique
+ * timestamp suffix to trackId (so it doesn't collide with the original), tags
+ * " (copy)" on the name, and regenerates each displayId to the canonical
+ * `${trackId}-${type}` form baseTrackConfig auto-injects — keeping them unique
+ * (displayId is a types.identifier, so a collision would crash MST).
+ */
+export function copyTrackSnapshot(config, opts) {
+    const snap = structuredClone(isStateTreeNode(config) ? getSnapshot(config) : config);
+    snap.trackId += `-${Date.now()}`;
+    snap.name += ' (copy)';
+    if (opts.clearCategory) {
+        snap.category = undefined;
+    }
+    for (const d of snap.displays ?? []) {
+        d.displayId = `${snap.trackId}-${d.type}`;
+    }
+    return snap;
+}

package/esm/Session/hydratedForms.d.ts

@@ -0,0 +1,16 @@
+import type { AssemblySnapshot, TrackSnapshot } from '../sessionUtils.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { IAnyType } from '@jbrowse/mobx-state-tree';
+/**
+ * A config as its own schema writes it back: shorthand expanded, a stub per
+ * compatible display injected, every slot at its default left out. A
+ * track-config delta is only exact between two configs in this form, because a
+ * member one has and the other lacks then means a reset rather than two
+ * spellings of one config.
+ */
+export interface HydratedForms {
+    track: (conf: TrackSnapshot) => TrackSnapshot;
+    assembly: (conf: AssemblySnapshot) => AssemblySnapshot;
+}
+export declare function hydratedTrackForm(pluginManager: PluginManager): (conf: TrackSnapshot) => TrackSnapshot;
+export declare function hydratedForms(pluginManager: PluginManager, assemblyConfigSchema: IAnyType): HydratedForms;

package/esm/Session/hydratedForms.js

@@ -0,0 +1,13 @@
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
+function snapshotThrough(schema, pluginManager) {
+    return (conf) => getSnapshot(schema.create(conf, { pluginManager }));
+}
+export function hydratedTrackForm(pluginManager) {
+    return snapshotThrough(pluginManager.pluggableConfigSchemaType('track'), pluginManager);
+}
+export function hydratedForms(pluginManager, assemblyConfigSchema) {
+    return {
+        track: hydratedTrackForm(pluginManager),
+        assembly: snapshotThrough(assemblyConfigSchema, pluginManager),
+    };
+}

package/esm/Session/index.d.ts

@@ -15,8 +15,12 @@ export { BaseSessionModel, isBaseSession, isSession } from './BaseSession.ts';
 export type { BaseSession, BaseSessionType } from './BaseSession.ts';
 export { SessionTracksManagerSessionMixin } from './SessionTracks.ts';
 export type { EditableTrackConfig, PlainTrackConfig, SessionWithSessionTracks, SessionWithSessionTracksType, } from './SessionTracks.ts';
+export { hydratedForms } from './hydratedForms.ts';
+export type { HydratedForms } from './hydratedForms.ts';
 export { bakeSessionCascades, getShareableSessionSnapshot, } from './shareableSnapshot.ts';
-export { TrackMenuItemsSessionMixin, aboutTrackMenuItem, copyTrackSnapshot, pluginExtraTrackItems, trackActionItems, trackActionMenuItems, trackListMenuItems, } from './TrackMenu.ts';
+export { TrackMenuItemsSessionMixin, aboutTrackMenuItem, trackActionItems, trackActionMenuItems, trackListMenuItems, } from './TrackMenu.ts';
+export { copyTrackSnapshot } from './copyTrackSnapshot.ts';
+export { pluginExtraTrackItems } from './pluginExtraTrackItems.ts';
 export { TrackMenuSessionMixin } from './TrackMenuSessionMixin.ts';
 export { finalizeSession } from './finalizeSession.ts';
 export type { AssertSessionModel } from './assertSessionModel.ts';

package/esm/Session/index.js

@@ -7,7 +7,10 @@ export { MultipleViewsSessionMixin, isSessionWithMultipleViews, } from './Multip
 export { PreferencesSessionMixin } from './Preferences.js';
 export { BaseSessionModel, isBaseSession, isSession } from './BaseSession.js';
 export { SessionTracksManagerSessionMixin } from './SessionTracks.js';
+export { hydratedForms } from './hydratedForms.js';
 export { bakeSessionCascades, getShareableSessionSnapshot, } from './shareableSnapshot.js';
-export { TrackMenuItemsSessionMixin, aboutTrackMenuItem, copyTrackSnapshot, pluginExtraTrackItems, trackActionItems, trackActionMenuItems, trackListMenuItems, } from './TrackMenu.js';
+export { TrackMenuItemsSessionMixin, aboutTrackMenuItem, trackActionItems, trackActionMenuItems, trackListMenuItems, } from './TrackMenu.js';
+export { copyTrackSnapshot } from './copyTrackSnapshot.js';
+export { pluginExtraTrackItems } from './pluginExtraTrackItems.js';
 export { TrackMenuSessionMixin } from './TrackMenuSessionMixin.js';
 export { finalizeSession } from './finalizeSession.js';

package/esm/Session/pluginExtraTrackItems.d.ts

@@ -0,0 +1,11 @@
+import type { SessionWithDialog } from './TrackMenu.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { MenuItem } from '@jbrowse/core/ui';
+import type { TrackActionView } from '@jbrowse/core/util/types';
+/**
+ * plugin-contributed per-track items (`Core-extraTrackMenuItems`), surfaced in
+ * both the hierarchical selector and the in-view label menu so plugins reach
+ * every track menu consistently
+ */
+export declare function pluginExtraTrackItems(pluginManager: PluginManager, session: SessionWithDialog, config: AnyConfigurationModel, view?: TrackActionView): MenuItem[];