atom.io 0.19.0 → 0.19.2

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`;
@@ -254,6 +242,7 @@ declare class Silo {
     selectorFamily: typeof selectorFamily;
     transaction: typeof transaction;
     timeline: typeof timeline;
+    findState: typeof findState;
     getState: typeof getState;
     setState: typeof setState;
     subscribe: typeof subscribe;
@@ -271,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>;
@@ -289,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>>;
@@ -306,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`;
@@ -345,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`:
@@ -90,11 +91,18 @@ var Silo = class {
     this.selectorFamily = (options) => createSelectorFamily(options, s);
     this.transaction = (options) => createTransaction(options, s);
     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) {
@@ -113,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);

package/internal/dist/index.cjs

@@ -212,16 +212,16 @@ var Junction = class {
     if (a === void 0 && typeof b === `string`) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
-        for (const a2 of bRelations) {
-          this.delete(a2, b);
+        for (const bRelation of bRelations) {
+          this.delete(bRelation, b);
         }
       }
     }
     if (typeof a === `string` && b === void 0) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
-        for (const b2 of aRelations) {
-          this.delete(a, b2);
+        for (const aRelation of aRelations) {
+          this.delete(a, aRelation);
         }
       }
     }
@@ -274,18 +274,18 @@ var Junction = class {
     if (a !== void 0 && b === void 0) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
-        return [...aRelations].map((b2) => {
+        return [...aRelations].map((aRelation) => {
           var _a;
-          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
+          return [aRelation, (_a = this.getContent(a, aRelation)) != null ? _a : null];
         });
       }
     }
     if (a === void 0 && b !== void 0) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
-        return [...bRelations].map((a2) => {
+        return [...bRelations].map((bRelation) => {
           var _a;
-          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
+          return [bRelation, (_a = this.getContent(bRelation, b)) != null ? _a : null];
         });
       }
     }
@@ -308,7 +308,9 @@ var Subject = class {
   }
   subscribe(key, subscriber) {
     this.subscribers.set(key, subscriber);
-    const unsubscribe = () => this.unsubscribe(key);
+    const unsubscribe = () => {
+      this.unsubscribe(key);
+    };
     return unsubscribe;
   }
   unsubscribe(key) {
@@ -541,8 +543,12 @@ function withdrawOrCreate(token, store) {
 var Future = class extends Promise {
   constructor(executor) {
     super((resolve, reject) => {
-      const pass = (value) => this.isCanceled ? reject(`canceled`) : resolve(value);
-      const fail = (reason) => this.isCanceled ? reject(`canceled`) : reject(reason);
+      const pass = (value) => {
+        this.isCanceled ? reject(`canceled`) : resolve(value);
+      };
+      const fail = (reason) => {
+        this.isCanceled ? reject(`canceled`) : reject(reason);
+      };
       if (typeof executor === `function`) {
         executor(pass, fail);
       } else {
@@ -564,7 +570,7 @@ function copyMutableIfNeeded(atom, origin, target) {
     if (originValue === void 0) {
       return typeof atom.default === `function` ? atom.default() : atom.default;
     }
-    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
+    origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
     const jsonValue = atom.toJson(originValue);
     const copiedValue = atom.fromJson(jsonValue);
     target.valueMap.set(atom.key, copiedValue);
@@ -669,7 +675,7 @@ function createRegularAtomFamily(options, store) {
       key: options.key,
       type: `atom_family`,
       subject,
-      install: (store2) => createRegularAtomFamily(options, store2)
+      install: (s) => createRegularAtomFamily(options, s)
     }
   );
   const target = newest(store);
@@ -710,7 +716,7 @@ function createReadonlySelectorFamily(options, store) {
       key: options.key,
       type: `readonly_selector_family`,
       subject,
-      install: (store2) => createReadonlySelectorFamily(options, store2)
+      install: (s) => createReadonlySelectorFamily(options, s)
     }
   );
   store.families.set(options.key, readonlySelectorFamily);
@@ -743,7 +749,7 @@ function createWritableSelectorFamily(options, store) {
       key: options.key,
       type: `selector_family`,
       subject,
-      install: (store2) => createWritableSelectorFamily(options, store2)
+      install: (s) => createWritableSelectorFamily(options, s)
     }
   );
   store.families.set(options.key, selectorFamily);
@@ -1252,7 +1258,7 @@ function deleteSelector(selectorToken, store) {
     }
   }
   target.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
+  store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
 }
 
 // internal/src/subscribe/recall-state.ts
@@ -1431,18 +1437,18 @@ var Tracker = class {
           this.unsubscribeFromInnerValue();
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
-            (update2) => {
+            (transceiverUpdate) => {
               if (target.operation.open) {
                 const unsubscribe = target.on.operationClose.subscribe(
                   subscriptionKey,
                   () => {
                     unsubscribe();
-                    setIntoStore(latestUpdateState, update2, target);
+                    setIntoStore(latestUpdateState, transceiverUpdate, target);
                   }
                 );
               } else {
                 setIntoStore(mutableState, (current) => current, target);
-                setIntoStore(latestUpdateState, update2, target);
+                setIntoStore(latestUpdateState, transceiverUpdate, target);
               }
             }
           );
@@ -1551,14 +1557,14 @@ function createMutableAtom(options, family, store) {
   const subject = new Subject();
   const newAtom = __spreadProps(__spreadValues({}, options), {
     type: `mutable_atom`,
-    install: (store2) => {
-      store2.logger.info(
+    install: (s) => {
+      s.logger.info(
         `\u{1F6E0}\uFE0F`,
         `atom`,
         options.key,
-        `installing in store "${store2.config.name}"`
+        `installing in store "${s.config.name}"`
       );
-      return createMutableAtom(options, family, store2);
+      return createMutableAtom(options, family, s);
     },
     subject
   });
@@ -1575,7 +1581,9 @@ function createMutableAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => setIntoStore(token, next, store),
+        setSelf: (next) => {
+          setIntoStore(token, next, store);
+        },
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1660,7 +1668,7 @@ function createMutableAtomFamily(options, store) {
       key: options.key,
       type: `mutable_atom_family`,
       subject,
-      install: (store2) => createMutableAtomFamily(options, store2),
+      install: (s) => createMutableAtomFamily(options, s),
       toJson: options.toJson,
       fromJson: options.fromJson
     }
@@ -1756,14 +1764,14 @@ function createRegularAtom(options, family, store) {
   const subject = new Subject();
   const newAtom = __spreadProps(__spreadValues({}, options), {
     type: `atom`,
-    install: (store2) => {
-      store2.logger.info(
+    install: (s) => {
+      s.logger.info(
         `\u{1F6E0}\uFE0F`,
         `atom`,
         options.key,
-        `installing in store "${store2.config.name}"`
+        `installing in store "${s.config.name}"`
       );
-      return createRegularAtom(options, family, store2);
+      return createRegularAtom(options, family, s);
     },
     subject
   });
@@ -1783,7 +1791,9 @@ function createRegularAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => setIntoStore(token, next, store),
+        setSelf: (next) => {
+          setIntoStore(token, next, store);
+        },
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1820,7 +1830,7 @@ function deleteAtom(atomToken, store) {
     store.logger.error(
       `\u274C`,
       `atom`,
-      `${key}`,
+      key,
       `Tried to delete atom, but it does not exist in the store.`
     );
   }
@@ -1843,7 +1853,7 @@ function deleteAtom(atomToken, store) {
     const updateToken = getUpdateToken(atomToken);
     deleteAtom(updateToken, store);
   }
-  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
+  store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
 }
 
 // internal/src/arbitrary.ts
@@ -1987,7 +1997,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
           tl.transactionKey = currentTransactionKey;
           const unsubscribe = currentTransaction.subject.subscribe(
             `timeline:${tl.key}`,
-            (update2) => {
+            (transactionUpdate) => {
               var _a2, _b2;
               unsubscribe();
               if (tl.timeTraveling === null && currentTransactionInstanceId) {
@@ -1995,11 +2005,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                   tl.history.splice(tl.at);
                 }
                 const filterUpdates = (updates2) => updates2.filter((updateFromTx) => {
-                  const target2 = newest(store);
+                  const newestStore = newest(store);
                   if (`updates` in updateFromTx) {
                     return true;
                   }
-                  const atomOrFamilyKeys = target2.timelineAtoms.getRelatedKeys(tl.key);
+                  const atomOrFamilyKeys = newestStore.timelineAtoms.getRelatedKeys(tl.key);
                   return atomOrFamilyKeys ? [...atomOrFamilyKeys].some(
                     (key) => {
                       var _a3;
@@ -2014,11 +2024,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                   }
                   return updateFromTx;
                 });
-                const updates = filterUpdates(update2.updates);
+                const updates = filterUpdates(transactionUpdate.updates);
                 const timelineTransactionUpdate = __spreadProps(__spreadValues({
                   type: `transaction_update`,
                   timestamp: Date.now()
-                }, update2), {
+                }, transactionUpdate), {
                   updates
                 });
                 const willCapture = (_b2 = (_a2 = tl.shouldCapture) == null ? void 0 : _a2.call(tl, timelineTransactionUpdate, tl)) != null ? _b2 : true;
@@ -2033,7 +2043,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                 `\u231B`,
                 `timeline`,
                 tl.key,
-                `got a transaction_update "${update2.key}"`
+                `got a transaction_update "${transactionUpdate.key}"`
               );
             }
           );
@@ -2133,7 +2143,7 @@ function createTimeline(options, store, data) {
     transactionKey: null
   }, data), {
     history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
-    install: (store2) => createTimeline(options, store2, tl),
+    install: (s) => createTimeline(options, s, tl),
     subject: new Subject()
   });
   if (options.shouldCapture) {
@@ -2424,16 +2434,18 @@ var buildTransaction = (key, params, store, id) => {
     update: {
       key,
       id,
-      epoch: epoch === void 0 ? NaN : epoch + 1,
+      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
       updates: [],
       params,
       output: void 0
     },
     transactors: {
       get: (token) => getFromStore(token, child),
-      set: (token, value) => setIntoStore(token, value, child),
-      run: (token, id2 = arbitrary()) => actUponStore(token, id2, child),
-      find: (token, key2) => findInStore(token, key2, child),
+      set: (token, value) => {
+        setIntoStore(token, value, child);
+      },
+      run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
+      find: (token, k) => findInStore(token, k, child),
       env: () => getEnvironmentData(child)
     }
   };
@@ -2470,7 +2482,7 @@ function createTransaction(options, store) {
         throw thrown;
       }
     },
-    install: (store2) => createTransaction(options, store2),
+    install: (s) => createTransaction(options, s),
     subject: new Subject()
   };
   const target = newest(store);

package/internal/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ƒn as _n, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, SelectorToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, SelectorToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, JsonInterface } from 'atom.io/json';
 
 type primitive = boolean | number | string | null;
@@ -77,9 +77,9 @@ declare class Junction<const ASide extends string, const BSide extends string, c
 
 declare const abortTransaction: (store: Store) => void;
 
-declare function actUponStore<ƒ extends _n>(token: TransactionToken<ƒ>, id: string, store: Store): (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+declare function actUponStore<F extends Func>(token: TransactionToken<F>, id: string, store: Store): (...parameters: Parameters<F>) => ReturnType<F>;
 
-declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
+declare const applyTransaction: <F extends Func>(output: ReturnType<F>, store: Store) => void;
 
 declare function assignTransactionToContinuity(continuityKey: string, transactionKey: string, store: Store): void;
 
@@ -89,7 +89,7 @@ interface RootStore extends Store {
     child: ChildStore | null;
 }
 interface ChildStore extends Store {
-    transactionMeta: TransactionProgress<_n>;
+    transactionMeta: TransactionProgress<Func>;
     parent: ChildStore | RootStore;
     child: ChildStore | null;
 }
@@ -111,14 +111,14 @@ declare class StatefulSubject<T> extends Subject<T> {
     next(value: T): void;
 }
 
-type Transaction<ƒ extends _n> = {
+type Transaction<F extends Func> = {
     key: string;
     type: `transaction`;
     install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<ƒ>>;
-    run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>;
+    subject: Subject<TransactionUpdate<F>>;
+    run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
 };
-declare function createTransaction<ƒ extends _n>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
+declare function createTransaction<F extends Func>(options: TransactionOptions<F>, store: Store): TransactionToken<F>;
 
 declare function getContinuityKey(transactionKey: string, store: Store): string | undefined;
 declare function getEpochNumberOfContinuity(continuityKey: string, store: Store): number | undefined;
@@ -129,9 +129,9 @@ declare function setEpochNumberOfAction(transactionKey: string, newEpoch: number
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
-type TransactionProgress<ƒ extends _n> = {
+type TransactionProgress<F extends Func> = {
     phase: `applying` | `building`;
-    update: TransactionUpdate<ƒ>;
+    update: TransactionUpdate<F>;
     transactors: TransactorsWithRunAndEnv;
 };
 type TransactionEpoch = {
@@ -144,7 +144,7 @@ declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>)
 declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
+declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 
 interface Lineage {
@@ -179,7 +179,7 @@ type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
     timestamp: number;
     atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
 };
-type TimelineTransactionUpdate = TransactionUpdate<_n> & {
+type TimelineTransactionUpdate = TransactionUpdate<Func> & {
     key: string;
     type: `transaction_update`;
     timestamp: number;
@@ -212,7 +212,7 @@ declare class Store implements Lineage {
     trackers: Map<string, Tracker<Transceiver<any>>>;
     families: Map<string, WritableSelectorFamily<any, any> | MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<any, any>>;
     timelines: Map<string, Timeline<any>>;
-    transactions: Map<string, Transaction<_n>>;
+    transactions: Map<string, Transaction<Func>>;
     atomsThatAreDefault: Set<string>;
     timelineAtoms: Junction<"timelineKey", "atomKey", null>;
     selectorAtoms: Junction<"selectorKey", "atomKey", null>;
@@ -222,13 +222,13 @@ declare class Store implements Lineage {
     on: {
         atomCreation: Subject<AtomToken<unknown>>;
         selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<_n>>;
+        transactionCreation: Subject<TransactionToken<Func>>;
         timelineCreation: Subject<TimelineToken<unknown>>;
-        transactionApplying: StatefulSubject<TransactionProgress<_n> | null>;
+        transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
         operationClose: Subject<OperationProgress>;
     };
     operation: OperationProgress;
-    transactionMeta: TransactionEpoch | TransactionProgress<_n>;
+    transactionMeta: TransactionEpoch | TransactionProgress<Func>;
     config: {
         name: string;
     };
@@ -242,7 +242,7 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
+type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
 declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
 declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
@@ -257,7 +257,7 @@ declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken
 declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
 declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
 declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
-declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never>;
+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 withdrawOrCreate<T>(token: RegularAtomToken<T>, store: Store): Atom<T>;
@@ -275,7 +275,7 @@ interface Transceiver<Signal extends Json.Serializable> {
 }
 declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
 type TransceiverMode = `playback` | `record` | `transaction`;
-type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer Signal> ? Signal : never;
+type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
 
 declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined, store: Store): MutableAtomToken<T, J>;
 
@@ -437,7 +437,7 @@ declare const traceAllSelectorAtoms: (selector: Selector<any>, store: Store) =>
 declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, store: Store) => void;
 
 type Modify<T> = (thing: T) => T;
-declare const become: <T>(nextVersionOfThing: T | Modify<T>) => (originalThing: T) => T;
+declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing: T) => T;
 
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
@@ -449,7 +449,7 @@ declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: Upda
 
 declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store) => (() => void);
 
-declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store) => (() => void);
+declare const subscribeToTransaction: <F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key: string, store: Store) => (() => void);
 
 type AtomIOState = {
     key: string;