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

package/esm/util/featureTransforms.js

@@ -1,42 +1,23 @@
 import { binnedAggregate, fusesBinAggregate } from './binnedAggregate.js';
 import { categoricalField } from './categoricalField.js';
+import { binnedCellMatches, fusesAfterCells, fusesCellMatches, } from './cellMatches.js';
+import { cells } from './cellsStep.js';
 import { DerivedTable, NO_COLUMN, WithTable, asTable, numberReaderOf, readerOf, selectRows, throughIndex, valueAt, withColumns, } from './featureTable.js';
 import { fieldReader, isPlainFieldRef } from './fieldReader.js';
-import { stringToJexlExpression } from './jexlStrings.js';
+import { isJexl, stringToJexlExpression } from './jexlStrings.js';
 import SimpleFeature, { buildJexlContext } from './simpleFeature.js';
-import { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS, MadeTable, OpSums, binSize, groupKey, intervalsOf, isWeighted, madeGroups, stepNumberReader, stepReader, } from './stepTables.js';
+import { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS, FannedTable, MadeTable, OpSums, binSize, boundsThrough, groupKey, intervalsOf, isWeighted, madeGroups, stepNumberReader, stepReader, } from './stepTables.js';
 import { junctionEnds, svClassOfAlt, svClassOfToken } from './svAlt.js';
 export { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS } from './stepTables.js';
 export const DEFAULT_BIN_FIELD = 'start';
 export const DEFAULT_FLATTEN_FIELD = 'subfeatures';
-export const DEFAULT_CELLS_FIELD = 'seq';
+export { DEFAULT_CELLS_FIELD } from './cellsStep.js';
 export const DEFAULT_COVERAGE_AS = 'coverage';
 export const DEFAULT_PILEUP_AS = 'row';
 export const DEFAULT_PILEUP_FIELDS = ['start', 'end'];
 function oneSection(n) {
     return Uint32Array.of(0, n);
 }
-// Section starts through a step whose rows came from its input's in order:
-// each section starts at the first row whose parent row is in it.
-function boundsThrough(bounds, parentRow) {
-    const out = new Uint32Array(bounds.length);
-    let lo = 0;
-    for (let s = 0; s < bounds.length; s++) {
-        const edge = bounds[s];
-        let hi = parentRow.length;
-        while (lo < hi) {
-            const mid = (lo + hi) >>> 1;
-            if (parentRow[mid] < edge) {
-                lo = mid + 1;
-            }
-            else {
-                hi = mid;
-            }
-        }
-        out[s] = lo;
-    }
-    return out;
-}
 function expression(expr, jexl) {
     if (!jexl) {
         throw new Error(`a jexl transform needs a jexl instance (${expr})`);
@@ -94,19 +75,6 @@ function fannedEntries(items) {
         ? Object.entries(items)
         : [];
 }
-/**
- * The entries a `flatten` fanned out, one row each over the container row it
- * came from. A container kept with nothing to fan out is a row of its own
- * that reads everything off itself.
- */
-class FannedTable extends DerivedTable {
-    get madeFrom() {
-        return true;
-    }
-    row(i) {
-        return this.isKept(i) ? this.parent.row(this.parentOf(i)) : super.row(i);
-    }
-}
 /**
  * The entries a `flatten` fanned out of a list or record a row holds. An
  * entry answers a field it carries — a feature its own, a record its own key,
@@ -421,425 +389,6 @@ function flattenValues({ table, bounds }, step) {
         bounds: boundsThrough(bounds, rows),
     };
 }
-const DASH = 45;
-const SPACE = 32;
-const LOWER_BIT = 0x20;
-const CELL_STATES = ['match', 'mismatch', 'gap', 'insertion'];
-const MATCH = 0;
-const MISMATCH = 1;
-const GAP = 2;
-const INSERTION = 3;
-const NO_STATE = 255;
-function isGapByte(b) {
-    return b === DASH || b === SPACE;
-}
-// The row a cell step reads against: past any table that only reordered or
-// annotated the rows, the one they were fanned out of.
-function containerOf(table) {
-    let at = table;
-    let toBase;
-    while (at instanceof DerivedTable && !at.madeFrom) {
-        toBase = at.parentRow ? compose(toBase, at.parentRow) : toBase;
-        at = at.parent;
-    }
-    if (!(at instanceof DerivedTable)) {
-        return undefined;
-    }
-    return {
-        made: at,
-        toMade: toBase,
-        table: at.parent,
-        row: at.parentRow ? compose(toBase, at.parentRow) : toBase,
-    };
-}
-function compose(outer, inner) {
-    if (!outer) {
-        return inner;
-    }
-    const out = new Uint32Array(outer.length);
-    for (let i = 0; i < outer.length; i++) {
-        out[i] = inner[outer[i]];
-    }
-    return out;
-}
-// Below this length a character loop copies a string faster than
-// `encodeInto`, as the MAF packer measured.
-const ASCII_COPY_MAX_LENGTH = 64;
-const encoder = new TextEncoder();
-// A column's text as bytes, one per character: an adapter's own, or the
-// strings a feature holds copied into one buffer.
-function textOf(column, n) {
-    if (column.kind === 'text') {
-        return column;
-    }
-    const read = readerOf(column);
-    const texts = new Array(n);
-    let total = 0;
-    for (let i = 0; i < n; i++) {
-        const v = read(i);
-        if (typeof v === 'string') {
-            texts[i] = v;
-            total += v.length;
-        }
-    }
-    const bytes = new Uint8Array(total);
-    const offset = new Uint32Array(n);
-    const length = new Uint32Array(n);
-    let pos = 0;
-    for (let i = 0; i < n; i++) {
-        const text = texts[i];
-        if (text === undefined) {
-            continue;
-        }
-        offset[i] = pos;
-        if (text.length <= ASCII_COPY_MAX_LENGTH) {
-            for (let c = 0; c < text.length; c++) {
-                bytes[pos + c] = text.charCodeAt(c);
-            }
-            length[i] = text.length;
-        }
-        else {
-            length[i] = encoder.encodeInto(text, bytes.subarray(pos, pos + text.length)).written;
-        }
-        pos += text.length;
-    }
-    return { kind: 'text', bytes, offset, length, at: undefined };
-}
-/**
- * The texts a `cells` walk reads, by the row of the table it walked: each
- * row's own, and the reference it is read against, which a row fanned out of
- * a container reads off the container.
- */
-class WalkedTexts {
-    row;
-    reference;
-    refRow;
-    constructor(row, ref, refRow) {
-        this.row = row;
-        this.reference = ref;
-        this.refRow = refRow;
-    }
-    rowOf(r) {
-        const { at } = this.row;
-        return at ? at[r] : r;
-    }
-    refOf(r) {
-        const p = this.refRow ? this.refRow[r] : r;
-        const { at } = this.reference;
-        return at ? at[p] : p;
-    }
-}
-function walkedTexts(table, field) {
-    const row = textOf(table.column(field), table.length);
-    const container = containerOf(table);
-    const made = container?.made;
-    if (container && !(made instanceof FannedTable && made.hasKept)) {
-        const { table: base } = container;
-        return new WalkedTexts(row, textOf(base.column(field), base.length), container.row);
-    }
-    // A container a flatten kept with nothing to fan out is the row itself, so
-    // its reference is its own container's, as its `parent()` says.
-    const byParent = (r) => table.row(r).parent?.()?.get(field);
-    const readContainer = container
-        ? readerOf(container.table.column(field))
-        : undefined;
-    const read = readContainer && made instanceof FannedTable
-        ? (r) => {
-            const { toMade, row: refRow } = container;
-            return made.isKept(toMade ? toMade[r] : r)
-                ? byParent(r)
-                : readContainer(refRow ? refRow[r] : r);
-        }
-        : byParent;
-    return new WalkedTexts(row, textOf({ kind: 'value', read }, table.length));
-}
-/**
- * The runs a `cells` step answers, one per stretch of one state against the
- * reference, typed: each run's span, its state and the text column it starts
- * at, with `base`, `match` and `length` read back out of the texts when asked
- * for.
- */
-class CellTable extends DerivedTable {
-    start;
-    end;
-    state;
-    textAt;
-    texts;
-    firstOfRow;
-    derived = new Map();
-    constructor(parent, parentRow, lanes, texts) {
-        super(parent, parentRow);
-        this.start = lanes.start;
-        this.end = lanes.end;
-        this.state = lanes.state;
-        this.textAt = lanes.textAt;
-        this.texts = texts;
-    }
-    get madeFrom() {
-        return true;
-    }
-    laneOf(name, build) {
-        let column = this.derived.get(name);
-        if (!column) {
-            column = build();
-            this.derived.set(name, column);
-        }
-        return column;
-    }
-    own(name) {
-        switch (name) {
-            case 'start': {
-                return { kind: 'number', values: this.start, at: undefined };
-            }
-            case 'end': {
-                return { kind: 'number', values: this.end, at: undefined };
-            }
-            case 'state': {
-                return {
-                    kind: 'category',
-                    codes: this.state,
-                    labels: CELL_STATES,
-                    at: undefined,
-                };
-            }
-            case 'match': {
-                return this.laneOf(name, () => {
-                    const values = new Float32Array(this.length);
-                    for (let i = 0; i < this.length; i++) {
-                        const s = this.state[i];
-                        values[i] = s === MATCH ? 1 : s === MISMATCH ? 0 : Number.NaN;
-                    }
-                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
-                });
-            }
-            case 'length': {
-                return this.laneOf(name, () => {
-                    const values = new Float32Array(this.length).fill(Number.NaN);
-                    for (let i = 0; i < this.length; i++) {
-                        if (this.state[i] === INSERTION) {
-                            values[i] = this.inserted(i).length;
-                        }
-                    }
-                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
-                });
-            }
-            case 'base': {
-                return this.laneOf(name, () => {
-                    const values = new Array(this.length);
-                    for (let i = 0; i < this.length; i++) {
-                        const s = this.state[i];
-                        values[i] =
-                            s === MISMATCH
-                                ? this.mismatched(i)
-                                : s === INSERTION
-                                    ? this.inserted(i)
-                                    : undefined;
-                    }
-                    return { kind: 'value', read: i => values[i] };
-                });
-            }
-            default: {
-                return undefined;
-            }
-        }
-    }
-    mismatched(i) {
-        const { bytes, offset } = this.texts.row;
-        const k = this.texts.rowOf(this.parentOf(i));
-        return String.fromCharCode(bytes[offset[k] + this.textAt[i]]);
-    }
-    // The bases a row holds where the reference has none, from the column the
-    // insertion starts at to the reference's next base.
-    inserted(i) {
-        const { row, reference: ref } = this.texts;
-        const r = this.parentOf(i);
-        const k = this.texts.rowOf(r);
-        const f = this.texts.refOf(r);
-        const rowAt = row.offset[k];
-        const refAt = ref.offset[f];
-        const end = Math.min(row.length[k], ref.length[f]);
-        let out = '';
-        for (let col = this.textAt[i]; col < end && ref.bytes[refAt + col] === DASH; col++) {
-            const b = row.bytes[rowAt + col];
-            if (!isGapByte(b)) {
-                out += String.fromCharCode(b);
-            }
-        }
-        return out;
-    }
-    id(i) {
-        const p = this.parentOf(i);
-        this.firstOfRow ??= firstRowIndex(this.parentRow, this.parent.length);
-        return `${this.parent.row(p).id()}#${i - this.firstOfRow[p]}`;
-    }
-    json(i) {
-        const out = {
-            ...this.parent.row(this.parentOf(i)).toJSON(),
-            start: this.start[i],
-            end: this.end[i],
-            state: CELL_STATES[this.state[i]],
-        };
-        for (const name of ['base', 'match', 'length']) {
-            const v = valueAt(this.column(name), i);
-            if (v !== undefined) {
-                out[name] = v;
-            }
-        }
-        return out;
-    }
-}
-// The lanes a `cells` walk writes, doubled as a row would overrun them.
-class RunLanes {
-    start;
-    end;
-    state;
-    textAt;
-    parentRow;
-    length = 0;
-    constructor(capacity) {
-        this.start = new Uint32Array(capacity);
-        this.end = new Uint32Array(capacity);
-        this.state = new Uint8Array(capacity);
-        this.textAt = new Uint32Array(capacity);
-        this.parentRow = new Uint32Array(capacity);
-    }
-    reserve(more) {
-        const need = this.length + more;
-        if (need <= this.start.length) {
-            return;
-        }
-        const size = Math.max(this.start.length * 2, need);
-        const widen = (a) => {
-            const next = new a.constructor(size);
-            next.set(a);
-            return next;
-        };
-        this.start = widen(this.start);
-        this.end = widen(this.end);
-        this.state = widen(this.state);
-        this.textAt = widen(this.textAt);
-        this.parentRow = widen(this.parentRow);
-    }
-    // One row's runs against its reference: a run per column is the most it
-    // can answer, so the lanes grow once and the walk writes through locals.
-    walk(r, startPos, rowBytes, rowAt, rowLen, refBytes, refAt, refLen) {
-        this.reserve(refLen + 1);
-        const { start, end, state, textAt, parentRow } = this;
-        let n = this.length;
-        let pos = startPos;
-        // The columns carrying the row's own sequence: a gap run reaching either
-        // end of the row measures where the block was cut, not the alignment, so
-        // it is no cell either.
-        let first = 0;
-        while (first < rowLen && isGapByte(rowBytes[rowAt + first])) {
-            first++;
-        }
-        let last = rowLen - 1;
-        while (last > first && isGapByte(rowBytes[rowAt + last])) {
-            last--;
-        }
-        let runStart = -1;
-        let runState = NO_STATE;
-        let runBase = -1;
-        let runCol = 0;
-        let insertAt = -1;
-        for (let col = 0; col < refLen; col++) {
-            const refByte = refBytes[refAt + col];
-            const rowByte = col < rowLen ? rowBytes[rowAt + col] : SPACE;
-            if (refByte === DASH) {
-                if (insertAt < 0 && col < rowLen && !isGapByte(rowByte)) {
-                    insertAt = col;
-                }
-                continue;
-            }
-            if (insertAt >= 0) {
-                start[n] = pos;
-                end[n] = pos;
-                state[n] = INSERTION;
-                textAt[n] = insertAt;
-                parentRow[n] = r;
-                n++;
-                insertAt = -1;
-            }
-            const drawn = col >= first && col <= last && col < rowLen;
-            const st = !drawn
-                ? NO_STATE
-                : isGapByte(rowByte)
-                    ? GAP
-                    : (refByte | LOWER_BIT) === (rowByte | LOWER_BIT)
-                        ? MATCH
-                        : MISMATCH;
-            const base = st === MISMATCH ? rowByte : -1;
-            if (st !== runState || base !== runBase) {
-                if (runStart >= 0) {
-                    start[n] = runStart;
-                    end[n] = pos;
-                    state[n] = runState;
-                    textAt[n] = runCol;
-                    parentRow[n] = r;
-                    n++;
-                }
-                runStart = st === NO_STATE ? -1 : pos;
-                runState = st;
-                runBase = base;
-                runCol = col;
-            }
-            pos++;
-        }
-        if (runStart >= 0) {
-            start[n] = runStart;
-            end[n] = pos;
-            state[n] = runState;
-            textAt[n] = runCol;
-            parentRow[n] = r;
-            n++;
-        }
-        this.length = n;
-    }
-}
-// Where each parent row's children start, for children written parent by
-// parent in order.
-function firstRowIndex(parentRow, parents) {
-    const first = new Uint32Array(parents);
-    for (let i = parentRow.length - 1; i >= 0; i--) {
-        first[parentRow[i]] = i;
-    }
-    return first;
-}
-function cells({ table, bounds }, step) {
-    const { field = DEFAULT_CELLS_FIELD } = step;
-    const texts = walkedTexts(table, field);
-    const readStart = numberReaderOf(table.column('start'));
-    const { bytes: rowBytes, offset: rowOffset, length: rowLength } = texts.row;
-    const { bytes: refBytes, offset: refOffset, length: refLength, } = texts.reference;
-    // A run per reference base is the most a row can answer and far past what
-    // one does, so the lanes start at an eighth of it.
-    let bound = 0;
-    for (let r = 0; r < table.length; r++) {
-        bound += refLength[texts.refOf(r)] + 1;
-    }
-    const lanes = new RunLanes(Math.max(1024, bound >>> 3));
-    for (let r = 0; r < table.length; r++) {
-        const f = texts.refOf(r);
-        const refLen = refLength[f];
-        const pos = readStart(r);
-        if (refLen > 0 && pos >= 0) {
-            const k = texts.rowOf(r);
-            lanes.walk(r, pos, rowBytes, rowOffset[k], rowLength[k], refBytes, refOffset[f], refLen);
-        }
-    }
-    const n = lanes.length;
-    const rows = lanes.parentRow.subarray(0, n);
-    return {
-        table: new CellTable(table, rows, {
-            start: lanes.start.subarray(0, n),
-            end: lanes.end.subarray(0, n),
-            state: lanes.state.subarray(0, n),
-            textAt: lanes.textAt.subarray(0, n),
-        }, texts),
-        bounds: boundsThrough(bounds, rows),
-    };
-}
 function statedMate(f) {
     const mate = f.get('mate');
     return mate?.refName !== undefined && mate.start !== undefined
@@ -867,23 +416,34 @@ function mateFields(f, alt, mate, ownDirection, alleleIndex = 0) {
         ...(svType ? { svType } : {}),
     };
 }
+// A paired read's mate, where the file places one: the sequence and position
+// its next segment aligns to, one base of it.
+function pairedMate(f) {
+    const refName = f.get('next_ref');
+    const pos = f.get('next_pos');
+    return typeof refName === 'string' && typeof pos === 'number' && pos >= 0
+        ? { refName, start: pos, end: pos + 1, mateDirection: 0 }
+        : undefined;
+}
 /**
  * #api
  * How a record states its other end, or undefined where it states none: the
- * `mate` a paired adapter fills (BEDPE, STAR-Fusion), or an `ALT` the breakend
- * and symbolic-SV readers resolve. The `mate` step admits exactly the features
- * this names one for, so a caller deciding whether links are the picture a
- * track wants asks here rather than re-reading the fields.
+ * `mate` a paired adapter fills (BEDPE, STAR-Fusion), an `ALT` the breakend
+ * and symbolic-SV readers resolve, or a read's `next_ref` and `next_pos`. The
+ * `mate` step admits exactly the features this names one for, so a caller
+ * deciding whether links are the picture a track wants asks here rather than
+ * re-reading the fields.
  */
 export function matedBy(f) {
     if (statedMate(f)) {
         return 'mate';
     }
     const alts = f.get('ALT');
-    return Array.isArray(alts) &&
-        alts.some((alt, i) => junctionEnds(f, alt, i))
-        ? 'alt'
-        : undefined;
+    if (Array.isArray(alts) &&
+        alts.some((alt, i) => junctionEnds(f, alt, i))) {
+        return 'alt';
+    }
+    return pairedMate(f) ? 'pair' : undefined;
 }
 /**
  * The ends a `mate` step admitted: each a row of the record it came from, with
@@ -923,9 +483,7 @@ function mates({ table, bounds }) {
     for (let s = 0; s + 1 < bounds.length; s++) {
         out[s] = parentRow.length;
         const seen = new Set();
-        const admit = (i, f, mate, written, id) => {
-            const here = `${f.get('refName')}:${f.get('start')}-${f.get('end')}`;
-            const there = `${mate.refName}:${mate.start}-${mate.end}`;
+        const admit = (i, here, there, written, id) => {
             const key = here < there ? `${here}|${there}` : `${there}|${here}`;
             if (!seen.has(key)) {
                 seen.add(key);
@@ -934,17 +492,26 @@ function mates({ table, bounds }) {
                 ids.push(id);
             }
         };
+        const span = (f, mate) => [
+            `${f.get('refName')}:${f.get('start')}-${f.get('end')}`,
+            `${mate.refName}:${mate.start}-${mate.end}`,
+        ];
         for (let i = bounds[s]; i < bounds[s + 1]; i++) {
             const f = table.row(i);
             const stated = statedMate(f);
             if (stated) {
                 const ends = junctionEnds(f);
                 const mate = { ...stated, mateDirection: ends.mate.keeps };
-                admit(i, f, mate, mateFields(f, undefined, mate, ends.own.keeps));
+                admit(i, ...span(f, mate), mateFields(f, undefined, mate, ends.own.keeps));
                 continue;
             }
             const alts = f.get('ALT');
             if (!Array.isArray(alts)) {
+                // each read of a pair names the other's start, so the pair is one key
+                const pair = pairedMate(f);
+                if (pair) {
+                    admit(i, `${f.get('refName')}:${f.get('start')}`, `${pair.refName}:${pair.start}`, { mate: pair, mateDirection: 0 });
+                }
                 continue;
             }
             for (const [a, alt] of alts.entries()) {
@@ -958,7 +525,7 @@ function mates({ table, bounds }) {
                     end: ends.mate.pos + 1,
                     mateDirection: ends.mate.keeps,
                 };
-                admit(i, f, mate, mateFields(f, alt, mate, ends.own.keeps, a), alts.length > 1 ? `${f.id()}#${a}` : undefined);
+                admit(i, ...span(f, mate), mateFields(f, alt, mate, ends.own.keeps, a), alts.length > 1 ? `${f.id()}#${a}` : undefined);
             }
         }
     }
@@ -1350,12 +917,24 @@ function runSteps(staged, steps, jexl) {
     for (let k = 0; k < list.length; k++) {
         const step = list[k];
         const next = list[k + 1];
-        const fused = step.type === 'bin' &&
+        const after = list[k + 2];
+        const matches = step.type === 'cells' &&
+            next?.type === 'bin' &&
+            after?.type === 'aggregate' &&
+            fusesCellMatches(step, next, after)
+            ? binnedCellMatches(current, step, next, after)
+            : undefined;
+        const fused = !matches &&
+            step.type === 'bin' &&
             next?.type === 'aggregate' &&
             fusesBinAggregate(step, next)
             ? binnedAggregate(current, step, next)
             : undefined;
-        if (fused) {
+        if (matches) {
+            current = matches;
+            k += 2;
+        }
+        else if (fused) {
             current = fused;
             k++;
         }
@@ -1365,10 +944,83 @@ function runSteps(staged, steps, jexl) {
     }
     return current;
 }
+/**
+ * Each layer's steps over `steps` run once for all of them. A trailing
+ * `cells` runs inside each layer whose own steps start with the bin and
+ * aggregate it fuses with, so `runSteps` meets the three together, and once
+ * for the other layers.
+ */
+function runLayers(staged, steps, layers, jexl, keep = s => s) {
+    const list = steps ?? [];
+    const last = list.at(-1);
+    const trailing = last?.type === 'cells' && layers.some(own => fusesAfterCells(last, own))
+        ? last
+        : undefined;
+    if (!trailing) {
+        const shared = keep(runSteps(staged, list, jexl), list);
+        return layers.map(own => keep(runSteps(shared, own, jexl), own));
+    }
+    const ahead = runSteps(staged, list.slice(0, -1), jexl);
+    let shared;
+    return layers.map(own => fusesAfterCells(trailing, own)
+        ? keep(runSteps(ahead, [trailing, ...own], jexl), [...list, ...own])
+        : keep(runSteps((shared ??= keep(runStep(ahead, trailing, jexl), list)), own, jexl), own));
+}
 function rowOf(value) {
     const row = Number(value);
     return row > 0 ? Math.floor(row) : 0;
 }
+/**
+ * A section's rows behind a step that made them from nothing, a coverage's
+ * runs or an aggregate's groups, still answer the field their section was
+ * split on, as a ggplot2 stat keeps its facet variable: one column of each
+ * section's key, built the first time a channel reads it, and a parent that
+ * carries the field itself is read instead.
+ */
+class SectionTable extends DerivedTable {
+    field;
+    labels;
+    bounds;
+    constructor(parent, field, labels, bounds) {
+        super(parent, undefined);
+        this.field = field;
+        this.labels = labels;
+        this.bounds = bounds;
+    }
+    own(field) {
+        if (field !== this.field || this.parent.column(field).kind !== 'none') {
+            return undefined;
+        }
+        const { labels } = this;
+        const codes = new Uint32Array(this.length);
+        for (let s = 0; s < labels.length; s++) {
+            codes.fill(s, this.bounds[s], this.bounds[s + 1]);
+        }
+        // the section of the rows with nothing in the field answers nothing
+        return labels.includes('')
+            ? { kind: 'value', read: i => labels[codes[i]] || undefined }
+            : { kind: 'category', codes, labels, at: undefined };
+    }
+    json(i) {
+        const out = super.json(i);
+        const label = valueAt(this.column(this.field), i);
+        return label === undefined || this.field in out
+            ? out
+            : { ...out, [this.field]: label };
+    }
+}
+function makesRows(steps) {
+    return steps?.some(s => s.type === 'aggregate' || s.type === 'coverage');
+}
+// The staged rows still naming their section's value where a step made them
+function keepingSection(staged, steps, field, labels) {
+    return !isJexl(field) && makesRows(steps)
+        ? {
+            ...staged,
+            table: new SectionTable(staged.table, field, labels, staged.bounds),
+        }
+        : staged;
+}
 /**
  * #api
  * A faceted request's layers: the rows split on the facet's field, the
@@ -1444,9 +1096,10 @@ export function facetLayers(input, facet, layers, jexl) {
     for (let i = 0; i < n; i++) {
         order[next[sectionOf[keyOfRow[i]]]++] = i;
     }
-    const sectioned = runSteps({ table: selectRows(table, order), bounds }, sectionSteps, jexl);
-    const placed = layers.map(({ transform, row }) => {
-        const out = runSteps(sectioned, transform, jexl);
+    const labels = ordered.map(k => keys[k]);
+    const layered = runLayers({ table: selectRows(table, order), bounds }, sectionSteps, layers.map(({ transform }) => transform), jexl, (staged, steps) => keepingSection(staged, steps, field, labels));
+    const placed = layers.map(({ row }, l) => {
+        const out = layered[l];
         const readRow = row === undefined
             ? undefined
             : isPlainFieldRef(row)
@@ -1556,12 +1209,11 @@ function partitionPoint(steps, field) {
 export function layerTables(input, request, jexl) {
     const { transform = [], facet, layers } = request;
     if (!facet) {
-        const shared = runTransforms(input, transform, jexl);
+        const table = asTable(input);
+        const layered = runLayers({ table, bounds: oneSection(table.length) }, transform, layers.map(layer => layer.transform), jexl);
         return {
-            layers: layers.map(layer => ({
-                table: layer.transform?.length
-                    ? runTransforms(shared, layer.transform, jexl)
-                    : shared,
+            layers: layers.map((layer, l) => ({
+                table: layered[l].table,
                 row: layer.row,
             })),
             sections: undefined,