@jbrowse/plugin-linear-genome-view 5.0.0-beta.2 → 5.0.0-beta.20

package/esm/MultiLevelRubberband/menuItems.js

@@ -0,0 +1,52 @@
+import { rowLabels } from './rowLabel.js';
+/**
+ * One row per genome row, each holding that row's own rubberband menu — Get
+ * sequence, Copy range, Highlight region, and whatever a plugin contributes
+ * under Launch.
+ *
+ * A drag on the multi-level strip commits offsets on EVERY row (see
+ * `useRangeSelect`), so each row's `rubberBandMenuItems()` already describes a
+ * real selection and was simply never offered: the stacked views' menu held
+ * "Zoom to region(s)" and nothing else, while the same drag in a plain linear
+ * genome view offered five actions. Per row rather than applied across rows
+ * because each row is its own assembly — one sequence to fetch, one range to
+ * copy, one highlight to place — so there is no "all rows" answer to give.
+ *
+ * Zoom is the exception and stays where each view already has it: zooming every
+ * row at once is what the gesture means, and the synteny view holds its follow
+ * anchor across the loop.
+ */
+export function multiLevelRowMenuItems(views) {
+    return rowLabels(views).map((label, idx) => ({
+        label,
+        subMenu: views[idx].rubberBandMenuItems(),
+    }));
+}
+/**
+ * The same per-row rows for a bare CLICK on the strip rather than a drag — each
+ * row's Center view here, Zoom to base level and Copy coordinate, at the base
+ * that row paints under `px`.
+ *
+ * No all-rows row above them, unlike the drag's "Zoom to region(s)". A drag
+ * names a span in pixels and every row can act on it; a click names a
+ * COORDINATE, and the rows are different assemblies, so which genome's base the
+ * pointer is over is the question the menu has to ask rather than answer.
+ *
+ * `px` rather than a resolved offset: each row maps the pixel through its own
+ * `pxToBp`, so there is no one offset to pass.
+ */
+export function multiLevelRowClickMenuItems(views, px) {
+    return rowLabels(views).flatMap((label, idx) => {
+        const view = views[idx];
+        // A row with no regions is dropped, because `pxToBp` THROWS on one rather
+        // than answering an offset that names no base — so gating on the built
+        // submenu being empty, which is what this did, was a guard that could never
+        // fire in front of a call that had already thrown. Reachable: a row's
+        // `initialized` is assembly readiness, and the stack mounts this strip once
+        // ANY row is ready.
+        if (!view.displayedRegions.length) {
+            return [];
+        }
+        return [{ label, subMenu: view.rubberbandClickMenuItems(view.pxToBp(px)) }];
+    });
+}

package/esm/MultiLevelRubberband/rowLabel.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What to call each genome row, one label per row. The assembly name where
+ * there is one, and the row's position where a row is still loading, so a label
+ * stays true whatever the assemblies turn out to be called.
+ *
+ * A NAME THAT REPEATS PICKS UP ITS ROW NUMBER, because a stack can hold one
+ * assembly twice — two loci of the same genome, a read against its own
+ * reference — and there the bare name gives two menu rows that open different
+ * things under identical text. Only the repeats pay for it: the ordinary
+ * pairwise view still reads "hg38" and "mm39".
+ *
+ * One function over the whole list rather than one row at a time, since
+ * uniqueness is a property of the list. Shared by every menu that names the
+ * rows — the track selectors, the row menus, the follow anchors, the
+ * rubberband — so they cannot drift into calling the same row two different
+ * things one click apart. Here rather than in the synteny view because the
+ * breakpoint split view is the same stack of rows and had been numbering them
+ * itself.
+ */
+export declare function rowLabels(views: {
+    assemblyNames: string[];
+}[]): string[];

package/esm/MultiLevelRubberband/rowLabel.js

@@ -0,0 +1,27 @@
+/**
+ * What to call each genome row, one label per row. The assembly name where
+ * there is one, and the row's position where a row is still loading, so a label
+ * stays true whatever the assemblies turn out to be called.
+ *
+ * A NAME THAT REPEATS PICKS UP ITS ROW NUMBER, because a stack can hold one
+ * assembly twice — two loci of the same genome, a read against its own
+ * reference — and there the bare name gives two menu rows that open different
+ * things under identical text. Only the repeats pay for it: the ordinary
+ * pairwise view still reads "hg38" and "mm39".
+ *
+ * One function over the whole list rather than one row at a time, since
+ * uniqueness is a property of the list. Shared by every menu that names the
+ * rows — the track selectors, the row menus, the follow anchors, the
+ * rubberband — so they cannot drift into calling the same row two different
+ * things one click apart. Here rather than in the synteny view because the
+ * breakpoint split view is the same stack of rows and had been numbering them
+ * itself.
+ */
+export function rowLabels(views) {
+    const names = views.map((view, idx) => view.assemblyNames[0] ?? `Row ${idx + 1}`);
+    const counts = new Map();
+    for (const name of names) {
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    return names.map((name, idx) => counts.get(name) > 1 ? `${name} (row ${idx + 1})` : name);
+}

package/esm/MultiLevelRubberband/types.d.ts

@@ -3,4 +3,5 @@ import type { MenuItem } from '@jbrowse/core/ui';
 export interface MultiLevelRubberbandModel {
     views: LinearGenomeViewModel[];
     rubberBandMenuItems: () => MenuItem[];
+    rubberbandClickMenuItemsAtPx: (px: number) => MenuItem[];
 }

package/esm/MultiLevelRubberband/useRangeSelect.d.ts

@@ -4,9 +4,10 @@ interface AnchorPosition {
     offsetX: number;
     clientX: number;
     clientY: number;
+    isClick: boolean;
 }
 export declare function useRangeSelect(ref: React.RefObject<HTMLDivElement | null>, model: MultiLevelRubberbandModel): {
-    open: boolean;
+    isClick: boolean | undefined;
     rubberbandOn: boolean;
     guideX: number | undefined;
     anchorPosition: AnchorPosition | undefined;

package/esm/MultiLevelRubberband/useRangeSelect.js

@@ -1,6 +1,7 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useState } from 'react';
 import { getRelativeX } from '@jbrowse/core/util/getRelativeX';
 import { transaction } from 'mobx';
+import { useWindowDrag } from '../shared/useWindowDrag.js';
 export function useRangeSelect(ref, model) {
     const [startX, setStartX] = useState();
     const [currentX, setCurrentX] = useState(0);
@@ -18,8 +19,15 @@ export function useRangeSelect(ref, model) {
         });
     }, [model]);
     // releases the committed offsets too, since mouseOut no longer does while the
-    // menu is open — closing the menu (button, Escape, or a bare click) is the
-    // point the selection is actually finished with
+    // menu is open — dismissing the menu, by its backdrop or Escape, is the point
+    // the selection is actually finished with. A bare click on the strip no longer
+    // comes through here: it opens the click menu instead.
+    //
+    // `CascadingMenu` dismisses BEFORE it runs the clicked row's callback, so this
+    // clears the offsets out from under it. Every menu built here captures them
+    // when the rows are built, which is why that works — the plain linear genome
+    // view's host never clears, so a row written to read them live works there
+    // and silently no-ops from a stacked row.
     const handleClose = useCallback(() => {
         setAnchorPosition(undefined);
         setStartX(undefined);
@@ -27,71 +35,48 @@ export function useRangeSelect(ref, model) {
         setGuideX(undefined);
         clearOffsets();
     }, [clearOffsets]);
-    useEffect(() => {
-        const el = ref.current;
-        if (!mouseDragging || !el) {
-            return;
-        }
-        // the container's left edge is fixed for the duration of a drag, so measure
-        // it once here rather than calling getBoundingClientRect on every mousemove
-        const { left } = el.getBoundingClientRect();
-        function globalMouseMove(event) {
-            setCurrentX(event.clientX - left);
-        }
-        function globalMouseUp(event) {
-            if (startX === undefined) {
+    useWindowDrag(ref, mouseDragging ? startX : undefined, {
+        onMove: setCurrentX,
+        onEnd: ({ startX, endX, isClick, clientX, clientY }) => {
+            setAnchorPosition({ offsetX: endX, clientX, clientY, isClick });
+            if (isClick) {
+                // the click menu names a coordinate, not a span, so nothing is
+                // committed; the guide stays at the click so the menu says where
+                setGuideX(endX);
                 return;
             }
-            const offsetX = event.clientX - left;
-            if (Math.abs(offsetX - startX) <= 3) {
-                handleClose();
-                return;
-            }
-            setAnchorPosition({
-                offsetX,
-                clientX: event.clientX,
-                clientY: event.clientY,
-            });
-            const leftPx = Math.min(startX, offsetX);
-            const rightPx = Math.max(startX, offsetX);
+            const leftPx = Math.min(startX, endX);
+            const rightPx = Math.max(startX, endX);
             transaction(() => {
                 for (const view of model.views) {
                     view.setOffsets(view.pxToBp(leftPx), view.pxToBp(rightPx));
                 }
             });
             setGuideX(undefined);
-        }
-        function globalKeyDown(event) {
-            if (event.key === 'Escape') {
-                handleClose();
-            }
-        }
-        window.addEventListener('mousemove', globalMouseMove);
-        window.addEventListener('mouseup', globalMouseUp);
-        window.addEventListener('keydown', globalKeyDown);
-        return () => {
-            window.removeEventListener('mousemove', globalMouseMove);
-            window.removeEventListener('mouseup', globalMouseUp);
-            window.removeEventListener('keydown', globalKeyDown);
-        };
-    }, [startX, mouseDragging, model, ref, handleClose]);
+        },
+        onCancel: handleClose,
+    });
     function mouseDown(event) {
-        event.preventDefault();
-        event.stopPropagation();
-        // clear any leftover menu/selection so a fresh drag isn't blocked by a
-        // stale anchorPosition keeping mouseDragging false
-        setAnchorPosition(undefined);
-        // the guide is what the pointer was showing up to now, and mouseMove won't
-        // touch it during the drag — leaving it set keeps the selection span from
-        // ever rendering, since the guide wins that either/or
-        setGuideX(undefined);
-        const relativeX = getRelativeX(event, ref.current);
-        setStartX(relativeX);
-        setCurrentX(relativeX);
+        if (event.button === 0) {
+            event.preventDefault();
+            event.stopPropagation();
+            // clear any leftover menu/selection so a fresh drag isn't blocked by a
+            // stale anchorPosition keeping mouseDragging false
+            setAnchorPosition(undefined);
+            // the guide is what the pointer was showing up to now, and mouseMove
+            // won't touch it during the drag — leaving it set keeps the selection
+            // span from ever rendering, since the guide wins that either/or
+            setGuideX(undefined);
+            const relativeX = getRelativeX(event, ref.current);
+            setStartX(relativeX);
+            setCurrentX(relativeX);
+        }
     }
     function mouseMove(event) {
-        // Don't update guideX while the menu is open (rubberband locked) or while a
-        // drag-selection is in progress (the rubberband should show, not the guide)
+        // Don't update guideX while a menu is open — the guide is what the click
+        // menu's rows refer to, so it stays at the click rather than following the
+        // pointer to the menu — or while a drag-selection is in progress (the
+        // rubberband should show, not the guide)
         if (anchorPosition || mouseDragging) {
             return;
         }
@@ -112,13 +97,14 @@ export function useRangeSelect(ref, model) {
         callback();
         handleClose();
     }
-    const rubberbandOn = startX !== undefined;
+    const isClick = anchorPosition?.isClick;
+    const rubberbandOn = startX !== undefined && !isClick;
     const right = anchorPosition?.offsetX ?? currentX;
     const left = rubberbandOn ? Math.min(right, startX) : 0;
     const width = rubberbandOn ? Math.abs(right - startX) : 0;
     const views = rubberbandOn ? model.views : [];
     return {
-        open: Boolean(anchorPosition),
+        isClick,
         rubberbandOn,
         guideX,
         anchorPosition,

package/esm/TrackModifiers/index.d.ts

@@ -0,0 +1,83 @@
+import type { FieldPredicate } from '@jbrowse/core/util/fieldPredicate';
+import type { TrackInit } from '@jbrowse/core/util/tracks';
+import type { DisplaySettings } from '@jbrowse/launch-args/displaySettings';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+/** The linear view a command line's tracks open in, as these helpers read it. */
+export interface ModifierView {
+    centerLineInfo?: {
+        refName?: string;
+        offset: number;
+        start: number;
+        end: number;
+        reversed?: boolean;
+        oob?: boolean;
+    };
+    launchTrack: (trackId: string, trackSnapshot?: object, displaySnapshot?: object) => Promise<{
+        displays: unknown[];
+    } | undefined>;
+    showTrack: (trackId: string, trackSnapshot?: object, displaySnapshot?: object) => unknown;
+    tracks: {
+        configuration: {
+            trackId: string;
+        };
+        displays: unknown[];
+        activeDisplay: {
+            configuration: Record<string, unknown>;
+        };
+    }[];
+}
+/**
+ * `displayTypeOf` for a track the session holds, undefined for one it does
+ * not; `displayType` is the display the caller opens it as when no
+ * `display:` modifier names one.
+ */
+export declare function openedDisplayType(session: {
+    getTrackById: (trackId: string) => unknown;
+}, trackId: string, modifiers: string[], displayType?: string): string | undefined;
+/**
+ * Write the `filter` of `trackId`'s `settings` onto its display open in
+ * `view`, by field over the configured filter, as the track menu would.
+ * Returns the display's filter as written, which reopens the track as drawn,
+ * or undefined when the settings write no filter.
+ */
+export declare function writeFilter(view: Pick<ModifierView, 'tracks' | 'showTrack'>, trackId: string, settings: DisplaySettings): FieldPredicate[] | undefined;
+/**
+ * @deprecated `writeFilter`, which every display category takes. This one
+ * writes an alignments `display`'s filter only.
+ */
+export declare function writeReadFilter(display: unknown, displayType: string | undefined, settings: DisplaySettings): FieldPredicate[] | undefined;
+interface LaunchOptions {
+    /** the track entry's own display settings, which the modifiers write over */
+    displaySnapshot?: Record<string, unknown>;
+    trackSnapshot?: Record<string, unknown>;
+    /** changes the settings after the center-line sort resolves, before the open */
+    adjust?: (settings: DisplaySettings) => void;
+    warn?: (message: string) => void;
+}
+/**
+ * Open `trackId` in `view` with its command-line modifiers applied, and return
+ * the session-spec track entry that reopens it as drawn, or undefined when the
+ * open fails, which `launchTrack` reports to the session.
+ */
+export declare function launchTrackWithModifiers(view: ModifierView, trackId: string, displayType: string | undefined, modifiers: string[], { displaySnapshot, trackSnapshot, adjust, warn, }?: LaunchOptions): Promise<{
+    trackId: string;
+    filter?: FieldPredicate[] | undefined;
+} | undefined>;
+/**
+ * Open a session spec's track entry in a navigated `view`, its `modifiers`
+ * written over its display settings. When a modifier or the open fails, the
+ * session's snackbar says why and the track opens with its own settings.
+ */
+export declare function launchTrackInit(view: ModifierView & IAnyStateTreeNode, t: TrackInit): Promise<void>;
+/**
+ * Write a track's `memberWrites` onto what its display in `view` already has,
+ * after every other modifier, so a member write keeps the rest of the setting
+ * whatever order the command line gives them in. A display replaces a color
+ * or facet object whole, which is why these cannot ride in on the launch
+ * snapshot. A keyed object (`rows`, ADR-257) seeds only its field and the
+ * objects written whole that the writes reach, such as `rows.color`: seeded
+ * whole it would restate the arrangement a field write must drop, and
+ * unseeded a spec holding the patch would lose the field and the channel.
+ */
+export declare function writeMembers(view: Pick<ModifierView, 'tracks' | 'showTrack'>, trackId: string, members: string[]): Record<string, unknown>;
+export {};

package/esm/TrackModifiers/index.js

@@ -0,0 +1,231 @@
+import { keyedWritesAt, mergeConfSettings, writesWholeAt, } from '@jbrowse/core/configuration';
+import { getEnv, getSession } from '@jbrowse/core/util';
+import { basePaintedAt } from '@jbrowse/core/util/Base1DUtils';
+import { predicatesOf, testsSomething, withFields, } from '@jbrowse/core/util/fieldPredicate';
+import { normalizeTrackInit, trackDisplayType } from '@jbrowse/core/util/tracks';
+import { buildDisplaySnapshot, displayCategory, memberPatch, memberWrites, mergeSettings, requestedDisplayType, } from '@jbrowse/launch-args/displaySettings';
+import { getSnapshot, getType, isArrayType, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
+/**
+ * The display a linear view opens `conf` as, read off the display picker so it
+ * follows `display:` and the adapter rather than a list of track types.
+ */
+function displayTypeOf(pluginManager, conf, modifiers, displayType) {
+    return trackDisplayType(pluginManager, conf, 'LinearGenomeView', requestedDisplayType(modifiers) ?? displayType);
+}
+/**
+ * `displayTypeOf` for a track the session holds, undefined for one it does
+ * not; `displayType` is the display the caller opens it as when no
+ * `display:` modifier names one.
+ */
+export function openedDisplayType(session, trackId, modifiers, displayType) {
+    const conf = session.getTrackById(trackId);
+    return conf
+        ? displayTypeOf(getEnv(session).pluginManager, (isStateTreeNode(conf) ? getSnapshot(conf) : conf), modifiers, displayType)
+        : undefined;
+}
+const consoleWarn = (message) => {
+    console.warn(`Warning: ${message}`);
+};
+function modifierLaunch(displayType, modifiers, warn = consoleWarn) {
+    return {
+        displayType,
+        settings: buildDisplaySnapshot(displayType, modifiers, warn),
+        members: memberWrites(displayType, modifiers),
+    };
+}
+// the entries grouped by field, as `setFilterFields` takes them: a field whose
+// entries are all bare is `[]`, which clears it, defaults included
+function filterPatch(entries) {
+    const patch = {};
+    for (const p of entries) {
+        patch[p.field] = [
+            ...(patch[p.field] ?? []),
+            ...(testsSomething(p) ? [p] : []),
+        ];
+    }
+    return patch;
+}
+// the display snapshot a track opens with. `filter` stays out of it:
+// `writeFilter` writes it once the track is open, since the list in a
+// snapshot would replace the configured one
+function launchSnapshot({ settings }) {
+    const { snap, displayType } = settings;
+    const { filter: _filter, ...unfiltered } = snap;
+    return {
+        ...unfiltered,
+        ...(displayType ? { type: displayType } : {}),
+    };
+}
+/**
+ * Write the `filter` of `trackId`'s `settings` onto its display open in
+ * `view`, by field over the configured filter, as the track menu would.
+ * Returns the display's filter as written, which reopens the track as drawn,
+ * or undefined when the settings write no filter.
+ */
+export function writeFilter(view, trackId, settings) {
+    const { filter } = settings.snap;
+    const track = view.tracks.find(t => t.configuration.trackId === trackId);
+    if (!filter || !track) {
+        return undefined;
+    }
+    const patch = filterPatch(filter);
+    const display = track.displays[0];
+    if (display?.setFilterFields) {
+        display.setFilterFields(patch);
+        return display.writtenFilter;
+    }
+    const written = withFields(predicatesOf(track.activeDisplay.configuration.filter), patch);
+    view.showTrack(trackId, {}, { filter: written });
+    return written;
+}
+/**
+ * @deprecated `writeFilter`, which every display category takes. This one
+ * writes an alignments `display`'s filter only.
+ */
+export function writeReadFilter(display, displayType, settings) {
+    const { filter } = settings.snap;
+    if (displayCategory(displayType) !== 'alignments' || !filter) {
+        return undefined;
+    }
+    const filterDisplay = display;
+    filterDisplay?.setFilterFields?.(filterPatch(filter));
+    return filterDisplay?.writtenFilter;
+}
+// the pivot is the base under the view's center, which a view has only once
+// it shows a region
+function centerSort(view, trackId, field, warn) {
+    const center = view.centerLineInfo;
+    if (center && !center.oob) {
+        return {
+            field,
+            pos: basePaintedAt(center, center.offset),
+            refName: center.refName ?? '',
+        };
+    }
+    else {
+        warn(`sort:${field} on "${trackId}" ignored — the view has no center position to sort at (pass --loc)`);
+        return undefined;
+    }
+}
+// The modifiers' settings written over the entry's own as a settings bag
+// writes them (`mergeConfSettings`): a namespace such as `pileup` member by
+// member, a bare value lifted first, and a channel such as `encoding.color`
+// whole, so a `color:` modifier is not mixed into the entry's color by field.
+// Plain JSON where no registered display type says which is which.
+function overEntry(view, displayType, entry, over) {
+    const pluginManager = isStateTreeNode(view)
+        ? getEnv(view).pluginManager
+        : undefined;
+    return displayType && pluginManager?.displayTypes.has(displayType)
+        ? mergeConfSettings(pluginManager.getDisplayType(displayType).configSchema, entry, over)
+        : mergeSettings(structuredClone(entry), over);
+}
+/**
+ * Open `trackId` in `view` with its command-line modifiers applied, and return
+ * the session-spec track entry that reopens it as drawn, or undefined when the
+ * open fails, which `launchTrack` reports to the session.
+ */
+export async function launchTrackWithModifiers(view, trackId, displayType, modifiers, { displaySnapshot = {}, trackSnapshot = {}, adjust, warn = consoleWarn, } = {}) {
+    const launch = modifierLaunch(displayType, modifiers, warn);
+    const { snap, sort } = launch.settings;
+    const at = sort && centerSort(view, trackId, sort.field, warn);
+    if (at) {
+        snap.sort = at;
+    }
+    adjust?.(launch.settings);
+    const launched = overEntry(view, displayType, displaySnapshot, launchSnapshot(launch));
+    const opened = await view.launchTrack(trackId, trackSnapshot, launched);
+    if (!opened) {
+        return undefined;
+    }
+    const drawnFilter = writeFilter(view, trackId, launch.settings);
+    const members = writeMembers(view, trackId, launch.members);
+    return {
+        trackId,
+        ...launched,
+        ...(drawnFilter ? { filter: drawnFilter } : {}),
+        ...members,
+    };
+}
+/**
+ * Open a session spec's track entry in a navigated `view`, its `modifiers`
+ * written over its display settings. When a modifier or the open fails, the
+ * session's snackbar says why and the track opens with its own settings.
+ */
+export async function launchTrackInit(view, t) {
+    const { trackId, trackSnapshot, displaySnapshot, modifiers } = normalizeTrackInit(t);
+    if (modifiers.length === 0) {
+        await view.launchTrack(trackId, trackSnapshot, displaySnapshot);
+        return;
+    }
+    const session = getSession(view);
+    const { type } = displaySnapshot;
+    const notes = [];
+    try {
+        await launchTrackWithModifiers(view, trackId, openedDisplayType(session, trackId, modifiers, typeof type === 'string' ? type : undefined), modifiers, {
+            trackSnapshot,
+            displaySnapshot,
+            warn: message => notes.push(message),
+        });
+    }
+    catch (e) {
+        console.error(e);
+        session.notifyError(`"${trackId}" ${modifiers.join(' ')}: ${e}`, e);
+    }
+    // launchTrack reports its own failure, such as a display:
+    // the track cannot open as
+    if (!view.tracks.some(t => t.configuration.trackId === trackId)) {
+        await view.launchTrack(trackId, trackSnapshot, displaySnapshot);
+    }
+    if (notes.length) {
+        session.notify(notes.join('; '), 'warning');
+    }
+}
+// the named members of a keyed object as configured, undefined when it
+// states none of them
+function keyedSeed(member, names) {
+    const configured = isStateTreeNode(member)
+        ? getSnapshot(member)
+        : {};
+    const seed = Object.fromEntries(names.flatMap(name => configured[name] === undefined ? [] : [[name, configured[name]]]));
+    return Object.keys(seed).length > 0 ? seed : undefined;
+}
+/**
+ * Write a track's `memberWrites` onto what its display in `view` already has,
+ * after every other modifier, so a member write keeps the rest of the setting
+ * whatever order the command line gives them in. A display replaces a color
+ * or facet object whole, which is why these cannot ride in on the launch
+ * snapshot. A keyed object (`rows`, ADR-257) seeds only its field and the
+ * objects written whole that the writes reach, such as `rows.color`: seeded
+ * whole it would restate the arrangement a field write must drop, and
+ * unseeded a spec holding the patch would lose the field and the channel.
+ */
+export function writeMembers(view, trackId, members) {
+    if (members.length === 0) {
+        return {};
+    }
+    const track = view.tracks.find(t => t.configuration.trackId === trackId);
+    if (!track) {
+        throw new Error(`"${trackId}" is not open, so ${members.join(' ')} has nothing to write to`);
+    }
+    const { configuration } = track.activeDisplay;
+    const configured = getSnapshot(configuration);
+    const type = getType(configuration);
+    const patch = memberPatch(members, (root, reached) => {
+        // a list at a default the snapshot strips, Manhattan's marks, still seeds
+        // the write, so `marks.0.mark=bar` edits the mark drawn
+        const member = configuration[root];
+        const keyed = keyedWritesAt(type, [root]);
+        return keyed
+            ? keyedSeed(member, [
+                keyed.keyedBy,
+                ...reached.filter(m => writesWholeAt(type, [root, m])),
+            ])
+            : (configured[root] ??
+                (isStateTreeNode(member) && isArrayType(getType(member))
+                    ? getSnapshot(member)
+                    : undefined));
+    });
+    view.showTrack(trackId, {}, patch);
+    return patch;
+}