igv 3.6.0 → 3.7.1

package/dist/igv.js

@@ -8453,7 +8453,7 @@
    function isGoogleURL(url) {
         return (url.includes("googleapis") && !url.includes("urlshortener")) ||
             isGoogleStorageURL(url) ||
-            isGoogleDriveURL(url);
+            isGoogleDriveURL$1(url);
     }
 
     function isGoogleStorageURL(url) {
@@ -8463,7 +8463,7 @@
             url.startsWith("https://storage.googleapis.com");
     }
 
-    function isGoogleDriveURL(url) {
+    function isGoogleDriveURL$1(url) {
         return url.startsWith("https://www.googleapis.com/drive/v3/files");
     }
 
@@ -8616,7 +8616,7 @@
    // })
 
    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"
@@ -8835,7 +8835,7 @@
                        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)
                        })
@@ -8859,7 +8859,7 @@
            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 {
@@ -8878,7 +8878,7 @@
                    }
                    url = addApiKey(url);
 
-                   if (isGoogleDriveURL(url)) {
+                   if (isGoogleDriveURL$1(url)) {
                        addTeamDrive(url);
                    }
 
@@ -12408,7 +12408,7 @@
        complements.set(p2.toLowerCase(), p1.toLowerCase());
    }
 
-   function complementBase(base) {
+   function complementBase$1(base) {
        return complements.has(base) ? complements.get(base) : base
    }
 
@@ -16993,6 +16993,35 @@
        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("))) ?
@@ -17617,7 +17646,20 @@
            }
        }
 
-       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 =
@@ -17626,8 +17668,9 @@
                    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];
                }
@@ -17637,8 +17680,6 @@
        }
 
        // Methods to support filtering api
-
-
        set filter(f) {
            this._filter = f;
            this.trackView.repaintViews();
@@ -35106,14 +35147,21 @@
        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;
 
    /**
@@ -35362,8 +35410,8 @@
        };
 
        const phase = getExonPhase(exon);
-       let ss = getEonStart(exon);
-       let ee = getExonEnd(exon);
+       let ss = getCodingStart(exon);
+       let ee = getCodingEnd(exon);
 
        let bpTripletStart;
        let bpTripletEnd;
@@ -35532,7 +35580,7 @@
                    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) {
@@ -35551,7 +35599,7 @@
                }
 
                const ritePhase = getExonPhase(riteExon);
-               const riteStart = getEonStart(riteExon);
+               const riteStart = getCodingStart(riteExon);
                stringB = sequenceInterval.getSequence(riteStart, riteStart + ritePhase);
 
                if (!stringB) {
@@ -35571,7 +35619,7 @@
                    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) {
@@ -35591,7 +35639,7 @@
                }
 
                const leftPhase = getExonPhase(leftExon);
-               const leftEnd = getExonEnd(leftExon);
+               const leftEnd = getCodingEnd(leftExon);
                stringA = sequenceInterval.getSequence(leftEnd - leftPhase, leftEnd);
 
                if (!stringA) {
@@ -39019,7 +39067,7 @@
 
                    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
@@ -40795,9 +40843,9 @@
 
                        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) {
@@ -40962,7 +41010,7 @@
 
        }
 
-       handleTrackClick(event) {
+       async handleTrackClick(event) {
 
            const clickState = this.createClickState(event);
 
@@ -40971,7 +41019,7 @@
            }
 
            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]);
 
@@ -44209,7 +44257,7 @@
                        track.autoscaleGroup = name;
                    }
                    track.isMergedTrack = false;
-                   browser.addTrack(track);
+                   await browser.addTrack(track);
                }
                await browser.updateViews();
                browser.reorderTracks();
@@ -44295,7 +44343,7 @@
 
            const mouseClickHandler = () => {
                this.setVisibility(false);
-               trackOverlayClickHandler.call(this);
+               this.trackOverlayClickHandler();
            };
 
            this.boundMouseClickHandler = mouseClickHandler.bind(this);
@@ -44305,50 +44353,49 @@
            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) {
@@ -47441,7 +47488,7 @@
            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() {
@@ -47491,7 +47538,7 @@
            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);
        }
 
@@ -48924,6 +48971,818 @@
        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;
@@ -49058,13 +49917,22 @@
            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) {
@@ -49083,6 +49951,26 @@
 
            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/>');
@@ -49158,7 +50046,7 @@
 
            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();
@@ -51363,8 +52251,8 @@
            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);
@@ -53685,7 +54573,7 @@
            highlightColor: undefined,
            minTLEN: undefined,
            maxTLEN: undefined,
-           tagColorPallete: "Set1",
+           tagColorPallete: "Set1"
        }
 
        _colorTables = new Map()
@@ -54035,7 +54923,7 @@
 
                        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
@@ -54044,7 +54932,7 @@
                            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
                            });
                        }
                    }
@@ -54087,7 +54975,7 @@
                            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;
@@ -54257,7 +55145,7 @@
                                        height: alignmentHeight
                                    },
                                    baseColor,
-                                   readChar,
+                                   readChar
                                });
                            }
 
@@ -54267,13 +55155,28 @@
                    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
@@ -55046,7 +55949,7 @@
                            this.colorTable = new PaletteColorTable(this.tagColorPallete);
                        }
                        color = this.colorTable.getColor(tagValue);
-                       
+
                    }
                    break
            }
@@ -55203,7 +56106,7 @@
 
 
                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) ?
@@ -55236,7 +56139,7 @@
 
    const DEFAULT_COVERAGE_COLOR = "rgb(150, 150, 150)";
 
-   class CoverageTrack  {
+   class CoverageTrack {
 
 
        constructor(config, parent) {
@@ -55248,7 +56151,7 @@
            this.top = 0;
 
            this.autoscale = config.autoscale || config.max === undefined;
-           if(config.coverageColor) {
+           if (config.coverageColor) {
                this.color = config.coverageColor;
            }
 
@@ -55265,11 +56168,15 @@
            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
@@ -55303,7 +56210,8 @@
                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);
@@ -55372,8 +56280,9 @@
            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()
@@ -55381,60 +56290,64 @@
            }
        }
 
-       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 {
@@ -72366,39 +73279,6 @@ ${indent}columns: ${matrix.columns}
        '*': '#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
     * {
@@ -72425,6 +73305,13 @@ ${indent}columns: ${matrix.columns}
 
        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");
@@ -72450,12 +73337,12 @@ ${indent}columns: ${matrix.columns}
 
                // 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()
 
                    };
                }
@@ -72580,110 +73467,6 @@ ${indent}columns: ${matrix.columns}
 
    }
 
-   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) {
@@ -75699,7 +76482,7 @@ ${indent}columns: ${matrix.columns}
        })
    }
 
-   const _version = "3.6.0";
+   const _version = "3.7.1";
    function version() {
        return _version
    }
@@ -78711,7 +79494,7 @@ ${indent}columns: ${matrix.columns}
            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) {
@@ -78719,8 +79502,8 @@ ${indent}columns: ${matrix.columns}
                }
            }
 
-               // 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) {
@@ -78756,7 +79539,7 @@ ${indent}columns: ${matrix.columns}
                    // 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);
@@ -79000,6 +79783,75 @@ ${indent}columns: ${matrix.columns}
        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);
+           }
+       }
    }
 
    /**
@@ -79817,10 +80669,7 @@ ${indent}columns: ${matrix.columns}
 
            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;
            }
@@ -79834,7 +80683,7 @@ ${indent}columns: ${matrix.columns}
         * @param options
         * @returns {Promise<*|XMLSession>}
         */
-       static async loadSessionFile(options, defaults) {
+       static async loadSessionFile(options) {
 
            const urlOrFile = options.url || options.file;
 
@@ -79863,7 +80712,7 @@ ${indent}columns: ${matrix.columns}
                    config = await igvxhr.loadJson(urlOrFile);
                }
            }
-           setDefaults(config, defaults);
+
            return config
        }
 
@@ -79874,6 +80723,9 @@ ${indent}columns: ${matrix.columns}
         */
        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;
@@ -79978,16 +80830,19 @@ ${indent}columns: ${matrix.columns}
 
            // 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);
+                       }
                    }
                }
            }
@@ -80002,22 +80857,40 @@ ${indent}columns: ${matrix.columns}
                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;
@@ -80913,7 +81786,7 @@ ${indent}columns: ${matrix.columns}
        }
 
        minimumBases() {
-           return this.config.minimumBases
+           return this.config.minimumBases ?? 40
        }
 
        // Zoom in by a factor of 2, keeping the same center location
@@ -81284,11 +82157,6 @@ ${indent}columns: ${matrix.columns}
            }
 
            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 = [];
@@ -81329,9 +82197,9 @@ ${indent}columns: ${matrix.columns}
 
                    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) {
@@ -81362,37 +82230,214 @@ ${indent}columns: ${matrix.columns}
 
            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() {
@@ -81896,6 +82941,281 @@ ${indent}columns: ${matrix.columns}
        }
    }
 
+   /**
+    * 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 = [];
 
    /**
@@ -81953,8 +83273,13 @@ ${indent}columns: ${matrix.columns}
 
        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) {
@@ -82147,7 +83472,8 @@ ${indent}columns: ${matrix.columns}
        loadSessionFile: Browser.loadSessionFile,
        loadHub,
        uncompressSession: Browser.uncompressSession,
-       createIcon
+       createIcon,
+       createWebSocketClient
    };
 
    return index;