@jbrowse/render-core 4.3.0

package/esm/installUpload.d.ts

@@ -0,0 +1,91 @@
+import type { LifecycleHost } from './RenderLifecycleMixin.ts';
+/**
+ * What every backend that takes keyed uploads implements. One cell is one
+ * immutable payload under one key, and the key is whatever the display's own
+ * map is keyed by: a `displayedRegionIndex`, a sibling display's
+ * `sharedBackendKey`, or a slot name on a display that holds one payload.
+ *
+ * `release` is per key, never an active-set prune. The diff below knows
+ * exactly which keys departed, so a per-key release does the same job on a
+ * display's own map and is the only correct shape on a canvas several displays
+ * share, where a prune computed from one display's map would wipe its
+ * siblings' buffers.
+ */
+export interface CellTarget<K, Encoded> {
+    upload(key: K, data: Encoded): void;
+    release(key: K): void;
+}
+/**
+ * What the backend takes, read off the backend, which is the direction the
+ * overloads have to check in: the payload reaching `upload` must be assignable
+ * to the parameter it declares. Inferring the other way, from `encode`'s
+ * return, loses to the contravariant `backend` position and no encoding
+ * display resolves an overload.
+ */
+type EncodedOf<B> = B extends {
+    upload(key: never, data: infer E): void;
+} ? E : never;
+export interface UploadSpec<K, Data, Props, Encoded, B> {
+    /**
+     * The display's payloads, one per key. Read inside the upload autorun, so a
+     * commit re-runs the diff and only the entries whose reference moved reach
+     * the backend. Absence is absence: a display with nothing to upload yet
+     * leaves the key out rather than storing `undefined` under it, and the
+     * departed key is released.
+     */
+    cells: () => ReadonlyMap<K, Data>;
+    /**
+     * Everything `encode` needs beyond the cell's own data, as one value. The
+     * helper memoizes it and re-encodes every cell on its identity, so return
+     * the narrow thing a re-encode is actually about, never the whole render
+     * state.
+     */
+    inputs?: () => Props;
+    /**
+     * Build one cell's upload payload. Pure in `(data, props, key)`: an
+     * observable read here is tracked but invalidates nothing, only `cells` and
+     * `inputs` do. The key is for a display whose cells are not all the same
+     * kind of thing, a contact matrix beside the palette it is drawn through.
+     */
+    encode?: (data: Data, props: Props, key: K) => Encoded;
+    /**
+     * Draw one frame from the latest encoded map and say whether real content
+     * reached the canvas.
+     */
+    render: (backend: B, encoded: ReadonlyMap<K, Encoded>) => boolean;
+}
+/**
+ * The cells of a display that holds one payload for the whole view: the key
+ * while the payload is there, nothing while it is not. Absence is how such a
+ * display says "nothing to upload yet", so the diff releases the key rather
+ * than being handed `undefined` under it.
+ */
+export declare function oneCell<K, T>(key: K, value: T | undefined | null): ReadonlyMap<K, T>;
+/**
+ * The one upload lifecycle. A display hands over a map of immutable payloads
+ * and a render; the helper diffs the map by reference on every commit,
+ * encodes and uploads what moved, releases what left, and re-uploads
+ * everything into a fresh backend after a context loss.
+ *
+ * Per-region, shared-canvas and whole-view displays were three installers
+ * over this one diff, split by how a departed key was released and by the
+ * name of the backend's upload method. With `CellTarget` naming both, what is
+ * left per family is the key the display's map is keyed by.
+ *
+ * **Calling again only swaps the backend.** Displays wire this from
+ * `startRenderingBackend`, which fires again on every context-loss recovery;
+ * the diff and the encode cache live in the setup thunk and survive it.
+ *
+ * @see installUpload.test.ts for the upload, encode and release counts.
+ * @see ADR-078 for why this is one autorun and a diff.
+ */
+export declare function installUpload<K, Data extends EncodedOf<B>, B extends CellTarget<K, unknown>>(self: LifecycleHost, backend: B, spec: {
+    cells: () => ReadonlyMap<K, Data>;
+    render: (backend: B, encoded: ReadonlyMap<K, Data>) => boolean;
+    encode?: never;
+    inputs?: never;
+}): void;
+export declare function installUpload<K, Data, Props, B extends CellTarget<K, unknown>>(self: LifecycleHost, backend: B, spec: UploadSpec<K, Data, Props, EncodedOf<B>, B> & {
+    encode: (data: Data, props: Props, key: K) => EncodedOf<B>;
+}): void;
+export {};

package/esm/installUpload.js

@@ -0,0 +1,94 @@
+import { getType } from '@jbrowse/mobx-state-tree';
+import { computed } from 'mobx';
+import { createMapUploadSync } from './mapUploadSync.js';
+import { isCheckedAtTheStore } from './regionDataMap.js';
+/**
+ * The cells of a display that holds one payload for the whole view: the key
+ * while the payload is there, nothing while it is not. Absence is how such a
+ * display says "nothing to upload yet", so the diff releases the key rather
+ * than being handed `undefined` under it.
+ */
+export function oneCell(key, value) {
+    const cells = new Map();
+    if (value !== undefined && value !== null) {
+        cells.set(key, value);
+    }
+    return cells;
+}
+const alreadyNamed = new WeakMap();
+function checkPayloads(self, cells) {
+    if (isCheckedAtTheStore(cells)) {
+        return;
+    }
+    for (const [key, value] of cells) {
+        if (value === undefined || value === null) {
+            let named = alreadyNamed.get(self);
+            if (!named) {
+                named = new Set();
+                alreadyNamed.set(self, named);
+            }
+            if (!named.has(key)) {
+                named.add(key);
+                console.error(`[jbrowse display contract] ${getType(self).name}: cell ${String(key)} ` +
+                    `handed to installUpload is \`${String(value)}\`. A fetch answers ` +
+                    'a payload or nothing; leave the key out until it has one.');
+            }
+        }
+    }
+}
+export function installUpload(self, backend, { cells, inputs, encode, render }) {
+    self.attachRenderingBackend(backend, () => {
+        const sync = createMapUploadSync({
+            upload: (b, key, data) => {
+                b.upload(key, data);
+            },
+            remove: (b, key) => {
+                b.release(key);
+            },
+        });
+        if (!encode) {
+            const own = cells;
+            return {
+                upload: b => {
+                    const current = own();
+                    if (process.env.NODE_ENV !== 'production') {
+                        checkPayloads(self, current);
+                    }
+                    return sync(b, current);
+                },
+                render: b => render(b, own()),
+            };
+        }
+        const encoded = new Map();
+        const encodedFrom = new Map();
+        const props = inputs && computed(inputs);
+        let lastProps;
+        return {
+            upload: b => {
+                const current = cells();
+                if (process.env.NODE_ENV !== 'production') {
+                    checkPayloads(self, current);
+                }
+                const p = props ? props.get() : undefined;
+                if (p !== lastProps) {
+                    lastProps = p;
+                    encodedFrom.clear();
+                }
+                for (const [key, data] of current) {
+                    if (encodedFrom.get(key) !== data) {
+                        encoded.set(key, encode(data, p, key));
+                        encodedFrom.set(key, data);
+                    }
+                }
+                for (const key of encoded.keys()) {
+                    if (!current.has(key)) {
+                        encoded.delete(key);
+                        encodedFrom.delete(key);
+                    }
+                }
+                return sync(b, encoded);
+            },
+            render: b => render(b, encoded),
+        };
+    });
+}

package/esm/instanceCache.d.ts

@@ -0,0 +1,43 @@
+export interface InstanceCacheOpts<TData> {
+    /**
+     * A field of `data` whose object identity changes exactly when the geometry
+     * does. Any one of the coordinate arrays works, because a refetch replaces
+     * them atomically — but it must be a coordinate array, not a color one.
+     */
+    geomToken: (data: TData) => object;
+    /** The per-instance packed colors, whose identity a recolor replaces. */
+    colors: (data: TData) => Uint32Array;
+    /** Pack every lane. Called only when the geometry moved. */
+    interleave: (data: TData) => ArrayBuffer;
+    /** Instance stride and color-lane offset, in u32 words. */
+    strideWords: number;
+    colorOffsetWords: number;
+}
+/**
+ * A per-key cache of packed instance bytes with a geometry/color split: a
+ * recolor patches the one color lane in place instead of re-packing every
+ * other one.
+ *
+ * The split is worth having because the two inputs move on completely
+ * different schedules — geometry on an RPC refetch, colors on a `colorBy`
+ * toggle or a palette change, which is interactive. Synteny re-packs 12 lanes
+ * and dotplot 5; both had measured the patch as the difference between a
+ * toggle that feels instant and one that doesn't.
+ *
+ * Shared because both had written it, identically, down to a sync comment on
+ * the patch loop saying the color write must mirror the interleave. What
+ * makes it worth a helper rather than two copies is the invalidation: get the
+ * `geomToken` comparison or the `colors` write-back wrong and the failure is
+ * stale geometry on screen, which no test catches and which looks like a data
+ * problem. `installUpload` exists for the same reason one
+ * layer up — an upload memo is not a hand-rolled `let`.
+ *
+ * The GPU re-upload still happens on a recolor (no HAL does partial buffer
+ * updates); what is skipped is the dominant CPU interleave.
+ */
+export declare function createInstanceCache<TData>(opts: InstanceCacheOpts<TData>): {
+    /** Packed bytes for `key`, re-packing or re-coloring only as needed. */
+    get(key: number, data: TData): ArrayBuffer;
+    delete(key: number): void;
+    clear(): void;
+};

package/esm/instanceCache.js

@@ -0,0 +1,53 @@
+/**
+ * A per-key cache of packed instance bytes with a geometry/color split: a
+ * recolor patches the one color lane in place instead of re-packing every
+ * other one.
+ *
+ * The split is worth having because the two inputs move on completely
+ * different schedules — geometry on an RPC refetch, colors on a `colorBy`
+ * toggle or a palette change, which is interactive. Synteny re-packs 12 lanes
+ * and dotplot 5; both had measured the patch as the difference between a
+ * toggle that feels instant and one that doesn't.
+ *
+ * Shared because both had written it, identically, down to a sync comment on
+ * the patch loop saying the color write must mirror the interleave. What
+ * makes it worth a helper rather than two copies is the invalidation: get the
+ * `geomToken` comparison or the `colors` write-back wrong and the failure is
+ * stale geometry on screen, which no test catches and which looks like a data
+ * problem. `installUpload` exists for the same reason one
+ * layer up — an upload memo is not a hand-rolled `let`.
+ *
+ * The GPU re-upload still happens on a recolor (no HAL does partial buffer
+ * updates); what is skipped is the dominant CPU interleave.
+ */
+export function createInstanceCache(opts) {
+    const { geomToken, colors, interleave, strideWords, colorOffsetWords } = opts;
+    const cache = new Map();
+    return {
+        /** Packed bytes for `key`, re-packing or re-coloring only as needed. */
+        get(key, data) {
+            const geom = geomToken(data);
+            const cols = colors(data);
+            const hit = cache.get(key);
+            if (hit?.geom === geom) {
+                if (hit.colors !== cols) {
+                    const u32 = new Uint32Array(hit.buf);
+                    for (let i = 0, n = cols.length; i < n; i++) {
+                        u32[i * strideWords + colorOffsetWords] = cols[i];
+                    }
+                    hit.colors = cols;
+                }
+                return hit.buf;
+            }
+            const buf = interleave(data);
+            cache.set(key, { geom, colors: cols, buf });
+            return buf;
+        },
+        delete(key) {
+            cache.delete(key);
+        },
+        clear() {
+            cache.clear();
+        },
+    };
+}

package/esm/instancePass.d.ts

@@ -0,0 +1,50 @@
+import type { GpuHal, PipelineDescriptor } from './hal';
+/**
+ * A shader pass bundled with the function that packs its instance buffer.
+ *
+ * A pass id, the packer that fills its buffer, and the upload that joins them
+ * are three statements of one fact, and renderers kept them in three places —
+ * so a pass could be registered and drawn while nothing uploaded to it, which
+ * paints nothing, silently, on the GPU backend only. Here they are one object:
+ *
+ * ```ts
+ * export const GAP_PASS = {
+ *   ...slangPass({ id: 'gap', mod: gapShader }),
+ *   pack: packGaps,
+ * }
+ * ```
+ *
+ * There is no constructor for this — `slangPass` is still how a pass is built,
+ * and a spread is how a packer joins it. That also covers the descriptor built
+ * somewhere payload-agnostic, like a shared glyph shape: `{ ...RectPass, pack }`
+ * is the same line.
+ *
+ * `TData` is the pass's own narrow payload, and stays narrow: a registry keyed
+ * on a wide payload accepts a packer of a supertype by contravariance, so
+ * declaring only the fields a pass actually reads costs nothing at the point of
+ * use.
+ */
+export interface InstancePass<TData> extends PipelineDescriptor {
+    pack: (data: TData) => ArrayBuffer | ArrayBufferView;
+}
+/**
+ * Pack a pass's instances for one region and hand them to the HAL.
+ *
+ * **The instance count is the buffer's own**, not a second expression agreeing
+ * with it. The HAL multiplies the count by the stride to find the last
+ * instance, so a count past `byteLength / stride` reads off the end —
+ * undefined pixels, no throw. A packer that allocates `n * INSTANCE_STRIDE_BYTES`
+ * has already stated `n`; asking it again from the source arrays
+ * (`positions.length / 2`, `numInsertions`, a parallel array the worker sized
+ * separately) is a second expression free to disagree.
+ *
+ * **A packer that over-allocates must right-size before returning** — the count
+ * is read off the bytes, so trailing capacity would draw as instances. Prefer
+ * the copy to a subarray view: a view pins the whole allocation, and these
+ * payloads are retained per region for as long as the region is loaded.
+ *
+ * An empty pack is passed through rather than skipped: every HAL deletes the
+ * pass's prior buffer before looking at the count, so `count === 0` IS the
+ * "this pass has nothing this time" instruction.
+ */
+export declare function uploadPass<TData>(hal: GpuHal, regionKey: number, pass: InstancePass<TData>, data: TData): void;

package/esm/instancePass.js

@@ -0,0 +1,34 @@
+/**
+ * Pack a pass's instances for one region and hand them to the HAL.
+ *
+ * **The instance count is the buffer's own**, not a second expression agreeing
+ * with it. The HAL multiplies the count by the stride to find the last
+ * instance, so a count past `byteLength / stride` reads off the end —
+ * undefined pixels, no throw. A packer that allocates `n * INSTANCE_STRIDE_BYTES`
+ * has already stated `n`; asking it again from the source arrays
+ * (`positions.length / 2`, `numInsertions`, a parallel array the worker sized
+ * separately) is a second expression free to disagree.
+ *
+ * **A packer that over-allocates must right-size before returning** — the count
+ * is read off the bytes, so trailing capacity would draw as instances. Prefer
+ * the copy to a subarray view: a view pins the whole allocation, and these
+ * payloads are retained per region for as long as the region is loaded.
+ *
+ * An empty pack is passed through rather than skipped: every HAL deletes the
+ * pass's prior buffer before looking at the count, so `count === 0` IS the
+ * "this pass has nothing this time" instruction.
+ */
+export function uploadPass(hal, regionKey, pass, data) {
+    const buf = pass.pack(data);
+    const count = buf.byteLength / pass.instanceStride;
+    if (!Number.isInteger(count)) {
+        // Unreachable from a packer sizing itself off the shader's own
+        // `INSTANCE_STRIDE_BYTES`. Reachable if a buffer packed somewhere that
+        // cannot import the `.slang` — a worker package with a codegen target of
+        // its own — was built against a stride that has since drifted. Loud beats a
+        // fractional instance count reaching the HAL.
+        throw new Error(`pass ${pass.id}: ${buf.byteLength} bytes is not a whole number of ` +
+            `${pass.instanceStride}-byte instances`);
+    }
+    hal.uploadBuffer(regionKey, pass.id, buf, count);
+}

package/esm/keyedRenderingBackend.d.ts

@@ -0,0 +1,41 @@
+import type { RenderingBackend } from './renderingBackendBase.ts';
+/**
+ * Shared contract for **keyed shared-canvas** backends — one canvas painting
+ * several displays at once, each holding its own uploaded buffer under its own
+ * key. Dotplot (a key per display in the view) and multi-LGV synteny (a key per
+ * track level) are the two.
+ *
+ * The third shape beside per-region and monolithic, and genuinely neither:
+ * per-region drives off `renderBlocks(blocks, regions, state)` with the model's
+ * data map handed back each frame, and monolithic is one payload under the `data` key
+ * with no key at all. These key their uploads and render every key in one
+ * frame from state the caller assembled, so they own the map.
+ *
+ * Unlike the other two this is an interface with no abstract class under it:
+ * the shared *state* (`hal` + uniform scratch, or `canvas` + 2D context) is
+ * `GpuRenderingBackendBase` / `Canvas2DRenderingBackendBase`, which every keyed
+ * backend extends, and there is no shared *behavior* on top — the render loops
+ * genuinely differ. An empty abstract class between them would only be a place
+ * to look.
+ */
+export interface KeyedRenderingBackend<UploadData, RenderState> extends RenderingBackend {
+    /** CSS-pixel size of the shared canvas. */
+    resize(width: number, height: number): void;
+    upload(key: number, data: UploadData): void;
+    release(key: number): void;
+    /** Paint every key the state names. */
+    render(state: RenderState): void;
+}
+/**
+ * Stable 32-bit slot for a display on a backend it shares with siblings, hashed
+ * from its MST node id (djb2). Collisions are vanishingly rare at display
+ * cardinalities, and the alternative — coordinating integer slots between
+ * displays that don't know about each other — is worse.
+ *
+ * Key by this, never by the display's index in its parent's list. An index
+ * renumbers when a sibling is hidden or reordered, which hands the survivor a
+ * slot holding another display's bytes: the keyed diff sees a changed
+ * reference and re-uploads every later display's whole buffer, and any frame
+ * drawn between the two mistakes one display's geometry for another's.
+ */
+export declare function sharedBackendKey(id: string): number;

package/esm/keyedRenderingBackend.js

@@ -0,0 +1,19 @@
+/**
+ * Stable 32-bit slot for a display on a backend it shares with siblings, hashed
+ * from its MST node id (djb2). Collisions are vanishingly rare at display
+ * cardinalities, and the alternative — coordinating integer slots between
+ * displays that don't know about each other — is worse.
+ *
+ * Key by this, never by the display's index in its parent's list. An index
+ * renumbers when a sibling is hidden or reordered, which hands the survivor a
+ * slot holding another display's bytes: the keyed diff sees a changed
+ * reference and re-uploads every later display's whole buffer, and any frame
+ * drawn between the two mistakes one display's geometry for another's.
+ */
+export function sharedBackendKey(id) {
+    let h = 5381;
+    for (let i = 0; i < id.length; i++) {
+        h = ((h << 5) + h + id.charCodeAt(i)) | 0;
+    }
+    return h >>> 0;
+}

package/esm/mapUploadSync.d.ts

@@ -0,0 +1,31 @@
+export interface MapUploadTarget<K, T, B> {
+    upload: (backend: B, key: K, data: T) => void;
+    /**
+     * How a key that left the map is released. `remove` deletes it by itself;
+     * `prune` is handed the keys still present and releases everything else.
+     * `installUpload` takes the first, which is the only correct shape on a
+     * canvas several displays share and does the same job on a display's own
+     * map.
+     */
+    remove?: (backend: B, key: K) => void;
+    prune?: (backend: B, active: ReadonlySet<K>) => void;
+}
+/**
+ * The one reference diff every keyed GPU upload in the tree runs on. Uploads
+ * only entries whose data reference changed, releases entries no longer
+ * present (and forgets them, so a later same-reference re-arrival still
+ * re-uploads), and re-uploads everything when the backend identity changes —
+ * a context-loss recovery hands a fresh backend with empty GPU buffers.
+ *
+ * Returns whether anything reached the backend, which is what lets the upload
+ * autorun skip the redraw it would otherwise force after every run.
+ *
+ * For the skip to fire, the map must keep **stable references** for unchanged
+ * entries across recomputes. With an always-fresh map every entry re-uploads,
+ * which is correct but defeats the optimization.
+ *
+ * **A display does not hold one of these.** The lifecycle installers own it,
+ * built inside the `attachRenderingBackend` setup thunk so the memo lives
+ * exactly as long as the callbacks that read it.
+ */
+export declare function createMapUploadSync<K, T, B>(target: MapUploadTarget<K, T, B>): (backend: B, entries: ReadonlyMap<K, T>) => boolean;

package/esm/mapUploadSync.js

@@ -0,0 +1,45 @@
+/**
+ * The one reference diff every keyed GPU upload in the tree runs on. Uploads
+ * only entries whose data reference changed, releases entries no longer
+ * present (and forgets them, so a later same-reference re-arrival still
+ * re-uploads), and re-uploads everything when the backend identity changes —
+ * a context-loss recovery hands a fresh backend with empty GPU buffers.
+ *
+ * Returns whether anything reached the backend, which is what lets the upload
+ * autorun skip the redraw it would otherwise force after every run.
+ *
+ * For the skip to fire, the map must keep **stable references** for unchanged
+ * entries across recomputes. With an always-fresh map every entry re-uploads,
+ * which is correct but defeats the optimization.
+ *
+ * **A display does not hold one of these.** The lifecycle installers own it,
+ * built inside the `attachRenderingBackend` setup thunk so the memo lives
+ * exactly as long as the callbacks that read it.
+ */
+export function createMapUploadSync(target) {
+    const uploaded = new Map();
+    let lastRenderingBackend;
+    return function sync(backend, entries) {
+        if (backend !== lastRenderingBackend) {
+            uploaded.clear();
+            lastRenderingBackend = backend;
+        }
+        let changed = false;
+        for (const [key, data] of entries) {
+            if (!uploaded.has(key) || uploaded.get(key) !== data) {
+                target.upload(backend, key, data);
+                uploaded.set(key, data);
+                changed = true;
+            }
+        }
+        for (const key of uploaded.keys()) {
+            if (!entries.has(key)) {
+                target.remove?.(backend, key);
+                uploaded.delete(key);
+                changed = true;
+            }
+        }
+        target.prune?.(backend, new Set(entries.keys()));
+        return changed;
+    };
+}

package/esm/namedReactions.d.ts

@@ -0,0 +1,29 @@
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+import type { IAutorunOptions } from 'mobx';
+/**
+ * Dev-only. Records a named reaction against the node it belongs to, so a test
+ * can ask for its dependency set by name. Every autorun installer in the tree
+ * calls this; a display's afterAttach discards the disposer, and this is the
+ * one place it can still be found.
+ */
+export declare function recordNamedReaction(self: object, name: string, disposer: () => void): void;
+/**
+ * An autorun that is disposed with `self` and answerable by name.
+ *
+ * The two halves belong together: `reactionDependencies` can only see a
+ * reaction that was recorded, so an installer that calls `autorun` and
+ * `addDisposer` directly silently opts its dependency set out of the tests that
+ * are supposed to pin it — and nothing fails, which is the same shape of
+ * quiet-hole the mechanism exists to close. Every installer goes through here
+ * so there is no second spelling to forget.
+ */
+export declare function namedAutorun(self: IAnyStateTreeNode, body: () => void, options: IAutorunOptions & {
+    name: string;
+}): import("mobx").IReactionDisposer;
+/**
+ * The observables a named reaction currently subscribes to, as sorted leaf
+ * names (`Model.prop`), computeds flattened to what they read. This is the
+ * dependency set MobX rebuilt on the reaction's last run, so it answers, for
+ * that state, the question no pure function can: which reads are tracked.
+ */
+export declare function reactionDependencies(self: object, name: string): string[];

package/esm/namedReactions.js

@@ -0,0 +1,62 @@
+import { addDisposer } from '@jbrowse/mobx-state-tree';
+import { autorun, getDependencyTree } from 'mobx';
+const registry = new WeakMap();
+/**
+ * Dev-only. Records a named reaction against the node it belongs to, so a test
+ * can ask for its dependency set by name. Every autorun installer in the tree
+ * calls this; a display's afterAttach discards the disposer, and this is the
+ * one place it can still be found.
+ */
+export function recordNamedReaction(self, name, disposer) {
+    if (process.env.NODE_ENV !== 'production') {
+        const forNode = registry.get(self);
+        if (forNode) {
+            forNode.set(name, disposer);
+        }
+        else {
+            registry.set(self, new Map([[name, disposer]]));
+        }
+    }
+}
+/**
+ * An autorun that is disposed with `self` and answerable by name.
+ *
+ * The two halves belong together: `reactionDependencies` can only see a
+ * reaction that was recorded, so an installer that calls `autorun` and
+ * `addDisposer` directly silently opts its dependency set out of the tests that
+ * are supposed to pin it — and nothing fails, which is the same shape of
+ * quiet-hole the mechanism exists to close. Every installer goes through here
+ * so there is no second spelling to forget.
+ */
+export function namedAutorun(self, body, options) {
+    const disposer = autorun(body, options);
+    recordNamedReaction(self, options.name, disposer);
+    addDisposer(self, disposer);
+    return disposer;
+}
+function leaves(tree, out) {
+    if (tree.dependencies?.length) {
+        for (const d of tree.dependencies) {
+            leaves(d, out);
+        }
+    }
+    else {
+        out.add(tree.name);
+    }
+    return out;
+}
+/**
+ * The observables a named reaction currently subscribes to, as sorted leaf
+ * names (`Model.prop`), computeds flattened to what they read. This is the
+ * dependency set MobX rebuilt on the reaction's last run, so it answers, for
+ * that state, the question no pure function can: which reads are tracked.
+ */
+export function reactionDependencies(self, name) {
+    const disposer = registry.get(self)?.get(name);
+    if (!disposer) {
+        throw new Error(`no reaction named ${name} recorded on this node; known: ${[
+            ...(registry.get(self)?.keys() ?? []),
+        ].join(', ')}`);
+    }
+    return [...leaves(getDependencyTree(disposer), new Set())].sort();
+}