atom.io 0.20.3 → 0.21.0

package/data/dist/index.cjs

@@ -443,7 +443,7 @@ var Join = class _Join {
         set(find(contentAtoms, key), content);
       };
       const deleteContent = ({ find }, key) => {
-        atom_io.dispose(find(contentAtoms, key));
+        atom_io.disposeState(find(contentAtoms, key));
       };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {

package/data/dist/index.js

@@ -1,4 +1,4 @@
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-SMZRGPN6.js';
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-KGZGBCYS.js';
 import '../../dist/chunk-FTONNX2R.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';

package/data/src/join.ts

@@ -10,7 +10,7 @@ import type {
 	Transactors,
 	Write,
 } from "atom.io"
-import { dispose, findState, getState, setState } from "atom.io"
+import { disposeState, findState, getState, setState } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createMutableAtomFamily,
@@ -343,7 +343,7 @@ export class Join<
 				set(find(contentAtoms, key), content)
 			}
 			const deleteContent: Write<(key: string) => void> = ({ find }, key) => {
-				dispose(find(contentAtoms, key))
+				disposeState(find(contentAtoms, key))
 			}
 			const externalStoreWithContentConfiguration = {
 				getContent: (contentKey: string) => {

package/dist/{chunk-SMZRGPN6.js → chunk-KGZGBCYS.js}

@@ -1,5 +1,5 @@
 import { Junction } from './chunk-FTONNX2R.js';
-import { dispose } from 'atom.io';
+import { disposeState } from 'atom.io';
 import { getFromStore, setIntoStore, findInStore, createMutableAtomFamily, createRegularAtomFamily, IMPLICIT, newest, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
@@ -166,7 +166,7 @@ var Join = class _Join {
         set(find(contentAtoms, key), content);
       };
       const deleteContent = ({ find }, key) => {
-        dispose(find(contentAtoms, key));
+        disposeState(find(contentAtoms, key));
       };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {

package/dist/chunk-PNIHPILQ.js

@@ -0,0 +1,8 @@
+import * as Internal from 'atom.io/internal';
+
+// src/get-state.ts
+function getState(token) {
+  return Internal.getFromStore(token, Internal.IMPLICIT.STORE);
+}
+
+export { getState };

package/dist/{chunk-2AIFLP2B.js → chunk-RT43TVKP.js}

@@ -1,4 +1,4 @@
-import { getFromStore, assignTransactionToContinuity, subscribeToTransaction, setIntoStore, deleteAtom, setEpochNumberOfContinuity, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, getJsonToken, actUponStore } from 'atom.io/internal';
+import { getFromStore, assignTransactionToContinuity, subscribeToTransaction, setIntoStore, disposeAtom, setEpochNumberOfContinuity, getEpochNumberOfContinuity, isRootStore, ingestTransactionUpdate, getJsonToken, actUponStore } from 'atom.io/internal';
 import { optimisticUpdateQueue, confirmedUpdateQueue } from 'atom.io/realtime-client';
 
 // realtime-client/src/sync-continuity.ts
@@ -313,7 +313,7 @@ function syncContinuity(continuity, socket, store) {
     `conceal:${continuityKey}`,
     (concealed) => {
       for (const token of concealed) {
-        deleteAtom(token, store);
+        disposeAtom(token, store);
       }
     }
   );

package/dist/index.cjs

@@ -29,15 +29,15 @@ function atom(options) {
 function atomFamily(options) {
   return Internal.createAtomFamily(options, Internal.IMPLICIT.STORE);
 }
-function dispose(token, store = Internal__namespace.IMPLICIT.STORE) {
+function disposeState(token, store = Internal__namespace.IMPLICIT.STORE) {
   switch (token.type) {
     case `atom`:
     case `mutable_atom`:
-      Internal__namespace.deleteAtom(token, store);
+      Internal__namespace.disposeAtom(token, store);
       break;
     case `selector`:
     case `readonly_selector`:
-      Internal__namespace.deleteSelector(token, store);
+      Internal__namespace.disposeSelector(token, store);
       break;
   }
 }
@@ -170,7 +170,7 @@ exports.Silo = Silo;
 exports.atom = atom;
 exports.atomFamily = atomFamily;
 exports.belongsTo = belongsTo;
-exports.dispose = dispose;
+exports.disposeState = disposeState;
 exports.findState = findState;
 exports.getState = getState;
 exports.isToken = isToken;

package/dist/index.d.ts

@@ -153,7 +153,7 @@ type SelectorFamilyToken<T, K extends Json.Serializable> = ReadonlySelectorFamil
 declare function selectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyTokenWithCall<T, K>;
 declare function selectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyTokenWithCall<T, K>;
 
-declare function dispose(token: ReadableToken<any>, store?: Internal.Store): void;
+declare function disposeState(token: ReadableToken<any>, store?: Internal.Store): void;
 
 declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken$1<T, J, K>, key: Key): MutableAtomToken$1<T, J>;
 declare function findState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T>;
@@ -336,4 +336,4 @@ type FamilyMetadata = {
     subKey: string;
 };
 
-export { type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomToken, type Effectors, type FamilyMetadata, type Func, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type ReadonlyTransactors, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, Silo, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type Transactors, type TransactorsWithRunAndEnv, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, dispose, findState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomToken, type Effectors, type FamilyMetadata, type Func, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type ReadonlyTransactors, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, Silo, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type Transactors, type TransactorsWithRunAndEnv, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, findState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -1,3 +1,4 @@
+export { getState } from './chunk-PNIHPILQ.js';
 import './chunk-F2X4B4VY.js';
 import * as Internal from 'atom.io/internal';
 import { createStandaloneAtom, IMPLICIT, createAtomFamily, findInStore, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, getFromStore, setIntoStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
@@ -8,15 +9,15 @@ function atom(options) {
 function atomFamily(options) {
   return createAtomFamily(options, IMPLICIT.STORE);
 }
-function dispose(token, store = Internal.IMPLICIT.STORE) {
+function disposeState(token, store = Internal.IMPLICIT.STORE) {
   switch (token.type) {
     case `atom`:
     case `mutable_atom`:
-      Internal.deleteAtom(token, store);
+      Internal.disposeAtom(token, store);
       break;
     case `selector`:
     case `readonly_selector`:
-      Internal.deleteSelector(token, store);
+      Internal.disposeSelector(token, store);
       break;
   }
 }
@@ -24,9 +25,6 @@ function findState(token, key) {
   const state = findInStore(token, key, IMPLICIT.STORE);
   return state;
 }
-function getState(token) {
-  return Internal.getFromStore(token, Internal.IMPLICIT.STORE);
-}
 
 // src/logger.ts
 var LOG_LEVELS = [`info`, `warn`, `error`];
@@ -143,4 +141,4 @@ function belongsTo(family, unknownToken) {
   return family.key === ((_a = unknownToken.family) == null ? void 0 : _a.key);
 }
 
-export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, dispose, findState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, findState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/internal/dist/index.cjs

@@ -436,9 +436,11 @@ var Store = class {
     );
     this.on = {
       atomCreation: new Subject(),
+      atomDisposal: new Subject(),
       selectorCreation: new Subject(),
-      transactionCreation: new Subject(),
+      selectorDisposal: new Subject(),
       timelineCreation: new Subject(),
+      transactionCreation: new Subject(),
       transactionApplying: new StatefulSubject(
         null
       ),
@@ -1220,8 +1222,8 @@ function createStandaloneSelector(options, store) {
   return createReadonlySelector(options, void 0, store);
 }
 
-// internal/src/selector/delete-selector.ts
-function deleteSelector(selectorToken, store) {
+// internal/src/selector/dispose-selector.ts
+function disposeSelector(selectorToken, store) {
   const target = newest(store);
   const { key } = selectorToken;
   switch (selectorToken.type) {
@@ -1242,11 +1244,12 @@ function deleteSelector(selectorToken, store) {
   );
   for (const downstreamToken of downstreamTokens) {
     if (downstreamToken) {
-      deleteSelector(downstreamToken, store);
+      disposeSelector(downstreamToken, store);
     }
   }
   target.selectorGraph.delete(key);
   store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
+  store.on.selectorDisposal.next(selectorToken);
 }
 
 // internal/src/subscribe/recall-state.ts
@@ -1875,8 +1878,8 @@ function createStandaloneAtom(options, store) {
   return createRegularAtom(options, void 0, store);
 }
 
-// internal/src/atom/delete-atom.ts
-function deleteAtom(atomToken, store) {
+// internal/src/atom/dispose-atom.ts
+function disposeAtom(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -1888,27 +1891,29 @@ function deleteAtom(atomToken, store) {
       key,
       `Tried to delete atom, but it does not exist in the store.`
     );
-  }
-  (_a = atom == null ? void 0 : atom.cleanup) == null ? void 0 : _a.call(atom);
-  target.atoms.delete(key);
-  target.valueMap.delete(key);
-  const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
-  if (selectorKeys) {
-    for (const selectorKey of selectorKeys) {
-      const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
-      if (token) {
-        deleteSelector(token, store);
+  } else {
+    (_a = atom.cleanup) == null ? void 0 : _a.call(atom);
+    target.atoms.delete(key);
+    target.valueMap.delete(key);
+    const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
+    if (selectorKeys) {
+      for (const selectorKey of selectorKeys) {
+        const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
+        if (token) {
+          disposeSelector(token, store);
+        }
       }
     }
+    target.selectorAtoms.delete(key);
+    target.atomsThatAreDefault.delete(key);
+    target.timelineAtoms.delete(key);
+    if (atomToken.type === `mutable_atom`) {
+      const updateToken = getUpdateToken(atomToken);
+      disposeAtom(updateToken, store);
+    }
+    store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
+    store.on.atomDisposal.next(atomToken);
   }
-  target.selectorAtoms.delete(key);
-  target.atomsThatAreDefault.delete(key);
-  target.timelineAtoms.delete(key);
-  if (atomToken.type === `mutable_atom`) {
-    const updateToken = getUpdateToken(atomToken);
-    deleteAtom(updateToken, store);
-  }
-  store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
 }
 
 // internal/src/get-environment-data.ts
@@ -2597,9 +2602,9 @@ exports.createStandaloneSelector = createStandaloneSelector;
 exports.createTimeline = createTimeline;
 exports.createTransaction = createTransaction;
 exports.createWritableSelector = createWritableSelector;
-exports.deleteAtom = deleteAtom;
-exports.deleteSelector = deleteSelector;
 exports.deposit = deposit;
+exports.disposeAtom = disposeAtom;
+exports.disposeSelector = disposeSelector;
 exports.evictCachedValue = evictCachedValue;
 exports.findInStore = findInStore;
 exports.getContinuityKey = getContinuityKey;

package/internal/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, SelectorToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, JsonInterface } from 'atom.io/json';
 
 type primitive = boolean | number | string | null;
@@ -141,8 +141,10 @@ type TransactionEpoch = {
 
 declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
 declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
+declare function deposit<T>(state: Atom<T>): AtomToken<T>;
 declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
+declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
@@ -221,9 +223,11 @@ declare class Store implements Lineage {
     }>;
     on: {
         atomCreation: Subject<AtomToken<unknown>>;
+        atomDisposal: Subject<AtomToken<unknown>>;
         selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<Func>>;
+        selectorDisposal: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
         timelineCreation: Subject<TimelineToken<unknown>>;
+        transactionCreation: Subject<TransactionToken<Func>>;
         transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
         operationClose: Subject<OperationProgress>;
     };
@@ -317,12 +321,12 @@ declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey exten
 
 declare function arbitrary(random?: () => number): string;
 
-declare function createRegularAtom<T>(options: MutableAtomOptions<any, any> | RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
+declare function createRegularAtom<T>(options: RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
 
 declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
 declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
 
-declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
+declare function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
 declare const isAtomDefault: (key: string, store: Store) => boolean;
 declare const markAtomAsDefault: (key: string, store: Store) => void;
@@ -429,7 +433,7 @@ declare function createStandaloneSelector<T>(options: ReadonlySelectorOptions<T>
 
 declare const createWritableSelector: <T>(options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => WritableSelectorToken<T>;
 
-declare function deleteSelector(selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>, store: Store): void;
+declare function disposeSelector(selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>, store: Store): void;
 
 declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
 
@@ -488,4 +492,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, 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 { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, 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 };

package/internal/dist/index.js

@@ -158,9 +158,11 @@ var Store = class {
     );
     this.on = {
       atomCreation: new Subject(),
+      atomDisposal: new Subject(),
       selectorCreation: new Subject(),
-      transactionCreation: new Subject(),
+      selectorDisposal: new Subject(),
       timelineCreation: new Subject(),
+      transactionCreation: new Subject(),
       transactionApplying: new StatefulSubject(
         null
       ),
@@ -942,8 +944,8 @@ function createStandaloneSelector(options, store) {
   return createReadonlySelector(options, void 0, store);
 }
 
-// internal/src/selector/delete-selector.ts
-function deleteSelector(selectorToken, store) {
+// internal/src/selector/dispose-selector.ts
+function disposeSelector(selectorToken, store) {
   const target = newest(store);
   const { key } = selectorToken;
   switch (selectorToken.type) {
@@ -964,11 +966,12 @@ function deleteSelector(selectorToken, store) {
   );
   for (const downstreamToken of downstreamTokens) {
     if (downstreamToken) {
-      deleteSelector(downstreamToken, store);
+      disposeSelector(downstreamToken, store);
     }
   }
   target.selectorGraph.delete(key);
   store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
+  store.on.selectorDisposal.next(selectorToken);
 }
 
 // internal/src/subscribe/recall-state.ts
@@ -1597,8 +1600,8 @@ function createStandaloneAtom(options, store) {
   return createRegularAtom(options, void 0, store);
 }
 
-// internal/src/atom/delete-atom.ts
-function deleteAtom(atomToken, store) {
+// internal/src/atom/dispose-atom.ts
+function disposeAtom(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -1610,27 +1613,29 @@ function deleteAtom(atomToken, store) {
       key,
       `Tried to delete atom, but it does not exist in the store.`
     );
-  }
-  (_a = atom == null ? void 0 : atom.cleanup) == null ? void 0 : _a.call(atom);
-  target.atoms.delete(key);
-  target.valueMap.delete(key);
-  const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
-  if (selectorKeys) {
-    for (const selectorKey of selectorKeys) {
-      const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
-      if (token) {
-        deleteSelector(token, store);
+  } else {
+    (_a = atom.cleanup) == null ? void 0 : _a.call(atom);
+    target.atoms.delete(key);
+    target.valueMap.delete(key);
+    const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
+    if (selectorKeys) {
+      for (const selectorKey of selectorKeys) {
+        const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
+        if (token) {
+          disposeSelector(token, store);
+        }
       }
     }
+    target.selectorAtoms.delete(key);
+    target.atomsThatAreDefault.delete(key);
+    target.timelineAtoms.delete(key);
+    if (atomToken.type === `mutable_atom`) {
+      const updateToken = getUpdateToken(atomToken);
+      disposeAtom(updateToken, store);
+    }
+    store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
+    store.on.atomDisposal.next(atomToken);
   }
-  target.selectorAtoms.delete(key);
-  target.atomsThatAreDefault.delete(key);
-  target.timelineAtoms.delete(key);
-  if (atomToken.type === `mutable_atom`) {
-    const updateToken = getUpdateToken(atomToken);
-    deleteAtom(updateToken, store);
-  }
-  store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
 }
 
 // internal/src/get-environment-data.ts
@@ -2285,4 +2290,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, deleteAtom, deleteSelector, deposit, 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, 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 };

package/internal/src/atom/create-regular-atom.ts

@@ -16,7 +16,7 @@ import { subscribeToState } from "../subscribe"
 import { markAtomAsDefault } from "./is-default"
 
 export function createRegularAtom<T>(
-	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
+	options: RegularAtomOptions<T>,
 	family: FamilyMetadata | undefined,
 	store: Store,
 ): RegularAtomToken<T> {

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

@@ -0,0 +1,42 @@
+import type { AtomToken } from "atom.io"
+
+import type { Store } from ".."
+import { disposeSelector, getUpdateToken, newest } from ".."
+
+export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
+	const target = newest(store)
+	const { key } = atomToken
+	const atom = target.atoms.get(key)
+	if (!atom) {
+		store.logger.error(
+			`❌`,
+			`atom`,
+			key,
+			`Tried to delete atom, but it does not exist in the store.`,
+		)
+	} else {
+		atom.cleanup?.()
+		target.atoms.delete(key)
+		target.valueMap.delete(key)
+		const selectorKeys = target.selectorAtoms.getRelatedKeys(key)
+		if (selectorKeys) {
+			for (const selectorKey of selectorKeys) {
+				const token =
+					target.selectors.get(selectorKey) ??
+					target.readonlySelectors.get(selectorKey)
+				if (token) {
+					disposeSelector(token, store)
+				}
+			}
+		}
+		target.selectorAtoms.delete(key)
+		target.atomsThatAreDefault.delete(key)
+		target.timelineAtoms.delete(key)
+		if (atomToken.type === `mutable_atom`) {
+			const updateToken = getUpdateToken(atomToken)
+			disposeAtom(updateToken, store)
+		}
+		store.logger.info(`🔥`, `atom`, key, `deleted`)
+		store.on.atomDisposal.next(atomToken)
+	}
+}

package/internal/src/atom/index.ts

@@ -1,4 +1,4 @@
 export * from "./create-regular-atom"
 export * from "./create-standalone-atom"
-export * from "./delete-atom"
+export * from "./dispose-atom"
 export * from "./is-default"

package/internal/src/selector/{delete-selector.ts → dispose-selector.ts}

@@ -3,7 +3,7 @@ import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
 import type { Store } from ".."
 import { newest } from ".."
 
-export function deleteSelector(
+export function disposeSelector(
 	selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>,
 	store: Store,
 ): void {
@@ -29,9 +29,10 @@ export function deleteSelector(
 		)
 	for (const downstreamToken of downstreamTokens) {
 		if (downstreamToken) {
-			deleteSelector(downstreamToken, store)
+			disposeSelector(downstreamToken, store)
 		}
 	}
 	target.selectorGraph.delete(key)
 	store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
+	store.on.selectorDisposal.next(selectorToken)
 }

package/internal/src/selector/index.ts

@@ -1,7 +1,7 @@
 export * from "./create-readonly-selector"
 export * from "./create-standalone-selector"
 export * from "./create-writable-selector"
-export * from "./delete-selector"
+export * from "./dispose-selector"
 export * from "./get-selector-dependency-keys"
 export * from "./register-selector"
 export * from "./trace-selector-atoms"

package/internal/src/store/deposit.ts

@@ -1,4 +1,5 @@
 import type {
+	AtomToken,
 	Func,
 	MutableAtomToken,
 	ReadableToken,
@@ -11,10 +12,12 @@ import type {
 } from "atom.io"
 
 import type {
+	Atom,
 	MutableAtom,
 	ReadableState,
 	ReadonlySelector,
 	RegularAtom,
+	Selector,
 	Transceiver,
 	WritableSelector,
 	WritableState,
@@ -25,8 +28,10 @@ export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
 export function deposit<T extends Transceiver<any>>(
 	state: MutableAtom<T, any>,
 ): MutableAtomToken<T, any>
+export function deposit<T>(state: Atom<T>): AtomToken<T>
 export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
+export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
 export function deposit<T extends Func>(
 	state: Transaction<T>,

package/internal/src/store/store.ts

@@ -82,11 +82,15 @@ export class Store implements Lineage {
 
 	public on = {
 		atomCreation: new Subject<AtomToken<unknown>>(),
+		atomDisposal: new Subject<AtomToken<unknown>>(),
 		selectorCreation: new Subject<
 			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
 		>(),
-		transactionCreation: new Subject<TransactionToken<Func>>(),
+		selectorDisposal: new Subject<
+			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
+		>(),
 		timelineCreation: new Subject<TimelineToken<unknown>>(),
+		transactionCreation: new Subject<TransactionToken<Func>>(),
 		transactionApplying: new StatefulSubject<TransactionProgress<Func> | null>(
 			null,
 		),