igv 3.6.0 → 3.7.1

package/dist/igv.esm.js

@@ -8447,7 +8447,7 @@ function regExpEscape(s) {
 function isGoogleURL(url) {
      return (url.includes("googleapis") && !url.includes("urlshortener")) ||
          isGoogleStorageURL(url) ||
-         isGoogleDriveURL(url);
+         isGoogleDriveURL$1(url);
  }
 
  function isGoogleStorageURL(url) {
@@ -8457,7 +8457,7 @@ function isGoogleURL(url) {
          url.startsWith("https://storage.googleapis.com");
  }
 
- function isGoogleDriveURL(url) {
+ function isGoogleDriveURL$1(url) {
      return url.startsWith("https://www.googleapis.com/drive/v3/files");
  }
 
@@ -8610,7 +8610,7 @@ async function getAccessToken(scope) {
 // })
 
 function getScopeForURL(url) {
-    if (isGoogleDriveURL(url)) {
+    if (isGoogleDriveURL$1(url)) {
         return "https://www.googleapis.com/auth/drive.file"
     } else if (isGoogleStorageURL(url)) {
         return "https://www.googleapis.com/auth/devstorage.read_only"
@@ -8829,7 +8829,7 @@ class IGVXhr {
                     return buffer
                 }
             } else {
-                if (isGoogleDriveURL(url) || url.startsWith("https://www.dropbox.com")) {
+                if (isGoogleDriveURL$1(url) || url.startsWith("https://www.dropbox.com")) {
                     return this.googleThrottle.add(async () => {
                         return this._loadURL(url, options)
                     })
@@ -8853,7 +8853,7 @@ class IGVXhr {
         options = options || {};
 
         let oauthToken;
-        if (isGoogleDriveURL(url)) {
+        if (isGoogleDriveURL$1(url)) {
             // Google drive urls always require oAuth
             oauthToken = await getAccessToken("https://www.googleapis.com/auth/drive.file");
         } else {
@@ -8872,7 +8872,7 @@ class IGVXhr {
                 }
                 url = addApiKey(url);
 
-                if (isGoogleDriveURL(url)) {
+                if (isGoogleDriveURL$1(url)) {
                     addTeamDrive(url);
                 }
 
@@ -12402,7 +12402,7 @@ for (let p of pairs) {
     complements.set(p2.toLowerCase(), p1.toLowerCase());
 }
 
-function complementBase(base) {
+function complementBase$1(base) {
     return complements.has(base) ? complements.get(base) : base
 }
 
@@ -16987,6 +16987,35 @@ function findFeatureAfterCenter(featureList, center, direction = true) {
     return sortedList[low]
 }
 
+/**
+ * Utilities for detecting problematic resources (local files, Google Drive URLs)
+ * that cannot be reliably loaded when a session is shared or restored.
+ */
+
+/**
+ * Check if an object is a local File instance
+ * @param {*} obj - The object to check
+ * @returns {boolean} True if the object is a File instance
+ */
+function isLocalFile(obj) {
+    return obj instanceof File
+}
+
+/**
+ * Check if a URL is a Google Drive URL
+ * Google Drive URLs require authentication and will not work when shared.
+ * 
+ * @param {string|*} url - The URL to check
+ * @returns {boolean} True if the URL is a Google Drive URL
+ */
+function isGoogleDriveURL(url) {
+    if (typeof url !== 'string') {
+        return false
+    }
+    // Match both googleapis.com/drive and drive.google.com URLs
+    return url.includes('googleapis.com/drive') || url.includes('drive.google.com')
+}
+
 const fixColor = (colorString) => {
     if (isString$3(colorString)) {
         return (colorString.indexOf(",") > 0 && !(colorString.startsWith("rgb(") || colorString.startsWith("rgba("))) ?
@@ -17611,7 +17640,20 @@ class TrackBase {
         }
     }
 
-    static localFileInspection(config) {
+    /**
+     * Prepare a track configuration for session serialization by identifying and marking
+     * problematic resources (local files).
+     *
+     * Local files are converted to {file: filename} or {indexFile: filename}
+     * Google Drive URLs are kept in the url/indexURL fields as-is and detected when loading
+     *
+     * This allows the configuration to be serialized while preserving information
+     * about resources that cannot be automatically loaded when the session is restored.
+     *
+     * @param {Object} config - Track configuration to prepare
+     * @returns {Object} Cleaned configuration with problematic resources marked
+     */
+    static prepareConfigForSession(config) {
 
         const cooked = Object.assign({}, config);
         const lut =
@@ -17620,8 +17662,9 @@ class TrackBase {
                 indexURL: 'indexFile'
             };
 
+        // Check for local File objects and convert to filename strings
         for (const key of ['url', 'indexURL']) {
-            if (cooked[key] && cooked[key] instanceof File) {
+            if (cooked[key] && isLocalFile(cooked[key])) {
                 cooked[lut[key]] = cooked[key].name;
                 delete cooked[key];
             }
@@ -17631,8 +17674,6 @@ class TrackBase {
     }
 
     // Methods to support filtering api
-
-
     set filter(f) {
         this._filter = f;
         this.trackView.repaintViews();
@@ -35100,14 +35141,21 @@ function getExonPhase(exon) {
     return (3 - exon.readingFrame) % 3
 }
 
-function getEonStart(exon) {
+function getCodingStart(exon) {
     return exon.cdStart || exon.start
 }
 
-function getExonEnd(exon) {
+function getCodingEnd(exon) {
     return exon.cdEnd || exon.end
 }
 
+function getCodingLength(exon) {
+    if (exon.utr) return 0
+    const start = exon.cdStart || exon.start;
+    const end = exon.cdEnd || exon.end;
+    return end - start
+}
+
 const aminoAcidSequenceRenderThreshold = 0.25;
 
 /**
@@ -35356,8 +35404,8 @@ function renderAminoAcidSequence(ctx, strand, leftExon, exon, riteExon, bpStart,
     };
 
     const phase = getExonPhase(exon);
-    let ss = getEonStart(exon);
-    let ee = getExonEnd(exon);
+    let ss = getCodingStart(exon);
+    let ee = getCodingEnd(exon);
 
     let bpTripletStart;
     let bpTripletEnd;
@@ -35526,7 +35574,7 @@ function getAminoAcidLetterWithExonGap(strand, phase, phaseExtentStart, phaseExt
                 return undefined
             }
 
-            [ss, ee] = [getExonEnd(leftExon) - (3 - phase), getExonEnd(leftExon)];
+            [ss, ee] = [getCodingEnd(leftExon) - (3 - phase), getCodingEnd(leftExon)];
             stringA = sequenceInterval.getSequence(ss, ee);
 
             if (!stringA) {
@@ -35545,7 +35593,7 @@ function getAminoAcidLetterWithExonGap(strand, phase, phaseExtentStart, phaseExt
             }
 
             const ritePhase = getExonPhase(riteExon);
-            const riteStart = getEonStart(riteExon);
+            const riteStart = getCodingStart(riteExon);
             stringB = sequenceInterval.getSequence(riteStart, riteStart + ritePhase);
 
             if (!stringB) {
@@ -35565,7 +35613,7 @@ function getAminoAcidLetterWithExonGap(strand, phase, phaseExtentStart, phaseExt
                 return undefined
             }
 
-            [ss, ee] = [getEonStart(riteExon), getEonStart(riteExon) + (3 - phase)];
+            [ss, ee] = [getCodingStart(riteExon), getCodingStart(riteExon) + (3 - phase)];
             stringB = sequenceInterval.getSequence(ss, ee);
 
             if (!stringB) {
@@ -35585,7 +35633,7 @@ function getAminoAcidLetterWithExonGap(strand, phase, phaseExtentStart, phaseExt
             }
 
             const leftPhase = getExonPhase(leftExon);
-            const leftEnd = getExonEnd(leftExon);
+            const leftEnd = getCodingEnd(leftExon);
             stringA = sequenceInterval.getSequence(leftEnd - leftPhase, leftEnd);
 
             if (!stringA) {
@@ -39013,7 +39061,7 @@ class TrackDbHub {
 
                 const isContainer = (s.hasOwnProperty("superTrack") && !s.hasOwnProperty("bigDataUrl")) ||
                     s.hasOwnProperty("compositeTrack") || s.hasOwnProperty("view") ||
-                    (s.hasOwnProperty("container") && s.getOwnProperty("container").equals("multiWig"));
+                    (s.hasOwnProperty("container") && (s.getOwnProperty("container") === "multiWig"));
 
                 // Find parent, if any. "group" containers can be implicit, all other types should be explicitly
                 // defined before their children
@@ -40789,9 +40837,9 @@ class TrackViewport extends Viewport {
 
                     if (typeof this.trackView.track.popupData === "function") {
 
-                        popupTimerID = setTimeout(() => {
+                        popupTimerID = setTimeout(async () => {
 
-                                const content = this.handleTrackClick(event);
+                                const content = await this.handleTrackClick(event);
                                 if (content) {
 
                                     if (false === event.shiftKey) {
@@ -40956,7 +41004,7 @@ class TrackViewport extends Viewport {
 
     }
 
-    handleTrackClick(event) {
+    async handleTrackClick(event) {
 
         const clickState = this.createClickState(event);
 
@@ -40965,7 +41013,7 @@ class TrackViewport extends Viewport {
         }
 
         let track = this.trackView.track;
-        const dataList = track.popupData(clickState);
+        const dataList = await track.popupData(clickState);
 
         const popupClickHandlerResult = this.browser.fireEvent('trackclick', [track, dataList, clickState.genomicLocation]);
 
@@ -44203,7 +44251,7 @@ class MergedTrack extends TrackBase {
                     track.autoscaleGroup = name;
                 }
                 track.isMergedTrack = false;
-                browser.addTrack(track);
+                await browser.addTrack(track);
             }
             await browser.updateViews();
             browser.reorderTracks();
@@ -44289,7 +44337,7 @@ class OverlayTrackButton extends NavbarButton {
 
         const mouseClickHandler = () => {
             this.setVisibility(false);
-            trackOverlayClickHandler.call(this);
+            this.trackOverlayClickHandler();
         };
 
         this.boundMouseClickHandler = mouseClickHandler.bind(this);
@@ -44299,50 +44347,49 @@ class OverlayTrackButton extends NavbarButton {
         this.setVisibility(true);
 
     }
-}
 
-async function trackOverlayClickHandler(e) {
+    async trackOverlayClickHandler() {
 
-    if (true === isOverlayTrackCriteriaMet(this.browser)) {
+        if (true === isOverlayTrackCriteriaMet(this.browser)) {
 
-        const tracks = this.browser.getSelectedTrackViews().map(({track}) => track);
-        for (const track of tracks) {
-            track.selected = false;
-        }
+            const tracks = this.browser.getSelectedTrackViews().map(({track}) => track);
+            for (const track of tracks) {
+                track.selected = false;
+            }
 
-        // Flatten any merged tracks.  Must do this before their removal
-        const flattenedTracks = [];
-        for (let t of tracks) {
-            if ("merged" === t.type) {
-                flattenedTracks.push(...t.tracks);
-            } else {
-                flattenedTracks.push(t);
+            // Flatten any merged tracks.  Must do this before their removal
+            const flattenedTracks = [];
+            for (let t of tracks) {
+                if ("merged" === t.type) {
+                    flattenedTracks.push(...t.tracks);
+                } else {
+                    flattenedTracks.push(t);
+                }
             }
-        }
 
-        const config =
-            {
-                name: 'Overlay',
-                type: 'merged',
-                autoscale: false,
-                alpha: 0.5, //fudge * (1.0/tracks.length),
-                height: Math.max(...tracks.map(({height}) => height)),
-                order: Math.min(...tracks.map(({order}) => order)),
-            };
+            const config =
+                {
+                    name: 'Overlay',
+                    type: 'merged',
+                    autoscale: false,
+                    alpha: 0.5, //fudge * (1.0/tracks.length),
+                    height: Math.max(...tracks.map(({height}) => height)),
+                    order: Math.min(...tracks.map(({order}) => order))
+                };
 
-        const mergedTrack = new MergedTrack(config, this.browser, flattenedTracks);
+            const mergedTrack = new MergedTrack(config, this.browser, flattenedTracks);
 
-        for (const track of tracks) {
-            const idx = this.browser.trackViews.indexOf(track.trackView);
-            this.browser.trackViews.splice(idx, 1);
-            track.trackView.dispose();
-        }
+            for (const track of tracks) {
+                const idx = this.browser.trackViews.indexOf(track.trackView);
+                this.browser.trackViews.splice(idx, 1);
+                track.trackView.dispose();
+            }
 
-        this.browser.addTrack(mergedTrack);
-        await mergedTrack.trackView.updateViews();
-        this.browser.reorderTracks();
+            await this.browser.addTrack(mergedTrack);
+            await mergedTrack.trackView.updateViews();
+            this.browser.reorderTracks();
+        }
     }
-
 }
 
 function isOverlayTrackCriteriaMet(browser) {
@@ -47435,7 +47482,7 @@ class BaseModificationKey {
         this.base = base;
         this.strand = strand;
         this.modification = modification;
-        this.canonicalBase = this.strand === '+' ? this.base : complementBase(this.base);
+        this.canonicalBase = this.strand === '+' ? this.base : complementBase$1(this.base);
     }
 
     getCanonicalBase() {
@@ -47485,7 +47532,7 @@ class BaseModificationSet {
         this.modification = modification;
         this.strand = strand;
         this.likelihoods = likelihoods;
-        this.canonicalBase = this.strand == '+' ? this.base : complementBase(this.base);
+        this.canonicalBase = this.strand == '+' ? this.base : complementBase$1(this.base);
         this.key = BaseModificationKey.getKey(base, strand, modification);
     }
 
@@ -48918,6 +48965,818 @@ function computeLengthOnReference(cigarString) {
     return len
 }
 
+// Lazy import to avoid circular dependency
+
+/**
+ * Search for a feature by name across various data sources
+ * This module is separate to avoid circular dependencies between search.js and hgvs.js
+ */
+
+const DEFAULT_SEARCH_CONFIG = {
+    timeout: 5000,
+    type: "plain",
+    url: 'https://igv.org/genomes/locus.php?genome=$GENOME$&name=$FEATURE$',
+    coords: 0
+};
+
+/**
+ * Search for a feature by name in MANE transcripts, searchable tracks, and web services
+ * @param {Object} browser - The IGV browser instance
+ * @param {string} name - The feature name to search for
+ * @returns {Promise<Object|undefined>} The found feature or undefined
+ */
+async function searchFeatures(browser, name) {
+
+    const searchConfig = browser.searchConfig || DEFAULT_SEARCH_CONFIG;
+    let feature;
+
+    name = name.toUpperCase();
+
+    // Search MANE transcripts first, if available
+    feature = await browser.genome.getManeTranscript(name);
+    if (feature) {
+        return feature
+    }
+
+    const searchableTracks = browser.tracks.filter(t => t.searchable);
+    for (let track of searchableTracks) {
+        const feature = await track.search(name);
+        if (feature) {
+            return feature
+        }
+    }
+
+    // If still not found try webservice, if enabled
+    if (browser.config && false !== browser.config.search) {
+        try {
+            feature = await searchWebService(browser, name, searchConfig);
+            return feature    // Might be undefined
+        } catch (error) {
+            console.log("Search service not available " + error);
+        }
+    }
+
+}
+
+/**
+ * Search for a feature using a web service
+ * @param {Object} browser - The IGV browser instance
+ * @param {string} locus - The locus to search for
+ * @param {Object} searchConfig - Search configuration
+ * @returns {Promise<Object|undefined>} The search result
+ */
+async function searchWebService(browser, locus, searchConfig) {
+
+    let path = searchConfig.url.replace("$FEATURE$", locus.toUpperCase());
+    if (path.indexOf("$GENOME$") > -1) {
+        path = path.replace("$GENOME$", (browser.genome.id ? browser.genome.id : "hg19"));
+    }
+    const options = searchConfig.timeout ? {timeout: searchConfig.timeout} : undefined;
+    const result = await igvxhr.loadString(path, options);
+
+    return await processSearchResult(browser, result, searchConfig)
+}
+
+/**
+ * Process search results from web service
+ * @param {Object} browser - The IGV browser instance
+ * @param {string} result - The raw result from the web service
+ * @param {Object} searchConfig - Search configuration
+ * @returns {Promise<Object|undefined>} The processed search result
+ */
+async function processSearchResult(browser, result, searchConfig) {
+
+    let results;
+
+    if ('plain' === searchConfig.type) {
+        results = await parseSearchResults(browser, result);
+    } else {
+        results = JSON.parse(result);
+    }
+
+    if (searchConfig.resultsField) {
+        results = results[searchConfig.resultsField];
+    }
+
+    if (!results || 0 === results.length) {
+        return undefined
+
+    } else {
+
+        const chromosomeField = searchConfig.chromosomeField || "chromosome";
+        const startField = searchConfig.startField || "start";
+        const endField = searchConfig.endField || "end";
+        const coords = searchConfig.coords || 1;
+
+
+        let result;
+        if (Array.isArray(results)) {
+            // Ignoring all but first result for now
+            // TODO -- present all and let user select if results.length > 1
+            result = results[0];
+        } else {
+            // When processing search results from Ensembl REST API
+            // Example: https://rest.ensembl.org/lookup/symbol/macaca_fascicularis/BRCA2?content-type=application/json
+            result = results;
+        }
+
+        if (!(result.hasOwnProperty(chromosomeField) && (result.hasOwnProperty(startField)))) {
+            console.error("Search service results must include chromosome and start fields: " + result);
+        }
+
+        const chr = result[chromosomeField];
+        let start = result[startField] - coords;
+        let end = result[endField];
+        if (undefined === end) {
+            end = start + 1;
+        }
+
+        const locusObject = {chr, start, end};
+
+        // Some GTEX hacks
+        if (searchConfig.geneField && searchConfig.snpField) {
+            const name = result[searchConfig.geneField] || result[searchConfig.snpField];  // Should never have both
+            if (name) locusObject.name = name.toUpperCase();
+        }
+
+        return locusObject
+    }
+}
+
+/**
+ * Parse the igv line-oriented (non json) search results.
+ * NOTE:  currently, and probably permanently,  this will always be a single line
+ * Example
+ *    EGFR    chr7:55,086,724-55,275,031    refseq
+ *
+ * @param {Object} browser - The IGV browser instance
+ * @param {string} data - The raw search result data
+ * @returns {Array} Array of parsed search results
+ */
+async function parseSearchResults(browser, data) {
+
+    const results = [];
+    const lines = splitLines$3(data);
+
+    for (let line of lines) {
+
+        const tokens = line.split("\t");
+
+        if (tokens.length >= 3) {
+            const locusTokens = tokens[1].split(":");
+            const rangeTokens = locusTokens[1].split("-");
+            results.push({
+                chromosome: browser.genome.getChromosomeName(locusTokens[0].trim()),
+                start: parseInt(rangeTokens[0].replace(/,/g, '')),
+                end: parseInt(rangeTokens[1].replace(/,/g, '')),
+                name: tokens[0].toUpperCase()
+            });
+        }
+    }
+
+    return results
+
+}
+
+const log = console;
+
+function isValidHGVS(notation) {
+    if (!notation) return false
+    // We only need to validate that we can parse the notation in the search method.
+    // Check for basic structure: <accession>:g.<position> or <accession>:c.<position> or <accession>:p.<position>
+    // We don't validate the variant details since we only need the position for searching.
+
+    // Genomic: g.\d+ (with optional range and anything after)
+    const genomic = "g\\.\\d+.*";
+    // Coding: c. followed by optional -, *, then digits, with optional intronic offset and anything after
+    const coding = "c\\.[-*]?\\d+.*";
+    // Non-coding: n. followed by optional leading '-' then digits, anything after
+    const nonCoding = "n\\.-?\\d+.*";
+    // Protein: p. followed by optional AA letters, digits, with optional range and anything after
+    const protein = "p\\.[A-Za-z*]*\\d+.*";
+    // Optional gene symbol in parentheses immediately after accession
+    const accessionWithOptionalGene = "^[A-Za-z0-9_.]+(?:\\([^)]+\\))?";
+
+    const pattern = new RegExp(accessionWithOptionalGene + ":(?:" + genomic + "|" + coding + "|" + nonCoding + "|" + protein + ")$");
+    return pattern.test(notation)
+}
+
+/**
+ * Searches for the given HGVS notation in the provided genome.
+ * Returns a SearchResult with the corresponding chromosome and position if found,
+ * otherwise returns null.
+ */
+async function search$1(hgvs, browser) {
+
+    if (!isValidHGVS(hgvs)) {
+        return null
+    }
+
+    const genome = browser.genome;
+
+    // Determine type and extract accession and position
+    const idxG = hgvs.indexOf(":g.");
+    const idxC = hgvs.indexOf(":c.");
+    const idxP = hgvs.indexOf(":p.");
+    const idxN = hgvs.indexOf(":n.");
+    let type;
+    let idx;
+    if (idxG >= 0) {
+        type = "g";
+        idx = idxG;
+    } else if (idxC >= 0) {
+        type = "c";
+        idx = idxC;
+    } else if (idxN >= 0) {
+        type = "n";
+        idx = idxN;
+    } else if (idxP >= 0) {
+        type = "p";
+        idx = idxP;
+    } else {
+        return null
+    }
+    let accession = hgvs.substring(0, idx);
+    // Strip optional trailing gene symbol in parentheses, e.g., "NM_000302.3(PLOD1)" -> "NM_000302.3"
+    if (accession.endsWith(")")) {
+        const openIdx = accession.lastIndexOf('(');
+        if (openIdx > 0) {
+            accession = accession.substring(0, openIdx);
+        }
+    }
+    const positionPart = hgvs.substring(idx + 3); // skip ':g.' or ':c.' or ':p.'
+
+    if (type === "g") {
+        if (!positionPart) return null
+        // Match genomic positions including:
+        // - Simple position: 123
+        // - Range: 123_456
+        // - Uncertain positions: 123_? or ?_456 or (123_456)
+        // Extract just the numeric positions, ignoring variant notation after
+        const match = positionPart.match(/^\(?(\d+)(?:_(\d+|\?))?/);
+        if (!match) return null
+        const start = parseInt(match[1], 10);
+        const endGroup = match[2];
+        // If end is '?' or undefined, use start as end
+        const end = (endGroup && endGroup !== '?') ? parseInt(endGroup, 10) : start;
+        const aliasRecord = await genome.getAliasRecord(accession);
+        const chr = aliasRecord ? aliasRecord.chr : accession;
+        return {chr, start: start - 1, end: end}
+
+    } else if (type === "p") {
+
+        // Protein notation not supported for search currently.  The code below is ported from Java and kept for
+        // future reference.
+        return null
+
+        // // Protein position mapping: map codon(s) to genomic span.
+        // const transcript = await getTranscript(browser, accession)
+        // if (!transcript) return null
+        //
+        // const proteinPart = positionPart
+        // const pm = proteinPart.match(/^[A-Za-z*]{0,3}(\d+)(?:_[A-Za-z*]{0,3}(\d+))?/)
+        // if (!pm) return null
+        // let p1 = parseInt(pm[1], 10)
+        // const p2Str = pm[2]
+        // let p2 = p1
+        // if (p2Str) {
+        //     p2 = parseInt(p2Str, 10)
+        // }
+        //
+        // const codon1 = transcript.getCodon(genome, transcript.chr, p1)
+        // if (!codon1 || !codon1.isGenomePositionsSet()) return null
+        // let start1 = Math.min(...codon1.getGenomePositions())
+        // let end1 = Math.max(...codon1.getGenomePositions())
+        //
+        // let regionStart = start1
+        // let regionEnd = end1
+        // if (p2 !== p1) {
+        //     const codon2 = transcript.getCodon(genome, transcript.chr, p2)
+        //     if (!codon2 || !codon2.isGenomePositionsSet()) return null
+        //     let start2 = Math.min(...codon2.getGenomePositions())
+        //     let end2 = Math.max(...codon2.getGenomePositions())
+        //     regionStart = Math.min(start1, start2)
+        //     regionEnd = Math.max(end1, end2)
+        // }
+        // const halfOpenEnd = regionEnd + 1
+        // return {chr: transcript.chr, start: regionStart, end: halfOpenEnd}
+
+    } else if (type === "n") {
+
+        // Non-coding transcript mapping: n.123 or n.-123 maps relative to transcript start
+        const transcript = await getTranscript(browser, accession);
+        if (!transcript) return null
+
+        // Parse signed position with optional range and intronic offset (e.g., n.123, n.123_456, n.-7080_-1781, n.123+5)
+        const matcher = positionPart.match(/^(-?\d+)(?:_(-?\d+))?([+-]\d+)?/);
+        if (!matcher) return null
+
+        const t1 = parseInt(matcher[1], 10);
+        const t2Str = matcher[2];
+        const t2 = t2Str != null ? parseInt(t2Str, 10) : t1;
+
+        // Map both transcript positions to genomic
+        let g1 = transcriptPositionToGenomicPosition(transcript, t1);
+        let g2 = transcriptPositionToGenomicPosition(transcript, t2);
+        if (g1 <= 0 || g2 <= 0) return null
+
+        // Apply intronic offset (if any) to BOTH endpoints, strand-aware
+        const offsetStr = matcher[3];
+        if (offsetStr) {
+            let offset = parseInt(offsetStr, 10);
+            if (transcript.strand === '-') offset = -offset;
+            g1 += offset;
+            g2 += offset;
+        }
+
+        // Normalize to genomic span regardless of strand
+        const regionStart = Math.min(g1, g2);
+        const regionEndInclusive = Math.max(g1, g2);
+        const halfOpenEnd = regionEndInclusive + 1;
+        return {chr: transcript.chr, start: regionStart, end: halfOpenEnd}
+
+    } else { // "c"
+
+        const transcript = await getTranscript(browser, accession);
+        if (transcript) {
+            // UTR 5' c.-N with optional range and intronic offset (e.g., c.-211_-215 or c.-211-1058C>G)
+            const utr5Matcher = positionPart.match(/^-(\d+)(?:_-(\d+))?([+-]\d+)?/);
+            if (utr5Matcher) {
+                const n1 = parseInt(utr5Matcher[1], 10);
+                const n2Str = utr5Matcher[2];
+                const n2 = n2Str != null ? parseInt(n2Str, 10) : null;
+                const firstCodingGenomic = codingToGenomePosition(transcript, 1);
+                if (firstCodingGenomic > 0) {
+                    let g1 = transcript.strand === '+' ? (firstCodingGenomic - n1) : (firstCodingGenomic + n1);
+                    let g2 = g1;
+                    if (n2 != null) {
+                        g2 = transcript.strand === '+' ? (firstCodingGenomic - n2) : (firstCodingGenomic + n2);
+                    }
+                    // Apply intronic offset (single value) to both ends if present
+                    const offsetStr = utr5Matcher[3];
+                    if (offsetStr) {
+                        let offset = parseInt(offsetStr, 10);
+                        if (transcript.strand === '-') offset = -offset;
+                        g1 += offset;
+                        g2 += offset;
+                    }
+                    const start = Math.min(g1, g2);
+                    const endInclusive = Math.max(g1, g2);
+                    const endExclusive = endInclusive + 1;
+                    return {resultType: "LOCUS", chr: transcript.chr, start, end: endExclusive}
+                }
+                return null
+            }
+
+            // UTR 3' c.*N with optional range and intronic offset (e.g., c.*526_*529delATCA or c.*123+45)
+            const utr3Matcher = positionPart.match(/^\*(\d+)(?:_\*(\d+))?([+-]\d+)?/);
+            if (utr3Matcher) {
+                const n1 = parseInt(utr3Matcher[1], 10);
+                const n2Str = utr3Matcher[2];
+                const n2 = n2Str != null ? parseInt(n2Str, 10) : null;
+                let codingLen = 0;
+                if (transcript.exons) {
+                    for (const exon of transcript.exons) {
+                        codingLen += getCodingLength(exon);
+                    }
+                }
+                if (codingLen > 0) {
+                    const lastCodingGenomic = codingToGenomePosition(transcript, codingLen);
+                    if (lastCodingGenomic > 0) {
+                        let g1 = transcript.strand === '+' ? (lastCodingGenomic + n1) : (lastCodingGenomic - n1);
+                        let g2 = g1;
+                        if (n2 != null) {
+                            g2 = transcript.strand === '+' ? (lastCodingGenomic + n2) : (lastCodingGenomic - n2);
+                        }
+                        // Apply intronic offset (single value) to both ends if present
+                        const offsetStr = utr3Matcher[3];
+                        if (offsetStr) {
+                            let offset = parseInt(offsetStr, 10);
+                            if (transcript.strand === '-') offset = -offset;
+                            g1 += offset;
+                            g2 += offset;
+                        }
+                        const start = Math.min(g1, g2);
+                        const endInclusive = Math.max(g1, g2);
+                        const endExclusive = endInclusive + 1;
+                        return {resultType: "LOCUS", chr: transcript.chr, start, end: endExclusive}
+                    }
+                }
+                return null
+            }
+
+            // CDS position with optional range
+            // First parse endpoints c.X(_Y)? ignoring intronic offsets
+            const cpos = positionPart.match(/^(\d+)(?:_(\d+))?/);
+            if (!cpos) return null
+            const c1 = parseInt(cpos[1], 10);
+            const c2Str = cpos[2];
+            const c2 = c2Str != null ? parseInt(c2Str, 10) : c1;
+
+            // Map both coding positions to genomic
+            let g1 = codingToGenomePosition(transcript, c1);
+            let g2 = codingToGenomePosition(transcript, c2);
+            if (g1 <= 0 || g2 <= 0) return null
+
+            // Now parse optional intronic offsets for each endpoint separately
+            // Patterns like: 123+5 or 123-2 at the beginning, optionally followed by _ and second with offset
+            const offs = positionPart.match(/^(\d+)([+-]\d+)?(?:_(\d+)([+-]\d+)?)?/);
+            if (offs) {
+                const off1Str = offs[2];
+                const off2Str = offs[4];
+                if (off1Str) {
+                    let off1 = parseInt(off1Str, 10);
+                    if (transcript.strand === '-') off1 = -off1;
+                    g1 += off1;
+                }
+                if (off2Str) {
+                    let off2 = parseInt(off2Str, 10);
+                    if (transcript.strand === '-') off2 = -off2;
+                    g2 += off2;
+                }
+            }
+
+            // If there is no explicit second coding position, ensure single-site locus
+            if (c2Str == null) {
+                g2 = g1;
+            }
+
+            const start = Math.min(g1, g2);
+            const endInclusive = Math.max(g1, g2);
+            const endExclusive = endInclusive + 1;
+            return {chr: transcript.chr, start, end: endExclusive}
+        }
+        return null
+    }
+
+}
+
+async function getTranscript(browser, accession) {
+    return searchFeatures(browser, accession)
+}
+
+/**
+ * Convert a transcript position (1-based, from transcription start) to genomic position
+ * for non-coding transcripts. Walks through exons to find the genomic coordinate.
+ */
+function transcriptPositionToGenomicPosition(transcript, transcriptPos) {
+    // Handle positions upstream of transcript start (negative n. values)
+    if (transcriptPos <= 0) {
+        const d = Math.abs(transcriptPos);
+        return transcript.strand === '+' ? (transcript.getStart() - d) : (transcript.getEnd() + d)
+    }
+
+    const exons = transcript.exons;
+    if (!exons || exons.length === 0) {
+        // No exons, treat as simple feature
+        if (transcript.strand === '+') {
+            return transcript.getStart() + transcriptPos - 1
+        } else {
+            return transcript.getEnd() - transcriptPos + 1
+        }
+    }
+
+    const positive = transcript.strand === '+';
+    let accumulatedLength = 0;
+
+    // Sort exons appropriately based on strand
+    const sortedExons = exons.slice();
+    if (!positive) {
+        sortedExons.sort((e1, e2) => e2.getStart() - e1.getStart());
+    } else {
+        sortedExons.sort((e1, e2) => e1.getStart() - e2.getStart());
+    }
+
+    for (const exon of sortedExons) {
+        const exonLength = exon.getEnd() - exon.getStart();
+        if (accumulatedLength + exonLength >= transcriptPos) {
+            // Position is in this exon
+            const offsetInExon = transcriptPos - accumulatedLength - 1;
+            if (positive) {
+                return exon.getStart() + offsetInExon
+            } else {
+                return exon.getEnd() - offsetInExon - 1
+            }
+        }
+        accumulatedLength += exonLength;
+    }
+
+    // Position beyond transcript end
+    return -1
+}
+
+/**
+ * Translate a 1-based coding position to a 0-based genomic position.  Supports HGVS parsing
+ *
+ * @param codingPosition 1-based coding position
+ * @return 0-based genomic position, or -1 if not found.
+ */
+function codingToGenomePosition(feature, codingPosition) {
+    if (codingPosition <= 0) {
+        return -1
+    }
+    const cdna = codingPosition - 1;  // Convert to 0-based
+
+    const exons = feature.exons;
+    if (!exons) {
+        return -1
+    }
+
+    const strand = feature.strand;
+    // if (strand === 'NONE') {
+    //     throw new Error("Cannot translate from coding position on an unstranded feature.")
+    // }
+    const positive = strand === '+';
+
+    let codingLength = 0;
+    for (let i = 0; i < exons.length; i++) {
+        const exon = positive ? exons[i] : exons[exons.length - 1 - i];
+        const exonCodingLength = getCodingLength(exon);
+        if (codingLength + exonCodingLength > cdna) {
+            const cdnaOffset = cdna - codingLength;
+            if (positive) {
+                return getCodingStart(exon) + cdnaOffset
+            } else {
+                return getCodingEnd(exon) - 1 - cdnaOffset
+            }
+        }
+        codingLength += exonCodingLength;
+    }
+
+    return -1
+}
+
+/**
+ * Returns genomic HGVS notation: <RefSeqAccession>:g.<position>
+ * Example: NC_000001.11:g.1234567
+ */
+async function getHGVSPosition(genome, chr, position) {
+    try {
+        const aliasRecord = await genome.getAliasRecord(chr);
+        let accession = null;
+
+        if (aliasRecord) {
+            for (const alias of Object.values(aliasRecord)) {
+                if (alias.startsWith("NC_") || alias.startsWith("NT_") || alias.startsWith("NW_") ||
+                    alias.startsWith("NG_") || alias.startsWith("NM_") || alias.startsWith("NR_") ||
+                    alias.startsWith("NP_")) {
+                    accession = alias;
+                    break
+                }
+            }
+        }
+
+        if (!accession) {
+            accession = chr;
+        }
+
+        return `${accession}:g.${position}`
+    } catch (e) {
+        log.error("Error getting HGVS position", e);
+        return null
+    }
+}
+
+/**
+ * Returns HGVS annotation for the position, for ref and alt bases.  If a MANE transcript is available that is
+ * used with coding notation (c.), otherwise genome position is used with genomic notation (g.).
+ * Example: NM_000302.3:c.1234A>G or NM_000302.3:c.123+5T>C (intronic) or NC_000001.11:g.1234567G>A
+ *
+ * @param genome The genome
+ * @param chr The chromosome name
+ * @param position The genomic position (0-based)
+ * @param reference The reference base (single-character string)
+ * @param alternate The alternate base (single-character string)
+ * @return {Promise<string|null>} HGVS notation string, or null if error
+ */
+async function createHGVSAnnotation(genome, chr, position, reference, alternate) {
+
+    try {
+        const transcript = await genome.getManeTranscriptAt(chr, position);
+
+        if (transcript && transcript.exons) {
+
+            // Ensure bases are uppercase
+            reference = reference.toUpperCase();
+            alternate = alternate.toUpperCase();
+
+            if (transcript.strand === '-') {
+                reference = complementBase(reference);
+                alternate = complementBase(alternate);
+            }
+
+
+            let positionString = "";
+
+            let transcriptName = transcript.name;
+            for (const key of Object.keys(transcript)) {
+                const value = transcript[key];
+                if (typeof value === 'string' && (value.startsWith("NM_") || value.startsWith("NR_"))) {
+                    transcriptName = value;
+                    break
+                }
+            }
+
+            if (transcriptName) {
+                // Check if position is within an exon (coding or non-coding)
+                let positionIsInExon = false;
+                for (const exon of transcript.exons) {
+                    if (position >= exon.start && position < exon.end) {
+                        positionIsInExon = true;
+                        break
+                    }
+                }
+
+                const positive = transcript.strand === '+';
+
+                if (positionIsInExon) {
+                    // Try to convert to coding position
+                    const codingPosition = genomeToCodingPosition(position, positive, transcript.exons);
+
+                    if (codingPosition >= 0) {
+                        // Position is in a coding region, return c. notation (1-based)
+                        positionString = `${transcriptName}:c.${codingPosition + 1}`;
+                    } else {
+                        // Position is in an exon but not coding - check if in UTR
+                        const firstCodingPos = codingToGenomePosition(transcript, 1);
+                        if (firstCodingPos > 0) {
+                            // Calculate total coding length
+                            let codingLen = 0;
+                            for (const exon of transcript.exons) {
+                                codingLen += getCodingLength(exon);
+                            }
+                            const lastCodingPos = codingToGenomePosition(transcript, codingLen);
+
+                            // Check if in 5' UTR
+                            if ((positive && position < firstCodingPos) || (!positive && position > firstCodingPos)) {
+                                const distance = Math.abs(position - firstCodingPos);
+                                positionString = `${transcriptName}:c.-${distance}`;
+                            }
+                            // Check if in 3' UTR
+                            else if ((positive && position >= lastCodingPos) || (!positive && position <= lastCodingPos)) {
+                                const distance = Math.abs(position - lastCodingPos) + 1;
+                                positionString = `${transcriptName}:c.*${distance}`;
+                            }
+                        }
+                    }
+                } else {
+                    // Position is intronic - find nearest exon boundary
+                    // For HGVS, we reference the last coding base in the nearest exon
+                    let nearestExonEdge = -1;
+                    let nearestCodingPos = -1;
+                    let minDistance = Number.MAX_SAFE_INTEGER;
+
+                    for (const exon of transcript.exons) {
+                        if (getCodingLength(exon) === 0) continue // Skip non-coding exons
+
+                        // Check distance to the last coding base at the start side of the exon
+                        // exon.start is 0-based inclusive
+                        const distToStart = Math.abs(position - exon.start);
+                        if (distToStart > 0 && distToStart < minDistance) {
+                            minDistance = distToStart;
+                            nearestExonEdge = exon.start;
+                            // Get coding position of first base in this exon
+                            nearestCodingPos = genomeToCodingPosition(getCodingStart(exon), positive, transcript.exons);
+                        }
+
+                        // Check distance to the last coding base at the end side of the exon
+                        // exon.end is 0-based exclusive, so last base is at end-1
+                        const distToEnd = Math.abs(position - (exon.end - 1));
+                        if (distToEnd > 0 && distToEnd < minDistance) {
+                            minDistance = distToEnd;
+                            nearestExonEdge = exon.end - 1;
+                            // Get coding position of last base in this exon
+                            nearestCodingPos = genomeToCodingPosition(getCodingEnd(exon) - 1, positive, transcript.exons);
+                        }
+                    }
+
+                    if (nearestCodingPos >= 0) {
+                        // Calculate offset: positive = downstream of exon, negative = upstream of exon
+                        let offset = position - nearestExonEdge;
+                        // For positive strand: + means to the right, - means to the left
+                        // For negative strand: + means to the left (genomically), - means to the right
+                        // But in HGVS, the sign is relative to transcript direction, so we need to flip for negative strand
+                        if (!positive) {
+                            offset = -offset;
+                        }
+                        const sign = offset >= 0 ? "+" : "";
+                        positionString = `${transcriptName}:c.${nearestCodingPos + 1}${sign}${offset}`;
+                    }
+                }
+            }
+
+            return positionString + reference + ">" + alternate
+        }
+
+        // Fallback to genomic notation
+        const aliasRecord = await genome.getAliasRecord(chr);
+        let accession = chr;
+
+        if (aliasRecord) {
+            for (const alias of Object.values(aliasRecord)) {
+                if (alias.startsWith("NC_") || alias.startsWith("NT_") || alias.startsWith("NW_") ||
+                    alias.startsWith("NG_") || alias.startsWith("NM_") || alias.startsWith("NR_") ||
+                    alias.startsWith("NP_")) {
+                    accession = alias;
+                    break
+                }
+            }
+        }
+
+        // HGVS genomic coordinate is 1-based; position parameter is 0-based
+        return `${accession}:g.${position + 1}${reference}>${alternate}`
+    } catch (e) {
+        log.error("Error creating HGVS annotation", e);
+        return null
+    }
+}
+
+// Helper function to complement a base (string)
+function complementBase(base) {
+    const complementMap = { 'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C' };
+    return complementMap[base] || base
+}
+
+function genomeToCodingPosition(genomePosition, positive, exons) {
+
+    if (exons) {
+
+        /*
+         We loop over all exons, either from the beginning or the end.
+         Increment position only on coding regions.
+         */
+
+        let codingOffset = 0;
+
+        for (let exnum = 0; exnum < exons.length; exnum++) {
+
+            const exon = positive ? exons[exnum] : exons[exons.length - 1 - exnum];
+
+            if (exon.start <= genomePosition && exon.end > genomePosition) {
+                const delta = positive
+                    ? genomePosition - getCodingStart(exon)
+                    : getCodingEnd(exon) - genomePosition - 1;
+                return codingOffset + delta
+            }
+
+            codingOffset += getCodingLength(exon);
+        }
+    }
+    return -1
+}
+
+
+
+const HGVS = {
+    isValidHGVS,
+    search: search$1,
+    getHGVSPosition,
+    createHGVSAnnotation
+};
+
+/**
+ * ClinVar utilities for searching and retrieving ClinVar variation information
+ */
+
+/**
+ * Get the ClinVar URL for the given HGVS notation
+ * @param {string} hgvsNotation - The HGVS notation string to search for
+ * @return {Promise<string|null>} The ClinVar variation URL, or null if not found or error occurs
+ */
+async function getClinVarURL(hgvsNotation) {
+    try {
+        const encodedHgvs = encodeURIComponent(hgvsNotation);
+        const esearchUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?` +
+            `db=clinvar&term=${encodedHgvs}&retmode=json`;
+
+        const response = await fetch(esearchUrl);
+
+        if (!response.ok) {
+            console.error(`HTTP error! status: ${response.status}`);
+            return null
+        }
+
+        // Parse JSON response to get the first ClinVar accession
+        const json = await response.json();
+        const esearchResult = json.esearchresult;
+
+        if (esearchResult.count > 0) {
+            const uid = esearchResult.idlist[0];
+            return `https://www.ncbi.nlm.nih.gov/clinvar/variation/${uid}/`
+        } else {
+            return null
+        }
+
+    } catch (e) {
+        console.error("Error fetching ClinVar URL", e);
+        return null
+    }
+}
+
+const ClinVar = {
+    getClinVarURL
+};
+
 const READ_PAIRED_FLAG = 0x1;
 const PROPER_PAIR_FLAG = 0x2;
 const READ_UNMAPPED_FLAG = 0x4;
@@ -49052,13 +49911,22 @@ class BamAlignment {
         return (genomicLocation >= s && genomicLocation <= (s + l))
     }
 
-    popupData(genomicLocation, hiddenTags, showTags) {
+    /**
+     * Return data to show in the popup.  Elements are either strings (for raw HTML) or
+     * objects with name, value, borderTop properties.
+     *
+     * @param genomicLocation - 0-based genomic location
+     * @param hiddenTags - Set of bam tags to hide
+     * @param showTags - Set of bam tags to show (overrides hide/show rules)
+     * @returns {*[]}
+     */
+    async popupData(genomicLocation, hiddenTags, showTags, refBase, genome) {
 
         // if the user clicks on a base next to an insertion, show just the
         // inserted bases in a popup (like in desktop IGV).
         const nameValues = [];
 
-        // Consert genomic location to int
+        // Convert genomic location to int
         genomicLocation = Math.floor(genomicLocation);
 
         if (this.insertions) {
@@ -49077,6 +49945,26 @@ class BamAlignment {
 
         nameValues.push({name: 'Read Name', value: this.readName});
 
+
+        // HGVS annotations for variants, and ClinVar links if available
+        const readBase = this.readBaseAt(genomicLocation);
+        if (refBase) {
+            if (readBase && readBase !== refBase && readBase !== '*') {
+                const hgvsNotation = await HGVS.createHGVSAnnotation(genome, this.chr, genomicLocation, refBase, readBase);
+                if (hgvsNotation) {
+                    const clinVarURL = await ClinVar.getClinVarURL(hgvsNotation);
+                    if (clinVarURL) {
+                        nameValues.push({
+                            name: 'ClinVar',
+                            value: `<a href='${clinVarURL}' target='_blank'>${hgvsNotation}</a>`
+                        });
+                    } else {
+                        nameValues.push({name: 'HGVS', value: hgvsNotation});
+                    }
+                }
+            }
+        }
+
         // Sample
         // Read group
         nameValues.push('<hr/>');
@@ -49152,7 +50040,7 @@ class BamAlignment {
 
         nameValues.push('<hr/>');
         nameValues.push({name: 'Genomic Location: ', value: numberFormatter$1(1 + genomicLocation)});
-        nameValues.push({name: 'Read Base:', value: this.readBaseAt(genomicLocation)});
+        nameValues.push({name: 'Read Base:', value: readBase});
         nameValues.push({name: 'Base Quality:', value: this.readBaseQualityAt(genomicLocation)});
 
         const bmSets = this.getBaseModificationSets();
@@ -51357,8 +52245,8 @@ class BamSource {
         if (alignmentContainer.hasAlignments) {
             const sequence = await genome.getSequence(chr, alignmentContainer.start, alignmentContainer.end);
             if (sequence) {
-                alignmentContainer.coverageMap.refSeq = sequence;    // TODO -- fix this
-                alignmentContainer.sequence = sequence;           // TODO -- fix this
+                alignmentContainer.coverageMap.refSeq = sequence;
+                alignmentContainer.sequence = sequence;
                 return alignmentContainer
             } else {
                 console.error("No sequence for: " + chr + ":" + alignmentContainer.start + "-" + alignmentContainer.end);
@@ -53679,7 +54567,7 @@ class AlignmentTrack extends TrackBase {
         highlightColor: undefined,
         minTLEN: undefined,
         maxTLEN: undefined,
-        tagColorPallete: "Set1",
+        tagColorPallete: "Set1"
     }
 
     _colorTables = new Map()
@@ -54029,7 +54917,7 @@ class AlignmentTrack extends TrackBase {
 
                     IGVGraphics.strokeLine(ctx, sPixel, yStrokedLine, ePixel, yStrokedLine, {
                         strokeStyle: color,
-                        lineWidth: 2,
+                        lineWidth: 2
                     });
 
                     // Add gap width as text like Java IGV if it fits nicely and is a multi-base gap
@@ -54038,7 +54926,7 @@ class AlignmentTrack extends TrackBase {
                         IGVGraphics.fillRect(ctx, textStart - 1, y - 1, gapTextWidth + 2, 12, {fillStyle: "white"});
                         IGVGraphics.fillText(ctx, gapLenText, textStart, y + 10, {
                             'font': 'normal 10px monospace',
-                            'fillStyle': this.deletionTextColor,
+                            'fillStyle': this.deletionTextColor
                         });
                     }
                 }
@@ -54081,7 +54969,7 @@ class AlignmentTrack extends TrackBase {
                         if (this.showInsertionText && insertionBlock.len > 1 && basePixelWidth > textPixelWidth) {
                             IGVGraphics.fillText(ctx, insertLenText, xBlockStart + 1, y + 10, {
                                 'font': 'normal 10px monospace',
-                                'fillStyle': this.insertionTextColor,
+                                'fillStyle': this.insertionTextColor
                             });
                         }
                         lastXBlockStart = xBlockStart;
@@ -54251,7 +55139,7 @@ class AlignmentTrack extends TrackBase {
                                     height: alignmentHeight
                                 },
                                 baseColor,
-                                readChar,
+                                readChar
                             });
                         }
 
@@ -54261,13 +55149,28 @@ class AlignmentTrack extends TrackBase {
                 return blockBasesToDraw
             }
         }
+    }
 
-    };
-
-    popupData(clickState) {
+    async popupData(clickState) {
         const clickedObject = this.getClickedObject(clickState);
-        return clickedObject?.popupData(clickState.genomicLocation, this.hiddenTags, this.showTags)
-    };
+        if (clickedObject) {
+
+            // Determine reference base at clicked position, used for HGVS notation
+            let refBase;
+            if (clickedObject.chr) {
+                const viewport = clickState.viewport;
+                const alignmentContainer = viewport.cachedFeatures;
+                const coverageMap = alignmentContainer?.coverageMap;
+                const refseq = coverageMap?.refSeq;
+                if (refseq) {
+                    const genomicLocation = Math.floor(clickState.genomicLocation);
+                    refBase = refseq.charAt(genomicLocation - coverageMap.bpStart).toUpperCase();
+                }
+            }
+
+            return clickedObject.popupData(clickState.genomicLocation, this.hiddenTags, this.showTags, refBase, this.browser.genome)
+        }
+    }
 
     /**
      * Return menu items for the AlignmentTrack
@@ -55040,7 +55943,7 @@ class AlignmentTrack extends TrackBase {
                         this.colorTable = new PaletteColorTable(this.tagColorPallete);
                     }
                     color = this.colorTable.getColor(tagValue);
-                    
+
                 }
                 break
         }
@@ -55197,7 +56100,7 @@ function drawModifications(ctx,
 
 
             const base = key.base;
-            const compl = complementBase(base);
+            const compl = complementBase$1(base);
 
             const modifiable = coverageMap.getCount(pos, base) + coverageMap.getCount(pos, compl);
             const detectable = modificationCounts.simplexModifications.has(key.modification) ?
@@ -55230,7 +56133,7 @@ function drawModifications(ctx,
 
 const DEFAULT_COVERAGE_COLOR = "rgb(150, 150, 150)";
 
-class CoverageTrack  {
+class CoverageTrack {
 
 
     constructor(config, parent) {
@@ -55242,7 +56145,7 @@ class CoverageTrack  {
         this.top = 0;
 
         this.autoscale = config.autoscale || config.max === undefined;
-        if(config.coverageColor) {
+        if (config.coverageColor) {
             this.color = config.coverageColor;
         }
 
@@ -55259,11 +56162,15 @@ class CoverageTrack  {
         return this.parent.coverageTrackHeight
     }
 
+    get browser() {
+        return this.parent.browser
+    }
+
     draw(options) {
 
         const pixelTop = options.pixelTop;
         pixelTop + options.pixelHeight;
-        const nucleotideColors = this.parent.browser.nucleotideColors;
+        const nucleotideColors = this.browser.nucleotideColors;
 
         if (pixelTop > this.height) {
             return //scrolled out of view
@@ -55297,7 +56204,8 @@ class CoverageTrack  {
             fillStyle: color,
             strokeStyle: color
         });
-        const w =  Math.max(1, 1.0 / bpPerPixel);
+
+        const w = Math.max(1, 1.0 / bpPerPixel);
         for (let i = 0, len = coverageMap.coverage.length; i < len; i++) {
 
             const bp = (coverageMap.bpStart + i);
@@ -55366,8 +56274,9 @@ class CoverageTrack  {
         const coverageMap = features.coverageMap;
         const coverageMapIndex = Math.floor(genomicLocation - coverageMap.bpStart);
         const coverage = coverageMap.coverage[coverageMapIndex];
-        if(coverage) {
+        if (coverage) {
             return {
+                reference: coverageMap.refSeq ? coverageMap.refSeq.charAt(coverageMapIndex).toUpperCase() : undefined,
                 coverage: coverage,
                 baseModCounts: features.baseModCounts,
                 hoverText: () => coverageMap.coverage[coverageMapIndex].hoverText()
@@ -55375,60 +56284,64 @@ class CoverageTrack  {
         }
     }
 
-    popupData(clickState) {
+    async popupData(clickState) {
 
         const nameValues = [];
 
-        const {coverage, baseModCounts} = this.getClickedObject(clickState);
+        const {reference, coverage, baseModCounts} = this.getClickedObject(clickState);
         if (coverage) {
             const genomicLocation = Math.floor(clickState.genomicLocation);
             const referenceFrame = clickState.viewport.referenceFrame;
 
             nameValues.push(referenceFrame.chr + ":" + numberFormatter$1(1 + genomicLocation));
-
             nameValues.push({name: 'Total Count', value: coverage.total});
+            nameValues.push('<HR/>');
 
             // A
-            let tmp = coverage.posA + coverage.negA;
-            if (tmp > 0) tmp = tmp.toString() + " (" + Math.round((tmp / coverage.total) * 100.0) + "%, " + coverage.posA + "+, " + coverage.negA + "- )";
-            nameValues.push({name: 'A', value: tmp});
-
-            // C
-            tmp = coverage.posC + coverage.negC;
-            if (tmp > 0) tmp = tmp.toString() + " (" + Math.round((tmp / coverage.total) * 100.0) + "%, " + coverage.posC + "+, " + coverage.negC + "- )";
-            nameValues.push({name: 'C', value: tmp});
-
-            // G
-            tmp = coverage.posG + coverage.negG;
-            if (tmp > 0) tmp = tmp.toString() + " (" + Math.round((tmp / coverage.total) * 100.0) + "%, " + coverage.posG + "+, " + coverage.negG + "- )";
-            nameValues.push({name: 'G', value: tmp});
-
-            // T
-            tmp = coverage.posT + coverage.negT;
-            if (tmp > 0) tmp = tmp.toString() + " (" + Math.round((tmp / coverage.total) * 100.0) + "%, " + coverage.posT + "+, " + coverage.negT + "- )";
-            nameValues.push({name: 'T', value: tmp});
-
-            // N
-            tmp = coverage.posN + coverage.negN;
-            if (tmp > 0) tmp = tmp.toString() + " (" + Math.round((tmp / coverage.total) * 100.0) + "%, " + coverage.posN + "+, " + coverage.negN + "- )";
-            nameValues.push({name: 'N', value: tmp});
+            for (let b of ['A', 'C', 'G', 'T', 'N']) {
+                let tmp = coverage[`pos${b}`] + coverage[`neg${b}`];
+                tmp = tmp.toString() + " (" + Math.round((tmp / coverage.total) * 100.0) + "%, " + coverage[`pos${b}`] + "+, " + coverage[`neg${b}`] + "- )";
+                nameValues.push({name: b, value: tmp});
+            }
 
-            nameValues.push('<HR/>');
-            nameValues.push({name: 'DEL', value: coverage.del.toString()});
-            nameValues.push({name: 'INS', value: coverage.ins.toString()});
+            if (coverage.del > 0) nameValues.push({name: 'DEL', value: coverage.del.toString()});
+            if (coverage.ins > 0) nameValues.push({name: 'INS', value: coverage.ins.toString()});
 
-            if(baseModCounts) {
+            if (baseModCounts) {
                 nameValues.push('<hr/>');
                 nameValues.push(...baseModCounts.popupData(genomicLocation, this.parent.colorBy));
 
             }
 
-        }
+            // HGVS annotations for variants, and ClinVar links if available
+            if (reference) {
+                let first = true;
+                for (let b of ['A', 'C', 'G', 'T']) {
+                    let count = coverage[`pos${b}`] + coverage[`neg${b}`];
+                    if (count > 0 && reference !== b) {
+                        if (first) {
+                            nameValues.push('<hr/>');
+                            first = false;
+                        }
+                        const hgvsNotation = await HGVS.createHGVSAnnotation(this.browser.genome, referenceFrame.chr, genomicLocation, reference, b);
+                        const clinVarURL = await ClinVar.getClinVarURL(hgvsNotation);
+                        if (clinVarURL) {
+                            nameValues.push({
+                                name: 'ClinVar',
+                                value: `<a href='${clinVarURL}' target='_blank'>${hgvsNotation}</a>`
+                            });
+                        } else {
+                            nameValues.push({name: 'HGVS', value: hgvsNotation});
+                        }
+                    }
+                }
+            }
 
-        return nameValues
 
-    }
+            return nameValues
 
+        }
+    }
 }
 
 class BAMTrack extends TrackBase {
@@ -72360,39 +73273,6 @@ const SV_COLOR_TABLE = new ColorTable({
     '*': '#002eff'
 });
 
-const DEFAULT_SEARCH_CONFIG = {
-    timeout: 5000,
-    type: "plain",
-    url: 'https://igv.org/genomes/locus.php?genome=$GENOME$&name=$FEATURE$',
-    coords: 0
-};
-
-async function searchFeatures(browser, name) {
-
-    const searchConfig = browser.searchConfig || DEFAULT_SEARCH_CONFIG;
-    let feature;
-
-    name = name.toUpperCase();
-    const searchableTracks = browser.tracks.filter(t => t.searchable);
-    for (let track of searchableTracks) {
-        const feature = await track.search(name);
-        if (feature) {
-            return feature
-        }
-    }
-
-    // If still not found try webservice, if enabled
-    if (browser.config && false !== browser.config.search) {
-        try {
-            feature = await searchWebService(browser, name, searchConfig);
-            return feature    // Might be undefined
-        } catch (error) {
-            console.log("Search service not available " + error);
-        }
-    }
-
-}
-
 /**
  * Return an object representing the locus of the given string.  Object is of the form
  * {
@@ -72419,6 +73299,13 @@ async function search(browser, string) {
 
     const searchForLocus = async (locus) => {
 
+        if (HGVS.isValidHGVS(locus)) {
+            const hgvsResult = await HGVS.search(locus, browser);
+            if (hgvsResult) {
+                return hgvsResult
+            }
+        }
+
         if (locus.trim().toLowerCase() === "all" || locus === "*") {
             if (browser.genome.wholeGenomeView) {
                 const wgChr = browser.genome.getChromosome("all");
@@ -72444,12 +73331,12 @@ async function search(browser, string) {
 
             // Not a locus string, search track annotations
             const feature = await searchFeatures(browser, locus);
-            if(feature) {
+            if (feature) {
                 locusObject = {
                     chr: feature.chr,
                     start: feature.start,
                     end: feature.end,
-                    name: (feature.name || locus).toUpperCase(),
+                    name: (feature.name || locus).toUpperCase()
 
                 };
             }
@@ -72574,110 +73461,6 @@ function parseLocusString(locus, isSoftclipped = false) {
 
 }
 
-async function searchWebService(browser, locus, searchConfig) {
-
-    let path = searchConfig.url.replace("$FEATURE$", locus.toUpperCase());
-    if (path.indexOf("$GENOME$") > -1) {
-        path = path.replace("$GENOME$", (browser.genome.id ? browser.genome.id : "hg19"));
-    }
-    const options = searchConfig.timeout ? {timeout: searchConfig.timeout} : undefined;
-    const result = await igvxhr.loadString(path, options);
-
-    return processSearchResult(browser, result, searchConfig)
-}
-
-function processSearchResult(browser, result, searchConfig) {
-
-    let results;
-
-    if ('plain' === searchConfig.type) {
-        results = parseSearchResults(browser, result);
-    } else {
-        results = JSON.parse(result);
-    }
-
-    if (searchConfig.resultsField) {
-        results = results[searchConfig.resultsField];
-    }
-
-    if (!results || 0 === results.length) {
-        return undefined
-
-    } else {
-
-        const chromosomeField = searchConfig.chromosomeField || "chromosome";
-        const startField = searchConfig.startField || "start";
-        const endField = searchConfig.endField || "end";
-        const coords = searchConfig.coords || 1;
-
-
-        let result;
-        if (Array.isArray(results)) {
-            // Ignoring all but first result for now
-            // TODO -- present all and let user select if results.length > 1
-            result = results[0];
-        } else {
-            // When processing search results from Ensembl REST API
-            // Example: https://rest.ensembl.org/lookup/symbol/macaca_fascicularis/BRCA2?content-type=application/json
-            result = results;
-        }
-
-        if (!(result.hasOwnProperty(chromosomeField) && (result.hasOwnProperty(startField)))) {
-            console.error("Search service results must include chromosome and start fields: " + result);
-        }
-
-        const chr = result[chromosomeField];
-        let start = result[startField] - coords;
-        let end = result[endField];
-        if (undefined === end) {
-            end = start + 1;
-        }
-
-        const locusObject = {chr, start, end};
-
-        // Some GTEX hacks
-        result.type ? result.type : "gene";
-        if (searchConfig.geneField && searchConfig.snpField) {
-            const name = result[searchConfig.geneField] || result[searchConfig.snpField];  // Should never have both
-            if (name) locusObject.name = name.toUpperCase();
-        }
-
-        return locusObject
-    }
-}
-
-/**
- * Parse the igv line-oriented (non json) search results.
- * NOTE:  currently, and probably permanently,  this will always be a single line
- * Example
- *    EGFR    chr7:55,086,724-55,275,031    refseq
- *
- */
-function parseSearchResults(browser, data) {
-
-    const results = [];
-    const lines = splitLines$3(data);
-
-    for (let line of lines) {
-
-        const tokens = line.split("\t");
-
-        if (tokens.length >= 3) {
-            const locusTokens = tokens[1].split(":");
-            const rangeTokens = locusTokens[1].split("-");
-            results.push({
-                chromosome: browser.genome.getChromosomeName(locusTokens[0].trim()),
-                start: parseInt(rangeTokens[0].replace(/,/g, '')),
-                end: parseInt(rangeTokens[1].replace(/,/g, '')),
-                name: tokens[0].toUpperCase()
-            });
-        }
-    }
-
-    return results
-
-}
-
 class QTLTrack extends TrackBase {
 
     constructor(config, browser) {
@@ -75693,7 +76476,7 @@ function createReferenceFrameList(loci, genome, browserFlanking, minimumBases, v
     })
 }
 
-const _version = "3.6.0";
+const _version = "3.7.1";
 function version() {
     return _version
 }
@@ -78705,7 +79488,7 @@ class Genome {
         this.sequence = await loadSequence(config, this.browser);
 
         // Load cytobands.  This is optional but required to support the ideogram.  Only needed for whole genome view
-        if(false !== config.showIdeogram && false !== config.wholeGenomeView) {
+        if (false !== config.showIdeogram && false !== config.wholeGenomeView) {
             if (config.cytobandURL) {
                 this.cytobandSource = new CytobandFile(config.cytobandURL, Object.assign({}, config));
             } else if (config.cytobandBbURL) {
@@ -78713,8 +79496,8 @@ class Genome {
             }
         }
 
-            // Search for chromosomes, that is an array of chromosome objects containing name and length.  This is
-            // optional but required to support whole genome view.
+        // Search for chromosomes, that is an array of chromosome objects containing name and length.  This is
+        // optional but required to support whole genome view.
         if (this.sequence.chromosomes) {
             this.chromosomes = this.sequence.chromosomes;
         } else if (config.chromSizesURL) {
@@ -78750,7 +79533,7 @@ class Genome {
                 // Trim to remove non-existent chromosomes
                 await this.chromAlias.preload(this.#wgChromosomeNames);
                 this.#wgChromosomeNames =
-                    this.#wgChromosomeNames.map(c =>  this.getChromosomeName(c)).filter(c => this.chromosomes.has(c));
+                    this.#wgChromosomeNames.map(c => this.getChromosomeName(c)).filter(c => this.chromosomes.has(c));
             } else {
                 this.#wgChromosomeNames = trimSmallChromosomes(this.chromosomes);
                 await this.chromAlias.preload(this.#wgChromosomeNames);
@@ -78994,6 +79777,75 @@ class Genome {
     getHubURLs() {
         return this.config.hubs
     }
+
+    /**
+     * Return the Mane transcript with the given name, or null if not found. We also check the refseq historical
+     * db if available for backward compatibility. This is only available for hg38.
+     * @param {string} name - The name of the Mane transcript to search for.
+     * @return {Promise<Object|null>} A Promise resolving to the Mane transcript object if found, or null otherwise.
+     */
+    async getManeTranscript(name) {
+
+        if (!this.maneFeatureSource && this.config.maneBbURL) {
+            this.loadManeFeatureSource();
+        }
+        if (this.maneFeatureSource) {
+            const feature = await this.maneFeatureSource.search(name);
+            if (feature) {
+                return feature
+            }
+        }
+        if (!this.rsDBFeatureSource && this.config.rsdbURL) {
+            this.rsDBFeatureSource = new BWSource({url: this.config.rsdbURL}, this);
+        }
+        if (this.rsDBFeatureSource) {
+            const feature = await this.rsDBFeatureSource.search(name);
+            if (feature) {
+                return feature
+            }
+        }
+        return null
+    }
+
+    /**
+     * Return the Mane transcript overlapping the given position, or null if none found.
+     *
+     * @param chr      Chromosome name (e.g., "chr1", "chrX") in which to search for the transcript.
+     * @param position Genomic position (0-based coordinate) to check for overlap with a Mane transcript.
+     * @return {Promise<*|null>} The feature representing the Mane transcript overlapping the specified position, or null if none is found.
+     */
+    async getManeTranscriptAt(chr, position) {
+        if (!this.maneFeatureSource && this.config.maneBbURL) {
+            this.loadManeFeatureSource();
+        }
+        if (this.maneFeatureSource) {
+            try {
+                const start = position;
+                const end = position + 1;
+                const features = await this.maneFeatureSource.getFeatures({chr, start, end});
+                if (features) {
+                    for (const feature of features) {
+                        if (feature.start <= position && feature.end >= position) {
+                            return feature
+                        }
+                    }
+                }
+            } catch (e) {
+                console.error("Error fetching MANE transcript", e);
+            }
+        }
+        return null
+    }
+
+    loadManeFeatureSource() {
+        if (this.config.maneBbURL != null) {
+            const bbConfig = {url: this.config.maneBbURL};
+            if (this.config.maneTrixURL) {
+                bbConfig.trixURL = this.config.maneTrixURL;
+            }
+            this.maneFeatureSource = new BWSource(bbConfig, this);
+        }
+    }
 }
 
 /**
@@ -79811,10 +80663,7 @@ class Browser {
 
         let session;
         if (options.url || options.file) {
-            session = await Browser.loadSessionFile(options, this.config);
-            // if (options.parentApp``) {
-            //     session.parentApp = options.parentApp
-            // }
+            session = await Browser.loadSessionFile(options);
         } else {
             session = options;
         }
@@ -79828,7 +80677,7 @@ class Browser {
      * @param options
      * @returns {Promise<*|XMLSession>}
      */
-    static async loadSessionFile(options, defaults) {
+    static async loadSessionFile(options) {
 
         const urlOrFile = options.url || options.file;
 
@@ -79857,7 +80706,7 @@ class Browser {
                 config = await igvxhr.loadJson(urlOrFile);
             }
         }
-        setDefaults(config, defaults);
+
         return config
     }
 
@@ -79868,6 +80717,9 @@ class Browser {
      */
     async loadSessionObject(session) {
 
+        // Capture current configuration options that might be missing from session
+        setDefaults(session, this.config);
+
         // prepare to load a new session, discarding DOM and state
         this.cleanHouseForSession();
         this.config = session;
@@ -79972,16 +80824,19 @@ class Browser {
 
         // Sample info
         const localSampleInfoFiles = [];
+        const googleDriveSampleInfoFiles = [];
         if (session.sampleinfo) {
             const sampleInfoArray = Array.isArray(session.sampleinfo) ? session.sampleinfo : [session.sampleinfo];
             for (const sampleInfoConfig of sampleInfoArray) {
-                // The "file" property is recorded in the session when a local file is referenced. It can't be used
-                // on reloading, its only purpose is to present an alert to the user.  This could also be used
-                // to prompt the user to load the file manually, but we don't currently do that.
                 if (sampleInfoConfig.file) {
                     localSampleInfoFiles.push(sampleInfoConfig.file);
                 } else {
-                    await this.sampleInfo.loadSampleInfo(sampleInfoConfig);
+                    const googleDriveItem = this.#createGoogleDriveItemIfPresent(sampleInfoConfig, 'Sample info', 'url', 'filename', 'Google Drive file');
+                    if (googleDriveItem) {
+                        googleDriveSampleInfoFiles.push(googleDriveItem);
+                    } else {
+                        await this.sampleInfo.loadSampleInfo(sampleInfoConfig);
+                    }
                 }
             }
         }
@@ -79996,22 +80851,40 @@ class Browser {
             trackConfigurations.push({type: "sequence", order: defaultSequenceTrackOrder, removable: false});
         }
 
-        const localTrackFileNames = trackConfigurations.filter((config) => undefined !== config.file).map(({file}) => file);
+        // Extract problematic resources from track configurations
+        const { localFileItems, googleDriveItems } = this.#extractProblematicResources(
+            trackConfigurations,
+            localSampleInfoFiles,
+            googleDriveSampleInfoFiles
+        );
 
-        const localIndexFileNames = trackConfigurations.filter((config) => undefined !== config.indexFile).map(({indexFile}) => indexFile);
-        if (localIndexFileNames.length > 0) {
-            localTrackFileNames.push(...localIndexFileNames);
-        }
+        // Display warning if problematic resources are found
+        if (localFileItems.length > 0 || googleDriveItems.length > 0) {
+            let message = 'Local and Google Drive files cannot be loaded from a saved session. The following file(s) will not be restored with this session.\n\n';
 
-        if (localSampleInfoFiles.length > 0) {
-            localTrackFileNames.push(...localSampleInfoFiles);
-        }
+            // Add local file items
+            for (const item of localFileItems) {
+                message += `Local file name: ${item.fileName}\n`;
+                message += `Track name: ${item.trackName}\n\n`;
+
+            }
+
+            // Add Google Drive items
+            for (const item of googleDriveItems) {
+                message += `Google Drive file name: ${item.fileName}\n`;
+                message += `Track name: ${item.trackName}\n\n`;
+
+            }
 
-        if (localTrackFileNames.length > 0) {
-            alert(`Local files cannot be loaded automatically.\nThis session contains references to these local files:\n${localTrackFileNames.map(str => `    ${str}`).join('\n')}`);
+            alert(message);
         }
 
-        const nonLocalTrackConfigurations = trackConfigurations.filter((config) => undefined === config.file);
+        const nonLocalTrackConfigurations = trackConfigurations.filter((config) =>
+            undefined === config.file &&
+            undefined === config.indexFile &&
+            // Filter out tracks with Google Drive URLs in url/indexURL fields
+            !(config.url && isGoogleDriveURL(config.url)) &&
+            !(config.indexURL && isGoogleDriveURL(config.indexURL)));
 
         // Maintain track order unless explicitly set
         let trackOrder = 1;
@@ -80907,7 +81780,7 @@ class Browser {
     }
 
     minimumBases() {
-        return this.config.minimumBases
+        return this.config.minimumBases ?? 40
     }
 
     // Zoom in by a factor of 2, keeping the same center location
@@ -81278,11 +82151,6 @@ class Browser {
         }
 
         json["reference"] = this.genome.toJSON();
-        if (json.reference.fastaURL instanceof File) {   // Test specifically for File.  Other types of File-like objects might be savable) {
-            throw new Error(`Error. Sessions cannot include local file references ${json.reference.fastaURL.name}.`)
-        } else if (json.reference.indexURL instanceof File) {   // Test specifically for File.  Other types of File-like objects might be savable) {
-            throw new Error(`Error. Sessions cannot include local file references ${json.reference.indexURL.name}.`)
-        }
 
         // Build locus array (multi-locus view).  Use the first track to extract the loci, any track could be used.
         const locus = [];
@@ -81323,9 +82191,9 @@ class Browser {
 
                 let config;
                 if (typeof track.getState === "function") {
-                    config = TrackBase.localFileInspection(track.getState());
+                    config = TrackBase.prepareConfigForSession(track.getState());
                 } else if (track.config) {
-                    config = TrackBase.localFileInspection(track.config);
+                    config = TrackBase.prepareConfigForSession(track.config);
                 }
 
                 if (config) {
@@ -81356,37 +82224,214 @@ class Browser {
 
         json["tracks"] = trackJson;
 
-        const localFileDetections = [];
-        for (const json of trackJson) {
-            for (const key of Object.keys(json)) {
-                if ('file' === key || 'indexFile' === key) {
-                    localFileDetections.push(json[key]);
-                }
+        // Sample info
+        if (this.config.sampleinfo) {
+            json["sampleinfo"] = this.config.sampleinfo;
+        }
+
+        // Validate reference genome and warn about problematic resources
+        this._validateAndWarnResources(json);
+
+        return json
+    }
+
+    /**
+     * Get a display identifier for a Google Drive file.
+     * Returns the provided filename if available, otherwise falls back to a default string.
+     * Note: Filenames should always be present in saved sessions since Google Drive files
+     * can only be added when the user is authenticated.
+     *
+     * @param {string|undefined} filename - The filename property from the config (e.g., config.filename or config.indexFilename)
+     * @param {string} defaultFallback - Default identifier to use if filename is not provided
+     * @returns {string} A display identifier (filename or fallback string)
+     * @private
+     */
+    #getGoogleDriveDisplayName(filename, defaultFallback = 'Google Drive file') {
+        return filename || defaultFallback
+    }
+
+    /**
+     * Check if a config has a Google Drive URL and create a Google Drive item if found.
+     *
+     * @param {Object} config - Track configuration object
+     * @param {string} trackName - Name of the track
+     * @param {string} urlField - Field name to check ('url' or 'indexURL')
+     * @param {string} filenameField - Field name for filename ('filename' or 'indexFilename')
+     * @param {string} defaultFileName - Default filename if not found
+     * @returns {Object|null} Google Drive item object or null if not a Google Drive URL
+     * @private
+     */
+    #createGoogleDriveItemIfPresent(config, trackName, urlField, filenameField, defaultFileName) {
+        const url = config[urlField];
+        if (url && isGoogleDriveURL(url)) {
+            const fileName = this.#getGoogleDriveDisplayName(config[filenameField], defaultFileName);
+            return {
+                trackName: trackName,
+                fileName: fileName
             }
         }
+        return null
+    }
 
-        // Sample info
-        const localSampleInfoFileDetections = [];
-        if (this.config.sampleinfo) {
+    /**
+     * Extract Google Drive items from a track configuration (checks both url and indexURL).
+     *
+     * @param {Object} config - Track configuration object
+     * @returns {Array} Array of Google Drive items found in this config
+     * @private
+     */
+    #extractGoogleDriveItemsFromConfig(config) {
+        const items = [];
+        const trackName = config.name || 'Unnamed track';
 
-            json["sampleinfo"] = this.config.sampleinfo;
+        // Check main file URL
+        const mainItem = this.#createGoogleDriveItemIfPresent(config, trackName, 'url', 'filename', 'Google Drive file');
+        if (mainItem) {
+            items.push(mainItem);
+        }
+
+        // Check index file URL
+        const indexItem = this.#createGoogleDriveItemIfPresent(config, `${trackName} index`, 'indexURL', 'indexFilename', 'Google Drive index file');
+        if (indexItem) {
+            items.push(indexItem);
+        }
+
+        return items
+    }
+
+    /**
+     * Extract problematic resources (local files and Google Drive files) from track configurations.
+     * Google Drive files are detected by checking if the url/indexURL fields contain Google Drive URLs,
+     * using the isGoogleDriveURL helper function from sessionResourceValidator.
+     *
+     * @param {Array} trackConfigurations - Array of track configuration objects
+     * @param {Array} localSampleInfoFiles - Array of local sample info filenames
+     * @param {Array} googleDriveSampleInfoFiles - Array of Google Drive sample info items (objects with trackName and fileName)
+     * @returns {{localFileItems: Array, googleDriveItems: Array}} Object containing arrays of problematic resources
+     * @private
+     */
+    #extractProblematicResources(trackConfigurations, localSampleInfoFiles = [], googleDriveSampleInfoFiles = []) {
+        const localFileItems = [];
+        const googleDriveItems = [];
+
+        // Collect local files from track configurations
+        for (const config of trackConfigurations) {
+            const trackName = config.name || 'Unnamed track';
+            if (config.file) {
+                localFileItems.push({
+                    trackName: trackName,
+                    fileName: config.file
+                });
+            }
+            if (config.indexFile) {
+                localFileItems.push({
+                    trackName: `${trackName} index`,
+                    fileName: config.indexFile
+                });
+            }
+        }
+
+        // Add sample info local files
+        for (const fileName of localSampleInfoFiles) {
+            localFileItems.push({
+                trackName: 'Sample info',
+                fileName: fileName
+            });
+        }
+
+        // Collect Google Drive files by checking if url/indexURL fields contain Google Drive URLs
+        for (const config of trackConfigurations) {
+            const items = this.#extractGoogleDriveItemsFromConfig(config);
+            googleDriveItems.push(...items);
+        }
+
+        // Add sample info Google Drive files
+        googleDriveItems.push(...googleDriveSampleInfoFiles);
+
+        return { localFileItems, googleDriveItems }
+    }
+
+    /**
+     * Validate reference genome and warn about problematic resources in the session.
+     *
+     * Reference genome: Throws error if local files or Google Drive URLs are detected
+     * Tracks/Sample Info: Shows warning if local files or Google Drive URLs are detected
+     *
+     * @param {Object} json - The session JSON object
+     * @private
+     */
+    _validateAndWarnResources(json) {
+        // 1. Validate reference genome (blocking errors)
+        const refErrors = [];
+
+        if (json.reference.fastaURL) {
+            if (isLocalFile(json.reference.fastaURL)) {
+                refErrors.push(`Local file: ${json.reference.fastaURL.name}`);
+            } else if (isGoogleDriveURL(json.reference.fastaURL)) {
+                refErrors.push(`Google Drive URL: ${json.reference.fastaURL}`);
+            }
+        }
+
+        if (json.reference.indexURL) {
+            if (isLocalFile(json.reference.indexURL)) {
+                refErrors.push(`Local file: ${json.reference.indexURL.name}`);
+            } else if (isGoogleDriveURL(json.reference.indexURL)) {
+                refErrors.push(`Google Drive URL: ${json.reference.indexURL}`);
+            }
+        }
+
+        if (refErrors.length > 0) {
+            throw new Error(
+                `Error: Sessions cannot include the following resources in the reference genome:\n` +
+                refErrors.map(err => `  - ${err}`).join('\n') + '\n' +
+                `These resources require local access or authentication and will not work when the session is shared.`
+            )
+        }
+
+        // 2. Collect warnings from tracks and sample info
+        const localSampleInfoFiles = [];
+        const googleDriveSampleInfoFiles = [];
 
+        // Check sample info
+        if (this.config.sampleinfo) {
             for (const path of this.sampleInfo.sampleInfoFiles) {
-                const config = TrackBase.localFileInspection({url: path});
+                const config = TrackBase.prepareConfigForSession({url: path});
                 if (config.file) {
-                    localSampleInfoFileDetections.push(config.file);
+                    localSampleInfoFiles.push(config.file);
+                }
+                // Check if the url field contains a Google Drive URL
+                const googleDriveItem = this.#createGoogleDriveItemIfPresent(config, 'Sample info', 'url', 'filename', 'Google Drive file');
+                if (googleDriveItem) {
+                    googleDriveSampleInfoFiles.push(googleDriveItem);
                 }
-            }
-            if (localSampleInfoFileDetections.length > 0) {
-                localFileDetections.push(...localSampleInfoFileDetections);
             }
         }
 
-        if (localFileDetections.length > 0) {
-            alert(`This session includes reference(s) to local file(s):\n${localFileDetections.map(str => `    ${str}`).join('\n')}\nLocal files cannot be loaded automatically when a saved session is restored.`);
-        }
+        // Extract problematic resources from tracks
+        const { localFileItems, googleDriveItems } = this.#extractProblematicResources(
+            json.tracks || [],
+            localSampleInfoFiles,
+            googleDriveSampleInfoFiles
+        );
 
-        return json
+        // 3. Display consolidated warning if any issues found
+        if (localFileItems.length > 0 || googleDriveItems.length > 0) {
+            let message = 'Local and Google Drive files cannot be loaded automatically when a saved session is restored. This session saves references to the following file(s) that will not be restored.\n\n';
+
+            // Add local file items
+            for (const item of localFileItems) {
+                message += `Local file name: ${item.fileName}\n`;
+                message += `Track name: ${item.trackName}\n\n`;
+            }
+
+            // Add Google Drive items
+            for (const item of googleDriveItems) {
+                message += `Google Drive file name: ${item.fileName}\n`;
+                message += `Track name: ${item.trackName}\n\n`;
+            }
+
+            alert(message);
+        }
     }
 
     compressedSession() {
@@ -81890,6 +82935,281 @@ toggleTrackLabels(trackViews, isVisible) {
     }
 }
 
+/**
+ * Handles incoming messages from the WebSocket connection.  Performs requested actions on the IGV browser instance
+ * and returns a response message.
+ *
+ * @param json
+ * @param browser
+ * @returns {Promise<{uniqueID, message: string, status: string}>}
+ */
+
+
+async function handleMessage(json, browser) {
+
+    const returnMsg = {uniqueID: json.uniqueID, status: 'ok'};
+
+    try {
+        let tracks;
+        const {type, args} = json;
+        switch (type.toLowerCase()) {
+
+            case "goto":
+            case "search":
+                const term = args.locus || args.term;
+                const found = await browser.search(term);
+                if (found) {
+                    returnMsg.message = `Locus ${term} found and navigated to successfully`;
+                } else {
+                    returnMsg.message = `Locus ${term} not found`;
+                    returnMsg.status = 'warning';
+                }
+                break
+
+            case "currentloci":
+                returnMsg.data = browser.currentLoci();
+                returnMsg.message = `Retrieved current loci successfully`;
+                break
+
+            case "visibilityChange":
+                returnMsg.message = await browser.visibilityChange();
+                break
+
+            case "tojson":
+                returnMsg.data = browser.toJSON();
+                returnMsg.message = `Session serialized to JSON successfully`;
+                break
+
+            case "compressedsession":
+                returnMsg.data = browser.compressedSession();
+                returnMsg.message = `Session serialized and compressed successfully`;
+                break
+
+            case "tosvg":
+                returnMsg.data = browser.toSVG();
+                returnMsg.message = `Session exported to SVG successfully`;
+                break
+
+            case "removetrackbyname": {
+                let {trackName} = args;
+                if(trackName) {
+                    tracks = browser.findTracks(t => trackName ? t.name === trackName : true);
+                    if (tracks) {
+                        tracks.forEach(t => browser.removeTrack(t));
+                        returnMsg.message = `Removed track(s) ${trackName} for ${tracks.length} track(s)`;
+                    } else {
+                        returnMsg.message = `No tracks found matching name ${trackName}`;
+                        returnMsg.status = 'warning';
+                    }
+                } else {
+                    returnMsg.message = `No track name provided`;
+                    returnMsg.status = 'warning';
+                }
+                break
+            }
+
+            case "loadsampleinfo": {
+                browser.loadSampleInfo(args);
+                returnMsg.message = `Sample info loaded successfully`;
+                break
+            }
+
+            case "discardsampleinfo":
+                browser.discardSampleInfo();
+                returnMsg.message = `Sample info discarded successfully`;
+                break
+
+            case "loadroi":
+                browser.loadROI(args);
+                returnMsg.message = `ROI loaded successfully`;
+                break
+
+            case "clearrois":
+                browser.clearROIs();
+                returnMsg.message = `ROIs cleared successfully`;
+                break
+
+            case "getuserdefinedrois":
+                const rois = await browser.getUserDefinedROIs();
+                returnMsg.data = rois;
+                returnMsg.message = `Retrieved ${rois.length} user-defined ROIs successfully`;
+                break
+
+            case 'loadtrack': {
+                const {url, indexURL} = args;
+                const track = await browser.loadTrack({url, indexURL});
+                returnMsg.message = `Track ${track.name} loaded successfully`;
+                break
+            }
+
+            case "genome":
+                const id = args.id;
+                await browser.loadGenome(id);
+                returnMsg.message = `Genome ${id} loaded successfully`;
+                break
+
+            case "loadsession":
+                const url = args.url;
+                await browser.loadSession({url});
+                returnMsg.message = `Session loaded successfully from ${url}`;
+                break
+
+            case "zoomin":
+                await browser.zoomIn();
+                returnMsg.message = `Zoomed in successfully`;
+                break
+
+            case "zoomout":
+                await browser.zoomOut();
+                returnMsg.message = `Zoomed out successfully`;
+                break
+
+            case "setcolor":
+
+                let {color, trackName} = args;
+
+                if (color.includes(",") && !color.startsWith("rgb(")) {
+                    // Convert "R,G,B" to "rgb(R,G,B)"
+                    color = `rgb(${color})`;
+                }
+
+                tracks = browser.findTracks(t => trackName ? t.name === trackName : true);
+                if (tracks) {
+                    tracks.forEach(t => t.color = color);
+                    browser.repaintViews();
+                    returnMsg.message = `Set color to ${color} for ${tracks.length} track(s)`;
+                } else {
+                    returnMsg.message = `No tracks found matching name ${trackName}`;
+                    returnMsg.status = 'warning';
+                }
+                break
+
+            case "renametrack":
+
+                const {currentName, newName} = args;
+
+                tracks = browser.findTracks(t => currentName === t.name);
+                if (tracks && tracks.length > 0) {
+                    tracks.forEach(t => {
+                        t.name = newName;
+                        browser.fireEvent('tracknamechange', [t]);
+                    });
+                    returnMsg.message = `Renamed ${tracks.length} track(s) from ${currentName} to ${newName}`;
+                } else {
+                    returnMsg.message = `No track found with name ${currentName}`;
+                    returnMsg.status = 'warning';
+                }
+                break
+
+            default:
+                returnMsg.message = `Unrecognized message type: ${type}`;
+                returnMsg.status = 'error';
+        }
+    } catch (err) {
+        returnMsg.message = err?.message || String(err);
+        returnMsg.status = 'error';
+    }
+
+    return returnMsg
+}
+
+/**
+ * Create a WebSocket client that connects to a server and handles messages.  The client attempts to connect to a
+ * WebSocketServer upon creation.  If the connection is not successful or lost, it will attempt to reconnect with an
+ * exponential backoff strategy.  Incoming messages are expected to be JSON formatted and are processed by the
+ * handleMessage function.  Messages encompass a subset of the igv.js API
+ *
+ * This client was created to interact with an MCP server, but could be used for other purposes.
+ *
+ * @param host Host for the WebSocket server
+ * @param port Port for the WebSocket server
+ * @param browser The igv.js browser instance
+ */
+
+function createWebSocketClient(host, port, browser) {
+
+    let socket;
+    let retryInterval = 1000;    // Initial retry interval in ms
+    const maxRetryInterval = 10000; // Maximum retry interval in ms
+    let reconnectTimer;
+    let intentionalClose = false; // Flag to prevent reconnection on intentional close
+
+    function connect() {
+
+        const isLocal = host === 'localhost' || host === '127.0.0.1';
+        const protocol = window.location.protocol === 'https:' && !isLocal ? 'wss:' : 'ws:';
+        socket = new WebSocket(`${protocol}//${host}:${port}`);
+
+        //  helper to safely send
+        const sendJSON = (obj) => {
+            if (socket.readyState === WebSocket.OPEN) {
+                socket.send(JSON.stringify(obj));
+            }
+        };
+
+        socket.addEventListener('open', function (event) {
+            retryInterval = 1000; // Reset retry interval on successful connection
+            sendJSON({message: 'Hello from browser client'});
+        });
+
+        // Listen for incoming messages
+        socket.addEventListener('message', async function (event) {
+            try {
+                const json = JSON.parse(event.data);
+
+                if("close" === json.type) {
+                    intentionalClose = true;
+                    clearTimeout(reconnectTimer);
+                    if (socket && socket.readyState === WebSocket.OPEN) {
+                        socket.close();
+                    }
+                    return
+                }
+
+                const returnMsg = await handleMessage(json, browser);
+                sendJSON(returnMsg);
+
+            } catch (e) {
+                if (e instanceof SyntaxError) {
+                    console.warn('Received non-JSON message from server:', event.data);
+                } else {
+                    console.error('Error handling message:', e);
+                    sendJSON({
+                        status: 'error',
+                        message: `Error handling message: ${e.message || e.toString()}`
+                    });
+                }
+            }
+        });
+
+        socket.addEventListener('error', function (event) {
+            console.error('WebSocket error:', event);
+            // The 'close' event will fire immediately after 'error', triggering the reconnect logic.
+        });
+
+        socket.addEventListener('close', function (event) {
+            if (intentionalClose) {
+                console.log('WebSocket closed intentionally. Not reconnecting.');
+                return
+            }
+            console.log('Disconnected from server. Retrying in ' + (retryInterval / 1000) + ' seconds.');
+            clearTimeout(reconnectTimer);
+            reconnectTimer = setTimeout(connect, retryInterval);
+            // Increase retry interval for next time, up to a max
+            retryInterval = Math.min(maxRetryInterval, retryInterval * 2);
+        });
+    }
+
+    connect(); // Initial connection attempt
+
+    window.addEventListener('beforeunload', function (event) {
+        clearTimeout(reconnectTimer); // Don't try to reconnect when page is closing
+        if (socket && socket.readyState === WebSocket.OPEN) {
+            socket.close();
+        }
+    });
+}
+
 let allBrowsers = [];
 
 /**
@@ -81947,8 +83267,13 @@ async function createBrowser(parentDiv, config) {
 
     browser.navbar.navbarDidResize();
 
-    return browser
+    if(config.enableWebSocket) {
+        const host = config.webSocketHost || "localhost";
+        const port = config.webSocketPort || 60141;
+        createWebSocketClient(host, port, browser);
+    }
 
+    return browser
 }
 
 function removeBrowser(browser) {
@@ -82141,7 +83466,8 @@ var index = {
     loadSessionFile: Browser.loadSessionFile,
     loadHub,
     uncompressSession: Browser.uncompressSession,
-    createIcon
+    createIcon,
+    createWebSocketClient
 };
 
 export { index as default };