@fjader/svelte 0.2.3 → 0.2.4

package/dist/components/marks/lifecycle/other-rows.svelte.d.ts

@@ -0,0 +1,104 @@
+/**
+ * What a mark's Other rows hold, and what is done with it: the one owner of
+ * the three things that read an Other row's member lists.
+ *
+ * - `register`: hands the members to their field, so a click on the bucket
+ *   selects them and the bucket is lit while the selection reaches into it.
+ * - `split`: a bar's selected share, for the bar renderer to draw as two parts.
+ * - `stats`: what that share is made of, for a tooltip.
+ *
+ * Takes getters, not values, so what it reads is tracked by whoever reads it.
+ * MarkLifecycleV2 holds one and says only what it is told by the mark.
+ */
+import type { Table } from '@uwdata/flechette';
+import type { FilterGroup } from '../../../query-engine/FilterGroup.svelte';
+import type { QueryEngine } from '../../../query-engine/QueryEngine';
+import type { ChannelIdentity } from '../../../types';
+/** What the mark is, for whether its Other bar can be split. */
+export interface SplitPlan {
+    markType: string;
+    /** The bar's length channel: `y` for vertical bars, `x` for horizontal. */
+    length: string | undefined;
+    /** The measure topN ranks by, null for its default (the length). */
+    by: string | null;
+    /** The length channel's select expression. */
+    expr: unknown;
+    /** The mark's topN has an Other bucket. */
+    hasOther: boolean;
+    /** JS transforms follow the query, so its rows no longer line up. */
+    hasJsTransforms: boolean;
+}
+/** What the bar renderer draws an Other split from. */
+export interface SplitProp {
+    /** 0 on rows that are not an Other row, `1 + share` on one. */
+    data: Float32Array;
+    /** Whether the split travels with the bar's morph or lands at once. */
+    slides: boolean;
+    /** The band axis the bars are grouped on; the split runs along the other. */
+    axis: 'x' | 'y';
+    /** Colour is the band's own field, so an Other row's colour term reads its id too. */
+    colorOnBand: boolean;
+}
+/** One Other row's share, in numbers. */
+export interface OtherRowStats {
+    picked: number;
+    total: number;
+    pickedCount: number;
+    memberCount: number;
+    /** The field has a selection; without one picked is everything and says nothing. */
+    active: boolean;
+}
+export interface OtherRowsDeps {
+    queryEngine: QueryEngine;
+    filterGroup: FilterGroup;
+    markId: string;
+    /** The mark's result, and the version it is at. */
+    table: () => Table | null;
+    dataVersion: () => number;
+    identity: () => Record<string, ChannelIdentity> | null;
+    /** The identity key of a band axis, or null when it has none. */
+    identityKey: (axis: 'x' | 'y') => string | null;
+    /** The mark is filtered by the selection rather than dimmed by it. */
+    filtered: () => boolean;
+    /** The mark's plan, or null before its setup completes. */
+    plan: () => SplitPlan | null;
+    /** The identity key of the mark's ordinal colour scale, or null. */
+    colorKey: () => string | null;
+    /** The identity key of the chart's band scale on an axis, or null. */
+    bandScaleKey: (axis: 'x' | 'y') => string | null;
+}
+export declare class OtherRows {
+    #private;
+    constructor(deps: OtherRowsDeps);
+    /**
+     * Register this result's Other rows with their field: what each Other bucket
+     * holds, per facet cell, for a click on it to select (FieldActivity.setOther).
+     * Per result, so the members follow the filters the mark receives. A mark
+     * filtered by the selection (`'filter'`) registers with no group, which is
+     * how a click on its Other knows to drill down rather than toggle off.
+     */
+    register(): void;
+    /** Give every registered row up: the mark is going away or starting over. */
+    unregister(): void;
+    /**
+     * The bar renderer's split, or null: no split, the bar is lit or dim as a
+     * whole (see #splitAxis for when a bar has one).
+     *
+     * Per row, share = Σ values[k] · selected(ids[k]) / Σ values[k] over the
+     * row's own member lists: the part of the bar the selection holds. A weighted
+     * sum over values the query already returned, in JS, per result and per
+     * selection change: the alternative is re-querying a mark that dims, which is
+     * what dimming exists to avoid.
+     */
+    get split(): SplitProp | null;
+    /** What an Other row's share is made of, or null where it has no split. */
+    stats(row: number): OtherRowStats | null;
+    /**
+     * `stats` of the Other row a tooltip point names: its band id and, with
+     * facets, its cell (null: any). A tooltip's rows are not the result's, so it
+     * finds its row by identity. A scan of the result's rows, per hover change
+     * and not per frame; null where the point is not an Other row of this mark's
+     * split.
+     */
+    statsAt(bandId: number, facetId: number | null): OtherRowStats | null;
+}

package/dist/components/marks/lifecycle/other-rows.svelte.js

@@ -0,0 +1,193 @@
+/**
+ * What a mark's Other rows hold, and what is done with it: the one owner of
+ * the three things that read an Other row's member lists.
+ *
+ * - `register`: hands the members to their field, so a click on the bucket
+ *   selects them and the bucket is lit while the selection reaches into it.
+ * - `split`: a bar's selected share, for the bar renderer to draw as two parts.
+ * - `stats`: what that share is made of, for a tooltip.
+ *
+ * Takes getters, not values, so what it reads is tracked by whoever reads it.
+ * MarkLifecycleV2 holds one and says only what it is told by the mark.
+ */
+import { OTHER_IDS_COLUMN, OTHER_VALUES_COLUMN } from '../../../transforms';
+import { otherSplit, splittable } from './other-split';
+export class OtherRows {
+    #deps;
+    /** The (field, Other id) pairs this mark has rows registered under. */
+    #registered = new Map();
+    /** The split last computed, and for which result: what a selection change holds against. */
+    #last = null;
+    constructor(deps) {
+        this.#deps = deps;
+    }
+    /**
+     * Register this result's Other rows with their field: what each Other bucket
+     * holds, per facet cell, for a click on it to select (FieldActivity.setOther).
+     * Per result, so the members follow the filters the mark receives. A mark
+     * filtered by the selection (`'filter'`) registers with no group, which is
+     * how a click on its Other knows to drill down rather than toggle off.
+     */
+    register() {
+        const { table: getTable, identity: getIdentity, filterGroup, markId } = this.#deps;
+        const table = getTable();
+        const identity = getIdentity();
+        const group = this.#deps.filtered() ? null : filterGroup.index;
+        const now = new Map();
+        const ids = table?.getChild(OTHER_IDS_COLUMN) ?? null;
+        if (table && identity && ids) {
+            const facets = table.getChild('__facet');
+            for (const axis of ['x', 'y']) {
+                const otherId = identity[axis]?.otherId;
+                const key = this.#deps.identityKey(axis);
+                const band = table.getChild(axis);
+                if (otherId == null || !key || !band)
+                    continue;
+                const rows = [];
+                for (let i = 0; i < table.numRows; i++) {
+                    if (Number(band.at(i)) !== otherId)
+                        continue;
+                    const members = ids.at(i);
+                    if (!members)
+                        continue;
+                    rows.push({ facetId: facets ? Number(facets.at(i)) : null, ids: members });
+                }
+                filterGroup.activity(key).setOther(otherId, markId, { group, rows });
+                now.set(key, otherId);
+            }
+        }
+        // A field or bucket this mark no longer draws an Other on gives its rows up.
+        for (const [key, otherId] of this.#registered) {
+            if (now.get(key) !== otherId)
+                filterGroup.activity(key).setOther(otherId, markId, null);
+        }
+        this.#registered = now;
+    }
+    /** Give every registered row up: the mark is going away or starting over. */
+    unregister() {
+        for (const [key, otherId] of this.#registered) {
+            this.#deps.filterGroup.activity(key).setOther(otherId, this.#deps.markId, null);
+        }
+        this.#registered = new Map();
+    }
+    /**
+     * The bar renderer's split, or null: no split, the bar is lit or dim as a
+     * whole (see #splitAxis for when a bar has one).
+     *
+     * Per row, share = Σ values[k] · selected(ids[k]) / Σ values[k] over the
+     * row's own member lists: the part of the bar the selection holds. A weighted
+     * sum over values the query already returned, in JS, per result and per
+     * selection change: the alternative is re-querying a mark that dims, which is
+     * what dimming exists to avoid.
+     */
+    get split() {
+        const axis = this.#splitAxis;
+        const computed = this.#computed;
+        if (!axis || !computed)
+            return null;
+        return {
+            data: computed.split,
+            slides: computed.slides,
+            axis,
+            colorOnBand: this.#colorOnBand(axis)
+        };
+    }
+    /** What an Other row's share is made of, or null where it has no split. */
+    stats(row) {
+        const computed = this.#computed;
+        if (!computed || computed.memberCount[row] === 0)
+            return null;
+        return {
+            picked: computed.picked[row],
+            total: computed.total[row],
+            pickedCount: computed.pickedCount[row],
+            memberCount: computed.memberCount[row],
+            active: computed.active
+        };
+    }
+    /**
+     * `stats` of the Other row a tooltip point names: its band id and, with
+     * facets, its cell (null: any). A tooltip's rows are not the result's, so it
+     * finds its row by identity. A scan of the result's rows, per hover change
+     * and not per frame; null where the point is not an Other row of this mark's
+     * split.
+     */
+    statsAt(bandId, facetId) {
+        const axis = this.#splitAxis;
+        const table = this.#deps.table();
+        const otherId = axis ? this.#deps.identity()?.[axis]?.otherId : null;
+        if (!axis || !table || otherId == null || bandId !== otherId)
+            return null;
+        const band = table.getChild(axis);
+        const facets = facetId == null ? null : table.getChild('__facet');
+        if (!band)
+            return null;
+        for (let row = 0; row < table.numRows; row++) {
+            if (Number(band.at(row)) !== bandId)
+                continue;
+            if (facets && Number(facets.at(row)) !== facetId)
+                continue;
+            return this.stats(row);
+        }
+        return null;
+    }
+    /**
+     * The band axis whose Other bar splits, or null. Only where a share is what
+     * it looks like:
+     * - a bar mark ('bary', 'barx') with a topN Other bucket, dimming (not
+     *   'filter', which never dims) and without JS transforms, whose rows would
+     *   no longer line up with the query's;
+     * - whose length is the measure topN ranks by, which is what Other sums;
+     * - and that measure a bare COUNT or SUM, or a raw column: a mean or a max
+     *   summed into Other is no total, and a share of it would mean nothing.
+     */
+    get #splitAxis() {
+        const plan = this.#deps.plan();
+        if (!plan || this.#deps.filtered())
+            return null;
+        if (!plan.hasOther || plan.hasJsTransforms)
+            return null;
+        if (plan.markType !== 'bary' && plan.markType !== 'barx')
+            return null;
+        return splittable(plan.length, plan.by, plan.expr)
+            ? plan.markType === 'barx'
+                ? 'y'
+                : 'x'
+            : null;
+    }
+    /** Whether colour is the band's own field, so an Other row's colour term reads its id too. */
+    #colorOnBand(axis) {
+        const color = this.#deps.colorKey();
+        return color != null && color === this.#deps.bandScaleKey(axis);
+    }
+    #computed = $derived.by(() => {
+        const axis = this.#splitAxis;
+        if (!axis)
+            return null;
+        const dataVersion = this.#deps.dataVersion();
+        const table = this.#deps.table();
+        const otherId = this.#deps.identity()?.[axis]?.otherId;
+        const key = this.#deps.identityKey(axis);
+        const ids = table?.getChild(OTHER_IDS_COLUMN) ?? null;
+        const values = table?.getChild(OTHER_VALUES_COLUMN) ?? null;
+        const band = table?.getChild(axis) ?? null;
+        if (!table || otherId == null || !key || !ids || !values || !band)
+            return null;
+        // The last split, for the same result only: a selection change holds a
+        // flat row's position. A new result starts afresh and travels with the bar.
+        const { filterGroup, queryEngine } = this.#deps;
+        const last = this.#last;
+        const next = otherSplit({
+            rows: table.numRows,
+            band,
+            otherId,
+            ids,
+            values,
+            selected: filterGroup.activity(key).selectedValues(filterGroup.index),
+            decode: queryEngine.identityFor(key).values,
+            previous: last && last.dataVersion === dataVersion ? last.split : null
+        });
+        this.#last = { dataVersion, split: next };
+        return next;
+    });
+}

package/dist/components/marks/lifecycle/other-split.d.ts

@@ -0,0 +1,80 @@
+/**
+ * An Other bar's selected share, per row, and when a bar has one: the pure
+ * half of MarkLifecycleV2's `otherSplit`, so it can be tested without a mark.
+ */
+/** A column of a result, as Arrow (flechette) hands it: one value per row. */
+export interface RowColumn {
+    at(row: number): unknown;
+}
+/** One computed split: the channel, and which Other rows are flat. */
+export interface OtherSplit {
+    /** 0 on rows that are not an Other row, `1 + share` (or a held position) on one. */
+    split: Float32Array;
+    /**
+     * 1 on an Other row whose two parts look the same: nothing selected (both
+     * lit), or none of its members selected (both dim). Its split position is
+     * invisible there, so it is held, and moving out of it lands rather than
+     * slides.
+     */
+    flat: Uint8Array;
+    /**
+     * Whether the split travels with this write (the renderer morphs it) or
+     * lands at once. It lands when a row leaves a flat state: both sides of it
+     * look the same at that moment, so a slide would be a movement the eye
+     * reads as meaning something; the fades show the change instead.
+     */
+    slides: boolean;
+    /**
+     * What the share is made of, per row (0 on a row with no split), for a
+     * tooltip to say: `picked` of `total` (Σ values over the selected members,
+     * over all), `pickedCount` of `memberCount` categories. With nothing
+     * selected everything counts as picked.
+     */
+    picked: Float64Array;
+    total: Float64Array;
+    pickedCount: Int32Array;
+    memberCount: Int32Array;
+    /** The field has a selection: without one, everything counts as picked, which says nothing. */
+    active: boolean;
+}
+/**
+ * The split channel for the bar renderer, per row: share = Σ values · selected
+ * / Σ values over the row's own member lists. Selection is by value (`decode`
+ * maps an id to its value), so the NULL category needs nothing special. A row
+ * whose members mix signs gets no split (0): a share of a sum that cancels
+ * means nothing.
+ *
+ * `previous`: the last split for the SAME rows (the same result), when only the
+ * selection changed. A flat row then holds its previous position, so going flat
+ * (a selection cleared, or one that no longer reaches into Other) is a fade,
+ * not a slide. Without it (a new result) every row takes its value, and the
+ * split travels with the bar's own morph.
+ *
+ * Cost, measured: about 22 ns per Other member per call (the `selected.has`),
+ * so 0.1 ms at 5 000 members and about 1.2 ms at 50 000. Fine per click. If
+ * selection ever changes continuously (a brush on a band axis) over a very large
+ * Other, test membership against a Uint8Array indexed by id, built once per
+ * change, rather than a Set. The arrays allocated here are sized by rows.
+ */
+export declare function otherSplit(opts: {
+    rows: number;
+    band: RowColumn;
+    otherId: number;
+    ids: RowColumn;
+    values: RowColumn;
+    selected: ReadonlySet<unknown> | null;
+    decode: ArrayLike<unknown>;
+    previous?: OtherSplit | null;
+}): OtherSplit;
+/**
+ * Whether a bar's Other bucket can be split: its length must be what Other
+ * sums, and a total. `length` is the bar's length channel, `by` the channel
+ * topN ranks by (null: its default, the length), `expr` the length channel's
+ * select expression.
+ *
+ * Other sums `by`, so a length channel that is not `by` is 0 on the Other row.
+ * A bare COUNT or SUM, or a raw column (an ungrouped mark), is a total; a mean,
+ * a max, a ratio or a distinct count summed into Other is not, and a share of
+ * it would look exact while meaning nothing.
+ */
+export declare function splittable(length: string | undefined, by: string | null, expr: unknown): boolean;

package/dist/components/marks/lifecycle/other-split.js

@@ -0,0 +1,112 @@
+/**
+ * An Other bar's selected share, per row, and when a bar has one: the pure
+ * half of MarkLifecycleV2's `otherSplit`, so it can be tested without a mark.
+ */
+/**
+ * The split channel for the bar renderer, per row: share = Σ values · selected
+ * / Σ values over the row's own member lists. Selection is by value (`decode`
+ * maps an id to its value), so the NULL category needs nothing special. A row
+ * whose members mix signs gets no split (0): a share of a sum that cancels
+ * means nothing.
+ *
+ * `previous`: the last split for the SAME rows (the same result), when only the
+ * selection changed. A flat row then holds its previous position, so going flat
+ * (a selection cleared, or one that no longer reaches into Other) is a fade,
+ * not a slide. Without it (a new result) every row takes its value, and the
+ * split travels with the bar's own morph.
+ *
+ * Cost, measured: about 22 ns per Other member per call (the `selected.has`),
+ * so 0.1 ms at 5 000 members and about 1.2 ms at 50 000. Fine per click. If
+ * selection ever changes continuously (a brush on a band axis) over a very large
+ * Other, test membership against a Uint8Array indexed by id, built once per
+ * change, rather than a Set. The arrays allocated here are sized by rows.
+ */
+export function otherSplit(opts) {
+    const { rows, band, otherId, ids, values, selected, decode } = opts;
+    const previous = opts.previous && opts.previous.split.length === rows ? opts.previous : null;
+    const split = new Float32Array(rows);
+    const flat = new Uint8Array(rows);
+    const pickedSums = new Float64Array(rows);
+    const totals = new Float64Array(rows);
+    const pickedCount = new Int32Array(rows);
+    const memberCount = new Int32Array(rows);
+    let slides = true;
+    for (let row = 0; row < rows; row++) {
+        if (Number(band.at(row)) !== otherId)
+            continue;
+        const memberIds = ids.at(row);
+        const memberValues = values.at(row);
+        if (!memberIds || !memberValues)
+            continue;
+        let total = 0;
+        let picked = 0;
+        let count = 0;
+        let positive = false;
+        let negative = false;
+        for (let k = 0; k < memberIds.length; k++) {
+            const v = memberValues[k];
+            if (v > 0)
+                positive = true;
+            else if (v < 0)
+                negative = true;
+            total += v;
+            if (selected == null || selected.has(decode[memberIds[k]])) {
+                picked += v;
+                count++;
+            }
+        }
+        if (positive && negative)
+            continue;
+        pickedSums[row] = picked;
+        totals[row] = total;
+        pickedCount[row] = count;
+        memberCount[row] = memberIds.length;
+        const share = total === 0 ? (selected == null ? 1 : 0) : Math.min(1, Math.max(0, picked / total));
+        const isFlat = selected == null || share === 0;
+        flat[row] = isFlat ? 1 : 0;
+        if (isFlat && previous) {
+            const held = previous.split[row];
+            split[row] = held > 0.5 ? held : 2;
+        }
+        else {
+            split[row] = 1 + share;
+        }
+        if (previous && previous.flat[row] === 1 && !isFlat)
+            slides = false;
+    }
+    return {
+        split,
+        flat,
+        slides,
+        picked: pickedSums,
+        total: totals,
+        pickedCount,
+        memberCount,
+        active: selected != null
+    };
+}
+/**
+ * Whether a bar's Other bucket can be split: its length must be what Other
+ * sums, and a total. `length` is the bar's length channel, `by` the channel
+ * topN ranks by (null: its default, the length), `expr` the length channel's
+ * select expression.
+ *
+ * Other sums `by`, so a length channel that is not `by` is 0 on the Other row.
+ * A bare COUNT or SUM, or a raw column (an ungrouped mark), is a total; a mean,
+ * a max, a ratio or a distinct count summed into Other is not, and a share of
+ * it would look exact while meaning nothing.
+ */
+export function splittable(length, by, expr) {
+    if (!length || (by ?? length) !== length)
+        return false;
+    if (typeof expr === 'string')
+        return true;
+    const node = expr;
+    if (!node || typeof node !== 'object')
+        return false;
+    if (node.type === 'COLUMN_REF')
+        return true;
+    if (node.type !== 'AGGREGATE' || node.isDistinct)
+        return false;
+    return node.name === 'count' || node.name === 'sum';
+}

package/dist/components/marks/lifecycle/query-builder.d.ts

@@ -26,7 +26,31 @@ export interface QueryParts {
      *  CAST for ORDER BY, ordinal CASE for PARTITION BY). Used by preagg to
      *  fold redundant window col refs into channel aliases. */
     passthroughChannels: Map<string, string>;
+    /**
+     * `nulls="drop"`: the categorical channels whose NULL the mark leaves out.
+     * Stated by CHANNEL, not by source column, so every path filters in the
+     * terms of its own select: `assembleQuery` reads each channel's expression
+     * from the `selectDef` it is given — the id column on the base table, the
+     * preagg table's column when preagg rewrote it — and ANDs the predicate
+     * into the base scan, before any transform.
+     */
+    nullDrops?: readonly NullDrop[];
 }
+/**
+ * One channel whose NULL a mark drops. With `nullId`, the channel carries dim
+ * ids and the NULL category is that id: `<channel> <> nullId`. Without (a raw
+ * value, or a dim with no NULL row): `<channel> IS NOT NULL`.
+ */
+export interface NullDrop {
+    channel: string;
+    nullId: number | null;
+}
+/**
+ * The predicates for `drops`, each on its channel's expression in `selectDef`.
+ * A dropped channel must be a row-level group key of the query; one the query
+ * does not select would be left unfiltered, so that is an error, not a skip.
+ */
+export declare function nullDropPredicates(drops: readonly NullDrop[], selectDef: Record<string, unknown>): ExprNode[];
 /** Window functions to apply in an outer CTE over the assembled inner query. */
 export interface WindowWrap {
     /** channel → outer WindowNode (already rewritten to reference channel aliases). */
@@ -38,9 +62,10 @@ export interface AssembleOptions {
     parts: QueryParts;
     /** Per-call filter predicates (crossfilter, bin filters). */
     filter?: unknown[];
-    /** Columns to add IS NOT NULL predicates for. */
     transformCompiler: TransformCompiler;
     limit?: number | null;
+    /** The table already has the mark's row filters (`filter()`) applied: a preagg table. */
+    skipRowFilters?: boolean;
     /** When set, the inner query is wrapped in a CTE and these window
      *  functions are applied in the outer SELECT. ORDER BY / LIMIT move to
      *  the outer query. */

package/dist/components/marks/lifecycle/query-builder.js

@@ -1,5 +1,22 @@
-import { isNode, isAggregateExpression, isColumnRef, isColumnParam, column as sqlColumn, cast, coalesce, collectColumns, rewrite, sql, isNotNull, and, sum, avg, min, max, Query, WindowNode } from '@uwdata/mosaic-sql';
+import { isNode, isAggregateExpression, isColumnRef, isColumnParam, column as sqlColumn, cast, coalesce, collectColumns, rewrite, sql, isNotNull, neq, literal, and, sum, avg, min, max, Query, WindowNode } from '@uwdata/mosaic-sql';
 import { isWindowExpression, isVerbatimWindowExpression } from '../../../sql/expression-utils';
+/**
+ * The predicates for `drops`, each on its channel's expression in `selectDef`.
+ * A dropped channel must be a row-level group key of the query; one the query
+ * does not select would be left unfiltered, so that is an error, not a skip.
+ */
+export function nullDropPredicates(drops, selectDef) {
+    const out = [];
+    for (const { channel, nullId } of drops) {
+        const value = selectDef[channel];
+        if (value === undefined) {
+            throw new Error(`nulls="drop" filters the "${channel}" channel, which this query does not select.`);
+        }
+        const expr = (typeof value === 'string' ? sqlColumn(value) : value);
+        out.push(nullId === null ? isNotNull(expr) : neq(expr, literal(nullId)));
+    }
+    return out;
+}
 // ---------------------------------------------------------------------------
 // Numeric CAST policy (single rule for every assembly path)
 // ---------------------------------------------------------------------------
@@ -208,7 +225,7 @@ export function buildQueryParts(select, orderConfig, hasSQLTransforms, passthrou
  * Order is fixed and shared by the flat, window-CTE, and preagg paths:
  *
  *   SELECT parts.selectDef FROM table [GROUP BY dims]
- *   WHERE filter AND nulls          — on the base scan, so transform CTEs
+ *   WHERE filter AND nullDrops      — on the base scan, so transform CTEs
  *                                     (topN ranking etc.) see filtered rows
  *   → SQL transforms (CTE wrapping)
  *   → [window CTE: outer SELECT applies window fns over the inner result]
@@ -267,19 +284,22 @@ export function outerOrder(preference, alignment) {
     return order;
 }
 export function assembleQuery(opts) {
-    const { table, parts, filter = [], transformCompiler, limit, window } = opts;
+    const { table, parts, filter = [], transformCompiler, limit, window, skipRowFilters } = opts;
     const { selectDef, nonAggregateGroupBy, hasAggregates, hasSQLTransforms, orderChannels } = parts;
     const q = Query.from(table).select(selectDef);
     if (hasAggregates && nonAggregateGroupBy.length > 0) {
         q.groupby(nonAggregateGroupBy);
     }
-    const allFilters = [...filter];
+    const allFilters = [
+        ...filter,
+        ...nullDropPredicates(parts.nullDrops ?? [], selectDef)
+    ];
     if (allFilters.length > 0) {
         q.where(and(allFilters));
     }
     let result = q;
     if (hasSQLTransforms) {
-        result = transformCompiler.applyToQuery(q, { groupKeys: parts.groupKeys });
+        result = transformCompiler.applyToQuery(q, { groupKeys: parts.groupKeys }, { skipRowFilters });
     }
     if (window) {
         const outerSelect = {};

package/dist/components/marks/utils/reactive-config.d.ts

@@ -12,6 +12,6 @@ import type { MarkEntry } from '../../../config/ChartConfig.svelte';
  * @param entry - The mark entry (reactive props from ChartConfig)
  * @param opts.resolveFitDomain - Getter for resolved fitDomain (deferred read)
  */
-export declare function buildReactiveConfig(entry: Partial<Pick<MarkEntry, 'sort' | 'limit' | 'domain' | 'tooltip' | 'tip' | 'fitDomain' | 'selectionResponse'>>, opts?: {
+export declare function buildReactiveConfig(entry: Partial<Pick<MarkEntry, 'sort' | 'limit' | 'domain' | 'tooltip' | 'tip' | 'fitDomain' | 'selectionResponse' | 'nulls' | 'contributeDomain'>>, opts?: {
     resolveFitDomain?: () => 'x' | 'y' | boolean | undefined;
 }): ReactiveConfig;

package/dist/components/marks/utils/reactive-config.js

@@ -33,6 +33,12 @@ export function buildReactiveConfig(entry, opts) {
         },
         get selectionResponse() {
             return entry.selectionResponse;
+        },
+        get nulls() {
+            return entry.nulls;
+        },
+        get contributeDomain() {
+            return entry.contributeDomain;
         }
     };
 }

package/dist/components/marks/utils/tooltip-helpers.d.ts

@@ -1,3 +1,4 @@
+import type { OtherRowStats } from '../lifecycle/other-rows.svelte';
 import type { ChartContext } from '../../../types';
 import type { ColorScaleState } from '../../../scales/ColorScaleState.svelte';
 import type { DimValue } from '../../../query-engine/categorical-identity';
@@ -34,6 +35,7 @@ interface TooltipConfigParams {
     constantRadius?: number;
     sizeScaleState?: SizeScaleState | null;
     displayFields?: string[] | null;
+    otherStats?: TooltipConfig['otherStats'];
 }
 interface TooltipConfig {
     tempTable: string;
@@ -61,7 +63,8 @@ interface TooltipConfig {
     constantRadius?: number;
     sizeScaleState?: SizeScaleState | null;
     displayFields?: string[] | null;
+    otherStats?: (point: Record<string, unknown>) => OtherRowStats | null;
     enabled: boolean;
 }
-export declare function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields }: TooltipConfigParams): TooltipConfig;
+export declare function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields, otherStats }: TooltipConfigParams): TooltipConfig;
 export {};

package/dist/components/marks/utils/tooltip-helpers.js

@@ -1,4 +1,4 @@
-export function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields }) {
+export function buildTooltipConfig({ tempTable, markType, chartContext, channelFields, columns, bandAxes, colorColumn, markColor, seriesColumn, markSeries, proximityAxis, constantRadius, sizeScaleState, displayFields, otherStats }) {
     const colorScaleState = markColor.scaleState;
     const constantColor = markColor.constantCssColor;
     return {
@@ -33,6 +33,7 @@ export function buildTooltipConfig({ tempTable, markType, chartContext, channelF
         ...(constantRadius != null && { constantRadius }),
         ...(sizeScaleState && { sizeScaleState }),
         ...(displayFields && { displayFields }),
+        ...(otherStats && { otherStats }),
         enabled: true
     };
 }

package/dist/components/rendering/BaseGPURenderer.svelte.d.ts

@@ -57,7 +57,9 @@ export declare class BaseGPURenderer {
      * the band axis's scale is whose clock these channels adopt. See
      * MorphedChannels for the fold, the snap and the clock.
      */
-    writeMorphed(bandAxis: 'x' | 'y', bandIds: ArrayLike<number>, channels: readonly (readonly [number, AllowSharedBufferSource])[]): void;
+    writeMorphed(bandAxis: 'x' | 'y', bandIds: ArrayLike<number>, channels: readonly (readonly [number, AllowSharedBufferSource])[], 
+    /** Bindings that land at once rather than travel (see MorphedChannels.write). */
+    land?: readonly number[]): void;
     /**
      * Write data to a uniform binding.
      */