atom.io 0.19.1 → 0.19.2

package/dist/{chunk-7ZR244C2.js → chunk-MSCJWACE.js}

@@ -1,4 +1,4 @@
-import { Junction } from './chunk-WX2NCOZR.js';
+import { Junction } from './chunk-FTONNX2R.js';
 import { dispose } 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';
@@ -31,11 +31,13 @@ var Join = class _Join {
     this.alternates.set(store.config.name, this);
     this.transactors = {
       get: (token) => getFromStore(token, store),
-      set: (token, value) => setIntoStore(token, value, store),
+      set: (token, value) => {
+        setIntoStore(token, value, store);
+      },
       find: (token, key) => findInStore(token, key, store)
     };
-    const a = options.between[0];
-    const b = options.between[1];
+    const aSide = options.between[0];
+    const bSide = options.between[1];
     const relatedKeysAtoms = createMutableAtomFamily(
       {
         key: `${options.key}/relatedKeys`,
@@ -48,23 +50,23 @@ var Join = class _Join {
     );
     this.core = { findRelatedKeysState: relatedKeysAtoms };
     const getRelatedKeys = ({ find, get }, key) => get(find(relatedKeysAtoms, key));
-    const addRelation = (transactors, a2, b2) => {
+    const addRelation = (transactors, a, b) => {
       const { set, find } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a2);
-      const bKeysState = find(relatedKeysAtoms, b2);
-      set(aKeysState, (aKeys) => aKeys.add(b2));
-      set(bKeysState, (bKeys) => bKeys.add(a2));
+      const aKeysState = find(relatedKeysAtoms, a);
+      const bKeysState = find(relatedKeysAtoms, b);
+      set(aKeysState, (aKeys) => aKeys.add(b));
+      set(bKeysState, (bKeys) => bKeys.add(a));
     };
-    const deleteRelation = (transactors, a2, b2) => {
+    const deleteRelation = (transactors, a, b) => {
       const { find, set } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a2);
-      const bKeysState = find(relatedKeysAtoms, b2);
-      set(aKeysState, (aKeys) => (aKeys.delete(b2), aKeys));
-      set(bKeysState, (bKeys) => (bKeys.delete(a2), bKeys));
+      const aKeysState = find(relatedKeysAtoms, a);
+      const bKeysState = find(relatedKeysAtoms, b);
+      set(aKeysState, (aKeys) => (aKeys.delete(b), aKeys));
+      set(bKeysState, (bKeys) => (bKeys.delete(a), bKeys));
     };
-    const replaceRelationsSafely = (transactors, a2, newRelationsOfA) => {
+    const replaceRelationsSafely = (transactors, a, newRelationsOfA) => {
       const { find, get, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const relationsOfAState = find(relatedKeysAtoms, a);
       const currentRelationsOfA = get(relationsOfAState);
       for (const currentRelationB of currentRelationsOfA) {
         const remainsRelated = newRelationsOfA.includes(currentRelationB);
@@ -73,7 +75,7 @@ var Join = class _Join {
         }
         const relationsOfBState = find(relatedKeysAtoms, currentRelationB);
         set(relationsOfBState, (relationsOfB) => {
-          relationsOfB.delete(a2);
+          relationsOfB.delete(a);
           return relationsOfB;
         });
       }
@@ -82,10 +84,10 @@ var Join = class _Join {
           nextRelationsOfA.clear();
           for (const newRelationB of newRelationsOfA) {
             const relationsOfB = getRelatedKeys(transactors, newRelationB);
-            const newRelationBIsAlreadyRelated = relationsOfB.has(a2);
+            const newRelationBIsAlreadyRelated = relationsOfB.has(a);
             if (this.relations.cardinality === `1:n`) {
               for (const previousOwner of relationsOfB) {
-                if (previousOwner === a2) {
+                if (previousOwner === a) {
                   continue;
                 }
                 const previousOwnerRelations = getRelatedKeys(
@@ -99,7 +101,7 @@ var Join = class _Join {
               }
             }
             if (!newRelationBIsAlreadyRelated) {
-              relationsOfB.add(a2);
+              relationsOfB.add(a);
             }
             nextRelationsOfA.add(newRelationB);
           }
@@ -108,9 +110,9 @@ var Join = class _Join {
         return relationsOfA;
       });
     };
-    const replaceRelationsUnsafely = (transactors, a2, newRelationsOfA) => {
+    const replaceRelationsUnsafely = (transactors, a, newRelationsOfA) => {
       const { find, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const relationsOfAState = find(relatedKeysAtoms, a);
       set(relationsOfAState, (relationsOfA) => {
         relationsOfA.transaction((nextRelationsOfA) => {
           for (const newRelationB of newRelationsOfA) {
@@ -123,23 +125,31 @@ var Join = class _Join {
       for (const newRelationB of newRelationsOfA) {
         const newRelationsBState = find(relatedKeysAtoms, newRelationB);
         set(newRelationsBState, (newRelationsB) => {
-          newRelationsB.add(a2);
+          newRelationsB.add(a);
           return newRelationsB;
         });
       }
       return true;
     };
-    const has = (transactors, a2, b2) => {
-      const aKeys = getRelatedKeys(transactors, a2);
-      return b2 ? aKeys.has(b2) : aKeys.size > 0;
+    const has = (transactors, a, b) => {
+      const aKeys = getRelatedKeys(transactors, a);
+      return b ? aKeys.has(b) : aKeys.size > 0;
     };
     const baseExternalStoreConfiguration = {
       getRelatedKeys: (key) => getRelatedKeys(this.transactors, key),
-      addRelation: (a2, b2) => addRelation(this.transactors, a2, b2),
-      deleteRelation: (a2, b2) => deleteRelation(this.transactors, a2, b2),
-      replaceRelationsSafely: (a2, bs) => replaceRelationsSafely(this.transactors, a2, bs),
-      replaceRelationsUnsafely: (a2, bs) => replaceRelationsUnsafely(this.transactors, a2, bs),
-      has: (a2, b2) => has(this.transactors, a2, b2)
+      addRelation: (a, b) => {
+        addRelation(this.transactors, a, b);
+      },
+      deleteRelation: (a, b) => {
+        deleteRelation(this.transactors, a, b);
+      },
+      replaceRelationsSafely: (a, bs) => {
+        replaceRelationsSafely(this.transactors, a, bs);
+      },
+      replaceRelationsUnsafely: (a, bs) => {
+        replaceRelationsUnsafely(this.transactors, a, bs);
+      },
+      has: (a, b) => has(this.transactors, a, b)
     };
     let externalStore;
     let contentAtoms;
@@ -152,8 +162,12 @@ 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 deleteContent = ({ find }, key) => dispose(find(contentAtoms, key));
+      const setContent = ({ find, set }, key, content) => {
+        set(find(contentAtoms, key), content);
+      };
+      const deleteContent = ({ find }, key) => {
+        dispose(find(contentAtoms, key));
+      };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {
           const content = getContent(this.transactors, contentKey);
@@ -241,8 +255,8 @@ var Join = class _Join {
     switch (options.cardinality) {
       case `1:1`: {
         const findSingleRelatedKeyState = createSingleKeyStateFamily();
-        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeyOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findSingleRelatedKeyState,
           [stateKeyB]: findSingleRelatedKeyState
@@ -250,8 +264,8 @@ var Join = class _Join {
         let states;
         if (defaultContent) {
           const findSingleRelatedEntryState = createSingleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
           const contentStates = {
             [entriesStateKeyA]: findSingleRelatedEntryState,
             [entriesStateKeyB]: findSingleRelatedEntryState
@@ -267,8 +281,8 @@ var Join = class _Join {
       case `1:n`: {
         const findSingleRelatedKeyState = createSingleKeyStateFamily();
         const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findSingleRelatedKeyState,
           [stateKeyB]: findMultipleRelatedKeysState
@@ -277,8 +291,10 @@ var Join = class _Join {
         if (defaultContent) {
           const findSingleRelatedEntryState = createSingleEntryStateFamily();
           const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
           const contentStates = {
             [entriesStateKeyA]: findSingleRelatedEntryState,
             [entriesStateKeyB]: findMultipleRelatedEntriesState
@@ -293,8 +309,8 @@ var Join = class _Join {
       }
       default: {
         const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${a}KeysOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findMultipleRelatedKeysState,
           [stateKeyB]: findMultipleRelatedKeysState
@@ -302,8 +318,12 @@ var Join = class _Join {
         let states;
         if (defaultContent) {
           const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
+            bSide
+          )}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
           const contentStates = {
             [entriesStateKeyA]: findMultipleRelatedEntriesState,
             [entriesStateKeyB]: findMultipleRelatedEntriesState
@@ -341,21 +361,21 @@ function getJoinMap(store) {
 function getJoin(token, store) {
   var _a;
   const joinMap = getJoinMap(store);
-  let join2 = joinMap.get(token.key);
-  if (join2 === void 0) {
+  let myJoin = joinMap.get(token.key);
+  if (myJoin === void 0) {
     const rootJoinMap = getJoinMap(IMPLICIT.STORE);
-    join2 = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
-    if (join2 === void 0) {
+    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (myJoin === void 0) {
       throw new Error(
         `Join "${token.key}" not found in store "${store.config.name}"`
       );
     }
-    joinMap.set(token.key, join2);
+    joinMap.set(token.key, myJoin);
   }
-  return join2;
+  return myJoin;
 }
 function findRelationsInStore(token, key, store) {
-  const join2 = getJoin(token, store);
+  const myJoin = getJoin(token, store);
   let relations;
   switch (token.cardinality) {
     case `1:1`: {
@@ -363,27 +383,27 @@ function findRelationsInStore(token, key, store) {
       const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
       relations = {
         get [keyAB]() {
-          const familyAB = join2.states[keyAB];
+          const familyAB = myJoin.states[keyAB];
           const state = findInStore(familyAB, key, store);
           return state;
         },
         get [keyBA]() {
-          const familyBA = join2.states[keyBA];
+          const familyBA = myJoin.states[keyBA];
           const state = findInStore(familyBA, key, store);
           return state;
         }
       };
       const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in join2.states) {
+      if (entryAB in myJoin.states) {
         const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entryAB]() {
-            const familyAB = join2.states[entryAB];
+            const familyAB = myJoin.states[entryAB];
             const state = findInStore(familyAB, key, store);
             return state;
           },
           get [entryBA]() {
-            const familyBA = join2.states[entryBA];
+            const familyBA = myJoin.states[entryBA];
             const state = findInStore(familyBA, key, store);
             return state;
           }
@@ -396,27 +416,27 @@ function findRelationsInStore(token, key, store) {
       const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
       relations = {
         get [keyAB]() {
-          const familyAB = join2.states[keyAB];
+          const familyAB = myJoin.states[keyAB];
           const state = findInStore(familyAB, key, store);
           return state;
         },
         get [keysBA]() {
-          const familyBA = join2.states[keysBA];
+          const familyBA = myJoin.states[keysBA];
           const state = findInStore(familyBA, key, store);
           return state;
         }
       };
       const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in join2.states) {
+      if (entryAB in myJoin.states) {
         const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entryAB]() {
-            const familyAB = join2.states[entryAB];
+            const familyAB = myJoin.states[entryAB];
             const state = findInStore(familyAB, key, store);
             return state;
           },
           get [entriesBA]() {
-            const familyBA = join2.states[entriesBA];
+            const familyBA = myJoin.states[entriesBA];
             const state = findInStore(familyBA, key, store);
             return state;
           }
@@ -429,27 +449,27 @@ function findRelationsInStore(token, key, store) {
       const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
       relations = {
         get [keysAB]() {
-          const familyAB = join2.states[keysAB];
+          const familyAB = myJoin.states[keysAB];
           const state = findInStore(familyAB, key, store);
           return state;
         },
         get [keysBA]() {
-          const familyBA = join2.states[keysBA];
+          const familyBA = myJoin.states[keysBA];
           const state = findInStore(familyBA, key, store);
           return state;
         }
       };
       const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
-      if (entriesAB in join2.states) {
+      if (entriesAB in myJoin.states) {
         const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entriesAB]() {
-            const familyAB = join2.states[entriesAB];
+            const familyAB = myJoin.states[entriesAB];
             const state = findInStore(familyAB, key, store);
             return state;
           },
           get [entriesBA]() {
-            const familyBA = join2.states[entriesBA];
+            const familyBA = myJoin.states[entriesBA];
             const state = findInStore(familyBA, key, store);
             return state;
           }
@@ -463,23 +483,23 @@ function findRelations(token, key) {
   return findRelationsInStore(token, key, IMPLICIT.STORE);
 }
 function editRelationsInStore(token, change, store) {
-  const join2 = getJoin(token, store);
+  const myJoin = getJoin(token, store);
   const target = newest(store);
   if (isChildStore(target)) {
     const { transactors } = target.transactionMeta;
-    join2.transact(transactors, ({ relations }) => {
+    myJoin.transact(transactors, ({ relations }) => {
       change(relations);
     });
   } else {
-    change(join2.relations);
+    change(myJoin.relations);
   }
 }
 function editRelations(token, change) {
   editRelationsInStore(token, change, IMPLICIT.STORE);
 }
 function getInternalRelationsFromStore(token, store) {
-  const join2 = getJoin(token, store);
-  const family = join2.core.findRelatedKeysState;
+  const myJoin = getJoin(token, store);
+  const family = myJoin.core.findRelatedKeysState;
   return family;
 }
 function getInternalRelations(token) {

package/dist/index.cjs

@@ -32,6 +32,7 @@ function atomFamily(options) {
 function dispose(token, store = Internal__namespace.IMPLICIT.STORE) {
   switch (token.type) {
     case `atom`:
+    case `mutable_atom`:
       Internal__namespace.deleteAtom(token, store);
       break;
     case `selector`:
@@ -113,10 +114,16 @@ var Silo = class {
     this.timeline = (options) => Internal.createTimeline(options, s);
     this.findState = (token, key) => Internal.findInStore(token, key, s);
     this.getState = (token) => Internal.getFromStore(token, s);
-    this.setState = (token, newValue) => Internal.setIntoStore(token, newValue, s);
+    this.setState = (token, newValue) => {
+      Internal.setIntoStore(token, newValue, s);
+    };
     this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
-    this.undo = (token) => Internal.timeTravel(`undo`, token, s);
-    this.redo = (token) => Internal.timeTravel(`redo`, token, s);
+    this.undo = (token) => {
+      Internal.timeTravel(`undo`, token, s);
+    };
+    this.redo = (token) => {
+      Internal.timeTravel(`redo`, token, s);
+    };
   }
 };
 function subscribe(token, handleUpdate, key = Internal.arbitrary(), store = Internal.IMPLICIT.STORE) {
@@ -135,11 +142,11 @@ function subscribe(token, handleUpdate, key = Internal.arbitrary(), store = Inte
 var timeline = (options) => {
   return Internal.createTimeline(options, Internal.IMPLICIT.STORE);
 };
-var redo = (timeline2) => {
-  Internal.timeTravel(`redo`, timeline2, Internal.IMPLICIT.STORE);
+var redo = (tl) => {
+  Internal.timeTravel(`redo`, tl, Internal.IMPLICIT.STORE);
 };
-var undo = (timeline2) => {
-  Internal.timeTravel(`undo`, timeline2, Internal.IMPLICIT.STORE);
+var undo = (tl) => {
+  Internal.timeTravel(`undo`, tl, Internal.IMPLICIT.STORE);
 };
 function transaction(options) {
   return Internal.createTransaction(options, Internal.IMPLICIT.STORE);

package/dist/index.d.ts

@@ -33,10 +33,7 @@ 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 Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => RegularAtomToken<T>);
 type RegularAtomFamily<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & {
     (key: K): RegularAtomToken<T>;
     subject: Subject<RegularAtomToken<T>>;
@@ -55,10 +52,7 @@ 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 Prefer the `findState`, `findInStore`, or `find` 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>>;
@@ -69,19 +63,19 @@ 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>;
 
-type TransactionToken<F> = {
+type TransactionToken<F extends Func> = {
     key: string;
     type: `transaction`;
     __F?: F;
 };
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | TransactionUpdate<ƒn>;
-type TransactionUpdate<ƒ extends ƒn> = {
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | TransactionUpdate<Func>;
+type TransactionUpdate<F extends Func> = {
     key: string;
     id: string;
     epoch: number;
     updates: TransactionUpdateContent[];
-    params: Parameters<ƒ>;
-    output: ReturnType<ƒ>;
+    params: Parameters<F>;
+    output: ReturnType<F>;
 };
 type Transactors = Readonly<{
     get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S;
@@ -96,16 +90,16 @@ type TransactorsWithRunAndEnv = Readonly<{
     env: () => EnvironmentData;
 }>;
 type ReadonlyTransactors = Pick<Transactors, `find` | `get`>;
-type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-type Transact<ƒ extends ƒn> = (transactors: TransactorsWithRunAndEnv, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-type TransactionOptions<ƒ extends ƒn> = {
+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>;
+type TransactionOptions<F extends Func> = {
     key: string;
-    do: Transact<ƒ>;
+    do: Transact<F>;
 };
-type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer ƒ> ? ƒ : never;
-declare function transaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>): TransactionToken<ƒ>;
-declare function runTransaction<ƒ extends ƒn>(token: TransactionToken<ƒ>, id?: string): (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer F> ? F : never;
+declare function transaction<F extends Func>(options: TransactionOptions<F>): TransactionToken<F>;
+declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
 
 type WritableSelectorOptions<T> = {
     key: string;
@@ -133,10 +127,7 @@ 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 Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => WritableSelectorToken<T>);
 type WritableSelectorFamily<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & {
     (key: K): WritableSelectorToken<T>;
     subject: Subject<WritableSelectorToken<T>>;
@@ -148,10 +139,7 @@ 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 Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => ReadonlySelectorToken<T>);
 type ReadonlySelectorFamily<T, K extends Json.Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
@@ -272,9 +260,9 @@ type KeyedStateUpdate<T> = StateUpdate<T> & {
     family?: FamilyMetadata;
 };
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
+type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
 declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string, store?: Store): () => void;
-declare function subscribe<ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key?: string, store?: Store): () => void;
+declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string, store?: Store): () => void;
 declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string, store?: Store): () => void;
 
 type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
@@ -290,8 +278,8 @@ type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 };
 type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineSelectorUpdate<ManagedAtom> | TimelineTransactionUpdate;
 declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
-declare const redo: (timeline: TimelineToken<any>) => void;
-declare const undo: (timeline: TimelineToken<any>) => void;
+declare const redo: (tl: TimelineToken<any>) => void;
+declare const undo: (tl: TimelineToken<any>) => void;
 
 type TokenType<Comparison extends ReadableFamilyToken$1<any, any> | ReadableToken$1<any>> = Comparison extends ReadableToken$1<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken$1<infer RepresentedValue, any> ? RepresentedValue : never;
 declare function isToken<KnownToken extends RegularAtomToken$1<any>>(knownToken: KnownToken, unknownToken: ReadableToken$1<any>): unknownToken is RegularAtomToken$1<TokenType<KnownToken>>;
@@ -307,7 +295,7 @@ declare function belongsTo<Family extends ReadonlySelectorFamilyToken$1<any, any
 declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<Family>>;
 declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
 
-type ƒn = (...parameters: any[]) => any;
+type Func = (...parameters: any[]) => any;
 type RegularAtomToken<T> = {
     key: string;
     type: `atom`;
@@ -346,4 +334,4 @@ type FamilyMetadata = {
     subKey: string;
 };
 
-export { type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomToken, type Effectors, type FamilyMetadata, 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, type ƒn };
+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 };

package/dist/index.js

@@ -11,6 +11,7 @@ function atomFamily(options) {
 function dispose(token, store = Internal.IMPLICIT.STORE) {
   switch (token.type) {
     case `atom`:
+    case `mutable_atom`:
       Internal.deleteAtom(token, store);
       break;
     case `selector`:
@@ -92,10 +93,16 @@ var Silo = class {
     this.timeline = (options) => createTimeline(options, s);
     this.findState = (token, key) => findInStore(token, key, s);
     this.getState = (token) => getFromStore(token, s);
-    this.setState = (token, newValue) => setIntoStore(token, newValue, s);
+    this.setState = (token, newValue) => {
+      setIntoStore(token, newValue, s);
+    };
     this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
-    this.undo = (token) => timeTravel(`undo`, token, s);
-    this.redo = (token) => timeTravel(`redo`, token, s);
+    this.undo = (token) => {
+      timeTravel(`undo`, token, s);
+    };
+    this.redo = (token) => {
+      timeTravel(`redo`, token, s);
+    };
   }
 };
 function subscribe(token, handleUpdate, key = arbitrary(), store = IMPLICIT.STORE) {
@@ -114,11 +121,11 @@ function subscribe(token, handleUpdate, key = arbitrary(), store = IMPLICIT.STOR
 var timeline = (options) => {
   return createTimeline(options, IMPLICIT.STORE);
 };
-var redo = (timeline2) => {
-  timeTravel(`redo`, timeline2, IMPLICIT.STORE);
+var redo = (tl) => {
+  timeTravel(`redo`, tl, IMPLICIT.STORE);
 };
-var undo = (timeline2) => {
-  timeTravel(`undo`, timeline2, IMPLICIT.STORE);
+var undo = (tl) => {
+  timeTravel(`undo`, tl, IMPLICIT.STORE);
 };
 function transaction(options) {
   return createTransaction(options, IMPLICIT.STORE);