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

package/esm/ReExports/names.js

@@ -0,0 +1,3 @@
+// Published as `@jbrowse/core/ReExports/names` for plugin build tooling; the
+// generated file keeps its suffix so the formatter skips it.
+export { default } from './names.generated.js';

package/esm/TextSearch/TextSearchManager.d.ts

@@ -1,6 +1,6 @@
 import QuickLRU from '../util/QuickLRU/index.ts';
 import type PluginManager from '../PluginManager.ts';
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyConfigurationModel, AnyTrackConfig } from '../configuration/index.ts';
 import type { BaseTextSearchAdapter, BaseTextSearchArgs } from '../data_adapters/BaseAdapter/index.ts';
 import type BaseResult from './BaseResults.ts';
 export interface SearchIndex {
@@ -30,9 +30,9 @@ export default class TextSearchManager {
     relevantAdapters(assemblyName: string): AnyConfigurationModel[];
     relevantIndexes(assemblyName: string): SearchIndex[];
     getAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): AnyConfigurationModel[];
-    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): {
+    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyTrackConfig[]): {
         conf: AnyConfigurationModel;
-        trackId: string;
+        trackId: any;
     }[];
     search(args: BaseTextSearchArgs, assemblyName: string): Promise<BaseResult[]>;
     searchIndexes(args: BaseTextSearchArgs, assemblyName: string): Promise<TextSearchReport>;

package/esm/TextSearch/TextSearchManager.js

@@ -3,7 +3,7 @@ import { hydrateTrackConfig, readConfObject } from '../configuration/index.js';
 import { adapterConfigCacheKey } from '../data_adapters/dataAdapterCache.js';
 import QuickLRU from '../util/QuickLRU/index.js';
 import { checkAbortSignal, isAbortException } from '../util/aborting.js';
-import { allSessionTracks, canonicalAssemblyNames } from '../util/tracks.js';
+import { allSessionTracks, canonicalAssemblyNames, getConfAssemblyNamesOrNone, } from '../util/tracks.js';
 // A misconfigured or unreachable index (a 404 .ix, a config missing
 // ixFilePath) must not take down search as a whole: the remaining indexes, and
 // the refName results the caller merges in afterwards, are still useful. The
@@ -84,24 +84,17 @@ export default class TextSearchManager {
     getTrackAdaptersWithAssembly(matches, confs) {
         return confs
             .filter(conf => {
-            const indexNames = readConfObject(conf, [
-                'textSearching',
-                'textSearchAdapter',
-                'assemblyNames',
-            ]);
-            return (!!readConfObject(conf, ['textSearching', 'textSearchAdapter']) &&
-                matches(indexNames?.length
-                    ? indexNames
-                    : readConfObject(conf, 'assemblyNames')));
+            const adapter = conf.textSearching?.textSearchAdapter;
+            const indexNames = adapter?.assemblyNames;
+            return (!!adapter &&
+                matches(indexNames?.length ? indexNames : getConfAssemblyNamesOrNone(conf)));
         })
             .flatMap(track => {
             const live = isStateTreeNode(track)
                 ? track
                 : hydrateTrackConfig(this.pluginManager, track);
             const conf = live?.textSearching.textSearchAdapter;
-            return conf
-                ? [{ conf, trackId: readConfObject(track, 'trackId') }]
-                : [];
+            return conf ? [{ conf, trackId: track.trackId }] : [];
         });
     }
     async search(args, assemblyName) {

package/esm/assemblyManager/assembly.d.ts

@@ -22,6 +22,9 @@ export interface BasicRegion {
 }
 /**
  * #stateModel Assembly
+ * Loads an assembly's reference sequence names, refName aliases and
+ * cytobands, and maps each data file's refNames onto the assembly's canonical
+ * names.
  */
 export default function assemblyFactory(assemblyConfigType: IAnyType, pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
     /**
@@ -294,6 +297,12 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
      */
     isValidRefName(refName: string): boolean;
 } & {
+    /**
+     * #method
+     * Whether the assembly's `circularRefNames` lists this refName, matched
+     * through its aliases.
+     */
+    isCircularRefName(refName: string): boolean;
     /**
      * #method
      * Where a refName — canonical or any alias — sits in this assembly's own

package/esm/assemblyManager/assembly.js

@@ -17,6 +17,9 @@ export { lookupGeneticCodeId } from './geneticCodes.js';
 export { refNameMismatchMessage } from './refNameMismatch.js';
 /**
  * #stateModel Assembly
+ * Loads an assembly's reference sequence names, refName aliases and
+ * cytobands, and maps each data file's refNames onto the assembly's canonical
+ * names.
  */
 export default function assemblyFactory(assemblyConfigType, pluginManager) {
     return types
@@ -542,6 +545,16 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
         },
     }))
         .views(self => ({
+        /**
+         * #method
+         * Whether the assembly's `circularRefNames` lists this refName, matched
+         * through its aliases.
+         */
+        isCircularRefName(refName) {
+            const canonical = self.getCanonicalRefName2(refName);
+            const names = self.getConf('circularRefNames') ?? [];
+            return names.some(name => self.getCanonicalRefName2(name) === canonical);
+        },
         /**
          * #method
          * Where a refName — canonical or any alias — sits in this assembly's own

package/esm/assemblyManager/assemblyConfigSchema.d.ts

@@ -1,6 +1,6 @@
 import type PluginManager from '../PluginManager.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
-export { expandAssemblySequence, expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expandAssemblyConfigShorthand.ts';
+export { expandAssemblySequence, expandAssemblySequenceAdapter, expandAssemblyShorthand, expandSidecarShorthand, refNameAliasAdapterType, } from './expandAssemblyConfigShorthand.ts';
 /**
  * #config BaseAssembly
  * #category assemblyManagement
@@ -116,6 +116,11 @@ declare function assemblyConfigSchema(pluginManager: PluginManager): import("../
     } & {
         defaultValue: unknown;
     };
+    readonly circularRefNames: {
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
+    };
     readonly geneticCodesLocation: {
         type: "maybeFileLocation";
     };

package/esm/assemblyManager/assemblyConfigSchema.js

@@ -1,26 +1,10 @@
 import { ConfigurationSchema } from '../configuration/index.js';
-import { expandAssemblyShorthand } from './expandAssemblyConfigShorthand.js';
-export { expandAssemblySequence, expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expandAssemblyConfigShorthand.js';
-/**
- * A sidecar sub-schema written as just its file: `'aliases.txt'` or
- * `{ uri: 'aliases.txt' }` becomes `{ adapter: { type, uri } }`, with `type`
- * picked from the uri. baseUri, stamped by addRelativeUris, rides along. An
- * explicit `adapter` passes through untouched.
- */
+import { expandAssemblyShorthand, expandSidecarShorthand, refNameAliasAdapterType, } from './expandAssemblyConfigShorthand.js';
+export { expandAssemblySequence, expandAssemblySequenceAdapter, expandAssemblyShorthand, expandSidecarShorthand, refNameAliasAdapterType, } from './expandAssemblyConfigShorthand.js';
 function fileAdapterShorthand(typeFor) {
     return {
         shorthand: 'uri',
-        preProcessSnapshot: (snap) => {
-            const { uri, baseUri, adapter } = snap;
-            if (adapter) {
-                return snap;
-            }
-            return {
-                adapter: typeof uri === 'string'
-                    ? { type: typeFor(uri), uri, ...(baseUri ? { baseUri } : {}) }
-                    : { type: typeFor('') },
-            };
-        },
+        preProcessSnapshot: (snap) => expandSidecarShorthand(snap, typeFor),
     };
 }
 /**
@@ -172,6 +156,25 @@ function assemblyConfigSchema(pluginManager) {
             defaultValue: {},
             description: 'Map of reference sequence name to NCBI genetic-code (translation table) id for sequences not using the standard code, e.g. { "chrM": 2 }',
         },
+        /**
+         * #slot
+         * The reference sequences that are circular: a plasmid, an organelle, a
+         * bacterial chromosome. The circular view closes a circle of one such
+         * sequence into a ring with no gap at its origin; every other sequence
+         * keeps the gap that marks its two ends. Names are matched through
+         * refName aliasing.
+         *
+         * #example
+         * The human mitochondrion, by its RefSeq accession:
+         * ```js
+         * ['NC_012920.1']
+         * ```
+         */
+        circularRefNames: {
+            type: 'stringArray',
+            defaultValue: [],
+            description: 'Reference sequences that are circular (a plasmid, an organelle, a bacterial chromosome), which the circular view closes into a ring',
+        },
         /**
          * #slot
          * Optional file (tab-separated `refName<TAB>geneticCodeId`, `#` comments
@@ -198,9 +201,7 @@ function assemblyConfigSchema(pluginManager) {
              * commonly a tsv like chromAliases.txt from UCSC or similar
              */
             adapter: pluginManager.pluggableConfigSchemaType('adapter'),
-        }, fileAdapterShorthand(uri => /sequence_report\.tsv(\.gz)?$/i.test(uri)
-            ? 'NcbiSequenceReportAliasAdapter'
-            : 'RefNameAliasAdapter')),
+        }, fileAdapterShorthand(refNameAliasAdapterType)),
         cytobands: ConfigurationSchema('Cytoband', {
             /**
              * #slot cytobands.adapter

package/esm/assemblyManager/assemblyManager.d.ts

@@ -12,6 +12,8 @@ export interface AssemblyBaseOpts {
 }
 /**
  * #stateModel AssemblyManager
+ * Keeps an `Assembly` for each assembly in the config and the session, and
+ * looks one up by name or alias.
  */
 declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
     /**
@@ -81,6 +83,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -192,6 +195,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -259,6 +263,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -346,6 +351,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -413,6 +419,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -532,6 +539,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -599,6 +607,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -682,6 +691,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -749,6 +759,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {

package/esm/assemblyManager/assemblyManager.js

@@ -85,6 +85,8 @@ function createUnrecognizedAssemblyReports() {
 }
 /**
  * #stateModel AssemblyManager
+ * Keeps an `Assembly` for each assembly in the config and the session, and
+ * looks one up by name or alias.
  */
 function assemblyManagerFactory(conf, pm) {
     return types

package/esm/assemblyManager/expandAssemblyConfigShorthand.d.ts

@@ -7,6 +7,15 @@ export declare function referenceSequenceTrackId(assemblyName: unknown): string;
  * filled in when omitted. Returns `snap` itself when there is nothing to do.
  */
 export declare function expandAssemblySequence<T>(snap: T): T;
+/**
+ * A sidecar sub-schema written as just its file: `{ uri: 'aliases.txt' }`
+ * becomes `{ adapter: { type, uri } }`, with `type` picked from the uri.
+ * baseUri, stamped by addRelativeUris, rides along. An explicit `adapter`
+ * passes through untouched.
+ */
+export declare function expandSidecarShorthand(snap: Record<string, unknown>, typeFor: (uri: string) => string): Record<string, unknown>;
+/** The alias adapter an assembly's `refNameAliases` file is read with. */
+export declare function refNameAliasAdapterType(uri: string): "NcbiSequenceReportAliasAdapter" | "RefNameAliasAdapter";
 /**
  * Expand an assembly snapshot's own shorthands into the `sequence` an assembly
  * config declares: {@link expandAssemblySequence}, then the sequence adapter's

package/esm/assemblyManager/expandAssemblyConfigShorthand.js

@@ -37,6 +37,29 @@ export function expandAssemblySequence(snap) {
         },
     };
 }
+/**
+ * A sidecar sub-schema written as just its file: `{ uri: 'aliases.txt' }`
+ * becomes `{ adapter: { type, uri } }`, with `type` picked from the uri.
+ * baseUri, stamped by addRelativeUris, rides along. An explicit `adapter`
+ * passes through untouched.
+ */
+export function expandSidecarShorthand(snap, typeFor) {
+    const { uri, baseUri, adapter } = snap;
+    if (adapter) {
+        return snap;
+    }
+    return {
+        adapter: typeof uri === 'string'
+            ? { type: typeFor(uri), uri, ...(baseUri ? { baseUri } : {}) }
+            : { type: typeFor('') },
+    };
+}
+/** The alias adapter an assembly's `refNameAliases` file is read with. */
+export function refNameAliasAdapterType(uri) {
+    return /sequence_report\.tsv(\.gz)?$/i.test(uri)
+        ? 'NcbiSequenceReportAliasAdapter'
+        : 'RefNameAliasAdapter';
+}
 /**
  * Expand an assembly snapshot's own shorthands into the `sequence` an assembly
  * config declares: {@link expandAssemblySequence}, then the sequence adapter's

package/esm/checkPlugins.js

@@ -1,4 +1,4 @@
-import { isStorePluginDefinition, maybePluginUrl, pluginUrl, } from './pluginDefinitions.js';
+import { isStorePluginDefinition, maybePluginUrl, resolvedPluginUrl, } from './pluginDefinitions.js';
 // Whether a set of plugin definitions is safe to load without asking the user.
 // Lives in core rather than a product because every product that can be handed
 // a config by an untrusted party needs the same gate: Web from its address bar,
@@ -66,8 +66,11 @@ function isTrustedUrl(url) {
  * exist to prevent on the loader side.
  */
 function isTrustedDefinition(def) {
-    const url = maybePluginUrl(def);
-    return url === undefined ? isStorePluginDefinition(def) : isTrustedUrl(url);
+    if (maybePluginUrl(def) === undefined) {
+        return isStorePluginDefinition(def);
+    }
+    const url = resolvedPluginUrl(def);
+    return url !== undefined && isTrustedUrl(url);
 }
 // Every url a store entry can resolve to: the top-level fallback plus each
 // version-pinned build. A config plugin is "in the store" if its url is any of
@@ -82,7 +85,10 @@ export function checkPluginsAgainstStore(pluginsToCheck, storePlugins) {
         return true;
     }
     const storeUrls = new Set(storePlugins.plugins.flatMap(storePluginUrls));
-    return pluginsToCheck.every(p => isTrustedDefinition(p) || storeUrls.has(pluginUrl(p)));
+    return pluginsToCheck.every(p => {
+        const url = resolvedPluginUrl(p);
+        return isTrustedDefinition(p) || (url !== undefined && storeUrls.has(url));
+    });
 }
 export async function checkPlugins(pluginsToCheck) {
     // Trusted-by-prefix plugins and store refs are accepted without consulting

package/esm/configuration/configurationSchema.d.ts

@@ -6,17 +6,8 @@ import type { AnyConfigurationModel, AnyConfigurationSchemaType, ConfigNodeActio
 import type { IAnyType, ISimpleType, IType, ReferenceIdentifier, SnapshotIn, SnapshotOut } from '@jbrowse/mobx-state-tree';
 export type { AnyConfigurationModel, AnyConfigurationSchemaType, } from './types.ts';
 /**
- * The three entry kinds `makeConfigurationSchemaModel` classifies: a slot
- * definition, a constant (bare string/number), or a nested sub-schema — which
- * is the **MST type** `ConfigurationSchema()` returned, hence `IAnyType`.
- *
- * A raw nested `ConfigurationSchemaDefinition` used to be a fourth member here,
- * and it was both dead and load-bearing in the wrong direction: nothing
- * constructs a sub-schema from one (the loop has no branch for it, so it throws
- * "no type set for config slot"), while a plain object of strings and numbers is
- * exactly what a *slot definition* is — so every slot in the repo matched that
- * member instead and was never checked against `ConfigSlotDefinition` at all.
- * `type: 'enum'`, a name this system has never had, compiled for years that way.
+ * Each entry is a slot definition, a constant (bare string/number), or a
+ * sub-schema: the MST type `ConfigurationSchema()` returned.
  */
 export interface ConfigurationSchemaDefinition {
     [n: string]: ConfigSlotDefinition | string | number | IAnyType;
@@ -46,9 +37,14 @@ export interface ConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfiguration
      */
     shorthandWith?: Record<string, unknown>;
     /**
-     * Refuse a snapshot key the schema does not declare, where MST would drop
-     * it in silence. Checked after the `shorthand` lift and before
-     * `preProcessSnapshot`, on the same paths.
+     * What a snapshot key the schema does not declare meets, where MST would
+     * drop it in silence: a config loading names the key on the console and
+     * loads without it, so a config written for another version still draws,
+     * and a write (`refusingUndeclaredKeys`) refuses it. Checked after the
+     * `shorthand` lift and the schema's own `preProcessSnapshot`, on the same
+     * paths, and only on the schema's own snapshot where a union runs every
+     * member over an entry. A display, the `explicitlyTyped` schema identified
+     * by `displayId`, is closed unless it says `false`.
      */
     closed?: boolean;
     /**
@@ -58,38 +54,36 @@ export interface ConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfiguration
      * snapshot or a settings bag arrives by, and read by the `displayDefaults`
      * router, so one declaration serves a config entry, the shorthand object, a
      * share link and an agent's bag alike. A spelling the snapshot already
-     * carries wins over the one a lift produces.
+     * carries wins over the one a lift produces, and a name the schema declares
+     * is left alone, so a subclass keeping a slot its base retired still takes
+     * it. A lift reading no value and answering no member (`() => ({})`) drops
+     * the key, which `jbrowse validate` reports as never read.
      */
     retired?: Record<string, RetiredSpelling>;
     /**
-     * A colour object's defaults by `field`, `*` for any other: the scale while
+     * A color object's defaults by `field`, `*` for any other: the scale while
      * `scale` is unset, and the members that scale reads while unwritten.
      */
     fieldPresets?: Readonly<Record<string, {
         readonly scale: string;
     }>>;
+    /**
+     * The field a color object naming neither a field nor a constant maps
+     * (`withImpliedField`).
+     */
+    impliedField?: string;
     preProcessSnapshot?: (snapshot: Record<string, unknown>) => Record<string, unknown>;
     requires?: REQUIREMENT[];
 }
 type SchemaHook = (self: any) => any;
 /**
- * Options as **stored**: what a caller passes, except that the three
- * MST-chained hooks may have accumulated a chain by merging in a
- * `baseConfiguration`. A caller's single function is a valid chain of one, so
- * `ConfigurationSchemaOptions` is assignable to this and no call site changes.
- *
- * They stay a chain rather than being folded into one function because MST is
- * what does the chaining: `.actions()` is called once per entry, which is what
- * puts the base's members on `self` by the time the subclass's function runs,
- * and what lets the subclass override one by redeclaring its name. Folding to
- * `self => ({...base(self), ...child(self)})` would give neither, and would
- * corrupt `extend` outright (it returns `{actions, views, state}`, so a spread
- * merge drops whichever side declared fewer of the three).
- *
- * `preProcessSnapshot` is the exception and composes into a single function,
- * `child(base(snapshot))`: the base normalizes and migrates first, the subclass
- * refines. It has to stay one function because `preProcessSnapshotWith` runs it
- * straight off the registry, over a partial settings bag as well as a snapshot.
+ * Options as stored, with a `baseConfiguration`'s hooks merged in. `actions`,
+ * `views` and `extend` stay a chain that MST applies one call per entry, which
+ * puts the base's members on `self` before the subclass's function runs and
+ * lets the subclass override one by name; a spread merge would give neither,
+ * and would drop half of `extend`'s `{actions, views, state}`.
+ * `preProcessSnapshot` composes into one function, `child(base(snapshot))`,
+ * since `preProcessSnapshotWith` runs it off the registry.
  */
 export interface MergedConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfigurationSchemaType | undefined, EXPLICIT_IDENTIFIER extends string | undefined> extends Omit<ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER>, 'actions' | 'views' | 'extend'> {
     actions?: SchemaHook | SchemaHook[];
@@ -98,21 +92,16 @@ export interface MergedConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfigu
 }
 declare function makeConfigurationSchemaModel<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends MergedConfigurationSchemaOptions<any, any>>(modelName: string, schemaDefinition: DEFINITION, options: OPTIONS): import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<Record<string, any>, ConfigNodeActions, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>, [undefined]>;
 /**
- * DEFINITION is unconstrained on purpose. It carries the *merged* definition —
- * `MergeConfigDef`, an unresolved conditional that cannot be checked against a
- * constraint — and intersecting it with `ConfigurationSchemaDefinition` to
- * satisfy one would put an index signature straight back into
- * `keyof DEFINITION`. The authoring check lives on `ConfigurationSchema`'s own
- * parameter, where the literal arrives, and on the `extends` clause below.
+ * DEFINITION is unconstrained: a constraint would put an index signature back
+ * into `keyof DEFINITION`. `ConfigurationSchema`'s own parameter checks the
+ * literal where it arrives. ADR-145.
  */
 export interface ConfigurationSchemaType<out DEFINITION, OPTIONS extends ConfigurationSchemaOptions<any, any>> extends ReturnType<typeof makeConfigurationSchemaModel<DEFINITION & ConfigurationSchemaDefinition, OPTIONS>> {
     /**
-     * Overrides the factory's, whose props come off a `Record<string, any>` and
-     * so admit every name. Slots come from the definition — the identifier and
-     * an `explicitlyTyped` schema's `type` ride in as two of them — and the brand
-     * names this schema, which is what `ConfigurationSchemaForModel` infers back
-     * out. `TypeWithoutSTN` too, since a wrapper — `types.optional`,
-     * `types.stripDefault` — builds its instance from that one.
+     * Replaces the factory's `Record<string, any>` props with the definition's,
+     * and brands the node with this schema for `ConfigurationSchemaForModel`.
+     * `TypeWithoutSTN` is what a `types.optional` or `stripDefault` wrapper builds
+     * its instance from.
      */
     readonly Type: ConfigNodeProps<DEFINITION> & ConfigNodeActions & ConfigNodeBrand<this>;
     readonly TypeWithoutSTN: ConfigNodeProps<DEFINITION> & ConfigNodeActions;
@@ -133,70 +122,32 @@ export declare function ConfigurationSchema<const DEFINITION extends Configurati
 } : unknown), BASE_SCHEMA>, ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER, EXPLICITLY_TYPED>>;
 /**
  * #api core/configuration
- * Hydrate a plain track config into a live config node, dispatching on its
- * `type` to find the schema. `session.tracks` holds `types.frozen` plain
- * objects until something references a track (ADR-031). One of those holds only
- * what was literally authored: a slot at its schema default is absent,
- * `preProcessSnapshot` has not run, and nothing that walks a live node applies
- * to it.
+ * Hydrate a plain track config, such as a `session.tracks` entry, into a live
+ * config node, dispatching on its `type` to find the schema. A plain entry
+ * holds only what was authored: a slot at its default is absent and
+ * `preProcessSnapshot` has not run.
  *
- * Use it where a caller needs the resolved config and may be handed either
- * form. The About dialog's "Copy config" is reached from two menus, and one of
- * them passes a `session.tracks` entry.
- *
- * Returns **undefined** when the config names a track type no plugin
- * registered, or when `create` rejects it as invalid. An un-hydrated config has
- * never been validated, so the dialog opening over it should not throw. Callers
- * fall back to using the plain object.
- *
- * Shares `TrackConfigurationReference`'s per-PluginManager cache, so hydrating
- * the same entry twice returns the same node, and in an admin session a track
- * opened later resolves to that same node. A non-admin's open track
- * resolves to the session's private working copy (ADR-032), and this function
- * returns the pristine mirror beside it. The two have the same content;
- * `CopyConfigEntryPoints.test.ts` tests both cases.
+ * Returns **undefined** when no plugin registered the type or `create` rejects
+ * the config, which has never been validated; callers fall back to the plain
+ * object. Hydrating one entry twice returns one node. A shown track resolves to
+ * the session's working copy instead (ADR-032), which has the same content.
  */
 export declare function hydrateTrackConfig(pluginManager: PluginManager, config: Record<string, unknown>): AnyConfigurationModel | undefined;
 type ConfigReferenceInstance<SCHEMA extends AnyConfigurationSchemaType> = SCHEMA extends ConfigurationSchemaType<infer D, any> ? IsAny<D> extends true ? any : SCHEMA['Type'] : SCHEMA['Type'];
 /**
- * Static type of the value `ConfigurationReference` produces, and therefore of a
- * track/display state model's `configuration` prop. Its **instance** type is a
- * clean, single-branded schema instance (see `ConfigReferenceInstance`), so
- * `ConfigurationSchemaForModel` — and thus `getConf(self, slot)` /
- * `readConfObject(self.configuration, slot)` — recovers the concrete schema and
- * its precise slot value types instead of `any`. The snapshot types stay
- * `id-string | schema-snapshot`, matching the runtime union (`idOrSnapshotUnion`):
- * a saved config serializes to its id string, and both an id string and a full
- * inline snapshot are accepted as input — so views that push string ids or
- * synthesized configs (`CircularView`, `SvInspectorView`) keep type-checking.
- *
- * Built by `Omit`-ing `Type` off `IType` and re-adding it, rather than reusing
- * the runtime `ITypeUnion`: `IType`'s own `Type` is `STNValue<T, this>`, which
- * re-brands `T` with `IStateTreeNode<this>`. Layering that over an already-branded
- * `SCHEMA['Type']` (which carries `IStateTreeNode<SCHEMA>`) double-brands the
- * node, and the two competing `IStateTreeNode<…>` brands defeat the single
- * `infer SCHEMA` in `ConfigurationSchemaForModel` (leaving it `any`). Re-adding a
- * plain `Type` keeps the single brand. See the "Config read type narrowing"
- * section of `packages/core/src/configuration/CLAUDE.md`.
+ * The type of a track or display model's `configuration` prop: snapshots are
+ * `id | config`, as the runtime union takes, and the instance carries the
+ * concrete schema so `getConf(self, slot)` narrows. `Type` is re-added rather
+ * than taken from `IType`, whose `STNValue` would brand the node a second time
+ * and leave `ConfigurationSchemaForModel` inferring `any`.
  */
 export type IConfigurationReference<SCHEMA extends AnyConfigurationSchemaType> = Omit<IType<ReferenceIdentifier | SnapshotIn<SCHEMA>, ReferenceIdentifier | SnapshotOut<SCHEMA>, ConfigReferenceInstance<SCHEMA>>, 'Type'> & {
     readonly Type: ConfigReferenceInstance<SCHEMA>;
 };
 /**
- * Dispatch by the schema's identifier: `trackId` → track-ref (resolves through
- * `session.getTrackById`), `displayId` → display-ref (resolves through the
- * parent track's displays array), anything else → plain reference.
- *
- * Display schemas must declare `explicitIdentifier: 'displayId'` (directly or
- * via `baseConfiguration: baseLinearDisplayConfigSchema`, which merges its
- * options through `preprocessConfigurationSchemaArguments`).
- *
- * The return is annotated `IConfigurationReference<SCHEMATYPE>` (see its doc)
- * so `self.configuration` carries the concrete schema. The three runtime
- * branches produce MST reference/union types over `schemaType` that are
- * assignable to that annotation, so `return ref` needs no cast — and must not
- * get one: a prior `as SCHEMATYPE` was dropped because it narrowed `SnapshotIn`
- * to just the object branch and forced callers pushing string ids to
- * `@ts-expect-error` (see `TrackConfigurationReference`'s note).
+ * A reference resolved by the schema's identifier: a `trackId` through the
+ * session, a `displayId` through the containing track's `displays`, anything
+ * else by MST's own identifier lookup. No `as SCHEMATYPE` on the return: it
+ * would narrow `SnapshotIn` to the object branch and refuse a string id.
  */
 export declare function ConfigurationReference<SCHEMATYPE extends AnyConfigurationSchemaType>(schemaType: SCHEMATYPE): IConfigurationReference<SCHEMATYPE>;