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

package/esm/assemblyManager/expandAssemblyConfigShorthand.d.ts

@@ -1,32 +1,39 @@
 import type PluginManager from '../PluginManager.ts';
+export declare function referenceSequenceTrackId(assemblyName: unknown): string;
 /**
- * Fill in an assembly `sequence.adapter`'s `type` from its `uri` when the type
- * is omitted, so `sequence: { adapter: { uri: 'genome.fa.gz' } }` resolves to a
- * `BgzipFastaAdapter` (and `.fa` → indexed, `.2bit` → `TwoBitAdapter`). Uses the
- * same `Core-guessAdapterForLocation` extension point the "Add track" flow uses,
- * so every host describes a custom genome with just a URL and lets jbrowse-core
- * pick the adapter — no adapter-type table in the Python/R/JS bindings.
- *
- * The guesser also derives the index locations (`.fai`/`.gzi`) from the uri;
- * explicit adapter fields (e.g. a non-sibling `faiLocation`) are spread on top
- * so they win. A `uri` matching no sequence adapter is left untouched, so a
- * genuinely bad config still surfaces its own downstream error. Returns the same
- * object reference when there is nothing to expand, so callers can cheaply skip
- * a rebuild.
+ * The part of {@link expandAssemblyShorthand} that needs no plugin manager, for
+ * a reader of raw config JSON: the flat `{ name, uri }` form moves onto
+ * `sequence.adapter`, and `sequence.type` and `sequence.trackId` are each
+ * filled in when omitted. Returns `snap` itself when there is nothing to do.
  */
+export declare function expandAssemblySequence<T>(snap: T): T;
 /**
  * Expand an assembly snapshot's own shorthands into the `sequence` an assembly
- * config declares: the flat `{ name, uri: 'genome.fa.gz' }` form, the
- * `sequence: { adapter: { uri } }` form, and the omitted
- * `sequence.type`/`trackId`.
+ * config declares: {@link expandAssemblySequence}, then the sequence adapter's
+ * type guessed from its `uri`.
  *
  * This is the assembly config schema's `preProcessSnapshot`, lifted out so a
  * caller that has to see canonical locations *before* MST builds the tree can
  * run it too. `localFiles` is that caller: it rewrites `{ uri: <a registered
  * name> }` location nodes into blobs, and until this has run the only `uri` in
  * a shorthand assembly is on the assembly itself, where it is not a location
- * node and must not be rewritten as one. Idempotent — the flat `uri` is
- * consumed, so the schema's own later pass finds nothing to do.
+ * node and must not be rewritten as one. Idempotent, and returns `snap` itself
+ * when there is nothing to expand.
  */
 export declare function expandAssemblyShorthand<T>(snap: T, pluginManager: PluginManager): T;
+/**
+ * Fill in an assembly `sequence.adapter`'s `type` from its `uri` when the type
+ * is omitted, so `sequence: { adapter: { uri: 'genome.fa.gz' } }` resolves to a
+ * `BgzipFastaAdapter` (and `.fa` → indexed, `.2bit` → `TwoBitAdapter`). Uses the
+ * same `Core-guessAdapterForLocation` extension point the "Add track" flow uses,
+ * so every host describes a custom genome with just a URL and lets jbrowse-core
+ * pick the adapter — no adapter-type table in the Python/R/JS bindings.
+ *
+ * Only the type comes off the guess: the adapter's own `normalizeSnapshot`
+ * expands the `uri` into the location slots it declares, so the shorthand
+ * expands to the same thing here as it does when the config names the type.
+ * A `uri` matching no sequence adapter is left untouched, and the same object
+ * reference comes back when there is nothing to expand, so callers can cheaply
+ * skip a rebuild.
+ */
 export declare function expandAssemblySequenceAdapter(sequence: unknown, pluginManager: PluginManager): unknown;

package/esm/assemblyManager/expandAssemblyConfigShorthand.js

@@ -1,65 +1,78 @@
+import { isPlainObject } from '../util/objectUtils.js';
 import { UNKNOWN } from '../util/tracks.js';
-function isPlainObject(v) {
-    return typeof v === 'object' && v !== null && !Array.isArray(v);
+export function referenceSequenceTrackId(assemblyName) {
+    return `${assemblyName}-ReferenceSequenceTrack`;
 }
 /**
- * Fill in an assembly `sequence.adapter`'s `type` from its `uri` when the type
- * is omitted, so `sequence: { adapter: { uri: 'genome.fa.gz' } }` resolves to a
- * `BgzipFastaAdapter` (and `.fa` → indexed, `.2bit` → `TwoBitAdapter`). Uses the
- * same `Core-guessAdapterForLocation` extension point the "Add track" flow uses,
- * so every host describes a custom genome with just a URL and lets jbrowse-core
- * pick the adapter — no adapter-type table in the Python/R/JS bindings.
- *
- * The guesser also derives the index locations (`.fai`/`.gzi`) from the uri;
- * explicit adapter fields (e.g. a non-sibling `faiLocation`) are spread on top
- * so they win. A `uri` matching no sequence adapter is left untouched, so a
- * genuinely bad config still surfaces its own downstream error. Returns the same
- * object reference when there is nothing to expand, so callers can cheaply skip
- * a rebuild.
+ * The part of {@link expandAssemblyShorthand} that needs no plugin manager, for
+ * a reader of raw config JSON: the flat `{ name, uri }` form moves onto
+ * `sequence.adapter`, and `sequence.type` and `sequence.trackId` are each
+ * filled in when omitted. Returns `snap` itself when there is nothing to do.
  */
+export function expandAssemblySequence(snap) {
+    if (!isPlainObject(snap)) {
+        return snap;
+    }
+    const { uri, baseUri, ...rest } = snap;
+    const given = rest.sequence;
+    // baseUri, stamped next to `uri` by addRelativeUris, rides down onto the
+    // adapter so the sequence resolves against the config's location
+    const seq = typeof uri === 'string' &&
+        (given === undefined || (isPlainObject(given) && !given.adapter))
+        ? {
+            ...(isPlainObject(given) ? given : {}),
+            adapter: { uri, ...(baseUri ? { baseUri } : {}) },
+        }
+        : given;
+    if (!isPlainObject(seq) ||
+        (seq === snap.sequence && 'type' in seq && 'trackId' in seq)) {
+        return snap;
+    }
+    return {
+        ...rest,
+        sequence: {
+            type: 'ReferenceSequenceTrack',
+            trackId: referenceSequenceTrackId(snap.name),
+            ...seq,
+        },
+    };
+}
 /**
  * Expand an assembly snapshot's own shorthands into the `sequence` an assembly
- * config declares: the flat `{ name, uri: 'genome.fa.gz' }` form, the
- * `sequence: { adapter: { uri } }` form, and the omitted
- * `sequence.type`/`trackId`.
+ * config declares: {@link expandAssemblySequence}, then the sequence adapter's
+ * type guessed from its `uri`.
  *
  * This is the assembly config schema's `preProcessSnapshot`, lifted out so a
  * caller that has to see canonical locations *before* MST builds the tree can
  * run it too. `localFiles` is that caller: it rewrites `{ uri: <a registered
  * name> }` location nodes into blobs, and until this has run the only `uri` in
  * a shorthand assembly is on the assembly itself, where it is not a location
- * node and must not be rewritten as one. Idempotent — the flat `uri` is
- * consumed, so the schema's own later pass finds nothing to do.
+ * node and must not be rewritten as one. Idempotent, and returns `snap` itself
+ * when there is nothing to expand.
  */
 export function expandAssemblyShorthand(snap, pluginManager) {
-    if (!isPlainObject(snap)) {
-        return snap;
+    const expanded = expandAssemblySequence(snap);
+    if (!isPlainObject(expanded)) {
+        return expanded;
     }
-    const { name, uri, baseUri, ...rest } = snap;
-    // flattest shorthand: `{ name, uri: 'genome.fa.gz' }` describes an
-    // assembly by its sequence file alone. baseUri, stamped next to the
-    // `uri` key by addRelativeUris (hub/relative configs), rides down onto
-    // the adapter so the sequence resolves against the config's location.
-    const rawSequence = rest.sequence ??
-        (typeof uri === 'string'
-            ? { adapter: { uri, ...(baseUri ? { baseUri } : {}) } }
-            : undefined);
-    // infer sequence.adapter.type from its uri when omitted, so a config can
-    // give just `sequence: { adapter: { uri: 'genome.fa.gz' } }` and core
-    // picks the adapter (Bgzip/Indexed/TwoBit) — no adapter table in hosts
-    const seq = expandAssemblySequenceAdapter(rawSequence, pluginManager);
-    // then allow sequence.type/trackId to be omitted, since they are always
-    // 'ReferenceSequenceTrack' and a name derived from the assembly name
-    const sequence = seq && typeof seq === 'object' && !('type' in seq)
-        ? {
-            type: 'ReferenceSequenceTrack',
-            trackId: `${name}-ReferenceSequenceTrack`,
-            ...seq,
-        }
-        : seq;
-    // preserve the identity-unchanged case so nothing rebuilds needlessly
-    return (sequence === snap.sequence ? snap : { ...rest, name, sequence });
+    const sequence = expandAssemblySequenceAdapter(expanded.sequence, pluginManager);
+    return sequence === expanded.sequence ? expanded : { ...expanded, sequence };
 }
+/**
+ * Fill in an assembly `sequence.adapter`'s `type` from its `uri` when the type
+ * is omitted, so `sequence: { adapter: { uri: 'genome.fa.gz' } }` resolves to a
+ * `BgzipFastaAdapter` (and `.fa` → indexed, `.2bit` → `TwoBitAdapter`). Uses the
+ * same `Core-guessAdapterForLocation` extension point the "Add track" flow uses,
+ * so every host describes a custom genome with just a URL and lets jbrowse-core
+ * pick the adapter — no adapter-type table in the Python/R/JS bindings.
+ *
+ * Only the type comes off the guess: the adapter's own `normalizeSnapshot`
+ * expands the `uri` into the location slots it declares, so the shorthand
+ * expands to the same thing here as it does when the config names the type.
+ * A `uri` matching no sequence adapter is left untouched, and the same object
+ * reference comes back when there is nothing to expand, so callers can cheaply
+ * skip a rebuild.
+ */
 export function expandAssemblySequenceAdapter(sequence, pluginManager) {
     const adapter = isPlainObject(sequence) ? sequence.adapter : undefined;
     if (isPlainObject(sequence) &&
@@ -77,9 +90,25 @@ export function expandAssemblySequenceAdapter(sequence, pluginManager) {
             ...(typeof baseUri === 'string' ? { baseUri } : {}),
         };
         const guess = guesser(file, undefined);
-        return guess && guess.type !== UNKNOWN
-            ? { ...sequence, adapter: { ...guess, ...extras } }
-            : sequence;
+        if (!guess || guess.type === UNKNOWN) {
+            return sequence;
+        }
+        // the type is the only thing the guess is needed for. The adapter's own
+        // normalizeSnapshot expands `uri` and everything riding with it — a 2bit's
+        // `chromSizes`, which the guess has no slot for and MST then dropped
+        // unannounced — so this is not a second place that knows how a sequence
+        // file names its sidecars. An adapter declaring no shorthand keeps the
+        // guess's derived locations.
+        const normalize = pluginManager.hasAdapterType(guess.type)
+            ? pluginManager.getAdapterType(guess.type).normalizeSnapshot
+            : undefined;
+        const shorthand = { ...adapter, type: guess.type };
+        const normalized = normalize?.(shorthand) ?? shorthand;
+        // `uri` is consumed, and it has to GO: localFiles substitutes a blob into a
+        // location node, and an adapter still carrying `uri` reads as one
+        const full = normalized === shorthand ? { ...guess, ...extras } : normalized;
+        const { uri: _consumed, baseUri: _spent, ...expanded } = full;
+        return { ...sequence, adapter: expanded };
     }
     return sequence;
 }

package/esm/assemblyManager/geneticCodes.js

@@ -1,4 +1,3 @@
-import { isBlank } from '../util/assemblyConfigUtils.js';
 import { fetchAndMaybeUnzipText } from '../util/fetchAndMaybeUnzip.js';
 import { parseTranslTable } from '../util/geneticCodes.js';
 import { openLocation } from '../util/io/index.js';
@@ -24,14 +23,12 @@ export function lookupGeneticCodeId(refName, refNameAliases, maps) {
         .find(id => id !== undefined) ?? STANDARD_GENETIC_CODE_ID);
 }
 // Loads an optional `refName<TAB>geneticCodeId` TSV (# comments allowed) into a
-// map; an empty location yields {} so the inline geneticCodes slot is the only
+// map; no location yields {} so the inline geneticCodes slot is the only
 // source. Kept as a plain file read rather than a pluggable adapter because the
 // mapping is trivial and format-fixed.
 export async function getGeneticCodesFromFile({ location, pluginManager, opts, }) {
     const map = {};
-    // skip the config slot's default blank location ({ uri: '' }); a real file
-    // yields the refName -> geneticCodeId map
-    if (location && !isBlank(location)) {
+    if (location) {
         const text = await fetchAndMaybeUnzipText(openLocation(location, pluginManager), opts, 'Downloading genetic codes');
         for (const line of text.split(/\r\n|\r|\n/)) {
             if (line && !line.startsWith('#')) {

package/esm/assemblyManager/getSequenceAdapterConfig.d.ts

@@ -1,3 +1,4 @@
+import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type { Assembly } from './assembly.ts';
 /**
  * The assembly's reference-sequence adapter config as a plain snapshot, or
@@ -7,3 +8,12 @@ import type { Assembly } from './assembly.ts';
  * safe) or undefined (?. handles it).
  */
 export declare function getSequenceAdapterConfig(assembly?: Pick<Assembly, 'configuration'>): Record<string, unknown> | undefined;
+/**
+ * {@link getSequenceAdapterConfig} for a name, canonical or alias, read off
+ * the config rather than the built model, so it answers before the model
+ * exists and does not report an unknown name the way `assemblyManager.get`
+ * does; a track config may name an assembly the session lacks.
+ */
+export declare function getSequenceAdapterConfigByName(assemblyManager: {
+    confByName: Map<string, AnyConfigurationModel>;
+}, assemblyName: string): Record<string, unknown> | undefined;

package/esm/assemblyManager/getSequenceAdapterConfig.js

@@ -10,3 +10,13 @@ export function getSequenceAdapterConfig(assembly) {
     const adapter = assembly?.configuration?.sequence?.adapter;
     return adapter ? getSnapshot(adapter) : undefined;
 }
+/**
+ * {@link getSequenceAdapterConfig} for a name, canonical or alias, read off
+ * the config rather than the built model, so it answers before the model
+ * exists and does not report an unknown name the way `assemblyManager.get`
+ * does; a track config may name an assembly the session lacks.
+ */
+export function getSequenceAdapterConfigByName(assemblyManager, assemblyName) {
+    const adapter = assemblyManager.confByName.get(assemblyName)?.sequence?.adapter;
+    return adapter ? getSnapshot(adapter) : undefined;
+}

package/esm/assemblyManager/indexAssemblyNames.d.ts

@@ -0,0 +1,9 @@
+/**
+ * name -> item for every name an assembly answers to. An assembly's own name
+ * beats another assembly's alias, and otherwise the first to claim a name keeps
+ * it, so the answer never depends on which array an assembly sits in.
+ */
+export declare function indexAssemblyNames<T>(items: Iterable<T>, namesOf: (item: T) => {
+    name: string;
+    aliases: readonly string[];
+}): Map<string, T>;

package/esm/assemblyManager/indexAssemblyNames.js

@@ -0,0 +1,22 @@
+/**
+ * name -> item for every name an assembly answers to. An assembly's own name
+ * beats another assembly's alias, and otherwise the first to claim a name keeps
+ * it, so the answer never depends on which array an assembly sits in.
+ */
+export function indexAssemblyNames(items, namesOf) {
+    const index = new Map();
+    const named = Array.from(items, item => ({ item, ...namesOf(item) }));
+    for (const { item, name } of named) {
+        if (!index.has(name)) {
+            index.set(name, item);
+        }
+    }
+    for (const { item, aliases } of named) {
+        for (const alias of aliases) {
+            if (!index.has(alias)) {
+                index.set(alias, item);
+            }
+        }
+    }
+    return index;
+}

package/esm/assemblyManager/loadRefNameMap.d.ts

@@ -1,5 +1,5 @@
 import type { BaseOptions } from '../data_adapters/BaseAdapter/index.ts';
 import type { Assembly } from './assembly.ts';
 import type { RefNameAliases } from './refNameMaps.ts';
-export type RefNameMapAssembly = Pick<Assembly, 'name' | 'load' | 'error' | 'regions' | 'refNames' | 'refNameAliases' | 'rpcManager' | 'configuration' | 'getCanonicalRefName' | 'setRefNameMismatch'>;
+export type RefNameMapAssembly = Pick<Assembly, 'name' | 'load' | 'error' | 'regions' | 'refNames' | 'refNameAliases' | 'rpcManager' | 'getCanonicalRefName' | 'setRefNameMismatch'>;
 export declare function loadRefNameMap(assembly: RefNameMapAssembly, adapterConfig: unknown, options: BaseOptions): Promise<RefNameAliases>;

package/esm/assemblyManager/loadRefNameMap.js

@@ -1,6 +1,5 @@
 import { adapterConfigCacheKey } from '../data_adapters/dataAdapterCache.js';
 import { updateStatus } from '../util/progress.js';
-import { getSequenceAdapterConfig } from './getSequenceAdapterConfig.js';
 import { checkRefName } from './refNameMaps.js';
 import { detectRefNameMismatch } from './refNameMismatch.js';
 export async function loadRefNameMap(assembly, adapterConfig, options) {
@@ -12,10 +11,6 @@ export async function loadRefNameMap(assembly, adapterConfig, options) {
     // set, so awaiting it is a direct, promise-based alternative to a reactive
     // `when` on those volatiles. It rejects on failure, so no error check follows
     await assembly.load();
-    // pass the assembly's sequence adapter config (as a snapshot, since MST
-    // objects can't be assigned elsewhere) so BAM/CRAM adapters can cache it for
-    // later use when fetching features
-    const sequenceAdapter = getSequenceAdapterConfig(assembly);
     // Labelled, because this is the multi-second stall before any RPC's own
     // status appears: `renameRegionsIfNeeded` runs inside `serializeArguments`,
     // so every fetch waits here first, and the byte-granularity progress below
@@ -26,11 +21,11 @@ export async function loadRefNameMap(assembly, adapterConfig, options) {
     const refNames = await updateStatus('Loading', options.statusCallback, () => assembly.rpcManager.call(sessionId, 'CoreGetRefNames', {
         adapterConfig: adapterConfig,
         assemblyName: assembly.name,
-        sequenceAdapter,
-        // stopToken intentionally not passed, fixes issues like #2221.
+        haplotypes: options.haplotypes,
+        // signal intentionally not passed, fixes issues like #2221.
         // alternative fix #2540 was proposed but non-working currently
-        stopToken: undefined,
-        // Forwarded rather than dropped (unlike stopToken above), because the
+        signal: undefined,
+        // Forwarded rather than dropped (unlike signal above), because the
         // adapter's index download happens here during refname mapping
         // (getRefNames -> setup) and this is the only place its "Downloading
         // index" progress can surface. For an in-memory adapter it is not an

package/esm/assemblyManager/refNameMapKey.d.ts

@@ -0,0 +1,7 @@
+import type { BaseOptions } from '../data_adapters/BaseAdapter/index.ts';
+/**
+ * A source that reads only the lanes it is asked about answers a different
+ * refName set per selection, so each selection loads its own map; the worker
+ * keeps each lane's names, so a second selection reads only its new lanes.
+ */
+export declare function refNameMapKey(adapterConf: Record<string, unknown>, options: BaseOptions): string;

package/esm/assemblyManager/refNameMapKey.js

@@ -0,0 +1,12 @@
+import { adapterConfigCacheKey } from '../data_adapters/dataAdapterCache.js';
+/**
+ * A source that reads only the lanes it is asked about answers a different
+ * refName set per selection, so each selection loads its own map; the worker
+ * keeps each lane's names, so a second selection reads only its new lanes.
+ */
+export function refNameMapKey(adapterConf, options) {
+    const key = adapterConfigCacheKey(adapterConf);
+    return options.haplotypes === undefined
+        ? key
+        : `${key}|${[...options.haplotypes].sort().join(',')}`;
+}

package/esm/checkPlugins.d.ts

@@ -5,6 +5,8 @@ export declare const PLUGIN_STORE_URL = "https://jbrowse.org/plugin-store/v2/plu
 export declare function fetchPlugins(): Promise<{
     plugins: JBrowsePlugin[];
 }>;
+/** Drops the cached manifest, so the next read fetches again. For tests. */
+export declare function forgetFetchedPlugins(): void;
 export declare function checkPluginsAgainstStore(pluginsToCheck: PluginDefinition[], storePlugins: {
     plugins: JBrowsePlugin[];
 }): boolean;

package/esm/checkPlugins.js

@@ -7,18 +7,44 @@ import { isStorePluginDefinition, maybePluginUrl, pluginUrl, } from './pluginDef
 // reach PluginLoader with unvetted definitions.
 export const TRUSTED_PLUGIN_URL_PREFIXES = ['https://jbrowse.org/plugins/'];
 // v2 adds per-version JBrowse compatibility ranges + integrity hashes; the v1
-// plugins.json is still served for older clients. One constant, shared with the
-// hook every install surface reads (util/useFetchPlugins.ts), because the gate
-// and the list have to be looking at the same manifest — a second copy is how
-// one of them silently ends up on the unhashed v1 list, and then the gate
-// rejects a plugin the store just offered.
+// plugins.json is still served for older clients. Read only through
+// `fetchPlugins` below — the gate, the ref resolver and every install surface
+// have to be looking at the same manifest, and a second copy of the fetch is
+// how one of them silently ends up on the unhashed v1 list and then rejects a
+// plugin the store just offered.
 export const PLUGIN_STORE_URL = 'https://jbrowse.org/plugin-store/v2/plugins.json';
+// One request per page, shared by every reader.
+//
+// There are four in a boot that needs them — the config's trust gate, the
+// config's store refs, the session's gate, the session's refs — plus one per
+// time the plugin store widget is opened, since `useFetch` holds no data cache.
+// The HTTP cache does not fold them: the manifest is served
+// `cache-control: no-cache, must-revalidate`, so each is at least a
+// revalidation round trip, and concurrent ones do not dedupe at all.
+//
+// Held for the life of the page rather than for a window. A manifest that
+// changes mid-session would only matter to a store listing the user is looking
+// at, and an install from a stale row still resolves against the version the
+// row named.
+let cached;
 export async function fetchPlugins() {
-    const response = await fetch(PLUGIN_STORE_URL);
-    if (!response.ok) {
-        throw new Error(`HTTP ${response.status} ${response.statusText} fetching plugins`);
-    }
-    return response.json();
+    // Rethrown to every caller and then forgotten, so a store that was down when
+    // the config loaded is retried when the widget opens.
+    cached ??= (async () => {
+        const response = await fetch(PLUGIN_STORE_URL);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} ${response.statusText} fetching plugins`);
+        }
+        return response.json();
+    })().catch((error) => {
+        cached = undefined;
+        throw error;
+    });
+    return cached;
+}
+/** Drops the cached manifest, so the next read fetches again. For tests. */
+export function forgetFetchedPlugins() {
+    cached = undefined;
 }
 function isTrustedUrl(url) {
     return TRUSTED_PLUGIN_URL_PREFIXES.some(prefix => url.startsWith(prefix));
@@ -47,13 +73,8 @@ function isTrustedDefinition(def) {
 // version-pinned build. A config plugin is "in the store" if its url is any of
 // these.
 function storePluginUrls(p) {
-    const top = [p.url, p.umdUrl, p.esmUrl, p.cjsUrl];
-    const versioned = (p.versions ?? []).flatMap(v => [
-        v.url,
-        v.umdUrl,
-        v.esmUrl,
-        v.cjsUrl,
-    ]);
+    const top = [p.url, p.umdUrl, p.esmUrl];
+    const versioned = (p.versions ?? []).flatMap(v => [v.url, v.umdUrl, v.esmUrl]);
     return [...top, ...versioned].filter(url => url !== undefined);
 }
 export function checkPluginsAgainstStore(pluginsToCheck, storePlugins) {

package/esm/configuration/bamIndexFields.d.ts

@@ -0,0 +1,49 @@
+/**
+ * BAM's `index`, which is the tabix pair over a different enumeration: BAI/CSI
+ * rather than TBI/CSI, with its own default and its own placeholder name.
+ * Folding the two would mean a slot whose vocabulary depends on its adapter,
+ * which is why `tabixIndexFields` says BAM is deliberately not there.
+ *
+ * Only the enumeration differs. `fillIndexType` is the same function, since a
+ * `.csi` names itself the same way whichever sibling format it stands in for.
+ */
+export declare const bamIndexFields: {
+    readonly indexType: {
+        readonly model: import("@jbrowse/mobx-state-tree").ISimpleType<"BAI" | "CSI">;
+        readonly type: 'stringEnum';
+        readonly defaultValue: 'BAI';
+        readonly description: '`BAI` is the usual `samtools index` output. `CSI` is required for a reference longer than 512 Mb, which BAI cannot address. Derived from the index file name where the config names a `.csi` and leaves this unset.';
+    };
+    readonly location: {
+        readonly type: 'fileLocation';
+        readonly defaultValue: {
+            readonly uri: '/path/to/my.bam.bai';
+            readonly locationType: 'UriLocation';
+        };
+        readonly description: 'location of the index. Only needed when it is not named `<file>.bam.bai` (or `.bam.csi`), the names the `uri` shorthand assumes.';
+    };
+};
+/**
+ * #config BamIndex
+ * #category adapter
+ * Where a BAM's index is and which of the two kinds it is. `indexType` is
+ * derived from the index file's own name where the config names a `.csi` and
+ * leaves it unset, so the usual config states neither — the `uri` shorthand
+ * derives both, and `csi: true` beside it switches the pair together. Spell
+ * `location` out for an index that does not sit beside its BAM; a `.csi` named
+ * there is read as a CSI without `indexType` as well.
+ */
+export declare function bamIndexSchema(): import("./configurationSchema.ts").ConfigurationSchemaType<{
+    readonly indexType: {
+        type: "stringEnum";
+    } & {
+        model: import("@jbrowse/mobx-state-tree").ISimpleType<"BAI" | "CSI">;
+    } & {
+        defaultValue: string;
+    };
+    readonly location: {
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
+    };
+}, import("./configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("./requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;

package/esm/configuration/bamIndexFields.js

@@ -0,0 +1,41 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { ConfigurationSchema } from './configurationSchema.js';
+import { fillIndexType } from './indexType.js';
+/**
+ * BAM's `index`, which is the tabix pair over a different enumeration: BAI/CSI
+ * rather than TBI/CSI, with its own default and its own placeholder name.
+ * Folding the two would mean a slot whose vocabulary depends on its adapter,
+ * which is why `tabixIndexFields` says BAM is deliberately not there.
+ *
+ * Only the enumeration differs. `fillIndexType` is the same function, since a
+ * `.csi` names itself the same way whichever sibling format it stands in for.
+ */
+export const bamIndexFields = {
+    indexType: {
+        model: types.enumeration('IndexType', ['BAI', 'CSI']),
+        type: 'stringEnum',
+        defaultValue: 'BAI',
+        description: '`BAI` is the usual `samtools index` output. `CSI` is required for a reference longer than 512 Mb, which BAI cannot address. Derived from the index file name where the config names a `.csi` and leaves this unset.',
+    },
+    location: {
+        type: 'fileLocation',
+        defaultValue: {
+            uri: '/path/to/my.bam.bai',
+            locationType: 'UriLocation',
+        },
+        description: 'location of the index. Only needed when it is not named `<file>.bam.bai` (or `.bam.csi`), the names the `uri` shorthand assumes.',
+    },
+};
+/**
+ * #config BamIndex
+ * #category adapter
+ * Where a BAM's index is and which of the two kinds it is. `indexType` is
+ * derived from the index file's own name where the config names a `.csi` and
+ * leaves it unset, so the usual config states neither — the `uri` shorthand
+ * derives both, and `csi: true` beside it switches the pair together. Spell
+ * `location` out for an index that does not sit beside its BAM; a `.csi` named
+ * there is read as a CSI without `indexType` as well.
+ */
+export function bamIndexSchema() {
+    return ConfigurationSchema('BamIndex', { ...bamIndexFields }, { preProcessSnapshot: fillIndexType });
+}