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

package/esm/configuration/types.d.ts

@@ -5,42 +5,23 @@ import type { BuiltinSlotTypeName } from './configurationSlot.ts';
 import type { IAnyType, IArrayType, IOptionalIType, ISimpleType, IStateTreeNode, Instance, SnapshotOut } from '@jbrowse/mobx-state-tree';
 export type ConfigurationSchemaForModel<MODEL> = IsAny<MODEL> extends true ? AnyConfigurationSchemaType : MODEL extends IStateTreeNode<infer T> ? T extends AnyConfigurationSchemaType ? T : T extends IOptionalIType<infer INNER extends AnyConfigurationSchemaType, any> ? INNER : AnyConfigurationSchemaType : never;
 /**
- * A schema's definition as **stored**: the author's own entries over the ones
- * its `baseConfiguration` contributed, the type-level twin of
- * `mergeSchemaDefinition`. The base arrives already merged with its own base,
- * so one level here covers a chain of any depth.
- *
- * A flat mapped type over the union of both key sets, not
- * `Omit<BASE, keyof D> & D`: an intersection's `keyof` is a union of key sets,
- * and mapping over a union that includes `string` — which
- * `ConfigurationSchemaDefinition`'s index signature contributes — collapses
- * back to an index signature, which is the thing `ConfigNodeProps` exists to
- * get rid of.
+ * A schema's definition over its `baseConfiguration`'s, the type-level twin of
+ * `mergeSchemaDefinition`. A flat mapped type rather than
+ * `Omit<BASE, keyof D> & D`, which states it less clearly. ADR-145.
  */
 export type MergeConfigDef<D, BASE> = BASE extends ConfigurationSchemaType<infer BD, any> ? {
     [K in keyof BD | keyof D]: NormalizeSlotDef<K extends keyof D ? K extends keyof BD ? MergeSlotDef<BD[K], D[K]> : D[K] : K extends keyof BD ? BD[K] : never>;
 } : {
     [K in keyof D]: NormalizeSlotDef<D[K]>;
 };
-/**
- * A redeclared slot merges field-by-field over the base's; a sub-schema or a
- * constant keeps replace semantics, matching `mergeSchemaDefinition`'s
- * `isSlotDefinitionEntry` guard.
- */
 type MergeSlotDef<BASE_ENTRY, ENTRY> = BASE_ENTRY extends {
     type: string;
 } ? ENTRY extends {
     type: string;
 } ? Omit<BASE_ENTRY, keyof ENTRY> & ENTRY : ENTRY : ENTRY;
 /**
- * What the type level reads off a slot definition: the slot's `type`, a
- * `stringEnum`'s `model`, and whether a `defaultValue` is there at all — widened
- * off its literal. The description, `advanced`, `contextVariable` and the
- * literal default are documentation and runtime, and carrying them makes two
- * schemas that differ only in one of them mutually unassignable: a subclass
- * raising `height` from 100 to 250 stopped satisfying a parameter pinned to its
- * base. `SlotValueRawFromDef` re-widens a scalar default anyway, and reaches
- * `any` for everything else, so nothing downstream loses precision.
+ * Only `type`, `model` and a widened `defaultValue`: carrying a description or
+ * a literal default makes a subclass that changes one unassignable to its base.
  */
 type NormalizeSlotDef<E> = E extends AnyConfigurationSchemaType ? E : E extends {
     type: infer T;
@@ -58,106 +39,58 @@ type NormalizeSlotDef<E> = E extends AnyConfigurationSchemaType ? E : E extends
 type WidenDefaultValue<V> = [V] extends [boolean] ? boolean : [V] extends [string] ? string : [V] extends [number] ? number : unknown;
 type ConfigNodeValue<DEF> = IsAny<DEF> extends true ? any : DEF extends AnyConfigurationSchemaType ? DEF['Type'] : DEF extends IArrayType<any> | IOptionalIType<IArrayType<any>, any> ? DEF['Type'] : DEF extends string ? string : DEF extends number ? number : SlotValueRawFromDef<DEF>;
 /**
- * The slots a config node presents, read off the schema's own DEFINITION rather
- * than the `Record<string, any>` `makeConfigurationSchemaModel` assembles its
- * MST props from. Those props carry an index signature, so every
- * `node.anything` resolves to `any`; mapping the definition instead is what
- * makes `node.colorr` a compile error.
- *
- * A plain mapped type, and it has to stay one. Wrapping it in a conditional —
- * to answer early for a widened definition, say — makes TypeScript measure
- * DEFINITION as covariant instead of invariant, and it refuses a failed
- * covariant check on a type argument outright where a failed invariant one
- * falls back to comparing the two schemas structurally. Structural is the
- * comparison that matters: a subclass schema's node has every slot the base's
- * does, while its *definition* restates `defaultValue` and `description` and so
- * matches nothing. The widened case belongs on `AnyConfigurationModel`.
+ * A config node's slots, off the schema's definition, so `node.colorr` is a
+ * compile error (ADR-145). It must stay a plain mapped type: a conditional
+ * wrapper makes TypeScript refuse a subclass schema where the base is expected
+ * instead of comparing the two structurally.
  */
 export type ConfigNodeProps<DEFINITION> = {
     [K in keyof DEFINITION]: ConfigNodeValue<DEFINITION[K]>;
 };
 /**
- * The two write actions every config node carries, which `setConf` is the
- * spelling of. A type alias rather than an interface because it annotates the
- * `.actions` block: MST constrains that to `ModelActions`, an index signature
- * of functions, and only a type alias of an object literal gets the implicit
- * index signature that satisfies it.
+ * The two write actions under `setConf`. An alias, not an interface: only an
+ * alias gets the implicit index signature MST's `ModelActions` requires.
  */
 export type ConfigNodeActions = {
     setSubschema: (slotName: string, data: unknown) => unknown;
     setSlot: (slotName: string, value: unknown) => void;
 };
 /**
- * MST's node brand, restated. A config node carries its own schema here by
- * polymorphic `this`, and `ConfigurationSchemaForModel` walks it back out —
- * which is what every `getConf` / `readConfObject` / `setConf` slot-name
- * constraint hangs off, so losing it switches the read-side check off with no
- * error anywhere. `scripts/audit-config-read-types.ts` is the only thing that
- * reports that; run it after touching this.
- *
- * Structurally identical to `IStateTreeNode<IT>`, but an alias rather than an
- * interface: TypeScript infers an implicit index signature for an intersection
- * only when every constituent is an alias or a mapped type, and that is what
- * leaves a concrete config node — whose props are a mapped type with no index
- * signature of its own — assignable to `AnyConfigurationModel`.
+ * MST's node brand restated as an alias, which keeps a concrete node assignable
+ * to `AnyConfigurationModel`. It carries the schema by polymorphic `this`, and
+ * every slot-name check hangs off `ConfigurationSchemaForModel` walking it back
+ * out: run `scripts/audit-config-read-types.ts` after touching it.
  */
 export type ConfigNodeBrand<IT extends IAnyType> = {
     readonly $treenode?: any;
     readonly $__mstStateTreeNodeType__?: [IT] | [any];
 };
 /**
- * The identifier a schema's `explicitIdentifier` installs, folded into the
- * definition as if it were a declared string slot — which is what it is at
- * runtime, `makeConfigurationSchemaModel` just builds it from the options rather
- * than from the table. Folding it in rather than intersecting it onto `Type`
- * keeps it out of `ConfigurationSchemaType`'s parameter list: as a parameter it
- * reads as invariant (it lands in a `Record<K, …>` key position), which stops a
- * concrete schema widening to `AnyConfigurationSchemaType`. Inheritance comes
- * free, since `MergeConfigDef` already folds the base's whole definition in.
+ * The `explicitIdentifier` prop, folded into the definition as a string slot
+ * rather than a type parameter, which would read as invariant and stop a
+ * concrete schema widening to `AnyConfigurationSchemaType`.
  */
 export interface IdentifierSlotDef {
     type: 'string';
     defaultValue: '';
 }
-/**
- * The `type` prop an `explicitlyTyped` schema installs, folded into the
- * definition the same way and for the same reasons. Separate from
- * `IdentifierSlotDef` despite the identical shape, because the runtime prop is
- * `types.literal(modelName)` and this is where that would be said if the model
- * name ever became a type parameter.
- */
+/** An `explicitlyTyped` schema's `type` prop, folded in the same way. */
 export interface TypeSlotDef {
     type: 'string';
     defaultValue: '';
 }
 export type ConfigurationSlotName<SCHEMA> = IsAny<SCHEMA> extends true ? string : SCHEMA extends ConfigurationSchemaType<infer D, any> ? keyof D & string : never;
 /**
- * The names a config snapshot for `SCHEMA` may use — its own slots, its
- * sub-schemas recursively, its identifier and everything it inherits — with
- * every value left `unknown`.
- *
- * Names are the whole point of it. A slot value can be its own type, a `jexl:`
- * callback string, or (for a `maybe*` slot) absent, and nothing here tries to
- * check that; a *name* the schema does not declare is dropped on the way in
- * without a word, so `preferance` is a setting that reads as applied and never
- * applies. Against an object literal — which is how an embedder writes one —
- * TypeScript's excess-property check turns that into a compile error.
+ * The names a config snapshot for `SCHEMA` may use, sub-schemas included, with
+ * every value `unknown`. MST drops an undeclared name silently; against an
+ * object literal, the excess-property check makes it a compile error.
  */
 export type ConfigurationSnapshot<SCHEMA> = SCHEMA extends undefined ? never : SCHEMA extends ConfigurationSchemaType<infer D, any> ? {
     [K in keyof D]?: D[K] extends ConfigurationSchemaType<any, any> ? ConfigurationSnapshot<D[K]> : unknown;
 } : unknown;
 /**
- * The value each builtin slot `type` reads as — the type-level twin of
- * `slotTypes` in `configurationSlot.ts`, which is the same list as MST models.
- * A table rather than the fourteen-deep conditional staircase this used to be:
- * adding a slot type is now one row here and one there, and the two tables sit
- * side by side where a name present in one and missing from the other is
- * visible. Missing a row is not silent either — it drops the slot to the
- * `defaultValue` fallback below, which is what `SlotValueRawFromDef` documents.
- *
- * `stringEnum`/`maybeStringEnum` are deliberately absent: their value type comes
- * from the author's own `types.enumeration`, read off `model` before this table
- * is consulted.
+ * What each builtin slot type reads as, beside `slotTypes` in
+ * `configurationSlot.ts`. The enum types read their members off `model`.
  */
 interface SlotValueByType {
     stringArray: string[];
@@ -171,15 +104,7 @@ interface SlotValueByType {
     maybeBoolean: boolean | undefined;
     maybeColor: string | undefined;
     maybeString: string | undefined;
-    /**
-     * `frozen` and its `maybe*` form are `any` deliberately — arbitrary dynamic
-     * JSON whose shape the caller asserts at the read boundary. `unknown` would
-     * only add cast ceremony on values that are legitimately dynamic.
-     *
-     * Stated here rather than left to the `defaultValue` fallback, which reaches
-     * `any` for these only by accident: no `frozen` slot in the repo happens to
-     * default to a scalar.
-     */
+    /** arbitrary JSON, whose shape the caller asserts where it reads it */
     frozen: any;
     maybeFrozen: any;
     number: number;
@@ -191,19 +116,6 @@ interface SlotValueByType {
     color: string;
     colorArray: string[];
 }
-/**
- * The two tables name the same builtin slot types, checked rather than
- * remembered.
- *
- * A row present in one and missing from the other is otherwise **not** an
- * error: the slot drops through to `SlotValueRawFromDef`'s `defaultValue`
- * fallback, which re-widens a scalar default but reaches `any` for everything
- * else — so a new `stringArray`-shaped type would silently read as `any` at
- * every call site. The "every builtin slot type reads as its declared value
- * type" case in `configTypeNarrowing.test.ts` lists the rows by hand, so it
- * only catches the drift if whoever adds the type also edits the test; this
- * catches it either way.
- */
 type MutuallyExtends<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
 type Assert<T extends true> = T;
 export type SlotValueTableCoversBuiltinSlotTypes = Assert<MutuallyExtends<BuiltinSlotTypeName, keyof SlotValueByType>>;
@@ -225,14 +137,10 @@ type SubSchemaSlotPath<SCHEMA> = SCHEMA extends ConfigurationSchemaType<infer D,
     } ? readonly [K, ...string[]] : never;
 }[keyof D & string] : readonly string[];
 /**
- * The array paths a read may take into `SCHEMA`. Past one segment each is
- * checked: a sub-schema's name, then one of its slot names or a deeper path. A
- * head naming something other than a sub-schema — a pluggable adapter union, an
- * array or map of sub-schemas, a `frozen` slot — keeps an unchecked tail, and a
- * widened schema admits any `string[]`.
- *
- * A one-segment path stays unchecked: it is how a generic class body, where
- * `SCHEMA` is unresolved, reads a slot at all (`FastaAdapterBase`).
+ * The array paths a read may take into `SCHEMA`, checked segment by segment
+ * through sub-schemas. A pluggable union, a collection or a `frozen` slot keeps
+ * an unchecked tail. A one-segment path stays unchecked, since a generic class
+ * body with `SCHEMA` unresolved reads a slot that way (`FastaAdapterBase`).
  */
 export type ConfigurationSlotPath<SCHEMA> = readonly [] | readonly [string] | SubSchemaSlotPath<SCHEMA>;
 /** what a read of `PATH` into `SCHEMA` yields */
@@ -243,17 +151,8 @@ export type ConfigurationSlotPathValue<SCHEMA, PATH> = PATH extends readonly [
 /** what a raw read (`getConf` / `readConfObject`) of this slot yields */
 export type ConfigurationSlotValue<SCHEMA, K extends string> = SCHEMA extends ConfigurationSchemaType<infer D, any> ? K extends keyof D ? SlotValueRawFromDef<D[K]> : any : any;
 /**
- * Naming convention for config types, paired per schema:
- * - `XConfigSchema` is the MST IType (the schema itself). Use it for
- *   `getConf`, `ConfigurationReference`, and factory params — anywhere a schema
- *   is expected.
- * - `XConfigModel` is `Instance<XConfigSchema>` (a resolved config node). Use it
- *   for `readConfObject` results, model fields, and values read off a session.
- *
- * Prefer a named `XConfigModel` alias over inlining `Instance<XConfigSchema>` at
- * call sites. Two historical names predate this convention and stay as-is:
- * `BaseTrackConfig` (the track instance type) and `AnyConfiguration` (a
- * model-or-snapshot union, not a plain instance).
+ * Naming: `XConfigSchema` is the schema (an MST type), for factory params and
+ * `ConfigurationReference`; `XConfigModel` is `Instance<XConfigSchema>`, a node.
  */
 export type AnyConfigurationSchemaType = ConfigurationSchemaType<any, any>;
 export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType> & Record<string, any>;
@@ -266,22 +165,11 @@ export interface PluggableConfigNode extends AnyConfigurationModel {
     type: string;
 }
 /**
- * The `XConfigModel` for a **field table** — a `*ConfigSchemaFields` export —
- * rather than for a whole assembled schema. What it is for is the cast a
- * cross-cutting mixin uses to reach the `configuration` its composing display
- * supplies but its own `self` cannot see: cast to `AnyConfigurationModel` there
- * and `getConf`/`setConf` derive their slot-name constraint from a schema
- * widened to `any`, so every name typechecks and a misspelled *read* returns
- * `undefined` with no diagnostic at any layer. Name the mixin's own field table
- * instead and the check comes back, scoped to exactly the slots that mixin owns.
- *
- * `BASE` is for the mixin that also reads a slot off the schema its displays
- * inherit from — `ConfigurationSlotName` walks the base chain, so passing it
- * admits those names too and nothing else (`HeightModeMixin` and `height`).
- *
- * The pairing this depends on is a mixin and its field table living together:
- * `RowHeightMixin` + `rowHeightConfigSchemaFields` is the worked example, and
- * `packages/tree-sidebar/CLAUDE.md` has the reasoning.
+ * The node type for a mixin's field table (a `*ConfigSchemaFields` export), for
+ * the cast a mixin uses to reach its host's `configuration`. A cast to
+ * `AnyConfigurationModel` there checks no slot name, so a misspelled read
+ * returns `undefined` silently. `BASE` admits the slots of the schema the
+ * mixin's displays inherit (`HeightModeMixin`'s `height`).
  */
 export type ConfigModelForFields<FIELDS extends ConfigurationSchemaDefinition, BASE extends AnyConfigurationSchemaType | undefined = undefined> = Instance<ConfigurationSchemaType<MergeConfigDef<FIELDS, BASE>, ConfigurationSchemaOptions<BASE, undefined>>>;
 /**
@@ -292,11 +180,8 @@ export type ConfigModelForFields<FIELDS extends ConfigurationSchemaDefinition, B
  * const pin: HostChecksSlotNames<HeightModeHost> = true
  * ```
  *
- * Worth a named type because the widened form has **no symptom** — a mixin host
- * cast to `AnyConfigurationModel` compiles and runs and checks nothing. Every
- * misspelled slot name below it typechecks, and a misspelled *read* returns
- * `undefined` with no diagnostic at any layer, so only a sabotage or this
- * assertion tells the two apart.
+ * The widened form has no symptom: a host cast to `AnyConfigurationModel`
+ * compiles, runs and checks nothing.
  */
 export type HostChecksSlotNames<HOST extends {
     configuration: AnyConfigurationModel;
@@ -305,12 +190,28 @@ export type HostChecksSlotNames<HOST extends {
 export type AnyConfigurationSnapshot = SnapshotOut<AnyConfigurationModel>;
 /**
  * A value readable as configuration: either a live configuration model or a
- * plain snapshot of one. `session.tracks` holds plain base or merged configs
- * that hydrate to MST only on first reference access, `getTrackById` also
- * answers live assembly-sequence and connection nodes, and `readConfObject`
- * reads both — so this is the honest type at those boundaries. Reserve
- * `AnyConfigurationModel` for values that must be live (actions, identity,
- * reference resolution).
+ * plain snapshot of one, such as a config a caller hands to an add action.
+ * Reserve `AnyConfigurationModel` for values that must be live (actions,
+ * identity, reference resolution).
  */
 export type AnyConfiguration = AnyConfigurationModel | AnyConfigurationSnapshot;
+/**
+ * A track config as `jbrowse.tracks` and `session.tracks` hold it: a frozen
+ * plain object, which hydrates to a config node only when a track reads its
+ * `configuration`. It holds what was written, so a slot at its default is
+ * absent. `readConfObject` refuses one for that reason; read `trackId` and
+ * `type` off it directly, and a slot through a helper that supplies the
+ * default, such as `getConfAssemblyNamesOrNone`.
+ */
+export interface TrackConfigEntry {
+    trackId: string;
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * What `getTrackById` answers: a {@link TrackConfigEntry}, or a live node for
+ * an assembly's sequence track or a track a connection holds. A raw member
+ * read works on both, and finds a slot at its default only on the node.
+ */
+export type AnyTrackConfig = TrackConfigEntry | AnyConfigurationModel;
 export {};

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';

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

@@ -2,7 +2,7 @@ import type { BaseOptions } from './types.ts';
 /**
  * #api
  * One row an adapter lists: `name` is a value of the listing's field, and
- * `label` and `color` are what the adapter names and colours that row with.
+ * `label` and `color` are what the adapter names and colors that row with.
  */
 export interface ListedRowSource {
     name: string;
@@ -13,7 +13,7 @@ export interface ListedRowSource {
  * #api
  * Every row an adapter has, in its own order, whatever the loaded regions hold,
  * so a row display gives a row with nothing in view its place, label and
- * colour.
+ * color.
  */
 export interface RowSourceListing {
     /** The feature field the listed names are values of: `source` on a multi-BigWig, `alignments` on a MAF, whose per-species record is keyed by them. */

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

@@ -7,6 +7,7 @@ export interface BaseOptions {
     sessionId?: string;
     statusCallback?: StatusCallback;
     notices?: string[];
+    facts?: Record<string, unknown>;
     headers?: Record<string, string>;
     assemblyName?: string;
     lodMode?: LodTier;

package/esm/data_adapters/CytobandAdapter/configSchema.d.ts

@@ -1,5 +1,7 @@
 /**
  * #config CytobandAdapter
+ * Reads an assembly's cytoband file, which the linear genome view draws as
+ * ideogram banding in its overview bar.
  *
  * #example
  * Goes on an ASSEMBLY, under `cytobands` — not on a track. It draws the

package/esm/data_adapters/CytobandAdapter/configSchema.js

@@ -1,6 +1,8 @@
 import { ConfigurationSchema, expandUriShorthand, } from '../../configuration/index.js';
 /**
  * #config CytobandAdapter
+ * Reads an assembly's cytoband file, which the linear genome view draws as
+ * ideogram banding in its overview bar.
  *
  * #example
  * Goes on an ASSEMBLY, under `cytobands` — not on a track. It draws the
@@ -37,6 +39,9 @@ const configSchema = ConfigurationSchema('CytobandAdapter', {
     },
 }, {
     explicitlyTyped: true,
+    closed: true,
+    // desktop's open-sequence dialog wrote the plural through v4.3
+    retired: { cytobandsLocation: cytobandLocation => ({ cytobandLocation }) },
     /**
      * #preProcessSnapshot
      *

package/esm/data_adapters/dataAdapterCache.d.ts

@@ -38,20 +38,19 @@ export type getSubAdapterType = (adapterConfigSnap: ConfigSnap) => ReturnType<ty
  * other session still claims. Reached from the CoreFreeResources RPC when the
  * last track using an adapter config closes.
  *
- * Deleting the key is the whole reclamation: the cache is the only strong
- * reference to an adapter, so once it goes the instance and everything it holds
- * — a whole parsed GFF3, a BAM chunk cache — become unreachable and are
- * collected normally. There is nothing to free by hand.
+ * Deleting the key makes the instance unreachable from here, and for most
+ * adapters that is the whole reclamation: a parsed GFF3 goes with it.
  *
- * "Collected normally" is not the same as "collected now", and for the indexed
- * adapters it is not even soon. @gmod/bam, @gmod/cram and @gmod/tabix each hold
- * their parsed chunks in a SharedReadCache that sweeps itself on a setInterval,
- * and a pending timer is a GC root — so the instance stays reachable through its
- * own sweep timer until that sweep empties the cache and stops itself, three
- * minutes later. Measured: closing a panned alignments track reclaims nothing at
- * the time it happens, and the worker falls from 296 MB to 7 MB four minutes on.
- * Deleting the key is still the only thing to do here; just don't read a heap
- * immediately after a close and conclude this did nothing.
+ * The indexed adapters are the exception, which is why an evicted adapter is
+ * also told so (`freeResources`). @gmod/bam, @gmod/cram and @gmod/tabix each
+ * hold their parsed chunks in a SharedReadCache charged to the shared budget,
+ * and the budget credits a dropped cache back only once the collector has
+ * taken it. A run that opens and closes a track per image has no GC to wait
+ * for. `jb2export batch` drew a callset from CRAM slices of long reads at
+ * about a record every two seconds, and before @gmod/shared-read-cache 2.1 two
+ * of its four processes reached the 4 GB heap limit 135 s in, with the budget
+ * at 3,100 MB against its 1,024 MB limit: the budget left each of 54 caches
+ * its last entry. 2.1 keeps one entry per budget instead.
  *
  * The refcount is what makes this safe to call on any track close: an adapter
  * pulled in as a sub-adapter carries its parent's sessionId (getSubAdapter
@@ -61,5 +60,18 @@ export type getSubAdapterType = (adapterConfigSnap: ConfigSnap) => ReturnType<ty
 export declare function freeAdapterResources(args: {
     sessionId?: string;
 }): Promise<void>;
+/** How many adapter requests the cache has answered. */
+export declare function adapterRequests(): number;
+/**
+ * Evict every cached adapter `keep` declines, each told to free what it holds,
+ * whatever sessions claim it. `keep` sees the settled adapters most recently
+ * requested first, each with the {@link adapterRequests} count at its latest
+ * request. For a host with no tracks to close, such as `@jbrowse/tables`,
+ * which would otherwise keep an adapter, its parsed index and its share of the
+ * decoded-bytes budget for every file it ever read.
+ */
+export declare function keepAdapters(keep: (dataAdapter: AnyDataAdapter, lastRequest: number) => boolean): Promise<void>;
+/** How many adapters the cache holds, failed and pending ones included. */
+export declare function cachedAdapterCount(): number;
 export declare function clearAdapterCache(): void;
 export {};