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

package/esm/configuration/index.js

@@ -14,7 +14,7 @@ export { mergeFormatCallbacks } from './mergeFormatCallbacks.js';
 export { evaluateForFeature, readConfObject, readConfigValue, } from './readConfObject.js';
 export { applyConfSettings, getConf, setConf } from './getConf.js';
 export { fillLocations } from './fillLocations.js';
-export { applyRetiredSpellings, liftRetiredSpellings, preProcessConfigSnapshot, preProcessSnapshotWith, } from './snapshotPreprocess.js';
+export { applyRetiredSpellings, declaredSnapshot, liftRetiredSpellings, preProcessConfigSnapshot, preProcessSnapshotWith, refusingUndeclaredKeys, } from './snapshotPreprocess.js';
 export { shorthandTargets, shorthandTargetsOf } from './schemaTypes.js';
 export { requirementProblems } from './requirements.js';
 export { expandTabixShorthand, indexSnapshot, requestedIndexType, tabixIndexSnapshot, } from './tabixShorthand.js';

package/esm/configuration/plot.d.ts

@@ -60,8 +60,8 @@ export declare function liftPlot(conf: AnyConfigurationModel, draft: Plot): AnyC
  */
 export declare function plotWrites(conf: AnyConfigurationModel, draft: Plot): Record<string, unknown>;
 /**
- * What a lifted plot's colour objects and `scales.y` say together that the
- * display cannot draw as written, as corner-notice lines: each colour object
+ * What a lifted plot's color objects and `scales.y` say together that the
+ * display cannot draw as written, as corner-notice lines: each color object
  * under its schema's `fieldPresets`, as `jbrowse validate` judges it.
  */
 export declare function schemaPlotProblems(lifted: AnyConfigurationModel): string[];

package/esm/configuration/plot.js

@@ -1,9 +1,10 @@
 import { getSnapshot, getType, isArrayType, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
 import { compareStructural } from 'mobx';
-import { colorProblems, colorSlotsOf, noticeLines, scaleEndProblems, scaleEndsOf, } from '../util/colorScale.js';
+import { colorProblems, colorSlotsOf, noticeLines, scaleEndProblems, scaleEndsOf, withImpliedField, } from '../util/colorScale.js';
 import { readConfObject } from './readConfObject.js';
 import { getConfigurationSchemaMetadata } from './schemaRegistry.js';
 import { bareFormOf, shorthandTargets } from './schemaTypes.js';
+import { refusingUndeclaredKeys } from './snapshotPreprocess.js';
 /**
  * #api core/configuration
  * The grammar's settings, by the slot name every display that has one gives
@@ -11,22 +12,30 @@ import { bareFormOf, shorthandTargets } from './schemaTypes.js';
  * display's `plot`. A display's plot is the ones its config declares
  * (`plotKeysOf`).
  */
+// The multi-row display's `rowGroups` is not here yet; it joins when "Edit
+// plot..." should show the row grouping.
 export const PLOT_VOCABULARY = {
     marks: 'the marks drawn in order, each a mark and an encoding',
+    mark: 'the shape each value is drawn as: a bar, a point, a line or a span',
+    interpolate: 'the path a line takes between values: held across each bin, or centre to centre',
+    aggregate: 'the stored zoom-bin summary drawn: mean, min or max',
+    extent: "the span drawn around each bin's aggregate: its min to max, or none",
     transform: 'the steps run over the features before any mark',
-    unit: 'what one row stands for: a read or a chain, a sample or a haplotype',
+    unit: 'the unit one row draws: a read or a chain, a sample or a haplotype',
     facet: 'one section per value of a field',
+    sort: 'the order the rows stack in: one over the whole window, or by a column at one base',
     rows: 'the rows: their field or order, labels, focus and tree',
-    rowColor: 'the colour of each row, by a row attribute',
-    color: 'the colour',
+    rowColor: 'the color of each row, by a row attribute',
+    color: 'the color',
     baseColor: 'the per-base layer over the reads',
-    arcColor: 'the colour of the arcs between mates',
-    ribbonColor: 'the colour of the ribbons between lanes',
+    arcColor: 'the color of the arcs between mates',
+    ribbonColor: 'the color of the ribbons between lanes',
     laneLayers: 'the layers drawn over each lane',
     scales: 'the axes, scales.y the value axis',
-    y: "what each row's bar height carries",
-    filter: 'the jexl: expressions a feature has to pass',
-    filterBy: 'the read flags and tags a read has to pass',
+    y: 'the field plotted on the value axis',
+    size: "a point's diameter or a line's width, in px",
+    origin: 'the value bars grow from',
+    filter: 'the tests a feature has to pass: jexl: expressions, or on an alignments display the read flags, name, tags and categories',
 };
 const LIFT_ID = 'plotLift';
 /**
@@ -120,10 +129,10 @@ function merged(draft, current) {
  */
 export function liftPlot(conf, draft) {
     checkKeys(draft, plotKeysOf(conf));
-    return getType(conf).create({
+    return refusingUndeclaredKeys(() => getType(conf).create({
         displayId: LIFT_ID,
         ...structuredClone(merged(draft, plotOf(conf))),
-    });
+    }));
 }
 /**
  * #api core/configuration
@@ -140,7 +149,7 @@ export function plotWrites(conf, draft) {
         if (value === undefined || compareStructural(lifted[key], current[key])) {
             continue;
         }
-        writes[key] = lifted[key] ?? null;
+        writes[key] = value === null ? null : (lifted[key] ?? null);
     }
     return writes;
 }
@@ -148,24 +157,29 @@ function subConfOf(conf, key) {
     const member = conf[key];
     return isStateTreeNode(member) ? member : undefined;
 }
+// `value` raw, as `colorSettingOf` reads it: a `jexl:` constant is a constant
+// to judge, never a callback to evaluate here.
 function membersOf(node) {
-    return (name) => readConfObject(node, name);
+    return (name) => name === 'value'
+        ? node.value
+        : readConfObject(node, name);
 }
 /**
- * What a lifted plot's colour objects and `scales.y` say together that the
- * display cannot draw as written, as corner-notice lines: each colour object
+ * What a lifted plot's color objects and `scales.y` say together that the
+ * display cannot draw as written, as corner-notice lines: each color object
  * under its schema's `fieldPresets`, as `jbrowse validate` judges it.
  */
 export function schemaPlotProblems(lifted) {
     return plotKeysOf(lifted).flatMap(key => {
         const node = subConfOf(lifted, key);
-        const presets = node
-            ? getConfigurationSchemaMetadata(node)?.options.fieldPresets
+        const options = node
+            ? getConfigurationSchemaMetadata(node)?.options
             : undefined;
+        const presets = options?.fieldPresets;
         const y = key === 'scales' && node ? subConfOf(node, 'y') : undefined;
         return [
             ...(node && presets
-                ? noticeLines(key, colorProblems(colorSlotsOf(membersOf(node)), presets))
+                ? noticeLines(key, colorProblems(withImpliedField(colorSlotsOf(membersOf(node)), options.impliedField), presets))
                 : []),
             ...(y
                 ? noticeLines('scales.y', scaleEndProblems(scaleEndsOf(membersOf(y))))

package/esm/configuration/schemaRegistry.d.ts

@@ -11,8 +11,6 @@ export interface ConfigurationSchemaMetadata {
      * i.e. with any `baseConfiguration`'s hooks already composed in
      */
     options: MergedConfigurationSchemaOptions<any, any>;
-    /** the frozen-family slots, the only members a snapshot's `null` is stored in */
-    storesNull: ReadonlySet<string>;
     /** the `featureField` slots, which the reader hands over as written */
     featureFields: ReadonlySet<string>;
     /** the slots that refuse a `jexl:` string: every one but a callback and a featureField */

package/esm/configuration/slotFacade.js

@@ -5,7 +5,7 @@ import { slotWriteRefusal } from './configurationSlot.js';
 import { setConf } from './getConf.js';
 import { getConfigurationSchemaDefinition, getConfigurationSchemaMetadata, } from './schemaRegistry.js';
 import { isConfigurationSchemaType, isSlotDefinitionEntry, } from './schemaTypes.js';
-import { preProcessSnapshotWith } from './snapshotPreprocess.js';
+import { preProcessSnapshotWith, refusingUndeclaredKeys, } from './snapshotPreprocess.js';
 /**
  * The slot's metadata entry, or undefined when `slotName` names a nested
  * sub-schema or a string/number constant rather than a slot.
@@ -42,7 +42,7 @@ export function slotValueRefusal(schema, key, value) {
     try {
         const lifted = preProcessSnapshotWith(meta, { [key]: value })[key];
         if (subSchema) {
-            subSchema.create(lifted);
+            refusingUndeclaredKeys(() => subSchema.create(lifted));
         }
         else if (isSlotDefinitionEntry(entry) && !slotType?.is(lifted)) {
             return slotWriteRefusal(`${meta.name}.${key}`, entry.type, value);

package/esm/configuration/snapshotPreprocess.d.ts

@@ -2,42 +2,66 @@ import type { RetiredSpelling } from './configurationSchema.ts';
 import type { ConfigurationSchemaMetadata } from './schemaRegistry.ts';
 import type { IAnyType } from '@jbrowse/mobx-state-tree';
 export declare function listed(keys: readonly string[]): string;
+/**
+ * #api core/configuration
+ * Runs `write` as a write: a `closed` schema created inside it refuses a key
+ * it does not declare, at any depth, where a config loading only names the
+ * key on the console. `setConf`, a settings bag and a plot draft write this
+ * way, so a typo in an edit is an error and a config written for another
+ * version still draws.
+ */
+export declare function refusingUndeclaredKeys<T>(write: () => T): T;
 /**
  * The snapshot with each spelling `retired` names rewritten: a lift's members
  * take the old key's place, and what the snapshot already spells wins, member
  * by member inside an object, since writing the current name is the stronger
  * statement — so a retired flag lifting into `scales.y` lands beside a
  * `scales.y` the snapshot writes. The old key goes whether or not it carried a
- * value, so a `closed` schema never meets it. Where two retired names lift
- * onto one member — a slot the entry spelt directly and the same slot inside a
- * retired `renderer` — the one declared first wins.
+ * value, so a `closed` schema never meets it, and a member a lift produces
+ * that no slot takes goes with it: a v4 `renderer` block carried settings
+ * the display has no slot for, and they were dropped then too. Where two
+ * retired names lift onto one member — a slot the entry spelt directly and
+ * the same slot inside a retired `renderer` — the one declared first wins.
+ * A retired name the schema itself declares is that slot, not a spelling,
+ * so a list shared across displays leaves it alone where one still takes it.
  */
 export declare function liftRetiredSpellings(schema: ConfigurationSchemaMetadata, snapshot: Record<string, unknown>): Record<string, unknown>;
 /**
- * `liftRetiredSpellings` over a map directly, for a schema whose own
- * `preProcessSnapshot` uncovers a retired name the pass above could not see —
- * one that arrives out of a legacy sub-config rather than off the entry.
+ * `liftRetiredSpellings` over a map directly, for a lift that uncovers a
+ * retired name one level down, as a v4 `renderer` block carries a `color1`.
  * Applying the same map twice costs nothing, since a lift deletes the name it
- * reads.
+ * reads. `takes` says which lifted members land; every one does unless given.
  */
-export declare function applyRetiredSpellings(retired: Record<string, RetiredSpelling>, snapshot: Record<string, unknown>): Record<string, unknown>;
+export declare function applyRetiredSpellings(retired: Record<string, RetiredSpelling>, snapshot: Record<string, unknown>, takes?: (name: string) => boolean): Record<string, unknown>;
 /**
  * What a schema does to every snapshot on its way in, whichever door it
  * arrives by (`create`, `applySnapshot`, `setSubschema`, a settings bag): a
  * bare string or number lifts into the `shorthand` slot taking its form, beside any
  * `shorthandWith` slots, and `null` into the empty object that clears it; a
- * `null` member reads as unset, except in a frozen-family slot, which stores
- * it; a `retired` spelling becomes the members that replaced it; a `closed`
- * schema refuses a key it does not declare, then the schema's
- * own `preProcessSnapshot` runs, and a `jexl:` callback in a slot declaring no
- * `contextVariable` is refused. A bare value the shorthand does not lift
- * passes through for MST to refuse.
+ * `null` member reads as unset; a `retired` spelling becomes the members that
+ * replaced it; the schema's own `preProcessSnapshot` runs, which is where a
+ * track folds `displayDefaults` into its displays; then a `closed` schema
+ * names a key it does not declare on the console, or refuses it inside
+ * `refusingUndeclaredKeys`, unless the caller is a settings bag that routes
+ * an undeclared key itself (`routesUndeclared`); it refuses a bare value no
+ * shorthand lifted on every door, and so is a `jexl:` callback in a slot
+ * declaring no `contextVariable`.
+ */
+export declare function preProcessSnapshotWith(schema: ConfigurationSchemaMetadata, snapshot: unknown, { routesUndeclared }?: {
+    routesUndeclared?: boolean | undefined;
+}): Record<string, unknown>;
+/**
+ * #api core/configuration
+ * A snapshot as `type` lifts it, without the keys it does not declare: the
+ * config half of an entry that carries its owner's keys beside one, as a
+ * `MultiWiggleAdapter` subadapter carries its row's `name` and `color`.
  */
-export declare function preProcessSnapshotWith(schema: ConfigurationSchemaMetadata, snapshot: unknown): Record<string, unknown>;
+export declare function declaredSnapshot(type: IAnyType, snapshot: Record<string, unknown>): Record<string, unknown>;
 /**
  * #api core/configuration
- * A snapshot as `type` admits it: the same lift and checks `type.create`
- * applies, so a dialog or a validator refuses exactly what a config file
- * cannot hold. Throws what the schema's `preProcessSnapshot` throws.
+ * A snapshot as a write to `type` admits it: the lift and checks `setConf`
+ * applies, so a dialog or a validator refuses what an edit cannot hold, an
+ * undeclared key included. Throws what the schema's `preProcessSnapshot`
+ * throws.
  */
 export declare function preProcessConfigSnapshot(type: IAnyType, snapshot: unknown): Record<string, unknown>;

package/esm/configuration/snapshotPreprocess.js

@@ -11,18 +11,51 @@ export function listed(keys) {
         ? `${keys.slice(0, -1).join(', ')} and ${keys.at(-1)}`
         : (keys[0] ?? 'nothing');
 }
-function refuseUndeclaredKeys({ name, definition, options }, snapshot) {
+function declaredKeys({ definition, options }) {
     const id = options.explicitIdentifier;
-    const declared = [
+    return [
         ...Object.keys(definition).filter(key => !isConstantEntry(definition[key])),
         ...(options.explicitlyTyped ? ['type'] : []),
         ...(id ? [id] : []),
     ];
-    const unknown = typeof snapshot === 'string'
+}
+const warned = new Set();
+let writes = 0;
+/**
+ * #api core/configuration
+ * Runs `write` as a write: a `closed` schema created inside it refuses a key
+ * it does not declare, at any depth, where a config loading only names the
+ * key on the console. `setConf`, a settings bag and a plot draft write this
+ * way, so a typo in an edit is an error and a config written for another
+ * version still draws.
+ */
+export function refusingUndeclaredKeys(write) {
+    writes++;
+    try {
+        return write();
+    }
+    finally {
+        writes--;
+    }
+}
+function checkUndeclaredKeys(schema, snapshot) {
+    const { name, options } = schema;
+    const declared = declaredKeys(schema);
+    const bare = snapshot !== undefined &&
+        (typeof snapshot !== 'object' || Array.isArray(snapshot));
+    const unknown = bare
         ? [JSON.stringify(snapshot)]
         : Object.keys(snapshot ?? {}).filter(key => !declared.includes(key) && !COMMENT_KEY.test(key));
     if (unknown.length > 0) {
-        throw new Error(`${name} takes ${listed(declared)}, not ${unknown.join(', ')}`);
+        if (bare || writes > 0) {
+            throw new Error(`${name} takes ${listed(declared)}, not ${unknown.join(', ')}`);
+        }
+        const key = `${name} ${unknown.toSorted().join(' ')}`;
+        if (!warned.has(key)) {
+            warned.add(key);
+            const id = snapshot[options.explicitIdentifier ?? ''];
+            console.warn(`${name}${typeof id === 'string' ? ` "${id}"` : ''} does not declare ${listed(unknown)}: loading without it`);
+        }
     }
 }
 // Checked here as well as by each slot's MST type because this runs on every
@@ -39,11 +72,13 @@ function refuseCallbacks({ name, takesNoCallback }, snapshot) {
     }
 }
 // ADR-146's reset, on the snapshot path: the member keeps its key, so a
-// settings bag still resets it, and `create` reads `undefined` as the default
-function nullMembersAsUnset(snapshot, storesNull) {
+// settings bag still resets it, and `create` reads `undefined` as the default.
+// A frozen slot resets too, since its readers take the default's shape and
+// `setSlot` already resets it; storing the null put one past them.
+function nullMembersAsUnset(snapshot) {
     let out = snapshot;
     for (const key in snapshot) {
-        if (snapshot[key] === null && !storesNull.has(key)) {
+        if (snapshot[key] === null) {
             out = out === snapshot ? { ...snapshot } : out;
             out[key] = undefined;
         }
@@ -82,24 +117,30 @@ function underWritten(written, lifted) {
  * by member inside an object, since writing the current name is the stronger
  * statement — so a retired flag lifting into `scales.y` lands beside a
  * `scales.y` the snapshot writes. The old key goes whether or not it carried a
- * value, so a `closed` schema never meets it. Where two retired names lift
- * onto one member — a slot the entry spelt directly and the same slot inside a
- * retired `renderer` — the one declared first wins.
+ * value, so a `closed` schema never meets it, and a member a lift produces
+ * that no slot takes goes with it: a v4 `renderer` block carried settings
+ * the display has no slot for, and they were dropped then too. Where two
+ * retired names lift onto one member — a slot the entry spelt directly and
+ * the same slot inside a retired `renderer` — the one declared first wins.
+ * A retired name the schema itself declares is that slot, not a spelling,
+ * so a list shared across displays leaves it alone where one still takes it.
  */
 export function liftRetiredSpellings(schema, snapshot) {
     const { retired } = schema.options;
-    return retired && isOwnSnapshot(schema, snapshot)
-        ? applyRetiredSpellings(retired, snapshot)
-        : snapshot;
+    if (!retired || !isOwnSnapshot(schema, snapshot)) {
+        return snapshot;
+    }
+    const declared = new Set(declaredKeys(schema));
+    const spellings = Object.fromEntries(Object.entries(retired).filter(([name]) => !declared.has(name)));
+    return applyRetiredSpellings(spellings, snapshot, name => declared.has(name));
 }
 /**
- * `liftRetiredSpellings` over a map directly, for a schema whose own
- * `preProcessSnapshot` uncovers a retired name the pass above could not see —
- * one that arrives out of a legacy sub-config rather than off the entry.
+ * `liftRetiredSpellings` over a map directly, for a lift that uncovers a
+ * retired name one level down, as a v4 `renderer` block carries a `color1`.
  * Applying the same map twice costs nothing, since a lift deletes the name it
- * reads.
+ * reads. `takes` says which lifted members land; every one does unless given.
  */
-export function applyRetiredSpellings(retired, snapshot) {
+export function applyRetiredSpellings(retired, snapshot, takes = () => true) {
     const present = Object.keys(retired).filter(key => key in snapshot);
     if (present.length === 0) {
         return snapshot;
@@ -111,7 +152,9 @@ export function applyRetiredSpellings(retired, snapshot) {
     for (const key of present.filter(key => snapshot[key] !== undefined)) {
         const lifted = retired[key](snapshot[key]);
         for (const [name, value] of Object.entries(lifted)) {
-            out[name] = underWritten(out[name], value);
+            if (takes(name)) {
+                out[name] = underWritten(out[name], value);
+            }
         }
     }
     return out;
@@ -121,14 +164,16 @@ export function applyRetiredSpellings(retired, snapshot) {
  * arrives by (`create`, `applySnapshot`, `setSubschema`, a settings bag): a
  * bare string or number lifts into the `shorthand` slot taking its form, beside any
  * `shorthandWith` slots, and `null` into the empty object that clears it; a
- * `null` member reads as unset, except in a frozen-family slot, which stores
- * it; a `retired` spelling becomes the members that replaced it; a `closed`
- * schema refuses a key it does not declare, then the schema's
- * own `preProcessSnapshot` runs, and a `jexl:` callback in a slot declaring no
- * `contextVariable` is refused. A bare value the shorthand does not lift
- * passes through for MST to refuse.
+ * `null` member reads as unset; a `retired` spelling becomes the members that
+ * replaced it; the schema's own `preProcessSnapshot` runs, which is where a
+ * track folds `displayDefaults` into its displays; then a `closed` schema
+ * names a key it does not declare on the console, or refuses it inside
+ * `refusingUndeclaredKeys`, unless the caller is a settings bag that routes
+ * an undeclared key itself (`routesUndeclared`); it refuses a bare value no
+ * shorthand lifted on every door, and so is a `jexl:` callback in a slot
+ * declaring no `contextVariable`.
  */
-export function preProcessSnapshotWith(schema, snapshot) {
+export function preProcessSnapshotWith(schema, snapshot, { routesUndeclared = false } = {}) {
     const { shorthandWith, closed, preProcessSnapshot } = schema.options;
     const form = bareFormOf(snapshot);
     const target = form && shorthandTargets(schema)[form];
@@ -136,24 +181,39 @@ export function preProcessSnapshotWith(schema, snapshot) {
         ? {}
         : target !== undefined
             ? { ...shorthandWith, [target]: snapshot }
-            : nullMembersAsUnset(snapshot, schema.storesNull);
+            : nullMembersAsUnset(snapshot);
     const named = liftRetiredSpellings(schema, lifted);
-    if (closed) {
-        refuseUndeclaredKeys(schema, named);
-    }
     const processed = preProcessSnapshot ? preProcessSnapshot(named) : named;
+    if (closed && !routesUndeclared && isOwnSnapshot(schema, processed)) {
+        checkUndeclaredKeys(schema, processed);
+    }
     refuseCallbacks(schema, processed);
     return processed;
 }
 /**
  * #api core/configuration
- * A snapshot as `type` admits it: the same lift and checks `type.create`
- * applies, so a dialog or a validator refuses exactly what a config file
- * cannot hold. Throws what the schema's `preProcessSnapshot` throws.
+ * A snapshot as `type` lifts it, without the keys it does not declare: the
+ * config half of an entry that carries its owner's keys beside one, as a
+ * `MultiWiggleAdapter` subadapter carries its row's `name` and `color`.
+ */
+export function declaredSnapshot(type, snapshot) {
+    const schema = getConfigurationSchemaMetadata(type);
+    if (!schema) {
+        return snapshot;
+    }
+    const declared = new Set(declaredKeys(schema));
+    return Object.fromEntries(Object.entries(preProcessSnapshotWith(schema, snapshot, { routesUndeclared: true })).filter(([key]) => declared.has(key)));
+}
+/**
+ * #api core/configuration
+ * A snapshot as a write to `type` admits it: the lift and checks `setConf`
+ * applies, so a dialog or a validator refuses what an edit cannot hold, an
+ * undeclared key included. Throws what the schema's `preProcessSnapshot`
+ * throws.
  */
 export function preProcessConfigSnapshot(type, snapshot) {
     const schema = getConfigurationSchemaMetadata(type);
     return schema
-        ? preProcessSnapshotWith(schema, snapshot)
+        ? refusingUndeclaredKeys(() => preProcessSnapshotWith(schema, snapshot))
         : snapshot;
 }

package/esm/configuration/tabixShorthand.js

@@ -63,9 +63,7 @@ export function tabixIndexSnapshot(snap) {
 export function expandTabixShorthand(snap, locationKey) {
     return snap.uri
         ? {
-            ...fillLocations(snap, {
-                [locationKey]: { uri: snap.uri, baseUri: snap.baseUri },
-            }),
+            ...fillLocations(snap, { [locationKey]: { uri: snap.uri, baseUri: snap.baseUri } }, ['csi']),
             index: tabixIndexSnapshot(snap),
         }
         : snap;

package/esm/data_adapters/BaseAdapter/BaseAdapter.d.ts

@@ -19,6 +19,13 @@ export declare class BaseAdapter<CONF extends AnyConfigurationModel = AnyConfigu
     readonly sequenceAdapterConfig?: Record<string, unknown>;
     static capabilities: string[];
     constructor(config?: CONF, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager, sequenceAdapterConfig?: Record<string, unknown>);
+    /**
+     * Called once, when the last session holding this adapter lets go and
+     * dataAdapterCache drops it. An adapter whose library keeps parsed data
+     * clears it here, so the memory and its charge to the shared budget in
+     * cacheBudgets go back now rather than when the collector takes the cache.
+     */
+    freeResources(): void;
     /** shorthand for `readConfObject(this.config, arg)` */
     getConf<const SLOT extends ConfigurationSlotName<ConfigurationSchemaForModel<CONF>> | ConfigurationSlotPath<ConfigurationSchemaForModel<CONF>> = ConfigurationSlotName<ConfigurationSchemaForModel<CONF>>>(arg: SLOT, args?: Record<string, unknown>): SLOT extends string ? ConfigurationSlotValue<ConfigurationSchemaForModel<CONF>, SLOT> : ConfigurationSlotPathValue<ConfigurationSchemaForModel<CONF>, SLOT>;
 }

package/esm/data_adapters/BaseAdapter/BaseAdapter.js

@@ -25,6 +25,13 @@ export class BaseAdapter {
         this.sequenceAdapterConfig = sequenceAdapterConfig;
         this.id = getAdapterId(config);
     }
+    /**
+     * Called once, when the last session holding this adapter lets go and
+     * dataAdapterCache drops it. An adapter whose library keeps parsed data
+     * clears it here, so the memory and its charge to the shared budget in
+     * cacheBudgets go back now rather than when the collector takes the cache.
+     */
+    freeResources() { }
     /** shorthand for `readConfObject(this.config, arg)` */
     getConf(arg, args) {
         return readConfObject(this.config, arg, args);

package/esm/data_adapters/BaseAdapter/BaseFeatureDataAdapter.d.ts

@@ -3,7 +3,6 @@ import type { AnyConfigurationModel } from '../../configuration/index.ts';
 import type { FeatureTable } from '../../util/featureTable.ts';
 import type { Feature } from '../../util/simpleFeature.ts';
 import type { AugmentedRegion as Region } from '../../util/types/index.ts';
-import type { FeatureDensity } from './featureDensity.ts';
 import type { BaseOptions, ZoomRange } from './types.ts';
 import type { Observable } from 'rxjs';
 /**
@@ -101,16 +100,6 @@ export declare abstract class BaseFeatureDataAdapter<CONF extends AnyConfigurati
      * @returns Whether data source has data for the given reference name
      */
     hasDataForRefName(refName: string, opts?: BaseOptions): Promise<boolean>;
-    /**
-     * Calculates the minimum score, maximum score, and other statistics from
-     * features over a region, primarily used for quantitative tracks
-     */
-    getRegionQuantitativeStats(region: Region, opts?: BaseOptions): Promise<import("../../util/stats.ts").RectifiedQuantitativeStats>;
-    /**
-     * Calculates the minimum score, maximum score, and other statistics from
-     * features over multiple regions, primarily used for quantitative tracks
-     */
-    getMultiRegionQuantitativeStats(regions?: Region[], opts?: BaseOptions): Promise<import("../../util/stats.ts").RectifiedQuantitativeStats>;
     /**
      * Cheap upper bound on the compressed bytes a fetch of `regions` would pull,
      * derived from an index without downloading or parsing any features. The
@@ -144,17 +133,6 @@ export declare abstract class BaseFeatureDataAdapter<CONF extends AnyConfigurati
      * for skew.
      */
     getValueDomain(_opts?: BaseOptions): Promise<[number, number] | undefined>;
-    /**
-     * Features per bin over each region, at the view's `bpPerPx`, for the density
-     * tier the display draws where the region-too-large gate refused the
-     * features. The default reads the `densityAdapter` sidecar slot
-     * (`densityAdapterConfigSchemaFields`) through `getSubAdapter`; `undefined`
-     * means no tier, and the banner stands. ADR-102 records why no index
-     * estimate stands in for a missing sidecar.
-     */
-    getFeatureDensity(regions: Region[], opts: BaseOptions & {
-        bpPerPx: number;
-    }): Promise<FeatureDensity[] | undefined>;
     getSources(regions: Region[], opts?: BaseOptions): Promise<{
         name: string;
         color?: string;

package/esm/data_adapters/BaseAdapter/BaseFeatureDataAdapter.js

@@ -2,11 +2,7 @@ import { firstValueFrom, merge } from 'rxjs';
 import { toArray } from 'rxjs/operators';
 import { asTable } from '../../util/featureTable.js';
 import { createStatusFanOut } from '../../util/progress.js';
-import { blankStats, scoresToStats } from '../../util/stats.js';
 import { BaseAdapter } from './BaseAdapter.js';
-import { isSubAdapterConfig } from './featureDensity.js';
-import { aggregateQuantitativeStats } from './stats.js';
-import { isFeatureAdapter } from './util.js';
 /**
  * Base class for feature adapters to extend. Defines some methods that
  * subclasses must implement.
@@ -83,25 +79,6 @@ export class BaseFeatureDataAdapter extends BaseAdapter {
         const refNames = await this.getRefNames(opts);
         return refNames.includes(refName);
     }
-    /**
-     * Calculates the minimum score, maximum score, and other statistics from
-     * features over a region, primarily used for quantitative tracks
-     */
-    async getRegionQuantitativeStats(region, opts) {
-        const feats = this.getFeatures(region, opts);
-        return scoresToStats(region, feats);
-    }
-    /**
-     * Calculates the minimum score, maximum score, and other statistics from
-     * features over multiple regions, primarily used for quantitative tracks
-     */
-    async getMultiRegionQuantitativeStats(regions = [], opts) {
-        if (!regions.length) {
-            return blankStats();
-        }
-        const stats = await Promise.all(regions.map(region => this.getRegionQuantitativeStats(region, opts)));
-        return aggregateQuantitativeStats(stats);
-    }
     /**
      * Cheap upper bound on the compressed bytes a fetch of `regions` would pull,
      * derived from an index without downloading or parsing any features. The
@@ -141,38 +118,6 @@ export class BaseFeatureDataAdapter extends BaseAdapter {
     async getValueDomain(_opts) {
         return undefined;
     }
-    /**
-     * Features per bin over each region, at the view's `bpPerPx`, for the density
-     * tier the display draws where the region-too-large gate refused the
-     * features. The default reads the `densityAdapter` sidecar slot
-     * (`densityAdapterConfigSchemaFields`) through `getSubAdapter`; `undefined`
-     * means no tier, and the banner stands. ADR-102 records why no index
-     * estimate stands in for a missing sidecar.
-     */
-    async getFeatureDensity(regions, opts) {
-        const sidecar = this.getConf(['densityAdapter']);
-        const resolved = isSubAdapterConfig(sidecar) && this.getSubAdapter
-            ? (await this.getSubAdapter(sidecar)).dataAdapter
-            : undefined;
-        if (resolved && !isFeatureAdapter(resolved)) {
-            throw new Error(`densityAdapter ${isSubAdapterConfig(sidecar) ? sidecar.type : ''} is not a feature adapter`);
-        }
-        return resolved
-            ? Promise.all(regions.map(async (region) => {
-                const features = await resolved.getFeaturesArray(region, opts);
-                const starts = new Uint32Array(features.length);
-                const ends = new Uint32Array(features.length);
-                const scores = new Float32Array(features.length);
-                features.forEach((feature, i) => {
-                    const score = feature.get('score');
-                    starts[i] = feature.get('start');
-                    ends[i] = feature.get('end');
-                    scores[i] = score === undefined ? 0 : score;
-                });
-                return { starts, ends, scores };
-            }))
-            : undefined;
-    }
     async getSources(regions, opts = {}) {
         const features = await this.getFeaturesInMultipleRegionsArray(regions, opts);
         const sources = new Set();

package/esm/data_adapters/BaseAdapter/index.d.ts

@@ -8,7 +8,6 @@ export type { BaseOptions, BaseTextSearchArgs, LodTier, SearchType, ZoomRange, }
 export { BaseAdapter } from './BaseAdapter.ts';
 export { cachedSetup } from '../../util/cachedSetup.ts';
 export { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter.ts';
-export { type FeatureDensity, densityAdapterConfigSchemaFields, isSubAdapterConfig, } from './featureDensity.ts';
 export { BaseSequenceAdapter } from './BaseSequenceAdapter.ts';
 export type { BaseTextSearchAdapter } from './BaseTextSearchAdapter.ts';
 export type { Alias, BaseRefNameAliasAdapter, } from './BaseRefNameAliasAdapter.ts';

package/esm/data_adapters/BaseAdapter/index.js

@@ -2,5 +2,4 @@ export { isFeatureAdapter, isRefNameAliasAdapter, isRegionsAdapter, isSequenceAd
 export { BaseAdapter } from './BaseAdapter.js';
 export { cachedSetup } from '../../util/cachedSetup.js';
 export { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter.js';
-export { densityAdapterConfigSchemaFields, isSubAdapterConfig, } from './featureDensity.js';
 export { BaseSequenceAdapter } from './BaseSequenceAdapter.js';