@fjader/svelte 0.2.2 → 0.2.4

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

@@ -11,14 +11,16 @@
  *    later tables APPEND unseen values with continuing ids. It never reorders and
  *    never renumbers, so an id already baked into a vertex buffer stays valid and
  *    no earlier mark has to requery. `value` carries the source column's own type
- *    and `label` is NULL, except on a synthetic row (`reserveSynthetic`), where
- *    that is inverted.
+ *    and `label` is NULL, except on a synthetic row (`acquireSynthetic`), where
+ *    that is inverted, and on the NULL category's row, where both are NULL.
  *
  * 2. A **per-table view**, `<table>_v_s<session>`, selecting `*` plus one
  *    `__dplot_<field>_idx` column per requested field. Always LEFT JOIN with
  *    COALESCE(-1): an inner join silently drops rows whose value is not in the
- *    dim (NULLs, values added later), which is data loss presenting as a
- *    rendering bug. -1 is the unmapped sentinel, unified in `1ac4fd4`.
+ *    dim (a value a later append will add), which is data loss presenting as a
+ *    rendering bug. -1 is the unmapped sentinel, unified in `1ac4fd4`. A NULL
+ *    value is not unmapped: the dim has a row for it (value NULL, label NULL),
+ *    joined with IS NOT DISTINCT FROM, so NULL is a category like any other.
  *
  * 3. An **additive coalescer**, `ensureColumns()`. Concurrent callers union into
  *    a pending set, one CREATE OR REPLACE VIEW runs with the full union, and a
@@ -46,6 +48,16 @@ import { IDENTITY_SLOT_CAPACITY } from '../gpu/identity-slot-packing';
 function asField(field) {
     return typeof field === 'string' ? { key: field, sql: quote(field) } : field;
 }
+/**
+ * How a category value is shown: as itself, except the NULL category, which has
+ * no text of its own. The one formatter for axis ticks, legend entries, facet
+ * labels and tooltips, so NULL reads the same everywhere. Selections keep the
+ * raw `null`: this is display only.
+ */
+export const NULL_CATEGORY_LABEL = '(null)';
+export function categoryLabel(value) {
+    return value === null ? NULL_CATEGORY_LABEL : value;
+}
 /**
  * A field's id <-> value bijection, both directions in one object.
  *
@@ -61,11 +73,33 @@ function asField(field) {
  * once and stay correct when a second table appends to the dim.
  */
 export class FieldIdentity {
-    /** id -> source value. Dense and 0-based, so position is the id. */
+    /**
+     * id -> source value. Dense and 0-based, so position is the id. A synthetic
+     * id (an Other bucket) holds its display label here.
+     */
     values = [];
-    /** source value -> id. The exact inverse of `values`. */
+    /**
+     * source value -> id, for real values only: the inverse of `values` with the
+     * synthetic ids left out. A label is not a value, and several synthetic ids
+     * may share one, so nothing resolves a bucket by its label.
+     */
     ids = new Map();
-    constructor(values) {
+    /** The synthetic ids (Other buckets): rows of the dim no source row joins to. */
+    synthetic = new Set();
+    /**
+     * The NULL category's id, or null while the data has no NULL. An ordinary
+     * category: ranked, drawn, selectable; `values[nullId]` is `null`, and `ids`
+     * maps `null` to it, so value lookups need no special case.
+     */
+    nullId = null;
+    /**
+     * The identity key this is the bijection for, as `identityKeyFor` derives
+     * it: what a scale that adopted it is keyed by for selection activity.
+     * Empty for one built outside the engine, as tests do.
+     */
+    key;
+    constructor(values, key = '') {
+        this.key = key;
         if (values)
             this.reset(values);
     }
@@ -76,14 +110,26 @@ export class FieldIdentity {
      * comparing `values.length` is not.
      */
     version = 0;
-    /** Replace both directions. The only writer. */
-    reset(values) {
+    /**
+     * Replace both directions. The only writer. `synthetic` names the ids that
+     * are buckets rather than values: they keep their label in `values` and stay
+     * out of `ids`.
+     */
+    reset(values, synthetic = []) {
         this.version++;
         this.values.length = 0;
         this.ids.clear();
+        this.synthetic.clear();
+        this.nullId = null;
+        for (const id of synthetic)
+            this.synthetic.add(id);
         for (let i = 0; i < values.length; i++) {
             this.values.push(values[i]);
+            if (this.synthetic.has(i))
+                continue;
             this.ids.set(values[i], i);
+            if (values[i] === null)
+                this.nullId = i;
         }
     }
     /** True once the dim has been built and holds at least one value. */
@@ -130,10 +176,11 @@ function identityToken(field) {
     return sanitized === field ? field : `h${shortHash(field)}`;
 }
 /**
- * Above this many distinct values a band axis is refused outright.
- * The shared slot buffer holds 16384 floats across every band and point scale,
- * so a single axis this large cannot render whatever else is on the page — the
- * limit is capacity, not taste.
+ * Above this many distinct values a band axis is refused outright. The shared
+ * slot buffer (IDENTITY_SLOT_CAPACITY floats) holds every band and point
+ * scale's slots and every selected field's activity, one run per filter group,
+ * so an axis this large would crowd out the rest of the page — the limit is
+ * capacity, not taste.
  */
 export const MAX_IDENTITY_CARDINALITY = 10000;
 /**
@@ -201,6 +248,12 @@ export class CategoricalIdentity {
      * flight.
      */
     #identities = new Map();
+    /**
+     * Released synthetic ids, per field and label, for the next acquire. Keeps the
+     * dim from growing a row per remount: mark ids are random, so nothing about a
+     * remounted mark can name the id it held before. Cleared with the dims.
+     */
+    #freeSynthetic = new Map();
     /** key -> SQL producing the value. Set at registration, read by the drain. */
     #sqlFor = new Map();
     constructor(exec, session) {
@@ -216,9 +269,9 @@ export class CategoricalIdentity {
         return this.#sqlFor.get(field);
     }
     /**
-     * Whether `field`'s dim has folded in `table`, so every non-NULL value the
-     * table holds has an id and `-1` can only mean NULL. A dim another table
-     * built may lack this table's values; a refused dim covers nothing.
+     * Whether `field`'s dim has folded in `table`, so every value the table holds,
+     * NULL included, has an id and `-1` never appears. A dim another table built
+     * may lack this table's values; a refused dim covers nothing.
      */
     dimCovers(field, table) {
         const dim = this.#dims.get(field);
@@ -239,6 +292,31 @@ export class CategoricalIdentity {
     dimTable(field) {
         return `__dplot_dim_${identityToken(field)}_s${this.#session}`;
     }
+    /**
+     * The table of ids `table` holds for `field`, or null before that table has
+     * folded into the dim. What `dense()` pads from, so a chart never pads a
+     * category only another table has.
+     */
+    presentTable(field, table) {
+        return this.#dims.get(field)?.present.get(table)?.name ?? null;
+    }
+    /** The ids `table` holds for `field`, or null before that table has folded in. */
+    presentIds(field, table) {
+        return this.#dims.get(field)?.present.get(table)?.ids ?? null;
+    }
+    /**
+     * Record which of the dim's ids `table` holds: the ids of its distinct values,
+     * joined as the view joins (NULL to a NULL row, never to a synthetic one).
+     * Once per table, when it folds in.
+     */
+    async #recordPresent(dim, table, expr, src) {
+        const name = `${dim.name}_t_${identityToken(table)}`;
+        await this.#exec.exec(`CREATE OR REPLACE TABLE ${quote(name)} AS ` +
+            `SELECT DISTINCT d.id FROM (SELECT DISTINCT ${expr} AS v FROM ${src}) s ` +
+            `JOIN ${quote(dim.name)} d ON s.v IS NOT DISTINCT FROM d.value AND d.label IS NULL`);
+        const rows = await this.#exec.queryRows(`SELECT id FROM ${quote(name)}`);
+        dim.present.set(table, { name, ids: new Set(rows.map((r) => Number(r.id))) });
+    }
     /** Name of the view that carries id columns for `table`. */
     viewTable(table) {
         return `${identityToken(table)}_v_s${this.#session}`;
@@ -277,11 +355,19 @@ export class CategoricalIdentity {
     identity(field) {
         let entry = this.#identities.get(field);
         if (!entry) {
-            entry = new FieldIdentity();
+            entry = new FieldIdentity(undefined, field);
             this.#identities.set(field, entry);
         }
         return entry;
     }
+    /**
+     * The field's current bijection, or null if nothing has asked for it since
+     * the last reset. Unlike `identity`, never creates one: for a holder checking
+     * whether the identity it applied is still the live one, on every frame.
+     */
+    peekIdentity(field) {
+        return this.#identities.get(field) ?? null;
+    }
     /** Fields the view for `table` currently exposes. Empty when there is no view. */
     columnsFor(table) {
         return [...(this.#views.get(table)?.current ?? [])];
@@ -428,7 +514,8 @@ export class CategoricalIdentity {
                 sql: this.#sqlFor.get(field) ?? quote(field),
                 tables: new Set(),
                 refusal: null,
-                chain: Promise.resolve()
+                chain: Promise.resolve(),
+                present: new Map()
             };
             this.#dims.set(field, dim);
         }
@@ -441,38 +528,84 @@ export class CategoricalIdentity {
         return next;
     }
     /**
-     * Reserve an id for a value that exists in no table — the synthetic "Other"
-     * bucket a `topN({ includeOthers })` produces.
+     * Acquire an id for a value that exists in no table — the synthetic "Other"
+     * bucket a `topN({ includeOthers })` produces — and return it with the label
+     * it displays.
      *
-     * Goes through the same writer as every other id, so `values(f)[otherId]` is
-     * the label and no consumer has to know it was synthetic. Serialized on the
-     * per-field chain, so it cannot interleave with an append.
+     * A released id with the same label is reused before a dim row is inserted,
+     * so remounting a chart does not grow the dim or the field's activity block.
+     * Keyed by label too, so a reused id never needs relabelling.
+     *
+     * Goes through the same writer as every other id, so `values(f)[id]` is the
+     * label; `synthetic` records that it is a bucket, which keeps it out of the
+     * value -> id map. Serialized on the per-field chain, so it cannot interleave
+     * with an append.
      *
      * Non-negative by construction: `scaleBand` discards `value < 0.0` before the
      * slot lookup, so a negative sentinel could never render.
      *
-     * **Reuses the id if a real category already carries this label**, rather
-     * than inserting a duplicate value — see the fan-out note above. Callers get
-     * an id that may already be in the data, which the transform has to fold
-     * into rather than append beside.
+     * **A real category carrying the label stays a category.** The bucket takes
+     * `"<label> (rest)"` instead, so two bars never share a label and the real
+     * one stays selectable. The check runs at acquire; a reload re-acquires.
      *
      * Requires the dim to exist: call after `ensureColumns` has resolved.
      */
-    reserveSynthetic(field, label) {
+    acquireSynthetic(field, label) {
         const dim = this.#dims.get(field);
         if (!dim) {
-            return Promise.reject(new Error(`No dim for "${field}" — reserveSynthetic must follow ensureColumns.`));
+            return Promise.reject(new Error(`No dim for "${field}" — acquireSynthetic must follow ensureColumns.`));
         }
-        const next = dim.chain.then(() => this.#reserveSyntheticNow(dim, field, label));
+        const generation = this.#generation;
+        const next = dim.chain.then(() => this.#acquireSyntheticNow(dim, field, label, generation));
         // Drop both the value and any rejection: the chain only sequences work,
         // and one failure must not poison every later append.
         dim.chain = next.then(() => { }, () => { });
         return next;
     }
-    async #reserveSyntheticNow(dim, field, label) {
-        const existing = this.identity(field).ids.get(label);
-        if (existing !== undefined)
-            return existing;
+    /**
+     * Give an acquired id back for the next acquire of the same label. One from
+     * before a reset names a row of a dropped dim, and is ignored.
+     */
+    releaseSynthetic(synthetic) {
+        if (synthetic.generation !== this.#generation)
+            return;
+        let byLabel = this.#freeSynthetic.get(synthetic.field);
+        if (!byLabel)
+            this.#freeSynthetic.set(synthetic.field, (byLabel = new Map()));
+        let free = byLabel.get(synthetic.label);
+        if (!free)
+            byLabel.set(synthetic.label, (free = []));
+        if (!free.includes(synthetic.id))
+            free.push(synthetic.id);
+    }
+    /**
+     * Abort an acquire that a reset overtook. An AbortError, which a mark's setup
+     * treats as superseded rather than failed: the reset re-runs that setup, and
+     * it acquires again from the new dim.
+     */
+    #throwIfSuperseded(generation, field, label) {
+        if (this.#generation === generation)
+            return;
+        const superseded = new Error(`Acquiring "${label}" for "${field}" was superseded by a reset.`);
+        superseded.name = 'AbortError';
+        throw superseded;
+    }
+    async #acquireSyntheticNow(dim, field, requested, generation) {
+        // Queued behind work that outlived a reset, as #ensureDimNow checks too.
+        // Without this the INSERT would write a bucket row into the NEW dim (same
+        // name) that no one holds and no release can return: releases from an
+        // older generation are ignored.
+        // Checked again after each await: a reset landing mid-flight drops the dim
+        // the row went into, and the identity read afterwards is a new one.
+        this.#throwIfSuperseded(generation, field, requested);
+        const identity = this.identity(field);
+        let label = requested;
+        while (identity.ids.has(label))
+            label = `${label} (rest)`;
+        const free = this.#freeSynthetic.get(field)?.get(label);
+        const reused = free?.pop();
+        if (reused !== undefined)
+            return { field, id: reused, label, generation };
         const dimName = quote(dim.name);
         // value NULL, label carrying the text. The label cannot go in `value`:
         // that column has the source column's type, so 'Other' against a year or
@@ -484,15 +617,21 @@ export class CategoricalIdentity {
         // joins ON t.key = d.value. Any in-range sentinel would collide with a
         // real category the moment the data contained it; NULL cannot, since
         // NULL = anything is never true.
-        await this.#exec.exec(`INSERT INTO ${dimName} (value, label, id) ` +
+        //
+        // RETURNING, not a lookup by label afterwards: several buckets may carry
+        // one label, and labels are kept out of the value -> id map.
+        const rows = await this.#exec.queryRows(`INSERT INTO ${dimName} (value, label, id) ` +
             `SELECT NULL, ${literal(label)}, ` +
-            `(SELECT COALESCE(MAX(id), -1) + 1 FROM ${dimName})::INT`);
+            `(SELECT COALESCE(MAX(id), -1) + 1 FROM ${dimName})::INT ` +
+            `RETURNING id`);
+        this.#throwIfSuperseded(generation, field, requested);
         await this.#refreshValues(field);
-        const id = this.identity(field).ids.get(label);
-        if (id === undefined) {
-            throw new Error(`Reserved "${label}" for "${field}" but it is absent from the dim.`);
+        this.#throwIfSuperseded(generation, field, requested);
+        const id = Number(rows[0]?.id);
+        if (!Number.isInteger(id) || !identity.synthetic.has(id)) {
+            throw new Error(`Acquired "${label}" for "${field}" but it is absent from the dim.`);
         }
-        return id;
+        return { field, id, label, generation };
     }
     async #ensureDimNow(dim, field, table, generation) {
         // BEFORE the tables check, not after: a mark whose setup re-runs would
@@ -520,8 +659,8 @@ export class CategoricalIdentity {
             // that column is a conversion error, not a fallback.
             await this.#exec.exec(`CREATE TABLE IF NOT EXISTS ${dimName} AS ` +
                 `SELECT value, NULL::VARCHAR AS label, ` +
-                `(ROW_NUMBER() OVER (ORDER BY value) - 1)::INT AS id ` +
-                `FROM (SELECT DISTINCT ${expr} AS value FROM ${src} WHERE ${expr} IS NOT NULL)`);
+                `(ROW_NUMBER() OVER (ORDER BY value NULLS LAST) - 1)::INT AS id ` +
+                `FROM (SELECT DISTINCT ${expr} AS value FROM ${src})`);
             // A second statement: CTAS cannot carry a constraint. `value` is unique
             // by construction here (DISTINCT) and on append (WHERE NOT EXISTS), but
             // reserveSynthetic is a writer that could break it, and a duplicate
@@ -539,12 +678,18 @@ export class CategoricalIdentity {
             // a positional INSERT would silently put the id into `label`.
             await this.#exec.exec(`INSERT INTO ${dimName} (value, label, id) ` +
                 `SELECT s.v, NULL, ((SELECT COALESCE(MAX(id), -1) FROM ${dimName}) + ` +
-                `ROW_NUMBER() OVER (ORDER BY s.v))::INT ` +
-                `FROM (SELECT DISTINCT ${expr} AS v FROM ${src} WHERE ${expr} IS NOT NULL) s ` +
-                `WHERE NOT EXISTS (SELECT 1 FROM ${dimName} d WHERE d.value = s.v)`);
+                `ROW_NUMBER() OVER (ORDER BY s.v NULLS LAST))::INT ` +
+                `FROM (SELECT DISTINCT ${expr} AS v FROM ${src}) s ` +
+                // IS NOT DISTINCT FROM, so a second table's NULLs find the NULL row
+                // (NULL = NULL is never true, and `=` appended one per table). The
+                // label test keeps a synthetic row, also value NULL, from passing
+                // for it.
+                `WHERE NOT EXISTS (SELECT 1 FROM ${dimName} d ` +
+                `WHERE d.value IS NOT DISTINCT FROM s.v AND d.label IS NULL)`);
         }
         dim.tables.add(table);
         await this.#refreshValues(field);
+        await this.#recordPresent(dim, table, expr, src);
         // The gate above saw ONE table. The dim spans every table that registers
         // the field, so two tables of 6k each pass it individually and produce a
         // 12k dim — and the limit is a property of the dim, since that is what
@@ -630,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
@@ -638,10 +793,18 @@ export class CategoricalIdentity {
         //
         // `label` wins where it is set, which is only ever a synthetic row. Every
         // real row has label NULL and keeps its native value, so this does not
-        // stringify anything the dim read from the source (see DimValue). It is
-        // the one place the two columns collapse back into one space, and it is
-        // why no consumer has to know a bucket was synthetic.
-        this.identity(field).reset(rows.map((row) => (row.label ?? row.value)));
+        // stringify anything the dim read from the source (see DimValue). A row
+        // with a label is recorded as synthetic, which keeps it out of the
+        // value -> id map: a label is not a value.
+        const synthetic = [];
+        for (let i = 0; i < rows.length; i++)
+            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) {
@@ -657,7 +820,12 @@ export class CategoricalIdentity {
             keyExprs.push(`(${this.#dims.get(field).sql}) AS ${quote(keyCol)}`);
             keyCols.push(quote(keyCol));
             columns.push(`COALESCE(${alias}.id, -1) AS ${quote(this.idColumn(field))}`);
-            joins.push(`LEFT JOIN ${dimName} ${alias} ON t.${quote(keyCol)} = ${alias}.value`);
+            // IS NOT DISTINCT FROM, so a NULL source value joins the NULL row; the
+            // label test keeps synthetic rows (also value NULL) out. Measured free:
+            // it keeps the hash join. An `= OR (both NULL)` form falls back to a
+            // nested loop, 73 s on 2 M rows x 10 000 categories — never write it.
+            joins.push(`LEFT JOIN ${dimName} ${alias} ON t.${quote(keyCol)} IS NOT DISTINCT FROM ${alias}.value ` +
+                `AND ${alias}.label IS NULL`);
         });
         // The value expression is computed in an inner SELECT, where only the
         // source table is in scope, and joined on the qualified helper column.
@@ -691,14 +859,20 @@ 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()].map((d) => d.name);
+        const dims = [...this.#dims.values()].flatMap((d) => [
+            d.name,
+            ...[...d.present.values()].map((p) => p.name)
+        ]);
         this.#views.clear();
         this.#dims.clear();
         // In place, so any scale still holding the reference empties with it.
         for (const identity of this.#identities.values())
             identity.reset([]);
         this.#identities.clear();
+        // Their ids name rows of the dims being dropped.
+        this.#freeSynthetic.clear();
         for (const view of views) {
             await this.#exec.exec(`DROP VIEW IF EXISTS ${quote(view)}`);
         }

package/dist/query-engine/index.d.ts

@@ -41,6 +41,7 @@ export { MarkHandle } from './MarkHandle.svelte';
 export type { QueryParams } from './MarkHandle.svelte';
 export { FilterGroupRegistry } from './FilterGroupRegistry.svelte';
 export { FilterGroup } from './FilterGroup.svelte';
-export type { SourceOpts, SourceHandle, ToggleHandle, FilterItem, ActiveValueScale } from './FilterGroup.svelte';
+export type { SourceOpts, SourceHandle, ToggleHandle, FilterItem } from './FilterGroup.svelte';
+export { FieldActivity } from './FieldActivity.svelte';
 export { CrossfilterSelection } from './CrossfilterSelection.svelte';
 export type { FilterExpr, FilterSchema, Clause, ClauseEntry } from './CrossfilterSelection.svelte';

package/dist/query-engine/index.js

@@ -47,4 +47,5 @@ export { mapSqlTypeToJs, buildSchemaMap } from './QueryEngine';
 export { MarkHandle } from './MarkHandle.svelte';
 export { FilterGroupRegistry } from './FilterGroupRegistry.svelte';
 export { FilterGroup } from './FilterGroup.svelte';
+export { FieldActivity } from './FieldActivity.svelte';
 export { CrossfilterSelection } from './CrossfilterSelection.svelte';

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

@@ -59,7 +59,7 @@ export declare class Preagg {
      *
      * The source is named by its ID rather than inferred: before the first drag
      * it has no clause yet, and other clauses on the same chart (a Toggle)
-     * exclude the same marks a brush does.
+     * skip the same chart a brush does.
      */
     activate(filterGroup: FilterGroup, source: ActivationSource): Promise<void>;
     /**

package/dist/query-engine/preagg/Preagg.js

@@ -15,6 +15,7 @@
  * 3-Clause License; see NOTICE.
  */
 import { binsFineEnough } from '../sufficient-statistics';
+import { NO_ROUTE } from '../CrossfilterSelection.svelte';
 import { planPreagg, preaggSelectSQL, preaggQuerySQL, bakedClausesHold, markKeys, estimateGroups, activeDimsKeyOf, binFitsView, fnvHash } from './plan';
 import { BuildQueue } from './BuildQueue';
 /**
@@ -95,10 +96,10 @@ export class Preagg {
      *
      * The source is named by its ID rather than inferred: before the first drag
      * it has no clause yet, and other clauses on the same chart (a Toggle)
-     * exclude the same marks a brush does.
+     * skip the same chart a brush does.
      */
     async activate(filterGroup, source) {
-        const { sourceId: activeSourceId, excludedByAll, dims } = source;
+        const { sourceId: activeSourceId, categoricalKey, dims } = source;
         if (this.#destroyed || dims.length === 0)
             return;
         // An activation outside batch() (a legend's hover) is a batch of one.
@@ -111,7 +112,8 @@ export class Preagg {
                 continue;
             // A mark the source never filters gets no table for it, and keeps
             // the tables it holds for other sources.
-            if (excludedByAll.has(markId))
+            const route = reg.descriptor.route ?? NO_ROUTE;
+            if (!selection.filters(route, activeSourceId, categoricalKey))
                 continue;
             const own = this.#of(markId);
             // Skip if the latest build, finished or in flight, still matches
@@ -122,7 +124,7 @@ export class Preagg {
                     basis.activeSourceId === activeSourceId &&
                     basis.dimsKey === dimsKey &&
                     this.#binsFitDims(latest, dims) &&
-                    bakedClausesHold(markId, selection, latest)) {
+                    bakedClausesHold(route, selection, latest)) {
                     continue;
                 }
             }
@@ -136,8 +138,8 @@ export class Preagg {
                 continue;
             // Bake every other clause into the preagg table. Sorted by source ID,
             // so the same filters always give the same SQL, and so the same table.
-            const bakedClauses = selection.bakedClauses(markId, activeSourceId);
-            const staticFilters = selection.bakedPredicates(markId, activeSourceId);
+            const bakedClauses = selection.bakedClauses(route, activeSourceId);
+            const staticFilters = selection.bakedPredicates(route, activeSourceId);
             // Hash-based naming: identical preagg SQL reuses the same table (like Mosaic).
             // CREATE TABLE IF NOT EXISTS avoids rebuilding when switching charts.
             const preaggSQL = preaggSelectSQL(plan.creation, staticFilters);
@@ -194,7 +196,7 @@ export class Preagg {
         const preagg = this.#usable(markId, reg);
         if (!preagg)
             return null;
-        const sql = preaggQuerySQL(markId, reg.descriptor, reg.filterGroup.selection, preagg, reg.handle.params, this.#host.identity);
+        const sql = preaggQuerySQL(reg.descriptor.route ?? NO_ROUTE, reg.descriptor, reg.filterGroup.selection, preagg, reg.handle.params, this.#host.identity);
         return sql ? { sql, table: preagg.table } : null;
     }
     /**
@@ -308,7 +310,7 @@ export class Preagg {
             this.#marks.get(markId)?.building.get(sourceId) === build &&
             reg.descriptor.parts === build.basis.parts &&
             this.#binsFitCurrentView(build) &&
-            bakedClausesHold(markId, reg.filterGroup.selection, build));
+            bakedClausesHold(reg.descriptor.route ?? NO_ROUTE, reg.filterGroup.selection, build));
     }
     /**
      * The size guard: whether a planned table would hold more than a quarter of
@@ -371,7 +373,7 @@ export class Preagg {
         for (const [sourceId, state] of own.tables) {
             if (state.basis.parts === reg.descriptor.parts &&
                 this.#binsFineEnough(state) &&
-                bakedClausesHold(markId, selection, state)) {
+                bakedClausesHold(reg.descriptor.route ?? NO_ROUTE, selection, state)) {
                 // A Map keeps the first insertion position of a key, so listing
                 // this entry first and spreading the rest moves it to the front.
                 if (!first)

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

@@ -16,7 +16,7 @@ import { type BrushActivation } from '../sufficient-statistics';
 import { type QueryParts } from '../../components/marks/lifecycle/query-builder';
 import type { MarkHandle, QueryParams } from '../MarkHandle.svelte';
 import type { CategoricalIdentity } from '../categorical-identity';
-import type { Clause, CrossfilterSelection, FilterExpr } from '../CrossfilterSelection.svelte';
+import type { Clause, CrossfilterSelection, FilterExpr, MarkRoute } from '../CrossfilterSelection.svelte';
 import type { QueryDescriptor } from '../QueryEngine';
 /** What planning needs from the categorical identity. */
 export type PreaggIdentity = Pick<CategoricalIdentity, 'idColumn' | 'fieldOfIdColumn' | 'values' | 'dimCovers' | 'viewHas' | 'sqlFor' | 'dimTable' | 'identity'>;
@@ -35,8 +35,12 @@ export type ActiveDim = ({
 /** What activate() needs to know about a source, as FilterGroup sees it at hover time. */
 export interface ActivationSource {
     sourceId: string;
-    /** Marks every registration of the source excludes: it filters none of them. */
-    excludedByAll: Set<string>;
+    /**
+     * The source's categorical field (identity key), or null for a brush or a
+     * tuple. With the registrations, decides which marks the source would
+     * filter: a mark that reads this field dims by it and needs no table.
+     */
+    categoricalKey: string | null;
     dims: ActiveDim[];
     /**
      * For a source with bin dims: writes its current view, `[d0, d1, pixel
@@ -66,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
@@ -172,14 +181,14 @@ export declare function estimateGroups(markKeys: GroupKey[], activeKeys: GroupKe
  * mismatch the table's SQL is rebuilt from the current clauses and compared.
  * Once that fails, frames that still see the same clauses skip the rebuild.
  */
-export declare function bakedClausesHold(markId: string, selection: CrossfilterSelection, state: PreaggState): boolean;
+export declare function bakedClausesHold(route: MarkRoute, selection: CrossfilterSelection, state: PreaggState): boolean;
 /**
  * The query a mark runs on a preagg table, or null when the table cannot
  * answer it (a brush end past its window, a toggled value with no id).
  * Builds modified QueryParts from the stored outputSelect + bin filters,
  * then delegates to assembleQuery().
  */
-export declare function preaggQuerySQL(markId: string, descriptor: QueryDescriptor, selection: CrossfilterSelection, preagg: PreaggState, params: QueryParams, identity: PreaggIdentity): string | null;
+export declare function preaggQuerySQL(route: MarkRoute, descriptor: QueryDescriptor, selection: CrossfilterSelection, preagg: PreaggState, params: QueryParams, identity: PreaggIdentity): string | null;
 /** A preagg table's SELECT. Build and validity check share it, so equal SQL means an equal table. */
 export declare function preaggSelectSQL(creation: PreaggCreation, filters: FilterExpr[]): string;
 /**