@fjader/svelte 0.2.2 → 0.2.4

package/dist/gpu/MorphedChannels.js

@@ -1,6 +1,39 @@
 import { RESOLVE_IMMEDIATE_SIZE, RESOLVE_WORKGROUP, resolvePipelineFor } from './ResolveShader';
 import { TransitionClock } from '../animation/TransitionClock';
 import { immediatesSupported } from './immediates';
+/**
+ * Channels of one mark that morph between data updates rather than replacing
+ * outright.
+ *
+ * Each holds three buffers where a static channel holds one: `from` and `to` are
+ * read by a compute pass, and `resolved = mix(from, to, t)` is what the vertex
+ * stage binds — in place of the static buffer, not in addition to it. So
+ * animating a channel costs the vertex stage nothing, which is what makes it
+ * affordable on a mark already at the device's storage-buffer limit.
+ *
+ * THE FOLD. When a transition restarts, whatever is on screen becomes the new
+ * `from`. On screen is the resolved buffer as last dispatched, so the fold is a
+ * buffer copy, and it reads neither `from` nor `to` — which is what lets data
+ * land at any moment, in any order relative to anything else. Writing it as
+ * `from = mix(from, to, t)` would need the OLD `to`, making the order of two
+ * writes load-bearing and silently wrong if they ever swap.
+ *
+ * THE SNAP. Some updates have nothing to travel from: the first one, a buffer
+ * that had to be reallocated, and a row set that is not the one being animated.
+ * Those copy `to` over `from`, which makes the mix the identity for every t.
+ *
+ * THE CLOCK. A mark ADOPTS the band scale's clock when it has one, so a bar's
+ * height travels on the same number as its slot — two clocks with two velocities
+ * desynchronise on a retarget, and the bar reaches its rank before or after it
+ * finishes growing. It OWNS one otherwise. Adoption is safe across marks because
+ * a mark with no new data folds to where it already is and does not move.
+ */
+/**
+ * The coordinator's slice this needs. Structural, so tests can supply a fake.
+ * It is also the loop an owned clock joins — the clock does that itself.
+ */
+/** No bindings: the default for `write`'s `land`. */
+const NO_BINDINGS = [];
 /**
  * A cheap fingerprint of the band ids, per update.
  *
@@ -87,8 +120,13 @@ export class MorphedChannels {
      *
      * All channels in one call, so one update starts one transition. Returns
      * whether any buffer was (re)allocated, which the caller must rebind.
+     *
+     * `land`: bindings whose new values take effect at once while the rest
+     * travel. For a channel whose change is shown some other way at that moment
+     * (an Other bar's split, when both sides of it look the same): sliding it
+     * would draw a movement nothing asked for.
      */
-    write(rowIds, channels) {
+    write(rowIds, channels, land = NO_BINDINGS) {
         const key = alignmentKey(rowIds);
         let travels = this.#alignmentKey === key;
         this.#alignmentKey = key;
@@ -100,6 +138,7 @@ export class MorphedChannels {
                 reallocated = true;
             }
             channel.count = data.byteLength >> 2;
+            channel.land = land.includes(binding);
             this.#device.queue.writeBuffer(channel.to, 0, data);
         }
         // A fresh buffer holds nothing that was ever on screen, so there is
@@ -158,8 +197,10 @@ export class MorphedChannels {
             return;
         for (let i = 0; i < channels.length; i++) {
             const channel = channels[i];
-            if (snap) {
+            if (snap || channel.land) {
+                // A landed channel: from = to, so the mix is its new value at any t.
                 encoder.copyBufferToBuffer(channel.to, 0, channel.from, 0, channel.size);
+                channel.land = false;
             }
             else if (this.#foldPending) {
                 // A transition interrupted mid-flight continues from where it is,
@@ -225,7 +266,8 @@ export class MorphedChannels {
             resolved: make('resolved'),
             size,
             count: 0,
-            bindGroup: null
+            bindGroup: null,
+            land: false
         };
         this.#channels.set(binding, channel);
         this.#channelList = [...this.#channels.values()];

package/dist/gpu/ResolveShader.d.ts

@@ -6,8 +6,8 @@
  * are bound to the compute pipeline; the render stages bind `resolved` alone.
  * So an animated channel REPLACES a vertex binding rather than adding one, and
  * animating any number of channels leaves that stage's budget where it was —
- * which is what makes this affordable on a mark that already sits at the
- * default limit of 8.
+ * which is what makes this affordable on a mark that already uses 7 of the
+ * default 8 storage buffers (Rects).
  *
  * ONE KERNEL FOR BOTH, because the two differ only in where a range starts. A
  * value channel is one mark's rows in buffers of their own, so it starts at 0.

package/dist/gpu/ResolveShader.js

@@ -7,8 +7,8 @@ import { isNanExpr } from './NanShaderLib';
  * are bound to the compute pipeline; the render stages bind `resolved` alone.
  * So an animated channel REPLACES a vertex binding rather than adding one, and
  * animating any number of channels leaves that stage's budget where it was —
- * which is what makes this affordable on a mark that already sits at the
- * default limit of 8.
+ * which is what makes this affordable on a mark that already uses 7 of the
+ * default 8 storage buffers (Rects).
  *
  * ONE KERNEL FOR BOTH, because the two differ only in where a range starts. A
  * value channel is one mark's rows in buffers of their own, so it starts at 0.

package/dist/gpu/ScaleTemplateSystem.d.ts

@@ -36,6 +36,9 @@ interface ShaderResult {
  * `ScaleParam`, 16 bytes each. Every layout declares the same size because a
  * draw requires every declared byte to have been set, and the pass sets them
  * once, before its first draw.
+ *
+ * Immediates carry state shared across the pass and read by several marks: the
+ * chart's scales and settings. 64 bytes are available on M-series Macs.
  */
 export declare const CHART_SCALE_IMMEDIATE_SIZE = 32;
 /**
@@ -66,6 +69,22 @@ export declare class ScaleTemplateSystem {
      * @private
      */
     _buildDeclarations(xFragment: ScaleFragment, yFragment: ScaleFragment): string;
+    /**
+     * `bandActivityX(value, group)` and `bandActivityY(value, group)`: how
+     * selected a band or point axis's category is in the mark's filter group,
+     * 0..1, for selection dimming.
+     *
+     * Emitted for every shader, so a renderer can call both without knowing its
+     * scale types: an axis that is not band or point returns 1.0. On a band or
+     * point axis the value is an identity id and the chart's scale carries its
+     * block base in p4, as for the slot lookup. A missing category (-1) or a NaN
+     * is fully active, checked before the cast, since u32() of a negative or NaN
+     * float is indeterminate in WGSL.
+     */
+    _buildBandActivityHelpers(scaleTypes: {
+        x: string;
+        y: string;
+    }): string;
     /**
      * The shared slot table, and the lookup into it.
      *

package/dist/gpu/ScaleTemplateSystem.js

@@ -1,6 +1,9 @@
 // src/lib/gpu/ScaleTemplateSystem.ts
 import { COLOR_SCALE_STRUCTS, COLOR_SCALE_BINDINGS, COLOR_SCALE_FUNCTIONS } from './ColorScaleShaderLib';
 import { SIZE_SCALE_STRUCTS, SIZE_SCALE_BINDINGS, SIZE_SCALE_FUNCTIONS } from './SizeScaleShaderLib';
+import { NO_GROUP } from './identity-slot-packing';
+import { isNanExpr } from './NanShaderLib';
+import { DEFAULT_INACTIVE_OPACITY } from '../scales/ActivityTable';
 /**
  * Scale fragment definitions
  * Each scale type provides: declaration, function call, and implementation
@@ -175,10 +178,10 @@ const SCALE_FRAGMENTS = {
 					rangeMax
 				);
 				
-				// Return center of band
-				// X: left to right (index 0 at left)
-				// Y: bottom to top (index 0 at bottom, matching D3 convention)
-				${axis === 'y' ? 'return rangeMax - bandLayout.x - bandLayout.y * 0.5;' : 'return rangeMin + bandLayout.x + bandLayout.y * 0.5;'}
+				// Return center of band, slot 0 at the start of the range on both
+				// axes: the left on x, the top on y, so a y band axis reads top-down
+				// like a list and its exit (one past the last slot) is the list's end.
+				return rangeMin + bandLayout.x + bandLayout.y * 0.5;
 			}
   	`,
         bufferLayout: {
@@ -280,6 +283,9 @@ function _scaleFunctionName(scaleType, axis) {
  * `ScaleParam`, 16 bytes each. Every layout declares the same size because a
  * draw requires every declared byte to have been set, and the pass sets them
  * once, before its first draw.
+ *
+ * Immediates carry state shared across the pass and read by several marks: the
+ * chart's scales and settings. 64 bytes are available on M-series Macs.
  */
 export const CHART_SCALE_IMMEDIATE_SIZE = 32;
 /**
@@ -370,6 +376,7 @@ export class ScaleTemplateSystem {
       // ===== 3. HELPER FUNCTIONS =====
       
       ${this._buildSlotTableHelpers()}
+      ${this._buildBandActivityHelpers(scaleTypes)}
       ${bandHelpers}
       ${implementations}
       ${scaleFunctions}
@@ -409,6 +416,24 @@ export class ScaleTemplateSystem {
       };
       var<immediate> chartScales: ChartScales;
 
+      // Selection dimming: a mark's activity mapped to an opacity, with
+      // inactive categories at DEFAULT_INACTIVE_OPACITY. selectionOpacity in
+      // ActivityTable.ts is its CPU twin, for band labels and legend entries,
+      // and both read the same constant so they cannot drift apart.
+      const SELECTION_DIM_STRENGTH: f32 = ${(1 - DEFAULT_INACTIVE_OPACITY).toFixed(6)};
+      fn selectionDim(activity: f32) -> f32 {
+        return 1.0 - SELECTION_DIM_STRENGTH * (1.0 - activity);
+      }
+
+      // A mark's activities combined: colour, and band for marks on band axes.
+      // The least active wins rather than the product, so a bar whose colour
+      // and band are the same field fades on the same curve as its label
+      // instead of twice as fast. At rest every activity is 0 or 1, where the
+      // two agree.
+      fn markActivity(color: f32, bandX: f32, bandY: f32) -> f32 {
+        return min(color, min(bandX, bandY));
+      }
+
       // The ONE place that says where a chart's scales come from. Every
       // consumer reads through these — scaleX/scaleY, the bandwidth helpers,
       // and mark code that needs the raw params. A mark with scales of its own
@@ -423,6 +448,45 @@ export class ScaleTemplateSystem {
     `;
         return `${structDef}\n${chartScaleDeclaration}`;
     }
+    /**
+     * `bandActivityX(value, group)` and `bandActivityY(value, group)`: how
+     * selected a band or point axis's category is in the mark's filter group,
+     * 0..1, for selection dimming.
+     *
+     * Emitted for every shader, so a renderer can call both without knowing its
+     * scale types: an axis that is not band or point returns 1.0. On a band or
+     * point axis the value is an identity id and the chart's scale carries its
+     * block base in p4, as for the slot lookup. A missing category (-1) or a NaN
+     * is fully active, checked before the cast, since u32() of a negative or NaN
+     * float is indeterminate in WGSL.
+     */
+    _buildBandActivityHelpers(scaleTypes) {
+        const helper = (axis, type) => {
+            if (type !== 'band' && type !== 'point') {
+                return `fn bandActivity${axis}(value: f32, group: u32) -> f32 {
+      return 1.0;
+    }
+    fn bandFreeActivity${axis}(group: u32) -> f32 {
+      return 1.0;
+    }`;
+            }
+            return `fn bandActivity${axis}(value: f32, group: u32) -> f32 {
+      if (value < 0.0 || ${isNanExpr('value')}) {
+        return 1.0;
+      }
+      return identityActivity(u32(chartScale${axis}().p4), group, u32(value));
+    }
+    fn bandFreeActivity${axis}(group: u32) -> f32 {
+      return identityFreeActivity(u32(chartScale${axis}().p4), group);
+    }`;
+        };
+        return `
+    // ===== BAND SELECTION ACTIVITY =====
+    ${helper('X', scaleTypes.x)}
+
+    ${helper('Y', scaleTypes.y)}
+    `;
+    }
     /**
      * The shared slot table, and the lookup into it.
      *
@@ -459,12 +523,12 @@ export class ScaleTemplateSystem {
     }
 
     fn identitySlot(base: u32, id: u32) -> f32 {
-      // Block layout: [count, slot0, slot1, ...]. The count is what makes a
-      // block self-describing, so an id past this scale's end is discarded
-      // instead of reading into the next scale's slots. It survives the resolve
-      // exactly because it holds the same value in both halves, and the kernel
-      // returns equal ends as they are — u32() truncates, so an inexact mix
-      // would drop the last id.
+      // Block layout: [count, actRef, n, slot0, slot1, ...]. The count is what
+      // makes a block self-describing, so an id past this scale's end is
+      // discarded instead of reading into the next scale's slots. It survives
+      // the resolve exactly because it holds the same value in both halves, and
+      // the kernel returns equal ends as they are — u32() truncates, so an
+      // inexact mix would drop the last id.
       let count = u32(identitySlots[base]);
       if (id >= count) {
         return -1.0;
@@ -473,7 +537,43 @@ export class ScaleTemplateSystem {
       // both halves, so the resolve wrote -1 without a branch; one that is
       // leaving holds a real slot in both, which is what lets it travel. The
       // scale normalises that before packing, so nothing here re-derives it.
-      return identitySlots[base + 1u + id];
+      return identitySlots[base + 3u + id];
+    }
+
+    fn identityActivity(base: u32, group: u32, id: u32) -> f32 {
+      // How selected this id is in the mark's filter group, 1 active and 0
+      // inactive, already resolved at that group's selection clock. The scale
+      // block's header points at its field's activity block (actRef) and says
+      // how many ids it covers (n); the block holds one run of n per group.
+      // Header first, so this is two dependent reads. Past n, or in the empty
+      // block where n is 0, an id is fully active.
+      //
+      // NO_GROUP (a mark whose selectionResponse is 'filter') is fully active,
+      // checked before anything is read, so it never becomes an offset.
+      if (group == ${NO_GROUP}u) {
+        return 1.0;
+      }
+      let actRef = u32(identitySlots[base + 1u]);
+      let n = u32(identitySlots[base + 2u]);
+      if (id >= n) {
+        return 1.0;
+      }
+      return identitySlots[actRef + n * group + id];
+    }
+
+    fn identityFreeActivity(base: u32, group: u32) -> f32 {
+      // The last slot of the group's run, past every id: 1 while the group
+      // selects nothing on the field, 0 while it selects anything, at the
+      // selection clock (FieldActivity's FREE SLOT). 1 without a block.
+      if (group == ${NO_GROUP}u) {
+        return 1.0;
+      }
+      let actRef = u32(identitySlots[base + 1u]);
+      let n = u32(identitySlots[base + 2u]);
+      if (n == 0u) {
+        return 1.0;
+      }
+      return identitySlots[actRef + n * group + n - 1u];
     }
     `;
     }

package/dist/gpu/SizeScaleShaderLib.d.ts

@@ -19,10 +19,10 @@ export declare const MAX_SIZE_SLOTS = 64;
  * changes rather than per frame. Every property that makes a uniform buffer the
  * right container was already true of it.
  *
- * What it buys: the vertex stage sits at the default
- * maxStorageBuffersPerShaderStage of 8 (six mark channels, scale params, and
- * this), and animating a value channel needs a `from` and a `to` where there is
- * now one buffer. Uniform buffers are nowhere near their own default of 12.
+ * What it buys: a slot in the vertex stage's storage budget, the default
+ * maxStorageBuffersPerShaderStage of 8, of which Rects uses 7 (six mark
+ * channels and the identity slot table). Uniform buffers are nowhere near
+ * their own default of 12.
  *
  * Dynamic indexing — `sizeConfigs[scaleIndex]` — is permitted on uniform arrays
  * in WGSL, and the shared slot table already relies on the same thing.

package/dist/gpu/SizeScaleShaderLib.js

@@ -28,10 +28,10 @@ export const MAX_SIZE_SLOTS = 64;
  * changes rather than per frame. Every property that makes a uniform buffer the
  * right container was already true of it.
  *
- * What it buys: the vertex stage sits at the default
- * maxStorageBuffersPerShaderStage of 8 (six mark channels, scale params, and
- * this), and animating a value channel needs a `from` and a `to` where there is
- * now one buffer. Uniform buffers are nowhere near their own default of 12.
+ * What it buys: a slot in the vertex stage's storage budget, the default
+ * maxStorageBuffersPerShaderStage of 8, of which Rects uses 7 (six mark
+ * channels and the identity slot table). Uniform buffers are nowhere near
+ * their own default of 12.
  *
  * Dynamic indexing — `sizeConfigs[scaleIndex]` — is permitted on uniform arrays
  * in WGSL, and the shared slot table already relies on the same thing.

package/dist/gpu/identity-slot-packing.d.ts

@@ -18,12 +18,45 @@
  * on it. It is a pure function over plain arrays and maps, which is
  * what it should have been.
  *
- * Layout: index 0 is a permanent zero-length block, then one block per scale of
- * `[count, slot0, slot1, ...]`. The count header makes each block
- * self-describing, so the shader rejects an id past this scale's end instead of
- * reading into the next scale's slots — ids and the slot table can disagree
- * transiently while a dim appends. Budget is therefore
- * `capacity - 1 - (1 per scale)` slots.
+ * LAYOUT. Index 0 is a permanent empty block `[0, 0, 0]`. Then one SLOT
+ * block per scale, then one ACTIVITY block per live categorical field:
+ *
+ *   scale block: [count, actRef, n, slot0 … slot(count-1)]
+ *   field block: [group 0: act0 … act(n-1), group 1: act0 … act(n-1), …]
+ *
+ * Slots come first so that when the buffer runs out it is activity that is
+ * lost (a mark draws undimmed), never an axis. A field has a block while a
+ * scale draws it, selected on or not, and a field no chart draws any more
+ * frees its space. Tying the block to the selection instead saved that space
+ * on pages with nothing selected, but every select and clear then moved the
+ * block and rewrote every scale block pointing at it, slots included:
+ * measured at about 105000 floats uploaded per click for 20 scales on a
+ * 5000-category field, against 5000 when the block stays.
+ *
+ * KNOWN LIMIT: a field block that does not fit leaves a selection on that
+ * field doing nothing for the marks that dim by it. Routing (the mark's reads,
+ * see activity-reads.ts) still sends them to dim rather than filter, and their
+ * shader finds no activity. Routing does not ask the packer whether a field
+ * got a block, which would tie the query layer to the GPU layout; the packer
+ * warns instead, on load. It takes fields of tens of thousands of ids across
+ * several groups to reach. A buffer that grows on demand is the real fix.
+ *
+ * A scale block's header says how many ids its slots cover (`count`), where its
+ * field's activity block starts (`actRef`) and how many ids that block covers
+ * (`n`). The count is what makes a block self-describing, so the shader rejects
+ * an id past this scale's end instead of reading into the next scale's slots —
+ * ids and the slot table can disagree transiently while a dim appends.
+ *
+ * ACTIVITY says how selected each id is in each filter group (1 active, 0
+ * inactive; see FieldActivity). It belongs to the field, not to the scale:
+ * every scale on one field reads the same block, a mark choosing its group's
+ * half by its group index. So a click rewrites and resolves one half of one
+ * field block, however many scales draw that field. The header comes first so
+ * the shader finds `actRef` and `n` without reading `count`: the activity read
+ * is two dependent loads, as it was when the activity sat after the slots. No
+ * mark holds `actRef`; the packer writes it in the same pass that moves the
+ * field block, so it cannot go stale. A scale with no field to dim points at
+ * the empty block, where `n` is 0 and every id is active.
  *
  * TWO buffers share one set of offsets: `from` is where each id's current
  * transition started and `to` where it is going, and the resolve kernel writes
@@ -31,28 +64,43 @@
  * bindings rather than two runs in one buffer, so the halves line up at the
  * same base and one dispatch per block covers both.
  *
- * `t` is not in the buffers. It is PER SCALE — each band scale has its own
- * driver — and reaches the kernel as an immediate on that scale's dispatch, so
- * a frame where only `t` moved uploads nothing at all.
+ * `t` is not in the buffers. It is per scale (its data clock) and per field
+ * half (that group's selection clock), and reaches the kernel as an immediate
+ * on that range's dispatch, so a frame where only `t` moved uploads nothing.
  */
 /**
  * Floats GLOBALLY across every band and point scale on the page, headers
- * included.
+ * included, and every live field's activity.
  *
  * No longer a binding limit: the tables are storage buffers, bound only to the
- * resolve pass, and the render stages read one resolved storage buffer. The
- * number is left over from when they were 64 KB uniforms, and making the
- * allocation grow on demand (recreate the buffers, rebuild the bind groups) is
- * what would retire it.
+ * resolve pass, and the render stages read one resolved storage buffer. Making
+ * the allocation grow on demand (recreate the buffers, rebuild the bind groups)
+ * is what would retire it.
+ *
+ * Each scale takes `3 + count`; each live field `n × groups`. 65536 fits a
+ * 5000-category field selected on across 3 groups (15000) with its scales
+ * (about 5000 each) several times over. It costs 256 KB per buffer, 768 KB for
+ * the three; the resolve pass dispatches per block, sized by the block, so a
+ * larger buffer costs no GPU time.
  */
-export declare const IDENTITY_SLOT_CAPACITY = 16384;
+export declare const IDENTITY_SLOT_CAPACITY = 65536;
 /**
- * Base of the permanent zero-length block. A scale that cannot be placed points
- * here, so every lookup finds count 0 and discards — which is what the capacity
- * warning claims happens. Pointing it at a stale base instead left the scale
- * rendering, from another scale's slots.
+ * Base of the permanent empty block `[0, 0, 0]`. A scale that cannot be placed
+ * points here, so every lookup finds count 0 and discards, and every activity
+ * read finds n 0 and is fully active. Pointing it at a stale base instead left
+ * the scale rendering, from another scale's slots.
  */
 export declare const IDENTITY_SLOT_EMPTY = 0;
+/**
+ * The group index of a mark that reads no selection activity: identityActivity
+ * returns fully active for it before computing any offset, so it never indexes
+ * past a field block. A mark whose selectionResponse is 'filter' gets it: in
+ * the chart holding a selection's control it keeps its data (the chart skips
+ * its own selection), and this keeps it from dimming there too.
+ */
+export declare const NO_GROUP = 4294967295;
+/** Floats before a scale block's slots: count, actRef, n. */
+export declare const IDENTITY_SLOT_HEADER = 3;
 /**
  * One scale's slot table as the packer reads it: identity id -> display slot,
  * as the two ends of a transition and where between them it is.
@@ -73,17 +121,51 @@ export interface SlotSource {
     /** Bumped whenever `from` or `to` move; the packer re-uploads on it alone. */
     readonly version: number;
 }
-/** A scale with a slot table, as the packer needs it. */
+/**
+ * One group's activity on one field as the packer reads it: 1 active, 0
+ * inactive, as the two ends of a fade. ActivityTable has this shape.
+ *
+ * Its length is not trusted: the packer takes `n` from the field and pads with
+ * 1 or truncates, so a moment where the two disagree cannot shift the half onto
+ * the wrong ids.
+ */
+export interface ActivitySource {
+    readonly from: Float32Array;
+    readonly to: Float32Array;
+    /** 0 -> from, 1 -> to. Its own clock, not the slots'. */
+    readonly t: number;
+    /** Bumped whenever `from` or `to` change. */
+    readonly version: number;
+}
+/**
+ * A scale with a slot table, as the packer needs it: its slots, and the identity
+ * key of its field, whose activity block its header points at. No field (or a
+ * field with no activity block) points it at the empty block.
+ */
 export interface IdentitySlotScale {
     id: string;
     slots: SlotSource;
+    field?: string | null;
 }
 /**
- * One block to resolve this frame: `length` floats from `base`, at `t`.
+ * A categorical field's selection activity, as the packer reads it: one fade
+ * per filter group, over `count` ids. FieldActivity has this shape.
+ */
+export interface ActivityField {
+    readonly key: string;
+    /** Ids covered: the block's `n`. */
+    readonly count: number;
+    /** Group `index`'s fade, or null when that group never selected here (all 1). */
+    fadeOf(index: number): ActivitySource | null;
+}
+/**
+ * One range to resolve this frame: `length` floats from `base`, at `t`. A
+ * scale's slots and each group's half of a field block are separate ranges,
+ * since each has its own `t`.
  *
- * The count header is inside the range rather than skipped: it holds the same
- * value in both halves, so mixing it returns it, and the render stages read
- * their bound from the resolved copy. Pooled in the state and overwritten by
+ * The header is inside the slot range rather than skipped: it holds the same
+ * values in both buffers, so the kernel returns them exactly, and the render
+ * stages read it from the resolved copy. Pooled in the state and overwritten by
  * the next pack.
  */
 export interface ResolveBlock {
@@ -116,30 +198,65 @@ export interface IdentitySlotState {
     offsets: Map<string, number>;
     /** Last packed slotVersion per scale, so a static chart re-uploads nothing. */
     versions: Map<string, number>;
+    /** Last packed count per scale. */
+    counts: Map<string, number>;
+    /** Last packed actRef and n per scale: a field block that moved rewrites the header. */
+    refs: Map<string, number>;
+    ns: Map<string, number>;
+    /**
+     * The `t` each scale's slots were last resolved at, so a still frame
+     * dispatches nothing. A typed array per scale, created once, rather than a
+     * `Map<string, number>`: a fractional `t` stored as a Map value is boxed,
+     * which allocated on every frame of every transition.
+     */
+    resolvedT: Map<string, Float64Array>;
+    /** Per field: its block's base, `n` and the group count it was packed for. */
+    fieldBases: Map<string, number>;
+    fieldNs: Map<string, number>;
+    fieldGroups: Map<string, number>;
+    /** Per field, per group: the fade version last written and the `t` last resolved. */
+    fieldVersions: Map<string, Float64Array>;
+    fieldT: Map<string, Float64Array>;
+    /** The pass a scale last drew each field in: a field no scale draws gets no block. */
+    fieldSeen: Map<string, number>;
+    /** Fields whose block did not fit, warned about once until they fit again. */
+    warnedFields: Set<string>;
     /**
-     * The `t` each scale's block was last resolved at, so a still frame
-     * dispatches nothing and an animating one dispatches only the scales that
-     * are moving.
+     * The pass each scale was last seen in, for the eviction sweep.
+     *
+     * A pass counter rather than a Set cleared every pack: clearing a Set
+     * allocates a new table in V8, which made every frame allocate ~370 bytes
+     * (measured, 20 scales) even when nothing moved. Re-setting an existing key
+     * to a small integer allocates nothing.
      */
-    resolvedT: Map<string, number>;
-    /** Scratch for the eviction sweep; cleared, not reallocated, per pack. */
-    seen: Set<string>;
+    seenPass: Map<string, number>;
+    /** The current pass, a small integer that wraps. */
+    pass: number;
     /** Returned by every pack and overwritten by the next — read it immediately. */
     result: PackResult;
 }
 /** A state with the permanent empty block in place. */
 export declare function createIdentitySlotState(capacity?: number): IdentitySlotState;
 /**
- * Assign every scale a base, write the blocks that moved, and list what to
- * upload and what to resolve.
+ * Assign every field and scale a base, write the ranges that moved, and list
+ * what to upload and what to resolve.
+ *
+ * | Range | Rewritten when | Resolved when |
+ * |---|---|---|
+ * | A field's group half | its base, `n` or the group count moved, or that group's fade version | rewritten, or that fade's `t` moved |
+ * | A scale's header + slots | its base, slot version, or its field block's base or `n` moved | rewritten, or slot `t` moved |
+ *
+ * A range that is rewritten must be resolved even when its `t` did not move:
+ * the render stages read the resolved buffer, not these. A parked scale is
+ * neither rewritten nor resolved: it has no block, and the empty block it
+ * points at is never written.
  *
- * A block is REWRITTEN when its base or its version moved, and RESOLVED when it
- * was rewritten or its `t` moved. A parked scale is neither: it has no block,
- * and the empty block it points at is never written.
+ * Offsets are recomputed on every call because a block appearing or
+ * disappearing shifts every block after it. That is a running sum over a
+ * handful of blocks, and the alternative — a free list — would have to survive
+ * a block changing size, which happens whenever a dim appends. A field block
+ * that moves rewrites the headers pointing at it in the same pass.
  *
- * Offsets are recomputed on every call because a scale appearing or
- * disappearing shifts every scale after it. That is a running sum over a
- * handful of scales, and the alternative — a free list — would have to survive
- * a scale changing size, which happens whenever a dim appends.
+ * `fields` and `groups` default to none, which packs the slots alone.
  */
-export declare function packIdentitySlots(scales: readonly IdentitySlotScale[], state: IdentitySlotState): PackResult;
+export declare function packIdentitySlots(scales: readonly IdentitySlotScale[], state: IdentitySlotState, fields?: readonly ActivityField[], groups?: number): PackResult;