@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/featureTransforms.js

@@ -0,0 +1,1579 @@
+import { binnedAggregate, fusesBinAggregate } from './binnedAggregate.js';
+import { categoricalField } from './categoricalField.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 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 { 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 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})`);
+    }
+    return stringToJexlExpression(expr, jexl);
+}
+class RowsBuilder {
+    data = new Uint32Array(256);
+    length = 0;
+    push(v) {
+        if (this.length === this.data.length) {
+            const next = new Uint32Array(this.data.length * 2);
+            next.set(this.data);
+            this.data = next;
+        }
+        this.data[this.length++] = v;
+    }
+    finish() {
+        return this.data.slice(0, this.length);
+    }
+}
+function filter({ table, bounds }, expr, jexl) {
+    const compiled = expression(expr, jexl);
+    const kept = new RowsBuilder();
+    for (let i = 0; i < table.length; i++) {
+        if (compiled.eval(buildJexlContext({ feature: table.row(i) }))) {
+            kept.push(i);
+        }
+    }
+    const parentRow = kept.finish();
+    return {
+        table: selectRows(table, parentRow),
+        bounds: boundsThrough(bounds, parentRow),
+    };
+}
+function formula({ table, bounds }, expr, as, jexl) {
+    const compiled = expression(expr, jexl);
+    const values = new Array(table.length);
+    for (let i = 0; i < table.length; i++) {
+        values[i] = compiled.eval(buildJexlContext({ feature: table.row(i) }));
+    }
+    const column = { kind: 'value', read: i => values[i] };
+    return { table: new WithTable(table, new Map([[as, column]])), bounds };
+}
+function isFeature(item) {
+    return typeof item?.get === 'function';
+}
+// An array's elements in order, or a record's entries keyed by name; a
+// feature standing in the field is neither.
+function fannedEntries(items) {
+    if (Array.isArray(items)) {
+        return [...items.entries()];
+    }
+    return typeof items === 'object' && items !== null && !isFeature(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,
+ * a plain value the fanned field — and the container answers the rest,
+ * except the fanned field itself, so an entry never reads back its siblings.
+ */
+class FlatTable extends FannedTable {
+    field;
+    items;
+    at;
+    position;
+    indexField;
+    keyField;
+    constructor(parent, parentRow, field, items, at, position, step) {
+        super(parent, parentRow);
+        this.field = field;
+        this.items = items;
+        this.at = at;
+        this.position = position;
+        this.indexField = step.index;
+        this.keyField = step.key;
+    }
+    isKept(i) {
+        return this.at[i] === undefined;
+    }
+    get hasKept() {
+        return this.at.includes(undefined);
+    }
+    // An entry's value for a field, `undefined` where it states none.
+    entryValue(i, name) {
+        if (this.at[i] === undefined) {
+            return undefined;
+        }
+        const item = this.items[i];
+        if (isFeature(item)) {
+            return item.get(name);
+        }
+        if (typeof item === 'object' && item !== null) {
+            return name === 'uniqueId'
+                ? this.id(i)
+                : item[name];
+        }
+        return name === this.field ? item : undefined;
+    }
+    isOwnKey(i) {
+        return this.keyField !== undefined && typeof this.at[i] === 'string';
+    }
+    // The key as codes into the names met, where every row is an entry keyed
+    // by name: a record's species or samples, which a facet then splits on
+    // once per name.
+    keyCategory() {
+        const codes = new Uint32Array(this.length);
+        const labels = [];
+        const codeOf = new Map();
+        for (let i = 0; i < this.length; i++) {
+            const at = this.at[i];
+            if (typeof at !== 'string') {
+                return undefined;
+            }
+            let code = codeOf.get(at);
+            if (code === undefined) {
+                code = labels.length;
+                codeOf.set(at, code);
+                labels.push(at);
+            }
+            codes[i] = code;
+        }
+        return { kind: 'category', codes, labels, at: undefined };
+    }
+    own(name) {
+        const read = readerOf(this.inherited(name));
+        const fanned = name === this.field;
+        const entryThenContainer = (i) => {
+            const v = this.entryValue(i, name);
+            return v === undefined && (!fanned || this.isKept(i)) ? read(i) : v;
+        };
+        if (name === this.indexField) {
+            const { position } = this;
+            return {
+                kind: 'value',
+                read: i => this.at[i] === undefined ? entryThenContainer(i) : position[i],
+            };
+        }
+        if (name === this.keyField) {
+            return (this.keyCategory() ?? {
+                kind: 'value',
+                read: i => (this.isOwnKey(i) ? this.at[i] : entryThenContainer(i)),
+            });
+        }
+        return { kind: 'value', read: entryThenContainer };
+    }
+    id(i) {
+        const at = this.at[i];
+        const container = this.parent.row(this.parentOf(i));
+        if (at === undefined) {
+            return container.id();
+        }
+        const item = this.items[i];
+        return isFeature(item) ? item.id() : `${container.id()}#${at}`;
+    }
+    json(i) {
+        const containerRow = this.parent.row(this.parentOf(i));
+        const at = this.at[i];
+        const own = {};
+        if (this.indexField !== undefined && at !== undefined) {
+            own[this.indexField] = this.position[i];
+        }
+        if (this.keyField !== undefined && this.isOwnKey(i)) {
+            own[this.keyField] = at;
+        }
+        if (at === undefined) {
+            return { ...containerRow.toJSON(), ...own };
+        }
+        const item = this.items[i];
+        if (!isFeature(item) && (typeof item !== 'object' || item === null)) {
+            return { ...containerRow.toJSON(), [this.field]: item, ...own };
+        }
+        const { [this.field]: _siblings, ...container } = containerRow.toJSON();
+        const entry = isFeature(item)
+            ? item.toJSON()
+            : new SimpleFeature({
+                refName: containerRow.get('refName'),
+                start: containerRow.get('start'),
+                end: containerRow.get('end'),
+                ...item,
+                uniqueId: this.id(i),
+            }).toJSON();
+        return { ...container, ...entry, ...own };
+    }
+}
+/**
+ * The entries a `flatten` fanned out of a list column, which are the list's
+ * own rows: an entry reads the fields its list holds straight off the list's
+ * lanes, and the container the rest. A keyed entry is a record filed under
+ * its name, any other a feature of its own.
+ */
+class ListFlatTable extends FannedTable {
+    field;
+    list;
+    entryRow;
+    position;
+    kept;
+    indexField;
+    keyField;
+    constructor(parent, parentRow, field, list, entryRow, position, kept, step) {
+        super(parent, parentRow);
+        this.field = field;
+        this.list = list;
+        this.entryRow = entryRow;
+        this.position = position;
+        this.kept = kept;
+        this.indexField = step.index;
+        this.keyField = step.key;
+    }
+    isKept(i) {
+        return this.kept?.[i] === 1;
+    }
+    get hasKept() {
+        return this.kept !== undefined;
+    }
+    entryOf(i) {
+        return this.entryRow ? this.entryRow[i] : i;
+    }
+    throughEntries(column) {
+        return this.entryRow ? throughIndex(column, this.entryRow) : column;
+    }
+    entryColumn(name) {
+        const { keys, entries } = this.list;
+        if (name === this.indexField) {
+            return { kind: 'number', values: this.position, at: undefined };
+        }
+        if (name === this.keyField && keys) {
+            return this.throughEntries(keys);
+        }
+        if (name === this.field) {
+            return NO_COLUMN;
+        }
+        if (name === 'uniqueId' && keys) {
+            return { kind: 'value', read: i => this.id(i) };
+        }
+        const column = entries.column(name);
+        return column.kind === 'none' ? undefined : this.throughEntries(column);
+    }
+    own(name) {
+        const column = this.entryColumn(name);
+        const { kept } = this;
+        if (!kept || column === undefined) {
+            return column;
+        }
+        const entry = readerOf(column);
+        const container = readerOf(this.inherited(name));
+        return { kind: 'value', read: i => (kept[i] ? container(i) : entry(i)) };
+    }
+    id(i) {
+        const container = this.parent.row(this.parentOf(i));
+        if (this.isKept(i)) {
+            return container.id();
+        }
+        const { keys, entries } = this.list;
+        const j = this.entryOf(i);
+        return keys
+            ? `${container.id()}#${String(valueAt(keys, j))}`
+            : entries.id(j);
+    }
+    json(i) {
+        const containerRow = this.parent.row(this.parentOf(i));
+        if (this.isKept(i)) {
+            return containerRow.toJSON();
+        }
+        const { keys, entries } = this.list;
+        const j = this.entryOf(i);
+        const own = {};
+        if (this.indexField !== undefined) {
+            own[this.indexField] = this.position[i];
+        }
+        if (this.keyField !== undefined && keys) {
+            own[this.keyField] = valueAt(keys, j);
+        }
+        const { [this.field]: _siblings, ...container } = containerRow.toJSON();
+        const entry = keys
+            ? {
+                refName: containerRow.get('refName'),
+                start: containerRow.get('start'),
+                end: containerRow.get('end'),
+                ...entries.record(j),
+                uniqueId: this.id(i),
+            }
+            : entries.json(j);
+        return { ...container, ...entry, ...own };
+    }
+}
+// A list column fanned out: each row's entries in order, their positions and
+// the entry rows they are, with no entry read.
+function flattenList({ table, bounds }, step, field, list) {
+    const { start, at } = list;
+    const n = table.length;
+    let size = 0;
+    let empty = 0;
+    for (let i = 0; i < n; i++) {
+        const r = at ? at[i] : i;
+        const count = start[r + 1] - start[r];
+        size += count;
+        if (count === 0) {
+            empty++;
+        }
+    }
+    const total = size + (step.keepEmpty ? empty : 0);
+    const parentRow = new Uint32Array(total);
+    const position = new Uint32Array(total);
+    const entryRow = new Uint32Array(total);
+    const kept = total > size ? new Uint8Array(total) : undefined;
+    let k = 0;
+    let inOrder = true;
+    for (let i = 0; i < n; i++) {
+        const r = at ? at[i] : i;
+        const from = start[r];
+        const to = start[r + 1];
+        if (from === to && kept) {
+            parentRow[k] = i;
+            kept[k] = 1;
+            inOrder = false;
+            k++;
+        }
+        for (let j = from; j < to; j++) {
+            parentRow[k] = i;
+            position[k] = j - from;
+            entryRow[k] = j;
+            inOrder &&= j === k;
+            k++;
+        }
+    }
+    return {
+        table: new ListFlatTable(table, parentRow, field, list, inOrder ? undefined : entryRow, position, kept, step),
+        bounds: boundsThrough(bounds, parentRow),
+    };
+}
+function flatten(staged, step) {
+    const { field = DEFAULT_FLATTEN_FIELD } = step;
+    const column = isPlainFieldRef(field) ? staged.table.column(field) : undefined;
+    return column?.kind === 'list'
+        ? flattenList(staged, step, field, column)
+        : flattenValues(staged, step);
+}
+function flattenValues({ table, bounds }, step) {
+    const { field = DEFAULT_FLATTEN_FIELD, keepEmpty } = step;
+    const read = stepReader(table, field, 'a flatten');
+    const parentRow = new RowsBuilder();
+    const position = new RowsBuilder();
+    const items = [];
+    const at = [];
+    for (let i = 0; i < table.length; i++) {
+        const entries = fannedEntries(read(i));
+        if (entries.length === 0) {
+            if (keepEmpty) {
+                parentRow.push(i);
+                position.push(0);
+                items.push(undefined);
+                at.push(undefined);
+            }
+            continue;
+        }
+        for (const [p, [key, item]] of entries.entries()) {
+            parentRow.push(i);
+            position.push(p);
+            items.push(item);
+            at.push(key);
+        }
+    }
+    const rows = parentRow.finish();
+    return {
+        table: new FlatTable(table, rows, field, items, at, position.finish(), 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
+        ? {
+            refName: mate.refName,
+            start: mate.start,
+            end: mate.end ?? mate.start + 1,
+            mateDirection: mate.mateDirection ?? 0,
+        }
+        : undefined;
+}
+function mateFields(f, alt, mate, ownDirection, alleleIndex = 0) {
+    const info = f.get('INFO');
+    const svType = alt === undefined
+        ? svClassOfToken(String(info?.SVTYPE?.[0] ?? ''))
+        : svClassOfAlt(alt, {
+            ref: f.get('REF'),
+            info,
+            alleleIndex,
+        });
+    return {
+        mate,
+        mateDirection: ownDirection,
+        ...(alt === undefined ? {} : { alt }),
+        ...(svType ? { svType } : {}),
+    };
+}
+/**
+ * #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.
+ */
+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;
+}
+/**
+ * The ends a `mate` step admitted: each a row of the record it came from, with
+ * its mate's fields beside the record's, an allele of a record with several
+ * named by its position.
+ */
+class MateTable extends DerivedTable {
+    fields;
+    ids;
+    constructor(parent, parentRow, fields, ids) {
+        super(parent, parentRow);
+        this.fields = fields;
+        this.ids = ids;
+    }
+    own(name) {
+        if (!this.fields.some(f => name in f)) {
+            return undefined;
+        }
+        const read = readerOf(this.inherited(name));
+        return {
+            kind: 'value',
+            read: i => (name in this.fields[i] ? this.fields[i][name] : read(i)),
+        };
+    }
+    id(i) {
+        return this.ids[i] ?? super.id(i);
+    }
+    json(i) {
+        return { ...super.json(i), ...this.fields[i] };
+    }
+}
+function mates({ table, bounds }) {
+    const parentRow = new RowsBuilder();
+    const fields = [];
+    const ids = [];
+    const out = new Uint32Array(bounds.length);
+    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 key = here < there ? `${here}|${there}` : `${there}|${here}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                parentRow.push(i);
+                fields.push(written);
+                ids.push(id);
+            }
+        };
+        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));
+                continue;
+            }
+            const alts = f.get('ALT');
+            if (!Array.isArray(alts)) {
+                continue;
+            }
+            for (const [a, alt] of alts.entries()) {
+                const ends = junctionEnds(f, alt, a);
+                if (!ends) {
+                    continue;
+                }
+                const mate = {
+                    refName: ends.mate.refName,
+                    start: ends.mate.pos,
+                    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);
+            }
+        }
+    }
+    out[bounds.length - 1] = parentRow.length;
+    return {
+        table: new MateTable(table, parentRow.finish(), fields, ids),
+        bounds: out,
+    };
+}
+function bin(staged, step) {
+    return step.fields
+        ? binIntervals(staged, step, step.fields)
+        : binPoints(staged, step);
+}
+function binPoints({ table, bounds }, step) {
+    const { field = DEFAULT_BIN_FIELD } = step;
+    const size = binSize(step);
+    const [asStart, asEnd] = step.as ?? DEFAULT_BIN_AS;
+    const read = stepNumberReader(table, field, 'a bin');
+    const n = table.length;
+    const starts = new Float64Array(n);
+    const ends = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        const s = Math.floor(read(i) / size) * size;
+        starts[i] = s;
+        ends[i] = s + size;
+    }
+    const written = new Map([
+        [asStart, { kind: 'number', values: starts, at: undefined }],
+        [asEnd, { kind: 'number', values: ends, at: undefined }],
+    ]);
+    return { table: new WithTable(table, written), bounds };
+}
+function binIntervals({ table, bounds }, step, fields) {
+    const size = binSize(step);
+    const [asStart, asEnd] = step.as ?? DEFAULT_BIN_AS;
+    const iv = intervalsOf(table, fields, size, bounds);
+    const { pieces } = iv;
+    const parentRow = new Uint32Array(pieces);
+    const binStart = new Float64Array(pieces);
+    const binEnd = new Float64Array(pieces);
+    const overlap = new Float64Array(pieces);
+    let k = 0;
+    for (let i = 0; i < table.length; i++) {
+        const first = iv.first[i];
+        if (Number.isNaN(first)) {
+            continue;
+        }
+        const s = iv.start[i];
+        const e = iv.end[i];
+        for (let b = first; b <= iv.last[i]; b++) {
+            const lo = b * size;
+            const hi = lo + size;
+            parentRow[k] = i;
+            binStart[k] = lo;
+            binEnd[k] = hi;
+            overlap[k] = Math.min(e, hi) - Math.max(s, lo);
+            k++;
+        }
+    }
+    const written = new Map([
+        [asStart, { kind: 'number', values: binStart, at: undefined }],
+        [asEnd, { kind: 'number', values: binEnd, at: undefined }],
+        [BIN_OVERLAP_FIELD, { kind: 'number', values: overlap, at: undefined }],
+    ]);
+    return {
+        table: new WithTable(table, written, parentRow),
+        bounds: boundsThrough(bounds, parentRow),
+    };
+}
+// Each row's group, numbered in the order groups are first met, a section
+// being the outermost level: the groups keyed by their raw values, one Map
+// level per groupby field, where a string key built per row was the
+// aggregate's whole cost.
+function groupRows(n, bounds, reads, normalize) {
+    const groupOf = new Uint32Array(n);
+    const firstRow = [];
+    const sectionOf = [];
+    const last = reads.length - 1;
+    for (let s = 0; s + 1 < bounds.length; s++) {
+        const root = new Map();
+        for (let i = bounds[s]; i < bounds[s + 1]; i++) {
+            let g;
+            if (reads.length === 0) {
+                g =
+                    firstRow.length > 0 && sectionOf.at(-1) === s
+                        ? firstRow.length - 1
+                        : -1;
+                if (g < 0) {
+                    g = firstRow.length;
+                    firstRow.push(i);
+                    sectionOf.push(s);
+                }
+            }
+            else {
+                let node = root;
+                for (let l = 0; l < last; l++) {
+                    const raw = reads[l](i);
+                    const v = normalize && typeof raw !== 'object' ? raw : groupKey(raw);
+                    let next = node.get(v);
+                    if (!next) {
+                        next = new Map();
+                        node.set(v, next);
+                    }
+                    node = next;
+                }
+                const raw = reads[last](i);
+                const v = normalize && typeof raw !== 'object' ? raw : groupKey(raw);
+                let at = node.get(v);
+                if (at === undefined) {
+                    at = firstRow.length;
+                    node.set(v, at);
+                    firstRow.push(i);
+                    sectionOf.push(s);
+                }
+                g = at;
+            }
+            groupOf[i] = g;
+        }
+    }
+    return { groupOf, firstRow, sectionOf };
+}
+function aggregate({ table, bounds }, step) {
+    const { groupby = [], ops } = step;
+    const n = table.length;
+    const keyed = groupby.some(field => !isPlainFieldRef(field));
+    const reads = groupby.map(field => keyed
+        ? stepReader(table, field, 'an aggregate')
+        : readerOf(table.column(field)));
+    const { groupOf, firstRow, sectionOf } = groupRows(n, bounds, reads, !keyed);
+    const groups = firstRow.length;
+    const readStart = readerOf(table.column('start'));
+    const readEnd = readerOf(table.column('end'));
+    const readRefName = readerOf(table.column('refName'));
+    const start = new Float64Array(groups).fill(Infinity);
+    const end = new Float64Array(groups).fill(-Infinity);
+    for (let i = 0; i < n; i++) {
+        const g = groupOf[i];
+        start[g] = Math.min(start[g], readStart(i));
+        end[g] = Math.max(end[g], readEnd(i));
+    }
+    return madeGroups({
+        groups,
+        keys: groupby.map((field, f) => {
+            const read = reads[f];
+            return [field, firstRow.map(i => groupKey(read(i)))];
+        }),
+        ops: ops.map(agg => aggregateColumn(table, agg, groupOf, groups)),
+        step,
+        refNames: firstRow.map(i => readRefName(i)),
+        start,
+        end,
+        sectionOf,
+        sections: bounds.length,
+    });
+}
+function aggregateColumn(table, agg, groupOf, groups) {
+    const n = table.length;
+    const sums = new OpSums(agg, groups);
+    const { field, weight } = agg;
+    const readValue = agg.op === 'count' || field === undefined
+        ? () => Number.NaN
+        : stepNumberReader(table, field, 'an aggregate');
+    const readWeight = weight !== undefined && isWeighted(agg)
+        ? stepNumberReader(table, weight, 'an aggregate')
+        : () => 1;
+    for (let i = 0; i < n; i++) {
+        sums.add(groupOf[i], readValue(i), readWeight(i));
+    }
+    return sums.column(groups);
+}
+// Rows in start order, ties in the order they came: a start and a row packed
+// into one double and sorted without a comparator, which leaves the typed
+// sort's fast path only where the packing could not be exact.
+function sortByStart(rows, starts) {
+    const n = rows.length;
+    let lo = Infinity;
+    let hi = -Infinity;
+    let whole = true;
+    for (let k = 0; k < n; k++) {
+        const v = starts[rows[k]];
+        if (v < lo) {
+            lo = v;
+        }
+        if (v > hi) {
+            hi = v;
+        }
+        whole &&= Number.isInteger(v);
+    }
+    if (whole && (hi - lo + 1) * n < Number.MAX_SAFE_INTEGER) {
+        const keys = new Float64Array(n);
+        for (let k = 0; k < n; k++) {
+            keys[k] = (starts[rows[k]] - lo) * n + k;
+        }
+        keys.sort();
+        const placed = Uint32Array.from(rows);
+        for (let k = 0; k < n; k++) {
+            rows[k] = placed[keys[k] % n];
+        }
+    }
+    else {
+        rows.sort((a, b) => starts[a] - starts[b] || a - b);
+    }
+}
+/**
+ * The lowest row each row fits on, greedy first fit in start order within its
+ * section, as a step in front of the encoder rather than a packer behind it.
+ * The rows come out in start order, as the packing met them.
+ */
+function pileup({ table, bounds }, step) {
+    const as = step.as ?? DEFAULT_PILEUP_AS;
+    const [startField, endField] = step.fields ?? DEFAULT_PILEUP_FIELDS;
+    const padding = step.padding ?? 0;
+    const n = table.length;
+    const readStart = stepNumberReader(table, startField, 'a pileup');
+    const readEnd = stepNumberReader(table, endField, 'a pileup');
+    const starts = new Float64Array(n);
+    const ends = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        starts[i] = readStart(i);
+        ends[i] = readEnd(i);
+    }
+    const order = new Uint32Array(n);
+    const packed = new Float64Array(n);
+    for (let s = 0; s + 1 < bounds.length; s++) {
+        const lo = bounds[s];
+        const hi = bounds[s + 1];
+        let inOrder = true;
+        for (let i = lo + 1; i < hi; i++) {
+            inOrder &&= starts[i] >= starts[i - 1];
+        }
+        // Any unreadable start leaves the section out of order. Read as Infinity,
+        // it sorts last and packs where it claims no row a readable one could
+        // want, where NaN left the sort without an order and a row's end
+        // unreadable.
+        if (!inOrder) {
+            for (let i = lo; i < hi; i++) {
+                if (Number.isNaN(starts[i])) {
+                    starts[i] = Infinity;
+                }
+            }
+        }
+        for (let i = lo; i < hi; i++) {
+            order[i] = i;
+        }
+        if (!inOrder) {
+            sortByStart(order.subarray(lo, hi), starts);
+        }
+        const rowEnds = [];
+        for (let k = lo; k < hi; k++) {
+            const i = order[k];
+            const start = starts[i];
+            const end = ends[i];
+            let row = 0;
+            while (row < rowEnds.length && rowEnds[row] > start) {
+                row++;
+            }
+            rowEnds[row] = (end > start ? end : start) + padding;
+            packed[k] = row;
+        }
+    }
+    const written = new Map([
+        [as, { kind: 'number', values: packed, at: undefined }],
+    ]);
+    return { table: withColumns(table, written, order), bounds };
+}
+/**
+ * Piecewise-constant depth over the rows' spans, per section: one row per run
+ * of equal depth, where the depth is not zero. A sweep over the sorted edges,
+ * so the input need not be sorted.
+ */
+function coverage({ table, bounds }, step) {
+    const as = step.as ?? DEFAULT_COVERAGE_AS;
+    const readStart = numberReaderOf(table.column('start'));
+    const readEnd = numberReaderOf(table.column('end'));
+    const readRefName = readerOf(table.column('refName'));
+    // Each edge opens or closes one run at most, so two a row bounds the runs.
+    const capacity = 2 * table.length;
+    const outStart = new Float64Array(capacity);
+    const outEnd = new Float64Array(capacity);
+    const outDepth = new Float64Array(capacity);
+    const outSection = new Uint32Array(capacity);
+    const sectionRef = [];
+    const out = new Uint32Array(bounds.length);
+    let k = 0;
+    for (let s = 0; s + 1 < bounds.length; s++) {
+        out[s] = k;
+        const lo = bounds[s];
+        const hi = bounds[s + 1];
+        const spanStarts = new Float64Array(hi - lo);
+        const spanEnds = new Float64Array(hi - lo);
+        let n = 0;
+        for (let i = lo; i < hi; i++) {
+            const start = readStart(i);
+            const end = readEnd(i);
+            if (Number.isFinite(start) && Number.isFinite(end)) {
+                spanStarts[n] = start;
+                spanEnds[n] = end;
+                n++;
+            }
+        }
+        sectionRef.push(n > 0 ? readRefName(lo) : undefined);
+        if (n === 0) {
+            continue;
+        }
+        const starts = spanStarts.subarray(0, n).sort();
+        const ends = spanEnds.subarray(0, n).sort();
+        const first = k;
+        let depth = 0;
+        let runStart = starts[0];
+        let si = 0;
+        let ei = 0;
+        while (si < n || ei < n) {
+            const nextStart = si < n ? starts[si] : Infinity;
+            const nextEnd = ei < n ? ends[ei] : Infinity;
+            const at = Math.min(nextStart, nextEnd);
+            if (depth > 0 && at > runStart) {
+                if (k > first &&
+                    outEnd[k - 1] === runStart &&
+                    outDepth[k - 1] === depth) {
+                    outEnd[k - 1] = at;
+                }
+                else {
+                    outStart[k] = runStart;
+                    outEnd[k] = at;
+                    outDepth[k] = depth;
+                    outSection[k] = s;
+                    k++;
+                }
+            }
+            runStart = at;
+            while (si < n && starts[si] === at) {
+                depth++;
+                si++;
+            }
+            while (ei < n && ends[ei] === at) {
+                depth--;
+                ei++;
+            }
+        }
+    }
+    out[bounds.length - 1] = k;
+    const section = outSection.slice(0, k);
+    const columns = new Map([
+        ['refName', { kind: 'value', read: i => sectionRef[section[i]] }],
+        ['start', { kind: 'number', values: outStart.slice(0, k), at: undefined }],
+        ['end', { kind: 'number', values: outEnd.slice(0, k), at: undefined }],
+        [as, { kind: 'number', values: outDepth.slice(0, k), at: undefined }],
+    ]);
+    return {
+        table: new MadeTable(k, columns, () => ''),
+        bounds: out,
+    };
+}
+function runStep(staged, step, jexl) {
+    switch (step.type) {
+        case 'filter': {
+            return filter(staged, step.expr, jexl);
+        }
+        case 'formula': {
+            return formula(staged, step.expr, step.as, jexl);
+        }
+        case 'flatten': {
+            return flatten(staged, step);
+        }
+        case 'cells': {
+            return cells(staged, step);
+        }
+        case 'bin': {
+            return bin(staged, step);
+        }
+        case 'aggregate': {
+            return aggregate(staged, step);
+        }
+        case 'coverage': {
+            return coverage(staged, step);
+        }
+        case 'pileup': {
+            return pileup(staged, step);
+        }
+        case 'mate': {
+            return mates(staged);
+        }
+    }
+}
+function runSteps(staged, steps, jexl) {
+    let current = staged;
+    const list = steps ?? [];
+    for (let k = 0; k < list.length; k++) {
+        const step = list[k];
+        const next = list[k + 1];
+        const fused = step.type === 'bin' &&
+            next?.type === 'aggregate' &&
+            fusesBinAggregate(step, next)
+            ? binnedAggregate(current, step, next)
+            : undefined;
+        if (fused) {
+            current = fused;
+            k++;
+        }
+        else {
+            current = runStep(current, step, jexl);
+        }
+    }
+    return current;
+}
+function rowOf(value) {
+    const row = Number(value);
+    return row > 0 ? Math.floor(row) : 0;
+}
+/**
+ * #api
+ * A faceted request's layers: the rows split on the facet's field, the
+ * facet's own steps and then each layer's run over each section alone, and
+ * the sections stacked — a section's rows start where the one above it ends,
+ * and it is as tall as the tallest layer packed it. Every layer's rows come
+ * back in section order beside their stacked rows, so a faceted display is
+ * the unfaceted one drawn once per section, and a row is handed on as its
+ * steps left it. A layer naming no `row` field stands on each section's first
+ * row, the answer the unfaceted encoder gives it.
+ *
+ * The split is a counting sort into section order rather than a list per
+ * section: every step runs once over the ordered rows, keeping section order,
+ * and one that groups rows groups within a section.
+ */
+export function facetLayers(input, facet, layers, jexl) {
+    const table = asTable(input);
+    const { field, transform: sectionSteps } = facet;
+    const categories = categoricalField(field);
+    const n = table.length;
+    const sectionOfKey = new Map();
+    const keyOfRow = new Uint32Array(n);
+    const keys = [];
+    const keyIndex = (key) => {
+        let k = sectionOfKey.get(key);
+        if (k === undefined) {
+            k = keys.length;
+            sectionOfKey.set(key, k);
+            keys.push(key);
+        }
+        return k;
+    };
+    const column = isPlainFieldRef(field) ? table.column(field) : undefined;
+    if (column?.kind === 'category') {
+        // A label's key is filed once, and each row looks its code up.
+        const { codes, labels, at } = column;
+        const ofCode = new Int32Array(labels.length).fill(-1);
+        for (let i = 0; i < n; i++) {
+            const code = codes[at ? at[i] : i];
+            let k = ofCode[code];
+            if (k < 0) {
+                k = keyIndex(categories.key(labels[code]));
+                ofCode[code] = k;
+            }
+            keyOfRow[i] = k;
+        }
+    }
+    else {
+        const read = column
+            ? readerOf(column)
+            : (() => {
+                const r = fieldReader(field, jexl);
+                return (i) => r(table.row(i));
+            })();
+        for (let i = 0; i < n; i++) {
+            keyOfRow[i] = keyIndex(categories.key(read(i)));
+        }
+    }
+    const ordered = [...keys.keys()].sort((a, b) => categories.compare(keys[a], keys[b]));
+    const sectionOf = new Uint32Array(keys.length);
+    for (const [s, k] of ordered.entries()) {
+        sectionOf[k] = s;
+    }
+    const bounds = new Uint32Array(keys.length + 1);
+    for (let i = 0; i < n; i++) {
+        bounds[sectionOf[keyOfRow[i]] + 1]++;
+    }
+    for (let s = 0; s < keys.length; s++) {
+        bounds[s + 1] = bounds[s + 1] + bounds[s];
+    }
+    const next = bounds.slice(0, keys.length);
+    const order = new Uint32Array(n);
+    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 readRow = row === undefined
+            ? undefined
+            : isPlainFieldRef(row)
+                ? readerOf(out.table.column(row))
+                : (() => {
+                    const r = fieldReader(row, jexl);
+                    return (i) => r(out.table.row(i));
+                })();
+        const local = new Uint32Array(out.table.length);
+        if (readRow) {
+            for (let i = 0; i < local.length; i++) {
+                local[i] = rowOf(readRow(i));
+            }
+        }
+        return { ...out, local };
+    });
+    const rowCount = new Uint32Array(keys.length).fill(1);
+    for (const { bounds: b, local } of placed) {
+        for (let s = 0; s < keys.length; s++) {
+            for (let i = b[s]; i < b[s + 1]; i++) {
+                if (local[i] + 1 > rowCount[s]) {
+                    rowCount[s] = local[i] + 1;
+                }
+            }
+        }
+    }
+    const sections = [];
+    const firstRow = new Uint32Array(keys.length);
+    let stacked = 0;
+    for (const [s, k] of ordered.entries()) {
+        firstRow[s] = stacked;
+        sections.push({ key: keys[k], firstRow: stacked, rowCount: rowCount[s] });
+        stacked += rowCount[s];
+    }
+    return {
+        layers: placed.map(({ table: t, bounds: b, local }) => {
+            const rows = new Uint32Array(t.length);
+            for (let s = 0; s < keys.length; s++) {
+                for (let i = b[s]; i < b[s + 1]; i++) {
+                    rows[i] = firstRow[s] + local[i];
+                }
+            }
+            return { table: t, rows };
+        }),
+        sections,
+    };
+}
+/**
+ * #api
+ * Run the transform steps over a feature list or a table, in order, in the
+ * worker. The table a step answers is what the next one reads, and the last
+ * one is what the encoder walks.
+ */
+export function runTransforms(input, steps, jexl) {
+    const table = asTable(input);
+    return runSteps({ table, bounds: oneSection(table.length) }, steps, jexl)
+        .table;
+}
+// The fields a step writes onto its rows, which a partition on one of them
+// has to wait for; none for a step that must see every row at once.
+function writes(step) {
+    switch (step.type) {
+        case 'filter': {
+            return [];
+        }
+        case 'formula': {
+            return [step.as];
+        }
+        case 'bin': {
+            const as = step.as ?? DEFAULT_BIN_AS;
+            return step.fields ? [...as, BIN_OVERLAP_FIELD] : as;
+        }
+        case 'cells': {
+            return ['start', 'end', 'state', 'base', 'match', 'length'];
+        }
+        default: {
+            return undefined;
+        }
+    }
+}
+/**
+ * How many of `steps` must run before rows can be split on `field`: the rest
+ * each read a row and answer rows of it in order without writing `field`, so
+ * running them after the split answers the same rows in the same order. A step
+ * that groups rows, fans a row out into entries that may carry their own
+ * `field`, or pairs rows up must run before it, and so must everything ahead
+ * of it.
+ */
+function partitionPoint(steps, field) {
+    if (!isPlainFieldRef(field)) {
+        return steps.length;
+    }
+    let at = steps.length;
+    while (at > 0 && writes(steps[at - 1])?.includes(field) === false) {
+        at--;
+    }
+    return at;
+}
+/**
+ * #api
+ * A layered request's rows: the shared steps, the facet's split where it
+ * names one, and each layer's own steps, with the row each layer's rows stand
+ * in — the field it names, or under a facet each row's stacked row. The split
+ * comes as early as it can: after the last shared step that must see every
+ * row, so the steps that follow it read the rows already in section order.
+ */
+export function layerTables(input, request, jexl) {
+    const { transform = [], facet, layers } = request;
+    if (!facet) {
+        const shared = runTransforms(input, transform, jexl);
+        return {
+            layers: layers.map(layer => ({
+                table: layer.transform?.length
+                    ? runTransforms(shared, layer.transform, jexl)
+                    : shared,
+                row: layer.row,
+            })),
+            sections: undefined,
+        };
+    }
+    const at = partitionPoint(transform, facet.field);
+    const split = facetLayers(runTransforms(input, transform.slice(0, at), jexl), {
+        ...facet,
+        transform: [...transform.slice(at), ...(facet.transform ?? [])],
+    }, layers, jexl);
+    return {
+        layers: split.layers.map(({ table, rows }) => ({ table, row: rows })),
+        sections: split.sections,
+    };
+}