atom.io 0.21.1 → 0.22.0

package/dist/{chunk-HITX3MO4.js → chunk-JA4V7TJY.js}

@@ -1,40 +1,42 @@
 import { Junction } from './chunk-FTONNX2R.js';
 import { disposeState } from 'atom.io';
-import { getFromStore, setIntoStore, findInStore, createMutableAtomFamily, createRegularAtomFamily, IMPLICIT, newest, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { getFromStore, setIntoStore, findInStore, seekInStore, initFamilyMember, createMutableAtomFamily, createRegularAtomFamily, IMPLICIT, newest, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { stringifyJson } from 'atom.io/json';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
 }
 var Join = class _Join {
-  transact(transactors, run) {
-    const originalTransactors = this.transactors;
-    this.transactors = transactors;
-    run(this);
-    this.transactors = originalTransactors;
-  }
-  in(store) {
-    const key = store.config.name;
-    const alternate = this.alternates.get(key);
-    if (alternate) {
-      return alternate;
-    }
-    const join2 = new _Join(this.options, this.defaultContent, store);
-    this.alternates.set(key, join2);
-    join2.alternates = this.alternates;
-    return join2;
-  }
   constructor(options, defaultContent, store = IMPLICIT.STORE) {
+    this.molecules = /* @__PURE__ */ new Map();
+    this.store = store;
     this.options = options;
     this.defaultContent = defaultContent;
     this.alternates = /* @__PURE__ */ new Map();
     this.alternates.set(store.config.name, this);
+    this.store.miscResources.set(`join:${options.key}`, this);
     this.transactors = {
       get: (token) => getFromStore(token, store),
       set: (token, value) => {
         setIntoStore(token, value, store);
       },
-      find: (token, key) => findInStore(token, key, store)
+      find: (token, key) => findInStore(token, key, store),
+      seek: (token, key) => seekInStore(token, key, store)
+    };
+    this.retrieve = (token, key) => {
+      const maybeToken = this.transactors.seek(token, key);
+      if (maybeToken) {
+        return maybeToken;
+      }
+      const molecule = this.molecules.get(stringifyJson(key));
+      if (!molecule) {
+        if (store.config.lifespan === `immortal`) {
+          throw new Error(`No molecule found for key "${stringifyJson(key)}"`);
+        }
+        return initFamilyMember(token, key, store);
+      }
+      return molecule.bond(token);
     };
     const aSide = options.between[0];
     const bSide = options.between[1];
@@ -49,31 +51,57 @@ var Join = class _Join {
       store
     );
     this.core = { findRelatedKeysState: relatedKeysAtoms };
-    const getRelatedKeys = ({ find, get }, key) => get(find(relatedKeysAtoms, key));
+    const getRelatedKeys = ({ get }, key) => get(this.retrieve(relatedKeysAtoms, key));
     const addRelation = (transactors, a, b) => {
-      const { set, find } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a);
-      const bKeysState = find(relatedKeysAtoms, b);
+      const { set } = transactors;
+      const aKeysState = this.retrieve(relatedKeysAtoms, a);
+      const bKeysState = this.retrieve(relatedKeysAtoms, b);
       set(aKeysState, (aKeys) => aKeys.add(b));
       set(bKeysState, (bKeys) => bKeys.add(a));
     };
     const deleteRelation = (transactors, a, b) => {
-      const { find, set } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a);
-      const bKeysState = find(relatedKeysAtoms, b);
-      set(aKeysState, (aKeys) => (aKeys.delete(b), aKeys));
-      set(bKeysState, (bKeys) => (bKeys.delete(a), bKeys));
+      var _a, _b;
+      const { set } = transactors;
+      const aKeysState = this.retrieve(relatedKeysAtoms, a);
+      const bKeysState = this.retrieve(relatedKeysAtoms, b);
+      let stringA;
+      let stringB;
+      set(aKeysState, (aKeys) => {
+        aKeys.delete(b);
+        if (aKeys.size === 0) {
+          stringA = `"${a}"`;
+        }
+        return aKeys;
+      });
+      set(bKeysState, (bKeys) => {
+        bKeys.delete(a);
+        if (bKeys.size === 0) {
+          stringB = `"${b}"`;
+        }
+        return bKeys;
+      });
+      if (stringA && this.molecules.has(stringA)) {
+        (_a = this.molecules.get(stringA)) == null ? void 0 : _a.clear();
+        this.molecules.delete(stringA);
+      }
+      if (stringB && this.molecules.has(stringB)) {
+        (_b = this.molecules.get(stringB)) == null ? void 0 : _b.clear();
+        this.molecules.delete(stringB);
+      }
     };
     const replaceRelationsSafely = (transactors, a, newRelationsOfA) => {
-      const { find, get, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a);
+      const { get, set } = transactors;
+      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
       const currentRelationsOfA = get(relationsOfAState);
       for (const currentRelationB of currentRelationsOfA) {
         const remainsRelated = newRelationsOfA.includes(currentRelationB);
         if (remainsRelated) {
           continue;
         }
-        const relationsOfBState = find(relatedKeysAtoms, currentRelationB);
+        const relationsOfBState = this.retrieve(
+          relatedKeysAtoms,
+          currentRelationB
+        );
         set(relationsOfBState, (relationsOfB) => {
           relationsOfB.delete(a);
           return relationsOfB;
@@ -86,6 +114,7 @@ var Join = class _Join {
             const relationsOfB = getRelatedKeys(transactors, newRelationB);
             const newRelationBIsAlreadyRelated = relationsOfB.has(a);
             if (this.relations.cardinality === `1:n`) {
+              const previousOwnersToDispose = [];
               for (const previousOwner of relationsOfB) {
                 if (previousOwner === a) {
                   continue;
@@ -95,10 +124,21 @@ var Join = class _Join {
                   previousOwner
                 );
                 previousOwnerRelations.delete(newRelationB);
+                if (previousOwnerRelations.size === 0) {
+                  previousOwnersToDispose.push(previousOwner);
+                }
               }
               if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
                 relationsOfB.clear();
               }
+              for (const previousOwner of previousOwnersToDispose) {
+                const molecule = this.molecules.get(previousOwner);
+                molecule == null ? void 0 : molecule.clear();
+                this.molecules.delete(previousOwner);
+                const sorted = [newRelationB, previousOwner].sort();
+                const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
+                this.molecules.delete(compositeKey);
+              }
             }
             if (!newRelationBIsAlreadyRelated) {
               relationsOfB.add(a);
@@ -111,8 +151,8 @@ var Join = class _Join {
       });
     };
     const replaceRelationsUnsafely = (transactors, a, newRelationsOfA) => {
-      const { find, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a);
+      const { set } = transactors;
+      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
       set(relationsOfAState, (relationsOfA) => {
         relationsOfA.transaction((nextRelationsOfA) => {
           for (const newRelationB of newRelationsOfA) {
@@ -123,7 +163,7 @@ var Join = class _Join {
         return relationsOfA;
       });
       for (const newRelationB of newRelationsOfA) {
-        const newRelationsBState = find(relatedKeysAtoms, newRelationB);
+        const newRelationsBState = this.retrieve(relatedKeysAtoms, newRelationB);
         set(newRelationsBState, (newRelationsB) => {
           newRelationsB.add(a);
           return newRelationsB;
@@ -161,12 +201,13 @@ var Join = class _Join {
         },
         store
       );
-      const getContent = ({ find, get }, key) => get(find(contentAtoms, key));
-      const setContent = ({ find, set }, key, content) => {
-        set(find(contentAtoms, key), content);
+      const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
+      const setContent = ({ set }, key, content) => {
+        set(this.retrieve(contentAtoms, key), content);
       };
-      const deleteContent = ({ find }, key) => {
-        disposeState(find(contentAtoms, key));
+      const deleteContent = (_, compositeKey) => {
+        disposeState(this.retrieve(contentAtoms, compositeKey));
+        this.molecules.delete(`"${compositeKey}"`);
       };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {
@@ -189,13 +230,24 @@ var Join = class _Join {
     }
     const relations = new Junction(options, {
       externalStore,
-      makeContentKey: (...args) => args.sort().join(`:`)
+      makeContentKey: (...args) => {
+        const sorted = args.sort();
+        const compositeKey = `${sorted[0]}:${sorted[1]}`;
+        const [m0, m1] = sorted.map(
+          (key) => this.molecules.get(stringifyJson(key))
+        );
+        if (store.config.lifespan === `immortal` && m0 && m1) {
+          const composite = m0.with(m1)(compositeKey);
+          this.molecules.set(`"${compositeKey}"`, composite);
+        }
+        return compositeKey;
+      }
     });
     const createSingleKeyStateFamily = () => createSelectorFamily(
       {
         key: `${options.key}/singleRelatedKey`,
-        get: (key) => ({ find, get }) => {
-          const relatedKeysState = find(relatedKeysAtoms, key);
+        get: (key) => ({ get }) => {
+          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
           const relatedKeys = get(relatedKeysState);
           for (const relatedKey of relatedKeys) {
             return relatedKey;
@@ -209,9 +261,9 @@ var Join = class _Join {
       return createSelectorFamily(
         {
           key: `${options.key}/multipleRelatedKeys`,
-          get: (key) => ({ find, get }) => {
+          get: (key) => ({ get }) => {
             const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-            const jsonState = find(jsonFamily, key);
+            const jsonState = this.retrieve(jsonFamily, key);
             const json = get(jsonState);
             return json.members;
           }
@@ -222,12 +274,12 @@ var Join = class _Join {
     const createSingleEntryStateFamily = () => createSelectorFamily(
       {
         key: `${options.key}/singleRelatedEntry`,
-        get: (key) => ({ find, get }) => {
-          const relatedKeysState = find(relatedKeysAtoms, key);
+        get: (key) => ({ get }) => {
+          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
           const relatedKeys = get(relatedKeysState);
           for (const relatedKey of relatedKeys) {
             const contentKey = relations.makeContentKey(key, relatedKey);
-            const contentState = find(contentAtoms, contentKey);
+            const contentState = this.retrieve(contentAtoms, contentKey);
             const content = get(contentState);
             return [relatedKey, content];
           }
@@ -239,12 +291,13 @@ var Join = class _Join {
     const getMultipleEntryStateFamily = () => createSelectorFamily(
       {
         key: `${options.key}/multipleRelatedEntries`,
-        get: (key) => ({ find, get }) => {
+        get: (key) => ({ get }) => {
           const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-          const json = get(jsonFamily(key));
+          const jsonState = this.retrieve(jsonFamily, key);
+          const json = get(jsonState);
           return json.members.map((relatedKey) => {
             const contentKey = relations.makeContentKey(key, relatedKey);
-            const contentState = find(contentAtoms, contentKey);
+            const contentState = this.retrieve(contentAtoms, contentKey);
             const content = get(contentState);
             return [relatedKey, content];
           });
@@ -337,6 +390,26 @@ var Join = class _Join {
       }
     }
   }
+  transact(transactors, run) {
+    const originalTransactors = this.transactors;
+    this.transactors = transactors;
+    run(this);
+    this.transactors = originalTransactors;
+  }
+  [Symbol.dispose]() {
+    this.alternates.delete(this.store.config.name);
+  }
+  in(store) {
+    const key = store.config.name;
+    const alternate = this.alternates.get(key);
+    if (alternate) {
+      return alternate;
+    }
+    const join2 = new _Join(this.options, this.defaultContent, store);
+    this.alternates.set(key, join2);
+    join2.alternates = this.alternates;
+    return join2;
+  }
 };
 function join(options, defaultContent, store = IMPLICIT.STORE) {
   const joins = getJoinMap(store);
@@ -384,12 +457,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keyAB]() {
           const familyAB = myJoin.states[keyAB];
-          const state = findInStore(familyAB, key, store);
+          const state = myJoin.retrieve(familyAB, key);
           return state;
         },
         get [keyBA]() {
           const familyBA = myJoin.states[keyBA];
-          const state = findInStore(familyBA, key, store);
+          const state = myJoin.retrieve(familyBA, key);
           return state;
         }
       };
@@ -399,12 +472,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entryAB]() {
             const familyAB = myJoin.states[entryAB];
-            const state = findInStore(familyAB, key, store);
+            const state = myJoin.retrieve(familyAB, key);
             return state;
           },
           get [entryBA]() {
             const familyBA = myJoin.states[entryBA];
-            const state = findInStore(familyBA, key, store);
+            const state = myJoin.retrieve(familyBA, key);
             return state;
           }
         });
@@ -417,12 +490,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keyAB]() {
           const familyAB = myJoin.states[keyAB];
-          const state = findInStore(familyAB, key, store);
+          const state = myJoin.retrieve(familyAB, key);
           return state;
         },
         get [keysBA]() {
           const familyBA = myJoin.states[keysBA];
-          const state = findInStore(familyBA, key, store);
+          const state = myJoin.retrieve(familyBA, key);
           return state;
         }
       };
@@ -432,12 +505,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entryAB]() {
             const familyAB = myJoin.states[entryAB];
-            const state = findInStore(familyAB, key, store);
+            const state = myJoin.retrieve(familyAB, key);
             return state;
           },
           get [entriesBA]() {
             const familyBA = myJoin.states[entriesBA];
-            const state = findInStore(familyBA, key, store);
+            const state = myJoin.retrieve(familyBA, key);
             return state;
           }
         });
@@ -450,12 +523,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keysAB]() {
           const familyAB = myJoin.states[keysAB];
-          const state = findInStore(familyAB, key, store);
+          const state = myJoin.retrieve(familyAB, key);
           return state;
         },
         get [keysBA]() {
           const familyBA = myJoin.states[keysBA];
-          const state = findInStore(familyBA, key, store);
+          const state = myJoin.retrieve(familyBA, key);
           return state;
         }
       };
@@ -465,12 +538,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entriesAB]() {
             const familyAB = myJoin.states[entriesAB];
-            const state = findInStore(familyAB, key, store);
+            const state = myJoin.retrieve(familyAB, key);
             return state;
           },
           get [entriesBA]() {
             const familyBA = myJoin.states[entriesBA];
-            const state = findInStore(familyBA, key, store);
+            const state = myJoin.retrieve(familyBA, key);
             return state;
           }
         });

package/dist/index.cjs

@@ -41,10 +41,6 @@ function disposeState(token, store = Internal__namespace.IMPLICIT.STORE) {
       break;
   }
 }
-function findState(token, key) {
-  const state = Internal.findInStore(token, key, Internal.IMPLICIT.STORE);
-  return state;
-}
 function getState(token) {
   return Internal__namespace.getFromStore(token, Internal__namespace.IMPLICIT.STORE);
 }
@@ -97,8 +93,8 @@ function setState(token, value) {
   Internal__namespace.setIntoStore(token, value, Internal__namespace.IMPLICIT.STORE);
 }
 var Silo = class {
-  constructor(name, fromStore = null) {
-    const s = new Internal.Store(name, fromStore);
+  constructor(config, fromStore = null) {
+    const s = new Internal.Store(config, fromStore);
     function _atom(options) {
       return Internal.createStandaloneAtom(options, s);
     }
@@ -171,7 +167,6 @@ exports.atom = atom;
 exports.atomFamily = atomFamily;
 exports.belongsTo = belongsTo;
 exports.disposeState = disposeState;
-exports.findState = findState;
 exports.getState = getState;
 exports.isToken = isToken;
 exports.redo = redo;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as Internal from 'atom.io/internal';
 import { Transceiver, Subject, Store, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineSelectorUpdate, TimelineTransactionUpdate } from 'atom.io/internal';
 import { Json, JsonInterface } from 'atom.io/json';
+import { findState } from 'atom.io/ephemeral';
 import { MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1 } from 'atom.io';
 
 type Effectors<T> = {
@@ -33,7 +34,10 @@ type RegularAtomFamilyToken<T, K extends Json.Serializable> = {
     __T?: T;
     __K?: K;
 };
-type RegularAtomFamilyTokenWithCall<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => RegularAtomToken<T>);
+type RegularAtomFamilyTokenWithCall<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): RegularAtomToken<T>;
+};
 type RegularAtomFamily<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & {
     (key: K): RegularAtomToken<T>;
     subject: Subject<RegularAtomToken<T>>;
@@ -52,7 +56,10 @@ type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializa
     __J?: J;
     __K?: K;
 };
-type MutableAtomFamilyTokenWithCall<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = MutableAtomFamilyToken<T, J, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => MutableAtomToken<T, J>);
+type MutableAtomFamilyTokenWithCall<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = MutableAtomFamilyToken<T, J, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): MutableAtomToken<T, J>;
+};
 type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
     (key: K): MutableAtomToken<T, J>;
     subject: Subject<MutableAtomToken<T, J>>;
@@ -63,6 +70,13 @@ type AtomFamilyToken<T, K extends Json.Serializable = Json.Serializable> = Mutab
 declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyTokenWithCall<T, J, K>;
 declare function atomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyTokenWithCall<T, K>;
 
+declare function seekState<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> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T> | undefined;
+
 type TransactionToken<F extends Func> = {
     key: string;
     type: `transaction`;
@@ -81,15 +95,17 @@ type Transactors = Readonly<{
     get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S;
     set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
     find: typeof findState;
+    seek: typeof seekState;
 }>;
 type TransactorsWithRunAndEnv = Readonly<{
     get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S;
     set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
     find: typeof findState;
+    seek: typeof seekState;
     run: typeof runTransaction;
     env: () => EnvironmentData;
 }>;
-type ReadonlyTransactors = Pick<Transactors, `find` | `get`>;
+type ReadonlyTransactors = Pick<Transactors, `find` | `get` | `seek`>;
 type Read<F extends Func> = (transactors: ReadonlyTransactors, ...parameters: Parameters<F>) => ReturnType<F>;
 type Write<F extends Func> = (transactors: Transactors, ...parameters: Parameters<F>) => ReturnType<F>;
 type Transact<F extends Func> = (transactors: TransactorsWithRunAndEnv, ...parameters: Parameters<F>) => ReturnType<F>;
@@ -127,7 +143,10 @@ type WritableSelectorFamilyToken<T, K extends Json.Serializable> = {
     __T?: T;
     __K?: K;
 };
-type WritableSelectorFamilyTokenWithCall<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => WritableSelectorToken<T>);
+type WritableSelectorFamilyTokenWithCall<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): WritableSelectorToken<T>;
+};
 type WritableSelectorFamily<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & {
     (key: K): WritableSelectorToken<T>;
     subject: Subject<WritableSelectorToken<T>>;
@@ -139,7 +158,10 @@ type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
     __T?: T;
     __K?: K;
 };
-type ReadonlySelectorFamilyTokenWithCall<T, K extends Json.Serializable> = ReadonlySelectorFamilyToken<T, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => ReadonlySelectorToken<T>);
+type ReadonlySelectorFamilyTokenWithCall<T, K extends Json.Serializable> = ReadonlySelectorFamilyToken<T, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): ReadonlySelectorToken<T>;
+};
 type ReadonlySelectorFamily<T, K extends Json.Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
@@ -155,13 +177,6 @@ declare function selectorFamily<T, K extends Json.Serializable>(options: Readonl
 
 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>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T>;
-
 declare function getState<T>(token: ReadableToken<T>): T;
 
 declare const LoggerIconDictionary: {
@@ -250,7 +265,7 @@ declare class Silo {
     subscribe: typeof subscribe;
     undo: typeof undo;
     redo: typeof redo;
-    constructor(name: string, fromStore?: Store | null);
+    constructor(config: Store[`config`], fromStore?: Store | null);
 }
 
 type StateUpdate<T> = {
@@ -336,4 +351,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, disposeState, 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, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -1,7 +1,7 @@
 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';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
 
 function atom(options) {
   return createStandaloneAtom(options, IMPLICIT.STORE);
@@ -21,10 +21,6 @@ function disposeState(token, store = Internal.IMPLICIT.STORE) {
       break;
   }
 }
-function findState(token, key) {
-  const state = findInStore(token, key, IMPLICIT.STORE);
-  return state;
-}
 
 // src/logger.ts
 var LOG_LEVELS = [`info`, `warn`, `error`];
@@ -74,8 +70,8 @@ function setState(token, value) {
   Internal.setIntoStore(token, value, Internal.IMPLICIT.STORE);
 }
 var Silo = class {
-  constructor(name, fromStore = null) {
-    const s = new Store(name, fromStore);
+  constructor(config, fromStore = null) {
+    const s = new Store(config, fromStore);
     function _atom(options) {
       return createStandaloneAtom(options, s);
     }
@@ -141,4 +137,4 @@ function belongsTo(family, unknownToken) {
   return family.key === ((_a = unknownToken.family) == null ? void 0 : _a.key);
 }
 
-export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, findState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/ephemeral/dist/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var internal = require('atom.io/internal');
+
+// ephemeral/src/find-state.ts
+function findState(token, key) {
+  const state = internal.findInStore(token, key, internal.IMPLICIT.STORE);
+  return state;
+}
+
+exports.findState = findState;

package/ephemeral/dist/index.js

@@ -0,0 +1,9 @@
+import '../../dist/chunk-F2X4B4VY.js';
+import { findInStore, IMPLICIT } from 'atom.io/internal';
+
+function findState(token, key) {
+  const state = findInStore(token, key, IMPLICIT.STORE);
+  return state;
+}
+
+export { findState };

package/ephemeral/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "atom.io-ephemeral",
+	"type": "module",
+	"private": true,
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"browser": "./dist/index.js",
+			"require": "./dist/index.cjs",
+			"types": "./dist/index.d.ts"
+		}
+	}
+}

package/ephemeral/src/index.ts

@@ -0,0 +1 @@
+export * from "./find-state"