@jbrowse/product-core 4.3.0 → 5.0.0-beta.10

package/esm/Session/Tracks.js

@@ -1,49 +1,248 @@
-import { types } from '@jbrowse/mobx-state-tree';
-import { BaseSessionModel, isBaseSession } from "./BaseSession.js";
-import { ReferenceManagementSessionMixin } from "./ReferenceManagement.js";
+import { expandLooseTrackConfig } from '@jbrowse/core/util/tracks';
+import { addDisposer, types } from '@jbrowse/mobx-state-tree';
+import { autorun, computed } from 'mobx';
+import { BaseSessionModel, isBaseSession } from './BaseSession.js';
+import { isSessionWithConnections } from './Connections.js';
+import { ReferenceManagementSessionMixin } from './ReferenceManagement.js';
+import { assertNotReaddedDifferently } from './readdedTrackConf.js';
+import { assertTrackConfOutlivesItsAssemblies } from './temporaryAssemblyTracks.js';
+/**
+ * #stateModel TracksManagerSessionMixin
+ */
 export function TracksManagerSessionMixin(pluginManager) {
     return types
         .compose('TracksManagerSessionMixin', BaseSessionModel(pluginManager), ReferenceManagementSessionMixin(pluginManager))
         .views(self => ({
+        /**
+         * #getter
+         * Each track's base by trackId: the entry its edits diff against. Here
+         * the config.json entry, which an edit writes directly.
+         */
+        get trackBasesById() {
+            const tracks = self.jbrowse.tracks;
+            return new Map(tracks.map(t => [t.trackId, t]));
+        },
+        /**
+         * #method
+         * A track's base as the session resolves it, its edits applied. Here the
+         * base itself.
+         */
+        withTrackEdits(base) {
+            return base;
+        },
+        /**
+         * #getter
+         */
         get tracks() {
             return self.jbrowse.tracks;
         },
-        get assemblies() {
-            return self.jbrowse.assemblies;
-        },
-        getTracksById() {
+    }))
+        .extend(self => {
+        // Assembly sequences and connection tracks by trackId, which win over a
+        // track base of the same id.
+        const otherConfigsById = computed(() => {
             const temporaryAssemblies = 'temporaryAssemblies' in self
                 ? self.temporaryAssemblies
                 : [];
-            const connectionInstances = 'connectionInstances' in self
-                ? self.connectionInstances
-                : [];
+            // both come from the connections mixin, which not every session
+            // composes. connectionInstances is annotated because its element type
+            // is a runtime-pluggable stateModel, so the guard can't infer it.
+            const connectionInstances = isSessionWithConnections(self) ? self.connectionInstances : [];
+            const connectionTrackConfigs = isSessionWithConnections(self)
+                ? self.connectionTrackConfigs
+                : {};
             return Object.fromEntries([
-                ...this.tracks.map(t => [t.trackId, t]),
-                ...this.assemblies.map(a => [a.sequence.trackId, a.sequence]),
+                ...self.assemblies.map(a => [a.sequence.trackId, a.sequence]),
                 ...temporaryAssemblies.map(a => [a.sequence.trackId, a.sequence]),
                 ...connectionInstances.flatMap(c => c.tracks.map(t => [t.trackId, t])),
+                // Persisted configs of opened connection tracks. Placed last so they
+                // win over the live connection instance: identity-stable across
+                // reload, and resolves even when the connection isn't re-established.
+                ...Object.entries(connectionTrackConfigs).map(([trackId, e]) => [
+                    trackId,
+                    e.config,
+                ]),
             ]);
-        },
-    }))
-        .actions(self => ({
-        addTrackConf(trackConf) {
-            return self.jbrowse.addTrackConf(trackConf);
-        },
-        deleteTrackConf(trackConf) {
-            const callbacksToDereferenceTrack = [];
-            const dereferenceTypeCount = {};
-            const referring = self.getReferring(trackConf);
-            self.removeReferring(referring, trackConf, callbacksToDereferenceTrack, dereferenceTypeCount);
-            for (const cb of callbacksToDereferenceTrack) {
-                cb();
+        }, { name: 'otherConfigsById' });
+        // Kept against the two lists it was built from rather than held, since
+        // holding it would rebuild it on every edit
+        let tracksById;
+        // Per-id computeds backing getTrackById, so an id's readers wake only
+        // when it resolves to another config. Not evicted: bounded by the
+        // distinct ids resolved this session.
+        const trackByIdComputeds = new Map();
+        return {
+            views: {
+                /**
+                 * #method
+                 * Config for one trackId — a track, assembly sequence, or connection
+                 * track — or undefined. Per-id reactive: every display resolves its
+                 * config through this (via TrackConfigurationReference) and
+                 * subscribes only to its own id, so one track's settings edit doesn't
+                 * re-render the others.
+                 */
+                getTrackById(id) {
+                    let c = trackByIdComputeds.get(id);
+                    if (!c) {
+                        c = computed(() => {
+                            const other = otherConfigsById.get()[id];
+                            if (other) {
+                                return other;
+                            }
+                            const base = self.trackBasesById.get(id);
+                            return base && self.withTrackEdits(base);
+                        });
+                        trackByIdComputeds.set(id, c);
+                    }
+                    return c.get();
+                },
+                /**
+                 * #method
+                 * Every track config the session can resolve, keyed by trackId.
+                 * Prefer the per-id reactive `getTrackById(id)`: this map is rebuilt
+                 * over every track on the first read after any edit, and reading it
+                 * subscribes the caller to all of them. Kept for plugins that look
+                 * up ids in a non-reactive context.
+                 *
+                 * @deprecated
+                 */
+                getTracksById() {
+                    const { tracks } = self;
+                    const others = otherConfigsById.get();
+                    if (tracksById?.tracks !== tracks || tracksById.others !== others) {
+                        tracksById = {
+                            tracks,
+                            others,
+                            record: Object.fromEntries([
+                                ...tracks.map(t => [t.trackId, t]),
+                                ...Object.entries(others),
+                            ]),
+                        };
+                    }
+                    return tracksById.record;
+                },
+            },
+            actions: {
+                // Holds the indexes getTrackById reads and the track list, so a
+                // reader outside any reaction (ranking search hits: 33ms per search
+                // unheld on a 2000-track config, 0.07ms held; the search box's
+                // adapter list) gets the cache too. Not `keepAlive`: that
+                // subscription never ends, and it reaches jbrowse.tracks on the
+                // root, so it pinned every superseded session for the tab's life.
+                afterAttach() {
+                    addDisposer(self, autorun(() => {
+                        void self.tracks;
+                        void self.trackBasesById;
+                        otherConfigsById.get();
+                    }, { name: 'trackIndex' }));
+                },
+            },
+        };
+    })
+        .actions(self => {
+        function addToSession(trackConf) {
+            assertTrackConfOutlivesItsAssemblies(self, trackConf, 'jbrowse.tracks');
+            const expanded = expandLooseTrackConfig(trackConf, pluginManager);
+            const { trackId, type } = expanded;
+            const existing = self.getTrackById(trackId);
+            if (existing) {
+                assertNotReaddedDifferently(pluginManager, existing, {
+                    ...expanded,
+                    trackId,
+                    type,
+                });
+                return existing;
             }
-            if (self.adminMode) {
-                return self.jbrowse.deleteTrackConf(trackConf);
-            }
-        },
-    }));
+            return self.jbrowse.addTrackConf(trackConf);
+        }
+        return {
+            /**
+             * #action
+             * Add a track config to *this session*.
+             *
+             * This mixin's session has no separate session-track store, so the
+             * destination is the jbrowse config — which in the products that compose
+             * it (desktop) is the single user's own file rather than something a
+             * server hands other visitors, so the two scopes are the same place.
+             * Defined here anyway so that every session has it: a feature standing a
+             * track up on the user's behalf can then call one action everywhere
+             * instead of asking which mixin it landed on.
+             * `SessionTracksManagerSessionMixin` overrides it with the real
+             * session-scoped store.
+             */
+            addSessionTrackConf(trackConf) {
+                return addToSession(trackConf);
+            },
+            /**
+             * #action
+             * Add a track config wherever *this user's* catalog edits belong — the
+             * "Add track" workflows, where an admin adding a track means to add it
+             * for the whole site. `SessionTracksManagerSessionMixin` overrides it to
+             * send a non-admin's to the session instead; here there is only the one
+             * destination.
+             *
+             * Anything that is not an Add-track workflow wants
+             * `addSessionTrackConf`: a track a feature stands up on the user's behalf
+             * — a search result, a computed consensus, a reconstruction's labels — is
+             * not a catalog entry, and publishing one writes it into the config.json
+             * every visitor is served, once per click.
+             */
+            publishTrackConf(trackConf) {
+                assertTrackConfOutlivesItsAssemblies(self, trackConf, 'jbrowse.tracks');
+                return self.jbrowse.addTrackConf(trackConf);
+            },
+            /**
+             * #action
+             * Deprecated alias of `addSessionTrackConf`. Call that, or
+             * `publishTrackConf`, which say which destination they mean.
+             *
+             * @deprecated
+             *
+             * Kept because a prebuilt plugin bundle reaches this by name at runtime
+             * and cannot be recompiled — `jbrowse-plugin-protein3d` calls it, and a
+             * member lookup that stops resolving throws nothing at all
+             * (`pluginFacingSessionApi.test.ts` is the guard). It now means the
+             * session, which is the destination every such caller wanted: a track a
+             * plugin stands up for one user is not a catalog entry. Nothing in tree
+             * may call it — `no-restricted-syntax` says so.
+             */
+            addTrackConf(trackConf) {
+                return addToSession(trackConf);
+            },
+            /**
+             * #action
+             * Persist edited track config back to the in-memory jbrowse config. The
+             * session-tracks mixin overrides this so a non-admin's edits become a
+             * shareable session-track override instead.
+             */
+            updateTrackConfiguration(trackConf) {
+                // an opened connection track lives in connectionTrackConfigs, not
+                // jbrowse.tracks; persist its edit there (jbrowse.updateTrackConf would
+                // no-op, since the track isn't in the config). Desktop uses this base
+                // mixin, so without this branch a connection-track edit is lost on
+                // reload.
+                if (isSessionWithConnections(self) &&
+                    trackConf.trackId in self.connectionTrackConfigs) {
+                    self.updateConnectionTrackConfig(trackConf);
+                }
+                else {
+                    self.jbrowse.updateTrackConf(trackConf);
+                }
+            },
+            /**
+             * #action
+             */
+            deleteTrackConf(trackConf) {
+                const { trackId } = trackConf;
+                self.dereferenceTrack(trackId, self.getReferring(trackId));
+                if (self.adminMode) {
+                    return self.jbrowse.deleteTrackConf(trackConf);
+                }
+            },
+        };
+    });
 }
+/** Type guard for SessionWithTracks */
 export function isSessionWithTracks(thing) {
     return isBaseSession(thing) && 'tracks' in thing;
 }

package/esm/Session/assertSessionModel.d.ts

@@ -0,0 +1,21 @@
+import type { AssertExtends } from '../assertExtends.ts';
+import type { AbstractSessionModel } from '@jbrowse/core/util/types';
+/**
+ * Compile-time assertion that a concrete session-model instance type satisfies
+ * `AbstractSessionModel`. Reference it with a product's session instance type
+ * to force the check; there is no runtime component, so a missing member
+ * surfaces as a type error at the reference site:
+ *
+ * ```ts
+ * type _Check = AssertSessionModel<Instance<WebSessionModelType>>
+ * ```
+ *
+ * Every product's session model pairs this with one `AssertExtends` per
+ * capability contract it relies on, because this assertion alone is not enough:
+ * `AbstractSessionModel` marks those capabilities **optional**, so it cannot
+ * catch a member drifting out of sync with the `SessionWith*` interface plugins
+ * actually narrow to. Keep them as one assertion per contract rather than
+ * collapsing them into a list — the whole value is the compile error naming the
+ * contract that broke.
+ */
+export type AssertSessionModel<T extends AbstractSessionModel> = AssertExtends<T, AbstractSessionModel>;

package/esm/Session/assertSessionModel.js

@@ -0,0 +1 @@
+export {};

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.name = `${snap.name || snap.trackId} (copy)`;
+    snap.trackId += `-${Date.now()}`;
+    if (opts.clearCategory) {
+        snap.category = undefined;
+    }
+    for (const d of snap.displays ?? []) {
+        d.displayId = `${snap.trackId}-${d.type}`;
+    }
+    return snap;
+}

package/esm/Session/developerMode.d.ts

@@ -0,0 +1,7 @@
+import type { NotificationSink } from '@jbrowse/core/util/types';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+interface DeveloperModeHost extends IStateTreeNode, Pick<NotificationSink, 'notify'> {
+    getPreference: (key: string) => unknown;
+}
+export declare function applyDeveloperMode(self: DeveloperModeHost): void;
+export {};

package/esm/Session/developerMode.js

@@ -0,0 +1,43 @@
+import { addDisposer, isAlive } from '@jbrowse/mobx-state-tree';
+import { enableContractReports, setContractReportSink, } from '@jbrowse/render-core/contractReports';
+/**
+ * What a plugin author sees when their display breaks an ordering contract in
+ * somebody else's production build.
+ *
+ * The checks themselves have always run and always reported; what they had no
+ * way to reach was this population, which is the one least able to diagnose the
+ * symptom and the one nobody can write a test for. A `console.error` surviving
+ * the build would not have fixed that — nobody has a console open on a page
+ * they did not write — so the report has to land in the app, in the session the
+ * broken display is in, and it has to explain itself: the reader did not turn
+ * this on deliberately in the common case (a plugin served from their own
+ * machine did), and a message they cannot place reads as the app being broken.
+ *
+ * `warning` rather than `error`: an error snackbar in this app means the user's
+ * data or their request failed, and every word here is about code they are
+ * writing. Warnings persist until dismissed, which is what a message with a fix
+ * in it wants, and identical ones collapse in the snackbar — so a violation
+ * repeating across ten tracks of one broken type is still one notice.
+ */
+function notification({ family, message, armedBy }) {
+    return (`JBrowse ${family} contract broken — a bug in code, not in your data or ` +
+        `configuration.\n\n${message}\n\n` +
+        `Shown because ${armedBy}. These notices can be turned on anywhere with ` +
+        `localStorage.jbrowseDeveloperMode = 1, or site-wide with ` +
+        `configuration.preferences.developerMode.`);
+}
+export function applyDeveloperMode(self) {
+    if (self.getPreference('developerMode') === true) {
+        enableContractReports('this site sets configuration.preferences.developerMode');
+    }
+    addDisposer(self, setContractReportSink(report => {
+        // out of whatever reaction, fetch handler or upload found the violation:
+        // `notify` writes observables, and a diagnostic that throws where it is
+        // read is worse than the bug it describes
+        queueMicrotask(() => {
+            if (isAlive(self)) {
+                self.notify(notification(report), 'warning');
+            }
+        });
+    }));
+}

package/esm/Session/finalizeSession.d.ts

@@ -0,0 +1,15 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { IAnyModelType, SnapshotIn, SnapshotOut } from '@jbrowse/mobx-state-tree';
+/**
+ * Apply the `Core-extendSession` extension point and drop the legacy
+ * object-shaped `connectionInstances` from incoming snapshots (the schema
+ * changed from an object to an array, so old snapshots must be filtered out,
+ * xref https://github.com/GMOD/jbrowse-components/issues/1903).
+ *
+ * Shared by the web and desktop session factories so the extension point + migration live in one place.
+ */
+export declare function finalizeSession<T extends IAnyModelType>(pluginManager: PluginManager, sessionModel: T): import("@jbrowse/mobx-state-tree").ISnapshotProcessor<T, Omit<SnapshotIn<T> & {
+    connectionInstances?: unknown;
+}, "connectionInstances">, Omit<SnapshotOut<T> & {
+    connectionInstances?: unknown;
+}, "connectionInstances">>;

package/esm/Session/finalizeSession.js

@@ -0,0 +1,28 @@
+import { types } from '@jbrowse/mobx-state-tree';
+/**
+ * Apply the `Core-extendSession` extension point and drop the legacy
+ * object-shaped `connectionInstances` from incoming snapshots (the schema
+ * changed from an object to an array, so old snapshots must be filtered out,
+ * xref https://github.com/GMOD/jbrowse-components/issues/1903).
+ *
+ * Shared by the web and desktop session factories so the extension point + migration live in one place.
+ */
+export function finalizeSession(pluginManager, sessionModel) {
+    const extendedSessionModel = pluginManager.evaluateExtensionPoint(
+    /** #extensionPoint Core-extendSession | sync | Extend the session model with extra state or actions */
+    'Core-extendSession', sessionModel);
+    return types.snapshotProcessor(extendedSessionModel, {
+        preProcessor(snapshot) {
+            const { connectionInstances, ...rest } = snapshot;
+            return !Array.isArray(connectionInstances) ? rest : snapshot;
+        },
+        postProcessor(snapshot) {
+            // connectionInstances are runtime-only: they hold the whole fetched hub
+            // (thousands of tracks), so persisting them bloats the session. Open
+            // connection tracks survive reload via `connectionTrackConfigs` instead,
+            // which resolves synchronously without re-establishing the connection.
+            const { connectionInstances: _connectionInstances, ...rest } = snapshot;
+            return rest;
+        },
+    });
+}

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

@@ -1,10 +1,27 @@
-export * from './ReferenceManagement.ts';
-export * from './Connections.ts';
-export * from './DrawerWidgets.ts';
-export * from './DialogQueue.ts';
-export * from './Themes.ts';
-export * from './Tracks.ts';
-export * from './MultipleViews.ts';
-export * from './BaseSession.ts';
-export * from './SessionTracks.ts';
-export * from './BaseSession.ts';
+export { ReferenceManagementSessionMixin, isSessionWithReferenceManagement, } from './ReferenceManagement.ts';
+export type { ReferringNode, SessionWithReferenceManagement, SessionWithReferenceManagementType, } from './ReferenceManagement.ts';
+export { ConnectionManagementSessionMixin, isSessionWithConnections, } from './Connections.ts';
+export type { ConnectionTrackConfigEntry, SessionWithConnections, SessionWithConnectionsType, } from './Connections.ts';
+export { DrawerWidgetSessionMixin, isSessionWithDrawerWidgets, } from './DrawerWidgets.ts';
+export type { SessionWithDrawerWidgets, SessionWithDrawerWidgetsType, } from './DrawerWidgets.ts';
+export { ThemeManagerSessionMixin, isSessionWithThemes, storedThemeArgs, } from './Themes.ts';
+export type { ThemeModeSelection } from './Themes.ts';
+export type { SessionWithThemes, SessionWithThemesType } from './Themes.ts';
+export { TracksManagerSessionMixin, isSessionWithTracks } from './Tracks.ts';
+export type { SessionWithTracks, SessionWithTracksType } from './Tracks.ts';
+export { MultipleViewsSessionMixin, isSessionWithMultipleViews, } from './MultipleViews.ts';
+export type { SessionWithMultipleViews, SessionWithMultipleViewsType, } from './MultipleViews.ts';
+export { PreferencesSessionMixin } from './Preferences.ts';
+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, 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

@@ -1,10 +1,16 @@
-export * from "./ReferenceManagement.js";
-export * from "./Connections.js";
-export * from "./DrawerWidgets.js";
-export * from "./DialogQueue.js";
-export * from "./Themes.js";
-export * from "./Tracks.js";
-export * from "./MultipleViews.js";
-export * from "./BaseSession.js";
-export * from "./SessionTracks.js";
-export * from "./BaseSession.js";
+export { ReferenceManagementSessionMixin, isSessionWithReferenceManagement, } from './ReferenceManagement.js';
+export { ConnectionManagementSessionMixin, isSessionWithConnections, } from './Connections.js';
+export { DrawerWidgetSessionMixin, isSessionWithDrawerWidgets, } from './DrawerWidgets.js';
+export { ThemeManagerSessionMixin, isSessionWithThemes, storedThemeArgs, } from './Themes.js';
+export { TracksManagerSessionMixin, isSessionWithTracks } from './Tracks.js';
+export { MultipleViewsSessionMixin, isSessionWithMultipleViews, } from './MultipleViews.js';
+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, 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[];

package/esm/Session/pluginExtraTrackItems.js

@@ -0,0 +1,13 @@
+import { buildExtraTrackMenuItems } from '@jbrowse/core/ui/buildExtraTrackMenuItems';
+/**
+ * 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,
+    });
+}

package/esm/Session/readdedTrackConf.d.ts

@@ -0,0 +1,8 @@
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+type TrackConfInput = {
+    trackId: string;
+    type: string;
+} & Record<string, unknown>;
+export declare function assertNotReaddedDifferently(pluginManager: PluginManager, existing: AnyConfigurationModel | TrackConfInput, trackConf: TrackConfInput): void;
+export {};

package/esm/Session/readdedTrackConf.js

@@ -0,0 +1,24 @@
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { compareStructural } from 'mobx';
+import { hydratedTrackForm } from './hydratedForms.js';
+// What a config means once its defaults are resolved: a live config node
+// answers with its snapshot, and a plain object (desktop's `jbrowse.tracks` is
+// frozen, so its entries are the input as written) is hydrated through the
+// same schema first. Two inputs that would build the same node compare equal.
+function resolvedTrackConf(pluginManager, conf) {
+    return isStateTreeNode(conf)
+        ? getSnapshot(conf)
+        : hydratedTrackForm(pluginManager)(conf);
+}
+// Re-adding a trackId the session already holds returns the existing config,
+// which is what keeps a content-hashed trackId idempotent. It is also the trap
+// a recomputed track walks into: the new features arrive under the old id, the
+// old config is handed back, nothing is said, and the track keeps showing the
+// first values it saw. Same id with different content is therefore refused,
+// naming the two-step that works.
+export function assertNotReaddedDifferently(pluginManager, existing, trackConf) {
+    const same = compareStructural(resolvedTrackConf(pluginManager, existing), resolvedTrackConf(pluginManager, trackConf));
+    if (!same) {
+        throw new Error(`Track "${trackConf.trackId}" is already in this session with a different configuration, and adding it again would keep the old one. Delete it first (session.deleteTrackConf(session.getTrackById("${trackConf.trackId}"))), then add — and give a recomputed FromConfigAdapter a new adapterId, since the adapter cache is keyed on it.`);
+    }
+}

package/esm/Session/shareableSnapshot.d.ts

@@ -0,0 +1,23 @@
+import type { AbstractSessionModel } from '@jbrowse/core/util';
+/**
+ * The session snapshot to hand to anyone else — a share link, an exported
+ * `session.json`, a desktop→web export. Snapshotting and baking are one call so
+ * the pair can't be split: a bare `getSnapshot(session)` is never a correct
+ * outgoing snapshot (see `bakeSessionCascades`), and three of the four
+ * boundaries were spelling the two steps out identically.
+ *
+ * The fourth (desktop `ExportToWebDialog`) bakes a *transformed* snapshot from
+ * `planWebExport`, so it calls `bakeSessionCascades` directly.
+ */
+export declare function getShareableSessionSnapshot(session: AbstractSessionModel): Record<string, unknown>;
+/**
+ * Everything an outgoing snapshot has to resolve because the live session
+ * resolves it at read time against state that is staying behind — currently the
+ * workspaces intent alone.
+ *
+ * It keeps its own entry point rather than being inlined into the one caller
+ * because the failure of a boundary that performs half of them is invisible at
+ * that boundary: the export succeeds, and what is missing only shows up on
+ * someone else's screen.
+ */
+export declare function bakeSessionCascades(session: AbstractSessionModel, snapshot: Record<string, unknown>): Record<string, unknown>;