@genome-spy/core 0.72.0 → 0.74.0

package/dist/src/scales/scaleResolution.js

@@ -24,10 +24,21 @@ import {
 } from "./scaleResolutionConstants.js";
 
 import { getAccessorDomainKey } from "../encoder/accessor.js";
-import { isSecondaryChannel } from "../encoder/encoder.js";
+import {
+    isPrimaryPositionalChannel,
+    isSecondaryChannel,
+} from "../encoder/encoder.js";
 import { NominalDomain } from "../utils/domainArray.js";
 import { shallowArrayEquals } from "../utils/arrayUtils.js";
 import createIndexer from "../utils/indexer.js";
+import { getCachedOrCall, invalidate } from "../utils/propertyCacher.js";
+import { resolveUrl } from "../utils/url.js";
+import {
+    findIntervalSelectionBindingOwners,
+    normalizeIntervalForSelection,
+    requireIntervalSelection,
+} from "./selectionDomainUtils.js";
+import { toExternalIndexLikeInterval } from "./indexLikeDomainUtils.js";
 
 // Register scaleLocus to Vega-Scale.
 // Loci are discrete but the scale's domain can be adjusted in a continuous manner.
@@ -111,6 +122,16 @@ export default class ScaleResolution {
 
     #categoricalIndexerExplicit = false;
 
+    /** @type {(() => void)[]} */
+    #selectionDomainParamUnsubscribers = [];
+
+    #selectionReverseSyncSuppressionDepth = 0;
+
+    #ignoreSelectionInitial = false;
+
+    /** @type {[number, number] | null | undefined} */
+    #lastLinkedSelectionInterval = undefined;
+
     /**
      * @param {Channel} channel
      */
@@ -124,10 +145,11 @@ export default class ScaleResolution {
 
         this.#domainAggregator = new DomainPlanner({
             getMembers: () => this.#getActiveMembers(),
+            getAllMembers: () => this.#members,
             getDataMembers: () =>
                 this.#getActiveMembers(this.#dataDomainMembers),
             getType: () => this.type,
-            getLocusExtent: () => this.#getLocusExtent(),
+            getLocusExtent: (assembly) => this.#getLocusExtent(assembly),
             fromComplexInterval: this.fromComplexInterval.bind(this),
         });
 
@@ -143,8 +165,7 @@ export default class ScaleResolution {
             getAnimator: () => this.#viewContext.animator,
             getInitialDomainSnapshot: () =>
                 this.#domainAggregator.initialDomainSnapshot,
-            getResetDomain: () =>
-                this.#domainAggregator.getConfiguredOrDefaultDomain(),
+            getResetDomain: () => this.#getConfiguredOrDefaultDomain(),
             fromComplexInterval: this.fromComplexInterval.bind(this),
             getGenomeExtent: () => this.#getLocusExtent(),
         });
@@ -200,21 +221,24 @@ export default class ScaleResolution {
     }
 
     /**
+     * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {number[]}
      */
-    #getLocusExtent() {
-        return getGenomeExtent(this.#getGenomeSource());
+    #getLocusExtent(assembly) {
+        return getGenomeExtent(this.#getGenomeSource(assembly));
     }
 
     /**
+     * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {import("../genome/scaleLocus.js").GenomeSource}
      */
-    #getGenomeSource() {
+    #getGenomeSource(assembly) {
         if (this.type !== LOCUS) {
             return undefined;
         }
         return /** @type {import("../genome/scaleLocus.js").GenomeSource} */ (
-            this.#scaleManager.scale ?? this.#scaleManager.getLocusGenome()
+            this.#scaleManager.scale ??
+                this.#scaleManager.getLocusGenome(assembly)
         );
     }
 
@@ -242,6 +266,13 @@ export default class ScaleResolution {
      * @param {ScaleResolutionEventType} type
      */
     #notifyListeners(type) {
+        if (
+            type === "domain" &&
+            this.#selectionReverseSyncSuppressionDepth === 0
+        ) {
+            this.syncLinkedSelectionFromDomain();
+        }
+
         for (const listener of this.#listeners[type].values()) {
             listener({
                 type,
@@ -250,14 +281,139 @@ export default class ScaleResolution {
         }
     }
 
+    /**
+     * @param {() => void} callback
+     */
+    #withSelectionReverseSyncSuppressed(callback) {
+        this.#selectionReverseSyncSuppressionDepth += 1;
+        try {
+            callback();
+        } finally {
+            this.#selectionReverseSyncSuppressionDepth -= 1;
+        }
+    }
+
+    syncLinkedSelectionFromDomain() {
+        const linkInfo =
+            this.#domainAggregator.getSelectionConfiguredDomainBindingInfo();
+        if (!linkInfo || !this.isZoomable()) {
+            return;
+        }
+
+        const selection = requireIntervalSelection(
+            linkInfo.runtime.getValue(linkInfo.param),
+            linkInfo.param
+        );
+
+        const interval = this.#normalizeDomainIntervalForLinkedSelection(
+            this.getScale().domain()
+        );
+        if (!interval) {
+            return;
+        }
+
+        const fallbackInterval =
+            this.#normalizeDomainIntervalForLinkedSelection(
+                this.#domainAggregator.getDefaultDomain(true)
+            );
+
+        const syncedInterval =
+            fallbackInterval && shallowArrayEquals(interval, fallbackInterval)
+                ? null
+                : interval;
+
+        const previousInterval = selection.intervals[linkInfo.encoding] ?? null;
+        if (intervalsEqual(previousInterval, syncedInterval)) {
+            return;
+        }
+
+        linkInfo.runtime.setValue(linkInfo.param, {
+            ...selection,
+            type: "interval",
+            intervals: {
+                ...selection.intervals,
+                [linkInfo.encoding]: syncedInterval,
+            },
+        });
+    }
+
+    /**
+     * @param {any[]} domain
+     * @returns {[number, number] | undefined}
+     */
+    #normalizeDomainIntervalForLinkedSelection(domain) {
+        return normalizeIntervalForSelection(domain, this.zoomExtent);
+    }
+
+    #getLinkedSelectionInfo() {
+        return this.#domainAggregator.getSelectionConfiguredDomainBindingInfo();
+    }
+
+    #shouldIncludeSelectionInitial() {
+        return !this.#ignoreSelectionInitial;
+    }
+
+    /**
+     * @param {boolean} [extractDataDomain]
+     * @param {import("../spec/scale.js").Scale["assembly"]} [locusAssembly]
+     * @returns {any[]}
+     */
+    #getConfiguredOrDefaultDomain(extractDataDomain = false, locusAssembly) {
+        return this.#domainAggregator.getConfiguredOrDefaultDomain(
+            extractDataDomain,
+            locusAssembly,
+            {
+                includeSelectionInitial: this.#shouldIncludeSelectionInitial(),
+            }
+        );
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    #hasConfiguredDomain() {
+        return this.#domainAggregator.hasConfiguredDomain({
+            includeSelectionInitial: this.#shouldIncludeSelectionInitial(),
+        });
+    }
+
+    /**
+     * @param {import("./domainPlanner.js").SelectionDomainLinkInfo} linkInfo
+     * @returns {[number, number] | null}
+     */
+    #getCurrentLinkedSelectionInterval(linkInfo) {
+        const selection = requireIntervalSelection(
+            linkInfo.runtime.getValue(linkInfo.param),
+            linkInfo.param
+        );
+        const interval = selection.intervals[linkInfo.encoding];
+        return interval && interval.length === 2
+            ? /** @type {[number, number]} */ (interval)
+            : null;
+    }
+
+    /**
+     * @param {[number, number] | null} previousInterval
+     * @param {[number, number] | null} nextInterval
+     */
+    #updateSelectionInitialBypass(previousInterval, nextInterval) {
+        if (nextInterval) {
+            this.#ignoreSelectionInitial = false;
+        } else if (previousInterval) {
+            this.#ignoreSelectionInitial = true;
+        }
+    }
+
     /**
      * Add a view to this resolution.
      * N.B. This is expected to be called in depth-first order
      *
      * @param {ScaleResolutionMember} newMember
+     * @returns {ScaleResolutionMember}
      */
     #addMember(newMember) {
-        const { channel, channelDef } = newMember;
+        const member = normalizeMember(newMember);
+        const { channel, channelDef } = member;
 
         // A convenience hack for cases where the new member should adapt
         // the scale type to the existing one. For example: SelectionRect
@@ -283,6 +439,20 @@ export default class ScaleResolution {
         // @ts-expect-error "sample" is not really a channel with scale
         const type = channel == "sample" ? "nominal" : channelDef.type;
         const name = channelDef?.scale?.name;
+        const explicitScaleType = channelDef.scale?.type;
+        const effectiveScaleType =
+            explicitScaleType ??
+            (type === INDEX || type === LOCUS ? type : undefined);
+
+        if (
+            effectiveScaleType &&
+            [INDEX, LOCUS].includes(effectiveScaleType) &&
+            !isPrimaryPositionalChannel(this.channel)
+        ) {
+            throw new Error(
+                `Index and locus scales are only supported on positional channels (x/y). Channel "${this.channel}" resolves to scale type "${effectiveScaleType}".`
+            );
+        }
 
         if (name) {
             if (this.name !== undefined && name != this.name) {
@@ -297,20 +467,26 @@ export default class ScaleResolution {
             if (!this.type) {
                 this.type = type;
             } else if (type !== this.type && !isSecondaryChannel(channel)) {
+                // TODO: Revisit shared discrete positional scales when
+                // implementing Vega-Lite-like band-vs-point inference.
+                // Nominal/ordinal members should be able to share a scale even
+                // if one member wants "point" and another wants "band"; the
+                // merged result should resolve to "band". Explicit
+                // user-specified incompatible scale types should still error.
                 // TODO: Include a reference to the layer
                 throw new Error(
                     `Can not use shared scale for different data types: ${this.type} vs. ${type}. Use "resolve: independent" for channel ${this.channel}`
                 );
-                // Actually, point scale could be changed into band scale
-                // TODO: Use the same merging logic as in: https://github.com/vega/vega-lite/blob/master/src/scale.ts
             }
         }
 
-        this.#members.add(newMember);
-        if (newMember.contributesToDomain) {
-            this.#dataDomainMembers.add(newMember);
+        this.#members.add(member);
+        if (member.contributesToDomain) {
+            this.#dataDomainMembers.add(member);
         }
-        this.#domainAggregator.invalidateConfiguredDomain();
+        this.#invalidateConfiguredDomain();
+        this.#refreshSelectionDomainParamSubscriptions();
+        return member;
     }
 
     /**
@@ -318,23 +494,64 @@ export default class ScaleResolution {
      * @returns {() => boolean}
      */
     registerMember(member) {
-        this.#addMember(member);
+        const registeredMember = this.#addMember(member);
         return () => {
-            const removed = this.#members.delete(member);
+            const removed = this.#members.delete(registeredMember);
             if (removed) {
-                this.#dataDomainMembers.delete(member);
-                this.#domainAggregator.invalidateConfiguredDomain();
+                this.#dataDomainMembers.delete(registeredMember);
+                this.#invalidateConfiguredDomain();
+                this.#refreshSelectionDomainParamSubscriptions();
             }
             return removed && this.#members.size === 0;
         };
     }
 
     dispose() {
+        this.#clearSelectionDomainParamSubscriptions();
         this.#listeners.domain.clear();
         this.#listeners.range.clear();
         this.#scaleManager.dispose();
     }
 
+    #clearSelectionDomainParamSubscriptions() {
+        for (const unsubscribe of this.#selectionDomainParamUnsubscribers) {
+            unsubscribe();
+        }
+        this.#selectionDomainParamUnsubscribers = [];
+        this.#lastLinkedSelectionInterval = undefined;
+    }
+
+    #refreshSelectionDomainParamSubscriptions() {
+        this.#clearSelectionDomainParamSubscriptions();
+
+        if (this.#members.size === 0) {
+            return;
+        }
+
+        const linkInfo = this.#getLinkedSelectionInfo();
+        if (!linkInfo) {
+            return;
+        }
+
+        this.#lastLinkedSelectionInterval =
+            this.#getCurrentLinkedSelectionInterval(linkInfo);
+
+        this.#selectionDomainParamUnsubscribers.push(
+            linkInfo.runtime.subscribe(linkInfo.param, () => {
+                const previousInterval = this.#lastLinkedSelectionInterval;
+                const currentInterval =
+                    this.#getCurrentLinkedSelectionInterval(linkInfo);
+                this.#updateSelectionInitialBypass(
+                    previousInterval,
+                    currentInterval
+                );
+                this.#lastLinkedSelectionInterval = currentInterval;
+                this.#invalidateConfiguredDomain();
+                this.reconfigureDomain();
+            })
+        );
+    }
+
     #hasRenderedMember() {
         for (const member of this.#members) {
             if (member.view.hasRendered()) {
@@ -386,11 +603,11 @@ export default class ScaleResolution {
     /**
      * Returns true if the domain has been defined explicitly, i.e. not extracted from the data.
      */
-    #isExplicitDomain() {
-        return this.#domainAggregator.hasConfiguredDomain();
+    isDomainDefinedExplicitly() {
+        return this.#hasConfiguredDomain();
     }
 
-    #isDomainInitialized() {
+    isDomainInitialized() {
         const s = this.#scaleManager.scale;
         if (!s) {
             return false;
@@ -416,14 +633,92 @@ export default class ScaleResolution {
      * @returns {import("../spec/scale.js").Scale}
      */
     #getMergedScaleProps() {
-        return resolveScalePropsBase({
-            channel: this.channel,
-            dataType: this.type,
-            members: this.#members,
-            isExplicitDomain: this.#isExplicitDomain(),
+        return getCachedOrCall(this, "mergedScaleProps", () => {
+            const props = resolveScalePropsBase({
+                channel: this.channel,
+                dataType: this.type,
+                members: this.#members,
+                isExplicitDomain: this.isDomainDefinedExplicitly(),
+                configScopes: this.#firstMemberView.getConfigScopes(),
+            });
+            this.#validateLinkedSelectionConfiguration(props);
+            return props;
         });
     }
 
+    #invalidateMergedScaleProps() {
+        invalidate(this, "mergedScaleProps");
+    }
+
+    #invalidateConfiguredDomain() {
+        this.#domainAggregator.invalidateConfiguredDomain();
+        this.#invalidateMergedScaleProps();
+    }
+
+    /**
+     * @param {import("../spec/scale.js").Scale} props
+     */
+    #validateLinkedSelectionConfiguration(props) {
+        const linkInfo = this.#getLinkedSelectionInfo();
+        if (!linkInfo || props === null || props.type === "null") {
+            return;
+        }
+
+        const isZoomable =
+            isContinuous(props.type) && !isDiscrete(props.type) && !!props.zoom;
+
+        if (linkInfo.hasInitial && !isZoomable) {
+            throw new Error(
+                `Selection domain reference "${linkInfo.param}.${linkInfo.encoding}" cannot use "initial" with a non-zoomable ${this.channel} scale. ` +
+                    `Enable zoom on the linked scale or remove "initial".`
+            );
+        }
+    }
+
+    /**
+     * Returns locus assembly requirements without initializing the scale.
+     *
+     * This is intentionally side-effect free: it only inspects merged scale
+     * properties from registered members and does not touch default domains or
+     * instantiate scale instances.
+     *
+     * @returns {{
+     *   assembly: import("../spec/scale.js").Scale["assembly"] | undefined,
+     *   needsDefaultAssembly: boolean
+     * }}
+     */
+    getAssemblyRequirement() {
+        const props = this.#getMergedScaleProps();
+        if (props === null || props.type === "null" || props.type !== LOCUS) {
+            return {
+                assembly: undefined,
+                needsDefaultAssembly: false,
+            };
+        }
+
+        return {
+            assembly: props.assembly,
+            needsDefaultAssembly: props.assembly === undefined,
+        };
+    }
+
+    /**
+     * Returns the resolved scale type without instantiating the scale.
+     *
+     * Useful during view construction, before assembly preflight has loaded
+     * URL-backed locus genomes.
+     *
+     * @returns {import("../spec/scale.js").Scale["type"] | undefined}
+     */
+    getResolvedScaleType() {
+        const props = this.#getMergedScaleProps();
+        if (props === null || props.type === "null") {
+            return undefined;
+        }
+
+        return props.type;
+    }
+
     /**
      * Returns the merged scale properties supplemented with inferred properties
      * and domain.
@@ -439,13 +734,15 @@ export default class ScaleResolution {
             return { type: "null" };
         }
 
-        const domain =
-            this.#domainAggregator.getConfiguredOrDefaultDomain(
-                extractDataDomain
-            );
+        const resolvedProps = { ...props };
+
+        const domain = this.#getConfiguredOrDefaultDomain(
+            extractDataDomain,
+            resolvedProps.type === LOCUS ? resolvedProps.assembly : undefined
+        );
 
-        if (isDiscrete(props.type)) {
-            const isExplicit = this.#isExplicitDomain();
+        if (isDiscrete(resolvedProps.type)) {
+            const isExplicit = this.isDomainDefinedExplicitly();
             const indexer = this.#getCategoricalIndexer(isExplicit);
             if (domain != null) {
                 if (
@@ -461,7 +758,7 @@ export default class ScaleResolution {
                 const indexedDomain = indexer
                     .domain()
                     .filter((value) => active.has(value));
-                props.domain =
+                resolvedProps.domain =
                     indexedDomain.length > 0
                         ? /** @type {import("../spec/scale.js").ScalarDomain} */ (
                               indexedDomain
@@ -469,7 +766,7 @@ export default class ScaleResolution {
                         : new NominalDomain();
             } else {
                 const indexedDomain = indexer.domain();
-                props.domain =
+                resolvedProps.domain =
                     indexedDomain.length > 0
                         ? /** @type {import("../spec/scale.js").ScalarDomain} */ (
                               indexedDomain
@@ -477,18 +774,21 @@ export default class ScaleResolution {
                         : new NominalDomain();
             }
             // Scale props are spec-shaped; keep the indexer off the public type.
-            /** @type {any} */ (props).domainIndexer = indexer;
+            /** @type {any} */ (resolvedProps).domainIndexer = indexer;
         } else if (domain && domain.length > 0) {
-            props.domain = domain;
+            resolvedProps.domain = domain;
         }
 
-        if (!props.domain && props.domainMid !== undefined) {
+        if (!resolvedProps.domain && resolvedProps.domainMid !== undefined) {
             // Initialize with a bogus domain so that scale.js can inject the domainMid.
             // The number of domain elements must be know before the glsl scale is generated.
-            props.domain = [props.domainMin ?? 0, props.domainMax ?? 1];
+            resolvedProps.domain = [
+                resolvedProps.domainMin ?? 0,
+                resolvedProps.domainMax ?? 1,
+            ];
         }
 
-        return props;
+        return resolvedProps;
     }
 
     /**
@@ -512,15 +812,17 @@ export default class ScaleResolution {
      * or when scale properties are otherwise re-resolved from the view hierarchy.
      */
     reconfigure() {
-        this.#domainAggregator.invalidateConfiguredDomain();
-        const state = this.#computeScaleState(true);
-        if (!state) {
-            return;
-        }
-        this.#applyReconfigure(state, (scale, props) =>
-            this.#scaleManager.reconfigureScale(props)
-        );
-        this.#finalizeReconfigure(state);
+        this.#withSelectionReverseSyncSuppressed(() => {
+            this.#invalidateConfiguredDomain();
+            const state = this.#computeScaleState(true);
+            if (!state) {
+                return;
+            }
+            this.#applyReconfigure(state, (scale, props) =>
+                this.#scaleManager.reconfigureScale(props)
+            );
+            this.#finalizeReconfigure(state);
+        });
     }
 
     /**
@@ -530,28 +832,32 @@ export default class ScaleResolution {
      *
      */
     reconfigureDomain() {
-        const state = this.#computeScaleState(true, true);
-        if (!state) {
-            return;
-        }
-        const { domainConfig, targetDomain } = state;
-        const domainMatches =
-            targetDomain != null &&
-            shallowArrayEquals(targetDomain, state.scale.domain());
-
-        if (targetDomain != null && !domainMatches) {
-            this.#applyReconfigure(state, (scale) => {
-                scale.domain(targetDomain);
-                if (domainConfig.applyOrdinalUnknown) {
-                    // Keep ordinal unknown handling close to the domain write so
-                    // domainImplicit semantics stay aligned with the applied domain.
-                    /** @type {any} */ (scale).unknown(
-                        domainConfig.ordinalUnknown
-                    );
-                }
-            });
-        }
-        this.#finalizeReconfigure(state);
+        this.#withSelectionReverseSyncSuppressed(() => {
+            this.#invalidateMergedScaleProps();
+            const state = this.#computeScaleState(true, true);
+            if (!state) {
+                return;
+            }
+            const { domainConfig, targetDomain } = state;
+            const domainMatches =
+                targetDomain != null &&
+                shallowArrayEquals(targetDomain, state.scale.domain());
+
+            if (targetDomain != null && !domainMatches) {
+                this.#applyReconfigure(state, (scale) => {
+                    scale.domain(targetDomain);
+                    if (domainConfig.applyOrdinalUnknown) {
+                        // Keep ordinal unknown handling close to the domain write so
+                        // domainImplicit semantics stay aligned with the applied domain.
+                        /** @type {any} */ (scale).unknown(
+                            domainConfig.ordinalUnknown
+                        );
+                    }
+                });
+            }
+            this.#finalizeReconfigure(state);
+            this.syncLinkedSelectionFromDomain();
+        });
     }
 
     /**
@@ -562,6 +868,7 @@ export default class ScaleResolution {
      *     props: import("../spec/scale.js").Scale,
      *     previousDomain: any[],
      *     domainWasInitialized: boolean,
+     *     hasSelectionConfiguredDomain: boolean,
      *     domainConfig?: ReturnType<typeof configureDomain>,
      *     targetDomain?: any[] | null,
      * } | undefined}
@@ -577,7 +884,9 @@ export default class ScaleResolution {
             scale,
             props: this.#getScaleProps(extractDataDomain),
             previousDomain: scale.domain(),
-            domainWasInitialized: this.#isDomainInitialized(),
+            domainWasInitialized: this.isDomainInitialized(),
+            hasSelectionConfiguredDomain:
+                this.#domainAggregator.hasSelectionConfiguredDomain(),
         };
 
         if (includeDomainConfig) {
@@ -610,15 +919,26 @@ export default class ScaleResolution {
      *     scale: ScaleWithProps,
      *     previousDomain: any[],
      *     domainWasInitialized: boolean,
+     *     hasSelectionConfiguredDomain: boolean,
      * }} inputs
      */
     #finalizeReconfigure(inputs) {
-        const { scale, previousDomain, domainWasInitialized } = inputs;
+        const {
+            scale,
+            previousDomain,
+            domainWasInitialized,
+            hasSelectionConfiguredDomain,
+        } = inputs;
+
+        const initialDomainSnapshot = hasSelectionConfiguredDomain
+            ? this.#domainAggregator.getDefaultDomain(true)
+            : undefined;
 
         if (
             this.#domainAggregator.captureInitialDomain(
                 scale,
-                domainWasInitialized
+                domainWasInitialized,
+                initialDomainSnapshot
             )
         ) {
             // Domain changes were suppressed during reconfigure; notify explicitly.
@@ -633,12 +953,22 @@ export default class ScaleResolution {
         );
 
         if (action === "restore") {
-            // Don't mess with zoomed views, restore the previous domain
-            this.#scaleManager.withDomainNotificationsSuppressed(() => {
-                scale.domain(previousDomain);
-            });
+            if (hasSelectionConfiguredDomain) {
+                // Selection-linked domains are the source of truth and must not
+                // be overridden by previously zoomed domains.
+                this.#notifyListeners("domain");
+            } else {
+                // Don't mess with zoomed views, restore the previous domain
+                this.#scaleManager.withDomainNotificationsSuppressed(() => {
+                    scale.domain(previousDomain);
+                });
+            }
         } else if (action === "animate") {
-            if (this.#hasRenderedMember()) {
+            if (hasSelectionConfiguredDomain) {
+                // Linked domains can update continuously (e.g., brushing), so
+                // skip zoomTo transitions and apply domain updates directly.
+                this.#notifyListeners("domain");
+            } else if (this.#hasRenderedMember()) {
                 // It can be zoomed, so lets make a smooth transition.
                 // Restore the previous domain and zoom smoothly to the new domain.
                 this.#scaleManager.withDomainNotificationsSuppressed(() => {
@@ -712,10 +1042,39 @@ export default class ScaleResolution {
      */
     getComplexDomain() {
         return /** @type {NumericDomain | ComplexDomain} */ (
-            toComplexInterval(this.#getGenomeSource(), this.getDomain())
+            toComplexInterval(
+                this.#getGenomeSource(),
+                toExternalIndexLikeInterval(this.type, this.getDomain())
+            )
         );
     }
 
+    /**
+     * Returns metadata about a selection-linked domain, if present.
+     */
+    getLinkedSelectionDomainInfo() {
+        const linkInfo = this.#getLinkedSelectionInfo();
+        if (!linkInfo) {
+            return;
+        }
+
+        const root = this.#firstMemberView.getLayoutAncestors().at(-1);
+        const persist = root
+            ? findIntervalSelectionBindingOwners(
+                  root,
+                  linkInfo.runtime,
+                  linkInfo.param,
+                  linkInfo.encoding
+              ).some((owner) => owner.param.persist !== false)
+            : false;
+
+        return {
+            param: linkInfo.param,
+            encoding: linkInfo.encoding,
+            persist,
+        };
+    }
+
     /**
      * Return true if the scale is zoomable and the current domain differs from the initial domain.
      *
@@ -729,8 +1088,14 @@ export default class ScaleResolution {
      * Returns true if zooming is supported and allowed in view spec.
      */
     isZoomable() {
-        // Check explicit configuration
-        return this.#interactionController.isZoomable();
+        const props = this.#getMergedScaleProps();
+        if (props === null || props.type === "null") {
+            return false;
+        }
+
+        return (
+            isContinuous(props.type) && !isDiscrete(props.type) && !!props.zoom
+        );
     }
 
     /**
@@ -847,3 +1212,60 @@ export default class ScaleResolution {
         return /** @type {number[]} */ (interval);
     }
 }
+
+/**
+ * @param {number[] | null} a
+ * @param {number[] | null} b
+ * @returns {boolean}
+ */
+function intervalsEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+
+    if (!a || !b) {
+        return false;
+    }
+
+    return a.length === b.length && shallowArrayEquals(a, b);
+}
+
+/**
+ * Normalizes member-specific scale URLs so that inline `scale.assembly.url`
+ * values resolve against the member view's base URL before scale props are
+ * merged.
+ *
+ * @template {ChannelWithScale}[T=ChannelWithScale]
+ * @param {ScaleResolutionMember<T>} member
+ * @returns {ScaleResolutionMember<T>}
+ */
+function normalizeMember(member) {
+    const scale = member.channelDef.scale;
+    const assembly = scale?.assembly;
+    if (!scale || !assembly || typeof assembly !== "object") {
+        return member;
+    }
+
+    if (!("url" in assembly)) {
+        return member;
+    }
+
+    const resolvedUrl = resolveUrl(member.view.getBaseUrl(), assembly.url);
+    if (resolvedUrl === assembly.url) {
+        return member;
+    }
+
+    return {
+        ...member,
+        channelDef: {
+            ...member.channelDef,
+            scale: {
+                ...scale,
+                assembly: {
+                    ...assembly,
+                    url: resolvedUrl,
+                },
+            },
+        },
+    };
+}