@jbrowse/core 5.0.0-beta.13 → 5.0.0-beta.14

package/esm/util/originCut.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The id of the piece of a feature lying past a circular sequence's origin,
+ * the feature cut there and `id` the piece before it. Only GFF3 cuts:
+ * bedToBigBed refuses an end past the contig, and on 2026-10-11 none of hg38's
+ * 35 hosted BED tabix tracks had a chrM record ending past 16569.
+ *
+ * The linear view reads across the origin with the tail and head typed as two
+ * regions, `NC_012920.1:15,000-16,569 NC_012920.1:1-2,000`, where the two
+ * pieces abut in one row. A locstring that wraps past the origin, or a menu
+ * item, would save the typing; neither was built (2026-10-14).
+ */
+export declare function originTailId(id: string): string;
+/** The id of the piece before the origin, when `id` names the one past it. */
+export declare function originHeadId(id: string): string | undefined;

package/esm/util/originCut.js

@@ -0,0 +1,19 @@
+const TAIL_SUFFIX = '-origin';
+/**
+ * The id of the piece of a feature lying past a circular sequence's origin,
+ * the feature cut there and `id` the piece before it. Only GFF3 cuts:
+ * bedToBigBed refuses an end past the contig, and on 2026-10-11 none of hg38's
+ * 35 hosted BED tabix tracks had a chrM record ending past 16569.
+ *
+ * The linear view reads across the origin with the tail and head typed as two
+ * regions, `NC_012920.1:15,000-16,569 NC_012920.1:1-2,000`, where the two
+ * pieces abut in one row. A locstring that wraps past the origin, or a menu
+ * item, would save the typing; neither was built (2026-10-14).
+ */
+export function originTailId(id) {
+    return `${id}${TAIL_SUFFIX}`;
+}
+/** The id of the piece before the origin, when `id` names the one past it. */
+export function originHeadId(id) {
+    return id.endsWith(TAIL_SUFFIX) ? id.slice(0, -TAIL_SUFFIX.length) : undefined;
+}

package/esm/util/paintLayer.d.ts

@@ -6,7 +6,7 @@ export type PaintLayerOpts = SvgRasterCanvasOpts & {
     rasterizeLayers?: boolean;
 };
 /**
- * Paint into either a 2× rasterize canvas (PNG-embedded as <image>) or an
+ * Paint into either a rasterize canvas (PNG-embedded as <image>) or an
  * SvgCanvas (serialized into a <g>). Renders one element — callers don't
  * branch on which mode was picked.
  *

package/esm/util/paintLayer.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { SvgCanvas } from './SvgCanvas.js';
-import { createSvgRasterCanvas } from './createSvgRasterCanvas.js';
+import { createSvgRasterCanvas, svgRasterDataUrl, } from './createSvgRasterCanvas.js';
 /**
- * Paint into either a 2× rasterize canvas (PNG-embedded as <image>) or an
+ * Paint into either a rasterize canvas (PNG-embedded as <image>) or an
  * SvgCanvas (serialized into a <g>). Renders one element — callers don't
  * branch on which mode was picked.
  *
@@ -20,11 +20,12 @@ import { createSvgRasterCanvas } from './createSvgRasterCanvas.js';
  * canvas is blank means reading its pixels back — and it does not need one: a
  * fully transparent PNG is a couple of hundred bytes.
  */
+// eslint-disable-next-line no-restricted-syntax -- drawn inside a frozen SVG figure
 export function PaintLayer({ width, height, opts, paint, }) {
     if (opts?.rasterizeLayers && width > 0 && height > 0) {
         const { canvas, ctx } = createSvgRasterCanvas(width, height, opts);
         paint(ctx);
-        return (_jsx("image", { width: width, height: height, xlinkHref: canvas.toDataURL('image/png') }));
+        return (_jsx("image", { width: width, height: height, xlinkHref: svgRasterDataUrl(canvas) }));
     }
     const svg = new SvgCanvas();
     paint(svg);

package/esm/util/pathSeries.d.ts

@@ -0,0 +1,18 @@
+import type { FeatureTable } from './featureTable.ts';
+import type { JexlInstance } from './jexlStrings.ts';
+import type { FieldRef, PathSpec, TransformStep } from './markEncodingTypes.ts';
+type RowEncoding = FieldRef | ArrayLike<number> | undefined;
+/**
+ * #api
+ * A path layer's table in series order, as {@link PathSpec} defines a series,
+ * with each row's series beside it and the stretch past which a series breaks.
+ * `steps` are every step the layer's rows went through, which a `window` among
+ * them reads the default break from.
+ */
+export declare function pathSeries(table: FeatureTable, row: RowEncoding, path: PathSpec, steps: readonly TransformStep[], jexl?: JexlInstance): {
+    table: FeatureTable;
+    row: RowEncoding;
+    series: Uint32Array<ArrayBuffer>;
+    gapBp: number | undefined;
+};
+export {};

package/esm/util/pathSeries.js

@@ -0,0 +1,143 @@
+// A path layer's rows in series order. `layerFeatures` applies it, so the
+// table `CoreGetEncodedFeature` reads is the one `CoreGetEncodedLayers`
+// encoded and an instance's index names the same row in both. Imported by
+// relative path only.
+import { numberReaderOf, readerOf, selectRows } from './featureTable.js';
+import { fieldReader, isPlainFieldRef } from './fieldReader.js';
+import { groupKey, sortByStart } from './stepTables.js';
+import { DEFAULT_WINDOW_FRAME } from './windowStep.js';
+function reader(table, ref, jexl) {
+    if (isPlainFieldRef(ref)) {
+        return readerOf(table.column(ref));
+    }
+    const read = fieldReader(ref, jexl);
+    return (i) => read(table.row(i));
+}
+// Each row's series, numbered in the order met: one per distinct pair of the
+// row it stands in and its `by` value.
+function seriesOf(table, row, by, jexl) {
+    const n = table.length;
+    const readRow = typeof row === 'string'
+        ? reader(table, row, jexl)
+        : row
+            ? (i) => row[i]
+            : () => 0;
+    const readBy = by === undefined ? () => undefined : reader(table, by, jexl);
+    const keys = new Map();
+    const series = new Uint32Array(n);
+    let count = 0;
+    for (let i = 0; i < n; i++) {
+        const r = readRow(i);
+        let byRow = keys.get(r);
+        if (!byRow) {
+            byRow = new Map();
+            keys.set(r, byRow);
+        }
+        const key = groupKey(readBy(i));
+        let s = byRow.get(key);
+        if (s === undefined) {
+            s = count++;
+            byRow.set(key, s);
+        }
+        series[i] = s;
+    }
+    return { series, count };
+}
+// The rows grouped by series, each series in start order, and where each
+// series begins.
+function seriesOrder(starts, series, count) {
+    const n = series.length;
+    const first = new Uint32Array(count + 1);
+    for (let i = 0; i < n; i++) {
+        first[series[i] + 1]++;
+    }
+    for (let s = 0; s < count; s++) {
+        first[s + 1] += first[s];
+    }
+    const order = new Uint32Array(n);
+    const next = first.slice(0, count);
+    for (let i = 0; i < n; i++) {
+        order[next[series[i]]++] = i;
+    }
+    for (let s = 0; s < count; s++) {
+        const rows = order.subarray(first[s], first[s + 1]);
+        let sorted = true;
+        for (let k = 1; k < rows.length && sorted; k++) {
+            sorted = starts[rows[k]] >= starts[rows[k - 1]];
+        }
+        if (!sorted) {
+            sortByStart(rows, starts);
+        }
+    }
+    return { order, first };
+}
+// The bases a window's frame spans at the median row: each row's frame runs
+// from the start `before` rows back to the start `after` rows on, cut at its
+// series' ends, as the window step cut it.
+function frameSpanBp(starts, order, first, [before, after]) {
+    const spans = [];
+    for (let s = 0; s + 1 < first.length; s++) {
+        const lo = first[s];
+        const m = first[s + 1] - lo;
+        for (let j = 0; j < m; j++) {
+            const a = Math.max(0, j + before);
+            const b = Math.min(m - 1, j + after);
+            if (a <= b) {
+                spans.push(starts[order[lo + b]] - starts[order[lo + a]]);
+            }
+        }
+    }
+    if (spans.length === 0) {
+        return undefined;
+    }
+    spans.sort((x, y) => x - y);
+    return spans[spans.length >> 1];
+}
+function windowFrame(steps) {
+    const step = steps.findLast(s => s.type === 'window');
+    if (step?.type !== 'window') {
+        return undefined;
+    }
+    const [before, after] = step.frame ?? DEFAULT_WINDOW_FRAME;
+    return before === null || after === null
+        ? undefined
+        : [before, after];
+}
+/**
+ * #api
+ * A path layer's table in series order, as {@link PathSpec} defines a series,
+ * with each row's series beside it and the stretch past which a series breaks.
+ * `steps` are every step the layer's rows went through, which a `window` among
+ * them reads the default break from.
+ */
+export function pathSeries(table, row, path, steps, jexl) {
+    const n = table.length;
+    const { series, count } = seriesOf(table, row, path.by, jexl);
+    const readStart = numberReaderOf(table.column('start'));
+    const starts = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        const s = readStart(i);
+        starts[i] = Number.isNaN(s) ? Infinity : s;
+    }
+    const { order, first } = seriesOrder(starts, series, count);
+    const ordered = new Uint32Array(n);
+    for (let k = 0; k < n; k++) {
+        ordered[k] = series[order[k]];
+    }
+    let rowOut = row;
+    if (row !== undefined && typeof row !== 'string') {
+        const permuted = new Uint32Array(n);
+        for (let k = 0; k < n; k++) {
+            permuted[k] = row[order[k]];
+        }
+        rowOut = permuted;
+    }
+    const frame = path.gapBp === undefined ? windowFrame(steps) : undefined;
+    return {
+        table: selectRows(table, order),
+        row: rowOut,
+        series: ordered,
+        gapBp: path.gapBp ??
+            (frame ? frameSpanBp(starts, order, first, frame) : undefined),
+    };
+}

package/esm/util/pressOwner.d.ts

@@ -0,0 +1,20 @@
+interface Press {
+    target: EventTarget | null;
+    currentTarget: EventTarget | null;
+}
+/**
+ * Whether an event reached a container's React handler from outside the
+ * container's DOM. React bubbles a portal's events to its React parent, so a
+ * press in a dialog or menu that a track opened arrives at every handler above
+ * the track.
+ */
+export declare function isFromPortal({ target, currentTarget }: Press): boolean;
+/**
+ * Whether a container's own drag gesture leaves a press alone: one from a
+ * portal, or one on a control that claimed it (`[data-gesture-owner]`,
+ * JBrowse's marker on the parts that drag on their own), a button, or a
+ * draggable element. `closest`, because the press usually lands on an icon
+ * inside the control.
+ */
+export declare function isClaimedPress(event: Press): boolean;
+export {};

package/esm/util/pressOwner.js

@@ -0,0 +1,26 @@
+/**
+ * Whether an event reached a container's React handler from outside the
+ * container's DOM. React bubbles a portal's events to its React parent, so a
+ * press in a dialog or menu that a track opened arrives at every handler above
+ * the track.
+ */
+export function isFromPortal({ target, currentTarget }) {
+    return (target instanceof Node &&
+        currentTarget instanceof Node &&
+        !currentTarget.contains(target));
+}
+/**
+ * Whether a container's own drag gesture leaves a press alone: one from a
+ * portal, or one on a control that claimed it (`[data-gesture-owner]`,
+ * JBrowse's marker on the parts that drag on their own), a button, or a
+ * draggable element. `closest`, because the press usually lands on an icon
+ * inside the control.
+ */
+export function isClaimedPress(event) {
+    const { target } = event;
+    return (isFromPortal(event) ||
+        (target instanceof HTMLElement && target.draggable) ||
+        (target instanceof Element &&
+            target.closest('button, [data-gesture-owner], [draggable="true"]') !==
+                null));
+}

package/esm/util/quantileExtent.d.ts

@@ -37,13 +37,13 @@ export declare function quantileOf(a: Float32Array, n: number, quantile: number)
  * the axis nor the ramp, and a sparse tail of the other sign keeps its own
  * end. An axis that starts at 0 adds it itself. Under 0.5 reads as 0.5,
  * where the ends meet rather than cross. `scales.y.domainQuantile` and a
- * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
+ * color's `domainQuantile` both name it. `[Infinity, -Infinity]` where
  * nothing is finite.
  *
  * Nearest rank keeps ties: where one value holds the rank, as on a segmented
  * copy-number track, a ramp clipped below 1 paints nearly every value one
- * colour. A value axis fences instead ({@link fenceOutliers}); a ramp takes
- * the same fence once a colour default below 1 meets tied data.
+ * color. A value axis fences instead ({@link fenceOutliers}); a ramp takes
+ * the same fence once a color default below 1 meets tied data.
  */
 export declare function quantileExtent(values: ArrayLike<number>, count: number, quantile?: number): [number, number];
 /**

package/esm/util/quantileExtent.js

@@ -111,13 +111,13 @@ function lowQuantileOf(a, n, quantile) {
  * the axis nor the ramp, and a sparse tail of the other sign keeps its own
  * end. An axis that starts at 0 adds it itself. Under 0.5 reads as 0.5,
  * where the ends meet rather than cross. `scales.y.domainQuantile` and a
- * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
+ * color's `domainQuantile` both name it. `[Infinity, -Infinity]` where
  * nothing is finite.
  *
  * Nearest rank keeps ties: where one value holds the rank, as on a segmented
  * copy-number track, a ramp clipped below 1 paints nearly every value one
- * colour. A value axis fences instead ({@link fenceOutliers}); a ramp takes
- * the same fence once a colour default below 1 meets tied data.
+ * color. A value axis fences instead ({@link fenceOutliers}); a ramp takes
+ * the same fence once a color default below 1 meets tied data.
  */
 export function quantileExtent(values, count, quantile = 1) {
     if (!(quantile < 1)) {

package/esm/util/rowStackGeometry.d.ts

@@ -9,7 +9,7 @@
  * cohort-sized track. Two rules follow, and each caller used to restate them:
  *
  * - **Ask at the pixel's centre.** Rasterization fills a pixel when its centre
- *   falls inside the rect, so the centre is the scanline the colour the reader
+ *   falls inside the rect, so the centre is the scanline the color the reader
  *   is pointing at was decided on. The top edge misses by `0.5 / rowHeight`
  *   rows — 5.4 of them on a 2,504-sample matrix at the default fit height.
  * - **Floor `mouseY` before adding `scrollTop`.** The canvas draws at

package/esm/util/rowStackGeometry.js

@@ -9,7 +9,7 @@
  * cohort-sized track. Two rules follow, and each caller used to restate them:
  *
  * - **Ask at the pixel's centre.** Rasterization fills a pixel when its centre
- *   falls inside the rect, so the centre is the scanline the colour the reader
+ *   falls inside the rect, so the centre is the scanline the color the reader
  *   is pointing at was decided on. The top edge misses by `0.5 / rowHeight`
  *   rows — 5.4 of them on a 2,504-sample matrix at the default fit height.
  * - **Floor `mouseY` before adding `scrollTop`.** The canvas draws at

package/esm/util/sessionActivity.d.ts

@@ -0,0 +1,36 @@
+export interface ActivitySession {
+    sessionTracks: {
+        type: string;
+    }[];
+    views: {
+        type: string;
+        tracks?: readonly object[];
+    }[];
+    widgets?: {
+        values(): Iterable<{
+            type: string;
+        }>;
+    };
+}
+export interface SessionShape {
+    viewTypes: string[];
+    trackTypes: string[];
+    widgetTypes: string[];
+}
+export declare function describeSession(session: ActivitySession | undefined): SessionShape;
+export declare function tallyTypes(types: string[]): string;
+export declare function createSessionActivity(): {
+    watch(getSession: () => ActivitySession | undefined): void;
+    stop(): void;
+    readonly watching: boolean;
+    stats(): {
+        'view-types': string;
+        'open-track-types': string;
+        'seen-view-types': string;
+        'seen-track-types': string;
+        'seen-widget-types': string;
+        'max-open-views': number;
+        'max-open-tracks': number;
+    };
+};
+export type SessionActivity = ReturnType<typeof createSessionActivity>;

package/esm/util/sessionActivity.js

@@ -0,0 +1,88 @@
+import { autorun } from 'mobx';
+export function describeSession(session) {
+    const shape = { viewTypes: [], trackTypes: [], widgetTypes: [] };
+    if (session) {
+        for (const view of session.views) {
+            shape.viewTypes.push(view.type);
+            for (const track of view.tracks ?? []) {
+                if ('type' in track && typeof track.type === 'string') {
+                    shape.trackTypes.push(track.type);
+                }
+            }
+        }
+        for (const widget of session.widgets?.values() ?? []) {
+            shape.widgetTypes.push(widget.type);
+        }
+    }
+    return shape;
+}
+// `LinearGenomeView:2,DotplotView:1`, sorted so equal sessions give equal text
+export function tallyTypes(types) {
+    const counts = new Map();
+    for (const type of types) {
+        counts.set(type, (counts.get(type) ?? 0) + 1);
+    }
+    return [...counts]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([type, count]) => `${type}:${count}`)
+        .join(',');
+}
+// Accumulates what a page load's sessions held at any point, so the end report
+// can say what was opened during use and not only what is open at the end.
+export function createSessionActivity() {
+    const seen = {
+        viewTypes: new Set(),
+        trackTypes: new Set(),
+        widgetTypes: new Set(),
+    };
+    let maxOpenViews = 0;
+    let maxOpenTracks = 0;
+    let current = describeSession(undefined);
+    let stopWatching;
+    function record(shape) {
+        current = shape;
+        maxOpenViews = Math.max(maxOpenViews, shape.viewTypes.length);
+        maxOpenTracks = Math.max(maxOpenTracks, shape.trackTypes.length);
+        for (const key of ['viewTypes', 'trackTypes', 'widgetTypes']) {
+            for (const type of shape[key]) {
+                seen[key].add(type);
+            }
+        }
+    }
+    return {
+        // jbrowse-web rebuilds the root model when plugins change and Desktop
+        // builds one per session opened, so each call replaces the previous watch.
+        // A root model that has left its state tree throws when read; the watch
+        // then keeps what it last saw.
+        watch(getSession) {
+            stopWatching?.();
+            stopWatching = autorun(() => {
+                try {
+                    record(describeSession(getSession()));
+                }
+                catch {
+                    // dead state tree
+                }
+            });
+        },
+        stop() {
+            stopWatching?.();
+            stopWatching = undefined;
+        },
+        get watching() {
+            return stopWatching !== undefined;
+        },
+        stats() {
+            const list = (types) => [...types].sort().join(',');
+            return {
+                'view-types': tallyTypes(current.viewTypes),
+                'open-track-types': tallyTypes(current.trackTypes),
+                'seen-view-types': list(seen.viewTypes),
+                'seen-track-types': list(seen.trackTypes),
+                'seen-widget-types': list(seen.widgetTypes),
+                'max-open-views': maxOpenViews,
+                'max-open-tracks': maxOpenTracks,
+            };
+        },
+    };
+}

package/esm/util/stepOutputs.d.ts

@@ -0,0 +1,165 @@
+/**
+ * What each transform step does to the rows it reads, stated once for the
+ * runtime's facet split, the validator, the field pickers and the channels a
+ * mark adopts by default. Imports nothing, so the validator's copy of the mark
+ * rule list carries it unchanged.
+ *
+ * Every step type answers three things:
+ * - `rowwise`: it answers each row from that row alone and in order, so a
+ *   facet split may run ahead of it.
+ * - `replacesRows`: it makes its rows anew (an aggregate, a coverage), so a
+ *   field survives it only where it writes that field or keeps it as a group.
+ * - `writes`: the fields it sets, each with the kind of value it holds and the
+ *   channel a mark leaving that channel unwritten reads it through.
+ */
+/** The field an aggregate op writes: `as` where named, else `count` for a count, else `<op>_<field>`. */
+export declare function aggregateFieldName({ op, field, as, }: {
+    op: string;
+    field?: string;
+    as?: string;
+}): string;
+export declare const DEFAULT_FORMULA_AS = "value";
+export declare const DEFAULT_COVERAGE_AS = "coverage";
+export declare const DEFAULT_PILEUP_AS = "row";
+export declare const DEFAULT_AGGREGATE_OP = "count";
+export declare const DEFAULT_BIN_AS: readonly [string, string];
+/** What a `bin` over `fields` writes on each piece: the bases of its interval inside its bin. */
+export declare const BIN_OVERLAP_FIELD = "overlap";
+/** What a `cells` step writes: `state` on every cell, `base` on a mismatch or an insertion, `match` off a gap or a reference `N`, `length` on an insertion. */
+export declare const CELLS_FIELDS: readonly ['state', 'base', 'match', 'length'];
+/** What a `mate` step writes on every feature it answers. */
+export declare const MATE_FIELDS: readonly ['mate.refName', 'mate.start', 'mate.end', 'mate.mateDirection', 'mateDirection', 'alt', 'svType'];
+/** Where a row stands, which every row keeps through every step. */
+export declare const POSITION_FIELDS: readonly ['refName', 'start', 'end'];
+/** The kind of value a step writes into a field; `unknown` keeps whatever the field held. */
+export type FieldKind = 'numeric' | 'categorical' | 'unknown';
+/** A channel a step's output fills where a mark leaves it unwritten. */
+export type FilledChannel = 'y' | 'row' | 'x2';
+export interface WrittenField {
+    field: string;
+    kind: FieldKind;
+    fills?: FilledChannel;
+}
+/** A step as a config node, a snapshot or a worker request holds it, any default unwritten. */
+export interface StepOutline {
+    type: string;
+    as?: string | readonly string[];
+    ops?: readonly {
+        op?: string;
+        field?: string;
+        as?: string;
+    }[];
+    groupby?: readonly string[];
+    fields?: readonly string[];
+    index?: string;
+    key?: string;
+}
+export interface StepOutput {
+    rowwise: boolean;
+    replacesRows: boolean;
+    /** `edges` are the fields the last `bin` before this step wrote its edges to. */
+    writes: (step: StepOutline, edges: readonly string[]) => WrittenField[];
+}
+declare function summaries(step: StepOutline): WrittenField[];
+export declare const STEP_OUTPUTS: {
+    filter: {
+        rowwise: true;
+        replacesRows: false;
+        writes: () => never[];
+    };
+    formula: {
+        rowwise: true;
+        replacesRows: false;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: "numeric";
+        }[];
+    };
+    bin: {
+        rowwise: true;
+        replacesRows: false;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: 'numeric';
+        }[];
+    };
+    cells: {
+        rowwise: true;
+        replacesRows: false;
+        writes: () => ({
+            field: string;
+            kind: "numeric";
+        } | {
+            field: string;
+            kind: "categorical";
+        })[];
+    };
+    aggregate: {
+        rowwise: false;
+        replacesRows: true;
+        writes: (step: StepOutline, edges: readonly string[]) => WrittenField[];
+    };
+    window: {
+        rowwise: false;
+        replacesRows: false;
+        writes: typeof summaries;
+    };
+    coverage: {
+        rowwise: false;
+        replacesRows: true;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: "numeric";
+            fills: "y";
+        }[];
+    };
+    pileup: {
+        rowwise: false;
+        replacesRows: false;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: "numeric";
+            fills: "row";
+        }[];
+    };
+    flatten: {
+        rowwise: false;
+        replacesRows: false;
+        writes: (step: StepOutline) => ({
+            field: string;
+            kind: 'numeric';
+        } | {
+            field: string;
+            kind: 'categorical';
+        })[];
+    };
+    mate: {
+        rowwise: false;
+        replacesRows: false;
+        writes: () => {
+            field: "alt" | "mate.end" | "mate.mateDirection" | "mate.refName" | "mate.start" | "mateDirection" | "svType";
+            kind: "categorical" | "numeric";
+            fills?: "x2" | undefined;
+        }[];
+    };
+};
+export type StepType = keyof typeof STEP_OUTPUTS;
+/**
+ * The fields one step writes. A step this table does not know writes nothing
+ * it can name.
+ */
+export declare function stepWrites(step: StepOutline, edges?: readonly string[]): WrittenField[];
+/** Whether a step answers each row from that row alone, in order. */
+export declare function isRowwise(step: StepOutline): boolean;
+/**
+ * What a run of steps leaves: every field written, the last write of each
+ * winning, and, where a step made the rows anew, the only fields that survive
+ * it (`undefined` while the input's own fields all do). `channels` are what
+ * the output fills where a mark leaves them unwritten.
+ */
+export declare function stepsOutput(steps: readonly (StepOutline | undefined)[]): {
+    written: WrittenField[];
+    surviving: Set<string> | undefined;
+    channels: Map<FilledChannel, string>;
+};
+export {};