atom.io 0.16.2 → 0.17.0

package/internal/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var atom_io = require('atom.io');
 var json = require('atom.io/json');
+var atom_io = require('atom.io');
 var internal = require('atom.io/internal');
 
 var __defProp = Object.defineProperty;
@@ -369,11 +369,15 @@ var Store = class {
       selectorCreation: new Subject(),
       transactionCreation: new Subject(),
       timelineCreation: new Subject(),
-      transactionApplying: new StatefulSubject(null),
+      transactionApplying: new StatefulSubject(
+        null
+      ),
       operationClose: new Subject()
     };
     this.operation = { open: false };
-    this.transactionMeta = null;
+    this.transactionMeta = {
+      epoch: -1
+    };
     this.config = {
       name: `IMPLICIT_STORE`
     };
@@ -397,7 +401,7 @@ var Store = class {
     if (store !== null) {
       this.valueMap = new Map(store == null ? void 0 : store.valueMap);
       this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
-      this.transactionMeta = null;
+      this.transactionMeta = __spreadValues({}, store == null ? void 0 : store.transactionMeta);
       this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
         name
       });
@@ -590,7 +594,7 @@ var evictCachedValue = (key, target) => {
   target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
 };
 
-// internal/src/read-or-compute-value.ts
+// internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
     target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
@@ -610,12 +614,164 @@ var readOrComputeValue = (state, target) => {
   );
   return state.default instanceof Function ? state.default() : state.default;
 };
+function createRegularAtomFamily(options, store) {
+  const subject = new Subject();
+  const atomFamily = Object.assign(
+    (key) => {
+      const subKey = json.stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const existing = withdraw({ key: fullKey, type: `atom` }, store);
+      let token;
+      if (existing) {
+        token = deposit(existing);
+      } else {
+        const individualOptions = {
+          key: fullKey,
+          default: options.default instanceof Function ? options.default(key) : options.default
+        };
+        if (options.effects) {
+          individualOptions.effects = options.effects(key);
+        }
+        token = createRegularAtom(individualOptions, family, store);
+        subject.next(token);
+      }
+      return token;
+    },
+    {
+      key: options.key,
+      type: `atom_family`,
+      subject,
+      install: (store2) => createRegularAtomFamily(options, store2)
+    }
+  );
+  const target = newest(store);
+  target.families.set(options.key, atomFamily);
+  return atomFamily;
+}
+
+// internal/src/families/create-atom-family.ts
+function createAtomFamily(options, store) {
+  const isMutable2 = `mutable` in options;
+  if (isMutable2) {
+    return createMutableAtomFamily(options, store);
+  }
+  return createRegularAtomFamily(options, store);
+}
+function createReadonlySelectorFamily(options, store) {
+  const subject = new Subject();
+  const readonlySelectorFamily = Object.assign(
+    (key) => {
+      const target = newest(store);
+      const subKey = json.stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const existing = target.readonlySelectors.get(fullKey);
+      if (existing) {
+        return deposit(existing);
+      }
+      return createReadonlySelector(
+        {
+          key: fullKey,
+          get: options.get(key)
+        },
+        family,
+        store
+      );
+    },
+    {
+      key: options.key,
+      type: `readonly_selector_family`,
+      subject,
+      install: (store2) => createReadonlySelectorFamily(options, store2)
+    }
+  );
+  store.families.set(options.key, readonlySelectorFamily);
+  return readonlySelectorFamily;
+}
+function createWritableSelectorFamily(options, store) {
+  const subject = new Subject();
+  const selectorFamily = Object.assign(
+    (key) => {
+      const subKey = json.stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const existing = store.selectors.get(fullKey);
+      if (existing) {
+        return deposit(existing);
+      }
+      const token = createWritableSelector(
+        {
+          key: fullKey,
+          get: options.get(key),
+          set: options.set(key)
+        },
+        family,
+        store
+      );
+      subject.next(token);
+      return token;
+    },
+    {
+      key: options.key,
+      type: `selector_family`,
+      subject,
+      install: (store2) => createWritableSelectorFamily(options, store2)
+    }
+  );
+  store.families.set(options.key, selectorFamily);
+  return selectorFamily;
+}
+
+// internal/src/families/create-selector-family.ts
+function createSelectorFamily(options, store) {
+  const isWritable = `set` in options;
+  if (isWritable) {
+    return createWritableSelectorFamily(options, store);
+  }
+  return createReadonlySelectorFamily(options, store);
+}
+
+// internal/src/not-found-error.ts
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+function prettyPrintTokenType(token) {
+  if (token.type === `readonly_selector`) {
+    return `Readonly Selector`;
+  }
+  return capitalize(token.type);
+}
+var NotFoundError = class extends Error {
+  constructor(token, store) {
+    super(
+      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
+    );
+  }
+};
+
+// internal/src/families/find-in-store.ts
+function findInStore(token, key, store) {
+  const familyKey = token.key;
+  const family = store.families.get(familyKey);
+  if (family === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  const state = family(key);
+  return state;
+}
 
 // internal/src/set-state/become.ts
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
   originalThing instanceof Function ? originalThing() : originalThing
 ) : nextVersionOfThing;
 
+// internal/src/transaction/is-root-store.ts
+function isRootStore(store) {
+  return `epoch` in store.transactionMeta;
+}
+function isChildStore(store) {
+  return `phase` in store.transactionMeta;
+}
+
 // internal/src/operation.ts
 var openOperation = (token, store) => {
   if (store.operation.open) {
@@ -638,7 +794,7 @@ var openOperation = (token, store) => {
     `\u2B55`,
     token.type,
     token.key,
-    `operation start in store "${store.config.name}"${store.transactionMeta === null ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
+    `operation start in store "${store.config.name}"${!isChildStore(store) ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
   );
 };
 var closeOperation = (store) => {
@@ -736,7 +892,7 @@ function shouldUpdateBeStowed(key, update) {
 var stowUpdate = (state, update, store) => {
   const { key } = state;
   const target = newest(store);
-  if (target.transactionMeta === null || target.transactionMeta.phase !== `building`) {
+  if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
     store.logger.error(
       `\u{1F41E}`,
       `atom`,
@@ -779,7 +935,7 @@ var setAtom = (atom, next, target) => {
   markDone(atom.key, target);
   evictDownStream(atom, target);
   const update = { oldValue, newValue };
-  if (target.transactionMeta === null) {
+  if (isRootStore(target)) {
     emitUpdate(atom, update, target);
   } else if (target.parent) {
     if (target.on.transactionApplying.state === null) {
@@ -789,7 +945,16 @@ var setAtom = (atom, next, target) => {
       const mutableAtom = target.atoms.get(mutableKey);
       let mutable = target.valueMap.get(mutableKey);
       mutable = copyMutableIfWithinTransaction(mutable, mutableAtom, target);
-      mutable.do(update.newValue);
+      const output = mutable.do(update.newValue);
+      if (output !== null) {
+        target.logger.warn(
+          `\u274C`,
+          `mutable_atom`,
+          mutableKey,
+          `could not be updated.`,
+          typeof output === `number` ? `Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${output}` : output
+        );
+      }
     }
   }
 };
@@ -807,6 +972,21 @@ var setAtomOrSelector = (state, value, store) => {
   }
 };
 
+// internal/src/set-state/set-into-store.ts
+function setIntoStore(token, value, store) {
+  var _a;
+  const rejection = openOperation(token, store);
+  if (rejection) {
+    return;
+  }
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
 // internal/src/keys.ts
 var isAtomKey = (key, store) => newest(store).atoms.has(key);
 var isSelectorKey = (key, store) => newest(store).selectors.has(key);
@@ -887,11 +1067,12 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
+    var _a;
     const target = newest(store);
-    const dependencyState = withdraw(dependency, store);
+    const dependencyState = (_a = withdraw(dependency, store)) != null ? _a : withdrawNewFamilyMember(dependency, store);
     if (dependencyState === void 0) {
       throw new Error(
-        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+        `State "${dependency.key}" not found in store "${store.config.name}".`
       );
     }
     const dependencyValue = readOrComputeValue(dependencyState, store);
@@ -924,7 +1105,7 @@ var registerSelector = (selectorKey, store) => ({
     }
     setAtomOrSelector(state, newValue, store);
   },
-  find: (token, key) => atom_io.findInStore(token, key, store)
+  find: (token, key) => findInStore(token, key, store)
 });
 
 // internal/src/selector/create-readonly-selector.ts
@@ -990,7 +1171,7 @@ var createWritableSelector = (options, family, store) => {
     );
     cacheValue(options.key, newValue, subject, store);
     markDone(options.key, store);
-    if (target.transactionMeta === null) {
+    if (isRootStore(target)) {
       subject.next({ newValue, oldValue });
     }
     options.set(transactors, newValue);
@@ -1184,6 +1365,8 @@ var subscribeToTransaction = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/mutable/tracker.ts
 var Tracker = class {
   initializeState(mutableState, store) {
     var _a;
@@ -1208,24 +1391,23 @@ var Tracker = class {
     }
     return latestUpdateState;
   }
-  observeCore(mutableState, latestUpdateState, store) {
-    const subscriptionKey = `tracker:${store.config.name}:${store.transactionMeta === null ? `main` : store.transactionMeta.update.key}:${mutableState.key}`;
-    const originalInnerValue = atom_io.getState(mutableState, store);
-    const target = newest(store);
+  observeCore(mutableState, latestUpdateState, target) {
+    const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+    const originalInnerValue = getFromStore(mutableState, target);
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
-      `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
+      subscriptionKey,
       (update) => {
         if (target.operation.open) {
           const unsubscribe = target.on.operationClose.subscribe(
             subscriptionKey,
             () => {
               unsubscribe();
-              atom_io.setState(latestUpdateState, update, target);
+              setIntoStore(latestUpdateState, update, target);
             }
           );
         } else {
-          atom_io.setState(mutableState, (current) => current, target);
-          atom_io.setState(latestUpdateState, update, target);
+          setIntoStore(mutableState, (current) => current, target);
+          setIntoStore(latestUpdateState, update, target);
         }
       }
     );
@@ -1234,46 +1416,45 @@ var Tracker = class {
       (update) => {
         if (update.newValue !== update.oldValue) {
           this.unsubscribeFromInnerValue();
-          const target2 = newest(store);
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
             (update2) => {
-              if (target2.operation.open) {
-                const unsubscribe = target2.on.operationClose.subscribe(
+              if (target.operation.open) {
+                const unsubscribe = target.on.operationClose.subscribe(
                   subscriptionKey,
                   () => {
                     unsubscribe();
-                    atom_io.setState(latestUpdateState, update2, target2);
+                    setIntoStore(latestUpdateState, update2, target);
                   }
                 );
               } else {
-                atom_io.setState(mutableState, (current) => current, target2);
-                atom_io.setState(latestUpdateState, update2, target2);
+                setIntoStore(mutableState, (current) => current, target);
+                setIntoStore(latestUpdateState, update2, target);
               }
             }
           );
         }
       },
       subscriptionKey,
-      store
+      target
     );
   }
-  updateCore(mutableState, latestUpdateState, store) {
-    const subscriptionKey = `tracker:${store.config.name}:${store.transactionMeta === null ? `main` : store.transactionMeta.update.key}:${mutableState.key}`;
+  updateCore(mutableState, latestUpdateState, target) {
+    const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
     subscribeToState(
       latestUpdateState,
       ({ newValue, oldValue }) => {
-        const timelineId = store.timelineAtoms.getRelatedKey(
+        const timelineId = target.timelineAtoms.getRelatedKey(
           latestUpdateState.key
         );
         if (timelineId) {
-          const timelineData = store.timelines.get(timelineId);
+          const timelineData = target.timelines.get(timelineId);
           if (timelineData == null ? void 0 : timelineData.timeTraveling) {
             const unsubscribe2 = subscribeToTimeline(
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                atom_io.setState(
+                setIntoStore(
                   mutableState,
                   (transceiver) => {
                     if (update === `redo` && newValue) {
@@ -1283,34 +1464,41 @@ var Tracker = class {
                     }
                     return transceiver;
                   },
-                  store
+                  target
                 );
               },
               subscriptionKey,
-              store
+              target
             );
             return;
           }
         }
-        const unsubscribe = store.on.operationClose.subscribe(
+        const unsubscribe = target.on.operationClose.subscribe(
           subscriptionKey,
           () => {
             unsubscribe();
-            const mutable = atom_io.getState(mutableState, store);
+            const mutable = getFromStore(mutableState, target);
             const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
-              atom_io.setState(
+              setIntoStore(
                 mutableState,
                 (transceiver) => (transceiver.do(newValue), transceiver),
-                store
+                target
+              );
+            } else {
+              target.logger.info(
+                `\u274C`,
+                `mutable_atom`,
+                mutableState.key,
+                `could not be updated. Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${updateNumber}`
               );
             }
           }
         );
       },
       subscriptionKey,
-      store
+      target
     );
   }
   constructor(mutableState, store) {
@@ -1374,7 +1562,7 @@ function createMutableAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => atom_io.setState(token, next, store),
+        setSelf: (next) => setIntoStore(token, next, store),
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1393,125 +1581,6 @@ function createMutableAtom(options, family, store) {
   store.on.atomCreation.next(token);
   return token;
 }
-function createRegularAtomFamily(options, store) {
-  const subject = new Subject();
-  const atomFamily = Object.assign(
-    (key) => {
-      const subKey = json.stringifyJson(key);
-      const family = { key: options.key, subKey };
-      const fullKey = `${options.key}(${subKey})`;
-      const existing = withdraw({ key: fullKey, type: `atom` }, store);
-      let token;
-      if (existing) {
-        token = deposit(existing);
-      } else {
-        const individualOptions = {
-          key: fullKey,
-          default: options.default instanceof Function ? options.default(key) : options.default
-        };
-        if (options.effects) {
-          individualOptions.effects = options.effects(key);
-        }
-        token = createRegularAtom(individualOptions, family, store);
-        subject.next(token);
-      }
-      return token;
-    },
-    {
-      key: options.key,
-      type: `atom_family`,
-      subject,
-      install: (store2) => createRegularAtomFamily(options, store2)
-    }
-  );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
-  return atomFamily;
-}
-
-// internal/src/families/create-atom-family.ts
-function createAtomFamily(options, store) {
-  const isMutable2 = `mutable` in options;
-  if (isMutable2) {
-    return createMutableAtomFamily(options, store);
-  }
-  return createRegularAtomFamily(options, store);
-}
-function createReadonlySelectorFamily(options, store) {
-  const subject = new Subject();
-  const readonlySelectorFamily = Object.assign(
-    (key) => {
-      const target = newest(store);
-      const subKey = json.stringifyJson(key);
-      const family = { key: options.key, subKey };
-      const fullKey = `${options.key}(${subKey})`;
-      const existing = target.readonlySelectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
-      return createReadonlySelector(
-        {
-          key: fullKey,
-          get: options.get(key)
-        },
-        family,
-        store
-      );
-    },
-    {
-      key: options.key,
-      type: `readonly_selector_family`,
-      subject,
-      install: (store2) => createReadonlySelectorFamily(options, store2)
-    }
-  );
-  store.families.set(options.key, readonlySelectorFamily);
-  return readonlySelectorFamily;
-}
-function createWritableSelectorFamily(options, store) {
-  const subject = new Subject();
-  const selectorFamily = Object.assign(
-    (key) => {
-      const subKey = json.stringifyJson(key);
-      const family = { key: options.key, subKey };
-      const fullKey = `${options.key}(${subKey})`;
-      const existing = store.selectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
-      const token = createWritableSelector(
-        {
-          key: fullKey,
-          get: options.get(key),
-          set: options.set(key)
-        },
-        family,
-        store
-      );
-      subject.next(token);
-      return token;
-    },
-    {
-      key: options.key,
-      type: `selector_family`,
-      subject,
-      install: (store2) => createWritableSelectorFamily(options, store2)
-    }
-  );
-  store.families.set(options.key, selectorFamily);
-  return selectorFamily;
-}
-
-// internal/src/families/create-selector-family.ts
-function createSelectorFamily(options, store) {
-  const isWritable = `set` in options;
-  if (isWritable) {
-    return createWritableSelectorFamily(options, store);
-  }
-  return createReadonlySelectorFamily(options, store);
-}
-
-// internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
   constructor(findMutableState, store) {
     this.findLatestUpdateState = createRegularAtomFamily(
@@ -1700,7 +1769,7 @@ function createRegularAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => atom_io.setState(token, next, store),
+        setSelf: (next) => setIntoStore(token, next, store),
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1766,10 +1835,22 @@ function getEnvironmentData(store) {
     store
   };
 }
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(token, store) {
+  var _a;
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  return readOrComputeValue(state, store);
+}
+
+// internal/src/ingest-updates/ingest-atom-update.ts
 function ingestAtomUpdate(applying, atomUpdate, store) {
   const { key, newValue, oldValue } = atomUpdate;
   const value = applying === `newValue` ? newValue : oldValue;
-  atom_io.setState({ key, type: `atom` }, value, store);
+  setIntoStore({ key, type: `atom` }, value, store);
 }
 
 // internal/src/ingest-updates/ingest-selector-update.ts
@@ -1826,22 +1907,6 @@ var LazyMap = class extends Map {
   }
 };
 
-// internal/src/not-found-error.ts
-var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
-function prettyPrintTokenType(token) {
-  if (token.type === `readonly_selector`) {
-    return `Readonly Selector`;
-  }
-  return capitalize(token.type);
-}
-var NotFoundError = class extends Error {
-  constructor(token, store) {
-    super(
-      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
-    );
-  }
-};
-
 // internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
   let maybeAtom = withdraw(atomToken, store);
@@ -1861,8 +1926,9 @@ var addAtomToTimeline = (atomToken, tl, store) => {
     const target = newest(store);
     const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
     const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
-    const currentTransactionKey = (_a = target.on.transactionApplying.state) == null ? void 0 : _a.update.key;
-    const currentTransactionTime = (_b = target.on.transactionApplying.state) == null ? void 0 : _b.time;
+    const { transactionApplying } = target.on;
+    const currentTransactionKey = (_a = transactionApplying.state) == null ? void 0 : _a.update.key;
+    const currentTransactionInstanceId = (_b = transactionApplying.state) == null ? void 0 : _b.update.id;
     store.logger.info(
       `\u23F3`,
       `timeline`,
@@ -1909,7 +1975,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
             (update2) => {
               var _a2, _b2;
               unsubscribe();
-              if (tl.timeTraveling === null && currentTransactionTime) {
+              if (tl.timeTraveling === null && currentTransactionInstanceId) {
                 if (tl.at !== tl.history.length) {
                   tl.history.splice(tl.at);
                 }
@@ -1936,7 +2002,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
                 const updates = filterUpdates(update2.updates);
                 const timelineTransactionUpdate = __spreadProps(__spreadValues({
                   type: `transaction_update`,
-                  timestamp: currentTransactionTime
+                  timestamp: Date.now()
                 }, update2), {
                   updates
                 });
@@ -2198,7 +2264,7 @@ var timeTravel = (action, token, store) => {
 // internal/src/transaction/abort-transaction.ts
 var abortTransaction = (store) => {
   const target = newest(store);
-  if (target.transactionMeta === null || target.parent === null) {
+  if (!isChildStore(target)) {
     store.logger.warn(
       `\u{1F41E}`,
       `transaction`,
@@ -2221,7 +2287,7 @@ var applyTransaction = (output, store) => {
   var _a;
   const child = newest(store);
   const { parent } = child;
-  if (parent === null || child.transactionMeta === null || ((_a = child.transactionMeta) == null ? void 0 : _a.phase) !== `building`) {
+  if (parent === null || !isChildStore(child) || ((_a = child.transactionMeta) == null ? void 0 : _a.phase) !== `building`) {
     store.logger.warn(
       `\u{1F41E}`,
       `transaction`,
@@ -2263,7 +2329,8 @@ var applyTransaction = (output, store) => {
     }
   }
   ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
-  if (parent.transactionMeta === null) {
+  if (isRootStore(parent)) {
+    parent.transactionMeta.epoch = child.transactionMeta.update.epoch;
     const myTransaction = withdraw(
       { key: child.transactionMeta.update.key, type: `transaction` },
       store
@@ -2275,21 +2342,20 @@ var applyTransaction = (output, store) => {
       child.transactionMeta.update.key,
       `Finished applying transaction.`
     );
-  } else {
+  } else if (isChildStore(parent)) {
     parent.transactionMeta.update.updates.push(child.transactionMeta.update);
   }
   parent.on.transactionApplying.next(null);
 };
 var buildTransaction = (key, params, store, id) => {
   const parent = newest(store);
-  const child = {
+  const childBase = {
     parent,
     child: null,
     on: parent.on,
     loggers: parent.loggers,
     logger: parent.logger,
     config: parent.config,
-    transactionMeta: null,
     atoms: new LazyMap(parent.atoms),
     atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
     families: new LazyMap(parent.families),
@@ -2306,24 +2372,27 @@ var buildTransaction = (key, params, store, id) => {
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap)
   };
-  child.transactionMeta = {
+  const transactionMeta = {
     phase: `building`,
-    time: Date.now(),
     update: {
       key,
       id: id != null ? id : Math.random().toString(36).slice(2),
+      epoch: isRootStore(parent) ? parent.transactionMeta.epoch + 1 : NaN,
       updates: [],
       params,
       output: void 0
     },
     transactors: {
-      get: (token) => atom_io.getState(token, child),
-      set: (token, value) => atom_io.setState(token, value, child),
+      get: (token) => getFromStore(token, child),
+      set: (token, value) => setIntoStore(token, value, child),
       run: (token, id2) => atom_io.runTransaction(token, id2, child),
-      find: (token, key2) => atom_io.findInStore(token, key2, child),
+      find: (token, key2) => findInStore(token, key2, child),
       env: () => getEnvironmentData(child)
     }
   };
+  const child = Object.assign(childBase, {
+    transactionMeta
+  });
   parent.child = child;
   store.logger.info(
     `\u{1F6EB}`,
@@ -2332,6 +2401,7 @@ var buildTransaction = (key, params, store, id) => {
     `Building transaction with params:`,
     params
   );
+  return child;
 };
 
 // internal/src/transaction/create-transaction.ts
@@ -2340,10 +2410,10 @@ function createTransaction(options, store) {
     key: options.key,
     type: `transaction`,
     run: (params, id) => {
-      buildTransaction(options.key, params, store, id);
+      const childStore = buildTransaction(options.key, params, store, id);
       try {
         const target2 = newest(store);
-        const { transactors } = target2.transactionMeta;
+        const { transactors } = childStore.transactionMeta;
         const output = options.do(transactors, ...params);
         applyTransaction(output, target2);
         return output;
@@ -2401,7 +2471,9 @@ exports.deleteAtom = deleteAtom;
 exports.deleteSelector = deleteSelector;
 exports.deposit = deposit;
 exports.evictCachedValue = evictCachedValue;
+exports.findInStore = findInStore;
 exports.getEnvironmentData = getEnvironmentData;
+exports.getFromStore = getFromStore;
 exports.getJsonFamily = getJsonFamily;
 exports.getJsonToken = getJsonToken;
 exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
@@ -2426,6 +2498,7 @@ exports.readCachedValue = readCachedValue;
 exports.readOrComputeValue = readOrComputeValue;
 exports.registerSelector = registerSelector;
 exports.setAtomOrSelector = setAtomOrSelector;
+exports.setIntoStore = setIntoStore;
 exports.subscribeToRootAtoms = subscribeToRootAtoms;
 exports.subscribeToState = subscribeToState;
 exports.subscribeToTimeline = subscribeToTimeline;