atom.io 0.21.1 → 0.22.0

package/internal/dist/index.js

@@ -113,7 +113,7 @@ function isChildStore(store) {
 
 // internal/src/store/store.ts
 var Store = class {
-  constructor(name, store = null) {
+  constructor(config, store = null) {
     this.parent = null;
     this.child = null;
     this.valueMap = /* @__PURE__ */ new Map();
@@ -142,6 +142,8 @@ var Store = class {
         makeContentKey: (...keys) => keys.sort().join(`:`)
       }
     );
+    this.molecules = /* @__PURE__ */ new Map();
+    this.miscResources = /* @__PURE__ */ new Map();
     this.on = {
       atomCreation: new Subject(),
       atomDisposal: new Subject(),
@@ -163,7 +165,8 @@ var Store = class {
       })
     };
     this.config = {
-      name: `IMPLICIT_STORE`
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
     };
     this.loggers = [
       new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
@@ -193,9 +196,7 @@ var Store = class {
           )
         };
       }
-      this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
-        name
-      });
+      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
       for (const [, family] of store.families) {
         family.install(this);
       }
@@ -206,7 +207,7 @@ var Store = class {
         }
         atom.install(this);
         if (atom.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(atom);
+          const originalJsonToken = getJsonToken(atom, store);
           const originalUpdateToken = getUpdateToken(atom);
           mutableHelpers.add(originalJsonToken.key);
           mutableHelpers.add(originalUpdateToken.key);
@@ -234,12 +235,18 @@ var IMPLICIT = {
   STORE_INTERNAL: void 0,
   get STORE() {
     var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
+    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store({
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
+    });
   }
 };
 var clearStore = (store) => {
   const { config } = store;
-  Object.assign(store, new Store(config.name));
+  for (const disposable of store.miscResources.values()) {
+    disposable[Symbol.dispose]();
+  }
+  Object.assign(store, new Store(config));
   store.config = config;
 };
 
@@ -280,36 +287,6 @@ function withdraw(token, store) {
   throw new NotFoundError(token, store);
 }
 
-// internal/src/store/withdraw-new-family-member.ts
-function withdrawOrCreate(token, store) {
-  try {
-    const state = withdraw(token, store);
-    return state;
-  } catch (notFoundError) {
-    if (token.family) {
-      store.logger.info(
-        `\u{1F46A}`,
-        token.type,
-        token.key,
-        `creating new family member in store "${store.config.name}"`
-      );
-      const target = newest(store);
-      const family = target.families.get(token.family.key);
-      if (family) {
-        const jsonSubKey = JSON.parse(token.family.subKey);
-        family(jsonSubKey);
-        const state = withdraw(token, store);
-        return state;
-      }
-      throw new NotFoundError(
-        { key: token.family.key, type: `${token.type}_family` },
-        store
-      );
-    }
-    throw notFoundError;
-  }
-}
-
 // internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
@@ -337,22 +314,17 @@ function createRegularAtomFamily(options, store) {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const target2 = newest(store);
-      const atomAlreadyCreated = target2.atoms.has(fullKey);
-      let token;
-      if (atomAlreadyCreated) {
-        token = { type: `atom`, key: fullKey, family };
-      } else {
-        const individualOptions = {
-          key: fullKey,
-          default: options.default instanceof Function ? options.default(key) : options.default
-        };
-        if (options.effects) {
-          individualOptions.effects = options.effects(key);
-        }
-        token = createRegularAtom(individualOptions, family, store);
-        subject.next(token);
+      const target = newest(store);
+      const def = options.default;
+      const individualOptions = {
+        key: fullKey,
+        default: def instanceof Function ? def(key) : def
+      };
+      if (options.effects) {
+        individualOptions.effects = options.effects(key);
       }
+      const token = createRegularAtom(individualOptions, family, target);
+      subject.next(token);
       return token;
     },
     {
@@ -362,8 +334,7 @@ function createRegularAtomFamily(options, store) {
       install: (s) => createRegularAtomFamily(options, s)
     }
   );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily);
   return atomFamily;
 }
 
@@ -379,22 +350,20 @@ function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
   const readonlySelectorFamily = Object.assign(
     (key) => {
-      const target = newest(store);
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = target.readonlySelectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
-      return createReadonlySelector(
+      const target = newest(store);
+      const token = createReadonlySelector(
         {
           key: fullKey,
           get: options.get(key)
         },
         family,
-        store
+        target
       );
+      subject.next(token);
+      return token;
     },
     {
       key: options.key,
@@ -413,10 +382,7 @@ function createWritableSelectorFamily(options, store) {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = store.selectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
+      const target = newest(store);
       const token = createWritableSelector(
         {
           key: fullKey,
@@ -424,7 +390,7 @@ function createWritableSelectorFamily(options, store) {
           set: options.set(key)
         },
         family,
-        store
+        target
       );
       subject.next(token);
       return token;
@@ -452,10 +418,18 @@ function createSelectorFamily(options, store) {
 // internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
-  if (token.type === `readonly_selector`) {
-    return `Readonly Selector`;
+  switch (token.type) {
+    case `atom_family`:
+      return `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 capitalize(token.type);
 }
 var NotFoundError = class extends Error {
   constructor(token, store) {
@@ -465,8 +439,8 @@ var NotFoundError = class extends Error {
   }
 };
 
-// internal/src/families/find-in-store.ts
-function findInStore(token, key, store) {
+// internal/src/families/init-family-member.ts
+function initFamilyMember(token, key, store) {
   const familyKey = token.key;
   const family = store.families.get(familyKey);
   if (family === void 0) {
@@ -475,6 +449,44 @@ function findInStore(token, key, store) {
   const state = family(key);
   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;
+  }
+  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 = initFamilyMember(token, key, store);
+  return state;
+}
 
 // internal/src/set-state/become.ts
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
@@ -717,7 +729,7 @@ function setIntoStore(token, value, store) {
     );
     return;
   }
-  const state = withdrawOrCreate(token, store);
+  const state = withdraw(token, store);
   setAtomOrSelector(state, value, store);
   closeOperation(store);
 }
@@ -803,7 +815,7 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
     const target = newest(store);
-    const dependencyState = withdrawOrCreate(dependency, store);
+    const dependencyState = withdraw(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
     store.logger.info(
       `\u{1F50C}`,
@@ -826,19 +838,20 @@ var registerSelector = (selectorKey, store) => ({
     return dependencyValue;
   },
   set: (WritableToken, newValue) => {
-    const state = withdrawOrCreate(WritableToken, store);
+    const state = withdraw(WritableToken, store);
     setAtomOrSelector(state, newValue, store);
   },
-  find: (token, key) => findInStore(token, key, store)
+  find: (token, key) => findInStore(token, key, store),
+  seek: (token, key) => seekInStore(token, key, store)
 });
 
 // internal/src/selector/create-readonly-selector.ts
 var createReadonlySelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
-  const { get, find } = registerSelector(options.key, target);
+  const { get, find, seek } = registerSelector(options.key, target);
   const getSelf = () => {
-    const value = options.get({ get, find });
+    const value = options.get({ get, find, seek });
     cacheValue(options.key, value, subject, newest(store));
     return value;
   };
@@ -873,8 +886,8 @@ var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
   const transactors = registerSelector(options.key, target);
-  const { find, get } = transactors;
-  const readonlyTransactors = { find, get };
+  const { find, get, seek } = transactors;
+  const readonlyTransactors = { find, get, seek };
   const getSelf = () => {
     const value = options.get(readonlyTransactors);
     cacheValue(options.key, value, subject, newest(store));
@@ -932,32 +945,50 @@ function createStandaloneSelector(options, store) {
 
 // internal/src/selector/dispose-selector.ts
 function disposeSelector(selectorToken, store) {
+  var _a;
   const target = newest(store);
   const { key } = selectorToken;
-  switch (selectorToken.type) {
-    case `selector`:
-      target.selectors.delete(key);
-      break;
-    case `readonly_selector`:
-      target.readonlySelectors.delete(key);
-      break;
-  }
-  target.valueMap.delete(key);
-  target.selectorAtoms.delete(key);
-  const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
-    ([downstreamSelectorKey]) => {
-      var _a;
-      return (_a = target.selectors.get(downstreamSelectorKey)) != null ? _a : target.readonlySelectors.get(downstreamSelectorKey);
+  const selector = (_a = target.selectors.get(key)) != null ? _a : target.readonlySelectors.get(key);
+  if (!selector) {
+    store.logger.error(
+      `\u274C`,
+      `selector`,
+      key,
+      `Tried to dispose selector, but it does not exist in the store.`
+    );
+  } else if (!selector.family) {
+    store.logger.error(
+      `\u274C`,
+      `selector`,
+      key,
+      `Standalone selectors cannot be disposed.`
+    );
+  } else {
+    switch (selectorToken.type) {
+      case `selector`:
+        target.selectors.delete(key);
+        break;
+      case `readonly_selector`:
+        target.readonlySelectors.delete(key);
+        break;
     }
-  );
-  for (const downstreamToken of downstreamTokens) {
-    if (downstreamToken) {
-      disposeSelector(downstreamToken, store);
+    target.valueMap.delete(key);
+    target.selectorAtoms.delete(key);
+    const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
+      ([downstreamSelectorKey]) => {
+        var _a2;
+        return (_a2 = target.selectors.get(downstreamSelectorKey)) != null ? _a2 : target.readonlySelectors.get(downstreamSelectorKey);
+      }
+    );
+    for (const downstreamToken of downstreamTokens) {
+      if (downstreamToken) {
+        disposeSelector(downstreamToken, store);
+      }
     }
+    target.selectorGraph.delete(key);
+    store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
+    store.on.selectorDisposal.next(selectorToken);
   }
-  target.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
-  store.on.selectorDisposal.next(selectorToken);
 }
 
 // internal/src/subscribe/recall-state.ts
@@ -1028,7 +1059,7 @@ function subscribeToState(token, handleUpdate, key, store) {
       handleUpdate(update);
     }
   }
-  const state = withdrawOrCreate(token, store);
+  const state = withdraw(token, store);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
   const isSelector = state.type === `selector` || state.type === `readonly_selector`;
   let dependencyUnsubFunctions = null;
@@ -1289,37 +1320,41 @@ function createMutableAtom(options, family, store) {
     };
   }
   new Tracker(token, store);
-  selectJson(token, options, store);
+  if (!family) {
+    selectJson(token, options, store);
+  }
   store.on.atomCreation.next(token);
   return token;
 }
 var FamilyTracker = class {
-  constructor(findMutableState, store) {
-    this.findLatestUpdateState = createRegularAtomFamily(
+  constructor(mutableAtoms, store) {
+    this.latestUpdateAtoms = createRegularAtomFamily(
       {
-        key: `*${findMutableState.key}`,
+        key: `*${mutableAtoms.key}`,
         default: null
       },
       store
     );
-    this.findMutableState = findMutableState;
-    this.findMutableState.subject.subscribe(
+    this.mutableAtoms = mutableAtoms;
+    this.mutableAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
           const key = parseJson(atomToken.family.subKey);
-          this.findLatestUpdateState(key);
+          seekInStore(this.latestUpdateAtoms, key, store);
           new Tracker(atomToken, store);
         }
       }
     );
-    this.findLatestUpdateState.subject.subscribe(
+    this.latestUpdateAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
           const key = parseJson(atomToken.family.subKey);
-          const mutableAtomToken = this.findMutableState(key);
-          new Tracker(mutableAtomToken, store);
+          const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
+          if (mutableAtomToken) {
+            new Tracker(mutableAtomToken, store);
+          }
         }
       }
     );
@@ -1334,25 +1369,19 @@ function createMutableAtomFamily(options, store) {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const target2 = newest(store);
-      const atomAlreadyCreated = target2.atoms.has(fullKey);
-      let token;
-      if (atomAlreadyCreated) {
-        token = { type: `mutable_atom`, key: fullKey, family };
-      } else {
-        const individualOptions = {
-          key: fullKey,
-          default: () => options.default(key),
-          toJson: options.toJson,
-          fromJson: options.fromJson,
-          mutable: true
-        };
-        if (options.effects) {
-          individualOptions.effects = options.effects(key);
-        }
-        token = createMutableAtom(individualOptions, family, store);
-        subject.next(token);
+      const target = newest(store);
+      const individualOptions = {
+        key: fullKey,
+        default: () => options.default(key),
+        toJson: options.toJson,
+        fromJson: options.fromJson,
+        mutable: true
+      };
+      if (options.effects) {
+        individualOptions.effects = options.effects(key);
       }
+      const token = createMutableAtom(individualOptions, family, target);
+      subject.next(token);
       return token;
     },
     {
@@ -1364,8 +1393,7 @@ function createMutableAtomFamily(options, store) {
       fromJson: options.fromJson
     }
   );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily);
   selectJsonFamily(atomFamily, options, store);
   new FamilyTracker(atomFamily, store);
   return atomFamily;
@@ -1380,19 +1408,24 @@ var getJsonFamily = (mutableAtomFamily, store) => {
 };
 
 // internal/src/mutable/get-json-token.ts
-var getJsonToken = (mutableAtomToken) => {
-  const key = mutableAtomToken.family ? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})` : `${mutableAtomToken.key}:JSON`;
-  const jsonToken = {
-    type: `selector`,
-    key
-  };
+var getJsonToken = (mutableAtomToken, store) => {
   if (mutableAtomToken.family) {
-    jsonToken.family = {
-      key: `${mutableAtomToken.family.key}:JSON`,
-      subKey: mutableAtomToken.family.subKey
+    const target = newest(store);
+    const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
+    const jsonFamilyToken = {
+      key: jsonFamilyKey,
+      type: `selector_family`
     };
+    const family = withdraw(jsonFamilyToken, target);
+    const subKey = JSON.parse(mutableAtomToken.family.subKey);
+    const jsonToken = findInStore(family, subKey, store);
+    return jsonToken;
   }
-  return jsonToken;
+  const token = {
+    type: `selector`,
+    key: `${mutableAtomToken.key}:JSON`
+  };
+  return token;
 };
 
 // internal/src/mutable/get-update-token.ts
@@ -1588,8 +1621,10 @@ function disposeAtom(atomToken, store) {
       `\u274C`,
       `atom`,
       key,
-      `Tried to delete atom, but it does not exist in the store.`
+      `Tried to dispose atom, but it does not exist in the store.`
     );
+  } else if (!atom.family) {
+    store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
     (_a = atom.cleanup) == null ? void 0 : _a.call(atom);
     target.atoms.delete(key);
@@ -1609,6 +1644,7 @@ function disposeAtom(atomToken, store) {
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
       disposeAtom(updateToken, store);
+      store.trackers.delete(key);
     }
     store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
     store.on.atomDisposal.next(atomToken);
@@ -1626,7 +1662,7 @@ function getEnvironmentData(store) {
 
 // internal/src/get-state/get-from-store.ts
 function getFromStore(token, store) {
-  const state = withdrawOrCreate(token, store);
+  const state = withdraw(token, store);
   return readOrComputeValue(state, store);
 }
 
@@ -2180,7 +2216,9 @@ var buildTransaction = (key, params, store, id) => {
       makeContentKey: (...keys) => keys.sort().join(`:`)
     }),
     selectors: new LazyMap(parent.selectors),
-    valueMap: new LazyMap(parent.valueMap)
+    valueMap: new LazyMap(parent.valueMap),
+    molecules: new LazyMap(parent.molecules),
+    miscResources: new LazyMap(parent.miscResources)
   };
   const epoch = getEpochNumberOfAction(key, store);
   const transactionMeta = {
@@ -2200,6 +2238,7 @@ var buildTransaction = (key, params, store, id) => {
       },
       run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
       find: (token, k) => findInStore(token, k, child),
+      seek: (token, k) => seekInStore(token, k, child),
       env: () => getEnvironmentData(child)
     }
   };
@@ -2267,4 +2306,4 @@ function getEpochNumberOfAction(transactionKey, store) {
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMember, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/src/atom/dispose-atom.ts

@@ -12,8 +12,10 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			`❌`,
 			`atom`,
 			key,
-			`Tried to delete atom, but it does not exist in the store.`,
+			`Tried to dispose atom, but it does not exist in the store.`,
 		)
+	} else if (!atom.family) {
+		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()
 		target.atoms.delete(key)
@@ -35,6 +37,7 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
 			disposeAtom(updateToken, store)
+			store.trackers.delete(key)
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`)
 		store.on.atomDisposal.next(atomToken)

package/internal/src/families/create-readonly-selector-family.ts

@@ -10,7 +10,6 @@ import { stringifyJson } from "atom.io/json"
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
-import { deposit } from "../store"
 import { Subject } from "../subject"
 
 export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
@@ -18,24 +17,25 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 	store: Store,
 ): ReadonlySelectorFamily<T, K> {
 	const subject = new Subject<ReadonlySelectorToken<T>>()
+
 	const readonlySelectorFamily = Object.assign(
 		(key: K): ReadonlySelectorToken<T> => {
-			const target = newest(store)
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = target.readonlySelectors.get(fullKey)
-			if (existing) {
-				return deposit(existing)
-			}
-			return createReadonlySelector(
+			const target = newest(store)
+
+			const token = createReadonlySelector(
 				{
 					key: fullKey,
 					get: options.get(key),
 				},
 				family,
-				store,
+				target,
 			)
+
+			subject.next(token)
+			return token
 		},
 		{
 			key: options.key,
@@ -43,7 +43,7 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 			subject,
 			install: (s: Store) => createReadonlySelectorFamily(options, s),
 		} as const,
-	) as ReadonlySelectorFamily<T, K>
+	) satisfies ReadonlySelectorFamily<T, K>
 	store.families.set(options.key, readonlySelectorFamily)
 	return readonlySelectorFamily
 }