@fjader/svelte 0.2.4 → 0.2.5

package/dist/components/marks/lifecycle/domain-queries.d.ts

@@ -16,7 +16,14 @@ export declare function fetchCategoricalDomains(coordinator: QueryEngine, table:
     y?: DimValue[];
 } | null, 
 /** nulls="drop": the band and facet domains leave out the NULL category. */
-dropNull?: boolean): Promise<number>;
+dropNull?: boolean, 
+/**
+ * True once the setup run that called this has been superseded or its mark
+ * destroyed. Checked at every write, after each query returns: the scales
+ * it would write may have been dropped with a ChartScales the chart has
+ * since replaced.
+ */
+stale?: () => boolean): Promise<number>;
 /**
  * Fetch global min/max extents for aggregated fields using a "sidecar" query.
  * Runs the same aggregation as the main query but without filters, wrapped
@@ -25,6 +32,8 @@ dropNull?: boolean): Promise<number>;
  * Returns `{ globalAggregatesSet: true }` on success so the caller can
  * update its reactive state.
  */
-export declare function fetchGlobalAggregates(coordinator: QueryEngine, table: string, select: Record<string, unknown>, channelsNeedingDataDomain: Set<string>, autoBinNodeCount: number, buildQueryFn: (table: string, config: unknown, filter: unknown[], forMosaic: boolean) => Query, config: unknown, xScaleState: ContinuousScaleState | null, yScaleState: ContinuousScaleState | null, colorScaleState: ColorScaleState | null, markId: string): Promise<{
+export declare function fetchGlobalAggregates(coordinator: QueryEngine, table: string, select: Record<string, unknown>, channelsNeedingDataDomain: Set<string>, autoBinNodeCount: number, buildQueryFn: (table: string, config: unknown, filter: unknown[], forMosaic: boolean) => Query, config: unknown, xScaleState: ContinuousScaleState | null, yScaleState: ContinuousScaleState | null, colorScaleState: ColorScaleState | null, markId: string, 
+/** As for fetchCategoricalDomains: checked before writing the extents. */
+stale?: () => boolean): Promise<{
     globalAggregatesSet: boolean;
 }>;

package/dist/components/marks/lifecycle/domain-queries.js

@@ -12,7 +12,14 @@ import { identityKeyFor } from '../../../query-engine/identity-key';
  */
 export async function fetchCategoricalDomains(coordinator, table, select, actualXScaleType, actualYScaleType, xScaleState, yScaleState, facetBandScale, fx, colorChannel, colorScaleState, sizeChannel, sizeScaleState, seriesScaleState, seriesChannel, bandDomainFromData, markId, explicitDomain, 
 /** nulls="drop": the band and facet domains leave out the NULL category. */
-dropNull = false) {
+dropNull = false, 
+/**
+ * True once the setup run that called this has been superseded or its mark
+ * destroyed. Checked at every write, after each query returns: the scales
+ * it would write may have been dropped with a ChartScales the chart has
+ * since replaced.
+ */
+stale = () => false) {
     const categoriesOf = (key) => {
         const categories = coordinator.categoryValues(key, table);
         return dropNull ? categories.filter((c) => c !== null) : categories;
@@ -70,6 +77,8 @@ dropNull = false) {
         fetches.push((async () => {
             // Idempotent and coalesced — the mark's own setup calls this too.
             await coordinator.ensureColumns(table, { categorical: [identityField] });
+            if (stale())
+                return;
             // This table's categories: the dim spans every table on the field.
             const categories = categoriesOf(identityField.key);
             // A snapshot of the real categories. The scale adopts the live
@@ -128,6 +137,8 @@ dropNull = false) {
         fetches.push((async () => {
             // Idempotent and coalesced — the mark's own setup calls this too.
             await coordinator.ensureColumns(table, { categorical: [facetKey] });
+            if (stale())
+                return;
             const categories = categoriesOf(facetKey.key);
             if (categories.length > 0)
                 facetBandScale.addMark(categories, markId);
@@ -150,7 +161,9 @@ dropNull = false) {
             min_time: min(colExpr),
             max_time: max(colExpr)
         });
-        fetches.push(coordinator.query(q).then((result) => {
+        fetches.push(coordinator.query(q, { cache: true, source: table }).then((result) => {
+            if (stale())
+                return;
             const row = Array.from(result)[0];
             if (row && row.min_time != null && row.max_time != null) {
                 console.log(`[fetchCategoricalDomains] Time extent for ${axis}:`, [
@@ -192,6 +205,8 @@ dropNull = false) {
                     fetches.push((async () => {
                         // Idempotent and coalesced — the mark's own setup calls this too.
                         await coordinator.ensureColumns(table, { categorical: [colorIdentity] });
+                        if (stale())
+                            return;
                         const categories = coordinator.categoryValues(colorIdentity.key);
                         if (categories.length > 0) {
                             colorScaleState.setDomain(categories);
@@ -205,7 +220,9 @@ dropNull = false) {
                     min_color: cast(min(colExpr), 'REAL'),
                     max_color: cast(max(colExpr), 'REAL')
                 });
-                fetches.push(coordinator.query(q).then((result) => {
+                fetches.push(coordinator.query(q, { cache: true, source: table }).then((result) => {
+                    if (stale())
+                        return;
                     const row = Array.from(result)[0];
                     if (row && row.min_color != null && row.max_color != null) {
                         console.log(`[fetchCategoricalDomains] Color domain (sequential):`, [
@@ -226,7 +243,9 @@ dropNull = false) {
             min_radius: cast(min(sqlColumn(String(sizeField))), 'REAL'),
             max_radius: cast(max(sqlColumn(String(sizeField))), 'REAL')
         });
-        fetches.push(coordinator.query(q).then((result) => {
+        fetches.push(coordinator.query(q, { cache: true, source: table }).then((result) => {
+            if (stale())
+                return;
             const row = Array.from(result)[0];
             if (row && row.min_radius != null && row.max_radius != null) {
                 sizeScaleState.setDomain([row.min_radius, row.max_radius]);
@@ -241,6 +260,8 @@ dropNull = false) {
         if (seriesIdentity) {
             fetches.push((async () => {
                 await coordinator.ensureColumns(table, { categorical: [seriesIdentity] });
+                if (stale())
+                    return;
                 const categories = coordinator.categoryValues(seriesIdentity.key);
                 if (categories.length > 0) {
                     seriesScaleState.setDomain(categories);
@@ -250,6 +271,8 @@ dropNull = false) {
     }
     if (fetches.length > 0)
         await Promise.all(fetches);
+    if (stale())
+        return fetches.length;
     // Apply explicit domains after all async fetches — ViewManager columns
     // from color/series scales are now registered, so the band view will
     // include all necessary index columns.
@@ -272,7 +295,9 @@ dropNull = false) {
  * Returns `{ globalAggregatesSet: true }` on success so the caller can
  * update its reactive state.
  */
-export async function fetchGlobalAggregates(coordinator, table, select, channelsNeedingDataDomain, autoBinNodeCount, buildQueryFn, config, xScaleState, yScaleState, colorScaleState, markId) {
+export async function fetchGlobalAggregates(coordinator, table, select, channelsNeedingDataDomain, autoBinNodeCount, buildQueryFn, config, xScaleState, yScaleState, colorScaleState, markId, 
+/** As for fetchCategoricalDomains: checked before writing the extents. */
+stale = () => false) {
     // Only proceed if we have channels needing data-derived domains
     if (channelsNeedingDataDomain.size === 0) {
         console.log(`[${markId}] No aggregated channels, skipping sidecar query`);
@@ -334,7 +359,9 @@ export async function fetchGlobalAggregates(coordinator, table, select, channels
         const sidecarQuery = Query.from(innerQuery).select(outerSelect);
         console.log(`📊 [${markId}] Sidecar query SQL:`, sidecarQuery.toString());
         // Step 3: Execute the query
-        const result = await coordinator.query(sidecarQuery);
+        const result = await coordinator.query(sidecarQuery, { cache: true, source: table });
+        if (stale())
+            return { globalAggregatesSet: false };
         const extents = Array.from(result)[0];
         console.log(`✅ [${markId}] Sidecar results:`, extents);
         // Step 4: Apply extents to scales

package/dist/components/marks/lifecycle/domain-registration.d.ts

@@ -39,5 +39,10 @@ export declare function setInitialContinuousDomains(fieldInfo: Record<string, Fi
 export declare function registerDataDerivedDomains(data: DataAccessor, channelsNeedingDataDomain: Set<string>, additionalChannels: string[], skipDomainUpdateForAxis: string | null, zeroBaseline: {
     x?: boolean;
     y?: boolean;
-} | undefined, actualXScaleType: string, actualYScaleType: string, xScaleState: ContinuousScaleState | null, yScaleState: ContinuousScaleState | null, bandDomainFromData: boolean, xBandScaleState: BandScaleState | null, yBandScaleState: BandScaleState | null, markId: string, isRebinning: boolean, colorScaleState?: ColorScaleState | null): RegisterDomainsResult;
+} | undefined, actualXScaleType: string, actualYScaleType: string, xScaleState: ContinuousScaleState | null, yScaleState: ContinuousScaleState | null, bandDomainFromData: boolean, xBandScaleState: BandScaleState | null, yBandScaleState: BandScaleState | null, markId: string, 
+/**
+ * Whether a scale's change from this result lands without animating: a
+ * catch-up result on a scale no other visible chart draws. Null: animate.
+ */
+instantFor: ((scale: object) => boolean) | null, colorScaleState?: ColorScaleState | null): RegisterDomainsResult;
 export {};

package/dist/components/marks/lifecycle/domain-registration.js

@@ -100,7 +100,12 @@ export function setInitialContinuousDomains(fieldInfo, scaleMap, select, actualX
  * Called from Effect 7 on each data update. Uses positional args to avoid
  * object allocation on the crossfilter hot path.
  */
-export function registerDataDerivedDomains(data, channelsNeedingDataDomain, additionalChannels, skipDomainUpdateForAxis, zeroBaseline, actualXScaleType, actualYScaleType, xScaleState, yScaleState, bandDomainFromData, xBandScaleState, yBandScaleState, markId, isRebinning, colorScaleState) {
+export function registerDataDerivedDomains(data, channelsNeedingDataDomain, additionalChannels, skipDomainUpdateForAxis, zeroBaseline, actualXScaleType, actualYScaleType, xScaleState, yScaleState, bandDomainFromData, xBandScaleState, yBandScaleState, markId, 
+/**
+ * Whether a scale's change from this result lands without animating: a
+ * catch-up result on a scale no other visible chart draws. Null: animate.
+ */
+instantFor, colorScaleState) {
     if (!data || data.length === 0) {
         return { dataDerivedDomainsSet: false, skipDomainUpdateForAxis };
     }
@@ -152,7 +157,8 @@ export function registerDataDerivedDomains(data, channelsNeedingDataDomain, addi
             if (zeroBaseline?.x) {
                 extent = [Math.min(0, extent[0]), Math.max(0, extent[1])];
             }
-            registerExtentOnScale(xScaleState, actualXScaleType, extent, markId, isRebinning, 'X');
+            const instant = !!xScaleState && (instantFor?.(xScaleState) ?? false);
+            registerExtentOnScale(xScaleState, actualXScaleType, extent, markId, instant, 'X');
         }
     }
     // Compute and register Y domain
@@ -166,7 +172,8 @@ export function registerDataDerivedDomains(data, channelsNeedingDataDomain, addi
             if (zeroBaseline?.y) {
                 extent = [Math.min(0, extent[0]), Math.max(0, extent[1])];
             }
-            registerExtentOnScale(yScaleState, actualYScaleType, extent, markId, isRebinning, 'Y');
+            const instant = !!yScaleState && (instantFor?.(yScaleState) ?? false);
+            registerExtentOnScale(yScaleState, actualYScaleType, extent, markId, instant, 'Y');
         }
     }
     // Band scale domain from the query result, for a mark whose axis is decided
@@ -217,7 +224,7 @@ export function registerDataDerivedDomains(data, channelsNeedingDataDomain, addi
                     continue;
                 bandScale.addMark(categories, markId);
             }
-            bandScale.updateDomainFromExtents();
+            bandScale.updateDomainFromExtents({ instant: instantFor?.(bandScale) ?? false });
         }
     }
     // Color domain from query results (needed when sidecar is skipped, e.g. binned marks)
@@ -240,20 +247,14 @@ export function registerDataDerivedDomains(data, channelsNeedingDataDomain, addi
 // ---------------------------------------------------------------------------
 // Internal helper
 // ---------------------------------------------------------------------------
-function registerExtentOnScale(scaleState, scaleType, extent, markId, isRebinning, axisLabel) {
+function registerExtentOnScale(scaleState, scaleType, extent, markId, instant, axisLabel) {
     if (scaleType === 'time' && scaleState?.addOffsetExtent) {
         // Time scale: data is in offset form, use addOffsetExtent
         console.log(`📊 [${markId}] Registering ${axisLabel} domain from data (time offsets):`, extent);
-        scaleState.addOffsetExtent(extent, markId);
+        scaleState.addOffsetExtent(extent, markId, { instant });
     }
     else if (scaleState?.addMark) {
-        // Linear/log/symlog scale: use addMark with instant flag when rebinning
-        if (isRebinning) {
-            console.log(`⚡ [${markId}] Instant ${axisLabel} domain update (rebinning):`, extent);
-        }
-        else {
-            console.log(`📊 [${markId}] Registering ${axisLabel} domain from data:`, extent);
-        }
-        scaleState.addMark(extent, markId, { instant: isRebinning });
+        console.log(`📊 [${markId}] Registering ${axisLabel} domain from data:`, extent);
+        scaleState.addMark(extent, markId, { instant });
     }
 }

package/dist/components/marks/lifecycle/other-rows.svelte.d.ts

@@ -58,8 +58,16 @@ export interface OtherRowsDeps {
     identity: () => Record<string, ChannelIdentity> | null;
     /** The identity key of a band axis, or null when it has none. */
     identityKey: (axis: 'x' | 'y') => string | null;
-    /** The mark is filtered by the selection rather than dimmed by it. */
+    /**
+     * The mark is filtered by every selection (`'filter'`): its Other is
+     * recomputed inside the selection, so a click on it drills down.
+     */
     filtered: () => boolean;
+    /**
+     * A selection can dim the mark (`'auto'`). Not under `'filter'` or
+     * `'ignore'`, whose Other bars get no selected share.
+     */
+    dims: () => boolean;
     /** The mark's plan, or null before its setup completes. */
     plan: () => SplitPlan | null;
     /** The identity key of the mark's ordinal colour scale, or null. */

package/dist/components/marks/lifecycle/other-rows.svelte.js

@@ -135,7 +135,7 @@ export class OtherRows {
      * The band axis whose Other bar splits, or null. Only where a share is what
      * it looks like:
      * - a bar mark ('bary', 'barx') with a topN Other bucket, dimming (not
-     *   'filter', which never dims) and without JS transforms, whose rows would
+     *   'filter' or 'ignore', which never dim) and without JS transforms, whose rows would
      *   no longer line up with the query's;
      * - whose length is the measure topN ranks by, which is what Other sums;
      * - and that measure a bare COUNT or SUM, or a raw column: a mean or a max
@@ -143,7 +143,7 @@ export class OtherRows {
      */
     get #splitAxis() {
         const plan = this.#deps.plan();
-        if (!plan || this.#deps.filtered())
+        if (!plan || !this.#deps.dims())
             return null;
         if (!plan.hasOther || plan.hasJsTransforms)
             return null;

package/dist/components/marks/lifecycle/query-builder.d.ts

@@ -1,6 +1,7 @@
 import { sum, Query, WindowNode, type ExprNode } from '@uwdata/mosaic-sql';
 import type { TransformCompiler } from '../../../transforms/TransformCompiler';
 import type { ColumnSchema } from '../../../query-engine/QueryEngine';
+import type { BinPadding } from '../../../types';
 interface OrderConfig {
     seriesChannel: string | null;
     dimensionChannel: string;
@@ -18,6 +19,14 @@ export interface QueryParts {
      * combination, and cannot recover from a query topN has already wrapped.
      */
     groupKeys: string[] | null;
+    /**
+     * The numeric `bin()` channels and their bins, set by the mark from the
+     * same resolution its bin expressions came from. With them `dense()` pads a
+     * histogram to every bin; preagg reads copy them, so both paths pad alike.
+     */
+    bins?: Record<string, BinPadding> | null;
+    /** The query reads a preagg table that already holds its padding rows. */
+    padded?: boolean;
     orderChannels: string[] | null;
     aliasMap: Map<string, string>;
     /** Channels whose raw config value was a column-name passthrough (string
@@ -74,8 +83,8 @@ export interface AssembleOptions {
 /**
  * Wrap an expression so DuckDB returns a Float32-compatible REAL with NULLs
  * mapped to NaN: COALESCE(CAST(expr AS REAL), 'NaN'::REAL). Arrow columns then
- * have nullCount=0 and clean buffers for zero-copy GPU upload; shaders detect
- * NaN and discard.
+ * have nullCount=0 and clean Float32 buffers that upload to the GPU as they are,
+ * with no per-row JS pass; shaders detect NaN and discard.
  */
 export declare function castReal(expr: unknown): ExprNode;
 /**
@@ -159,5 +168,21 @@ export declare function buildQueryParts(select: Record<string, unknown>, orderCo
  * discarded one level up.
  */
 export declare function outerOrder(preference: string[] | null, alignment: string[] | null): string[] | null;
+/**
+ * Assemble a Query from cached parts + per-call filter.
+ *
+ * Order is fixed and shared by the flat, window-CTE, and preagg paths:
+ *
+ *   SELECT parts.selectDef FROM table [GROUP BY dims]
+ *   WHERE filter AND nullDrops      — on the base scan, so transform CTEs
+ *                                     (topN ranking etc.) see filtered rows
+ *   → SQL transforms (CTE wrapping)
+ *   → [window CTE: outer SELECT applies window fns over the inner result]
+ *   → ORDER BY outerOrder(...)      — alignment, then orderChannels; outermost
+ *   → LIMIT
+ *
+ * Callers decide what is CAST-wrapped by preparing parts.selectDef with
+ * castNumeric(); assembly never inspects expression types.
+ */
 export declare function assembleQuery(opts: AssembleOptions): Query;
 export {};

package/dist/components/marks/lifecycle/query-builder.js

@@ -23,8 +23,8 @@ export function nullDropPredicates(drops, selectDef) {
 /**
  * Wrap an expression so DuckDB returns a Float32-compatible REAL with NULLs
  * mapped to NaN: COALESCE(CAST(expr AS REAL), 'NaN'::REAL). Arrow columns then
- * have nullCount=0 and clean buffers for zero-copy GPU upload; shaders detect
- * NaN and discard.
+ * have nullCount=0 and clean Float32 buffers that upload to the GPU as they are,
+ * with no per-row JS pass; shaders detect NaN and discard.
  */
 export function castReal(expr) {
     return coalesce(cast(expr, 'REAL'), sql `'NaN'::REAL`);
@@ -219,22 +219,6 @@ export function buildQueryParts(select, orderConfig, hasSQLTransforms, passthrou
 // ---------------------------------------------------------------------------
 // Assembly — the one sequence every query path follows
 // ---------------------------------------------------------------------------
-/**
- * Assemble a Query from cached parts + per-call filter.
- *
- * Order is fixed and shared by the flat, window-CTE, and preagg paths:
- *
- *   SELECT parts.selectDef FROM table [GROUP BY dims]
- *   WHERE filter AND nullDrops      — on the base scan, so transform CTEs
- *                                     (topN ranking etc.) see filtered rows
- *   → SQL transforms (CTE wrapping)
- *   → [window CTE: outer SELECT applies window fns over the inner result]
- *   → ORDER BY outerOrder(...)      — alignment, then orderChannels; outermost
- *   → LIMIT
- *
- * Callers decide what is CAST-wrapped by preparing parts.selectDef with
- * castNumeric(); assembly never inspects expression types.
- */
 /** Output aliases a query exposes to whatever wraps it. */
 function selectAliases(query) {
     const sel = query._select;
@@ -283,6 +267,22 @@ export function outerOrder(preference, alignment) {
         add(channel);
     return order;
 }
+/**
+ * Assemble a Query from cached parts + per-call filter.
+ *
+ * Order is fixed and shared by the flat, window-CTE, and preagg paths:
+ *
+ *   SELECT parts.selectDef FROM table [GROUP BY dims]
+ *   WHERE filter AND nullDrops      — on the base scan, so transform CTEs
+ *                                     (topN ranking etc.) see filtered rows
+ *   → SQL transforms (CTE wrapping)
+ *   → [window CTE: outer SELECT applies window fns over the inner result]
+ *   → ORDER BY outerOrder(...)      — alignment, then orderChannels; outermost
+ *   → LIMIT
+ *
+ * Callers decide what is CAST-wrapped by preparing parts.selectDef with
+ * castNumeric(); assembly never inspects expression types.
+ */
 export function assembleQuery(opts) {
     const { table, parts, filter = [], transformCompiler, limit, window, skipRowFilters } = opts;
     const { selectDef, nonAggregateGroupBy, hasAggregates, hasSQLTransforms, orderChannels } = parts;
@@ -299,7 +299,7 @@ export function assembleQuery(opts) {
     }
     let result = q;
     if (hasSQLTransforms) {
-        result = transformCompiler.applyToQuery(q, { groupKeys: parts.groupKeys }, { skipRowFilters });
+        result = transformCompiler.applyToQuery(q, { groupKeys: parts.groupKeys, bins: parts.bins ?? null, padded: parts.padded ?? false }, { skipRowFilters });
     }
     if (window) {
         const outerSelect = {};
@@ -327,7 +327,10 @@ export function assembleQuery(opts) {
             .with({ [window.cteName]: result });
     }
     const alignment = hasSQLTransforms
-        ? transformCompiler.alignment(Object.keys(selectDef), { groupKeys: parts.groupKeys })
+        ? transformCompiler.alignment(Object.keys(selectDef), {
+            groupKeys: parts.groupKeys,
+            bins: parts.bins ?? null
+        })
         : null;
     const order = outerOrder(orderChannels, alignment);
     if (order) {

package/dist/components/marks/utils/MarkColor.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { ColorScaleState } from '../../../scales/ColorScaleState.svelte';
-import type { ColorProp, ChartContext } from '../../../types';
+import type { ColorDomainValue, ColorProp, ChartContext } from '../../../types';
 import type { ScaleRegistry } from '../../../scales/ScaleRegistry.svelte';
 import type { MarkSetupState } from './mark-types';
 interface ColorConfig {
@@ -11,6 +11,8 @@ interface ColorConfig {
     explicitType?: string;
     constant?: number;
     exponent?: number;
+    range?: readonly string[];
+    pinnedDomain?: readonly ColorDomainValue[];
 }
 export declare class MarkColor {
     #private;

package/dist/components/marks/utils/MarkColor.svelte.js

@@ -30,6 +30,10 @@ export class MarkColor {
             const mode = this.#mode;
             const field = this.#field;
             const type = this.config.scaleType;
+            // Again when the chart's scales are replaced: the registry dropped
+            // this one with the old ChartScales (its GPU slots may already be
+            // someone else's), and holding it would write to a destroyed scale.
+            void this.#chartContext.scaleGeneration;
             // Only create scale when type is known (not null)
             if (mode === 'field' && field && this.#scaleRegistry && type !== null) {
                 untrack(() => {
@@ -42,7 +46,9 @@ export class MarkColor {
                         type: type,
                         scheme: this.config.scheme,
                         constant: this.config.constant,
-                        exponent: this.config.exponent
+                        exponent: this.config.exponent,
+                        range: this.config.range,
+                        pinnedDomain: this.config.pinnedDomain
                     }, this.#chartContext.chartId);
                 });
             }
@@ -66,6 +72,21 @@ export class MarkColor {
                 this.scaleState.setScheme(scheme);
             }
         });
+        // 2a. Lifecycle: Update explicit colours (Fast Path - no scale recreation)
+        // Like the scheme, a mark without them leaves a shared scale's alone; one
+        // that drops them (an edited prop) clears what it set.
+        let hadRange = false;
+        $effect(() => {
+            const range = this.config.range;
+            const pinned = this.config.pinnedDomain;
+            const scale = this.scaleState;
+            if (!scale?.isOrdinal)
+                return;
+            const has = !!(range?.length || pinned?.length);
+            if (has || hadRange)
+                scale.setRange(range ?? null, pinned ?? null);
+            hadRange = has;
+        });
         // 2b. Lifecycle: Update Transform (Fast Path - no scale recreation)
         $effect(() => {
             const type = this.config.explicitType;
@@ -148,6 +169,8 @@ export class MarkColor {
         let explicitType;
         let constant;
         let exponent;
+        let range;
+        let pinnedDomain;
         // Handle object wrapper format { field: "species", scheme: "dark2", type: "symlog" }
         if (typeof c === 'object' && 'field' in c && !isNode(c)) {
             field = c.field;
@@ -155,10 +178,15 @@ export class MarkColor {
             explicitType = c.type;
             constant = c.constant;
             exponent = c.exponent;
+            range = c.range;
+            pinnedDomain = c.domain;
         }
         // 1. Determine Type from field semantics + schema (may return null if waiting for schema)
         // If an explicit type is given (log/symlog/sqrt/pow), use it directly.
-        const scaleType = explicitType || this.#resolveScaleType(field);
+        // Explicit colours or pinned values mean categories, whatever the column
+        // type: a 0/1 integer column would otherwise read as continuous.
+        const scaleType = explicitType ||
+            (range?.length || pinnedDomain?.length ? 'ordinal' : this.#resolveScaleType(field));
         // 2. Pass explicit scheme if provided, otherwise undefined (registry will apply default)
         return {
             mode: 'field',
@@ -167,7 +195,9 @@ export class MarkColor {
             scheme: explicitScheme, // undefined if not specified
             explicitType,
             constant,
-            exponent
+            exponent,
+            range,
+            pinnedDomain
         };
     });
     // Separate derived for mode (independent of scheme to avoid unnecessary tracking)

package/dist/components/marks/utils/MarkSeries.svelte.d.ts

@@ -12,8 +12,21 @@ import type { MarkSetupState } from './mark-types';
 export declare class MarkSeries {
     #private;
     scaleState: ColorScaleState | null;
-    constructor(getSeries: () => string | object | null, channelName: string, getSetup: () => MarkSetupState, scaleRegistry: ScaleRegistry, chartContext: ChartContext);
+    constructor(getSeries: () => string | object | null, channelName: string, getSetup: () => MarkSetupState, scaleRegistry: ScaleRegistry, chartContext: ChartContext, getColorScale?: () => ColorScaleState | null);
     selectField: string | object | null;
     data: Float32Array | null;
+    /**
+     * Whether the renderer reads selection activity through the series scale:
+     * 1 for a `z` of its own, a field that carries ids, so a selection on it
+     * dims the other series. 0 without `z` (the series is the colour, read
+     * already), for a `z` on the colour field (the registry hands both
+     * channels one scale, and reading it twice is a load for nothing), and
+     * before the scale has an identity, while its values are not ids yet.
+     * Routing (MarkLifecycleV2's reads) lists the same field in the same
+     * cases, so the mark dims rather than filters exactly when this is 1.
+     */
+    activityMode: number;
+    /** The series scale's colour config index, read when `activityMode` is 1. */
+    activityScaleIndex: number;
     ready: boolean;
 }

package/dist/components/marks/utils/MarkSeries.svelte.js

@@ -15,17 +15,23 @@ export class MarkSeries {
     #setupState;
     #scaleRegistry;
     #chartContext;
+    #colorScale;
     scaleState = $state(null);
-    constructor(getSeries, channelName, getSetup, scaleRegistry, chartContext) {
+    constructor(getSeries, channelName, getSetup, scaleRegistry, chartContext, getColorScale = () => null) {
         this.#seriesProp = getSeries;
         this.#channelName = channelName;
         this.#setupState = getSetup;
         this.#scaleRegistry = scaleRegistry;
         this.#chartContext = chartContext;
+        this.#colorScale = getColorScale;
         // Lifecycle: Create/Destroy Scale
         // Series grouping is always ordinal
         $effect(() => {
             const field = this.#field;
+            // Again when the chart's scales are replaced: the registry dropped
+            // this one with the old ChartScales (its GPU slots may already be
+            // someone else's), and holding it would write to a destroyed scale.
+            void this.#chartContext.scaleGeneration;
             if (field && this.#scaleRegistry) {
                 untrack(() => {
                     // Use raw field name - registry deduplicates automatically
@@ -89,6 +95,24 @@ export class MarkSeries {
         }
         return this.scaleState.processDataForGPU(raw);
     });
+    /**
+     * Whether the renderer reads selection activity through the series scale:
+     * 1 for a `z` of its own, a field that carries ids, so a selection on it
+     * dims the other series. 0 without `z` (the series is the colour, read
+     * already), for a `z` on the colour field (the registry hands both
+     * channels one scale, and reading it twice is a load for nothing), and
+     * before the scale has an identity, while its values are not ids yet.
+     * Routing (MarkLifecycleV2's reads) lists the same field in the same
+     * cases, so the mark dims rather than filters exactly when this is 1.
+     */
+    activityMode = $derived.by(() => {
+        const scale = this.scaleState;
+        if (this.#channelName !== 'z' || !scale?.hasIdentity)
+            return 0;
+        return scale === this.#colorScale() ? 0 : 1;
+    });
+    /** The series scale's colour config index, read when `activityMode` is 1. */
+    activityScaleIndex = $derived(this.scaleState?.gpuIndex ?? 0);
     // Ready when: no field (single series) or scale is ready
     ready = $derived(!this.#field || (this.scaleState?.ready ?? false));
 }

package/dist/components/marks/utils/MarkSize.svelte.js

@@ -18,6 +18,10 @@ export class MarkSize {
         $effect(() => {
             const mode = this.#mode;
             const field = this.#field;
+            // Again when the chart's scales are replaced: the registry dropped
+            // this one with the old ChartScales (its GPU slots may already be
+            // someone else's), and holding it would write to a destroyed scale.
+            void this.#chartContext.scaleGeneration;
             if (mode === 'field' && field && this.#scaleRegistry) {
                 untrack(() => {
                     this.scaleState = this.#scaleRegistry.getOrCreateScale(field, 'size', { range: this.#rangeProp() }, this.#chartContext.chartId);

package/dist/components/marks/utils/reactive-config.d.ts

@@ -12,6 +12,6 @@ import type { MarkEntry } from '../../../config/ChartConfig.svelte';
  * @param entry - The mark entry (reactive props from ChartConfig)
  * @param opts.resolveFitDomain - Getter for resolved fitDomain (deferred read)
  */
-export declare function buildReactiveConfig(entry: Partial<Pick<MarkEntry, 'sort' | 'limit' | 'domain' | 'tooltip' | 'tip' | 'fitDomain' | 'selectionResponse' | 'nulls' | 'contributeDomain'>>, opts?: {
+export declare function buildReactiveConfig(entry: Partial<Pick<MarkEntry, 'sort' | 'limit' | 'domain' | 'tooltip' | 'tip' | 'fitDomain' | 'selectionResponse' | 'nulls' | 'contributeDomain' | 'holdsEntrance'>>, opts?: {
     resolveFitDomain?: () => 'x' | 'y' | boolean | undefined;
 }): ReactiveConfig;

package/dist/components/marks/utils/reactive-config.js

@@ -19,6 +19,9 @@ export function buildReactiveConfig(entry, opts) {
         get limit() {
             return entry.limit;
         },
+        get holdsEntrance() {
+            return entry.holdsEntrance;
+        },
         get domain() {
             return entry.domain ?? null;
         },