@jbrowse/cli 5.0.0-beta.4 → 5.0.0-beta.8

package/dist/commands/validate/validateConfig.js

@@ -1,18 +1,16 @@
-// Checks a JBrowse config (or a saved session file) against the generated
-// config-slot manifest.
+// Checks a JBrowse config (or a saved session file): the generated JSON Schema
+// first, which reports every key or value the schema can judge, then the
+// cross-references a schema cannot express and the warnings for stale
+// spellings a migration still rewrites.
 //
-// Why this exists at all, given MST type-checks a config on load: **MST models
-// ignore snapshot keys they do not declare**. Write `bamLocatoin`, or a
-// `renderers: {...}` block from an older config, and nothing anywhere reports
-// it — the track loads, appears, and the setting silently does nothing. That is
-// the check no other layer performs, and it is the mistake config authors
-// (human or agent) make most.
+// Why a validator at all, given MST type-checks a config on load: MST models
+// ignore snapshot keys they do not declare, so a misspelt slot leaves the track
+// loading normally with the setting doing nothing.
 //
 // Pure: no filesystem, no process exit. The command wrapper owns both.
 import { configManifest } from './configManifest.generated.js';
-import { displayDefaultKeys } from './displayDefaultKeys.js';
+import { schemaProblems } from './schemaValidate.js';
 import { didYouMean } from './suggest.js';
-// ------------------------------------------------------------------ reporting
 class Report {
     problems = [];
     notes = [];
@@ -34,100 +32,58 @@ class Report {
         };
     }
 }
-// ------------------------------------------------------------------- checking
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-// Keys a schema entry accepts as input: what it declares, plus the shorthands
-// normalizeSnapshot expands — an adapter written with `uri` never mentions
-// `bamLocation`, and both forms are correct.
-function acceptedKeys(entry) {
-    return [...entry.slots.map(s => s.name), ...(entry.shorthandKeys ?? [])];
-}
-// A key JBrowse fills in for itself, so writing one by hand is an anti-pattern
-// whether or not the schema happens to declare a slot for it. Both halves get a
-// message that says so, because the generic ones send the author looking for a
-// typo in a key that is spelled correctly.
-//
-// `sequenceAdapter` is the standing case, and it is now uniform:
-// `getFeatureAdapter` and `CoreGetRefNames` prime every feature adapter's
-// `sequenceAdapterConfig` from the assembly the track is displayed against, and
-// `getSequenceSubAdapter` is what every adapter that reads a sequence resolves
-// through. So no track has to carry one — three grape/peach/volvox configs were
-// copying their own assembly's FASTA urls into a GC track, and two hg002 tracks
-// carried one on a `CramAdapter`, which declares no such slot at all.
-//
-// Two levels, and the split is this validator's own rule: an undeclared key does
-// nothing where it is written (error), a declared one works and is simply the
-// wrong way round (warning).
+// A declared `sequenceAdapter` works and is simply the wrong way round: every
+// feature adapter takes its sequence from the assembly the track is displayed
+// against, so a hand-written one pins the track to that source. An undeclared
+// one is the schema's unknown-key error, with its own message there.
 const SELF_SUPPLIED = {
-    sequenceAdapter: {
-        undeclared: 'JBrowse takes the sequence from the assembly the track is displayed against, and this adapter declares no `sequenceAdapter` slot, so the one written here is never read — delete it',
-        declared: '`sequenceAdapter` is set by hand. JBrowse takes the sequence from the assembly the track is displayed against, so this is only needed to read some OTHER sequence — and it pins the track to that source even when the assembly changes. Delete it unless that is what you meant',
-    },
+    sequenceAdapter: '`sequenceAdapter` is set by hand. JBrowse takes the sequence from the assembly the track is displayed against, so this is only needed to read some OTHER sequence — and it pins the track to that source even when the assembly changes. Delete it unless that is what you meant',
 };
-function checkSlots(obj, entry, where, report) {
-    const accepted = acceptedKeys(entry);
-    const legacyKeys = entry.legacyKeys ?? [];
-    for (const key of Object.keys(obj)) {
-        if (accepted.includes(key)) {
-            const selfSupplied = SELF_SUPPLIED[key];
-            if (selfSupplied) {
-                report.warn(`${where}.${key}`, selfSupplied.declared);
-            }
-            continue;
+// The warnings a slot table carries: a legacy key or value a migration
+// rewrites, and a declared key JBrowse fills in for itself.
+function warnSlots(obj, entry, where, report) {
+    const declared = new Set(entry.slots.map(s => s.name));
+    for (const [key, value] of Object.entries(obj)) {
+        if (declared.has(key) && SELF_SUPPLIED[key]) {
+            report.warn(`${where}.${key}`, SELF_SUPPLIED[key]);
         }
-        // JSON has no comments, so people reach for a `_comment` key. MST drops it
-        // like any other undeclared key, which is what the author wanted — calling
-        // that "silently does nothing" is true and useless, and a validator that
-        // cries wolf on a deliberate annotation is one an author learns to ignore.
-        if (/^_+comment/i.test(key)) {
-            continue;
+        else if (entry.legacyValues?.[key]?.includes(value)) {
+            report.warn(`${where}.${key}`, `${JSON.stringify(value)} is a legacy value of "${key}" that a migration rewrites — the config loads, but the current spelling is one of the enum's members`);
         }
-        // A legacy key is consumed by the schema's own preProcessSnapshot and
-        // lifted into current slots, so the config does load — but it is stale, and
-        // whether every setting inside it survived the lift is worth a look.
-        if (legacyKeys.includes(key)) {
+        else if (!declared.has(key) && entry.legacyKeys?.includes(key)) {
             report.warn(`${where}.${key}`, `"${key}" is a legacy key that a migration rewrites into current slots — the config loads, but check the settings inside it landed`);
-            continue;
         }
-        report.error(`${where}.${key}`, SELF_SUPPLIED[key]?.undeclared ??
-            `unknown slot "${key}"${didYouMean(key, accepted)} — JBrowse ignores keys it does not declare, so this setting silently does nothing`);
     }
-    // Recurse into sub-schemas the config actually filled in. One it omits is
-    // fine: the sub-schema supplies its own defaults.
     for (const slot of entry.slots) {
         const value = obj[slot.name];
-        if (slot.subSlots && isRecord(value)) {
-            checkSlots(value, { slots: slot.subSlots }, `${where}.${slot.name}`, report);
+        if (!slot.subSlots) {
+            continue;
+        }
+        for (const [item, suffix] of isRecord(value)
+            ? [[value, '']]
+            : Array.isArray(value)
+                ? value.map((v, i) => [v, `[${i}]`])
+                : []) {
+            if (isRecord(item)) {
+                warnSlots(item, { slots: slot.subSlots }, `${where}.${slot.name}${suffix}`, report);
+            }
         }
     }
 }
-// Resolves a `type` against one of the manifest's groups.
-//
-// An unrecognized type is a WARNING, never an error, and the line is drawn
-// there deliberately:
-//
-//   error   = JBrowse accepts the config and silently does the wrong thing
-//   warning = JBrowse will complain by itself when the config loads
-//
-// An unknown type is loud — MST throws "Unknown track type" on load, so the
-// author finds out either way. It is also frequently not wrong: a plugin
-// registers types this manifest never saw. An unknown *slot* has neither
-// property, which is why that one is the error.
+// Resolves a `type` against one of the manifest's groups. An unregistered type
+// is a warning: MST is loud about it on load, and a plugin registers types the
+// manifest never saw.
 function resolveType(obj, group, groupLabel, where, report) {
     const typeName = obj.type;
     if (typeof typeName !== 'string') {
-        report.error(where, `missing "type" — expected one of the ${groupLabel} types`);
         return undefined;
     }
     const canonical = typeName in group
         ? typeName
-        : // An old type name a current type still answers to. baseTrackConfig
-            // canonicalizes it before validation and sessionMigrations restores the
-            // settings that made the old type distinct, so this is supported config
-            // — check it against the type that absorbed it.
-            Object.keys(group).find(name => group[name].aliases?.includes(typeName));
+        : Object.keys(group).find(name => group[name].aliases?.includes(typeName));
     const entry = canonical === undefined ? undefined : group[canonical];
     if (entry && canonical !== undefined) {
         return { ...entry, canonicalName: canonical };
@@ -135,65 +91,26 @@ function resolveType(obj, group, groupLabel, where, report) {
     report.warn(where, `${groupLabel} type "${typeName}" is not registered by the core plugins${didYouMean(typeName, Object.keys(group))} — it may come from a plugin`);
     return undefined;
 }
-function checkAdapter(adapter, manifest, where, report) {
-    if (!isRecord(adapter)) {
-        report.error(where, 'missing "adapter"');
-        return;
-    }
-    const entry = resolveType(adapter, manifest.adapters, 'adapter', `${where}.type`, report);
-    if (entry) {
-        checkSlots(adapter, entry, where, report);
-    }
-}
-// A pluggable sub-object written inline: resolve its type against `group`, then
-// check its own slots. `connections`, `aggregateTextSearchAdapters` and a
-// track's `textSearching.textSearchAdapter` are all this shape, and none of
-// them was opened at all — a Trix path typo is a search that returns nothing,
-// which is the class of mistake this command exists to catch.
 function checkPluggable(obj, group, groupLabel, where, report) {
     if (!isRecord(obj)) {
-        report.error(where, `${groupLabel} must be an object`);
         return;
     }
     const entry = resolveType(obj, group, groupLabel, `${where}.type`, report);
     if (entry) {
-        checkSlots(obj, entry, where, report);
-    }
-}
-function checkDisplayDefaults(defaults, trackEntry, manifest, where, report) {
-    if (!isRecord(defaults)) {
-        report.error(where, 'displayDefaults must be an object of display settings');
-        return;
-    }
-    const accepted = displayDefaultKeys(trackEntry, manifest);
-    if (accepted.length === 0) {
-        return;
-    }
-    for (const key of Object.keys(defaults)) {
-        if (!accepted.includes(key)) {
-            report.error(`${where}.${key}`, `no display of this track declares "${key}"${didYouMean(key, accepted)}`);
-        }
+        warnSlots(obj, entry, where, report);
     }
 }
 function checkTrack(track, index, manifest, report, ctx) {
     const where = `tracks[${index}]`;
-    // The loose form: a data file and no adapter. JBrowse infers the track type
-    // and adapter from the file's extension at load, so neither is required
-    // here, and neither can be checked against the manifest without the format
-    // plugins' guessers — the keys written beside `uri` still are.
     const loose = typeof track.uri === 'string' && !('adapter' in track);
-    const entry = loose && track.type === undefined
-        ? undefined
-        : resolveType(track, manifest.tracks, 'track', `${where}.type`, report);
     const trackId = track.trackId;
-    if (typeof trackId !== 'string' || !trackId) {
-        report.error(`${where}.trackId`, 'missing "trackId"');
-    }
-    else if (ctx.seenTrackIds.has(trackId)) {
-        report.error(`${where}.trackId`, `duplicate trackId "${trackId}" — a later track with the same id shadows the earlier one`);
-    }
-    else {
-        ctx.seenTrackIds.add(trackId);
+    if (typeof trackId === 'string' && trackId) {
+        if (ctx.seenTrackIds.has(trackId)) {
+            report.error(`${where}.trackId`, `duplicate trackId "${trackId}" — a later track with the same id shadows the earlier one`);
+        }
+        else {
+            ctx.seenTrackIds.add(trackId);
+        }
     }
     const names = track.assemblyNames;
     if (!Array.isArray(names) || names.length === 0) {
@@ -204,120 +121,49 @@ function checkTrack(track, index, manifest, report, ctx) {
     else {
         for (const name of names) {
             if (typeof name === 'string' && !ctx.assemblyNames.has(name)) {
-                // The connection caveat leads and the spelling guess trails, because a
-                // connection needn't be in this file to supply the assembly — the one
-                // that supplies test_data/volvox's `volvox_del2` is added at runtime,
-                // and `did you mean "volvox_del"?` called a working config a typo.
+                // The connection caveat leads and the spelling guess trails: a
+                // connection added at runtime can supply the assembly, and a guess
+                // called a working config a typo.
                 report.error(`${where}.assemblyNames`, `assembly "${name}" is not defined in this config, and no connection here supplies one — though a connection added at runtime can${didYouMean(name, [...ctx.assemblyNames])}`);
             }
         }
     }
-    if (entry) {
-        // displayDefaults is a shorthand no track schema declares, so it is
-        // exempted from the track's own slot check and validated on its own terms.
-        checkSlots(track, {
-            ...entry,
-            shorthandKeys: [
-                ...(entry.shorthandKeys ?? []),
-                'displayDefaults',
-                ...(loose ? ['uri', 'index'] : []),
-            ],
-        }, where, report);
-        if (track.displayDefaults !== undefined) {
-            checkDisplayDefaults(track.displayDefaults, entry, manifest, `${where}.displayDefaults`, report);
-        }
-    }
+    checkPluggable(track, manifest.tracks, 'track', where, report);
     if (!loose) {
-        checkAdapter(track.adapter, manifest, `${where}.adapter`, report);
+        checkPluggable(track.adapter, manifest.adapters, 'adapter', `${where}.adapter`, report);
     }
     const textSearching = track.textSearching;
-    if (isRecord(textSearching) &&
-        textSearching.textSearchAdapter !== undefined) {
+    if (isRecord(textSearching)) {
         checkPluggable(textSearching.textSearchAdapter, manifest.textSearchAdapters, 'text search adapter', `${where}.textSearching.textSearchAdapter`, report);
     }
     if (Array.isArray(track.displays)) {
         for (const [i, display] of track.displays.entries()) {
-            if (!isRecord(display)) {
-                continue;
-            }
-            const displayWhere = `${where}.displays[${i}]`;
-            const displayEntry = resolveType(display, manifest.displays, 'display', `${displayWhere}.type`, report);
-            if (displayEntry) {
-                checkSlots(display, displayEntry, displayWhere, report);
-            }
+            checkPluggable(display, manifest.displays, 'display', `${where}.displays[${i}]`, report);
         }
     }
 }
 function checkAssembly(assembly, index, manifest, report) {
-    const where = `assemblies[${index}]`;
-    if (typeof assembly.name !== 'string' || !assembly.name) {
-        report.error(`${where}.name`, 'missing assembly "name"');
-    }
-    // An assembly has three levels of shorthand, all filled in by
-    // assemblyConfigSchema's preProcessSnapshot, and this used to reject every one
-    // of them — including `{ name, uri }`, which the cookbook calls the smallest
-    // possible config:
-    //
-    //   1. `{ name, uri }`                          -> sequence: { adapter: { uri } }
-    //   2. `sequence: { adapter: { uri } }`         -> adapter type from the extension
-    //   3. sequence with no type/trackId            -> ReferenceSequenceTrack, derived id
-    //
-    // Only (2) can't be checked here, and deliberately: the type is guessed
-    // through the `Core-guessAdapterForLocation` extension point, and this command
-    // loads no plugins on purpose. A `uri` is therefore taken as enough — saying
-    // nothing about an adapter we can't name beats calling a working config broken.
-    const sequence = assembly.sequence ??
-        (typeof assembly.uri === 'string'
-            ? { adapter: { uri: assembly.uri } }
-            : undefined);
-    if (!isRecord(sequence)) {
-        report.error(`${where}.sequence`, 'missing "sequence" track (or a `uri` naming the sequence file)');
-        return;
+    const sequence = assembly.sequence;
+    if (isRecord(sequence) && isRecord(sequence.adapter)) {
+        checkPluggable(sequence.adapter, manifest.adapters, 'adapter', `assemblies[${index}].sequence.adapter`, report);
     }
-    if (isRecord(sequence.adapter) && !('type' in sequence.adapter)) {
-        if (typeof sequence.adapter.uri !== 'string') {
-            report.error(`${where}.sequence.adapter`, 'adapter has neither a "type" nor a "uri" to infer one from');
-        }
-        return;
-    }
-    checkAdapter(sequence.adapter, manifest, `${where}.sequence.adapter`, report);
 }
-// A display node written inside a session — `views[].tracks[].displays[]` — is
-// instantiated by the display's STATE MODEL, not by its config schema. Almost
-// every track-menu setting is a config slot now, and a slot name here is dropped
-// exactly like a misspelling: the session loads, the track appears, the setting
-// does nothing. That is the same silent failure the slot checks above exist for,
-// on the surface people hand-write most, and it is why a whole class of these
-// sat unnoticed in this repo's own fixtures.
-//
-// The advice differs from the unknown-slot case, so the messages do too — a slot
-// is real, it is just in the wrong place, and there are two right places for it.
+// A display node inside a session is instantiated by the display's state
+// model; the schema reports a key it does not declare. What remains here is
+// the legacy display-instance key a session migration still lifts.
 function checkSessionDisplay(display, manifest, where, report) {
     const entry = resolveType(display, manifest.displays, 'display', `${where}.type`, report);
-    // A display type the manifest doesn't know (a plugin's) has already been
-    // reported as a warning by resolveType; its props are unknowable here.
     if (!entry?.stateModelProps) {
         return;
     }
-    const props = entry.stateModelProps;
-    const slots = entry.slots.map(slot => slot.name);
     const migrated = new Set([
         ...(manifest.migratedDisplayKeys['*'] ?? []),
         ...(manifest.migratedDisplayKeys[entry.canonicalName] ?? []),
     ]);
     for (const key of Object.keys(display)) {
-        if (props.includes(key)) {
-            continue;
-        }
-        if (migrated.has(key)) {
+        if (!entry.stateModelProps.includes(key) && migrated.has(key)) {
             report.warn(`${where}.${key}`, `"${key}" is a legacy display-instance key that a session migration lifts onto the config slot replacing it — it still works, but writing the current slot is clearer`);
         }
-        else if (slots.includes(key)) {
-            report.error(`${where}.${key}`, `"${key}" is a config slot, not a display property, so a session snapshot drops it and the setting silently does nothing — put it on the track's "displays" entry under "tracks", or in a "trackConfigDeltas" entry, instead`);
-        }
-        else {
-            report.error(`${where}.${key}`, `unknown display property "${key}"${didYouMean(key, [...props, ...slots])} — a session snapshot drops keys the display does not declare, so this setting silently does nothing`);
-        }
     }
 }
 // Walks the tracks of a view and its sub-views (a synteny view holds a row of
@@ -344,40 +190,6 @@ function checkSessionViewTracks(view, manifest, where, report) {
         }
     }
 }
-// A view node in a session — `defaultSession.views[]` — is instantiated by the
-// view's STATE MODEL, and a view has no config schema at all, so every setting
-// an author writes lands on that node: the properties MST restores, plus the
-// launch keys a launcher resolves (`assembly`, `loc`, `tracks`). Those two
-// together are the whole accepted set, which is what makes this check
-// exhaustive rather than a guess — anything else is dropped exactly like a
-// misspelling, and the view opens on its defaults with nothing said.
-//
-// The same trap checkSessionDisplay catches one level down, and the same three
-// diagnoses: a real key in the wrong place, a stale spelling that still works,
-// and a key nothing anywhere reads.
-function checkSessionViewKeys(view, entry, manifest, where, report) {
-    const accepted = [
-        ...entry.stateModelProps,
-        ...entry.launchKeys,
-        ...(entry.passThrough ?? []),
-    ];
-    for (const key of Object.keys(view)) {
-        // `init` gets its own message from checkSessionView below
-        if (accepted.includes(key) || key === 'init') {
-            continue;
-        }
-        // Whichever other view types do read the key. `assembly` on a DotplotView is
-        // not a misspelling and no suggestion reaches it, so naming the views that
-        // take it is the only thing that tells the author what they wrote.
-        const elsewhere = Object.entries(manifest.views)
-            .filter(([name, other]) => name !== entry.canonicalName &&
-            [...other.stateModelProps, ...other.launchKeys].includes(key))
-            .map(([name]) => name);
-        report.error(`${where}.${key}`, elsewhere.length
-            ? `"${key}" is a setting of ${elsewhere.join(', ')}, not of ${entry.canonicalName}${didYouMean(key, accepted)} — a session snapshot drops keys the view does not declare, so this setting silently does nothing`
-            : `unknown view key "${key}"${didYouMean(key, accepted)} — a session snapshot drops keys the view does not declare, so this setting silently does nothing`);
-    }
-}
 // The ids a view names, which nothing validates at load: a trackId that does not
 // exist simply fails to open, which reads as a rendering bug rather than a typo.
 function checkViewReferences(view, where, report, ctx) {
@@ -388,10 +200,8 @@ function checkViewReferences(view, where, report, ctx) {
     if (!Array.isArray(view.tracks)) {
         return;
     }
-    // A LinearSyntenyView's `tracks` is one array PER LEVEL (`[[a], [b]]`) — the
-    // multi-way form — so flatten one level before reading entries. Treating those
-    // inner arrays as track entries reported every genome row of every synteny
-    // demo as a track with no trackId.
+    // A LinearSyntenyView's `tracks` is one array per level, so flatten one level
+    // before reading entries.
     const entries = view.tracks.flatMap((t) => Array.isArray(t) ? t : [t]);
     for (const [j, entry] of entries.entries()) {
         // A built track snapshot names its config through `configuration` rather
@@ -400,10 +210,8 @@ function checkViewReferences(view, where, report, ctx) {
             continue;
         }
         const trackId = isRecord(entry) ? entry.trackId : entry;
-        if (typeof trackId !== 'string') {
-            report.error(`${where}.tracks[${j}]`, 'track entry has no trackId');
-        }
-        else if (!ctx.seenTrackIds.has(trackId) &&
+        if (typeof trackId === 'string' &&
+            !ctx.seenTrackIds.has(trackId) &&
             !ctx.sequenceTrackIds.has(trackId)) {
             report.error(`${where}.tracks[${j}]`, `trackId "${trackId}" is not defined in this config${didYouMean(trackId, [...ctx.seenTrackIds, ...ctx.sequenceTrackIds])}`);
         }
@@ -411,26 +219,21 @@ function checkViewReferences(view, where, report, ctx) {
 }
 function checkSessionView(view, manifest, where, report, ctx) {
     const entry = resolveType(view, manifest.views, 'view', `${where}.type`, report);
-    // A view type the manifest doesn't know (a plugin's) is already a warning from
-    // resolveType, and its keys are unknowable here.
     if (!entry) {
         return;
     }
-    checkSessionViewKeys(view, entry, manifest, where, report);
     checkViewReferences(view, where, report, ctx);
     // A warning, not an error: v5 unwraps the nesting on the way in, so the
-    // settings do arrive. The keys inside get the same check the flat ones do,
-    // since that is where they land.
+    // settings do arrive.
     if (view.init !== undefined) {
         report.warn(`${where}.init`, 'settings nested under "init", which is deprecated: write every setting directly on the view object');
         if (isRecord(view.init)) {
-            checkSessionViewKeys(view.init, entry, manifest, `${where}.init`, report);
             checkViewReferences(view.init, `${where}.init`, report, ctx);
         }
     }
-    // A synteny or breakpoint row is a whole view snapshot of its own. Only a row
-    // carrying a `type` can be checked: a row written as a recipe names no view
-    // type, and which one it becomes is the parent launcher's business.
+    // A synteny or breakpoint row is a whole view snapshot of its own. A row
+    // written as a recipe names no view type, and which one it becomes is the
+    // parent launcher's business.
     if (Array.isArray(view.views)) {
         for (const [i, row] of view.views.entries()) {
             if (isRecord(row) && typeof row.type === 'string') {
@@ -459,8 +262,9 @@ export function validateConfig(config, manifest = configManifest) {
         return report.result();
     }
     if (Array.isArray(config.plugins) && config.plugins.length > 0) {
-        report.note(`config declares ${config.plugins.length} plugin(s); the types and slots they register are not in the manifest and cannot be checked`);
+        report.note(`config declares ${config.plugins.length} plugin(s); the types and slots they register are not in the schema and cannot be checked`);
     }
+    report.problems.push(...schemaProblems(config));
     const assemblies = (Array.isArray(config.assemblies)
         ? config.assemblies
         : isRecord(config.assembly)
@@ -469,24 +273,15 @@ export function validateConfig(config, manifest = configManifest) {
     if (assemblies.length === 0) {
         report.error('assemblies', 'no assemblies — a config needs at least one');
     }
-    const connections = Array.isArray(config.connections)
-        ? config.connections
-        : [];
     const ctx = {
-        // An assembly's `aliases` are usable wherever its name is — a track can say
-        // `assemblyNames: ['vvx']` against an assembly named volvox that lists vvx
-        // as an alias. Leaving them out reports working configs as broken.
+        // An assembly's `aliases` are usable wherever its name is.
         assemblyNames: new Set(assemblies
             .flatMap(a => [a.name, ...(Array.isArray(a.aliases) ? a.aliases : [])])
             .filter((n) => typeof n === 'string')),
         assemblyCount: assemblies.length,
         seenTrackIds: new Set(),
-        // Each assembly's ReferenceSequenceTrack is a real track a session may show
-        // by id (`init.tracks: ['hg38-ReferenceSequenceTrack']`); it just lives on
-        // the assembly rather than in `tracks`, and collecting only `tracks`
-        // reported every such reference as undefined. Both the written trackId and
-        // the one the `{name, uri}` shorthand derives, since a config using the
-        // shorthand still gets the derived id at runtime.
+        // Both the written trackId and the one the `{name, uri}` shorthand derives,
+        // since a config using the shorthand still gets the derived id at runtime.
         sequenceTrackIds: new Set(assemblies.flatMap(a => {
             const declared = isRecord(a.sequence) ? a.sequence.trackId : undefined;
             return [
@@ -506,6 +301,9 @@ export function validateConfig(config, manifest = configManifest) {
     for (const [i, track] of tracks.entries()) {
         checkTrack(track, i, manifest, report, ctx);
     }
+    const connections = Array.isArray(config.connections)
+        ? config.connections
+        : [];
     for (const [i, connection] of connections.entries()) {
         checkPluggable(connection, manifest.connections, 'connection', `connections[${i}]`, report);
     }

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.0.0-beta.4';
+export const version = '5.0.0-beta.8';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/cli",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.8",
   "type": "module",
   "description": "A command line tool for working with JBrowse 2",
   "keywords": [
@@ -27,13 +27,14 @@
     "node": ">=18.3.0"
   },
   "dependencies": {
+    "ajv": "^8.20.0",
     "cli-progress": "^3.12.0",
     "ixixx": "^3.0.13",
     "serve-handler": "^6.1.7",
     "tmp": "^0.2.7",
-    "@jbrowse/add-track-core": "^5.0.0-beta.4",
-    "@jbrowse/text-indexing-core": "^5.0.0-beta.4",
-    "@jbrowse/cigar-utils": "^5.0.0-beta.4"
+    "@jbrowse/add-track-core": "^5.0.0-beta.8",
+    "@jbrowse/cigar-utils": "^5.0.0-beta.8",
+    "@jbrowse/text-indexing-core": "^5.0.0-beta.8"
   },
   "publishConfig": {
     "access": "public"