@fjader/svelte 0.2.3 → 0.2.4

package/dist/components/rendering/BaseGPURenderer.svelte.js

@@ -242,7 +242,9 @@ export class BaseGPURenderer {
      * the band axis's scale is whose clock these channels adopt. See
      * MorphedChannels for the fold, the snap and the clock.
      */
-    writeMorphed(bandAxis, bandIds, channels) {
+    writeMorphed(bandAxis, bandIds, channels, 
+    /** Bindings that land at once rather than travel (see MorphedChannels.write). */
+    land) {
         if (!this.#device)
             return;
         if (!MorphedChannels.supported) {
@@ -283,7 +285,7 @@ export class BaseGPURenderer {
             }
         }
         this.#morphAxis = bandAxis;
-        if (this.#morphed.write(bandIds, channels) || rebind) {
+        if (this.#morphed.write(bandIds, channels, land) || rebind) {
             this.#scheduleBindGroupUpdate();
         }
         else if (!this.#bindGroupUpdateScheduled) {

package/dist/components/rendering/Rects.svelte

@@ -5,7 +5,8 @@
 	import { getGPUContext } from '../../gpu';
 	import { DEFAULT_FILL_COLOR } from '../../scales/color-utils';
 	import type { ChartContext, WebGPUCanvasContext } from '../../types';
-	import { activityReads, markActivityWGSL } from './activity-reads';
+	import type { SplitProp } from '../marks/lifecycle/other-rows.svelte';
+	import { activityReads, markActivityWGSL, otherRowActivityWGSL } from './activity-reads';
 
 	const rectRendererDefinition = {
 		x: { concept: 'extent', channels: ['x0', 'x1'] },
@@ -21,7 +22,18 @@
 		Y1: 3,
 		COLOR: 4,
 		ALPHA: 5,
-		CONSTANTS: 6
+		CONSTANTS: 6,
+		/**
+		 * An Other bar's selected share, per row: 0 on rows that are not an Other
+		 * (so the zero-filled stand-in buffer means "no split anywhere"), `1 +
+		 * share` on one. Morphed with the bar's length.
+		 *
+		 * The vertex stage's 8th storage buffer: six channels, the identity slot
+		 * table and this fill WebGPU's default maxStorageBuffersPerShaderStage. A
+		 * further per-row channel needs another container (an instance vertex
+		 * attribute) or a raised device limit.
+		 */
+		SHARE: 7
 	};
 
 	// Facet uses vertex buffer slot 1 (not a storage binding)
@@ -35,8 +47,9 @@
 		GROUP_INDEX: 12,
 		CONSTANT_COLOR: 16,
 		DX: 32,
-		DY: 36
-		// 40-47: padding for 16-byte alignment
+		DY: 36,
+		OTHER_COLOR_ON_BAND: 40,
+		SPLIT_ALONG_X: 44
 	};
 
 	interface Props {
@@ -46,6 +59,12 @@
 		y1Data: Float32Array;
 		colorValueData: Float32Array | null;
 		alphaData: Float32Array | null;
+		/**
+		 * A bar's selected share per row (see BINDINGS.SHARE), or null for none: a
+		 * bar mark with a topN Other bucket passes its lifecycle's `otherRows.split`.
+		 * The fragment draws the bar above the share dimmed.
+		 */
+		share?: SplitProp | null;
 		facetData?: Float32Array | null;
 		dataVersion: number;
 		zIndex?: number;
@@ -77,6 +96,7 @@
 		y1Data,
 		colorValueData,
 		alphaData,
+		share = null,
 		facetData = null,
 		dataVersion,
 		zIndex = 0,
@@ -91,6 +111,11 @@
 		bandAxis = null
 	}: Props = $props();
 
+	const splitData = $derived(share?.data ?? null);
+	const splitSlides = $derived(share?.slides ?? true);
+	// Bars grouped on y run along x, so their split does too.
+	const splitAlongX = $derived(share?.axis === 'y');
+	const otherColorOnBand = $derived(share?.colorOnBand ?? false);
 	const morphX = $derived(bandAxis === 'y');
 	const morphY = $derived(bandAxis === 'x');
 
@@ -137,8 +162,8 @@
       constantColor: vec4<f32>, // Used when colorMode = 0
       dx: f32,                  // Horizontal pixel offset
       dy: f32,                  // Vertical pixel offset
-      _pad1: f32,
-      _pad2: f32,
+      otherColorOnBand: u32,    // 1: an Other row skips its colour activity too
+      splitAlongX: u32,         // 1: an Other bar splits along x (horizontal bars)
     };
     @group(1) @binding(6) var<uniform> markConstants: MarkConstants;
 
@@ -146,6 +171,13 @@
       @builtin(position) position: vec4<f32>,
       @location(0) colorValue: f32,   // Raw value for scale lookup
       @location(1) alpha: f32,
+      // The Other bar's selected share, or -1 on every other row; and where this
+      // fragment sits along the bar, 0 at its base, 1 at its end.
+      @location(2) @interpolate(flat) share: f32,
+      @location(3) along: f32,
+      // An Other bar's unselected part: dimmed by the other fields' activity and
+      // by the field's free slot, so it fades as the rest of the chart does.
+      @location(4) alphaRest: f32,
     };
 
     @group(1) @binding(0) var<storage, read> x0Values: array<f32>;
@@ -154,6 +186,7 @@
     @group(1) @binding(3) var<storage, read> y1Values: array<f32>;
     @group(1) @binding(4) var<storage, read> colorValues: array<f32>;
     @group(1) @binding(5) var<storage, read> alphaValues: array<f32>;
+    @group(1) @binding(7) var<storage, read> splitValues: array<f32>;
 
     @vertex
     fn vertexMain(
@@ -190,19 +223,47 @@
       var output: VertexOutput;
       output.position = vec4<f32>(normalizedPos.x, -normalizedPos.y, 0.0, 1.0);
       output.colorValue = colorValue;
-      output.alpha = alpha * selectionDim(
-        ${markActivityWGSL(ACTIVITY_READS, {
+      // An Other row (split > 0) is drawn in two parts, mixed in the fragment at
+      // its share. Below: as any bar, by its full activity, its own field's
+      // included, so it dims and lights with the bucket's lit state (#23). Above:
+      // by the other fields' activity and the field's free slot, so it is lit
+      // only while nothing is selected. Both fade on the selection clock, and the
+      // split only moves when the share moves between two parts that differ.
+      let split = splitValues[instanceIdx];
+      let isOther = split > 0.5;
+      output.share = select(-1.0, split - 1.0, isOther);
+      output.along = select(rectCorner.y, rectCorner.x, markConstants.splitAlongX == 1u);
+      let activity = ${markActivityWGSL(ACTIVITY_READS, {
+				color: 'markConstants.colorMode, markConstants.colorScaleIndex, colorValue',
+				x: 'x0',
+				y: 'y0',
+				group: 'markConstants.groupIndex'
+			})};
+      output.alpha = alpha * selectionDim(activity);
+      // The unselected part is drawn only on an Other row: every other bar skips
+      // its activity reads.
+      output.alphaRest = output.alpha;
+      if (isOther) {
+        let otherActivity = ${otherRowActivityWGSL(ACTIVITY_READS, {
 					color: 'markConstants.colorMode, markConstants.colorScaleIndex, colorValue',
-					x: 'x0',
-					y: 'y0',
-					group: 'markConstants.groupIndex'
-				})}
-      );
+					group: 'markConstants.groupIndex',
+					skipColor: 'markConstants.otherColorOnBand == 1u'
+				})};
+        let free = select(
+          bandFreeActivityX(markConstants.groupIndex),
+          bandFreeActivityY(markConstants.groupIndex),
+          markConstants.splitAlongX == 1u
+        );
+        output.alphaRest = alpha * selectionDim(min(otherActivity, free));
+      }
       return output;
     }
   
     @fragment
     fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
+      // Before any branch: a derivative must be taken in uniform control flow.
+      let aa = max(fwidth(input.along), 1e-4);
+
       // Get color based on mode
       var baseColor: vec4<f32>;
       if (markConstants.colorMode == 0u) {
@@ -217,7 +278,14 @@
         );
       }
   
-      let finalAlpha = baseColor.a * input.alpha;
+      var finalAlpha = baseColor.a * input.alpha;
+      // An Other bar's split: its own part up to the selected share, from its
+      // base, its unselected part above, with an anti-aliased edge. At share 1
+      // the whole bar is its own part, with no half-dimmed top row.
+      if (input.share >= 0.0 && input.share < 1.0) {
+        let below = 1.0 - smoothstep(input.share - aa, input.share + aa, input.along);
+        finalAlpha = baseColor.a * mix(input.alphaRest, input.alpha, below);
+      }
       return vec4<f32>(baseColor.rgb * finalAlpha, finalAlpha);
     }
   `
@@ -248,6 +316,7 @@
 		{ binding: BINDINGS.Y1, type: 'read-only-storage', visibility: GPUShaderStage.VERTEX },
 		{ binding: BINDINGS.COLOR, type: 'read-only-storage', visibility: GPUShaderStage.VERTEX },
 		{ binding: BINDINGS.ALPHA, type: 'read-only-storage', visibility: GPUShaderStage.VERTEX },
+		{ binding: BINDINGS.SHARE, type: 'read-only-storage', visibility: GPUShaderStage.VERTEX },
 		{
 			binding: BINDINGS.CONSTANTS,
 			type: 'uniform',
@@ -266,16 +335,40 @@
 	// a fraction that the slot table resolves to a DIFFERENT category.
 	$effect(() => {
 		if (!renderer?.resourcesCreated || !bandAxis) return;
+		// The Other share travels with the bar's length, on the same clock, so the
+		// split and the bar land together. A share that changes alone (a click)
+		// starts a transition of its own on that clock.
+		const split = splitData ? ([[BINDINGS.SHARE, splitData]] as const) : [];
+		const land = splitData && !splitSlides ? [BINDINGS.SHARE] : undefined;
 		if (bandAxis === 'x') {
-			renderer.writeMorphed('x', x0Data, [
-				[BINDINGS.Y0, y0Data],
-				[BINDINGS.Y1, y1Data]
-			]);
+			renderer.writeMorphed(
+				'x',
+				x0Data,
+				[[BINDINGS.Y0, y0Data], [BINDINGS.Y1, y1Data], ...split],
+				land
+			);
 		} else {
-			renderer.writeMorphed('y', y0Data, [
-				[BINDINGS.X0, x0Data],
-				[BINDINGS.X1, x1Data]
-			]);
+			renderer.writeMorphed(
+				'y',
+				y0Data,
+				[[BINDINGS.X0, x0Data], [BINDINGS.X1, x1Data], ...split],
+				land
+			);
+		}
+	});
+	// Without a band axis the share is written as is. A mark that had shares and
+	// has none now writes one array of zeros, which also drops a morphed channel:
+	// left alone, the shader would keep reading the last shares. A mark that
+	// never had any writes nothing and reads the zero-filled stand-in.
+	let splitWritten = false;
+	$effect(() => {
+		if (!renderer?.resourcesCreated) return;
+		if (splitData) {
+			if (!bandAxis) renderer.writeAttribute(BINDINGS.SHARE, splitData);
+			splitWritten = true;
+		} else if (splitWritten) {
+			renderer.writeAttribute(BINDINGS.SHARE, new Float32Array(Math.max(1, x0Data.length)));
+			splitWritten = false;
 		}
 	});
 	$effect(() => {
@@ -324,7 +417,8 @@
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 12, constantColor[3], LE);
 			view.setFloat32(UNIFORM_OFFSETS.DX, dx, LE);
 			view.setFloat32(UNIFORM_OFFSETS.DY, dy, LE);
-			// padding at 40-47
+			view.setUint32(UNIFORM_OFFSETS.OTHER_COLOR_ON_BAND, otherColorOnBand ? 1 : 0, LE);
+			view.setUint32(UNIFORM_OFFSETS.SPLIT_ALONG_X, splitAlongX ? 1 : 0, LE);
 
 			renderer.writeUniform(BINDINGS.CONSTANTS, new Uint8Array(buffer));
 		}

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

@@ -1,3 +1,4 @@
+import type { SplitProp } from '../marks/lifecycle/other-rows.svelte';
 interface Props {
     x0Data: Float32Array;
     x1Data: Float32Array;
@@ -5,6 +6,12 @@ interface Props {
     y1Data: Float32Array;
     colorValueData: Float32Array | null;
     alphaData: Float32Array | null;
+    /**
+     * A bar's selected share per row (see BINDINGS.SHARE), or null for none: a
+     * bar mark with a topN Other bucket passes its lifecycle's `otherRows.split`.
+     * The fragment draws the bar above the share dimmed.
+     */
+    share?: SplitProp | null;
     facetData?: Float32Array | null;
     dataVersion: number;
     zIndex?: number;

package/dist/components/rendering/activity-reads.d.ts

@@ -31,6 +31,12 @@ export interface ActivityReads {
  * 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 declare function activityReads(renderer: ActivityRenderer, hasExtent?: boolean): ActivityReads;
 /**
@@ -85,6 +91,18 @@ export declare function colorActivityWGSL(reads: ActivityReads, args: {
  * 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 declare function otherRowActivityWGSL(reads: ActivityReads, args: {
+    color: string;
+    group: string;
+    skipColor: string;
+}): string;
 export declare function markActivityWGSL(reads: ActivityReads, args: {
     color: string;
     x: string;

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

@@ -26,6 +26,12 @@ 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) {
@@ -127,6 +133,19 @@ export function colorActivityWGSL(reads, args) {
  * 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';

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

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

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.

package/dist/gpu/MorphedChannels.js

@@ -1,6 +1,39 @@
 import { RESOLVE_IMMEDIATE_SIZE, RESOLVE_WORKGROUP, resolvePipelineFor } from './ResolveShader';
 import { TransitionClock } from '../animation/TransitionClock';
 import { immediatesSupported } from './immediates';
+/**
+ * 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.
+ */
+/** No bindings: the default for `write`'s `land`. */
+const NO_BINDINGS = [];
 /**
  * A cheap fingerprint of the band ids, per update.
  *
@@ -87,8 +120,13 @@ export 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, channels) {
+    write(rowIds, channels, land = NO_BINDINGS) {
         const key = alignmentKey(rowIds);
         let travels = this.#alignmentKey === key;
         this.#alignmentKey = key;
@@ -100,6 +138,7 @@ export class MorphedChannels {
                 reallocated = true;
             }
             channel.count = data.byteLength >> 2;
+            channel.land = land.includes(binding);
             this.#device.queue.writeBuffer(channel.to, 0, data);
         }
         // A fresh buffer holds nothing that was ever on screen, so there is
@@ -158,8 +197,10 @@ export class MorphedChannels {
             return;
         for (let i = 0; i < channels.length; i++) {
             const channel = channels[i];
-            if (snap) {
+            if (snap || channel.land) {
+                // A landed channel: from = to, so the mix is its new value at any t.
                 encoder.copyBufferToBuffer(channel.to, 0, channel.from, 0, channel.size);
+                channel.land = false;
             }
             else if (this.#foldPending) {
                 // A transition interrupted mid-flight continues from where it is,
@@ -225,7 +266,8 @@ export class MorphedChannels {
             resolved: make('resolved'),
             size,
             count: 0,
-            bindGroup: null
+            bindGroup: null,
+            land: false
         };
         this.#channels.set(binding, channel);
         this.#channelList = [...this.#channels.values()];

package/dist/gpu/ScaleTemplateSystem.js

@@ -178,10 +178,10 @@ const SCALE_FRAGMENTS = {
 					rangeMax
 				);
 				
-				// Return center of band
-				// X: left to right (index 0 at left)
-				// Y: bottom to top (index 0 at bottom, matching D3 convention)
-				${axis === 'y' ? 'return rangeMax - bandLayout.x - bandLayout.y * 0.5;' : 'return rangeMin + bandLayout.x + bandLayout.y * 0.5;'}
+				// Return center of band, slot 0 at the start of the range on both
+				// axes: the left on x, the top on y, so a y band axis reads top-down
+				// like a list and its exit (one past the last slot) is the list's end.
+				return rangeMin + bandLayout.x + bandLayout.y * 0.5;
 			}
   	`,
         bufferLayout: {
@@ -465,6 +465,9 @@ export class ScaleTemplateSystem {
             if (type !== 'band' && type !== 'point') {
                 return `fn bandActivity${axis}(value: f32, group: u32) -> f32 {
       return 1.0;
+    }
+    fn bandFreeActivity${axis}(group: u32) -> f32 {
+      return 1.0;
     }`;
             }
             return `fn bandActivity${axis}(value: f32, group: u32) -> f32 {
@@ -472,6 +475,9 @@ export class ScaleTemplateSystem {
         return 1.0;
       }
       return identityActivity(u32(chartScale${axis}().p4), group, u32(value));
+    }
+    fn bandFreeActivity${axis}(group: u32) -> f32 {
+      return identityFreeActivity(u32(chartScale${axis}().p4), group);
     }`;
         };
         return `
@@ -554,6 +560,21 @@ export class ScaleTemplateSystem {
       }
       return identitySlots[actRef + n * group + id];
     }
+
+    fn identityFreeActivity(base: u32, group: u32) -> f32 {
+      // The last slot of the group's run, past every id: 1 while the group
+      // selects nothing on the field, 0 while it selects anything, at the
+      // selection clock (FieldActivity's FREE SLOT). 1 without a block.
+      if (group == ${NO_GROUP}u) {
+        return 1.0;
+      }
+      let actRef = u32(identitySlots[base + 1u]);
+      let n = u32(identitySlots[base + 2u]);
+      if (n == 0u) {
+        return 1.0;
+      }
+      return identitySlots[actRef + n * group + n - 1u];
+    }
     `;
     }
     _buildBandHelpers(scaleTypes) {

package/dist/index.d.ts

@@ -19,5 +19,7 @@ export * from './components';
 export * from './transforms';
 export * from './sql/bin';
 export * from './types';
+export { getFilterGroups } from './query-engine';
+export type { FilterGroupRegistry, FilterGroup, FilterItem } from './query-engine';
 export { Fjader, render } from './spec';
 export type { FjaderSpec, FjaderHandle, RenderOptions } from './spec';

package/dist/index.js

@@ -25,5 +25,8 @@ export * from './components';
 export * from './transforms';
 export * from './sql/bin';
 export * from './types';
+// Selection state: the registry initFjader() returns, for code outside it (is anything
+// brushed? which groups exist?). Read from the same context.
+export { getFilterGroups } from './query-engine';
 // Spec-driven rendering API
 export { Fjader, render } from './spec';

package/dist/interactors/Interval1D.svelte

@@ -97,7 +97,12 @@
 			column: typeof resolvedField === 'string' ? resolvedField : (resolvedField?.toString() ?? ''),
 			label: typeof resolvedField === 'string' ? resolvedField : resolvedField?.toString(),
 			values: value ? [(value as number[])[0], (value as number[])[1]] : []
-		})
+		}),
+		// The clause was removed from outside (clearAll, a filter pill): take the
+		// rectangle down too, which only this control holds.
+		onCleared: () => {
+			if (brush.active) clearBrush();
+		}
 	});
 
 	// Pointer state (reused to avoid GC)

package/dist/interactors/Interval2D.svelte

@@ -97,7 +97,12 @@
 			yColumn: resolvedYField,
 			xValues: (value as unknown[][])?.[0],
 			yValues: (value as unknown[][])?.[1]
-		})
+		}),
+		// The clause was removed from outside (clearAll, a filter pill): take the
+		// rectangle down too, which only this control holds.
+		onCleared: () => {
+			if (brush.active) clearBrush();
+		}
 	});
 
 	// Pointer state (reused to avoid GC)

package/dist/interactors/ParallelAxisSource.svelte

@@ -83,7 +83,16 @@
 			column,
 			label: column,
 			values: value ? [(value as number[])[0], (value as number[])[1]] : []
-		})
+		}),
+		// The clause was removed from outside (clearAll, a filter pill): take this
+		// axis's rectangle down too, which only ParallelBrushes' state holds.
+		onCleared: () => {
+			const axis = axes.get(column);
+			if (!axis) return;
+			axis.brush.clear();
+			axis.lastEmitted.min = null;
+			axis.lastEmitted.max = null;
+		}
 	});
 
 	axes.set(column, { handle, brush: new BrushState1D(), lastEmitted: { min: null, max: null } });