atom.io 0.14.8 → 0.15.1

package/internal/dist/index.js

@@ -1,8 +1,23 @@
+import { getState as getState$1, setState as setState$1, runTransaction } from '../../dist/chunk-S7R5MU6A.js';
 import { Junction } from '../../dist/chunk-NYTGCPHB.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
-import { AtomIOLogger, getState, setState, runTransaction } from 'atom.io';
 import { selectJson, stringifyJson, parseJson, selectJsonFamily } from 'atom.io/json';
-import { withdraw as withdraw$1, subscribeToRootAtoms as subscribeToRootAtoms$1 } from 'atom.io/internal';
+import { AtomIOLogger, getState, setState } from 'atom.io';
+import { withdraw as withdraw$1 } from 'atom.io/internal';
+
+// internal/src/lineage.ts
+function newest(scion) {
+  while (scion.child !== null) {
+    scion = scion.child;
+  }
+  return scion;
+}
+function eldest(scion) {
+  while (scion.parent !== null) {
+    scion = scion.parent;
+  }
+  return scion;
+}
 
 // internal/src/future.ts
 var Future = class extends Promise {
@@ -23,39 +38,24 @@ var Future = class extends Promise {
   }
 };
 
-// internal/src/lineage.ts
-function newest(scion) {
-  while (scion.child !== null) {
-    scion = scion.child;
-  }
-  return scion;
-}
-function eldest(scion) {
-  while (scion.parent !== null) {
-    scion = scion.parent;
-  }
-  return scion;
-}
-
 // internal/src/caching.ts
-function cacheValue(key, value, subject, store) {
-  const target = newest(store);
+function cacheValue(key, value, subject, target) {
   const currentValue = target.valueMap.get(key);
   if (currentValue instanceof Future) {
     currentValue.cancel();
   }
   if (value instanceof Promise) {
     const future = new Future(value);
-    newest(store).valueMap.set(key, future);
+    target.valueMap.set(key, future);
     future.then((resolved) => {
       if (future.isCanceled) {
         return;
       }
-      cacheValue(key, resolved, subject, store);
+      cacheValue(key, resolved, subject, target);
       subject.next({ newValue: resolved, oldValue: future });
     }).catch((thrown) => {
       if (thrown !== `canceled`) {
-        store.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+        target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
       }
     });
     return future;
@@ -63,23 +63,22 @@ function cacheValue(key, value, subject, store) {
   target.valueMap.set(key, value);
   return value;
 }
-var readCachedValue = (key, store) => {
-  return newest(store).valueMap.get(key);
+var readCachedValue = (key, target) => {
+  return target.valueMap.get(key);
 };
-var isValueCached = (key, store) => {
-  return newest(store).valueMap.has(key);
+var isValueCached = (key, target) => {
+  return target.valueMap.has(key);
 };
-var evictCachedValue = (key, store) => {
-  const core = newest(store);
-  const currentValue = core.valueMap.get(key);
+var evictCachedValue = (key, target) => {
+  const currentValue = target.valueMap.get(key);
   if (currentValue instanceof Future) {
     currentValue.cancel();
   }
-  if (core.operation.open) {
-    core.operation.prev.set(key, currentValue);
+  if (target.operation.open) {
+    target.operation.prev.set(key, currentValue);
   }
-  core.valueMap.delete(key);
-  store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+  target.valueMap.delete(key);
+  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
 };
 
 // internal/src/read-or-compute-value.ts
@@ -105,17 +104,16 @@ var readOrComputeValue = (state, store) => {
 
 // internal/src/operation.ts
 var openOperation = (token, store) => {
-  const target = newest(store);
-  if (target.operation.open) {
+  if (store.operation.open) {
     store.logger.error(
       `\u274C`,
       token.type,
       token.key,
-      `failed to setState during a setState for "${target.operation.token.key}"`
+      `failed to setState during a setState for "${store.operation.token.key}"`
     );
     return `rejection`;
   }
-  target.operation = {
+  store.operation = {
     open: true,
     done: /* @__PURE__ */ new Set(),
     prev: /* @__PURE__ */ new Map(),
@@ -126,25 +124,23 @@ var openOperation = (token, store) => {
     `\u2B55`,
     token.type,
     token.key,
-    `operation start in store "${store.config.name}"${target.transactionMeta === null ? `` : ` ${target.transactionMeta.phase} "${target.transactionMeta.update.key}"`}`
+    `operation start in store "${store.config.name}"${store.transactionMeta === null ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
   );
 };
 var closeOperation = (store) => {
-  const target = newest(store);
-  if (target.operation.open) {
+  if (store.operation.open) {
     store.logger.info(
       `\u{1F534}`,
-      target.operation.token.type,
-      target.operation.token.key,
+      store.operation.token.type,
+      store.operation.token.key,
       `operation done in store "${store.config.name}"`
     );
   }
-  target.operation = { open: false };
-  store.subject.operationStatus.next(target.operation);
+  store.operation = { open: false };
+  store.subject.operationStatus.next(store.operation);
 };
 var isDone = (key, store) => {
-  const target = newest(store);
-  if (!target.operation.open) {
+  if (!store.operation.open) {
     store.logger.warn(
       `\u{1F41E}`,
       `unknown`,
@@ -153,11 +149,10 @@ var isDone = (key, store) => {
     );
     return true;
   }
-  return target.operation.done.has(key);
+  return store.operation.done.has(key);
 };
 var markDone = (key, store) => {
-  const target = newest(store);
-  if (!target.operation.open) {
+  if (!store.operation.open) {
     store.logger.warn(
       `\u{1F41E}`,
       `unknown`,
@@ -166,7 +161,7 @@ var markDone = (key, store) => {
     );
     return;
   }
-  target.operation.done.add(key);
+  store.operation.done.add(key);
 };
 
 // internal/src/set-state/become.ts
@@ -272,8 +267,7 @@ var emitUpdate = (state, update, store) => {
 
 // internal/src/set-state/evict-downstream.ts
 var evictDownStream = (atom, store) => {
-  const target = newest(store);
-  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
+  const downstreamKeys = store.selectorAtoms.getRelatedKeys(atom.key);
   store.logger.info(
     `\u{1F9F9}`,
     atom.type,
@@ -282,12 +276,12 @@ var evictDownStream = (atom, store) => {
     downstreamKeys != null ? downstreamKeys : `to evict`
   );
   if (downstreamKeys) {
-    if (target.operation.open) {
+    if (store.operation.open) {
       store.logger.info(
         `\u{1F9F9}`,
         atom.type,
         atom.key,
-        `[ ${[...target.operation.done].join(`, `)} ] already done`
+        `[ ${[...store.operation.done].join(`, `)} ] already done`
       );
     }
     for (const key of downstreamKeys) {
@@ -344,23 +338,24 @@ var stowUpdate = (state, update, store) => {
 };
 
 // internal/src/set-state/set-atom.ts
-var setAtom = (atom, next, store) => {
-  const target = newest(store);
-  const oldValue = readOrComputeValue(atom, store);
-  let newValue = copyMutableIfWithinTransaction(oldValue, atom, store);
+var setAtom = (atom, next, target) => {
+  const oldValue = readOrComputeValue(atom, target);
+  let newValue = copyMutableIfWithinTransaction(oldValue, atom, target);
   newValue = become(next)(newValue);
-  store.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
-  newValue = cacheValue(atom.key, newValue, atom.subject, store);
-  if (isAtomDefault(atom.key, store)) {
-    markAtomAsNotDefault(atom.key, store);
+  target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
+  newValue = cacheValue(atom.key, newValue, atom.subject, target);
+  if (isAtomDefault(atom.key, target)) {
+    markAtomAsNotDefault(atom.key, target);
   }
-  markDone(atom.key, store);
-  evictDownStream(atom, store);
+  markDone(atom.key, target);
+  evictDownStream(atom, target);
   const update = { oldValue, newValue };
-  if (target.transactionMeta === null || target.transactionMeta.phase === `applying`) {
-    emitUpdate(atom, update, store);
+  if (target.transactionMeta === null) {
+    emitUpdate(atom, update, target);
+  } else if (target.transactionMeta.phase === `applying` && target.parent) {
+    emitUpdate(atom, update, target.parent);
   } else {
-    stowUpdate(atom, update, store);
+    stowUpdate(atom, update, target);
   }
 };
 
@@ -451,13 +446,29 @@ var Store = class {
       this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
         name
       });
+      for (const [, family] of store.families) {
+        family.install(this);
+      }
+      const mutableHelpers = /* @__PURE__ */ new Set();
       for (const [, atom] of store.atoms) {
+        if (mutableHelpers.has(atom.key)) {
+          continue;
+        }
         atom.install(this);
+        if (`mutable` in atom) {
+          const originalJsonToken = getJsonToken(atom);
+          const originalUpdateToken = getUpdateToken(atom);
+          mutableHelpers.add(originalJsonToken.key);
+          mutableHelpers.add(originalUpdateToken.key);
+        }
       }
       for (const [, selector] of store.readonlySelectors) {
         selector.install(this);
       }
       for (const [, selector] of store.selectors) {
+        if (mutableHelpers.has(selector.key)) {
+          continue;
+        }
         selector.install(this);
       }
       for (const [, tx] of store.transactions) {
@@ -484,13 +495,31 @@ var clearStore = (store) => {
 
 // internal/src/store/withdraw.ts
 function withdraw(token, store) {
-  var _a, _b, _c, _d;
-  const target = newest(store);
-  const state = (_d = (_c = (_b = (_a = target.atoms.get(token.key)) != null ? _a : target.selectors.get(token.key)) != null ? _b : target.readonlySelectors.get(token.key)) != null ? _c : target.transactions.get(token.key)) != null ? _d : target.timelines.get(token.key);
-  if (state) {
-    return state;
+  let withdrawn;
+  let target = store;
+  while (target !== null) {
+    switch (token.type) {
+      case `atom`:
+        withdrawn = target.atoms.get(token.key);
+        break;
+      case `selector`:
+        withdrawn = target.selectors.get(token.key);
+        break;
+      case `readonly_selector`:
+        withdrawn = target.readonlySelectors.get(token.key);
+        break;
+      case `timeline`:
+        withdrawn = target.timelines.get(token.key);
+        break;
+      case `transaction`:
+        withdrawn = target.transactions.get(token.key);
+        break;
+    }
+    if (withdrawn) {
+      return withdrawn;
+    }
+    target = target.child;
   }
-  return void 0;
 }
 
 // internal/src/store/withdraw-new-family-member.ts
@@ -594,7 +623,6 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
     const target = newest(store);
-    const alreadyRegistered = target.selectorGraph.getRelationEntries({ downstreamSelectorKey: selectorKey }).some(([_, { source }]) => source === dependency.key);
     const dependencyState = withdraw(dependency, store);
     if (dependencyState === void 0) {
       throw new Error(
@@ -610,17 +638,15 @@ var registerSelector = (selectorKey, store) => ({
       dependencyValue,
       `)`
     );
-    if (!alreadyRegistered) {
-      target.selectorGraph.set(
-        {
-          upstreamSelectorKey: dependency.key,
-          downstreamSelectorKey: selectorKey
-        },
-        {
-          source: dependency.key
-        }
-      );
-    }
+    target.selectorGraph.set(
+      {
+        upstreamSelectorKey: dependency.key,
+        downstreamSelectorKey: selectorKey
+      },
+      {
+        source: dependency.key
+      }
+    );
     updateSelectorAtoms(selectorKey, dependency, store);
     return dependencyValue;
   },
@@ -642,7 +668,7 @@ var createReadWriteSelector = (options, family, store) => {
   const { get, set } = registerSelector(options.key, store);
   const getSelf = () => {
     const value = options.get({ get });
-    cacheValue(options.key, value, subject, store);
+    cacheValue(options.key, value, subject, newest(store));
     return value;
   };
   const setSelf = (next) => {
@@ -732,7 +758,7 @@ function createSelector(options, family, store) {
       `\u274C`,
       existingReadonly ? `readonly_selector` : `selector`,
       options.key,
-      `Tried to create selector, but it already exists in the store. (Ignore if you are in development using hot module replacement.)`
+      `Tried to create selector, but it already exists in the store.`
     );
   }
   if (`set` in options) {
@@ -781,8 +807,9 @@ var recallState = (state, store) => {
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
 var subscribeToRootAtoms = (state, store) => {
+  const target = newest(store);
   const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomKey) => {
-    const atom = store.atoms.get(atomKey);
+    const atom = target.atoms.get(atomKey);
     if (atom === void 0) {
       throw new Error(
         `Atom "${atomKey}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
@@ -802,8 +829,8 @@ var subscribeToRootAtoms = (state, store) => {
           `->`,
           atomChange.newValue
         );
-        const oldValue = recallState(state, store);
-        const newValue = readOrComputeValue(state, store);
+        const oldValue = recallState(state, target);
+        const newValue = readOrComputeValue(state, target);
         store.logger.info(
           `\u2728`,
           state.type,
@@ -819,8 +846,11 @@ var subscribeToRootAtoms = (state, store) => {
   });
   return dependencySubscriptions;
 };
+
+// internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
-  const state = withdraw$1(token, store);
+  var _a;
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
   if (state === void 0) {
     throw new Error(
       `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
@@ -828,7 +858,7 @@ function subscribeToState(token, handleUpdate, key, store) {
   }
   const unsubFunction = state.subject.subscribe(key, handleUpdate);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
-  const dependencyUnsubFunctions = state.type !== `atom` ? subscribeToRootAtoms$1(state, store) : null;
+  const dependencyUnsubFunctions = state.type !== `atom` ? subscribeToRootAtoms(state, store) : null;
   const unsubscribe = dependencyUnsubFunctions === null ? () => {
     store.logger.info(
       `\u{1F648}`,
@@ -905,6 +935,7 @@ var Tracker = class {
     target.trackers.set(mutableState.key, this);
   }
   initializeState(mutableState, store) {
+    var _a;
     const latestUpdateStateKey = `*${mutableState.key}`;
     store.atoms.delete(latestUpdateStateKey);
     store.valueMap.delete(latestUpdateStateKey);
@@ -912,7 +943,7 @@ var Tracker = class {
       key: `*${mutableState.family.key}`,
       subKey: mutableState.family.subKey
     } : void 0;
-    const latestUpdateState = createAtom(
+    const latestUpdateState = createRegularAtom(
       {
         key: latestUpdateStateKey,
         default: null
@@ -920,7 +951,7 @@ var Tracker = class {
       familyMetaData,
       store
     );
-    if (store.parent) {
+    if ((_a = store.parent) == null ? void 0 : _a.valueMap.has(latestUpdateStateKey)) {
       const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
       store.valueMap.set(latestUpdateStateKey, parentValue);
     }
@@ -932,11 +963,11 @@ var Tracker = class {
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
       (update) => {
-        const unsubscribe = store.subject.operationStatus.subscribe(
+        const unsubscribe = target.subject.operationStatus.subscribe(
           mutableState.key,
           () => {
             unsubscribe();
-            setState(latestUpdateState, update, store);
+            setState(latestUpdateState, update, target);
           }
         );
       }
@@ -1023,14 +1054,14 @@ var Tracker = class {
 };
 
 // internal/src/mutable/create-mutable-atom.ts
-function createMutableAtom(options, store) {
+function createMutableAtom(options, family, store) {
   store.logger.info(
     `\u{1F527}`,
     `atom`,
     options.key,
     `creating in store "${store.config.name}"`
   );
-  const coreState = createAtom(options, void 0, store);
+  const coreState = createRegularAtom(options, family, store);
   new Tracker(coreState, store);
   const jsonState = selectJson(coreState, options, store);
   const target = newest(store);
@@ -1047,7 +1078,7 @@ function createMutableAtom(options, store) {
   );
   return coreState;
 }
-function createAtomFamily(options, store) {
+function createRegularAtomFamily(options, store) {
   const subject = new Subject();
   const atomFamily = Object.assign(
     (key) => {
@@ -1066,7 +1097,16 @@ function createAtomFamily(options, store) {
         if (options.effects) {
           individualOptions.effects = options.effects(key);
         }
-        token = createAtom(individualOptions, family, store);
+        if (`mutable` in options) {
+          const mutableOptions = __spreadProps(__spreadValues({}, individualOptions), {
+            mutable: true,
+            toJson: options.toJson,
+            fromJson: options.fromJson
+          });
+          token = createMutableAtom(mutableOptions, family, store);
+        } else {
+          token = createRegularAtom(individualOptions, family, store);
+        }
         subject.next(token);
       }
       return token;
@@ -1074,7 +1114,8 @@ function createAtomFamily(options, store) {
     {
       key: options.key,
       type: `atom_family`,
-      subject
+      subject,
+      install: (store2) => createRegularAtomFamily(options, store2)
     }
   );
   if (`mutable` in options && typeof options.mutable === `boolean`) {
@@ -1084,9 +1125,17 @@ function createAtomFamily(options, store) {
   target.families.set(options.key, atomFamily);
   return atomFamily;
 }
+
+// internal/src/families/create-atom-family.ts
+function createAtomFamily(options, store) {
+  if (`mutable` in options) {
+    return createMutableAtomFamily(options, store);
+  }
+  return createRegularAtomFamily(options, store);
+}
 function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
-  return Object.assign(
+  const readonlySelectorFamily = Object.assign(
     (key) => {
       const target = newest(store);
       const subKey = stringifyJson(key);
@@ -1108,9 +1157,12 @@ function createReadonlySelectorFamily(options, store) {
     {
       key: options.key,
       type: `readonly_selector_family`,
-      subject
+      subject,
+      install: (store2) => createReadonlySelectorFamily(options, store2)
     }
   );
+  store.families.set(options.key, readonlySelectorFamily);
+  return readonlySelectorFamily;
 }
 function createSelectorFamily(options, store) {
   const isReadonly = !(`set` in options);
@@ -1142,7 +1194,9 @@ function createSelectorFamily(options, store) {
     },
     {
       key: options.key,
-      type: `selector_family`
+      type: `selector_family`,
+      subject,
+      install: (store2) => createSelectorFamily(options, store2)
     }
   );
   target.families.set(options.key, selectorFamily);
@@ -1152,7 +1206,7 @@ function createSelectorFamily(options, store) {
 // internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
   constructor(findMutableState, store) {
-    this.findLatestUpdateState = createAtomFamily(
+    this.findLatestUpdateState = createRegularAtomFamily(
       {
         key: `*${findMutableState.key}`,
         default: null
@@ -1186,7 +1240,7 @@ var FamilyTracker = class {
 // internal/src/mutable/create-mutable-atom-family.ts
 function createMutableAtomFamily(options, store) {
   const coreFamily = Object.assign(
-    createAtomFamily(options, store),
+    createRegularAtomFamily(options, store),
     options
   );
   selectJsonFamily(coreFamily, options);
@@ -1257,13 +1311,9 @@ var markAtomAsNotDefault = (key, store) => {
   core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
   core.atomsThatAreDefault.delete(key);
 };
-var isSelectorDefault = (key, store) => {
-  const rootKeys = traceAllSelectorAtoms(key, store);
-  return rootKeys.every((rootKey) => isAtomDefault(rootKey, store));
-};
 
-// internal/src/atom/create-atom.ts
-function createAtom(options, family, store) {
+// internal/src/atom/create-regular-atom.ts
+function createRegularAtom(options, family, store) {
   store.logger.info(
     `\u{1F528}`,
     `atom`,
@@ -1277,13 +1327,12 @@ function createAtom(options, family, store) {
       `\u274C`,
       `atom`,
       options.key,
-      `Tried to create atom, but it already exists in the store.`,
-      `(Ignore if you are in development using hot module replacement.)`
+      `Tried to create atom, but it already exists in the store.`
     );
     return deposit(existing);
   }
   const subject = new Subject();
-  const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
+  const newAtom = __spreadProps(__spreadValues({}, options), {
     type: `atom`,
     install: (store2) => {
       store2.logger.info(
@@ -1292,17 +1341,20 @@ function createAtom(options, family, store) {
         options.key,
         `installing in store "${store2.config.name}"`
       );
-      return `mutable` in options ? createMutableAtom(options, store2) : createAtom(options, void 0, store2);
+      return `mutable` in options ? createMutableAtom(options, family, store2) : createRegularAtom(options, family, store2);
     },
     subject
-  }), family && { family });
+  });
+  if (family) {
+    newAtom.family = family;
+  }
   let initialValue = options.default;
   if (options.default instanceof Function) {
     initialValue = options.default();
   }
   target.atoms.set(newAtom.key, newAtom);
   markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, subject, store);
+  cacheValue(options.key, initialValue, subject, target);
   const token = deposit(newAtom);
   if (options.effects) {
     let effectIndex = 0;
@@ -1327,6 +1379,14 @@ function createAtom(options, family, store) {
   return token;
 }
 
+// internal/src/atom/create-atom.ts
+function createAtom(options, family, store) {
+  if (`mutable` in options) {
+    return createMutableAtom(options, family, store);
+  }
+  return createRegularAtom(options, family, store);
+}
+
 // internal/src/atom/delete-atom.ts
 function deleteAtom2(atomToken, store) {
   var _a, _b;
@@ -1608,26 +1668,10 @@ var addAtomToTimeline = (atomToken, tl, store) => {
 };
 
 // internal/src/mutable/is-mutable.ts
-function isMutable(atomOrTokenOrFamily, store) {
+function isMutable(atomOrTokenOrFamily) {
   if (`mutable` in atomOrTokenOrFamily) {
     return atomOrTokenOrFamily.mutable;
   }
-  if (atomOrTokenOrFamily.type === `atom_family`) {
-    return false;
-  }
-  if (`default` in atomOrTokenOrFamily) {
-    return false;
-  }
-  if (!store) {
-    throw new Error(`Cannot check mutability without a store`);
-  }
-  const atom = withdraw(atomOrTokenOrFamily, store);
-  if (!atom) {
-    throw new Error(`Cannot check mutability without an atom`);
-  }
-  if (`mutable` in atom) {
-    return atom.mutable;
-  }
   return false;
 }
 
@@ -1888,8 +1932,27 @@ var applyTransaction = (output, store) => {
     `Applying transaction with ${updates.length} updates:`,
     updates
   );
+  for (const tracker of child.trackers.values()) {
+    const mutableKey = tracker.mutableState.key;
+    if (!parent.atoms.has(mutableKey)) {
+      const atom = child.atoms.get(mutableKey);
+      atom == null ? void 0 : atom.install(parent);
+    }
+  }
+  for (const atom of child.atoms.values()) {
+    if (!parent.atoms.has(atom.key)) {
+      parent.atoms.set(atom.key, atom);
+      parent.valueMap.set(atom.key, atom.default);
+      parent.logger.info(
+        `\u{1F528}`,
+        `transaction`,
+        child.transactionMeta.update.key,
+        `Adding atom "${atom.key}"`
+      );
+    }
+  }
+  ingestTransactionUpdate(child.transactionMeta.update, parent, child);
   if (parent.transactionMeta === null) {
-    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
     const myTransaction = withdraw(
       { key: child.transactionMeta.update.key, type: `transaction` },
       store
@@ -1902,7 +1965,6 @@ var applyTransaction = (output, store) => {
       `Finished applying transaction.`
     );
   } else {
-    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
     parent.transactionMeta.update.updates.push(child.transactionMeta.update);
   }
   parent.subject.transactionApplying.next(null);
@@ -1911,23 +1973,14 @@ var applyTransaction = (output, store) => {
 // internal/src/transaction/build-transaction.ts
 var buildTransaction = (key, params, store) => {
   const parent = newest(store);
-  parent.child = {
+  const child = {
     parent,
     child: null,
     subject: parent.subject,
     loggers: parent.loggers,
     logger: parent.logger,
     config: parent.config,
-    transactionMeta: {
-      phase: `building`,
-      time: Date.now(),
-      update: {
-        key,
-        updates: [],
-        params,
-        output: void 0
-      }
-    },
+    transactionMeta: null,
     atoms: new LazyMap(parent.atoms),
     atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
     families: new LazyMap(parent.families),
@@ -1944,6 +1997,22 @@ var buildTransaction = (key, params, store) => {
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap)
   };
+  child.transactionMeta = {
+    phase: `building`,
+    time: Date.now(),
+    update: {
+      key,
+      updates: [],
+      params,
+      output: void 0
+    },
+    transactors: {
+      get: (token) => getState$1(token, child),
+      set: (token, value) => setState$1(token, value, child),
+      run: (token) => runTransaction(token, child)
+    }
+  };
+  parent.child = child;
   store.logger.info(
     `\u{1F6EB}`,
     `transaction`,
@@ -1952,6 +2021,8 @@ var buildTransaction = (key, params, store) => {
     params
   );
 };
+
+// internal/src/transaction/create-transaction.ts
 function createTransaction(options, store) {
   const newTransaction = {
     key: options.key,
@@ -1959,18 +2030,13 @@ function createTransaction(options, store) {
     run: (...params) => {
       buildTransaction(options.key, params, store);
       try {
-        const output = options.do(
-          {
-            get: (token2) => getState(token2, store),
-            set: (token2, value) => setState(token2, value, store),
-            run: (token2) => runTransaction(token2, store)
-          },
-          ...params
-        );
-        applyTransaction(output, store);
+        const target2 = newest(store);
+        const { transactors } = target2.transactionMeta;
+        const output = options.do(transactors, ...params);
+        applyTransaction(output, target2);
         return output;
       } catch (thrown) {
-        abortTransaction(store);
+        abortTransaction(target);
         store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
         throw thrown;
       }
@@ -1984,46 +2050,10 @@ function createTransaction(options, store) {
   store.subject.transactionCreation.next(token);
   return token;
 }
-var redoTransactionUpdate = (transactionUpdate, store) => {
-  store.logger.info(`\u23ED\uFE0F`, `transaction`, transactionUpdate.key, `Redo`);
-  for (const update of transactionUpdate.updates) {
-    if (`newValue` in update) {
-      const { key, newValue } = update;
-      const token = { key, type: `atom` };
-      const state = withdraw(token, store);
-      if (state === void 0) {
-        throw new Error(
-          `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
-        );
-      }
-      setState(state, newValue, store);
-    } else {
-      redoTransactionUpdate(update, store);
-    }
-  }
-};
-var undoTransactionUpdate = (transactionUpdate, store) => {
-  store.logger.info(`\u23EE\uFE0F`, `transaction`, transactionUpdate.key, `Undo`);
-  for (const update of transactionUpdate.updates.reverse()) {
-    if (`newValue` in update) {
-      const { key, newValue } = update;
-      const token = { key, type: `atom` };
-      const state = withdraw(token, store);
-      if (state === void 0) {
-        throw new Error(
-          `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
-        );
-      }
-      setState(state, newValue, store);
-    } else {
-      undoTransactionUpdate(update, store);
-    }
-  }
-};
 
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom2 as deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom2 as deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map