@jbrowse/app-core 5.0.0-beta.1 → 5.0.0-beta.3

package/esm/WorkspaceLayout/spec.d.ts

@@ -1,19 +1,49 @@
 import type { LayoutTree, NodeKind } from './tree.ts';
+/**
+ * A view named by a layout leaf: an index into the view list the layout is
+ * applied against (a session spec's own `views`, or `session.views` for the
+ * live `applyLayoutSpec`), or a view id.
+ */
+export type LayoutViewRef = number | string;
 /**
  * The `layout` a session spec / URL param states, in the vocabulary users
- * write it in. **This shape is public** — it is documented as a URL parameter —
- * so it keeps `horizontal`/`vertical`/`tabs` and percentage `size` rather than
- * being renamed to match the internal tree.
+ * write it in, and the same shape the live `applyLayoutSpec` action takes — one
+ * shape, so an agent that has written one has written the other. **This shape
+ * is public** — it is documented as a URL parameter — so it keeps
+ * `horizontal`/`vertical`/`tabs` and percentage `size` rather than being
+ * renamed to match the internal tree.
+ *
+ * `resolveLayoutSpec` turns the indexes into ids; the tree builder below takes
+ * the resolved form only.
  */
-export interface LayoutSpecNode {
+export interface LayoutSpecNode<View = LayoutViewRef> {
     /** a leaf: the views to stack vertically in one tab */
-    viewIds?: string[];
+    views?: View[];
     /** how children divide the space; `tabs` puts them in one cell as tabs */
     direction?: 'horizontal' | 'vertical' | 'tabs';
-    children?: LayoutSpecNode[];
+    children?: LayoutSpecNode<View>[];
     /** share of the parent, as a percentage */
     size?: number;
 }
+export type ResolvedLayoutSpecNode = LayoutSpecNode<string>;
+/**
+ * Resolve every view a spec names to an id against `allViewIds`, the list its
+ * indexes count into. Anything that resolves to nothing throws, naming what was
+ * received: an untyped caller (the MCP `run_javascript` tool) that writes
+ * `viewIds` where `views` goes, or an index past the end, used to be accepted
+ * as an empty leaf and collapse the workspace into one blank tab with nothing
+ * said.
+ *
+ * A node stating no `views` and no `children` is NOT that slip — it is the
+ * empty panel `treeFromSpec` has always built, and refusing it here made the
+ * two surfaces disagree about the one shape they share. The slip is an
+ * unrecognized KEY, which is what `viewIds` actually is, and naming it beats
+ * the old message that could only say the node needed something else.
+ *
+ * `allViewIds` is undefined only on a model that composes no view list, where
+ * an id cannot be checked and an index cannot mean anything.
+ */
+export declare function resolveLayoutSpec(spec: LayoutSpecNode, allViewIds: string[] | undefined): ResolvedLayoutSpecNode;
 /** A request to move one view relative to the others. Public plugin API. */
 export interface PendingMove {
     type: 'newTab' | 'splitRight';
@@ -29,9 +59,9 @@ export interface PendingMove {
  * nesting, so `size` applies wherever it is written and there is no all-or-
  * nothing pass.
  */
-export declare function treeFromSpec(spec: LayoutSpecNode, nextId: (kind: NodeKind) => string): LayoutTree;
+export declare function treeFromSpec(spec: ResolvedLayoutSpecNode, nextId: (kind: NodeKind) => string): LayoutTree;
 /** Every viewId a spec names, depth-first — the order it states. */
-export declare function viewIdsInSpec(spec: LayoutSpecNode): string[];
+export declare function viewIdsInSpec(spec: ResolvedLayoutSpecNode): string[];
 /** How "arrange everything" lays the whole session out. */
 export type TileMode = 'tabs' | 'horizontal' | 'vertical' | 'grid';
 /**
@@ -49,10 +79,10 @@ export type TileMode = 'tabs' | 'horizontal' | 'vertical' | 'grid';
  * width, since `resolveSizes` reads bare siblings as an even share of their own
  * branch rather than of the grid.
  */
-export declare function tileLayoutSpec(viewIds: string[], mode: TileMode): LayoutSpecNode;
+export declare function tileLayoutSpec(viewIds: string[], mode: TileMode): ResolvedLayoutSpecNode;
 /**
  * `setPendingMove` as a spec: everything else keeps its side, the named view
  * takes the other. With nothing else on screen there is nothing to split from,
  * so the view just takes the space.
  */
-export declare function specForPendingMove(move: PendingMove, allViewIds: string[]): LayoutSpecNode;
+export declare function specForPendingMove(move: PendingMove, allViewIds: string[]): ResolvedLayoutSpecNode;

package/esm/WorkspaceLayout/spec.js

@@ -1,4 +1,77 @@
 import { normalize } from './tree.js';
+// `views`/`children` are pulled off by name; the rest pass through to the tree,
+// so an unrecognized one is a key the writer expected to mean something
+const layoutNodeKeys = new Set(['views', 'direction', 'children', 'size']);
+/**
+ * Resolve every view a spec names to an id against `allViewIds`, the list its
+ * indexes count into. Anything that resolves to nothing throws, naming what was
+ * received: an untyped caller (the MCP `run_javascript` tool) that writes
+ * `viewIds` where `views` goes, or an index past the end, used to be accepted
+ * as an empty leaf and collapse the workspace into one blank tab with nothing
+ * said.
+ *
+ * A node stating no `views` and no `children` is NOT that slip — it is the
+ * empty panel `treeFromSpec` has always built, and refusing it here made the
+ * two surfaces disagree about the one shape they share. The slip is an
+ * unrecognized KEY, which is what `viewIds` actually is, and naming it beats
+ * the old message that could only say the node needed something else.
+ *
+ * `allViewIds` is undefined only on a model that composes no view list, where
+ * an id cannot be checked and an index cannot mean anything.
+ */
+export function resolveLayoutSpec(spec, allViewIds) {
+    const describe = (value) => typeof value === 'string' ? `"${value}"` : String(value);
+    const resolveRef = (ref) => {
+        if (typeof ref === 'number') {
+            if (!allViewIds) {
+                throw new Error(`Layout names view index ${ref}, but this session has no view list for an index to count into; name the view by id`);
+            }
+            const id = allViewIds[ref];
+            if (id === undefined) {
+                throw new Error(`Layout names view index ${ref}, but the session has ${allViewIds.length} view(s)${allViewIds.length ? ` (indexes 0-${allViewIds.length - 1})` : ''}`);
+            }
+            return id;
+        }
+        if (typeof ref !== 'string') {
+            throw new Error(`Layout "views" entries are view indexes or view ids; received ${describe(ref)}`);
+        }
+        if (allViewIds && !allViewIds.includes(ref)) {
+            throw new Error(`Layout names view id ${describe(ref)}, which is not a view in this session (ids: ${allViewIds.map(describe).join(', ') || 'none'})`);
+        }
+        return ref;
+    };
+    const resolveNode = (node) => {
+        const { views, children, ...rest } = node;
+        const unknown = Object.keys(rest).filter(key => !layoutNodeKeys.has(key));
+        if (unknown.length > 0) {
+            throw new Error(`Layout node has unrecognized key(s) ${unknown.map(describe).join(', ')}; a leaf names its views with "views" (view indexes or ids) and a container nests "children"`);
+        }
+        if (views !== undefined && !Array.isArray(views)) {
+            throw new Error(`Layout "views" is an array of view indexes or ids; received ${describe(views)}`);
+        }
+        if (children !== undefined && !Array.isArray(children)) {
+            throw new Error(`Layout "children" is an array of layout nodes; received ${describe(children)}`);
+        }
+        return {
+            ...rest,
+            ...(views === undefined ? {} : { views: views.map(resolveRef) }),
+            ...(children === undefined
+                ? {}
+                : { children: children.map(resolveNode) }),
+        };
+    };
+    const resolved = resolveNode(spec);
+    const seen = new Set();
+    const repeated = new Set(viewIdsInSpec(resolved).filter(id => {
+        const already = seen.has(id);
+        seen.add(id);
+        return already;
+    }));
+    if (repeated.size > 0) {
+        throw new Error(`Layout seats view ${[...repeated].map(describe).join(', ')} in more than one cell; a view lives in exactly one tab, so name it once`);
+    }
+    return resolved;
+}
 /**
  * The effective size of each child of one branch.
  *
@@ -44,11 +117,11 @@ function resolveSizes(children) {
  */
 export function treeFromSpec(spec, nextId) {
     function build(node, size) {
-        if (node.viewIds) {
+        if (node.views) {
             return {
                 id: nextId('panel'),
                 size,
-                tabs: [{ id: nextId('tab'), viewIds: [...node.viewIds] }],
+                tabs: [{ id: nextId('tab'), viewIds: [...node.views] }],
                 activeTabId: undefined,
             };
         }
@@ -67,7 +140,7 @@ export function treeFromSpec(spec, nextId) {
         if (node.direction === 'tabs') {
             const tabs = children.flatMap(child => {
                 const viewIds = viewIdsInSpec(child);
-                return child.viewIds === undefined && viewIds.length === 0
+                return child.views === undefined && viewIds.length === 0
                     ? []
                     : [{ id: nextId('tab'), viewIds }];
             });
@@ -98,7 +171,7 @@ export function treeFromSpec(spec, nextId) {
 /** Every viewId a spec names, depth-first — the order it states. */
 export function viewIdsInSpec(spec) {
     return [
-        ...(spec.viewIds ?? []),
+        ...(spec.views ?? []),
         ...(spec.children ?? []).flatMap(viewIdsInSpec),
     ];
 }
@@ -121,9 +194,9 @@ export function tileLayoutSpec(viewIds, mode) {
     // Nothing to arrange: one view is the whole workspace whatever the mode, and
     // no views leaves the empty panel the tree already guarantees.
     if (viewIds.length <= 1) {
-        return { viewIds: [...viewIds] };
+        return { views: [...viewIds] };
     }
-    const cell = (id) => ({ viewIds: [id] });
+    const cell = (id) => ({ views: [id] });
     if (mode !== 'grid') {
         return { direction: mode, children: viewIds.map(cell) };
     }
@@ -147,7 +220,7 @@ export function specForPendingMove(move, allViewIds) {
     return others.length > 0
         ? {
             direction: move.type === 'splitRight' ? 'horizontal' : 'tabs',
-            children: [{ viewIds: others }, { viewIds: [move.viewId] }],
+            children: [{ views: others }, { views: [move.viewId] }],
         }
-        : { viewIds: [move.viewId] };
+        : { views: [move.viewId] };
 }

package/esm/index.d.ts

@@ -13,4 +13,6 @@ export type { LayoutNode, LgvUrlInit, ParsedSessionSpec, ViewSpec, } from './Ses
 export type { SessionModelFactory } from './sessionModelFactory.ts';
 export { deleteQueryParams, readAllQueryParams, readQueryParams, setQueryParams, useQueryParam, } from './queryParams.ts';
 export { processMutableMenuActions, resolveMenus } from './menus.ts';
-export type { Menu, MenuAction, MenuDefinition } from './menus.ts';
+export type { Menu, MenuAction } from './menus.ts';
+export { createJbApi, ensureReExports, safeJson, sessionOf, undeliveredNotifications, waitReady, } from './JbApi/index.ts';
+export type { JbApi } from './JbApi/index.ts';

package/esm/index.js

@@ -11,3 +11,6 @@ export { addSessionTracks, buildLgvInit, buildLgvInitFromParams, hubConnectionSp
 // embedded product must not rewrite its host's URL — see queryParams.ts
 export { deleteQueryParams, readAllQueryParams, readQueryParams, setQueryParams, useQueryParam, } from './queryParams.js';
 export { processMutableMenuActions, resolveMenus } from './menus.js';
+// The helper library an agent drives the app through: desktop serves it to
+// run_javascript over MCP, web hands it to the page as window.jb
+export { createJbApi, ensureReExports, safeJson, sessionOf, undeliveredNotifications, waitReady, } from './JbApi/index.js';

package/esm/menus.d.ts

@@ -1,4 +1,4 @@
-import type { MenuItem, MenuItemsGetter } from '@jbrowse/core/ui';
+import type { MenuItem } from '@jbrowse/core/ui/menuItems';
 /**
  * Ensure a top-level menu exists. `position` appends when omitted and counts
  * from the end when negative. A menu whose label is already on the bar is left
@@ -22,47 +22,33 @@ interface AddItemAction {
     menuItem: MenuItem;
     position?: number;
 }
-interface SetMenusAction {
-    type: 'setMenus';
-    newMenus: MenuDefinition[];
-}
-/**
- * `addMenu`/`setMenus` change which menus exist, so they resolve eagerly — the
- * app bar renders one button per menu before anything is opened. `addItem` only
- * changes a menu's contents, so it resolves when that menu opens, against
- * whatever its items are at that moment.
- */
-export type MenuAction = AddMenuAction | AddItemAction | SetMenusAction;
 /**
- * A menu as a root model authors it. Items may be a plain array, or a thunk for
- * a menu whose contents depend on state that would otherwise be read — and so
- * tracked — every time the app bar renders.
+ * `addMenu` changes which menus exist, so it resolves eagerly — the app bar
+ * renders one button per menu before anything is opened. `addItem` only changes
+ * a menu's contents, so it resolves when that menu opens, against whatever its
+ * items are at that moment.
  */
-export interface MenuDefinition {
-    label: string;
-    menuItems: MenuItemsGetter;
-}
+export type MenuAction = AddMenuAction | AddItemAction;
 /**
- * A menu as the app bar consumes it. Always a thunk returning a fresh array: a
- * menu's items are produced when it opens and never before, so no consumer has
- * to care which form the root model authored, and a plugin's contributions are
- * merged in at that point rather than spliced into the definition.
+ * A top-level menu. `menuItems` is a thunk the app bar calls when the menu
+ * opens and never before, so a root model's reads stay out of the bar's
+ * tracking scope and a plugin's contributions are merged onto each fresh
+ * result rather than spliced into a definition.
  */
 export interface Menu {
     label: string;
     menuItems: () => MenuItem[];
 }
 /**
- * Resolve a root model's menu definitions against the contributions plugins
- * have pushed (via `RootAppMenuMixin`). Structural contributions apply now;
- * item contributions are recorded against their target menu and applied when
- * that menu opens, so a menu that computes its items lazily stays lazy and
- * nothing is ever spliced into a definition.
+ * Resolve a root model's menus against the contributions plugins have pushed
+ * (via `RootAppMenuMixin`). Structural contributions apply now; item
+ * contributions are grouped by path and merged when the menu they target
+ * opens.
  *
  * Runs on every `menus()` evaluation, so it must not mutate `base` or anything
  * an action carries.
  */
-export declare function processMutableMenuActions(base: MenuDefinition[], actions: MenuAction[]): Menu[];
+export declare function processMutableMenuActions(base: Menu[], actions: MenuAction[]): Menu[];
 /**
  * Flatten resolved menus to plain data by opening every one of them. For tests
  * and other callers that want to assert on menu contents rather than render

package/esm/menus.js

@@ -1,82 +1,77 @@
-// a contribution that threw is reported once rather than on every open — the
-// menu re-resolves on each open and, while open, on each observer re-render
+// a conflict is reported once rather than on every open — the menu re-resolves
+// on each open and, while open, on each observer re-render — and the action is
+// what outlives the nodes, which are rebuilt on every menus() evaluation
 const reported = new WeakSet();
-/**
- * The action log is permanent; the menu it builds is thrown away when the menu
- * closes. Everything a resolution walks therefore has to belong to the
- * throwaway, because resolving a path is a **write**:
- * `appendToSubMenu(['Add', 'My plugin'], two)` means "find the array labelled
- * My plugin and push into it".
- *
- * So when an earlier action is what supplied that array —
- * `appendToMenu('Add', { label: 'My plugin', subMenu: [one] })` — and it goes
- * into the menu by reference, the push lands in the stored action instead. The
- * next open replays a log that now reads `subMenu: [one, two]` and pushes
- * again, so the sub-menu gains an item on every open, and on every observer
- * re-render while open.
- *
- * Cloning is what keeps the two apart: the copy is what the path resolves to
- * and what gets written, and it dies with the open. Leaf items are shared by
- * reference — nothing writes into them — so this costs an allocation only for
- * the rows that nest.
- */
-function cloneMenuItem(item) {
-    return 'subMenu' in item
-        ? { ...item, subMenu: cloneMenuItems(item.subMenu) }
-        : item;
-}
-function cloneMenuItems(items) {
-    return items.map(item => cloneMenuItem(item));
-}
-function materialize(menuItems) {
-    return typeof menuItems === 'function' ? menuItems() : menuItems;
+function register(node, action, depth) {
+    const label = action.menuPath[depth];
+    if (label === undefined) {
+        node.entries.push(action);
+    }
+    else {
+        let entry = node.entries.find((e) => e.type === 'subMenu' && e.label === label);
+        if (!entry) {
+            entry = {
+                type: 'subMenu',
+                label,
+                path: action.menuPath.slice(0, depth + 1),
+                node: { entries: [] },
+                first: action,
+            };
+            node.entries.push(entry);
+        }
+        register(entry.node, action, depth + 1);
+    }
 }
 // splice is already the "counts from the end when negative" rule, and clamps
 // rather than wrapping past the start; the default is what makes it an append
 function insertAt(items, item, position = items.length) {
     items.splice(position, 0, item);
 }
+// the author's form is kept: an array sub-menu resolves now, a thunk sub-menu
+// resolves when its panel opens, with the contributions merged in either way
+function withContributions(item, node) {
+    const { subMenu } = item;
+    return {
+        ...item,
+        subMenu: typeof subMenu === 'function'
+            ? () => apply(subMenu(), node)
+            : apply(subMenu, node),
+    };
+}
 /**
- * Walk `menuPath` past its first segment (the top-level menu, already
- * resolved), creating empty sub-menus as needed, and return the deepest
- * sub-menu's item array. Throws if a path segment names an item that is not a
- * sub-menu.
+ * Return a copy of `items` with a node's contributions merged in. Nothing is
+ * written into `items`, into any sub-menu it holds, or into a contribution's
+ * own payload: a sub-menu that gains contributions is replaced by a copy whose
+ * `subMenu` resolves them, so the arrays behind a definition or an action are
+ * the same on every open.
+ *
+ * A path segment naming a row that is not a sub-menu is a plugin bug. It
+ * costs that subtree of contributions, reported once, and nothing else — this
+ * runs from the app bar's click handler, where a throw goes straight through
+ * React.
  */
-function resolveSubMenu(items, menuPath) {
-    let level = items;
-    for (const [idx, menuName] of menuPath.slice(1).entries()) {
-        let sub = level.find((mi) => 'subMenu' in mi && mi.label === menuName);
-        if (!sub) {
-            if (level.some(mi => 'label' in mi && mi.label === menuName)) {
-                const pathSoFar = menuPath.slice(0, idx + 2).join(' > ');
-                throw new Error(`"${menuName}" in path "${pathSoFar}" is not a subMenu`);
-            }
-            sub = { label: menuName, subMenu: [] };
-            level.push(sub);
+function apply(items, node) {
+    const result = [...items];
+    for (const entry of node.entries) {
+        if (entry.type === 'addItem') {
+            insertAt(result, entry.menuItem, entry.position);
         }
-        level = sub.subMenu;
-    }
-    return level;
-}
-// each contribution is applied independently: a plugin that names a bad path
-// loses its own item rather than every other plugin's, and never the session —
-// this runs from the app bar's click handler, where a throw goes straight
-// through React
-function applyItemActions(items, actions) {
-    for (const action of actions) {
-        try {
-            const target = resolveSubMenu(items, action.menuPath);
-            // cloned rather than inserted by reference — see cloneMenuItem
-            insertAt(target, cloneMenuItem(action.menuItem), action.position);
-        }
-        catch (error) {
-            if (!reported.has(action)) {
-                reported.add(action);
-                console.error(error);
+        else {
+            const idx = result.findIndex(mi => 'label' in mi && mi.label === entry.label);
+            const found = result[idx];
+            if (found === undefined) {
+                result.push({ label: entry.label, subMenu: apply([], entry.node) });
+            }
+            else if ('subMenu' in found) {
+                result[idx] = withContributions(found, entry.node);
+            }
+            else if (!reported.has(entry.first)) {
+                reported.add(entry.first);
+                console.error(new Error(`"${entry.label}" in path "${entry.path.join(' > ')}" is not a subMenu`));
             }
         }
     }
-    return items;
+    return result;
 }
 // first menu with this label, or a new empty one — an item action naming a menu
 // that doesn't exist creates it, so a plugin can populate its own menu without
@@ -86,47 +81,33 @@ function findOrCreateMenu(pending, label, position) {
     if (found) {
         return found;
     }
-    const menu = { label, base: [], itemActions: [] };
-    insertAt(pending, menu, position);
-    return menu;
-}
-function toMenu({ label, base, itemActions }) {
-    return {
+    const menu = {
         label,
-        menuItems: () => applyItemActions(cloneMenuItems(materialize(base)), itemActions),
+        menuItems: () => [],
+        node: { entries: [] },
     };
+    insertAt(pending, menu, position);
+    return menu;
 }
 /**
- * Resolve a root model's menu definitions against the contributions plugins
- * have pushed (via `RootAppMenuMixin`). Structural contributions apply now;
- * item contributions are recorded against their target menu and applied when
- * that menu opens, so a menu that computes its items lazily stays lazy and
- * nothing is ever spliced into a definition.
+ * Resolve a root model's menus against the contributions plugins have pushed
+ * (via `RootAppMenuMixin`). Structural contributions apply now; item
+ * contributions are grouped by path and merged when the menu they target
+ * opens.
  *
  * Runs on every `menus()` evaluation, so it must not mutate `base` or anything
  * an action carries.
  */
 export function processMutableMenuActions(base, actions) {
-    const toPending = (m) => ({
-        label: m.label,
-        base: m.menuItems,
-        itemActions: [],
-    });
-    let pending = base.map(toPending);
+    const pending = base.map(m => ({ ...m, node: { entries: [] } }));
     for (const action of actions) {
         switch (action.type) {
-            case 'setMenus': {
-                // replaces the menu bar wholesale, so item contributions made before it
-                // are dropped along with the menus they targeted
-                pending = action.newMenus.map(toPending);
-                break;
-            }
             case 'addMenu': {
                 findOrCreateMenu(pending, action.menuName, action.position);
                 break;
             }
             case 'addItem': {
-                findOrCreateMenu(pending, action.menuPath[0]).itemActions.push(action);
+                register(findOrCreateMenu(pending, action.menuPath[0]).node, action, 1);
                 break;
             }
             default: {
@@ -134,7 +115,10 @@ export function processMutableMenuActions(base, actions) {
             }
         }
     }
-    return pending.map(m => toMenu(m));
+    return pending.map(({ label, menuItems, node }) => ({
+        label,
+        menuItems: () => apply(menuItems(), node),
+    }));
 }
 /**
  * Flatten resolved menus to plain data by opening every one of them. For tests

package/esm/ui/App/AppReadyMarker.d.ts

@@ -1,6 +1,6 @@
 import type { AppSession } from './types.ts';
 /**
- * One element that says whether the whole app has finished.
+ * 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
@@ -14,6 +14,15 @@ import type { AppSession } from './types.ts';
  * 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

package/esm/ui/App/AppReadyMarker.js

@@ -1,28 +1,20 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { openTracks, openViews } from '@jbrowse/core/util/openViews';
 import { observer } from 'mobx-react';
-function containerLoading(container) {
-    return (container.tracks ?? []).some(track => (track.displays ?? []).some(d => d.displayPhase === 'loading'));
+function trackLoading(track) {
+    return track.displays.some(d => d.displayPhase === 'loading');
 }
-/**
- * Is anything in this session still working?
- *
- * The same two facts the per-element attributes publish — a view still
- * resolving its assembly, a display still in its own fetch — reduced to one
- * answer for the whole app. Duck-typed rather than imported: every view type
- * would otherwise have to be a dependency of the app shell.
- */
-function anythingLoading(views) {
-    return views.some(view => view.showLoading === true ||
-        view.initialized === false ||
-        containerLoading(view) ||
-        // A view whose tracks hang off something else — the synteny view's are on
-        // its levels, one list per band. `view.tracks` is empty there, so without
-        // this a stack of ribbons still fetching reads as idle.
-        (view.trackContainers ?? []).some(containerLoading) ||
-        anythingLoading(view.views ?? []));
+// 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.
+function viewLoading(view) {
+    const flags = view;
+    return (flags.error === undefined &&
+        (flags.showLoading === true || flags.initialized === false));
 }
 /**
- * One element that says whether the whole app has finished.
+ * 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
@@ -36,6 +28,15 @@ function anythingLoading(views) {
  * 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
@@ -51,6 +52,11 @@ function anythingLoading(views) {
  * and says why an error separates them). Both harnesses do it in that order.
  */
 const AppReadyMarker = observer(function AppReadyMarker({ session, }) {
-    return (_jsx("span", { hidden: true, "data-testid": "app-ready-marker", "data-app-phase": anythingLoading(session.views) ? 'loading' : 'ready' }));
+    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/App/ViewButtons.js

@@ -20,9 +20,9 @@ const useStyles = makeStyles()(theme => ({
 const ViewButtons = observer(function ViewButtons({ view, }) {
     const { classes } = useStyles();
     const session = getSession(view);
-    return (_jsxs(_Fragment, { children: [_jsx(IconButton, { "data-testid": "minimize_view", onClick: () => {
+    return (_jsxs(_Fragment, { children: [_jsx(IconButton, { "aria-label": view.minimized ? 'Restore view' : 'Minimize view', "data-testid": "minimize_view", onClick: () => {
                     view.setMinimized(!view.minimized);
-                }, children: view.minimized ? (_jsx(AddIcon, { className: classes.icon, fontSize: "small" })) : (_jsx(MinimizeIcon, { className: classes.icon, fontSize: "small" })) }), _jsx(IconButton, { "data-testid": "close_view", onClick: () => {
+                }, children: view.minimized ? (_jsx(AddIcon, { className: classes.icon, fontSize: "small" })) : (_jsx(MinimizeIcon, { className: classes.icon, fontSize: "small" })) }), _jsx(IconButton, { "aria-label": "Close view", "data-testid": "close_view", onClick: () => {
                     session.removeView(view);
                 }, children: _jsx(CloseIcon, { className: classes.icon, fontSize: "small" }) })] }));
 });

package/esm/ui/App/ViewLauncher.js

@@ -22,7 +22,7 @@ const ViewLauncher = observer(function ViewLauncher({ session, }) {
     return (_jsxs(Paper, { className: classes.selectPaper, children: [_jsx(Typography, { children: "Select a view to launch" }), _jsx(FormControl, { className: classes.m2, children: _jsx(Select, { value: value, onChange: event => {
                         setValue(event.target.value);
                     }, children: viewTypes.map(({ displayName, name }) => (_jsx(MenuItem, { value: name, children: displayName }, name))) }) }), _jsx(FormControl, { className: classes.m2, children: _jsx(Button, { onClick: () => {
-                        session.addView(value, {});
+                        void session.launchView(value, {});
                     }, variant: "contained", color: "primary", children: "Launch view" }) })] }));
 });
 export default ViewLauncher;