atom.io 0.27.4 → 0.28.0

package/dist/{chunk-JRENM6KL.js → chunk-BX3MTH2Z.js}

@@ -2,6 +2,7 @@ import { Junction } from './chunk-IBTHB2PI.js';
 import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 import { getJoin, findRelations } from 'atom.io/data';
+import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1 } from 'atom.io/internal';
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -66,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) {
@@ -144,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
@@ -437,26 +454,22 @@ var setAtomOrSelector = (state, value, store) => {
       break;
   }
 };
-
-// internal/src/families/throw-in-case-of-conflicting-family.ts
-function throwInCaseOfConflictingFamily(family, store) {
-  const existingFamily = store.families.get(family.key);
-  if (existingFamily) {
-    throw new Error(
-      `Tried to create ${family.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(family)} with key "${family.key}", but "${family.key}" already exists in store "${store.config.name}" as ${existingFamily.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(
-        existingFamily
-      )}`
-    );
-  }
-}
-
-// internal/src/families/create-regular-atom-family.ts
-function createRegularAtomFamily(options, store, internalRoles) {
+function createRegularAtomFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `atom_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `atom_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -471,13 +484,13 @@ function createRegularAtomFamily(options, store, internalRoles) {
     if (options.effects) {
       individualOptions.effects = options.effects(key);
     }
-    const token = createRegularAtom(individualOptions, family, target);
+    const token = createRegularAtom(target, individualOptions, family);
     subject.next({ type: `state_creation`, token });
     return token;
   };
   const atomFamily = Object.assign(familyFunction, familyToken, {
     subject,
-    install: (s) => createRegularAtomFamily(options, s),
+    install: (s) => createRegularAtomFamily(s, options),
     internalRoles
   });
   store.families.set(options.key, atomFamily);
@@ -486,52 +499,63 @@ function createRegularAtomFamily(options, store, internalRoles) {
 }
 
 // internal/src/families/create-atom-family.ts
-function createAtomFamily(options, store) {
+function createAtomFamily(store, options) {
   const isMutable = `mutable` in options;
   if (isMutable) {
-    return createMutableAtomFamily(options, store);
+    return createMutableAtomFamily(store, options);
   }
-  return createRegularAtomFamily(options, store);
+  return createRegularAtomFamily(store, options);
 }
-function getFromStore(...params) {
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(store, ...params) {
   let token;
-  let store;
-  if (params.length === 2) {
+  if (params.length === 1) {
     token = params[0];
-    store = params[1];
   } else {
     const family = params[0];
     const key = params[1];
-    store = params[2];
-    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
-    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`:
@@ -629,12 +653,12 @@ var registerSelector = (selectorKey, covered, store) => ({
       const [family, key] = params;
       switch (family.type) {
         case `molecule_family`:
-          return getFromStore(family, key, store);
+          return getFromStore(store, family, key);
         default:
           if (store.config.lifespan === `ephemeral`) {
-            dependency = findInStore(family, key, store);
+            dependency = findInStore(store, family, key);
           } else {
-            const maybeDependency = seekInStore(family, key, store);
+            const maybeDependency = seekInStore(store, family, key);
             if (maybeDependency) {
               dependency = maybeDependency;
             } else {
@@ -646,7 +670,7 @@ var registerSelector = (selectorKey, covered, store) => ({
       [dependency] = params;
     }
     if (dependency.type === `molecule`) {
-      return getFromStore(dependency, store);
+      return getFromStore(store, dependency);
     }
     const dependencyState = withdraw(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
@@ -680,7 +704,7 @@ var registerSelector = (selectorKey, covered, store) => ({
       const family = params[0];
       const key = params[1];
       value = params[2];
-      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
+      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(store, family, key) : seekInStore(store, family, key);
       if (!maybeToken) {
         throw new NotFoundError(family, key, store);
       }
@@ -690,13 +714,13 @@ var registerSelector = (selectorKey, covered, store) => ({
     const state = withdraw(token, target);
     setAtomOrSelector(state, value, target);
   },
-  find: (token, key) => findInStore(token, key, store),
-  seek: (token, key) => seekInStore(token, key, store),
-  json: (token) => getJsonToken(token, store)
+  find: (token, key) => findInStore(store, token, key),
+  seek: (token, key) => seekInStore(store, token, key),
+  json: (token) => getJsonToken(store, token)
 });
 
 // internal/src/selector/create-readonly-selector.ts
-var createReadonlySelector = (options, family, store) => {
+var createReadonlySelector = (store, options, family) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
@@ -714,7 +738,7 @@ var createReadonlySelector = (options, family, store) => {
   const readonlySelector = {
     ...options,
     subject,
-    install: (s) => createReadonlySelector(options, family, s),
+    install: (s) => createReadonlySelector(s, options, family),
     get: getSelf,
     type: `readonly_selector`,
     ...family && { family }
@@ -739,7 +763,7 @@ var createReadonlySelector = (options, family, store) => {
 };
 
 // internal/src/selector/create-writable-selector.ts
-var createWritableSelector = (options, family, store) => {
+var createWritableSelector = (store, options, family) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
@@ -776,7 +800,7 @@ var createWritableSelector = (options, family, store) => {
   const mySelector = {
     ...options,
     subject,
-    install: (s) => createWritableSelector(options, family, s),
+    install: (s) => createWritableSelector(s, options, family),
     get: getSelf,
     set: setSelf,
     type: `selector`,
@@ -796,14 +820,14 @@ var createWritableSelector = (options, family, store) => {
 };
 
 // internal/src/selector/create-standalone-selector.ts
-function createStandaloneSelector(options, store) {
+function createStandaloneSelector(store, options) {
   const isWritable = `set` in options;
   if (isWritable) {
-    const state2 = createWritableSelector(options, void 0, store);
+    const state2 = createWritableSelector(store, options, void 0);
     store.on.selectorCreation.next(state2);
     return state2;
   }
-  const state = createReadonlySelector(options, void 0, store);
+  const state = createReadonlySelector(store, options, void 0);
   store.on.selectorCreation.next(state);
   return state;
 }
@@ -812,15 +836,8 @@ function createStandaloneSelector(options, store) {
 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`,
@@ -884,12 +901,22 @@ function disposeSelector(selectorToken, store) {
 }
 
 // internal/src/families/create-readonly-selector-family.ts
-function createReadonlySelectorFamily(options, store, internalRoles) {
+function createReadonlySelectorFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `readonly_selector_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `readonly_selector_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -897,12 +924,12 @@ function createReadonlySelectorFamily(options, store, internalRoles) {
     const fullKey = `${options.key}(${subKey})`;
     const target = newest(store);
     const token = createReadonlySelector(
+      target,
       {
         key: fullKey,
         get: options.get(key)
       },
-      family,
-      target
+      family
     );
     subject.next({ type: `state_creation`, token });
     return token;
@@ -910,26 +937,36 @@ function createReadonlySelectorFamily(options, store, internalRoles) {
   const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
     internalRoles,
     subject,
-    install: (s) => createReadonlySelectorFamily(options, s),
+    install: (s) => createReadonlySelectorFamily(s, options),
     default: (key) => {
       const getFn = options.get(key);
       return getFn({
-        get: (token) => getFromStore(token, store),
-        find: (token, k) => findInStore(token, k, store),
-        seek: (token, k) => seekInStore(token, k, store),
-        json: (token) => getJsonToken(token, store)
+        get: (...ps) => getFromStore(store, ...ps),
+        find: (token, k) => findInStore(store, token, k),
+        seek: (token, k) => seekInStore(store, token, k),
+        json: (token) => getJsonToken(store, token)
       });
     }
   });
   store.families.set(options.key, readonlySelectorFamily);
   return familyToken;
 }
-function createWritableSelectorFamily(options, store, internalRoles) {
+function createWritableSelectorFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `selector_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `selector_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -937,13 +974,13 @@ function createWritableSelectorFamily(options, store, internalRoles) {
     const fullKey = `${options.key}(${subKey})`;
     const target = newest(store);
     const token = createWritableSelector(
+      target,
       {
         key: fullKey,
         get: options.get(key),
         set: options.set(key)
       },
-      family,
-      target
+      family
     );
     subject.next({ type: `state_creation`, token });
     return token;
@@ -951,15 +988,14 @@ function createWritableSelectorFamily(options, store, internalRoles) {
   const selectorFamily = Object.assign(familyFunction, familyToken, {
     internalRoles,
     subject,
-    install: (s) => createWritableSelectorFamily(options, s),
+    install: (s) => createWritableSelectorFamily(s, options),
     default: (key) => {
       const getFn = options.get(key);
       return getFn({
-        get: (...params) => getFromStore(...params, store),
-        // TODO: make store zero-arg
-        find: (token, k) => findInStore(token, k, store),
-        seek: (token, k) => seekInStore(token, k, store),
-        json: (token) => getJsonToken(token, store)
+        get: (...ps) => getFromStore(store, ...ps),
+        find: (token, k) => findInStore(store, token, k),
+        seek: (token, k) => seekInStore(store, token, k),
+        json: (token) => getJsonToken(store, token)
       });
     }
   });
@@ -968,32 +1004,23 @@ function createWritableSelectorFamily(options, store, internalRoles) {
 }
 
 // internal/src/families/create-selector-family.ts
-function createSelectorFamily(options, store) {
+function createSelectorFamily(store, options) {
   const isWritable = `set` in options;
   if (isWritable) {
-    return createWritableSelectorFamily(options, store);
+    return createWritableSelectorFamily(store, options);
   }
-  return createReadonlySelectorFamily(options, store);
+  return createReadonlySelectorFamily(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));
@@ -1016,7 +1043,7 @@ function disposeMolecule(token, store) {
       disposalEvent.family = token.family;
     }
     for (const state of molecule.tokens.values()) {
-      disposeFromStore(state, store);
+      disposeFromStore(store, state);
     }
     for (const child of molecule.below.values()) {
       if (child.family?.dependsOn === `all`) {
@@ -1037,191 +1064,13 @@ 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(token, key, store) {
-  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(token, key, store) {
-  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(token, key, store) {
-  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(token, key, store);
-  if (state) {
-    return state;
-  }
-  state = initFamilyMemberInStore(token, key, store);
-  return state;
-}
-
-// internal/src/families/dispose-from-store.ts
-function disposeFromStore(...params) {
-  let token;
-  let store;
-  if (params.length === 2) {
-    token = params[0];
-    store = params[1];
-  } else {
-    const family = params[0];
-    const key = params[1];
-    store = params[2];
-    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
-    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(...params) {
-  let token;
-  let value;
-  let store;
-  if (params.length === 3) {
-    token = params[0];
-    value = params[1];
-    store = params[2];
-  } else {
-    const family = params[0];
-    const key = params[1];
-    value = params[2];
-    store = params[3];
-    const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
-    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(token, value, store);
-      }
-    );
-    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(token, value, store);
-}
-
 // internal/src/molecule/create-molecule-family.ts
-function createMoleculeFamily(options, store) {
+function createMoleculeFamily(store, options) {
   const subject = new Subject();
   const token = {
     type: `molecule_family`,
@@ -1239,7 +1088,7 @@ function createMoleculeFamily(options, store) {
 
 // internal/src/molecule/grow-molecule-in-store.ts
 function growMoleculeInStore(molecule, family, store) {
-  const stateToken = initFamilyMemberInStore(family, molecule.key, store);
+  const stateToken = initFamilyMemberInStore(store, family, molecule.key);
   molecule.tokens.set(stateToken.key, stateToken);
   const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
   const moleculeInProgress = store.moleculeInProgress === molecule.key;
@@ -1312,16 +1161,16 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
     owner.below.set(molecule.stringKey, molecule);
   }
   const toolkit = {
-    get: (...ps) => getFromStore(...ps, newest(rootStore)),
+    get: (...ps) => getFromStore(newest(rootStore), ...ps),
     set: (...ps) => {
-      setIntoStore(...ps, newest(rootStore));
+      setIntoStore(newest(rootStore), ...ps);
     },
-    seek: (t, k) => seekInStore(t, k, newest(rootStore)),
-    json: (t) => getJsonToken(t, newest(rootStore)),
+    seek: (t, k) => seekInStore(newest(rootStore), t, k),
+    json: (t) => getJsonToken(newest(rootStore), t),
     run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
     make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
     dispose: (t) => {
-      disposeFromStore(t, newest(rootStore));
+      disposeFromStore(newest(rootStore), t);
     },
     env: () => getEnvironmentData(newest(rootStore)),
     bond: (token2, maybeRole) => {
@@ -1407,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`: {
@@ -1415,7 +1459,7 @@ function ingestCreationEvent(update, applying, store) {
       break;
     }
     case `oldValue`: {
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
     }
   }
@@ -1423,7 +1467,7 @@ function ingestCreationEvent(update, applying, store) {
 function ingestDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
     }
     case `oldValue`: {
@@ -1443,9 +1487,18 @@ 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(family, parseJson(token.family.subKey), store);
+      initFamilyMemberInStore(store, family, parseJson(token.family.subKey));
     }
   }
 }
@@ -1461,14 +1514,14 @@ function ingestMoleculeCreationEvent(update, applying, store) {
       );
       break;
     case `oldValue`:
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
   }
 }
 function ingestMoleculeDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      disposeFromStore(update.token, store);
+      disposeFromStore(store, update.token);
       break;
     case `oldValue`:
       {
@@ -1669,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,
@@ -1687,17 +1741,17 @@ var buildTransaction = (key, params, store, id) => {
       output: void 0
     },
     toolkit: {
-      get: (...ps) => getFromStore(...ps, child),
+      get: (...ps) => getFromStore(child, ...ps),
       set: (...ps) => {
-        setIntoStore(...ps, child);
+        setIntoStore(child, ...ps);
       },
       run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
-      find: (token, k) => findInStore(token, k, child),
-      seek: (token, k) => seekInStore(token, k, child),
-      json: (token) => getJsonToken(token, child),
+      find: (token, k) => findInStore(child, token, k),
+      seek: (token, k) => seekInStore(child, token, k),
+      json: (token) => getJsonToken(child, token),
       make: (context, family, k, ...args) => makeMoleculeInStore(child, context, family, k, ...args),
       dispose: (...ps) => {
-        disposeFromStore(...ps, child);
+        disposeFromStore(child, ...ps);
       },
       env: () => getEnvironmentData(child)
     }
@@ -1766,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;
@@ -1804,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;
@@ -1871,7 +1956,7 @@ var Store = class {
         }
         atom.install(this);
         if (atom.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(atom, store);
+          const originalJsonToken = getJsonToken(store, atom);
           const originalUpdateToken = getUpdateToken(atom);
           mutableHelpers.add(originalJsonToken.key);
           mutableHelpers.add(originalUpdateToken.key);
@@ -1964,6 +2049,19 @@ var recallState = (state, store) => {
   }
   return target.valueMap.get(state.key);
 };
+function subscribeInStore(store, token, handleUpdate, key = arbitrary$1()) {
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+    case `readonly_selector`:
+    case `selector`:
+      return subscribeToState(token, handleUpdate, key, store);
+    case `transaction`:
+      return subscribeToTransaction(token, handleUpdate, key, store);
+    case `timeline`:
+      return subscribeToTimeline(token, handleUpdate, key, store);
+  }
+}
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
 var subscribeToRootAtoms = (selector, store) => {
@@ -2010,7 +2108,7 @@ var subscribeToRootAtoms = (selector, store) => {
 };
 
 // internal/src/subscribe/subscribe-to-state.ts
-function subscribeToState(token, handleUpdate, key, store) {
+function subscribeToState2(token, handleUpdate, key, store) {
   function safelyHandleUpdate(update) {
     if (store.operation.open) {
       const unsubscribe2 = store.on.operationClose.subscribe(
@@ -2058,7 +2156,7 @@ function subscribeToState(token, handleUpdate, key, store) {
 }
 
 // internal/src/subscribe/subscribe-to-timeline.ts
-var subscribeToTimeline = (token, handleUpdate, key, store) => {
+var subscribeToTimeline2 = (token, handleUpdate, key, store) => {
   const tl = withdraw(token, store);
   store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
   const unsubscribe = tl.subject.subscribe(key, handleUpdate);
@@ -2074,7 +2172,7 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
 };
 
 // internal/src/subscribe/subscribe-to-transaction.ts
-var subscribeToTransaction = (token, handleUpdate, key, store) => {
+var subscribeToTransaction2 = (token, handleUpdate, key, store) => {
   const tx = withdraw(token, store);
   store.logger.info(
     `\u{1F440}`,
@@ -2106,12 +2204,12 @@ var Tracker = class {
       subKey: mutableState.family.subKey
     } : void 0;
     const latestUpdateState = createRegularAtom(
+      store,
       {
         key: latestUpdateStateKey,
         default: null
       },
-      familyMetaData,
-      store
+      familyMetaData
     );
     if (store.parent?.valueMap.has(latestUpdateStateKey)) {
       const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
@@ -2123,14 +2221,14 @@ var Tracker = class {
   unsubscribeFromState;
   observeCore(mutableState, latestUpdateState, target) {
     const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-    const originalInnerValue = getFromStore(mutableState, target);
+    const originalInnerValue = getFromStore(target, mutableState);
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       subscriptionKey,
       (update) => {
-        setIntoStore(latestUpdateState, update, target);
+        setIntoStore(target, latestUpdateState, update);
       }
     );
-    this.unsubscribeFromState = subscribeToState(
+    this.unsubscribeFromState = subscribeToState2(
       mutableState,
       (update) => {
         if (update.newValue !== update.oldValue) {
@@ -2138,7 +2236,7 @@ var Tracker = class {
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
             (transceiverUpdate) => {
-              setIntoStore(latestUpdateState, transceiverUpdate, target);
+              setIntoStore(target, latestUpdateState, transceiverUpdate);
             }
           );
         }
@@ -2149,7 +2247,7 @@ var Tracker = class {
   }
   updateCore(mutableState, latestUpdateState, target) {
     const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-    subscribeToState(
+    subscribeToState2(
       latestUpdateState,
       ({ newValue, oldValue }) => {
         const timelineId = target.timelineTopics.getRelatedKey(
@@ -2158,22 +2256,18 @@ var Tracker = class {
         if (timelineId) {
           const timelineData = target.timelines.get(timelineId);
           if (timelineData?.timeTraveling) {
-            const unsubscribe2 = subscribeToTimeline(
+            const unsubscribe2 = subscribeToTimeline2(
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                setIntoStore(
-                  mutableState,
-                  (transceiver) => {
-                    if (update === `redo` && newValue) {
-                      transceiver.do(newValue);
-                    } else if (update === `undo` && oldValue) {
-                      transceiver.undo(oldValue);
-                    }
-                    return transceiver;
-                  },
-                  target
-                );
+                setIntoStore(target, mutableState, (transceiver) => {
+                  if (update === `redo` && newValue) {
+                    transceiver.do(newValue);
+                  } else if (update === `undo` && oldValue) {
+                    transceiver.undo(oldValue);
+                  }
+                  return transceiver;
+                });
               },
               subscriptionKey,
               target
@@ -2185,14 +2279,14 @@ var Tracker = class {
           subscriptionKey,
           () => {
             unsubscribe();
-            const mutable = getFromStore(mutableState, target);
+            const mutable = getFromStore(target, mutableState);
             const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
               setIntoStore(
+                target,
                 mutableState,
-                (transceiver) => (transceiver.do(newValue), transceiver),
-                target
+                (transceiver) => (transceiver.do(newValue), transceiver)
               );
             } else {
               target.logger.info(
@@ -2228,7 +2322,7 @@ var Tracker = class {
 };
 
 // internal/src/mutable/create-mutable-atom.ts
-function createMutableAtom(options, family, store) {
+function createMutableAtom(store, options, family) {
   store.logger.info(
     `\u{1F528}`,
     `atom`,
@@ -2257,7 +2351,7 @@ function createMutableAtom(options, family, store) {
         options.key,
         `installing in store "${s.config.name}"`
       );
-      return createMutableAtom(options, family, s);
+      return createMutableAtom(s, options, family);
     },
     subject
   };
@@ -2275,9 +2369,9 @@ function createMutableAtom(options, family, store) {
     for (const effect of options.effects) {
       const cleanup = effect({
         setSelf: (next) => {
-          setIntoStore(token, next, store);
+          setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState2(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2302,11 +2396,11 @@ var FamilyTracker = class {
   mutableAtoms;
   constructor(mutableAtoms, store) {
     const updateAtoms = createRegularAtomFamily(
+      store,
       {
         key: `*${mutableAtoms.key}`,
         default: null
       },
-      store,
       [`mutable`, `updates`]
     );
     this.latestUpdateAtoms = withdraw(updateAtoms, store);
@@ -2316,7 +2410,7 @@ var FamilyTracker = class {
       (event) => {
         if (event.token.family) {
           const key = parseJson(event.token.family.subKey);
-          seekInStore(this.latestUpdateAtoms, key, store);
+          seekInStore(store, this.latestUpdateAtoms, key);
           new Tracker(event.token, store);
         }
       }
@@ -2326,7 +2420,7 @@ var FamilyTracker = class {
       (event) => {
         if (event.token.family) {
           const key = parseJson(event.token.family.subKey);
-          const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
+          const mutableAtomToken = seekInStore(store, this.mutableAtoms, key);
           if (mutableAtomToken) {
             new Tracker(mutableAtomToken, store);
           }
@@ -2337,12 +2431,22 @@ var FamilyTracker = class {
 };
 
 // internal/src/mutable/create-mutable-atom-family.ts
-function createMutableAtomFamily(options, store, internalRoles) {
+function createMutableAtomFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
     type: `mutable_atom_family`
   };
-  throwInCaseOfConflictingFamily(familyToken, store);
+  const existing = store.families.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u2757`,
+      `mutable_atom_family`,
+      options.key,
+      `Overwriting an existing ${prettyPrintTokenType(
+        existing
+      )} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`
+    );
+  }
   const subject = new Subject();
   const familyFunction = (key) => {
     const subKey = stringifyJson(key);
@@ -2359,13 +2463,13 @@ function createMutableAtomFamily(options, store, internalRoles) {
     if (options.effects) {
       individualOptions.effects = options.effects(key);
     }
-    const token = createMutableAtom(individualOptions, family, target);
+    const token = createMutableAtom(target, individualOptions, family);
     subject.next({ type: `state_creation`, token });
     return token;
   };
   const atomFamily = Object.assign(familyFunction, familyToken, {
     subject,
-    install: (s) => createMutableAtomFamily(options, s),
+    install: (s) => createMutableAtomFamily(s, options),
     toJson: options.toJson,
     fromJson: options.fromJson,
     internalRoles
@@ -2385,7 +2489,7 @@ var getJsonFamily = (mutableAtomFamily, store) => {
 };
 
 // internal/src/mutable/get-json-token.ts
-var getJsonToken = (mutableAtomToken, store) => {
+var getJsonToken = (store, mutableAtomToken) => {
   if (mutableAtomToken.family) {
     const target = newest(store);
     const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
@@ -2395,7 +2499,7 @@ var getJsonToken = (mutableAtomToken, store) => {
     };
     const family = withdraw(jsonFamilyToken, target);
     const subKey = JSON.parse(mutableAtomToken.family.subKey);
-    const jsonToken = findInStore(family, subKey, store);
+    const jsonToken = findInStore(store, family, subKey);
     return jsonToken;
   }
   const token = {
@@ -2514,7 +2618,7 @@ var markAtomAsNotDefault = (key, store) => {
 };
 
 // internal/src/atom/create-regular-atom.ts
-function createRegularAtom(options, family, store) {
+function createRegularAtom(store, options, family) {
   store.logger.info(
     `\u{1F528}`,
     `atom`,
@@ -2543,7 +2647,7 @@ function createRegularAtom(options, family, store) {
         options.key,
         `installing in store "${s.config.name}"`
       );
-      return createRegularAtom(options, family, s);
+      return createRegularAtom(s, options, family);
     },
     subject
   };
@@ -2564,9 +2668,9 @@ function createRegularAtom(options, family, store) {
     for (const effect of options.effects) {
       const cleanup = effect({
         setSelf: (next) => {
-          setIntoStore(token, next, store);
+          setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState2(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2583,14 +2687,14 @@ function createRegularAtom(options, family, store) {
 }
 
 // internal/src/atom/create-standalone-atom.ts
-function createStandaloneAtom(options, store) {
+function createStandaloneAtom(store, options) {
   const isMutable = `mutable` in options;
   if (isMutable) {
-    const state2 = createMutableAtom(options, void 0, store);
+    const state2 = createMutableAtom(store, options, void 0);
     store.on.atomCreation.next(state2);
     return state2;
   }
-  const state = createRegularAtom(options, void 0, store);
+  const state = createRegularAtom(store, options, void 0);
   store.on.atomCreation.next(state);
   return state;
 }
@@ -2599,15 +2703,8 @@ function createStandaloneAtom(options, store) {
 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?.();
@@ -3070,7 +3167,7 @@ function handleStateLifecycleEvent(event, tl, store) {
 }
 
 // internal/src/timeline/time-travel.ts
-var timeTravel = (action, token, store) => {
+var timeTravel = (store, action, token) => {
   store.logger.info(
     action === `redo` ? `\u23E9` : `\u23EA`,
     `timeline`,
@@ -3145,4 +3242,4 @@ var timeTravel = (action, token, store) => {
   );
 };
 
-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, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, 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 };