@jbrowse/plugin-config 4.3.0 → 5.0.0-beta.1

package/esm/ConfigurationEditorWidget/model.d.ts

@@ -1,11 +1,18 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+/**
+ * #stateModel ConfigurationEditorWidget
+ * Widget for editing a config model's slots in a form: holds the target
+ * configuration and debounce-saves edits back to the session.
+ */
 export default function stateModelFactory(_pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
-    type: import("@jbrowse/mobx-state-tree").ISimpleType<"ConfigurationEditorWidget">;
+    type: import("@jbrowse/mobx-state-tree").ILiteralType<"ConfigurationEditorWidget">;
 }, {
     target: AnyConfigurationModel | undefined;
+    expandedDisplayId: string | undefined;
 } & {
     setTarget(newTarget: AnyConfigurationModel | undefined): void;
+    setExpandedDisplayId(displayId: string | undefined): void;
     afterCreate(): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ConfigurationEditorWidget/model.js

@@ -2,6 +2,11 @@ import { getSession } from '@jbrowse/core/util';
 import { ElementId } from '@jbrowse/core/util/types/mst';
 import { addDisposer, getSnapshot, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
+/**
+ * #stateModel ConfigurationEditorWidget
+ * Widget for editing a config model's slots in a form: holds the target
+ * configuration and debounce-saves edits back to the session.
+ */
 export default function stateModelFactory(_pluginManager) {
     return types
         .model('ConfigurationEditorWidget', {
@@ -9,24 +14,58 @@ export default function stateModelFactory(_pluginManager) {
         type: types.literal('ConfigurationEditorWidget'),
     })
         .volatile(() => ({
+        // Target is stored as volatile since it doesn't need to be serialized.
+        // The target is an MST model from track.configuration (which creates
+        // an MST model from frozen config via ConfigurationReference).
         target: undefined,
+        // displayId of the display active in the view this editor was opened
+        // from; its config accordion expands by default while the track's other
+        // (incompatible/inactive) displays start collapsed
+        expandedDisplayId: undefined,
     }))
         .actions(self => ({
         setTarget(newTarget) {
             self.target = newTarget;
         },
+        setExpandedDisplayId(displayId) {
+            self.expandedDisplayId = displayId;
+        },
         afterCreate() {
             let timeout;
+            // Auto-save configuration changes with 400ms debounce. The autorun
+            // reacts to any changes in the target configuration model and persists
+            // them back to the session after a short delay via
+            // updateTrackConfiguration, which routes admin edits to the jbrowse
+            // config in place and everyone else's to a shareable per-track delta
+            // (trackConfigDeltas) against the admin base. It keys off trackId; in
+            // practice the widget is only opened on track configs. A config with no
+            // trackId (assembly/connection) degrades gracefully: updateTrackConfiguration
+            // finds no base/session/connection home and the edit just applies to the
+            // live MST node in memory for this session.
+            //
+            // BaseTrackModel's afterAttach runs a sibling debounced save (a reaction
+            // on the same config node) for direct setSlot quick-edits on a *shown*
+            // track. Both intentionally coexist: this widget also handles an unshown
+            // track edited from the selector, which has no BaseTrackModel. When both
+            // fire they compute an identical delta, deduped in updateTrackConfiguration
+            // — don't drop one to "simplify".
             addDisposer(self, autorun(() => {
                 if (self.target) {
+                    // track configs (the practical case) carry a trackId; a
+                    // trackId-less snapshot degrades to an in-memory edit (see above)
                     const snapshot = getSnapshot(self.target);
                     clearTimeout(timeout);
                     timeout = setTimeout(() => {
                         const session = getSession(self);
-                        session.jbrowse.updateTrackConf(snapshot);
+                        session.updateTrackConfiguration(snapshot);
                     }, 400);
                 }
             }));
+            // ensure a pending debounced save can't fire after disposal, where
+            // getSession(self) would throw on the now-detached node
+            addDisposer(self, () => {
+                clearTimeout(timeout);
+            });
         },
     }));
 }

package/esm/FromConfigAdapter/FromConfigAdapter.d.ts

@@ -4,6 +4,11 @@ import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
 import type { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util/simpleFeature';
 import type { NoAssemblyRegion } from '@jbrowse/core/util/types';
+export declare function mergeFeaturesToRegions(features: Map<string, Feature[]>): {
+    refName: string;
+    start: number;
+    end: number;
+}[];
 export declare function makeFeatures(fdata: SimpleFeatureSerialized[]): Map<string, Feature[]>;
 export default class FromConfigAdapter extends BaseFeatureDataAdapter {
     protected features: Map<string, Feature[]>;
@@ -11,7 +16,7 @@ export default class FromConfigAdapter extends BaseFeatureDataAdapter {
     getRefNames(): Promise<string[]>;
     getRefNameAliases(): Promise<{
         refName: string;
-        aliases: any;
+        aliases: unknown;
     }[]>;
     getFeatures(region: NoAssemblyRegion): import("rxjs").Observable<Feature>;
 }

package/esm/FromConfigAdapter/FromConfigAdapter.js

@@ -2,6 +2,35 @@ import { readConfObject } from '@jbrowse/core/configuration';
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
+export function mergeFeaturesToRegions(features) {
+    const regions = [];
+    for (const [refName, feats] of features) {
+        let currentRegion;
+        for (const feature of feats) {
+            if (currentRegion &&
+                currentRegion.end >= feature.get('start') &&
+                currentRegion.start <= feature.get('end')) {
+                // take the max: a fully-contained feature (smaller end) must not
+                // shrink the merged region
+                currentRegion.end = Math.max(currentRegion.end, feature.get('end'));
+            }
+            else {
+                if (currentRegion) {
+                    regions.push(currentRegion);
+                }
+                currentRegion = {
+                    refName,
+                    start: feature.get('start'),
+                    end: feature.get('end'),
+                };
+            }
+        }
+        if (currentRegion) {
+            regions.push(currentRegion);
+        }
+    }
+    return regions;
+}
 export function makeFeatures(fdata) {
     const features = new Map();
     for (const entry of fdata) {
@@ -14,6 +43,7 @@ export function makeFeatures(fdata) {
         }
         bucket.push(f);
     }
+    // sort the features on each reference sequence by start coordinate
     for (const refFeatures of features.values()) {
         refFeatures.sort((a, b) => a.get('start') - b.get('start'));
     }
@@ -38,7 +68,7 @@ export default class FromConfigAdapter extends BaseFeatureDataAdapter {
     getFeatures(region) {
         const { refName, start, end } = region;
         return ObservableCreate(async (observer) => {
-            const features = this.features.get(refName) || [];
+            const features = this.features.get(refName) ?? [];
             for (const f of features) {
                 if (f.get('end') > start && f.get('start') < end) {
                     observer.next(f);

package/esm/FromConfigAdapter/configSchema.d.ts

@@ -1,7 +1,40 @@
+/**
+ * #config FromConfigAdapter
+ * #trackType FeatureTrack
+ * #fileFormat inline | Inline features | Features written straight into config.json
+ * supplies features inline in the config instead of reading a file, useful for
+ * small feature sets added via a URL or session spec
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'FromConfigAdapter',
+ *   features: [
+ *     { uniqueId: 'f1', refName: 'ctgA', start: 100, end: 200, name: 'feature1' },
+ *   ],
+ * }
+ * ```
+ */
 declare const configSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    features: {
-        type: string;
-        defaultValue: never[];
+    /**
+     * #slot
+     * stable identifier used as the adapter cache key; avoids hashing the
+     * (potentially large) features array. optional — falls back to hash.
+     */
+    readonly adapterId: {
+        readonly type: "string";
+        readonly defaultValue: "";
+    };
+    /**
+     * #slot
+     * the features themselves, as an array of plain objects. Each needs a
+     * `uniqueId`, `refName`, `start` and `end` (0-based half-open); anything
+     * else — `name`, `type`, `score`, `strand`, nested `subfeatures` — is
+     * carried through onto the feature as-is.
+     */
+    readonly features: {
+        readonly type: "frozen";
+        readonly defaultValue: readonly [];
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default configSchema;

package/esm/FromConfigAdapter/configSchema.js

@@ -1,9 +1,41 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-function x() { }
+/**
+ * #config FromConfigAdapter
+ * #trackType FeatureTrack
+ * #fileFormat inline | Inline features | Features written straight into config.json
+ * supplies features inline in the config instead of reading a file, useful for
+ * small feature sets added via a URL or session spec
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'FromConfigAdapter',
+ *   features: [
+ *     { uniqueId: 'f1', refName: 'ctgA', start: 100, end: 200, name: 'feature1' },
+ *   ],
+ * }
+ * ```
+ */
 const configSchema = ConfigurationSchema('FromConfigAdapter', {
+    /**
+     * #slot
+     * stable identifier used as the adapter cache key; avoids hashing the
+     * (potentially large) features array. optional — falls back to hash.
+     */
+    adapterId: {
+        type: 'string',
+        defaultValue: '',
+    },
+    /**
+     * #slot
+     * the features themselves, as an array of plain objects. Each needs a
+     * `uniqueId`, `refName`, `start` and `end` (0-based half-open); anything
+     * else — `name`, `type`, `score`, `strand`, nested `subfeatures` — is
+     * carried through onto the feature as-is.
+     */
     features: {
         type: 'frozen',
         defaultValue: [],
     },
-}, { explicitlyTyped: true, implicitIdentifier: 'adapterId' });
+}, { explicitlyTyped: true });
 export default configSchema;

package/esm/FromConfigAdapter/index.js

@@ -1,10 +1,10 @@
 import { AdapterType } from '@jbrowse/core/pluggableElementTypes';
-import configSchema from "./configSchema.js";
+import configSchema from './configSchema.js';
 export default function FromConfigAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'FromConfigAdapter',
         configSchema,
-        getAdapterClass: () => import("./FromConfigAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./FromConfigAdapter.js').then(r => r.default),
         adapterMetadata: {
             hiddenFromGUI: true,
         },

package/esm/FromConfigRegionsAdapter/FromConfigRegionsAdapter.d.ts

@@ -3,9 +3,17 @@ import type PluginManager from '@jbrowse/core/PluginManager';
 import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import type { RegionsAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { getSubAdapterType } from '@jbrowse/core/data_adapters/dataAdapterCache';
+/**
+ * Adapter that just returns the features defined in its `features` configuration
+ * key, like:
+ *   `"features": [ { "refName": "ctgA", "start":1, "end":20 }, ... ]`
+ */
 export default class FromConfigRegionsAdapter extends BaseAdapter implements RegionsAdapter {
     private features;
     constructor(config: AnyConfigurationModel, getSubAdapter?: getSubAdapterType, pluginManager?: PluginManager);
+    /**
+     * Get refName, start, and end for all features after collapsing any overlaps
+     */
     getRegions(): Promise<{
         refName: string;
         start: number;

package/esm/FromConfigRegionsAdapter/FromConfigRegionsAdapter.js

@@ -1,6 +1,11 @@
 import { readConfObject } from '@jbrowse/core/configuration';
 import { BaseAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { makeFeatures } from "../FromConfigAdapter/FromConfigAdapter.js";
+import { makeFeatures, mergeFeaturesToRegions, } from '../FromConfigAdapter/FromConfigAdapter.js';
+/**
+ * Adapter that just returns the features defined in its `features` configuration
+ * key, like:
+ *   `"features": [ { "refName": "ctgA", "start":1, "end":20 }, ... ]`
+ */
 export default class FromConfigRegionsAdapter extends BaseAdapter {
     features;
     constructor(config, getSubAdapter, pluginManager) {
@@ -8,31 +13,11 @@ export default class FromConfigRegionsAdapter extends BaseAdapter {
         const f = readConfObject(config, 'features');
         this.features = makeFeatures(f);
     }
+    /**
+     * Get refName, start, and end for all features after collapsing any overlaps
+     */
     async getRegions() {
-        const regions = [];
-        for (const [refName, features] of this.features) {
-            let currentRegion;
-            for (const feature of features) {
-                if (currentRegion &&
-                    currentRegion.end >= feature.get('start') &&
-                    currentRegion.start <= feature.get('end')) {
-                    currentRegion.end = feature.get('end');
-                }
-                else {
-                    if (currentRegion) {
-                        regions.push(currentRegion);
-                    }
-                    currentRegion = {
-                        refName,
-                        start: feature.get('start'),
-                        end: feature.get('end'),
-                    };
-                }
-            }
-            if (currentRegion) {
-                regions.push(currentRegion);
-            }
-        }
+        const regions = mergeFeaturesToRegions(this.features);
         regions.sort((a, b) => a.refName.localeCompare(b.refName));
         return regions;
     }

package/esm/FromConfigRegionsAdapter/configSchema.d.ts

@@ -1,7 +1,46 @@
+/**
+ * #config FromConfigRegionsAdapter
+ * #trackType ReferenceSequenceTrack
+ * #fileFormat inline | Inline regions | refNames and sizes only, no sequence
+ * used for specifying refNames+sizes of an assembly
+ *
+ * #example
+ * Supplies refNames+sizes with no sequence, as the adapter of an assembly's
+ * `sequence` (a `ReferenceSequenceTrack`):
+ * ```js
+ * {
+ *   type: 'ReferenceSequenceTrack',
+ *   trackId: 'my_refseq',
+ *   adapter: {
+ *     type: 'FromConfigRegionsAdapter',
+ *     features: [
+ *       { uniqueId: 'ctgA', refName: 'ctgA', start: 0, end: 50000 },
+ *       { uniqueId: 'ctgB', refName: 'ctgB', start: 0, end: 6079 },
+ *     ],
+ *   },
+ * }
+ * ```
+ */
 declare const regionsConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    features: {
-        type: string;
-        defaultValue: never[];
+    /**
+     * #slot
+     * stable identifier used as the adapter cache key; avoids hashing the
+     * (potentially large) features array. optional — falls back to hash.
+     */
+    readonly adapterId: {
+        readonly type: "string";
+        readonly defaultValue: "";
+    };
+    /**
+     * #slot
+     * one entry per reference sequence, each with a `uniqueId`, `refName`,
+     * `start: 0` and `end` set to that sequence's length. This is what defines
+     * the assembly's reference names and sizes; no bases are supplied, so
+     * base-level views are empty.
+     */
+    readonly features: {
+        readonly type: "frozen";
+        readonly defaultValue: readonly [];
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default regionsConfigSchema;

package/esm/FromConfigRegionsAdapter/configSchema.js

@@ -1,12 +1,49 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
-function x() { }
+/**
+ * #config FromConfigRegionsAdapter
+ * #trackType ReferenceSequenceTrack
+ * #fileFormat inline | Inline regions | refNames and sizes only, no sequence
+ * used for specifying refNames+sizes of an assembly
+ *
+ * #example
+ * Supplies refNames+sizes with no sequence, as the adapter of an assembly's
+ * `sequence` (a `ReferenceSequenceTrack`):
+ * ```js
+ * {
+ *   type: 'ReferenceSequenceTrack',
+ *   trackId: 'my_refseq',
+ *   adapter: {
+ *     type: 'FromConfigRegionsAdapter',
+ *     features: [
+ *       { uniqueId: 'ctgA', refName: 'ctgA', start: 0, end: 50000 },
+ *       { uniqueId: 'ctgB', refName: 'ctgB', start: 0, end: 6079 },
+ *     ],
+ *   },
+ * }
+ * ```
+ */
 const regionsConfigSchema = ConfigurationSchema('FromConfigRegionsAdapter', {
+    /**
+     * #slot
+     * stable identifier used as the adapter cache key; avoids hashing the
+     * (potentially large) features array. optional — falls back to hash.
+     */
+    adapterId: {
+        type: 'string',
+        defaultValue: '',
+    },
+    /**
+     * #slot
+     * one entry per reference sequence, each with a `uniqueId`, `refName`,
+     * `start: 0` and `end` set to that sequence's length. This is what defines
+     * the assembly's reference names and sizes; no bases are supplied, so
+     * base-level views are empty.
+     */
     features: {
         type: 'frozen',
         defaultValue: [],
     },
 }, {
     explicitlyTyped: true,
-    implicitIdentifier: 'adapterId',
 });
 export default regionsConfigSchema;

package/esm/FromConfigRegionsAdapter/index.js

@@ -1,10 +1,10 @@
 import { AdapterType } from '@jbrowse/core/pluggableElementTypes';
-import configSchema from "./configSchema.js";
+import configSchema from './configSchema.js';
 export default function FromConfigRegionsAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'FromConfigRegionsAdapter',
         configSchema,
-        getAdapterClass: () => import("./FromConfigRegionsAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./FromConfigRegionsAdapter.js').then(r => r.default),
         adapterMetadata: {
             hiddenFromGUI: true,
         },

package/esm/FromConfigSequenceAdapter/FromConfigSequenceAdapter.d.ts

@@ -1,12 +1,25 @@
 import FromConfigAdapter from '../FromConfigAdapter/FromConfigAdapter.ts';
-import type { RegionsAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { BaseOptions, RegionsAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
 import type { Feature } from '@jbrowse/core/util/simpleFeature';
 import type { NoAssemblyRegion } from '@jbrowse/core/util/types';
 export default class FromConfigSequenceAdapter extends FromConfigAdapter implements RegionsAdapter {
+    /**
+     * Fetch features for a certain region
+     * @param region - Region
+     * @returns Observable of Feature objects in the region
+     */
     getFeatures(region: NoAssemblyRegion): import("rxjs").Observable<Feature>;
     getRegions(): Promise<{
+        refName: string;
         start: number;
         end: number;
-        refName: string;
     }[]>;
+    /**
+     * `BaseSequenceAdapter`'s default, which this cannot inherit — it extends
+     * `FromConfigAdapter` — and which anything resolving a sequence SUB-adapter
+     * requires by name: `getSequenceSubAdapter` checks for the method and refuses
+     * an adapter without it, so a GC content track over a from-config assembly
+     * failed with "provides no sequence".
+     */
+    getSequence(region: NoAssemblyRegion, opts?: BaseOptions): Promise<string | undefined>;
 }

package/esm/FromConfigSequenceAdapter/FromConfigSequenceAdapter.js

@@ -1,50 +1,42 @@
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
 import SimpleFeature from '@jbrowse/core/util/simpleFeature';
-import { firstValueFrom } from 'rxjs';
-import { toArray } from 'rxjs/operators';
-import FromConfigAdapter from "../FromConfigAdapter/FromConfigAdapter.js";
+import FromConfigAdapter, { mergeFeaturesToRegions, } from '../FromConfigAdapter/FromConfigAdapter.js';
 export default class FromConfigSequenceAdapter extends FromConfigAdapter {
+    /**
+     * Fetch features for a certain region
+     * @param region - Region
+     * @returns Observable of Feature objects in the region
+     */
     getFeatures(region) {
-        return ObservableCreate(async (observer) => {
-            const feats = await firstValueFrom(super.getFeatures(region).pipe(toArray()));
-            const feat = feats[0];
-            observer.next(new SimpleFeature({
-                ...feat.toJSON(),
-                uniqueId: `${feat.id()}:${region.start}-${region.end}`,
-                end: region.end,
-                start: region.start,
-                seq: feat
-                    .get('seq')
-                    .slice(Math.max(region.start - feat.get('start'), 0), Math.max(region.end - feat.get('start'), 0)),
-            }));
+        const { refName, start, end } = region;
+        return ObservableCreate(observer => {
+            const feats = this.features.get(refName) ?? [];
+            const feat = feats.find(f => f.get('end') > start && f.get('start') < end);
+            if (feat) {
+                const featStart = feat.get('start');
+                observer.next(new SimpleFeature({
+                    ...feat.toJSON(),
+                    uniqueId: `${feat.id()}:${start}-${end}`,
+                    start,
+                    end,
+                    seq: feat.get('seq').slice(Math.max(start - featStart, 0), Math.max(end - featStart, 0)),
+                }));
+            }
             observer.complete();
         });
     }
     async getRegions() {
-        const regions = [];
-        for (const [refName, features] of this.features) {
-            let currentRegion;
-            for (const feature of features) {
-                if (currentRegion &&
-                    currentRegion.end >= feature.get('start') &&
-                    currentRegion.start <= feature.get('end')) {
-                    currentRegion.end = feature.get('end');
-                }
-                else {
-                    if (currentRegion) {
-                        regions.push(currentRegion);
-                    }
-                    currentRegion = {
-                        refName,
-                        start: feature.get('start'),
-                        end: feature.get('end'),
-                    };
-                }
-            }
-            if (currentRegion) {
-                regions.push(currentRegion);
-            }
-        }
-        return regions;
+        return mergeFeaturesToRegions(this.features);
+    }
+    /**
+     * `BaseSequenceAdapter`'s default, which this cannot inherit — it extends
+     * `FromConfigAdapter` — and which anything resolving a sequence SUB-adapter
+     * requires by name: `getSequenceSubAdapter` checks for the method and refuses
+     * an adapter without it, so a GC content track over a from-config assembly
+     * failed with "provides no sequence".
+     */
+    async getSequence(region, opts) {
+        const features = await this.getFeaturesArray({ ...region, assemblyName: '' }, opts);
+        return features[0]?.get('seq');
     }
 }

package/esm/FromConfigSequenceAdapter/configSchema.d.ts

@@ -1,7 +1,45 @@
+/**
+ * #config FromConfigSequenceAdapter
+ * #trackType ReferenceSequenceTrack
+ * #fileFormat inline | Inline sequence | Each feature's `seq` holds the bases for its region
+ * supplies reference sequence inline in the config; each feature's `seq` holds
+ * the bases for its region
+ *
+ * #example
+ * Used as the adapter of an assembly's `sequence` (a `ReferenceSequenceTrack`):
+ * ```js
+ * {
+ *   type: 'ReferenceSequenceTrack',
+ *   trackId: 'my_refseq',
+ *   adapter: {
+ *     type: 'FromConfigSequenceAdapter',
+ *     features: [
+ *       { uniqueId: 'ctgA', refName: 'ctgA', start: 0, end: 10, seq: 'ATGCATGCAT' },
+ *     ],
+ *   },
+ * }
+ * ```
+ */
 declare const sequenceConfigSchema: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    features: {
-        type: string;
-        defaultValue: never[];
+    /**
+     * #slot
+     * stable identifier used as the adapter cache key; avoids hashing the
+     * (potentially large) features array. optional — falls back to hash.
+     */
+    readonly adapterId: {
+        readonly type: "string";
+        readonly defaultValue: "";
+    };
+    /**
+     * #slot
+     * one entry per reference sequence, each with a `uniqueId`, `refName`,
+     * `start`, `end`, and a `seq` string holding the bases for that span. The
+     * bases live in the config, so this is for small sequences — a plasmid, a
+     * test contig — not a genome.
+     */
+    readonly features: {
+        readonly type: "frozen";
+        readonly defaultValue: readonly [];
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default sequenceConfigSchema;