@fjader/svelte 0.2.4 → 0.2.5

package/dist/scales/ChartScales.svelte.js

@@ -55,6 +55,7 @@ export class ChartScales {
         this.gpuCoordinator = config.gpuCoordinator;
         this.#scaleRegistry = config.scaleRegistry;
         this.#getFacetChartIds = config.getFacetChartIds ?? null;
+        this.#entranceGateOff = config.entranceGate?.onOpen(() => this.#markScalesEntered()) ?? null;
         if (!this.#scaleRegistry) {
             console.error('ChartScales initialized without scaleRegistry!');
         }
@@ -271,14 +272,10 @@ export class ChartScales {
                 xScaleConfig.__fitDomain = this.chartId;
             const neededXScale = this.#scaleRegistry.getOrCreateScale(xKey, xConfig.type, xScaleConfig, this.chartId);
             if (this.#xScaleInstance !== neededXScale) {
-                const wasReplacement = !!this.#xScaleInstance;
                 if (this.#xScaleInstance) {
                     this.#scaleRegistry.deregisterChart(this.#xScaleInstance, this.chartId);
                 }
                 this.#xScaleInstance = neededXScale;
-                if (wasReplacement && neededXScale instanceof LinearScaleState) {
-                    neededXScale.zoomInEffect.enabled = false;
-                }
             }
         }
         if (yConfig) {
@@ -290,16 +287,13 @@ export class ChartScales {
                 yScaleConfig.__fitDomain = this.chartId;
             const neededYScale = this.#scaleRegistry.getOrCreateScale(yKey, yConfig.type, yScaleConfig, this.chartId);
             if (this.#yScaleInstance !== neededYScale) {
-                const wasReplacement = !!this.#yScaleInstance;
                 if (this.#yScaleInstance) {
                     this.#scaleRegistry.deregisterChart(this.#yScaleInstance, this.chartId);
                 }
                 this.#yScaleInstance = neededYScale;
-                if (wasReplacement && neededYScale instanceof LinearScaleState) {
-                    neededYScale.zoomInEffect.enabled = false;
-                }
             }
         }
+        this.#markScalesEntered();
     }
     scaleConfigurations = $derived.by(() => {
         try {
@@ -438,6 +432,7 @@ export class ChartScales {
                 this.#scaleRegistry.deregisterChart(scale, this.chartId);
         }
         this.#parallelScaleInstances = next;
+        this.#markScalesEntered();
         this.#parallelAxisOrder = wanted.map((_, i) => i);
         if (next.size > 0)
             this.#ensureReorder().resetSprings();
@@ -764,7 +759,30 @@ export class ChartScales {
             setBinStepMultiplier: (v) => coordinator.setBinStepMultiplier(v)
         };
     }
+    /**
+     * A scale snaps every extent change until a chart drawing it has its marks'
+     * first data in, so the domain is that chart's whole extent when it enters,
+     * and its axes show no ticks before then (the domain is a placeholder).
+     * Marked here when the chart's entrance gate opens, and again whenever the
+     * scale instances change after that.
+     */
+    #entranceGateOff = null;
+    #markScalesEntered() {
+        const gate = this.config.entranceGate;
+        if (gate && !gate.opened)
+            return;
+        for (const scale of [
+            this.#xScaleInstance,
+            this.#yScaleInstance,
+            ...this.#parallelScaleInstances.values()
+        ]) {
+            if (scale instanceof LinearScaleState && !scale.entered)
+                scale.entered = true;
+        }
+    }
     destroy() {
+        this.#entranceGateOff?.();
+        this.#entranceGateOff = null;
         this.#reorder?.destroy();
         this.#reorder = null;
         if (this.#scaleRegistry) {

package/dist/scales/ColorScaleState.svelte.d.ts

@@ -1,6 +1,6 @@
 import type { RGBA, D3ColorScale } from './color-utils';
 import type { FieldIdentity } from '../query-engine/categorical-identity';
-import type { ColorScaleType } from '../types';
+import type { ColorDomainValue, ColorScaleType } from '../types';
 import type { ScaleRegistry } from './ScaleRegistry.svelte';
 import { type GPUCoordinator } from '../gpu/GPUCoordinator.svelte';
 import type { SlotSource } from '../gpu/identity-slot-packing';
@@ -13,6 +13,10 @@ interface ColorScaleConfig {
     midpoint?: number;
     constant?: number;
     exponent?: number;
+    /** Explicit palette colours, in place of the scheme's. */
+    range?: readonly string[] | null;
+    /** Values pinned to palette positions: pinnedDomain[i] draws range[i]. */
+    pinnedDomain?: readonly ColorDomainValue[] | null;
 }
 /**
  * Reactive state for a GPU-backed color scale.
@@ -118,9 +122,9 @@ export declare class ColorScaleState {
      * the new one and simply mean other categories.
      */
     setIdentity(identity: FieldIdentity): void;
-    /** True once this scale's channel carries dim ids rather than palette indices. */
     /** The field's live id <-> value bijection, once adopted. */
     get identity(): FieldIdentity | null;
+    /** True once this scale's channel carries dim ids rather than palette indices. */
     get hasIdentity(): boolean;
     /**
      * Source value for a channel id — the decode side of the encode the query
@@ -134,6 +138,18 @@ export declare class ColorScaleState {
      * Update the scheme. Triggers GPU re-upload.
      */
     setScheme(newScheme: string): void;
+    /**
+     * Set explicit palette colours and pinned values, or clear them with nulls.
+     * Triggers GPU re-upload.
+     *
+     * The ranks are cleared: they were handed out under the old mapping, and a
+     * new pin means the author has just said which value takes which colour.
+     */
+    setRange(range: readonly string[] | null, pinnedDomain: readonly ColorDomainValue[] | null): void;
+    /** The explicit palette colours, or null for the scheme's. */
+    get range(): readonly string[] | null;
+    /** The pinned values, or null when ranks follow the domain's sorted order. */
+    get pinnedDomain(): readonly ColorDomainValue[] | null;
     /**
      * Update the normalization transform. Triggers GPU re-upload.
      * Called when the user changes the color scale type (e.g., linear → symlog)

package/dist/scales/ColorScaleState.svelte.js

@@ -78,6 +78,17 @@ export class ColorScaleState {
      * stop meaning anything and holding colours to them would be wrong.
      */
     #paletteRank = new Map();
+    /**
+     * Explicit palette colours (`range` on the colour prop), or null for the
+     * scheme's. Ordinal only.
+     */
+    #range = null;
+    /**
+     * Values pinned to palette positions (`domain` on the colour prop): value i
+     * takes rank i, in place of its position in the sorted domain. Values outside
+     * it draw the null colour. Null when ranks follow the domain, the default.
+     */
+    #pinned = null;
     #nextRank = 0;
     /**
      * id -> rank as a dense array, packed into the shared identity slot table so
@@ -179,6 +190,8 @@ export class ColorScaleState {
         this.#midpoint = config.midpoint;
         this.#constant = config.constant ?? 1;
         this.#exponent = config.exponent ?? 1;
+        this.#range = config.range?.length ? [...config.range] : null;
+        this.#pinned = config.pinnedDomain?.length ? [...config.pinnedDomain] : null;
         this.#registry = registry;
         this.#gpuCoordinator = gpuCoordinator;
         // Explicit type wins, fallback to inference from scheme
@@ -373,7 +386,9 @@ export class ColorScaleState {
             this.#refreshRanks();
             this.#d3Scale = this.#hasRanks()
                 ? this.#buildRankedOrdinalScale()
-                : createD3Scale(this.#scheme, this.domain, { reverse: this.#reverse });
+                : this.#range || this.#pinned
+                    ? this.#buildExplicitOrdinalScale()
+                    : createD3Scale(this.#scheme, this.domain, { reverse: this.#reverse });
             this.#uploadOrdinal();
         }
         else {
@@ -457,42 +472,58 @@ export class ColorScaleState {
         if (hadIdentity !== this.hasIdentity && this.domain.length > 0)
             this.#uploadToGPU();
     }
-    /** True once this scale's channel carries dim ids rather than palette indices. */
     /** The field's live id <-> value bijection, once adopted. */
     get identity() {
         return this.#identity ?? null;
     }
+    /** True once this scale's channel carries dim ids rather than palette indices. */
     get hasIdentity() {
         return this.isOrdinal && (this.#identity?.present ?? false);
     }
-    /**
-     * Hand a rank to every domain category that does not have one, then rebuild
-     * the dense table. Existing ranks are never touched, which is what makes a
-     * colour survive its category disappearing.
-     */
     /** The value -> position map, rebuilt only when the domain array changes. */
     #categoryPositions() {
         if (this.#categoryMap && this.#categoryMapFor === this.domain)
             return this.#categoryMap;
         const map = new Map();
-        this.domain.forEach((cat, i) => map.set(cat, i));
+        // Pinned values index the palette directly; anything else maps to -1.
+        const positions = this.#pinned ?? this.domain;
+        positions.forEach((cat, i) => map.set(cat, i));
         this.#categoryMap = map;
         this.#categoryMapFor = this.domain;
         return map;
     }
+    /**
+     * Hand a rank to every domain category that does not have one, then rebuild
+     * the dense table. Existing ranks are never touched, which is what makes a
+     * colour survive its category disappearing.
+     */
     #refreshRanks() {
         const identity = this.#identity;
         if (!identity?.present)
             return;
         this.#ranksVersion = identity.version;
-        for (const value of this.domain) {
-            const id = identity.ids.get(value);
-            if (id === undefined || this.#paletteRank.has(id))
-                continue;
-            // The NULL category takes no palette slot (see below).
-            if (id === identity.nullId)
-                continue;
-            this.#paletteRank.set(id, this.#nextRank++);
+        const pinned = this.#pinned;
+        if (pinned) {
+            // Pinned: value i takes rank i. Values that have not appeared yet keep
+            // their rank reserved, the same way a filtered-out category does. A
+            // pinned null is the one way the NULL category takes a palette colour.
+            pinned.forEach((value, rank) => {
+                const id = ColorScaleState.#idOf(identity, value);
+                if (id !== undefined && !this.#paletteRank.has(id))
+                    this.#paletteRank.set(id, rank);
+            });
+            this.#nextRank = Math.max(this.#nextRank, pinned.length);
+        }
+        else {
+            for (const value of this.domain) {
+                const id = identity.ids.get(value);
+                if (id === undefined || this.#paletteRank.has(id))
+                    continue;
+                // The NULL category takes no palette slot (see below).
+                if (id === identity.nullId)
+                    continue;
+                this.#paletteRank.set(id, this.#nextRank++);
+            }
         }
         const table = new Float32Array(identity.values.length);
         table.fill(-1);
@@ -503,9 +534,18 @@ export class ColorScaleState {
         // The NULL category and the Other buckets draw the null colour: no palette
         // slot, so they read as missing data or "the rest" and shift no category's
         // colour. Not -1, which the shader draws transparent: a category outside
-        // this scale's domain.
-        if (identity.nullId !== null)
+        // this scale's domain. With a pinned domain, so does every category the
+        // pin leaves out: drawn, but plainly not one of the named ones.
+        if (pinned) {
+            for (const value of this.domain) {
+                const id = identity.ids.get(value);
+                if (id !== undefined && table[id] === -1)
+                    table[id] = NULL_COLOR_RANK;
+            }
+        }
+        if (identity.nullId !== null && !this.#paletteRank.has(identity.nullId)) {
             table[identity.nullId] = NULL_COLOR_RANK;
+        }
         for (const id of identity.synthetic)
             if (id < table.length)
                 table[id] = NULL_COLOR_RANK;
@@ -519,6 +559,39 @@ export class ColorScaleState {
     #hasRanks() {
         return this.hasIdentity && this.#paletteRank.size > 0;
     }
+    /**
+     * The dim id of a pinned value. Dim values keep the driver's type (an
+     * INTEGER column's are numbers, a BIGINT's may be bigints), while a pinned
+     * domain is whatever the author wrote, or JSON produced: `0` against `0n`,
+     * `'1'` against `1`. An exact match wins; failing that, the first value with
+     * the same string form.
+     */
+    static #idOf(identity, value) {
+        const exact = identity.ids.get(value);
+        if (exact !== undefined)
+            return exact;
+        if (value === null)
+            return identity.nullId ?? undefined;
+        const key = String(value);
+        const i = identity.values.findIndex((v) => v !== null && String(v) === key);
+        return i < 0 ? undefined : i;
+    }
+    /** The palette's colours: the explicit range, else the scheme's. */
+    #colors() {
+        const colors = this.#range ?? getOrdinalColors(this.#scheme) ?? [];
+        return this.#reverse ? [...colors].reverse() : colors;
+    }
+    /**
+     * The CPU scale for an explicit range or pinned domain before identity has
+     * landed, indexed the way #categoryPositions indexes the GPU's palette.
+     */
+    #buildExplicitOrdinalScale() {
+        const colors = this.#colors();
+        const positions = this.#pinned ?? this.domain;
+        return scaleOrdinal()
+            .domain(positions.map(String))
+            .range(positions.map((_, i) => colors[i % colors.length]));
+    }
     /**
      * An ordinal scale whose range is permuted to match the palette ranks, so
      * `getColor(value)` returns the colour the GPU actually draws.
@@ -529,9 +602,7 @@ export class ColorScaleState {
      * happening to be domain order.
      */
     #buildRankedOrdinalScale() {
-        let colors = getOrdinalColors(this.#scheme) ?? [];
-        if (this.#reverse)
-            colors = [...colors].reverse();
+        const colors = this.#colors();
         const identity = this.#identity;
         const range = this.domain.map((value) => {
             const id = identity.ids.get(value);
@@ -558,7 +629,7 @@ export class ColorScaleState {
     /** Called from #uploadToGPU only, which has refreshed the ranks. */
     #uploadOrdinal() {
         // Bake and upload palette
-        const paletteData = bakePalette(this.#scheme, { reverse: this.#reverse });
+        const paletteData = bakePalette(this.#range ?? this.#scheme, { reverse: this.#reverse });
         this.#gpuCoordinator.writeColorPalette(this.#paletteSlot, paletteData);
         // Build and upload config struct
         // paletteSize is the modulus the shader wraps a rank with, so it has to
@@ -570,7 +641,9 @@ export class ColorScaleState {
         // Capped at 32, the palette's size, so a chart with more categories than
         // that wraps as it always has. Floored at 1: this is a u32 modulus and 0
         // is undefined behaviour in WGSL.
-        const rankSpace = this.hasIdentity ? this.#nextRank : this.domain.length;
+        const rankSpace = this.hasIdentity
+            ? this.#nextRank
+            : (this.#pinned?.length ?? this.domain.length);
         const config = this.#buildColorConfig({
             type: 0, // ORDINAL
             paletteOffset: this.#paletteSlot * 32,
@@ -668,6 +741,40 @@ export class ColorScaleState {
             this.#registry.invalidateChartsUsingScale(this);
         }
     }
+    /**
+     * Set explicit palette colours and pinned values, or clear them with nulls.
+     * Triggers GPU re-upload.
+     *
+     * The ranks are cleared: they were handed out under the old mapping, and a
+     * new pin means the author has just said which value takes which colour.
+     */
+    setRange(range, pinnedDomain) {
+        const nextRange = range?.length ? [...range] : null;
+        const nextPinned = pinnedDomain?.length ? [...pinnedDomain] : null;
+        if (sameList(nextRange, this.#range) && sameList(nextPinned, this.#pinned))
+            return;
+        this.#range = nextRange;
+        this.#pinned = nextPinned;
+        this.#paletteRank.clear();
+        this.#nextRank = 0;
+        this.#categoryMap = null;
+        this._version++;
+        // CPU state, rebuilt here rather than left to the upload, which needs a
+        // coordinator: a legend reads the ranks too.
+        this.#refreshRanks();
+        if (this.domain.length > 0) {
+            this.#uploadToGPU();
+            this.#registry.invalidateChartsUsingScale(this);
+        }
+    }
+    /** The explicit palette colours, or null for the scheme's. */
+    get range() {
+        return this.#range;
+    }
+    /** The pinned values, or null when ranks follow the domain's sorted order. */
+    get pinnedDomain() {
+        return this.#pinned;
+    }
     /**
      * Update the normalization transform. Triggers GPU re-upload.
      * Called when the user changes the color scale type (e.g., linear → symlog)
@@ -759,9 +866,7 @@ export class ColorScaleState {
         const rank = id === undefined ? undefined : this.#paletteRank.get(id);
         if (rank === undefined)
             return ColorScaleState.NULL_COLOR;
-        let colors = getOrdinalColors(this.#scheme) ?? [];
-        if (this.#reverse)
-            colors = [...colors].reverse();
+        const colors = this.#colors();
         // Same wrap the shader applies, so an over-32 palette agrees too.
         return colors.length ? colors[rank % colors.length] : ColorScaleState.NULL_COLOR;
     }
@@ -819,3 +924,10 @@ export class ColorScaleState {
             `now belong to another scale. Register the holder's chart id.`);
     }
 }
+function sameList(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b || a.length !== b.length)
+        return false;
+    return a.every((v, i) => v === b[i]);
+}

package/dist/scales/LinearScaleState.svelte.d.ts

@@ -6,11 +6,6 @@ export interface LinearScaleOptions {
         chartsUsing(scale: unknown): string[];
     } | null;
     disableZoom?: boolean;
-    zoomInEffect?: boolean;
-    zoomInFactor?: number;
-    zoomInSpringConfig?: {
-        stiffness?: number;
-    };
 }
 export interface GpuScaleState {
     domainMin: number;
@@ -68,11 +63,6 @@ export declare class LinearScaleState {
         min: number;
     };
     disableZoom: boolean;
-    zoomInEffect: {
-        enabled: boolean;
-        factor: number;
-        stiffness: number;
-    };
     /**
      * Charts to redraw while this scale animates, asked of the registry rather
      * than written into this object.
@@ -157,6 +147,13 @@ export declare class LinearScaleState {
      * @param visualCenter - Cursor position as a visual fraction [0,1] (0=left/bottom, 1=right/top)
      */
     accumulateZoom(visualCenter: number, scaleFactor: number): void;
+    /**
+     * True once a chart drawing this scale has its marks' first data in (its
+     * entrance gate opened). Until then every extent change snaps, and the
+     * axes draw no ticks: the domain is a placeholder, [0, 100], and showing
+     * it, or springing out of it, is the zoom-in on load by another route.
+     */
+    entered: boolean;
     /**
      * Reset zoom to show full extent.
      */

package/dist/scales/LinearScaleState.svelte.js

@@ -1,6 +1,7 @@
 // =============================================================================
 // LinearScaleState.svelte.ts - Refactored with SpringPair physics
 // =============================================================================
+import { noteTransition, transitionsObserved } from '../animation/transition-log';
 import { scaleLinear } from 'd3-scale';
 import { extent as d3Extent } from 'd3-array';
 import { SpringPair, SPRING_PRESETS } from '../animation';
@@ -12,7 +13,6 @@ const SCALE_SPRING_PRESETS = {
     pan: SPRING_PRESETS.pan.stiffness, // 600 - responsive dragging
     zoom: SPRING_PRESETS.zoom.stiffness, // 400 - smooth zoom
     reset: SPRING_PRESETS.reset.stiffness, // 150 - gentle reset animation
-    zoomIn: 200, // Initial zoom-in effect
     externalDomain: 600 // Brush-driven domain tracking (snappy, like pan)
 };
 // =============================================================================
@@ -112,12 +112,6 @@ export class LinearScaleState {
         center: 0,
         hasUpdates: false
     };
-    // --- Zoom-In Effect Config ---
-    zoomInEffect = {
-        enabled: true,
-        factor: 5,
-        stiffness: SCALE_SPRING_PRESETS.zoomIn
-    };
     // --- Affected Charts Cache (set by GPUCoordinator) ---
     /**
      * Charts to redraw while this scale animates, asked of the registry rather
@@ -170,17 +164,6 @@ export class LinearScaleState {
         // Store zoom limits
         this.zoomLimits.max = zoomLimits[0];
         this.zoomLimits.min = zoomLimits[1];
-        // Zoom-in effect options
-        if (options.zoomInEffect !== undefined) {
-            this.zoomInEffect.enabled = options.zoomInEffect;
-        }
-        if (options.zoomInFactor !== undefined) {
-            this.zoomInEffect.factor = options.zoomInFactor;
-        }
-        if (options.zoomInSpringConfig !== undefined) {
-            this.zoomInEffect.stiffness =
-                options.zoomInSpringConfig.stiffness || SCALE_SPRING_PRESETS.zoomIn;
-        }
         // Create domain accessor object
         this.domain = this.#createDomainAccessor();
     }
@@ -404,6 +387,13 @@ export class LinearScaleState {
         this.#setStiffness(SCALE_SPRING_PRESETS.zoom);
         this.#ensureAnimating();
     }
+    /**
+     * True once a chart drawing this scale has its marks' first data in (its
+     * entrance gate opened). Until then every extent change snaps, and the
+     * axes draw no ticks: the domain is a placeholder, [0, 100], and showing
+     * it, or springing out of it, is the zoom-in on load by another route.
+     */
+    entered = $state(false);
     /**
      * Reset zoom to show full extent.
      */
@@ -422,28 +412,20 @@ export class LinearScaleState {
                 instant = true;
             }
         }
-        if (instant || (!this.ready && !this.zoomInEffect.enabled)) {
-            // Instant update - skip animation entirely.
-            // Also snaps when zoom-in is disabled on a not-yet-ready scale
-            // (e.g., column reassignment — no point animating from default domain).
-            this.#setInstant(min, max);
+        if (transitionsObserved()) {
+            noteTransition('domain', instant || !this.entered, () => this._affectedChartsArray, this.name);
         }
-        else if (!this.ready && this.zoomInEffect.enabled) {
-            // First time - do zoom-in effect from expanded view
-            this.#setStiffness(this.zoomInEffect.stiffness);
-            const center = (min + max) / 2;
-            const range = max - min;
-            const factor = this.zoomInEffect.factor;
-            const expandedMin = center - (range * factor) / 2;
-            const expandedMax = center + (range * factor) / 2;
-            // Set current position to expanded, target to actual
-            this.#springPair.set(this.toSpringSpace(expandedMin), this.toSpringSpace(expandedMax));
-            this.#setTarget(min, max); // #setTarget transforms internally
-            // Initialize render values so first frame renders correctly
-            this.#renderMin = expandedMin;
-            this.#renderMax = expandedMax;
-            this.#updateGpuState();
-            this.#ensureAnimating();
+        if (instant || !this.entered) {
+            // Instant update - skip animation entirely. A scale's first domain
+            // snaps too: the viewport does not move on load. A chart's entrance
+            // is its data arriving (see the chart's entrance clock), not the
+            // camera travelling to it. So does every extent until a chart drawing
+            // this scale has its marks in (`entered`): the axes take the union of
+            // that chart's extents before it enters. Not `ready`, which several
+            // paths set before the first extent lands (time scales, field stats),
+            // and the scale then sprang from its placeholder domain. A chart that
+            // shares the scale and lands later springs it, as later data does.
+            this.#setInstant(min, max);
         }
         else {
             // Normal reset

package/dist/scales/ScaleGeneration.svelte.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Counts replacements of a chart's x and y scales: a defined scale id giving
+ * way to a different one, as a relabelled axis or a re-resolved scale type
+ * does. Marks rebuild their lifecycle on it.
+ *
+ * Not the ids themselves, which marks tracked before: a mark's own lifecycle
+ * registers the scale requirements that make the scales resolve, so the ids
+ * went from undefined to defined right after every mark was built, and every
+ * lifecycle was rebuilt once for nothing (its scale registration redone, and a
+ * tooltip-table DROP sent to DuckDB). The first resolution is not a change.
+ *
+ * Owned by the chart, not by ChartScales: the container recreates its
+ * ChartScales when a label or the layout changes, and a counter on that
+ * instance would restart and miss the swap. A recreated ChartScales is itself
+ * a replacement: it starts with no scale requirements (the container replays
+ * only those queued before the first one existed), so marks must rebuild to
+ * register with it. Its first resolution after that is not counted again.
+ */
+import type { ChartScales } from './ChartScales.svelte';
+/** The ChartScales and last defined ids seen, and the replacements counted so far. */
+export interface ScaleIds {
+    owner: unknown;
+    x: string | undefined;
+    y: string | undefined;
+    count: number;
+}
+/**
+ * Fold the current ChartScales and ids into `seen`. Counts a replacement when
+ * the ChartScales itself is a different one than before (it then forgets the
+ * ids: the new one's first resolution is part of the same replacement), or
+ * when an axis that had a defined id now has a different defined one.
+ * Undefined is neither a change nor remembered. Mutates and returns `seen`.
+ */
+export declare function foldScaleIds(seen: ScaleIds, owner: unknown, x: string | undefined, y: string | undefined): ScaleIds;
+export declare class ScaleGeneration {
+    #private;
+    constructor(scales: () => ChartScales | null | undefined);
+    /**
+     * Replacements so far. Reactive: reads the chart's current ChartScales and
+     * scale ids. The derived updates `#seen` as it computes, which is safe only
+     * because folding the same input twice changes nothing: a recompute that
+     * sees unchanged ids counts nothing. Reads skipped between changes can
+     * merge two replacements into one count, which is fine: marks only need to
+     * know that it changed (a recreated scale has a new id, so a scale that
+     * goes away and returns is still seen as different).
+     */
+    value: number;
+}

package/dist/scales/ScaleGeneration.svelte.js

@@ -0,0 +1,42 @@
+/**
+ * Fold the current ChartScales and ids into `seen`. Counts a replacement when
+ * the ChartScales itself is a different one than before (it then forgets the
+ * ids: the new one's first resolution is part of the same replacement), or
+ * when an axis that had a defined id now has a different defined one.
+ * Undefined is neither a change nor remembered. Mutates and returns `seen`.
+ */
+export function foldScaleIds(seen, owner, x, y) {
+    if (owner && seen.owner && owner !== seen.owner) {
+        seen.count++;
+        seen.x = seen.y = undefined;
+    }
+    if (owner)
+        seen.owner = owner;
+    if ((x && seen.x && x !== seen.x) || (y && seen.y && y !== seen.y))
+        seen.count++;
+    if (x)
+        seen.x = x;
+    if (y)
+        seen.y = y;
+    return seen;
+}
+export class ScaleGeneration {
+    #scales;
+    #seen = { owner: undefined, x: undefined, y: undefined, count: 0 };
+    constructor(scales) {
+        this.#scales = scales;
+    }
+    /**
+     * Replacements so far. Reactive: reads the chart's current ChartScales and
+     * scale ids. The derived updates `#seen` as it computes, which is safe only
+     * because folding the same input twice changes nothing: a recompute that
+     * sees unchanged ids counts nothing. Reads skipped between changes can
+     * merge two replacements into one count, which is fine: marks only need to
+     * know that it changed (a recreated scale has a new id, so a scale that
+     * goes away and returns is still seen as different).
+     */
+    value = $derived.by(() => {
+        const scales = this.#scales();
+        return foldScaleIds(this.#seen, scales, scales?.xScaleState?.id, scales?.yScaleState?.id).count;
+    });
+}

package/dist/scales/ScaleRegistry.svelte.js

@@ -266,7 +266,9 @@ export class ScaleRegistry {
                         reverse: config.reverse ?? false,
                         midpoint: config.midpoint,
                         constant: config.constant,
-                        exponent: config.exponent
+                        exponent: config.exponent,
+                        range: config.range,
+                        pinnedDomain: config.pinnedDomain
                     }, this, this.#gpuCoordinator));
                 }
                 else if (type === 'size') {

package/dist/scales/SlotTransition.d.ts

@@ -150,7 +150,21 @@ export declare class SlotTransition implements SlotSource {
      * one). The space is unchanged, existing ids keep their paths, and the copy
      * on resize is exactly right.
      */
-    layout(space: 'ids' | 'positions', order: ArrayLike<number> | null, idCount: number): void;
+    layout(space: 'ids' | 'positions', order: ArrayLike<number> | null, idCount: number, 
+    /**
+     * Land at once rather than travel: every id takes its new slot, leavers
+     * go and entrants appear. For a catch-up result, a change nobody just
+     * made. It settles the clock, which the marks on this axis share: their
+     * values land with it, which is what the caller wants for its chart.
+     */
+    instant?: boolean): void;
+    /**
+     * The latest layout's number if it landed at once (an instant layout), 0
+     * otherwise. What follows from a layout, like a band grid's line opacity,
+     * lands with it, once: a number, so a consumer lands only its first write
+     * after that layout.
+     */
+    get landedLayout(): number;
     /**
      * Start a transition without changing what is displayed.
      *