@jbrowse/core 5.0.0-beta.2 → 5.0.0-beta.3

package/esm/util/renderToStaticMarkup.js

@@ -7,6 +7,16 @@ import { createRoot } from 'react-dom/client';
 // reason to pull react/react-dom/@emotion, and the barrel is imported by
 // worker-side adapter code that never renders.
 //
+// It is not part of the plugin ABI either, and that removal did break two
+// published bundles before anyone noticed: react-msaview's SVG export read it
+// off `@jbrowse/core/util`, and jbrowse-plugin-msaview and -tview bundle
+// react-msaview. Resolved on their side -- react-msaview owns its own copy now
+// (packages/lib/src/renderToStaticMarkup.ts there) -- because a rendering
+// library asking its host for a renderer was the coupling worth removing, and
+// because react-dom is a host external for a plugin anyway, so it costs them a
+// few hundred bytes rather than a duplicate react. sharedModules.purity.test.ts
+// is what keeps this file off the worker's graph now.
+//
 // https://react.dev/reference/react-dom/server/renderToString#removing-rendertostring-from-the-client-code
 export function renderToStaticMarkup(node) {
     const div = document.createElement('div');

package/esm/util/scheduleDetachedDestroy.d.ts

@@ -0,0 +1,18 @@
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * Free a tree an action has already let go of — a superseded session, a view
+ * taken out of one, a superseded rootModel the React host has detached.
+ *
+ * A task rather than a microtask: the wait is for React to unmount the
+ * components rendering it, which happens on the re-render that the action's own
+ * reactions schedule. Deferring is acceptable here, and is not elsewhere,
+ * because the node stays alive and detached until it fires — a late read gets a
+ * live tree nobody is rendering. ADR-069.
+ *
+ * The destroy itself is not optional. `beforeDestroy` is a plugin-facing
+ * contract (jbrowse-plugin-apollo aborts its in-flight fetches there) and core's
+ * `BaseTrackModel` releases the `rpcSessionId` claim that lets
+ * `CoreFreeResources` evict a parsed adapter from the worker — so detaching and
+ * forgetting would trade a console warning for an unbounded leak.
+ */
+export declare function scheduleDetachedDestroy(node: IAnyStateTreeNode): void;

package/esm/util/scheduleDetachedDestroy.js

@@ -0,0 +1,24 @@
+import { destroy, isAlive } from '@jbrowse/mobx-state-tree';
+/**
+ * Free a tree an action has already let go of — a superseded session, a view
+ * taken out of one, a superseded rootModel the React host has detached.
+ *
+ * A task rather than a microtask: the wait is for React to unmount the
+ * components rendering it, which happens on the re-render that the action's own
+ * reactions schedule. Deferring is acceptable here, and is not elsewhere,
+ * because the node stays alive and detached until it fires — a late read gets a
+ * live tree nobody is rendering. ADR-069.
+ *
+ * The destroy itself is not optional. `beforeDestroy` is a plugin-facing
+ * contract (jbrowse-plugin-apollo aborts its in-flight fetches there) and core's
+ * `BaseTrackModel` releases the `rpcSessionId` claim that lets
+ * `CoreFreeResources` evict a parsed adapter from the worker — so detaching and
+ * forgetting would trade a console warning for an unbounded leak.
+ */
+export function scheduleDetachedDestroy(node) {
+    setTimeout(() => {
+        if (isAlive(node)) {
+            destroy(node);
+        }
+    }, 0);
+}

package/esm/util/scrollLatch.d.ts

@@ -1,4 +1,5 @@
 export declare function createScrollLatch(timeoutMs?: number): {
     scroll(e: WheelEvent, cur: number, delta: number, max: number, min?: number): number | null;
+    holds(e: WheelEvent): boolean;
     reset(): void;
 };

package/esm/util/scrollLatch.js

@@ -47,6 +47,14 @@ export function createScrollLatch(timeoutMs = LATCH_TIMEOUT_MS) {
             }
             return null;
         },
+        // Whether this panel already owns the gesture `e` belongs to, i.e. it has
+        // scrolled during a run of events this one continues. Callers ask before
+        // declining an event on their own rules: a gesture that has latched keeps
+        // every event it fires, cross-axis momentum included, which is the whole
+        // point of latching.
+        holds(e) {
+            return latched && e.timeStamp - lastEvent < timeoutMs;
+        },
         // Forget the gesture state so the next event is treated as a fresh gesture.
         // Called when the pointer leaves the panel: a gesture the browser has
         // latched to this element must not keep the page suppressed once the cursor

package/esm/util/stopToken.d.ts

@@ -31,11 +31,12 @@ import type { TimeGate } from './timeGate.ts';
  * either way over a 2000x BAM cancel burst) and that measurement was sound but
  * scoped: every loop on the alignments path is already chunked by awaits at
  * region granularity, so there was nothing there for an intra-loop probe to
- * interrupt. The counter-example is `getLDMatrix.ts`'s O(n²) Float32Array fill —
- * millions of pair computations with no await anywhere, where this probe is the
- * only thing that can stop the work, and which that bench never exercises. Any
- * future attempt to delete this needs a cancel measurement on an
- * await-free workload (LD or multi-sample-variant), not on a pileup.
+ * interrupt. The counter-example is the multi-sample-variant genotype matrix
+ * fill (`VariantRPC/getGenotypeMatrix.ts`) — millions of cells with no await
+ * anywhere, where this probe is the only thing that can stop the work, and
+ * which that bench never exercises. Any future attempt to delete this needs a
+ * cancel measurement on an await-free workload, not on a pileup. LD's O(n²)
+ * pair fill was the original example and went with the in-browser estimator.
  *
  * ## Which path runs where
  *

package/esm/util/trackConfigDelta.d.ts

@@ -23,9 +23,9 @@
  * empty delta, and `SessionTracks.updateTrackConfiguration` used to read that as
  * "the edit netted back to the base" and revert the track's working copy — which
  * undid a removal on screen 400ms after it landed. Promotable slots made that
- * reachable rather than rare: the promoted-default snackbar's "Override N
- * customized tracks" exists to unset a slot, and an admin config is free to set
- * one. That branch now keeps the working copy; see the comment there.
+ * reachable rather than rare: a slider row's reset unsets its slot, and an
+ * admin config is free to set one. That branch now keeps the working copy; see
+ * the comment there.
  *
  * `displays` is merged by `displayId` so an edit to one display doesn't pin the
  * others. Nested config objects (e.g. `adapter`) recurse. Any other array (value
@@ -59,9 +59,9 @@ export declare function mergeTrackConfig(base: Record<string, unknown>, delta: R
 export interface TrackConfigChange {
     /**
      * Where the setting lives, and — for a row a UI can revert — its **address**:
-     * `resetPreferenceChange` parses a promoted display-type default's path back
-     * into the type and slot it clears. So a producer that wants a friendlier
-     * heading sets `label` and leaves this alone.
+     * product-core's `resetDisplayDefault` parses a promoted display-type
+     * default's path back into the type and slot it clears. So a producer that
+     * wants a friendlier heading sets `label` and leaves this alone.
      */
     path: string[];
     from: Json;

package/esm/util/trackConfigDelta.js

@@ -23,9 +23,9 @@
  * empty delta, and `SessionTracks.updateTrackConfiguration` used to read that as
  * "the edit netted back to the base" and revert the track's working copy — which
  * undid a removal on screen 400ms after it landed. Promotable slots made that
- * reachable rather than rare: the promoted-default snackbar's "Override N
- * customized tracks" exists to unset a slot, and an admin config is free to set
- * one. That branch now keeps the working copy; see the comment there.
+ * reachable rather than rare: a slider row's reset unsets its slot, and an
+ * admin config is free to set one. That branch now keeps the working copy; see
+ * the comment there.
  *
  * `displays` is merged by `displayId` so an edit to one display doesn't pin the
  * others. Nested config objects (e.g. `adapter`) recurse. Any other array (value

package/esm/util/types/index.d.ts

@@ -376,22 +376,30 @@ export interface SessionWithSessionPlugins extends AbstractSessionModel {
     removeSessionPlugin: (plugin: PluginDefinition) => void;
 }
 export declare function isSessionWithSessionPlugins(thing: unknown): thing is SessionWithSessionPlugins;
+export interface PermanentPluginsSafeMode {
+    reason: 'requested' | 'previousLaunchFailed';
+    /** what was loading when the launch that failed did not finish */
+    suspects: string[];
+}
 /**
  * A session whose product keeps a plugin list of its own, outside both the
  * config and the session — jbrowse-web's permanent plugins, stored in the
  * browser against the config being viewed, so an install survives a new session
  * and the next visit.
  *
- * The list is not MST state, so `permanentPlugins` re-reads storage on each
- * call and nothing observes it. That is enough for its two readers, both of
- * which run in response to a click: adding or removing one asks for the whole-
- * app reload every plugin change needs anyway.
+ * The plugin store is the whole surface: the pin beside an installed plugin
+ * writes the list, and an entry the load skipped is a row there with a switch
+ * on it, which is what makes the safe mode below something a user can act on.
  */
 export interface SessionWithPermanentPlugins extends AbstractSessionModel {
-    permanentPlugins: PluginDefinition[];
-    permanentPluginsSkipped: boolean;
+    permanentPlugins: (PluginDefinition & {
+        disabled?: boolean;
+    })[];
+    permanentPluginsSafeMode: PermanentPluginsSafeMode | undefined;
     addPermanentPlugin: (plugin: PluginDefinition) => void;
     removePermanentPlugin: (plugin: PluginDefinition) => void;
+    setPermanentPluginDisabled: (plugin: PluginDefinition, disabled: boolean) => void;
+    reloadWithPermanentPlugins: () => void;
 }
 export declare function isSessionWithPermanentPlugins(thing: unknown): thing is SessionWithPermanentPlugins;
 /** abstract interface for a session that manages a global selection */
@@ -480,22 +488,19 @@ export interface AbstractViewModel {
      */
     trackContainers?: TrackContainer[];
     /**
-     * every track open on this view itself — its own `tracks` and any containers
-     * it owns instead; tracks on nested views are excluded. Derived by
-     * `BaseViewModel`, so a view composing the base answers correctly without
-     * implementing anything. Required, like `bodyMounted`: a stand-in that
-     * forgets it would silently under-report instead of failing the build.
+     * what this view contributes to the census of what is open: the tracks it
+     * holds itself, and the views nested directly inside it. `BaseViewModel`
+     * answers both with nothing, so a view declares what it owns instead of the
+     * base reading properties whose meaning belongs to the view — see
+     * `util/openViews.ts`, where the recursion over them lives.
+     *
+     * Required, like `bodyMounted`, so a stand-in that means to be enumerated
+     * says so; the empty default means forgetting under-reports rather than
+     * putting something that is not a track in front of the readiness marker.
      */
     ownTracks: AbstractTrackModel[];
-    /**
-     * this view and every view nested inside it, to any depth. The walk over
-     * `tracks` / `trackContainers` / `views` is written once, in `BaseViewModel`;
-     * anything needing "everything on screen" asks this and `ownTracks` rather
-     * than knowing which property a container keeps its children on.
-     */
-    allViews: AbstractViewModel[];
-    /** every track open on this view or any view nested inside it */
-    allTracks: AbstractTrackModel[];
+    /** the views nested directly inside this one — see `ownTracks` */
+    ownViews: AbstractViewModel[];
 }
 export declare function isViewModel(thing: unknown): thing is AbstractViewModel;
 type Display = {

package/esm/util/usePanelVirtualScroll.d.ts

@@ -8,11 +8,15 @@ interface PanelScrollTarget {
  * the canvas basic display: a plain wheel scrolls it, `shift` keeps scrolling it
  * once `scrollZoom` has claimed the plain wheel for the view, and ctrl/meta is
  * left to the browser and the view's pinch-zoom. Nothing here resizes anything.
+ * A sideways-dominant wheel is the view's pan and is declined
+ * (`useVirtualScrollWheel`, which says what latching does with that).
  *
  * These panels paint a fixed-size canvas at `-scrollTop` rather than living in a
  * DOM overflow container, so nothing scrolls them without this. The latch (inside
- * `applyScroll`) owns `preventDefault` but never `stopPropagation`, so a diagonal
- * wheel still bubbles its horizontal component to the LGV for panning.
+ * `applyScroll`) owns `preventDefault` but never `stopPropagation`: the event
+ * still reaches the LGV, which reads that flag and declines a gesture this panel
+ * has claimed, so a diagonal wheel scrolls the reads without also panning the
+ * genome sideways.
  *
  * ADR-027 keeps wheel-*intent* dispatch per handler, because the panels do not
  * agree on what a gesture means. This is the second of the two rules that

package/esm/util/usePanelVirtualScroll.js

@@ -4,11 +4,15 @@ import { useVirtualScrollWheel } from './useVirtualScrollWheel.js';
  * the canvas basic display: a plain wheel scrolls it, `shift` keeps scrolling it
  * once `scrollZoom` has claimed the plain wheel for the view, and ctrl/meta is
  * left to the browser and the view's pinch-zoom. Nothing here resizes anything.
+ * A sideways-dominant wheel is the view's pan and is declined
+ * (`useVirtualScrollWheel`, which says what latching does with that).
  *
  * These panels paint a fixed-size canvas at `-scrollTop` rather than living in a
  * DOM overflow container, so nothing scrolls them without this. The latch (inside
- * `applyScroll`) owns `preventDefault` but never `stopPropagation`, so a diagonal
- * wheel still bubbles its horizontal component to the LGV for panning.
+ * `applyScroll`) owns `preventDefault` but never `stopPropagation`: the event
+ * still reaches the LGV, which reads that flag and declines a gesture this panel
+ * has claimed, so a diagonal wheel scrolls the reads without also panning the
+ * genome sideways.
  *
  * ADR-027 keeps wheel-*intent* dispatch per handler, because the panels do not
  * agree on what a gesture means. This is the second of the two rules that

package/esm/util/useRowVirtualScroll.d.ts

@@ -10,7 +10,7 @@ interface RowScrollTarget {
  * Wheel gestures over a **row-stack** panel — the multi-sample variant displays
  * and MAF: `shift`+wheel resizes the rows (a vertical-zoom that keeps the row
  * under the cursor put), a plain wheel scrolls them, and anything the panel
- * can't consume is left to bubble to the view.
+ * can't consume — a sideways swipe included — is left to bubble to the view.
  *
  * These panels paint a fixed-size canvas at `-scrollTop` rather than living in a
  * DOM overflow container, so nothing scrolls them without this.

package/esm/util/useRowVirtualScroll.js

@@ -4,7 +4,7 @@ import { useVirtualScrollWheel } from './useVirtualScrollWheel.js';
  * Wheel gestures over a **row-stack** panel — the multi-sample variant displays
  * and MAF: `shift`+wheel resizes the rows (a vertical-zoom that keeps the row
  * under the cursor put), a plain wheel scrolls them, and anything the panel
- * can't consume is left to bubble to the view.
+ * can't consume — a sideways swipe included — is left to bubble to the view.
  *
  * These panels paint a fixed-size canvas at `-scrollTop` rather than living in a
  * DOM overflow container, so nothing scrolls them without this.

package/esm/util/useVirtualScrollWheel.js

@@ -58,7 +58,17 @@ onWheel) {
     // not-yet-committed model read.
     const runningRef = useRef(0);
     const applyScroll = useCallback((e, { scrollTop, viewportHeight, scrollableHeight }, commit) => {
-        if (scrollableHeight <= 0) {
+        // Each handler takes the gesture whose dominant axis is its own: a
+        // sideways swipe belongs to the view's pan, and consuming its small
+        // vertical component would both drift the panel and — since consuming
+        // means preventDefault, which is how the view knows to stay out — kill
+        // the pan the user actually asked for. A tie is vertical, matching the
+        // view's own zoom-vs-pan tie-break. Raw deltas, because both axes of one
+        // event share a deltaMode. `holds` is what keeps this from cutting a
+        // gesture in half: once the panel has latched, the sideways momentum
+        // trailing a vertical scroll stays with the panel.
+        const sideways = Math.abs(e.deltaX) > Math.abs(e.deltaY);
+        if (scrollableHeight <= 0 || (sideways && !latch.holds(e))) {
             return;
         }
         // A fresh frame (nothing pending) re-syncs to the model's live scrollTop;

package/esm/util/wheelZoom.d.ts

@@ -17,6 +17,7 @@ export interface WheelZoomTarget {
     views: WheelZoomView[];
     scrollZoom: boolean;
     originElement: () => HTMLElement | undefined;
+    hold?: <T>(fn: () => T) => T;
 }
 export interface WheelZoomControllerOptions {
     element: HTMLElement;
@@ -37,9 +38,10 @@ export interface WheelZoomControllerOptions {
 /**
  * The one wheel gesture handler for linear views. Its decision matrix:
  *
+ *   - a wheel a nested scroller already consumed  → declined, it owns the gesture
  *   - ctrl/meta+wheel, or (scrollZoom && |dy| >= |dx|)  → zoom about the cursor
  *   - shift+wheel while scrollZoom is on                → declined, we pass
- *   - a horizontal delta, unless one arrives mid-zoom   → pan by dx
+ *   - a sideways delta, unless one arrives mid-zoom     → pan by dx
  *
  * Declining shift is what leaves a nested panel its own scroll
  * (`usePanelVirtualScroll`) — it is not a way back to the page. Browsers turn

package/esm/util/wheelZoom.js

@@ -89,9 +89,10 @@ export function applyZoomAccum(bpPerPx, zoomAccum, elapsedMs) {
 /**
  * The one wheel gesture handler for linear views. Its decision matrix:
  *
+ *   - a wheel a nested scroller already consumed  → declined, it owns the gesture
  *   - ctrl/meta+wheel, or (scrollZoom && |dy| >= |dx|)  → zoom about the cursor
  *   - shift+wheel while scrollZoom is on                → declined, we pass
- *   - a horizontal delta, unless one arrives mid-zoom   → pan by dx
+ *   - a sideways delta, unless one arrives mid-zoom     → pan by dx
  *
  * Declining shift is what leaves a nested panel its own scroll
  * (`usePanelVirtualScroll`) — it is not a way back to the page. Browsers turn
@@ -141,26 +142,41 @@ export function createWheelZoomController({ element, resolveTarget, swallowUnhan
                 s.originLeft = origin.getBoundingClientRect().left;
             }
             const originLeft = s.originLeft;
-            transaction(() => {
-                if (s.zoomAccum !== 0 && originLeft !== undefined) {
-                    const offset = s.lastClientX - originLeft;
-                    for (const view of target.views) {
-                        view.zoomTo(applyZoomAccum(view.bpPerPx, s.zoomAccum, elapsed), offset);
+            const apply = () => {
+                transaction(() => {
+                    if (s.zoomAccum !== 0 && originLeft !== undefined) {
+                        const offset = s.lastClientX - originLeft;
+                        for (const view of target.views) {
+                            view.zoomTo(applyZoomAccum(view.bpPerPx, s.zoomAccum, elapsed), offset);
+                        }
                     }
-                }
-                if (s.scrollDelta !== 0) {
-                    for (const view of target.views) {
-                        view.horizontalScroll(s.scrollDelta);
+                    if (s.scrollDelta !== 0) {
+                        for (const view of target.views) {
+                            view.horizontalScroll(s.scrollDelta);
+                        }
                     }
-                }
-            });
+                });
+            };
+            if (target.hold) {
+                target.hold(apply);
+            }
+            else {
+                apply();
+            }
         }
         s.zoomAccum = 0;
         s.scrollDelta = 0;
     }
     function onWheel(event) {
         onEvent?.(event);
-        const gated = presence !== undefined && !presence.isOver;
+        // A nested vertical scroller preventDefaults exactly what it consumed, and
+        // that flag is still readable on the way up, so the view declines what a
+        // panel is already scrolling: a trackpad emits a small deltaX alongside
+        // every vertical swipe, which used to pan the genome sideways under someone
+        // who was only scrolling reads. No timer of our own — the scroll latch
+        // holds the whole continuous gesture, boundary included, and releasing it
+        // is the pause that ends the gesture.
+        const gated = event.defaultPrevented || (presence !== undefined && !presence.isOver);
         const target = gated ? undefined : resolveTarget(event);
         if (target && !(event.shiftKey && target.scrollZoom)) {
             // a gap longer than the frame-elapsed clamp means this event starts a new
@@ -216,7 +232,16 @@ export function createWheelZoomController({ element, resolveTarget, swallowUnhan
                     Math.abs(deltaX) > Math.abs(2 * deltaY)) {
                     event.preventDefault();
                 }
-                s.scrollDelta = accumulateScroll(s.scrollDelta, deltaX);
+                // Pan on a gesture that is actually sideways. A trackpad puts a small
+                // deltaX on every vertical swipe, and panning on it drifted the genome
+                // under anyone scrolling a track — including where no panel handler
+                // reports the scroll for us to decline, as with the natively-scrolling
+                // pinned-tracks block. Ties go vertical, the same way the zoom test
+                // above resolves them. With scrollZoom on this changes nothing: a
+                // vertical-dominant wheel was already taken as a zoom.
+                if (Math.abs(deltaX) > Math.abs(deltaY)) {
+                    s.scrollDelta = accumulateScroll(s.scrollDelta, deltaX);
+                }
             }
             frame.schedule(flush);
         }

package/esm/util/withLaunchInput.d.ts

@@ -1,5 +1,34 @@
 export { legacyInitMessage, unknownKeysMessage } from './unknownSnapshotKeys.ts';
-import type { IAnyModelType, IModelType, SnapshotIn } from '@jbrowse/mobx-state-tree';
+import type { IAnyModelType, IModelType, SnapshotIn, SnapshotOut } from '@jbrowse/mobx-state-tree';
+/**
+ * The slice of a PluginManager the partition reads: which view type a
+ * snapshot's `type` names, and that type's state model as REGISTERED — the
+ * one `extendViewType` may have composed more properties onto after the
+ * factory wrapped its own.
+ */
+export interface ViewTypeLookup {
+    viewTypes: {
+        has: (name: string) => boolean;
+    };
+    getViewType: (name: string) => {
+        isStateModelLoaded: boolean;
+        stateModel: IAnyModelType;
+    };
+}
+export interface LaunchInputOptions<M extends IAnyModelType> {
+    /** the PluginManager; without it the partition sees only the wrapped model */
+    registry?: ViewTypeLookup;
+    /**
+     * Whether a snapshot shows the launch applied — rows built, regions set. The
+     * blob persists only until then: a snapshot taken mid-load (an autosave
+     * firing before the launch autorun navigates) has to rebuild the view rather
+     * than drop it to the import form, and a materialized view has nothing left
+     * to rebuild. `installInitAutorun` keys its failure policy off the same line,
+     * read from the live node. `Partial` because a `stripDefault` property is
+     * absent from the snapshot when empty, whatever its declared type says.
+     */
+    materialized: (snap: Partial<SnapshotOut<M>>) => boolean;
+}
 /**
  * How a launch key's value is told apart from the state property of the same
  * name. A key whose name collides with nothing is `launch`; the rest name the
@@ -93,6 +122,17 @@ export type LaunchInputModel<M extends IAnyModelType, Commands, PassThrough exte
 export declare function defineLaunchKeys<Commands>(): <const P extends readonly string[] = readonly never[]>(keys: Record<keyof Commands, LaunchKeySpec>, { passThrough }?: {
     passThrough?: P;
 }) => LaunchKeyRegistration<Commands, P[number]>;
+/**
+ * The part of a launch spec that belongs on the snapshot: everything but the
+ * launch keys, and the identity and `launch` keys no spec may set. For a caller
+ * that applies the launch itself and builds the view from a snapshot — a
+ * synteny row, whose parent navigates it and opens its tracks — so what it
+ * hands MST is settings only, and the view's own partition sorts those into
+ * properties and reported typos.
+ */
+export declare function snapshotSettings(spec: Record<string, unknown>, registration: LaunchKeyRegistration<unknown, string> | undefined): {
+    [k: string]: unknown;
+};
 /**
  * Accept a view's settings written directly on the view object, and move the
  * ones a launcher has to resolve into the internal `launch` property.
@@ -104,6 +144,11 @@ export declare function defineLaunchKeys<Commands>(): <const P extends readonly
  * are about to be rejected. `afterAttach` — reached only by a snapshot that won
  * — reports what the partition captured.
  *
+ * `registry` is the PluginManager. With it the partition classifies against
+ * the view type as registered, `extendViewType`'s added properties included;
+ * without it, against the model as wrapped here. `materialized` draws the line
+ * past which the blob is no longer persisted; see `LaunchInputOptions`.
+ *
  * ORDER: MST runs preprocessors in the reverse of the order they were added, so
  * this belongs on the chain BEFORE a view's own legacy-key preprocessor, where
  * it partitions the snapshot MST finally consumes rather than a key that remap
@@ -120,4 +165,4 @@ export declare function defineLaunchKeys<Commands>(): <const P extends readonly
  * without a word, and `ViewType.stateModel` and every `.properties`
  * introspection site break with it.
  */
-export declare function withLaunchInput<M extends IAnyModelType, Commands, PassThrough extends string>(model: M, registration: LaunchKeyRegistration<Commands, PassThrough>): LaunchInputModel<M, Commands, PassThrough>;
+export declare function withLaunchInput<M extends IAnyModelType, Commands, PassThrough extends string>(model: M, registration: LaunchKeyRegistration<Commands, PassThrough>, { registry, materialized }: LaunchInputOptions<M>): LaunchInputModel<M, Commands, PassThrough>;

package/esm/util/withLaunchInput.js

@@ -41,6 +41,18 @@ export function defineLaunchKeys() {
 // is ever a setting and neither can be lifted off the snapshot.
 const IDENTITY = new Set(['id', 'type']);
 const LAUNCH = 'launch';
+/**
+ * The part of a launch spec that belongs on the snapshot: everything but the
+ * launch keys, and the identity and `launch` keys no spec may set. For a caller
+ * that applies the launch itself and builds the view from a snapshot — a
+ * synteny row, whose parent navigates it and opens its tracks — so what it
+ * hands MST is settings only, and the view's own partition sorts those into
+ * properties and reported typos.
+ */
+export function snapshotSettings(spec, registration) {
+    const keys = registration?.keys ?? {};
+    return Object.fromEntries(Object.entries(spec).filter(([key]) => !(key in keys) && !IDENTITY.has(key) && key !== LAUNCH));
+}
 function isObject(value) {
     return !!value && typeof value === 'object';
 }
@@ -80,6 +92,31 @@ function splitEntries(kind, value) {
         state: built.length ? (Array.isArray(value) ? built : value) : undefined,
     };
 }
+// The properties a snapshot's keys are classified against are the REGISTERED
+// view type's, read at preprocess time: `extendViewType` composes onto the
+// model after `withLaunchInput` wrapped it, and a set frozen at wrap time sent
+// every added property to `unknown` — restored at its default, with a warning
+// naming it a typo. The wrapped model's own properties are the answer when no
+// registry is given, or the snapshot names a type it does not hold, which is
+// how a factory-built model in a test behaves.
+function knownPropsResolver(model, registry) {
+    let cachedProps;
+    let cachedKeys = new Set();
+    return (snap) => {
+        const name = snap.type;
+        const registered = registry && typeof name === 'string' && registry.viewTypes.has(name)
+            ? registry.getViewType(name)
+            : undefined;
+        const props = registered?.isStateModelLoaded
+            ? registered.stateModel.properties
+            : model.properties;
+        if (props !== cachedProps) {
+            cachedProps = props;
+            cachedKeys = new Set(Object.keys(props));
+        }
+        return cachedKeys;
+    };
+}
 function classify(snap, { keys, passThrough }, known, out) {
     for (const [key, value] of Object.entries(snap)) {
         const spec = keys[key];
@@ -140,6 +177,11 @@ function legacyInitSnapshot(init, { keys }) {
  * are about to be rejected. `afterAttach` — reached only by a snapshot that won
  * — reports what the partition captured.
  *
+ * `registry` is the PluginManager. With it the partition classifies against
+ * the view type as registered, `extendViewType`'s added properties included;
+ * without it, against the model as wrapped here. `materialized` draws the line
+ * past which the blob is no longer persisted; see `LaunchInputOptions`.
+ *
  * ORDER: MST runs preprocessors in the reverse of the order they were added, so
  * this belongs on the chain BEFORE a view's own legacy-key preprocessor, where
  * it partitions the snapshot MST finally consumes rather than a key that remap
@@ -156,13 +198,14 @@ function legacyInitSnapshot(init, { keys }) {
  * without a word, and `ViewType.stateModel` and every `.properties`
  * introspection site break with it.
  */
-export function withLaunchInput(model, registration) {
-    const known = new Set(Object.keys(model.properties));
+export function withLaunchInput(model, registration, { registry, materialized }) {
+    const knownProps = knownPropsResolver(model, registry);
     const partitioned = model
         .preProcessSnapshot((snap) => {
         if (!isObject(snap)) {
             return snap;
         }
+        const known = knownProps(snap);
         const { init, ...rest } = snap;
         const out = {
             state: {},
@@ -207,20 +250,22 @@ export function withLaunchInput(model, registration) {
             reportMalformedRows(self, Object.keys(launch?.malformed ?? {}));
         },
     }))
-        // `legacyInit` names the SPELLING of the snapshot this view was opened from,
-        // and a saved one does not use it — so persisting the flag makes every later
-        // restore report nesting the snapshot it is reading does not contain,
-        // forever, since nothing clears it (`pendingLaunch` excludes the report
-        // keys, so the launch autorun never runs). `unknown` and `malformed` stay:
-        // those name content that was DISCARDED, which is still true of the saved
-        // snapshot, and the blob is the only record of it.
+        // Whole while the view has yet to materialize, since the pending launch is
+        // then the only thing a reload can rebuild the view from, and gone once it
+        // has — the report keys with it, so a saved session never carries a
+        // typo report about content it no longer holds. `legacyInit` goes either
+        // way: it names the SPELLING of the snapshot this view was opened from,
+        // and the saved one does not use it, so persisting it would report nesting
+        // on every restore forever (`pendingLaunch` excludes the report keys, so
+        // no launch run ever clears it).
         .postProcessSnapshot((snap) => {
         const launch = snap[LAUNCH];
-        if (!isObject(launch) || !launch.legacyInit) {
+        if (!isObject(launch)) {
             return snap;
         }
         const { legacyInit, ...kept } = launch;
-        return Object.keys(kept).length
+        return Object.keys(kept).length &&
+            !materialized(snap)
             ? { ...snap, [LAUNCH]: kept }
             : Object.fromEntries(Object.entries(snap).filter(([key]) => key !== LAUNCH));
     });