@fjader/svelte 0.2.3 → 0.2.4

package/dist/query-engine/FieldActivity.svelte.js

@@ -45,6 +45,14 @@ class GroupFade {
  * `reconcile` runs from the packer and from `set`, never from a reader, so
  * nothing is resized or retargeted while a template renders.
  */
+/**
+ * THE FREE SLOT. Each group's table holds one slot past the field's ids: 1 while
+ * the group selects nothing on the field, 0 while it selects anything, faded on
+ * the same clock as every id. The shader reads it as the last slot of the
+ * group's run (identityFreeActivity): an Other bar's unselected part dims by it,
+ * so clearing a selection fades it back in with the other bars, rather than its
+ * split sliding.
+ */
 export class FieldActivity {
     key;
     #host;
@@ -63,9 +71,20 @@ export class FieldActivity {
         this.key = key;
         this.#host = host;
     }
-    /** How many ids the tables cover: the applied identity's, 0 without one. */
+    /**
+     * How many slots the tables cover: one per id of the applied identity, and
+     * one past them (FREE_SLOT); 0 without an identity.
+     */
     get count() {
-        return this.#identity ? this.#identity.values.length : 0;
+        return this.#identity ? this.#identity.values.length + 1 : 0;
+    }
+    /**
+     * Group `index`'s selected values, or null when it selects nothing on this
+     * field. Reactive: a reader re-runs when the selection changes.
+     */
+    selectedValues(index) {
+        void this.#groupsVersion;
+        return this.#groups[index]?.values ?? null;
     }
     /** Group `index`'s fade, or null when that group never selected on this field. */
     fadeOf(index) {
@@ -164,6 +183,113 @@ export class FieldActivity {
         }
         return values.has(identity.values[id]) ? 1 : inactiveOpacity;
     }
+    // -----------------------------------------------------------------
+    // Other buckets: what each one holds, for a click to select
+    // -----------------------------------------------------------------
+    /**
+     * Every Other bucket's members, by its id and the mark that drew it. Each
+     * mark registers its Other rows per result (`setOther`): the folded ids its
+     * query returned, per facet cell. A click on Other reads them, so what it
+     * selects is exactly what the bar summed.
+     */
+    #others = new Map();
+    /**
+     * What an Other click contributed to a group's selection, by `group:otherId`:
+     * how a second click on the same Other knows what to take back. Dropped with
+     * the id's last entry, so a reused id starts with no memory.
+     */
+    #otherMemory = new Map();
+    /** Register `markId`'s Other rows under `otherId`; null removes them. */
+    setOther(otherId, markId, entry) {
+        let byMark = this.#others.get(otherId);
+        const before = byMark?.get(markId)?.group;
+        if (entry) {
+            if (!byMark)
+                this.#others.set(otherId, (byMark = new Map()));
+            byMark.set(markId, entry);
+        }
+        else {
+            if (!byMark?.delete(markId))
+                return;
+            if (byMark.size === 0) {
+                this.#others.delete(otherId);
+                for (const memKey of [...this.#otherMemory.keys()]) {
+                    if (memKey.endsWith(`:${otherId}`))
+                        this.#otherMemory.delete(memKey);
+                }
+            }
+        }
+        // The bucket's members moved (a new result), or it came or went: whether it
+        // is lit may have changed in the group its marks dim under. A fade it does
+        // not change costs nothing (#retarget returns early).
+        this.#reapply(before);
+        if (entry && entry.group !== before)
+            this.#reapply(entry.group);
+    }
+    #reapply(index) {
+        if (index == null)
+            return;
+        const group = this.#groups[index];
+        if (group && group.values != null)
+            this.#apply(group);
+    }
+    /**
+     * What a click on Other `otherId` does to group `group`'s selection, given
+     * the values it holds now (`current`), and records it. Null when nothing is
+     * registered under the id (no result yet) or it holds no members.
+     *
+     * - The members: every registered row under the id, or only facet cell
+     *   `facetId`'s when the click came from a cell.
+     * - Shift-click adds them, or takes back what this Other added before if it
+     *   is still selected.
+     * - A plain click on an Other whose marks all filter by the selection (no
+     *   group: `'filter'`) drills down, replacing the selection: such an Other is
+     *   computed inside the selection, so a second click means "the rest of it".
+     * - Otherwise a plain click toggles: it takes back what this Other added if
+     *   that is still selected, and replaces the selection with the members if not.
+     */
+    otherClick(group, otherId, facetId, current, multi) {
+        const entries = this.#others.get(otherId);
+        const identity = this.#host.identityOf(this.key);
+        if (!entries || entries.size === 0 || !identity)
+            return null;
+        const members = new Set();
+        let drill = true;
+        for (const entry of entries.values()) {
+            if (entry.group !== null)
+                drill = false;
+            for (const row of entry.rows) {
+                if (facetId !== null && row.facetId !== facetId)
+                    continue;
+                for (let i = 0; i < row.ids.length; i++) {
+                    const id = row.ids[i];
+                    if (identity.synthetic.has(id))
+                        continue;
+                    const value = identity.values[id];
+                    if (value !== undefined)
+                        members.add(value);
+                }
+            }
+        }
+        if (members.size === 0)
+            return null;
+        const memKey = `${group}:${otherId}`;
+        const before = this.#otherMemory.get(memKey);
+        const stillSelected = !!before && before.size > 0 && [...before].every((v) => current.has(v));
+        if (stillSelected && (multi || !drill)) {
+            this.#otherMemory.delete(memKey);
+            return { action: 'remove', values: [...before] };
+        }
+        if (!multi) {
+            // A replace: what any other Other added is gone from the selection.
+            for (const key of [...this.#otherMemory.keys()]) {
+                if (key.startsWith(`${group}:`))
+                    this.#otherMemory.delete(key);
+            }
+        }
+        this.#otherMemory.set(memKey, members);
+        return { action: multi ? 'add' : 'replace', values: [...members] };
+    }
     #group(index) {
         let group = this.#groups[index];
         if (!group) {
@@ -187,10 +313,13 @@ export class FieldActivity {
             group.table.resize(0);
             return;
         }
-        const count = identity.values.length;
+        // Every id, and the free slot past them: clear() sets it to 1 and
+        // setActive() leaves it out, so it fades to 0 while anything is selected
+        // and back to 1 once nothing is (see FieldActivity's FREE_SLOT note).
+        const count = identity.values.length + 1;
         const values = group.values;
         if (values == null) {
-            group.table.resize(count, null);
+            group.table.resize(count, null, true);
             group.table.clear();
             return;
         }
@@ -201,7 +330,49 @@ export class FieldActivity {
             if (id != null)
                 ids.push(id);
         }
-        group.table.resize(count, ids);
+        this.#lightOthers(this.#groups.indexOf(group), ids, count);
+        group.table.resize(count, ids, true);
         group.table.setActive(ids);
     }
+    /**
+     * Add to `ids` (the selected ids) every Other bucket that holds one of them,
+     * by the members its marks in group `index` registered: a bucket is lit while
+     * the selection reaches into it. In the same pass as the rest of the group's
+     * fade, so it is one retarget per update, never two. Marks filtered by the
+     * selection (no group) are skipped: they never dim.
+     */
+    #lightOthers(index, ids, count) {
+        if (this.#others.size === 0 || index < 0)
+            return;
+        let mask = this.#selectedMask;
+        if (mask.length < count)
+            mask = this.#selectedMask = new Uint8Array(count);
+        const selected = ids.length;
+        for (let i = 0; i < selected; i++)
+            mask[ids[i]] = 1;
+        for (const [otherId, entries] of this.#others) {
+            if (otherId >= count)
+                continue;
+            let lit = false;
+            for (const entry of entries.values()) {
+                if (entry.group !== index)
+                    continue;
+                for (const row of entry.rows) {
+                    for (let i = 0; i < row.ids.length && !lit; i++)
+                        lit = mask[row.ids[i]] === 1;
+                    if (lit)
+                        break;
+                }
+                if (lit)
+                    break;
+            }
+            if (lit)
+                ids.push(otherId);
+        }
+        // Unmark only what was marked: the selected ids, not the Others pushed after.
+        for (let i = 0; i < selected; i++)
+            mask[ids[i]] = 0;
+    }
+    /** Reused by #lightOthers: 1 at each selected id, 0 elsewhere between calls. */
+    #selectedMask = new Uint8Array(0);
 }

package/dist/query-engine/FilterGroup.svelte.d.ts

@@ -52,6 +52,16 @@ export interface SourceOpts extends SourceRegistration {
      * once per write and stored on the clause.
      */
     augment?: (value: unknown) => FilterSchema | null;
+    /**
+     * The source's clause was removed by someone other than this registration:
+     * `clearAll`, a `clearSource` from outside (a filter pill's remove button), or
+     * another registration under the same id clearing it. A control that keeps what
+     * it drew (a brush's rectangle) resets it here, because it reads no clause. Not
+     * called for the registration's own `clear()` or `destroy()`, which it initiated;
+     * and a control that clears itself from here does not loop, since the clause is
+     * already gone.
+     */
+    onCleared?: () => void;
 }
 export interface SourceHandle {
     /** Write the source's clause. */
@@ -81,6 +91,13 @@ export interface ToggleHandle extends Omit<SourceHandle, 'update'> {
     toggle(tuple: unknown[], multi: boolean, total?: number): void;
     /** Select exactly these tuples; empty clears. */
     set(tuples: unknown[][]): void;
+    /**
+     * A click on Other bucket `otherId` (from facet cell `facetId`, or null):
+     * selects, adds or takes back the categories it holds, as its field's
+     * registry says (FieldActivity.otherClick). A one-field toggle only: a
+     * bucket names no value in a tuple of several.
+     */
+    toggleOther(otherId: number, facetId: number | null, multi: boolean): void;
 }
 export declare class FilterGroup {
     #private;
@@ -136,7 +153,12 @@ export declare class FilterGroup {
     /**
      * Remove a source's clause. Re-queries only when there was a clause to
      * remove: an unmount or a clear with nothing selected changes no mark's data.
+     *
+     * The source's registrations are told (`onCleared`) so a control that drew the
+     * selection resets it, all of them from outside, and all but `by` when a
+     * registration is the one clearing (it has reset itself).
      */
-    clearSource(sourceId: string): void;
+    clearSource(sourceId: string, by?: SourceOpts): void;
+    /** Remove every clause, and tell the controls that drew them (`onCleared`). */
     clearAll(): void;
 }

package/dist/query-engine/FilterGroup.svelte.js

@@ -144,7 +144,8 @@ export class FilterGroup {
                 };
                 this.#afterUpdate(sourceId, selection.update(sourceId, next), next);
             },
-            clear: () => this.clearSource(sourceId),
+            // The registration's own clear: it already reset what it drew.
+            clear: () => this.clearSource(sourceId, opts),
             activate: () => this.#activate(sourceId),
             destroy: () => {
                 // Once only: a second call must not remove a newer registration
@@ -158,7 +159,8 @@ export class FilterGroup {
                     // while the registration is still in place, so the removal is
                     // routed by it: the marks re-queried are those the clause filtered.
                     this.#engine?.forgetSource(this, sourceId);
-                    this.clearSource(sourceId);
+                    // Quietly: the registration is going away, nothing of it to reset.
+                    this.clearSource(sourceId, opts);
                     selection.removeRegistration(sourceId, opts);
                     return;
                 }
@@ -275,6 +277,24 @@ export class FilterGroup {
                 write([...next.values()]);
             },
             set: (tuples) => write(tuples),
+            toggleOther: (otherId, facetId, multi) => {
+                if (list.length !== 1 || categoricalKey === null)
+                    return;
+                const click = this.activity(categoricalKey).otherClick(this.index, otherId, facetId, keysOf(selection.get(sourceId)), multi);
+                if (!click)
+                    return;
+                const next = new Map(tuplesOf(selection.get(sourceId)).map((t) => [tupleKey(t), t]));
+                if (click.action === 'replace')
+                    next.clear();
+                for (const value of click.values) {
+                    const tuple = [value];
+                    if (click.action === 'remove')
+                        next.delete(tupleKey(tuple));
+                    else
+                        next.set(tupleKey(tuple), tuple);
+                }
+                write([...next.values()]);
+            },
             clear: () => write([]),
             activate: source.activate,
             destroy: source.destroy
@@ -322,18 +342,38 @@ export class FilterGroup {
     /**
      * Remove a source's clause. Re-queries only when there was a clause to
      * remove: an unmount or a clear with nothing selected changes no mark's data.
+     *
+     * The source's registrations are told (`onCleared`) so a control that drew the
+     * selection resets it, all of them from outside, and all but `by` when a
+     * registration is the one clearing (it has reset itself).
      */
-    clearSource(sourceId) {
+    clearSource(sourceId, by) {
         if (!this.selection.isActive(sourceId))
             return;
         this.#afterUpdate(sourceId, this.selection.update(sourceId, null), null);
+        this.#notifyCleared(sourceId, by);
     }
+    /** Remove every clause, and tell the controls that drew them (`onCleared`). */
     clearAll() {
+        const cleared = this.selection.items.map((item) => item.sourceId);
         this.selection.clear();
         for (const key of this.#selectedFields)
             this.#activityOf(key).set(this.index, null);
         this.#selectedFields.clear();
         this.#engine?.onFilterChange(this);
+        for (const sourceId of cleared)
+            this.#notifyCleared(sourceId);
+    }
+    /** Tell a source's registrations, but `except`, that its clause is gone. */
+    #notifyCleared(sourceId, except) {
+        const registrations = this.selection.registrationsOf(sourceId);
+        if (!registrations)
+            return;
+        // A copy: a control resetting itself may register or destroy while this runs.
+        for (const opts of [...registrations]) {
+            if (opts !== except)
+                opts.onCleared?.();
+        }
     }
     // -----------------------------------------------------------------
     // After a change

package/dist/query-engine/FilterGroupRegistry.svelte.d.ts

@@ -24,10 +24,38 @@ export declare class FilterGroupRegistry {
      * at once.
      */
     setAnimation(loop: ClockLoop, chartsFor: (key: string, out: string[]) => string[]): void;
-    /** Get or create a FilterGroup by name. Undefined/null → "default". */
+    /**
+     * Get or create a FilterGroup by name. Undefined/null → "default".
+     *
+     * Untracked: a reader does not re-run because it called `get`. For a reactive
+     * read use `find`, `has` or `isActive`, which create nothing: a group created
+     * inside the derived that reads it is state that derived cannot track, so
+     * `$derived(get('brush').activeCount)` before any chart made the group never
+     * updates. Create groups from init, effects and handlers.
+     */
     get(name?: string | null): FilterGroup;
-    /** Check if a named group exists (without creating it). */
-    has(name: string): boolean;
+    /**
+     * The named group, or undefined if no chart has made it yet. Creates nothing.
+     * Reactive: a reader re-runs when the group is created.
+     */
+    find(name?: string | null): FilterGroup | undefined;
+    /** Whether a named group exists, without creating it. Reactive, as `find`. */
+    has(name?: string | null): boolean;
+    /**
+     * Whether a named group has a selection (a brush, a toggle, a legend), without
+     * creating it: false for a group no chart has made yet. Reactive in both the
+     * group appearing and its clauses changing, so `$derived(groups.isActive('brush'))`
+     * is safe before any chart exists.
+     */
+    isActive(name?: string | null): boolean;
+    /**
+     * The names of the groups, in creation order. Reactive: a reader re-runs when a
+     * group is created. A new array on each read. For app code that must reach every group the page's marks
+     * use, such as a clause that applies to the whole page.
+     */
+    get names(): readonly string[];
+    /** The groups, in the order of `names`. Reactive in the same way. */
+    get groups(): readonly FilterGroup[];
     /** How many groups the page has: the packer writes one activity half per group. */
     get groupCount(): number;
     /**

package/dist/query-engine/FilterGroupRegistry.svelte.js

@@ -9,10 +9,18 @@
  * and one FieldActivity per categorical field, which holds every group's
  * selection fade on that field.
  */
+import { untrack } from 'svelte';
+import { SvelteMap } from 'svelte/reactivity';
 import { FilterGroup } from './FilterGroup.svelte';
 import { FieldActivity } from './FieldActivity.svelte';
 export class FilterGroupRegistry {
-    #groups = new Map();
+    /**
+     * The groups by name, in creation order. Reactive, so `has`, `find`, `isActive`,
+     * `names` and `groups` re-run when a group is created. `get` reads and writes it
+     * untracked: templates and deriveds call `get`, and a tracked write there throws
+     * (`state_unsafe_mutation`) or re-runs the reader on its own write.
+     */
+    #groups = new SvelteMap();
     #engine = null;
     #fields = new Map();
     /**
@@ -54,27 +62,66 @@ export class FilterGroupRegistry {
         this.#loop = loop;
         this.#chartsFor = chartsFor;
     }
-    /** Get or create a FilterGroup by name. Undefined/null → "default". */
+    /**
+     * Get or create a FilterGroup by name. Undefined/null → "default".
+     *
+     * Untracked: a reader does not re-run because it called `get`. For a reactive
+     * read use `find`, `has` or `isActive`, which create nothing: a group created
+     * inside the derived that reads it is state that derived cannot track, so
+     * `$derived(get('brush').activeCount)` before any chart made the group never
+     * updates. Create groups from init, effects and handlers.
+     */
     get(name) {
         const key = name ?? 'default';
-        let g = this.#groups.get(key);
-        if (!g) {
-            // Indices are never reused or compacted: a mark keeps its group's
-            // index from mount, so renumbering would point it at another group.
-            g = new FilterGroup(this.#groups.size, (field) => this.field(field));
-            if (this.#engine)
-                g.setEngine(this.#engine);
-            this.#groups.set(key, g);
-        }
-        return g;
+        return untrack(() => {
+            let g = this.#groups.get(key);
+            if (!g) {
+                // Indices are never reused or compacted: a mark keeps its group's
+                // index from mount, so renumbering would point it at another group.
+                g = new FilterGroup(this.#groups.size, (field) => this.field(field));
+                if (this.#engine)
+                    g.setEngine(this.#engine);
+                this.#groups.set(key, g);
+            }
+            return g;
+        });
+    }
+    /**
+     * The named group, or undefined if no chart has made it yet. Creates nothing.
+     * Reactive: a reader re-runs when the group is created.
+     */
+    find(name) {
+        return this.#groups.get(name ?? 'default');
     }
-    /** Check if a named group exists (without creating it). */
+    /** Whether a named group exists, without creating it. Reactive, as `find`. */
     has(name) {
-        return this.#groups.has(name);
+        return this.#groups.has(name ?? 'default');
+    }
+    /**
+     * Whether a named group has a selection (a brush, a toggle, a legend), without
+     * creating it: false for a group no chart has made yet. Reactive in both the
+     * group appearing and its clauses changing, so `$derived(groups.isActive('brush'))`
+     * is safe before any chart exists.
+     */
+    isActive(name) {
+        const group = this.find(name);
+        return group ? group.activeCount > 0 : false;
+    }
+    /**
+     * The names of the groups, in creation order. Reactive: a reader re-runs when a
+     * group is created. A new array on each read. For app code that must reach every group the page's marks
+     * use, such as a clause that applies to the whole page.
+     */
+    get names() {
+        return [...this.#groups.keys()];
+    }
+    /** The groups, in the order of `names`. Reactive in the same way. */
+    get groups() {
+        return [...this.#groups.values()];
     }
     /** How many groups the page has: the packer writes one activity half per group. */
     get groupCount() {
-        return this.#groups.size;
+        return untrack(() => this.#groups.size);
     }
     /**
      * The selection state of a categorical field, by identity key. Created on

package/dist/query-engine/QueryEngine.js

@@ -97,7 +97,15 @@ export class QueryEngine {
     #preagg;
     /** When a filter last changed, in any group (performance.now()). */
     #lastFilterChangeAt = 0;
-    /** LRU query cache: SQL string → Arrow Table (or Promise<Table> while inflight). */
+    /**
+     * LRU query cache: Arrow Table (or Promise<Table> while inflight), keyed by
+     * `#cacheKey`, the SQL text and the dims' version. A mark's query reads dim
+     * tables (dense padding pads every category the dim holds), and dims grow
+     * after the first queries run: a table folding in, a topN mark reserving its
+     * Other. The text does not change when they do, so keyed by text alone the
+     * cache served a result from before, with fewer rows: the row set changed
+     * between updates and the bars snapped instead of morphing.
+     */
     #queryCache = lruCache({ max: 1000, ttl: 3 * 60 * 60 * 1000 });
     /**
      * Per-instance suffix for every table and view this engine creates.
@@ -329,7 +337,7 @@ export class QueryEngine {
         // Opt out with cache: false for queries against volatile temp tables.
         const useCache = opts?.cache !== false;
         if (useCache) {
-            const cached = this.#queryCache.get(sqlStr);
+            const cached = this.#queryCache.get(this.#cacheKey(sqlStr));
             if (cached !== undefined) {
                 return cached instanceof Promise ? cached : Promise.resolve(cached);
             }
@@ -366,9 +374,17 @@ export class QueryEngine {
         }
         return this.#queryRaw(sqlStr);
     }
+    /**
+     * The cache key for a query: its text and the dims' version, so a result read
+     * against a dim that has since grown is not served again.
+     */
+    #cacheKey(sqlStr) {
+        return `${this.#identity.version}\u0000${sqlStr}`;
+    }
     async #executeForCaller(callerId, sqlStr, signal, cache = true) {
         const controller = new AbortController();
         this.#inflight.set(callerId, controller);
+        let key = null;
         if (signal) {
             signal.addEventListener('abort', () => controller.abort(), { once: true });
         }
@@ -376,24 +392,28 @@ export class QueryEngine {
             if (controller.signal.aborted) {
                 throw new DOMException('Query superseded', 'AbortError');
             }
+            // Keyed when it runs, not when it was asked for: a pending query runs
+            // later, against whatever the dims hold by then.
+            key = this.#cacheKey(sqlStr);
             // Cache the Promise so concurrent identical queries share one inflight
             const queryPromise = this.#queryRaw(sqlStr);
             if (cache)
-                this.#queryCache.set(sqlStr, queryPromise);
+                this.#queryCache.set(key, queryPromise);
             const result = await queryPromise;
             // Replace Promise with resolved data for future lookups
             if (cache)
-                this.#queryCache.set(sqlStr, result);
+                this.#queryCache.set(key, result);
             if (controller.signal.aborted) {
                 // Don't cache results from aborted queries
-                this.#queryCache.delete(sqlStr);
+                this.#queryCache.delete(key);
                 throw new DOMException('Query superseded', 'AbortError');
             }
             return result;
         }
         catch (e) {
             // Remove failed query from cache so we don't serve a rejected Promise
-            this.#queryCache.delete(sqlStr);
+            if (key !== null)
+                this.#queryCache.delete(key);
             throw e;
         }
         finally {

package/dist/query-engine/categorical-identity.d.ts

@@ -290,6 +290,21 @@ export declare class CategoricalIdentity {
      * before a reset names a row of a dropped dim, and is ignored.
      */
     releaseSynthetic(synthetic: SyntheticId): void;
+    /**
+     * Re-read the dim into the field's value array, mutating in place.
+     *
+     * Re-reading the whole dim rather than only the new rows: categorical
+     * cardinality is small, this runs once per (field, table) pair at setup, and
+     * a full read cannot drift out of sync with the ids the way an incremental
+     * one can if an append is ever missed.
+     */
+    /**
+     * Bumped whenever a dim's rows change: a table folding in, an Other bucket
+     * reserved, a reset. A query that reads a dim (dense padding, an id join)
+     * returns different rows afterwards under the same SQL text, so whatever
+     * caches results by that text must also key on this. Only ever increases.
+     */
+    get version(): number;
     /**
      * Drop every view and dim and forget all state. Called on data reload, where
      * the ids are stale by definition — the same values may not exist any more,

package/dist/query-engine/categorical-identity.js

@@ -775,6 +775,16 @@ export class CategoricalIdentity {
      * a full read cannot drift out of sync with the ids the way an incremental
      * one can if an append is ever missed.
      */
+    /**
+     * Bumped whenever a dim's rows change: a table folding in, an Other bucket
+     * reserved, a reset. A query that reads a dim (dense padding, an id join)
+     * returns different rows afterwards under the same SQL text, so whatever
+     * caches results by that text must also key on this. Only ever increases.
+     */
+    get version() {
+        return this.#version;
+    }
+    #version = 0;
     async #refreshValues(field) {
         const rows = await this.#exec.queryRows(`SELECT id, value, label FROM ${quote(this.dimTable(field))} ORDER BY id`);
         // Ordered by id and dense by construction, so position is the id — and
@@ -791,6 +801,10 @@ export class CategoricalIdentity {
             if (rows[i].label != null)
                 synthetic.push(i);
         this.identity(field).reset(rows.map((row) => (row.label ?? row.value)), synthetic);
+        // After the rows are written, never before: a query keyed on the new
+        // version must see them. One keyed on the old version may also see them,
+        // which costs a re-run later, not a stale result.
+        this.#version++;
     }
     /** CREATE OR REPLACE the view with an id column for every field in `all`. */
     async #createView(table, all) {
@@ -845,6 +859,7 @@ export class CategoricalIdentity {
         // Before any await: work already in flight compares against this and
         // stops rather than re-creating what is about to be dropped.
         this.#generation++;
+        this.#version++;
         const views = [...this.#views.keys()].map((t) => this.viewTable(t));
         const dims = [...this.#dims.values()].flatMap((d) => [
             d.name,

package/dist/query-engine/preagg/plan.d.ts

@@ -70,6 +70,11 @@ export interface PreaggCreation {
     select: Record<string, ExprNode>;
     groupby: ExprNode[];
     orderby: ExprNode[];
+    /**
+     * The mark's own row filters (`filter()`), applied to the source rows inside the
+     * build: the table groups them away, so the read could not apply them.
+     */
+    where: ExprNode[];
     /**
      * Fields grouped by value inside and mapped to their ids on the grouped
      * result: `raw` is the inner column, `alias` the id column, `dim` the dim