atom.io 0.27.5 → 0.28.0

package/dist/{chunk-6ABWLAGY.js → chunk-BX3MTH2Z.js}

@@ -67,6 +67,37 @@ function eldest(scion) {
   }
   return scion;
 }
+var FAMILY_MEMBER_TOKEN_TYPES = {
+  atom_family: `atom`,
+  mutable_atom_family: `mutable_atom`,
+  selector_family: `selector`,
+  readonly_selector_family: `readonly_selector`,
+  molecule_family: `molecule`
+};
+function counterfeit(token, key) {
+  const subKey = stringifyJson(key);
+  const fullKey = `${token.key}(${subKey})`;
+  const type = FAMILY_MEMBER_TOKEN_TYPES[token.type];
+  const stateToken = {
+    key: fullKey,
+    type
+  };
+  if (type === `molecule`) {
+    Object.assign(stateToken, {
+      key,
+      family: token
+    });
+  } else {
+    Object.assign(stateToken, {
+      family: {
+        key: token.key,
+        subKey
+      }
+    });
+  }
+  Object.assign(stateToken, { counterfeit: true });
+  return stateToken;
+}
 
 // internal/src/store/deposit.ts
 function deposit(state) {
@@ -145,22 +176,7 @@ var abortTransaction = (store) => {
 // internal/src/pretty-print.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
-  switch (token.type) {
-    case `atom_family`:
-      return `Atom Family`;
-    case `molecule_family`:
-      return `Molecule Family`;
-    case `mutable_atom_family`:
-      return `Mutable Atom Family`;
-    case `readonly_selector`:
-      return `Readonly Selector`;
-    case `readonly_selector_family`:
-      return `Readonly Selector Family`;
-    case `selector_family`:
-      return `Selector Family`;
-    default:
-      return capitalize(token.type);
-  }
+  return token.type.split(`_`).map(capitalize).join(` `);
 }
 
 // internal/src/not-found-error.ts
@@ -490,6 +506,8 @@ function createAtomFamily(store, options) {
   }
   return createRegularAtomFamily(store, options);
 }
+
+// internal/src/get-state/get-from-store.ts
 function getFromStore(store, ...params) {
   let token;
   if (params.length === 1) {
@@ -497,35 +515,47 @@ function getFromStore(store, ...params) {
   } else {
     const family = params[0];
     const key = params[1];
-    const maybeToken = family.type === `molecule_family` ? seekInStore(store, family, key) : store.config.lifespan === `immortal` ? seekInStore(store, family, key) : findInStore(store, family, key);
-    if (!maybeToken) {
-      store.logger.error(
-        `\u2757`,
-        family.type,
-        family.key,
-        `tried to get member`,
-        stringifyJson(key),
-        `but it was not found in store`,
-        store.config.name
-      );
-      switch (family.type) {
-        case `atom_family`:
-        case `mutable_atom_family`:
-          return store.defaults.get(family.key);
-        case `selector_family`:
-        case `readonly_selector_family`: {
-          if (store.defaults.has(family.key)) {
-            return store.defaults.get(family.key);
-          }
-          const defaultValue = withdraw(family, store).default(key);
-          store.defaults.set(family.key, defaultValue);
-          return defaultValue;
+    let maybeToken;
+    if (family.type === `molecule_family`) {
+      maybeToken = seekInStore(store, family, key) ?? counterfeit(family, key);
+    } else {
+      maybeToken = findInStore(store, family, key);
+    }
+    token = maybeToken;
+  }
+  if (`counterfeit` in token && `family` in token) {
+    const family = token.type === `molecule` ? withdraw(token.family, store) : (
+      // biome-ignore lint/style/noNonNullAssertion: family must be present
+      store.families.get(token.family.key)
+    );
+    const subKey = token.type === `molecule` ? token.key : token.family.subKey;
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === token.key
+    );
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `could not be retrieved because it was not found in the store "${store.config.name}".`,
+      disposal ? `This state was previously disposed:
+${disposal.trace}` : `No previous disposal trace was found.`
+    );
+    switch (family.type) {
+      case `atom_family`:
+      case `mutable_atom_family`:
+        return store.defaults.get(family.key);
+      case `selector_family`:
+      case `readonly_selector_family`: {
+        if (store.defaults.has(family.key)) {
+          return store.defaults.get(token.family.key);
         }
-        case `molecule_family`:
-          throw new NotFoundError(family, key, store);
+        const defaultValue = withdraw(family, store).default(subKey);
+        store.defaults.set(family.key, defaultValue);
+        return defaultValue;
       }
+      case `molecule_family`:
+        throw new NotFoundError(family, subKey, store);
     }
-    token = maybeToken;
   }
   switch (token.type) {
     case `atom`:
@@ -806,15 +836,8 @@ function createStandaloneSelector(store, options) {
 function disposeSelector(selectorToken, store) {
   const target = newest(store);
   const { key } = selectorToken;
-  const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key);
-  if (!selector) {
-    store.logger.info(
-      `\u274C`,
-      `selector`,
-      key,
-      `Tried to dispose selector, but it does not exist in the store.`
-    );
-  } else if (!selector.family) {
+  const selector = withdraw(selectorToken, target);
+  if (!selector.family) {
     store.logger.error(
       `\u274C`,
       `selector`,
@@ -992,21 +1015,12 @@ function createSelectorFamily(store, options) {
 // internal/src/molecule/dispose-molecule.ts
 function disposeMolecule(token, store) {
   let molecule;
-  try {
-    molecule = withdraw(token, store);
-  } catch (thrown) {
-    if (thrown instanceof Error) {
-      store.logger.error(
-        `\u{1F41E}`,
-        `molecule`,
-        JSON.stringify(token.key),
-        `Failed to dispose molecule, because it was not found in the store.`,
-        thrown.message
-      );
-    }
-    return;
-  }
+  molecule = withdraw(token, store);
   const { family } = token;
+  for (const join of molecule.joins.values()) {
+    join.relations.delete(molecule.key);
+    join.molecules.delete(molecule.stringKey);
+  }
   const context = [];
   for (const above of molecule.above.values()) {
     context.push(deposit(above));
@@ -1050,183 +1064,11 @@ function disposeMolecule(token, store) {
     }
     store.molecules.delete(molecule.stringKey);
   }
-  for (const join of molecule.joins.values()) {
-    join.molecules.delete(molecule.stringKey);
-  }
   for (const parent of molecule.above.values()) {
     parent.below.delete(molecule.stringKey);
   }
 }
 
-// internal/src/families/init-family-member.ts
-function initFamilyMemberInStore(store, token, key) {
-  const familyKey = token.key;
-  const family = store.families.get(familyKey);
-  if (family === void 0) {
-    throw new NotFoundError(token, store);
-  }
-  const state = family(key);
-  const target = newest(store);
-  if (state.family && target.moleculeInProgress === null) {
-    if (isRootStore(target)) {
-      switch (state.type) {
-        case `atom`:
-        case `mutable_atom`:
-          store.on.atomCreation.next(state);
-          break;
-        case `selector`:
-        case `readonly_selector`:
-          store.on.selectorCreation.next(state);
-          break;
-      }
-    } else if (isChildStore(target) && target.on.transactionApplying.state === null) {
-      target.transactionMeta.update.updates.push({
-        type: `state_creation`,
-        token: state
-      });
-    }
-  }
-  return state;
-}
-function seekInStore(store, token, key) {
-  const subKey = stringifyJson(key);
-  const fullKey = `${token.key}(${subKey})`;
-  const target = newest(store);
-  let state;
-  switch (token.type) {
-    case `atom_family`:
-    case `mutable_atom_family`:
-      state = target.atoms.get(fullKey);
-      break;
-    case `selector_family`:
-      state = target.selectors.get(fullKey);
-      break;
-    case `readonly_selector_family`:
-      state = target.readonlySelectors.get(fullKey);
-      break;
-    case `molecule_family`:
-      state = target.molecules.get(stringifyJson(key));
-  }
-  if (state) {
-    return deposit(state);
-  }
-  return state;
-}
-
-// internal/src/families/find-in-store.ts
-function findInStore(store, token, key) {
-  if (store.config.lifespan === `immortal`) {
-    throw new Error(
-      `Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`
-    );
-  }
-  let state = seekInStore(store, token, key);
-  if (state) {
-    return state;
-  }
-  state = initFamilyMemberInStore(store, token, key);
-  return state;
-}
-
-// internal/src/families/dispose-from-store.ts
-function disposeFromStore(store, ...params) {
-  let token;
-  if (params.length === 1) {
-    token = params[0];
-  } else {
-    const family = params[0];
-    const key = params[1];
-    const maybeToken = family.type === `molecule_family` ? seekInStore(store, family, key) : store.config.lifespan === `immortal` ? seekInStore(store, family, key) : findInStore(store, family, key);
-    if (!maybeToken) {
-      store.logger.error(
-        `\u2757`,
-        family.type,
-        family.key,
-        `tried to dispose of member`,
-        stringifyJson(key),
-        `but it was not found in store`,
-        store.config.name
-      );
-      return;
-    }
-    token = maybeToken;
-  }
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      disposeAtom(token, store);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      disposeSelector(token, store);
-      break;
-    case `molecule`:
-      disposeMolecule(token, store);
-      break;
-  }
-}
-
-// internal/src/set-state/set-into-store.ts
-function setIntoStore(store, ...params) {
-  let token;
-  let value;
-  if (params.length === 2) {
-    token = params[0];
-    value = params[1];
-  } else {
-    const family = params[0];
-    const key = params[1];
-    value = params[2];
-    const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(store, family, key) : seekInStore(store, family, key);
-    if (!maybeToken) {
-      store.logger.error(
-        `\u2757`,
-        family.type,
-        family.key,
-        `tried to set member`,
-        stringifyJson(key),
-        `to`,
-        value,
-        `but it was not found in store`,
-        store.config.name
-      );
-      return;
-    }
-    token = maybeToken;
-  }
-  const rejectionTime = openOperation(token, store);
-  if (rejectionTime) {
-    const unsubscribe = store.on.operationClose.subscribe(
-      `waiting to set "${token.key}" at T-${rejectionTime}`,
-      () => {
-        unsubscribe();
-        store.logger.info(
-          `\u{1F7E2}`,
-          token.type,
-          token.key,
-          `resuming deferred setState from T-${rejectionTime}`
-        );
-        setIntoStore(store, token, value);
-      }
-    );
-    return;
-  }
-  const state = withdraw(token, store);
-  setAtomOrSelector(state, value, store);
-  closeOperation(store);
-}
-
-// internal/src/ingest-updates/ingest-atom-update.ts
-function ingestAtomUpdate(applying, atomUpdate, store) {
-  const { key, newValue, oldValue } = atomUpdate;
-  const value = applying === `newValue` ? newValue : oldValue;
-  const token = { key, type: `atom` };
-  if (atomUpdate.family) {
-    Object.assign(token, { family: atomUpdate.family });
-  }
-  setIntoStore(store, token, value);
-}
-
 // internal/src/molecule/create-molecule-family.ts
 function createMoleculeFamily(store, options) {
   const subject = new Subject();
@@ -1414,7 +1256,202 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
   return token;
 }
 
-// internal/src/ingest-updates/ingest-creation-disposal.ts
+// internal/src/families/init-family-member.ts
+function initFamilyMemberInStore(store, token, key) {
+  const familyKey = token.key;
+  const family = store.families.get(familyKey);
+  if (family === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  const state = family(key);
+  const target = newest(store);
+  if (state.family && target.moleculeInProgress === null) {
+    if (isRootStore(target)) {
+      switch (state.type) {
+        case `atom`:
+        case `mutable_atom`:
+          store.on.atomCreation.next(state);
+          break;
+        case `selector`:
+        case `readonly_selector`:
+          store.on.selectorCreation.next(state);
+          break;
+      }
+    } else if (isChildStore(target) && target.on.transactionApplying.state === null) {
+      target.transactionMeta.update.updates.push({
+        type: `state_creation`,
+        token: state
+      });
+    }
+  }
+  return state;
+}
+function seekInStore(store, token, key) {
+  const subKey = stringifyJson(key);
+  const fullKey = `${token.key}(${subKey})`;
+  const target = newest(store);
+  let state;
+  switch (token.type) {
+    case `atom_family`:
+    case `mutable_atom_family`:
+      state = target.atoms.get(fullKey);
+      break;
+    case `selector_family`:
+      state = target.selectors.get(fullKey);
+      break;
+    case `readonly_selector_family`:
+      state = target.readonlySelectors.get(fullKey);
+      break;
+    case `molecule_family`:
+      state = target.molecules.get(stringifyJson(key));
+  }
+  if (state) {
+    return deposit(state);
+  }
+  return state;
+}
+
+// internal/src/families/find-in-store.ts
+function findInStore(store, token, key) {
+  let state = seekInStore(store, token, key);
+  if (state) {
+    return state;
+  }
+  const molecule = store.molecules.get(stringifyJson(key));
+  if (molecule) {
+    return growMoleculeInStore(molecule, token, store);
+  }
+  if (store.config.lifespan === `immortal`) {
+    const fakeToken = counterfeit(token, key);
+    store.logger.error(
+      `\u274C`,
+      fakeToken.type,
+      fakeToken.key,
+      `was not found in store "${store.config.name}"; returned a counterfeit token.`
+    );
+    return fakeToken;
+  }
+  state = initFamilyMemberInStore(store, token, key);
+  return state;
+}
+
+// internal/src/families/dispose-from-store.ts
+function disposeFromStore(store, ...params) {
+  let token;
+  if (params.length === 1) {
+    token = params[0];
+    token.key;
+  } else {
+    const family = params[0];
+    const key = params[1];
+    const maybeToken = family.type === `molecule_family` ? seekInStore(store, family, key) ?? counterfeit(family, key) : findInStore(store, family, key);
+    token = maybeToken;
+  }
+  try {
+    withdraw(token, store);
+  } catch (thrown) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === token.key
+    );
+    console.log(
+      `seeking disposal trace for`,
+      token,
+      store.disposalTraces.buffer.filter(Boolean)
+    );
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `could not be disposed because it was not found in the store "${store.config.name}".`,
+      disposal ? `
+   This state was most recently disposed
+${disposal.trace}` : `No previous disposal trace was found.`
+    );
+    return;
+  }
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      disposeAtom(token, store);
+      break;
+    case `selector`:
+    case `readonly_selector`:
+      disposeSelector(token, store);
+      break;
+    case `molecule`:
+      disposeMolecule(token, store);
+      break;
+  }
+  const { stack } = new Error();
+  if (stack) {
+    const trace = stack?.split(`
+`)?.slice(3)?.join(`
+`);
+    store.disposalTraces.add({ key: token.key, trace });
+    console.log(`added`, token);
+  }
+}
+
+// internal/src/set-state/set-into-store.ts
+function setIntoStore(store, ...params) {
+  let token;
+  let value;
+  if (params.length === 2) {
+    token = params[0];
+    value = params[1];
+  } else {
+    const family = params[0];
+    const key = params[1];
+    value = params[2];
+    const maybeToken = findInStore(store, family, key);
+    token = maybeToken;
+  }
+  if (`counterfeit` in token) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === token.key
+    );
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `could not be set because it was not found in the store "${store.config.name}".`,
+      disposal ? `This state was previously disposed:
+${disposal.trace}` : `No previous disposal trace was found.`
+    );
+    return;
+  }
+  const rejectionTime = openOperation(token, store);
+  if (rejectionTime) {
+    const unsubscribe = store.on.operationClose.subscribe(
+      `waiting to set "${token.key}" at T-${rejectionTime}`,
+      () => {
+        unsubscribe();
+        store.logger.info(
+          `\u{1F7E2}`,
+          token.type,
+          token.key,
+          `resuming deferred setState from T-${rejectionTime}`
+        );
+        setIntoStore(store, token, value);
+      }
+    );
+    return;
+  }
+  const state = withdraw(token, store);
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
+// internal/src/ingest-updates/ingest-atom-update.ts
+function ingestAtomUpdate(applying, atomUpdate, store) {
+  const { key, newValue, oldValue } = atomUpdate;
+  const value = applying === `newValue` ? newValue : oldValue;
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(store, token, value);
+}
 function ingestCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
@@ -1450,7 +1487,16 @@ function createInStore(token, store) {
         return;
       }
       if (store.config.lifespan === `immortal`) {
-        throw new Error(`No molecule found for key "${token.family.subKey}"`);
+        store.logger.error(
+          `\u{1F41E}`,
+          `atom`,
+          token.family.key,
+          `tried to create member`,
+          `"${token.family.subKey}"`,
+          `but a molecule with that key was not found in store`,
+          `"${store.config.name}"`
+        );
+        return;
       }
       initFamilyMemberInStore(store, family, parseJson(token.family.subKey));
     }
@@ -1676,6 +1722,7 @@ var buildTransaction = (key, params, store, id) => {
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap),
     defaults: parent.defaults,
+    disposalTraces: store.disposalTraces.copy(),
     molecules: new LazyMap(parent.molecules),
     moleculeFamilies: new LazyMap(parent.moleculeFamilies),
     moleculeInProgress: parent.moleculeInProgress,
@@ -1773,6 +1820,36 @@ function getEpochNumberOfAction(transactionKey, store) {
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
+// internal/src/store/circular-buffer.ts
+var CircularBuffer = class _CircularBuffer {
+  _buffer;
+  _index = 0;
+  constructor(lengthOrArray) {
+    let length;
+    if (typeof lengthOrArray === `number`) {
+      length = lengthOrArray;
+    } else {
+      length = lengthOrArray.length;
+    }
+    this._buffer = Array.from({ length });
+  }
+  get buffer() {
+    return this._buffer;
+  }
+  get index() {
+    return this._index;
+  }
+  add(item) {
+    this._buffer[this._index] = item;
+    this._index = (this._index + 1) % this._buffer.length;
+  }
+  copy() {
+    const copy = new _CircularBuffer([...this._buffer]);
+    copy._index = this._index;
+    return copy;
+  }
+};
+
 // internal/src/store/store.ts
 var Store = class {
   parent = null;
@@ -1811,6 +1888,7 @@ var Store = class {
     between: [`timelineKey`, `topicKey`],
     cardinality: `1:n`
   });
+  disposalTraces = new CircularBuffer(100);
   molecules = /* @__PURE__ */ new Map();
   moleculeFamilies = /* @__PURE__ */ new Map();
   moleculeInProgress = null;
@@ -2625,15 +2703,8 @@ function createStandaloneAtom(store, options) {
 function disposeAtom(atomToken, store) {
   const target = newest(store);
   const { key } = atomToken;
-  const atom = target.atoms.get(key);
-  if (!atom) {
-    store.logger.error(
-      `\u274C`,
-      `atom`,
-      key,
-      `Tried to dispose atom, but it does not exist in the store.`
-    );
-  } else if (!atom.family) {
+  const atom = withdraw(atomToken, target);
+  if (!atom.family) {
     store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
     atom.cleanup?.();
@@ -3171,4 +3242,4 @@ var timeTravel = (store, action, token) => {
   );
 };
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };