@fjader/svelte 0.2.2 → 0.2.3

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/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.

package/dist/gpu/ResolveShader.js

@@ -7,8 +7,8 @@ import { isNanExpr } from './NanShaderLib';
  * 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.

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.
      *

package/dist/gpu/ScaleTemplateSystem.js

@@ -1,6 +1,9 @@
 // src/lib/gpu/ScaleTemplateSystem.ts
 import { COLOR_SCALE_STRUCTS, COLOR_SCALE_BINDINGS, COLOR_SCALE_FUNCTIONS } from './ColorScaleShaderLib';
 import { SIZE_SCALE_STRUCTS, SIZE_SCALE_BINDINGS, SIZE_SCALE_FUNCTIONS } from './SizeScaleShaderLib';
+import { NO_GROUP } from './identity-slot-packing';
+import { isNanExpr } from './NanShaderLib';
+import { DEFAULT_INACTIVE_OPACITY } from '../scales/ActivityTable';
 /**
  * Scale fragment definitions
  * Each scale type provides: declaration, function call, and implementation
@@ -280,6 +283,9 @@ function _scaleFunctionName(scaleType, axis) {
  * `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 const CHART_SCALE_IMMEDIATE_SIZE = 32;
 /**
@@ -370,6 +376,7 @@ export class ScaleTemplateSystem {
       // ===== 3. HELPER FUNCTIONS =====
       
       ${this._buildSlotTableHelpers()}
+      ${this._buildBandActivityHelpers(scaleTypes)}
       ${bandHelpers}
       ${implementations}
       ${scaleFunctions}
@@ -409,6 +416,24 @@ export class ScaleTemplateSystem {
       };
       var<immediate> chartScales: ChartScales;
 
+      // Selection dimming: a mark's activity mapped to an opacity, with
+      // inactive categories at DEFAULT_INACTIVE_OPACITY. selectionOpacity in
+      // ActivityTable.ts is its CPU twin, for band labels and legend entries,
+      // and both read the same constant so they cannot drift apart.
+      const SELECTION_DIM_STRENGTH: f32 = ${(1 - DEFAULT_INACTIVE_OPACITY).toFixed(6)};
+      fn selectionDim(activity: f32) -> f32 {
+        return 1.0 - SELECTION_DIM_STRENGTH * (1.0 - activity);
+      }
+
+      // A mark's activities combined: colour, and band for marks on band axes.
+      // The least active wins rather than the product, so a bar whose colour
+      // and band are the same field fades on the same curve as its label
+      // instead of twice as fast. At rest every activity is 0 or 1, where the
+      // two agree.
+      fn markActivity(color: f32, bandX: f32, bandY: f32) -> f32 {
+        return min(color, min(bandX, bandY));
+      }
+
       // The ONE place that says where a chart's scales come from. Every
       // consumer reads through these — scaleX/scaleY, the bandwidth helpers,
       // and mark code that needs the raw params. A mark with scales of its own
@@ -423,6 +448,39 @@ export class ScaleTemplateSystem {
     `;
         return `${structDef}\n${chartScaleDeclaration}`;
     }
+    /**
+     * `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) {
+        const helper = (axis, type) => {
+            if (type !== 'band' && type !== 'point') {
+                return `fn bandActivity${axis}(value: f32, group: u32) -> f32 {
+      return 1.0;
+    }`;
+            }
+            return `fn bandActivity${axis}(value: f32, group: u32) -> f32 {
+      if (value < 0.0 || ${isNanExpr('value')}) {
+        return 1.0;
+      }
+      return identityActivity(u32(chartScale${axis}().p4), group, u32(value));
+    }`;
+        };
+        return `
+    // ===== BAND SELECTION ACTIVITY =====
+    ${helper('X', scaleTypes.x)}
+
+    ${helper('Y', scaleTypes.y)}
+    `;
+    }
     /**
      * The shared slot table, and the lookup into it.
      *
@@ -459,12 +517,12 @@ export class ScaleTemplateSystem {
     }
 
     fn identitySlot(base: u32, id: u32) -> f32 {
-      // Block layout: [count, slot0, slot1, ...]. The count is what makes a
-      // block self-describing, so an id past this scale's end is discarded
-      // instead of reading into the next scale's slots. It survives the resolve
-      // exactly because it holds the same value in both halves, and the kernel
-      // returns equal ends as they are — u32() truncates, so an inexact mix
-      // would drop the last id.
+      // Block layout: [count, actRef, n, slot0, slot1, ...]. The count is what
+      // makes a block self-describing, so an id past this scale's end is
+      // discarded instead of reading into the next scale's slots. It survives
+      // the resolve exactly because it holds the same value in both halves, and
+      // the kernel returns equal ends as they are — u32() truncates, so an
+      // inexact mix would drop the last id.
       let count = u32(identitySlots[base]);
       if (id >= count) {
         return -1.0;
@@ -473,7 +531,28 @@ export class ScaleTemplateSystem {
       // both halves, so the resolve wrote -1 without a branch; one that is
       // leaving holds a real slot in both, which is what lets it travel. The
       // scale normalises that before packing, so nothing here re-derives it.
-      return identitySlots[base + 1u + id];
+      return identitySlots[base + 3u + id];
+    }
+
+    fn identityActivity(base: u32, group: u32, id: u32) -> f32 {
+      // How selected this id is in the mark's filter group, 1 active and 0
+      // inactive, already resolved at that group's selection clock. The scale
+      // block's header points at its field's activity block (actRef) and says
+      // how many ids it covers (n); the block holds one run of n per group.
+      // Header first, so this is two dependent reads. Past n, or in the empty
+      // block where n is 0, an id is fully active.
+      //
+      // NO_GROUP (a mark whose selectionResponse is 'filter') is fully active,
+      // checked before anything is read, so it never becomes an offset.
+      if (group == ${NO_GROUP}u) {
+        return 1.0;
+      }
+      let actRef = u32(identitySlots[base + 1u]);
+      let n = u32(identitySlots[base + 2u]);
+      if (id >= n) {
+        return 1.0;
+      }
+      return identitySlots[actRef + n * group + id];
     }
     `;
     }

package/dist/gpu/SizeScaleShaderLib.d.ts

@@ -19,10 +19,10 @@ export declare const MAX_SIZE_SLOTS = 64;
  * changes rather than per frame. Every property that makes a uniform buffer the
  * right container was already true of it.
  *
- * What it buys: the vertex stage sits at the default
- * maxStorageBuffersPerShaderStage of 8 (six mark channels, scale params, and
- * this), and animating a value channel needs a `from` and a `to` where there is
- * now one buffer. Uniform buffers are nowhere near their own default of 12.
+ * What it buys: a slot in the vertex stage's storage budget, the default
+ * maxStorageBuffersPerShaderStage of 8, of which Rects uses 7 (six mark
+ * channels and the identity slot table). Uniform buffers are nowhere near
+ * their own default of 12.
  *
  * Dynamic indexing — `sizeConfigs[scaleIndex]` — is permitted on uniform arrays
  * in WGSL, and the shared slot table already relies on the same thing.

package/dist/gpu/SizeScaleShaderLib.js

@@ -28,10 +28,10 @@ export const MAX_SIZE_SLOTS = 64;
  * changes rather than per frame. Every property that makes a uniform buffer the
  * right container was already true of it.
  *
- * What it buys: the vertex stage sits at the default
- * maxStorageBuffersPerShaderStage of 8 (six mark channels, scale params, and
- * this), and animating a value channel needs a `from` and a `to` where there is
- * now one buffer. Uniform buffers are nowhere near their own default of 12.
+ * What it buys: a slot in the vertex stage's storage budget, the default
+ * maxStorageBuffersPerShaderStage of 8, of which Rects uses 7 (six mark
+ * channels and the identity slot table). Uniform buffers are nowhere near
+ * their own default of 12.
  *
  * Dynamic indexing — `sizeConfigs[scaleIndex]` — is permitted on uniform arrays
  * in WGSL, and the shared slot table already relies on the same thing.