dara-core 1.13.1__py3-none-any.whl → 1.14.0__py3-none-any.whl

dara/core/umd/dara.core.umd.js

@@ -33,7 +33,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
 (function(global2, factory) {
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("react"), require("@tanstack/react-query"), require("react-dom"), require("styled-components")) : typeof define === "function" && define.amd ? define(["exports", "react", "@tanstack/react-query", "react-dom", "styled-components"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory((global2.dara = global2.dara || {}, global2.dara.core = {}), global2.React, global2.ReactQuery, global2.ReactDOM, global2.styled));
 })(this, function(exports, React, reactQuery, ReactDOM, styled) {
-  var _pingInterval, _socketUrl, _reconnectCount, _events$, _parentBus, _instance, _observers;
+  var _locks, _subscribers, _pingInterval, _socketUrl, _reconnectCount, _events$, _parentBus, _instance, _observers;
   "use strict";
   const _interopDefaultLegacy = (e3) => e3 && typeof e3 === "object" && "default" in e3 ? e3 : { default: e3 };
   function _interopNamespace(e3) {
@@ -3381,22 +3381,22 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
     }
   }
-  function saveDepsToStore(key, deps, store, version) {
+  function saveDepsToStore(key, deps, store2, version) {
     var _storeState$nextTree, _storeState$previousT, _storeState$previousT2, _storeState$previousT3;
-    const storeState = store.getState();
+    const storeState = store2.getState();
     if (!(version === storeState.currentTree.version || version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version)))
       ;
-    const graph2 = store.getGraph(version);
+    const graph2 = store2.getGraph(version);
     mergeDepsIntoGraph(key, deps, graph2);
     if (version === ((_storeState$previousT2 = storeState.previousTree) === null || _storeState$previousT2 === void 0 ? void 0 : _storeState$previousT2.version)) {
-      const currentGraph = store.getGraph(storeState.currentTree.version);
+      const currentGraph = store2.getGraph(storeState.currentTree.version);
       mergeDepsIntoGraph(key, deps, currentGraph, graph2);
     }
     if (version === ((_storeState$previousT3 = storeState.previousTree) === null || _storeState$previousT3 === void 0 ? void 0 : _storeState$previousT3.version) || version === storeState.currentTree.version) {
       var _storeState$nextTree2;
       const nextVersion = (_storeState$nextTree2 = storeState.nextTree) === null || _storeState$nextTree2 === void 0 ? void 0 : _storeState$nextTree2.version;
       if (nextVersion !== void 0) {
-        const nextGraph = store.getGraph(nextVersion);
+        const nextGraph = store2.getGraph(nextVersion);
         mergeDepsIntoGraph(key, deps, nextGraph, graph2);
       }
     }
@@ -3550,13 +3550,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   const emptySet = Object.freeze(/* @__PURE__ */ new Set());
   class ReadOnlyRecoilValueError extends Error {
   }
-  function initializeRetentionForNode(store, nodeKey, retainedBy) {
+  function initializeRetentionForNode(store2, nodeKey, retainedBy) {
     if (!Recoil_gkx("recoil_memory_managament_2020")) {
       return () => void 0;
     }
     const {
       nodesRetainedByZone: nodesRetainedByZone2
-    } = store.getState().retention;
+    } = store2.getState().retention;
     function addToZone(zone) {
       let set2 = nodesRetainedByZone2.get(zone);
       if (!set2) {
@@ -3577,7 +3577,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
       const {
         retention
-      } = store.getState();
+      } = store2.getState();
       function deleteFromZone(zone) {
         const set2 = retention.nodesRetainedByZone.get(zone);
         set2 === null || set2 === void 0 ? void 0 : set2.delete(nodeKey);
@@ -3594,34 +3594,34 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
     };
   }
-  function initializeNodeIfNewToStore(store, treeState, key, trigger) {
-    const storeState = store.getState();
+  function initializeNodeIfNewToStore(store2, treeState, key, trigger) {
+    const storeState = store2.getState();
     if (storeState.nodeCleanupFunctions.has(key)) {
       return;
     }
     const node = getNode$1(key);
-    const retentionCleanup = initializeRetentionForNode(store, key, node.retainedBy);
-    const nodeCleanup = node.init(store, treeState, trigger);
+    const retentionCleanup = initializeRetentionForNode(store2, key, node.retainedBy);
+    const nodeCleanup = node.init(store2, treeState, trigger);
     storeState.nodeCleanupFunctions.set(key, () => {
       nodeCleanup();
       retentionCleanup();
     });
   }
-  function initializeNode(store, key, trigger) {
-    initializeNodeIfNewToStore(store, store.getState().currentTree, key, trigger);
+  function initializeNode(store2, key, trigger) {
+    initializeNodeIfNewToStore(store2, store2.getState().currentTree, key, trigger);
   }
-  function cleanUpNode(store, key) {
+  function cleanUpNode(store2, key) {
     var _state$nodeCleanupFun;
-    const state = store.getState();
+    const state = store2.getState();
     (_state$nodeCleanupFun = state.nodeCleanupFunctions.get(key)) === null || _state$nodeCleanupFun === void 0 ? void 0 : _state$nodeCleanupFun();
     state.nodeCleanupFunctions.delete(key);
   }
-  function getNodeLoadable(store, state, key) {
-    initializeNodeIfNewToStore(store, state, key, "get");
-    return getNode$1(key).get(store, state);
+  function getNodeLoadable(store2, state, key) {
+    initializeNodeIfNewToStore(store2, state, key, "get");
+    return getNode$1(key).get(store2, state);
   }
-  function peekNodeLoadable(store, state, key) {
-    return getNode$1(key).peek(store, state);
+  function peekNodeLoadable(store2, state, key) {
+    return getNode$1(key).peek(store2, state);
   }
   function setUnvalidatedAtomValue_DEPRECATED(state, key, newValue) {
     var _node$invalidate;
@@ -3634,23 +3634,23 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       dirtyAtoms: setByAddingToSet$1(state.dirtyAtoms, key)
     };
   }
-  function setNodeValue(store, state, key, newValue) {
+  function setNodeValue(store2, state, key, newValue) {
     const node = getNode$1(key);
     if (node.set == null) {
       throw new ReadOnlyRecoilValueError(`Attempt to set read-only RecoilValue: ${key}`);
     }
     const set2 = node.set;
-    initializeNodeIfNewToStore(store, state, key, "set");
-    return set2(store, state, newValue);
+    initializeNodeIfNewToStore(store2, state, key, "set");
+    return set2(store2, state, newValue);
   }
-  function peekNodeInfo(store, state, key) {
-    const storeState = store.getState();
-    const graph2 = store.getGraph(state.version);
+  function peekNodeInfo(store2, state, key) {
+    const storeState = store2.getState();
+    const graph2 = store2.getGraph(state.version);
     const type = getNode$1(key).nodeType;
     return Recoil_lazyProxy$1({
       type
     }, {
-      loadable: () => peekNodeLoadable(store, state, key),
+      loadable: () => peekNodeLoadable(store2, state, key),
       isActive: () => storeState.knownAtoms.has(key) || storeState.knownSelectors.has(key),
       isSet: () => type === "selector" ? false : state.atomValues.has(key),
       isModified: () => state.dirtyAtoms.has(key),
@@ -3661,7 +3661,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       subscribers: () => {
         var _storeState$nodeToCom, _storeState$nodeToCom2;
         return {
-          nodes: recoilValuesForKeys$1(Recoil_filterIterable(getDownstreamNodes(store, state, /* @__PURE__ */ new Set([key])), (nodeKey) => nodeKey !== key)),
+          nodes: recoilValuesForKeys$1(Recoil_filterIterable(getDownstreamNodes(store2, state, /* @__PURE__ */ new Set([key])), (nodeKey) => nodeKey !== key)),
           components: Recoil_mapIterable((_storeState$nodeToCom = (_storeState$nodeToCom2 = storeState.nodeToComponentSubscriptions.get(key)) === null || _storeState$nodeToCom2 === void 0 ? void 0 : _storeState$nodeToCom2.values()) !== null && _storeState$nodeToCom !== void 0 ? _storeState$nodeToCom : [], ([name]) => ({
             name
           }))
@@ -3669,10 +3669,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
     });
   }
-  function getDownstreamNodes(store, state, keys2) {
+  function getDownstreamNodes(store2, state, keys2) {
     const visitedNodes = /* @__PURE__ */ new Set();
     const visitingNodes = Array.from(keys2);
-    const graph2 = store.getGraph(state.version);
+    const graph2 = store2.getGraph(state.version);
     for (let key = visitingNodes.pop(); key; key = visitingNodes.pop()) {
       var _graph$nodeToNodeSubs;
       visitedNodes.add(key);
@@ -3734,14 +3734,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   const {
     invalidateMemoizedSnapshot: invalidateMemoizedSnapshot$1
   } = Recoil_SnapshotCache;
-  function getRecoilValueAsLoadable(store, {
+  function getRecoilValueAsLoadable(store2, {
     key
-  }, treeState = store.getState().currentTree) {
+  }, treeState = store2.getState().currentTree) {
     var _storeState$nextTree, _storeState$previousT;
-    const storeState = store.getState();
+    const storeState = store2.getState();
     if (!(treeState.version === storeState.currentTree.version || treeState.version === ((_storeState$nextTree = storeState.nextTree) === null || _storeState$nextTree === void 0 ? void 0 : _storeState$nextTree.version) || treeState.version === ((_storeState$previousT = storeState.previousTree) === null || _storeState$previousT === void 0 ? void 0 : _storeState$previousT.version)))
       ;
-    const loadable = getNodeLoadable$1(store, treeState, key);
+    const loadable = getNodeLoadable$1(store2, treeState, key);
     if (loadable.state === "loading") {
       loadable.contents.catch(() => {
         return;
@@ -3760,11 +3760,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     });
     return result;
   }
-  function valueFromValueOrUpdater(store, state, {
+  function valueFromValueOrUpdater(store2, state, {
     key
   }, valueOrUpdater) {
     if (typeof valueOrUpdater === "function") {
-      const current = getNodeLoadable$1(store, state, key);
+      const current = getNodeLoadable$1(store2, state, key);
       if (current.state === "loading") {
         const msg = `Tried to set atom or selector "${key}" using an updater function while the current state is pending, this is not currently supported.`;
         throw Recoil_err$2(msg);
@@ -3776,14 +3776,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       return valueOrUpdater;
     }
   }
-  function applyAction(store, state, action) {
+  function applyAction(store2, state, action) {
     if (action.type === "set") {
       const {
         recoilValue,
         valueOrUpdater
       } = action;
-      const newValue = valueFromValueOrUpdater(store, state, recoilValue, valueOrUpdater);
-      const writes = setNodeValue$1(store, state, recoilValue.key, newValue);
+      const newValue = valueFromValueOrUpdater(store2, state, recoilValue, valueOrUpdater);
+      const writes = setNodeValue$1(store2, state, recoilValue.key, newValue);
       for (const [key, loadable] of writes.entries()) {
         writeLoadableToTreeState(state, key, loadable);
       }
@@ -3828,27 +3828,27 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     state.dirtyAtoms.add(key);
     state.nonvalidatedAtoms.delete(key);
   }
-  function applyActionsToStore(store, actions) {
-    store.replaceState((state) => {
+  function applyActionsToStore(store2, actions) {
+    store2.replaceState((state) => {
       const newState = copyTreeState(state);
       for (const action of actions) {
-        applyAction(store, newState, action);
+        applyAction(store2, newState, action);
       }
-      invalidateDownstreams(store, newState);
+      invalidateDownstreams(store2, newState);
       invalidateMemoizedSnapshot$1();
       return newState;
     });
   }
-  function queueOrPerformStateUpdate(store, action) {
+  function queueOrPerformStateUpdate(store2, action) {
     if (batchStack.length) {
       const actionsByStore = batchStack[batchStack.length - 1];
-      let actions = actionsByStore.get(store);
+      let actions = actionsByStore.get(store2);
       if (!actions) {
-        actionsByStore.set(store, actions = []);
+        actionsByStore.set(store2, actions = []);
       }
       actions.push(action);
     } else {
-      applyActionsToStore(store, [action]);
+      applyActionsToStore(store2, [action]);
     }
   }
   const batchStack = [];
@@ -3856,8 +3856,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     const actionsByStore = /* @__PURE__ */ new Map();
     batchStack.push(actionsByStore);
     return () => {
-      for (const [store, actions] of actionsByStore) {
-        applyActionsToStore(store, actions);
+      for (const [store2, actions] of actionsByStore) {
+        applyActionsToStore(store2, actions);
       }
       batchStack.pop();
     };
@@ -3870,62 +3870,62 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       dirtyAtoms: new Set(state.dirtyAtoms)
     };
   }
-  function invalidateDownstreams(store, state) {
-    const downstreams = getDownstreamNodes$1(store, state, state.dirtyAtoms);
+  function invalidateDownstreams(store2, state) {
+    const downstreams = getDownstreamNodes$1(store2, state, state.dirtyAtoms);
     for (const key of downstreams) {
       var _getNodeMaybe, _getNodeMaybe$invalid;
       (_getNodeMaybe = getNodeMaybe$2(key)) === null || _getNodeMaybe === void 0 ? void 0 : (_getNodeMaybe$invalid = _getNodeMaybe.invalidate) === null || _getNodeMaybe$invalid === void 0 ? void 0 : _getNodeMaybe$invalid.call(_getNodeMaybe, state);
     }
   }
-  function setRecoilValue(store, recoilValue, valueOrUpdater) {
-    queueOrPerformStateUpdate(store, {
+  function setRecoilValue(store2, recoilValue, valueOrUpdater) {
+    queueOrPerformStateUpdate(store2, {
       type: "set",
       recoilValue,
       valueOrUpdater
     });
   }
-  function setRecoilValueLoadable(store, recoilValue, loadable) {
+  function setRecoilValueLoadable(store2, recoilValue, loadable) {
     if (loadable instanceof DefaultValue$1$1) {
-      return setRecoilValue(store, recoilValue, loadable);
+      return setRecoilValue(store2, recoilValue, loadable);
     }
-    queueOrPerformStateUpdate(store, {
+    queueOrPerformStateUpdate(store2, {
       type: "setLoadable",
       recoilValue,
       loadable
     });
   }
-  function markRecoilValueModified(store, recoilValue) {
-    queueOrPerformStateUpdate(store, {
+  function markRecoilValueModified(store2, recoilValue) {
+    queueOrPerformStateUpdate(store2, {
       type: "markModified",
       recoilValue
     });
   }
-  function setUnvalidatedRecoilValue(store, recoilValue, unvalidatedValue) {
-    queueOrPerformStateUpdate(store, {
+  function setUnvalidatedRecoilValue(store2, recoilValue, unvalidatedValue) {
+    queueOrPerformStateUpdate(store2, {
       type: "setUnvalidated",
       recoilValue,
       unvalidatedValue
     });
   }
-  function subscribeToRecoilValue(store, {
+  function subscribeToRecoilValue(store2, {
     key
   }, callback, componentDebugName = null) {
     const subID = getNextComponentID$1();
-    const storeState = store.getState();
+    const storeState = store2.getState();
     if (!storeState.nodeToComponentSubscriptions.has(key)) {
       storeState.nodeToComponentSubscriptions.set(key, /* @__PURE__ */ new Map());
     }
     Recoil_nullthrows$1(storeState.nodeToComponentSubscriptions.get(key)).set(subID, [componentDebugName !== null && componentDebugName !== void 0 ? componentDebugName : "<not captured>", callback]);
     const mode = reactMode$1();
     if (mode.early && (mode.mode === "LEGACY" || mode.mode === "MUTABLE_SOURCE")) {
-      const nextTree = store.getState().nextTree;
+      const nextTree = store2.getState().nextTree;
       if (nextTree && nextTree.dirtyAtoms.has(key)) {
         callback(nextTree);
       }
     }
     return {
       release: () => {
-        const releaseStoreState = store.getState();
+        const releaseStoreState = store2.getState();
         const subs = releaseStoreState.nodeToComponentSubscriptions.get(key);
         if (subs === void 0 || !subs.has(subID)) {
           return;
@@ -3937,13 +3937,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
     };
   }
-  function refreshRecoilValue(store, recoilValue) {
+  function refreshRecoilValue(store2, recoilValue) {
     var _node$clearCache;
     const {
       currentTree
-    } = store.getState();
+    } = store2.getState();
     const node = getNode$2(recoilValue.key);
-    (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, currentTree);
+    (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store2, currentTree);
   }
   var Recoil_RecoilValueInterface = {
     RecoilValueReadOnly: RecoilValueReadOnly$1,
@@ -3988,8 +3988,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   } = Recoil_RetentionZone;
   const SUSPENSE_TIMEOUT_MS = 12e4;
   const emptySet$1 = /* @__PURE__ */ new Set();
-  function releaseRetainablesNowOnCurrentTree(store, retainables) {
-    const storeState = store.getState();
+  function releaseRetainablesNowOnCurrentTree(store2, retainables) {
+    const storeState = store2.getState();
     const treeState = storeState.currentTree;
     if (storeState.nextTree) {
       return;
@@ -4004,15 +4004,15 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         nodes2.add(r2);
       }
     }
-    const releasableNodes = findReleasableNodes(store, nodes2);
+    const releasableNodes = findReleasableNodes(store2, nodes2);
     for (const node of releasableNodes) {
-      releaseNode(store, treeState, node);
+      releaseNode(store2, treeState, node);
     }
   }
-  function findReleasableNodes(store, searchFromNodes) {
-    const storeState = store.getState();
+  function findReleasableNodes(store2, searchFromNodes) {
+    const storeState = store2.getState();
     const treeState = storeState.currentTree;
-    const graph2 = store.getGraph(treeState.version);
+    const graph2 = store2.getGraph(treeState.version);
     const releasableNodes = /* @__PURE__ */ new Set();
     const nonReleasableNodes = /* @__PURE__ */ new Set();
     findReleasableNodesInner(searchFromNodes);
@@ -4020,7 +4020,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     function findReleasableNodesInner(searchFromNodes2) {
       const releasableNodesFoundThisIteration = /* @__PURE__ */ new Set();
       const downstreams = getDownstreamNodesInTopologicalOrder(
-        store,
+        store2,
         treeState,
         searchFromNodes2,
         releasableNodes,
@@ -4062,8 +4062,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
     }
   }
-  function getDownstreamNodesInTopologicalOrder(store, treeState, nodes2, doNotDescendInto1, doNotDescendInto2) {
-    const graph2 = store.getGraph(treeState.version);
+  function getDownstreamNodesInTopologicalOrder(store2, treeState, nodes2, doNotDescendInto1, doNotDescendInto2) {
+    const graph2 = store2.getGraph(treeState.version);
     const answer = [];
     const visited = /* @__PURE__ */ new Set();
     while (nodes2.size > 0) {
@@ -4089,12 +4089,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       answer.push(node);
     }
   }
-  function releaseNode(store, treeState, node) {
+  function releaseNode(store2, treeState, node) {
     if (!Recoil_gkx("recoil_memory_managament_2020")) {
       return;
     }
-    cleanUpNode$1(store, node);
-    const storeState = store.getState();
+    cleanUpNode$1(store2, node);
+    const storeState = store2.getState();
     storeState.knownAtoms.delete(node);
     storeState.knownSelectors.delete(node);
     storeState.nodeTransactionSubscriptions.delete(node);
@@ -4135,41 +4135,41 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       return retainedBy;
     }
   }
-  function scheduleOrPerformPossibleReleaseOfRetainable(store, retainable) {
-    const state = store.getState();
+  function scheduleOrPerformPossibleReleaseOfRetainable(store2, retainable) {
+    const state = store2.getState();
     if (state.nextTree) {
       state.retention.retainablesToCheckForRelease.add(retainable);
     } else {
-      releaseRetainablesNowOnCurrentTree(store, /* @__PURE__ */ new Set([retainable]));
+      releaseRetainablesNowOnCurrentTree(store2, /* @__PURE__ */ new Set([retainable]));
     }
   }
-  function updateRetainCount(store, retainable, delta) {
+  function updateRetainCount(store2, retainable, delta) {
     var _map$get;
     if (!Recoil_gkx("recoil_memory_managament_2020")) {
       return;
     }
-    const map2 = store.getState().retention.referenceCounts;
+    const map2 = store2.getState().retention.referenceCounts;
     const newCount = ((_map$get = map2.get(retainable)) !== null && _map$get !== void 0 ? _map$get : 0) + delta;
     if (newCount === 0) {
-      updateRetainCountToZero(store, retainable);
+      updateRetainCountToZero(store2, retainable);
     } else {
       map2.set(retainable, newCount);
     }
   }
-  function updateRetainCountToZero(store, retainable) {
+  function updateRetainCountToZero(store2, retainable) {
     if (!Recoil_gkx("recoil_memory_managament_2020")) {
       return;
     }
-    const map2 = store.getState().retention.referenceCounts;
+    const map2 = store2.getState().retention.referenceCounts;
     map2.delete(retainable);
-    scheduleOrPerformPossibleReleaseOfRetainable(store, retainable);
+    scheduleOrPerformPossibleReleaseOfRetainable(store2, retainable);
   }
-  function releaseScheduledRetainablesNow(store) {
+  function releaseScheduledRetainablesNow(store2) {
     if (!Recoil_gkx("recoil_memory_managament_2020")) {
       return;
     }
-    const state = store.getState();
-    releaseRetainablesNowOnCurrentTree(store, state.retention.retainablesToCheckForRelease);
+    const state = store2.getState();
+    releaseRetainablesNowOnCurrentTree(store2, state.retention.retainablesToCheckForRelease);
     state.retention.retainablesToCheckForRelease.clear();
   }
   function retainedByOptionWithDefault(r2) {
@@ -4450,8 +4450,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       return this._store.storeID;
     }
   }
-  function cloneStoreState(store, treeState, bumpVersion = false) {
-    const storeState = store.getState();
+  function cloneStoreState(store2, treeState, bumpVersion = false) {
+    const storeState = store2.getState();
     const version = bumpVersion ? getNextTreeStateVersion$2() : treeState.version;
     return {
       currentTree: {
@@ -4474,7 +4474,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       nodeToComponentSubscriptions: /* @__PURE__ */ new Map(),
       queuedComponentCallbacks_DEPRECATED: [],
       suspendedComponentResolvers: /* @__PURE__ */ new Set(),
-      graphsByVersion: (/* @__PURE__ */ new Map()).set(version, store.getGraph(treeState.version)),
+      graphsByVersion: (/* @__PURE__ */ new Map()).set(version, store2.getGraph(treeState.version)),
       retention: {
         referenceCounts: /* @__PURE__ */ new Map(),
         nodesRetainedByZone: /* @__PURE__ */ new Map(),
@@ -4489,23 +4489,23 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return initializeState != null ? snapshot.map(initializeState) : snapshot;
   }
   const [memoizedCloneSnapshot, invalidateMemoizedSnapshot$2] = memoizeOneWithArgsHashAndInvalidation$1(
-    (store, version) => {
+    (store2, version) => {
       var _storeState$nextTree;
-      const storeState = store.getState();
+      const storeState = store2.getState();
       const treeState = version === "latest" ? (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree : Recoil_nullthrows$1(storeState.previousTree);
-      return new Snapshot(cloneStoreState(store, treeState), store.storeID);
+      return new Snapshot(cloneStoreState(store2, treeState), store2.storeID);
     },
-    (store, version) => {
+    (store2, version) => {
       var _store$getState$nextT, _store$getState$previ;
-      return String(version) + String(store.storeID) + String((_store$getState$nextT = store.getState().nextTree) === null || _store$getState$nextT === void 0 ? void 0 : _store$getState$nextT.version) + String(store.getState().currentTree.version) + String((_store$getState$previ = store.getState().previousTree) === null || _store$getState$previ === void 0 ? void 0 : _store$getState$previ.version);
+      return String(version) + String(store2.storeID) + String((_store$getState$nextT = store2.getState().nextTree) === null || _store$getState$nextT === void 0 ? void 0 : _store$getState$nextT.version) + String(store2.getState().currentTree.version) + String((_store$getState$previ = store2.getState().previousTree) === null || _store$getState$previ === void 0 ? void 0 : _store$getState$previ.version);
     }
   );
   setInvalidateMemoizedSnapshot$1(invalidateMemoizedSnapshot$2);
-  function cloneSnapshot(store, version = "latest") {
-    const snapshot = memoizedCloneSnapshot(store, version);
+  function cloneSnapshot(store2, version = "latest") {
+    const snapshot = memoizedCloneSnapshot(store2, version);
     if (!snapshot.isRetained()) {
       invalidateMemoizedSnapshot$2();
-      return memoizedCloneSnapshot(store, version);
+      return memoizedCloneSnapshot(store2, version);
     }
     return snapshot;
   }
@@ -4515,27 +4515,27 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       _defineProperty$a(this, "_batch", void 0);
       _defineProperty$a(this, "set", (recoilState, newValueOrUpdater) => {
         this.checkRefCount_INTERNAL();
-        const store = this.getStore_INTERNAL();
+        const store2 = this.getStore_INTERNAL();
         this._batch(() => {
-          updateRetainCount$1(store, recoilState.key, 1);
+          updateRetainCount$1(store2, recoilState.key, 1);
           setRecoilValue$1(this.getStore_INTERNAL(), recoilState, newValueOrUpdater);
         });
       });
       _defineProperty$a(this, "reset", (recoilState) => {
         this.checkRefCount_INTERNAL();
-        const store = this.getStore_INTERNAL();
+        const store2 = this.getStore_INTERNAL();
         this._batch(() => {
-          updateRetainCount$1(store, recoilState.key, 1);
+          updateRetainCount$1(store2, recoilState.key, 1);
           setRecoilValue$1(this.getStore_INTERNAL(), recoilState, DEFAULT_VALUE$1$1);
         });
       });
       _defineProperty$a(this, "setUnvalidatedAtomValues_DEPRECATED", (values) => {
         this.checkRefCount_INTERNAL();
-        const store = this.getStore_INTERNAL();
+        const store2 = this.getStore_INTERNAL();
         batchUpdates$1(() => {
           for (const [k2, v2] of values.entries()) {
-            updateRetainCount$1(store, k2, 1);
-            setUnvalidatedRecoilValue$1(store, new AbstractRecoilValue$2(k2), v2);
+            updateRetainCount$1(store2, k2, 1);
+            setUnvalidatedRecoilValue$1(store2, new AbstractRecoilValue$2(k2), v2);
           }
         });
       });
@@ -4633,15 +4633,15 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     addTransactionMetadata: notInAContext
   });
   let stateReplacerIsBeingExecuted = false;
-  function startNextTreeIfNeeded(store) {
+  function startNextTreeIfNeeded(store2) {
     if (stateReplacerIsBeingExecuted) {
       throw Recoil_err$2("An atom update was triggered within the execution of a state updater function. State updater functions provided to Recoil must be pure functions.");
     }
-    const storeState = store.getState();
+    const storeState = store2.getState();
     if (storeState.nextTree === null) {
       if (Recoil_gkx("recoil_memory_managament_2020") && Recoil_gkx("recoil_release_on_cascading_update_killswitch_2021")) {
         if (storeState.commitDepth > 0) {
-          releaseScheduledRetainablesNow$1(store);
+          releaseScheduledRetainablesNow$1(store2);
         }
       }
       const version = storeState.currentTree.version;
@@ -4665,8 +4665,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     const mutableSource = useContext(MutableSourceContext);
     return mutableSource;
   }
-  function notifyComponents(store, storeState, treeState) {
-    const dependentNodes = getDownstreamNodes$2(store, treeState, treeState.dirtyAtoms);
+  function notifyComponents(store2, storeState, treeState) {
+    const dependentNodes = getDownstreamNodes$2(store2, treeState, treeState.dirtyAtoms);
     for (const key of dependentNodes) {
       const comps = storeState.nodeToComponentSubscriptions.get(key);
       if (comps) {
@@ -4676,23 +4676,23 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
     }
   }
-  function sendEndOfBatchNotifications(store) {
-    const storeState = store.getState();
+  function sendEndOfBatchNotifications(store2) {
+    const storeState = store2.getState();
     const treeState = storeState.currentTree;
     const dirtyAtoms = treeState.dirtyAtoms;
     if (dirtyAtoms.size) {
       for (const [key, subscriptions] of storeState.nodeTransactionSubscriptions) {
         if (dirtyAtoms.has(key)) {
           for (const [_, subscription] of subscriptions) {
-            subscription(store);
+            subscription(store2);
           }
         }
       }
       for (const [_, subscription] of storeState.transactionSubscriptions) {
-        subscription(store);
+        subscription(store2);
       }
       if (!reactMode$2().early || storeState.suspendedComponentResolvers.size > 0) {
-        notifyComponents(store, storeState, treeState);
+        notifyComponents(store2, storeState, treeState);
         storeState.suspendedComponentResolvers.forEach((cb) => cb());
         storeState.suspendedComponentResolvers.clear();
       }
@@ -4700,8 +4700,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     storeState.queuedComponentCallbacks_DEPRECATED.forEach((cb) => cb(treeState));
     storeState.queuedComponentCallbacks_DEPRECATED.splice(0, storeState.queuedComponentCallbacks_DEPRECATED.length);
   }
-  function endBatch(store) {
-    const storeState = store.getState();
+  function endBatch(store2) {
+    const storeState = store2.getState();
     storeState.commitDepth++;
     try {
       const {
@@ -4713,7 +4713,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       storeState.previousTree = storeState.currentTree;
       storeState.currentTree = nextTree;
       storeState.nextTree = null;
-      sendEndOfBatchNotifications(store);
+      sendEndOfBatchNotifications(store2);
       if (storeState.previousTree != null) {
         storeState.graphsByVersion.delete(storeState.previousTree.version);
       } else {
@@ -4722,7 +4722,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       storeState.previousTree = null;
       if (Recoil_gkx("recoil_memory_managament_2020")) {
         if (nextTree == null) {
-          releaseScheduledRetainablesNow$1(store);
+          releaseScheduledRetainablesNow$1(store2);
         }
       }
     } finally {
@@ -4749,12 +4749,12 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     });
     return null;
   }
-  function initialStoreState_DEPRECATED(store, initializeState) {
+  function initialStoreState_DEPRECATED(store2, initializeState) {
     const initial2 = makeEmptyStoreState$2();
     initializeState({
       set: (atom2, value) => {
         const state = initial2.currentTree;
-        const writes = setNodeValue$2(store, state, atom2.key, value);
+        const writes = setNodeValue$2(store2, state, atom2.key, value);
         const writtenNodes = new Set(writes.keys());
         const nonvalidatedAtoms = state.nonvalidatedAtoms.clone();
         for (const n2 of writtenNodes) {
@@ -4877,13 +4877,13 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     storeStateRef = Recoil_useRefInitOnce(() => initializeState_DEPRECATED != null ? initialStoreState_DEPRECATED(storeRef.current, initializeState_DEPRECATED) : initializeState != null ? initialStoreState(initializeState) : makeEmptyStoreState$2());
     const mutableSource = useMemo$2(() => createMutableSource$1 === null || createMutableSource$1 === void 0 ? void 0 : createMutableSource$1(storeStateRef, () => storeStateRef.current.currentTree.version), [storeStateRef]);
     useEffect$4(() => {
-      const store = storeRef.current;
-      for (const atomKey of new Set(store.getState().knownAtoms)) {
-        initializeNode$2(store, atomKey, "get");
+      const store2 = storeRef.current;
+      for (const atomKey of new Set(store2.getState().knownAtoms)) {
+        initializeNode$2(store2, atomKey, "get");
       }
       return () => {
-        for (const atomKey of store.getState().knownAtoms) {
-          cleanUpNode$2(store, atomKey);
+        for (const atomKey of store2.getState().knownAtoms) {
+          cleanUpNode$2(store2, atomKey);
         }
       };
     }, [storeRef]);
@@ -4977,31 +4977,31 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       if (!Recoil_gkx("recoil_memory_managament_2020")) {
         return;
       }
-      const store = storeRef.current;
+      const store2 = storeRef.current;
       if (timeoutID.current && !isSSR$2) {
         window.clearTimeout(timeoutID.current);
         timeoutID.current = null;
       } else {
         for (const r2 of retainables) {
-          updateRetainCount$2(store, r2, 1);
+          updateRetainCount$2(store2, r2, 1);
         }
       }
       return () => {
         for (const r2 of retainables) {
-          updateRetainCount$2(store, r2, -1);
+          updateRetainCount$2(store2, r2, -1);
         }
       };
     }, [storeRef, ...retainables]);
     const timeoutID = useRef$3$1();
     const previousRetainables = Recoil_usePrevious$1(retainables);
     if (!isSSR$2 && (previousRetainables === void 0 || !Recoil_shallowArrayEqual(previousRetainables, retainables))) {
-      const store = storeRef.current;
+      const store2 = storeRef.current;
       for (const r2 of retainables) {
-        updateRetainCount$2(store, r2, 1);
+        updateRetainCount$2(store2, r2, 1);
       }
       if (previousRetainables) {
         for (const r2 of previousRetainables) {
-          updateRetainCount$2(store, r2, -1);
+          updateRetainCount$2(store2, r2, -1);
         }
       }
       if (timeoutID.current) {
@@ -5010,7 +5010,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       timeoutID.current = window.setTimeout(() => {
         timeoutID.current = null;
         for (const r2 of retainables) {
-          updateRetainCount$2(store, r2, -1);
+          updateRetainCount$2(store2, r2, -1);
         }
       }, SUSPENSE_TIMEOUT_MS$1);
     }
@@ -5097,20 +5097,20 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
     }, []);
     useEffect$3$1(() => {
-      const store = storeRef.current;
+      const store2 = storeRef.current;
       Recoil_differenceSets(recoilValuesUsed.current, previousSubscriptions.current).forEach((key) => {
         if (subscriptions.current.has(key)) {
           return;
         }
-        const sub = subscribeToRecoilValue$1(store, new AbstractRecoilValue$3(key), (state2) => updateState(state2, key), componentName);
+        const sub = subscribeToRecoilValue$1(store2, new AbstractRecoilValue$3(key), (state2) => updateState(state2, key), componentName);
         subscriptions.current.set(key, sub);
-        const state = store.getState();
+        const state = store2.getState();
         if (state.nextTree) {
-          store.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
-            updateState(store.getState(), key);
+          store2.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
+            updateState(store2.getState(), key);
           });
         } else {
-          updateState(store.getState(), key);
+          updateState(store2.getState(), key);
         }
       });
       Recoil_differenceSets(previousSubscriptions.current, recoilValuesUsed.current).forEach((key) => {
@@ -5171,10 +5171,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     const componentName = Recoil_useComponentName();
     const getSnapshot = useCallback$1$1(() => {
       var _storeState$nextTree2;
-      const store = storeRef.current;
-      const storeState = store.getState();
+      const store2 = storeRef.current;
+      const storeState = store2.getState();
       const treeState = reactMode$3().early ? (_storeState$nextTree2 = storeState.nextTree) !== null && _storeState$nextTree2 !== void 0 ? _storeState$nextTree2 : storeState.currentTree : storeState.currentTree;
-      const loadable = getRecoilValueAsLoadable$2(store, recoilValue, treeState);
+      const loadable = getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
       return {
         loadable,
         key: recoilValue.key
@@ -5194,8 +5194,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     }, []);
     const getMemoizedSnapshot = useMemo$1$1(() => memoizePreviousSnapshot(getSnapshot), [getSnapshot, memoizePreviousSnapshot]);
     const subscribe = useCallback$1$1((notify) => {
-      const store = storeRef.current;
-      const subscription = subscribeToRecoilValue$1(store, recoilValue, notify, componentName);
+      const store2 = storeRef.current;
+      const subscription = subscribeToRecoilValue$1(store2, recoilValue, notify, componentName);
       return subscription.release;
     }, [storeRef, recoilValue, componentName]);
     return useSyncExternalStore$1(
@@ -5208,18 +5208,18 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     const storeRef = useStoreRef$2();
     const getLoadable = useCallback$1$1(() => {
       var _storeState$nextTree3;
-      const store = storeRef.current;
-      const storeState = store.getState();
+      const store2 = storeRef.current;
+      const storeState = store2.getState();
       const treeState = reactMode$3().early ? (_storeState$nextTree3 = storeState.nextTree) !== null && _storeState$nextTree3 !== void 0 ? _storeState$nextTree3 : storeState.currentTree : storeState.currentTree;
-      return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
+      return getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
     }, [storeRef, recoilValue]);
     const getLoadableWithTesting = useCallback$1$1(() => {
       return getLoadable();
     }, [getLoadable]);
     const componentName = Recoil_useComponentName();
     const subscribe = useCallback$1$1((_storeState, notify) => {
-      const store = storeRef.current;
-      const subscription = subscribeToRecoilValue$1(store, recoilValue, () => {
+      const store2 = storeRef.current;
+      const subscription = subscribeToRecoilValue$1(store2, recoilValue, () => {
         if (!Recoil_gkx("recoil_suppress_rerender_in_callback")) {
           return notify();
         }
@@ -5247,10 +5247,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     const componentName = Recoil_useComponentName();
     const getLoadable = useCallback$1$1(() => {
       var _storeState$nextTree4;
-      const store = storeRef.current;
-      const storeState = store.getState();
+      const store2 = storeRef.current;
+      const storeState = store2.getState();
       const treeState = reactMode$3().early ? (_storeState$nextTree4 = storeState.nextTree) !== null && _storeState$nextTree4 !== void 0 ? _storeState$nextTree4 : storeState.currentTree : storeState.currentTree;
-      return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
+      return getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
     }, [storeRef, recoilValue]);
     const getState2 = useCallback$1$1(() => ({
       loadable: getLoadable(),
@@ -5276,10 +5276,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     const componentName = Recoil_useComponentName();
     const getLoadable = useCallback$1$1(() => {
       var _storeState$nextTree5;
-      const store = storeRef.current;
-      const storeState = store.getState();
+      const store2 = storeRef.current;
+      const storeState = store2.getState();
       const treeState = reactMode$3().early ? (_storeState$nextTree5 = storeState.nextTree) !== null && _storeState$nextTree5 !== void 0 ? _storeState$nextTree5 : storeState.currentTree : storeState.currentTree;
-      return getRecoilValueAsLoadable$2(store, recoilValue, treeState);
+      return getRecoilValueAsLoadable$2(store2, recoilValue, treeState);
     }, [storeRef, recoilValue]);
     const loadable = getLoadable();
     const prevLoadableRef = useRef$4(loadable);
@@ -5287,9 +5287,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       prevLoadableRef.current = loadable;
     });
     useEffect$3$1(() => {
-      const store = storeRef.current;
-      const storeState = store.getState();
-      const subscription = subscribeToRecoilValue$1(store, recoilValue, (_state) => {
+      const store2 = storeRef.current;
+      const storeState = store2.getState();
+      const subscription = subscribeToRecoilValue$1(store2, recoilValue, (_state) => {
         var _prevLoadableRef$curr;
         if (!Recoil_gkx("recoil_suppress_rerender_in_callback")) {
           return forceUpdate([]);
@@ -5301,7 +5301,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         prevLoadableRef.current = newLoadable;
       }, componentName);
       if (storeState.nextTree) {
-        store.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
+        store2.getState().queuedComponentCallbacks_DEPRECATED.push(() => {
           prevLoadableRef.current = null;
           forceUpdate([]);
         });
@@ -5470,11 +5470,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return Recoil_mergeMaps(state.nonvalidatedAtoms.toMap(), persistedAtomContentsValues);
   }
   function useTransactionObservation_DEPRECATED(callback) {
-    useTransactionSubscription(useCallback$2$1((store) => {
-      let previousTree = store.getState().previousTree;
-      const currentTree = store.getState().currentTree;
+    useTransactionSubscription(useCallback$2$1((store2) => {
+      let previousTree = store2.getState().previousTree;
+      const currentTree = store2.getState().currentTree;
       if (!previousTree) {
-        previousTree = store.getState().currentTree;
+        previousTree = store2.getState().currentTree;
       }
       const atomValues = externallyVisibleAtomValuesInState(currentTree);
       const previousAtomValues = externallyVisibleAtomValuesInState(previousTree);
@@ -5500,9 +5500,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     }, [callback]));
   }
   function useRecoilTransactionObserver(callback) {
-    useTransactionSubscription(useCallback$2$1((store) => {
-      const snapshot = cloneSnapshot$1(store, "latest");
-      const previousSnapshot = cloneSnapshot$1(store, "previous");
+    useTransactionSubscription(useCallback$2$1((store2) => {
+      const snapshot = cloneSnapshot$1(store2, "latest");
+      const previousSnapshot = cloneSnapshot$1(store2, "previous");
       callback({
         snapshot,
         previousSnapshot
@@ -5515,7 +5515,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     const previousSnapshot = Recoil_usePrevious$1(snapshot);
     const timeoutID = useRef$5();
     const releaseRef = useRef$5();
-    useTransactionSubscription(useCallback$2$1((store) => setSnapshot(cloneSnapshot$1(store)), []));
+    useTransactionSubscription(useCallback$2$1((store2) => setSnapshot(cloneSnapshot$1(store2)), []));
     useEffect$4$1(() => {
       const release = snapshot.retain();
       if (timeoutID.current && !isSSR$4) {
@@ -5547,9 +5547,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     }
     return snapshot;
   }
-  function gotoSnapshot(store, snapshot) {
+  function gotoSnapshot(store2, snapshot) {
     var _storeState$nextTree;
-    const storeState = store.getState();
+    const storeState = store2.getState();
     const prev = (_storeState$nextTree = storeState.nextTree) !== null && _storeState$nextTree !== void 0 ? _storeState$nextTree : storeState.currentTree;
     const next = snapshot.getStore_INTERNAL().getState().currentTree;
     batchUpdates$3(() => {
@@ -5563,9 +5563,9 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         }
       }
       keysToUpdate.forEach((key) => {
-        setRecoilValueLoadable$1(store, new AbstractRecoilValue$4(key), next.atomValues.has(key) ? Recoil_nullthrows$1(next.atomValues.get(key)) : DEFAULT_VALUE$3);
+        setRecoilValueLoadable$1(store2, new AbstractRecoilValue$4(key), next.atomValues.has(key) ? Recoil_nullthrows$1(next.atomValues.get(key)) : DEFAULT_VALUE$3);
       });
-      store.replaceState((state) => ({
+      store2.replaceState((state) => ({
         ...state,
         stateID: snapshot.getID()
       }));
@@ -5610,17 +5610,17 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     if (reactMode$4().mode === "MUTABLE_SOURCE") {
       console.warn("Warning: There are known issues using useRecoilBridgeAcrossReactRoots() in recoil_mutable_source rendering mode.  Please consider upgrading to recoil_sync_external_store mode.");
     }
-    const store = useStoreRef$5().current;
+    const store2 = useStoreRef$5().current;
     return useMemo$2$1(() => {
       function RecoilBridge({
         children
       }) {
         return /* @__PURE__ */ React__default.default.createElement(RecoilRoot$1, {
-          store_INTERNAL: store
+          store_INTERNAL: store2
         }, children);
       }
       return RecoilBridge;
-    }, [store]);
+    }, [store2]);
   }
   var Recoil_useRecoilBridgeAcrossReactRoots = useRecoilBridgeAcrossReactRoots;
   const {
@@ -5643,7 +5643,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     return getNode$5(recoilValue.key).nodeType === "atom";
   }
   class TransactionInterfaceImpl {
-    constructor(store, treeState) {
+    constructor(store2, treeState) {
       _defineProperty$a(this, "_store", void 0);
       _defineProperty$a(this, "_treeState", void 0);
       _defineProperty$a(this, "_changes", void 0);
@@ -5678,7 +5678,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       _defineProperty$a(this, "reset", (recoilState) => {
         this.set(recoilState, DEFAULT_VALUE$4);
       });
-      this._store = store;
+      this._store = store2;
       this._treeState = treeState;
       this._changes = /* @__PURE__ */ new Map();
     }
@@ -5694,10 +5694,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       return newState;
     }
   }
-  function atomicUpdater(store) {
+  function atomicUpdater(store2) {
     return (fn) => {
-      store.replaceState((treeState) => {
-        const changeset = new TransactionInterfaceImpl(store, treeState);
+      store2.replaceState((treeState) => {
+        const changeset = new TransactionInterfaceImpl(store2, treeState);
         fn(changeset);
         return changeset.newTreeState_INTERNAL();
       });
@@ -5746,7 +5746,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   class Sentinel {
   }
   const SENTINEL = new Sentinel();
-  function recoilCallback(store, fn, args, extraInterface) {
+  function recoilCallback(store2, fn, args, extraInterface) {
     let ret = SENTINEL;
     let releaseSnapshot;
     batchUpdates$4(() => {
@@ -5756,14 +5756,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
       const callbackInterface = Recoil_lazyProxy$1({
         ...extraInterface !== null && extraInterface !== void 0 ? extraInterface : {},
-        set: (node, newValue) => setRecoilValue$3(store, node, newValue),
-        reset: (node) => setRecoilValue$3(store, node, DEFAULT_VALUE$5),
-        refresh: (node) => refreshRecoilValue$1(store, node),
-        gotoSnapshot: (snapshot) => gotoSnapshot$1(store, snapshot),
-        transact_UNSTABLE: (transaction) => atomicUpdater$1(store)(transaction)
+        set: (node, newValue) => setRecoilValue$3(store2, node, newValue),
+        reset: (node) => setRecoilValue$3(store2, node, DEFAULT_VALUE$5),
+        refresh: (node) => refreshRecoilValue$1(store2, node),
+        gotoSnapshot: (snapshot) => gotoSnapshot$1(store2, snapshot),
+        transact_UNSTABLE: (transaction) => atomicUpdater$1(store2)(transaction)
       }, {
         snapshot: () => {
-          const snapshot = cloneSnapshot$2(store);
+          const snapshot = cloneSnapshot$2(store2);
           releaseSnapshot = snapshot.retain();
           return snapshot;
         }
@@ -5811,8 +5811,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   function useRecoilRefresher(recoilValue) {
     const storeRef = useStoreRef$7();
     return useCallback$4$1(() => {
-      const store = storeRef.current;
-      refreshRecoilValue$2(store, recoilValue);
+      const store2 = storeRef.current;
+      refreshRecoilValue$2(store2, recoilValue);
     }, [recoilValue, storeRef]);
   }
   var Recoil_useRecoilRefresher = useRecoilRefresher;
@@ -6336,8 +6336,8 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     function selectorIsLive() {
       return !Recoil_gkx("recoil_memory_managament_2020") || liveStoresCount > 0;
     }
-    function selectorInit(store) {
-      store.getState().knownSelectors.add(key);
+    function selectorInit(store2) {
+      store2.getState().knownSelectors.add(key);
       liveStoresCount++;
       return () => {
         liveStoresCount--;
@@ -6346,19 +6346,19 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     function selectorShouldDeleteConfigOnRelease() {
       return getConfigDeletionHandler$1(key) !== void 0 && !selectorIsLive();
     }
-    function resolveAsync(store, state, executionID, loadable, depValues) {
+    function resolveAsync(store2, state, executionID, loadable, depValues) {
       setCache(state, loadable, depValues);
-      notifyStoresOfResolvedAsync(store, executionID);
+      notifyStoresOfResolvedAsync(store2, executionID);
     }
-    function notifyStoresOfResolvedAsync(store, executionID) {
-      if (isLatestExecution(store, executionID)) {
-        clearExecutionInfo(store);
+    function notifyStoresOfResolvedAsync(store2, executionID) {
+      if (isLatestExecution(store2, executionID)) {
+        clearExecutionInfo(store2);
       }
       notifyWaitingStores(executionID, true);
     }
-    function notifyStoresOfNewAsyncDep(store, executionID) {
-      if (isLatestExecution(store, executionID)) {
-        const executionInfo = Recoil_nullthrows$1(getExecutionInfo(store));
+    function notifyStoresOfNewAsyncDep(store2, executionID) {
+      if (isLatestExecution(store2, executionID)) {
+        const executionInfo = Recoil_nullthrows$1(getExecutionInfo(store2));
         executionInfo.stateVersions.clear();
         notifyWaitingStores(executionID, false);
       }
@@ -6374,52 +6374,52 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         }
       }
     }
-    function markStoreWaitingForResolvedAsync(store, executionID) {
+    function markStoreWaitingForResolvedAsync(store2, executionID) {
       let stores = waitingStores.get(executionID);
       if (stores == null) {
         waitingStores.set(executionID, stores = /* @__PURE__ */ new Set());
       }
-      stores.add(store);
+      stores.add(store2);
     }
-    function wrapResultPromise(store, promise, state, depValues, executionID, loadingDepsState) {
+    function wrapResultPromise(store2, promise, state, depValues, executionID, loadingDepsState) {
       return promise.then((value) => {
         if (!selectorIsLive()) {
-          clearExecutionInfo(store);
+          clearExecutionInfo(store2);
           throw CANCELED;
         }
         const loadable = loadableWithValue$2(value);
-        resolveAsync(store, state, executionID, loadable, depValues);
+        resolveAsync(store2, state, executionID, loadable, depValues);
         return value;
       }).catch((errorOrPromise) => {
         if (!selectorIsLive()) {
-          clearExecutionInfo(store);
+          clearExecutionInfo(store2);
           throw CANCELED;
         }
         if (Recoil_isPromise(errorOrPromise)) {
-          return wrapPendingDependencyPromise(store, errorOrPromise, state, depValues, executionID, loadingDepsState);
+          return wrapPendingDependencyPromise(store2, errorOrPromise, state, depValues, executionID, loadingDepsState);
         }
         const loadable = loadableWithError$1(errorOrPromise);
-        resolveAsync(store, state, executionID, loadable, depValues);
+        resolveAsync(store2, state, executionID, loadable, depValues);
         throw errorOrPromise;
       });
     }
-    function wrapPendingDependencyPromise(store, promise, state, existingDeps, executionID, loadingDepsState) {
+    function wrapPendingDependencyPromise(store2, promise, state, existingDeps, executionID, loadingDepsState) {
       return promise.then((resolvedDep) => {
         if (!selectorIsLive()) {
-          clearExecutionInfo(store);
+          clearExecutionInfo(store2);
           throw CANCELED;
         }
         if (loadingDepsState.loadingDepKey != null && loadingDepsState.loadingDepPromise === promise) {
           state.atomValues.set(loadingDepsState.loadingDepKey, loadableWithValue$2(resolvedDep));
         } else {
-          store.getState().knownSelectors.forEach((nodeKey) => {
+          store2.getState().knownSelectors.forEach((nodeKey) => {
             state.atomValues.delete(nodeKey);
           });
         }
-        const cachedLoadable = getLoadableFromCacheAndUpdateDeps(store, state);
+        const cachedLoadable = getLoadableFromCacheAndUpdateDeps(store2, state);
         if (cachedLoadable && cachedLoadable.state !== "loading") {
-          if (isLatestExecution(store, executionID) || getExecutionInfo(store) == null) {
-            notifyStoresOfResolvedAsync(store, executionID);
+          if (isLatestExecution(store2, executionID) || getExecutionInfo(store2) == null) {
+            notifyStoresOfResolvedAsync(store2, executionID);
           }
           if (cachedLoadable.state === "hasValue") {
             return cachedLoadable.contents;
@@ -6427,15 +6427,15 @@ var __privateWrapper = (obj, member, setter, getter) => ({
             throw cachedLoadable.contents;
           }
         }
-        if (!isLatestExecution(store, executionID)) {
-          const executionInfo = getInProgressExecutionInfo(store, state);
+        if (!isLatestExecution(store2, executionID)) {
+          const executionInfo = getInProgressExecutionInfo(store2, state);
           if (executionInfo != null) {
             return executionInfo.loadingLoadable.contents;
           }
         }
-        const [loadable, depValues] = evaluateSelectorGetter(store, state, executionID);
+        const [loadable, depValues] = evaluateSelectorGetter(store2, state, executionID);
         if (loadable.state !== "loading") {
-          resolveAsync(store, state, executionID, loadable, depValues);
+          resolveAsync(store2, state, executionID, loadable, depValues);
         }
         if (loadable.state === "hasError") {
           throw loadable.contents;
@@ -6446,25 +6446,25 @@ var __privateWrapper = (obj, member, setter, getter) => ({
           throw CANCELED;
         }
         if (!selectorIsLive()) {
-          clearExecutionInfo(store);
+          clearExecutionInfo(store2);
           throw CANCELED;
         }
         const loadable = loadableWithError$1(error);
-        resolveAsync(store, state, executionID, loadable, existingDeps);
+        resolveAsync(store2, state, executionID, loadable, existingDeps);
         throw error;
       });
     }
-    function updateDeps(store, state, deps, executionID) {
+    function updateDeps(store2, state, deps, executionID) {
       var _store$getState, _store$getState$curre, _store$getState2, _store$getState2$next;
-      if (isLatestExecution(store, executionID) || state.version === ((_store$getState = store.getState()) === null || _store$getState === void 0 ? void 0 : (_store$getState$curre = _store$getState.currentTree) === null || _store$getState$curre === void 0 ? void 0 : _store$getState$curre.version) || state.version === ((_store$getState2 = store.getState()) === null || _store$getState2 === void 0 ? void 0 : (_store$getState2$next = _store$getState2.nextTree) === null || _store$getState2$next === void 0 ? void 0 : _store$getState2$next.version)) {
+      if (isLatestExecution(store2, executionID) || state.version === ((_store$getState = store2.getState()) === null || _store$getState === void 0 ? void 0 : (_store$getState$curre = _store$getState.currentTree) === null || _store$getState$curre === void 0 ? void 0 : _store$getState$curre.version) || state.version === ((_store$getState2 = store2.getState()) === null || _store$getState2 === void 0 ? void 0 : (_store$getState2$next = _store$getState2.nextTree) === null || _store$getState2$next === void 0 ? void 0 : _store$getState2$next.version)) {
         var _store$getState$nextT, _store$getState3, _store$getState3$next;
-        saveDepsToStore$1(key, deps, store, (_store$getState$nextT = (_store$getState3 = store.getState()) === null || _store$getState3 === void 0 ? void 0 : (_store$getState3$next = _store$getState3.nextTree) === null || _store$getState3$next === void 0 ? void 0 : _store$getState3$next.version) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree.version);
+        saveDepsToStore$1(key, deps, store2, (_store$getState$nextT = (_store$getState3 = store2.getState()) === null || _store$getState3 === void 0 ? void 0 : (_store$getState3$next = _store$getState3.nextTree) === null || _store$getState3$next === void 0 ? void 0 : _store$getState3$next.version) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store2.getState().currentTree.version);
       }
       for (const nodeKey of deps) {
         discoveredDependencyNodeKeys.add(nodeKey);
       }
     }
-    function evaluateSelectorGetter(store, state, executionID) {
+    function evaluateSelectorGetter(store2, state, executionID) {
       const endPerfBlock = startPerfBlock$1(key);
       let duringSynchronousExecution = true;
       let duringAsynchronousExecution = true;
@@ -6483,11 +6483,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       function getRecoilValue({
         key: depKey
       }) {
-        const depLoadable = getNodeLoadable$2(store, state, depKey);
+        const depLoadable = getNodeLoadable$2(store2, state, depKey);
         depValues.set(depKey, depLoadable);
         if (!duringSynchronousExecution) {
-          updateDeps(store, state, new Set(depValues.keys()), executionID);
-          notifyStoresOfNewAsyncDep(store, executionID);
+          updateDeps(store2, state, new Set(depValues.keys()), executionID);
+          notifyStoresOfNewAsyncDep(store2, executionID);
         }
         switch (depLoadable.state) {
           case "hasValue":
@@ -6508,7 +6508,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
           }
           !(recoilValue != null) ? Recoil_invariant(false) : void 0;
           return recoilCallback$1(
-            store,
+            store2,
             fn,
             args,
             {
@@ -6530,7 +6530,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
           result = result.contents;
         }
         if (Recoil_isPromise(result)) {
-          result = wrapResultPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
+          result = wrapResultPromise(store2, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
         } else {
           finishEvaluation();
         }
@@ -6538,7 +6538,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       } catch (errorOrDepPromise) {
         result = errorOrDepPromise;
         if (Recoil_isPromise(result)) {
-          result = wrapPendingDependencyPromise(store, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
+          result = wrapPendingDependencyPromise(store2, result, state, depValues, executionID, loadingDepsState).finally(finishEvaluation);
         } else {
           resultIsError = true;
           finishEvaluation();
@@ -6552,11 +6552,11 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         loadable = loadableWithValue$2(result);
       }
       duringSynchronousExecution = false;
-      updateExecutionInfoDepValues(store, executionID, depValues);
-      updateDeps(store, state, new Set(depValues.keys()), executionID);
+      updateExecutionInfoDepValues(store2, executionID, depValues);
+      updateDeps(store2, state, new Set(depValues.keys()), executionID);
       return [loadable, depValues];
     }
-    function getLoadableFromCacheAndUpdateDeps(store, state) {
+    function getLoadableFromCacheAndUpdateDeps(store2, state) {
       let cachedLoadable = state.atomValues.get(key);
       if (cachedLoadable != null) {
         return cachedLoadable;
@@ -6565,7 +6565,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       try {
         cachedLoadable = cache2.get((nodeKey) => {
           !(typeof nodeKey === "string") ? false ? Recoil_invariant(false, "Cache nodeKey is type string") : Recoil_invariant(false) : void 0;
-          return getNodeLoadable$2(store, state, nodeKey).contents;
+          return getNodeLoadable$2(store2, state, nodeKey).contents;
         }, {
           onNodeVisit: (node) => {
             if (node.type === "branch" && node.nodeKey !== key) {
@@ -6579,40 +6579,40 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       if (cachedLoadable) {
         var _getExecutionInfo;
         state.atomValues.set(key, cachedLoadable);
-        updateDeps(store, state, depsAfterCacheLookup, (_getExecutionInfo = getExecutionInfo(store)) === null || _getExecutionInfo === void 0 ? void 0 : _getExecutionInfo.executionID);
+        updateDeps(store2, state, depsAfterCacheLookup, (_getExecutionInfo = getExecutionInfo(store2)) === null || _getExecutionInfo === void 0 ? void 0 : _getExecutionInfo.executionID);
       }
       return cachedLoadable;
     }
-    function getSelectorLoadableAndUpdateDeps(store, state) {
-      const cachedVal = getLoadableFromCacheAndUpdateDeps(store, state);
+    function getSelectorLoadableAndUpdateDeps(store2, state) {
+      const cachedVal = getLoadableFromCacheAndUpdateDeps(store2, state);
       if (cachedVal != null) {
-        clearExecutionInfo(store);
+        clearExecutionInfo(store2);
         return cachedVal;
       }
-      const inProgressExecutionInfo = getInProgressExecutionInfo(store, state);
+      const inProgressExecutionInfo = getInProgressExecutionInfo(store2, state);
       if (inProgressExecutionInfo != null) {
         var _inProgressExecutionI;
         if (((_inProgressExecutionI = inProgressExecutionInfo.loadingLoadable) === null || _inProgressExecutionI === void 0 ? void 0 : _inProgressExecutionI.state) === "loading") {
-          markStoreWaitingForResolvedAsync(store, inProgressExecutionInfo.executionID);
+          markStoreWaitingForResolvedAsync(store2, inProgressExecutionInfo.executionID);
         }
         return inProgressExecutionInfo.loadingLoadable;
       }
       const newExecutionID = getNewExecutionID();
-      const [loadable, newDepValues] = evaluateSelectorGetter(store, state, newExecutionID);
+      const [loadable, newDepValues] = evaluateSelectorGetter(store2, state, newExecutionID);
       if (loadable.state === "loading") {
-        setExecutionInfo(store, newExecutionID, loadable, newDepValues, state);
-        markStoreWaitingForResolvedAsync(store, newExecutionID);
+        setExecutionInfo(store2, newExecutionID, loadable, newDepValues, state);
+        markStoreWaitingForResolvedAsync(store2, newExecutionID);
       } else {
-        clearExecutionInfo(store);
+        clearExecutionInfo(store2);
         setCache(state, loadable, newDepValues);
       }
       return loadable;
     }
-    function getInProgressExecutionInfo(store, state) {
-      const pendingExecutions = Recoil_concatIterables([executionInfoMap.has(store) ? [Recoil_nullthrows$1(executionInfoMap.get(store))] : [], Recoil_mapIterable(Recoil_filterIterable(executionInfoMap, ([s]) => s !== store), ([, execInfo]) => execInfo)]);
+    function getInProgressExecutionInfo(store2, state) {
+      const pendingExecutions = Recoil_concatIterables([executionInfoMap.has(store2) ? [Recoil_nullthrows$1(executionInfoMap.get(store2))] : [], Recoil_mapIterable(Recoil_filterIterable(executionInfoMap, ([s]) => s !== store2), ([, execInfo]) => execInfo)]);
       function anyDepChanged(execDepValues) {
         for (const [depKey, execLoadable] of execDepValues) {
-          if (!getNodeLoadable$2(store, state, depKey).is(execLoadable)) {
+          if (!getNodeLoadable$2(store2, state, depKey).is(execLoadable)) {
             return true;
           }
         }
@@ -6628,31 +6628,31 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       }
       return void 0;
     }
-    function getExecutionInfo(store) {
-      return executionInfoMap.get(store);
+    function getExecutionInfo(store2) {
+      return executionInfoMap.get(store2);
     }
-    function setExecutionInfo(store, newExecutionID, loadable, depValues, state) {
-      executionInfoMap.set(store, {
+    function setExecutionInfo(store2, newExecutionID, loadable, depValues, state) {
+      executionInfoMap.set(store2, {
         depValuesDiscoveredSoFarDuringAsyncWork: depValues,
         executionID: newExecutionID,
         loadingLoadable: loadable,
         stateVersions: /* @__PURE__ */ new Map([[state.version, true]])
       });
     }
-    function updateExecutionInfoDepValues(store, executionID, depValues) {
-      if (isLatestExecution(store, executionID)) {
-        const executionInfo = getExecutionInfo(store);
+    function updateExecutionInfoDepValues(store2, executionID, depValues) {
+      if (isLatestExecution(store2, executionID)) {
+        const executionInfo = getExecutionInfo(store2);
         if (executionInfo != null) {
           executionInfo.depValuesDiscoveredSoFarDuringAsyncWork = depValues;
         }
       }
     }
-    function clearExecutionInfo(store) {
-      executionInfoMap.delete(store);
+    function clearExecutionInfo(store2) {
+      executionInfoMap.delete(store2);
     }
-    function isLatestExecution(store, executionID) {
+    function isLatestExecution(store2, executionID) {
       var _getExecutionInfo2;
-      return executionID === ((_getExecutionInfo2 = getExecutionInfo(store)) === null || _getExecutionInfo2 === void 0 ? void 0 : _getExecutionInfo2.executionID);
+      return executionID === ((_getExecutionInfo2 = getExecutionInfo(store2)) === null || _getExecutionInfo2 === void 0 ? void 0 : _getExecutionInfo2.executionID);
     }
     function depValuesToDepRoute(depValues) {
       return Array.from(depValues.entries()).map(([depKey, valLoadable]) => [depKey, valLoadable.contents]);
@@ -6677,7 +6677,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         dependencyStack.pop();
       }
     }
-    function selectorPeek(store, state) {
+    function selectorPeek(store2, state) {
       const cachedLoadable = state.atomValues.get(key);
       if (cachedLoadable != null) {
         return cachedLoadable;
@@ -6685,29 +6685,29 @@ var __privateWrapper = (obj, member, setter, getter) => ({
       return cache2.get((nodeKey) => {
         var _peekNodeLoadable;
         !(typeof nodeKey === "string") ? Recoil_invariant(false) : void 0;
-        return (_peekNodeLoadable = peekNodeLoadable$1(store, state, nodeKey)) === null || _peekNodeLoadable === void 0 ? void 0 : _peekNodeLoadable.contents;
+        return (_peekNodeLoadable = peekNodeLoadable$1(store2, state, nodeKey)) === null || _peekNodeLoadable === void 0 ? void 0 : _peekNodeLoadable.contents;
       });
     }
-    function selectorGet(store, state) {
-      return detectCircularDependencies(() => getSelectorLoadableAndUpdateDeps(store, state));
+    function selectorGet(store2, state) {
+      return detectCircularDependencies(() => getSelectorLoadableAndUpdateDeps(store2, state));
     }
     function invalidateSelector(state) {
       state.atomValues.delete(key);
     }
-    function clearSelectorCache(store, treeState) {
+    function clearSelectorCache(store2, treeState) {
       !(recoilValue != null) ? Recoil_invariant(false) : void 0;
       for (const nodeKey of discoveredDependencyNodeKeys) {
         var _node$clearCache;
         const node = getNode$6(nodeKey);
-        (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store, treeState);
+        (_node$clearCache = node.clearCache) === null || _node$clearCache === void 0 ? void 0 : _node$clearCache.call(node, store2, treeState);
       }
       discoveredDependencyNodeKeys.clear();
       invalidateSelector(treeState);
       cache2.clear();
-      markRecoilValueModified$1(store, recoilValue);
+      markRecoilValueModified$1(store2, recoilValue);
     }
     if (set2 != null) {
-      const selectorSet = (store, state, newValue) => {
+      const selectorSet = (store2, state, newValue) => {
         let syncSelectorSetFinished = false;
         const writes = /* @__PURE__ */ new Map();
         function getRecoilValue({
@@ -6716,7 +6716,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
           if (syncSelectorSetFinished) {
             throw Recoil_err$2("Recoil: Async selector sets are not currently supported.");
           }
-          const loadable = getNodeLoadable$2(store, state, depKey);
+          const loadable = getNodeLoadable$2(store2, state, depKey);
           if (loadable.state === "hasValue") {
             return loadable.contents;
           } else if (loadable.state === "loading") {
@@ -6732,7 +6732,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
             throw Recoil_err$2(msg);
           }
           const setValue = typeof valueOrUpdater === "function" ? valueOrUpdater(getRecoilValue(recoilState)) : valueOrUpdater;
-          const upstreamWrites = setNodeValue$3(store, state, recoilState.key, setValue);
+          const upstreamWrites = setNodeValue$3(store2, state, recoilState.key, setValue);
           upstreamWrites.forEach((v2, k2) => writes.set(k2, v2));
         }
         function resetRecoilState(recoilState) {
@@ -6836,40 +6836,40 @@ var __privateWrapper = (obj, member, setter, getter) => ({
     function maybeFreezeValueOrPromise(valueOrPromise) {
       return valueOrPromise;
     }
-    function wrapPendingPromise(store, promise) {
+    function wrapPendingPromise(store2, promise) {
       const wrappedPromise = promise.then((value) => {
         var _store$getState$nextT, _state$atomValues$get;
-        const state = (_store$getState$nextT = store.getState().nextTree) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store.getState().currentTree;
+        const state = (_store$getState$nextT = store2.getState().nextTree) !== null && _store$getState$nextT !== void 0 ? _store$getState$nextT : store2.getState().currentTree;
         if (((_state$atomValues$get = state.atomValues.get(key)) === null || _state$atomValues$get === void 0 ? void 0 : _state$atomValues$get.contents) === wrappedPromise) {
-          setRecoilValue$4(store, node, value);
+          setRecoilValue$4(store2, node, value);
         }
         return value;
       }).catch((error) => {
         var _store$getState$nextT2, _state$atomValues$get2;
-        const state = (_store$getState$nextT2 = store.getState().nextTree) !== null && _store$getState$nextT2 !== void 0 ? _store$getState$nextT2 : store.getState().currentTree;
+        const state = (_store$getState$nextT2 = store2.getState().nextTree) !== null && _store$getState$nextT2 !== void 0 ? _store$getState$nextT2 : store2.getState().currentTree;
         if (((_state$atomValues$get2 = state.atomValues.get(key)) === null || _state$atomValues$get2 === void 0 ? void 0 : _state$atomValues$get2.contents) === wrappedPromise) {
-          setRecoilValueLoadable$2(store, node, loadableWithError$2(error));
+          setRecoilValueLoadable$2(store2, node, loadableWithError$2(error));
         }
         throw error;
       });
       return wrappedPromise;
     }
-    function initAtom(store, initState, trigger) {
+    function initAtom(store2, initState, trigger) {
       var _options$effects;
       liveStoresCount++;
       const cleanupAtom = () => {
         var _cleanupEffectsByStor;
         liveStoresCount--;
-        (_cleanupEffectsByStor = cleanupEffectsByStore.get(store)) === null || _cleanupEffectsByStor === void 0 ? void 0 : _cleanupEffectsByStor.forEach((cleanup) => cleanup());
-        cleanupEffectsByStore.delete(store);
+        (_cleanupEffectsByStor = cleanupEffectsByStore.get(store2)) === null || _cleanupEffectsByStor === void 0 ? void 0 : _cleanupEffectsByStor.forEach((cleanup) => cleanup());
+        cleanupEffectsByStore.delete(store2);
       };
-      store.getState().knownAtoms.add(key);
+      store2.getState().knownAtoms.add(key);
       if (defaultLoadable.state === "loading") {
         const notifyDefaultSubscribers = () => {
           var _store$getState$nextT3;
-          const state = (_store$getState$nextT3 = store.getState().nextTree) !== null && _store$getState$nextT3 !== void 0 ? _store$getState$nextT3 : store.getState().currentTree;
+          const state = (_store$getState$nextT3 = store2.getState().nextTree) !== null && _store$getState$nextT3 !== void 0 ? _store$getState$nextT3 : store2.getState().currentTree;
           if (!state.atomValues.has(key)) {
-            markRecoilValueModified$2(store, node);
+            markRecoilValueModified$2(store2, node);
           }
         };
         defaultLoadable.contents.finally(notifyDefaultSubscribers);
@@ -6879,14 +6879,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         let getLoadable = function(recoilValue) {
           if (isDuringInit && recoilValue.key === key) {
             const retValue = initValue;
-            return retValue instanceof DefaultValue$2$1 ? peekAtom(store, initState) : Recoil_isPromise(retValue) ? loadableWithPromise$2(retValue.then((v2) => v2 instanceof DefaultValue$2$1 ? defaultLoadable.toPromise() : v2)) : loadableWithValue$3(retValue);
+            return retValue instanceof DefaultValue$2$1 ? peekAtom(store2, initState) : Recoil_isPromise(retValue) ? loadableWithPromise$2(retValue.then((v2) => v2 instanceof DefaultValue$2$1 ? defaultLoadable.toPromise() : v2)) : loadableWithValue$3(retValue);
           }
-          return getRecoilValueAsLoadable$4(store, recoilValue);
+          return getRecoilValueAsLoadable$4(store2, recoilValue);
         }, getPromise = function(recoilValue) {
           return getLoadable(recoilValue).toPromise();
         }, getInfo_UNSTABLE = function(recoilValue) {
           var _store$getState$nextT4;
-          const info = peekNodeInfo$3(store, (_store$getState$nextT4 = store.getState().nextTree) !== null && _store$getState$nextT4 !== void 0 ? _store$getState$nextT4 : store.getState().currentTree, recoilValue.key);
+          const info = peekNodeInfo$3(store2, (_store$getState$nextT4 = store2.getState().nextTree) !== null && _store$getState$nextT4 !== void 0 ? _store$getState$nextT4 : store2.getState().currentTree, recoilValue.key);
           return isDuringInit && recoilValue.key === key && !(initValue instanceof DefaultValue$2$1) ? {
             ...info,
             isSet: true,
@@ -6921,7 +6921,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
                 value: unwrap(valueOrUpdater)
               };
             }
-            setRecoilValue$4(store, node, typeof valueOrUpdater === "function" ? (currentValue) => {
+            setRecoilValue$4(store2, node, typeof valueOrUpdater === "function" ? (currentValue) => {
               const newValue = unwrap(
                 valueOrUpdater(currentValue)
               );
@@ -6938,7 +6938,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
           var _cleanupEffectsByStor2;
           const {
             release
-          } = store.subscribeToTransactions((currentStore) => {
+          } = store2.subscribeToTransactions((currentStore) => {
             var _currentTree$atomValu;
             let {
               currentTree,
@@ -6960,14 +6960,14 @@ var __privateWrapper = (obj, member, setter, getter) => ({
               }
             }
           }, key);
-          cleanupEffectsByStore.set(store, [...(_cleanupEffectsByStor2 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor2 !== void 0 ? _cleanupEffectsByStor2 : [], release]);
+          cleanupEffectsByStore.set(store2, [...(_cleanupEffectsByStor2 = cleanupEffectsByStore.get(store2)) !== null && _cleanupEffectsByStor2 !== void 0 ? _cleanupEffectsByStor2 : [], release]);
         };
         for (const effect2 of effects) {
           try {
             const cleanup = effect2({
               node,
-              storeID: store.storeID,
-              parentStoreID_UNSTABLE: store.parentStoreID,
+              storeID: store2.storeID,
+              parentStoreID_UNSTABLE: store2.parentStoreID,
               trigger,
               setSelf: setSelf(effect2),
               resetSelf: resetSelf(effect2),
@@ -6978,7 +6978,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
             });
             if (cleanup != null) {
               var _cleanupEffectsByStor3;
-              cleanupEffectsByStore.set(store, [...(_cleanupEffectsByStor3 = cleanupEffectsByStore.get(store)) !== null && _cleanupEffectsByStor3 !== void 0 ? _cleanupEffectsByStor3 : [], cleanup]);
+              cleanupEffectsByStore.set(store2, [...(_cleanupEffectsByStor3 = cleanupEffectsByStore.get(store2)) !== null && _cleanupEffectsByStor3 !== void 0 ? _cleanupEffectsByStor3 : [], cleanup]);
             }
           } catch (error) {
             initValue = error;
@@ -6988,10 +6988,10 @@ var __privateWrapper = (obj, member, setter, getter) => ({
         isDuringInit = false;
         if (!(initValue instanceof DefaultValue$2$1)) {
           var _store$getState$nextT5;
-          const initLoadable = isInitError ? loadableWithError$2(initValue) : Recoil_isPromise(initValue) ? loadableWithPromise$2(wrapPendingPromise(store, initValue)) : loadableWithValue$3(unwrap(initValue));
+          const initLoadable = isInitError ? loadableWithError$2(initValue) : Recoil_isPromise(initValue) ? loadableWithPromise$2(wrapPendingPromise(store2, initValue)) : loadableWithValue$3(unwrap(initValue));
           maybeFreezeValueOrPromise(initLoadable.contents);
           initState.atomValues.set(key, initLoadable);
-          (_store$getState$nextT5 = store.getState().nextTree) === null || _store$getState$nextT5 === void 0 ? void 0 : _store$getState$nextT5.atomValues.set(key, initLoadable);
+          (_store$getState$nextT5 = store2.getState().nextTree) === null || _store$getState$nextT5 === void 0 ? void 0 : _store$getState$nextT5.atomValues.set(key, initLoadable);
         }
       }
       return cleanupAtom;
@@ -54952,13 +54952,80 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
     return baseClone$1(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG$1);
   }
   var cloneDeep_1 = cloneDeep;
+  class GlobalStore {
+    constructor() {
+      __privateAdd(this, _locks, void 0);
+      __privateAdd(this, _subscribers, void 0);
+      __privateSet(this, _locks, {});
+      __privateSet(this, _subscribers, {});
+    }
+    clear() {
+      __privateSet(this, _locks, {});
+      __privateSet(this, _subscribers, {});
+    }
+    async getValue(key) {
+      if (__privateGet(this, _locks)[key]) {
+        return __privateGet(this, _locks)[key];
+      }
+      return localStorage.getItem(key);
+    }
+    getValueSync(key) {
+      return localStorage.getItem(key);
+    }
+    setValue(key, value) {
+      if (value === null) {
+        localStorage.removeItem(key);
+      } else {
+        localStorage.setItem(key, value);
+      }
+    }
+    async replaceValue(key, fn) {
+      if (__privateGet(this, _locks)[key]) {
+        return __privateGet(this, _locks)[key];
+      }
+      let unlock;
+      let unlockError;
+      const lockPromise = new Promise((resolve, reject) => {
+        unlock = resolve;
+        unlockError = reject;
+      });
+      __privateGet(this, _locks)[key] = lockPromise;
+      let result;
+      try {
+        result = await fn();
+        this.setValue(key, result);
+        unlock(result);
+      } catch (e3) {
+        unlockError(e3);
+      } finally {
+        delete __privateGet(this, _locks)[key];
+      }
+      return lockPromise;
+    }
+    subscribe(key, callback) {
+      if (!__privateGet(this, _subscribers)[key]) {
+        __privateGet(this, _subscribers)[key] = [];
+      }
+      const subFunc = (e3) => {
+        if (e3.storageArea === localStorage && e3.key === key) {
+          callback(e3.newValue);
+        }
+      };
+      window.addEventListener("storage", subFunc);
+      return () => {
+        window.removeEventListener("storage", subFunc);
+      };
+    }
+  }
+  _locks = new WeakMap();
+  _subscribers = new WeakMap();
+  const store = new GlobalStore();
   class RequestExtrasSerializable {
     constructor(extras) {
       __publicField(this, "extras");
       this.extras = extras;
     }
     toSerializable() {
-      var _a;
       if (!this.extras) {
         return null;
       }
@@ -54966,9 +55033,9 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
         return this.extras;
       }
       const serializable = cloneDeep_1(this.extras);
-      if ((_a = serializable.options) == null ? void 0 : _a.headers) {
-        const headers = new Headers(serializable.options.headers);
-        serializable.options.headers = Object.fromEntries(headers.entries());
+      if (serializable == null ? void 0 : serializable.headers) {
+        const headers = new Headers(serializable.headers);
+        serializable.headers = Object.fromEntries(headers.entries());
       }
       return serializable;
     }
@@ -54982,8 +55049,8 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
   }
   async function request(url, options, extras) {
     var _a, _b;
-    const sessionToken = typeof extras === "string" ? extras : extras == null ? void 0 : extras.sessionToken;
-    const mergedOptions = extras && typeof extras === "object" ? { ...options, ...extras.options } : options;
+    const sessionToken = await store.getValue(getTokenKey());
+    const mergedOptions = extras ? { ...options, ...extras } : options;
     const { headers, ...other } = mergedOptions;
     const headersInterface = new Headers(headers);
     if (!headersInterface.has("Accept")) {
@@ -54997,18 +55064,35 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
     }
     const baseUrl = (_b = (_a = window.dara) == null ? void 0 : _a.base_url) != null ? _b : "";
     const urlString = url instanceof URL ? url.pathname + url.search : url;
-    return fetch(baseUrl + urlString, {
+    const response = await fetch(baseUrl + urlString, {
       headers: headersInterface,
       ...other
     });
-  }
-  const authCtx = React__namespace.createContext({ setToken: noop_1, token: "" });
-  function useAuthCtx() {
-    return React__namespace.useContext(authCtx);
-  }
-  function useSessionToken() {
-    const { token } = React__namespace.useContext(authCtx);
-    return token;
+    if (response.status === 401 || response.status === 403) {
+      try {
+        const refreshedToken = await store.replaceValue(getTokenKey(), async () => {
+          const refreshResponse = await fetch(`${baseUrl}/api/auth/refresh-token`, {
+            headers: headersInterface,
+            ...other,
+            method: "POST"
+          });
+          if (refreshResponse.ok) {
+            const { token } = await refreshResponse.json();
+            return token;
+          }
+          await validateResponse(refreshResponse, "Request auth error, failed to refresh the session token");
+        });
+        headersInterface.set("Authorization", `Bearer ${refreshedToken}`);
+        return fetch(baseUrl + urlString, {
+          headers: headersInterface,
+          ...other
+        });
+      } catch (e3) {
+        console.error("Failed to refresh token", e3);
+        return response;
+      }
+    }
+    return response;
   }
   const directionCtx = React.createContext({ direction: "row" });
   const importersCtx = React.createContext({});
@@ -55930,14 +56014,10 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
   }
   const requestExtrasCtx = React.createContext({ options: {} });
   function useRequestExtras() {
-    const sessionToken = useSessionToken();
     const { options } = React.useContext(requestExtrasCtx);
     const extras = React.useMemo(() => {
-      return {
-        options,
-        sessionToken
-      };
-    }, [useDeepCompare(options), sessionToken]);
+      return options;
+    }, [useDeepCompare(options)]);
     return extras;
   }
   function RequestExtrasProvider({
@@ -56052,11 +56132,11 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
       message.reason
     );
   }
-  function useAuthComponents() {
+  function useAuthConfig() {
     return reactQuery.useQuery(
-      ["auth-components"],
+      ["auth-config"],
       async () => {
-        const response = await request("/api/core/auth-components", {
+        const response = await request("/api/core/auth-config", {
           method: HTTP_METHOD.GET
         });
         return response.json();
@@ -56064,23 +56144,17 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
       { refetchOnWindowFocus: false }
     );
   }
-  async function revokeSession(token) {
-    if (token) {
-      try {
-        const response = await request(
-          "/api/auth/revoke-session",
-          {
-            method: HTTP_METHOD.POST
-          },
-          token
-        );
-        if (response.ok) {
-          const responseData = await response.json();
-          return responseData;
-        }
-      } catch (e3) {
-        console.error("Failed to revoke session", e3);
+  async function revokeSession() {
+    try {
+      const response = await request("/api/auth/revoke-session", {
+        method: HTTP_METHOD.POST
+      });
+      if (response.ok) {
+        const responseData = await response.json();
+        return responseData;
       }
+    } catch (e3) {
+      console.error("Failed to revoke session", e3);
     }
   }
   async function handleAuthErrors(res, toLogin = false, ignoreErrors = null) {
@@ -56109,7 +56183,7 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
       refetchOnWindowFocus: false
     });
   }
-  async function getSessionToken(body = {}) {
+  async function requestSessionToken(body = {}) {
     const res = await request("/api/auth/session", {
       body: JSON.stringify(body),
       method: HTTP_METHOD.POST
@@ -56124,14 +56198,10 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
     localStorage.setItem(getTokenKey(), token);
     return token;
   }
-  async function verifySessionToken(token) {
-    const res = await request(
-      "/api/auth/verify-session",
-      {
-        method: HTTP_METHOD.POST
-      },
-      token
-    );
+  async function verifySessionToken() {
+    const res = await request("/api/auth/verify-session", {
+      method: HTTP_METHOD.POST
+    });
     return res.ok;
   }
   function isPlaceholder(value) {
@@ -56496,6 +56566,16 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
         );
       }
     }
+    updateToken(newToken) {
+      if (this.socket.readyState === WebSocket.OPEN) {
+        this.socket.send(
+          JSON.stringify({
+            message: newToken,
+            type: "token_update"
+          })
+        );
+      }
+    }
     sendCustomMessage(kind, data, awaitResponse = false) {
       if (this.socket.readyState === WebSocket.OPEN) {
         if (awaitResponse) {
@@ -58015,6 +58095,18 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
     }
     return resolver(getOrRegisterPlainVariable(variable, client, taskContext, extras));
   }
+  function onTokenChange(cb) {
+    return store.subscribe(getTokenKey(), cb);
+  }
+  function getSessionToken() {
+    return store.getValueSync(getTokenKey());
+  }
+  function setSessionToken(token) {
+    store.setValue(getTokenKey(), token);
+  }
+  function useSessionToken() {
+    return React__namespace.useSyncExternalStore(onTokenChange, getSessionToken);
+  }
   const STORE_EXTRAS_MAP = /* @__PURE__ */ new Map();
   function BackendStoreSync({ children }) {
     const { client } = React__namespace.useContext(websocketCtx);
@@ -58072,55 +58164,44 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
       storeKey: "BackendStore"
     });
   }
-  function getSessionKey(extras, uid2) {
-    const sessionToken = typeof extras === "string" ? extras : extras.sessionToken;
+  function getSessionKey(uid2) {
     if (isEmbedded()) {
       return `dara-session-${window.frameElement.dataset.daraPageId}-var-${uid2}`;
     }
-    return `dara-session-${sessionToken}-var-${uid2}`;
+    return `dara-session-${getSessionToken()}-var-${uid2}`;
   }
   function BrowserStoreSync({ children }) {
-    const extras = useRequestExtras();
-    const getStoreValue = React__namespace.useCallback(
-      (itemKey) => {
+    const getStoreValue = React__namespace.useCallback((itemKey) => {
+      var _a;
+      const key = getSessionKey(itemKey);
+      return JSON.parse((_a = localStorage.getItem(key)) != null ? _a : "null");
+    }, []);
+    const syncStoreValues = React__namespace.useCallback(({ diff }) => {
+      for (const [itemKey, value] of diff.entries()) {
+        const key = getSessionKey(itemKey);
+        localStorage.setItem(key, JSON.stringify(value));
+      }
+    }, []);
+    const listenToStoreChanges = React__namespace.useCallback(({ updateItem }) => {
+      const listener2 = (e3) => {
         var _a;
-        const key = getSessionKey(extras, itemKey);
-        return JSON.parse((_a = localStorage.getItem(key)) != null ? _a : "null");
-      },
-      [extras]
-    );
-    const syncStoreValues = React__namespace.useCallback(
-      ({ diff }) => {
-        for (const [itemKey, value] of diff.entries()) {
-          const key = getSessionKey(extras, itemKey);
-          localStorage.setItem(key, JSON.stringify(value));
-        }
-      },
-      [extras]
-    );
-    const listenToStoreChanges = React__namespace.useCallback(
-      ({ updateItem }) => {
-        const listener2 = (e3) => {
-          var _a;
-          if (e3.storageArea === localStorage) {
-            if (e3.key) {
-              const match2 = e3.key.match(/^dara-session-(.*)-var-(.*)$/);
-              if (match2) {
-                const [, sessionToken, uid2] = match2;
-                if (typeof extras === "string" && sessionToken === extras || typeof extras === "object" && extras.sessionToken === sessionToken) {
-                  updateItem(uid2, JSON.parse((_a = e3.newValue) != null ? _a : "null"));
-                }
+        if (e3.storageArea === localStorage) {
+          if (e3.key) {
+            const match2 = e3.key.match(/^dara-session-(.*)-var-(.*)$/);
+            if (match2) {
+              const [, sessionToken, uid2] = match2;
+              if (sessionToken === getSessionToken()) {
+                updateItem(uid2, JSON.parse((_a = e3.newValue) != null ? _a : "null"));
               }
             }
           }
-        };
-        window.addEventListener("storage", listener2);
-        return () => {
-          window.removeEventListener("storage", listener2);
-        };
-      },
-      [extras]
-    );
+        }
+      };
+      window.addEventListener("storage", listener2);
+      return () => {
+        window.removeEventListener("storage", listener2);
+      };
+    }, []);
     return /* @__PURE__ */ React__namespace.createElement(RecoilSync_index_1, { listen: listenToStoreChanges, read: getStoreValue, storeKey: "BrowserStore", write: syncStoreValues }, children);
   }
   function localStorageEffect(variable, extrasSerializable, wsClient, taskContext) {
@@ -59036,26 +59117,21 @@ Inferred class string: "${iconClasses}."`
       }).catch((err2) => {
         throw new Error(`Failed to import module ${props.component.py_module}`, err2);
       });
-    }, [props.component]);
+    }, [props.component, importers]);
     return component;
   }
   function AuthWrapper(props) {
-    const [token, setToken] = React.useState(() => getToken());
-    const { data: authComponents, isLoading } = useAuthComponents();
-    function onSetToken(newToken) {
-      const key = getTokenKey();
-      if (newToken) {
-        localStorage.setItem(key, newToken);
-      } else {
-        localStorage.removeItem(key);
-      }
-      setToken(newToken);
+    const { data: authConfig, isLoading } = useAuthConfig();
+    const isMounted = React.useRef(false);
+    if (!isMounted.current) {
+      isMounted.current = true;
+      setSessionToken(getToken());
     }
     if (isLoading) {
       return /* @__PURE__ */ React__default.default.createElement(Center, null, /* @__PURE__ */ React__default.default.createElement(DefaultFallback, null));
     }
-    const { login, logout, ...extraRoutes } = authComponents;
-    return /* @__PURE__ */ React__default.default.createElement(authCtx.Provider, { value: { setToken: onSetToken, token } }, /* @__PURE__ */ React__default.default.createElement(Switch$1, null, /* @__PURE__ */ React__default.default.createElement(Route, { path: "/login" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: login })), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/logout" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: logout })), Object.entries(extraRoutes).map(([path, component]) => /* @__PURE__ */ React__default.default.createElement(Route, { key: path, path: `/${path}` }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component }))), /* @__PURE__ */ React__default.default.createElement(Route, { component: ErrorPage, path: "/error" }), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/", render: () => /* @__PURE__ */ React__default.default.createElement(PrivateRoute, null, props.children) })));
+    const { login, logout, ...extraRoutes } = authConfig.auth_components;
+    return /* @__PURE__ */ React__default.default.createElement(Switch$1, null, /* @__PURE__ */ React__default.default.createElement(Route, { path: "/login" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: login })), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/logout" }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component: logout })), Object.entries(extraRoutes).map(([path, component]) => /* @__PURE__ */ React__default.default.createElement(Route, { key: path, path: `/${path}` }, /* @__PURE__ */ React__default.default.createElement(DynamicAuthComponent, { component }))), /* @__PURE__ */ React__default.default.createElement(Route, { component: ErrorPage, path: "/error" }), /* @__PURE__ */ React__default.default.createElement(Route, { path: "/", render: () => /* @__PURE__ */ React__default.default.createElement(PrivateRoute, null, props.children) }));
   }
   const index = "";
   const ErrorBoundaryContext = React.createContext(null);
@@ -60323,6 +60399,14 @@ Inferred class string: "${iconClasses}."`
     React.useEffect(() => {
       cleanSessionCache(token);
     }, [token]);
+    React.useEffect(() => {
+      if (!wsClient) {
+        return;
+      }
+      return onTokenChange((newToken) => {
+        wsClient.updateToken(newToken);
+      });
+    }, [wsClient]);
     React.useEffect(() => {
       if (config2 == null ? void 0 : config2.title) {
         document.title = config2.title;
@@ -85913,7 +85997,6 @@ Inferred class string: "${iconClasses}."`
     const [username, setUsername] = React.useState("");
     const [password, setPassword] = React.useState("");
     const [isError2, setIsError] = React.useState(false);
-    const { token, setToken } = React.useContext(authCtx);
     const history2 = useHistory();
     const location2 = useLocation();
     const queryParams = new URLSearchParams(location2.search);
@@ -85922,9 +86005,9 @@ Inferred class string: "${iconClasses}."`
       setIsLoggingIn(true);
       setIsError(false);
       try {
-        const sessionToken = await getSessionToken({ password, username });
+        const sessionToken = await requestSessionToken({ password, username });
         if (sessionToken) {
-          setToken(sessionToken);
+          setSessionToken(sessionToken);
           history2.replace(decodeURIComponent(previousLocation));
         }
       } catch {
@@ -85933,9 +86016,8 @@ Inferred class string: "${iconClasses}."`
       setIsLoggingIn(false);
     };
     React.useEffect(() => {
-      const key = getTokenKey();
-      if (token) {
-        verifySessionToken(localStorage.getItem(key)).then((verified) => {
+      if (getSessionToken()) {
+        verifySessionToken().then((verified) => {
           if (verified) {
             history2.replace(decodeURIComponent(previousLocation));
           } else {
@@ -85993,10 +86075,9 @@ Inferred class string: "${iconClasses}."`
     ))));
   }
   function BasicAuthLogout() {
-    const { setToken, token } = useAuthCtx();
     React.useEffect(() => {
-      revokeSession(token).then(() => {
-        setToken(null);
+      revokeSession().then(() => {
+        setSessionToken(null);
         window.location.href = `${window.dara.base_url}/login`;
       });
     }, []);
@@ -86004,26 +86085,20 @@ Inferred class string: "${iconClasses}."`
   }
   function DefaultAuthLogin() {
     var _a;
-    const { token, setToken } = React.useContext(authCtx);
     const history2 = useHistory();
     const location2 = useLocation();
     const queryParams = new URLSearchParams(location2.search);
     const previousLocation = (_a = queryParams.get("referrer")) != null ? _a : "/";
     async function getNewToken() {
-      const sessionToken = await getSessionToken({});
+      const sessionToken = await requestSessionToken({});
       if (sessionToken) {
-        setToken(sessionToken);
+        setSessionToken(sessionToken);
         history2.replace(decodeURIComponent(previousLocation));
       }
     }
     React.useEffect(() => {
-      const key = getTokenKey();
-      if (token) {
-        const storedToken = localStorage.getItem(key);
-        if (token !== void 0 && token !== null && (!storedToken || storedToken === "undefined")) {
-          localStorage.setItem(key, token);
-        }
-        verifySessionToken(localStorage.getItem(key)).then((verified) => {
+      if (getSessionToken()) {
+        verifySessionToken().then((verified) => {
           if (verified) {
             history2.replace(decodeURIComponent(previousLocation));
           } else {
@@ -86378,6 +86453,7 @@ Inferred class string: "${iconClasses}."`
   exports.combineFilters = combineFilters;
   exports.default = run;
   exports.getIcon = getIcon;
+  exports.getSessionToken = getSessionToken;
   exports.getToken = getToken;
   exports.getTokenKey = getTokenKey;
   exports.handleAuthErrors = handleAuthErrors;
@@ -86388,10 +86464,10 @@ Inferred class string: "${iconClasses}."`
   exports.request = request;
   exports.resolveValue = resolveValue;
   exports.revokeSession = revokeSession;
+  exports.setSessionToken = setSessionToken;
   exports.useAction = useAction;
   exports.useActionIsLoading = useActionIsLoading;
   exports.useAnyVariable = useAnyVariable;
-  exports.useAuthCtx = useAuthCtx;
   exports.useComponentStyles = useComponentStyles;
   exports.useDataVariable = useDataVariable;
   exports.useEventBus = useEventBus;