@fjader/svelte 0.2.2 → 0.2.4

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

@@ -4,11 +4,48 @@
  * Marks and interactors specify which group to use via their `selection`
  * prop (e.g. selection="brush"). Groups are created on first access.
  * Routes that don't use named selections get the "default" group.
+ *
+ * Also owns what is shared between the groups: each group's page-wide index,
+ * 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();
+    /**
+     * Bumped when a field is created, so a reader that found none (and so read
+     * no fade) runs again once it exists. Fields are created by selections and by
+     * the coordinator for every field a scale draws, never while a template
+     * renders.
+     */
+    #fieldsVersion = $state(0);
+    /** The same activities as an array, for the packer's per-frame loop. */
+    #fieldList = [];
+    #loop = null;
+    #chartsFor = (_key, out) => out;
+    /** Shared by every FieldActivity: reads the registry's current wiring. */
+    #host;
+    constructor() {
+        const registry = this;
+        this.#host = {
+            get loop() {
+                return registry.#loop;
+            },
+            chartsFor: (key, out) => this.#chartsFor(key, out),
+            identityOf: (key) => this.#engine?.peekIdentity(key) ?? null
+        };
+    }
     /** Wire the engine to all existing and future groups. */
     setEngine(engine) {
         this.#engine = engine;
@@ -16,20 +53,132 @@ export class FilterGroupRegistry {
             group.setEngine(engine);
         }
     }
-    /** Get or create a FilterGroup by name. Undefined/null → "default". */
+    /**
+     * Wire the fades to the animation loop and to the charts to redraw while
+     * they run. Called by the GPU coordinator. A fade created before this lands
+     * at once.
+     */
+    setAnimation(loop, chartsFor) {
+        this.#loop = loop;
+        this.#chartsFor = chartsFor;
+    }
+    /**
+     * 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) {
-            g = new FilterGroup();
-            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;
+        });
     }
-    /** Check if a named group exists (without creating it). */
+    /**
+     * 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');
+    }
+    /** 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 untrack(() => this.#groups.size);
+    }
+    /**
+     * The selection state of a categorical field, by identity key. Created on
+     * first ask, by a selection or by the coordinator for a field a scale draws.
+     *
+     * Never removed: a session that switches through many categorical columns
+     * keeps every field it drew, each one step of the coordinator's per-frame
+     * reconcile loop. Their buffer space is freed (the packer gives a block only
+     * to fields a scale draws), so this costs a loop step, not memory on the GPU.
+     * Dropping a field once no scale draws it and no group selects on it is a
+     * possible follow-up.
+     */
+    field(key) {
+        let activity = this.#fields.get(key);
+        if (!activity) {
+            activity = new FieldActivity(key, this.#host);
+            this.#fields.set(key, activity);
+            this.#fieldList.push(activity);
+            this.#fieldsVersion++;
+        }
+        return activity;
+    }
+    /**
+     * How visible `value` of field `key` is now, for a label shown for marks of
+     * several groups: the least visible over `groups`, so it dims when any of
+     * those groups dims it. 1 for a field no group ever selected on. Pure, so
+     * safe in a template: it creates nothing and reconciles nothing.
+     */
+    opacityOfValue(key, groups, value) {
+        void this.#fieldsVersion;
+        const activity = this.#fields.get(key);
+        if (!activity)
+            return 1;
+        let opacity = 1;
+        for (let i = 0; i < groups.length; i++) {
+            opacity = Math.min(opacity, activity.opacityOfValue(groups[i], value));
+        }
+        return opacity;
+    }
+    /**
+     * How visible the category with dim id `id` of field `key` is now: the id form
+     * of `opacityOfValue`, and the one a label for an Other bucket must use. The
+     * least visible over `groups`. Pure, so safe in a template.
+     */
+    opacityOfId(key, groups, id) {
+        void this.#fieldsVersion;
+        const activity = this.#fields.get(key);
+        if (!activity)
+            return 1;
+        let opacity = 1;
+        for (let i = 0; i < groups.length; i++) {
+            opacity = Math.min(opacity, activity.opacityOfId(groups[i], id));
+        }
+        return opacity;
+    }
+    /** Every field's activity, in creation order. Read every frame; do not mutate. */
+    get fields() {
+        return this.#fieldList;
     }
 }

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

@@ -24,7 +24,15 @@ export declare class MarkHandle {
     /** Called by mark lifecycle when sort/limit change. */
     updateParams(params: QueryParams): void;
     _onParamsChange: (() => void) | null;
-    /** Engine-internal: called to deliver query results. */
+    /**
+     * Engine-internal: called to deliver query results.
+     *
+     * The table it already holds changes nothing, so it bumps nothing: a cache
+     * hit hands back the same object, and bumping `dataVersion` for it reran
+     * every effect that reads it (the tooltip table, data-following domains).
+     * The error is cleared either way, so a success after a failure still
+     * clears it.
+     */
     _setResult(table: Table): void;
     /** Engine-internal: called on query error. */
     _setError(error: Error): void;

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

@@ -21,11 +21,21 @@ export class MarkHandle {
     // Engine sets this callback during registration.
     // Conventional underscore — engine needs external access.
     _onParamsChange = null;
-    /** Engine-internal: called to deliver query results. */
+    /**
+     * Engine-internal: called to deliver query results.
+     *
+     * The table it already holds changes nothing, so it bumps nothing: a cache
+     * hit hands back the same object, and bumping `dataVersion` for it reran
+     * every effect that reads it (the tooltip table, data-following domains).
+     * The error is cleared either way, so a success after a failure still
+     * clears it.
+     */
     _setResult(table) {
+        this.error = null;
+        if (table === this.arrowTable)
+            return;
         this.arrowTable = table;
         this.dataVersion++;
-        this.error = null;
     }
     /** Engine-internal: called on query error. */
     _setError(error) {

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

@@ -3,8 +3,9 @@
  * mark registration for batch filter-driven re-queries.
  *
  * The mark layer's only interface to DuckDB. All query execution goes through
- * queryEngine.query(sql, opts) for ad-hoc queries, or registerMark() +
- * onFilterChange() for the reactive registration path.
+ * queryEngine.query(sql, opts) for ad-hoc queries, or registerMark() for the
+ * reactive registration path: FilterGroup calls onClauseChange() when one
+ * clause changes, and onFilterChange() when all of a group's do (clearAll).
  *
  * v1: Direct execution (await connection.query(sql))
  * v2: Cancel-on-supersede — keyed on callerId, drops stale in-flight queries.
@@ -22,8 +23,9 @@ import { type QueryParts } from '../components/marks/lifecycle/query-builder';
 import type { ActivationSource } from './preagg/plan';
 export type { ActiveDim, ActivationSource } from './preagg/plan';
 import { MarkHandle } from './MarkHandle.svelte';
-import { type DimValue, type FieldIdentity, type IdentityField } from './categorical-identity';
+import { type DimValue, type FieldIdentity, type IdentityField, type SyntheticId } from './categorical-identity';
 import type { FilterGroup } from './FilterGroup.svelte';
+import { type Clause, type MarkRoute } from './CrossfilterSelection.svelte';
 import type { TransformCompiler } from '../transforms/TransformCompiler';
 export interface QueryOpts {
     /** Caller identifier for cancel-on-supersede. When a new query arrives
@@ -82,6 +84,8 @@ export interface QueryDescriptor {
     parts: QueryParts;
     schema: Map<string, ColumnSchema>;
     transformCompiler: TransformCompiler;
+    /** What routing needs to know about the mark. Absent in tests that route nothing. */
+    route?: MarkRoute;
 }
 export declare class QueryEngine {
     #private;
@@ -127,27 +131,40 @@ export declare class QueryEngine {
      */
     dimTableFor(field: string): string;
     /**
-     * Dim values for `field`, indexed by id — the decode side of the string -> id
-     * encode. Not display labels: formatting belongs to the scale/axis layer.
+     * The field's categories as of now, in id order, without the synthetic Other
+     * buckets: a bucket is not a category of the data, and another chart's bucket
+     * must not appear on an axis, a facet or a colour legend that has none.
      *
-     * The LIVE array — hold the reference, do not snapshot it. A second table
-     * registering the same field appends to the dim afterwards and this array
-     * grows in place.
+     * With `table`, only the categories that table holds: the dim spans every
+     * table registering the field, and an axis over one table must not show a
+     * slot for a category only another has. Without it (a scale shared per field,
+     * like ordinal colour), every category of the dim.
+     *
+     * A snapshot, not the live array: for decoding ids, hold `identityFor(field)`.
+     */
+    categoryValues(field: string, table?: string): DimValue[];
+    /**
+     * The table of ids `table` holds for `field`, for `dense()` to pad from, or
+     * null before the table has folded into the field's dim.
      */
-    identityValues(field: string): DimValue[];
+    presentTableFor(field: string, table: string): string | null;
     /**
      * The field's id <-> value bijection. One live object owning both
      * directions, so a holder cannot end up with a value array and a reverse map
-     * that disagree. Prefer this over identityValues() anywhere the reverse
+     * that disagree. Prefer this over categoryValues() anywhere the reverse
      * direction is needed; do not rebuild it locally.
      */
     identityFor(field: string): FieldIdentity;
+    /** The field's current bijection, or null; never creates one (see CategoricalIdentity). */
+    peekIdentity(field: string): FieldIdentity | null;
     /**
-     * Reserve an id for a value present in no table — the synthetic "Other"
-     * bucket from `topN({ includeOthers })`. Call after ensureColumns.
-     * Returns an existing id when a real category already carries the label.
+     * Acquire an id for a value present in no table — the synthetic "Other"
+     * bucket from `topN({ includeOthers })` — with the label it displays. Call
+     * after ensureColumns; release it when its holder goes.
      */
-    reserveSyntheticIdentity(field: string, label: string): Promise<number>;
+    acquireSyntheticIdentity(field: string, label: string): Promise<SyntheticId>;
+    /** Give back an id from `acquireSyntheticIdentity`, for the next acquire to reuse. */
+    releaseSyntheticIdentity(synthetic: SyntheticId): void;
     /**
      * Subscribe to identity resets. Returns an unsubscribe function.
      *
@@ -234,10 +251,29 @@ export declare class QueryEngine {
     /** When a filter last changed, in any group, for settling (performance.now()). */
     get lastFilterChangeAt(): number;
     /**
-     * Called by FilterGroup when any filter clause changes.
-     * Iterates registered marks for this group and batch-queries them.
+     * Called by FilterGroup when its clauses change wholesale (clearAll):
+     * re-queries every mark in the group.
      */
     onFilterChange(group: FilterGroup): void;
+    /**
+     * Called by FilterGroup when the clause of `sourceId` changes: `prev` is the
+     * clause it replaced or removed, `next` the one now in force (null when
+     * removed).
+     *
+     * Re-queries only the group's marks that either one filters. A mark neither
+     * filters has the same SQL as before, so querying it would only assemble that
+     * SQL to find the cached result, on every brush frame. A mark that reads the
+     * clause's categorical field dims by it instead, and a mark in a chart that
+     * skips the source is not filtered by it: neither is re-queried.
+     */
+    onClauseChange(group: FilterGroup, sourceId: string, prev: Clause | undefined, next: Clause | null): void;
+    /**
+     * Called by FilterGroup when a registration that skips `chart` comes or
+     * goes while its source has a clause: re-queries the group's marks in that
+     * chart, whose filters may have changed. A mark whose SQL did not change
+     * stops at the cache and the same-Table guard.
+     */
+    onChartRouteChange(group: FilterGroup, chart: object): void;
     /**
      * Pre-aggregate marks for a filter group before a source is used: builds a
      * preagg table per mark the source filters (see Preagg.activate). Called

package/dist/query-engine/QueryEngine.js

@@ -3,8 +3,9 @@
  * mark registration for batch filter-driven re-queries.
  *
  * The mark layer's only interface to DuckDB. All query execution goes through
- * queryEngine.query(sql, opts) for ad-hoc queries, or registerMark() +
- * onFilterChange() for the reactive registration path.
+ * queryEngine.query(sql, opts) for ad-hoc queries, or registerMark() for the
+ * reactive registration path: FilterGroup calls onClauseChange() when one
+ * clause changes, and onFilterChange() when all of a group's do (clearAll).
  *
  * v1: Direct execution (await connection.query(sql))
  * v2: Cancel-on-supersede — keyed on callerId, drops stale in-flight queries.
@@ -21,6 +22,7 @@ import { assembleQuery, castNumeric, splitWindowSelect } from '../components/mar
 import { Preagg } from './preagg/Preagg';
 import { MarkHandle } from './MarkHandle.svelte';
 import { CategoricalIdentity } from './categorical-identity';
+import { NO_ROUTE } from './CrossfilterSelection.svelte';
 /**
  * How long a queued build waits behind mark queries before it is sent anyway,
  * by default. During a drag on the base table a mark query is always waiting
@@ -95,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.
@@ -197,32 +207,64 @@ export class QueryEngine {
         return this.#identity.dimTable(field);
     }
     /**
-     * Dim values for `field`, indexed by id — the decode side of the string -> id
-     * encode. Not display labels: formatting belongs to the scale/axis layer.
+     * The field's categories as of now, in id order, without the synthetic Other
+     * buckets: a bucket is not a category of the data, and another chart's bucket
+     * must not appear on an axis, a facet or a colour legend that has none.
      *
-     * The LIVE array — hold the reference, do not snapshot it. A second table
-     * registering the same field appends to the dim afterwards and this array
-     * grows in place.
+     * With `table`, only the categories that table holds: the dim spans every
+     * table registering the field, and an axis over one table must not show a
+     * slot for a category only another has. Without it (a scale shared per field,
+     * like ordinal colour), every category of the dim.
+     *
+     * A snapshot, not the live array: for decoding ids, hold `identityFor(field)`.
      */
-    identityValues(field) {
-        return this.#identity.values(field);
+    categoryValues(field, table) {
+        const identity = this.#identity.identity(field);
+        const values = identity.values;
+        const present = table ? this.#identity.presentIds(field, table) : null;
+        if (identity.synthetic.size === 0 && !present)
+            return values.slice();
+        const out = [];
+        for (let id = 0; id < values.length; id++) {
+            if (identity.synthetic.has(id))
+                continue;
+            if (present && !present.has(id))
+                continue;
+            out.push(values[id]);
+        }
+        return out;
+    }
+    /**
+     * The table of ids `table` holds for `field`, for `dense()` to pad from, or
+     * null before the table has folded into the field's dim.
+     */
+    presentTableFor(field, table) {
+        return this.#identity.presentTable(field, table);
     }
     /**
      * The field's id <-> value bijection. One live object owning both
      * directions, so a holder cannot end up with a value array and a reverse map
-     * that disagree. Prefer this over identityValues() anywhere the reverse
+     * that disagree. Prefer this over categoryValues() anywhere the reverse
      * direction is needed; do not rebuild it locally.
      */
     identityFor(field) {
         return this.#identity.identity(field);
     }
+    /** The field's current bijection, or null; never creates one (see CategoricalIdentity). */
+    peekIdentity(field) {
+        return this.#identity.peekIdentity(field);
+    }
     /**
-     * Reserve an id for a value present in no table — the synthetic "Other"
-     * bucket from `topN({ includeOthers })`. Call after ensureColumns.
-     * Returns an existing id when a real category already carries the label.
+     * Acquire an id for a value present in no table — the synthetic "Other"
+     * bucket from `topN({ includeOthers })` — with the label it displays. Call
+     * after ensureColumns; release it when its holder goes.
      */
-    reserveSyntheticIdentity(field, label) {
-        return this.#identity.reserveSynthetic(field, label);
+    acquireSyntheticIdentity(field, label) {
+        return this.#identity.acquireSynthetic(field, label);
+    }
+    /** Give back an id from `acquireSyntheticIdentity`, for the next acquire to reuse. */
+    releaseSyntheticIdentity(synthetic) {
+        this.#identity.releaseSynthetic(synthetic);
     }
     /**
      * Subscribe to identity resets. Returns an unsubscribe function.
@@ -295,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);
             }
@@ -332,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 });
         }
@@ -342,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 {
@@ -559,27 +613,55 @@ export class QueryEngine {
         return this.#lastFilterChangeAt;
     }
     /**
-     * Called by FilterGroup when any filter clause changes.
-     * Iterates registered marks for this group and batch-queries them.
+     * Called by FilterGroup when its clauses change wholesale (clearAll):
+     * re-queries every mark in the group.
      */
     onFilterChange(group) {
         this.#lastFilterChangeAt = performance.now();
-        const batch = [];
         for (const [markId, reg] of this.#marks) {
-            if (reg.filterGroup === group) {
-                batch.push([markId, reg]);
-            }
+            if (reg.filterGroup === group)
+                this.#queryMark(markId, reg);
         }
-        if (batch.length > 0) {
-            this.#executeBatch(batch);
+    }
+    /**
+     * Called by FilterGroup when the clause of `sourceId` changes: `prev` is the
+     * clause it replaced or removed, `next` the one now in force (null when
+     * removed).
+     *
+     * Re-queries only the group's marks that either one filters. A mark neither
+     * filters has the same SQL as before, so querying it would only assemble that
+     * SQL to find the cached result, on every brush frame. A mark that reads the
+     * clause's categorical field dims by it instead, and a mark in a chart that
+     * skips the source is not filtered by it: neither is re-queried.
+     */
+    onClauseChange(group, sourceId, prev, next) {
+        this.#lastFilterChangeAt = performance.now();
+        const { selection } = group;
+        for (const [markId, reg] of this.#marks) {
+            if (reg.filterGroup !== group)
+                continue;
+            const route = reg.descriptor.route ?? NO_ROUTE;
+            if ((prev && selection.applies(sourceId, prev, route)) ||
+                (next && selection.applies(sourceId, next, route))) {
+                this.#queryMark(markId, reg);
+            }
         }
     }
-    #executeBatch(batch) {
-        for (const [markId, reg] of batch)
-            this.#queryMark(markId, reg);
+    /**
+     * Called by FilterGroup when a registration that skips `chart` comes or
+     * goes while its source has a clause: re-queries the group's marks in that
+     * chart, whose filters may have changed. A mark whose SQL did not change
+     * stops at the cache and the same-Table guard.
+     */
+    onChartRouteChange(group, chart) {
+        for (const [markId, reg] of this.#marks) {
+            if (reg.filterGroup === group && reg.descriptor.route?.chart === chart) {
+                this.#queryMark(markId, reg);
+            }
+        }
     }
     /**
-     * Query a single mark: on a filter change (via #executeBatch) or a params
+     * Query a single mark: on a filter change or a params
      * change (via _onParamsChange). Reads a preagg table when one answers; if
      * that read fails, the table is set aside and the base table is queried once.
      */
@@ -611,7 +693,7 @@ export class QueryEngine {
     /** The query a mark runs on its base table, applying every clause. */
     #baseSQL(markId, reg) {
         const { descriptor, handle } = reg;
-        return this.#assembleSQL(descriptor, descriptor.table, reg.filterGroup.selection.predicate(markId), handle.params);
+        return this.#assembleSQL(descriptor, descriptor.table, reg.filterGroup.selection.predicate(reg.descriptor.route ?? NO_ROUTE), handle.params);
     }
     /**
      * Assemble SQL from a query descriptor + filter + per-mark params.