@jbrowse/core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/configuration/types.d.ts

@@ -1,22 +1,136 @@
 import type { FileLocation } from '../util/types/index.ts';
+import type { IsAny } from '../util/types/isAny.ts';
 import type { ConfigurationSchemaDefinition, ConfigurationSchemaOptions, ConfigurationSchemaType } from './configurationSchema.ts';
 import type { BuiltinSlotTypeName } from './configurationSlot.ts';
-import type { ISimpleType, IStateTreeNode, Instance, SnapshotOut } from '@jbrowse/mobx-state-tree';
-export type GetOptions<SCHEMA> = SCHEMA extends ConfigurationSchemaType<any, infer OPTIONS> ? OPTIONS : never;
-export type GetBase<SCHEMA> = SCHEMA extends undefined ? never : GetOptions<SCHEMA> extends ConfigurationSchemaOptions<undefined, any> ? undefined : GetOptions<SCHEMA> extends ConfigurationSchemaOptions<infer BASE extends AnyConfigurationSchemaType, any> ? BASE : never;
-export type GetExplicitIdentifier<SCHEMA> = GetOptions<SCHEMA> extends ConfigurationSchemaOptions<any, infer EXPLICIT_IDENTIFIER extends string> ? EXPLICIT_IDENTIFIER : never;
-/**
- * The identifier prop a schema declares **or inherits** — `trackId`,
- * `displayId`, or whatever `explicitIdentifier` names. Recursive because most
- * display schemas never declare it themselves: they pick up `displayId` from
- * `baseConfiguration: baseLinearDisplayConfigSchema`, whose options
- * `preprocessConfigurationSchemaArguments` merges in at runtime, leaving the
- * subclass's own `EXPLICIT_IDENTIFIER` param `undefined`. Same walk
- * `ConfigurationSlotName` does for inherited slot names.
- */
-export type GetInheritedIdentifier<SCHEMA> = SCHEMA extends undefined ? never : SCHEMA extends ConfigurationSchemaType<any, any> ? GetExplicitIdentifier<SCHEMA> | (GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? GetInheritedIdentifier<GetBase<SCHEMA>> : never) : never;
+import type { IAnyType, IArrayType, ISimpleType, IStateTreeNode, Instance, SnapshotOut } from '@jbrowse/mobx-state-tree';
 export type ConfigurationSchemaForModel<MODEL> = MODEL extends IStateTreeNode<infer SCHEMA extends AnyConfigurationSchemaType> ? SCHEMA : never;
-export type ConfigurationSlotName<SCHEMA> = SCHEMA extends undefined ? never : SCHEMA extends ConfigurationSchemaType<infer D, any> ? (keyof D & string) | GetExplicitIdentifier<SCHEMA> | (GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSlotName<GetBase<SCHEMA>> : never) : 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.
+ */
+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.
+ */
+type NormalizeSlotDef<E> = E extends AnyConfigurationSchemaType ? E : E extends {
+    type: infer T;
+} ? {
+    type: T;
+} & (E extends {
+    model: infer M;
+} ? {
+    model: M;
+} : unknown) & (E extends {
+    defaultValue: infer V;
+} ? {
+    defaultValue: WidenDefaultValue<V>;
+} : unknown) : E;
+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> ? 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`.
+ */
+export type ConfigNodeProps<DEFINITION> = {
+    [K in keyof DEFINITION]: ConfigNodeValue<DEFINITION[K]>;
+};
+/**
+ * The three write actions every config node carries. 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.
+ */
+export type ConfigNodeActions = {
+    setSubschema: (slotName: string, data: unknown) => unknown;
+    setSubschemaArray: (slotName: string, data: unknown[]) => void;
+    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`.
+ */
+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.
+ */
+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.
+ */
+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
@@ -31,9 +145,7 @@ export type ConfigurationSlotName<SCHEMA> = SCHEMA extends undefined ? never : S
  */
 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;
-} & {
-    [K in GetExplicitIdentifier<SCHEMA>]?: string;
-} & (GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSnapshot<GetBase<SCHEMA>> : unknown) : 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.
@@ -55,6 +167,7 @@ interface SlotValueByType {
     maybeNumber: number | undefined;
     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
@@ -71,7 +184,9 @@ interface SlotValueByType {
     boolean: boolean;
     string: string;
     text: string;
+    featureField: string;
     color: string;
+    colorArray: string[];
 }
 /**
  * The two tables name the same builtin slot types, checked rather than
@@ -93,13 +208,37 @@ type SlotValueRawFromDef<DEF> = DEF extends AnyConfigurationSchemaType ? AnyConf
     model: ISimpleType<infer T extends string>;
 } ? DEF extends {
     type: 'maybeStringEnum';
-} ? T | undefined : T : DEF extends {
+} ? T | undefined : DEF extends {
+    type: 'stringEnumArray';
+} ? T[] : T : DEF extends {
     type: infer T extends keyof SlotValueByType;
 } ? SlotValueByType[T] : DEF extends {
     defaultValue: infer V;
 } ? [V] extends [boolean] ? boolean : [V] extends [string] ? string : [V] extends [number] ? number : any : any;
+type SubSchemaOf<SCHEMA, K> = IsAny<SCHEMA> extends true ? any : SCHEMA extends ConfigurationSchemaType<infer D, any> ? K extends keyof D ? D[K] : never : never;
+type SubSchemaSlotPath<SCHEMA> = SCHEMA extends ConfigurationSchemaType<infer D, any> ? IsAny<D> extends true ? readonly string[] : {
+    [K in keyof D & string]: D[K] extends AnyConfigurationSchemaType ? readonly [K, ConfigurationSlotName<D[K]>] | readonly [K, ...SubSchemaSlotPath<D[K]>] : D[K] extends IAnyType | {
+        type: 'frozen' | 'maybeFrozen';
+    } ? 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`).
+ */
+export type ConfigurationSlotPath<SCHEMA> = readonly [] | readonly [string] | SubSchemaSlotPath<SCHEMA>;
+/** what a read of `PATH` into `SCHEMA` yields */
+export type ConfigurationSlotPathValue<SCHEMA, PATH> = PATH extends readonly [
+    infer HEAD,
+    ...infer REST
+] ? SubSchemaOf<SCHEMA, HEAD> extends infer SUB extends AnyConfigurationSchemaType ? REST extends readonly [infer SLOT extends string] ? ConfigurationSlotValue<SUB, SLOT> : ConfigurationSlotPathValue<SUB, REST> : any : any;
 /** 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]> : GetBase<SCHEMA> extends ConfigurationSchemaType<any, any> ? ConfigurationSlotValue<GetBase<SCHEMA>, K> : any : any;
+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
@@ -114,7 +253,7 @@ export type ConfigurationSlotValue<SCHEMA, K extends string> = SCHEMA extends Co
  * model-or-snapshot union, not a plain instance).
  */
 export type AnyConfigurationSchemaType = ConfigurationSchemaType<any, any>;
-export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
+export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType> & Record<string, any>;
 /**
  * The `XConfigModel` for a **field table** — a `*ConfigSchemaFields` export —
  * rather than for a whole assembled schema. What it is for is the cast a
@@ -133,7 +272,7 @@ export type AnyConfigurationModel = Instance<AnyConfigurationSchemaType>;
  * `RowHeightMixin` + `rowHeightConfigSchemaFields` is the worked example, and
  * `packages/tree-sidebar/CLAUDE.md` has the reasoning.
  */
-export type ConfigModelForFields<FIELDS extends ConfigurationSchemaDefinition, BASE extends AnyConfigurationSchemaType | undefined = undefined> = Instance<ConfigurationSchemaType<FIELDS, ConfigurationSchemaOptions<BASE, undefined>>>;
+export type ConfigModelForFields<FIELDS extends ConfigurationSchemaDefinition, BASE extends AnyConfigurationSchemaType | undefined = undefined> = Instance<ConfigurationSchemaType<MergeConfigDef<FIELDS, BASE>, ConfigurationSchemaOptions<BASE, undefined>>>;
 /**
  * `true` when HOST's `configuration` still narrows slot names, `false` when it
  * has widened them back to `string`. One line per mixin pins it:

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

@@ -1,5 +1,5 @@
 import type PluginManager from '../../PluginManager.ts';
-import type { AnyConfigurationModel, ConfigurationSchemaForModel, ConfigurationSlotName, ConfigurationSlotValue } from '../../configuration/index.ts';
+import type { AnyConfigurationModel, ConfigurationSchemaForModel, ConfigurationSlotName, ConfigurationSlotPath, ConfigurationSlotPathValue, ConfigurationSlotValue } from '../../configuration/index.ts';
 import type { getSubAdapterType } from '../dataAdapterCache.ts';
 export declare class BaseAdapter<CONF extends AnyConfigurationModel = AnyConfigurationModel> {
     id: string;
@@ -26,5 +26,5 @@ export declare class BaseAdapter<CONF extends AnyConfigurationModel = AnyConfigu
      */
     setSequenceAdapterConfig(config: Record<string, unknown> | undefined): void;
     /** shorthand for `readConfObject(this.config, arg)` */
-    getConf<SLOT extends ConfigurationSlotName<ConfigurationSchemaForModel<CONF>> | string[] = ConfigurationSlotName<ConfigurationSchemaForModel<CONF>>>(arg: SLOT, args?: Record<string, unknown>): SLOT extends string ? ConfigurationSlotValue<ConfigurationSchemaForModel<CONF>, SLOT> : any;
+    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/BaseFeatureDataAdapter.d.ts

@@ -3,7 +3,7 @@ import type { AnyConfigurationModel } from '../../configuration/index.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 } from './types.ts';
+import type { BaseOptions, ZoomRange } from './types.ts';
 import type { Observable } from 'rxjs';
 /**
  * Base class for feature adapters to extend. Defines some methods that
@@ -76,7 +76,7 @@ export declare abstract class BaseFeatureDataAdapter<CONF extends AnyConfigurati
     /**
      * Convenience wrapper that collects {@link getFeatures} for a region into an
      * array — the common shape across RPC methods (RenderFeatureData, Manhattan,
-     * Wiggle, etc.). Pass `opts` so `statusCallback`/`stopToken` reach the
+     * Wiggle, etc.). Pass `opts` so `statusCallback`/`signal` reach the
      * adapter; omitting them means no download progress and a fetch that can't be
      * interrupted mid-flight.
      */
@@ -118,6 +118,15 @@ export declare abstract class BaseFeatureDataAdapter<CONF extends AnyConfigurati
      * agent-docs/reference/REGION_TOO_LARGE.md.
      */
     getRegionByteSize(_regions: Region[], _opts?: BaseOptions): Promise<number | undefined>;
+    /**
+     * The bp/px interval over which this adapter answers a fetch from the same
+     * zoom level it answers `opts.bpPerPx` from, so a display holding the answer
+     * refetches only when the view leaves it. The default, `undefined`, is an
+     * answer that does not depend on the zoom, which a display never refetches
+     * for a zoom. An adapter that reads `bpPerPx` declares its range here
+     * (`BigWigAdapter` from its header's zoom levels).
+     */
+    getZoomRange(_opts?: BaseOptions): Promise<ZoomRange | 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

package/esm/data_adapters/BaseAdapter/BaseFeatureDataAdapter.js

@@ -49,7 +49,7 @@ export class BaseFeatureDataAdapter extends BaseAdapter {
     /**
      * Convenience wrapper that collects {@link getFeatures} for a region into an
      * array — the common shape across RPC methods (RenderFeatureData, Manhattan,
-     * Wiggle, etc.). Pass `opts` so `statusCallback`/`stopToken` reach the
+     * Wiggle, etc.). Pass `opts` so `statusCallback`/`signal` reach the
      * adapter; omitting them means no download progress and a fetch that can't be
      * interrupted mid-flight.
      */
@@ -109,6 +109,17 @@ export class BaseFeatureDataAdapter extends BaseAdapter {
     async getRegionByteSize(_regions, _opts) {
         return undefined;
     }
+    /**
+     * The bp/px interval over which this adapter answers a fetch from the same
+     * zoom level it answers `opts.bpPerPx` from, so a display holding the answer
+     * refetches only when the view leaves it. The default, `undefined`, is an
+     * answer that does not depend on the zoom, which a display never refetches
+     * for a zoom. An adapter that reads `bpPerPx` declares its range here
+     * (`BigWigAdapter` from its header's zoom levels).
+     */
+    async getZoomRange(_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

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

@@ -22,9 +22,8 @@ export declare const densityAdapterConfigSchemaFields: {
      * #slot
      */
     readonly densityAdapter: {
-        readonly type: 'frozen';
-        readonly defaultValue: null;
-        readonly description: 'optional quantitative sub-adapter (e.g. a BigWigAdapter over a features-per-bin bigWig) drawn as a density band where the region is too large to fetch features; null disables it';
+        readonly type: 'maybeFrozen';
+        readonly description: 'optional quantitative sub-adapter (e.g. a BigWigAdapter over a features-per-bin bigWig) drawn as a density band where the region is too large to fetch features; leave it unset to disable';
     };
 };
 /**

package/esm/data_adapters/BaseAdapter/featureDensity.js

@@ -10,9 +10,8 @@ export const densityAdapterConfigSchemaFields = {
      * #slot
      */
     densityAdapter: {
-        type: 'frozen',
-        defaultValue: null,
-        description: 'optional quantitative sub-adapter (e.g. a BigWigAdapter over a features-per-bin bigWig) drawn as a density band where the region is too large to fetch features; null disables it',
+        type: 'maybeFrozen',
+        description: 'optional quantitative sub-adapter (e.g. a BigWigAdapter over a features-per-bin bigWig) drawn as a density band where the region is too large to fetch features; leave it unset to disable',
     },
 };
 /**

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

@@ -1,9 +1,10 @@
 import type PluginManager from '../../PluginManager.ts';
-import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type { AnyConfigurationSchemaType } from '../../configuration/index.ts';
 import type { getSubAdapterType } from '../dataAdapterCache.ts';
 import type { AnyDataAdapter } from './util.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
 export { type AnyDataAdapter, isFeatureAdapter, isRefNameAliasAdapter, isRegionsAdapter, isSequenceAdapter, isTextSearchAdapter, } from './util.ts';
-export type { BaseOptions, BaseTextSearchArgs, LodTier, SearchType, } from './types.ts';
+export type { BaseOptions, BaseTextSearchArgs, LodTier, SearchType, ZoomRange, } from './types.ts';
 export { BaseAdapter } from './BaseAdapter.ts';
 export { cachedSetup } from '../../util/cachedSetup.ts';
 export { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter.ts';
@@ -13,4 +14,22 @@ export type { BaseTextSearchAdapter } from './BaseTextSearchAdapter.ts';
 export type { Alias, BaseRefNameAliasAdapter, } from './BaseRefNameAliasAdapter.ts';
 export type { RegionsAdapter } from './RegionsAdapter.ts';
 export type { CytobandAdapter } from './CytobandAdapter.ts';
-export type AnyAdapter = new (config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager) => AnyDataAdapter;
+/**
+ * The adapter class that goes with SCHEMA — the class whose `config` is that
+ * schema's node. `AdapterType` is generic over the schema so registering the
+ * two together checks that they are the same adapter's; the pairing is
+ * otherwise only a shared `type` string, and nothing reports a class reading
+ * slots its declared schema never had.
+ *
+ * see
+ * https://www.typescriptlang.org/docs/handbook/2/classes.html#abstract-construct-signatures
+ * for why this is the abstract construct signature
+ */
+export type AdapterClassFor<SCHEMA> = new (config: SCHEMA extends AnyConfigurationSchemaType ? Instance<SCHEMA> : any, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager) => AnyDataAdapter;
+/**
+ * An adapter class with its schema forgotten, which is what the registry holds
+ * and `dataAdapterCache` constructs: the config node it has in hand came from
+ * the `AdapterType` the same `type` name resolved to, and that lookup is the
+ * only thing tying the two together.
+ */
+export type AnyAdapter = AdapterClassFor<any>;

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

@@ -1,11 +1,10 @@
 import type { StatusCallback } from '../../util/progress.ts';
-import type { StopToken } from '../../util/stopToken.ts';
+export type { ZoomRange } from './zoomRange.ts';
 export type LodTier = 'fine' | 'coarse';
 export interface BaseOptions {
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     bpPerPx?: number;
     sessionId?: string;
-    signal?: AbortSignal;
     statusCallback?: StatusCallback;
     headers?: Record<string, string>;
     assemblyName?: string;
@@ -16,5 +15,5 @@ export type SearchType = 'full' | 'prefix' | 'exact';
 export interface BaseTextSearchArgs {
     queryString: string;
     searchType?: SearchType;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
 }

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

@@ -0,0 +1,10 @@
+/**
+ * #api
+ * The bp/px interval, `[minBpPerPx, maxBpPerPx)`, over which an adapter with
+ * zoom levels answers a fetch from the same level it answered `opts.bpPerPx`
+ * from. A display holding the answer refetches when the view leaves it.
+ */
+export interface ZoomRange {
+    minBpPerPx: number;
+    maxBpPerPx: number;
+}

package/esm/data_adapters/BaseAdapter/zoomRange.js

@@ -0,0 +1 @@
+export {};

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

@@ -25,17 +25,15 @@
  * ```
  */
 declare const configSchema: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * location of a UCSC-style `cytoBand.txt` (`chrom start end name
-     * gieStain`), which draws the ideogram banding in the view's overview bar.
-     * May be gzipped. Configured on an assembly, not on a track.
-     */
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
     readonly cytobandLocation: {
-        readonly type: "fileLocation";
-        readonly defaultValue: {
-            readonly uri: "/path/to/cytoband.txt.gz";
-        };
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
     };
-}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
 export default configSchema;

package/esm/data_adapters/getSequenceSubAdapter.d.ts

@@ -11,9 +11,7 @@ import type { BaseAdapter, BaseSequenceAdapter } from './BaseAdapter/index.ts';
  * so it wins only when explicitly present, and `jbrowse validate` warns about it.
  *
  * In core rather than beside one of its callers because the field it reads is
- * `BaseAdapter`'s. Deliberately NOT in `BaseAdapter/index.ts`: that barrel is a
- * `@jbrowse/core/*` re-export, and a name published there is load-bearing ABI —
- * `abi.test.ts`/`abiBaseline.json` fails a removal from it.
+ * `BaseAdapter`'s.
  *
  * `configured` is passed in rather than read here so each adapter reads its own
  * slot through its own config type.

package/esm/data_adapters/getSequenceSubAdapter.js

@@ -10,9 +10,7 @@
  * so it wins only when explicitly present, and `jbrowse validate` warns about it.
  *
  * In core rather than beside one of its callers because the field it reads is
- * `BaseAdapter`'s. Deliberately NOT in `BaseAdapter/index.ts`: that barrel is a
- * `@jbrowse/core/*` re-export, and a name published there is load-bearing ABI —
- * `abi.test.ts`/`abiBaseline.json` fails a removal from it.
+ * `BaseAdapter`'s.
  *
  * `configured` is passed in rather than read here so each adapter reads its own
  * slot through its own config type.

package/esm/pluggableElementTypes/AdapterType.d.ts

@@ -1,6 +1,6 @@
 import PluggableElementBase from './PluggableElementBase.ts';
 import type { AnyConfigurationSchemaType } from '../configuration/index.ts';
-import type { AnyAdapter } from '../data_adapters/BaseAdapter/index.ts';
+import type { AdapterClassFor } from '../data_adapters/BaseAdapter/index.ts';
 export interface AdapterMetadata {
     category?: string;
     hiddenFromGUI?: boolean;
@@ -25,9 +25,9 @@ export interface AdapterMetadata {
 }
 /** Expand a raw adapter config snapshot (plain JSON) to its canonical form. */
 export type NormalizeSnapshot = (snap: Record<string, unknown>) => Record<string, unknown>;
-export default class AdapterType extends PluggableElementBase {
-    getAdapterClass: () => Promise<AnyAdapter>;
-    configSchema: AnyConfigurationSchemaType;
+export default class AdapterType<SCHEMA extends AnyConfigurationSchemaType = any> extends PluggableElementBase {
+    getAdapterClass: () => Promise<AdapterClassFor<SCHEMA>>;
+    configSchema: SCHEMA;
     adapterCapabilities: string[];
     adapterMetadata?: AdapterMetadata;
     private declaredNormalizeSnapshot?;
@@ -61,7 +61,7 @@ export default class AdapterType extends PluggableElementBase {
     locationKey?: string;
     constructor(stuff: {
         name: string;
-        configSchema: AnyConfigurationSchemaType;
+        configSchema: SCHEMA;
         displayName?: string;
         aliases?: string[];
         adapterCapabilities?: string[];
@@ -69,8 +69,8 @@ export default class AdapterType extends PluggableElementBase {
         normalizeSnapshot?: NormalizeSnapshot;
         locationKey?: string;
     } & ({
-        getAdapterClass: () => Promise<AnyAdapter>;
+        getAdapterClass: () => Promise<AdapterClassFor<SCHEMA>>;
     } | {
-        AdapterClass: AnyAdapter;
+        AdapterClass: AdapterClassFor<SCHEMA>;
     }));
 }

package/esm/pluggableElementTypes/RpcMethodType.d.ts

@@ -109,7 +109,7 @@ export default abstract class RpcMethodType<MethodName extends string = string>
      * is not cosmetic, because the two handles every method receives are the two
      * an author who did not write them down never forwards.
      *
-     * `CoreGetExportData` is the worked example: the stop token and status
+     * `CoreGetExportData` is the worked example: the signal and status
      * callback arrived on every call and its `execute` destructured neither, so
      * the Save-track-data dialog's cancel did nothing and its progress never moved
      * on the adapter-export branch. Nothing was mistyped — the fields simply were

package/esm/pluggableElementTypes/RpcMethodType.js

@@ -64,17 +64,12 @@ function isCloneable(thing) {
 }
 // Values that structuredClone handles natively and that must pass through
 // ownArgs unchanged: `Object.entries` on them yields `[]`, so naive cloning
-// would collapse them to plain `{}` (e.g. a SharedArrayBuffer-backed stop token
-// would silently stop working, a typed array would lose its data).
+// would collapse them to plain `{}` (a typed array would lose its data).
 function isStructuredClonePassthrough(thing) {
     return (thing instanceof File ||
         thing instanceof Blob ||
         thing instanceof ArrayBuffer ||
-        // SharedArrayBuffer is not an ArrayBuffer subclass; without this it
-        // collapses to {} and SAB-based stop tokens silently stop working. Nothing
-        // we ship mints one (see `stopToken.ts`, "Which path runs where"), so this
-        // arm is correctness for an isolated embedding host and nothing else —
-        // keep it, but it is not a hot path and never was.
+        // not an ArrayBuffer subclass
         (typeof SharedArrayBuffer !== 'undefined' &&
             thing instanceof SharedArrayBuffer) ||
         ArrayBuffer.isView(thing) ||
@@ -96,7 +91,7 @@ function isStructuredClonePassthrough(thing) {
 // DataCloneError on every call a display makes.
 //
 // So: non-cloneable leaves (functions, Errors) and structured-clone natives
-// (typed arrays, Blobs, the SAB stop token...) pass through by reference
+// (typed arrays, Blobs...) pass through by reference
 // unchanged. A genuinely non-cloneable value that leaked in by mistake is still
 // caught — at the worker postMessage boundary, which is a real structuredClone.
 function ownArgs(thing, seen = new WeakMap()) {

package/esm/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions.d.ts

@@ -2,7 +2,6 @@ import RpcMethodTypeWithRenameRegions from './RpcMethodTypeWithRenameRegions.ts'
 import SerializableFilterChain from './renderers/util/serializableFilterChain.ts';
 import type { Region } from '../util/index.ts';
 import type { StatusCallback } from '../util/progress.ts';
-import type { StopToken } from '../util/stopToken.ts';
 interface FilterRenameArgs {
     sessionId: string;
     regions?: Region[];
@@ -14,7 +13,7 @@ export default abstract class RpcMethodTypeWithFiltersAndRenameRegions<MethodNam
         filters?: unknown;
     }): Promise<T>;
     serializeArguments(args: FilterRenameArgs & {
-        stopToken?: StopToken;
+        signal?: AbortSignal;
         statusCallback?: StatusCallback;
     }): Promise<Record<string, unknown>>;
 }

package/esm/pluggableElementTypes/TextSearchAdapterType.d.ts

@@ -1,18 +1,18 @@
 import PluggableElementBase from './PluggableElementBase.ts';
 import type { AnyConfigurationSchemaType } from '../configuration/index.ts';
-import type { AnyAdapter } from '../data_adapters/BaseAdapter/index.ts';
-export default class TextSearchAdapterType extends PluggableElementBase {
-    getAdapterClass: () => Promise<AnyAdapter>;
-    configSchema: AnyConfigurationSchemaType;
+import type { AdapterClassFor } from '../data_adapters/BaseAdapter/index.ts';
+export default class TextSearchAdapterType<SCHEMA extends AnyConfigurationSchemaType = any> extends PluggableElementBase {
+    getAdapterClass: () => Promise<AdapterClassFor<SCHEMA>>;
+    configSchema: SCHEMA;
     description?: string;
     constructor(stuff: {
         name: string;
-        configSchema: AnyConfigurationSchemaType;
+        configSchema: SCHEMA;
         displayName?: string;
         description?: string;
     } & ({
-        getAdapterClass: () => Promise<AnyAdapter>;
+        getAdapterClass: () => Promise<AdapterClassFor<SCHEMA>>;
     } | {
-        AdapterClass: AnyAdapter;
+        AdapterClass: AdapterClassFor<SCHEMA>;
     }));
 }

package/esm/pluggableElementTypes/index.d.ts

@@ -8,7 +8,7 @@ import type TextSearchAdapterType from './TextSearchAdapterType.ts';
 import type TrackType from './TrackType.ts';
 import type ViewType from './ViewType.ts';
 import type WidgetType from './WidgetType.ts';
-export { BaseConnectionModelFactory, BaseDisplay, type BaseDisplayModel, type BaseDisplayStateModel, BaseInternetAccountConfig, type BaseInternetAccountModel, type BaseInternetAccountStateModel, type BaseTrackConfig, type BaseTrackModel, type BaseTrackStateModel, BaseViewModel, type DisplayModel, type FileTypeExporter, HighlightsMixin, type IBaseViewModel, InternetAccount, addDisplayConfigMigration, baseConnectionConfig, createBaseTrackConfig, createBaseTrackModel, preprocessTrackConfigSnapshot, type TrackConfigSnapshot, trackConfigActions, } from './models/index.ts';
+export { BaseConnectionModelFactory, BaseDisplay, type BaseDisplayModel, type BaseDisplayStateModel, BaseInternetAccountConfig, type BaseInternetAccountModel, type BaseInternetAccountStateModel, type BaseTrackConfig, type BaseTrackModel, type BaseTrackStateModel, BaseViewModel, type DisplayModel, type FileTypeExporter, type IBaseViewModel, InternetAccount, addDisplayConfigMigration, baseConnectionConfig, createBaseTrackConfig, createBaseTrackModel, preprocessTrackConfigSnapshot, type TrackConfigSnapshot, } from './models/index.ts';
 export type PluggableElementType = AdapterType | ConnectionType | WidgetType | TrackType | DisplayType | ViewType | RpcMethodType | InternetAccountType | TextSearchAdapterType | AddTrackWorkflowType;
 export { extendDisplayType, extendViewType } from './extendElementType.ts';
 export { addDisplayMenuItems, addViewMenuItems } from './addMenuItems.ts';

package/esm/pluggableElementTypes/index.js

@@ -1,4 +1,4 @@
-export { BaseConnectionModelFactory, BaseDisplay, BaseInternetAccountConfig, BaseViewModel, HighlightsMixin, InternetAccount, addDisplayConfigMigration, baseConnectionConfig, createBaseTrackConfig, createBaseTrackModel, preprocessTrackConfigSnapshot, trackConfigActions, } from './models/index.js';
+export { BaseConnectionModelFactory, BaseDisplay, BaseInternetAccountConfig, BaseViewModel, InternetAccount, addDisplayConfigMigration, baseConnectionConfig, createBaseTrackConfig, createBaseTrackModel, preprocessTrackConfigSnapshot, } from './models/index.js';
 export { extendDisplayType, extendViewType } from './extendElementType.js';
 export { addDisplayMenuItems, addViewMenuItems } from './addMenuItems.js';
 export { default as AdapterType } from './AdapterType.js';