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

package/dist/commands/validate/validateConfig.js

@@ -1,18 +1,21 @@
-// 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 { fileNameOf, isLooseTrackConfig, matchFormat, } from '@jbrowse/add-track-core';
 import { configManifest } from './configManifest.generated.js';
-import { displayDefaultKeys } from './displayDefaultKeys.js';
+import { displayDefaultsForTrackType } from './displayDefaultKeys.js';
+import { isRecord, liftToSnapshot } from './liftConfig.js';
+import { colorProblems, scaleEndProblems } from './markRules/colorScale.js';
+import { markProblems } from './markRules/markProblems.js';
+import { hasDeclaredShape, rootConfigurationSlots, schemaProblems, } from './schemaValidate.js';
 import { didYouMean } from './suggest.js';
-// ------------------------------------------------------------------ reporting
 class Report {
     problems = [];
     notes = [];
@@ -34,100 +37,55 @@ 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 +93,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 loose = isLooseTrackConfig(track);
     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 +123,62 @@ 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);
+    if (loose) {
+        const file = fileNameOf(track.uri);
+        const spec = matchFormat(file)?.spec;
+        if (!spec || !('adapterType' in spec)) {
+            const message = `JBrowse infers no track from "${file}", so the track fails to load: give it an "adapter"`;
+            if (ctx.declaresPlugins) {
+                report.warn(`${where}.uri`, `${message}, unless a plugin it declares guesses this extension`);
+            }
+            else {
+                report.error(`${where}.uri`, message);
+            }
         }
     }
+    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;
-    }
-    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;
+    const sequence = assembly.sequence;
+    if (isRecord(sequence) && isRecord(sequence.adapter)) {
+        checkPluggable(sequence.adapter, manifest.adapters, 'adapter', `assemblies[${index}].sequence.adapter`, report);
     }
-    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,9 +205,64 @@ function checkSessionViewTracks(view, manifest, where, report) {
         }
     }
 }
-// A view's `init` names tracks and an assembly by id. Nothing validates those at
-// load: a trackId that does not exist simply fails to open, which reads as a
-// rendering bug rather than a typo.
+// 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) {
+    const assembly = view.assembly;
+    if (typeof assembly === 'string' && !ctx.assemblyNames.has(assembly)) {
+        report.error(`${where}.assembly`, `assembly "${assembly}" is not defined in this config${didYouMean(assembly, [...ctx.assemblyNames])}`);
+    }
+    if (!Array.isArray(view.tracks)) {
+        return;
+    }
+    // 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
+        // than `trackId`, and is state MST restores rather than a reference to open.
+        if (isRecord(entry) && !('trackId' in entry)) {
+            continue;
+        }
+        const trackId = isRecord(entry) ? entry.trackId : entry;
+        if (typeof trackId === 'string' &&
+            !ctx.seenTrackIds.has(trackId) &&
+            !ctx.sequenceTrackIds.has(trackId)) {
+            const message = `trackId "${trackId}" is not defined in this config${didYouMean(trackId, [...ctx.seenTrackIds, ...ctx.sequenceTrackIds])}`;
+            if (ctx.declaresPlugins) {
+                report.warn(`${where}.tracks[${j}]`, `${message} — a plugin it declares may create it`);
+            }
+            else {
+                report.error(`${where}.tracks[${j}]`, message);
+            }
+        }
+    }
+}
+function checkSessionView(view, manifest, where, report, ctx) {
+    const entry = resolveType(view, manifest.views, 'view', `${where}.type`, report);
+    if (!entry) {
+        return;
+    }
+    checkViewReferences(view, where, report, ctx);
+    // A warning, not an error: v5 unwraps the nesting on the way in, so the
+    // 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)) {
+            checkViewReferences(view.init, `${where}.init`, report, ctx);
+        }
+    }
+    // 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') {
+                checkSessionView(row, manifest, `${where}.views[${i}]`, report, ctx);
+            }
+        }
+    }
+}
 function checkSession(session, manifest, report, ctx) {
     if (!isRecord(session) || !Array.isArray(session.views)) {
         return;
@@ -355,47 +271,194 @@ function checkSession(session, manifest, report, ctx) {
         checkSessionViewTracks(view, manifest, `defaultSession.views[${i}]`, report);
     }
     for (const [i, view] of session.views.entries()) {
-        if (!isRecord(view) || !isRecord(view.init)) {
+        if (isRecord(view)) {
+            checkSessionView(view, manifest, `defaultSession.views[${i}]`, report, ctx);
+        }
+    }
+}
+const MARK_DISPLAY = 'LinearMarkDisplay';
+const SLOTS_POINTER = `/$defs/${MARK_DISPLAY}Slots/properties`;
+// The rule list reads a config snapshot, which is what a file is once the
+// schema passes its keys and types and the manifest's lifts are applied. An
+// entry the schema refuses is the schema's to report, and stands as a gap so
+// its siblings keep their indices and their own reports. A list the file
+// leaves unwritten is the slot's default entries, a display's default plot.
+function declaredEntries(lifted, display, slot, slots) {
+    const list = lifted[slot];
+    const written = display[slot];
+    if (!Array.isArray(written)) {
+        return (slots.find(s => s.name === slot)?.defaultEntries ?? []);
+    }
+    return Array.isArray(list)
+        ? list.map((entry, i) => hasDeclaredShape(written[i], `${SLOTS_POINTER}/${slot}/items`)
+            ? entry
+            : undefined)
+        : [];
+}
+function slotPath(slot) {
+    return slot.replaceAll(/\.(\d+)(?=\.|$)/g, '[$1]');
+}
+// The display types that read a marks list: the mark display and every one
+// built on it, which the manifest tells apart by the `marks` slot each lists.
+function isMarkDisplayType(type, manifest) {
+    return (typeof type === 'string' &&
+        !!manifest.displays[type]?.slots.some(slot => slot.name === 'marks'));
+}
+// A mark display's own entry, whose marks may be its type's default plot, or
+// a `displayDefaults` holding marks. A mark is a record with a `transform` of
+// its own, so an untyped node counts only by its `marks`.
+function holdsMarkRules(node, manifest) {
+    return (isMarkDisplayType(node.type, manifest) ||
+        (node.type === undefined && Array.isArray(node.marks)));
+}
+// What the marks of one display say together that it cannot draw as written:
+// the rule list the display shows in its corner notice, copied from the plugin
+// (`markRules/`). A single mark's `requires` is the schema's to report.
+function checkMarkDisplay(display, manifest, where, report) {
+    const type = typeof display.type === 'string' ? display.type : MARK_DISPLAY;
+    const slots = manifest.displays[type]?.slots;
+    const lifted = liftToSnapshot(display, slots ?? []);
+    if (!slots || !isRecord(lifted)) {
+        return;
+    }
+    const { facet, rows, scales } = lifted;
+    for (const { level, rule, mark, slot, message } of markProblems({
+        marks: declaredEntries(lifted, display, 'marks', slots),
+        facet: isRecord(facet) ? facet : undefined,
+        transform: declaredEntries(lifted, display, 'transform', slots),
+        rows: isRecord(rows) ? rows : undefined,
+        scales: isRecord(scales) ? scalesOf(scales) : undefined,
+    })) {
+        pushOnce(report, {
+            level,
+            where: `${where}${mark === undefined ? '' : `.marks[${mark}]`}.${slotPath(slot)}`,
+            message,
+            rule,
+        });
+    }
+}
+// A problem the colour and scale rules and the mark rule list both reach, such
+// as scales.y's ends on a mark display, is reported once.
+function pushOnce(report, problem) {
+    if (!report.problems.some(p => p.where === problem.where && p.rule === problem.rule)) {
+        report.problems.push(problem);
+    }
+}
+function numberOf(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function scaleEndsOf(scale) {
+    return {
+        domainMin: numberOf(scale.domainMin),
+        domainMax: numberOf(scale.domainMax),
+        domainQuantile: numberOf(scale.domainQuantile),
+    };
+}
+function scalesOf(scales) {
+    return isRecord(scales.y) ? { y: scaleEndsOf(scales.y) } : {};
+}
+function declaredMembers(written, slot) {
+    const declared = new Set((slot.subSlots ?? []).map(s => s.name));
+    return Object.fromEntries(Object.entries(written).filter(([key]) => declared.has(key)));
+}
+// What the display's colour objects and its value scale say together that it
+// cannot draw as written: its schema's fieldPresets stand in for the plugin
+// code the CLI does not run, and every quantitative scale's ends answer to
+// one rule.
+function checkScaleSlots(display, slots, where, report) {
+    const lifted = liftToSnapshot(display, slots);
+    if (!isRecord(lifted)) {
+        return;
+    }
+    const warn = (at, { rule, slot, message }) => {
+        pushOnce(report, {
+            level: 'warning',
+            where: `${at}.${slot}`,
+            message,
+            rule,
+        });
+    };
+    for (const slot of slots) {
+        const written = lifted[slot.name];
+        if (!isRecord(written)) {
             continue;
         }
-        const init = view.init;
-        const where = `defaultSession.views[${i}].init`;
-        if (typeof init.assembly === 'string' &&
-            !ctx.assemblyNames.has(init.assembly)) {
-            report.error(`${where}.assembly`, `assembly "${init.assembly}" is not defined in this config${didYouMean(init.assembly, [...ctx.assemblyNames])}`);
+        const members = declaredMembers(written, slot);
+        if (slot.fieldPresets) {
+            for (const problem of colorProblems({
+                ...scaleEndsOf(members),
+                field: typeof members.field === 'string' ? members.field : '',
+                scale: typeof members.scale === 'string' ? members.scale : undefined,
+                domain: Array.isArray(members.domain) ? members.domain : undefined,
+                range: Array.isArray(members.range) ? members.range : undefined,
+                labels: Array.isArray(members.labels) ? members.labels : undefined,
+            }, slot.fieldPresets)) {
+                warn(`${where}.${slot.name}`, problem);
+            }
         }
-        if (Array.isArray(init.tracks)) {
-            // 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.
-            const entries = init.tracks.flatMap((t) => Array.isArray(t) ? t : [t]);
-            for (const [j, entry] of entries.entries()) {
-                const trackId = typeof entry === 'string'
-                    ? entry
-                    : isRecord(entry)
-                        ? entry.trackId
-                        : undefined;
-                if (typeof trackId !== 'string') {
-                    report.error(`${where}.tracks[${j}]`, 'track entry has no trackId');
-                }
-                else if (!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])}`);
-                }
+        if (slot.name === 'scales' && isRecord(members.y)) {
+            for (const problem of scaleEndProblems(scaleEndsOf(members.y))) {
+                warn(`${where}.scales.y`, problem);
             }
         }
     }
 }
+// A marks list sits wherever a config takes a mark display's slots: a
+// track's `displays` entry, its `displayDefaults`, a session's inline track
+// entry. Only a mark display declares `marks`, so the walk is over the whole
+// file, past a place where the schema refused the key: a session display node
+// drops it.
+function checkMarkDisplays(node, manifest, where, report) {
+    if (Array.isArray(node)) {
+        for (const [i, item] of node.entries()) {
+            checkMarkDisplays(item, manifest, `${where}[${i}]`, report);
+        }
+    }
+    else if (isRecord(node)) {
+        const slots = typeof node.type === 'string'
+            ? manifest.displays[node.type]?.slots
+            : undefined;
+        if (slots) {
+            checkScaleSlots(node, slots, where, report);
+        }
+        if (typeof node.type === 'string' && isRecord(node.displayDefaults)) {
+            for (const display of displayDefaultsForTrackType(node.type, manifest)
+                .displayTypes) {
+                checkScaleSlots(node.displayDefaults, manifest.displays[display]?.slots ?? [], `${where}.displayDefaults`, report);
+            }
+        }
+        if (holdsMarkRules(node, manifest) &&
+            !report.problems.some(p => p.where === `${where}.marks`)) {
+            checkMarkDisplay(node, manifest, where, report);
+        }
+        for (const [key, member] of Object.entries(node)) {
+            checkMarkDisplays(member, manifest, where ? `${where}.${key}` : key, report);
+        }
+    }
+}
 export function validateConfig(config, manifest = configManifest) {
     const report = new Report();
     if (!isRecord(config)) {
         report.error('', 'config is not a JSON object');
         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`);
+    const declaresPlugins = Array.isArray(config.plugins) && config.plugins.length > 0;
+    if (declaresPlugins) {
+        report.note(`config declares ${config.plugins.length} plugin(s); the types and slots they register are not in the schema and cannot be checked`);
     }
+    const { configuration } = config;
+    const pluginSlots = declaresPlugins && isRecord(configuration)
+        ? Object.keys(configuration).filter(k => !rootConfigurationSlots.has(k))
+        : [];
+    for (const key of pluginSlots) {
+        report.warn(`configuration.${key}`, `core declares no "${key}" slot${didYouMean(key, [...rootConfigurationSlots])} — a plugin this config declares may`);
+    }
+    report.problems.push(...schemaProblems(pluginSlots.length && isRecord(configuration)
+        ? {
+            ...config,
+            configuration: Object.fromEntries(Object.entries(configuration).filter(([k]) => !pluginSlots.includes(k))),
+        }
+        : config));
     const assemblies = (Array.isArray(config.assemblies)
         ? config.assemblies
         : isRecord(config.assembly)
@@ -404,24 +467,16 @@ 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.
+        declaresPlugins,
+        // 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 [
@@ -441,6 +496,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);
     }
@@ -453,5 +511,6 @@ export function validateConfig(config, manifest = configManifest) {
     // Tracks are registered before the session is checked, so a session may
     // reference any track in the file regardless of declaration order.
     checkSession(config.defaultSession, manifest, report, ctx);
+    checkMarkDisplays(config, manifest, '', report);
     return report.result();
 }