@fjader/svelte 0.2.2 → 0.2.4

package/dist/components/rendering/Rects.svelte

@@ -1,9 +1,12 @@
 <script lang="ts">
+	import { UNIFORM_BYTES } from './uniform-sizes';
 	import { getContext, onMount, onDestroy } from 'svelte';
 	import { RendererHost } from './RendererHost.svelte';
 	import { getGPUContext } from '../../gpu';
 	import { DEFAULT_FILL_COLOR } from '../../scales/color-utils';
 	import type { ChartContext, WebGPUCanvasContext } from '../../types';
+	import type { SplitProp } from '../marks/lifecycle/other-rows.svelte';
+	import { activityReads, markActivityWGSL, otherRowActivityWGSL } from './activity-reads';
 
 	const rectRendererDefinition = {
 		x: { concept: 'extent', channels: ['x0', 'x1'] },
@@ -19,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)
@@ -30,11 +44,12 @@
 		COLOR_MODE: 0,
 		COLOR_SCALE_INDEX: 4,
 		INSET: 8,
-		_PAD0: 12,
+		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 {
@@ -44,11 +59,19 @@
 		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;
 		colorMode?: number;
 		colorScaleIndex?: number;
+		/** The page-wide index of this mark's filter group: which run of a field's activity block it reads. */
+		groupIndex?: number;
 		constantColor?: [number, number, number, number];
 		inset?: number;
 		dx?: number;
@@ -73,11 +96,13 @@
 		y1Data,
 		colorValueData,
 		alphaData,
+		share = null,
 		facetData = null,
 		dataVersion,
 		zIndex = 0,
 		colorMode = 0,
 		colorScaleIndex = 0,
+		groupIndex = 0,
 		constantColor = DEFAULT_FILL_COLOR,
 		inset = 0,
 		dx = 0,
@@ -86,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');
 
@@ -119,18 +149,21 @@
 
 	const rectVertexCount = 6;
 
+	/** The selection activities this shader reads; routing reads the same table. */
+	const ACTIVITY_READS = activityReads('rects');
+
 	const rectsShaderCode = `
     // MarkConstants uniform for per-mark configuration
     struct MarkConstants {
       colorMode: u32,           // 0 = constant, 1 = scale
       colorScaleIndex: u32,     // Index into colorConfigs
       inset: f32,               // Pixel inset on all sides
-      _pad0: u32,
+      groupIndex: u32,          // Page-wide filter group index, for activity reads
       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;
 
@@ -138,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>;
@@ -146,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(
@@ -182,12 +223,47 @@
       var output: VertexOutput;
       output.position = vec4<f32>(normalizedPos.x, -normalizedPos.y, 0.0, 1.0);
       output.colorValue = colorValue;
-      output.alpha = alpha;
+      // 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',
+					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) {
@@ -202,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);
     }
   `
@@ -233,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',
@@ -251,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(() => {
@@ -295,21 +403,22 @@
 			// re-fires once data loads.
 			if (colorMode === 1 && !colorValueData) return;
 
-			const buffer = new ArrayBuffer(48);
+			const buffer = new ArrayBuffer(UNIFORM_BYTES.rectsMarkConstants);
 			const view = new DataView(buffer);
 			const LE = true;
 
 			view.setUint32(UNIFORM_OFFSETS.COLOR_MODE, colorMode, LE);
 			view.setUint32(UNIFORM_OFFSETS.COLOR_SCALE_INDEX, colorScaleIndex, LE);
+			view.setUint32(UNIFORM_OFFSETS.GROUP_INDEX, groupIndex, LE);
 			view.setFloat32(UNIFORM_OFFSETS.INSET, inset, LE);
-			// padding at 12
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 0, constantColor[0], LE);
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 4, constantColor[1], LE);
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 8, constantColor[2], LE);
 			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,11 +6,19 @@ 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;
     colorMode?: number;
     colorScaleIndex?: number;
+    /** The page-wide index of this mark's filter group: which run of a field's activity block it reads. */
+    groupIndex?: number;
     constantColor?: [number, number, number, number];
     inset?: number;
     dx?: number;

package/dist/components/rendering/RuleX.svelte

@@ -1,9 +1,11 @@
 <script lang="ts">
+	import { UNIFORM_BYTES } from './uniform-sizes';
 	import { getContext, onMount, onDestroy } from 'svelte';
 	import { RendererHost } from './RendererHost.svelte';
 	import { getGPUContext } from '../../gpu';
 	import { DEFAULT_FILL_COLOR } from '../../scales/color-utils';
 	import type { ChartContext, WebGPUCanvasContext } from '../../types';
+	import { activityReads, markActivityWGSL } from './activity-reads';
 
 	// Named Bindings — stable indices regardless of hasExtent
 	const BINDINGS = {
@@ -23,7 +25,7 @@
 		COLOR_MODE: 0,
 		COLOR_SCALE_INDEX: 4,
 		STROKE_WIDTH: 8,
-		_PAD0: 12,
+		GROUP_INDEX: 12,
 		CONSTANT_COLOR: 16,
 		_PAD1: 32,
 		_PAD2: 36,
@@ -42,6 +44,8 @@
 		zIndex?: number;
 		colorMode?: number;
 		colorScaleIndex?: number;
+		/** The page-wide index of this mark's filter group: which run of a field's activity block it reads. */
+		groupIndex?: number;
 		constantColor?: [number, number, number, number];
 		strokeWidth?: number;
 		markId?: string;
@@ -58,6 +62,7 @@
 		zIndex = 0,
 		colorMode = 0,
 		colorScaleIndex = 0,
+		groupIndex = 0,
 		constantColor = DEFAULT_FILL_COLOR,
 		strokeWidth = 1,
 		markId = ''
@@ -113,12 +118,15 @@
 	const initializationError = $derived(host.error);
 	let lineGeometryBuffer: GPUBuffer;
 
+	/** The selection activities this shader reads; routing reads the same table. */
+	const ACTIVITY_READS = activityReads('rulex', hasExtent);
+
 	const ruleXShaderCode = `
     struct MarkConstants {
       colorMode: u32,
       colorScaleIndex: u32,
       strokeWidth: f32,
-      _pad0: u32,
+      groupIndex: u32,
       constantColor: vec4<f32>,
       _pad1: f32,
       _pad2: f32,
@@ -173,7 +181,14 @@
       var output: VertexOutput;
       output.position = vec4<f32>(normalizedPos.x, -normalizedPos.y, 0.0, 1.0);
       output.colorValue = colorValue;
-      output.alpha = alpha;
+      output.alpha = alpha * selectionDim(
+        ${markActivityWGSL(ACTIVITY_READS, {
+					color: 'markConstants.colorMode, markConstants.colorScaleIndex, colorValue',
+					x: 'x',
+					y: 'y0',
+					group: 'markConstants.groupIndex'
+				})}
+      );
       return output;
     }
 
@@ -266,14 +281,14 @@
 		if (renderer?.resourcesCreated) {
 			if (colorMode === 1 && !colorValueData) return;
 
-			const buffer = new ArrayBuffer(48);
+			const buffer = new ArrayBuffer(UNIFORM_BYTES.ruleXMarkConstants);
 			const view = new DataView(buffer);
 			const LE = true;
 
 			view.setUint32(UNIFORM_OFFSETS.COLOR_MODE, colorMode, LE);
 			view.setUint32(UNIFORM_OFFSETS.COLOR_SCALE_INDEX, colorScaleIndex, LE);
+			view.setUint32(UNIFORM_OFFSETS.GROUP_INDEX, groupIndex, LE);
 			view.setFloat32(UNIFORM_OFFSETS.STROKE_WIDTH, strokeWidth, LE);
-			// padding at 12
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 0, constantColor[0], LE);
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 4, constantColor[1], LE);
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 8, constantColor[2], LE);

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

@@ -9,6 +9,8 @@ interface Props {
     zIndex?: number;
     colorMode?: number;
     colorScaleIndex?: number;
+    /** The page-wide index of this mark's filter group: which run of a field's activity block it reads. */
+    groupIndex?: number;
     constantColor?: [number, number, number, number];
     strokeWidth?: number;
     markId?: string;

package/dist/components/rendering/RuleY.svelte

@@ -1,9 +1,11 @@
 <script lang="ts">
+	import { UNIFORM_BYTES } from './uniform-sizes';
 	import { getContext, onMount, onDestroy } from 'svelte';
 	import { RendererHost } from './RendererHost.svelte';
 	import { getGPUContext } from '../../gpu';
 	import { DEFAULT_FILL_COLOR } from '../../scales/color-utils';
 	import type { ChartContext, WebGPUCanvasContext } from '../../types';
+	import { activityReads, markActivityWGSL } from './activity-reads';
 
 	// Named Bindings — stable indices regardless of hasExtent
 	const BINDINGS = {
@@ -23,7 +25,7 @@
 		COLOR_MODE: 0,
 		COLOR_SCALE_INDEX: 4,
 		STROKE_WIDTH: 8,
-		_PAD0: 12,
+		GROUP_INDEX: 12,
 		CONSTANT_COLOR: 16,
 		_PAD1: 32,
 		_PAD2: 36,
@@ -42,6 +44,8 @@
 		zIndex?: number;
 		colorMode?: number;
 		colorScaleIndex?: number;
+		/** The page-wide index of this mark's filter group: which run of a field's activity block it reads. */
+		groupIndex?: number;
 		constantColor?: [number, number, number, number];
 		strokeWidth?: number;
 		markId?: string;
@@ -58,6 +62,7 @@
 		zIndex = 0,
 		colorMode = 0,
 		colorScaleIndex = 0,
+		groupIndex = 0,
 		constantColor = DEFAULT_FILL_COLOR,
 		strokeWidth = 1,
 		markId = ''
@@ -112,12 +117,15 @@
 	const initializationError = $derived(host.error);
 	let lineGeometryBuffer: GPUBuffer;
 
+	/** The selection activities this shader reads; routing reads the same table. */
+	const ACTIVITY_READS = activityReads('ruley', hasExtent);
+
 	const ruleYShaderCode = `
     struct MarkConstants {
       colorMode: u32,
       colorScaleIndex: u32,
       strokeWidth: f32,
-      _pad0: u32,
+      groupIndex: u32,
       constantColor: vec4<f32>,
       _pad1: f32,
       _pad2: f32,
@@ -172,7 +180,14 @@
       var output: VertexOutput;
       output.position = vec4<f32>(normalizedPos.x, -normalizedPos.y, 0.0, 1.0);
       output.colorValue = colorValue;
-      output.alpha = alpha;
+      output.alpha = alpha * selectionDim(
+        ${markActivityWGSL(ACTIVITY_READS, {
+					color: 'markConstants.colorMode, markConstants.colorScaleIndex, colorValue',
+					x: 'x0',
+					y: 'y',
+					group: 'markConstants.groupIndex'
+				})}
+      );
       return output;
     }
 
@@ -265,14 +280,14 @@
 		if (renderer?.resourcesCreated) {
 			if (colorMode === 1 && !colorValueData) return;
 
-			const buffer = new ArrayBuffer(48);
+			const buffer = new ArrayBuffer(UNIFORM_BYTES.ruleYMarkConstants);
 			const view = new DataView(buffer);
 			const LE = true;
 
 			view.setUint32(UNIFORM_OFFSETS.COLOR_MODE, colorMode, LE);
 			view.setUint32(UNIFORM_OFFSETS.COLOR_SCALE_INDEX, colorScaleIndex, LE);
+			view.setUint32(UNIFORM_OFFSETS.GROUP_INDEX, groupIndex, LE);
 			view.setFloat32(UNIFORM_OFFSETS.STROKE_WIDTH, strokeWidth, LE);
-			// padding at 12
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 0, constantColor[0], LE);
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 4, constantColor[1], LE);
 			view.setFloat32(UNIFORM_OFFSETS.CONSTANT_COLOR + 8, constantColor[2], LE);

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

@@ -9,6 +9,8 @@ interface Props {
     zIndex?: number;
     colorMode?: number;
     colorScaleIndex?: number;
+    /** The page-wide index of this mark's filter group: which run of a field's activity block it reads. */
+    groupIndex?: number;
     constantColor?: [number, number, number, number];
     strokeWidth?: number;
     markId?: string;

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

@@ -0,0 +1,111 @@
+/**
+ * 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';
+/** The renderers that read selection activity. Text reads it on the CPU. */
+export type ActivityRenderer = 'dots' | 'rects' | 'rulex' | 'ruley' | 'lines' | 'areas' | 'parallel' | 'text';
+export interface ActivityReads {
+    readonly color: boolean;
+    readonly x: boolean;
+    readonly y: boolean;
+}
+/**
+ * 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;
+/**
+ * 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 declare function ruleHasExtent(lo: unknown, hi: unknown): boolean;
+/** The renderer a mark type draws with, or null for one that reads no activity. */
+export declare function rendererForMark(markType: string): ActivityRenderer | 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 declare function readsFor(reads: ActivityReads, keys: {
+    color: string | null;
+    x: string | null;
+    y: string | null;
+}): readonly string[];
+/** A mark that reads no activity. Shared, so its reads never look changed. */
+export declare const NO_READS: readonly string[];
+/**
+ * How a mark responds to selections in its filter group (the `selectionResponse`
+ * prop). 'auto', the default: a categorical selection on a field the mark draws
+ * by (its band axes, its ordinal colour) dims it, and any other selection
+ * filters it. 'filter': every selection filters it, even on a field it draws
+ * by, so its aggregates are recomputed for the subset (top N within a region).
+ */
+export type SelectionResponse = 'auto' | 'filter';
+export { NO_GROUP };
+/** A mark's reads under its selection response: none for 'filter', which never dims. */
+export declare function readsForResponse(response: SelectionResponse | undefined, reads: readonly string[]): readonly string[];
+/** The group index a mark's shader reads activity with: NO_GROUP for 'filter'. */
+export declare function groupIndexForResponse(response: SelectionResponse | undefined, groupIndex: number): number;
+/**
+ * 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 declare function colorActivityWGSL(reads: ActivityReads, args: {
+    color: string;
+    group: string;
+}): string;
+/**
+ * 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 declare function otherRowActivityWGSL(reads: ActivityReads, args: {
+    color: string;
+    group: string;
+    skipColor: string;
+}): string;
+export declare function markActivityWGSL(reads: ActivityReads, args: {
+    color: string;
+    x: string;
+    y: string;
+    group: string;
+}): string;