@fjader/svelte 0.2.2 → 0.2.4

package/dist/components/rendering/activity-reads.js

@@ -0,0 +1,154 @@
+/**
+ * Which selection activities a mark reads: its ordinal colour, its band x,
+ * its band y. One answer per renderer, used twice:
+ *
+ * - The renderer builds its shader's `markActivity` call from it, so a read
+ *   the table does not list is passed as 1.0 and cannot happen.
+ * - MarkLifecycleV2 turns it into the mark's `reads`, the identity keys of the
+ *   fields it dims by, which decide whether a categorical selection on a field
+ *   dims the mark or filters it.
+ *
+ * The two must agree exactly. A mark routed to dim on a field its shader does
+ * not read would be neither dimmed nor filtered; one whose shader reads a field
+ * routing missed would be filtered and dimmed at once. Deriving both from this
+ * table is what keeps them together. One case they still disagree on: a field
+ * whose activity block did not fit in the identity slot buffer (see the known
+ * limit in identity-slot-packing.ts).
+ *
+ * A function of the config, not a constant per renderer, because a rule's
+ * answer depends on a prop: a rule without an extent spans the whole cross
+ * axis, belongs to no category on it, and must not dim by it.
+ */
+import { NO_GROUP } from '../../gpu/identity-slot-packing';
+const ALL = { color: true, x: true, y: true };
+const COLOR_ONLY = { color: true, x: false, y: false };
+/**
+ * What a renderer reads. `hasExtent` is a rule's: RuleX with y1/y2, RuleY with
+ * x1/x2. Lines, areas and parallel coordinates dim by colour only: a line over
+ * a band axis spans its categories.
+ *
+ * Not yet supported: a line or area grouped by `z` that is not its colour
+ * field. Its series ids reach the shader, but only to break the line between
+ * series; no activity is read through them, and the series field is not among
+ * the mark's reads. So a selection on that field filters the mark in other
+ * charts and does nothing in its own, instead of dimming the other series.
+ */
+export function activityReads(renderer, hasExtent = false) {
+    switch (renderer) {
+        case 'dots':
+        case 'rects':
+        case 'text':
+            return ALL;
+        case 'rulex':
+            return { color: true, x: true, y: hasExtent };
+        case 'ruley':
+            return { color: true, x: hasExtent, y: true };
+        case 'lines':
+        case 'areas':
+        case 'parallel':
+            return COLOR_ONLY;
+    }
+}
+/**
+ * Whether a rule spans an extent on its cross axis: both ends given, as a
+ * field or a constant. A rule mark builds its renderer's extent data from this
+ * and hands it to routing as `ruleExtent`, so the two cannot disagree; a
+ * constant end (y1={0}, or the y shorthand) counts like a field.
+ */
+export function ruleHasExtent(lo, hi) {
+    return lo !== undefined && hi !== undefined;
+}
+/** The renderer a mark type draws with, or null for one that reads no activity. */
+export function rendererForMark(markType) {
+    switch (markType) {
+        case 'dot':
+            return 'dots';
+        case 'bary':
+        case 'barx':
+        case 'rect':
+        case 'rectx':
+        case 'recty':
+            return 'rects';
+        case 'rulex':
+            return 'rulex';
+        case 'ruley':
+            return 'ruley';
+        case 'line':
+            return 'lines';
+        case 'areax':
+        case 'areay':
+            return 'areas';
+        case 'parallel':
+            return 'parallel';
+        case 'text':
+            return 'text';
+        default:
+            return null;
+    }
+}
+/**
+ * A mark's reads: the identity keys of the fields whose activity it reads,
+ * sorted, from what its renderer reads and the identity key of each of its
+ * categorical scales (null for a channel with no such scale, or a scale with
+ * no identity: a field with no identity has no activity to dim by, so a
+ * selection on it filters the mark).
+ */
+export function readsFor(reads, keys) {
+    const out = [];
+    if (reads.color && keys.color)
+        out.push(keys.color);
+    if (reads.x && keys.x)
+        out.push(keys.x);
+    if (reads.y && keys.y)
+        out.push(keys.y);
+    if (out.length === 0)
+        return NO_READS;
+    return [...new Set(out)].sort();
+}
+/** A mark that reads no activity. Shared, so its reads never look changed. */
+export const NO_READS = [];
+export { NO_GROUP };
+/** A mark's reads under its selection response: none for 'filter', which never dims. */
+export function readsForResponse(response, reads) {
+    return response === 'filter' ? NO_READS : reads;
+}
+/** The group index a mark's shader reads activity with: NO_GROUP for 'filter'. */
+export function groupIndexForResponse(response, groupIndex) {
+    return response === 'filter' ? NO_GROUP : groupIndex;
+}
+/**
+ * The WGSL activity of a renderer that reads colour only (lines, areas,
+ * parallel coordinates): `markColorActivity(...)`, or 1.0 if the table says
+ * it reads nothing. Throws for a renderer that reads a band axis, whose call
+ * is markActivityWGSL.
+ */
+export function colorActivityWGSL(reads, args) {
+    if (reads.x || reads.y)
+        throw new Error('colorActivityWGSL: this renderer reads a band axis');
+    return reads.color ? `markColorActivity(${args.color}, ${args.group})` : '1.0';
+}
+/**
+ * The WGSL `markActivity(...)` call for `reads`: each activity the renderer
+ * reads, and 1.0 for each it does not. `color` is markColorActivity's first
+ * three arguments; `x` and `y` are the band channel values; `group` the mark's
+ * group index.
+ */
+/**
+ * The activity of an Other row: the same terms as markActivityWGSL without the
+ * band axes', and without colour's when colour is the band's own field
+ * (`skipColor`, a WGSL bool). Those read the Other bucket's own fade, and the
+ * bar's split already shows how much of it is selected (Rects); multiplying
+ * them in as well would dim it twice. Activity on any other field stays.
+ */
+export function otherRowActivityWGSL(reads, args) {
+    const color = reads.color
+        ? `select(markColorActivity(${args.color}, ${args.group}), 1.0, ${args.skipColor})`
+        : '1.0';
+    return `markActivity(${color}, 1.0, 1.0)`;
+}
+export function markActivityWGSL(reads, args) {
+    const color = reads.color ? `markColorActivity(${args.color}, ${args.group})` : '1.0';
+    const x = reads.x ? `bandActivityX(${args.x}, ${args.group})` : '1.0';
+    const y = reads.y ? `bandActivityY(${args.y}, ${args.group})` : '1.0';
+    return `markActivity(${color}, ${x}, ${y})`;
+}

package/dist/components/rendering/uniform-sizes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 declare const PARALLEL_MAX_AXES = 16;
+export declare const UNIFORM_BYTES: {
+    readonly dotsMarkConstants: 48;
+    readonly rectsMarkConstants: 48;
+    readonly ruleXMarkConstants: 48;
+    readonly ruleYMarkConstants: 48;
+    readonly linesMarkConstants: 64;
+    readonly areasMarkConstants: 64;
+    readonly gridLineRuleConstants: 32;
+    readonly parallelConfig: 176;
+    readonly parallelAxisScales: number;
+};
+/** The stand-in uniform buffer: as large as the largest struct any renderer binds. */
+export declare const UNIFORM_STAND_IN_BYTES: number;

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,4 +1,5 @@
-import type { FieldRef, LODConfig, SortConfig, ColorScheme, CurveType, Transform } from '../types';
+import type { SelectionResponse } from '../components/rendering/activity-reads';
+import type { FieldRef, LODConfig, SortConfig, ColorScheme, CurveType, NullsResponse, Transform } from '../types';
 import type { MarkLODSurface } from '../lod/rung-types';
 export interface MarkEntry {
     readonly id: string;
@@ -23,6 +24,9 @@ export interface MarkEntry {
     scheme?: ColorScheme;
     transforms?: Transform[];
     selection?: string;
+    selectionResponse?: SelectionResponse;
+    contributeDomain?: boolean;
+    nulls?: NullsResponse;
     limit?: number;
     preferredXScaleType?: string | null;
     preferredYScaleType?: string | null;

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_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

@@ -36,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
@@ -70,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>>;
 `;
@@ -120,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
@@ -129,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);
@@ -146,7 +169,7 @@ 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 (${isNanExpr('value')}) {
@@ -165,7 +188,7 @@ 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> {
@@ -179,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/MorphedChannels.d.ts

@@ -1,35 +1,4 @@
 import { TransitionClock, type ClockLoop } from '../animation/TransitionClock';
-/**
- * Channels of one mark that morph between data updates rather than replacing
- * outright.
- *
- * Each holds three buffers where a static channel holds one: `from` and `to` are
- * read by a compute pass, and `resolved = mix(from, to, t)` is what the vertex
- * stage binds — in place of the static buffer, not in addition to it. So
- * animating a channel costs the vertex stage nothing, which is what makes it
- * affordable on a mark already at the device's storage-buffer limit.
- *
- * THE FOLD. When a transition restarts, whatever is on screen becomes the new
- * `from`. On screen is the resolved buffer as last dispatched, so the fold is a
- * buffer copy, and it reads neither `from` nor `to` — which is what lets data
- * land at any moment, in any order relative to anything else. Writing it as
- * `from = mix(from, to, t)` would need the OLD `to`, making the order of two
- * writes load-bearing and silently wrong if they ever swap.
- *
- * THE SNAP. Some updates have nothing to travel from: the first one, a buffer
- * that had to be reallocated, and a row set that is not the one being animated.
- * Those copy `to` over `from`, which makes the mix the identity for every t.
- *
- * THE CLOCK. A mark ADOPTS the band scale's clock when it has one, so a bar's
- * height travels on the same number as its slot — two clocks with two velocities
- * desynchronise on a retarget, and the bar reaches its rank before or after it
- * finishes growing. It OWNS one otherwise. Adoption is safe across marks because
- * a mark with no new data folds to where it already is and does not move.
- */
-/**
- * The coordinator's slice this needs. Structural, so tests can supply a fake.
- * It is also the loop an owned clock joins — the clock does that itself.
- */
 export interface MorphHost extends ClockLoop {
     registerComputeWork(key: string, fn: (encoder: GPUCommandEncoder) => void): void;
     removeComputeWork(key: string): void;
@@ -85,8 +54,13 @@ export declare class MorphedChannels {
      *
      * All channels in one call, so one update starts one transition. Returns
      * whether any buffer was (re)allocated, which the caller must rebind.
+     *
+     * `land`: bindings whose new values take effect at once while the rest
+     * travel. For a channel whose change is shown some other way at that moment
+     * (an Other bar's split, when both sides of it look the same): sliding it
+     * would draw a movement nothing asked for.
      */
-    write(rowIds: ArrayLike<number>, channels: readonly (readonly [number, AllowSharedBufferSource])[]): boolean;
+    write(rowIds: ArrayLike<number>, channels: readonly (readonly [number, AllowSharedBufferSource])[], land?: readonly number[]): boolean;
     /**
      * Stop morphing a channel and release its buffers. Returns whether it was
      * morphing, in which case the caller's binding has lost its buffer.