@fjader/svelte 0.2.1 → 0.2.3

package/dist/components/rendering/uniform-sizes.js

@@ -0,0 +1,28 @@
+/**
+ * The byte size of every renderer's uniform struct, as WGSL lays it out.
+ *
+ * Renderers allocate their uniform buffers from these, and BaseGPURenderer
+ * sizes its stand-in from the largest: a binding not yet written is bound to
+ * the stand-in, and WebGPU rejects a draw whose uniform buffer is smaller than
+ * the struct it declares, which loses every chart's frame in that submit. A
+ * comment saying "must fit the largest struct" went stale the first time a
+ * struct grew, so uniform-sizes.test.ts derives each size from the shader
+ * source and fails when one drifts.
+ */
+/** Axes a parallel coordinates chart can hold: its axis arrays are sized for it. */
+export const PARALLEL_MAX_AXES = 16;
+/** One ScaleParam: four f32. */
+const SCALE_PARAM_BYTES = 16;
+export const UNIFORM_BYTES = {
+    dotsMarkConstants: 48,
+    rectsMarkConstants: 48,
+    ruleXMarkConstants: 48,
+    ruleYMarkConstants: 48,
+    linesMarkConstants: 64,
+    areasMarkConstants: 64,
+    gridLineRuleConstants: 32,
+    parallelConfig: 176,
+    parallelAxisScales: PARALLEL_MAX_AXES * SCALE_PARAM_BYTES
+};
+/** The stand-in uniform buffer: as large as the largest struct any renderer binds. */
+export const UNIFORM_STAND_IN_BYTES = Math.max(...Object.values(UNIFORM_BYTES));

package/dist/config/ChartConfig.svelte.d.ts

@@ -1,3 +1,4 @@
+import type { SelectionResponse } from '../components/rendering/activity-reads';
 import type { FieldRef, LODConfig, SortConfig, ColorScheme, CurveType, Transform } from '../types';
 import type { MarkLODSurface } from '../lod/rung-types';
 export interface MarkEntry {
@@ -23,6 +24,7 @@ export interface MarkEntry {
     scheme?: ColorScheme;
     transforms?: Transform[];
     selection?: string;
+    selectionResponse?: SelectionResponse;
     limit?: number;
     preferredXScaleType?: string | null;
     preferredYScaleType?: string | null;

package/dist/data/DataAccessor.js

@@ -29,7 +29,7 @@ export class ArrowDataAccessor {
         // FAST PATH: Single chunk numeric - try to return underlying buffer directly.
         // NULL handling: Query-level COALESCE(CAST(expr AS REAL), 'NaN'::REAL)
         // converts SQL NULLs to the NaN float value, so Arrow columns from Fjader
-        // queries have nullCount=0 and clean buffers. GPU shaders detect NaN (v != v)
+        // queries have nullCount=0 and clean buffers. GPU shaders detect NaN by its bit pattern (NanShaderLib)
         // and discard those vertices to create gaps in lines/areas.
         if (!isStringType && col.data.length === 1) {
             const chunk = col.data[0];

package/dist/gpu/ColorScaleShaderLib.d.ts

@@ -15,6 +15,18 @@ export declare const COLOR_CONFIG_BYTES = 48;
 export declare const COLOR_CONFIG_SLOT_BASE_OFFSET = 32;
 /** `slotBase` meaning "this channel already carries a palette index". */
 export declare const NO_SLOT_TABLE = 4294967295;
+/**
+ * The rank of a category an ordinal colour scale draws in the null colour: it
+ * takes no palette slot, so it reads as missing data and shifts no category's
+ * colour. The NULL category and the Other buckets. -1, by contrast, is a category
+ * outside this scale's domain, which draws transparent.
+ */
+export declare const NULL_COLOR_RANK = -2;
+/**
+ * How many colour configs the buffer holds. A uniform array has a fixed length
+ * in WGSL, so the shader declaration and the buffer size both read this.
+ */
+export declare const MAX_COLOR_SLOTS = 64;
 export declare const COLOR_SCALE_STRUCTS = "\nstruct ColorConfig {\n    domainMin: f32,         // byte 0  \u2014 pre-transformed for non-linear types\n    domainMax: f32,         // byte 4  \u2014 pre-transformed for non-linear types\n    rampOffset: u32,        // byte 8\n    paletteOffset: u32,     // byte 12\n    paletteSize: u32,       // byte 16\n    scaleType: u32,         // byte 20 \u2014 scheme rendering type (ordinal/sequential/diverging/cyclical)\n    transformType: u32,     // byte 24 \u2014 normalization transform (linear/log/symlog/sqrt/pow)\n    transformParam: f32,    // byte 28 \u2014 symlog constant C, or pow exponent\n    slotBase: u32,          // byte 32 \u2014 base into identitySlots, or NO_SLOT_TABLE\n    _pad0: u32,             // byte 36\n    _pad1: u32,             // byte 40\n    _pad2: u32,             // byte 44\n}\n\n/**\n * slotBase when this scale's channel already carries a palette index rather\n * than an identity id. Distinct from base 0, which is a real block \u2014 the\n * permanently empty one \u2014 so it cannot be confused with \"not placed\".\n */\nconst NO_SLOT_TABLE: u32 = 0xFFFFFFFFu;\n\nconst COLOR_SCALE_ORDINAL: u32 = 0u;\nconst COLOR_SCALE_SEQUENTIAL: u32 = 1u;\nconst COLOR_SCALE_DIVERGING: u32 = 2u;\nconst COLOR_SCALE_CYCLICAL: u32 = 3u;\n\nconst COLOR_TRANSFORM_LINEAR: u32 = 0u;\nconst COLOR_TRANSFORM_LOG: u32 = 1u;\nconst COLOR_TRANSFORM_SYMLOG: u32 = 2u;\nconst COLOR_TRANSFORM_SQRT: u32 = 3u;\nconst COLOR_TRANSFORM_POW: u32 = 4u;\n";
-export declare const COLOR_SCALE_BINDINGS = "\n@group(2) @binding(1) var<storage, read> colorConfigs: array<ColorConfig>;\n@group(2) @binding(2) var<storage, read> colorRamps: array<vec4<f32>>;\n@group(2) @binding(3) var<storage, read> ordinalPalettes: array<vec4<f32>>;\n";
-export declare const COLOR_SCALE_FUNCTIONS = "\nfn applyColorTransform(config: ColorConfig, value: f32) -> f32 {\n    switch config.transformType {\n        case COLOR_TRANSFORM_LOG: {\n            return log(max(value, 1e-38));\n        }\n        case COLOR_TRANSFORM_SYMLOG: {\n            let c = config.transformParam;\n            return sign(value) * log(1.0 + abs(value / c));\n        }\n        case COLOR_TRANSFORM_SQRT: {\n            return sign(value) * sqrt(abs(value));\n        }\n        case COLOR_TRANSFORM_POW: {\n            return sign(value) * pow(abs(value), config.transformParam);\n        }\n        default: {\n            return value;\n        }\n    }\n}\n\nfn normalizeValue(config: ColorConfig, value: f32) -> f32 {\n    let transformed = applyColorTransform(config, value);\n\n    let range = config.domainMax - config.domainMin;\n\n    if (abs(range) < 0.0001) {\n        return 0.5;\n    }\n\n    let t_raw = (transformed - config.domainMin) / range;\n\n    if (config.scaleType == COLOR_SCALE_CYCLICAL) {\n        return fract(t_raw);\n    }\n\n    return clamp(t_raw, 0.0, 1.0);\n}\n\nfn sampleRamp(config: ColorConfig, t: f32) -> vec4<f32> {\n    let idx = min(u32(t * 255.0), 255u); // Must match COLOR_RAMP_RESOLUTION (256 stops)\n    return colorRamps[config.rampOffset + idx];\n}\n\nfn samplePalette(config: ColorConfig, categoryIndex: u32) -> vec4<f32> {\n    // The channel carries an identity id, which is stable and has nothing to do\n    // with this scale's palette. Resolve it to this scale's own rank first; the\n    // palette is indexed by rank, so the plotted categories take palette colours\n    // in order and the wrap below is over the PLOTTED count, not the dim's.\n    var idx = categoryIndex;\n    if (config.slotBase != NO_SLOT_TABLE) {\n        let slot = identitySlot(config.slotBase, categoryIndex);\n        if (slot < 0.0) {\n            // Not ranked by this scale: a category outside its domain.\n            return vec4<f32>(0.0, 0.0, 0.0, 0.0);\n        }\n        idx = u32(slot);\n    }\n    return ordinalPalettes[config.paletteOffset + (idx % config.paletteSize)];\n}\n\nfn getColorFromScale(scaleIndex: u32, value: f32, nullColor: vec4<f32>) -> vec4<f32> {\n    let config = colorConfigs[scaleIndex];\n\n    if (config.scaleType == COLOR_SCALE_ORDINAL) {\n        // 0-based indexing: -1 = null, 0+ = valid categories\n        if (value < 0.0) {\n            return nullColor;\n        }\n        let catIdx = u32(value);\n        return samplePalette(config, catIdx);\n    }\n\n    if (value != value) {\n        return nullColor;\n    }\n\n    // Log requires strictly positive values \u2014 treat \u22640 as unmappable\n    if (config.transformType == COLOR_TRANSFORM_LOG && value <= 0.0) {\n        return nullColor;\n    }\n\n    let t = normalizeValue(config, value);\n    return sampleRamp(config, t);\n}\n\nfn getOrdinalColor(scaleIndex: u32, categoryIndex: u32, nullColor: vec4<f32>) -> vec4<f32> {\n    // Note: This function expects u32, so caller must handle -1 check before casting\n    let config = colorConfigs[scaleIndex];\n    return samplePalette(config, categoryIndex);\n}\n\nfn getContinuousColor(scaleIndex: u32, value: f32, nullColor: vec4<f32>) -> vec4<f32> {\n    if (value != value) {\n        return nullColor;\n    }\n    let config = colorConfigs[scaleIndex];\n    if (config.transformType == COLOR_TRANSFORM_LOG && value <= 0.0) {\n        return nullColor;\n    }\n    let t = normalizeValue(config, value);\n    return sampleRamp(config, t);\n}\n";
+export declare const COLOR_SCALE_BINDINGS = "\n@group(2) @binding(1) var<uniform> colorConfigs: array<ColorConfig, 64>;\n@group(2) @binding(2) var<storage, read> colorRamps: array<vec4<f32>>;\n@group(2) @binding(3) var<storage, read> ordinalPalettes: array<vec4<f32>>;\n";
+export declare const COLOR_SCALE_FUNCTIONS: string;

package/dist/gpu/ColorScaleShaderLib.js

@@ -1,3 +1,4 @@
+import { isNanExpr } from './NanShaderLib';
 // src/lib/gpu/ColorScaleShaderLib.ts
 // ---------------------------------------------------------------------------
 // Design note: branching vs JIT-compiled shaders for color normalization
@@ -35,6 +36,18 @@ export const COLOR_CONFIG_BYTES = 48;
 export const COLOR_CONFIG_SLOT_BASE_OFFSET = 32;
 /** `slotBase` meaning "this channel already carries a palette index". */
 export const NO_SLOT_TABLE = 0xffffffff;
+/**
+ * The rank of a category an ordinal colour scale draws in the null colour: it
+ * takes no palette slot, so it reads as missing data and shifts no category's
+ * colour. The NULL category and the Other buckets. -1, by contrast, is a category
+ * outside this scale's domain, which draws transparent.
+ */
+export const NULL_COLOR_RANK = -2;
+/**
+ * How many colour configs the buffer holds. A uniform array has a fixed length
+ * in WGSL, so the shader declaration and the buffer size both read this.
+ */
+export const MAX_COLOR_SLOTS = 64;
 export const COLOR_SCALE_STRUCTS = /* wgsl */ `
 struct ColorConfig {
     domainMin: f32,         // byte 0  — pre-transformed for non-linear types
@@ -69,8 +82,14 @@ const COLOR_TRANSFORM_SYMLOG: u32 = 2u;
 const COLOR_TRANSFORM_SQRT: u32 = 3u;
 const COLOR_TRANSFORM_POW: u32 = 4u;
 `;
+// colorConfigs is a UNIFORM, visible to the vertex stage as well: selection
+// dimming reads a colour scale's slotBase per vertex. As storage it would take
+// the last of the vertex stage's default 8 storage buffers on Rects, which uses
+// 7 (six channels and the identity slot table); as a uniform it leaves that
+// slot free. 64 × 48 bytes is 3 KB, written when a scale changes, which is what
+// uniform buffers are for.
 export const COLOR_SCALE_BINDINGS = /* wgsl */ `
-@group(2) @binding(1) var<storage, read> colorConfigs: array<ColorConfig>;
+@group(2) @binding(1) var<uniform> colorConfigs: array<ColorConfig, ${MAX_COLOR_SLOTS}>;
 @group(2) @binding(2) var<storage, read> colorRamps: array<vec4<f32>>;
 @group(2) @binding(3) var<storage, read> ordinalPalettes: array<vec4<f32>>;
 `;
@@ -119,7 +138,7 @@ fn sampleRamp(config: ColorConfig, t: f32) -> vec4<f32> {
     return colorRamps[config.rampOffset + idx];
 }
 
-fn samplePalette(config: ColorConfig, categoryIndex: u32) -> vec4<f32> {
+fn samplePalette(config: ColorConfig, categoryIndex: u32, nullColor: vec4<f32>) -> vec4<f32> {
     // The channel carries an identity id, which is stable and has nothing to do
     // with this scale's palette. Resolve it to this scale's own rank first; the
     // palette is indexed by rank, so the plotted categories take palette colours
@@ -128,7 +147,12 @@ fn samplePalette(config: ColorConfig, categoryIndex: u32) -> vec4<f32> {
     if (config.slotBase != NO_SLOT_TABLE) {
         let slot = identitySlot(config.slotBase, categoryIndex);
         if (slot < 0.0) {
-            // Not ranked by this scale: a category outside its domain.
+            // ${NULL_COLOR_RANK}: a category drawn in the null colour, which takes no
+            // palette slot (the NULL category, an Other bucket).
+            if (slot < -1.5) {
+                return nullColor;
+            }
+            // -1: not ranked by this scale, a category outside its domain.
             return vec4<f32>(0.0, 0.0, 0.0, 0.0);
         }
         idx = u32(slot);
@@ -145,10 +169,10 @@ fn getColorFromScale(scaleIndex: u32, value: f32, nullColor: vec4<f32>) -> vec4<
             return nullColor;
         }
         let catIdx = u32(value);
-        return samplePalette(config, catIdx);
+        return samplePalette(config, catIdx, nullColor);
     }
 
-    if (value != value) {
+    if (${isNanExpr('value')}) {
         return nullColor;
     }
 
@@ -164,11 +188,11 @@ fn getColorFromScale(scaleIndex: u32, value: f32, nullColor: vec4<f32>) -> vec4<
 fn getOrdinalColor(scaleIndex: u32, categoryIndex: u32, nullColor: vec4<f32>) -> vec4<f32> {
     // Note: This function expects u32, so caller must handle -1 check before casting
     let config = colorConfigs[scaleIndex];
-    return samplePalette(config, categoryIndex);
+    return samplePalette(config, categoryIndex, nullColor);
 }
 
 fn getContinuousColor(scaleIndex: u32, value: f32, nullColor: vec4<f32>) -> vec4<f32> {
-    if (value != value) {
+    if (${isNanExpr('value')}) {
         return nullColor;
     }
     let config = colorConfigs[scaleIndex];
@@ -178,4 +202,32 @@ fn getContinuousColor(scaleIndex: u32, value: f32, nullColor: vec4<f32>) -> vec4
     let t = normalizeValue(config, value);
     return sampleRamp(config, t);
 }
+
+/**
+ * How selected this value's category is on an ordinal colour scale, 0..1.
+ *
+ * Read per vertex for selection dimming. 1.0 for anything that has no category
+ * to select: a continuous scale, an ordinal scale whose channel does not carry
+ * identity ids yet (NO_SLOT_TABLE), and a missing category. The -1 and NaN
+ * checks come before the cast, because u32() of a negative or NaN float is
+ * indeterminate in WGSL and would read an arbitrary activity.
+ */
+fn colorActivity(scaleIndex: u32, value: f32, group: u32) -> f32 {
+    if (value < 0.0 || ${isNanExpr('value')}) {
+        return 1.0;
+    }
+    let config = colorConfigs[scaleIndex];
+    if (config.scaleType != COLOR_SCALE_ORDINAL || config.slotBase == NO_SLOT_TABLE) {
+        return 1.0;
+    }
+    return identityActivity(config.slotBase, group, u32(value));
+}
+
+/** A mark's colour activity in its filter group: 1.0 unless it colours through a scale. */
+fn markColorActivity(colorMode: u32, colorScaleIndex: u32, colorValue: f32, group: u32) -> f32 {
+    if (colorMode != 1u) {
+        return 1.0;
+    }
+    return colorActivity(colorScaleIndex, colorValue, group);
+}
 `;

package/dist/gpu/GPUCoordinator.svelte.d.ts

@@ -1,5 +1,6 @@
 import type { RendererDefinition } from './ScaleTemplateSystem';
 import type { ScaleRegistry } from '../scales/ScaleRegistry.svelte';
+import type { FilterGroupRegistry } from '../query-engine/FilterGroupRegistry.svelte';
 /** Number of color stops per ramp slot. Shared with ColorScaleState for bakeGradient(). */
 export declare const COLOR_RAMP_RESOLUTION = 256;
 interface LayerConfig {
@@ -182,6 +183,13 @@ export declare class GPUCoordinator {
      */
     releaseRenderer(rendererId: string): void;
     setScaleRegistry(scaleRegistry: ScaleRegistry): void;
+    /**
+     * The page's filter groups, whose field activity the packer writes into the
+     * identity slot table. Their fades run on this loop and redraw the charts
+     * drawing any scale on their field. Set before any selection, so no fade is
+     * created without the loop.
+     */
+    setFilterGroups(filterGroups: FilterGroupRegistry): void;
     registerScale(scaleId: string, scaleType?: string): void;
     unregisterScale(scaleId: string): void;
     scheduleTopologyUpdate(): void;

package/dist/gpu/GPUCoordinator.svelte.js

@@ -7,7 +7,8 @@ import { RESOLVE_IMMEDIATE_SIZE, RESOLVE_WORKGROUP, resolvePipelineFor } from '.
 import { IDENTITY_SLOT_CAPACITY, IDENTITY_SLOT_EMPTY, createIdentitySlotState, packIdentitySlots } from './identity-slot-packing';
 import { frameUniformIsStale } from './frame-uniform-sync';
 import { immediatesSupported, IMMEDIATES_MISSING_MESSAGE } from './immediates';
-import { COLOR_CONFIG_BYTES, COLOR_CONFIG_SLOT_BASE_OFFSET } from './ColorScaleShaderLib';
+import { COLOR_CONFIG_BYTES, COLOR_CONFIG_SLOT_BASE_OFFSET, MAX_COLOR_SLOTS } from './ColorScaleShaderLib';
+import { trackScalesById } from './tracked-scales';
 /** Number of color stops per ramp slot. Shared with ColorScaleState for bakeGradient(). */
 export const COLOR_RAMP_RESOLUTION = 256;
 /**
@@ -18,6 +19,8 @@ export const COLOR_RAMP_RESOLUTION = 256;
 function layerCanDraw(layer, chartScalesKnown) {
     return (!!layer.renderer?.perDataBindGroup && (chartScalesKnown || layer.readsChartScales === false));
 }
+/** No fields to pack, for a coordinator without filter groups. */
+const NO_FIELDS = [];
 // =============================================================================
 // HELPER CLASSES
 // =============================================================================
@@ -113,6 +116,7 @@ export class GPUCoordinator {
     #animatedSources = new Set(); // Set for O(1) membership check
     #animatedSourcesArray = []; // Array for O(1) iteration (no allocation)
     #scaleRegistry = null;
+    #filterGroups = null;
     // =========================================================================
     // HOVER STATE (Keep loop warm while any chart is hovered)
     // =========================================================================
@@ -196,7 +200,7 @@ export class GPUCoordinator {
     #sizeConfigBuffer = null; // MAX_SIZE_SLOTS × 16 bytes = 1KB
     #maxSizeSlots = MAX_SIZE_SLOTS;
     // Constants
-    #maxColorSlots = 64;
+    #maxColorSlots = MAX_COLOR_SLOTS;
     #rampColorsPerSlot = COLOR_RAMP_RESOLUTION;
     #paletteColorsPerSlot = 32;
     // =========================================================================
@@ -363,10 +367,17 @@ export class GPUCoordinator {
             label: 'scale-resources-layout',
             entries: [
                 {
-                    // Binding 1: Color scale configs (fragment only)
+                    // Binding 1: Color scale configs.
+                    //
+                    // Uniform, and visible to the VERTEX stage as well: selection
+                    // dimming reads a colour scale's slotBase per vertex. As storage
+                    // it would take the last of the vertex stage's default 8 storage
+                    // buffers on Rects, which uses 7; as a uniform it counts against
+                    // the separate uniform limit and leaves that slot free. Same move
+                    // as binding 4.
                     binding: 1,
-                    visibility: GPUShaderStage.FRAGMENT, // ← Changed
-                    buffer: { type: 'read-only-storage' }
+                    visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+                    buffer: { type: 'uniform' }
                 },
                 {
                     // Binding 2: Color ramps (fragment only)
@@ -400,8 +411,9 @@ export class GPUCoordinator {
                     // buffer and do no interpolation.
                     //
                     // Storage, where it used to be two uniforms. It costs the vertex
-                    // stage one binding where the pair cost none — Rects lands at 8 of
-                    // 8, the default maxStorageBuffersPerShaderStage — and in exchange
+                    // stage one binding where the pair cost none — Rects lands at 7 of
+                    // the default maxStorageBuffersPerShaderStage of 8, its six channels
+                    // and this — and in exchange
                     // the vec4 packing, the 64 KB uniform binding cap and the
                     // 16384-float global ceiling all go away with the address space.
                     //
@@ -409,8 +421,9 @@ export class GPUCoordinator {
                     // the compute pipeline, which has its own budget.
                     //
                     // FRAGMENT as well as VERTEX: band axes resolve a slot in the
-                    // vertex stage, ordinal colour carries the same ids and resolves
-                    // in the fragment stage.
+                    // vertex stage, and ordinal colour resolves its palette rank in
+                    // the fragment stage. Both read their selection activity, the
+                    // second half of each block, in the vertex stage.
                     binding: 5,
                     visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
                     buffer: { type: 'read-only-storage' }
@@ -435,11 +448,12 @@ export class GPUCoordinator {
     }
     #createColorScaleBuffers() {
         const device = this.#device;
-        // ColorConfig buffer: 64 slots × 48 bytes each
+        // ColorConfig buffer: 64 slots × 48 bytes each. A uniform, so the vertex
+        // stage can read it without a storage binding — see COLOR_SCALE_BINDINGS.
         this.#colorConfigBuffer = device.createBuffer({
-            label: 'ColorConfig SSBO',
+            label: 'ColorConfig uniform',
             size: this.#maxColorSlots * COLOR_CONFIG_BYTES,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
         });
         // Color ramp buffer: 64 slots × 256 colors × 4 floats × 4 bytes
         this.#colorRampBuffer = device.createBuffer({
@@ -578,9 +592,16 @@ export class GPUCoordinator {
             const slots = scale.slots;
             if (!slots)
                 continue;
-            const entry = (pool[scales.length] ??= { id: '', slots });
+            const entry = (pool[scales.length] ??= { id: '', slots, field: null });
             entry.id = scale.id;
             entry.slots = slots;
+            // The field whose activity block this scale's header points at. Every
+            // field a scale draws has one, so a selection moves nothing; the
+            // registry creates its FieldActivity once (a Map lookup after that).
+            const field = scale.identityKey ?? null;
+            entry.field = field;
+            if (field)
+                this.#filterGroups?.field(field);
             scales.push(entry);
             // Index-aligned with `scales`, so the base can be handed back after
             // packing without searching for the instance again.
@@ -588,7 +609,14 @@ export class GPUCoordinator {
                 ? scale
                 : null);
         }
-        const { uploadStart, uploadEnd } = packIdentitySlots(scales, state);
+        // Every field follows its live identity here, where nothing is reactive:
+        // a reload snaps its fades, a grown dim extends them. Two comparisons a
+        // field when nothing moved.
+        const registry = this.#filterGroups;
+        const fields = registry?.fields ?? NO_FIELDS;
+        for (let i = 0; i < fields.length; i++)
+            fields[i].reconcile();
+        const { uploadStart, uploadEnd } = packIdentitySlots(scales, state, fields, registry?.groupCount ?? 0);
         // Hand back the base to any scale that reads it from its own config rather
         // than from p4. A band scale's base is refilled into p4 every frame; an
         // ordinal colour scale's lives in a config uploaded only when the scale
@@ -960,12 +988,13 @@ export class GPUCoordinator {
             }
             const passEncoder = commandEncoder.beginRenderPass(this.#createRenderPassDescriptor(view, chartConfig));
             // The chart's scales, written once for the whole pass and before the
-            // first draw. Every pipeline declares the same 32 bytes and a draw
-            // requires every declared byte to have been set, so this is the whole
-            // range, every pass. Immediate data survives setPipeline between
-            // layouts of the same size, which is what makes once enough. Pushed even
-            // when the chart's scales are not both known: a layer that does not
-            // read them still needs every byte set before it may draw.
+            // first draw. Every pipeline declares the same
+            // CHART_SCALE_IMMEDIATE_SIZE and a draw requires every declared byte to
+            // have been set, so this is the whole range, every pass. Immediate data
+            // survives setPipeline between layouts of the same size, which is what
+            // makes once enough. Pushed even when the chart's scales are not both
+            // known: a layer that does not read them still needs every byte set
+            // before it may draw.
             const scalesKnown = this.#writeChartScales(chartConfig, this.#chartScaleImmediates);
             passEncoder.setImmediates(0, this.#chartScaleImmediates);
             if (chartConfig.perFrameBindGroup) {
@@ -1226,6 +1255,16 @@ export class GPUCoordinator {
     setScaleRegistry(scaleRegistry) {
         this.#scaleRegistry = scaleRegistry;
     }
+    /**
+     * The page's filter groups, whose field activity the packer writes into the
+     * identity slot table. Their fades run on this loop and redraw the charts
+     * drawing any scale on their field. Set before any selection, so no fade is
+     * created without the loop.
+     */
+    setFilterGroups(filterGroups) {
+        this.#filterGroups = filterGroups;
+        filterGroups.setAnimation(this, (key, out) => this.#scaleRegistry ? this.#scaleRegistry.chartsDrawingField(key, out) : out);
+    }
     registerScale(scaleId, scaleType = 'linear') {
         if (!this.#initialized)
             return;
@@ -1249,18 +1288,15 @@ export class GPUCoordinator {
         const usageMap = this.#scaleRegistry.scaleUsage;
         if (!usageMap || typeof usageMap[Symbol.iterator] !== 'function')
             return;
-        // Clear and rebuild
-        this.#scaleIdToInstance.clear();
-        for (const [scaleInstance] of usageMap) {
-            // Only positional scales (Linear, Band, Time) carry an id.
-            const scale = scaleInstance;
-            if (!scale?.id)
-                continue;
-            // The redraw list is NOT rebuilt here any more. It belongs to the
-            // registry, derived from the same usage map this reads, and a scale
-            // asks for it. Copying it from a second owner is how it went stale.
-            this.#scaleIdToInstance.set(scale.id, scale);
-        }
+        // Clear and rebuild: every scale with an id — positional scales, and
+        // ordinal colour, whose slots the packer needs too. The id map is only
+        // looked up with a chart's x and y scale ids, so a colour scale in it is
+        // never mistaken for a positional one.
+        //
+        // The redraw list is NOT rebuilt here any more. It belongs to the
+        // registry, derived from the same usage map this reads, and a scale asks
+        // for it. Copying it from a second owner is how it went stale.
+        trackScalesById(usageMap.keys(), this.#scaleIdToInstance);
         this.#scales = [...this.#scaleIdToInstance.values()];
     }
     // =========================================================================

package/dist/gpu/NanShaderLib.d.ts

@@ -0,0 +1,30 @@
+/**
+ * NaN tests for WGSL that a shader compiler cannot remove.
+ *
+ * fjader sends nulls to the GPU as NaN. WGSL lets an implementation assume
+ * floats are finite, and Apple's Metal compilers act on that: `v != v` and
+ * `!(v == v)` can compile to `false`, so a NaN goes undetected. Whether that
+ * happens depends on the GPU generation and on the code around the test, so a
+ * check that works on one Mac can be gone on another. /test/nan-probe shows
+ * what a given GPU does.
+ *
+ * These test the bit pattern instead: an exponent of all ones and a non-zero
+ * mantissa. That is integer arithmetic, which no float assumption touches.
+ *
+ * `NAN_BITS` is the quiet NaN written wherever a shader needs to produce one.
+ * Writing it as bits into a u32 view of the buffer keeps it exact; producing
+ * a NaN through float arithmetic is not guaranteed to.
+ */
+/** The quiet NaN fjader writes, as bits. */
+export declare const NAN_BITS_HEX = "0x7FC00000u";
+/**
+ * `isNanBits(u)` for a value read through a u32 view, and `isNaN(v)` for one
+ * already loaded as f32. Prefer the u32 view where a shader can read the
+ * buffer that way: it never loads the NaN as a float at all.
+ */
+export declare const NAN_WGSL = "\nconst NAN_BITS: u32 = 0x7FC00000u;\n\nfn isNanBits(u: u32) -> bool {\n\treturn (u & 0x7fffffffu) > 0x7f800000u;\n}\n\nfn isNaN(v: f32) -> bool {\n\treturn isNanBits(bitcast<u32>(v));\n}\n";
+/**
+ * The same test as an expression, for shader libraries that are pasted into
+ * other shaders and so cannot define functions those shaders may define too.
+ */
+export declare function isNanExpr(f32Expr: string): string;

package/dist/gpu/NanShaderLib.js

@@ -0,0 +1,42 @@
+/**
+ * NaN tests for WGSL that a shader compiler cannot remove.
+ *
+ * fjader sends nulls to the GPU as NaN. WGSL lets an implementation assume
+ * floats are finite, and Apple's Metal compilers act on that: `v != v` and
+ * `!(v == v)` can compile to `false`, so a NaN goes undetected. Whether that
+ * happens depends on the GPU generation and on the code around the test, so a
+ * check that works on one Mac can be gone on another. /test/nan-probe shows
+ * what a given GPU does.
+ *
+ * These test the bit pattern instead: an exponent of all ones and a non-zero
+ * mantissa. That is integer arithmetic, which no float assumption touches.
+ *
+ * `NAN_BITS` is the quiet NaN written wherever a shader needs to produce one.
+ * Writing it as bits into a u32 view of the buffer keeps it exact; producing
+ * a NaN through float arithmetic is not guaranteed to.
+ */
+/** The quiet NaN fjader writes, as bits. */
+export const NAN_BITS_HEX = '0x7FC00000u';
+/**
+ * `isNanBits(u)` for a value read through a u32 view, and `isNaN(v)` for one
+ * already loaded as f32. Prefer the u32 view where a shader can read the
+ * buffer that way: it never loads the NaN as a float at all.
+ */
+export const NAN_WGSL = /* wgsl */ `
+const NAN_BITS: u32 = ${NAN_BITS_HEX};
+
+fn isNanBits(u: u32) -> bool {
+	return (u & 0x7fffffffu) > 0x7f800000u;
+}
+
+fn isNaN(v: f32) -> bool {
+	return isNanBits(bitcast<u32>(v));
+}
+`;
+/**
+ * The same test as an expression, for shader libraries that are pasted into
+ * other shaders and so cannot define functions those shaders may define too.
+ */
+export function isNanExpr(f32Expr) {
+    return `((bitcast<u32>(${f32Expr}) & 0x7fffffffu) > 0x7f800000u)`;
+}

package/dist/gpu/ResolveShader.d.ts

@@ -6,8 +6,8 @@
  * are bound to the compute pipeline; the render stages bind `resolved` alone.
  * So an animated channel REPLACES a vertex binding rather than adding one, and
  * animating any number of channels leaves that stage's budget where it was —
- * which is what makes this affordable on a mark that already sits at the
- * default limit of 8.
+ * which is what makes this affordable on a mark that already uses 7 of the
+ * default 8 storage buffers (Rects).
  *
  * ONE KERNEL FOR BOTH, because the two differ only in where a range starts. A
  * value channel is one mark's rows in buffers of their own, so it starts at 0.
@@ -69,7 +69,7 @@ export declare const RESOLVE_IMMEDIATE_SIZE = 12;
  * hand every dispatch the last one's values. Immediates are pass state, set in
  * command order, so each dispatch reads its own.
  */
-export declare const RESOLVE_SHADER = "\nrequires immediate_address_space;\n\nstruct Params {\n  // Elements in this range. The rest of the buffer is left alone.\n  count: u32,\n  // 0 -> from, 1 -> to. Shared by every element of the range.\n  t: f32,\n  // Where the range starts, in all three buffers alike.\n  offset: u32,\n};\n\n@group(0) @binding(0) var<storage, read>       valueFrom: array<f32>;\n@group(0) @binding(1) var<storage, read>       valueTo:   array<f32>;\n@group(0) @binding(2) var<storage, read_write> resolved:  array<f32>;\nvar<immediate> params: Params;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.count) {\n    return;\n  }\n  let j = params.offset + gid.x;\n  let a = valueFrom[j];\n  let b = valueTo[j];\n  // A NaN on either side means one end of this transition is not a number, so\n  // there is nothing to interpolate along. Take the destination and be done.\n  // Note the test has to be explicit: every comparison against NaN is false, so\n  // mix() would silently propagate it instead.\n  // Equal ends take b too, so they come out exact on any driver \u2014 see above.\n  let takeTo = a == b || a != a || b != b;\n  resolved[j] = select(mix(a, b, params.t), b, takeTo);\n}\n";
+export declare const RESOLVE_SHADER: string;
 /**
  * The same expression in JS, and the reason it exists.
  *

package/dist/gpu/ResolveShader.js

@@ -1,3 +1,4 @@
+import { isNanExpr } from './NanShaderLib';
 /**
  * The resolve kernel: `resolved[j] = mix(from[j], to[j], t)` over one range.
  *
@@ -6,8 +7,8 @@
  * are bound to the compute pipeline; the render stages bind `resolved` alone.
  * So an animated channel REPLACES a vertex binding rather than adding one, and
  * animating any number of channels leaves that stage's budget where it was —
- * which is what makes this affordable on a mark that already sits at the
- * default limit of 8.
+ * which is what makes this affordable on a mark that already uses 7 of the
+ * default 8 storage buffers (Rects).
  *
  * ONE KERNEL FOR BOTH, because the two differ only in where a range starts. A
  * value channel is one mark's rows in buffers of their own, so it starts at 0.
@@ -96,10 +97,10 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   let b = valueTo[j];
   // A NaN on either side means one end of this transition is not a number, so
   // there is nothing to interpolate along. Take the destination and be done.
-  // Note the test has to be explicit: every comparison against NaN is false, so
-  // mix() would silently propagate it instead.
+  // Note the test has to be explicit, and on the bits: mix() would silently
+  // propagate a NaN, and a compiler may fold a float test like a != a to false.
   // Equal ends take b too, so they come out exact on any driver — see above.
-  let takeTo = a == b || a != a || b != b;
+  let takeTo = a == b || ${isNanExpr('a')} || ${isNanExpr('b')};
   resolved[j] = select(mix(a, b, params.t), b, takeTo);
 }
 `;

package/dist/gpu/ScaleTemplateSystem.d.ts

@@ -36,6 +36,9 @@ interface ShaderResult {
  * `ScaleParam`, 16 bytes each. Every layout declares the same size because a
  * draw requires every declared byte to have been set, and the pass sets them
  * once, before its first draw.
+ *
+ * Immediates carry state shared across the pass and read by several marks: the
+ * chart's scales and settings. 64 bytes are available on M-series Macs.
  */
 export declare const CHART_SCALE_IMMEDIATE_SIZE = 32;
 /**
@@ -66,6 +69,22 @@ export declare class ScaleTemplateSystem {
      * @private
      */
     _buildDeclarations(xFragment: ScaleFragment, yFragment: ScaleFragment): string;
+    /**
+     * `bandActivityX(value, group)` and `bandActivityY(value, group)`: how
+     * selected a band or point axis's category is in the mark's filter group,
+     * 0..1, for selection dimming.
+     *
+     * Emitted for every shader, so a renderer can call both without knowing its
+     * scale types: an axis that is not band or point returns 1.0. On a band or
+     * point axis the value is an identity id and the chart's scale carries its
+     * block base in p4, as for the slot lookup. A missing category (-1) or a NaN
+     * is fully active, checked before the cast, since u32() of a negative or NaN
+     * float is indeterminate in WGSL.
+     */
+    _buildBandActivityHelpers(scaleTypes: {
+        x: string;
+        y: string;
+    }): string;
     /**
      * The shared slot table, and the lookup into it.
      *