@pond-ts/charts 0.57.0 → 0.58.0

package/dist/span.js

@@ -0,0 +1,203 @@
+/**
+ * Span-selection membership — the one place the containment rule lives
+ * (interaction RFC A5.2/A5.3, edge rule A7.6).
+ *
+ * `selectionContains` is the **public** predicate, and it is deliberately the
+ * same code every layer's draw runs per mark ({@link spanContainsPoint} for
+ * span entries): a consumer asking "is this hit already selected?" must get
+ * exactly the answer the canvas paints, or the boundary marks disagree with
+ * the span that swept them — the inverse-band-scale friction the marks
+ * currency was built to kill (`selection.md` A4.2) re-imported through the
+ * back door.
+ *
+ * Pure, DOM-free, theme-free — unit-tests like `select.ts` does.
+ */
+/** Stable identity for "no spans" — the resting case, shared by the container
+ *  normalization and every layer's narrowing, so a spanless render never hands
+ *  a draw (or a memo dep) a fresh empty array. */
+export const NO_SPANS = [];
+/**
+ * Is this `selected` entry a span descriptor rather than a single mark? The
+ * discriminant is the `kind` field, which {@link SelectInfo} does not have —
+ * useful to a consumer editing a mixed selection (RFC A5.2's demote-on-edit:
+ * filter the span out, splice in the marks it stashed at commit time).
+ */
+export function isSpanSelection(entry) {
+    return entry.kind === 'span';
+}
+/**
+ * Does `span` contain the mark with these channels? The containment rule of
+ * {@link SpanSelection}, minus the layer-`id` gate (the caller has already
+ * matched it — a layer narrows the set to its own `id` once per render, not
+ * once per mark):
+ *
+ * - `key` in the **half-open** `x` interval — `x[0] <= key < x[1]`;
+ * - `value` in the half-open `y` interval, when the span has one;
+ * - `label` a member of `rows`, when the span has one.
+ *
+ * Each channel is the mark's own {@link SelectInfo} field, so the test is
+ * answerable from a hit alone *and* from a draw loop's per-mark scalars — the
+ * property RFC A5.3 requires (nothing here reads a slot index or a pixel).
+ * `NaN` in any tested channel fails its comparison, so a series-scoped entry
+ * (`key: NaN`) or a gap value is never inside any span. A span carrying `rows`
+ * tested against a caller with no label channel (`label === undefined`)
+ * matches nothing — a row-set has to be checked, not skipped.
+ *
+ * O(1) per mark (plus O(|rows|) for the label set, which is a handful of row
+ * names) — the whole point of the descriptor: a span covering ten thousand
+ * marks costs each of them one interval test, not a ten-thousand-entry scan.
+ */
+export function spanContainsPoint(span, key, value, label) {
+    const x = span.x;
+    if (!(key >= x[0] && key < x[1]))
+        return false;
+    const y = span.y;
+    if (y !== undefined && !(value >= y[0] && value < y[1]))
+        return false;
+    const rows = span.rows;
+    if (rows !== undefined) {
+        if (label === undefined)
+            return false;
+        let found = false;
+        for (let i = 0; i < rows.length; i += 1) {
+            if (rows[i] === label) {
+                found = true;
+                break;
+            }
+        }
+        if (!found)
+            return false;
+    }
+    return true;
+}
+/**
+ * Does **any** of `spans` contain the mark with these channels? The set form of
+ * {@link spanContainsPoint}, for the draw loops — `spans` is the layer's
+ * already-`id`-narrowed list (see {@link spansForLayer}), so this is pure
+ * channel tests. Linear over the spans for the reason `barMatchesAny` records
+ * about mark sets: a selection is a handful of entries, and the common cases
+ * (0 or 1) short-circuit.
+ */
+export function spanMatchesAny(spans, key, value, label) {
+    for (let i = 0; i < spans.length; i += 1) {
+        if (spanContainsPoint(spans[i], key, value, label))
+            return true;
+    }
+    return false;
+}
+/**
+ * Narrow the container's span set to one layer — the span analog of the
+ * per-layer mark narrowing every chart component already does (`keysOf`,
+ * `marksOf`): drop the spans naming other layers, and — when the layer's marks
+ * all share **one** label (`label` given: a single-series bar, scatter or box,
+ * whose `SelectInfo.label` is the series label) — resolve the `rows` channel
+ * here, once, instead of per mark: a row set that excludes the constant label
+ * can never match and is dropped; one that includes it always matches and is
+ * stripped. Layers whose label varies per mark (a stack's groups, a heat map's
+ * rows) pass no `label` and keep `rows` for the draw to test per mark.
+ *
+ * Returns {@link NO_SPANS} when nothing survives, so the resting case keeps a
+ * stable identity (no re-registered layer, no repaint, when some *other*
+ * layer's spans change).
+ */
+export function spansForLayer(spans, id, label) {
+    if (id === undefined || spans.length === 0)
+        return NO_SPANS;
+    let out = null;
+    for (let i = 0; i < spans.length; i += 1) {
+        const s = spans[i];
+        if (s.id !== id)
+            continue;
+        let keep = s;
+        if (label !== undefined && s.rows !== undefined) {
+            let found = false;
+            for (let r = 0; r < s.rows.length; r += 1) {
+                if (s.rows[r] === label) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                continue; // can never match this layer's constant label
+            // Always satisfied — strip it so the draw never re-tests a constant.
+            keep =
+                s.y !== undefined
+                    ? { kind: 'span', id: s.id, x: s.x, y: s.y }
+                    : { kind: 'span', id: s.id, x: s.x };
+        }
+        (out ??= []).push(keep);
+    }
+    return out ?? NO_SPANS;
+}
+/**
+ * **Are these the same mark?** The full mark identity, matching the
+ * container's own hover dedup: same layer `id`, same per-mark handle — the
+ * stable `mark` when **both** sides carry one, else the sample `key` (the
+ * `barMatches` fallback rule) — and same `label`, which on a grouped layer
+ * (stack segment, heat cell) is the half of the identity that separates two
+ * marks sharing a bin. `NaN` keys never match (`NaN !== NaN`), so a
+ * series-scoped legend entry names no mark, deliberately.
+ *
+ * Exported as the companion to {@link selectionContains}, whose doc has
+ * always told a consumer to write `remove(cur, hit)` without giving them
+ * anything to write it with. **`key` alone is not identity**, and reaching
+ * for it is the natural mistake: it is right for a bar, a box and a candle,
+ * and on a stack or a heat map it silently takes out every mark in the bin.
+ * `<MultiSelector>`'s own demote-on-edit stories made exactly that error, in
+ * three places, in the file that is supposed to be the worked example —
+ * which is why this is a library export and not a docs note.
+ */
+export function sameMark(a, b) {
+    if (a.id !== b.id)
+        return false;
+    if (a.mark !== undefined && b.mark !== undefined) {
+        if (a.mark !== b.mark)
+            return false;
+    }
+    else if (a.key !== b.key) {
+        return false;
+    }
+    return a.label === b.label;
+}
+/**
+ * Is `hit` inside the selection — named by a mark entry, or covered by a span
+ * (interaction RFC A5.2)? **The same predicate the layers run**, exported so a
+ * consumer implementing click-policy over a mixed selection (toggle a mark out,
+ * ⌘-click-add next to a swept span) never re-implements the interval test in
+ * axis units — the exact friction `selection.md` A4.2's marks currency exists
+ * to eliminate.
+ *
+ * ```tsx
+ * onSelect={(hit, mods) =>
+ *   setSelected((cur) =>
+ *     hit === null ? []
+ *     : mods?.additive
+ *       ? selectionContains(cur, hit)
+ *         ? cur.filter((e) => isSpanSelection(e) || !sameMark(e, hit))
+ *         : [...cur, hit]
+ *       : [hit],
+ *   )
+ * }
+ * ```
+ *
+ * Span entries use {@link SpanSelection}'s containment rule (half-open `x`/`y`
+ * intervals on the hit's `key`/`value`, `rows` membership on its `label`);
+ * mark entries use the full mark identity (`id`, `mark`-or-`key`, `label`).
+ * Entries naming another layer's `id` never match. O(|sel|) with O(1) per
+ * entry, spans included.
+ */
+export function selectionContains(sel, hit) {
+    for (let i = 0; i < sel.length; i += 1) {
+        const entry = sel[i];
+        if (isSpanSelection(entry)) {
+            if (entry.id === hit.id &&
+                spanContainsPoint(entry, hit.key, hit.value, hit.label))
+                return true;
+        }
+        else if (sameMark(entry, hit)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=span.js.map

package/dist/sweep.d.ts

@@ -0,0 +1,154 @@
+import type { SelectInfo, SweepSession } from './context.js';
+/**
+ * The 1-D **sweep session** — `<MultiSelector>`'s per-drag range query over a
+ * layer's interval marks (interaction RFC A7.6/A7.7).
+ *
+ * A layer's marks are sorted and non-overlapping on the key axis by
+ * construction (bars/bins are bucketed series), so the marks covered by a swept
+ * window are one **contiguous index run `[lo, hi)`** — the 1-D analog of the
+ * heat map's "four integers" session state. Each {@link SweepSession.update} is
+ * two binary searches (O(log N)); the covered run is compared against the last
+ * one, so an unchanged frame costs nothing further and the materialised
+ * preview refreshes **only when the covered set changed** (A1.4's
+ * frame-coalesced, delta-gated preview). {@link SweepSession.hits} caches that
+ * materialisation, which is what makes A5.2's "the hits are free at commit
+ * time" true here: release reads the same array the preview lit, it never runs
+ * a fresh range query.
+ *
+ * **Capture is by intersection, the span is snapped outward** (the A7.6 edge
+ * rule): a mark `[begin, end)` is covered when it intersects the half-open
+ * window `[x0, x1)` — `begin < x1 && end > x0` — and
+ * {@link SweepSession.extent} reports `[begin(first), end(last))` of the
+ * covered run, so `selectionContains`' half-open key test reproduces exactly
+ * the captured set (contiguous neighbours fall out on the open side).
+ *
+ * **Nothing persists** (A7.7): a session is allocated on the pointer-down that
+ * survives `DRAG_SLOP` under a mounted `<MultiSelector>` and dropped at
+ * release. It snapshots the layer's arrays at press — a mid-drag data update
+ * lands on the next gesture, not this one. Consumers who never sweep pay
+ * literally zero: no index, no memory, no draw-path branch.
+ *
+ * Pure and DOM-free, so it unit-tests like `select.ts` does.
+ */
+/** First index in sorted `xs[0..length)` with `xs[i] > v` (upper bound). */
+export declare function firstAbove(xs: ArrayLike<number>, length: number, v: number): number;
+/** First index in sorted `xs[0..length)` with `xs[i] >= v` (lower bound). */
+export declare function firstAtOrAbove(xs: ArrayLike<number>, length: number, v: number): number;
+/**
+ * Build a {@link SweepSession} over one layer's sorted, non-overlapping
+ * interval marks. The layer supplies its identity and two closures:
+ *
+ * - `selectable(i)` — whether mark `i` can own membership at all (a gap bar, an
+ *   all-gap bin). The covered run's **edges** are trimmed to selectable marks so
+ *   the committed span never claims territory whose end marks hold nothing;
+ *   interior gaps stay inside the extent and simply own no membership (A7.6's
+ *   "holes own no membership").
+ * - `materialize(lo, hi)` — the covered marks as the same {@link SelectInfo}s
+ *   the layer's `hitTest` would report (skipping unselectable marks itself), so
+ *   a swept mark and a clicked mark are indistinguishable downstream.
+ */
+export declare function sweep1D(opts: {
+    readonly id: string;
+    /** Mark key-axis begins, ascending. */
+    readonly begin: ArrayLike<number>;
+    /** Mark key-axis ends, ascending (marks are non-overlapping). */
+    readonly end: ArrayLike<number>;
+    readonly length: number;
+    selectable(i: number): boolean;
+    materialize(lo: number, hi: number): readonly SelectInfo[];
+}): SweepSession;
+/**
+ * A **2-D** sweep session — the rect gesture, for layers whose marks do not
+ * reduce to a run of columns ([PND-INTERACT2D], RFC A7.6/A7.7).
+ *
+ * The x half is {@link sweep1D}'s exactly: two binary-search probes over the
+ * sorted, non-overlapping key spans. A **point** layer passes `begin === end`
+ * (a position has no span either side of it), which makes the same cut mean
+ * "keys within the window". The y half is the layer's own business — it
+ * arrives as a window and the layer's `materialize` applies it, because a
+ * scatter filters a continuous value while a heat map picks whole row slots.
+ *
+ * **No spatial index, deliberately** (Q14): the x cut is `O(log N)` and the y
+ * filter is a scan of that run, so nothing persists outside a drag. The
+ * delta-gate below is what keeps that affordable — a pointer move that changes
+ * neither the run nor the y window re-materialises nothing, which is the
+ * lesson A8.1 cost 6.2 s/frame to learn on the 1-D preview.
+ */
+export declare function sweep2D(opts: {
+    readonly id: string;
+    /** Key-axis begins, ascending. Equal to `end` for a point layer. */
+    readonly begin: ArrayLike<number>;
+    /** Key-axis ends, ascending. Equal to `begin` for a point layer. */
+    readonly end: ArrayLike<number>;
+    readonly length: number;
+    /**
+     * Where the committed span's `x` interval comes from. (Not to be confused
+     * with `RowLayer.xExtent`, which is the layer's whole key range.)
+     *
+     * - `'bins'` — the marks **tile** the key axis, so the span snaps outward to
+     *   the covered bins' own edges, exactly as 1-D (a heat map).
+     * - `'drag'` — the marks are isolated positions with no interval either side
+     *   to snap to, so the drag's own half-open window is the span (a scatter).
+     *   Deriving `[first.key, last.key]` from the hits looks tighter and is
+     *   wrong: `SpanSelection`'s `x` test is half-open, so that span excludes
+     *   the very last point the drag captured. The drag window is also what the
+     *   `y` channel reports, so a point layer describes both of its dimensions
+     *   the same way.
+     */
+    readonly spanFrom: 'bins' | 'drag';
+    /** The marks in key-run `[lo, hi)` whose y falls in the **half-open**
+     *  `[y0, y1)` — the same rule `SpanSelection.y` tests, so the capture and
+     *  the committed descriptor agree on the boundary. */
+    materialize(lo: number, hi: number, y0: number, y1: number): readonly SelectInfo[];
+    /**
+     * The cut's **snapped rect in axis units** — `x` in key units, `y` in the
+     * layer's own y-axis units — or omitted when the layer's cut is free.
+     *
+     * This is for the BRUSH, not for the commit: a layer that snaps should draw
+     * the rect it is actually going to take, not the raw pointer rectangle,
+     * or the preview promises a different set than the release delivers. A
+     * scatter omits it and keeps the pointer rect, which is honest there
+     * because a free cut takes exactly what the pointer enclosed.
+     */
+    snap?(lo: number, hi: number, y0: number, y1: number): {
+        readonly x: readonly [number, number];
+        readonly y: readonly [number, number];
+    } | null;
+    /** The captured set's second-dimension channels — see
+     *  {@link SweepSession.extent2D}. */
+    channels(hits: readonly SelectInfo[], y0: number, y1: number): {
+        readonly y?: readonly [number, number];
+        readonly rows?: readonly string[];
+    } | null;
+}): SweepSession;
+/**
+ * A **span-only** sweep session — for a layer that has a range but **no marks**
+ * ([PND-TRACESEL]): a continuous trace.
+ *
+ * The third shape beside {@link sweep1D} and {@link sweep2D}, and the smallest:
+ * `hits()` is always empty and `extent()` is the drag's own window. That is not
+ * a stub, it is the answer. A `<LineChart>`'s samples are **not marks** — they
+ * are usually undrawn, and at any real density there are several per pixel — so
+ * "the samples you swept" is a set the user never expressed. Reporting the
+ * range they *did* express, and nothing else, is the honest cut.
+ *
+ * It is also the cheap one, which is the same decision viewed from the other
+ * side. Materialising the covered samples would mint an array per changed frame
+ * over a series that may hold a million points — the **A8.1** shape this whole
+ * family of sessions is built to avoid. Here there is nothing to materialise at
+ * all: no index, no scan, no allocation, and `NO_HITS` is a shared constant so
+ * even the empty case never mints an array. A consumer who wants the samples
+ * has the span and their own series, and slicing it is one call in pond.
+ *
+ * **The window is not snapped**, because there is nothing to snap to: a trace
+ * tiles no bins. `Layers` still bucket-snaps the drag through the shared
+ * `cursorBuckets` when a sibling layer publishes `binIntervals`, which is
+ * deliberate — a line over a histogram should cut on the histogram's edges.
+ */
+export declare function sweepSpan(opts: {
+    readonly id: string;
+    /** The layer's whole key range, so a drag past the data does not claim
+     *  territory the trace never covered. Omit for an unbounded cut. */
+    readonly bounds?: readonly [number, number];
+}): SweepSession;
+//# sourceMappingURL=sweep.d.ts.map

package/dist/sweep.js

@@ -0,0 +1,282 @@
+/**
+ * The 1-D **sweep session** — `<MultiSelector>`'s per-drag range query over a
+ * layer's interval marks (interaction RFC A7.6/A7.7).
+ *
+ * A layer's marks are sorted and non-overlapping on the key axis by
+ * construction (bars/bins are bucketed series), so the marks covered by a swept
+ * window are one **contiguous index run `[lo, hi)`** — the 1-D analog of the
+ * heat map's "four integers" session state. Each {@link SweepSession.update} is
+ * two binary searches (O(log N)); the covered run is compared against the last
+ * one, so an unchanged frame costs nothing further and the materialised
+ * preview refreshes **only when the covered set changed** (A1.4's
+ * frame-coalesced, delta-gated preview). {@link SweepSession.hits} caches that
+ * materialisation, which is what makes A5.2's "the hits are free at commit
+ * time" true here: release reads the same array the preview lit, it never runs
+ * a fresh range query.
+ *
+ * **Capture is by intersection, the span is snapped outward** (the A7.6 edge
+ * rule): a mark `[begin, end)` is covered when it intersects the half-open
+ * window `[x0, x1)` — `begin < x1 && end > x0` — and
+ * {@link SweepSession.extent} reports `[begin(first), end(last))` of the
+ * covered run, so `selectionContains`' half-open key test reproduces exactly
+ * the captured set (contiguous neighbours fall out on the open side).
+ *
+ * **Nothing persists** (A7.7): a session is allocated on the pointer-down that
+ * survives `DRAG_SLOP` under a mounted `<MultiSelector>` and dropped at
+ * release. It snapshots the layer's arrays at press — a mid-drag data update
+ * lands on the next gesture, not this one. Consumers who never sweep pay
+ * literally zero: no index, no memory, no draw-path branch.
+ *
+ * Pure and DOM-free, so it unit-tests like `select.ts` does.
+ */
+/** First index in sorted `xs[0..length)` with `xs[i] > v` (upper bound). */
+export function firstAbove(xs, length, v) {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (xs[mid] > v)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    return lo;
+}
+/** First index in sorted `xs[0..length)` with `xs[i] >= v` (lower bound). */
+export function firstAtOrAbove(xs, length, v) {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (xs[mid] >= v)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    return lo;
+}
+/** Stable "nothing covered" identity, so an empty preview never mints arrays. */
+const NO_HITS = [];
+/**
+ * Build a {@link SweepSession} over one layer's sorted, non-overlapping
+ * interval marks. The layer supplies its identity and two closures:
+ *
+ * - `selectable(i)` — whether mark `i` can own membership at all (a gap bar, an
+ *   all-gap bin). The covered run's **edges** are trimmed to selectable marks so
+ *   the committed span never claims territory whose end marks hold nothing;
+ *   interior gaps stay inside the extent and simply own no membership (A7.6's
+ *   "holes own no membership").
+ * - `materialize(lo, hi)` — the covered marks as the same {@link SelectInfo}s
+ *   the layer's `hitTest` would report (skipping unselectable marks itself), so
+ *   a swept mark and a clicked mark are indistinguishable downstream.
+ */
+export function sweep1D(opts) {
+    const { id, begin, end, length, selectable, materialize } = opts;
+    // The covered run [curLo, curHi) — empty to start (a press is not a sweep).
+    let curLo = 0;
+    let curHi = 0;
+    let cache = NO_HITS;
+    let dirty = false;
+    return {
+        id,
+        update(x0, x1) {
+            // Intersection cut: first mark ending past x0, first mark beginning at or
+            // past x1. Two O(log N) probes; empty/reversed windows yield an empty run.
+            let lo = firstAbove(end, length, x0);
+            let hi = firstAtOrAbove(begin, length, x1);
+            if (hi < lo)
+                hi = lo;
+            // Trim the run's edges to selectable marks (the span must snap outward
+            // to marks that own membership, not to gaps).
+            while (lo < hi && !selectable(lo))
+                lo += 1;
+            while (hi > lo && !selectable(hi - 1))
+                hi -= 1;
+            if (lo === curLo && hi === curHi)
+                return false;
+            curLo = lo;
+            curHi = hi;
+            dirty = true;
+            return true;
+        },
+        hits() {
+            if (dirty) {
+                cache = curHi > curLo ? materialize(curLo, curHi) : NO_HITS;
+                dirty = false;
+            }
+            return cache;
+        },
+        extent() {
+            return curHi > curLo ? [begin[curLo], end[curHi - 1]] : null;
+        },
+    };
+}
+/**
+ * A **2-D** sweep session — the rect gesture, for layers whose marks do not
+ * reduce to a run of columns ([PND-INTERACT2D], RFC A7.6/A7.7).
+ *
+ * The x half is {@link sweep1D}'s exactly: two binary-search probes over the
+ * sorted, non-overlapping key spans. A **point** layer passes `begin === end`
+ * (a position has no span either side of it), which makes the same cut mean
+ * "keys within the window". The y half is the layer's own business — it
+ * arrives as a window and the layer's `materialize` applies it, because a
+ * scatter filters a continuous value while a heat map picks whole row slots.
+ *
+ * **No spatial index, deliberately** (Q14): the x cut is `O(log N)` and the y
+ * filter is a scan of that run, so nothing persists outside a drag. The
+ * delta-gate below is what keeps that affordable — a pointer move that changes
+ * neither the run nor the y window re-materialises nothing, which is the
+ * lesson A8.1 cost 6.2 s/frame to learn on the 1-D preview.
+ */
+export function sweep2D(opts) {
+    const { id, begin, end, length, spanFrom, snap, materialize, channels } = opts;
+    let curLo = 0;
+    let curHi = 0;
+    // The y window is part of the gate: moving the pointer vertically changes
+    // the covered set without moving the x run at all.
+    let curY0 = 0;
+    let curY1 = 0;
+    // The drag's raw x window, kept for `spanFrom: 'drag'`.
+    let curX0 = 0;
+    let curX1 = 0;
+    let cache = NO_HITS;
+    let dirty = false;
+    return {
+        id,
+        twoD: true,
+        update(x0, x1, y0 = 0, y1 = 0) {
+            let lo = firstAbove(end, length, x0);
+            let hi = firstAtOrAbove(begin, length, x1);
+            if (hi < lo)
+                hi = lo;
+            // A point layer's `end === begin`, so a mark sitting exactly on `x0` is
+            // excluded by `firstAbove`. Pull it back in: the press pixel is inside
+            // the rect the user is drawing, not outside it.
+            while (lo > 0 && begin[lo - 1] === x0)
+                lo -= 1;
+            curX0 = x0;
+            curX1 = x1;
+            let [ylo, yhi] = y0 <= y1 ? [y0, y1] : [y1, y0];
+            // **Gate on the SNAPPED window.** A snapping layer's covered set only
+            // changes when the pointer crosses a row edge, so comparing raw axis
+            // units re-materialises the whole set on every sub-cell pixel of
+            // vertical movement — the delta gate defeating itself, and precisely
+            // the A8.1 shape this gate exists to prevent. Idempotent for the
+            // layers that snap (a row run snapped twice is the same run), and
+            // inert for the ones that do not.
+            const snapped = snap?.(lo, hi, ylo, yhi) ?? null;
+            if (snapped !== null) {
+                ylo = snapped.y[0];
+                yhi = snapped.y[1];
+            }
+            if (lo === curLo && hi === curHi && ylo === curY0 && yhi === curY1) {
+                return false;
+            }
+            curLo = lo;
+            curHi = hi;
+            curY0 = ylo;
+            curY1 = yhi;
+            dirty = true;
+            return true;
+        },
+        hits() {
+            if (dirty) {
+                cache =
+                    curHi > curLo ? materialize(curLo, curHi, curY0, curY1) : NO_HITS;
+                dirty = false;
+            }
+            return cache;
+        },
+        extent() {
+            const hs = this.hits();
+            if (hs.length === 0)
+                return null;
+            // A point layer reports the drag's own window — see `spanFrom`.
+            // Snapping to the hits would give `[first.key, last.key]`, which the
+            // half-open test then reads as excluding the last point captured.
+            if (spanFrom === 'drag')
+                return [curX0, curX1];
+            // Snapped outward exactly as 1-D — but over the marks the **y filter
+            // kept**, not the whole x run. A column whose cells all fell outside the
+            // rect must not widen the span, or replaying that span would re-select
+            // marks the drag never covered.
+            //
+            // Every mark's `key` IS its `begin` on both 2-D layers, and `materialize`
+            // walks the run in index order, so the surviving edges are the first and
+            // last hit keys — the right edge found with one `O(log N)` probe rather
+            // than a scan.
+            const lo = hs[0].key;
+            const last = hs[hs.length - 1].key;
+            const i = firstAtOrAbove(begin, length, last);
+            return [lo, i < length && begin[i] === last ? end[i] : last];
+        },
+        snappedRect() {
+            return curHi > curLo
+                ? (snap?.(curLo, curHi, curY0, curY1) ?? null)
+                : null;
+        },
+        extent2D() {
+            const hs = this.hits();
+            return hs.length === 0 ? null : channels(hs, curY0, curY1);
+        },
+    };
+}
+/**
+ * A **span-only** sweep session — for a layer that has a range but **no marks**
+ * ([PND-TRACESEL]): a continuous trace.
+ *
+ * The third shape beside {@link sweep1D} and {@link sweep2D}, and the smallest:
+ * `hits()` is always empty and `extent()` is the drag's own window. That is not
+ * a stub, it is the answer. A `<LineChart>`'s samples are **not marks** — they
+ * are usually undrawn, and at any real density there are several per pixel — so
+ * "the samples you swept" is a set the user never expressed. Reporting the
+ * range they *did* express, and nothing else, is the honest cut.
+ *
+ * It is also the cheap one, which is the same decision viewed from the other
+ * side. Materialising the covered samples would mint an array per changed frame
+ * over a series that may hold a million points — the **A8.1** shape this whole
+ * family of sessions is built to avoid. Here there is nothing to materialise at
+ * all: no index, no scan, no allocation, and `NO_HITS` is a shared constant so
+ * even the empty case never mints an array. A consumer who wants the samples
+ * has the span and their own series, and slicing it is one call in pond.
+ *
+ * **The window is not snapped**, because there is nothing to snap to: a trace
+ * tiles no bins. `Layers` still bucket-snaps the drag through the shared
+ * `cursorBuckets` when a sibling layer publishes `binIntervals`, which is
+ * deliberate — a line over a histogram should cut on the histogram's edges.
+ */
+export function sweepSpan(opts) {
+    const { id, bounds } = opts;
+    let lo = 0;
+    let hi = 0;
+    let live = false;
+    return {
+        id,
+        spanOnly: true,
+        update(x0, x1) {
+            let a = Math.min(x0, x1);
+            let b = Math.max(x0, x1);
+            if (bounds !== undefined) {
+                a = Math.max(a, bounds[0]);
+                b = Math.min(b, bounds[1]);
+            }
+            // An empty or fully-clipped window covers nothing — reported as "no
+            // extent" rather than as a zero-width span, so a release outside the
+            // data reads as the swept-empty deselect every other layer gives.
+            const next = b > a;
+            if (next === live && a === lo && b === hi)
+                return false;
+            lo = a;
+            hi = b;
+            live = next;
+            return true;
+        },
+        hits() {
+            return NO_HITS;
+        },
+        extent() {
+            return live ? [lo, hi] : null;
+        },
+    };
+}
+//# sourceMappingURL=sweep.js.map