@genome-spy/core 0.72.0 → 0.74.0

package/dist/src/genome/genomeStore.js

@@ -1,5 +1,17 @@
 import Genome from "./genome.js";
 
+/**
+ * Resolves genome assemblies for locus scales.
+ *
+ * Keeps configured genome definitions and loaded `Genome` instances, supports
+ * named and inline assemblies, and deduplicates concurrent URL loads.
+ *
+ * `ensureAssembly(...)` is the async loading boundary. `getGenome(...)` is
+ * synchronous and expects required URL-backed assemblies to be ensured first.
+ *
+ * The default assembly comes from root `assembly`, a single configured genome,
+ * or a single already-loaded built-in genome.
+ */
 export default class GenomeStore {
     /**
      * @param {string} baseUrl
@@ -7,48 +19,427 @@ export default class GenomeStore {
     constructor(baseUrl) {
         /** @type {Map<string, Genome>} */
         this.genomes = new Map();
+
+        this.#configuredGenomesByName = new Map();
+        this.#loadingPromisesByName = new Map();
+        this.#inlineAssemblyNamesByKey = new Map();
+        this.#nextInlineAssemblyIndex = 0;
+        this.#defaultAssemblyName = undefined;
+
         this.baseUrl = baseUrl;
     }
 
+    /** @type {Map<string, import("../spec/root.js").NamedGenomeConfig>} */
+    #configuredGenomesByName;
+
+    /** @type {Map<string, Promise<void>>} */
+    #loadingPromisesByName;
+
+    /** @type {Map<string, string>} */
+    #inlineAssemblyNamesByKey;
+
+    /** @type {number} */
+    #nextInlineAssemblyIndex;
+
+    /** @type {string | undefined} */
+    #defaultAssemblyName;
+
     /**
      * @param {import("../spec/genome.js").GenomeConfig} genomeConfig
      */
-    // eslint-disable-next-line require-await
     async initialize(genomeConfig) {
-        const genome = new Genome(genomeConfig);
-        this.genomes.set(genome.name, genome);
+        const { name, ...config } = genomeConfig;
+        this.configureGenomes(new Map([[name, config]]), name);
+        await this.ensureAssembly(name);
+    }
 
-        return Promise.all(
-            [...this.genomes.values()].map((genome) =>
-                genome.load(this.baseUrl)
-            )
-        );
+    /**
+     * @param {Map<string, import("../spec/root.js").NamedGenomeConfig>} genomesByName
+     * @param {string} [defaultAssembly]
+     */
+    configureGenomes(genomesByName, defaultAssembly) {
+        this.genomes.clear();
+        this.#loadingPromisesByName.clear();
+        this.#inlineAssemblyNamesByKey.clear();
+        this.#nextInlineAssemblyIndex = 0;
+        this.#configuredGenomesByName = new Map(genomesByName);
+        this.#defaultAssemblyName = defaultAssembly;
+    }
+
+    /**
+     * @returns {string | undefined}
+     */
+    getDefaultAssemblyName() {
+        if (this.#defaultAssemblyName) {
+            return this.#defaultAssemblyName;
+        }
+
+        if (this.#configuredGenomesByName.size === 1) {
+            return this.#configuredGenomesByName.keys().next().value;
+        }
+
+        if (
+            this.#configuredGenomesByName.size === 0 &&
+            this.genomes.size === 1
+        ) {
+            return this.genomes.keys().next().value;
+        }
+
+        return undefined;
     }
 
     /**
-     * @param {string} [name] If not given, a default genome is returned.
+     * @param {(string | import("../spec/scale.js").InlineLocusAssembly | undefined)[]} assemblies
+     */
+    async ensureAssemblies(assemblies) {
+        /** @type {Promise<Genome>[]} */
+        const pending = [];
+        /** @type {Set<string>} */
+        const seenAssemblies = new Set();
+
+        for (const assembly of assemblies) {
+            if (!assembly) {
+                continue;
+            }
+
+            const dedupKey = getAssemblyDedupKey(assembly);
+            if (seenAssemblies.has(dedupKey)) {
+                continue;
+            }
+
+            seenAssemblies.add(dedupKey);
+            pending.push(this.ensureAssembly(assembly));
+        }
+
+        await Promise.all(pending);
+    }
+
+    /**
+     * @param {string | import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {Promise<Genome>}
+     */
+    async ensureAssembly(assembly) {
+        if (typeof assembly === "object") {
+            return this.#ensureInlineAssemblyGenome(assembly);
+        }
+
+        const existing = this.genomes.get(assembly);
+        if (existing) {
+            return existing;
+        }
+
+        const configured = this.#configuredGenomesByName.get(assembly);
+        if (configured) {
+            return this.#ensureConfiguredGenome(assembly, configured);
+        }
+
+        const builtIn = this.#getOrCreateBuiltInGenome(assembly);
+        if (builtIn) {
+            return builtIn;
+        }
+
+        throw this.#createUnknownGenomeError(assembly);
+    }
+
+    /**
+     * @param {string | import("../spec/scale.js").InlineLocusAssembly} [name] If not given, a default genome is returned.
      * @returns {Genome}
      */
     getGenome(name) {
-        if (!this.genomes.size) {
-            throw new Error("No genomes have been configured!");
+        if (name && typeof name == "object") {
+            return this.#getInlineAssemblyGenome(name);
         }
 
-        if (name) {
+        if (typeof name === "string") {
             const genome = this.genomes.get(name);
-            if (!genome) {
+            if (genome) {
+                return genome;
+            }
+
+            if (this.#configuredGenomesByName.has(name)) {
                 throw new Error(
-                    `No genome with the name ${name} has been configured!`
+                    `Genome ${name} has not been loaded yet. Call ensureAssembly("${name}") before accessing it.`
                 );
             }
+
+            const builtIn = this.#getOrCreateBuiltInGenome(name);
+            if (builtIn) {
+                return builtIn;
+            }
+
+            throw this.#createUnknownGenomeError(name);
+        }
+
+        const defaultAssemblyName = this.getDefaultAssemblyName();
+        if (defaultAssemblyName) {
+            return this.getGenome(defaultAssemblyName);
+        }
+
+        if (this.#configuredGenomesByName.size > 1) {
+            throw new Error(
+                "Cannot pick a default genome! More than one have been configured!"
+            );
+        }
+
+        if (this.genomes.size === 0 && this.#configuredGenomesByName.size) {
+            throw new Error(
+                "Default genome is not loaded. Define root `assembly` or call ensureAssembly() first."
+            );
+        }
+
+        if (this.genomes.size > 1) {
+            throw new Error(
+                "Cannot pick a default genome! More than one have been configured!"
+            );
+        }
+
+        if (this.genomes.size === 0) {
+            throw new Error("No genomes have been configured!");
+        }
+
+        return this.genomes.values().next().value;
+    }
+
+    /**
+     * @param {string} name
+     * @returns {Genome | undefined}
+     */
+    #tryCreateBuiltInGenome(name) {
+        try {
+            return new Genome({ name });
+        } catch {
+            return undefined;
+        }
+    }
+
+    /**
+     * @param {string} name
+     * @returns {Error}
+     */
+    #createUnknownGenomeError(name) {
+        return new Error(
+            `No genome with the name ${name} has been configured!`
+        );
+    }
+
+    /**
+     * @param {string} name
+     * @returns {Genome | undefined}
+     */
+    #getOrCreateBuiltInGenome(name) {
+        const builtIn = this.#tryCreateBuiltInGenome(name);
+        if (builtIn) {
+            this.genomes.set(name, builtIn);
+            return builtIn;
+        }
+
+        return undefined;
+    }
+
+    /**
+     * @param {string} name
+     * @param {string} missingGenomeError
+     * @returns {Promise<Genome>}
+     */
+    async #awaitLoadedGenomeFromPending(name, missingGenomeError) {
+        const pending = this.#loadingPromisesByName.get(name);
+        if (!pending) {
+            throw new Error(`No pending genome load for ${name}.`);
+        }
+
+        await pending;
+        const loaded = this.genomes.get(name);
+        if (!loaded) {
+            throw new Error(missingGenomeError);
+        }
+
+        return loaded;
+    }
+
+    /**
+     * @param {string} name
+     * @param {Genome} genome
+     * @returns {Promise<Genome>}
+     */
+    async #loadGenome(name, genome) {
+        const loadPromise = genome.load(this.baseUrl);
+        this.#loadingPromisesByName.set(name, loadPromise);
+
+        try {
+            await loadPromise;
+        } catch (error) {
+            this.genomes.delete(name);
+            throw error;
+        } finally {
+            this.#loadingPromisesByName.delete(name);
+        }
+
+        return genome;
+    }
+
+    /**
+     * @param {string} name
+     * @param {import("../spec/root.js").NamedGenomeConfig} config
+     * @returns {Promise<Genome>}
+     */
+    async #ensureConfiguredGenome(name, config) {
+        const existing = this.genomes.get(name);
+        if (existing) {
+            if (this.#loadingPromisesByName.has(name)) {
+                return this.#awaitLoadedGenomeFromPending(
+                    name,
+                    `Loading genome ${name} failed before it became available.`
+                );
+            }
+            return existing;
+        }
+
+        if (this.#loadingPromisesByName.has(name)) {
+            return this.#awaitLoadedGenomeFromPending(
+                name,
+                `Loading genome ${name} failed before it became available.`
+            );
+        }
+
+        const genome = new Genome({
+            name,
+            ...config,
+        });
+        this.genomes.set(name, genome);
+
+        if ("url" in config) {
+            return this.#loadGenome(name, genome);
+        }
+
+        return genome;
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {Promise<Genome>}
+     */
+    async #ensureInlineAssemblyGenome(assembly) {
+        this.#validateInlineAssembly(assembly);
+
+        const inlineName = this.#resolveInlineAssemblyName(assembly);
+
+        const existing = this.genomes.get(inlineName);
+        if (existing) {
+            if (this.#loadingPromisesByName.has(inlineName)) {
+                return this.#awaitLoadedGenomeFromPending(
+                    inlineName,
+                    `Loading inline assembly ${inlineName} failed before it became available.`
+                );
+            }
+            return existing;
+        }
+
+        if (this.#loadingPromisesByName.has(inlineName)) {
+            return this.#awaitLoadedGenomeFromPending(
+                inlineName,
+                `Loading inline assembly ${inlineName} failed before it became available.`
+            );
+        }
+
+        if ("contigs" in assembly) {
+            const genome = new Genome({
+                name: inlineName,
+                contigs: assembly.contigs,
+            });
+            this.genomes.set(inlineName, genome);
             return genome;
-        } else {
-            if (this.genomes.size > 1) {
+        }
+
+        const genome = new Genome({
+            name: inlineName,
+            url: assembly.url,
+        });
+        this.genomes.set(inlineName, genome);
+
+        return this.#loadGenome(inlineName, genome);
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {Genome}
+     */
+    #getInlineAssemblyGenome(assembly) {
+        this.#validateInlineAssembly(assembly);
+
+        const inlineName = this.#resolveInlineAssemblyName(assembly);
+        const existing = this.genomes.get(inlineName);
+        if (existing) {
+            if (this.#loadingPromisesByName.has(inlineName)) {
                 throw new Error(
-                    "Cannot pick a default genome! More than one have been configured!"
+                    `Inline URL assembly ${inlineName} has not been loaded yet. Call ensureAssembly() before accessing it.`
                 );
             }
-            return this.genomes.values().next().value;
+            return existing;
+        }
+
+        if ("url" in assembly) {
+            throw new Error(
+                "Inline URL assemblies must be loaded first. Call ensureAssembly() before accessing it."
+            );
         }
+
+        const genome = new Genome({
+            name: inlineName,
+            contigs: assembly.contigs,
+        });
+        this.genomes.set(inlineName, genome);
+
+        return genome;
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     */
+    #validateInlineAssembly(assembly) {
+        const hasContigs = "contigs" in assembly;
+        const hasUrl = "url" in assembly;
+        if (hasContigs === hasUrl) {
+            throw new Error(
+                "Inline `scale.assembly` objects must define exactly one of `contigs` or `url`."
+            );
+        }
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {string}
+     */
+    #resolveInlineAssemblyName(assembly) {
+        const key = JSON.stringify(assembly);
+        const existingName = this.#inlineAssemblyNamesByKey.get(key);
+        if (existingName) {
+            return existingName;
+        }
+
+        let candidate = `inline_assembly_${this.#nextInlineAssemblyIndex}`;
+        this.#nextInlineAssemblyIndex += 1;
+        while (
+            this.genomes.has(candidate) ||
+            this.#configuredGenomesByName.has(candidate) ||
+            this.#loadingPromisesByName.has(candidate)
+        ) {
+            candidate = `inline_assembly_${this.#nextInlineAssemblyIndex}`;
+            this.#nextInlineAssemblyIndex += 1;
+        }
+
+        this.#inlineAssemblyNamesByKey.set(key, candidate);
+        return candidate;
     }
 }
+
+/**
+ * @param {string | import("../spec/scale.js").InlineLocusAssembly} assembly
+ * @returns {string}
+ */
+function getAssemblyDedupKey(assembly) {
+    if (typeof assembly === "string") {
+        return `name:${assembly}`;
+    }
+
+    return `inline:${JSON.stringify(assembly)}`;
+}

package/dist/src/genome/rootGenomeConfig.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @typedef {import("../spec/root.js").RootConfig} RootConfig
+ * @typedef {import("../spec/root.js").NamedGenomeConfig} NamedGenomeDefinition
+ */
+/**
+ * @typedef {object} ResolvedRootGenomeConfig
+ * @prop {Map<string, NamedGenomeDefinition>} genomesByName
+ * @prop {string | undefined} defaultAssembly
+ * @prop {string | undefined} deprecationWarning
+ */
+/**
+ * Resolves root-level genome configuration into a canonical map and default
+ * assembly name.
+ *
+ * @param {RootConfig} rootConfig
+ * @returns {ResolvedRootGenomeConfig}
+ */
+export function resolveRootGenomeConfig(rootConfig: RootConfig): ResolvedRootGenomeConfig;
+export type RootConfig = import("../spec/root.js").RootConfig;
+export type NamedGenomeDefinition = import("../spec/root.js").NamedGenomeConfig;
+export type ResolvedRootGenomeConfig = {
+    genomesByName: Map<string, NamedGenomeDefinition>;
+    defaultAssembly: string | undefined;
+    deprecationWarning: string | undefined;
+};
+//# sourceMappingURL=rootGenomeConfig.d.ts.map

package/dist/src/genome/rootGenomeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootGenomeConfig.d.ts","sourceRoot":"","sources":["../../../src/genome/rootGenomeConfig.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AACH,oDAHW,UAAU,GACR,wBAAwB,CAsDpC;yBAtEY,OAAO,iBAAiB,EAAE,UAAU;oCACpC,OAAO,iBAAiB,EAAE,iBAAiB;;mBAK9C,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC;qBAClC,MAAM,GAAG,SAAS;wBAClB,MAAM,GAAG,SAAS"}

package/dist/src/genome/rootGenomeConfig.js

@@ -0,0 +1,98 @@
+import { getContigs } from "./genomes.js";
+
+/**
+ * @typedef {import("../spec/root.js").RootConfig} RootConfig
+ * @typedef {import("../spec/root.js").NamedGenomeConfig} NamedGenomeDefinition
+ */
+
+/**
+ * @typedef {object} ResolvedRootGenomeConfig
+ * @prop {Map<string, NamedGenomeDefinition>} genomesByName
+ * @prop {string | undefined} defaultAssembly
+ * @prop {string | undefined} deprecationWarning
+ */
+
+/**
+ * Resolves root-level genome configuration into a canonical map and default
+ * assembly name.
+ *
+ * @param {RootConfig} rootConfig
+ * @returns {ResolvedRootGenomeConfig}
+ */
+export function resolveRootGenomeConfig(rootConfig) {
+    if (rootConfig.genome && rootConfig.genomes) {
+        throw new Error(
+            "Do not mix deprecated `genome` with `genomes`. Use only `genomes` and `assembly`."
+        );
+    }
+
+    if (rootConfig.genome && rootConfig.assembly) {
+        throw new Error(
+            "Do not mix deprecated `genome` with root `assembly`. Use `genomes` and `assembly`."
+        );
+    }
+
+    if (rootConfig.genome) {
+        const { name, ...config } = rootConfig.genome;
+        const hasDefinition = Object.keys(config).length > 0;
+        return {
+            genomesByName:
+                !hasDefinition && isBuiltInAssembly(name)
+                    ? new Map()
+                    : new Map([[name, config]]),
+            defaultAssembly: name,
+            deprecationWarning: getLegacyGenomeWarning(),
+        };
+    }
+
+    /** @type {Map<string, NamedGenomeDefinition>} */
+    const genomesByName = new Map();
+    for (const [name, config] of Object.entries(rootConfig.genomes ?? {})) {
+        genomesByName.set(name, config ?? {});
+    }
+
+    let defaultAssembly = rootConfig.assembly;
+    if (!defaultAssembly && genomesByName.size === 1) {
+        defaultAssembly = genomesByName.keys().next().value;
+    }
+
+    if (
+        defaultAssembly &&
+        !genomesByName.has(defaultAssembly) &&
+        !isBuiltInAssembly(defaultAssembly)
+    ) {
+        throw new Error(
+            `Root assembly "${defaultAssembly}" is neither defined in \`genomes\` nor a built-in assembly.`
+        );
+    }
+
+    return {
+        genomesByName,
+        defaultAssembly,
+        deprecationWarning: undefined,
+    };
+}
+
+/**
+ * @returns {string}
+ */
+function getLegacyGenomeWarning() {
+    return (
+        "Root `genome` is deprecated and will be removed in a future version. " +
+        "Use root `genomes` and `assembly` instead. Built-in migration example: " +
+        '{"genome":{"name":"hg38"}} -> {"assembly":"hg38"}.'
+    );
+}
+
+/**
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isBuiltInAssembly(name) {
+    try {
+        getContigs(name);
+        return true;
+    } catch {
+        return false;
+    }
+}

package/dist/src/genome/scaleLocus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleLocus.d.ts","sourceRoot":"","sources":["../../../src/genome/scaleLocus.js"],"names":[],"mappings":"AAMA,2EAsGC;;AASD;;;;GAIG;AACH,8CAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,SAC5F,MAAM,GACJ,MAAM,GAAG,OAAO,aAAa,EAAE,gBAAgB,CAK3D;AAED;;;;GAIG;AACH,gDAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,WAC5F,MAAM,GAAG,OAAO,aAAa,EAAE,gBAAgB,GAC7C,MAAM,CAQlB;AAED;;;;GAIG;AACH,mDAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,YAC5F,OAAO,kBAAkB,EAAE,YAAY,GAAG,OAAO,kBAAkB,EAAE,aAAa,GAChF,MAAM,EAAE,CAQpB;AAED;;;;GAIG;AACH,iDAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,YAC5F,OAAO,kBAAkB,EAAE,YAAY,GAAG,OAAO,kBAAkB,EAAE,aAAa,GAChF,OAAO,kBAAkB,EAAE,YAAY,GAAG,OAAO,kBAAkB,EAAE,aAAa,CAO9F;AAED;;;GAGG;AACH,+CAHW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,GAC1F,MAAM,EAAE,CAQpB"}
+{"version":3,"file":"scaleLocus.d.ts","sourceRoot":"","sources":["../../../src/genome/scaleLocus.js"],"names":[],"mappings":"AAQA,2EAuHC;;AASD;;;;GAIG;AACH,8CAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,SAC5F,MAAM,GACJ,MAAM,GAAG,OAAO,aAAa,EAAE,gBAAgB,CAK3D;AAED;;;;GAIG;AACH,gDAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,WAC5F,MAAM,GAAG,OAAO,aAAa,EAAE,gBAAgB,GAC7C,MAAM,CAQlB;AAED;;;;GAIG;AACH,mDAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,YAC5F,OAAO,kBAAkB,EAAE,YAAY,GAAG,OAAO,kBAAkB,EAAE,aAAa,GAChF,MAAM,EAAE,CAQpB;AAED;;;;GAIG;AACH,iDAJW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,YAC5F,OAAO,kBAAkB,EAAE,YAAY,GAAG,OAAO,kBAAkB,EAAE,aAAa,GAChF,OAAO,kBAAkB,EAAE,YAAY,GAAG,OAAO,kBAAkB,EAAE,aAAa,CAO9F;AAED;;;GAGG;AACH,+CAHW,OAAO,aAAa,EAAE,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,OAAO,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,GAC1F,MAAM,EAAE,CAQpB"}

package/dist/src/genome/scaleLocus.js

@@ -4,6 +4,8 @@ import { format as d3format } from "d3-format";
 import scaleIndex from "./scaleIndex.js";
 import { isChromosomalLocus, isChromosomalLocusInterval } from "./genome.js";
 
+const EXACT_LOCUS_LABEL_STEP_THRESHOLD = 1e6;
+
 export default function scaleLocus() {
     /** @type {import("./scaleLocus.js").ScaleLocus} */
     const scale = /** @type {any} */ (scaleIndex().numberingOffset(1));
@@ -27,14 +29,26 @@ export default function scaleLocus() {
         }
 
         const domain = scale.domain();
+        const domainSpan = domain[1] - domain[0];
         const numberingOffset = scale.numberingOffset();
 
-        const [minChrom, maxChrom] = [
-            Math.max(domain[0], 0),
-            Math.min(domain[1], genome.totalSize - 1),
-        ].map((x) => genome.toChromosome(x));
+        const minChrom = genome.toChromosome(Math.max(domain[0], 0));
+        const maxChrom = genome.toChromosome(
+            Math.min(domain[1], genome.totalSize - 1)
+        );
+
+        const requestedCount = Math.max(
+            1,
+            Math.min(count ?? 10, Math.ceil(domainSpan))
+        );
+
+        let step = tickStep(domain[0], domain[1], requestedCount);
+
+        if (step < EXACT_LOCUS_LABEL_STEP_THRESHOLD) {
+            step = tickStep(domain[0], domain[1], requestedCount * 0.65);
+        }
 
-        const step = Math.max(1, tickStep(domain[0], domain[1], count));
+        step = Math.max(1, step);
 
         const ticks = [];
 
@@ -75,12 +89,17 @@ export default function scaleLocus() {
         const step = tickStep(
             domain[0],
             domain[1],
-            Math.min(count, Math.ceil(domainSpan))
+            Math.max(1, Math.min(count ?? 10, Math.ceil(domainSpan)))
         );
         // Use higher display precision for smaller spans
         // TODO: max absolute value should be taken into account too. 2.00M vs 200M
-        const numberFormat = step < 1e6 ? d3format(",") : d3format(".3s");
+        const numberFormat =
+            step < EXACT_LOCUS_LABEL_STEP_THRESHOLD
+                ? d3format(",")
+                : d3format(".3s");
 
+        // Axis tick values live in the continuous whole-genome coordinate
+        // system, but labels should show chromosome-local one-based positions.
         /** @type {function(number):number} */
         const fixer = (x) => x - genome.toChromosome(x).continuousStart;