@fjader/svelte 0.2.2 → 0.2.4

package/dist/components/marks/lifecycle/MarkLifecycleV2.svelte.js

@@ -11,7 +11,8 @@
  *   → setupComplete = true
  *
  * Registration: watches #resolvedQueryParts, registers with engine.
- *   Engine handles filter-driven re-queries via onFilterChange().
+ *   Engine handles filter-driven re-queries via onClauseChange() and
+ *   onFilterChange().
  *
  * Params: watches sort/limit on ReactiveConfig.
  *   Changes trigger re-query for this mark only, no teardown.
@@ -19,7 +20,7 @@
 import { untrack } from 'svelte';
 import { Query, isNode, isAggregateExpression, isColumnRef, isColumnParam, sql, column as sqlColumn, cast, min, max, isNotNull, and } from '@uwdata/mosaic-sql';
 import { TransformCompiler } from '../../../transforms/TransformCompiler';
-import { withDenseCategories, withRanking } from '../../../transforms';
+import { withDenseCategories, withoutOtherMembers, withRanking } from '../../../transforms';
 import { ArrowDataAccessor } from '../../../data/DataAccessor';
 import { MarkHandle } from '../../../query-engine/MarkHandle.svelte';
 import { isContinuousScale, isNumericScale } from '../../../scales/scale-categories';
@@ -28,6 +29,7 @@ import { isBinExpression } from '../../../sql/bin';
 import { isRollingAvgExpression } from '../../../sql/rolling-avg';
 import { isWindowExpression } from '../../../sql/expression-utils';
 import { identityKeyFor } from '../../../query-engine/identity-key';
+import { activityReads, groupIndexForResponse, NO_READS, readsFor, readsForResponse, rendererForMark } from '../../rendering/activity-reads';
 import { AdaptiveBinRung } from '../../../lod/AdaptiveBinRung.svelte';
 /** A SQL identifier, quoted, with any double quote in it doubled. */
 function ident(name) {
@@ -39,6 +41,8 @@ import { detectChannelsNeedingDataDomain } from './domain-computation';
 import { buildQueryParts, assembleQuery, castReal } from './query-builder';
 import { setScalesReady, markDeferredScalesReady, setInitialContinuousDomains, registerDataDerivedDomains } from './domain-registration';
 import { fetchCategoricalDomains, fetchGlobalAggregates } from './domain-queries';
+import { transformScaleKey } from './transform-scale-key';
+import { OtherRows } from './other-rows.svelte';
 // ---------------------------------------------------------------------------
 // MarkLifecycleV2
 // ---------------------------------------------------------------------------
@@ -182,8 +186,68 @@ export class MarkLifecycleV2 {
         this.#inlineIdentityColumns(resolvedSelect);
         this.#inlineTimeOffsets(resolvedSelect);
         const parts = buildQueryParts(resolvedSelect, this.#config._orderConfig ?? null, this.#transformCompiler.hasSQLTransforms(), passthroughChannels);
+        const nullDrops = this.#nullDrops(semanticSelect, resolvedSelect);
+        if (nullDrops.length > 0)
+            parts.nullDrops = nullDrops;
         return parts;
     });
+    /**
+     * The mark's categorical channels, each with the source expression it draws:
+     * a band or point axis, an ordinal colour, a separate series, and the facet
+     * (`__facet`, from the chart's fx). What `nulls="drop"` filters.
+     */
+    #categoricalChannels(select) {
+        const out = [];
+        const categorical = (type) => type === 'band' || type === 'point';
+        if (categorical(this.actualXScaleType))
+            out.push(['x', select.x]);
+        if (categorical(this.actualYScaleType))
+            out.push(['y', select.y]);
+        const colorChannel = this.#config.colorChannel || 'fill';
+        if (this.#colorScaleState?.isOrdinal)
+            out.push([colorChannel, select[colorChannel]]);
+        const seriesChannel = this.#config._orderConfig?.seriesChannel ?? null;
+        if (seriesChannel && seriesChannel !== colorChannel) {
+            out.push([seriesChannel, select[seriesChannel]]);
+        }
+        if (this.#chartContext.fx)
+            out.push(['__facet', this.#chartContext.fx]);
+        // Only row-level values: an aggregate has no NULL category to drop.
+        return out.filter(([, source]) => source != null &&
+            typeof source !== 'number' &&
+            !(isNode(source) && isAggregateExpression(source)));
+    }
+    /**
+     * `nulls="drop"`, by channel (see QueryParts.nullDrops). A channel the query
+     * selects as its dim's id column drops the NULL category's id; one still
+     * carrying its raw value (identity not landed yet) drops SQL NULL. Read off
+     * the select itself, so the two cannot disagree: inlining an id column is
+     * what changes the channel's expression.
+     */
+    #nullDrops(semantic, resolved) {
+        if (this.#reactiveConfig.nulls !== 'drop')
+            return [];
+        const drops = [];
+        for (const [channel, source] of this.#categoricalChannels(semantic)) {
+            const encoded = channel === '__facet' ? '__facet' in resolved : resolved[channel] !== source;
+            if (channel === '__facet' && !encoded)
+                continue;
+            const key = encoded ? identityKeyFor(source)?.key : null;
+            const nullId = key ? this.#queryEngine.identityFor(key).nullId : null;
+            drops.push({ channel, nullId });
+        }
+        return drops;
+    }
+    /**
+     * `nulls="drop"` for a query over the RAW select (no id columns, no
+     * `__facet`): `<source> IS NOT NULL` per categorical channel, the facet's
+     * on the chart's fx. Passed as that query's filter.
+     */
+    #rawNullFilters(select) {
+        if (this.#reactiveConfig.nulls !== 'drop')
+            return [];
+        return this.#categoricalChannels(select).map(([, source]) => isNotNull((typeof source === 'string' ? sqlColumn(source) : source)));
+    }
     // --- Domain State ---
     #channelsNeedingDataDomain = new Set();
     #dataDerivedDomainsSet = $state(false);
@@ -254,6 +318,25 @@ export class MarkLifecycleV2 {
         // than rebuilding. With no sort it passes the query through.
         this.#transformCompiler = new TransformCompiler(withRanking(withDenseCategories(config.transforms || [], config.dense !== false), () => this.#rankingSort), this.#transformConfig);
         this.#detectAutoBins();
+        this.otherRows = new OtherRows({
+            queryEngine,
+            filterGroup,
+            markId,
+            table: () => this.#handle?.arrowTable ?? null,
+            dataVersion: () => this.dataVersion,
+            identity: () => this.#identity,
+            identityKey: (axis) => this.#identityKey(axis)?.key ?? null,
+            filtered: () => this.#reactiveConfig.selectionResponse === 'filter',
+            plan: () => this.#splitPlan,
+            colorKey: () => {
+                const color = this.#colorScaleState;
+                return color?.isOrdinal ? color.identityKey : null;
+            },
+            bandScaleKey: (axis) => {
+                const band = (axis === 'x' ? this.#chartContext.xScaleState : this.#chartContext.yScaleState);
+                return band?.identityKey ?? null;
+            }
+        });
         // AdaptiveBinRung for binned marks (watches viewport domain, triggers rebin)
         if (this.#autoBinNodes.size > 0 && options?.gpuCoordinator) {
             const binAxes = [...this.#autoBinNodes.keys()].map((ch) => (ch.startsWith('x') ? 'x' : 'y'));
@@ -338,6 +421,11 @@ export class MarkLifecycleV2 {
         if (this.#destroyed)
             return;
         this.#identityFields.clear();
+        // The Other ids name rows of the dropped dims. Every holder lets go, so
+        // the scale acquires afresh when setup re-runs; so do the registered rows.
+        this.otherRows.unregister();
+        for (const scale of [...this.#otherScales])
+            this.#releaseOther(scale);
         // Every dim it names just went away — topN must not bucket into one.
         this.#setIdentity(null);
         this.setupComplete = false;
@@ -359,8 +447,12 @@ export class MarkLifecycleV2 {
             let config = scaleRequirements.x.config || {};
             if (scaleRequirements.x.type === 'band' && hasCatReducing) {
                 const key = this.#transformCompiler.getCategoryTransformKey();
-                if (key)
-                    config = { ...config, transformKey: `${table}:${key}` };
+                if (key) {
+                    config = {
+                        ...config,
+                        transformKey: transformScaleKey(table, key, this.#chartContext.config)
+                    };
+                }
             }
             this.#chartContext.registerScaleType('x', scaleRequirements.x.type, scaleRequirements.x.priority, this.#markId, config, inferredScaleColumns?.x);
         }
@@ -368,8 +460,12 @@ export class MarkLifecycleV2 {
             let config = scaleRequirements.y.config || {};
             if (scaleRequirements.y.type === 'band' && hasCatReducing) {
                 const key = this.#transformCompiler.getCategoryTransformKey();
-                if (key)
-                    config = { ...config, transformKey: `${table}:${key}` };
+                if (key) {
+                    config = {
+                        ...config,
+                        transformKey: transformScaleKey(table, key, this.#chartContext.config)
+                    };
+                }
             }
             this.#chartContext.registerScaleType('y', scaleRequirements.y.type, scaleRequirements.y.priority, this.#markId, config, inferredScaleColumns?.y);
         }
@@ -421,7 +517,14 @@ export class MarkLifecycleV2 {
             const schema = this.#schema;
             if (!schema)
                 return;
+            // Read after setup, once the scales have adopted identity. A change of
+            // reads or of selectionResponse re-registers the mark: a selection
+            // that dimmed it may now filter it. The key is a string, so reads
+            // rebuilt with the same contents do not.
+            void this.#readsKey;
+            const response = this.#reactiveConfig.selectionResponse;
             untrack(() => {
+                this.#route = { reads: this.#reads, chart: this.#chartContext.config, response };
                 // registerMark handles cleanup of previous registration for this
                 // markId and reuses the existing handle (preserves arrowTable
                 // during re-query so the chart doesn't flash empty on rebin).
@@ -430,7 +533,8 @@ export class MarkLifecycleV2 {
                     baseTable: this.#config.table,
                     parts,
                     schema,
-                    transformCompiler: this.#transformCompiler
+                    transformCompiler: this.#transformCompiler,
+                    route: this.#route
                 }, this.#filterGroup);
             });
         });
@@ -468,14 +572,35 @@ export class MarkLifecycleV2 {
                 return;
             untrack(() => {
                 this.#handleDataDomains(dv);
+                this.otherRows.register();
             });
         });
-        // Tooltip: write tooltip table when data updates (debounced).
+        // Tooltip: two effects, so a data update does not take the table away.
+        //
+        // This one owns the table's lifetime: it drops it when tooltips go from
+        // wanted to not. It used to be one effect with the write below, and its
+        // cleanup then ran on every data update too: the table was dropped and
+        // marked not ready, the mark's tooltip unregistered, and the hovered row
+        // went with it. A click right after a data update found no row under the
+        // pointer, read as a click on empty space and cleared the selection, and
+        // the next click did nothing until the pointer moved.
         $effect(() => {
             const tooltipConfig = this.#reactiveConfig.tooltip;
             const fitDomain = this.#reactiveConfig.fitDomain;
-            const tooltipWanted = tooltipConfig !== false || !!fitDomain;
-            if (!tooltipWanted)
+            if (tooltipConfig === false && !fitDomain)
+                return;
+            return () => {
+                clearTimeout(this.#tooltipWriteTimeout);
+                this.#tooltipTableReady = false;
+                this.#queryEngine.exec(`DROP TABLE IF EXISTS "${this.#tooltipTableName}"`).catch(() => { });
+            };
+        });
+        // And this one rewrites it when data updates (debounced). The old table
+        // stays readable until the rewrite replaces it.
+        $effect(() => {
+            const tooltipConfig = this.#reactiveConfig.tooltip;
+            const fitDomain = this.#reactiveConfig.fitDomain;
+            if (tooltipConfig === false && !fitDomain)
                 return;
             const dataVersion = this.dataVersion;
             if (dataVersion === 0)
@@ -488,12 +613,7 @@ export class MarkLifecycleV2 {
                         this.#writeTooltipTable(data);
                 }, 300);
             });
-            // Cleanup: when tooltip goes true→false, drop the temp table.
-            return () => {
-                clearTimeout(this.#tooltipWriteTimeout);
-                this.#tooltipTableReady = false;
-                this.#queryEngine.exec(`DROP TABLE IF EXISTS "${this.#tooltipTableName}"`).catch(() => { });
-            };
+            return () => clearTimeout(this.#tooltipWriteTimeout);
         });
         // fitDomain — query DuckDB for fitted axis extent on driving axis change.
         $effect(() => {
@@ -589,7 +709,7 @@ export class MarkLifecycleV2 {
             const [schemaColumns, fetchCount, aggResult, fieldStats] = await Promise.all([
                 // Fetch table schema (cached on QueryEngine, needed for CAST type decisions)
                 this.#queryEngine.describe(this.#config.table),
-                fetchCategoricalDomains(this.#queryEngine, this.#config.table, this.#config.select, this.actualXScaleType, this.actualYScaleType, this.#chartContext.xScaleState, this.#chartContext.yScaleState, this.#chartContext.facetBandScale, this.#chartContext.fx, this.#config.colorChannel || 'fill', this.#colorScaleState, this.#config.sizeChannel || 'r', this.#sizeScaleState, this.#seriesScaleState, seriesKey, this.#bandDomainFromData, this.#markId, this.#reactiveConfig.domain),
+                fetchCategoricalDomains(this.#queryEngine, this.#config.table, this.#config.select, this.actualXScaleType, this.actualYScaleType, this.#bandScaleForDomain('x'), this.#bandScaleForDomain('y'), this.#chartContext.facetBandScale, this.#chartContext.fx, this.#config.colorChannel || 'fill', this.#colorScaleState, this.#config.sizeChannel || 'r', this.#sizeScaleState, this.#seriesScaleState, seriesKey, this.#bandDomainFromData, this.#markId, this.#reactiveConfig.domain, this.#reactiveConfig.nulls === 'drop'),
                 fetchGlobalAggregates(this.#queryEngine, this.#config.table, this.#config.select, this.#channelsNeedingDataDomain, this.#autoBinNodes.size, this.#buildQueryForAggregates.bind(this), this.#config, this.#chartContext.xScaleState, this.#chartContext.yScaleState, this.#colorScaleState, this.#markId),
                 this.#fetchFieldStats(),
                 this.#ensureIdentityColumns()
@@ -849,7 +969,7 @@ export class MarkLifecycleV2 {
             const additionalChannels = this.#transformCompiler.getAdditionalChannels();
             const xState = this.#chartContext.xScaleState;
             const yState = this.#chartContext.yScaleState;
-            const domainResult = registerDataDerivedDomains(data, this.#channelsNeedingDataDomain, additionalChannels, this.#skipDomainUpdateForAxis, this.#config.zeroBaseline, this.actualXScaleType, this.actualYScaleType, xState, yState, this.#bandDomainFromData, this.#chartContext.xScaleState, this.#chartContext.yScaleState, this.#markId, false, // isRebinning
+            const domainResult = registerDataDerivedDomains(data, this.#channelsNeedingDataDomain, additionalChannels, this.#skipDomainUpdateForAxis, this.#config.zeroBaseline, this.actualXScaleType, this.actualYScaleType, xState, yState, this.#bandDomainFromData, this.#bandScaleForDomain('x'), this.#bandScaleForDomain('y'), this.#markId, false, // isRebinning
             this.#colorScaleState);
             this.#dataDerivedDomainsSet = domainResult.dataDerivedDomainsSet;
             this.#skipDomainUpdateForAxis = domainResult.skipDomainUpdateForAxis;
@@ -983,10 +1103,16 @@ export class MarkLifecycleV2 {
         // one id, which does not move a row limit that coarse.
         const identity = {};
         const describe = (channel, key, positional) => {
+            const present = this.#queryEngine.presentTableFor(key, this.#config.table);
+            // nulls="drop": its rows are filtered out, and dense() must not pad a
+            // zero row for it either, or a sorted axis keeps a "(null)" slot.
+            const nullId = this.#reactiveConfig.nulls === 'drop' ? this.#queryEngine.identityFor(key).nullId : null;
             identity[channel] = {
                 dim: this.#queryEngine.dimTableFor(key),
                 size: this.#queryEngine.identityFor(key).values.length,
-                positional
+                positional,
+                ...(present ? { present } : {}),
+                ...(nullId !== null ? { dropNullId: nullId } : {})
             };
         };
         for (const { axis, key } of axes)
@@ -1057,26 +1183,33 @@ export class MarkLifecycleV2 {
         // be reserved before a transform can write it. Reserved for every
         // categorical field of this mark rather than guessing which axis topN
         // will pick — at most two, and the transform looks its own field up.
+        const otherScales = new Set();
         if (this.#transformCompiler.hasSyntheticOtherBucket()) {
             const otherIds = {};
             for (const { axis, key } of axes) {
-                const id = await this.#queryEngine.reserveSyntheticIdentity(key, 'Other');
-                otherIds[axis] = id;
-                // Re-adopt: the reservation appended to the value array, and a scale
-                // that adopted before it must see the new entry.
                 const scale = (axis === 'x' ? this.#chartContext.xScaleState : this.#chartContext.yScaleState);
-                scale?.setIdentity(this.#queryEngine.identityFor(key));
-                // And tell it WHICH id is the bucket, so an entrance can come out of
-                // Other and an exit can go into it rather than past the end of the
-                // axis. With an Other bucket that is where the value actually goes.
+                // Always there by now: `axes` holds only axes whose resolved type is
+                // band or point, and ChartScales resolves the scale instance eagerly
+                // from registerScaleType, in this mark's constructor, so the scale
+                // exists before setup runs. The guard is for the type, not a case.
+                if (!scale)
+                    continue;
+                // One Other per band scale, shared by every mark on it (see
+                // retainOther). The scale also takes it as its Other id, so an
+                // entrance can come out of Other and an exit go into it rather than
+                // past the end of the axis.
                 //
-                // Set on EVERY categorical axis, like the reservation above, rather
-                // than re-deriving which axis topN picked — that derivation living
-                // in two places is what silently dropped the Other row once already.
-                // The axes topN did not pick are unaffected: their reserved id is on
-                // no row, so it is never displayed, and setOtherId documents why an
-                // undisplayed id cannot act as a gateway.
-                scale?.setOtherId(id);
+                // Held on EVERY categorical axis rather than re-deriving which axis
+                // topN picked — that derivation living in two places is what silently
+                // dropped the Other row once already. The axes topN did not pick are
+                // unaffected: their id is on no row, so it is never displayed.
+                otherScales.add(scale);
+                this.#otherScales.add(scale);
+                const other = await scale.retainOther(this.#markId, () => this.#queryEngine.acquireSyntheticIdentity(key, 'Other'));
+                otherIds[axis] = other.id;
+                // Re-adopt: acquiring may have appended to the value array, and a
+                // scale that adopted before it must see the new entry.
+                scale.setIdentity(this.#queryEngine.identityFor(key));
             }
             // topN buckets past its cutoff into these ids. The query parts rebuild:
             // anything assembled before the reservation had no id and left Other
@@ -1097,6 +1230,79 @@ export class MarkLifecycleV2 {
                 this.#setIdentity(withOther);
             }
         }
+        // Scales this mark no longer draws an Other on (its axis or transform
+        // changed) get their claim back.
+        for (const scale of this.#otherScales) {
+            if (!otherScales.has(scale))
+                this.#releaseOther(scale);
+        }
+    }
+    #warnedFollow = false;
+    /**
+     * Whether this mark follows its band axes instead of adding its categories to
+     * them (`contributeDomain={false}`). It cannot also choose its own categories
+     * or their order: a topN or a ranking would be what a follower exists not to
+     * do, and an explicit domain is a contribution. Such a mark is refused, once,
+     * and contributes as usual.
+     */
+    get #followsDomain() {
+        if (this.#reactiveConfig.contributeDomain !== false)
+            return false;
+        const reason = this.#transformCompiler.hasCategoryReducingTransforms()
+            ? 'a category-reducing transform (topN)'
+            : this.#rankingSort
+                ? 'a sort'
+                : this.#reactiveConfig.domain
+                    ? 'an explicit domain'
+                    : null;
+        if (!reason)
+            return true;
+        if (!this.#warnedFollow) {
+            this.#warnedFollow = true;
+            console.error(`[${this.#markId}] Unsupported: contributeDomain={false} with ${reason}. A mark that ` +
+                `follows its band axis cannot choose its own categories or their order. It will ` +
+                `contribute to the domain as usual.`);
+        }
+        return false;
+    }
+    /**
+     * The band scale of an axis, for registering this mark's categories on it:
+     * null for a mark that follows, so it registers nothing and withdraws what it
+     * had (the prop can change). The scale still draws the mark's rows, only those
+     * of categories it shows.
+     */
+    #bandScaleForDomain(axis) {
+        const scale = (axis === 'x' ? this.#chartContext.xScaleState : this.#chartContext.yScaleState);
+        // Only a band or point axis has categories to follow; a value axis is
+        // the mark's own.
+        const type = axis === 'x' ? this.actualXScaleType : this.actualYScaleType;
+        if ((type !== 'band' && type !== 'point') || !this.#followsDomain)
+            return scale;
+        scale?.removeMark(this.#markId);
+        return null;
+    }
+    /** What this mark's Other rows hold, and what is done with it. */
+    otherRows;
+    /** What the mark is, for whether its Other bar splits; null before setup completes. */
+    get #splitPlan() {
+        if (!this.setupComplete)
+            return null;
+        const markType = this.#transformConfig.markType;
+        const length = markType === 'barx' ? this.#transformConfig.x : this.#transformConfig.y;
+        return {
+            markType,
+            length,
+            by: this.#transformCompiler.otherBy(),
+            expr: length ? this.#config.select[length] : undefined,
+            hasOther: this.#transformCompiler.hasSyntheticOtherBucket(),
+            hasJsTransforms: this.#transformCompiler.jsTransforms.length > 0
+        };
+    }
+    /** The band scales whose Other bucket this mark holds a claim on. */
+    #otherScales = new Set();
+    #releaseOther(scale) {
+        this.#otherScales.delete(scale);
+        scale.releaseOther(this.#markId, (other) => this.#queryEngine.releaseSyntheticIdentity(other));
     }
     /**
      * The one writer of identity: the reactive copy the query parts read, and
@@ -1151,10 +1357,12 @@ export class MarkLifecycleV2 {
         // Build raw query parts directly from config.select (no identity columns,
         // no bin resolution — scale states aren't ready yet during Phase 1).
         const parts = buildQueryParts(this.#config.select, this.#config._orderConfig ?? null, this.#transformCompiler.hasSQLTransforms());
+        // Domains from the rows the mark draws: without what nulls="drop" leaves
+        // out. This select is raw, so the filter is on the raw values.
         const q = assembleQuery({
             table: this.#config.table,
             parts,
-            filter,
+            filter: [...filter, ...this.#rawNullFilters(this.#config.select)],
             transformCompiler: this.#transformCompiler
         });
         if (!q)
@@ -1173,7 +1381,7 @@ export class MarkLifecycleV2 {
     buildViewportCountQuery(xLo, xHi, yLo, yHi) {
         if (!this.setupComplete || !this.#resolvedQueryParts)
             return null;
-        const filter = this.#filterGroup.selection.predicate(this.#markId) ?? [];
+        const filter = this.#filterGroup.selection.predicate(this.#route) ?? [];
         const q = assembleQuery({
             table: this.#sourceTable,
             parts: this.#resolvedQueryParts,
@@ -1210,6 +1418,43 @@ export class MarkLifecycleV2 {
     get channelFieldMap() {
         return buildChannelFieldMap(this.#config.select);
     }
+    // --- Selection routing ---
+    /**
+     * The identity keys of the categorical fields this mark's renderer reads
+     * selection activity for, sorted: its ordinal colour and its band axes, as
+     * activity-reads.ts says the renderer reads them. A categorical selection on
+     * one of these dims the mark; on any other field it filters it.
+     */
+    #reads = $derived.by(() => {
+        const renderer = rendererForMark(this.#config.markType);
+        if (!renderer)
+            return NO_READS;
+        const color = this.#colorScaleState;
+        const bandKey = (axis) => {
+            const type = axis === 'x' ? this.actualXScaleType : this.actualYScaleType;
+            if (type !== 'band' && type !== 'point')
+                return null;
+            const band = this.#chartContext[`${axis}ScaleState`];
+            return band?.identityKey ?? null;
+        };
+        return readsForResponse(this.#reactiveConfig.selectionResponse, readsFor(activityReads(renderer, this.#config.ruleExtent ?? false), {
+            color: color?.isOrdinal ? color.identityKey : null,
+            x: bandKey('x'),
+            y: bandKey('y')
+        }));
+    });
+    /** `#reads` as one string, so the registration effect re-runs only on a real change. */
+    #readsKey = $derived(this.#reads.join('\u001f'));
+    /** Built at registration; the engine and every predicate call hold this object. */
+    #route = { reads: NO_READS, chart: null };
+    /**
+     * The page-wide index of this mark's filter group. Its renderer stores it in
+     * MarkConstants to read its group's run of each field's activity block.
+     */
+    get groupIndex() {
+        // NO_GROUP for selectionResponse 'filter', which never dims.
+        return groupIndexForResponse(this.#reactiveConfig.selectionResponse, this.#filterGroup.index);
+    }
     get dataVersion() {
         return this.#handle?.dataVersion ?? 0;
     }
@@ -1409,10 +1654,14 @@ export class MarkLifecycleV2 {
                     if (orderCol)
                         orderClause = ` ORDER BY ${orderCol}`;
                 }
-                await this.#queryEngine.exec([
-                    `DROP TABLE IF EXISTS "${tableName}"`,
-                    `CREATE TEMP TABLE "${tableName}" AS SELECT *${replaceClause} FROM (${tooltipQuery})${orderClause}`
-                ]);
+                // Without Other's member lists: every hover query is `SELECT *` from
+                // this table, so lists of up to the field's cardinality would ship on
+                // each one. Only those, not every `__dplot_` column as Path B drops:
+                // the rest are scalars (the rank, id columns), cheap to keep, and the
+                // lists are the only ones whose size grows with the field.
+                const withoutMembers = withoutOtherMembers(tooltipQuery);
+                // One statement: a hover query never finds the table missing.
+                await this.#queryEngine.exec(`CREATE OR REPLACE TEMP TABLE "${tableName}" AS SELECT *${replaceClause} FROM (${withoutMembers})${orderClause}`);
             }
             else {
                 // Path B: Serialize transformed data via SQL VALUES.
@@ -1467,6 +1716,9 @@ export class MarkLifecycleV2 {
                 }
             }
             this.#tooltipTableReady = true;
+            // The row under a still pointer was read from the old table: read it
+            // again, so the tooltip and a click show the new data without a move.
+            this.#chartContext.tooltipManager?.refresh();
             this.#onTooltipTableWritten();
         }
         catch (error) {
@@ -1480,7 +1732,7 @@ export class MarkLifecycleV2 {
     #buildTooltipQuery() {
         if (!this.#resolvedQueryParts)
             return null;
-        const filter = this.#filterGroup.selection.predicate(this.#markId) ?? [];
+        const filter = this.#filterGroup.selection.predicate(this.#route) ?? [];
         const q = assembleQuery({
             table: this.#sourceTable,
             parts: this.#resolvedQueryParts,
@@ -1537,7 +1789,10 @@ export class MarkLifecycleV2 {
         }
         Object.assign(sidecarSelect, tipExtras);
         const sidecarParts = buildQueryParts(sidecarSelect, undefined, this.#transformCompiler.hasSQLTransforms());
-        const filter = this.#filterGroup.selection.predicate(this.#markId) ?? [];
+        // The same rows as the mark: it leaves out what the mark leaves out. Its
+        // select holds every non-aggregate channel, so each dropped one is there.
+        sidecarParts.nullDrops = this.#resolvedQueryParts.nullDrops;
+        const filter = this.#filterGroup.selection.predicate(this.#route) ?? [];
         const sidecarQuery = assembleQuery({
             table: this.#sourceTable,
             parts: sidecarParts,
@@ -1735,6 +1990,9 @@ export class MarkLifecycleV2 {
         this.#destroyed = true;
         this.#identityResetOff?.();
         this.#identityResetOff = null;
+        this.otherRows.unregister();
+        for (const scale of [...this.#otherScales])
+            this.#releaseOther(scale);
         this.#handle?.destroy();
         clearTimeout(this.#fitDomainTimeout);
         clearTimeout(this.#tooltipWriteTimeout);

package/dist/components/marks/lifecycle/domain-queries.d.ts

@@ -14,7 +14,9 @@ import type { ContinuousScaleState } from '../../../types';
 export declare function fetchCategoricalDomains(coordinator: QueryEngine, table: string, select: Record<string, unknown>, actualXScaleType: string, actualYScaleType: string, xScaleState: BandScaleState | null, yScaleState: BandScaleState | null, facetBandScale: BandScaleState | null | undefined, fx: unknown, colorChannel: string, colorScaleState: ColorScaleState | null, sizeChannel: string, sizeScaleState: SizeScaleState | null, seriesScaleState: ColorScaleState | null, seriesChannel: string | null, bandDomainFromData: boolean, markId: string, explicitDomain?: {
     x?: DimValue[];
     y?: DimValue[];
-} | null): Promise<number>;
+} | null, 
+/** nulls="drop": the band and facet domains leave out the NULL category. */
+dropNull?: boolean): Promise<number>;
 /**
  * Fetch global min/max extents for aggregated fields using a "sidecar" query.
  * Runs the same aggregation as the main query but without filters, wrapped

package/dist/components/marks/lifecycle/domain-queries.js

@@ -10,7 +10,13 @@ import { identityKeyFor } from '../../../query-engine/identity-key';
  *
  * Returns the number of fetches executed (for logging).
  */
-export async function fetchCategoricalDomains(coordinator, table, select, actualXScaleType, actualYScaleType, xScaleState, yScaleState, facetBandScale, fx, colorChannel, colorScaleState, sizeChannel, sizeScaleState, seriesScaleState, seriesChannel, bandDomainFromData, markId, explicitDomain) {
+export async function fetchCategoricalDomains(coordinator, table, select, actualXScaleType, actualYScaleType, xScaleState, yScaleState, facetBandScale, fx, colorChannel, colorScaleState, sizeChannel, sizeScaleState, seriesScaleState, seriesChannel, bandDomainFromData, markId, explicitDomain, 
+/** nulls="drop": the band and facet domains leave out the NULL category. */
+dropNull = false) {
+    const categoriesOf = (key) => {
+        const categories = coordinator.categoryValues(key, table);
+        return dropNull ? categories.filter((c) => c !== null) : categories;
+    };
     const fetches = [];
     const setupFetch = (axis, field, scaleState) => {
         if (!field || !scaleState)
@@ -42,10 +48,11 @@ export async function fetchCategoricalDomains(coordinator, table, select, actual
         //
         //  - Order. DISTINCT has no ORDER BY, so today's domain is whatever DuckDB
         //    returned, then "first-appearance order" in updateDomainFromExtents.
-        //    Arbitrary. Dim labels are ordered by id, so the domain is
-        //    deterministic — and position-in-domain now EQUALS the dim id, which
-        //    is the invariant that lets the query switch to the view's id column
-        //    without moving a single bar.
+        //    Arbitrary. Dim values are listed in id order, so the domain is
+        //    deterministic. It is the real categories only (`categoryValues`
+        //    leaves out Other buckets), so position-in-domain equals the dim id
+        //    only until a bucket's row: the scale encodes each value to its id
+        //    rather than relying on position.
         //  - Multi-table. The dim spans every table registering the field, so two
         //    marks on one shared scale agree on the category set by construction.
         //
@@ -63,10 +70,11 @@ export async function fetchCategoricalDomains(coordinator, table, select, actual
         fetches.push((async () => {
             // Idempotent and coalesced — the mark's own setup calls this too.
             await coordinator.ensureColumns(table, { categorical: [identityField] });
-            const categories = coordinator.identityValues(identityField.key);
-            // The scale adopts this same array in MarkLifecycleV2's
-            // #ensureIdentityColumns, which also covers the explicit-domain axes
-            // that never reach this branch.
+            // This table's categories: the dim spans every table on the field.
+            const categories = categoriesOf(identityField.key);
+            // A snapshot of the real categories. The scale adopts the live
+            // identity itself in MarkLifecycleV2's #ensureIdentityColumns, which
+            // also covers the explicit-domain axes that never reach this branch.
             if (categories.length > 0)
                 scaleState.addMark(categories, markId);
         })());
@@ -101,9 +109,8 @@ export async function fetchCategoricalDomains(coordinator, table, select, actual
             // Registered from the data.
         }
         else if (explicitDomain?.y && yScaleState) {
-            // Y band scale maps index 0 → bottom, so reverse the user's
-            // top-to-bottom array to match GPU rendering order.
-            deferredExplicitY = [...explicitDomain.y].reverse();
+            // Slot 0 is at the top of a y band axis, so the list is used as given.
+            deferredExplicitY = explicitDomain.y;
         }
         else {
             setupFetch('y', select.y, yScaleState);
@@ -121,7 +128,7 @@ export async function fetchCategoricalDomains(coordinator, table, select, actual
         fetches.push((async () => {
             // Idempotent and coalesced — the mark's own setup calls this too.
             await coordinator.ensureColumns(table, { categorical: [facetKey] });
-            const categories = coordinator.identityValues(facetKey.key);
+            const categories = categoriesOf(facetKey.key);
             if (categories.length > 0)
                 facetBandScale.addMark(categories, markId);
         })());
@@ -185,7 +192,7 @@ export async function fetchCategoricalDomains(coordinator, table, select, actual
                     fetches.push((async () => {
                         // Idempotent and coalesced — the mark's own setup calls this too.
                         await coordinator.ensureColumns(table, { categorical: [colorIdentity] });
-                        const categories = coordinator.identityValues(colorIdentity.key);
+                        const categories = coordinator.categoryValues(colorIdentity.key);
                         if (categories.length > 0) {
                             colorScaleState.setDomain(categories);
                         }
@@ -234,7 +241,7 @@ export async function fetchCategoricalDomains(coordinator, table, select, actual
         if (seriesIdentity) {
             fetches.push((async () => {
                 await coordinator.ensureColumns(table, { categorical: [seriesIdentity] });
-                const categories = coordinator.identityValues(seriesIdentity.key);
+                const categories = coordinator.categoryValues(seriesIdentity.key);
                 if (categories.length > 0) {
                     seriesScaleState.setDomain(categories);
                 }

package/dist/components/marks/lifecycle/domain-registration.js

@@ -193,12 +193,8 @@ export function registerDataDerivedDomains(data, channelsNeedingDataDomain, addi
                 // order the ranked query had. See RANK_COLUMN.
                 const ranked = data.getColumn(RANK_COLUMN) != null;
                 const ids = extractIdsRankedFromData(data, axis, RANK_COLUMN);
-                // A y band axis puts slot 0 at the bottom and a ranking is read
-                // from the top. Reversed here, once, for every ranked axis —
-                // topN's and the sort's alike — rather than by whichever transform
-                // produced the rank.
-                if (ranked && axis === 'y')
-                    ids.reverse();
+                // Used as ranked on both axes: slot 0 is at the left of x and the
+                // top of y, where a ranking is read from.
                 if (ids.length === 0)
                     continue;
                 // `sorted` says this list is a ranking the axis should prefer over