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

package/dist/commands/validate/index.js

@@ -2,9 +2,10 @@ import { parseArgs } from 'node:util';
 import { printHelp, readConfigFile } from '../../utils.js';
 import { validateConfig } from './validateConfig.js';
 const description = 'Check a JBrowse configuration for errors, including the ones JBrowse itself accepts silently';
-const notes = `A config key JBrowse does not recognize is ignored rather than reported, so a
-misspelled slot leaves the track loading normally with the setting doing
-nothing. That is what this command is mainly for.
+const notes = `A config key JBrowse does not recognize does nothing: a track, an adapter or
+a display names it on the browser console and loads without it, and a session
+snapshot drops it in silence. This command reports each one offline, before
+anyone opens the config.
 
 Two levels are reported:
 
@@ -24,7 +25,7 @@ what it cannot draw in a corner notice rather than refusing the track.
 This command runs the display's own rule list over every "marks" list in the
 file: an error where a mark draws nothing, never draws or a step cannot run,
 and a warning where a slot waits unread or the marks draw in an arrangement
-the author may not have meant. With --json each finding carries the stable
+the author may not have meant. With --json each finding has the stable
 "rule" id of the rule that made it.
 
 Types registered by plugins are not known to this command, so they come through

package/dist/commands/validate/markRules/colorScale.js

@@ -1,10 +1,10 @@
 // Generated by scripts/generateMarkRules.ts from packages/core/src/util/colorScale.ts: do not edit, `pnpm autogen` rewrites it.
 /**
- * The scales a colour object paints through, in a module that imports
+ * The scales a color object paints through, in a module that imports
  * nothing: `jbrowse validate` carries a copy of it, so the validator and the
  * displays read one statement.
  */
-/** How a colour object maps its `field`; `none` paints `value`. */
+/** How a color object maps its `field`; `none` paints `value`. */
 export const COLOR_SCALES = [
     'none',
     'categorical',
@@ -13,20 +13,23 @@ export const COLOR_SCALES = [
     'threshold',
 ];
 /**
- * The scale that maps no field: each feature paints the colour it carries, and
- * the key names the colours `domain` lists. Only a display whose features
- * carry colours of their own declares it.
+ * The scale that maps no field: each feature paints the color it carries, and
+ * the key names the colors `domain` lists. Only a display whose features
+ * carry colors of their own declares it.
  */
 export const IDENTITY_SCALE = 'identity';
 const CATEGORICAL_PRESET = { scale: 'categorical' };
 /**
- * The fields whose values have names, an order and colours of their own on
- * every display, beneath each display's own presets. Red forward and blue
- * reverse is what the synteny ribbons paint too. The SV classes are
+ * The fields whose values have names, an order and colors of their own on
+ * every display, beneath each display's own presets. The synteny ribbons
+ * paint strand from this range too. The SV classes are
  * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
  * paint them, insertion the pileup's purple, and the rest kept apart under
  * deuteranopia and protanopia. A record with no class files under `''`, so
- * each display keeps its own no-value colour for it.
+ * each display keeps its own no-value color for it. The impact tiers are a
+ * variant's most severe SnpEff (ANN) or VEP (CSQ) consequence, and a record
+ * with neither files under Unannotated, its own color: "nobody looked" is
+ * not MODIFIER's "we looked and it is harmless".
  */
 export const UNIVERSAL_FIELD_PRESETS = {
     strand: {
@@ -63,6 +66,13 @@ export const UNIVERSAL_FIELD_PRESETS = {
         ],
         title: 'SV type',
     },
+    impact: {
+        scale: 'categorical',
+        missing: 'Unannotated',
+        domain: ['HIGH', 'MODERATE', 'LOW', 'MODIFIER', 'Unannotated'],
+        range: ['#d32f2f', '#f57c00', '#fbc02d', '#9e9e9e', '#607d8b'],
+        title: 'Consequence impact',
+    },
 };
 /** The universal preset of `field`, if it has one. */
 export function universalPresetOf(field) {
@@ -82,6 +92,63 @@ export const FEATURE_FIELD_PRESETS = {
     score: { scale: 'linear' },
     '*': CATEGORICAL_PRESET,
 };
+/**
+ * Mapping quality's bins, each keyed by its lowest score and confident reads
+ * first: real MAPQ is bimodal at the aligner's ceiling and at 0, and these
+ * are the cuts people filter on (`samtools view -q 10` / `-q 30`).
+ */
+export const MAPQ_BINS = [
+    { key: '30', min: 30, label: 'MAPQ 30+ (high confidence)' },
+    { key: '10', min: 10, label: 'MAPQ 10-29' },
+    { key: '1', min: 1, label: 'MAPQ 1-9 (low)' },
+    { key: '0', min: 0, label: 'MAPQ 0 (multi-mapping)' },
+];
+const MAPQ_BINS_ASCENDING = [...MAPQ_BINS].reverse();
+/**
+ * The measurements whose scale is part of what they mean, for a display
+ * whose features carry them to spread into its own presets: `mapq` in the
+ * bins above; `identity` a fraction from 0 to 1, red where it diverges and
+ * blue where it is conserved, as conservation tracks paint it, through a grey
+ * middle that stays visible on a white page and under a faint ribbon, where
+ * viridis's bright top washed out; and `dnds` read against 1, its ramp's pale
+ * middle, up to 2, past which a few fast-evolving genes would flatten the
+ * rest into one blue; and `syntenicDepth` grey where a gene pair is
+ * one-to-one, so genes sharing one ortholog are what takes color. Opt-in rather
+ * than universal, since a column another file names `identity` need not be a
+ * fraction.
+ */
+export const MEASURE_FIELD_PRESETS = {
+    mapq: {
+        scale: 'threshold',
+        domain: MAPQ_BINS_ASCENDING.slice(1).map(bin => bin.key),
+        scheme: 'cividis',
+        labels: MAPQ_BINS_ASCENDING.map(bin => bin.label),
+        title: 'Mapping quality',
+        descending: true,
+    },
+    identity: {
+        scale: 'linear',
+        domainMin: 0,
+        domainMax: 1,
+        scheme: 'redgreyblue',
+        title: 'Identity',
+    },
+    dnds: {
+        scale: 'linear',
+        domainMin: 0,
+        domainMax: 2,
+        domainMid: 1,
+        scheme: 'blueyellowred',
+        title: 'dN/dS',
+    },
+    syntenicDepth: {
+        scale: 'threshold',
+        domain: ['2', '3'],
+        range: ['#bdbdbd', '#fdae6b', '#e6550d'],
+        labels: ['One-to-one', 'Shared by 2 genes', 'Shared by 3 or more'],
+        title: 'Syntenic depth',
+    },
+};
 /**
  * A field's preset under `presets`: its own, else a universal one, else
  * `*`'s, else categorical.
@@ -99,13 +166,14 @@ function unwritten(value) {
     return value === undefined || (Array.isArray(value) && value.length === 0);
 }
 /**
- * A colour object with its field's preset under it: each member the preset
+ * A color object with its field's preset under it: each member the preset
  * names and the config leaves unwritten, an empty list counting as unwritten.
- * Only while the colour paints through the preset's own scale, so the cuts of
+ * Only while the color paints through the preset's own scale, so the cuts of
  * a threshold preset never reach a field read through a ramp. A categorical
- * preset's `range` and `labels` name its `domain`'s values in order, so they
- * fill only while `domain` does too: a written order keeps each value's own
- * colour and name.
+ * preset's `range` and `labels` name its `domain`'s values in order, and a
+ * threshold preset's `labels` its intervals, so they fill only while `domain`
+ * does too: a written order keeps each value's own color and name, and written
+ * cuts keep the preset's palette and lose its interval names.
  */
 export function withPreset(color, presets) {
     const field = color.field ?? '';
@@ -114,17 +182,27 @@ export function withPreset(color, presets) {
         return color;
     }
     const written = new Map(Object.entries(color));
-    const ordered = preset.scale !== 'categorical' ||
-        !preset.domain ||
-        unwritten(written.get('domain'));
+    const ownDomain = !preset.domain || unwritten(written.get('domain'));
+    const named = preset.scale === 'categorical' ? ['range', 'labels'] : ['labels'];
     const filled = Object.entries(preset).filter(([key]) => key !== 'scale' &&
         key !== 'missing' &&
-        (ordered || (key !== 'range' && key !== 'labels')) &&
+        (ownDomain || !named.includes(key)) &&
         unwritten(written.get(key)));
     return filled.length > 0 ? { ...color, ...Object.fromEntries(filled) } : color;
 }
 /**
- * The scale a colour object paints through: `none` while no `field` is
+ * A color object with `implied` as its field while it names neither a field
+ * nor a constant, for a display whose bare color object still maps one (a
+ * quantitative display's `score`), so the display and `jbrowse validate`
+ * read it alike. A written `value` keeps the object a constant.
+ */
+export function withImpliedField(color, implied) {
+    return implied && !color.field && color.value === undefined
+        ? { ...color, field: implied }
+        : color;
+}
+/**
+ * The scale a color object paints through: `none` while no `field` is
  * named, else its own `scale`, or `fieldScale` where that is unset.
  */
 export function paintedScale({ scale, field }, fieldScale) {
@@ -134,11 +212,22 @@ export function paintedScale({ scale, field }, fieldScale) {
  * What a quantitative scale's ends say together that neither can refuse
  * alone: a `domainMax` below its `domainMin`, which every such scale draws in
  * order either way, and a `domainQuantile` outside 0.5 to 1, where the quantile
- * an open end follows is clamped. `reverse` is whether the scale turns round by
- * a member of its own, which is then the spelling to point at.
+ * an open end follows is clamped; and a log scale's `domainMin` at or below 0,
+ * which no log scale can hold, so the end floors above it. `reverse` is whether
+ * the scale turns round by a member of its own, which is then the spelling to
+ * point at.
  */
-export function scaleEndProblems({ domainMin, domainMax, domainQuantile }, { reverse = false } = {}) {
+export function scaleEndProblems({ domainMin, domainMax, domainQuantile, type }, { reverse = false } = {}) {
     return [
+        ...(type === 'log' && domainMin !== undefined && domainMin <= 0
+            ? [
+                {
+                    rule: 'log-floor',
+                    slot: 'domainMin',
+                    message: `a log scale has no ${domainMin}: the end floors to a positive value, so leave domainMin unset to follow the data or pin it above 0`,
+                },
+            ]
+            : []),
         ...(domainMin !== undefined &&
             domainMax !== undefined &&
             domainMin > domainMax
@@ -166,11 +255,44 @@ export function scaleEndProblems({ domainMin, domainMax, domainQuantile }, { rev
 export function noticeLines(setting, problems) {
     return problems.map(({ slot, message }) => `${setting}.${slot}: ${message}`);
 }
+function numberOf(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function stringOf(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function listOf(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+/** A quantitative scale's ends among the members `member` reads, each a number or unset. */
+export function scaleEndsOf(member) {
+    return {
+        domainMin: numberOf(member('domainMin')),
+        domainMax: numberOf(member('domainMax')),
+        domainQuantile: numberOf(member('domainQuantile')),
+        type: stringOf(member('type')),
+    };
+}
+/**
+ * The members `colorProblems` reads among the ones `member` reads, each of the
+ * type it reads or unset, so a config snapshot and a config node answer alike.
+ */
+export function colorSlotsOf(member) {
+    return {
+        ...scaleEndsOf(member),
+        value: stringOf(member('value')),
+        field: stringOf(member('field')) ?? '',
+        scale: stringOf(member('scale')),
+        domain: listOf(member('domain')),
+        range: listOf(member('range')),
+        labels: listOf(member('labels')),
+    };
+}
 function pinned(entry) {
     return entry !== '' && Number.isFinite(Number(entry));
 }
 /**
- * What a colour object's slots say together that no single slot can refuse,
+ * What a color object's slots say together that no single slot can refuse,
  * since the config editor writes one slot at a time (ADR-133), read with its
  * field's preset under it. A display shows these as a notice and draws what
  * it can. A threshold naming no cuts leaves its intervals to the display —
@@ -199,7 +321,7 @@ export function colorProblems(written, presets) {
             problems.push({
                 rule: 'threshold-range',
                 slot: 'range',
-                message: `${domain.length} threshold ${domain.length === 1 ? 'cut makes' : 'cuts make'} ${domain.length + 1} intervals, one colour each, and range lists ${range.length}: a missing colour comes from the default palette and an extra one is never read`,
+                message: `${domain.length} threshold ${domain.length === 1 ? 'cut makes' : 'cuts make'} ${domain.length + 1} intervals, one color each, and range lists ${range.length}: a missing color comes from the default palette and an extra one is never read`,
             });
         }
     }
@@ -208,10 +330,17 @@ export function colorProblems(written, presets) {
             problems.push({
                 rule: 'ramp-domain',
                 slot: 'domain',
-                message: "a linear or log scale reads no domain, which is a categorical scale's order and a threshold scale's cuts; a ramp's ends are domainMin and domainMax where the colour has them",
+                message: "a linear or log scale reads no domain, which is a categorical scale's order and a threshold scale's cuts; a ramp's ends are domainMin and domainMax where the color has them",
+            });
+        }
+        if (range.length === 1) {
+            problems.push({
+                rule: 'ramp-range',
+                slot: 'range',
+                message: 'a linear or log ramp runs between at least two colors, and one paints every value alike; a single color is value',
             });
         }
-        problems.push(...scaleEndProblems(color, { reverse: true }));
+        problems.push(...scaleEndProblems({ ...color, type: scale }, { reverse: true }));
     }
     const { labels = [] } = color;
     const named = scale === 'categorical' || scale === IDENTITY_SCALE
@@ -226,13 +355,13 @@ export function colorProblems(written, presets) {
         const what = scale === 'categorical'
             ? 'value'
             : scale === IDENTITY_SCALE
-                ? 'colour'
+                ? 'color'
                 : 'interval';
         problems.push({
             rule: 'labels-domain',
             slot: 'labels',
             message: named === undefined
-                ? "labels names a categorical scale's values, a threshold scale's intervals or an identity scale's colours, and this colour paints none of them"
+                ? "labels names a categorical scale's values, a threshold scale's intervals or an identity scale's colors, and this color paints none of them"
                 : `labels names one ${what} each, and ${labels.length} ${labels.length === 1 ? 'label names' : 'labels name'} ${named} ${named === 1 ? what : `${what}s`}: a label past them names nothing`,
         });
     }

package/dist/commands/validate/markRules/markProblems.js

@@ -1,19 +1,19 @@
 // Generated by scripts/generateMarkRules.ts from plugins/marks/src/LinearMarkDisplay/markProblems.ts: do not edit, `pnpm autogen` rewrites it.
 import { AUTO_BIN } from './autoBin.js';
-import { FEATURE_FIELD_PRESETS, aggregateFieldName, colorProblems, fieldScaleOf, isJexl, SHAPE_NAMES, isNamedColor, paintedScale, scaleEndProblems, universalPresetOf, } from './markRuleFacts.js';
+import { FEATURE_FIELD_PRESETS, colorProblems, fieldScaleOf, isJexl, SHAPE_NAMES, isNamedColor, paintedScale, scaleEndProblems, stepsOutput, universalPresetOf, } from './markRuleFacts.js';
 import { MARK_SPECS, readsValue } from './markSpecs.js';
-import { DEFAULT_AGGREGATE_OP, BIN_OVERLAP_FIELD, DEFAULT_BIN_AS, DEFAULT_BIN_FIELD, DEFAULT_COVERAGE_AS, DEFAULT_FORMULA_AS, DEFAULT_LINE_INTERPOLATE, DEFAULT_ROW_PROPORTION, DEFAULT_LINK_SHAPE, DEFAULT_MARK_TYPE, CELLS_FIELDS, DEFAULT_PILEUP_AS, DEFAULT_PILEUP_FIELDS, DEFAULT_TEXT_FIELD, DEFAULT_X2, MATE_FIELDS, MAX_THRESHOLD_CUTS, } from './markVocabulary.js';
+import { DEFAULT_AGGREGATE_OP, DEFAULT_BIN_AS, DEFAULT_BIN_FIELD, DEFAULT_LINE_INTERPOLATE, DEFAULT_ROW_PROPORTION, DEFAULT_LINK_SHAPE, DEFAULT_MARK_TYPE, DEFAULT_PILEUP_FIELDS, DEFAULT_TEXT_FIELD, DEFAULT_WINDOW_FRAME, DEFAULT_X2, isWindowFrame, MAX_THRESHOLD_CUTS, } from './markVocabulary.js';
 import { stepChannels } from './stepChannels.js';
 /**
  * The level of every rule of the list, by the stable id a report and a test
  * refer to it by.
  */
 export const MARK_RULES = {
-    /** A bar, point or rule naming no `y`, with no step before it writing one it reads by default. */
+    /** A bar, point, rule or line naming no `y`, with no step before it writing one it reads by default. */
     'mark-without-value': 'error',
     /** A channel the mark's type does not read, such as `y` on a `span` or a size field on a point. */
     'unread-channel': 'warning',
-    /** An `encoding.size` on a mark that draws no point or rule and strokes no link. */
+    /** An `encoding.size` on a mark that draws no point, rule or line and strokes no link. */
     'unread-size': 'warning',
     /** A `linkShape` on a mark that draws no link. */
     'unread-link-shape': 'warning',
@@ -21,25 +21,27 @@ export const MARK_RULES = {
     'unread-interpolate': 'warning',
     /** A `rowProportion` on a mark that draws no span. */
     'unread-row-proportion': 'warning',
-    /** `source: "density"` on a `span`, a `text` or a `link`, which cannot draw the sidecar's bins. */
-    'span-density-source': 'warning',
     /** Threshold cuts that repeat, leaving an interval no value falls in. */
     'threshold-cuts': 'warning',
-    /** A threshold colour naming no cut, so every value paints one colour. */
+    /** A threshold color naming no cut, so every value paints one color. */
     'threshold-no-cuts': 'warning',
-    /** A threshold colour naming more cuts than it paints, so a value past the eighth takes the ninth colour. */
+    /** A threshold color naming more cuts than it paints, so a value past the eighth takes the ninth color. */
     'threshold-cut-count': 'warning',
-    /** A threshold `range` not one colour longer than its cuts. */
+    /** A threshold `range` not one color longer than its cuts. */
     'threshold-range': 'warning',
-    /** A `domain` on a linear or log colour, whose ends are `domainMin` and `domainMax`. */
+    /** A `domain` on a linear or log color, whose ends are `domainMin` and `domainMax`. */
     'ramp-domain': 'warning',
-    /** A scale's `domainMax` below its `domainMin`: a colour ramp's, a width's or `scales.y`'s. */
+    /** A linear or log color whose `range` lists one color, which paints every value alike. */
+    'ramp-range': 'warning',
+    /** A scale's `domainMax` below its `domainMin`: a color ramp's, a width's or `scales.y`'s. */
     'domain-ends': 'warning',
-    /** A colour ramp's or `scales.y`'s `domainQuantile` outside 0.5 to 1, a percent among them. */
+    /** A color ramp's or `scales.y`'s `domainQuantile` outside 0.5 to 1, a percent among them. */
     'domain-quantile': 'warning',
-    /** A colour's or a shape's `field` spelling a CSS colour or a shape name, which is a constant written `{ value }`. */
+    /** A log scale's `domainMin` at or below 0, which it cannot hold, so the end floors above it. */
+    'log-floor': 'warning',
+    /** A color's or a shape's `field` spelling a CSS color or a shape name, which is a constant written `{ value }`. */
     'field-spells-constant': 'warning',
-    /** A colour's or a shape's `labels` naming values its `domain` does not list, or no categorical scale's. */
+    /** A color's or a shape's `labels` naming values its `domain` does not list, or no categorical scale's. */
     'labels-domain': 'warning',
     /** A `minBpPerPx` not below the mark's `maxBpPerPx`, so the mark never draws. */
     'empty-zoom-range': 'error',
@@ -47,6 +49,10 @@ export const MARK_RULES = {
     'step-expression': 'error',
     /** A `bin` whose `step` is neither `"auto"` nor a positive width. */
     'bin-width': 'error',
+    /** A `window`'s `frame` other than two whole row offsets or `null`, the first not past the second, so the step reads its default. */
+    'window-frame': 'warning',
+    /** A `gapBp` on a mark that draws no line. */
+    'unread-gap': 'warning',
     /** A `bin`'s `as` or `fields`, or a `pileup`'s `fields`, naming other than two fields, so the step reads its defaults. */
     'step-pair': 'warning',
     /** A `bin` naming a `field` beside the `fields` it cuts at the bin edges, which leaves the `field` unread. */
@@ -67,8 +73,6 @@ export const MARK_RULES = {
     'two-packings': 'warning',
     /** A `pileup` in the display's `transform` under a `facet`, packing across every section. */
     'cross-section-packing': 'warning',
-    /** A second mark standing in for the density sidecar at a zoom where one already does. */
-    'second-density-mark': 'warning',
     /** `rows` beside a `facet` on another field, where the facet draws alone. */
     'rows-beside-facet': 'warning',
     /** A `pileup` or a `row` field under `rows`, whose packed rows share their value's one row. */
@@ -129,9 +133,9 @@ function sizeFieldOf(size) {
             ? (size.field ?? '')
             : '';
 }
-// A shape's labels name its domain values in order, as a colour's do, and a
+// A shape's labels name its domain values in order, as a color's do, and a
 // constant shape names none.
-// What a reader writes as a colour, without the colour parser the rule list
+// What a reader writes as a color, without the color parser the rule list
 // cannot carry into `jbrowse validate`.
 function spellsColor(text) {
     return (/^(#[\da-f]{3,8}|(rgb|hsl|hwb|lab|lch|oklab|oklch|color)a?\(.*\)|transparent)$/i.test(text) || isNamedColor(text.toLowerCase()));
@@ -143,14 +147,14 @@ function fieldOf(channel) {
     return typeof field === 'string' && !isJexl(field) ? field : '';
 }
 // Inside `encoding` a bare string is a field, so a constant written the way a
-// display-level colour takes one reads as a field no feature holds.
+// display-level color takes one reads as a field no feature holds.
 function constantAsFieldProblems(encoding) {
     const color = fieldOf(encoding?.color);
     const shape = fieldOf(encoding?.shape);
     return [
         ...(color && spellsColor(color)
             ? [
-                found('field-spells-constant', 'encoding.color.field', `${JSON.stringify(color)} is a colour, and a string in encoding is a field: a constant colour is { "value": ${JSON.stringify(color)} }`),
+                found('field-spells-constant', 'encoding.color.field', `${JSON.stringify(color)} is a color, and a string in encoding is a field: a constant color is { "value": ${JSON.stringify(color)} }`),
             ]
             : []),
         ...(shape && SHAPE_NAMES.includes(shape)
@@ -177,9 +181,6 @@ function shapeLabelProblems(shape) {
         ]
         : [];
 }
-function drawsDensity(mark) {
-    return mark.source === 'density' && readsValue(markTypeOf(mark));
-}
 function drawTogether(a, b) {
     const upper = (m) => m.maxBpPerPx || Infinity;
     const lower = (m) => m.minBpPerPx ?? 0;
@@ -197,6 +198,7 @@ function fieldRefs(step) {
         case 'pileup':
             return list('fields', step.fields);
         case 'aggregate':
+        case 'window':
             return [
                 ...list('groupby', step.groupby),
                 ...(step.ops ?? []).flatMap((o, k) => [
@@ -266,69 +268,10 @@ function banded(mark, shared) {
         stepChannels([...shared, ...stepsOf(mark)]).row !== undefined);
 }
 // The fields the last step that makes its features from nothing leaves behind,
-// with what the steps after it add, over the display's steps and then the
-// mark's; undefined where no step does, and every field of the file is still
-// there.
+// with what the steps after it add; undefined where no step does, and every
+// field of the file is still there.
 function madeFields(steps) {
-    const made = steps.findLastIndex(s => s.type === 'aggregate' || s.type === 'coverage');
-    const last = steps[made];
-    if (!last) {
-        return undefined;
-    }
-    const fields = new Set(['refName', 'start', 'end']);
-    if (last.type === 'coverage') {
-        fields.add(last.as ?? DEFAULT_COVERAGE_AS);
-    }
-    else if (last.type === 'aggregate') {
-        const bin = steps
-            .slice(0, made)
-            .findLast((s) => s.type === 'bin');
-        const edges = bin?.as ?? DEFAULT_BIN_AS;
-        for (const field of last.groupby?.length
-            ? last.groupby
-            : edges.length === 2
-                ? edges
-                : []) {
-            fields.add(field);
-        }
-        for (const { op = DEFAULT_AGGREGATE_OP, field, as } of last.ops ?? []) {
-            fields.add(aggregateFieldName({ op, field, as }));
-        }
-    }
-    for (const step of steps.slice(made + 1)) {
-        if (step.type === 'formula') {
-            fields.add(step.as ?? DEFAULT_FORMULA_AS);
-        }
-        else if (step.type === 'pileup') {
-            fields.add(step.as ?? DEFAULT_PILEUP_AS);
-        }
-        else if (step.type === 'flatten') {
-            for (const field of [step.index, step.key]) {
-                if (field) {
-                    fields.add(field);
-                }
-            }
-        }
-        else if (step.type === 'mate') {
-            for (const field of MATE_FIELDS) {
-                fields.add(field);
-            }
-        }
-        else if (step.type === 'cells') {
-            for (const field of CELLS_FIELDS) {
-                fields.add(field);
-            }
-        }
-        else if (step.type === 'bin') {
-            for (const edge of step.as?.length === 2 ? step.as : DEFAULT_BIN_AS) {
-                fields.add(edge);
-            }
-            if (step.fields?.length === 2) {
-                fields.add(BIN_OVERLAP_FIELD);
-            }
-        }
-    }
-    return fields;
+    return stepsOutput(steps).surviving;
 }
 // What a list of steps cannot run as written, a mark's, the facet's or the
 // display's, each slot under the list's own name.
@@ -349,6 +292,11 @@ function stepProblems(steps, list = 'transform') {
             !(Number(step.step) > 0)) {
             problems.push(found('bin-width', `${at}.step`, 'a bin is a positive width in bp'));
         }
+        if (type === 'window' &&
+            step.frame !== undefined &&
+            !isWindowFrame(step.frame)) {
+            problems.push(found('window-frame', `${at}.frame`, `a window's frame is two whole row offsets, either null for unbounded, the first not past the second, so it reads [${DEFAULT_WINDOW_FRAME.join(', ')}]`));
+        }
         for (const pair of pairSlots(step)) {
             if (pair.names && pair.names.length !== 2) {
                 problems.push(found('step-pair', `${at}.${pair.slot}`, `a ${type} reads two field names from ${pair.slot} and this names ${pair.names.length}, so it reads ${pair.reads}`));
@@ -360,7 +308,7 @@ function stepProblems(steps, list = 'transform') {
             step.field !== DEFAULT_BIN_FIELD) {
             problems.push(found('bin-field-and-fields', `${at}.field`, `a bin over fields cuts each interval at the bin edges and reads no field, so ${step.field} is unread`));
         }
-        if (type === 'aggregate') {
+        if (type === 'aggregate' || type === 'window') {
             for (const [k, { op = DEFAULT_AGGREGATE_OP, field, weight }] of (step.ops ?? []).entries()) {
                 if (op !== 'count' && !field) {
                     problems.push(found('op-field', `${at}.ops.${k}.field`, `${op} reads a field and names none`));
@@ -379,7 +327,7 @@ function stepProblems(steps, list = 'transform') {
     return problems;
 }
 // Each field a mark's channels read besides `y`, by the slot naming it: the
-// channels its type reads, a colour's or a shape's field where it is a scale,
+// channels its type reads, a color's or a shape's field where it is a scale,
 // a text's field as its default leaves it, and a link's size field.
 function channelFields(mark, spec) {
     const encoding = mark.encoding ?? {};
@@ -423,7 +371,7 @@ function ownProblems(mark, display, section, split) {
     }
     const size = mark.encoding?.size;
     if (!unwritten(size) && spec.size === undefined) {
-        problems.push(found('unread-size', 'encoding.size', `a ${type} draws no point or rule and strokes no link, so it reads no size`));
+        problems.push(found('unread-size', 'encoding.size', `a ${type} draws no point, rule or line and strokes no link, so it reads no size`));
     }
     else if (spec.size === 'constant' && sizeFieldOf(size)) {
         problems.push(found('unread-channel', 'encoding.size.field', `a ${type} reads its size as a number, and only a link maps a field to it`));
@@ -438,25 +386,25 @@ function ownProblems(mark, display, section, split) {
         type !== 'line') {
         problems.push(found('unread-interpolate', 'interpolate', `a ${type} draws no line, so it reads no interpolate`));
     }
+    if (mark.gapBp !== undefined && type !== 'line') {
+        problems.push(found('unread-gap', 'gapBp', `a ${type} draws no line, so it reads no gapBp`));
+    }
     if (mark.rowProportion !== undefined &&
         mark.rowProportion !== DEFAULT_ROW_PROPORTION &&
         type !== 'span') {
         problems.push(found('unread-row-proportion', 'rowProportion', `a ${type} draws no span, so it reads no rowProportion`));
     }
-    if (!readsValue(type) && mark.source === 'density') {
-        problems.push(found('span-density-source', 'source', `a ${type} does not draw the density sidecar`));
-    }
     const color = mark.encoding?.color ?? {};
     for (const { rule, slot, message } of colorProblems(color, FEATURE_FIELD_PRESETS)) {
         problems.push(found(rule, `encoding.color.${slot}`, message));
     }
     if (colorScaleOf(color) === 'threshold' &&
         (color.domain ?? []).length === 0) {
-        problems.push(found('threshold-no-cuts', 'encoding.color.domain', 'a threshold names its cut points in domain, and with none every value paints the first colour'));
+        problems.push(found('threshold-no-cuts', 'encoding.color.domain', 'a threshold names its cut points in domain, and with none every value paints the first color'));
     }
     const cutCount = (color.domain ?? []).filter(cut => Number.isFinite(Number(cut))).length;
     if (colorScaleOf(color) === 'threshold' && cutCount > MAX_THRESHOLD_CUTS) {
-        problems.push(found('threshold-cut-count', 'encoding.color.domain', `a threshold paints ${MAX_THRESHOLD_CUTS} cuts, and these ${cutCount} leave a value past the ${MAX_THRESHOLD_CUTS}th in the ${MAX_THRESHOLD_CUTS + 1}th colour`));
+        problems.push(found('threshold-cut-count', 'encoding.color.domain', `a threshold paints ${MAX_THRESHOLD_CUTS} cuts, and these ${cutCount} leave a value past the ${MAX_THRESHOLD_CUTS}th in the ${MAX_THRESHOLD_CUTS + 1}th color`));
     }
     problems.push(...shapeLabelProblems(mark.encoding?.shape));
     problems.push(...constantAsFieldProblems(mark.encoding));
@@ -509,8 +457,16 @@ export function markProblems({ marks, facet, transform = [], rows, scales, }) {
     const section = readable(facet?.transform ?? []);
     const display = readable(transform);
     const shared = [...display, ...section];
+    const madeBeforeSplit = split
+        ? madeFields(drawsRows ? shared : display)
+        : undefined;
     const problems = [
         ...stepProblems(transform),
+        ...(split && madeBeforeSplit && !madeBeforeSplit.has(split)
+            ? [
+                found('unwritten-field', faceted ? 'facet.field' : 'rows.field', `reads "${split}", which no step before it writes; they leave ${[...madeBeforeSplit].join(', ')}`),
+            ]
+            : []),
         ...stepProblems(facet?.transform ?? [], 'facet.transform'),
         ...scaleEndProblems(scales?.y ?? {}).map(({ rule, slot, message }) => found(rule, `scales.y.${slot}`, message)),
         ...(faceted
@@ -554,12 +510,6 @@ export function markProblems({ marks, facet, transform = [], rows, scales, }) {
                     ...found('two-packings', 'transform', `packs rows of its own, as mark ${j} does, and the two share row numbers; one pileup in the ${faceted ? "facet's transform packs them together per section" : "display's transform packs them together"}`),
                 });
             }
-            if (i > j && drawsDensity(mark) && drawsDensity(other)) {
-                problems.push({
-                    mark: i,
-                    ...found('second-density-mark', 'source', `mark ${j} already stands in for the density sidecar here`),
-                });
-            }
         }
     }
     return problems;

package/dist/commands/validate/markRules/markRuleFacts.js

@@ -1,5 +1,5 @@
 // Generated by scripts/generateMarkRules.ts from plugins/marks/src/LinearMarkDisplay/markRuleFacts.ts: do not edit, `pnpm autogen` rewrites it.
-export { aggregateFieldName } from './aggregateFieldName.js';
+export { BIN_OVERLAP_FIELD, DEFAULT_AGGREGATE_OP, DEFAULT_BIN_AS, DEFAULT_COVERAGE_AS, DEFAULT_FORMULA_AS, DEFAULT_PILEUP_AS, aggregateFieldName, stepsOutput, } from './stepOutputs.js';
 export { isNamedColor } from './cssColorsLevel4.js';
 export { isJexl } from './jexlStrings.js';
 export { FEATURE_FIELD_PRESETS, colorProblems, fieldScaleOf, paintedScale, scaleEndProblems, universalPresetOf, } from './colorScale.js';

package/dist/commands/validate/markRules/markSpecs.js

@@ -31,6 +31,7 @@ export const MARK_SPECS = {
         value: 'required',
         hit: 'rows',
         size: 'constant',
+        path: true,
     },
     span: {
         channels: ['row', 'color'],
@@ -62,11 +63,11 @@ export function plotsValue(type) {
     return specOf(type).value !== 'none';
 }
 /** Whether a mark type answers a hover through the hit index the worker builds. */
-export function hitsByIndex(type) {
+function hitsByIndex(type) {
     return specOf(type).hit === 'index';
 }
 /**
- * The lanes a mark asks the worker to fill: its type's channels, the colour
+ * The lanes a mark asks the worker to fill: its type's channels, the color
  * lanes `colorLanesOf` chose for its declaration, and the hit index where the
  * mark answers a hover through one.
  */
@@ -79,6 +80,7 @@ export function markLanes(type, colorLanes) {
                 ? colorLanes
                 : [channel]),
         ...(spec.farFoot ? ['x2Ref'] : []),
+        ...(spec.path ? ['series'] : []),
         ...(hitsByIndex(type) ? ['index'] : []),
     ];
 }