@genome-spy/core 0.67.0 → 0.69.0

package/dist/src/view/axisView.js

@@ -1,5 +1,6 @@
 import LayerView from "./layerView.js";
 import { FlexDimensions } from "./layout/flexLayout.js";
+import { markViewAsNonAddressable } from "./viewSelectors.js";
 
 const CHROM_LAYER_NAME = "chromosome_ticks_and_labels";
 
@@ -93,12 +94,13 @@ export default class AxisView extends LayerView {
             `axis_${axisProps.orient}`,
             {
                 blockEncodingInheritance: true,
-                contributesToScaleDomain: false,
                 ...options,
             }
         );
 
         this.axisProps = fullAxisProps;
+
+        markViewAsNonAddressable(this, { skipSubtree: true });
     }
 
     getSize() {
@@ -266,6 +268,11 @@ function createAxis(axisProps, type) {
 
     const anchor = ap.orient == "bottom" || ap.orient == "left" ? 1 : 0;
 
+    const makeMainDomainDef = () => ({
+        field: "value",
+        type,
+    });
+
     /**
      * @return {import("../spec/view.js").UnitSpec}
      */
@@ -302,7 +309,7 @@ function createAxis(axisProps, type) {
             minBufferSize: 1500, // to prevent GPU buffer reallocation when zooming
         },
         encoding: {
-            [main]: { field: "value", type },
+            [main]: makeMainDomainDef(),
             text: { field: "label" },
         },
     });
@@ -358,7 +365,7 @@ function createAxis(axisProps, type) {
         const spec = {
             name: "ticks_and_labels",
             encoding: {
-                [main]: { field: "value", type },
+                [main]: makeMainDomainDef(),
             },
             layer: [],
         };
@@ -378,6 +385,7 @@ function createAxis(axisProps, type) {
     const axisSpec = {
         // Force the resolution towards the parent view even if it has "independent" behavior
         resolve: { scale: { [main]: "forced" } },
+        domainInert: true,
         [CHANNEL_DIMENSIONS[getPerpendicularChannel(main)]]: ap.extent,
         data: {
             lazy: {
@@ -527,7 +535,10 @@ export function createGenomeAxis(axisProps, type) {
                 ...chromLabelMarkProps,
             },
             encoding: {
-                [main + "2"]: { field: "continuousEnd", type },
+                [main + "2"]: {
+                    field: "continuousEnd",
+                    type,
+                },
                 text: { field: "name" },
             },
         };
@@ -582,7 +593,11 @@ export function createGenomeAxis(axisProps, type) {
             },
             encoding: {
                 // TODO: { chrom: "name", type: "locus" } // without pos = pos is 0
-                [main]: { field: "continuousStart", type, band: 0 },
+                [main]: {
+                    field: "continuousStart",
+                    type,
+                    band: 0,
+                },
             },
             layer: [],
         };

package/dist/src/view/concatView.js

@@ -44,12 +44,12 @@ export default class ConcatView extends GridView {
 
         this.setChildren(
             await Promise.all(
-                childSpecs.map((childSpec, i) =>
+                childSpecs.map((childSpec) =>
                     this.context.createOrImportView(
                         childSpec,
                         this,
                         this,
-                        "grid" + i
+                        this.getNextAutoName("grid")
                     )
                 )
             )
@@ -151,7 +151,7 @@ export default class ConcatView extends GridView {
             afterRemove: async () => {
                 await this.syncSharedAxes();
             },
-            defaultName: (_index) => "grid" + this.childCount,
+            defaultName: () => this.getNextAutoName("grid"),
         });
     }
 }

package/dist/src/view/containerMutationHelper.js

@@ -55,7 +55,7 @@ export default class ContainerMutationHelper {
         const insertIndex = index ?? specs.length;
         const name =
             this.options.defaultName?.(insertIndex, childSpec) ??
-            "child" + specs.length;
+            this.container.getNextAutoName("child");
 
         const childView = await this.container.context.createOrImportView(
             childSpec,

package/dist/src/view/containerView.d.ts

@@ -14,16 +14,19 @@ export default class ContainerView extends View {
     constructor(spec: import("../spec/view.js").ContainerSpec, context: import("../types/viewContext.js").default, layoutParent: ContainerView, dataParent: import("./view.js").default, name: string, options?: import("./view.js").ViewOptions);
     spec: import("../spec/view.js").ContainerSpec;
     initializeChildren(): Promise<void>;
+    /**
+     * Generates an auto name that is guaranteed to be unique within this container
+     * for the given prefix. Intended for debugging-only default names.
+     *
+     * @param {string} prefix
+     * @returns {string}
+     */
+    getNextAutoName(prefix: string): string;
     /**
      * @param {string[]} path An array of view names
      * @returns {View}
      */
     findDescendantByPath(path: string[]): View;
-    /**
-     *
-     * @param {string} name
-     */
-    findChildByName(name: string): View;
     /**
      *
      * @param {string} name
@@ -33,6 +36,7 @@ export default class ContainerView extends View {
      * @returns {IterableIterator<View>}
      */
     [Symbol.iterator](): IterableIterator<View>;
+    #private;
 }
 import View from "./view.js";
 //# sourceMappingURL=containerView.d.ts.map

package/dist/src/view/containerView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"containerView.d.ts","sourceRoot":"","sources":["../../../src/view/containerView.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;;;;;;OAQG;IACH,kBAPW,OAAO,iBAAiB,EAAE,aAAa,WACvC,OAAO,yBAAyB,EAAE,OAAO,gBACzC,aAAa,cACb,OAAO,WAAW,EAAE,OAAO,QAC3B,MAAM,YACN,OAAO,WAAW,EAAE,WAAW,EAMzC;IADG,8CAAgB;IAGpB,oCAEC;IAsDD;;;OAGG;IACH,2BAHW,MAAM,EAAE,GACN,IAAI,CAYhB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAchB;IAhGD;;OAEG;IACH,qBAFa,gBAAgB,CAAC,IAAI,CAAC,CAIlC;CAqGJ;iBAnI4C,WAAW"}
+{"version":3,"file":"containerView.d.ts","sourceRoot":"","sources":["../../../src/view/containerView.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAII;;;;;;;;OAQG;IACH,kBAPW,OAAO,iBAAiB,EAAE,aAAa,WACvC,OAAO,yBAAyB,EAAE,OAAO,gBACzC,aAAa,cACb,OAAO,WAAW,EAAE,OAAO,QAC3B,MAAM,YACN,OAAO,WAAW,EAAE,WAAW,EAMzC;IADG,8CAAgB;IAGpB,oCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAMlB;IAsDD;;;OAGG;IACH,2BAHW,MAAM,EAAE,GACN,IAAI,CAsBhB;IAaD;;;OAGG;IACH,2BAFW,MAAM,QAchB;IAzGD;;OAEG;IACH,qBAFa,gBAAgB,CAAC,IAAI,CAAC,CAIlC;;CA8GJ;iBA5J4C,WAAW"}

package/dist/src/view/containerView.js

@@ -4,6 +4,9 @@ import View, { VISIT_STOP, VISIT_SKIP } from "./view.js";
  * Compositor view represents a non-leaf node in the view hierarchy.
  */
 export default class ContainerView extends View {
+    /** @type {Map<string, number>} */
+    #autoNameCounters = new Map();
+
     /**
      *
      * @param {import("../spec/view.js").ContainerSpec} spec
@@ -23,6 +26,19 @@ export default class ContainerView extends View {
         // override
     }
 
+    /**
+     * Generates an auto name that is guaranteed to be unique within this container
+     * for the given prefix. Intended for debugging-only default names.
+     *
+     * @param {string} prefix
+     * @returns {string}
+     */
+    getNextAutoName(prefix) {
+        const counter = this.#autoNameCounters.get(prefix) ?? 0;
+        this.#autoNameCounters.set(prefix, counter + 1);
+        return prefix + counter;
+    }
+
     /**
      * @returns {IterableIterator<View>}
      */
@@ -80,22 +96,31 @@ export default class ContainerView extends View {
      * @returns {View}
      */
     findDescendantByPath(path) {
-        for (const child of this) {
-            if (child.name === path[0]) {
-                if (path.length == 1) {
-                    return child;
-                } else if (child instanceof ContainerView) {
-                    return child.findDescendantByPath(path.slice(1));
-                }
+        /** @type {View | ContainerView} */
+        let current = this;
+
+        for (let i = 0; i < path.length; i++) {
+            if (!(current instanceof ContainerView)) {
+                return;
+            }
+
+            const next = current.#findImmediateChildByName(path[i]);
+            if (!next) {
+                return;
             }
+
+            if (i === path.length - 1) {
+                return next;
+            }
+
+            current = next;
         }
     }
 
     /**
-     *
      * @param {string} name
      */
-    findChildByName(name) {
+    #findImmediateChildByName(name) {
         for (const child of this) {
             if (child.name === name) {
                 return child;

package/dist/src/view/dataReadiness.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {import("../view/view.js").default} View
+ * @typedef {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessRequest} DataReadinessRequest
+ */
+/**
+ * Builds a readiness request for the provided channels.
+ *
+ * @param {View} view
+ * @param {import("../spec/channel.js").PrimaryPositionalChannel[]} channels
+ * @returns {DataReadinessRequest | undefined}
+ */
+export function buildReadinessRequest(view: View, channels: import("../spec/channel.js").PrimaryPositionalChannel[]): DataReadinessRequest | undefined;
+/**
+ * Checks whether all data sources under the subtree report readiness.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeReady(subtreeRoot: View, readinessRequest: DataReadinessRequest, viewFilter?: (view: View) => boolean): boolean;
+/**
+ * Checks readiness for lazy data sources under the subtree. Non-lazy sources
+ * are ignored so they do not block readiness checks.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest | undefined} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeLazyReady(subtreeRoot: View, readinessRequest: DataReadinessRequest | undefined, viewFilter?: (view: View) => boolean): boolean;
+/**
+ * Waits until lazy data sources under the subtree satisfy the readiness request.
+ * Non-lazy sources are ignored so they do not block readiness checks.
+ *
+ * @param {import("../types/viewContext.js").default} context
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {AbortSignal} [signal]
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {Promise<void>}
+ */
+export function awaitSubtreeLazyReady(context: import("../types/viewContext.js").default, subtreeRoot: View, readinessRequest: DataReadinessRequest, signal?: AbortSignal, viewFilter?: (view: View) => boolean): Promise<void>;
+export type View = import("../view/view.js").default;
+export type DataReadinessRequest = import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessRequest;
+//# sourceMappingURL=dataReadiness.d.ts.map

package/dist/src/view/dataReadiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataReadiness.d.ts","sourceRoot":"","sources":["../../../src/view/dataReadiness.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;GAMG;AACH,4CAJW,IAAI,YACJ,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,GACrD,oBAAoB,GAAG,SAAS,CAe5C;AAED;;;;;;;GAOG;AACH,4CALW,IAAI,oBACJ,oBAAoB,eACpB,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACrB,OAAO,CAiDnB;AAED;;;;;;;;GAQG;AACH,gDALW,IAAI,oBACJ,oBAAoB,GAAG,SAAS,eAChC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACrB,OAAO,CAwDnB;AAED;;;;;;;;;;GAUG;AACH,+CAPW,OAAO,yBAAyB,EAAE,OAAO,eACzC,IAAI,oBACJ,oBAAoB,WACpB,WAAW,eACX,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,GACrB,OAAO,CAAC,IAAI,CAAC,CAyGzB;mBAtQY,OAAO,iBAAiB,EAAE,OAAO;mCACjC,OAAO,8CAA8C,EAAE,oBAAoB"}

package/dist/src/view/dataReadiness.js

@@ -0,0 +1,267 @@
+import DataSource from "../data/sources/dataSource.js";
+import UnitView from "./unitView.js";
+
+/**
+ * @typedef {import("../view/view.js").default} View
+ * @typedef {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessRequest} DataReadinessRequest
+ */
+
+/**
+ * Builds a readiness request for the provided channels.
+ *
+ * @param {View} view
+ * @param {import("../spec/channel.js").PrimaryPositionalChannel[]} channels
+ * @returns {DataReadinessRequest | undefined}
+ */
+export function buildReadinessRequest(view, channels) {
+    /** @type {DataReadinessRequest} */
+    const request = {};
+
+    for (const channel of channels) {
+        const resolution = view.getScaleResolution(channel);
+        if (!resolution) {
+            continue;
+        }
+        request[channel] = Array.from(resolution.getDomain());
+    }
+
+    return Object.keys(request).length ? request : undefined;
+}
+
+/**
+ * Checks whether all data sources under the subtree report readiness.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeReady(subtreeRoot, readinessRequest, viewFilter) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    const unitViews = subtreeRoot
+        .getDescendants()
+        .filter((view) => view instanceof UnitView && shouldConsiderView(view));
+
+    if (unitViews.length === 0) {
+        return subtreeRoot.isDataInitialized();
+    }
+
+    for (const view of unitViews) {
+        /** @type {import("../data/collector.js").default | undefined} */
+        const collector = view.flowHandle?.collector;
+        if (!collector || !collector.completed) {
+            return false;
+        }
+
+        /** @type {import("../data/flowNode.js").default | undefined} */
+        let node = collector;
+        while (node && !(node instanceof DataSource)) {
+            node = node.parent;
+        }
+
+        const dataSource = /** @type {DataSource | undefined} */ (node);
+        if (!dataSource) {
+            return false;
+        }
+
+        if ("isDataReadyForDomain" in dataSource) {
+            // It's available in SingleAxisLazySource and its subclasses
+            const checkableSource =
+                /** @type {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessCheckable} */ (
+                    dataSource
+                );
+            if (
+                !readinessRequest ||
+                !checkableSource.isDataReadyForDomain(readinessRequest)
+            ) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Checks readiness for lazy data sources under the subtree. Non-lazy sources
+ * are ignored so they do not block readiness checks.
+ *
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest | undefined} readinessRequest
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {boolean}
+ */
+export function isSubtreeLazyReady(subtreeRoot, readinessRequest, viewFilter) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    /** @type {Set<DataSource>} */
+    const dataSources = new Set();
+
+    subtreeRoot.visit((view) => {
+        if (!(view instanceof UnitView)) {
+            return;
+        }
+        if (!shouldConsiderView(view)) {
+            return;
+        }
+
+        /** @type {View | null} */
+        let current = view;
+        while (current) {
+            if (current.flowHandle && current.flowHandle.dataSource) {
+                break;
+            }
+            current = current.dataParent;
+        }
+
+        if (!current || !current.flowHandle) {
+            return;
+        }
+        const dataSource = current.flowHandle.dataSource;
+        if (!("isDataReadyForDomain" in dataSource)) {
+            return;
+        }
+        dataSources.add(dataSource);
+    });
+
+    if (!dataSources.size) {
+        return true;
+    }
+
+    if (!readinessRequest) {
+        return false;
+    }
+
+    for (const dataSource of dataSources) {
+        const checkReady =
+            /** @type {import("../data/sources/lazy/singleAxisLazySource.js").DataReadinessCheckable["isDataReadyForDomain"]} */ (
+                /** @type {any} */ (dataSource).isDataReadyForDomain
+            );
+        if (!checkReady.call(dataSource, readinessRequest)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Waits until lazy data sources under the subtree satisfy the readiness request.
+ * Non-lazy sources are ignored so they do not block readiness checks.
+ *
+ * @param {import("../types/viewContext.js").default} context
+ * @param {View} subtreeRoot
+ * @param {DataReadinessRequest} readinessRequest
+ * @param {AbortSignal} [signal]
+ * @param {(view: View) => boolean} [viewFilter]
+ * @returns {Promise<void>}
+ */
+export function awaitSubtreeLazyReady(
+    context,
+    subtreeRoot,
+    readinessRequest,
+    signal,
+    viewFilter
+) {
+    const shouldConsiderView =
+        viewFilter ??
+        ((/** @type {View} */ view) => view.isConfiguredVisible());
+
+    if (!readinessRequest) {
+        if (
+            isSubtreeLazyReady(
+                subtreeRoot,
+                readinessRequest,
+                shouldConsiderView
+            )
+        ) {
+            return Promise.resolve();
+        }
+        return Promise.reject(
+            new Error("Lazy subtree readiness requires a readiness request.")
+        );
+    }
+
+    return new Promise((resolve, reject) => {
+        /** @type {Set<() => void>} */
+        const unregisters = new Set();
+        /** @type {Set<import("../data/collector.js").default>} */
+        const observedCollectors = new Set();
+
+        /** @type {(message: import("./view.js").BroadcastMessage) => void} */
+        const broadcastListener = () => {
+            attachCollectors();
+            checkReady();
+        };
+
+        const cleanup = () => {
+            for (const unregister of unregisters) {
+                unregister();
+            }
+            unregisters.clear();
+            context.removeBroadcastListener(
+                "subtreeDataReady",
+                broadcastListener
+            );
+            if (signal) {
+                signal.removeEventListener("abort", abortHandler);
+            }
+        };
+
+        const checkReady = () => {
+            if (
+                isSubtreeLazyReady(
+                    subtreeRoot,
+                    readinessRequest,
+                    shouldConsiderView
+                )
+            ) {
+                cleanup();
+                resolve();
+            }
+        };
+
+        const attachCollectors = () => {
+            subtreeRoot.visit((view) => {
+                if (!(view instanceof UnitView)) {
+                    return;
+                }
+                if (!shouldConsiderView(view)) {
+                    return;
+                }
+                const collector = view.flowHandle?.collector;
+                if (!collector) {
+                    return;
+                }
+                if (observedCollectors.has(collector)) {
+                    return;
+                }
+                observedCollectors.add(collector);
+                unregisters.add(collector.observe(checkReady));
+            });
+        };
+
+        const abortHandler = () => {
+            cleanup();
+            reject(new Error("Lazy subtree readiness was aborted."));
+        };
+
+        attachCollectors();
+        checkReady();
+
+        context.addBroadcastListener("subtreeDataReady", broadcastListener);
+
+        if (signal) {
+            if (signal.aborted) {
+                abortHandler();
+                return;
+            }
+            signal.addEventListener("abort", abortHandler, { once: true });
+        }
+    });
+}

package/dist/src/view/dataReadiness.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dataReadiness.test.d.ts.map

package/dist/src/view/dataReadiness.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataReadiness.test.d.ts","sourceRoot":"","sources":["../../../src/view/dataReadiness.test.js"],"names":[],"mappings":""}

package/dist/src/view/facetView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facetView.d.ts","sourceRoot":"","sources":["../../../src/view/facetView.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;;;OAOG;IACH;;;;;;OAMG;IACH,kBALW,OAAO,gBAAgB,EAAE,SAAS,WAClC,OAAO,gBAAgB,EAAE,WAAW,UACpC,aAAa,QACb,MAAM,EA8BhB;IAzBG,UAAgB;IAEhB,WAEC;IAED;;;;OAIG;IACH,aAFU,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAYvC;IAED,oDAAoD;IACpD,kBADY,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CACa;IAajE,sBAIC;IAED;;;OAGG;IACH,qBAFW,KAAK,GAAG,QAAQ,OAwB1B;IAED,qBAyCC;IAED,qBASC;IA6BD,kDAgBC;IAOD;;;;OAIG;IACH,gBAJW,OAAO,4CAA4C,EAAE,OAAO,UAC5D,OAAO,uBAAuB,EAAE,OAAO,YACvC,OAAO,WAAW,EAAE,gBAAgB,QA2L9C;IA3KO,wBAA0B;CA4KrC;2BAjbY,QAAQ,GAAG,KAAK;;;;;;aA4CnB,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;0BA1Df,oBAAoB;qBACzB,eAAe"}
+{"version":3,"file":"facetView.d.ts","sourceRoot":"","sources":["../../../src/view/facetView.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;;;OAOG;IACH;;;;;;OAMG;IACH,kBALW,OAAO,gBAAgB,EAAE,SAAS,WAClC,OAAO,gBAAgB,EAAE,WAAW,UACpC,aAAa,QACb,MAAM,EA+BhB;IA1BG,UAAgB;IAEhB,WAEC;IAED;;;;OAIG;IACH,aAFU,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAavC;IAED,oDAAoD;IACpD,kBADY,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CACa;IAajE,sBAIC;IAED;;;OAGG;IACH,qBAFW,KAAK,GAAG,QAAQ,OAwB1B;IAED,qBAyCC;IAED,qBASC;IA6BD,kDAgBC;IAOD;;;;OAIG;IACH,gBAJW,OAAO,4CAA4C,EAAE,OAAO,UAC5D,OAAO,uBAAuB,EAAE,OAAO,YACvC,OAAO,WAAW,EAAE,gBAAgB,QA2L9C;IA3KO,wBAA0B;CA4KrC;2BAlbY,QAAQ,GAAG,KAAK;;;;;;aA4CnB,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;0BA3Df,oBAAoB;qBACzB,eAAe"}

package/dist/src/view/facetView.js

@@ -12,6 +12,7 @@ import coalesce from "../utils/coalesce.js";
 import { field as vegaField } from "vega-util";
 import DecoratorView from "./decoratorView.js";
 import Padding from "./layout/padding.js";
+import { markViewAsNonAddressable } from "./viewSelectors.js";
 
 const DEFAULT_SPACING = 20;
 
@@ -95,15 +96,16 @@ export default class FacetView extends ContainerView {
          * @type {Record<FacetChannel, UnitView>}
          */
         this._labelViews = Object.fromEntries(
-            FACET_CHANNELS.map((channel) => [
-                channel,
-                new UnitView(
+            FACET_CHANNELS.map((channel) => {
+                const labelView = new UnitView(
                     createLabelViewSpec(headerConfigs[channel]),
                     this.context,
                     this,
                     `facetLabel-${channel}`
-                ),
-            ])
+                );
+                markViewAsNonAddressable(labelView, { skipSubtree: true });
+                return [channel, labelView];
+            })
         );
 
         /**  @type {Record<FacetChannel, FacetDimension>} */

package/dist/src/view/flowBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowBuilder.d.ts","sourceRoot":"","sources":["../../../src/view/flowBuilder.js"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,gFALW,QAAQ,eAER,CAAC,IAAI,6BAAM,KAAK,OAAO,gCACvB,CAAC,IAAI,6BAAM,KAAK,OAAO,YAoPjC;AAuBD;;;;;;GAMG;AACH,2CAFW,OAAO,eAAe,EAAE,OAAO;;;IAuG5B;;;OAGG;;EAYhB;AAgCD;;;;;;GAMG;AACH,4BAFwB,CAAC,SAAZ,qCAAU,cAFZ,CAAC,iBACA,uCAAW;;;0BAwBG,OAAO,CAAC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,KAAK,CAAC,CAAC;EAkB/E;qBA3eoB,qBAAqB;sBAPpB,sBAAsB"}
+{"version":3,"file":"flowBuilder.d.ts","sourceRoot":"","sources":["../../../src/view/flowBuilder.js"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,gFALW,QAAQ,eAER,CAAC,IAAI,6BAAM,KAAK,OAAO,gCACvB,CAAC,IAAI,6BAAM,KAAK,OAAO,YAoPjC;AAuBD;;;;;;GAMG;AACH,2CAFW,OAAO,eAAe,EAAE,OAAO;;;IAoH5B;;;OAGG;;EAYhB;AAgCD;;;;;;GAMG;AACH,4BAFwB,CAAC,SAAZ,qCAAU,cAFZ,CAAC,iBACA,uCAAW;;;0BAwBG,OAAO,CAAC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,KAAK,CAAC,CAAC;EAkB/E;qBAxfoB,qBAAqB;sBAPpB,sBAAsB"}

package/dist/src/view/flowBuilder.js

@@ -316,10 +316,11 @@ export function linearizeLocusAccess(view) {
     const rewrittenEncoding = {};
 
     // Use mark.encoding so we see the same channel defs that encoders consume,
-    // including inherited channels and mark defaults. getEncoding() only returns
-    // spec/inherited encodings and can omit channels during lazy init (e.g.,
-    // summary views that inherit chrom/pos), which would skip chrom/pos rewrites.
+    // including inherited channels and mark defaults. Keep the configured
+    // encoding too so we can avoid rewriting synthesized channels (e.g., x2
+    // introduced by mark defaults/fixups).
     const encoding = view.mark.encoding;
+    const configuredEncoding = view.getEncoding();
 
     /** @type {{ channel: Channel, chromPosDef: import("../spec/channel.js").ChromPosDef}[]} */
     const channelsAndChromPosDefs = [];
@@ -328,7 +329,18 @@ export function linearizeLocusAccess(view) {
     // that share the chromosome field and channel.
     for (const [c, channelDef] of Object.entries(encoding)) {
         const channel = /** @type {Channel} */ (c);
-        if (isPositionalChannel(channel) && isChromPosDef(channelDef)) {
+        if (
+            getPrimaryChannel(channel) !== channel &&
+            !(channel in configuredEncoding)
+        ) {
+            continue;
+        }
+
+        if (
+            isPositionalChannel(channel) &&
+            !Array.isArray(channelDef) &&
+            isChromPosDef(channelDef)
+        ) {
             channelsAndChromPosDefs.push({ channel, chromPosDef: channelDef });
         }
     }
@@ -365,6 +377,7 @@ export function linearizeLocusAccess(view) {
                 /** @type {any} */
                 const newFieldDef = {
                     ...(view.spec.encoding?.[channel] ??
+                        configuredEncoding[channel] ??
                         encoding[channel] ??
                         {}),
                     field: linearizedField,

package/dist/src/view/gridView/gridChild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gridChild.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridChild.js"],"names":[],"mappings":"AA4rBA;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA8BjD;AAED;;;GAGG;AACH,uDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA6CjD;AA1vBD;IACI;;;;;;OAMG;IAEH;;;;OAIG;IACH,kBAJW,OAAO,YAAY,EAAE,OAAO,gBAC5B,OAAO,qBAAqB,EAAE,OAAO,UACrC,MAAM,EAyFhB;IAtFG,oDAAgC;IAChC,mCAAgB;IAChB,eAAoB;IAEpB,uBAAuB;IACvB,YADW,QAAQ,CACQ;IAE3B,uBAAuB;IACvB,kBADW,QAAQ,CACc;IAEjC,sFAAsF;IACtF,MADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAC/D;IAEd,+FAA+F;IAC/F,WADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAC9D;IAEnB,mFAAmF;IACnF,YADW,OAAO,CAAC,MAAM,CAAC,OAAO,gBAAgB,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC,CAC3D;IAEpB,4BAA4B;IAC5B,eADW,aAAa,CACM;IAE9B,uBAAuB;IACvB,OADW,QAAQ,CACG;IAEtB,wBAAwB;IACxB,QADW,SAAS,CACQ;IAoZhC,sEAiBC;IAED;;OAEG;IACH,4BAwKC;IAED;;OAEG;IACH,yBAWC;IAED,uBAqBC;IAED,iCAEC;;CACJ;qBA3qBoB,gBAAgB;qBANK,gBAAgB;yBADjC,oBAAoB;sBAQvB,gBAAgB;0BACZ,oBAAoB;sBAJxB,wBAAwB;oBAF1B,sBAAsB"}
+{"version":3,"file":"gridChild.d.ts","sourceRoot":"","sources":["../../../../src/view/gridView/gridChild.js"],"names":[],"mappings":"AAysBA;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA8BjD;AAED;;;GAGG;AACH,uDAHW,OAAO,oBAAoB,EAAE,cAAc,GACzC,OAAO,oBAAoB,EAAE,QAAQ,CA6CjD;AAtwBD;IACI;;;;;;OAMG;IAEH;;;;OAIG;IACH,kBAJW,OAAO,YAAY,EAAE,OAAO,gBAC5B,OAAO,qBAAqB,EAAE,OAAO,UACrC,MAAM,EAgGhB;IA7FG,oDAAgC;IAChC,mCAAgB;IAChB,eAAoB;IAEpB,uBAAuB;IACvB,YADW,QAAQ,CACQ;IAE3B,uBAAuB;IACvB,kBADW,QAAQ,CACc;IAEjC,sFAAsF;IACtF,MADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAC/D;IAEd,+FAA+F;IAC/F,WADW,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAC9D;IAEnB,mFAAmF;IACnF,YADW,OAAO,CAAC,MAAM,CAAC,OAAO,gBAAgB,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC,CAC3D;IAEpB,4BAA4B;IAC5B,eADW,aAAa,CACM;IAE9B,uBAAuB;IACvB,OADW,QAAQ,CACG;IAEtB,wBAAwB;IACxB,QADW,SAAS,CACQ;IAgahC,sEAiBC;IAED;;OAEG;IACH,4BAwKC;IAED;;OAEG;IACH,yBAWC;IAED,uBAqBC;IAED,iCAEC;;CACJ;qBAxrBoB,gBAAgB;qBANK,gBAAgB;yBADjC,oBAAoB;sBASvB,gBAAgB;0BACZ,oBAAoB;sBALxB,wBAAwB;oBAF1B,sBAAsB"}