atom.io 0.20.3 → 0.21.1

package/data/dist/index.cjs

@@ -5,14 +5,14 @@ var atom_io = require('atom.io');
 var setRtx = require('atom.io/transceivers/set-rtx');
 
 // data/src/dict.ts
-function dict(findState2, index, store = internal.IMPLICIT.STORE) {
+function dict(findState, index, store = internal.IMPLICIT.STORE) {
   return internal.createStandaloneSelector(
     {
-      key: `${findState2.key}Dict`,
+      key: `${findState.key}Dict`,
       get: ({ get }) => {
         const keys = get(index);
         return keys.reduce((acc, key) => {
-          acc[key] = get(internal.findInStore(findState2, key, store));
+          acc[key] = get(internal.findInStore(findState, key, store));
           return acc;
         }, {});
       }
@@ -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-HITX3MO4.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

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import type {
+	findState,
 	MutableAtomFamily,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -10,7 +11,7 @@ import type {
 	Transactors,
 	Write,
 } from "atom.io"
-import { dispose, findState, getState, setState } from "atom.io"
+import { disposeState, getState, setState } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createMutableAtomFamily,
@@ -37,12 +38,6 @@ import type {
 import { Junction } from "~/packages/rel8/junction/src"
 import type * as Rel8 from "~/packages/rel8/types/src"
 
-const TRANSACTORS: Transactors = {
-	get: getState,
-	set: setState,
-	find: findState,
-}
-
 function capitalize<S extends string>(string: S): Capitalize<S> {
 	return (string[0].toUpperCase() + string.slice(1)) as Capitalize<S>
 }
@@ -343,7 +338,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-HITX3MO4.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

@@ -31,44 +31,30 @@ function arbitrary(random = Math.random) {
 // internal/src/future.ts
 var Future = class extends Promise {
   constructor(executor) {
-    let promise;
     let superResolve;
     let superReject;
     super((resolve, reject) => {
       superResolve = resolve;
       superReject = reject;
-      promise = executor instanceof Promise ? executor : new Promise(executor);
-      promise.then(
-        (value) => {
-          if (promise) {
-            this.pass(promise, value);
-          }
-        },
-        (reason) => {
-          if (promise) {
-            this.fail(promise, reason);
-          }
-        }
-      );
     });
-    this.destiny = promise;
     this.resolve = superResolve;
     this.reject = superReject;
+    this.use(executor instanceof Promise ? executor : new Promise(executor));
   }
   pass(promise, value) {
-    if (promise === this.destiny) {
+    if (promise === this.fate) {
       this.resolve(value);
     }
   }
   fail(promise, reason) {
-    if (promise === this.destiny) {
+    if (promise === this.fate) {
       this.reject(reason);
     }
   }
   use(value) {
     if (value instanceof Promise) {
       const promise = value;
-      this.destiny = promise;
+      this.fate = promise;
       promise.then(
         (resolved) => {
           this.pass(promise, resolved);
@@ -79,7 +65,7 @@ var Future = class extends Promise {
       );
     } else {
       this.resolve(value);
-      this.destiny = void 0;
+      this.fate = void 0;
     }
   }
 };
@@ -436,9 +422,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 +1208,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,20 +1230,21 @@ 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
 var recallState = (state, store) => {
   const target = newest(store);
-  if (!target.operation.open) {
-    return target.valueMap.get(state.key);
+  if (target.operation.open) {
+    return target.operation.prev.get(state.key);
   }
-  return target.operation.prev.get(state.key);
+  return target.valueMap.get(state.key);
 };
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
@@ -1304,11 +1293,24 @@ var subscribeToRootAtoms = (selector, store) => {
 
 // internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
+  function safelyHandleUpdate(update) {
+    if (store.operation.open) {
+      const unsubscribe2 = store.on.operationClose.subscribe(
+        `state subscription ${key}`,
+        () => {
+          unsubscribe2();
+          handleUpdate(update);
+        }
+      );
+    } else {
+      handleUpdate(update);
+    }
+  }
   const state = withdrawOrCreate(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;
-  let updateHandler = handleUpdate;
+  let updateHandler = safelyHandleUpdate;
   if (isSelector) {
     dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
     updateHandler = (update) => {
@@ -1316,7 +1318,7 @@ function subscribeToState(token, handleUpdate, key, store) {
         dependencyUnsubFunctions.length = 0;
         dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
       }
-      handleUpdate(update);
+      safelyHandleUpdate(update);
     };
   }
   const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
@@ -1405,18 +1407,7 @@ var Tracker = class {
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       subscriptionKey,
       (update) => {
-        if (target.operation.open) {
-          const unsubscribe = target.on.operationClose.subscribe(
-            subscriptionKey,
-            () => {
-              unsubscribe();
-              setIntoStore(latestUpdateState, update, target);
-            }
-          );
-        } else {
-          setIntoStore(mutableState, (current) => current, target);
-          setIntoStore(latestUpdateState, update, target);
-        }
+        setIntoStore(latestUpdateState, update, target);
       }
     );
     this.unsubscribeFromState = subscribeToState(
@@ -1427,18 +1418,7 @@ var Tracker = class {
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
             (transceiverUpdate) => {
-              if (target.operation.open) {
-                const unsubscribe = target.on.operationClose.subscribe(
-                  subscriptionKey,
-                  () => {
-                    unsubscribe();
-                    setIntoStore(latestUpdateState, transceiverUpdate, target);
-                  }
-                );
-              } else {
-                setIntoStore(mutableState, (current) => current, target);
-                setIntoStore(latestUpdateState, transceiverUpdate, target);
-              }
+              setIntoStore(latestUpdateState, transceiverUpdate, target);
             }
           );
         }
@@ -1875,8 +1855,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 +1868,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 +2579,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;
@@ -338,7 +342,7 @@ declare const markAtomAsNotDefault: (key: string, store: Store) => void;
  * Can be constructed like a Promise, or from an existing Promise.
  */
 declare class Future<T> extends Promise<T> {
-    private destiny;
+    private fate;
     private resolve;
     private reject;
     constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => 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 };