@genome-spy/core 0.77.0 → 0.79.0

package/dist/src/scales/scalePropsResolver.js

@@ -9,7 +9,12 @@ import {
     getConfiguredNamedRange,
     isConfigRangeName,
 } from "../config/scaleConfig.js";
-import { applyLockedProperties, getDefaultScaleType } from "./scaleRules.js";
+import { collectConfiguredDomainExprRefs } from "./domainExpressions.js";
+import {
+    applyLockedProperties,
+    getDefaultScaleType,
+    validateScaleTypeCompatibility,
+} from "./scaleRules.js";
 import { INDEX, LOCUS } from "./scaleResolutionConstants.js";
 
 /**
@@ -23,6 +28,7 @@ import { INDEX, LOCUS } from "./scaleResolutionConstants.js";
  * @param {Channel} options.channel
  * @param {import("../spec/channel.js").Type} options.dataType
  * @param {ScaleResolutionMember[]} options.orderedMembers
+ * @param {{ view: import("../view/view.js").default, config: Scale } | undefined} [options.viewLevelScaleConfig]
  * @param {boolean} options.isExplicitDomain
  * @param {import("../spec/config.js").GenomeSpyConfig[]} options.configScopes
  * @returns {Scale}
@@ -31,6 +37,7 @@ export function resolveScalePropsBase({
     channel,
     dataType,
     orderedMembers,
+    viewLevelScaleConfig,
     isExplicitDomain,
     configScopes,
 }) {
@@ -44,9 +51,11 @@ export function resolveScalePropsBase({
         )
         .filter((markType) => !!markType);
 
-    const propArray = memberList
-        .map((member) => member.channelDef.scale)
-        .filter((props) => props !== undefined);
+    const propArray = viewLevelScaleConfig
+        ? [viewLevelScaleConfig.config]
+        : memberList
+              .map((member) => member.channelDef.scale)
+              .filter((props) => props !== undefined);
 
     // TODO: Disabled scale: https://vega.github.io/vega-lite/docs/scale.html#disable
     const mergedProps = mergeObjects(propArray, "scale", ["domain"]);
@@ -76,6 +85,13 @@ export function resolveScalePropsBase({
         props.type = getDefaultScaleType(channel, dataType);
     }
 
+    validateScaleTypeCompatibility(
+        channel,
+        dataType,
+        viewLevelScaleConfig ? props.type : undefined,
+        `View-level scales.${channel}.type`
+    );
+
     if (typeof props.range == "string") {
         if (!isConfigRangeName(props.range)) {
             throw new Error(
@@ -132,9 +148,15 @@ export function resolveScalePropsBase({
     }
 
     if (props.domainTransition === undefined) {
-        const hasExprDrivenDomain = memberList.some((member) =>
-            isExprRef(member.channelDef.scale?.domain)
-        );
+        const hasExprDrivenDomain =
+            memberList.some(
+                (member) =>
+                    collectConfiguredDomainExprRefs(
+                        member.channelDef.scale?.domain
+                    ).length > 0
+            ) ||
+            collectConfiguredDomainExprRefs(viewLevelScaleConfig?.config.domain)
+                .length > 0;
         props.domainTransition = !hasExprDrivenDomain;
     }
 
@@ -143,9 +165,12 @@ export function resolveScalePropsBase({
         props.range.some(isExprRef) &&
         memberList.length > 0
     ) {
-        const rangeOwner = memberList.find(
-            (member) => member.channelDef.scale?.range !== undefined
-        )?.view;
+        const rangeOwner =
+            viewLevelScaleConfig?.config.range !== undefined
+                ? viewLevelScaleConfig.view
+                : memberList.find(
+                      (member) => member.channelDef.scale?.range !== undefined
+                  )?.view;
         if (rangeOwner) {
             /** @type {any} */
             (props).__rangeExprScope = rangeOwner;

package/dist/src/scales/scaleResolution.d.ts

@@ -68,6 +68,22 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * @returns {() => boolean}
      */
     registerMember(member: ScaleResolutionMember): () => boolean;
+    /**
+     * @param {import("../view/view.js").default} view
+     * @param {import("../spec/scale.js").Scale} config
+     */
+    attachViewLevelScaleConfig(view: import("../view/view.js").default, config: import("../spec/scale.js").Scale): void;
+    /**
+     * @param {import("../view/view.js").default} view
+     */
+    clearViewLevelScaleConfig(view: import("../view/view.js").default): void;
+    /**
+     * @returns {{ view: import("../view/view.js").default, config: import("../spec/scale.js").Scale } | undefined}
+     */
+    getViewLevelScaleConfig(): {
+        view: import("../view/view.js").default;
+        config: import("../spec/scale.js").Scale;
+    } | undefined;
     dispose(): void;
     /**
      * @param {import("../data/collector.js").default} collector
@@ -80,6 +96,39 @@ export default class ScaleResolution implements ScaleResolutionApi {
      */
     isDomainDefinedExplicitly(): boolean;
     isDomainInitialized(): boolean;
+    /**
+     * Returns the participating members in the same deterministic order used
+     * for scale property merging.
+     *
+     * @returns {ScaleResolutionMember[]}
+     */
+    getOrderedMembers(): ScaleResolutionMember[];
+    getDebugState(): {
+        kind: string;
+        channel: import("../spec/channel.js").Channel;
+        hostView: import("../view/view.js").default<import("../spec/view.js").ViewSpec>;
+        name: string;
+        type: import("../spec/channel.js").Type;
+        resolvedScaleType: import("../spec/scale.js").ScaleType;
+        domain: any[];
+        complexDomain: import("../spec/scale.js").NumericDomain | import("../spec/scale.js").ComplexDomain;
+        range: any[];
+        zoomable: boolean;
+        zoomed: boolean;
+        members: {
+            view: import("../view/unitView.js").default<import("../spec/view.js").UnitSpec>;
+            channel: import("../spec/channel.js").ChannelWithScale;
+            channelDef: import("../spec/channel.js").ChannelDefWithScale;
+            contributesToDomain: boolean;
+            active: boolean;
+        }[];
+        activeMemberCount: number;
+        dataDomainMemberCount: number;
+        viewLevelScaleConfig: {
+            view: import("../view/view.js").default<import("../spec/view.js").ViewSpec>;
+            config: import("../spec/scale.js").Scale;
+        };
+    };
     /**
      * Returns locus assembly requirements without initializing the scale.
      *
@@ -129,6 +178,9 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * Returns the scale instance, creating it if needed.
      *
      * Use this from call sites that may run before explicit initialization.
+     * Creating the scale resolves default domains and may require loaded
+     * assemblies for locus scales. For side-effect-free type checks, use
+     * `getResolvedScaleType()`.
      *
      * @returns {ScaleWithProps}
      */

package/dist/src/scales/scaleResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAoDA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA8cI;;;;;;;;OAQG;IACH,uBALa,CAAC,eACH,QAAQ,CAAC,eAAe,CAAC,YACzB,MAAM,CAAC,GACL,CAAC,CAqBb;IAnaD;;;OAGG;IACH,sEAFW,OAAO,iBAAiB,EAAE,OAAO,EAuC3C;IApCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IA2EzB,2BASC;IAwBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAiCD,sCA6CC;IA+MD;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAazB;IAED,gBAMC;IAoFD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IAED;;OAEG;IACH,qCAEC;IAED,+BAiBC;IAuED;;;;;;;;;;;OAWG;IACH,0BALa;QACR,QAAQ,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC;QACnE,oBAAoB,EAAE,OAAO,CAAA;KAC9B,CAeH;IAED;;;;;;;OAOG;IACH,wBAFa,OAAO,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,CAShE;IAgGD;;;;;OAKG;IACH,oBAYC;IAED;;;;;OAKG;IACH,0BA0BC;IAoID;;OAEG;IACH;eAnhCkC,OAAO,kBAAkB,EAAE,KAAK;MA0hCjE;IAED;;;;;;OAMG;IACH;eAniCkC,OAAO,kBAAkB,EAAE,KAAK;MA0iCjE;IAED;;;;OAIG;IACH;eAjjCkC,OAAO,kBAAkB,EAAE,KAAK;MA0jCjE;IAED,mBASC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CASzC;IAED;;OAEG;IACH;;;;MAqBC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,YAC7B,OAAO,gCAAgC,EAAE,aAAa,GAAG,OAAO,GAAG,MAAM,iBAKnF;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCAxyC+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBApCV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}
+{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAkDA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAwdI;;;;;;;;OAQG;IACH,uBALa,CAAC,eACH,QAAQ,CAAC,eAAe,CAAC,YACzB,MAAM,CAAC,GACL,CAAC,CAqBb;IAxaD;;;OAGG;IACH,sEAFW,OAAO,iBAAiB,EAAE,OAAO,EAyC3C;IAtCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IA6EzB,2BASC;IAwBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAiCD,sCA6CC;IAkND;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAazB;IAED;;;OAGG;IACH,iCAHW,OAAO,iBAAiB,EAAE,OAAO,UACjC,OAAO,kBAAkB,EAAE,KAAK,QAyB1C;IAED;;OAEG;IACH,gCAFW,OAAO,iBAAiB,EAAE,OAAO,QAc3C;IAED;;OAEG;IACH,2BAFa;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAA;KAAE,GAAG,SAAS,CAI7G;IA2CD,gBAMC;IAqGD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IAED;;OAEG;IACH,qCAEC;IAED,+BAiBC;IA+CD;;;;;OAKG;IACH,qBAFa,qBAAqB,EAAE,CAInC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;MA+BC;IAwCD;;;;;;;;;;;OAWG;IACH,0BALa;QACR,QAAQ,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC;QACnE,oBAAoB,EAAE,OAAO,CAAA;KAC9B,CAeH;IAED;;;;;;;OAOG;IACH,wBAFa,OAAO,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,CAShE;IAgGD;;;;;OAKG;IACH,oBAYC;IAED;;;;;OAKG;IACH,0BA0BC;IAoID;;OAEG;IACH;eArsCkC,OAAO,kBAAkB,EAAE,KAAK;MA4sCjE;IAED;;;;;;;;;OASG;IACH;eAxtCkC,OAAO,kBAAkB,EAAE,KAAK;MA+tCjE;IAED;;;;OAIG;IACH;eAtuCkC,OAAO,kBAAkB,EAAE,KAAK;MA+uCjE;IAED,mBASC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CASzC;IAED;;OAEG;IACH;;;;MAqBC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,YAC7B,OAAO,gCAAgC,EAAE,aAAa,GAAG,OAAO,GAAG,MAAM,iBAKnF;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCA79C+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBAjCV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}

package/dist/src/scales/scaleResolution.js

@@ -15,6 +15,7 @@ import ScaleInstanceManager from "./scaleInstanceManager.js";
 import { resolveScalePropsBase } from "./scalePropsResolver.js";
 import DomainPlanner from "./domainPlanner.js";
 import ScaleInteractionController from "./scaleInteractionController.js";
+import { validateScaleTypeCompatibility } from "./scaleRules.js";
 import {
     INDEX,
     LOCUS,
@@ -24,11 +25,8 @@ import {
 } from "./scaleResolutionConstants.js";
 
 import { getAccessorDomainKey } from "../encoder/accessor.js";
-import {
-    isPrimaryPositionalChannel,
-    isSecondaryChannel,
-} from "../encoder/encoder.js";
-import { isExprRef } from "../paramRuntime/paramUtils.js";
+import { isSecondaryChannel } from "../encoder/encoder.js";
+import { collectConfiguredDomainExprRefs } from "./domainExpressions.js";
 import { NominalDomain } from "../utils/domainArray.js";
 import { shallowArrayEquals } from "../utils/arrayUtils.js";
 import createIndexer from "../utils/indexer.js";
@@ -143,6 +141,11 @@ export default class ScaleResolution {
     /** @type {import("../view/view.js").default | undefined} */
     #hostView;
 
+    /**
+     * @type {{ view: import("../view/view.js").default, config: import("../spec/scale.js").Scale } | undefined}
+     */
+    #viewLevelScaleConfig;
+
     #resolvingScaleProps = 0;
 
     #memberRegistrationBatchDepth = 0;
@@ -168,6 +171,8 @@ export default class ScaleResolution {
             getAllMembers: () => this.#members,
             getDataMembers: () =>
                 this.#getActiveMembers(this.#dataDomainMembers),
+            getViewLevelConfiguredDomain: () =>
+                this.#getViewLevelConfiguredDomain(),
             getType: () => this.type,
             getLocusExtent: (assembly) => this.#getLocusExtent(assembly),
             fromComplexInterval: this.fromComplexInterval.bind(this),
@@ -400,6 +405,10 @@ export default class ScaleResolution {
      * @returns {boolean}
      */
     #hasConfiguredDomain() {
+        if (this.#viewLevelScaleConfig?.config.domain !== undefined) {
+            return true;
+        }
+
         for (const member of this.#members) {
             if (
                 member.contributesToDomain &&
@@ -452,6 +461,8 @@ export default class ScaleResolution {
         const member = normalizeMember(newMember);
         const { channel, channelDef } = member;
 
+        this.#assertCanRegisterMember(member);
+
         // A convenience hack for cases where the new member should adapt
         // the scale type to the existing one. For example: SelectionRect
         // TODO: Add test
@@ -481,15 +492,12 @@ export default class ScaleResolution {
             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}".`
-            );
-        }
+        validateScaleTypeCompatibility(
+            this.channel,
+            type,
+            effectiveScaleType,
+            `encoding.${channel}.scale.type`
+        );
 
         if (name) {
             if (this.name !== undefined && name != this.name) {
@@ -587,6 +595,100 @@ export default class ScaleResolution {
         };
     }
 
+    /**
+     * @param {import("../view/view.js").default} view
+     * @param {import("../spec/scale.js").Scale} config
+     */
+    attachViewLevelScaleConfig(view, config) {
+        if (
+            this.#viewLevelScaleConfig &&
+            this.#viewLevelScaleConfig.view !== view
+        ) {
+            throw new Error(
+                `Multiple view-level scale configs target the same ${this.channel} scale resolution.`
+            );
+        }
+
+        for (const member of this.#members) {
+            this.#assertMemberHasNoScaleConfig(member);
+        }
+
+        this.#viewLevelScaleConfig = { view, config };
+        this.#invalidateMergedScaleProps();
+        this.#invalidateConfiguredDomain();
+        this.#refreshSelectionDomainParamSubscriptions();
+        this.#refreshConfiguredDomainExprSubscriptions();
+        if (this.#scaleManager.scale) {
+            this.#scaleManager.resetScale();
+            this.initializeScale();
+        }
+    }
+
+    /**
+     * @param {import("../view/view.js").default} view
+     */
+    clearViewLevelScaleConfig(view) {
+        if (this.#viewLevelScaleConfig?.view === view) {
+            this.#viewLevelScaleConfig = undefined;
+            this.#invalidateMergedScaleProps();
+            this.#invalidateConfiguredDomain();
+            this.#refreshSelectionDomainParamSubscriptions();
+            this.#refreshConfiguredDomainExprSubscriptions();
+            if (this.#scaleManager.scale) {
+                this.#scaleManager.resetScale();
+                this.initializeScale();
+            }
+        }
+    }
+
+    /**
+     * @returns {{ view: import("../view/view.js").default, config: import("../spec/scale.js").Scale } | undefined}
+     */
+    getViewLevelScaleConfig() {
+        return this.#viewLevelScaleConfig;
+    }
+
+    #getViewLevelConfiguredDomain() {
+        const viewLevelScaleConfig = this.#viewLevelScaleConfig;
+        if (!viewLevelScaleConfig) {
+            return undefined;
+        }
+
+        return {
+            view: viewLevelScaleConfig.view,
+            channel:
+                /** @type {import("../spec/channel.js").ChannelWithScale} */ (
+                    this.channel
+                ),
+            type: this.type,
+            domain: viewLevelScaleConfig.config.domain,
+        };
+    }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     */
+    #assertCanRegisterMember(member) {
+        if (!this.#viewLevelScaleConfig) {
+            return;
+        }
+
+        this.#assertMemberHasNoScaleConfig(member);
+    }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     */
+    #assertMemberHasNoScaleConfig(member) {
+        if (member.channelDef.scale === undefined) {
+            return;
+        }
+
+        throw new Error(
+            `Cannot mix view-level scales.${this.channel} with encoding.${member.channel}.scale in the same scale resolution.`
+        );
+    }
+
     dispose() {
         this.#clearSelectionDomainParamSubscriptions();
         this.#clearConfiguredDomainExprSubscriptions();
@@ -658,11 +760,28 @@ export default class ScaleResolution {
                 continue;
             }
             const domain = member.channelDef.scale?.domain;
-            if (!isExprRef(domain)) {
+            const exprRefs = collectConfiguredDomainExprRefs(domain);
+            if (exprRefs.length === 0) {
                 continue;
             }
 
-            const expr = member.view.paramRuntime.createExpression(domain.expr);
+            for (const exprRef of exprRefs) {
+                const expr = member.view.paramRuntime.createExpression(
+                    exprRef.expr
+                );
+                const unsubscribe = expr.subscribe(listener);
+                this.#configuredDomainExprUnsubscribers.push(unsubscribe);
+            }
+        }
+
+        const viewLevelDomain = this.#viewLevelScaleConfig?.config.domain;
+        const viewLevelExprRefs =
+            collectConfiguredDomainExprRefs(viewLevelDomain);
+        for (const exprRef of viewLevelExprRefs) {
+            const expr =
+                this.#viewLevelScaleConfig.view.paramRuntime.createExpression(
+                    exprRef.expr
+                );
             const unsubscribe = expr.subscribe(listener);
             this.#configuredDomainExprUnsubscribers.push(unsubscribe);
         }
@@ -754,6 +873,7 @@ export default class ScaleResolution {
                 channel: this.channel,
                 dataType: this.type,
                 orderedMembers: this.#getOrderedMembers(),
+                viewLevelScaleConfig: this.#viewLevelScaleConfig,
                 isExplicitDomain: this.isDomainDefinedExplicitly(),
                 configScopes: this.#resolutionView.getConfigScopes(),
             });
@@ -786,6 +906,62 @@ export default class ScaleResolution {
         return this.#orderedMembers;
     }
 
+    /**
+     * Returns the participating members in the same deterministic order used
+     * for scale property merging.
+     *
+     * @returns {ScaleResolutionMember[]}
+     */
+    getOrderedMembers() {
+        return this.#getOrderedMembers().slice();
+    }
+
+    getDebugState() {
+        const scale = this.#scaleManager.scale;
+        const canReadDomain = scale && typeof scale.domain === "function";
+        const canReadRange = scale && typeof scale.range === "function";
+
+        return {
+            kind: "scale",
+            channel: this.channel,
+            hostView: this.#resolutionView,
+            name: this.name,
+            type: this.type,
+            resolvedScaleType: this.getResolvedScaleType(),
+            domain: canReadDomain ? this.getDomain() : undefined,
+            complexDomain: canReadDomain ? this.getComplexDomain() : undefined,
+            range: canReadRange ? scale.range() : undefined,
+            zoomable: this.isZoomable(),
+            zoomed: this.isZoomable() ? this.isZoomed() : false,
+            members: this.#getOrderedMembers().map((member) =>
+                this.#createDebugMember(member)
+            ),
+            activeMemberCount: this.#getActiveMembers().size,
+            dataDomainMemberCount: this.#dataDomainMembers.size,
+            viewLevelScaleConfig: this.#viewLevelScaleConfig
+                ? {
+                      view: this.#viewLevelScaleConfig.view,
+                      config: structuredClone(
+                          this.#viewLevelScaleConfig.config
+                      ),
+                  }
+                : undefined,
+        };
+    }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     */
+    #createDebugMember(member) {
+        return {
+            view: member.view,
+            channel: member.channel,
+            channelDef: structuredClone(member.channelDef),
+            contributesToDomain: member.contributesToDomain,
+            active: this.#getActiveMembers().has(member),
+        };
+    }
+
     #invalidateConfiguredDomain() {
         this.#domainAggregator.invalidateConfiguredDomain();
         this.#invalidateMergedScaleProps();
@@ -1149,6 +1325,9 @@ export default class ScaleResolution {
      * Returns the scale instance, creating it if needed.
      *
      * Use this from call sites that may run before explicit initialization.
+     * Creating the scale resolves default domains and may require loaded
+     * assemblies for locus scales. For side-effect-free type checks, use
+     * `getResolvedScaleType()`.
      *
      * @returns {ScaleWithProps}
      */

package/dist/src/scales/scaleRules.d.ts

@@ -7,6 +7,16 @@
  * @returns {import("../spec/scale.js").ScaleType}
  */
 export function getDefaultScaleType(channel: Channel, dataType: import("../spec/channel.js").Type): import("../spec/scale.js").ScaleType;
+/**
+ * Validates explicit scale type choices against the resolved data type and
+ * channel constraints.
+ *
+ * @param {Channel} channel
+ * @param {import("../spec/channel.js").Type} dataType
+ * @param {import("../spec/scale.js").ScaleType | undefined} scaleType
+ * @param {string} source
+ */
+export function validateScaleTypeCompatibility(channel: Channel, dataType: import("../spec/channel.js").Type, scaleType: import("../spec/scale.js").ScaleType | undefined, source: string): void;
 /**
  * @param {import("../spec/scale.js").Scale} props
  * @param {Channel} channel

package/dist/src/scales/scaleRules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleRules.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleRules.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;;;;GAIG;AACH,6CAJW,OAAO,YACP,OAAO,oBAAoB,EAAE,IAAI,GAC/B,OAAO,kBAAkB,EAAE,SAAS,CA2EhD;AAED;;;GAGG;AACH,6CAHW,OAAO,kBAAkB,EAAE,KAAK,WAChC,OAAO,QAgBjB;sBArGY,OAAO,oBAAoB,EAAE,OAAO"}
+{"version":3,"file":"scaleRules.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleRules.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;;;;GAIG;AACH,6CAJW,OAAO,YACP,OAAO,oBAAoB,EAAE,IAAI,GAC/B,OAAO,kBAAkB,EAAE,SAAS,CA0EhD;AAED;;;;;;;;GAQG;AACH,wDALW,OAAO,YACP,OAAO,oBAAoB,EAAE,IAAI,aACjC,OAAO,kBAAkB,EAAE,SAAS,GAAG,SAAS,UAChD,MAAM,QA6BhB;AAED;;;GAGG;AACH,6CAHW,OAAO,kBAAkB,EAAE,KAAK,WAChC,OAAO,QAgBjB;sBA1IY,OAAO,oBAAoB,EAAE,OAAO"}

package/dist/src/scales/scaleRules.js

@@ -37,7 +37,6 @@ export function getDefaultScaleType(channel, dataType) {
         if (isPrimaryPositionalChannel(channel)) {
             return dataType;
         } else {
-            // TODO: Also explicitly set scales should be validated
             throw new Error(
                 channel +
                     " does not support " +
@@ -96,6 +95,44 @@ export function getDefaultScaleType(channel, dataType) {
     return type;
 }
 
+/**
+ * Validates explicit scale type choices against the resolved data type and
+ * channel constraints.
+ *
+ * @param {Channel} channel
+ * @param {import("../spec/channel.js").Type} dataType
+ * @param {import("../spec/scale.js").ScaleType | undefined} scaleType
+ * @param {string} source
+ */
+export function validateScaleTypeCompatibility(
+    channel,
+    dataType,
+    scaleType,
+    source
+) {
+    if (!scaleType) {
+        return;
+    }
+
+    if (
+        [INDEX, LOCUS].includes(scaleType) &&
+        !isPrimaryPositionalChannel(channel)
+    ) {
+        throw new Error(
+            `Index and locus scales are only supported on positional channels (x/y). Channel "${channel}" resolves to scale type "${scaleType}".`
+        );
+    }
+
+    if (
+        ([INDEX, LOCUS].includes(dataType) && scaleType !== dataType) ||
+        (scaleType === LOCUS && scaleType !== dataType)
+    ) {
+        throw new Error(
+            `${source} "${scaleType}" is incompatible with "${dataType}" data.`
+        );
+    }
+}
+
 /**
  * @param {import("../spec/scale.js").Scale} props
  * @param {Channel} channel

package/dist/src/scales/viewLevelGuideConfig.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Maps view-level axis configs and attaches non-pending configs to their
+ * target resolutions.
+ *
+ * @param {View} root
+ * @returns {ViewLevelAxisConfigMapping[]}
+ */
+export function attachViewLevelAxisConfigs(root: View): ViewLevelAxisConfigMapping[];
+/**
+ * Maps view-level legend configs and attaches non-pending configs to their
+ * target resolutions.
+ *
+ * @param {View} root
+ * @returns {ViewLevelLegendConfigMapping[]}
+ */
+export function attachViewLevelLegendConfigs(root: View): ViewLevelLegendConfigMapping[];
+/**
+ * Clears view-level guide configs owned by views in the subtree.
+ *
+ * @param {View} root
+ */
+export function clearViewLevelGuideConfigs(root: View): void;
+export type ChannelWithScale = import("../spec/channel.js").ChannelWithScale;
+export type PrimaryPositionalChannel = import("../spec/channel.js").PrimaryPositionalChannel;
+export type AxisConfig = import("../spec/axis.js").Axis & import("../spec/axis.js").GenomeAxis;
+export type LegendConfig = import("../spec/legend.js").Legend;
+export type View = import("../view/view.js").default;
+export type AxisResolution = import("./axisResolution.js").default;
+export type LegendResolution = import("./legendResolution.js").default;
+export type ViewLevelAxisConfigMapping = {
+    view: View;
+    channel: PrimaryPositionalChannel;
+    config: Partial<AxisConfig>;
+    resolution: AxisResolution | undefined;
+};
+export type ViewLevelLegendConfigMapping = {
+    view: View;
+    channel: ChannelWithScale;
+    config: LegendConfig;
+    resolution: LegendResolution | undefined;
+};
+export type GuideConfigSpec = {
+    configKey: "axes" | "legends";
+    resolutionType: "axis" | "legend";
+    getResolution: (view: View, channel: any) => AxisResolution | LegendResolution | undefined;
+    getAllResolutions: (view: View) => Iterable<AxisResolution | LegendResolution>;
+    attach: (resolution: any, view: View, config: any) => void;
+    getAttachedConfig: (resolution: any) => {
+        view: View;
+    } | undefined;
+    clear: (resolution: any, view: View) => void;
+};
+//# sourceMappingURL=viewLevelGuideConfig.d.ts.map

package/dist/src/scales/viewLevelGuideConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewLevelGuideConfig.d.ts","sourceRoot":"","sources":["../../../src/scales/viewLevelGuideConfig.js"],"names":[],"mappings":"AA0DA;;;;;;GAMG;AACH,iDAHW,IAAI,GACF,0BAA0B,EAAE,CAMxC;AAED;;;;;;GAMG;AACH,mDAHW,IAAI,GACF,4BAA4B,EAAE,CAM1C;AAED;;;;GAIG;AACH,iDAFW,IAAI,QAKd;+BAxFY,OAAO,oBAAoB,EAAE,gBAAgB;uCAC7C,OAAO,oBAAoB,EAAE,wBAAwB;yBACrD,OAAO,iBAAiB,EAAE,IAAI,GAAG,OAAO,iBAAiB,EAAE,UAAU;2BACrE,OAAO,mBAAmB,EAAE,MAAM;mBAClC,OAAO,iBAAiB,EAAE,OAAO;6BACjC,OAAO,qBAAqB,EAAE,OAAO;+BACrC,OAAO,uBAAuB,EAAE,OAAO;;UAG1C,IAAI;aACJ,wBAAwB;YACxB,OAAO,CAAC,UAAU,CAAC;gBACnB,cAAc,GAAG,SAAS;;;UAG1B,IAAI;aACJ,gBAAgB;YAChB,YAAY;gBACZ,gBAAgB,GAAG,SAAS;;;eAG5B,MAAM,GAAG,SAAS;oBAClB,MAAM,GAAG,QAAQ;mBACjB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,KAAK,cAAc,GAAG,gBAAgB,GAAG,SAAS;uBAC3E,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,cAAc,GAAG,gBAAgB,CAAC;YAC3D,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI;uBAClD,CAAC,UAAU,EAAE,GAAG,KAAK;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,SAAS;WAC/C,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI"}