@fjader/svelte 0.2.2 → 0.2.3

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;

package/dist/components/rendering/uniform-sizes.js

@@ -0,0 +1,28 @@
+/**
+ * The byte size of every renderer's uniform struct, as WGSL lays it out.
+ *
+ * Renderers allocate their uniform buffers from these, and BaseGPURenderer
+ * sizes its stand-in from the largest: a binding not yet written is bound to
+ * the stand-in, and WebGPU rejects a draw whose uniform buffer is smaller than
+ * the struct it declares, which loses every chart's frame in that submit. A
+ * comment saying "must fit the largest struct" went stale the first time a
+ * struct grew, so uniform-sizes.test.ts derives each size from the shader
+ * source and fails when one drifts.
+ */
+/** Axes a parallel coordinates chart can hold: its axis arrays are sized for it. */
+export const PARALLEL_MAX_AXES = 16;
+/** One ScaleParam: four f32. */
+const SCALE_PARAM_BYTES = 16;
+export const UNIFORM_BYTES = {
+    dotsMarkConstants: 48,
+    rectsMarkConstants: 48,
+    ruleXMarkConstants: 48,
+    ruleYMarkConstants: 48,
+    linesMarkConstants: 64,
+    areasMarkConstants: 64,
+    gridLineRuleConstants: 32,
+    parallelConfig: 176,
+    parallelAxisScales: PARALLEL_MAX_AXES * SCALE_PARAM_BYTES
+};
+/** The stand-in uniform buffer: as large as the largest struct any renderer binds. */
+export const UNIFORM_STAND_IN_BYTES = Math.max(...Object.values(UNIFORM_BYTES));

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

@@ -1,3 +1,4 @@
+import type { SelectionResponse } from '../components/rendering/activity-reads';
 import type { FieldRef, LODConfig, SortConfig, ColorScheme, CurveType, Transform } from '../types';
 import type { MarkLODSurface } from '../lod/rung-types';
 export interface MarkEntry {
@@ -23,6 +24,7 @@ export interface MarkEntry {
     scheme?: ColorScheme;
     transforms?: Transform[];
     selection?: string;
+    selectionResponse?: SelectionResponse;
     limit?: number;
     preferredXScaleType?: string | null;
     preferredYScaleType?: string | null;

package/dist/gpu/ColorScaleShaderLib.d.ts

@@ -15,6 +15,18 @@ export declare const COLOR_CONFIG_BYTES = 48;
 export declare const COLOR_CONFIG_SLOT_BASE_OFFSET = 32;
 /** `slotBase` meaning "this channel already carries a palette index". */
 export declare const NO_SLOT_TABLE = 4294967295;
+/**
+ * The rank of a category an ordinal colour scale draws in the null colour: it
+ * takes no palette slot, so it reads as missing data and shifts no category's
+ * colour. The NULL category and the Other buckets. -1, by contrast, is a category
+ * outside this scale's domain, which draws transparent.
+ */
+export declare const NULL_COLOR_RANK = -2;
+/**
+ * How many colour configs the buffer holds. A uniform array has a fixed length
+ * in WGSL, so the shader declaration and the buffer size both read this.
+ */
+export declare const MAX_COLOR_SLOTS = 64;
 export declare const COLOR_SCALE_STRUCTS = "\nstruct ColorConfig {\n    domainMin: f32,         // byte 0  \u2014 pre-transformed for non-linear types\n    domainMax: f32,         // byte 4  \u2014 pre-transformed for non-linear types\n    rampOffset: u32,        // byte 8\n    paletteOffset: u32,     // byte 12\n    paletteSize: u32,       // byte 16\n    scaleType: u32,         // byte 20 \u2014 scheme rendering type (ordinal/sequential/diverging/cyclical)\n    transformType: u32,     // byte 24 \u2014 normalization transform (linear/log/symlog/sqrt/pow)\n    transformParam: f32,    // byte 28 \u2014 symlog constant C, or pow exponent\n    slotBase: u32,          // byte 32 \u2014 base into identitySlots, or NO_SLOT_TABLE\n    _pad0: u32,             // byte 36\n    _pad1: u32,             // byte 40\n    _pad2: u32,             // byte 44\n}\n\n/**\n * slotBase when this scale's channel already carries a palette index rather\n * than an identity id. Distinct from base 0, which is a real block \u2014 the\n * permanently empty one \u2014 so it cannot be confused with \"not placed\".\n */\nconst NO_SLOT_TABLE: u32 = 0xFFFFFFFFu;\n\nconst COLOR_SCALE_ORDINAL: u32 = 0u;\nconst COLOR_SCALE_SEQUENTIAL: u32 = 1u;\nconst COLOR_SCALE_DIVERGING: u32 = 2u;\nconst COLOR_SCALE_CYCLICAL: u32 = 3u;\n\nconst COLOR_TRANSFORM_LINEAR: u32 = 0u;\nconst COLOR_TRANSFORM_LOG: u32 = 1u;\nconst COLOR_TRANSFORM_SYMLOG: u32 = 2u;\nconst COLOR_TRANSFORM_SQRT: u32 = 3u;\nconst COLOR_TRANSFORM_POW: u32 = 4u;\n";
-export declare const COLOR_SCALE_BINDINGS = "\n@group(2) @binding(1) var<storage, read> colorConfigs: array<ColorConfig>;\n@group(2) @binding(2) var<storage, read> colorRamps: array<vec4<f32>>;\n@group(2) @binding(3) var<storage, read> ordinalPalettes: array<vec4<f32>>;\n";
+export declare const COLOR_SCALE_BINDINGS = "\n@group(2) @binding(1) var<uniform> colorConfigs: array<ColorConfig, 64>;\n@group(2) @binding(2) var<storage, read> colorRamps: array<vec4<f32>>;\n@group(2) @binding(3) var<storage, read> ordinalPalettes: array<vec4<f32>>;\n";
 export declare const COLOR_SCALE_FUNCTIONS: string;