gramene-search 2.1.10 → 2.2.0

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "gramene-search",
-  "version": "2.1.10",
+  "version": "2.2.0",
   "description": "search wrapper for gramene",
   "main": "dist/index.js",
+  "alias": {
+    "react": "./node_modules/react",
+    "react-dom": "./node_modules/react-dom"
+  },
   "targets": {
     "main": {
       "source": "src/index.js"
@@ -42,7 +46,6 @@
     "flat-to-nested": "^1.1.1",
     "gramene-bins-client": "^2.3.3",
     "gramene-dbxrefs": "^3.0.15",
-    "gramene-efp-browser": "^1.0.11",
     "gramene-genetree-vis": "^4.2.11",
     "gramene-mdview": "^2.0.8",
     "gramene-search-vis": "^4.2.5",

package/src/bundles/api.js

@@ -1,7 +1,13 @@
 import { createAsyncResourceBundle, createSelector } from 'redux-bundler'
 import _ from 'lodash'
-import binsClient from "gramene-bins-client";
-import treesClient from "gramene-trees-client";
+// Import the leaf modules directly (not the package index) so we don't
+// trigger gramene-bins-client/index.js and gramene-trees-client/index.js,
+// each of which eagerly require()s ./src/promise -> gramene-search-client
+// -> grameneSwaggerClient.js, whose top-level IIFE fires a GET to /swagger
+// at module load. We never use the promise path, so the fetch was pure
+// waste — two requests per page load before this change.
+import bins from "gramene-bins-client/src/bins";
+import taxonomy from "gramene-trees-client/src/taxonomy";
 import {build} from "gramene-taxonomy-with-genomes";
 
 const facets = [
@@ -220,29 +226,6 @@ expressionSamples.reactExpressionSamples = createSelector(
   }
 );
 
-const curatedGenes = createAsyncResourceBundle( {
-  name: 'curatedGenes',
-  actionBaseType: 'CURATED_GENES',
-  persist: true,
-  staleAfter: 24 * 60 * 60 * 1000,
-  getPromise: ({store}) => {
-    return fetch(`https://devdata.gramene.org/curation/curations?rows=0&minFlagged=0&since=12-12-2029`)
-      .then(res => res.json())
-      .then(curation => _.keyBy(curation.genes, 'gene_id'))
-  }
-});
-// Curated annotations are consumed by GeneList rows and Homology details,
-// both inside the gene-list view.
-curatedGenes.reactCuratedGenes = createSelector(
-  'selectCuratedGenesShouldUpdate',
-  'selectGrameneViewsOn',
-  (shouldUpdate, viewsOn) => {
-    if (!shouldUpdate) return;
-    if (!viewsOn || !viewsOn.has('list')) return;
-    return { actionCreator: 'doFetchCuratedGenes' }
-  }
-);
-
 const grameneGermplasm = createAsyncResourceBundle( {
   name: 'grameneGermplasm',
   actionBaseType: 'GRAMENE_GERMPLASM',
@@ -387,35 +370,34 @@ const grameneSearch = createAsyncResourceBundle({
     const effectiveRows = noFilters ? 0 : rows;
     const facetField = noFilters ? noFilterFacets : facets;
 
-    // Build the set of hidden taxon_ids (as strings for stable comparison
-    // against either string or numeric facet values from Solr).
-    const hiddenTaxa = new Set(Object.keys(m).filter(tid => m[tid].hidden));
+    // Set of taxon_ids the UI knows about — keep only these in the response.
+    // Anything else (hidden taxa, or taxa that exist in Solr but not in this
+    // site's maps collection) is stripped so downstream consumers — notably
+    // the TaxDist Vis which throws on unknown tids — see a clean visible-only
+    // view. Mirrors the old server-side `fq=taxon_id:(visible)` behavior.
+    const visibleTaxaSet = new Set(visibleTaxa);
 
     // return fetch(`${store.selectGrameneAPI()}/search?q=${q}&facet.field=${facetField}&rows=${effectiveRows}&start=${offset}${fq}&stats=true&${statsFields.join('&')}`)
     return fetch(`${store.selectGrameneAPI()}/search?q=${q}&facet.field=${facetField}&rows=${effectiveRows}&start=${offset}${fq}`)
       .then(res => res.json())
       .then(res => {
-        // Strip hidden-genome contributions client-side. With no fq filter
-        // on the server, the response reflects every taxon; we subtract
-        // hidden ones from totals and facets so the rest of the UI sees a
-        // "visible-only" view.
-        if (hiddenTaxa.size && res.facet_counts && res.facet_counts.facet_fields) {
+        if (visibleTaxaSet.size && res.facet_counts && res.facet_counts.facet_fields) {
           const tf = res.facet_counts.facet_fields.taxon_id;
           if (Array.isArray(tf)) {
-            let hiddenGeneCount = 0;
+            let droppedGeneCount = 0;
             const kept = [];
             for (let i = 0; i < tf.length; i += 2) {
-              if (hiddenTaxa.has(String(tf[i]))) {
-                hiddenGeneCount += tf[i + 1];
-              } else {
+              if (visibleTaxaSet.has(String(tf[i]))) {
                 kept.push(tf[i], tf[i + 1]);
+              } else {
+                droppedGeneCount += tf[i + 1];
               }
             }
             res.facet_counts.facet_fields.taxon_id = kept;
             if (res.response) {
-              res.response.numFound = Math.max(0, res.response.numFound - hiddenGeneCount);
+              res.response.numFound = Math.max(0, res.response.numFound - droppedGeneCount);
               if (Array.isArray(res.response.docs)) {
-                res.response.docs = res.response.docs.filter(d => !hiddenTaxa.has(String(d.taxon_id)));
+                res.response.docs = res.response.docs.filter(d => visibleTaxaSet.has(String(d.taxon_id)));
               }
             }
           }
@@ -482,8 +464,8 @@ const grameneTaxDist = {
           grameneTaxonomy[tid].name = map.display_name;
         });
         const binnedResults = formatFacetCountsForViz(grameneSearch.facet_counts.facet_fields.fixed_1000__bin);
-        let speciesTree = treesClient.taxonomy.tree(Object.values(grameneTaxonomy));
-        let binMapper = binsClient.bins(grameneMaps);
+        let speciesTree = taxonomy.tree(Object.values(grameneTaxonomy));
+        let binMapper = bins(grameneMaps);
         let taxDist = build(binMapper, speciesTree);
         taxDist.setBinType('fixed',1000);
         taxDist.setResults(binnedResults);
@@ -628,4 +610,4 @@ const grameneParalogs = {
 // });
 
 
-export default [grameneSuggestions, grameneSearch, grameneGeneAttribs, grameneMaps, grameneTaxonomy, grameneTaxDist, grameneOrthologs, grameneParalogs, curatedGenes, grameneGermplasm, expressionSamples, expressionStudies];
+export default [grameneSuggestions, grameneSearch, grameneGeneAttribs, grameneMaps, grameneTaxonomy, grameneTaxDist, grameneOrthologs, grameneParalogs, grameneGermplasm, expressionSamples, expressionStudies];

package/src/bundles/docs.js

@@ -4,9 +4,10 @@ import { getConfiguredCache } from 'money-clip';
 // indefinitely (default maxAge of `Infinity`). The pathway set is small
 // and stable enough to keep around across sessions, so we bulk-load it
 // once with `?rows=-1` and reuse it instead of issuing per-id requests.
+// Scoped to the subsite so per-site pathway corpora don't collide.
 const pathwayCache = getConfiguredCache({
   version: 1,
-  name: 'gramene_pathways'
+  name: `gramene_pathways_${process.env.SUBSITE || 'default'}`
 });
 
 let pathwaysBulkPromise = null;

package/src/bundles/exprViz.js

@@ -6,8 +6,12 @@ import { createSelector } from 'redux-bundler';
 //   activeTaxon: <taxon_id|null>,
 //   byTaxon: {
 //     [taxon_id]: {
-//       selectedFields: [<solr field name>...],
+//       selectedFields: [<solr field name>...],   // order = column/axis order
 //       fieldsModalOpen: <bool>,
+//       vizMode: 'heatmap'|'parallel',            // persisted view config
+//       scale: 'linear'|'log',                    // persisted view config
+//       brushes: { [field]: [lo, hi] },           // persisted parallel-coords brushes
+//       pendingLoad: <bool>,                       // transient: a restored view wants a re-fetch
 //       fetch: { status, offset, total, signature, requestId, error },
 //       rows: [<doc>...]
 //     }
@@ -54,6 +58,10 @@ const exprViz = {
       return {
         selectedFields: [],
         fieldsModalOpen: false,
+        vizMode: 'heatmap',
+        scale: 'linear',
+        brushes: {},
+        pendingLoad: false,
         fetch: { status: 'idle', offset: 0, total: 0, signature: null, requestId: 0, error: null },
         rows: [],
         availableAttrs: null,
@@ -96,12 +104,58 @@ const exprViz = {
               [payload.taxon]: {
                 ...t,
                 selectedFields: payload.fields,
+                // A new field selection invalidates any prior brushes (they
+                // reference axes that may no longer exist) and the loaded rows.
+                brushes: {},
                 rows: [],
                 fetch: { status: 'idle', offset: 0, total: 0, signature: null, requestId: 0, error: null }
               }
             }
           };
         }
+        case 'EXPRVIZ_VIZMODE_SET': {
+          const t = ensureTaxon(state, payload.taxon);
+          return {
+            ...state,
+            byTaxon: { ...state.byTaxon, [payload.taxon]: { ...t, vizMode: payload.vizMode } }
+          };
+        }
+        case 'EXPRVIZ_SCALE_SET': {
+          const t = ensureTaxon(state, payload.taxon);
+          return {
+            ...state,
+            byTaxon: { ...state.byTaxon, [payload.taxon]: { ...t, scale: payload.scale } }
+          };
+        }
+        case 'EXPRVIZ_BRUSHES_SET': {
+          const t = ensureTaxon(state, payload.taxon);
+          return {
+            ...state,
+            byTaxon: { ...state.byTaxon, [payload.taxon]: { ...t, brushes: payload.brushes || {} } }
+          };
+        }
+        case 'EXPRVIZ_RESTORED': {
+          // Re-apply persisted view config from a saved-view snapshot. Async
+          // data (rows) is NOT in the snapshot — instead each taxon with a
+          // field selection is flagged pendingLoad so reactExprVizRestoreLoad
+          // re-fetches it once the search context is ready.
+          const byTaxon = { ...state.byTaxon };
+          const cfg = payload.byTaxon || {};
+          for (const tid of Object.keys(cfg)) {
+            const base = ensureTaxon(state, tid);
+            const c = cfg[tid] || {};
+            const selectedFields = Array.isArray(c.selectedFields) ? c.selectedFields : [];
+            byTaxon[tid] = {
+              ...base,
+              selectedFields,
+              vizMode: c.vizMode || 'heatmap',
+              scale: c.scale || 'linear',
+              brushes: c.brushes || {},
+              pendingLoad: selectedFields.length > 0
+            };
+          }
+          return { ...state, activeTaxon: payload.activeTaxon || state.activeTaxon, byTaxon };
+        }
         case 'EXPRVIZ_FIELDS_REORDERED': {
           const t = state.byTaxon[payload.taxon];
           if (!t) return state;
@@ -128,6 +182,7 @@ const exprViz = {
               ...state.byTaxon,
               [payload.taxon]: {
                 ...t,
+                pendingLoad: false,
                 fetch: { ...t.fetch, status: 'loading', signature: payload.signature, requestId: payload.requestId, error: null }
               }
             }
@@ -309,6 +364,24 @@ const exprViz = {
   doReorderExprVizFields: (taxon, fields) => ({ dispatch }) =>
     dispatch({ type: 'EXPRVIZ_FIELDS_REORDERED', payload: { taxon, fields } }),
 
+  doSetExprVizVizMode: (taxon, vizMode) => ({ dispatch }) =>
+    dispatch({ type: 'EXPRVIZ_VIZMODE_SET', payload: { taxon, vizMode } }),
+
+  doSetExprVizScale: (taxon, scale) => ({ dispatch }) =>
+    dispatch({ type: 'EXPRVIZ_SCALE_SET', payload: { taxon, scale } }),
+
+  doSetExprVizBrushes: (taxon, brushes) => ({ dispatch }) =>
+    dispatch({ type: 'EXPRVIZ_BRUSHES_SET', payload: { taxon, brushes } }),
+
+  // Re-apply persisted exprViz view config from a saved-view snapshot. Called
+  // by viewSnapshot's doApplyViewSnapshot after filters/views have been
+  // restored, so the re-fetch (driven by reactExprVizRestoreLoad) sees the
+  // restored query context.
+  doApplyExprVizSnapshot: snap => ({ dispatch }) => {
+    if (!snap || typeof snap !== 'object') return;
+    dispatch({ type: 'EXPRVIZ_RESTORED', payload: { activeTaxon: snap.activeTaxon || null, byTaxon: snap.byTaxon || {} } });
+  },
+
   doFetchExprVizData: taxon => ({ dispatch, store }) => {
     const ev = store.selectExprViz();
     const t = ev.byTaxon[taxon];
@@ -413,6 +486,29 @@ const exprViz = {
     }
   ),
 
+  // After a saved view is applied, EXPRVIZ_RESTORED flags each taxon that had
+  // a field selection with pendingLoad. Once the search context is live (not
+  // 'init') and the view is on, re-fetch that taxon's rows. Fires one taxon at
+  // a time; EXPRVIZ_FETCH_STARTED clears the flag so this won't loop. Robust to
+  // a GRAMENE_SEARCH_CLEARED that wipes rows mid-restore — the flag persists.
+  reactExprVizRestoreLoad: createSelector(
+    'selectExprViz',
+    'selectGrameneFiltersStatus',
+    'selectGrameneViews',
+    (ev, filtersStatus, views) => {
+      if (!ev || filtersStatus === 'init') return;
+      const onView = views && views.options && views.options.find(v => v.id === 'exprViz');
+      if (!onView || onView.show !== 'on') return;
+      for (const tid of Object.keys(ev.byTaxon || {})) {
+        const t = ev.byTaxon[tid];
+        if (t && t.pendingLoad && t.selectedFields.length > 0
+            && t.rows.length === 0 && t.fetch.status !== 'loading') {
+          return { actionCreator: 'doFetchExprVizData', args: [tid] };
+        }
+      }
+    }
+  ),
+
   selectExprViz: state => state.exprViz,
   selectExprVizPivot: state => state.exprViz.pivot,
   selectExprVizActiveTaxon: state => state.exprViz.activeTaxon,

package/src/bundles/index.js

@@ -8,5 +8,8 @@ import exporterBundle from './exporter'
 import ontologiesBundle from './ontologies'
 import exprVizBundle from './exprViz'
 import ontologyEnrichmentBundle from './ontologyEnrichment'
+import uiViewStateBundle from './uiViewState'
+import viewSnapshotBundle from './viewSnapshot'
+import savedViewsBundle from './savedViews'
 
-export default [...apiBundles, docsBundle, filterBundle, viewsBundle, genomesBundle, fieldCatalogBundle, exporterBundle, ontologiesBundle, exprVizBundle, ontologyEnrichmentBundle];
+export default [...apiBundles, docsBundle, filterBundle, viewsBundle, genomesBundle, fieldCatalogBundle, exporterBundle, ontologiesBundle, exprVizBundle, ontologyEnrichmentBundle, uiViewStateBundle, viewSnapshotBundle, savedViewsBundle];

package/src/bundles/ontologyEnrichment.js

@@ -70,7 +70,10 @@ const ontologyEnrichment = {
         maxGSSize: 500,
         mostSpecific: false,
         ontology: 'all',
-        search: ''
+        search: '',
+        // Per-section table sort, keyed by ontology section id (e.g.
+        // 'GO:biological_process'): { [sectionKey]: { key, dir } }.
+        sort: {}
       }
     };
 
@@ -196,6 +199,16 @@ const ontologyEnrichment = {
   doSetOntologyEnrichmentUI: patch => ({ dispatch }) =>
     dispatch({ type: 'ONTOLOGY_ENRICHMENT_UI_SET', payload: patch }),
 
+  // Re-apply persisted view config from a saved-view snapshot. Setting the
+  // active taxon (last) lets reactOntologyEnrichmentFetch re-fetch the
+  // foreground/background facets for the restored filters — no bulk data is
+  // carried in the snapshot.
+  doApplyOntologyEnrichmentSnapshot: snap => ({ dispatch }) => {
+    if (!snap || typeof snap !== 'object') return;
+    if (snap.ui) dispatch({ type: 'ONTOLOGY_ENRICHMENT_UI_SET', payload: snap.ui });
+    if (snap.activeTaxon) dispatch({ type: 'ONTOLOGY_ENRICHMENT_ACTIVE_TAXON_SET', payload: snap.activeTaxon });
+  },
+
   doFetchOntologyEnrichmentForeground: taxon => ({ dispatch, store }) => {
     const q = store.selectGrameneFiltersQueryString();
     const signature = fgSig(q, taxon);

package/src/bundles/savedViews.js

@@ -0,0 +1,335 @@
+import bootViewFromUrl from '../utils/bootView';
+
+// Client for the saved-views API ({api}/saved_views — see gramene-swagger
+// phase 3b). Mirrors the gene_lists pattern: Firebase Bearer ID token,
+// hash-based addressing, public vs private scope.
+//
+// Action creators all return Promises so calling UI (modal, boot path,
+// list view) can await them and surface success/error inline.
+//
+// Dev-mode mock: set `window.__SAVED_VIEWS_MOCK__ = true` in the console
+// and saves/fetches go through localStorage instead of the network. Lets us
+// drive Phase 4 (UI) without waiting on Phase 3b (server). Production
+// builds never touch the mock unless the flag is set at runtime, so this
+// is safe to ship.
+
+const STORAGE_PREFIX = 'gramene_saved_view_mock_v1::';
+
+const initialState = {
+  saving: false,
+  saveError: null,
+  lastSavedHash: null,
+
+  fetching: false,
+  fetchError: null,
+  lastFetched: null,        // { hash, snapshot, meta }
+
+  privateList: null,        // null = not yet fetched
+  publicList: null,
+  listError: null
+};
+
+const savedViews = {
+  name: 'savedViews',
+
+  getReducer: () => (state = initialState, {type, payload}) => {
+    switch (type) {
+      case 'SAVED_VIEW_SAVE_STARTED':
+        return {...state, saving: true, saveError: null};
+      case 'SAVED_VIEW_SAVE_SUCCEEDED':
+        return {...state, saving: false, lastSavedHash: payload.hash};
+      case 'SAVED_VIEW_SAVE_FAILED':
+        return {...state, saving: false, saveError: payload.error};
+
+      case 'SAVED_VIEW_FETCH_STARTED':
+        return {...state, fetching: true, fetchError: null};
+      case 'SAVED_VIEW_FETCH_SUCCEEDED':
+        return {...state, fetching: false, lastFetched: payload};
+      case 'SAVED_VIEW_FETCH_FAILED':
+        return {...state, fetching: false, fetchError: payload.error};
+
+      case 'SAVED_VIEW_LIST_RECEIVED':
+        return {
+          ...state,
+          [payload.kind === 'public' ? 'publicList' : 'privateList']: payload.rows,
+          listError: null
+        };
+      case 'SAVED_VIEW_LIST_FAILED':
+        return {...state, listError: payload.error};
+
+      case 'SAVED_VIEW_RESET':
+        return {...initialState};
+
+      default:
+        return state;
+    }
+  },
+
+  selectSavedViews: state => state.savedViews,
+
+  // POST a snapshot. Returns Promise<{hash, shareUrl}> on success.
+  // `user` is a Firebase user object (must respond to .getIdToken()).
+  doSaveView: ({user, label, description, isPublic}) => async ({dispatch, store}) => {
+    dispatch({type: 'SAVED_VIEW_SAVE_STARTED'});
+    try {
+      const snapshot = store.selectViewSnapshot();
+      const hash = await computeContentHash(snapshot);
+      const site = (store.selectConfiguration && store.selectConfiguration().id) || '';
+      const token = (user && user.getIdToken) ? await user.getIdToken() : null;
+      if (!token) throw new Error('Not signed in');
+
+      const meta = {
+        hash, label, site, isPublic: !!isPublic,
+        description: description || ''
+      };
+
+      if (useMock()) {
+        mockSave({...meta, state: snapshot, uid: user.uid || 'mock', createdAt: new Date().toISOString()});
+      } else {
+        const api = store.selectGrameneAPI();
+        const res = await fetch(`${api}/saved_views`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify({...meta, state: snapshot})
+        });
+        if (!res.ok) throw new Error(`Save failed (${res.status})`);
+      }
+
+      const shareUrl = buildShareUrl(hash);
+      dispatch({type: 'SAVED_VIEW_SAVE_SUCCEEDED', payload: {hash}});
+      return {hash, shareUrl};
+    } catch (err) {
+      dispatch({type: 'SAVED_VIEW_SAVE_FAILED', payload: {error: err.message || String(err)}});
+      throw err;
+    }
+  },
+
+  // GET a snapshot by share hash. Anonymous-OK for public views; token is
+  // optional and only sent if the caller provides a user.
+  // Returns Promise<{snapshot, meta}>.
+  doFetchView: ({hash, user}) => async ({dispatch, store}) => {
+    dispatch({type: 'SAVED_VIEW_FETCH_STARTED'});
+    try {
+      let row;
+      if (useMock()) {
+        row = mockFetch(hash);
+        if (!row) throw new Error(`No saved view with hash ${hash}`);
+      } else {
+        const api = store.selectGrameneAPI();
+        const headers = {Accept: 'application/json'};
+        if (user && user.getIdToken) {
+          try { headers.Authorization = `Bearer ${await user.getIdToken()}`; }
+          catch (_) { /* anonymous fallback */ }
+        }
+        const res = await fetch(`${api}/saved_views?hash=${encodeURIComponent(hash)}`, {headers});
+        if (res.status === 401) throw new Error('Sign in to load this private view.');
+        if (res.status === 404) throw new Error('Saved view not found (it may have been deleted).');
+        if (!res.ok) throw new Error(`Fetch failed (${res.status})`);
+        row = await res.json();
+      }
+      const out = {
+        hash,
+        snapshot: row.state,
+        meta: {
+          label: row.label,
+          description: row.description || '',
+          site: row.site,
+          isPublic: !!row.isPublic,
+          owner: row.owner || null,
+          createdAt: row.createdAt || null
+        }
+      };
+      dispatch({type: 'SAVED_VIEW_FETCH_SUCCEEDED', payload: out});
+      return out;
+    } catch (err) {
+      dispatch({type: 'SAVED_VIEW_FETCH_FAILED', payload: {error: err.message || String(err)}});
+      throw err;
+    }
+  },
+
+  // List views for the current site. `scope` is 'public' (anonymous-OK)
+  // or 'private' (requires `user`).
+  doListSavedViews: ({scope, user}) => async ({dispatch, store}) => {
+    try {
+      const site = (store.selectConfiguration && store.selectConfiguration().id) || '';
+      let rows;
+      if (useMock()) {
+        rows = mockList({site, scope, uid: user && user.uid});
+      } else {
+        const api = store.selectGrameneAPI();
+        const headers = {Accept: 'application/json'};
+        if (scope === 'private') {
+          if (!user || !user.getIdToken) throw new Error('Not signed in');
+          headers.Authorization = `Bearer ${await user.getIdToken()}`;
+        }
+        const url = `${api}/saved_views?site=${encodeURIComponent(site)}&isPublic=${scope === 'public'}`;
+        const res = await fetch(url, {headers});
+        if (!res.ok) throw new Error(`List failed (${res.status})`);
+        rows = await res.json();
+      }
+      dispatch({type: 'SAVED_VIEW_LIST_RECEIVED', payload: {kind: scope, rows}});
+      return rows;
+    } catch (err) {
+      dispatch({type: 'SAVED_VIEW_LIST_FAILED', payload: {error: err.message || String(err)}});
+      throw err;
+    }
+  },
+
+  // PATCH label / isPublic on a view I own. Mirrors updateList.
+  doUpdateSavedView: ({viewId, user, label, isPublic}) => async ({store}) => {
+    const updates = {};
+    if (typeof label === 'string') updates.label = label;
+    if (typeof isPublic === 'boolean') updates.isPublic = isPublic;
+    if (!Object.keys(updates).length) return;
+
+    if (useMock()) {
+      mockUpdate(viewId, updates);
+      return {viewId, updates};
+    }
+    const token = await user.getIdToken();
+    const api = store.selectGrameneAPI();
+    const res = await fetch(`${api}/saved_views?viewId=${encodeURIComponent(viewId)}`, {
+      method: 'PATCH',
+      headers: {'Content-Type': 'application/json', Authorization: `Bearer ${token}`},
+      body: JSON.stringify(updates)
+    });
+    if (!res.ok) throw new Error(`Update failed (${res.status})`);
+    return res.json();
+  },
+
+  // DELETE one of my saved views. Mirrors deleteList.
+  doDeleteSavedView: ({viewId, user}) => async ({store}) => {
+    if (useMock()) {
+      mockDelete(viewId);
+      return {viewId};
+    }
+    const token = await user.getIdToken();
+    const api = store.selectGrameneAPI();
+    const res = await fetch(`${api}/saved_views?viewId=${encodeURIComponent(viewId)}`, {
+      method: 'DELETE',
+      headers: {Authorization: `Bearer ${token}`}
+    });
+    if (!res.ok) throw new Error(`Delete failed (${res.status})`);
+    return res.json();
+  },
+
+  doResetSavedViewState: () => ({dispatch}) => dispatch({type: 'SAVED_VIEW_RESET'}),
+
+  // Connect-friendly wrapper around bootViewFromUrl. Auth.js calls this on
+  // each auth-state emission, passing the current Firebase user (or null);
+  // bootView.js no-ops when ?view= isn't in the URL, so this is cheap to
+  // call repeatedly.
+  doBootSharedView: ({user} = {}) => ({store}) => {
+    return bootViewFromUrl(store, {user});
+  }
+};
+
+// ── helpers ─────────────────────────────────────────────────────────────
+
+// Test/dev: either set the runtime-only flag (`window.__SAVED_VIEWS_MOCK__ = true`,
+// cleared on reload), or persist via localStorage (`localStorage.setItem(
+// '__SAVED_VIEWS_MOCK__', 'true')`, survives reloads — needed for the
+// share-link round-trip which navigates).
+function useMock() {
+  if (typeof window === 'undefined') return false;
+  if (window.__SAVED_VIEWS_MOCK__) return true;
+  try { return typeof localStorage !== 'undefined' && localStorage.getItem('__SAVED_VIEWS_MOCK__') === 'true'; }
+  catch (_) { return false; }
+}
+
+function buildShareUrl(hash) {
+  if (typeof window === 'undefined') return `?view=${hash}`;
+  const u = new URL(window.location.href);
+  u.search = '';
+  u.searchParams.set('view', hash);
+  return u.toString();
+}
+
+// Content-addressable, ~72-bit short hash. The snapshot's `capturedAt` is
+// excluded from the hash input so two saves of the same view by the same
+// user produce the same hash (and the server's $setOnInsert preserves the
+// original createdAt).
+async function computeContentHash(snapshot) {
+  const forHash = {...snapshot, capturedAt: undefined};
+  const text = canonicalize(forHash);
+  if (typeof crypto !== 'undefined' && crypto.subtle) {
+    const buf = new TextEncoder().encode(text);
+    const digest = await crypto.subtle.digest('SHA-256', buf);
+    const bytes = new Uint8Array(digest);
+    let b64 = '';
+    for (let i = 0; i < bytes.length; i++) b64 += String.fromCharCode(bytes[i]);
+    return btoa(b64)
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_')
+      .replace(/=+$/, '')
+      .slice(0, 12);
+  }
+  // Last-resort fallback for environments without WebCrypto.
+  let h = 0;
+  for (let i = 0; i < text.length; i++) h = ((h << 5) - h + text.charCodeAt(i)) | 0;
+  return ('h' + (h >>> 0).toString(36)).slice(0, 12);
+}
+
+// Stable stringify: sort object keys recursively so semantically-equivalent
+// snapshots hash identically.
+function canonicalize(v) {
+  if (v === null || typeof v !== 'object') return JSON.stringify(v);
+  if (Array.isArray(v)) return '[' + v.map(canonicalize).join(',') + ']';
+  const keys = Object.keys(v).filter(k => v[k] !== undefined).sort();
+  return '{' + keys.map(k => JSON.stringify(k) + ':' + canonicalize(v[k])).join(',') + '}';
+}
+
+// ── mock backend (localStorage) ─────────────────────────────────────────
+
+function mockSave(row) {
+  if (typeof localStorage === 'undefined') return;
+  localStorage.setItem(STORAGE_PREFIX + row.hash, JSON.stringify({...row, _id: row.hash + ' ' + row.uid}));
+}
+function mockFetch(hash) {
+  if (typeof localStorage === 'undefined') return null;
+  const raw = localStorage.getItem(STORAGE_PREFIX + hash);
+  return raw ? JSON.parse(raw) : null;
+}
+function mockList({site, scope, uid}) {
+  if (typeof localStorage === 'undefined') return [];
+  const out = [];
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (!k || !k.startsWith(STORAGE_PREFIX)) continue;
+    const row = JSON.parse(localStorage.getItem(k));
+    if (row.site !== site) continue;
+    if (scope === 'public' && !row.isPublic) continue;
+    if (scope === 'private' && (row.isPublic || row.uid !== uid)) continue;
+    out.push(row);
+  }
+  return out.sort((a, b) => (b.createdAt || '').localeCompare(a.createdAt || ''));
+}
+function mockUpdate(viewId, updates) {
+  if (typeof localStorage === 'undefined') return;
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (!k || !k.startsWith(STORAGE_PREFIX)) continue;
+    const row = JSON.parse(localStorage.getItem(k));
+    if (row._id === viewId) {
+      localStorage.setItem(k, JSON.stringify({...row, ...updates}));
+      return;
+    }
+  }
+}
+function mockDelete(viewId) {
+  if (typeof localStorage === 'undefined') return;
+  for (let i = 0; i < localStorage.length; i++) {
+    const k = localStorage.key(i);
+    if (!k || !k.startsWith(STORAGE_PREFIX)) continue;
+    const row = JSON.parse(localStorage.getItem(k));
+    if (row._id === viewId) {
+      localStorage.removeItem(k);
+      return;
+    }
+  }
+}
+
+export default savedViews;