@jbrowse/plugin-linear-genome-view 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/FeatureTrack/configSchema.d.ts

@@ -40,85 +40,177 @@ import type PluginManager from '@jbrowse/core/PluginManager';
  * }
  * ```
  */
-declare const configSchema: (pluginManager: PluginManager) => import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+declare const configSchema: (pluginManager: PluginManager) => import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+    adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+    assemblyNames: {
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
+    };
+    category: {
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
+    };
+    description: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyType>;
+    formatAbout: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly config: {
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
+        };
+        readonly hideUris: {
+            type: "boolean";
+        } & {
+            defaultValue: boolean;
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+    formatDetails: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly feature: {
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
+        };
+        readonly subfeatures: {
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
+        };
+        readonly depth: {
+            type: "maybeNumber";
+        };
+        readonly maxDepth: {
+            type: "maybeNumber";
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+    metadata: {
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
+    };
+    name: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    textSearching: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly indexingAttributes: {
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
+        };
+        readonly indexingFeatureTypesToExclude: {
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
+        };
+        readonly indexingFeatureTypesToInclude: {
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
+        };
+        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, any>;
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+    trackId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
     readonly name: {
-        readonly description: "descriptive name of the track, falls back to the trackId when unset";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
     readonly assemblyNames: {
-        readonly description: "name of the assembly (or assemblies) track belongs to";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly ["assemblyName"];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
     readonly description: {
-        readonly description: "a description of the track";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
     readonly category: {
-        readonly description: "the category and sub-categories of a track";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
     readonly metadata: {
-        readonly type: "frozen";
-        readonly description: "anything to add about this track";
-        readonly defaultValue: {};
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
     readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
     readonly textSearching: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
         readonly indexingAttributes: {
-            readonly type: "stringArray";
-            readonly description: "list of which feature attributes to index for text searching";
-            readonly defaultValue: readonly ["Name", "ID", "symbol"];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
         readonly indexingFeatureTypesToExclude: {
-            readonly type: "stringArray";
-            readonly description: "list of feature types to exclude in text search index";
-            readonly defaultValue: readonly ["CDS", "exon"];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
         readonly indexingFeatureTypesToInclude: {
-            readonly type: "stringArray";
-            readonly description: "the only feature types to index; empty means index every type not excluded";
-            readonly defaultValue: readonly [];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").IAnyType;
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, any>;
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
     readonly displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyType>;
     readonly formatDetails: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
         readonly feature: {
-            readonly type: "frozen";
-            readonly description: "adds extra fields to the feature details";
-            readonly defaultValue: {};
-            readonly contextVariable: ["feature"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly subfeatures: {
-            readonly type: "frozen";
-            readonly description: "adds extra fields to the subfeatures of a feature";
-            readonly defaultValue: {};
-            readonly contextVariable: ["feature"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly depth: {
-            readonly type: "maybeNumber";
-            readonly description: "levels of subfeature the formatDetails.subfeatures callback runs on, default 2";
+            type: "maybeNumber";
         };
         readonly maxDepth: {
-            readonly type: "maybeNumber";
-            readonly description: "hide subfeatures nested deeper than this, default no limit";
+            type: "maybeNumber";
         };
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
     readonly formatAbout: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
         readonly config: {
-            readonly type: "frozen";
-            readonly description: "formats configuration object in about dialog";
-            readonly defaultValue: {};
-            readonly contextVariable: ["config"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly hideUris: {
-            readonly type: "boolean";
-            readonly defaultValue: false;
+            type: "boolean";
+        } & {
+            defaultValue: boolean;
         };
-    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "trackId">>, "trackId">>;
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined, undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    trackId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "trackId", true, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>, "trackId", undefined, import("@jbrowse/core/configuration").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
 export default configSchema;

package/esm/LinearGenomeView/afterAttach.d.ts

@@ -1,17 +1,17 @@
 import type { LinearGenomeViewModel } from './model.ts';
 import type { InitState } from './types.ts';
-import type { AssemblyHost, NotificationSink } from '@jbrowse/core/util';
+import type { AbstractSessionModel, AssemblyHost, NotificationSink } from '@jbrowse/core/util';
 /**
- * Apply an init blob's `highlight` entries to a view, coercing each locstring
- * or wire-format object and reporting a bad one without taking out its
- * siblings.
+ * Add an init blob's `highlight` entries to the session, coercing each
+ * locstring or wire-format object and reporting a bad one without taking out
+ * its siblings. An entry without an assembly takes the launch's.
  *
  * Exported because a LinearSyntenyView row is a LinearGenomeView that does NOT
  * go through this file's init autorun — the synteny view builds each row's
  * snapshot and navigates it itself — so the row's own `highlight` had nowhere
  * to be applied and was dropped in silence.
  */
-export declare function applyInitHighlights(self: LinearGenomeViewModel, session: AssemblyHost & NotificationSink, init: Pick<InitState, 'highlight' | 'assembly'>): void;
+export declare function applyInitHighlights(session: AssemblyHost & NotificationSink & Pick<AbstractSessionModel, 'addHighlight'>, init: Pick<InitState, 'highlight' | 'assembly'>): void;
 /**
  * Autorun that handles the init state - navigating to initial location,
  * showing tracks, etc.

package/esm/LinearGenomeView/afterAttach.js

@@ -5,6 +5,7 @@ import { normalizeTrackInit } from '@jbrowse/core/util/tracks';
 import { addDisposer } from '@jbrowse/mobx-state-tree';
 import { autorun, when } from 'mobx';
 import { SearchResultsNotFoundError } from '../searchUtils.js';
+import { installCloseUps } from './closeUps.js';
 // `init` is a frozen blob that often comes from hand-authored JSON, where a
 // lone entry gets written bare (`tracks: 'genes'`). A string is iterable, so
 // looping over it directly walked its characters — one track opened per letter.
@@ -97,7 +98,7 @@ async function navigateInit(self, session, init) {
             // a spec that listed its tracks gets those tracks; one that only named
             // a gene gets the track the gene was found in, as the search box would
             await self.navToLocString(init.loc, init.assembly, init.grow, {
-                showHitTrack: asArray(init.tracks).length === 0,
+                showHitTrack: init.showHitTrack ?? asArray(init.tracks).length === 0,
             });
         }
         else if (init.displayedRegionNames?.length) {
@@ -138,36 +139,24 @@ async function showInitTracks(self, init) {
         await self.launchTrack(trackId, trackSnapshot, displaySnapshot);
     }
 }
-// backfill assemblyName on any session-authored highlights that omitted it so
-// downstream code (bookmark widget grid, addBookmark, etc) doesn't have to keep
-// falling back
-function backfillHighlightAssemblies(self) {
-    const fallback = self.assemblyNames[0];
-    if (self.highlight.length && fallback) {
-        const normalized = self.highlight.map(h => h.assemblyName ? h : { ...h, assemblyName: fallback });
-        if (normalized.some((h, i) => h !== self.highlight[i])) {
-            self.setHighlight(normalized);
-        }
-    }
-}
 /**
- * Apply an init blob's `highlight` entries to a view, coercing each locstring
- * or wire-format object and reporting a bad one without taking out its
- * siblings.
+ * Add an init blob's `highlight` entries to the session, coercing each
+ * locstring or wire-format object and reporting a bad one without taking out
+ * its siblings. An entry without an assembly takes the launch's.
  *
  * Exported because a LinearSyntenyView row is a LinearGenomeView that does NOT
  * go through this file's init autorun — the synteny view builds each row's
  * snapshot and navigates it itself — so the row's own `highlight` had nowhere
  * to be applied and was dropped in silence.
  */
-export function applyInitHighlights(self, session, init) {
+export function applyInitHighlights(session, init) {
     for (const h of asArray(init.highlight)) {
         // parseLocString throws on an unknown refName or a malformed locstring, and
         // one bad entry must take out neither its siblings nor the rest of init
         try {
             const highlight = coerceHighlight(h, init.assembly, refName => session.assemblyManager.isValidRefName(refName, init.assembly));
             if (highlight) {
-                self.addToHighlights(highlight);
+                session.addHighlight(highlight);
             }
         }
         catch (e) {
@@ -176,8 +165,14 @@ export function applyInitHighlights(self, session, init) {
         }
     }
 }
-async function applyInit(self, init, { superseded }) {
+async function applyInit(self, pending, { superseded }) {
     const session = getSession(self);
+    // A re-launch of a view already showing an assembly need not restate it:
+    // jb.setSession writes `loc` and track entries beside the built state, and
+    // the readiness gate resolved the same default before letting this run.
+    const init = pending.assembly
+        ? pending
+        : { ...pending, assembly: self.launchAssemblyName ?? pending.assembly };
     if (init.tracklist) {
         await openTracklist(self, session, superseded);
     }
@@ -186,9 +181,8 @@ async function applyInit(self, init, { superseded }) {
     // reading or mutating a detached node throws) and also covers the case
     // isAlive misses — a newer setLaunch landed mid-apply, so the rest of *this*
     // blob is stale. Finishing it anyway appends its tracks and highlights under
-    // the one that replaced it, and addToHighlights pushes, so a re-launch of the
-    // same spec (a StrictMode remount) doubles the bands. The drain loop applies
-    // the newer init next either way.
+    // the one that replaced it. The drain loop applies the newer init next either
+    // way.
     //
     // Checked after each await rather than once at the top, and as early returns
     // rather than nesting, so a step added later takes a guard beside it instead
@@ -207,8 +201,7 @@ async function applyInit(self, init, { superseded }) {
     if (init.nav !== undefined) {
         self.setHideHeader(!init.nav);
     }
-    backfillHighlightAssemblies(self);
-    applyInitHighlights(self, session, init);
+    applyInitHighlights(session, init);
 }
 /**
  * Autorun that handles the init state - navigating to initial location,
@@ -272,4 +265,5 @@ export function doAfterAttach(self) {
     setupInitAutorun(self);
     setupCoarseDynamicBlocksAutorun(self);
     setupLocalStorageAutorun(self);
+    installCloseUps(self);
 }

package/esm/LinearGenomeView/closeUps.d.ts

@@ -0,0 +1,83 @@
+import type { LinearGenomeViewModel } from './model.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { Region } from '@jbrowse/core/util/types';
+import type { IAnyModelType, IStateTreeNode } from '@jbrowse/mobx-state-tree';
+import type { Theme } from '@mui/material';
+/**
+ * A close-up is a LinearGenomeView nested under another one, drawn below the
+ * host's tracks and showing a narrower window of the same locus — the header
+ * overview's relationship to the view, carried on downward. Its only state of
+ * its own is `windowWidthBp` and `tracks`: the host writes its regions, width
+ * and left edge, so the close-up always shares the host's centre.
+ *
+ * Declared by hand rather than as the view model's own instance type: the
+ * close-up array is a `types.late` back onto the registered LinearGenomeView,
+ * and naming the model's instance type inside its own factory is a circular
+ * reference tsc refuses (TS7022). Components outside the factory cast a
+ * close-up to `LinearGenomeViewModel`.
+ */
+export interface CloseUp extends IStateTreeNode {
+    id: string;
+    bpPerPx: number;
+    minBpPerPx: number;
+    windowWidthBp: number;
+    windowStartBp: number;
+    displayedRegions: Region[];
+    pendingLaunch?: unknown;
+    setWidth(width: number): void;
+    setDisplayedRegions(regions: Region[]): void;
+    setWindowFrame(windowWidthBp: number, windowStartBp: number): void;
+    showTrack(trackId: string): unknown;
+}
+/**
+ * The stack in page order, each close-up paired with the row above it — the
+ * previous close-up, or the host for the first. The array is widest first and
+ * every close-up is narrower than its host, so page order and array order are
+ * the same thing and each pair reads as one trapezoid: the span this row shows,
+ * marked on the row above it.
+ *
+ * One derivation for the screen and the SVG export, which otherwise agree on
+ * the order by having been written twice.
+ */
+export declare function closeUpStackRows<T>(host: T, closeUps: T[]): {
+    closeUp: T;
+    context: T;
+}[];
+export declare const CLOSE_UP_FRAME_WIDTH = 1;
+/**
+ * The outline a close-up and its connector share. Tertiary is the header
+ * overview's colour, but the dark themes set it near black, so those take its
+ * light shade.
+ */
+export declare function closeUpColor(theme: {
+    palette: Pick<Theme['palette'], 'mode' | 'tertiary'>;
+}): string;
+/**
+ * The registered view, read at first instantiation rather than the factory's
+ * own return value, so a close-up is the LinearGenomeView every
+ * `extendViewType` caller has already extended. The name goes through a
+ * `string` so the typed `getViewType` overload, whose result names this model's
+ * own instance type, is not what tsc resolves here.
+ */
+export declare function closeUpType(pluginManager: PluginManager): IAnyModelType;
+/**
+ * What a close-up reaches on the view holding it. Not `LinearGenomeViewModel`:
+ * the model's own factory calls this, and a return type naming the model there
+ * is the same circular reference as above, which tsc resolves by quietly
+ * widening the whole model.
+ */
+export interface CloseUpHost extends IStateTreeNode {
+    bpPerPx: number;
+    windowWidthBp: number;
+    closeUpViews: CloseUp[];
+    removeCloseUp(closeUp: CloseUp): void;
+    horizontalScroll(distance: number): number;
+    slide(viewWidths: number): void;
+    scrollToBp(startBp: number): number;
+}
+export declare function closeUpHost(node: IStateTreeNode): CloseUpHost | undefined;
+export declare const CLOSE_UP_PANS: Set<string>;
+export declare const CLOSE_UP_NAVIGATIONS: Set<string>;
+export declare const CLOSE_UP_REPLAYS: Set<string>;
+export declare const CLOSE_UP_OWN: Set<string>;
+export declare function installCloseUps(self: LinearGenomeViewModel): void;

package/esm/LinearGenomeView/closeUps.js

@@ -0,0 +1,211 @@
+import { addDisposer, addMiddleware, getParent, hasParent, types, } from '@jbrowse/mobx-state-tree';
+import { autorun, untracked } from 'mobx';
+/**
+ * The stack in page order, each close-up paired with the row above it — the
+ * previous close-up, or the host for the first. The array is widest first and
+ * every close-up is narrower than its host, so page order and array order are
+ * the same thing and each pair reads as one trapezoid: the span this row shows,
+ * marked on the row above it.
+ *
+ * One derivation for the screen and the SVG export, which otherwise agree on
+ * the order by having been written twice.
+ */
+export function closeUpStackRows(host, closeUps) {
+    return closeUps.map((closeUp, i) => ({
+        closeUp,
+        context: closeUps[i - 1] ?? host,
+    }));
+}
+export const CLOSE_UP_FRAME_WIDTH = 1;
+/**
+ * The outline a close-up and its connector share. Tertiary is the header
+ * overview's colour, but the dark themes set it near black, so those take its
+ * light shade.
+ */
+export function closeUpColor(theme) {
+    return theme.palette.mode === 'dark'
+        ? theme.palette.tertiary.light
+        : theme.palette.tertiary.main;
+}
+/**
+ * The registered view, read at first instantiation rather than the factory's
+ * own return value, so a close-up is the LinearGenomeView every
+ * `extendViewType` caller has already extended. The name goes through a
+ * `string` so the typed `getViewType` overload, whose result names this model's
+ * own instance type, is not what tsc resolves here.
+ */
+export function closeUpType(pluginManager) {
+    const name = 'LinearGenomeView';
+    return types.late(() => pluginManager.getViewType(name).stateModel);
+}
+export function closeUpHost(node) {
+    const host = hasParent(node, 2)
+        ? getParent(node, 2)
+        : undefined;
+    return host && 'closeUps' in host
+        ? host
+        : undefined;
+}
+// The three sets below classify every navigation-shaped action of the view, and
+// `closeUps.test.ts` holds them against the view's real action list: a
+// navigation in none of them lands on the close-up and quietly walks it off the
+// host's centre.
+// A gesture on a close-up that means "move": replayed on the host in the host's
+// own units, and swallowed on the close-up, whose left edge is derived.
+export const CLOSE_UP_PANS = new Set(['horizontalScroll', 'scrollTo', 'slide']);
+// A navigation on a close-up that names a place. The close-up and its host lay
+// out the same regions, so the arguments mean the same thing on either, and the
+// host is where they belong. `centerAt` is not an action but a method over
+// `scrollTo`, so the pan above already lands it.
+export const CLOSE_UP_NAVIGATIONS = new Set([
+    'moveTo',
+    'flyToCenter',
+    'navTo',
+    'navToLocation',
+    'navToMultiple',
+    'navToLocString',
+    'navToLocations',
+    'navigateNewestHighlight',
+    'showRegions',
+    'showAllRegionsInAssembly',
+]);
+// Everything a close-up hands to its host untouched. The navigations above,
+// plus the picture: what a reader sees is the stack, and `renderToSvg` draws
+// every close-up above the host that owns them, so a close-up's own Export SVG
+// is the host's. A close-up alone is a row out of a figure nobody asked for.
+export const CLOSE_UP_REPLAYS = new Set([...CLOSE_UP_NAVIGATIONS, 'exportSvg']);
+// What stays the close-up's own: its zoom, which is its one piece of state, and
+// the primitives the sync writes through. `zoomTo` from a wheel anchors under
+// the cursor, and the sync puts the centre back on the same frame.
+export const CLOSE_UP_OWN = new Set([
+    'zoomTo',
+    'zoom',
+    'flyTo',
+    'flyToFit',
+    'showAllRegions',
+    'fitAllRegions',
+    'clampZoomToCeiling',
+    'setWindow',
+    'setWindowFrame',
+    'setNewView',
+    'scrollToBp',
+    'setDisplayedRegions',
+    'horizontallyFlip',
+]);
+/**
+ * Keep every close-up a derived view of its host: same regions, same width,
+ * same centre, and between base level and the row above it, so the stack reads
+ * the host's span at the top zooming in the whole way down. A close-up zoomed
+ * out past its ceiling is pulled back in; a host zoomed in past a close-up
+ * pulls the close-up in with it.
+ */
+function syncCloseUps(self) {
+    // The stack first and alone, so a view with no close-ups — which is every
+    // view in the session but the one someone built a stack on — depends on this
+    // array and nothing else, and its own pans and zooms wake nothing here.
+    const closeUps = self.closeUpViews;
+    if (!closeUps.length) {
+        return;
+    }
+    const { volatileWidth, displayedRegions, windowStartBp, windowWidthBp } = self;
+    if (volatileWidth === undefined || !displayedRegions.length) {
+        return;
+    }
+    const centerBp = windowStartBp + windowWidthBp / 2;
+    let ceiling = windowWidthBp;
+    for (const closeUp of closeUps) {
+        closeUp.setWidth(volatileWidth);
+        if (closeUp.displayedRegions !== displayedRegions) {
+            closeUp.setDisplayedRegions(displayedRegions);
+        }
+        // BOTH of the close-up's own window numbers are read, not just its width,
+        // and that is what makes this the thing holding a close-up under its host
+        // rather than the gesture sets below. An action that moves a close-up
+        // without resizing it — one the sets do not cover, or one added later that
+        // nobody classified — otherwise never wakes this autorun, and the close-up
+        // sits off the centre for good with nothing to put it back. Read, it snaps
+        // back, so a miss costs that gesture rather than the stack.
+        const { windowWidthBp: closeUpWidth, windowStartBp: closeUpStart } = closeUp;
+        // The floor is base level, which `zoomTo` holds every gesture to but not
+        // the window a snapshot arrives carrying — and a stack ten times in each
+        // step reaches it in three or four rungs.
+        const floor = closeUp.minBpPerPx * volatileWidth;
+        const width = Math.min(Math.max(closeUpWidth, floor), ceiling);
+        const start = centerBp - width / 2;
+        if (width !== closeUpWidth || start !== closeUpStart) {
+            closeUp.setWindowFrame(width, start);
+        }
+        ceiling = closeUp.windowWidthBp;
+    }
+}
+/**
+ * Replay a gesture made on a close-up onto its host, or answer false to let it
+ * through. Every read here is of the live tree, which is why the caller runs it
+ * untracked.
+ */
+function redirectCloseUpGesture(self, host, call, abort) {
+    // a close-up's own launch navigates it, and that is not a gesture: the sync
+    // above puts it back under the host once the regions land
+    if (self.pendingLaunch) {
+        return false;
+    }
+    if (CLOSE_UP_PANS.has(call.name)) {
+        const arg = call.args[0];
+        const ratio = self.bpPerPx / host.bpPerPx;
+        if (call.name === 'horizontalScroll') {
+            abort(host.horizontalScroll(arg * ratio) / ratio);
+        }
+        else if (call.name === 'slide') {
+            // a fraction of the close-up's window is that many of its bases, which is
+            // `ratio` widths of the host
+            host.slide(arg * ratio);
+            abort(undefined);
+        }
+        else {
+            const centerBp = arg * self.bpPerPx + self.windowWidthBp / 2;
+            host.scrollToBp(centerBp - host.windowWidthBp / 2);
+            abort(arg);
+        }
+        return true;
+    }
+    if (CLOSE_UP_REPLAYS.has(call.name)) {
+        const target = host;
+        abort(target[call.name](...call.args));
+        return true;
+    }
+    return false;
+}
+/**
+ * The gesture redirect, installed on the CLOSE-UP rather than on the view
+ * holding it. MST collects a call's middleware by walking from the action's own
+ * node up to the root, so one installed on the host runs for every action of
+ * every track and display beneath it — a tax on views that will never hold a
+ * close-up, which is nearly all of them — where one installed here sees this
+ * close-up's subtree and nothing else. It also makes the identity check an
+ * identity check rather than a search through the host's array.
+ */
+function installCloseUpGestures(self, host) {
+    addDisposer(self, addMiddleware(self, (call, next, abort) => {
+        const mine = call.type === 'action' &&
+            call.id === call.rootId &&
+            call.context === self;
+        // A middleware handler runs in whatever context dispatched the action,
+        // and one of those is `syncCloseUps` — an autorun that dispatches
+        // close-up actions. A `pendingLaunch` or `bpPerPx` read registered there
+        // re-runs the whole sync whenever anything in the stack moves.
+        // eslint-disable-next-line no-restricted-syntax -- effect input: the two scales a gesture is replayed at, read where an autorun may be the caller
+        const handled = untracked(() => mine && redirectCloseUpGesture(self, host, call, abort));
+        if (!handled) {
+            next(call);
+        }
+    }));
+}
+export function installCloseUps(self) {
+    addDisposer(self, autorun(function closeUpsAutorun() {
+        syncCloseUps(self);
+    }, { name: 'LGVCloseUps' }));
+    const host = closeUpHost(self);
+    if (host) {
+        installCloseUpGestures(self, host);
+    }
+}

package/esm/LinearGenomeView/components/AddCloseUpDialog.d.ts

@@ -0,0 +1,19 @@
+import type { LinearGenomeViewModel } from '../model.ts';
+import type { BpOffset } from '../types.ts';
+/**
+ * The one thing a close-up still needs deciding once a drag has named its
+ * span: whether it opens showing what this view shows, or empty for a track
+ * chosen afterwards.
+ *
+ * The span is the selection's, named here the way the same menu's "Copy range"
+ * names it, so the dialog says what it is about to open rather than describing
+ * the feature. The model's action takes the same two offsets, for a stack an
+ * agent or a spec builds outright.
+ */
+declare const AddCloseUpDialog: ({ model, leftOffset, rightOffset, handleClose, }: {
+    model: LinearGenomeViewModel;
+    leftOffset?: BpOffset;
+    rightOffset?: BpOffset;
+    handleClose: () => void;
+}) => import("react").JSX.Element;
+export default AddCloseUpDialog;