@jbrowse/core 5.0.0-beta.13 → 5.0.0-beta.14

package/esm/ui/rampKey.js

@@ -0,0 +1,17 @@
+import { cssColorToHex } from '../util/colorBits.js';
+import { rampLabels } from './colorScale.js';
+/**
+ * A ramp's bar as columns, for a host that draws the key itself, such as R
+ * through V8: each stop's `offset`, `#rrggbb` `color` and `opacity`, and the
+ * end labels the on-screen bar prints.
+ */
+export function rampKeyOf(scale) {
+    return {
+        id: scale.id,
+        title: scale.title ?? '',
+        ...rampLabels(scale),
+        offset: scale.stops.map(stop => stop.offset),
+        color: scale.stops.map(stop => cssColorToHex(stop.color)),
+        opacity: scale.stops.map(stop => stop.opacity ?? 1),
+    };
+}

package/esm/ui/showSubMenu.d.ts

@@ -6,11 +6,6 @@ import type { MenuItem } from './MenuTypes.ts';
  * multi-row painting with no legend) drops the row rather than opening an empty
  * submenu.
  *
- * One helper because this was eleven hand-written literals that had already
- * drifted three ways: the wiggle family said `'Show'` where everyone else said
- * `'Show...'`, only some set the redundant `type: 'subMenu'`, and only the
- * wiggle family omitted the empty submenu.
- *
  * Not exported from `ui/menuItems.ts`: the icon is a value import, and that
  * entry is the React-free one (see its header). Import this module directly —
  * `@jbrowse/core/ui/showSubMenu` — which costs one icon rather than the

package/esm/ui/showSubMenu.js

@@ -1,4 +1,5 @@
 import VisibilityIcon from '@mui/icons-material/Visibility';
+import { subMenuIfAny } from './MenuTypes.js';
 /**
  * The "Show..." submenu every display groups its visibility toggles under, and
  * the empty-omit that goes with it: a display whose toggles are all
@@ -6,25 +7,15 @@ import VisibilityIcon from '@mui/icons-material/Visibility';
  * multi-row painting with no legend) drops the row rather than opening an empty
  * submenu.
  *
- * One helper because this was eleven hand-written literals that had already
- * drifted three ways: the wiggle family said `'Show'` where everyone else said
- * `'Show...'`, only some set the redundant `type: 'subMenu'`, and only the
- * wiggle family omitted the empty submenu.
- *
  * Not exported from `ui/menuItems.ts`: the icon is a value import, and that
  * entry is the React-free one (see its header). Import this module directly —
  * `@jbrowse/core/ui/showSubMenu` — which costs one icon rather than the
  * `@jbrowse/core/ui` barrel's ~80 Material components.
  */
 export function makeShowSubMenu(items) {
-    return items.length
-        ? [
-            {
-                label: 'Show...',
-                icon: VisibilityIcon,
-                type: 'subMenu',
-                subMenu: items,
-            },
-        ]
-        : [];
+    return subMenuIfAny({
+        label: 'Show...',
+        icon: VisibilityIcon,
+        subMenu: items,
+    });
 }

package/esm/ui/theme.d.ts

@@ -14,9 +14,9 @@ type FramesOptions = FrameTuple<PaletteColorOptions>;
 declare module '@mui/material/styles' {
     interface Palette extends StringColors {
         /**
-         * The primary colour where it marks something on the page's own ground,
+         * The primary color where it marks something on the page's own ground,
          * such as a checked box or a selected row. `primary.main` in light mode,
-         * and the secondary text colour in dark mode, where a midnight primary
+         * and the secondary text color in dark mode, where a midnight primary
          * vanishes
          */
         accent: string;

package/esm/ui/theme.js

@@ -67,7 +67,7 @@ const baseThemeOptions = {
     components: {
         MuiAppBar: {
             // JBrowse's header keeps its brand in dark mode; MUI's default is to
-            // flatten it to the paper colour. A property of the app rather than of
+            // flatten it to the paper color. A property of the app rather than of
             // one palette — it used to sit on `darkStock` alone, so the theme a
             // reader reaches by picking Dark over the default palette lost the
             // header the old dark theme had. MUI reads this only in dark mode.

package/esm/ui/useAssemblySelection.d.ts

@@ -74,6 +74,7 @@ export declare function useAssemblySelection(session: AbstractSessionModel, loca
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -141,6 +142,7 @@ export declare function useAssemblySelection(session: AbstractSessionModel, loca
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {

package/esm/ui/useMouseTracking.d.ts

@@ -20,28 +20,16 @@ export declare function useClearTrackedPointer(): () => void;
  * Container-relative mouse position for the overlays that follow the pointer
  * (`Crosshairs`, tooltips), coalesced to one update per frame.
  *
- * The position is measured against the box of whatever element the handlers are
- * bound to, which is what the overlays are positioned in — off `currentTarget`,
- * so there is no ref to pass and no way to bind the two to different elements.
+ * The position is measured against the box of the element the handlers are
+ * bound to, off `currentTarget`, which is what the overlays are positioned in.
  * A display that also hit-tests takes `onMove`, so its hit and its guides come
- * off one measurement in one frame instead of two pointer paths that have to
- * agree.
+ * off one measurement in one frame.
  *
- * **It returns a `mouseTracker` rather than the position, and that is the
- * load-bearing part.** Its one caller is `DisplayChromeBase`, which owns the
- * container the handlers bind to — so if the position were state here, every
- * mouse move would re-render the chrome itself (re-running
- * `useRenderingBackend`), the status container with a fresh inline `style`
- * object, all three overlays, and only then the body that actually wanted the
- * coordinate. That is a whole display's chrome repainting because the cursor
- * moved a pixel over it; it cost a full document `Layout` plus three `Paint`s
- * per mousemove on the wiggle displays, back when each display called this hook
- * itself and every one of them had it.
- *
- * So the position is published instead, and whoever wants it calls
- * `useMouseState(mouseTracker)` — from inside the chrome's body, where the
- * overlays live. Re-rendering then starts at the component that reads it.
- * Passing the tracker down a prop is free; passing `mouseState` down is the bug.
+ * It returns a `mouseTracker` and not the position: the caller is
+ * `DisplayChromeBase`, and position held as state there would re-render the
+ * whole chrome on every mouse move. Whoever draws at the cursor calls
+ * `useMouseState(mouseTracker)`, so re-rendering starts at that component.
+ * Pass the tracker down, never the position.
  */
 export declare function useMouseTracking(onMove?: (state?: MouseState) => void): {
     mouseTracker: MouseTracker;

package/esm/ui/useMouseTracking.js

@@ -27,16 +27,11 @@ function createMouseStore() {
 /**
  * Drop the tracked pointer, published by whoever bound the handlers.
  *
- * `mouseleave` reports the pointer leaving an element, and the browser decides
- * that by comparing the hover chain before a move to the chain after it. A menu
- * portalled to the body opens under the cursor with no move at all, and closing
- * it detaches the chain's nodes — so hover restarts at `body` and the display
- * the menu covered is never told anything again. Its overlays then keep drawing
- * at the coordinate the pointer had when the menu opened, wherever the pointer
- * has since gone.
- *
- * `ContextMenu` calls this on close, which is why the default is a no-op: a menu
- * raised outside a display's chrome has no tracked pointer to drop.
+ * A menu portalled to the body opens under the cursor with no move, and
+ * closing it detaches the hover chain, so the display it covered never gets a
+ * `mouseleave` and its overlays keep drawing where the menu opened.
+ * `ContextMenu` calls this on close; the default is a no-op for a menu raised
+ * outside a display's chrome.
  */
 const ClearTrackedPointerContext = createContext(() => { });
 export const ClearTrackedPointerProvider = ClearTrackedPointerContext.Provider;
@@ -47,44 +42,25 @@ export function useClearTrackedPointer() {
  * Container-relative mouse position for the overlays that follow the pointer
  * (`Crosshairs`, tooltips), coalesced to one update per frame.
  *
- * The position is measured against the box of whatever element the handlers are
- * bound to, which is what the overlays are positioned in — off `currentTarget`,
- * so there is no ref to pass and no way to bind the two to different elements.
+ * The position is measured against the box of the element the handlers are
+ * bound to, off `currentTarget`, which is what the overlays are positioned in.
  * A display that also hit-tests takes `onMove`, so its hit and its guides come
- * off one measurement in one frame instead of two pointer paths that have to
- * agree.
- *
- * **It returns a `mouseTracker` rather than the position, and that is the
- * load-bearing part.** Its one caller is `DisplayChromeBase`, which owns the
- * container the handlers bind to — so if the position were state here, every
- * mouse move would re-render the chrome itself (re-running
- * `useRenderingBackend`), the status container with a fresh inline `style`
- * object, all three overlays, and only then the body that actually wanted the
- * coordinate. That is a whole display's chrome repainting because the cursor
- * moved a pixel over it; it cost a full document `Layout` plus three `Paint`s
- * per mousemove on the wiggle displays, back when each display called this hook
- * itself and every one of them had it.
+ * off one measurement in one frame.
  *
- * So the position is published instead, and whoever wants it calls
- * `useMouseState(mouseTracker)` — from inside the chrome's body, where the
- * overlays live. Re-rendering then starts at the component that reads it.
- * Passing the tracker down a prop is free; passing `mouseState` down is the bug.
+ * It returns a `mouseTracker` and not the position: the caller is
+ * `DisplayChromeBase`, and position held as state there would re-render the
+ * whole chrome on every mouse move. Whoever draws at the cursor calls
+ * `useMouseState(mouseTracker)`, so re-rendering starts at that component.
+ * Pass the tracker down, never the position.
  */
 export function useMouseTracking(onMove) {
     const rafRef = useRef(undefined);
     const storeRef = useRef(undefined);
     storeRef.current ??= createMouseStore();
     const store = storeRef.current;
-    // Reached through a ref rather than captured, so `handleMouseLeave` below can
-    // be identity-stable — one of its callers is an effect, and a handler that
-    // changed identity every render would make that effect re-run every render.
-    // Reading the latest is also the better answer for the frame callback, which
-    // runs after the render whose closure scheduled it.
-    //
-    // Written in an effect rather than during render: a render React discards must
-    // not leave this pointing at a callback from it. Nothing can read it before
-    // the first commit — both users are event/effect callbacks — and `useRef`'s
-    // initial value covers the first commit itself.
+    // Reached through a ref so `handleMouseLeave` is identity-stable (an effect
+    // depends on it), and written in an effect so a render React discards cannot
+    // leave it pointing at that render's callback.
     const onMoveRef = useRef(onMove);
     useEffect(() => {
         onMoveRef.current = onMove;
@@ -92,11 +68,10 @@ export function useMouseTracking(onMove) {
     /**
      * Drop the published position and tell `onMove` the pointer is gone.
      *
-     * Bound as the container's `onMouseLeave` — and called directly for the two
-     * cases `mouseleave` cannot report: the container being *removed* rather than
-     * left, and a portalled menu closing over it. `DisplayChromeBase` makes both
-     * calls, the second by publishing this on `ClearTrackedPointerProvider`.
-     * Identity-stable for both.
+     * Bound as the container's `onMouseLeave`, and called directly for the three
+     * cases `mouseleave` cannot report: the container being removed, a portalled
+     * menu closing over it, and the pointer moving onto a portalled overlay.
+     * `DisplayChromeBase` makes all three calls. Identity-stable.
      */
     const handleMouseLeave = useCallback(() => {
         if (rafRef.current) {
@@ -107,28 +82,14 @@ export function useMouseTracking(onMove) {
         onMoveRef.current?.(undefined);
     }, [store]);
     const handleMouseMove = (event) => {
-        // An overlay portaled out of the container still *bubbles* its React events
-        // here, even though its DOM node is not a descendant — so the coordinate
-        // would be measured against a box the pointer isn't in. HiC guarded this by
-        // hand (its resolution dropdown and legend portal); it is a hazard for any
-        // display with a portaled overlay, and several have one, so the guard lives
-        // here and applies to all of them. Treated as a leave: the pointer is over
-        // something else, and the guides should drop rather than freeze.
-        const { target } = event;
-        if (target instanceof Node && !event.currentTarget.contains(target)) {
-            handleMouseLeave();
-            return;
-        }
         if (rafRef.current) {
             cancelAnimationFrame(rafRef.current);
         }
         const clientX = event.clientX;
         const clientY = event.clientY;
-        // Captured here rather than read in the frame: React clears `currentTarget`
-        // once the handler returns. `isConnected` then stands in for the ref check
-        // this used to do — a display unmounted between the move and the frame
-        // measures as a zero rect, and would publish the client point as if the
-        // pointer were at the origin of a box that is gone.
+        // Captured here: React clears `currentTarget` once the handler returns. A
+        // display unmounted before the frame measures as a zero rect, hence the
+        // `isConnected` check.
         const container = event.currentTarget;
         rafRef.current = requestAnimationFrame(() => {
             if (container.isConnected) {

package/esm/ui/usePlacedMenuFocus.d.ts

@@ -0,0 +1,19 @@
+import type { PopoverActions } from '@mui/material';
+/**
+ * Props that move a MUI Menu's opening focus to after the menu is placed.
+ *
+ * MUI focuses the first row while the menu mounts, before Popover writes the
+ * paper's position, so the focused row still sits at the viewport's top-left.
+ * Firefox scrolls every enclosing frame to reveal a focused element, so a page
+ * that embeds JBrowse in an iframe jumped to the frame's top whenever a menu
+ * opened with that top scrolled out of view.
+ *
+ * The `onEntering` returned here places the paper through Popover's
+ * `updatePosition`, then focuses the first row without scrolling anything.
+ */
+export declare function usePlacedMenuFocus(): {
+    action: import("react").RefObject<PopoverActions | null>;
+    autoFocus: boolean;
+    disableAutoFocus: boolean;
+    onEntering: (paper: HTMLElement) => void;
+};

package/esm/ui/usePlacedMenuFocus.js

@@ -0,0 +1,28 @@
+import { useRef } from 'react';
+const FIRST_ROW = '[role^="menuitem"]:not(.Mui-disabled)';
+/**
+ * Props that move a MUI Menu's opening focus to after the menu is placed.
+ *
+ * MUI focuses the first row while the menu mounts, before Popover writes the
+ * paper's position, so the focused row still sits at the viewport's top-left.
+ * Firefox scrolls every enclosing frame to reveal a focused element, so a page
+ * that embeds JBrowse in an iframe jumped to the frame's top whenever a menu
+ * opened with that top scrolled out of view.
+ *
+ * The `onEntering` returned here places the paper through Popover's
+ * `updatePosition`, then focuses the first row without scrolling anything.
+ */
+export function usePlacedMenuFocus() {
+    const action = useRef(null);
+    return {
+        action,
+        autoFocus: false,
+        disableAutoFocus: true,
+        onEntering: (paper) => {
+            action.current?.updatePosition();
+            paper
+                .querySelector(FIRST_ROW)
+                ?.focus({ preventScroll: true });
+        },
+    };
+}

package/esm/util/Base1DViewModel.d.ts

@@ -4,9 +4,11 @@ import type { Instance } from '@jbrowse/mobx-state-tree';
 /**
  * #stateModel Base1DView
  * #category general
- * used in non-lgv view representations of a 1d view e.g. the two axes of the
- * dotplot use this. categorized General rather than View because it is not a
- * pluggable view type, which the name-suffix heuristic would otherwise assume
+ * Holds a one-dimensional axis of displayed regions, with its zoom and scroll
+ * offset, for views other than the linear genome view, such as the two axes of
+ * the dotplot.
+ *
+ * Its page sits under General because it is not a pluggable view type.
  */
 declare const Base1DView: import("@jbrowse/mobx-state-tree").IModelType<{
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;

package/esm/util/Base1DViewModel.js

@@ -7,9 +7,11 @@ import { ElementId } from './types/mst.js';
 /**
  * #stateModel Base1DView
  * #category general
- * used in non-lgv view representations of a 1d view e.g. the two axes of the
- * dotplot use this. categorized General rather than View because it is not a
- * pluggable view type, which the name-suffix heuristic would otherwise assume
+ * Holds a one-dimensional axis of displayed regions, with its zoom and scroll
+ * offset, for views other than the linear genome view, such as the two axes of
+ * the dotplot.
+ *
+ * Its page sits under General because it is not a pluggable view type.
  */
 const Base1DView = types
     .model('Base1DView', {

package/esm/util/SvgCanvas.js

@@ -175,7 +175,7 @@ export class SvgCanvas {
     // treats as the same rect anchored at `x-w`) is NOT normalized here — SVG
     // would emit `width="-w"` and silently not render. Callers must pass a
     // non-negative size; spans resolve both edges and take
-    // `left = min(x1,x2)` / `w = abs(x2-x1)` (see render-core/CLAUDE.md), the
+    // `left = min(x1,x2)` / `w = abs(x2-x1)`, the
     // same convention that keeps reversed blocks correct.
     transformRect(x, y, w, h) {
         const [tx, ty] = this.transformPoint(this.a < 0 ? x + w : x, this.d < 0 ? y + h : y);

package/esm/util/aggregateFieldName.d.ts

@@ -1,10 +1 @@
-/**
- * The field an aggregate op writes: `as` where named, else `count` for a
- * count, else `<op>_<field>`. Imports nothing, so the validator's copy of the
- * mark rule list carries it unchanged.
- */
-export declare function aggregateFieldName({ op, field, as, }: {
-    op: string;
-    field?: string;
-    as?: string;
-}): string;
+export { aggregateFieldName } from './stepOutputs.ts';

package/esm/util/aggregateFieldName.js

@@ -1,8 +1 @@
-/**
- * The field an aggregate op writes: `as` where named, else `count` for a
- * count, else `<op>_<field>`. Imports nothing, so the validator's copy of the
- * mark rule list carries it unchanged.
- */
-export function aggregateFieldName({ op, field, as, }) {
-    return as || (op === 'count' || !field ? op : `${op}_${field}`);
-}
+export { aggregateFieldName } from './stepOutputs.js';

package/esm/util/analytics.d.ts

@@ -1,4 +1,5 @@
 import type { AnyConfigurationModel, TrackConfigEntry } from '../configuration/index.ts';
+import type { ActivitySession } from './sessionActivity.ts';
 declare global {
     interface Window {
         ga?: (...args: unknown[]) => void;
@@ -12,14 +13,10 @@ interface AnalyticsRootModel {
             name?: string;
         }[];
     };
-    session?: {
-        sessionTracks: {
-            type: string;
-        }[];
-        views: unknown[];
-    };
+    session?: ActivitySession;
     version: string;
 }
+export declare function urlParamNames(search: string): string;
 type AnalyticsRootModelWithConfig = AnalyticsRootModel & {
     jbrowse: {
         configuration: AnyConfigurationModel;
@@ -27,5 +24,6 @@ type AnalyticsRootModelWithConfig = AnalyticsRootModel & {
 };
 export declare function writeAWSAnalytics(rootModel: AnalyticsRootModel, initialTimestamp: number, sessionQuery?: string | null): Promise<void>;
 export declare function writeGAAnalytics(rootModel: AnalyticsRootModel, initialTimestamp: number): Promise<void>;
+export declare function writeAWSSessionEnd(): Promise<void>;
 export declare function doAnalytics(rootModel: AnalyticsRootModelWithConfig | undefined, initialTimestamp: number, initialSessionQuery: string | null | undefined): void;
 export {};

package/esm/util/analytics.js

@@ -1,14 +1,58 @@
 import { effectiveRenderer, getGraphicsCapabilities, } from '@jbrowse/render-core/graphicsCapabilities';
 import { readConfObject } from '../configuration/index.js';
 import { isElectron, rIC } from '../util/index.js';
+import { createSessionActivity, describeSession, tallyTypes, } from './sessionActivity.js';
 import { getConfAssemblyNamesOrNone } from './tracks.js';
+const analyticsUrl = 'https://analytics.jbrowse.org/api/v1';
+// Ties a page load's end reports to its start report. It lives in memory only,
+// so a reload gets a new one and nothing follows a user from load to load.
+let pageLoadId;
+function getPageLoadId() {
+    pageLoadId ??=
+        typeof crypto.randomUUID === 'function'
+            ? crypto.randomUUID()
+            : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    return pageLoadId;
+}
+// Names only, and only JBrowse's own: says whether a load was a link to a
+// location or a set of tracks without saying which. Read when this module
+// loads, because jbrowse-web folds `loc`, `tracks` and `assembly` into a
+// `session` parameter before the report goes out.
+const knownUrlParams = [
+    'assembly',
+    'config',
+    'highlight',
+    'loc',
+    'nav',
+    'session',
+    'sessionName',
+    'sessionTracks',
+    'tracklist',
+    'tracks',
+];
+export function urlParamNames(search) {
+    const params = new URLSearchParams(search);
+    return knownUrlParams.filter(name => params.has(name)).join(',');
+}
+const initialUrlParams = typeof window === 'undefined' ? '' : urlParamNames(window.location.search);
+function sessionTrackTypeCounts(session) {
+    const counts = {};
+    for (const track of session?.sessionTracks ?? []) {
+        const key = `sessionTrack-types-${track.type}`;
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+}
+async function send(stats, init) {
+    const qs = new URLSearchParams(Object.entries(stats).map(([key, value]) => [key, String(value)])).toString();
+    await fetch(`${analyticsUrl}?${qs}`, init);
+}
 // Both writers are fire-and-forget from several call sites, so they swallow
 // their own failures rather than rejecting: a floating rejected promise trips
 // the webpack-dev-server overlay (it listens for unhandledrejection), and an
 // analytics ping is never worth interrupting a session for.
 export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuery) {
     try {
-        const url = 'https://analytics.jbrowse.org/api/v1';
         const multiAssemblyTracks = rootModel.jbrowse.tracks.filter(track => getConfAssemblyNamesOrNone(track).length > 1).length;
         // The rung createGpuHal built where a display has built one by idle time,
         // else the ladder's prediction with any page-wide pin applied — so a
@@ -25,8 +69,11 @@ export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuer
         const softwareRendering = capabilities.softwareWebgl ?? 'unknown';
         const { jbrowse: config, session, version: ver } = rootModel;
         const { tracks, assemblies, plugins } = config;
+        const shape = describeSession(session);
         // stats to be recorded in db
         const stats = {
+            event: 'start',
+            sid: getPageLoadId(),
             ver,
             'plugins-count': plugins?.length ?? 0,
             'plugin-names': plugins?.map(p => p.name).join(','),
@@ -34,6 +81,9 @@ export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuer
             'tracks-count': tracks.length,
             'session-tracks-count': session?.sessionTracks.length ?? 0,
             'open-views': session?.views.length ?? 0,
+            'view-types': tallyTypes(shape.viewTypes),
+            'open-track-types': tallyTypes(shape.trackTypes),
+            'url-params': initialUrlParams,
             'synteny-tracks-count': multiAssemblyTracks,
             // No `saved-sessions-count`: it counted localStorage keys matching
             // `localSaved-`, a format nothing has written since autosaved sessions
@@ -62,14 +112,8 @@ export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuer
             const key = `track-types-${track.type}`;
             trackTypeCounts[key] = (trackTypeCounts[key] ?? 0) + 1;
         }
-        const sessionTrackTypeCounts = {};
-        for (const track of session?.sessionTracks ?? []) {
-            const key = `sessionTrack-types-${track.type}`;
-            sessionTrackTypeCounts[key] = (sessionTrackTypeCounts[key] ?? 0) + 1;
-        }
-        Object.assign(stats, trackTypeCounts, sessionTrackTypeCounts);
-        const qs = new URLSearchParams(Object.entries(stats).map(([key, value]) => [key, String(value)])).toString();
-        await fetch(`${url}?${qs}`);
+        Object.assign(stats, trackTypeCounts, sessionTrackTypeCounts(session));
+        await send(stats);
     }
     catch (e) {
         console.warn('Failed to write analytics to AWS.', e);
@@ -109,6 +153,83 @@ export async function writeGAAnalytics(rootModel, initialTimestamp) {
         console.warn('Failed to write analytics to GA.', e);
     }
 }
+// What the page load's sessions held while in use, for the end report.
+const activity = createSessionActivity();
+let latestRootModel;
+let endReportsInstalled = false;
+let endReportsSent = 0;
+let lastEndSignature;
+let visibleMs = 0;
+let visibleSince;
+let visibleMsAtLastEnd = 0;
+const maxEndReports = 10;
+const resendAfterVisibleMs = 60_000;
+// The end report says what a session came to hold: the view, track and widget
+// types open when the tab was hidden and those opened at any point before.
+// A tab is hidden many times before it closes and the close itself is not
+// reliably observable, so each hide sends one, numbered by `seq`, when the
+// session changed or another minute was spent on the page. The last one for a
+// `sid` is the session's end.
+export async function writeAWSSessionEnd() {
+    try {
+        if (!activity.watching || endReportsSent >= maxEndReports) {
+            return;
+        }
+        const seen = activity.stats();
+        const signature = JSON.stringify(seen);
+        if (signature === lastEndSignature &&
+            visibleMs - visibleMsAtLastEnd < resendAfterVisibleMs) {
+            return;
+        }
+        lastEndSignature = signature;
+        visibleMsAtLastEnd = visibleMs;
+        endReportsSent += 1;
+        const stats = {
+            event: 'end',
+            sid: getPageLoadId(),
+            seq: endReportsSent,
+            duration: Math.round(performance.now() / 1000),
+            'visible-time': Math.round(visibleMs / 1000),
+            ...seen,
+            electron: isElectron,
+            jb2: true,
+        };
+        try {
+            const { session, version } = latestRootModel ?? {};
+            stats.ver = version;
+            stats['session-tracks-count'] = session?.sessionTracks.length ?? 0;
+            Object.assign(stats, sessionTrackTypeCounts(session));
+        }
+        catch {
+            // root model left its state tree; the accumulated types still go out
+        }
+        // keepalive lets the request outlive the page it was sent from
+        await send(stats, { keepalive: true });
+    }
+    catch (e) {
+        console.warn('Failed to write analytics to AWS.', e);
+    }
+}
+function installEndReports() {
+    if (!endReportsInstalled) {
+        endReportsInstalled = true;
+        if (document.visibilityState === 'visible') {
+            visibleSince = performance.now();
+        }
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                if (visibleSince !== undefined) {
+                    visibleMs += performance.now() - visibleSince;
+                    visibleSince = undefined;
+                }
+                void writeAWSSessionEnd();
+            }
+            else {
+                visibleSince = performance.now();
+            }
+        });
+    }
+}
 // One pageview per page load, not per pluginManager. jbrowse-web rebuilds the
 // whole pluginManager (and rootModel) whenever plugins change, and StrictMode
 // builds it twice on mount — without this guard each rebuild re-pings AWS and
@@ -116,9 +237,19 @@ export async function writeGAAnalytics(rootModel, initialTimestamp) {
 // growing the document on every plugin install.
 let analyticsSent = false;
 export function doAnalytics(rootModel, initialTimestamp, initialSessionQuery) {
-    if (rootModel &&
-        !analyticsSent &&
-        !readConfObject(rootModel.jbrowse.configuration, 'disableAnalytics')) {
+    if (!rootModel) {
+        return;
+    }
+    // a config that opts out stops the end reports too, whichever config or
+    // session started them
+    if (readConfObject(rootModel.jbrowse.configuration, 'disableAnalytics')) {
+        activity.stop();
+        return;
+    }
+    latestRootModel = rootModel;
+    activity.watch(() => rootModel.session);
+    installEndReports();
+    if (!analyticsSent) {
         analyticsSent = true;
         // writeGAAnalytics injects Google's scripts and writeAWSAnalytics probes
         // graphics capabilities, hundreds of ms of main-thread work together. Idle