atom.io 0.20.2 → 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>;
@@ -174,9 +174,11 @@ declare const LoggerIconDictionary: {
     readonly "\u23F9\uFE0F": "Time-travel complete";
     readonly "\u2705": "Realtime transaction success";
     readonly "\u2728": "Computation complete";
-    readonly "\u2757": "Must wait to proceed with attempted action";
     readonly "\u274C": "Conflict prevents attempted action";
     readonly "\u2B55": "Operation start";
+    readonly "\uD83D\uDD34": "Operation complete";
+    readonly "\u2757": "Operation blocked";
+    readonly "\uD83D\uDFE2": "Operation unblocked";
     readonly "\uD83D\uDC1E": "Possible bug in AtomIO";
     readonly "\uD83D\uDC40": "Subscription added";
     readonly "\uD83D\uDC4B": "Greeting";
@@ -195,7 +197,6 @@ declare const LoggerIconDictionary: {
     readonly "\uD83D\uDD25": "Delete state";
     readonly "\uD83D\uDD27": "Create mutable atom";
     readonly "\uD83D\uDD28": "Create immutable atom";
-    readonly "\uD83D\uDD34": "Operation complete";
     readonly "\uD83D\uDDD1": "Evict cached value";
     readonly "\uD83D\uDE48": "Subscription canceled";
     readonly "\uD83D\uDE80": "Performance measure";
@@ -335,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
       ),
@@ -774,13 +776,14 @@ var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing insta
 // internal/src/operation.ts
 var openOperation = (token, store) => {
   if (store.operation.open) {
-    store.logger.warn(
+    const rejectionTime = performance.now();
+    store.logger.info(
       `\u2757`,
       token.type,
       token.key,
-      `tried to setState, but must wait until setState for "${store.operation.token.key}" completes`
+      `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`
     );
-    return `rejection`;
+    return rejectionTime;
   }
   store.operation = {
     open: true,
@@ -989,12 +992,18 @@ var setAtomOrSelector = (state, value, store) => {
 
 // internal/src/set-state/set-into-store.ts
 function setIntoStore(token, value, store) {
-  const rejection = openOperation(token, store);
-  if (rejection) {
+  const rejectionTime = openOperation(token, store);
+  if (rejectionTime) {
     const unsubscribe = store.on.operationClose.subscribe(
-      `waiting to set "${token.key}"`,
+      `waiting to set "${token.key}" at T-${rejectionTime}`,
       () => {
         unsubscribe();
+        store.logger.info(
+          `\u{1F7E2}`,
+          token.type,
+          token.key,
+          `resuming deferred setState from T-${rejectionTime}`
+        );
         setIntoStore(token, value, store);
       }
     );
@@ -1213,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) {
@@ -1235,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
@@ -1307,8 +1317,8 @@ function subscribeToState(token, handleUpdate, key, store) {
     updateHandler = (update) => {
       if (dependencyUnsubFunctions) {
         dependencyUnsubFunctions.length = 0;
+        dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
       }
-      dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
       handleUpdate(update);
     };
   }
@@ -1868,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;
@@ -1881,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
@@ -2590,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>;
@@ -162,7 +164,7 @@ type OperationProgress = {
     time: number;
     token: WritableToken<any>;
 };
-declare const openOperation: (token: WritableToken<any>, store: Store) => `rejection` | undefined;
+declare const openOperation: (token: WritableToken<any>, store: Store) => number | undefined;
 declare const closeOperation: (store: Store) => void;
 declare const isDone: (key: string, store: Store) => boolean;
 declare const markDone: (key: string, store: Store) => void;
@@ -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>)[];
 
@@ -447,7 +451,7 @@ declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldVa
 
 declare function setIntoStore<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New), store: Store): void;
 
-declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[] | null;
+declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
 
 declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
 
@@ -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
       ),
@@ -496,13 +498,14 @@ var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing insta
 // internal/src/operation.ts
 var openOperation = (token, store) => {
   if (store.operation.open) {
-    store.logger.warn(
+    const rejectionTime = performance.now();
+    store.logger.info(
       `\u2757`,
       token.type,
       token.key,
-      `tried to setState, but must wait until setState for "${store.operation.token.key}" completes`
+      `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`
     );
-    return `rejection`;
+    return rejectionTime;
   }
   store.operation = {
     open: true,
@@ -711,12 +714,18 @@ var setAtomOrSelector = (state, value, store) => {
 
 // internal/src/set-state/set-into-store.ts
 function setIntoStore(token, value, store) {
-  const rejection = openOperation(token, store);
-  if (rejection) {
+  const rejectionTime = openOperation(token, store);
+  if (rejectionTime) {
     const unsubscribe = store.on.operationClose.subscribe(
-      `waiting to set "${token.key}"`,
+      `waiting to set "${token.key}" at T-${rejectionTime}`,
       () => {
         unsubscribe();
+        store.logger.info(
+          `\u{1F7E2}`,
+          token.type,
+          token.key,
+          `resuming deferred setState from T-${rejectionTime}`
+        );
         setIntoStore(token, value, store);
       }
     );
@@ -935,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) {
@@ -957,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
@@ -1029,8 +1039,8 @@ function subscribeToState(token, handleUpdate, key, store) {
     updateHandler = (update) => {
       if (dependencyUnsubFunctions) {
         dependencyUnsubFunctions.length = 0;
+        dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
       }
-      dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
       handleUpdate(update);
     };
   }
@@ -1590,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;
@@ -1603,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
@@ -2278,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"