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

package/esm/sessionUtils.js

@@ -235,17 +235,14 @@ function withoutBaseAssemblies(sessionAssemblies, baseAssemblyNames) {
 // `withoutBaseAssemblies` drops to keep the recipient's safeReferences
 // unambiguous.
 //
-// Edited-ness is `flattenTrackConfigDelta`, the same gate `splitTracksAgainstBase`
-// uses, so an export can't call an assembly edited on a diff too thin to be worth
+// Edited-ness is `editedDelta`, the same gate `splitTracksAgainstBase` uses, so
+// an export can't call an assembly edited on a diff too thin to be worth
 // shipping for a track.
-function assembliesRevertedToBase(assemblies, sessionAssemblies, baseAssemblies) {
+function assembliesRevertedToBase(assemblies, sessionAssemblies, baseAssemblies, form) {
     const baseByName = new Map(baseAssemblies.map(a => [a.name, a]));
     const edited = assemblies.flatMap(assembly => {
         const base = baseByName.get(assembly.name);
-        return base &&
-            flattenTrackConfigDelta(base, diffTrackConfig(base, assembly)).length > 0
-            ? [assembly.name]
-            : [];
+        return base && editedDelta(base, assembly, form) ? [assembly.name] : [];
     });
     const shadowed = sessionAssemblies.flatMap(a => {
         const name = readAssemblyName(a);
@@ -275,17 +272,19 @@ function droppableTrackIds(tracks, sessionTracks) {
 // (`addTrackTextSearchConf`), so indexing a remote BAM on desktop is enough to
 // make an otherwise perfectly portable track non-portable and get it dropped
 // whole. The data file is the track; the index is a search box over it. Shedding
-// the index costs the recipient that box and nothing else, and under a hosted
-// base the omission also lets the base's own (remote) index resolve, since a
-// delta records adds and changes but never a deletion.
-function withoutLocalTextSearch(track) {
+// the index costs the recipient that box and nothing else.
+//
+// A hub track takes the hub's own index in its place, so its delta records no
+// change there and the recipient searches with the hub's index. Leaving the
+// member out would be a reset of it.
+function withoutLocalTextSearch(track, hubIndex) {
     if (!isRecord(track) ||
         !isRecord(track.textSearching) ||
         analyzeWebPortability(track.textSearching).portable) {
         return track;
     }
     const { textSearching, ...rest } = track;
-    return rest;
+    return (hubIndex === undefined ? rest : { ...rest, textSearching: hubIndex });
 }
 // Display names of the tracks `withoutLocalTextSearch` stripped, for the report.
 function strippedTextIndexNames(before, after) {
@@ -329,23 +328,26 @@ function nonPortableUserTracks(report, droppable) {
 // but the delta channel it travels in means "user override" on the far side, and
 // a delta masks later admin changes to that track. Telling the two apart needs
 // the base as it was at session creation, which nothing persists.
-function splitTracksAgainstBase(tracks, baseTracks) {
+function splitTracksAgainstBase(tracks, baseTracks, form) {
     const baseById = new Map(baseTracks.map(t => [t.trackId, t]));
     const addedTracks = tracks.filter(t => !baseById.has(t.trackId));
     const editDeltas = Object.fromEntries(tracks.flatMap((track) => {
         const base = baseById.get(track.trackId);
-        if (!base) {
-            return [];
-        }
-        const delta = diffTrackConfig(base, track);
-        // gate on real slot changes, not the identity keys / injected display
-        // stubs a raw diff carries (matches the web session's "is edited" test)
-        return flattenTrackConfigDelta(base, delta).length > 0
-            ? [[track.trackId, delta]]
-            : [];
+        const delta = base && editedDelta(base, track, form);
+        return delta ? [[track.trackId, delta]] : [];
     }));
     return { addedTracks, editDeltas };
 }
+// The delta from `base` to `edited` with both in their hydrated form, or
+// undefined when no setting changed — the web session's own "is edited" test,
+// which a bare key count fails on the identity keys and display stubs
+function editedDelta(base, edited, form) {
+    const hydratedBase = form(base);
+    const delta = diffTrackConfig(hydratedBase, form(edited));
+    return flattenTrackConfigDelta(hydratedBase, delta).length > 0
+        ? delta
+        : undefined;
+}
 // Overlays edited-track deltas onto the session's trackConfigDeltas, preserving
 // any the base session already carried. A no-op (returns the session unchanged)
 // when there are no edits, so the exported snapshot stays minimal.
@@ -443,18 +445,27 @@ function withCarriedConfigs(session, plugins, connections) {
 // Decides how to hand a desktop session to jbrowse-web. When the session was
 // launched from a hosted hub config (sourceConfigUrl) that still covers all of
 // its assemblies, that config is reused as the base and only user-added/edited
-// tracks ride along; otherwise the session is made self-contained. `baseConfig`
-// is the fetched hub config (already rebased with addRelativeUris by the caller),
+// tracks ride along; otherwise the session is made self-contained. `base` holds
+// the fetched hub config (already rebased with addRelativeUris by the caller),
 // used to tell hub tracks from user-added ones and to diff edited hub tracks.
-export function planWebExport(snapshot, baseConfig) {
+export function planWebExport(snapshot, base) {
     const sourceConfigUrl = snapshot.configuration?.sourceConfigUrl;
     const assemblies = snapshot.assemblies ?? [];
     const defaultSession = snapshot.defaultSession ?? {};
     const priorSessionAssemblies = asArray(defaultSession.sessionAssemblies);
     const inputTracks = snapshot.tracks ?? [];
     const inputSessionTracks = asArray(defaultSession.sessionTracks);
-    const allTracks = inputTracks.map(withoutLocalTextSearch);
-    const allSessionTracks = inputSessionTracks.map(withoutLocalTextSearch);
+    const baseConfig = base?.config;
+    const baseAssemblyNames = new Set((baseConfig?.assemblies ?? []).map(a => a.name));
+    const coveredByBase = !!sourceConfigUrl &&
+        !!base &&
+        assemblies.every(a => baseAssemblyNames.has(a.name));
+    const hubIndexes = new Map((coveredByBase ? (base.config.tracks ?? []) : []).map(t => [
+        t.trackId,
+        t.textSearching,
+    ]));
+    const allTracks = inputTracks.map(t => withoutLocalTextSearch(t, hubIndexes.get(t.trackId)));
+    const allSessionTracks = inputSessionTracks.map(t => withoutLocalTextSearch(t));
     // over the stripped lists, so a track whose only local file was its own search
     // index is no longer read as one that has to be dropped
     const report = analyzeWebPortability({
@@ -469,11 +480,7 @@ export function planWebExport(snapshot, baseConfig) {
     };
     const tracks = allTracks.filter(keep);
     const priorSessionTracks = allSessionTracks.filter(keep);
-    const baseAssemblyNames = new Set((baseConfig?.assemblies ?? []).map(a => a.name));
-    const coveredByBase = !!sourceConfigUrl &&
-        !!baseConfig &&
-        assemblies.every(a => baseAssemblyNames.has(a.name));
-    // `baseConfig` is undefined only because the caller could not fetch
+    // `base` is undefined only because the caller could not fetch
     // `sourceConfigUrl` — it is the same fetch that produces it — so the two ways
     // a hub drops out of the plan are distinguishable here without a flag.
     const selfContainedReason = coveredByBase
@@ -488,7 +495,7 @@ export function planWebExport(snapshot, baseConfig) {
     // defined exactly when the hostedConfigBase strategy applies, so it doubles as
     // the strategy flag for the shared tail below
     const hosted = coveredByBase
-        ? splitTracksAgainstBase(tracks, baseConfig.tracks ?? [])
+        ? splitTracksAgainstBase(tracks, base.config.tracks ?? [], base.forms.track)
         : undefined;
     const session = withCarriedConfigs(hosted
         ? withDeltas({
@@ -525,8 +532,8 @@ export function planWebExport(snapshot, baseConfig) {
                 ...strippedTextIndexNames(inputSessionTracks, allSessionTracks),
             ]),
         ],
-        revertedAssemblies: hosted
-            ? assembliesRevertedToBase(assemblies, priorSessionAssemblies, baseConfig?.assemblies ?? [])
+        revertedAssemblies: coveredByBase
+            ? assembliesRevertedToBase(assemblies, priorSessionAssemblies, base.config.assemblies ?? [], base.forms.assembly)
             : [],
         unavailableAccounts: unavailableAccountIds(session, hosted ? (baseConfig?.internetAccounts ?? []) : []),
     };

package/esm/ui/AboutDialog.d.ts

@@ -1,4 +1,12 @@
-import type { AboutPanelProps } from './util.ts';
-export default function AboutDialog({ config, session, handleClose, }: AboutPanelProps & {
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { AbstractSessionModel } from '@jbrowse/core/util';
+export default function AboutDialog({ config, session, handleClose, }: {
+    session: AbstractSessionModel;
+    /**
+     * the in-view track label passes `track.configuration`, a live node; the
+     * hierarchical selector passes a `session.tracks` entry, a plain object
+     * until something references the track
+     */
+    config: AnyConfigurationModel | Record<string, unknown>;
     handleClose: () => void;
 }): import("react").JSX.Element;

package/esm/ui/AboutDialog.js

@@ -1,11 +1,20 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import Attributes from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/Attributes';
+import BaseCard from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/BaseCard';
+import { hydrateTrackConfig } from '@jbrowse/core/configuration';
 import { PluggableComponent } from '@jbrowse/core/ui';
 import Dialog from '@jbrowse/core/ui/Dialog';
 import { getEnv } from '@jbrowse/core/util';
 import { getTrackName } from '@jbrowse/core/util/tracks';
+import { isStateTreeNode } from '@jbrowse/mobx-state-tree';
 import AboutContents from './AboutDialogContents.js';
 export default function AboutDialog({ config, session, handleClose, }) {
-    const trackName = getTrackName(config, session);
     const { pluginManager } = getEnv(session);
-    return (_jsx(Dialog, { open: true, onClose: handleClose, title: trackName, maxWidth: "xl", children: _jsx(PluggableComponent, { pluginManager: pluginManager, name: "Core-replaceAbout", component: AboutContents, props: { config, session } }) }));
+    // hydrated once here, so every panel and every plugin on the two About points
+    // reads one live node: "Copy config" gives the same JSON whichever menu
+    // opened the dialog, and a jexl `formatAbout` slot has an env to evaluate in
+    const live = isStateTreeNode(config)
+        ? config
+        : hydrateTrackConfig(pluginManager, config);
+    return (_jsx(Dialog, { open: true, onClose: handleClose, title: getTrackName(config, session), maxWidth: "xl", children: live ? (_jsx(PluggableComponent, { pluginManager: pluginManager, name: "Core-replaceAbout", component: AboutContents, props: { config: live, session } })) : (_jsx(BaseCard, { title: "Configuration", children: _jsx(Attributes, { attributes: config }) })) }));
 }

package/esm/ui/AboutDialogContents.js

@@ -2,11 +2,10 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import Attributes from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/Attributes';
 import BaseCard from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/BaseCard';
-import { hydrateTrackConfig } from '@jbrowse/core/configuration';
+import { readConfObject } from '@jbrowse/core/configuration';
 import PluggableComponents from '@jbrowse/core/ui/PluggableComponents';
 import { getEnv } from '@jbrowse/core/util';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
 import { observer } from 'mobx-react';
 import AssemblyInfoPanel from './AssemblyInfoPanel.js';
 import DescriptionPanel from './DescriptionPanel.js';
@@ -24,25 +23,8 @@ const AboutDialogContents = observer(function AboutDialogContents({ config, sess
     const { classes } = useStyles();
     const [showRefNames, setShowRefNames] = useState(false);
     const { pluginManager } = getEnv(session);
-    // The two menus that open this dialog hand over different things: the in-view
-    // track label passes `track.configuration`, a live node, while the
-    // hierarchical selector passes a `session.tracks` entry, which is a
-    // `types.frozen` plain object until something references the track. Hydrating
-    // converges them, so "Copy config" gives the same JSON whichever menu you came
-    // from; it returns undefined for a config no plugin can build, and that falls
-    // back to copying it as authored.
-    const live = isStateTreeNode(config)
-        ? config
-        : hydrateTrackConfig(pluginManager, config);
-    const conf = live
-        ? getSnapshot(live)
-        : config;
-    const { config: shown, hideUris } = getAboutDialogConfig({
-        config,
-        session,
-        pluginManager,
-    });
-    return (_jsxs("div", { className: classes.content, children: [_jsxs(BaseCard, { title: "Configuration", children: [_jsx(HeaderButtons, { conf: conf, hideUris: hideUris, setShowRefNames: setShowRefNames }), _jsx(Attributes, { attributes: shown, omit: [...hideFields, 'metadata'], hideUris: hideUris })] }), shown.metadata ? (_jsx(BaseCard, { title: "Metadata", children: _jsx(Attributes, { attributes: shown.metadata, hideUris: hideUris }) })) : null, _jsx(DescriptionPanel, { config: config, session: session }), _jsx(AssemblyInfoPanel, { config: config, session: session, hideUris: hideUris }), _jsx(PluggableComponents, { pluginManager: pluginManager, 
+    const { config: shown, hideUris } = getAboutDialogConfig({ config, session });
+    return (_jsxs("div", { className: classes.content, children: [_jsxs(BaseCard, { title: "Configuration", children: [_jsx(HeaderButtons, { conf: readConfObject(config), hideUris: hideUris, setShowRefNames: setShowRefNames }), _jsx(Attributes, { attributes: shown, omit: [...hideFields, 'metadata'], hideUris: hideUris })] }), shown.metadata ? (_jsx(BaseCard, { title: "Metadata", children: _jsx(Attributes, { attributes: shown.metadata, hideUris: hideUris }) })) : null, _jsx(DescriptionPanel, { config: config, session: session }), _jsx(AssemblyInfoPanel, { config: config, session: session, hideUris: hideUris }), _jsx(PluggableComponents, { pluginManager: pluginManager, 
                 /** #extensionPoint Core-extraAboutPanel | sync | Add extra panels to a track's About dialog */
                 name: "Core-extraAboutPanel", props: { session, config } }), hideUris ? null : _jsx(FileInfoPanel, { config: config, session: session }), showRefNames ? (_jsx(RefNameInfoDialog, { session: session, config: config, onClose: () => {
                     setShowRefNames(false);

package/esm/ui/AppReadyMarker.d.ts

@@ -0,0 +1,45 @@
+import type { AbstractSessionModel } from '@jbrowse/core/util/types';
+/**
+ * One element that says whether the whole app has finished, and what is open.
+ *
+ * `[data-app-phase="ready"]` is the entire readiness contract for anything
+ * driving JBrowse from outside — a screenshot tool, a test, an agent. Wait for
+ * that selector and you are done; there is no chain to assemble and no
+ * per-display census to take.
+ *
+ * Why it exists when `data-view-phase` and `data-display-phase` already do:
+ * those are per-element and NEGATIVE. Asking them "is everything finished"
+ * means asserting that no element carries the loading value, which is equally
+ * true of an app that has not started — and the gap is real, measured at about
+ * a second on a two-track session. A positive attribute cannot be satisfied
+ * early, because something has to render it.
+ *
+ * The census attributes beside it — `data-app-views`, `data-app-assemblies`,
+ * `data-app-tracks` (the latter two JSON arrays) — publish WHAT is open the
+ * same way the phase publishes whether it is done, so an outside reader asking
+ * "is the track I requested actually open" reads one element instead of
+ * walking `window.JBrowseSession` with its own copy of the view nesting. The
+ * walk itself is `openViews`/`openTracks` over each view's declared
+ * `ownViews`/`ownTracks`, so this component knows nothing about which property
+ * a container view keeps its children on either.
+ *
+ * Its own component, and `hidden`, for two reasons: an observer here subscribes
+ * to every view's phase without re-rendering the app shell around it, and a
+ * marker that is never drawn cannot be mistaken for UI or shift a layout. It is
+ * still found by `querySelector`, which is what reads it.
+ *
+ * **What it is silent about**: a display in a TERMINAL state. `error` and
+ * `canceled` are finished states, so this reads `ready` over a display whose
+ * fetch failed or that the user stopped — correctly, since nothing is still
+ * working, and a user's cancel is durable until Retry. A capture wants more than
+ * that: it wants a picture, and neither banner is one. The capture census after
+ * this is what draws that line: `waitForDisplaysDone` keys on the
+ * `data-display-drawn` the two comparative canvases publish from their stricter
+ * `settled` gate (see `comparativeReadiness` in `@jbrowse/synteny-core`, which
+ * holds both answers and says why an error separates them), and the census
+ * names every `data-display-phase="canceled"`.
+ */
+declare const AppReadyMarker: ({ session, }: {
+    session: AbstractSessionModel;
+}) => import("react").JSX.Element;
+export default AppReadyMarker;

package/esm/ui/AppReadyMarker.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { openTracks, openViews } from '@jbrowse/core/util/openViews';
+import { observer } from 'mobx-react';
+function trackLoading(track) {
+    return track.displays.some(d => d.displayPhase === 'loading');
+}
+/**
+ * A view whose init failed (its assembly was never found) stays uninitialized
+ * for good and paints its error, so like a display's terminal phase it is
+ * finished, not pending: without this the whole app read `loading` for as long
+ * as that view was open, and every settle answered false with no reason.
+ *
+ * `pendingLaunch` is the third term and the one that was missing. `initialized`
+ * goes true mid-launch — LGV's flips the moment displayedRegions land, while
+ * the same apply pass still has the spec's tracks to attach — and `showLoading`
+ * goes false at the same moment, deliberately, so the reader sees the
+ * navigated view rather than a spinner while its tracks arrive. That left a
+ * window, exactly as wide as attaching the tracks, in which the marker said
+ * `ready` over a session missing everything it had been asked for.
+ * `whenViewSettled` states the same rule for the callers that await a single
+ * view, and says why in more detail. Not shared as one predicate: that one
+ * requires `initialized`, while absent here means not loading, and an adapter
+ * between the two null rules would read as agreement it does not have.
+ *
+ * `showImportForm` excuses the `initialized` term, and only that one. The
+ * comparative views spell `initialized` as "every row exists and is ready" —
+ * LinearSyntenyView's wants `views.length > 0`, dotplot's wants regions on both
+ * axes — so a view clicked into existence through `Add -> Linear synteny view`
+ * reads uninitialized for as long as its form is up, which is until a person
+ * fills it in. The app sat at `loading` behind every import-form figure. The
+ * other two terms keep their meaning: `showLoading` is the spinner the form
+ * yields to, and `showImportForm` is already false while a launch is pending.
+ */
+function viewLoading(view) {
+    const flags = view;
+    return (flags.error === undefined &&
+        (flags.showLoading === true ||
+            flags.pendingLaunch !== undefined ||
+            (flags.initialized === false && flags.showImportForm !== true)));
+}
+/**
+ * One element that says whether the whole app has finished, and what is open.
+ *
+ * `[data-app-phase="ready"]` is the entire readiness contract for anything
+ * driving JBrowse from outside — a screenshot tool, a test, an agent. Wait for
+ * that selector and you are done; there is no chain to assemble and no
+ * per-display census to take.
+ *
+ * Why it exists when `data-view-phase` and `data-display-phase` already do:
+ * those are per-element and NEGATIVE. Asking them "is everything finished"
+ * means asserting that no element carries the loading value, which is equally
+ * true of an app that has not started — and the gap is real, measured at about
+ * a second on a two-track session. A positive attribute cannot be satisfied
+ * early, because something has to render it.
+ *
+ * The census attributes beside it — `data-app-views`, `data-app-assemblies`,
+ * `data-app-tracks` (the latter two JSON arrays) — publish WHAT is open the
+ * same way the phase publishes whether it is done, so an outside reader asking
+ * "is the track I requested actually open" reads one element instead of
+ * walking `window.JBrowseSession` with its own copy of the view nesting. The
+ * walk itself is `openViews`/`openTracks` over each view's declared
+ * `ownViews`/`ownTracks`, so this component knows nothing about which property
+ * a container view keeps its children on either.
+ *
+ * Its own component, and `hidden`, for two reasons: an observer here subscribes
+ * to every view's phase without re-rendering the app shell around it, and a
+ * marker that is never drawn cannot be mistaken for UI or shift a layout. It is
+ * still found by `querySelector`, which is what reads it.
+ *
+ * **What it is silent about**: a display in a TERMINAL state. `error` and
+ * `canceled` are finished states, so this reads `ready` over a display whose
+ * fetch failed or that the user stopped — correctly, since nothing is still
+ * working, and a user's cancel is durable until Retry. A capture wants more than
+ * that: it wants a picture, and neither banner is one. The capture census after
+ * this is what draws that line: `waitForDisplaysDone` keys on the
+ * `data-display-drawn` the two comparative canvases publish from their stricter
+ * `settled` gate (see `comparativeReadiness` in `@jbrowse/synteny-core`, which
+ * holds both answers and says why an error separates them), and the census
+ * names every `data-display-phase="canceled"`.
+ */
+const AppReadyMarker = observer(function AppReadyMarker({ session, }) {
+    const views = openViews(session);
+    const tracks = openTracks(session);
+    const loading = views.some(viewLoading) || tracks.some(trackLoading);
+    return (_jsx("span", { hidden: true, "data-testid": "app-ready-marker", "data-app-phase": loading ? 'loading' : 'ready', "data-app-views": session.views.length, "data-app-assemblies": JSON.stringify([
+            ...new Set(views.flatMap(v => v.assemblyNames ?? [])),
+        ]), "data-app-tracks": JSON.stringify(tracks.map(t => t.configuration.trackId ?? '(unnamed)')) }));
+});
+export default AppReadyMarker;

package/esm/ui/AssemblyInfoPanel.js

@@ -2,11 +2,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import Attributes from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/Attributes';
 import BaseCard from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/BaseCard';
-import { readConfObject, readConfSlot } from '@jbrowse/core/configuration';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { CopyToClipboardButton } from '@jbrowse/core/ui';
 import { stripBaseUris } from '@jbrowse/core/util/addRelativeUris';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { getParent, hasParent, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { getParent, hasParent } from '@jbrowse/mobx-state-tree';
 import { Button } from '@mui/material';
 import { observer } from 'mobx-react';
 import RefNameAliasesDialog from './RefNameAliasesDialog.js';
@@ -39,15 +39,9 @@ const useStyles = makeStyles()(theme => ({
  * holding it *is* its assembly, the same walk `getConfAssemblyNames` makes.
  * Compared by identity against that node's `sequence`, so the card is the
  * assembly of the track the dialog is already showing.
- *
- * Both menus that open this dialog hand over a live node here: the hierarchical
- * selector reads `assemblyManager.get(name).configuration.sequence`, and the
- * in-view track label's `track.configuration` resolves to that same node
- * through `getTrackById`. The frozen `session.tracks` entry the rest of the
- * dialog has to cope with is never a reference sequence track.
  */
 function getAssemblyConf(config) {
-    const parent = isStateTreeNode(config) && hasParent(config)
+    const parent = hasParent(config)
         ? getParent(config)
         : undefined;
     return parent?.sequence === config ? parent : undefined;
@@ -58,7 +52,7 @@ const AssemblyCard = observer(function AssemblyCard({ assemblyConf, session, hid
     const conf = readConfObject(assemblyConf);
     return (_jsxs(BaseCard, { title: "Assembly", children: [_jsxs("span", { className: classes.buttons, children: [_jsx(Button, { variant: "contained", color: "secondary", onClick: () => {
                             setShowAliases(true);
-                        }, children: "Show ref name aliases" }), hideUris ? null : (_jsx(CopyToClipboardButton, { variant: "contained", value: () => JSON.stringify(stripBaseUris(structuredClone(conf)), null, 2), children: "Copy assembly config" }))] }), _jsx(Attributes, { attributes: conf, omit: hideFields, hideUris: hideUris }), showAliases ? (_jsx(RefNameAliasesDialog, { assemblyName: readConfSlot(assemblyConf, 'name'), session: session, onClose: () => {
+                        }, children: "Show ref name aliases" }), hideUris ? null : (_jsx(CopyToClipboardButton, { variant: "contained", value: () => JSON.stringify(stripBaseUris(structuredClone(conf)), null, 2), children: "Copy assembly config" }))] }), _jsx(Attributes, { attributes: conf, omit: hideFields, hideUris: hideUris }), showAliases ? (_jsx(RefNameAliasesDialog, { assemblyName: readConfObject(assemblyConf, 'name'), session: session, onClose: () => {
                     setShowAliases(false);
                 } })) : null] }));
 });

package/esm/ui/DescriptionPanel.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import BaseCard from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/BaseCard';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { ErrorBanner, LoadingEllipses, SanitizedHTML } from '@jbrowse/core/ui';
 import { openLocation } from '@jbrowse/core/util/io';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
@@ -18,7 +19,7 @@ const DescriptionCard = observer(function DescriptionCard({ url, }) {
     return (_jsxs(BaseCard, { title: "Description", children: [_jsxs(Typography, { variant: "caption", color: "textSecondary", component: "div", className: classes.provenance, children: ["From the track hub, written for the UCSC Genome Browser \u2014 some display options it describes differ in JBrowse.", ' ', _jsx(Link, { href: url, target: "_blank", rel: "noopener noreferrer", children: "View original" })] }), error ? (_jsx(ErrorBanner, { error: error })) : isLoading || html === undefined ? (_jsx(LoadingEllipses, { message: "Loading description" })) : (_jsx(SanitizedHTML, { html: html }))] }));
 });
 const DescriptionPanel = observer(function DescriptionPanel({ config, }) {
-    const url = getDescriptionHtmlUrl(config);
+    const url = getDescriptionHtmlUrl(readConfObject(config, 'metadata'));
     return url ? _jsx(DescriptionCard, { url: url }) : null;
 });
 export default DescriptionPanel;

package/esm/ui/FileInfoPanel.js

@@ -1,26 +1,21 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import Attributes from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/Attributes';
 import BaseCard from '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/BaseCard';
-import { readConfSlot } from '@jbrowse/core/configuration';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { ErrorBanner, LoadingEllipses } from '@jbrowse/core/ui';
 import { statusProgressLabel } from '@jbrowse/core/util';
 import { useFetch } from '@jbrowse/core/util/useFetch';
 import { observer } from 'mobx-react';
-// Inline `observer(function(){})`, not a bare declaration: this reads
-// observables (session.rpcManager, and config slots off what is usually a live
-// MST node), and babel-plugin-react-compiler compiles the bare form and can
-// memoize such a read into staleness. RefNameInfoDialog beside it is written
-// the same way; see the React Compiler x MobX note in CLAUDE.md
 const FileInfoPanel = observer(function FileInfoPanel({ config, session, }) {
     const { rpcManager } = session;
-    const trackId = readConfSlot(config, 'trackId');
+    const trackId = readConfObject(config, 'trackId');
     const { data: info, error, isLoading, status, } = useFetch(['CoreGetInfo', trackId], 
     // reading a header can mean walking a v8 .hic's norm-vector index or a
     // multi-megabyte VCF header, so it gets both handles: closing the About
     // dialog stops it, and the wait says what it is
-    async (_name, _trackId, stopToken, statusCallback) => (await rpcManager.call(trackId, 'CoreGetInfo', {
-        adapterConfig: readConfSlot(config, 'adapter'),
-        stopToken,
+    async (_name, _trackId, signal, statusCallback) => (await rpcManager.call(trackId, 'CoreGetInfo', {
+        adapterConfig: readConfObject(config, 'adapter'),
+        signal,
         statusCallback,
     })));
     const details = typeof info === 'string'

package/esm/ui/RefNameInfoDialog.js

@@ -1,11 +1,10 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { readConfSlot } from '@jbrowse/core/configuration';
+import { readConfObject } from '@jbrowse/core/configuration';
 import { CopyToClipboardButton, Dialog, ErrorBanner, LoadingEllipses, } from '@jbrowse/core/ui';
 import { createStatusFanOut, statusProgressLabel } from '@jbrowse/core/util';
 import { getConfAssemblyNames } from '@jbrowse/core/util/tracks';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
 import { useFetch } from '@jbrowse/core/util/useFetch';
-import { isStateTreeNode } from '@jbrowse/mobx-state-tree';
 import { DialogContent } from '@mui/material';
 import { observer } from 'mobx-react';
 const MAX_REF_NAMES = 10_000;
@@ -32,36 +31,24 @@ function formatRefNames(data, truncate) {
         .filter(s => s !== '')
         .join('\n');
 }
-/**
- * A `ReferenceSequenceTrack` config declares no `assemblyNames` slot at all —
- * `createReferenceSeqTrackConfig` omits it deliberately, because such a track's
- * assembly is the config node holding it. `getConfAssemblyNames` is the shared
- * resolver that walks to that parent, and reading the slot directly instead is
- * what left "Show ref names" on every reference sequence track loading forever:
- * `undefined` serialized into the fetch key, which `useFetch` reads as "don't
- * fetch". It throws when a config has neither, which is why this is called
- * inside the fetcher — an unanswerable question belongs in the error banner
- * rather than thrown out of a render.
- */
-function aboutAssemblyNames(config) {
-    return isStateTreeNode(config)
-        ? getConfAssemblyNames(config)
-        : (readConfSlot(config, 'assemblyNames') ?? []);
-}
 const RefNameInfoDialog = observer(function RefNameInfoDialog({ config, session, onClose, }) {
     const { classes } = useStyles();
     const { rpcManager } = session;
-    const trackId = readConfSlot(config, 'trackId');
-    const { data, error, isLoading, status } = useFetch(['CoreGetRefNames', trackId], (_name, _trackId, stopToken, statusCallback) => {
+    const trackId = readConfObject(config, 'trackId');
+    const { data, error, isLoading, status } = useFetch(['CoreGetRefNames', trackId], (_name, _trackId, signal, statusCallback) => {
         // one status slot per assembly, so N concurrent reads aggregate into one
         // bar instead of the last writer winning
         const slot = createStatusFanOut(statusCallback);
-        return Promise.all([...new Set(aboutAssemblyNames(config))].map(async (assemblyName) => [
+        // A `ReferenceSequenceTrack` config declares no `assemblyNames` slot: its
+        // assembly is the config node holding it, which `getConfAssemblyNames`
+        // walks to. It throws when a config has neither, and inside the fetcher
+        // that lands in the error banner rather than out of a render
+        return Promise.all([...new Set(getConfAssemblyNames(config))].map(async (assemblyName) => [
             assemblyName,
             await rpcManager.call(trackId, 'CoreGetRefNames', {
-                adapterConfig: readConfSlot(config, 'adapter'),
+                adapterConfig: readConfObject(config, 'adapter'),
                 assemblyName,
-                stopToken,
+                signal,
                 statusCallback: slot(),
             }),
         ]));