@fjader/svelte 0.2.1 → 0.2.3

package/dist/components/rendering/ParallelLines.svelte

@@ -1,15 +1,18 @@
 <script lang="ts">
+	import { activityReads, colorActivityWGSL } from './activity-reads';
+	import { PARALLEL_MAX_AXES, UNIFORM_BYTES } from './uniform-sizes';
 	import { getContext, onMount, onDestroy } from 'svelte';
 	import { RendererHost } from './RendererHost.svelte';
 	import { getGPUContext } from '../../gpu';
 	import { getCurveWGSL, getCurveResolution } from '../../gpu/CurveShaderLib';
+	import { NAN_WGSL } from '../../gpu/NanShaderLib';
 	import { DEFAULT_STROKE_COLOR } from '../../scales/color-utils';
 	import type { ChartContext, CurveType, WebGPUCanvasContext } from '../../types';
 
-	const MAX_AXES = 16;
-	const UNIFORM_SIZE = 176; // bytes, must match WGSL struct layout
+	const MAX_AXES = PARALLEL_MAX_AXES;
+	const UNIFORM_SIZE = UNIFORM_BYTES.parallelConfig;
 	// One ScaleParam (16 bytes) per axis, filled by the coordinator.
-	const AXIS_SCALES_SIZE = MAX_AXES * 16;
+	const AXIS_SCALES_SIZE = UNIFORM_BYTES.parallelAxisScales;
 
 	// Both x and y so ScaleTemplateSystem generates scaleX(), scaleLinearY(), pixelsToClip()
 	const rendererDefinition = {
@@ -31,6 +34,8 @@
 		colorValueData?: Float32Array | null;
 		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];
 		axisOrder: number[];
 		/** Each axis's scale id, in data (not visual) order. */
@@ -50,6 +55,7 @@
 		colorValueData = null,
 		colorMode = 0,
 		colorScaleIndex = 0,
+		groupIndex = 0,
 		constantColor = DEFAULT_STROKE_COLOR,
 		axisOrder,
 		axisScaleIds,
@@ -86,6 +92,9 @@
 	// (N-1) segments × resolution sub-quads × 6 verts + N circles × 6 verts
 	const vertexCount = $derived((axisCount - 1) * 6 * resolution + axisCount * 6);
 
+	/** The selection activity this shader reads; routing reads the same table. */
+	const ACTIVITY_READS = activityReads('parallel');
+
 	// evaluateCurve() and CURVE_RESOLUTION are prepended from CurveShaderLib.
 	// With linear (resolution=1): single quad per segment, identical to original.
 	// With bump-x (resolution=128): smooth S-curves between axes, adaptive.
@@ -100,7 +109,7 @@
     opacity: f32,
     colorMode: u32,
     colorScaleIndex: u32,
-    _pad0: u32,
+    groupIndex: u32,
     _pad1: u32,
     constantColor: vec4<f32>,
     axisOrder: array<vec4<u32>, 4>,
@@ -123,7 +132,7 @@
   // writes; only linear math is applied to them today.
   @group(1) @binding(3) var<uniform> axisScales: array<ScaleParam, ${MAX_AXES}>;
 
-  fn isNaN(v: f32) -> bool { return v != v; }
+  ${NAN_WGSL}
   const DISCARD_POS = vec4<f32>(2.0, 2.0, 2.0, 1.0);
 
   fn getAxisOrder(visualIdx: u32) -> u32 {
@@ -190,7 +199,12 @@
       var output: VertexOutput;
       output.position = pixelsToClip(pos);
       output.colorValue = colorValues[rowIdx];
-      output.alpha = config.opacity;
+      output.alpha = config.opacity * selectionDim(
+        ${colorActivityWGSL(ACTIVITY_READS, {
+					color: 'config.colorMode, config.colorScaleIndex, colorValues[rowIdx]',
+					group: 'config.groupIndex'
+				})}
+      );
       output.circleUV = quadPosition;
       output.circleRadius = halfWidth;
       return output;
@@ -269,7 +283,12 @@
     var output: VertexOutput;
     output.position = pixelsToClip(finalPos);
     output.colorValue = colorValues[rowIdx];
-    output.alpha = config.opacity;
+    output.alpha = config.opacity * selectionDim(
+      ${colorActivityWGSL(ACTIVITY_READS, {
+				color: 'config.colorMode, config.colorScaleIndex, colorValues[rowIdx]',
+				group: 'config.groupIndex'
+			})}
+    );
     output.circleUV = vec2<f32>(-2.0, -2.0);
     output.circleRadius = 0.0;
     return output;
@@ -360,7 +379,8 @@
 		f32[3] = opacity;
 		u32[4] = colorMode;
 		u32[5] = colorScaleIndex;
-		// u32[6], u32[7] = padding
+		u32[6] = groupIndex;
+		// u32[7] = padding
 		f32[8] = constantColor[0];
 		f32[9] = constantColor[1];
 		f32[10] = constantColor[2];

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

@@ -6,6 +6,8 @@ interface Props {
     colorValueData?: Float32Array | null;
     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];
     axisOrder: number[];
     /** Each axis's scale id, in data (not visual) order. */

package/dist/components/rendering/Rects.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';
 
 	const rectRendererDefinition = {
 		x: { concept: 'extent', channels: ['x0', 'x1'] },
@@ -30,7 +32,7 @@
 		COLOR_MODE: 0,
 		COLOR_SCALE_INDEX: 4,
 		INSET: 8,
-		_PAD0: 12,
+		GROUP_INDEX: 12,
 		CONSTANT_COLOR: 16,
 		DX: 32,
 		DY: 36
@@ -49,6 +51,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];
 		inset?: number;
 		dx?: number;
@@ -78,6 +82,7 @@
 		zIndex = 0,
 		colorMode = 0,
 		colorScaleIndex = 0,
+		groupIndex = 0,
 		constantColor = DEFAULT_FILL_COLOR,
 		inset = 0,
 		dx = 0,
@@ -119,13 +124,16 @@
 
 	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
@@ -182,7 +190,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: 'y0',
+					group: 'markConstants.groupIndex'
+				})}
+      );
       return output;
     }
   
@@ -295,14 +310,14 @@
 			// 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);

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

@@ -10,6 +10,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];
     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,93 @@
+/**
+ * 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.
+ */
+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.
+ */
+export declare function markActivityWGSL(reads: ActivityReads, args: {
+    color: string;
+    x: string;
+    y: string;
+    group: string;
+}): string;

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

@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+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.
+ */
+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;