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

package/esm/assemblyManager/assembly.d.ts

@@ -41,7 +41,7 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
     /**
      * #volatile
      */
-    volatileRegions: BasicRegion[] | undefined;
+    regions: BasicRegion[] | undefined;
     /**
      * #volatile
      */
@@ -196,10 +196,6 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
      * #getter
      */
     readonly initialized: boolean;
-    /**
-     * #getter
-     */
-    readonly regions: BasicRegion[] | undefined;
     /**
      * #getter
      * note: lowerCaseRefNameAliases not included here: this allows the list
@@ -298,6 +294,16 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
      */
     isValidRefName(refName: string): boolean;
 } & {
+    /**
+     * #method
+     * Where a refName — canonical or any alias — sits in this assembly's own
+     * order, which is what chromosome painting hands its palette out by.
+     * Canonicalized first because a name off a feature can be the FILE's
+     * spelling (`1` against a canonical `chr1`), and a missed probe is silent:
+     * the painter falls back to a hash color. Undefined before the regions
+     * load and for a name the assembly lacks.
+     */
+    getRefNamePosition(refName: string): number | undefined;
     /**
      * #method
      * The other names this assembly has for the same sequence as `refName` —
@@ -316,21 +322,17 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
      *
      * The load reports progress (the adapter's index download, or for an
      * in-memory adapter the whole file) through the `statusCallback` of
-     * whichever caller started it. The others await it silently, and that is
-     * deliberate rather than a gap worth plumbing around: the callers sharing
-     * an entry are almost always the N displayed regions of ONE display, so
-     * their callbacks all write into that display's aggregated status bar and
-     * the first one is already reporting on behalf of the rest. The costs of
-     * getting this "right" — a listener set per key, registration, and
-     * deregistration on settle — buy visibility only for a second display on
-     * the same file, and for a first caller torn down mid-load, which is a
-     * no-op rather than a hazard because the callbacks are `isAlive`-guarded
-     * at the display end.
+     * whichever caller started it. The other callers get no progress
+     * updates. The callers sharing an entry are almost always the N
+     * displayed regions of one display, so their callbacks all write into
+     * that display's aggregated status bar, where the first caller already
+     * reports for the rest. A listener set per key, with registration and
+     * deregistration on settle, would add progress only for a second display
+     * on the same file and for a first caller torn down mid-load. The latter
+     * is a no-op because the display guards its callbacks with `isAlive`.
      *
-     * If that ever stops being enough, the fix is not a subscription list
-     * bolted on here: it is for the assembly to hold the in-flight status as
-     * observable state that consumers read, which is what this model is
-     * already made of.
+     * If per-caller progress is ever needed, the assembly should hold the
+     * in-flight status as observable state that consumers read.
      */
     getRefNameMapForAdapter(adapterConf: AdapterConf, options: BaseOptions): Promise<RefNameAliases>;
     /**

package/esm/assemblyManager/assembly.js

@@ -1,13 +1,13 @@
 import { addDisposer, getParent, isAlive, types, } from '@jbrowse/mobx-state-tree';
 import { onBecomeObserved } from 'mobx';
 import { getConf } from '../configuration/index.js';
-import { adapterConfigCacheKey } from '../data_adapters/dataAdapterCache.js';
 import QuickLRU from '../util/QuickLRU/index.js';
 import { createStatusFanOut, createStatusWindow, statusFraction, statusMessageText, statusSource, } from '../util/progress.js';
 import { getAssemblyRegions, getCytobands, getRefNameAliases, } from './assemblyAdapters.js';
 import { getGeneticCodesFromFile, lookupGeneticCodeId } from './geneticCodes.js';
 import { loadRefNameMap } from './loadRefNameMap.js';
 import { defaultRefNameColors } from './refNameColors.js';
+import { refNameMapKey } from './refNameMapKey.js';
 import { buildRefNameMaps, checkRefName, groupNamesByCanonicalRefName, } from './refNameMaps.js';
 // re-exported so `@jbrowse/core/assemblyManager/assembly` stays the public entry
 // point for these, as plugins import them from here
@@ -52,7 +52,7 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
             /**
              * #volatile
              */
-            volatileRegions: undefined,
+            regions: undefined,
             /**
              * #volatile
              */
@@ -140,7 +140,7 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
          * #getter
          */
         get displayName() {
-            return self.getConf('displayName') || self.getConf('name') || '';
+            return self.getConf('displayName') || this.name;
         },
         /**
          * #getter
@@ -197,7 +197,7 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
          * in place by the time refNameAliases becomes observable.
          */
         setLoaded({ regions, refNameAliases, lowerCaseRefNameAliases, canonicalToSeqAdapterRefNames, cytobands, geneticCodes, }) {
-            self.volatileRegions = regions;
+            self.regions = regions;
             self.refNameAliases = refNameAliases;
             self.lowerCaseRefNameAliases = lowerCaseRefNameAliases;
             self.canonicalToSeqAdapterRefNames = canonicalToSeqAdapterRefNames;
@@ -365,7 +365,7 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
             // are watched because consumers observe them independently (regions vs
             // refNameAliases/allRefNames); load() is idempotent so the overlapping
             // triggers collapse to a single fetch.
-            for (const prop of ['volatileRegions', 'refNameAliases']) {
+            for (const prop of ['regions', 'refNameAliases']) {
                 addDisposer(self, onBecomeObserved(self, prop, () => {
                     // nothing awaits this fire-and-forget kick, so swallow the
                     // rejection: load() has already logged it and recorded it on
@@ -382,12 +382,6 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
         get initialized() {
             return !!self.refNameAliases;
         },
-        /**
-         * #getter
-         */
-        get regions() {
-            return self.volatileRegions;
-        },
         /**
          * #getter
          * note: lowerCaseRefNameAliases not included here: this allows the list
@@ -548,6 +542,18 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
         },
     }))
         .views(self => ({
+        /**
+         * #method
+         * Where a refName — canonical or any alias — sits in this assembly's own
+         * order, which is what chromosome painting hands its palette out by.
+         * Canonicalized first because a name off a feature can be the FILE's
+         * spelling (`1` against a canonical `chr1`), and a missed probe is silent:
+         * the painter falls back to a hash color. Undefined before the regions
+         * load and for a name the assembly lacks.
+         */
+        getRefNamePosition(refName) {
+            return self.refNameToIndex?.get(self.getCanonicalRefName2(refName));
+        },
         /**
          * #method
          * The other names this assembly has for the same sequence as `refName` —
@@ -569,27 +575,23 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
          *
          * The load reports progress (the adapter's index download, or for an
          * in-memory adapter the whole file) through the `statusCallback` of
-         * whichever caller started it. The others await it silently, and that is
-         * deliberate rather than a gap worth plumbing around: the callers sharing
-         * an entry are almost always the N displayed regions of ONE display, so
-         * their callbacks all write into that display's aggregated status bar and
-         * the first one is already reporting on behalf of the rest. The costs of
-         * getting this "right" — a listener set per key, registration, and
-         * deregistration on settle — buy visibility only for a second display on
-         * the same file, and for a first caller torn down mid-load, which is a
-         * no-op rather than a hazard because the callbacks are `isAlive`-guarded
-         * at the display end.
+         * whichever caller started it. The other callers get no progress
+         * updates. The callers sharing an entry are almost always the N
+         * displayed regions of one display, so their callbacks all write into
+         * that display's aggregated status bar, where the first caller already
+         * reports for the rest. A listener set per key, with registration and
+         * deregistration on settle, would add progress only for a second display
+         * on the same file and for a first caller torn down mid-load. The latter
+         * is a no-op because the display guards its callbacks with `isAlive`.
          *
-         * If that ever stops being enough, the fix is not a subscription list
-         * bolted on here: it is for the assembly to hold the in-flight status as
-         * observable state that consumers read, which is what this model is
-         * already made of.
+         * If per-caller progress is ever needed, the assembly should hold the
+         * in-flight status as observable state that consumers read.
          */
         getRefNameMapForAdapter(adapterConf, options) {
             if (!options.sessionId) {
                 throw new Error('sessionId is required');
             }
-            const key = adapterConfigCacheKey(adapterConf);
+            const key = refNameMapKey(adapterConf, options);
             let entry = self.adapterLoads.get(key);
             if (!entry) {
                 // evict on failure so a later call can retry

package/esm/assemblyManager/assemblyAdapters.d.ts

@@ -4,7 +4,7 @@ import type { BaseOptions } from '../data_adapters/BaseAdapter/index.ts';
 interface AdapterArgs {
     config: AnyConfigurationModel;
     pluginManager: PluginManager;
-    opts?: BaseOptions;
+    opts: BaseOptions;
 }
 export declare function getRefNameAliases({ config, pluginManager, opts, }: AdapterArgs): Promise<import("../data_adapters/BaseAdapter/BaseRefNameAliasAdapter.ts").Alias[]>;
 export declare function getCytobands({ config, pluginManager, opts, }: AdapterArgs): Promise<import("../util/simpleFeature.ts").Feature[]>;

package/esm/assemblyManager/assemblyAdapters.js

@@ -1,3 +1,4 @@
+import { isRegionsAdapter } from '../data_adapters/BaseAdapter/util.js';
 async function instantiateAdapter(config, pluginManager) {
     const CLASS = await pluginManager
         .getAdapterType(config.type)
@@ -6,7 +7,7 @@ async function instantiateAdapter(config, pluginManager) {
 }
 export async function getRefNameAliases({ config, pluginManager, opts, }) {
     const adapter = await instantiateAdapter(config, pluginManager);
-    return adapter.getRefNameAliases(opts ?? {});
+    return adapter.getRefNameAliases(opts);
 }
 export async function getCytobands({ config, pluginManager, opts, }) {
     const adapter = await instantiateAdapter(config, pluginManager);
@@ -14,5 +15,10 @@ export async function getCytobands({ config, pluginManager, opts, }) {
 }
 export async function getAssemblyRegions({ config, pluginManager, opts, }) {
     const adapter = await instantiateAdapter(config, pluginManager);
-    return adapter.getRegions(opts ?? {});
+    // an assembly written with no sequence at all gets whatever adapter the
+    // union defaults to, which lists no regions
+    if (!isRegionsAdapter(adapter)) {
+        throw new Error(`a ${config.type} cannot supply an assembly's sequence: give the assembly a "uri" or a "sequence.adapter"`);
+    }
+    return adapter.getRegions(opts);
 }

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 { expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expandAssemblyConfigShorthand.ts';
+export { expandAssemblySequence, expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expandAssemblyConfigShorthand.ts';
 /**
  * #config BaseAssembly
  * #category assemblyManagement
@@ -31,15 +31,15 @@ export { expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expan
  * The flattest form: an assembly is just a `name` and a sequence-file `uri`.
  * jbrowse-core picks the adapter (`Bgzip`/`Indexed`/`TwoBit`) from the
  * extension, derives the `.fai`/`.gzi` siblings, and fills in the
- * `ReferenceSequenceTrack`. `refNameAliases`/`cytobands` take the same bare
- * `{ uri }` shorthand. (Keep the `uri` *key* rather than a bare string so
- * relative URIs still resolve against the config's location.)
+ * `ReferenceSequenceTrack`. `refNameAliases`/`cytobands` are each just their
+ * file, as a path or `{ uri }`; an alias file named `…sequence_report.tsv` is
+ * read as NCBI's sequence report, anything else as a chromAlias-style table.
  * ```js
  * {
  *   name: 'hg38',
  *   uri: 'https://example.com/hg38.fa.gz',
- *   refNameAliases: { uri: 'https://example.com/hg38.aliases.txt' },
- *   cytobands: { uri: 'https://example.com/hg38.cytoBand.txt' },
+ *   refNameAliases: 'https://example.com/hg38.aliases.txt',
+ *   cytobands: 'https://example.com/hg38.cytoBand.txt',
  * }
  * ```
  *
@@ -84,7 +84,8 @@ export { expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expan
  * #example custom-display-name-and-genetic-codes-sidecar
  * Sets a `displayName` for the assembly selector and loads the per-refName
  * genetic codes from a sidecar TSV (`geneticCodesLocation`) instead of inlining
- * them — handy when a config generator emits the mapping separately:
+ * them, which is the shape to use when a config generator emits the mapping
+ * separately:
  * ```js
  * {
  *   name: 'hg38',
@@ -99,102 +100,42 @@ export { expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expan
  * ```
  */
 declare function assemblyConfigSchema(pluginManager: PluginManager): import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * aliases are "reference name aliases" e.g. aliases for hg38 might be
-     * "GRCh38"
-     */
     readonly aliases: {
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
-        readonly description: "Other possible names for the assembly";
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * sequence refers to a reference sequence track that has an adapter
-     * containing, importantly, a sequence adapter such as
-     * IndexedFastaAdapter
-     */
     readonly sequence: import("../configuration/types.ts").AnyConfigurationSchemaType;
-    /**
-     * #slot
-     */
     readonly refNameColors: {
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
-        readonly description: "Define custom colors for each reference sequence. Will cycle through this list if there are not enough colors for every sequence.";
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * Maps a reference sequence name to an NCBI genetic-code (translation
-     * table) id for sequences that don't use the standard code, e.g.
-     * `{ "chrM": 2 }` for the vertebrate mitochondrial code or
-     * `{ "chrPltd": 11 }` for a plastid. Drives the reference sequence track's
-     * translation rows; unlisted refNames use the standard code (1). CDS-level
-     * translation reads the GFF `transl_table` attribute directly and ignores
-     * this.
-     *
-     * #example
-     * Mitochondrial contig translated with the vertebrate mitochondrial code
-     * (NCBI table 2), a plastid contig with table 11; keys are matched through
-     * refName aliasing:
-     * ```js
-     * { chrM: 2, chrPltd: 11 }
-     * ```
-     */
     readonly geneticCodes: {
-        readonly type: "frozen";
-        readonly defaultValue: {};
-        readonly description: "Map of reference sequence name to NCBI genetic-code (translation table) id for sequences not using the standard code, e.g. { \"chrM\": 2 }";
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * Optional file (tab-separated `refName<TAB>geneticCodeId`, `#` comments
-     * allowed) to load the same refName-to-genetic-code mapping from, instead
-     * of inlining it — useful when a config generator emits a sidecar rather
-     * than inlining per assembly. Entries in the inline `geneticCodes` slot
-     * take precedence over the file.
-     *
-     * #example
-     * The TSV is `refName<TAB>geneticCodeId` with optional `#` comment lines:
-     * ```js
-     * { uri: 'https://example.com/hg38.genetic_codes.tsv' }
-     * ```
-     */
     readonly geneticCodesLocation: {
-        readonly type: "fileLocation";
-        readonly defaultValue: {
-            readonly uri: "";
-            readonly locationType: "UriLocation";
-        };
-        readonly description: "Optional TSV file of refName<TAB>geneticCodeId, an alternative to inlining the geneticCodes map";
+        type: "maybeFileLocation";
     };
     readonly refNameAliases: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-        /**
-         * #slot refNameAliases.adapter
-         * refNameAliases help resolve e.g. chr1 and 1 as the same entity the
-         * data for refNameAliases are fetched from an adapter, that is
-         * commonly a tsv like chromAliases.txt from UCSC or similar
-         */
-        readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
-    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+        readonly adapter: import("@jbrowse/core/PluginManager").PluggableConfigSchemaType;
+    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
     readonly cytobands: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-        /**
-         * #slot cytobands.adapter
-         * cytoband data is fetched from an adapter, and can be displayed by
-         * a view type as ideograms
-         */
-        readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
-    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-    /**
-     * #slot
-     */
+        readonly adapter: import("@jbrowse/core/PluginManager").PluggableConfigSchemaType;
+    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
     readonly displayName: {
-        readonly type: "string";
-        readonly defaultValue: "";
-        readonly description: "A human readable display name for the assembly e.g. \"Homo sapiens (hg38)\" while the assembly name may just be \"hg38\"";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "name">>;
+    name: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "name", undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export default assemblyConfigSchema;
 /** the assembly config schema IType (use with `getConf`, `ConfigurationReference`, etc.) */
 export type BaseAssemblyConfigSchema = ReturnType<typeof assemblyConfigSchema>;

package/esm/assemblyManager/assemblyConfigSchema.js

@@ -1,6 +1,28 @@
 import { ConfigurationSchema } from '../configuration/index.js';
 import { expandAssemblyShorthand } from './expandAssemblyConfigShorthand.js';
-export { expandAssemblySequenceAdapter, 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.
+ */
+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('') },
+            };
+        },
+    };
+}
 /**
  * #config BaseAssembly
  * #category assemblyManagement
@@ -31,15 +53,15 @@ export { expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expan
  * The flattest form: an assembly is just a `name` and a sequence-file `uri`.
  * jbrowse-core picks the adapter (`Bgzip`/`Indexed`/`TwoBit`) from the
  * extension, derives the `.fai`/`.gzi` siblings, and fills in the
- * `ReferenceSequenceTrack`. `refNameAliases`/`cytobands` take the same bare
- * `{ uri }` shorthand. (Keep the `uri` *key* rather than a bare string so
- * relative URIs still resolve against the config's location.)
+ * `ReferenceSequenceTrack`. `refNameAliases`/`cytobands` are each just their
+ * file, as a path or `{ uri }`; an alias file named `…sequence_report.tsv` is
+ * read as NCBI's sequence report, anything else as a chromAlias-style table.
  * ```js
  * {
  *   name: 'hg38',
  *   uri: 'https://example.com/hg38.fa.gz',
- *   refNameAliases: { uri: 'https://example.com/hg38.aliases.txt' },
- *   cytobands: { uri: 'https://example.com/hg38.cytoBand.txt' },
+ *   refNameAliases: 'https://example.com/hg38.aliases.txt',
+ *   cytobands: 'https://example.com/hg38.cytoBand.txt',
  * }
  * ```
  *
@@ -84,7 +106,8 @@ export { expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expan
  * #example custom-display-name-and-genetic-codes-sidecar
  * Sets a `displayName` for the assembly selector and loads the per-refName
  * genetic codes from a sidecar TSV (`geneticCodesLocation`) instead of inlining
- * them — handy when a config generator emits the mapping separately:
+ * them, which is the shape to use when a config generator emits the mapping
+ * separately:
  * ```js
  * {
  *   name: 'hg38',
@@ -164,8 +187,7 @@ function assemblyConfigSchema(pluginManager) {
          * ```
          */
         geneticCodesLocation: {
-            type: 'fileLocation',
-            defaultValue: { uri: '', locationType: 'UriLocation' },
+            type: 'maybeFileLocation',
             description: 'Optional TSV file of refName<TAB>geneticCodeId, an alternative to inlining the geneticCodes map',
         },
         refNameAliases: ConfigurationSchema('RefNameAliases', {
@@ -176,26 +198,9 @@ function assemblyConfigSchema(pluginManager) {
              * commonly a tsv like chromAliases.txt from UCSC or similar
              */
             adapter: pluginManager.pluggableConfigSchemaType('adapter'),
-        }, {
-            // the alias file is always a RefNameAliasAdapter, so both its type
-            // and the `adapter` nesting are boilerplate: allow a bare
-            // `refNameAliases: { uri: 'aliases.txt' }` (baseUri, stamped next to
-            // the uri key by addRelativeUris, rides along). An explicit `adapter`
-            // passes through untouched; absent, the empty default is filled in.
-            preProcessSnapshot: snap => snap.adapter
-                ? snap
-                : {
-                    adapter: {
-                        type: 'RefNameAliasAdapter',
-                        ...(snap.uri
-                            ? {
-                                uri: snap.uri,
-                                ...(snap.baseUri ? { baseUri: snap.baseUri } : {}),
-                            }
-                            : {}),
-                    },
-                },
-        }),
+        }, fileAdapterShorthand(uri => /sequence_report\.tsv(\.gz)?$/i.test(uri)
+            ? 'NcbiSequenceReportAliasAdapter'
+            : 'RefNameAliasAdapter')),
         cytobands: ConfigurationSchema('Cytoband', {
             /**
              * #slot cytobands.adapter
@@ -203,24 +208,7 @@ function assemblyConfigSchema(pluginManager) {
              * a view type as ideograms
              */
             adapter: pluginManager.pluggableConfigSchemaType('adapter'),
-        }, {
-            // same shorthand as refNameAliases: `cytobands: { uri: 'cytoBand.txt' }`
-            // fills in the CytobandAdapter; an explicit `adapter` passes through,
-            // absent it defaults to the empty adapter.
-            preProcessSnapshot: snap => snap.adapter
-                ? snap
-                : {
-                    adapter: {
-                        type: 'CytobandAdapter',
-                        ...(snap.uri
-                            ? {
-                                uri: snap.uri,
-                                ...(snap.baseUri ? { baseUri: snap.baseUri } : {}),
-                            }
-                            : {}),
-                    },
-                },
-        }),
+        }, fileAdapterShorthand(() => 'CytobandAdapter')),
         /**
          * #slot
          */