gramene-search 2.0.2 → 2.0.4

package/dist/index.js

@@ -31,6 +31,7 @@ var $gXNCa$reacticonsai = require("react-icons/ai");
 var $gXNCa$gramenesearchvis = require("gramene-search-vis");
 var $gXNCa$numeral = require("numeral");
 var $gXNCa$firebaseauth = require("firebase/auth");
+var $gXNCa$d3 = require("d3");
 
 
 function $parcel$defineInteropFlag(a) {
@@ -1420,12 +1421,6 @@ const $24971af0a229e0e3$var$grameneViews = {
                     show: 'off',
                     shouldScroll: false
                 },
-                {
-                    id: 'userLists',
-                    name: 'User Gene Lists',
-                    show: 'off',
-                    shouldScroll: false
-                },
                 {
                     id: 'taxonomy',
                     name: 'Taxonomic distribution',
@@ -1439,15 +1434,14 @@ const $24971af0a229e0e3$var$grameneViews = {
                     shouldScroll: false
                 },
                 {
-                    id: 'expression',
-                    name: 'Gene expression',
+                    id: 'exprViz',
+                    name: 'Expression visualization',
                     show: 'off',
-                    shouldScroll: false,
-                    desiredSamples: {}
+                    shouldScroll: false
                 },
                 {
-                    id: 'attribs',
-                    name: 'Gene attributes',
+                    id: 'userLists',
+                    name: 'User Gene Lists',
                     show: 'off',
                     shouldScroll: false
                 },
@@ -1456,6 +1450,19 @@ const $24971af0a229e0e3$var$grameneViews = {
                     name: 'Data exporter',
                     show: 'off',
                     shouldScroll: false
+                },
+                {
+                    id: 'expression',
+                    name: 'Gene expression',
+                    show: 'off',
+                    shouldScroll: false,
+                    desiredSamples: {}
+                },
+                {
+                    id: 'attribs',
+                    name: 'Gene attributes',
+                    show: 'off',
+                    shouldScroll: false
                 }
             ],
             touched: {}
@@ -3831,6 +3838,574 @@ const $c921a0d2b34aadb6$var$ontologies = {
 var $c921a0d2b34aadb6$export$2e2bcd8739ae039 = $c921a0d2b34aadb6$var$ontologies;
 
 
+
+// State shape:
+// {
+//   pivot: { status, signature, data: { [taxon_id]: <gene count> }, error, requestId },
+//   activeTaxon: <taxon_id|null>,
+//   byTaxon: {
+//     [taxon_id]: {
+//       selectedFields: [<solr field name>...],
+//       fieldsModalOpen: <bool>,
+//       fetch: { status, offset, total, signature, requestId, error },
+//       rows: [<doc>...]
+//     }
+//   }
+// }
+// Per-taxon study lists are derived in the view layer from expressionStudies.
+const $4f15cd8a7d970b18$var$PAGE_SIZE = 200;
+let $4f15cd8a7d970b18$var$pivotPendingId = 0;
+const $4f15cd8a7d970b18$var$fetchPending = {}; // per-taxon request id
+const $4f15cd8a7d970b18$var$attrsPending = {}; // per-taxon request id for available attrs
+const $4f15cd8a7d970b18$var$existencePending = {}; // per-taxon request id for field-existence check
+function $4f15cd8a7d970b18$var$pivotSignature(store) {
+    const q = store.selectGrameneFiltersQueryString();
+    const g = store.selectGrameneGenomes();
+    const m = store.selectGrameneMaps() || {};
+    const taxa = Object.keys(g.active || {}).filter((tid)=>m[tid] && !m[tid].hidden);
+    return `${q}|${taxa.sort().join(',')}`;
+}
+function $4f15cd8a7d970b18$var$fetchSignature(store, taxon) {
+    const q = store.selectGrameneFiltersQueryString();
+    const ev = store.selectExprViz();
+    const sel = ev.byTaxon[taxon] && ev.byTaxon[taxon].selectedFields || [];
+    return `${q}|${taxon}|${sel.slice().sort().join(',')}`;
+}
+const $4f15cd8a7d970b18$var$ALWAYS_FL = [
+    'id',
+    'name',
+    'system_name',
+    'taxon_id'
+];
+const $4f15cd8a7d970b18$var$exprViz = {
+    name: 'exprViz',
+    getReducer: ()=>{
+        const initialState = {
+            pivot: {
+                status: 'idle',
+                signature: null,
+                data: {},
+                error: null,
+                requestId: 0
+            },
+            activeTaxon: null,
+            byTaxon: {}
+        };
+        function ensureTaxon(state, taxon) {
+            if (state.byTaxon[taxon]) return state.byTaxon[taxon];
+            return {
+                selectedFields: [],
+                fieldsModalOpen: false,
+                fetch: {
+                    status: 'idle',
+                    offset: 0,
+                    total: 0,
+                    signature: null,
+                    requestId: 0,
+                    error: null
+                },
+                rows: [],
+                availableAttrs: null,
+                attrsSignature: null,
+                attrsRequestId: 0,
+                fieldExistence: null,
+                existenceStatus: 'idle',
+                existenceSignature: null,
+                existenceRequestId: 0
+            };
+        }
+        return (state = initialState, { type: type, payload: payload })=>{
+            switch(type){
+                case 'EXPRVIZ_PIVOT_STARTED':
+                    return {
+                        ...state,
+                        pivot: {
+                            status: 'loading',
+                            signature: payload.signature,
+                            data: state.pivot.data,
+                            error: null,
+                            requestId: payload.requestId
+                        }
+                    };
+                case 'EXPRVIZ_PIVOT_SUCCEEDED':
+                    if (payload.requestId !== state.pivot.requestId) return state;
+                    return {
+                        ...state,
+                        pivot: {
+                            status: 'ready',
+                            signature: state.pivot.signature,
+                            data: payload.data,
+                            error: null,
+                            requestId: payload.requestId
+                        }
+                    };
+                case 'EXPRVIZ_PIVOT_FAILED':
+                    if (payload.requestId !== state.pivot.requestId) return state;
+                    return {
+                        ...state,
+                        pivot: {
+                            ...state.pivot,
+                            status: 'error',
+                            error: payload.error
+                        }
+                    };
+                case 'EXPRVIZ_ACTIVE_TAXON_SET':
+                    return {
+                        ...state,
+                        activeTaxon: payload
+                    };
+                case 'EXPRVIZ_FIELDS_MODAL_TOGGLED':
+                    {
+                        const t = ensureTaxon(state, payload.taxon);
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    fieldsModalOpen: payload.open
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_FIELDS_SET':
+                    {
+                        const t = ensureTaxon(state, payload.taxon);
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    selectedFields: payload.fields,
+                                    rows: [],
+                                    fetch: {
+                                        status: 'idle',
+                                        offset: 0,
+                                        total: 0,
+                                        signature: null,
+                                        requestId: 0,
+                                        error: null
+                                    }
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_FIELDS_REORDERED':
+                    {
+                        const t = state.byTaxon[payload.taxon];
+                        if (!t) return state;
+                        // Same set of fields — preserve rows; only the column/axis order changes.
+                        const setA = new Set(t.selectedFields);
+                        const setB = new Set(payload.fields);
+                        if (setA.size !== setB.size || ![
+                            ...setA
+                        ].every((f)=>setB.has(f))) return state;
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    selectedFields: payload.fields
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_FETCH_STARTED':
+                    {
+                        const t = ensureTaxon(state, payload.taxon);
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    fetch: {
+                                        ...t.fetch,
+                                        status: 'loading',
+                                        signature: payload.signature,
+                                        requestId: payload.requestId,
+                                        error: null
+                                    }
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_FETCH_BATCH':
+                    {
+                        const t = state.byTaxon[payload.taxon];
+                        if (!t || payload.requestId !== t.fetch.requestId) return state;
+                        const rows = t.rows.concat(payload.docs);
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    rows: rows,
+                                    fetch: {
+                                        ...t.fetch,
+                                        offset: rows.length,
+                                        total: payload.total,
+                                        status: rows.length >= payload.total ? 'done' : 'loading'
+                                    }
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_FETCH_FAILED':
+                    {
+                        const t = state.byTaxon[payload.taxon];
+                        if (!t || payload.requestId !== t.fetch.requestId) return state;
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    fetch: {
+                                        ...t.fetch,
+                                        status: 'error',
+                                        error: payload.error
+                                    }
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_ATTRS_STARTED':
+                    {
+                        const t = ensureTaxon(state, payload.taxon);
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    attrsRequestId: payload.requestId,
+                                    attrsSignature: payload.signature
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_ATTRS_SUCCEEDED':
+                    {
+                        const t = state.byTaxon[payload.taxon];
+                        if (!t || payload.requestId !== t.attrsRequestId) return state;
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    availableAttrs: payload.attrs
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_EXISTENCE_STARTED':
+                    {
+                        const t = ensureTaxon(state, payload.taxon);
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    existenceStatus: 'loading',
+                                    existenceRequestId: payload.requestId,
+                                    existenceSignature: payload.signature
+                                }
+                            }
+                        };
+                    }
+                case 'EXPRVIZ_EXISTENCE_SUCCEEDED':
+                    {
+                        const t = state.byTaxon[payload.taxon];
+                        if (!t || payload.requestId !== t.existenceRequestId) return state;
+                        return {
+                            ...state,
+                            byTaxon: {
+                                ...state.byTaxon,
+                                [payload.taxon]: {
+                                    ...t,
+                                    existenceStatus: 'ready',
+                                    fieldExistence: payload.counts
+                                }
+                            }
+                        };
+                    }
+                case 'GRAMENE_SEARCH_CLEARED':
+                    {
+                        // Search context changed — invalidate pivot and any loaded rows.
+                        // Selected fields are kept so the user can re-run the load.
+                        const newByTaxon = {};
+                        for (const tid of Object.keys(state.byTaxon))newByTaxon[tid] = {
+                            ...state.byTaxon[tid],
+                            rows: [],
+                            fetch: {
+                                status: 'idle',
+                                offset: 0,
+                                total: 0,
+                                signature: null,
+                                requestId: 0,
+                                error: null
+                            },
+                            availableAttrs: null,
+                            attrsSignature: null,
+                            fieldExistence: null,
+                            existenceStatus: 'idle',
+                            existenceSignature: null
+                        };
+                        return {
+                            ...state,
+                            pivot: {
+                                status: 'idle',
+                                signature: null,
+                                data: {},
+                                error: null,
+                                requestId: 0
+                            },
+                            byTaxon: newByTaxon
+                        };
+                    }
+                default:
+                    return state;
+            }
+        };
+    },
+    doFetchExprVizPivot: ()=>({ dispatch: dispatch, store: store })=>{
+            const requestId = ++$4f15cd8a7d970b18$var$pivotPendingId;
+            const signature = $4f15cd8a7d970b18$var$pivotSignature(store);
+            dispatch({
+                type: 'EXPRVIZ_PIVOT_STARTED',
+                payload: {
+                    requestId: requestId,
+                    signature: signature
+                }
+            });
+            const api = store.selectGrameneAPI();
+            const q = store.selectGrameneFiltersQueryString();
+            const g = store.selectGrameneGenomes();
+            const m = store.selectGrameneMaps() || {};
+            const taxa = Object.keys(g.active || {}).filter((tid)=>m[tid] && !m[tid].hidden);
+            const fq = taxa.length ? `&fq=taxon_id:(${taxa.join(' OR ')})` : '';
+            const facetField = "{!facet.limit='300' facet.mincount='1' key='taxon_id'}taxon_id";
+            const url = `${api}/search?q=${q}${fq}&fq=expressed_in_gxa_attr_ss:*&rows=0&facet=true&facet.field=${facetField}`;
+            fetch(url).then((r)=>r.json()).then((json)=>{
+                const arr = json && json.facet_counts && json.facet_counts.facet_fields && json.facet_counts.facet_fields.taxon_id || [];
+                const data = {};
+                for(let i = 0; i < arr.length; i += 2)data[arr[i]] = arr[i + 1];
+                if (Object.keys(data).length === 0) console.warn('[exprViz] no taxon_ids found with expression', {
+                    url: url,
+                    json: json
+                });
+                dispatch({
+                    type: 'EXPRVIZ_PIVOT_SUCCEEDED',
+                    payload: {
+                        requestId: requestId,
+                        data: data
+                    }
+                });
+            }).catch((err)=>{
+                dispatch({
+                    type: 'EXPRVIZ_PIVOT_FAILED',
+                    payload: {
+                        requestId: requestId,
+                        error: String(err)
+                    }
+                });
+            });
+        },
+    doSetExprVizActiveTaxon: (tid)=>({ dispatch: dispatch })=>dispatch({
+                type: 'EXPRVIZ_ACTIVE_TAXON_SET',
+                payload: tid
+            }),
+    doToggleExprVizFieldsModal: (taxon, open)=>({ dispatch: dispatch, store: store })=>{
+            dispatch({
+                type: 'EXPRVIZ_FIELDS_MODAL_TOGGLED',
+                payload: {
+                    taxon: taxon,
+                    open: !!open
+                }
+            });
+            if (open) store.doFetchExprVizAvailableAttrs(taxon);
+        },
+    doFetchExprVizAvailableAttrs: (taxon)=>({ dispatch: dispatch, store: store })=>{
+            const q = store.selectGrameneFiltersQueryString();
+            const signature = `${q}|${taxon}`;
+            const ev = store.selectExprViz();
+            const t = ev.byTaxon[taxon];
+            if (t && t.availableAttrs && t.attrsSignature === signature) return;
+            const requestId = $4f15cd8a7d970b18$var$attrsPending[taxon] = ($4f15cd8a7d970b18$var$attrsPending[taxon] || 0) + 1;
+            dispatch({
+                type: 'EXPRVIZ_ATTRS_STARTED',
+                payload: {
+                    taxon: taxon,
+                    requestId: requestId,
+                    signature: signature
+                }
+            });
+            const api = store.selectGrameneAPI();
+            const facetField = "{!facet.limit='2000' facet.mincount='1' key='attrs'}expressed_in_gxa_attr_ss";
+            const url = `${api}/search?q=${q}&fq=taxon_id:${taxon}&fq=expressed_in_gxa_attr_ss:*&rows=0&facet=true&facet.field=${facetField}`;
+            fetch(url).then((r)=>r.json()).then((json)=>{
+                if (requestId !== $4f15cd8a7d970b18$var$attrsPending[taxon]) return;
+                const arr = json && json.facet_counts && json.facet_counts.facet_fields && json.facet_counts.facet_fields.attrs || [];
+                const attrs = [];
+                for(let i = 0; i < arr.length; i += 2)attrs.push(arr[i]);
+                dispatch({
+                    type: 'EXPRVIZ_ATTRS_SUCCEEDED',
+                    payload: {
+                        taxon: taxon,
+                        requestId: requestId,
+                        attrs: attrs
+                    }
+                });
+            }).catch(()=>{});
+        },
+    doSetExprVizFields: (taxon, fields)=>({ dispatch: dispatch })=>dispatch({
+                type: 'EXPRVIZ_FIELDS_SET',
+                payload: {
+                    taxon: taxon,
+                    fields: fields
+                }
+            }),
+    doReorderExprVizFields: (taxon, fields)=>({ dispatch: dispatch })=>dispatch({
+                type: 'EXPRVIZ_FIELDS_REORDERED',
+                payload: {
+                    taxon: taxon,
+                    fields: fields
+                }
+            }),
+    doFetchExprVizData: (taxon)=>({ dispatch: dispatch, store: store })=>{
+            const ev = store.selectExprViz();
+            const t = ev.byTaxon[taxon];
+            if (!t || t.selectedFields.length === 0) return;
+            const requestId = $4f15cd8a7d970b18$var$fetchPending[taxon] = ($4f15cd8a7d970b18$var$fetchPending[taxon] || 0) + 1;
+            const signature = $4f15cd8a7d970b18$var$fetchSignature(store, taxon);
+            dispatch({
+                type: 'EXPRVIZ_FETCH_STARTED',
+                payload: {
+                    taxon: taxon,
+                    requestId: requestId,
+                    signature: signature
+                }
+            });
+            const api = store.selectGrameneAPI();
+            const q = store.selectGrameneFiltersQueryString();
+            const fl = [
+                ...new Set([
+                    ...$4f15cd8a7d970b18$var$ALWAYS_FL,
+                    ...t.selectedFields
+                ])
+            ].join(',');
+            const fetchPage = (offset)=>{
+                if (requestId !== $4f15cd8a7d970b18$var$fetchPending[taxon]) return; // superseded
+                const url = `${api}/search?q=${q}&fq=taxon_id:${taxon}&fl=${fl}&rows=${$4f15cd8a7d970b18$var$PAGE_SIZE}&start=${offset}`;
+                fetch(url).then((r)=>r.json()).then((json)=>{
+                    if (requestId !== $4f15cd8a7d970b18$var$fetchPending[taxon]) return;
+                    const docs = json.response && json.response.docs || [];
+                    const total = json.response && json.response.numFound || 0;
+                    dispatch({
+                        type: 'EXPRVIZ_FETCH_BATCH',
+                        payload: {
+                            taxon: taxon,
+                            requestId: requestId,
+                            docs: docs,
+                            total: total
+                        }
+                    });
+                    const next = offset + docs.length;
+                    if (docs.length > 0 && next < total) fetchPage(next);
+                }).catch((err)=>{
+                    dispatch({
+                        type: 'EXPRVIZ_FETCH_FAILED',
+                        payload: {
+                            taxon: taxon,
+                            requestId: requestId,
+                            error: String(err)
+                        }
+                    });
+                });
+            };
+            fetchPage(0);
+        },
+    // Per-candidate-field non-null counts under the current q + taxon. Used by
+    // FieldsModal to hide fields that have no data in the current result set
+    // before the user picks. Uses stats.field (the swagger whitelist drops
+    // facet.query) batched across multiple GETs to stay under URL limits.
+    doFetchExprVizFieldExistence: (taxon, fields)=>({ dispatch: dispatch, store: store })=>{
+            if (!fields || fields.length === 0) return;
+            const q = store.selectGrameneFiltersQueryString();
+            const fieldsKey = fields.slice().sort().join(',');
+            const signature = `${q}|${taxon}|${fieldsKey}`;
+            const ev = store.selectExprViz();
+            const t = ev.byTaxon[taxon];
+            if (t && t.fieldExistence && t.existenceSignature === signature) return;
+            const requestId = $4f15cd8a7d970b18$var$existencePending[taxon] = ($4f15cd8a7d970b18$var$existencePending[taxon] || 0) + 1;
+            dispatch({
+                type: 'EXPRVIZ_EXISTENCE_STARTED',
+                payload: {
+                    taxon: taxon,
+                    requestId: requestId,
+                    signature: signature
+                }
+            });
+            const api = store.selectGrameneAPI();
+            const BATCH_SIZE = 40;
+            const batches = [];
+            for(let i = 0; i < fields.length; i += BATCH_SIZE)batches.push(fields.slice(i, i + BATCH_SIZE));
+            Promise.all(batches.map((batch)=>{
+                const params = new URLSearchParams();
+                params.append('q', q);
+                params.append('fq', `taxon_id:${taxon}`);
+                params.append('rows', '0');
+                params.append('stats', 'true');
+                batch.forEach((f)=>params.append('stats.field', f));
+                return fetch(`${api}/search?${params.toString()}`).then((r)=>r.json()).then((json)=>{
+                    const sf = json && json.stats && json.stats.stats_fields || {};
+                    const out = {};
+                    for (const f of Object.keys(sf)){
+                        const s = sf[f];
+                        out[f] = s && typeof s.count === 'number' ? s.count : 0;
+                    }
+                    return out;
+                });
+            })).then((results)=>{
+                if (requestId !== $4f15cd8a7d970b18$var$existencePending[taxon]) return;
+                const counts = Object.assign({}, ...results);
+                dispatch({
+                    type: 'EXPRVIZ_EXISTENCE_SUCCEEDED',
+                    payload: {
+                        taxon: taxon,
+                        requestId: requestId,
+                        counts: counts
+                    }
+                });
+            }).catch(()=>{});
+        },
+    reactExprVizPivot: (0, $gXNCa$reduxbundler.createSelector)('selectExprViz', 'selectGrameneFiltersStatus', 'selectGrameneViews', 'selectGrameneFiltersQueryString', 'selectGrameneGenomes', 'selectGrameneMaps', (ev, filtersStatus, views, q, g, m)=>{
+        if (!ev || filtersStatus === 'init') return;
+        const onView = views && views.options && views.options.find((v)=>v.id === 'exprViz');
+        if (!onView || onView.show !== 'on') return;
+        const maps = m || {};
+        const taxa = Object.keys(g && g.active || {}).filter((tid)=>maps[tid] && !maps[tid].hidden);
+        const sig = `${q}|${taxa.sort().join(',')}`;
+        if (ev.pivot.status === 'loading') return;
+        if (ev.pivot.signature === sig && ev.pivot.status === 'ready') return;
+        return {
+            actionCreator: 'doFetchExprVizPivot'
+        };
+    }),
+    selectExprViz: (state)=>state.exprViz,
+    selectExprVizPivot: (state)=>state.exprViz.pivot,
+    selectExprVizActiveTaxon: (state)=>state.exprViz.activeTaxon,
+    selectExprVizByTaxon: (state)=>state.exprViz.byTaxon
+};
+var $4f15cd8a7d970b18$export$2e2bcd8739ae039 = $4f15cd8a7d970b18$var$exprViz;
+
+
 var $5df6c55c1bef3469$export$2e2bcd8739ae039 = [
     ...(0, $9d9aeaf9299e61a1$export$2e2bcd8739ae039),
     (0, $671312b287158a8a$export$2e2bcd8739ae039),
@@ -3839,7 +4414,8 @@ var $5df6c55c1bef3469$export$2e2bcd8739ae039 = [
     (0, $0d54502f6cafe273$export$2e2bcd8739ae039),
     (0, $0f839422d0d8c772$export$2e2bcd8739ae039),
     (0, $1508f5a42be6e7b5$export$2e2bcd8739ae039),
-    (0, $c921a0d2b34aadb6$export$2e2bcd8739ae039)
+    (0, $c921a0d2b34aadb6$export$2e2bcd8739ae039),
+    (0, $4f15cd8a7d970b18$export$2e2bcd8739ae039)
 ];
 
 
@@ -10203,6 +10779,1438 @@ var $37b3bb0145d266b0$export$2e2bcd8739ae039 = (0, $gXNCa$reduxbundlerreact.conn
 
 
 
+
+function $4d0c2e01f58b53b1$var$speciesTaxonId(tid) {
+    const n = +tid;
+    return n > 1000000 ? Math.floor(n / 1000) : n;
+}
+const $4d0c2e01f58b53b1$var$EXPERIMENT_KEYS = [
+    {
+        key: 'exp:study',
+        label: 'Study'
+    },
+    {
+        key: 'exp:type',
+        label: 'Study type'
+    },
+    {
+        key: 'exp:organism',
+        label: 'Organism'
+    }
+];
+// One record per expression field (one sample group within one study).
+// `props` is a flat map of property-key → value used for filtering and display.
+function $4d0c2e01f58b53b1$var$buildFieldRecords(taxon, studyIds, expressionStudies, expressionSamples, fieldCatalog, grameneMaps) {
+    const records = [];
+    const factorTypes = new Set();
+    const charTypes = new Set();
+    if (!expressionSamples || !expressionStudies) return {
+        records: records,
+        factorTypes: [],
+        charTypes: []
+    };
+    const studyById = {};
+    const list = expressionStudies[taxon] || expressionStudies[$4d0c2e01f58b53b1$var$speciesTaxonId(taxon)] || [];
+    list.forEach((s)=>{
+        studyById[s._id] = s;
+    });
+    for (const studyId of studyIds){
+        const study = studyById[studyId];
+        if (!study) continue;
+        const samples = expressionSamples[studyId];
+        if (!samples) continue;
+        const byGroup = {};
+        for (const s of samples)if (!byGroup[s.group]) byGroup[s.group] = s;
+        for (const group of Object.keys(byGroup)){
+            const sample = byGroup[group];
+            const fieldName = `${studyId.replace(/-/g, '_')}_${group}__expr`;
+            if (fieldCatalog && fieldCatalog.fields && !fieldCatalog.fields[fieldName]) continue;
+            const props = {};
+            props['exp:study'] = study.description || studyId;
+            props['exp:type'] = study.type || '(unknown)';
+            const taxon_id = study.taxon_id;
+            const taxName = grameneMaps && (grameneMaps[taxon_id] || grameneMaps[$4d0c2e01f58b53b1$var$speciesTaxonId(taxon_id)]);
+            props['exp:organism'] = taxName && taxName.display_name || String(taxon_id);
+            const usedFactorTypes = new Set();
+            (sample.factor || []).forEach((f)=>{
+                props[`fac:${f.type}`] = f.label;
+                factorTypes.add(f.type);
+                usedFactorTypes.add(f.type);
+            });
+            (sample.characteristic || []).forEach((c)=>{
+                if (usedFactorTypes.has(c.type)) return; // factor takes precedence
+                props[`char:${c.type}`] = c.label;
+                charTypes.add(c.type);
+            });
+            records.push({
+                fieldName: fieldName,
+                studyId: studyId,
+                group: group,
+                props: props
+            });
+        }
+    }
+    return {
+        records: records,
+        factorTypes: Array.from(factorTypes).sort(),
+        charTypes: Array.from(charTypes).sort()
+    };
+}
+function $4d0c2e01f58b53b1$var$fieldMatches(field, selections, excludeKey) {
+    for (const key of Object.keys(selections)){
+        if (key === excludeKey) continue;
+        const values = selections[key];
+        if (!values || values.size === 0) continue;
+        const v = field.props[key];
+        if (v == null || !values.has(v)) return false;
+    }
+    return true;
+}
+function $4d0c2e01f58b53b1$var$valueCounts(records, key, selections) {
+    const counts = new Map();
+    for (const f of records){
+        if (!$4d0c2e01f58b53b1$var$fieldMatches(f, selections, key)) continue;
+        const v = f.props[key];
+        if (v == null) continue;
+        counts.set(v, (counts.get(v) || 0) + 1);
+    }
+    return counts;
+}
+function $4d0c2e01f58b53b1$var$labelForKey(key, tree) {
+    for (const grp of tree){
+        for (const t of grp.types)if (t.key === key) return t.label;
+    }
+    return key;
+}
+const $4d0c2e01f58b53b1$var$FieldsModalCmp = (props)=>{
+    const { fieldCatalog: fieldCatalog, exprViz: exprViz, expressionStudies: expressionStudies, expressionSamples: expressionSamples, grameneMaps: grameneMaps, doToggleExprVizFieldsModal: doToggleExprVizFieldsModal, doSetExprVizFields: doSetExprVizFields, doFetchExprVizFieldExistence: doFetchExprVizFieldExistence } = props;
+    const taxon = Object.keys(exprViz.byTaxon).find((t)=>exprViz.byTaxon[t].fieldsModalOpen);
+    const open = !!taxon;
+    const availableAttrs = taxon && exprViz.byTaxon[taxon] && exprViz.byTaxon[taxon].availableAttrs;
+    const studyIds = (0, $gXNCa$react.useMemo)(()=>{
+        if (!taxon || !expressionStudies) return [];
+        const list = expressionStudies[taxon] || expressionStudies[$4d0c2e01f58b53b1$var$speciesTaxonId(taxon)] || [];
+        let ids = list.map((s)=>s._id);
+        if (availableAttrs) {
+            const allow = new Set(availableAttrs);
+            ids = ids.filter((id)=>allow.has(id));
+        }
+        return ids;
+    }, [
+        taxon,
+        expressionStudies,
+        availableAttrs
+    ]);
+    const allRecords = (0, $gXNCa$react.useMemo)(()=>$4d0c2e01f58b53b1$var$buildFieldRecords(taxon, studyIds, expressionStudies, expressionSamples, fieldCatalog, grameneMaps), [
+        taxon,
+        studyIds,
+        expressionStudies,
+        expressionSamples,
+        fieldCatalog,
+        grameneMaps
+    ]);
+    const candidateFields = (0, $gXNCa$react.useMemo)(()=>allRecords.records.map((r)=>r.fieldName), [
+        allRecords
+    ]);
+    // Trigger the field-existence facet check whenever the modal is open and
+    // the candidate field list is known. The bundle caches per (q, taxon, fields).
+    (0, $gXNCa$react.useEffect)(()=>{
+        if (open && taxon && candidateFields.length > 0) doFetchExprVizFieldExistence(taxon, candidateFields);
+    }, [
+        open,
+        taxon,
+        candidateFields,
+        doFetchExprVizFieldExistence
+    ]);
+    const fieldExistence = taxon && exprViz.byTaxon[taxon] && exprViz.byTaxon[taxon].fieldExistence;
+    const existenceStatus = taxon && exprViz.byTaxon[taxon] && exprViz.byTaxon[taxon].existenceStatus;
+    // Once existence counts are loaded, drop fields with no data in the current
+    // result set. Until then, render with the full candidate set so the modal
+    // doesn't flash empty during the precheck.
+    const { records: records, factorTypes: factorTypes, charTypes: charTypes } = (0, $gXNCa$react.useMemo)(()=>{
+        if (!fieldExistence) return allRecords;
+        const live = new Set(Object.keys(fieldExistence).filter((f)=>fieldExistence[f] > 0));
+        const filtered = allRecords.records.filter((r)=>live.has(r.fieldName));
+        const factorTypes = new Set();
+        const charTypes = new Set();
+        for (const r of filtered)for (const k of Object.keys(r.props)){
+            if (k.startsWith('fac:')) factorTypes.add(k.slice(4));
+            else if (k.startsWith('char:')) charTypes.add(k.slice(5));
+        }
+        return {
+            records: filtered,
+            factorTypes: Array.from(factorTypes).sort(),
+            charTypes: Array.from(charTypes).sort()
+        };
+    }, [
+        allRecords,
+        fieldExistence
+    ]);
+    const propTree = (0, $gXNCa$react.useMemo)(()=>[
+            {
+                group: 'experiment',
+                label: 'Experiment',
+                types: $4d0c2e01f58b53b1$var$EXPERIMENT_KEYS
+            },
+            {
+                group: 'factors',
+                label: 'Factors',
+                types: factorTypes.map((t)=>({
+                        key: `fac:${t}`,
+                        label: t
+                    }))
+            },
+            {
+                group: 'characteristics',
+                label: 'Characteristics',
+                types: charTypes.map((t)=>({
+                        key: `char:${t}`,
+                        label: t
+                    }))
+            }
+        ], [
+        factorTypes,
+        charTypes
+    ]);
+    const [selections, setSelections] = (0, $gXNCa$react.useState)({});
+    const [expandedKey, setExpandedKey] = (0, $gXNCa$react.useState)(null);
+    const [collapsedGroups, setCollapsedGroups] = (0, $gXNCa$react.useState)({});
+    const [valueSort, setValueSort] = (0, $gXNCa$react.useState)('count');
+    const [orderedSelectedKeys, setOrderedSelectedKeys] = (0, $gXNCa$react.useState)([]);
+    const [searchQuery, setSearchQuery] = (0, $gXNCa$react.useState)('');
+    const searchLc = searchQuery.trim().toLowerCase();
+    const isSearching = searchLc.length > 0;
+    // Distinct values per property type, ignoring the type's own selection but
+    // applying every other selected type. Counts shown next to a property type
+    // reflect "how many distinct values exist among the fields currently
+    // matching the rest of the filter."
+    const valueSetByKey = (0, $gXNCa$react.useMemo)(()=>{
+        const allKeys = new Set();
+        for (const r of records)for (const k of Object.keys(r.props))allKeys.add(k);
+        const m = {};
+        for (const key of allKeys){
+            const set = new Set();
+            for (const r of records){
+                if (!$4d0c2e01f58b53b1$var$fieldMatches(r, selections, key)) continue;
+                const v = r.props[key];
+                if (v != null) set.add(v);
+            }
+            m[key] = set;
+        }
+        return m;
+    }, [
+        records,
+        selections
+    ]);
+    // Reset state when modal (re)opens for a taxon.
+    (0, $gXNCa$react.useEffect)(()=>{
+        if (open && taxon) {
+            setSelections({});
+            setExpandedKey(null);
+            setCollapsedGroups({});
+            setOrderedSelectedKeys([]);
+            setSearchQuery('');
+        }
+    }, [
+        open,
+        taxon
+    ]);
+    // Keep orderedSelectedKeys in sync with selections (preserves the order in
+    // which the user first selected each property type).
+    (0, $gXNCa$react.useEffect)(()=>{
+        setOrderedSelectedKeys((prev)=>{
+            const active = Object.keys(selections);
+            const activeSet = new Set(active);
+            const kept = prev.filter((k)=>activeSet.has(k));
+            const newOnes = active.filter((k)=>!prev.includes(k));
+            return [
+                ...kept,
+                ...newOnes
+            ];
+        });
+    }, [
+        selections
+    ]);
+    const matchingFields = (0, $gXNCa$react.useMemo)(()=>records.filter((r)=>$4d0c2e01f58b53b1$var$fieldMatches(r, selections, null)), [
+        records,
+        selections
+    ]);
+    if (!open) return null;
+    const toggleValue = (key, value)=>{
+        setSelections((prev)=>{
+            const next = {
+                ...prev
+            };
+            const set = new Set(next[key] || []);
+            if (set.has(value)) set.delete(value);
+            else set.add(value);
+            if (set.size === 0) delete next[key];
+            else next[key] = set;
+            return next;
+        });
+    };
+    const clearTypeSelection = (key)=>{
+        setSelections((prev)=>{
+            if (!prev[key]) return prev;
+            const next = {
+                ...prev
+            };
+            delete next[key];
+            return next;
+        });
+    };
+    const toggleGroup = (g)=>setCollapsedGroups((prev)=>({
+                ...prev,
+                [g]: !prev[g]
+            }));
+    const renderValues = (key, typeLabelMatches)=>{
+        const counts = $4d0c2e01f58b53b1$var$valueCounts(records, key, selections);
+        let entries = Array.from(counts.entries());
+        if (isSearching && !typeLabelMatches) entries = entries.filter(([v])=>String(v).toLowerCase().includes(searchLc));
+        if (valueSort === 'name') entries.sort((a, b)=>String(a[0]).localeCompare(String(b[0])));
+        else entries.sort((a, b)=>b[1] - a[1] || String(a[0]).localeCompare(String(b[0])));
+        const sel = selections[key] || new Set();
+        return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+            className: "exprviz-tree-values",
+            children: [
+                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                    className: "exprviz-values-toolbar",
+                    children: [
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.ToggleButtonGroup), {
+                            type: "radio",
+                            name: `exprviz-vsort-${key}`,
+                            size: "sm",
+                            value: valueSort,
+                            onChange: setValueSort,
+                            children: [
+                                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.ToggleButton), {
+                                    id: `exprviz-vsort-name-${key}`,
+                                    value: "name",
+                                    variant: "outline-secondary",
+                                    children: "Name"
+                                }),
+                                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.ToggleButton), {
+                                    id: `exprviz-vsort-count-${key}`,
+                                    value: "count",
+                                    variant: "outline-secondary",
+                                    children: "Count"
+                                })
+                            ]
+                        }),
+                        sel.size > 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                            size: "sm",
+                            variant: "link",
+                            onClick: ()=>clearTypeSelection(key),
+                            children: "clear"
+                        })
+                    ]
+                }),
+                entries.map(([v, c])=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("label", {
+                        className: "exprviz-tree-value",
+                        children: [
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("input", {
+                                type: "checkbox",
+                                checked: sel.has(v),
+                                onChange: ()=>toggleValue(key, v)
+                            }),
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                                className: "exprviz-tree-value-label",
+                                title: v,
+                                children: v
+                            }),
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                                className: "exprviz-tree-value-count",
+                                children: c
+                            })
+                        ]
+                    }, v)),
+                entries.length === 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("em", {
+                    className: "exprviz-tree-empty",
+                    children: "No values"
+                })
+            ]
+        });
+    };
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Modal), {
+        show: open,
+        onHide: ()=>doToggleExprVizFieldsModal(taxon, false),
+        size: "xl",
+        scrollable: true,
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Modal).Header, {
+                closeButton: true,
+                children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Modal).Title, {
+                    children: [
+                        "Filter expression fields (",
+                        matchingFields.length,
+                        " of ",
+                        records.length,
+                        " match)",
+                        existenceStatus === 'loading' && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                            className: "exprviz-modal-loading",
+                            children: " \xb7 checking field availability\u2026"
+                        })
+                    ]
+                })
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Modal).Body, {
+                children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                    className: "exprviz-fields-layout",
+                    children: [
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                            className: "exprviz-tree",
+                            children: [
+                                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("input", {
+                                    type: "text",
+                                    className: "exprviz-tree-search",
+                                    placeholder: "Search property types and values\u2026",
+                                    value: searchQuery,
+                                    onChange: (e)=>setSearchQuery(e.target.value)
+                                }),
+                                propTree.map((grp)=>{
+                                    const typeRows = grp.types.map((t)=>{
+                                        const numValues = valueSetByKey[t.key] && valueSetByKey[t.key].size || 0;
+                                        if (numValues === 0) return null;
+                                        const typeLabelMatches = isSearching && t.label.toLowerCase().includes(searchLc);
+                                        let matchingValueCount = numValues;
+                                        if (isSearching && !typeLabelMatches) {
+                                            const vset = valueSetByKey[t.key] || new Set();
+                                            matchingValueCount = 0;
+                                            for (const v of vset)if (String(v).toLowerCase().includes(searchLc)) matchingValueCount++;
+                                            if (matchingValueCount === 0) return null;
+                                        }
+                                        const sel = selections[t.key];
+                                        const selCount = sel ? sel.size : 0;
+                                        const isExpanded = isSearching ? !typeLabelMatches : expandedKey === t.key;
+                                        return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                                            className: `exprviz-tree-type${selCount > 0 ? ' is-active' : ''}`,
+                                            children: [
+                                                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                                                    className: "exprviz-tree-type-header",
+                                                    onClick: ()=>setExpandedKey(isExpanded ? null : t.key),
+                                                    children: [
+                                                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                                                            className: "exprviz-tree-caret",
+                                                            children: isExpanded ? "\u25BE" : "\u25B8"
+                                                        }),
+                                                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                                                            className: "exprviz-tree-type-label",
+                                                            children: t.label
+                                                        }),
+                                                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                                                            className: "exprviz-tree-type-count",
+                                                            children: selCount > 0 ? `${selCount}/${numValues}` : numValues
+                                                        })
+                                                    ]
+                                                }),
+                                                isExpanded && renderValues(t.key, typeLabelMatches)
+                                            ]
+                                        }, t.key);
+                                    }).filter(Boolean);
+                                    if (isSearching && typeRows.length === 0) return null;
+                                    const groupCollapsed = !isSearching && collapsedGroups[grp.group];
+                                    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                                        className: "exprviz-tree-group",
+                                        children: [
+                                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                                                className: "exprviz-tree-group-header",
+                                                onClick: ()=>toggleGroup(grp.group),
+                                                children: [
+                                                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                                                        className: "exprviz-tree-caret",
+                                                        children: groupCollapsed ? "\u25B6" : "\u25BC"
+                                                    }),
+                                                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("strong", {
+                                                        children: grp.label
+                                                    })
+                                                ]
+                                            }),
+                                            !groupCollapsed && grp.types.length === 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+                                                className: "exprviz-tree-empty",
+                                                children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("em", {
+                                                    children: "(none)"
+                                                })
+                                            }),
+                                            !groupCollapsed && typeRows
+                                        ]
+                                    }, grp.group);
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+                            className: "exprviz-fields-preview",
+                            children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("table", {
+                                className: "exprviz-fields-table",
+                                children: [
+                                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("thead", {
+                                        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("tr", {
+                                            children: [
+                                                /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("th", {
+                                                    children: "Field"
+                                                }),
+                                                orderedSelectedKeys.map((k)=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("th", {
+                                                        children: $4d0c2e01f58b53b1$var$labelForKey(k, propTree)
+                                                    }, k))
+                                            ]
+                                        })
+                                    }),
+                                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("tbody", {
+                                        children: [
+                                            matchingFields.map((f)=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("tr", {
+                                                    children: [
+                                                        /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("td", {
+                                                            title: f.fieldName,
+                                                            children: f.fieldName.replace(/__expr$/, '')
+                                                        }),
+                                                        orderedSelectedKeys.map((k)=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("td", {
+                                                                children: f.props[k] || ''
+                                                            }, k))
+                                                    ]
+                                                }, f.fieldName)),
+                                            matchingFields.length === 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("tr", {
+                                                children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("td", {
+                                                    colSpan: 1 + orderedSelectedKeys.length,
+                                                    children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("em", {
+                                                        children: "No matching fields"
+                                                    })
+                                                })
+                                            })
+                                        ]
+                                    })
+                                ]
+                            })
+                        })
+                    ]
+                })
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Modal).Footer, {
+                children: [
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        variant: "secondary",
+                        onClick: ()=>doToggleExprVizFieldsModal(taxon, false),
+                        children: "Cancel"
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Button), {
+                        variant: "primary",
+                        disabled: matchingFields.length === 0,
+                        onClick: ()=>{
+                            doSetExprVizFields(taxon, matchingFields.map((f)=>f.fieldName));
+                            doToggleExprVizFieldsModal(taxon, false);
+                        },
+                        children: [
+                            "Apply (",
+                            matchingFields.length,
+                            " fields)"
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+};
+var $4d0c2e01f58b53b1$export$2e2bcd8739ae039 = (0, $gXNCa$reduxbundlerreact.connect)('selectFieldCatalog', 'selectExprViz', 'selectExpressionStudies', 'selectExpressionSamples', 'selectGrameneMaps', 'doToggleExprVizFieldsModal', 'doSetExprVizFields', 'doFetchExprVizFieldExistence', $4d0c2e01f58b53b1$var$FieldsModalCmp);
+
+
+
+
+
+
+
+
+const $4ab64e76c1caef59$var$baseColDefs = [
+    {
+        field: 'id',
+        headerName: 'Gene ID',
+        pinned: 'left',
+        width: 160,
+        suppressMovable: true
+    },
+    {
+        field: 'name',
+        headerName: 'Name',
+        width: 140,
+        suppressMovable: true
+    }
+];
+function $4ab64e76c1caef59$var$arraysEqual(a, b) {
+    if (a.length !== b.length) return false;
+    for(let i = 0; i < a.length; i++)if (a[i] !== b[i]) return false;
+    return true;
+}
+function $4ab64e76c1caef59$var$buildFieldInfo(fields, studies, expressionSamples) {
+    const info = {};
+    if (!fields || !studies || !expressionSamples) return info;
+    const wanted = new Set(fields);
+    for (const study of studies){
+        const studyId = study._id;
+        const samples = expressionSamples[studyId];
+        if (!samples) continue;
+        const byGroup = {};
+        for (const s of samples)if (!byGroup[s.group]) byGroup[s.group] = s;
+        for (const group of Object.keys(byGroup)){
+            const fieldName = `${studyId.replace(/-/g, '_')}_${group}__expr`;
+            if (!wanted.has(fieldName)) continue;
+            const sample = byGroup[group];
+            const factors = {};
+            (sample.factor || []).forEach((f)=>{
+                factors[f.type] = f.label;
+            });
+            const characteristics = {};
+            (sample.characteristic || []).forEach((c)=>{
+                if (factors[c.type] != null) return;
+                characteristics[c.type] = c.label;
+            });
+            info[fieldName] = {
+                studyId: studyId,
+                studyDescription: study.description || studyId,
+                group: group,
+                replicates: samples.filter((s)=>s.group === group).length,
+                factors: factors,
+                characteristics: characteristics
+            };
+        }
+    }
+    return info;
+}
+// Custom header: re-implements sort click + menu button so ag-grid's column
+// drag/menu/filter still work, with an info icon as the popover trigger.
+const $4ab64e76c1caef59$var$HeaderWithInfo = (props)=>{
+    const { displayName: displayName, enableSorting: enableSorting, enableMenu: enableMenu, showColumnMenu: showColumnMenu, progressSort: progressSort, column: column, info: info } = props;
+    const [sort, setSort] = (0, $gXNCa$react.useState)(column && column.getSort ? column.getSort() : null);
+    const menuRef = (0, $gXNCa$react.useRef)(null);
+    (0, $gXNCa$react.useEffect)(()=>{
+        if (!column || !column.addEventListener) return;
+        const handler = ()=>setSort(column.getSort());
+        column.addEventListener('sortChanged', handler);
+        return ()=>column.removeEventListener('sortChanged', handler);
+    }, [
+        column
+    ]);
+    const onSortClick = (event)=>{
+        if (enableSorting && progressSort) progressSort(event.shiftKey);
+    };
+    const onMenuClick = (event)=>{
+        event.stopPropagation();
+        if (showColumnMenu && menuRef.current) showColumnMenu(menuRef.current);
+    };
+    const factorEntries = info ? Object.entries(info.factors || {}) : [];
+    const charEntries = info ? Object.entries(info.characteristics || {}) : [];
+    const popover = info ? /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Popover), {
+        id: `exprviz-header-${info.studyId}-${info.group}`,
+        className: "exprviz-header-popover",
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Popover).Header, {
+                as: "h6",
+                children: info.studyDescription
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Popover).Body, {
+                children: [
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                        children: [
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("strong", {
+                                children: "Study:"
+                            }),
+                            " ",
+                            info.studyId
+                        ]
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                        children: [
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("strong", {
+                                children: "Group:"
+                            }),
+                            " ",
+                            info.group,
+                            " (",
+                            info.replicates,
+                            " ",
+                            info.replicates === 1 ? 'rep' : 'reps',
+                            ")"
+                        ]
+                    }),
+                    factorEntries.length > 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                        className: "exprviz-header-section",
+                        children: [
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("strong", {
+                                children: "Factors"
+                            }),
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("ul", {
+                                children: factorEntries.map(([t, v])=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("li", {
+                                        children: [
+                                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("em", {
+                                                children: [
+                                                    t,
+                                                    ":"
+                                                ]
+                                            }),
+                                            " ",
+                                            v
+                                        ]
+                                    }, t))
+                            })
+                        ]
+                    }),
+                    charEntries.length > 0 && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                        className: "exprviz-header-section",
+                        children: [
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("strong", {
+                                children: "Characteristics"
+                            }),
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("ul", {
+                                children: charEntries.map(([t, v])=>/*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("li", {
+                                        children: [
+                                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("em", {
+                                                children: [
+                                                    t,
+                                                    ":"
+                                                ]
+                                            }),
+                                            " ",
+                                            v
+                                        ]
+                                    }, t))
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    }) : null;
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+        className: "exprviz-header",
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("span", {
+                className: "exprviz-header-text",
+                onClick: onSortClick,
+                style: {
+                    cursor: enableSorting ? 'pointer' : 'default'
+                },
+                children: [
+                    displayName,
+                    sort === 'asc' && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                        className: "exprviz-header-sort",
+                        children: " \u25B2"
+                    }),
+                    sort === 'desc' && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                        className: "exprviz-header-sort",
+                        children: " \u25BC"
+                    })
+                ]
+            }),
+            info && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.OverlayTrigger), {
+                trigger: [
+                    'hover',
+                    'focus'
+                ],
+                placement: "bottom",
+                overlay: popover,
+                delay: {
+                    show: 200,
+                    hide: 100
+                },
+                children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                    className: "exprviz-header-info",
+                    onClick: (e)=>e.stopPropagation(),
+                    onMouseDown: (e)=>e.stopPropagation(),
+                    "aria-label": "More info",
+                    children: "\u24D8"
+                })
+            }),
+            enableMenu && /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("span", {
+                ref: menuRef,
+                className: "exprviz-header-menu ag-icon ag-icon-menu",
+                onClick: onMenuClick
+            })
+        ]
+    });
+};
+const $4ab64e76c1caef59$var$ExprTable = ({ rows: rows, fields: fields, onReorder: onReorder, studies: studies, expressionSamples: expressionSamples, onHoverRow: onHoverRow })=>{
+    const fieldInfo = (0, $gXNCa$react.useMemo)(()=>$4ab64e76c1caef59$var$buildFieldInfo(fields, studies, expressionSamples), [
+        fields,
+        studies,
+        expressionSamples
+    ]);
+    const columnDefs = (0, $gXNCa$react.useMemo)(()=>{
+        const expressionCols = (fields || []).map((f)=>({
+                field: f,
+                headerName: f.replace(/__expr$/, ''),
+                width: 160,
+                suppressMovable: false,
+                headerComponent: $4ab64e76c1caef59$var$HeaderWithInfo,
+                headerComponentParams: {
+                    info: fieldInfo[f]
+                },
+                valueFormatter: (p)=>{
+                    const v = p.value;
+                    if (v == null) return '';
+                    if (Array.isArray(v)) return v.join(', ');
+                    if (typeof v === 'object') return JSON.stringify(v);
+                    return String(v);
+                }
+            }));
+        return [
+            ...$4ab64e76c1caef59$var$baseColDefs,
+            ...expressionCols
+        ];
+    }, [
+        fields,
+        fieldInfo
+    ]);
+    const onColumnMoved = (e)=>{
+        if (!onReorder || !e.finished) return;
+        const allCols = e.api.getAllGridColumns ? e.api.getAllGridColumns() : e.columnApi && e.columnApi.getAllGridColumns && e.columnApi.getAllGridColumns();
+        if (!allCols) return;
+        const next = allCols.map((c)=>c.getColId()).filter((id)=>fields.includes(id));
+        if (!$4ab64e76c1caef59$var$arraysEqual(next, fields)) onReorder(next);
+    };
+    if (!rows || rows.length === 0) return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+        className: "exprviz-table-empty",
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("em", {
+            children: "No data loaded."
+        })
+    });
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+        className: "ag-theme-quartz exprviz-aggrid",
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$aggridreact.AgGridReact), {
+            rowData: rows,
+            columnDefs: columnDefs,
+            defaultColDef: {
+                resizable: true,
+                sortable: true,
+                filter: true
+            },
+            animateRows: false,
+            suppressFieldDotNotation: true,
+            suppressDragLeaveHidesColumns: true,
+            onColumnMoved: onColumnMoved,
+            onCellMouseOver: (e)=>onHoverRow && onHoverRow(e.data && e.data.id),
+            onCellMouseOut: ()=>onHoverRow && onHoverRow(null)
+        })
+    });
+};
+var $4ab64e76c1caef59$export$2e2bcd8739ae039 = $4ab64e76c1caef59$var$ExprTable;
+
+
+
+
+
+// Parallel-coordinates plot with per-axis brushing and drag-to-reorder axes.
+// - Axis labels are draggable horizontally; on drop, onReorder(newOrder) fires.
+// - Brushes on axes intersect (AND): a row is "in" only when every active brush contains it.
+// - Numeric fields use a linear or symlog scale; non-numeric values are skipped.
+const $caf32827df861c4e$var$MARGIN = {
+    top: 100,
+    right: 24,
+    bottom: 24,
+    left: 32
+};
+const $caf32827df861c4e$var$LABEL_ROTATION = -40;
+const $caf32827df861c4e$var$BRUSH_WIDTH = 16;
+function $caf32827df861c4e$var$isNumeric(v) {
+    if (v == null) return false;
+    if (Array.isArray(v)) return false;
+    const n = +v;
+    return Number.isFinite(n);
+}
+function $caf32827df861c4e$var$arraysEqual(a, b) {
+    if (a.length !== b.length) return false;
+    for(let i = 0; i < a.length; i++)if (a[i] !== b[i]) return false;
+    return true;
+}
+// Powers-of-10 tick values spanning [lo, hi]; includes 0 if the range crosses zero.
+// Clamped to |v| >= 0.1 to keep low-magnitude tick labels from overlapping near 0.
+const $caf32827df861c4e$var$MIN_LOG_TICK = 0.1;
+function $caf32827df861c4e$var$logTickValues([lo, hi]) {
+    const ticks = new Set();
+    if (lo <= 0 && hi >= 0) ticks.add(0);
+    if (hi >= $caf32827df861c4e$var$MIN_LOG_TICK) {
+        const start = Math.max(-1, Math.floor(Math.log10(lo > 0 ? lo : $caf32827df861c4e$var$MIN_LOG_TICK)));
+        const end = Math.ceil(Math.log10(hi));
+        for(let p = start; p <= end; p++){
+            const v = Math.pow(10, p);
+            if (v >= $caf32827df861c4e$var$MIN_LOG_TICK && v <= hi) ticks.add(v);
+        }
+    }
+    if (lo <= -$caf32827df861c4e$var$MIN_LOG_TICK) {
+        const start = Math.max(-1, Math.floor(Math.log10(hi < 0 ? -hi : $caf32827df861c4e$var$MIN_LOG_TICK)));
+        const end = Math.ceil(Math.log10(-lo));
+        for(let p = start; p <= end; p++){
+            const v = -Math.pow(10, p);
+            if (-v >= $caf32827df861c4e$var$MIN_LOG_TICK && v >= lo) ticks.add(v);
+        }
+    }
+    return Array.from(ticks).sort((a, b)=>a - b);
+}
+function $caf32827df861c4e$var$logTickFormat(v) {
+    if (v === 0) return '0';
+    const a = Math.abs(v);
+    if (a >= 0.01 && a < 10000) return $gXNCa$d3.format('~g')(v);
+    return $gXNCa$d3.format('.0e')(v);
+}
+const $caf32827df861c4e$var$ParallelCoordsPlot = ({ rows: rows, fields: fields, scale: scale = 'linear', onBrushChange: onBrushChange, onReorder: onReorder, clearVersion: clearVersion = 0, hoveredId: hoveredId = null })=>{
+    const svgRef = (0, $gXNCa$react.useRef)(null);
+    const containerRef = (0, $gXNCa$react.useRef)(null);
+    // selections in data domain: { [field]: [lo, hi] }
+    const selectionsRef = (0, $gXNCa$react.useRef)({});
+    const lastClearRef = (0, $gXNCa$react.useRef)(0);
+    (0, $gXNCa$react.useEffect)(()=>{
+        if (clearVersion !== lastClearRef.current) {
+            selectionsRef.current = {};
+            lastClearRef.current = clearVersion;
+            if (onBrushChange) onBrushChange({});
+        }
+        Object.keys(selectionsRef.current).forEach((f)=>{
+            if (!fields || !fields.includes(f)) delete selectionsRef.current[f];
+        });
+        const svg = $gXNCa$d3.select(svgRef.current);
+        svg.selectAll('*').remove();
+        if (!fields || fields.length === 0 || !rows || rows.length === 0) return;
+        const el = containerRef.current;
+        const width = el && el.clientWidth || 600;
+        const height = el && el.clientHeight || 300;
+        const innerW = width - $caf32827df861c4e$var$MARGIN.left - $caf32827df861c4e$var$MARGIN.right;
+        const innerH = height - $caf32827df861c4e$var$MARGIN.top - $caf32827df861c4e$var$MARGIN.bottom;
+        svg.attr('viewBox', `0 0 ${width} ${height}`);
+        const g = svg.append('g').attr('transform', `translate(${$caf32827df861c4e$var$MARGIN.left},${$caf32827df861c4e$var$MARGIN.top})`);
+        // Mutable order during drag — starts as a copy of fields.
+        let order = fields.slice();
+        const x = $gXNCa$d3.scalePoint().range([
+            0,
+            innerW
+        ]).padding(0.5).domain(order);
+        const yByField = {};
+        let globalExt = null;
+        if (scale === 'log') {
+            const all = [];
+            fields.forEach((f)=>{
+                rows.forEach((r)=>{
+                    const v = r[f];
+                    if ($caf32827df861c4e$var$isNumeric(v)) all.push(+v);
+                });
+            });
+            globalExt = all.length ? $gXNCa$d3.extent(all) : [
+                0,
+                1
+            ];
+        }
+        fields.forEach((f)=>{
+            if (scale === 'log') yByField[f] = $gXNCa$d3.scaleSymlog().domain(globalExt).range([
+                innerH,
+                0
+            ]).nice();
+            else {
+                const vals = rows.map((r)=>r[f]).filter($caf32827df861c4e$var$isNumeric).map(Number);
+                const ext = vals.length ? $gXNCa$d3.extent(vals) : [
+                    0,
+                    1
+                ];
+                yByField[f] = $gXNCa$d3.scaleLinear().domain(ext).range([
+                    innerH,
+                    0
+                ]).nice();
+            }
+        });
+        function pathForRow(row, posOf) {
+            const pts = order.map((f)=>{
+                const v = row[f];
+                if (!$caf32827df861c4e$var$isNumeric(v)) return null;
+                return [
+                    posOf(f),
+                    yByField[f](Number(v))
+                ];
+            });
+            return line(pts);
+        }
+        const line = $gXNCa$d3.line().defined((d)=>d != null && Number.isFinite(d[1])).x((d)=>d[0]).y((d)=>d[1]);
+        const linesG = g.append('g').attr('class', 'exprviz-pc-lines');
+        const paths = linesG.selectAll('path').data(rows).enter().append('path').attr('fill', 'none').attr('stroke', 'steelblue').attr('stroke-width', 1).attr('data-id', (d)=>d && d.id != null ? String(d.id) : null).attr('d', (row)=>pathForRow(row, (f)=>x(f)));
+        function isBrushedIn(row) {
+            for (const f of order){
+                const sel = selectionsRef.current[f];
+                if (!sel) continue;
+                const v = row[f];
+                if (!$caf32827df861c4e$var$isNumeric(v)) return false;
+                const n = Number(v);
+                const [lo, hi] = sel;
+                if (n < lo || n > hi) return false;
+            }
+            return true;
+        }
+        function applyBrushStyles() {
+            const anyActive = Object.keys(selectionsRef.current).length > 0;
+            paths.classed('exprviz-pc-line-in', (d)=>!anyActive || isBrushedIn(d)).classed('exprviz-pc-line-out', (d)=>anyActive && !isBrushedIn(d));
+        }
+        applyBrushStyles();
+        // axis groups, keyed by field name so D3 can match them across reorders
+        const axisG = g.selectAll('.exprviz-pc-axis').data(order, (d)=>d).enter().append('g').attr('class', 'exprviz-pc-axis').attr('transform', (d)=>`translate(${x(d)},0)`);
+        axisG.each(function(f) {
+            const ax = $gXNCa$d3.select(this);
+            const axisGen = $gXNCa$d3.axisLeft(yByField[f]);
+            if (scale === 'log') axisGen.tickValues($caf32827df861c4e$var$logTickValues(yByField[f].domain())).tickFormat($caf32827df861c4e$var$logTickFormat);
+            else axisGen.ticks(5);
+            ax.call(axisGen);
+            const label = ax.append('text').attr('class', 'exprviz-pc-axis-label').attr('x', 4).attr('y', -4).attr('text-anchor', 'start').attr('transform', `rotate(${$caf32827df861c4e$var$LABEL_ROTATION}, 0, -4)`).attr('fill', '#333').style('font-size', '10px').style('cursor', 'grab').text(f.replace(/__expr$/, ''));
+            // hit area for grabbing — sits along the rotated label
+            ax.append('rect').attr('class', 'exprviz-pc-axis-handle').attr('x', 0).attr('y', -11).attr('width', 140).attr('height', 14).attr('transform', `rotate(${$caf32827df861c4e$var$LABEL_ROTATION}, 0, -4)`).attr('fill', 'transparent').style('cursor', 'grab');
+            const brush = $gXNCa$d3.brushY().extent([
+                [
+                    -$caf32827df861c4e$var$BRUSH_WIDTH / 2,
+                    0
+                ],
+                [
+                    $caf32827df861c4e$var$BRUSH_WIDTH / 2,
+                    innerH
+                ]
+            ]).on('brush end', (event)=>{
+                const s = event.selection;
+                if (!s) delete selectionsRef.current[f];
+                else {
+                    const y = yByField[f];
+                    const a = y.invert(s[0]);
+                    const b = y.invert(s[1]);
+                    selectionsRef.current[f] = [
+                        Math.min(a, b),
+                        Math.max(a, b)
+                    ];
+                }
+                applyBrushStyles();
+                // event.sourceEvent is null when brush.move is called programmatically
+                // (e.g. when this effect re-runs and we restore prior selections).
+                // Skipping that case avoids a re-render loop with the parent.
+                if (event.type === 'end' && event.sourceEvent && onBrushChange) onBrushChange({
+                    ...selectionsRef.current
+                });
+            });
+            const brushG = ax.append('g').attr('class', 'exprviz-pc-brush').call(brush);
+            const prior = selectionsRef.current[f];
+            if (prior) {
+                const y = yByField[f];
+                const py0 = y(prior[1]);
+                const py1 = y(prior[0]);
+                if (Number.isFinite(py0) && Number.isFinite(py1)) brushG.call(brush.move, [
+                    py0,
+                    py1
+                ]);
+            }
+        });
+        // Drag-to-reorder: while dragging, only the dragged axis moves and the
+        // line segments connecting to it are recomputed. Other axes stay put.
+        // The new order is computed once at drag end and emitted via onReorder.
+        const drag = $gXNCa$d3.drag().container(function() {
+            return g.node();
+        }).subject(function(event, d) {
+            return {
+                x: x(d),
+                y: 0
+            };
+        }).on('start', function(event, d) {
+            const axNode = this.parentNode;
+            $gXNCa$d3.select(axNode).raise().classed('exprviz-pc-axis-dragging', true);
+            $gXNCa$d3.select(axNode).select('.exprviz-pc-axis-label').style('cursor', 'grabbing');
+            linesG.classed('exprviz-pc-lines-dragging', true);
+        }).on('drag', function(event, d) {
+            const axNode = this.parentNode;
+            const newX = Math.max(0, Math.min(innerW, event.x));
+            $gXNCa$d3.select(axNode).attr('transform', `translate(${newX},0)`);
+            paths.attr('d', (row)=>pathForRow(row, (f)=>f === d ? newX : x(f)));
+        }).on('end', function(event, d) {
+            const axNode = this.parentNode;
+            const newX = Math.max(0, Math.min(innerW, event.x));
+            $gXNCa$d3.select(axNode).classed('exprviz-pc-axis-dragging', false);
+            $gXNCa$d3.select(axNode).select('.exprviz-pc-axis-label').style('cursor', 'grab');
+            linesG.classed('exprviz-pc-lines-dragging', false);
+            const newOrder = order.slice().sort((a, b)=>{
+                const xa = a === d ? newX : x(a);
+                const xb = b === d ? newX : x(b);
+                return xa - xb;
+            });
+            if (onReorder && !$caf32827df861c4e$var$arraysEqual(newOrder, fields)) {
+                // Snap the dragged axis to its target slot for the brief moment
+                // before the parent re-renders with the new order.
+                x.domain(newOrder);
+                $gXNCa$d3.select(axNode).attr('transform', `translate(${x(d)},0)`);
+                paths.attr('d', (row)=>pathForRow(row, (f)=>x(f)));
+                onReorder(newOrder);
+            } else {
+                // No order change — restore the dragged axis to its original slot.
+                $gXNCa$d3.select(axNode).attr('transform', `translate(${x(d)},0)`);
+                paths.attr('d', (row)=>pathForRow(row, (f)=>x(f)));
+            }
+        });
+        axisG.selectAll('.exprviz-pc-axis-label, .exprviz-pc-axis-handle').call(drag);
+    }, [
+        rows,
+        fields,
+        scale,
+        onBrushChange,
+        onReorder,
+        clearVersion
+    ]);
+    // Highlight the polyline matching the hovered row id without rebuilding the
+    // SVG. Raises the highlighted path so it draws above its neighbors.
+    (0, $gXNCa$react.useEffect)(()=>{
+        const svg = $gXNCa$d3.select(svgRef.current);
+        if (svg.empty()) return;
+        const paths = svg.selectAll('.exprviz-pc-lines path');
+        paths.classed('exprviz-pc-line-hover', false);
+        if (hoveredId == null) return;
+        const target = paths.filter(function() {
+            return this.getAttribute('data-id') === String(hoveredId);
+        });
+        target.classed('exprviz-pc-line-hover', true).raise();
+    }, [
+        hoveredId,
+        rows,
+        fields,
+        scale
+    ]);
+    if (!fields || fields.length === 0) return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+        className: "exprviz-plot-empty",
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("em", {
+            children: "Select fields to plot."
+        })
+    });
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+        ref: containerRef,
+        className: "exprviz-pc-container",
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("svg", {
+            ref: svgRef,
+            width: "100%",
+            height: "100%",
+            preserveAspectRatio: "none"
+        })
+    });
+};
+var $caf32827df861c4e$export$2e2bcd8739ae039 = $caf32827df861c4e$var$ParallelCoordsPlot;
+
+
+
+function $1fd2507769d5bd00$var$speciesTaxonId(tid) {
+    const n = +tid;
+    return n > 1000000 ? Math.floor(n / 1000) : n;
+}
+function $1fd2507769d5bd00$var$genomeName(grameneMaps, tid) {
+    if (!grameneMaps) return tid;
+    const direct = grameneMaps[tid];
+    if (direct && direct.display_name) return direct.display_name;
+    const sp = grameneMaps[$1fd2507769d5bd00$var$speciesTaxonId(tid)];
+    if (sp && sp.display_name) return sp.display_name;
+    return tid;
+}
+const $1fd2507769d5bd00$var$ExprVizViewCmp = (props)=>{
+    const { exprVizPivot: pivot, exprViz: exprViz, exprVizActiveTaxon: activeTaxon, grameneMaps: grameneMaps, expressionStudies: expressionStudies, expressionSamples: expressionSamples, doSetExprVizActiveTaxon: doSetExprVizActiveTaxon, doToggleExprVizFieldsModal: doToggleExprVizFieldsModal, doFetchExprVizData: doFetchExprVizData } = props;
+    const studiesFor = (tid)=>{
+        if (!expressionStudies) return [];
+        return expressionStudies[tid] || expressionStudies[$1fd2507769d5bd00$var$speciesTaxonId(tid)] || [];
+    };
+    const taxa = (0, $gXNCa$react.useMemo)(()=>{
+        const ids = Object.keys(pivot.data || {});
+        if (!grameneMaps) return ids;
+        return ids.sort((a, b)=>{
+            const ma = grameneMaps[a] || grameneMaps[$1fd2507769d5bd00$var$speciesTaxonId(a)];
+            const mb = grameneMaps[b] || grameneMaps[$1fd2507769d5bd00$var$speciesTaxonId(b)];
+            return (ma && ma.left_index || 0) - (mb && mb.left_index || 0);
+        });
+    }, [
+        pivot.data,
+        grameneMaps
+    ]);
+    (0, $gXNCa$react.useEffect)(()=>{
+        if (taxa.length === 0) return;
+        if (!activeTaxon || !taxa.includes(String(activeTaxon))) doSetExprVizActiveTaxon(taxa[0]);
+    }, [
+        taxa,
+        activeTaxon,
+        doSetExprVizActiveTaxon
+    ]);
+    if (pivot.status === 'loading') return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+        className: "exprviz-view",
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("em", {
+            children: "Loading studies\u2026"
+        })
+    });
+    if (pivot.status === 'error') return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+        className: "exprviz-view",
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("em", {
+            children: [
+                "Error: ",
+                pivot.error
+            ]
+        })
+    });
+    if (taxa.length === 0) return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+        className: "exprviz-view",
+        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("em", {
+            children: "No expression studies for current results."
+        })
+    });
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+        className: "exprviz-view",
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Tabs), {
+                activeKey: activeTaxon || taxa[0],
+                onSelect: (k)=>doSetExprVizActiveTaxon(k),
+                className: "exprviz-tabs",
+                children: taxa.map((tid)=>{
+                    const studies = studiesFor(tid);
+                    const taxName = $1fd2507769d5bd00$var$genomeName(grameneMaps, tid);
+                    const geneCount = pivot.data[tid] || 0;
+                    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Tab), {
+                        eventKey: tid,
+                        title: `${taxName} (${studies.length} studies \xb7 ${geneCount} genes)`,
+                        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)($1fd2507769d5bd00$var$TaxonPanel, {
+                            taxon: tid,
+                            studies: studies,
+                            expressionSamples: expressionSamples,
+                            tabState: exprViz.byTaxon[tid],
+                            onOpenFields: ()=>doToggleExprVizFieldsModal(tid, true),
+                            onLoad: ()=>doFetchExprVizData(tid),
+                            onReorder: (next)=>props.doReorderExprVizFields(tid, next),
+                            onAddRangeQuery: props.doAddGrameneRangeQuery
+                        })
+                    }, tid);
+                })
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $4d0c2e01f58b53b1$export$2e2bcd8739ae039), {})
+        ]
+    });
+};
+function $1fd2507769d5bd00$var$rowMatchesSelections(row, selections) {
+    for (const f of Object.keys(selections)){
+        const v = row[f];
+        if (v == null || Array.isArray(v)) return false;
+        const n = +v;
+        if (!Number.isFinite(n)) return false;
+        const [lo, hi] = selections[f];
+        if (n < lo || n > hi) return false;
+    }
+    return true;
+}
+function $1fd2507769d5bd00$var$fmt(n) {
+    if (!Number.isFinite(n)) return String(n);
+    const a = Math.abs(n);
+    if (a !== 0 && (a < 0.001 || a >= 1e6)) return n.toExponential(3);
+    return Number(n.toFixed(4)).toString();
+}
+function $1fd2507769d5bd00$var$tsvCell(v) {
+    if (v == null) return '';
+    if (Array.isArray(v)) return v.join(',');
+    const s = typeof v === 'object' ? JSON.stringify(v) : String(v);
+    return s.replace(/[\t\r\n]+/g, ' ');
+}
+function $1fd2507769d5bd00$var$downloadTsv(filename, rows, fields) {
+    const cols = [
+        'id',
+        'name',
+        ...fields
+    ];
+    const headerLabels = [
+        'id',
+        'name',
+        ...fields.map((f)=>f.replace(/__expr$/, ''))
+    ];
+    const lines = [
+        headerLabels.join('\t')
+    ];
+    for (const r of rows)lines.push(cols.map((c)=>$1fd2507769d5bd00$var$tsvCell(r[c])).join('\t'));
+    const blob = new Blob([
+        lines.join('\n') + '\n'
+    ], {
+        type: 'text/tab-separated-values'
+    });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}
+const $1fd2507769d5bd00$var$TaxonPanel = ({ taxon: taxon, studies: studies, expressionSamples: expressionSamples, tabState: tabState, onOpenFields: onOpenFields, onLoad: onLoad, onReorder: onReorder, onAddRangeQuery: onAddRangeQuery })=>{
+    const selected = tabState && tabState.selectedFields || [];
+    const rows = tabState && tabState.rows || [];
+    const fetchInfo = tabState && tabState.fetch || {
+        status: 'idle',
+        total: 0
+    };
+    const [scale, setScale] = (0, $gXNCa$react.useState)('linear');
+    const [selections, setSelections] = (0, $gXNCa$react.useState)({});
+    const [clearVersion, setClearVersion] = (0, $gXNCa$react.useState)(0);
+    const [hoveredId, setHoveredId] = (0, $gXNCa$react.useState)(null);
+    const hasBrush = Object.keys(selections).length > 0;
+    const filteredRows = (0, $gXNCa$react.useMemo)(()=>{
+        if (!hasBrush) return rows;
+        return rows.filter((r)=>$1fd2507769d5bd00$var$rowMatchesSelections(r, selections));
+    }, [
+        rows,
+        selections,
+        hasBrush
+    ]);
+    // Drop fields with no numeric data in the loaded rows so empty axes/columns
+    // don't clutter the visualization. Selected-but-empty fields stay in the
+    // underlying selection so a future load can repopulate them.
+    const visibleFields = (0, $gXNCa$react.useMemo)(()=>{
+        if (rows.length === 0 || selected.length === 0) return selected;
+        return selected.filter((f)=>rows.some((r)=>{
+                const v = r[f];
+                return v != null && !Array.isArray(v) && Number.isFinite(+v);
+            }));
+    }, [
+        rows,
+        selected
+    ]);
+    const handleReorder = onReorder ? (newVisibleOrder)=>{
+        const visibleSet = new Set(newVisibleOrder);
+        const hidden = selected.filter((f)=>!visibleSet.has(f));
+        onReorder([
+            ...newVisibleOrder,
+            ...hidden
+        ]);
+    } : undefined;
+    (0, $gXNCa$react.useEffect)(()=>{
+        if (rows.length === 0 && hasBrush) {
+            setSelections({});
+            setClearVersion((v)=>v + 1);
+        }
+    }, [
+        rows.length,
+        hasBrush
+    ]);
+    return /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+        className: "exprviz-tab-panel",
+        children: [
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                className: "exprviz-toolbar",
+                children: [
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        onClick: onOpenFields,
+                        children: [
+                            "Select fields (",
+                            selected.length,
+                            " selected, ",
+                            studies.length,
+                            " studies)"
+                        ]
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "primary",
+                        disabled: selected.length === 0 || fetchInfo.status === 'loading',
+                        onClick: onLoad,
+                        children: fetchInfo.status === 'loading' ? "Loading\u2026" : 'Load data'
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)((0, $gXNCa$reactbootstrap.ToggleButtonGroup), {
+                        type: "radio",
+                        name: `exprviz-scale-${taxon}`,
+                        size: "sm",
+                        value: scale,
+                        onChange: setScale,
+                        children: [
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.ToggleButton), {
+                                id: `exprviz-scale-${taxon}-lin`,
+                                value: "linear",
+                                variant: "outline-secondary",
+                                children: "Linear"
+                            }),
+                            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.ToggleButton), {
+                                id: `exprviz-scale-${taxon}-log`,
+                                value: "log",
+                                variant: "outline-secondary",
+                                children: "Log"
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "outline-secondary",
+                        disabled: !hasBrush,
+                        onClick: ()=>{
+                            setClearVersion((v)=>v + 1);
+                            setSelections({});
+                        },
+                        children: "Clear brushes"
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "outline-secondary",
+                        disabled: filteredRows.length === 0 || visibleFields.length === 0,
+                        onClick: ()=>$1fd2507769d5bd00$var$downloadTsv(`expression_${taxon}.tsv`, filteredRows, visibleFields),
+                        title: "Download the visible rows and columns as tab-delimited text",
+                        children: "Download TSV"
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $gXNCa$reactbootstrap.Button), {
+                        size: "sm",
+                        variant: "success",
+                        disabled: !hasBrush || !onAddRangeQuery,
+                        onClick: ()=>{
+                            const terms = Object.keys(selections).map((field)=>{
+                                const [lo, hi] = selections[field];
+                                return {
+                                    category: 'Expression',
+                                    name: `${field}: ${$1fd2507769d5bd00$var$fmt(lo)}\u{2013}${$1fd2507769d5bd00$var$fmt(hi)}`,
+                                    fq_field: field,
+                                    fq_value: `[${lo} TO ${hi}]`
+                                };
+                            });
+                            onAddRangeQuery(terms);
+                        },
+                        title: "Add brush ranges as an AND-conjunction filter on the search",
+                        children: "Apply as filter"
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("span", {
+                        className: "exprviz-status",
+                        children: [
+                            hasBrush ? `${filteredRows.length} of ${rows.length}` : rows.length,
+                            fetchInfo.total ? ` / ${fetchInfo.total}` : '',
+                            " genes",
+                            hasBrush ? ' (brushed)' : ' loaded'
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsxs)("div", {
+                className: "exprviz-body",
+                children: [
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+                        className: "exprviz-plot",
+                        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $caf32827df861c4e$export$2e2bcd8739ae039), {
+                            rows: rows,
+                            fields: visibleFields,
+                            scale: scale,
+                            onBrushChange: setSelections,
+                            onReorder: handleReorder,
+                            clearVersion: clearVersion,
+                            hoveredId: hoveredId
+                        })
+                    }),
+                    /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)("div", {
+                        className: "exprviz-table",
+                        children: /*#__PURE__*/ (0, $gXNCa$reactjsxruntime.jsx)((0, $4ab64e76c1caef59$export$2e2bcd8739ae039), {
+                            rows: filteredRows,
+                            fields: visibleFields,
+                            onReorder: handleReorder,
+                            studies: studies,
+                            expressionSamples: expressionSamples,
+                            onHoverRow: setHoveredId
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+var $1fd2507769d5bd00$export$2e2bcd8739ae039 = (0, $gXNCa$reduxbundlerreact.connect)('selectExprViz', 'selectExprVizPivot', 'selectExprVizActiveTaxon', 'selectGrameneMaps', 'selectExpressionStudies', 'selectExpressionSamples', 'doSetExprVizActiveTaxon', 'doToggleExprVizFieldsModal', 'doFetchExprVizData', 'doReorderExprVizFields', 'doAddGrameneRangeQuery', $1fd2507769d5bd00$var$ExprVizViewCmp);
+
+
+
+
+
+
+
+
+
 const $c5d403787de8b05f$var$provider = new (0, $gXNCa$firebaseauth.GoogleAuthProvider)();
 const $c5d403787de8b05f$var$Auth = (props)=>{
     const firebaseConfig = props.configuration && props.configuration.firebaseConfig;
@@ -10313,6 +12321,7 @@ const $693dd8c7a5607c3a$var$inventory = {
     taxonomy: (0, $a67cad486021eb32$export$2e2bcd8739ae039),
     attribs: (0, $67bf5a43401bffdc$export$2e2bcd8739ae039),
     expression: (0, $261baeb81c4d4d8a$export$2e2bcd8739ae039),
+    exprViz: (0, $1fd2507769d5bd00$export$2e2bcd8739ae039),
     userLists: (0, $0f50f369018a42ef$export$2e2bcd8739ae039),
     export: (0, $37b3bb0145d266b0$export$2e2bcd8739ae039)
 };