atom.io 0.27.5 → 0.28.1

package/dist/chunk-YQ46F5O2.js

@@ -0,0 +1,95 @@
+import { createWritableSelectorFamily } from './chunk-6WL4RQMQ.js';
+import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
+
+// json/src/entries.ts
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function toEntries(obj) {
+  return Object.entries(obj);
+}
+var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
+  return createStandaloneSelector(store, {
+    key: `${atom.key}:JSON`,
+    get: ({ get }) => transform.toJson(get(atom)),
+    set: ({ set }, newValue) => {
+      set(atom, transform.fromJson(newValue));
+    }
+  });
+};
+function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
+  const jsonFamily = createWritableSelectorFamily(
+    store,
+    {
+      key: `${atomFamilyToken.key}:JSON`,
+      get: (key) => ({ seek, get }) => {
+        const existingState = seek(atomFamilyToken, key);
+        if (existingState) {
+          return transform.toJson(get(existingState));
+        }
+        const stringKey = stringifyJson(key);
+        const molecule = store.molecules.get(stringKey);
+        if (molecule) {
+          const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
+          return transform.toJson(get(atom));
+        }
+        if (store.config.lifespan === `immortal`) {
+          throw new Error(`No molecule found for key "${stringKey}"`);
+        }
+        const newToken = initFamilyMemberInStore(store, atomFamilyToken, key);
+        return transform.toJson(get(newToken));
+      },
+      set: (key) => ({ seek, set }, newValue) => {
+        const existingState = seek(atomFamilyToken, key);
+        if (existingState) {
+          set(existingState, transform.fromJson(newValue));
+        } else {
+          const stringKey = stringifyJson(key);
+          const molecule = store.molecules.get(stringKey);
+          if (molecule) {
+            const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
+            set(atom, transform.fromJson(newValue));
+          } else {
+            if (store.config.lifespan === `immortal`) {
+              throw new Error(`No molecule found for key "${stringKey}"`);
+            }
+            set(
+              initFamilyMemberInStore(store, atomFamilyToken, key),
+              transform.fromJson(newValue)
+            );
+          }
+        }
+      }
+    },
+    [`mutable`, `json`]
+  );
+  const atomFamily = withdraw(atomFamilyToken, store);
+  atomFamily.subject.subscribe(
+    `store=${store.config.name}::json-selector-family`,
+    (event) => {
+      if (event.token.family) {
+        seekInStore(store, jsonFamily, parseJson(event.token.family.subKey));
+      }
+    }
+  );
+  return jsonFamily;
+}
+
+// json/src/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_PROTOTYPES = [
+  Array.prototype,
+  Boolean.prototype,
+  Number.prototype,
+  Object.prototype,
+  String.prototype
+];
+var isJson = (input) => {
+  if (input === null) return true;
+  if (input === void 0) return false;
+  const prototype = Object.getPrototypeOf(input);
+  return JSON_PROTOTYPES.includes(prototype);
+};
+
+export { fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries };

package/dist/index.d.ts

@@ -341,6 +341,7 @@ declare class Silo {
     redo: typeof redo;
     moleculeFamily: typeof moleculeFamily;
     makeMolecule: typeof makeMolecule;
+    runTransaction: typeof runTransaction;
     constructor(config: Store[`config`], fromStore?: Store | null);
 }
 

package/dist/index.js

@@ -1,6 +1,6 @@
 import './chunk-XWL6SNVU.js';
 import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, arbitrary, actUponStore } from 'atom.io/internal';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, actUponStore, arbitrary } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
 
 function atom(options) {
@@ -102,6 +102,7 @@ var Silo = class {
   redo;
   moleculeFamily;
   makeMolecule;
+  runTransaction;
   constructor(config, fromStore = null) {
     const s = new Store(config, fromStore);
     this.store = s;
@@ -132,6 +133,7 @@ var Silo = class {
     this.makeMolecule = (...params) => {
       return makeMoleculeInStore(s, ...params);
     };
+    this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s);
   }
 };
 function subscribe(token, handleUpdate, key = arbitrary()) {

package/internal/dist/index.d.ts

@@ -1,24 +1,43 @@
 import * as atom_io from 'atom.io';
-import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, ReadableToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, WritableSelectorFamilyToken, ReadonlySelectorFamilyToken, SelectorFamilyToken, WritableFamilyToken, ReadableFamilyToken, MoleculeConstructor, MoleculeFamily, MoleculeFamilyToken, MoleculeToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
-import { Canonical, Json, JsonInterface } from 'atom.io/json';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, MoleculeConstructor, MoleculeFamilyToken, MoleculeKey, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, MoleculeFamily, MoleculeToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Json as Json$1, Canonical, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
 
-type primitive = boolean | number | string | null;
+declare const FAMILY_MEMBER_TOKEN_TYPES: {
+    readonly atom_family: "atom";
+    readonly mutable_atom_family: "mutable_atom";
+    readonly selector_family: "selector";
+    readonly readonly_selector_family: "readonly_selector";
+    readonly molecule_family: "molecule";
+};
+declare function counterfeit<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+declare function counterfeit<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeKey<M>;
 
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+type primitive = boolean | number | string | null;
+declare namespace Json {
+    type Serializable = primitive | Readonly<{
+        [key: string]: Serializable;
+    }> | ReadonlyArray<Serializable>;
+    type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+    type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
+}
 
 type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
 type Cardinality = `1:1` | `1:n` | `n:n`;
 
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
+interface JunctionEntries<Content extends Json.Object | null> extends Json.Object {
     readonly relations: [string, string[]][];
     readonly contents: [string, Content][];
 }
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
+interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object {
     readonly between: [a: ASide, b: BSide];
     readonly cardinality: Cardinality;
 }
@@ -30,7 +49,7 @@ type BaseExternalStoreConfiguration = {
     getRelatedKeys: (key: string) => Set<string> | undefined;
     has: (a: string, b?: string) => boolean;
 };
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
+type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
     getContent: (contentKey: string) => Content | undefined;
     setContent: (contentKey: string, content: Content) => void;
     deleteContent: (contentKey: string) => void;
@@ -38,14 +57,14 @@ type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
 type Empty<Obj extends object> = {
     [Key in keyof Obj]?: undefined;
 };
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
+type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
+type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
     externalStore?: ExternalStoreConfiguration<Content>;
     isContent?: Refinement<unknown, Content>;
     makeContentKey?: (a: string, b: string) => string;
 };
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
+type JunctionJSON<ASide extends string, BSide extends string, Content extends Json.Object | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
+declare class Junction<const ASide extends string, const BSide extends string, const Content extends Json.Object | null = null> {
     readonly a: ASide;
     readonly b: BSide;
     readonly cardinality: Cardinality;
@@ -159,7 +178,7 @@ declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 declare function deposit<T, K extends Canonical>(state: RegularAtomFamily<T, K>): RegularAtomFamilyToken<T, K>;
-declare function deposit<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+declare function deposit<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>;
 declare function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>;
 declare function deposit<T>(state: WritableSelectorFamily<T, any>): WritableSelectorFamilyToken<T, any>;
 declare function deposit<T>(state: ReadonlySelectorFamily<T, any>): ReadonlySelectorFamilyToken<T, any>;
@@ -170,6 +189,7 @@ declare function deposit<M extends MoleculeConstructor>(state: MoleculeFamily<M>
 declare function deposit<M extends MoleculeConstructor>(state: Molecule<M>): MoleculeToken<M>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit(state: Molecule<any> | ReadableState<any>): MoleculeToken<any> | ReadableToken<any>;
+declare function deposit(state: Molecule<any> | MoleculeFamily<any> | ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>): MoleculeFamilyToken<any> | MoleculeToken<any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func>;
 
 interface Lineage {
     parent: typeof this | null;
@@ -238,6 +258,17 @@ declare function createTimeline<ManagedAtom extends TimelineManageable>(options:
 
 declare const timeTravel: (store: Store, action: `redo` | `undo`, token: TimelineToken<any>) => void;
 
+declare class CircularBuffer<T> {
+    protected _buffer: T[];
+    protected _index: number;
+    constructor(array: T[]);
+    constructor(length: number);
+    get buffer(): ReadonlyArray<T | undefined>;
+    get index(): number;
+    add(item: T): void;
+    copy(): CircularBuffer<T>;
+}
+
 declare class Store implements Lineage {
     parent: Store | null;
     child: Store | null;
@@ -259,6 +290,10 @@ declare class Store implements Lineage {
     timelineTopics: Junction<"timelineKey", "topicKey", {
         topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
     }>;
+    disposalTraces: CircularBuffer<{
+        key: string;
+        trace: string;
+    }>;
     molecules: Map<string, Molecule<any>>;
     moleculeFamilies: Map<string, Flat<atom_io.MoleculeFamilyToken<any> & {
         subject: Subject<atom_io.MoleculeCreation<any> | atom_io.MoleculeDisposal>;
@@ -304,7 +339,7 @@ declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>
 declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
 declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
 declare function withdraw<T, K extends Canonical>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
-declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+declare function withdraw<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
 declare function withdraw<T, K extends Canonical>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
@@ -315,29 +350,30 @@ declare function withdraw<M extends MoleculeConstructor>(token: MoleculeToken<M>
 declare function withdraw<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, store: Store): MoleculeFamily<M>;
 declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
 declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
+declare function withdraw<T, M extends MoleculeConstructor>(token: MoleculeToken<M> | ReadableToken<T>, store: Store): Molecule<M> | ReadableState<T>;
 
-interface Transceiver<Signal extends Json.Serializable> {
+interface Transceiver<Signal extends Json$1.Serializable> {
     do: (update: Signal) => number | `OUT_OF_RANGE` | null;
     undo: (update: Signal) => void;
     subscribe: (key: string, fn: (update: Signal) => void) => () => void;
     cacheUpdateNumber: number;
     getUpdateNumber: (update: Signal) => number;
 }
-declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
+declare function isTransceiver(value: unknown): value is Transceiver<Json$1.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
 type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
 
-declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined): MutableAtomToken<T, J>;
+declare function createMutableAtom<T extends Transceiver<any>, J extends Json$1.Serializable>(store: Store, options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined): MutableAtomToken<T, J>;
 
-declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
+declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json$1.Serializable, K extends string>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
 
-declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
+declare const getJsonFamily: <Core extends Transceiver<Json$1.Serializable>, SerializableCore extends Json$1.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
 
-declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
+declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json$1.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
 
-declare const getUpdateFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core>, Key>;
+declare const getUpdateFamily: <Core extends Transceiver<Json$1.Serializable>, SerializableCore extends Json$1.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core>, Key>;
 
-declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
+declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json$1.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
 
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
@@ -351,10 +387,10 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private unsubscribeFromState;
     private observeCore;
     private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+    mutableState: MutableAtomToken<Mutable, Json$1.Serializable>;
     latestUpdateState: RegularAtomToken<typeof this.Update | null>;
     dispose: () => void;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+    constructor(mutableState: MutableAtomToken<Mutable, Json$1.Serializable>, store: Store);
 }
 
 declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Canonical> {
@@ -369,7 +405,7 @@ declare function arbitrary(random?: () => number): string;
 declare function createRegularAtom<T>(store: Store, options: RegularAtomOptions<T>, family: FamilyMetadata | undefined): RegularAtomToken<T>;
 
 declare function createStandaloneAtom<T>(store: Store, options: RegularAtomOptions<T>): RegularAtomToken<T>;
-declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
+declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json$1.Serializable>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 
 declare function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
@@ -401,7 +437,7 @@ declare function cacheValue<T extends Promise<any>>(key: string, value: T, subje
 declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
-declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+declare function createAtomFamily<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
 declare function createAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
 
 declare function createReadonlySelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>, internalRoles?: string[]): ReadonlySelectorFamilyToken<T, K>;
@@ -415,7 +451,7 @@ declare function disposeFromStore(store: Store, token: MoleculeToken<any> | Read
 declare function disposeFromStore<K extends Canonical>(store: Store, token: ReadableFamilyToken<any, K>, key: K): void;
 declare function disposeFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
 
-declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function findInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
@@ -424,7 +460,7 @@ declare function findInStore<T, K extends Canonical, Key extends K>(store: Store
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
 
-declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
@@ -433,7 +469,7 @@ declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
 
-declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
+declare function seekInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
@@ -515,7 +551,7 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
 }
 
-declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomToken<T, J>;
+declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomToken<T, J>;
 declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomToken<T>;
 declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: AtomFamilyToken<T, K>, store: Store): AtomToken<T>;
 declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorToken<T>;
@@ -531,7 +567,7 @@ declare function prettyPrintTokenType(token: AtomIOToken): string;
 
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
-    constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
+    constructor(familyToken: AtomIOToken, key: Json$1.Serializable, store: Store);
 }
 
 declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
@@ -589,7 +625,7 @@ type RegularAtom<T> = AtomIOState & {
     default: T | (() => T);
     cleanup?: () => void;
 };
-type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
+type MutableAtom<T extends Transceiver<any>, J extends Json$1.Serializable> = AtomIOState & JsonInterface<T, J> & {
     type: `mutable_atom`;
     default: T | (() => T);
     cleanup?: () => void;
@@ -613,7 +649,7 @@ type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> &
     install: (store: Store) => void;
     internalRoles: string[] | undefined;
 };
-type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
+type MutableAtomFamily<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
     (key: K): MutableAtomToken<T, J>;
     subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
     install: (store: Store) => void;
@@ -636,4 +672,4 @@ type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | Wri
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 
-export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type Range, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type ChildStore, type EnvironmentData, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type Range, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -1,3 +1,3 @@
-export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-6ABWLAGY.js';
+export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-6WL4RQMQ.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';

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

@@ -12,15 +12,8 @@ import {
 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 dispose atom, but it does not exist in the store.`,
-		)
-	} else if (!atom.family) {
+	const atom = withdraw(atomToken, target)
+	if (!atom.family) {
 		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()

package/internal/src/families/dispose-from-store.ts

@@ -6,12 +6,12 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import { type Canonical, stringifyJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
 import { disposeMolecule } from "../molecule/dispose-molecule"
 import { disposeSelector } from "../selector"
-import type { Store } from "../store"
+import { counterfeit, type Store, withdraw } from "../store"
 import { findInStore } from "./find-in-store"
 import { seekInStore } from "./seek-in-store"
 
@@ -40,31 +40,36 @@ export function disposeFromStore(
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 ): void {
 	let token: MoleculeToken<any> | ReadableToken<any>
+	let fullKey: string
 	if (params.length === 1) {
 		token = params[0]
+		fullKey = token.key
 	} else {
 		const family = params[0]
 		const key = params[1]
 		const maybeToken =
 			family.type === `molecule_family`
-				? seekInStore(store, family, key)
-				: store.config.lifespan === `immortal`
-					? seekInStore(store, family, key)
-					: findInStore(store, family, key)
-		if (!maybeToken) {
-			store.logger.error(
-				`❗`,
-				family.type,
-				family.key,
-				`tried to dispose of member`,
-				stringifyJson(key),
-				`but it was not found in store`,
-				store.config.name,
-			)
-			return
-		}
+				? seekInStore(store, family, key) ?? counterfeit(family, key)
+				: findInStore(store, family, key)
 		token = maybeToken
 	}
+	try {
+		withdraw(token, store)
+	} catch (thrown) {
+		const disposal = store.disposalTraces.buffer.find(
+			(item) => item?.key === token.key,
+		)
+		store.logger.error(
+			`❌`,
+			token.type,
+			token.key,
+			`could not be disposed because it was not found in the store "${store.config.name}".`,
+			disposal
+				? `\n   This state was most recently disposed\n${disposal.trace}`
+				: `No previous disposal trace was found.`,
+		)
+		return
+	}
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:
@@ -78,4 +83,10 @@ export function disposeFromStore(
 			disposeMolecule(token, store)
 			break
 	}
+
+	const { stack } = new Error()
+	if (stack) {
+		const trace = stack?.split(`\n`)?.slice(3)?.join(`\n`)
+		store.disposalTraces.add({ key: token.key, trace })
+	}
 }

package/internal/src/families/find-in-store.ts

@@ -16,10 +16,11 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import { type Canonical, type Json, stringifyJson } from "atom.io/json"
 
+import { growMoleculeInStore } from "../molecule"
 import type { Transceiver } from "../mutable"
-import type { Store } from "../store"
+import { counterfeit, type Store } from "../store"
 import { initFamilyMemberInStore } from "./init-family-member"
 import { seekInStore } from "./seek-in-store"
 
@@ -81,15 +82,24 @@ export function findInStore(
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 ): ReadableToken<any> {
-	if (store.config.lifespan === `immortal`) {
-		throw new Error(
-			`Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`,
-		)
-	}
 	let state = seekInStore(store, token, key)
 	if (state) {
 		return state
 	}
+	const molecule = store.molecules.get(stringifyJson(key))
+	if (molecule) {
+		return growMoleculeInStore(molecule, token, store)
+	}
+	if (store.config.lifespan === `immortal`) {
+		const fakeToken = counterfeit(token, key)
+		store.logger.error(
+			`❌`,
+			fakeToken.type,
+			fakeToken.key,
+			`was not found in store "${store.config.name}"; returned a counterfeit token.`,
+		)
+		return fakeToken
+	}
 	state = initFamilyMemberInStore(store, token, key)
 	return state
 }