@jbrowse/core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/util/markEncodingTypes.d.ts

@@ -1,26 +1,23 @@
+import type { ZoomRange } from '../data_adapters/BaseAdapter/zoomRange.ts';
+import type { ColorSchemeName } from './colorSchemes.ts';
 /**
  * #api
  * Where a channel's value comes from: a feature field name, read natively
  * (`feature.get(name)`), or a `jexl:` expression over `feature` — the opt-in
- * escape, three orders of magnitude slower per feature.
+ * escape, measured at 1.5x to 2.0x native per feature (MARK_ENCODING.md
+ * "The jexl channel, measured").
  */
 export type FieldRef = string;
-/**
- * #api
- * The ramp a continuous colour scale samples: a named ramp, or evenly spaced
- * CSS colour stops.
- */
-export type RampRef = 'viridis' | string[];
 /**
  * #api
  * A field bound to a categorical scale: each distinct value takes one entry
- * of the channel's range — a palette entry for `color`, a glyph name for
- * `glyph`. With a `domain`, the listed values take the range in that order
- * and whatever else the region meets follows, sorted; without one each value
- * derives its entry from itself (an integer takes the slot it names, anything
- * else hashes in), so every region agrees on a value it shares with another at
- * the cost of an occasional collision, and `domain` is the way to spend the
- * range deliberately.
+ * of the channel's `range` — a colour for `color`, a glyph name for
+ * `glyph`. Every value derives its entry from itself (an integer takes the
+ * slot it names, anything else hashes in), so every region agrees on a value
+ * it shares with another at the cost of an occasional collision. A `domain`
+ * spends the range deliberately: the listed values take it in order, and a
+ * value the domain leaves out never takes a listed value's entry. The domain
+ * orders and spends; it never adds a value the data lacks.
  */
 export interface CategoricalRef {
     field: FieldRef;
@@ -29,42 +26,46 @@ export interface CategoricalRef {
 }
 /**
  * #api
- * How a mark's `color` channel resolves. A CSS colour or a `jexl:` expression
- * returning one paints per feature with no scale; the two object forms bind a
- * field to a scale, which is what a legend can describe. A continuous scale
- * reads the field through `domain` (the region's own extremes when absent)
- * into `ramp`, and there a listed `domain` is what pins the answer across a
- * whole view.
+ * A numeric field cut into intervals: `domain` is the ascending cut points
+ * and `range` holds one colour more, so a value paints the entry for the
+ * number of cut points it is at or past. A value that is not a number
+ * belongs to no interval.
  */
-export type ColorEncoding = string | (CategoricalRef & {
-    palette?: string[];
-}) | {
+export interface ThresholdRef {
     field: FieldRef;
-    scale: 'linear' | 'log';
-    domain?: [number, number];
-    ramp?: RampRef;
-};
+    scale: 'threshold';
+    domain?: (string | number)[];
+    range?: string[];
+}
 /**
  * #api
- * How a mark's `y` channel resolves: a feature field (or `jexl:` expression)
- * read on a linear scale over the loaded regions' extremes, or the same field
- * with the scale spelled out — `log` to read the domain logarithmically,
- * `domain` to pin `[min, max]` instead of autoscaling. The declaration is the
- * one owner: the display's axis, its ticks and the shader's placement are all
- * resolved from it.
- *
- * `resolve` is which axis the mark reads. `shared` — the default — folds it
- * into the display's one y domain with every other mark. `independent` gives
- * it a domain folded from its layers alone and a second axis on the right, so
- * a coverage run and the raw features can share a plot; one mark per display
- * may ask for it.
+ * A numeric field read through a linear or log scale into a ramp. Each end of
+ * the domain is pinned by `domainMin` or `domainMax`, or is the region's own
+ * extreme where unset, so pinning both keeps colours consistent across a
+ * whole view. The ramp is `range`'s CSS colours, evenly spaced, where it
+ * lists any, else the named `scheme`; `reverse` turns it round.
  */
-export type ValueEncoding = FieldRef | {
+export interface ContinuousRef {
     field: FieldRef;
-    scale?: 'linear' | 'log';
-    domain?: [number, number];
-    resolve?: 'shared' | 'independent';
-};
+    scale: 'linear' | 'log';
+    domainMin?: number;
+    domainMax?: number;
+    /** The value the ramp's middle stop sits at; the domain's centre unset. */
+    domainMid?: number;
+    range?: string[];
+    scheme?: ColorSchemeName;
+    reverse?: boolean;
+}
+/**
+ * #api
+ * How a mark's `color` channel resolves. A CSS colour or a `jexl:` expression
+ * returning one paints per feature with no scale; the object forms bind a
+ * field to a scale, which a legend can describe, and share the config's
+ * member names.
+ */
+export type ColorEncoding = string | (CategoricalRef & {
+    range?: string[];
+}) | ContinuousRef | ThresholdRef;
 export type GlyphName = 'disc' | 'triangle' | 'diamond';
 /**
  * #api
@@ -77,16 +78,17 @@ export type GlyphEncoding = GlyphName | `jexl:${string}` | (CategoricalRef & {
 });
 /**
  * #api
- * The declared mapping from a feature's fields to a mark's channels. `x`
- * defaults to `start` and `x2` to `end`; a mark that plots no value leaves `y`
- * off. `glyph` is read by the `point` shape alone, `row` — an integer field,
- * 0 where missing — by the `span` shape, which stacks a feature on the band
- * it names.
+ * The declared mapping from a feature's fields to a mark's channels. Every
+ * positional channel is a field: `x` defaults to `start` and `x2` to `end`, a
+ * mark that plots no value leaves `y` off, and the scale `y` is read through
+ * belongs to the display rather than to the encoding. `glyph` is read by the
+ * `point` shape alone, `row` — an integer field, 0 where missing — by every
+ * shape, which stands a feature in the band it names.
  */
 export interface MarkEncoding {
     x?: FieldRef;
     x2?: FieldRef;
-    y?: ValueEncoding;
+    y?: FieldRef;
     row?: FieldRef;
     color?: ColorEncoding;
     glyph?: GlyphEncoding;
@@ -109,21 +111,57 @@ export type LaneName = 'y' | 'color' | 'colorValue' | 'glyph' | 'row' | 'index';
 export type ColorScaleTable = {
     kind: 'categorical';
     field: string;
+    domain: string[];
+    /** The declared range, the other half of what assigns a key its colour. */
+    range?: string[];
+    /**
+     * Whether every non-empty key met here parsed as a finite number: a
+     * numeric field the declaration landed on a categorical scale, which
+     * the key can then say rather than the encoder typing the field from
+     * the data.
+     */
+    numericKeys?: boolean;
+    /** Each key met, in the field's order, `''` for no value. */
     entries: {
-        label: string;
+        value: string;
+        color: number;
+    }[];
+} | {
+    kind: 'threshold';
+    field: string;
+    /** The cut points, ascending, as numbers. */
+    domain: number[];
+    /** One row per interval, in order, labelled by the interval it spans. */
+    entries: {
+        value: string;
         color: number;
     }[];
 } | {
     kind: 'ramp';
     field: string;
     scale: 'linear' | 'log';
-    /** What the ramp spans here: the declared domain, else `extent`. */
+    /** What the ramp spans here: each declared end, else `extent`'s. */
     domain: [number, number];
-    /** Whether `domain` was declared, and so already agrees across regions. */
-    pinned: boolean;
-    /** This region's own extremes of the field, what a display unions. */
+    /**
+     * Whether each end was declared, and so already agrees across regions;
+     * an open end is what a display widens to the union of theirs.
+     */
+    pinned: [boolean, boolean];
+    /** The declared {@link ColorEncoding} `domainMid`, already baked into `lut`. */
+    domainMid?: number;
+    /**
+     * This region's own extremes of the field, what a display unions;
+     * `[Infinity, -Infinity]` where it holds no number, so a union passes
+     * over it.
+     */
     extent: [number, number];
     lut: Uint8Array;
+    /**
+     * The ramp's RGBA stops, carried beside a `domainMid`: where the middle
+     * stop lands in `lut` depends on the domain, so a display that unions an
+     * unpinned domain past this region's bakes `lut` again from these.
+     */
+    stops?: readonly (readonly [number, number, number, number])[];
 };
 /**
  * #api
@@ -133,8 +171,10 @@ export type ColorScaleTable = {
 export interface GlyphScaleTable {
     kind: 'glyph';
     field: string;
+    domain: string[];
+    range?: GlyphName[];
     entries: {
-        label: string;
+        value: string;
         glyph: GlyphName;
     }[];
 }
@@ -159,6 +199,12 @@ export interface EncodedChannels {
      * reads this beside `count` to say so.
      */
     skipped: number;
+    /**
+     * Of `skipped`, the features whose `x` or `x2` read no number, such as
+     * the edges a `bin` writes for a feature lacking its field. Absent where
+     * the layer placed nothing by a field, as the density sidecar's does.
+     */
+    skippedPosition?: number;
     x: Uint32Array;
     x2: Uint32Array;
     featureIndex: Uint32Array;
@@ -208,7 +254,10 @@ export interface LayerRequest {
  */
 export interface EncodedFeaturesResult {
     layers: EncodedChannels[];
+    /** The sections a facet stacked every layer's rows into. */
+    facet?: FacetSection[];
     bytes?: number;
+    zoomRange?: ZoomRange;
 }
 /**
  * #api
@@ -295,16 +344,14 @@ export interface FlattenStep {
  * there — greedy first fit in start order, the packing a pileup is — and
  * write it to the field `as` (`row`). `fields` names the interval read
  * (`start`, `end`); `padding` is bp of clearance kept between two features
- * sharing a row; `groupby` packs each distinct value set on its own rows,
- * each numbered from 0. The answer is the input in start order, so a `span`
- * encoding `row` stacks it.
+ * sharing a row. The answer is the input in start order, so a `span`
+ * encoding `row` stacks it. Under a facet it packs each section on its own.
  */
-export interface StackStep {
-    type: 'stack';
+export interface PileupStep {
+    type: 'pileup';
     as?: string;
-    fields?: [string, string];
+    fields?: [FieldRef, FieldRef];
     padding?: number;
-    groupby?: FieldRef[];
 }
 /**
  * #api
@@ -312,7 +359,7 @@ export interface StackStep {
  * way GenomeSpy spells a transform; every step runs in order and the next
  * reads what the last answered.
  */
-export type TransformStep = FilterStep | FormulaStep | FlattenStep | BinStep | AggregateStep | CoverageStep | StackStep;
+export type TransformStep = FilterStep | FormulaStep | FlattenStep | BinStep | AggregateStep | CoverageStep | PileupStep;
 export type CoreEncodeFeaturesArgs = {
     adapterConfig: Record<string, unknown>;
     region: {
@@ -324,8 +371,32 @@ export type CoreEncodeFeaturesArgs = {
     layers: LayerRequest[];
     /** The steps over the features, in order, before every layer encodes. */
     transform?: TransformStep[];
-    /** Sugar for leading `filter` steps: `jexl:`-prefixed expressions. */
-    filters?: string[];
+    /** Split the features after the shared steps, before each layer's own. */
+    facet?: FacetSpec;
+    /**
+     * The zoom the adapter reads at, for one with zoom levels (BigWig); absent
+     * is full resolution.
+     */
+    bpPerPx?: number;
     byteLimit?: number;
     sequenceAdapter?: Record<string, unknown>;
 };
+/**
+ * #api
+ * A row facet: split the features on `field`'s value, run every layer's own
+ * steps over each section alone, and stack the sections, each starting on the
+ * row after the one above it ends.
+ */
+export interface FacetSpec {
+    field: FieldRef;
+}
+/**
+ * #api
+ * One faceted section as the worker stacked it: its key, the row it starts on
+ * and how many rows it holds.
+ */
+export interface FacetSection {
+    key: string;
+    firstRow: number;
+    rowCount: number;
+}

package/esm/util/mstUtils.d.ts

@@ -49,33 +49,30 @@ export declare function getRenderingServices(node: IAnyStateTreeNode): Rendering
 /**
  * #api core/util
  * Resolve user-authored refName text against the assembly of the view
- * containing `node` — the one normalization layer, which resolves aliases and
- * casing together. Falls back to the input when the assembly is absent or its
- * aliases have not loaded.
+ * containing `node`, resolving aliases and casing together. Falls back to the
+ * input when the assembly is absent or its aliases have not loaded.
  *
- * Keyed off the VIEW's assembly rather than the track's, because the view is
- * what the comparison is against: displayed regions, loaded regions and blocks
- * all carry the refNames the view laid out.
+ * Uses the view's assembly, not the track's, because displayed regions, loaded
+ * regions and blocks all carry the refNames the view laid out.
  *
- * Reach for this wherever a refName a *person* wrote is about to be compared
- * against regions, features or blocks, which carry the assembly's canonical
- * name. A refName a display copied off a region is canonical already and needs
- * nothing; one that arrived in a session spec, a config slot or a URL is
- * whatever the author read out of the location box.
+ * Call it wherever a refName a *person* wrote is about to be compared against
+ * regions, features or blocks, which carry the assembly's canonical name. A
+ * refName a display copied off a region is already canonical. One from a
+ * session spec, a config slot or a URL is whatever the author typed.
  *
- * Skipping it fails silently and, worse, assembly-dependently: `chr12` matches
- * on an assembly canonicalized `chr12` and matches nothing on one canonicalized
- * `12`, so the same spec key works on one config and quietly does nothing on
- * the next, with no error for anyone to act on.
+ * Without it, matching depends on the assembly: `chr12` matches on an assembly
+ * canonicalized `chr12` and matches nothing on one canonicalized `12`. The
+ * same spec key works on one config and does nothing on the next, with no
+ * error.
  *
- * Resolves through `getCanonicalRefName2`, whose fallback is what keeps a spec
- * read before the alias file has loaded from throwing — and the getters that
- * read user specs do run from the first render.
+ * Resolves through `getCanonicalRefName2`, which falls back to the input
+ * instead of throwing when a spec is read before the alias file has loaded.
+ * The getters that read user specs run from the first render.
  *
- * Takes a refName, not a spec that might hold one: the resolver reads
- * `refName.toLowerCase()`, so anything else throws once the aliases are there,
- * and a caller reading an untyped `frozen` slot has to establish that it names
- * a refName at all before this is the right question to ask of it.
+ * Takes a refName, not a spec that might hold one. The resolver calls
+ * `refName.toLowerCase()`, so any other value throws once the aliases have
+ * loaded, and a caller reading an untyped `frozen` slot must first check that
+ * the value is a refName.
  */
 export declare function canonicalizeViewRefName(node: IAnyStateTreeNode, refName: string): string;
 /**

package/esm/util/mstUtils.js

@@ -64,33 +64,30 @@ export function getRenderingServices(node) {
 /**
  * #api core/util
  * Resolve user-authored refName text against the assembly of the view
- * containing `node` — the one normalization layer, which resolves aliases and
- * casing together. Falls back to the input when the assembly is absent or its
- * aliases have not loaded.
+ * containing `node`, resolving aliases and casing together. Falls back to the
+ * input when the assembly is absent or its aliases have not loaded.
  *
- * Keyed off the VIEW's assembly rather than the track's, because the view is
- * what the comparison is against: displayed regions, loaded regions and blocks
- * all carry the refNames the view laid out.
+ * Uses the view's assembly, not the track's, because displayed regions, loaded
+ * regions and blocks all carry the refNames the view laid out.
  *
- * Reach for this wherever a refName a *person* wrote is about to be compared
- * against regions, features or blocks, which carry the assembly's canonical
- * name. A refName a display copied off a region is canonical already and needs
- * nothing; one that arrived in a session spec, a config slot or a URL is
- * whatever the author read out of the location box.
+ * Call it wherever a refName a *person* wrote is about to be compared against
+ * regions, features or blocks, which carry the assembly's canonical name. A
+ * refName a display copied off a region is already canonical. One from a
+ * session spec, a config slot or a URL is whatever the author typed.
  *
- * Skipping it fails silently and, worse, assembly-dependently: `chr12` matches
- * on an assembly canonicalized `chr12` and matches nothing on one canonicalized
- * `12`, so the same spec key works on one config and quietly does nothing on
- * the next, with no error for anyone to act on.
+ * Without it, matching depends on the assembly: `chr12` matches on an assembly
+ * canonicalized `chr12` and matches nothing on one canonicalized `12`. The
+ * same spec key works on one config and does nothing on the next, with no
+ * error.
  *
- * Resolves through `getCanonicalRefName2`, whose fallback is what keeps a spec
- * read before the alias file has loaded from throwing — and the getters that
- * read user specs do run from the first render.
+ * Resolves through `getCanonicalRefName2`, which falls back to the input
+ * instead of throwing when a spec is read before the alias file has loaded.
+ * The getters that read user specs run from the first render.
  *
- * Takes a refName, not a spec that might hold one: the resolver reads
- * `refName.toLowerCase()`, so anything else throws once the aliases are there,
- * and a caller reading an untyped `frozen` slot has to establish that it names
- * a refName at all before this is the right question to ask of it.
+ * Takes a refName, not a spec that might hold one. The resolver calls
+ * `refName.toLowerCase()`, so any other value throws once the aliases have
+ * loaded, and a caller reading an untyped `frozen` slot must first check that
+ * the value is a refName.
  */
 export function canonicalizeViewRefName(node, refName) {
     const { assemblyManager } = getSession(node);

package/esm/util/numericUtils.d.ts

@@ -10,6 +10,13 @@ export declare function getNumberGrouping(): boolean;
 export declare function toLocale(n: number): string;
 export declare function toPrecision(s: number, n?: number): number;
 export declare function reducePrecision(s: number, n?: number): string;
+/**
+ * A score as a guide prints it: three significant figures below 100, whole
+ * numbers above, trailing fractional zeros dropped. The decimal-point guard
+ * matters because toPrecision can round up out of the fractional form —
+ * 99.95 comes back as "100", where a bare trailing-zero strip would report 1.
+ */
+export declare function formatScore(n: number): string;
 /**
  * A byte count as a person reads it. Shared by the region-too-large banner and
  * the save-track-data dialog, which quote the same index estimate and would

package/esm/util/numericUtils.js

@@ -98,6 +98,22 @@ export function toPrecision(s, n = 3) {
 export function reducePrecision(s, n = 3) {
     return toLocale(toPrecision(s, n));
 }
+/**
+ * A score as a guide prints it: three significant figures below 100, whole
+ * numbers above, trailing fractional zeros dropped. The decimal-point guard
+ * matters because toPrecision can round up out of the fractional form —
+ * 99.95 comes back as "100", where a bare trailing-zero strip would report 1.
+ */
+export function formatScore(n) {
+    if (n === 0) {
+        return '0';
+    }
+    if (Math.abs(n) >= 100) {
+        return n.toFixed(0);
+    }
+    const s = n.toPrecision(3);
+    return s.includes('.') ? s.replace(/\.?0+$/, '') : s;
+}
 /**
  * A byte count as a person reads it. Shared by the region-too-large banner and
  * the save-track-data dialog, which quote the same index estimate and would

package/esm/util/numericValue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A field's value as the number a quantitative channel or step reads, `NaN`
+ * where it holds none. `Number()` answers 0 for `null`, `''`, `[]` and
+ * `[null]` — a VCF's `DP=.` arrives as the last — which plots a missing value
+ * as a measured zero. A one-element list is its element, as a VCF INFO value
+ * is; a string has to hold digits; anything else is not a number.
+ *
+ * The order is the measurement: a number returns first, and a string converts
+ * before its blank check, which runs only on a zero. Over a million features
+ * against `Number()`, interleaved in one process: numbers 0.98x, strings
+ * 1.00-1.02x, one-element lists 0.28x. Testing the list first and trimming
+ * every string measured 1.11-1.16x on a string column.
+ */
+export declare function numericValue(value: unknown): number;

package/esm/util/numericValue.js

@@ -0,0 +1,34 @@
+function textNumber(text) {
+    const n = Number(text);
+    return n === 0 && text.trim() === '' ? Number.NaN : n;
+}
+/**
+ * A field's value as the number a quantitative channel or step reads, `NaN`
+ * where it holds none. `Number()` answers 0 for `null`, `''`, `[]` and
+ * `[null]` — a VCF's `DP=.` arrives as the last — which plots a missing value
+ * as a measured zero. A one-element list is its element, as a VCF INFO value
+ * is; a string has to hold digits; anything else is not a number.
+ *
+ * The order is the measurement: a number returns first, and a string converts
+ * before its blank check, which runs only on a zero. Over a million features
+ * against `Number()`, interleaved in one process: numbers 0.98x, strings
+ * 1.00-1.02x, one-element lists 0.28x. Testing the list first and trimming
+ * every string measured 1.11-1.16x on a string column.
+ */
+export function numericValue(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return textNumber(value);
+    }
+    if (Array.isArray(value) && value.length === 1) {
+        const v = value[0];
+        return typeof v === 'number'
+            ? v
+            : typeof v === 'string'
+                ? textNumber(v)
+                : Number.NaN;
+    }
+    return Number.NaN;
+}

package/esm/util/openFeatureWidget.js

@@ -30,14 +30,13 @@ export function openFeatureWidget(node, featureData, opts = {}) {
     }
     session.setSelection(opts.feature ?? new SimpleFeature(featureData));
     const { type, id } = opts.widget ?? DEFAULT_FEATURE_WIDGET;
-    const widget = session.addWidget(type, id, {
+    const widget = session.openWidget(type, id, {
         featureData,
         parentFeature: opts.parentFeature,
         view: getContainingView(node),
         track: getContainingTrack(node),
         ...opts.extra,
     });
-    session.showWidget(widget);
     return widget;
 }
 /**

package/esm/util/openViews.d.ts

@@ -14,3 +14,4 @@ import type { AbstractSessionModel, AbstractTrackModel, AbstractViewModel } from
 export declare function openViews(session: AbstractSessionModel): AbstractViewModel[];
 /** Every track on every open view. */
 export declare function openTracks(session: AbstractSessionModel): AbstractTrackModel[];
+export declare function viewAndNested(view: AbstractViewModel): AbstractViewModel[];

package/esm/util/openViews.js

@@ -11,12 +11,12 @@
  * getter holds annotation rows that are not tracks.
  */
 export function openViews(session) {
-    return session.views.flatMap(withNested);
+    return session.views.flatMap(viewAndNested);
 }
 /** Every track on every open view. */
 export function openTracks(session) {
     return openViews(session).flatMap(v => v.ownTracks ?? []);
 }
-function withNested(view) {
-    return [view, ...(view.ownViews ?? []).flatMap(withNested)];
+export function viewAndNested(view) {
+    return [view, ...(view.ownViews ?? []).flatMap(viewAndNested)];
 }

package/esm/util/parseLineByLine.d.ts

@@ -1,6 +1,5 @@
 import { IntervalTree } from './IntervalTree.ts';
 import type { StatusCallback } from './progress.ts';
-import type { StopToken } from './stopToken.ts';
 export type { StatusCallback };
 export type LineCallback = (line: string, lineIndex: number) => boolean | undefined;
 /**
@@ -37,10 +36,10 @@ export declare function makeFeatureIntervalTreeMap<T extends {
  *   default to `() => {}`, which says the opposite.
  * @param opts - `label` names the phase on the progress bar (a multi-phase
  *   adapter wants "Parsing PAF", not another "Loading" indistinguishable from
- *   the download that preceded it); `stopToken` makes a multi-GB parse
- *   interruptible instead of running to completion after a cancel.
+ *   the download that preceded it); `signal` is read on every line, but the
+ *   parse never yields, so it sees only an abort that landed before it began.
  */
 export declare function parseLineByLine(buffer: Uint8Array, lineCallback: LineCallback, statusCallback: StatusCallback | undefined, opts?: {
     label?: string;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
 }): void;

package/esm/util/parseLineByLine.js

@@ -97,21 +97,17 @@ function chunkBoundary(buffer, start) {
  *   default to `() => {}`, which says the opposite.
  * @param opts - `label` names the phase on the progress bar (a multi-phase
  *   adapter wants "Parsing PAF", not another "Loading" indistinguishable from
- *   the download that preceded it); `stopToken` makes a multi-GB parse
- *   interruptible instead of running to completion after a cancel.
+ *   the download that preceded it); `signal` is read on every line, but the
+ *   parse never yields, so it sees only an abort that landed before it began.
  */
 export function parseLineByLine(buffer, lineCallback, statusCallback, opts = {}) {
-    const { label = 'Loading', stopToken } = opts;
+    const { label = 'Loading', signal } = opts;
     const decoder = new TextDecoder('utf8');
-    // Time-gated, not gated on a line counter: a file of few but very expensive
-    // lines would never reach a count mask, freezing the bar at 0% for the whole
-    // parse (the failure createProgressReporter documents). The stop-token check
-    // rides the same tick, so cancellation lands within one window.
     const report = createProgressReporter({
         label,
         total: buffer.length,
         statusCallback,
-        stopToken,
+        signal,
     });
     let chunkStart = 0;
     let i = 0;
@@ -140,11 +136,9 @@ export function parseLineByLine(buffer, lineCallback, statusCallback, opts = {})
                     }
                 }
                 i++;
-                // Chunk-granular position, not line-granular: `report` is called every
-                // line so cancellation still lands within one throttle window, but the
-                // byte offset it publishes only advances per chunk. Interpolating
-                // within the chunk would mean converting a UTF-16 offset back to a byte
-                // offset, and at 64KB the bar already moves in sub-percent steps.
+                // Chunk-granular position: interpolating within the chunk would mean
+                // converting a UTF-16 offset back to a byte offset, and at 64KB the bar
+                // already moves in sub-percent steps.
                 report(chunkStart);
                 p = lineEnd + 1;
             }