atom.io 0.12.0 → 0.13.0

package/internal/dist/index.cjs

@@ -42,25 +42,209 @@ var Future = class extends Promise {
   }
 };
 
-// src/transaction/abort-transaction.ts
-var abortTransaction = (store) => {
-  if (store.transactionStatus.phase === `idle`) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+// 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;
+}
+
+// src/caching.ts
+function cacheValue(key, value, subject, store) {
+  const target = newest(store);
+  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);
+    future.then((resolved) => {
+      if (future.isCanceled) {
+        return;
+      }
+      cacheValue(key, resolved, subject, store);
+      subject.next({ newValue: resolved, oldValue: future });
+    }).catch((thrown) => {
+      if (thrown !== `canceled`) {
+        store.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+      }
+    });
+    return future;
+  }
+  target.valueMap.set(key, value);
+  return value;
+}
+var readCachedValue = (key, store) => {
+  return newest(store).valueMap.get(key);
+};
+var isValueCached = (key, store) => {
+  return newest(store).valueMap.has(key);
+};
+var evictCachedValue = (key, store) => {
+  const core = newest(store);
+  const currentValue = core.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    currentValue.cancel();
+  }
+  if (core.operation.open) {
+    core.operation.prev.set(key, currentValue);
+  }
+  core.valueMap.delete(key);
+  store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+};
+var Tracker = class {
+  constructor(mutableState, store) {
+    this.unsubscribeFromInnerValue = null;
+    this.mutableState = mutableState;
+    const target = newest(store);
+    this.latestUpdateState = this.initializeState(mutableState, target);
+    this.observeCore(mutableState, this.latestUpdateState, target);
+    this.updateCore(mutableState, this.latestUpdateState, target);
+    target.trackers.set(mutableState.key, this);
+  }
+  initializeState(mutableState, store) {
+    const latestUpdateStateKey = `*${mutableState.key}`;
+    deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store);
+    const familyMetaData = mutableState.family ? {
+      key: `*${mutableState.family.key}`,
+      subKey: mutableState.family.subKey
+    } : void 0;
+    const latestUpdateState = createAtom(
+      {
+        key: latestUpdateStateKey,
+        default: null
+      },
+      familyMetaData,
+      store
+    );
+    return latestUpdateState;
+  }
+  observeCore(mutableState, latestUpdateState, store) {
+    const originalInnerValue = atom_io.getState(mutableState, store);
+    const target = newest(store);
+    this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
+      `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
+      (update) => {
+        const unsubscribe = store.subject.operationStatus.subscribe(
+          mutableState.key,
+          () => {
+            unsubscribe();
+            atom_io.setState(latestUpdateState, update, store);
+          }
+        );
+      }
+    );
+    atom_io.subscribe(
+      mutableState,
+      (update) => {
+        var _a;
+        if (update.newValue !== update.oldValue) {
+          (_a = this.unsubscribeFromInnerValue) == null ? void 0 : _a.call(this);
+          const target2 = newest(store);
+          this.unsubscribeFromInnerValue = update.newValue.subscribe(
+            `tracker:${store.config.name}:${target2.transactionMeta === null ? `main` : target2.transactionMeta.update.key}`,
+            (update2) => {
+              const unsubscribe = store.subject.operationStatus.subscribe(
+                mutableState.key,
+                () => {
+                  unsubscribe();
+                  atom_io.setState(latestUpdateState, update2, store);
+                }
+              );
+            }
+          );
+        }
+      },
+      `${store.config.name}: tracker observing inner value`,
+      store
+    );
+  }
+  updateCore(mutableState, latestUpdateState, store) {
+    atom_io.subscribe(
+      latestUpdateState,
+      ({ newValue, oldValue }) => {
+        const timelineId = store.timelineAtoms.getRelatedKey(
+          latestUpdateState.key
+        );
+        if (timelineId) {
+          const timelineData = store.timelines.get(timelineId);
+          if (timelineData == null ? void 0 : timelineData.timeTraveling) {
+            const unsubscribe2 = atom_io.subscribeToTimeline(
+              { key: timelineId, type: `timeline` },
+              (update) => {
+                unsubscribe2();
+                atom_io.setState(
+                  mutableState,
+                  (transceiver) => {
+                    if (update === `redo` && newValue) {
+                      transceiver.do(newValue);
+                    } else if (update === `undo` && oldValue) {
+                      transceiver.undo(oldValue);
+                    }
+                    return transceiver;
+                  },
+                  store
+                );
+              }
+            );
+            return;
+          }
+        }
+        const unsubscribe = store.subject.operationStatus.subscribe(
+          latestUpdateState.key,
+          () => {
+            unsubscribe();
+            const mutable = atom_io.getState(mutableState, store);
+            const updateNumber = mutable.getUpdateNumber(newValue);
+            const eventOffset = updateNumber - mutable.cacheUpdateNumber;
+            if (newValue && eventOffset === 1) {
+              atom_io.setState(
+                mutableState,
+                (transceiver) => (transceiver.do(newValue), transceiver),
+                store
+              );
+            }
+          }
+        );
+      },
+      `${store.config.name}: tracker observing latest update`,
+      store
     );
-    return;
   }
+};
+
+// src/mutable/create-mutable-atom.ts
+function createMutableAtom(options, store) {
   store.logger.info(
-    `\u{1FA82}`,
-    `transaction`,
-    store.transactionStatus.key,
-    `Aborting transaction`
+    `\u{1F527}`,
+    `atom`,
+    options.key,
+    `creating in store "${store.config.name}"`
   );
-  store.transactionStatus = { phase: `idle` };
-};
+  const coreState = createAtom(options, void 0, store);
+  new Tracker(coreState, store);
+  const jsonState = json.selectJson(coreState, options, store);
+  const target = newest(store);
+  atom_io.subscribe(
+    jsonState,
+    () => {
+      const trackerHasBeenInitialized = newest(store).trackers.has(coreState.key);
+      if (!trackerHasBeenInitialized) {
+        new Tracker(coreState, store);
+      }
+    },
+    `tracker-initializer:${store == null ? void 0 : store.config.name}:${target.transactionMeta === null ? `main` : `${target.transactionMeta.update.key}`}`
+  );
+  return coreState;
+}
 
 // src/store/deposit.ts
 function deposit(state) {
@@ -351,10 +535,22 @@ var Subject = class {
     }
   }
 };
+var StatefulSubject = class extends Subject {
+  constructor(initialState) {
+    super();
+    this.state = initialState;
+  }
+  next(value) {
+    this.state = value;
+    super.next(value);
+  }
+};
 
 // src/store/store.ts
 var Store = class {
   constructor(name, store = null) {
+    this.parent = null;
+    this.child = null;
     this.valueMap = /* @__PURE__ */ new Map();
     this.atoms = /* @__PURE__ */ new Map();
     this.selectors = /* @__PURE__ */ new Map();
@@ -386,10 +582,11 @@ var Store = class {
       selectorCreation: new Subject(),
       transactionCreation: new Subject(),
       timelineCreation: new Subject(),
+      transactionApplying: new StatefulSubject(null),
       operationStatus: new Subject()
     };
     this.operation = { open: false };
-    this.transactionStatus = { phase: `idle` };
+    this.transactionMeta = null;
     this.config = {
       name: `IMPLICIT_STORE`
     };
@@ -413,7 +610,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.transactionStatus = __spreadValues({}, store == null ? void 0 : store.transactionStatus);
+      this.transactionMeta = (store == null ? void 0 : store.transactionMeta) ? __spreadValues({}, store == null ? void 0 : store.transactionMeta) : null;
       this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
         name
       });
@@ -448,1654 +645,1537 @@ var clearStore = (store) => {
   store.config = config;
 };
 
-// src/timeline/add-atom-to-timeline.ts
-var addAtomToTimeline = (atomToken, tl, store) => {
-  const atom = withdraw(atomToken, store);
-  if (atom === void 0) {
-    throw new Error(
-      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
-    );
+// 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;
   }
-  atom.subject.subscribe(`timeline`, (update) => {
-    var _a, _b, _c, _d;
-    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 = store.transactionStatus.phase === `applying` ? store.transactionStatus.key : null;
-    const currentTransactionTime = store.transactionStatus.phase === `applying` ? store.transactionStatus.time : null;
+  return void 0;
+}
+
+// src/store/withdraw-new-family-member.ts
+function withdrawNewFamilyMember(token, store) {
+  if (token.family) {
     store.logger.info(
-      `\u23F3`,
-      `timeline`,
-      tl.key,
-      `atom`,
-      atomToken.key,
-      `went`,
-      update.oldValue,
-      `->`,
-      update.newValue,
-      currentTransactionKey ? `in transaction "${currentTransactionKey}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
+      `\u{1F46A}`,
+      token.type,
+      token.key,
+      `creating new family member in store "${store.config.name}"`
     );
-    if (tl.timeTraveling === null) {
-      if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
-        const mostRecentUpdate = tl.history.at(-1);
-        if (mostRecentUpdate === void 0) {
-          throw new Error(
-            `Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`
-          );
-        }
-      }
-      if (currentTransactionKey && store.transactionStatus.phase === `applying`) {
-        const currentTransaction = withdraw(
-          { key: currentTransactionKey, type: `transaction` },
-          store
-        );
-        if (currentTransaction === void 0) {
-          throw new Error(
-            `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
-          );
-        }
-        if (tl.transactionKey !== currentTransactionKey) {
-          if (tl.transactionKey) {
-            store.logger.error(
-              `\u{1F41E}`,
-              `timeline`,
-              tl.key,
-              `unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`
-            );
-          }
-          tl.transactionKey = currentTransactionKey;
-          const unsubscribe = currentTransaction.subject.subscribe(
-            `timeline:${tl.key}`,
-            (update2) => {
-              var _a2, _b2;
-              unsubscribe();
-              if (tl.timeTraveling === null && currentTransactionTime) {
-                if (tl.at !== tl.history.length) {
-                  tl.history.splice(tl.at);
-                }
-                const atomUpdates = update2.atomUpdates.filter((atomUpdate) => {
-                  const core = target(store);
-                  const atomOrFamilyKeys = core.timelineAtoms.getRelatedKeys(
-                    tl.key
-                  );
-                  return atomOrFamilyKeys ? [...atomOrFamilyKeys].some(
-                    (key) => {
-                      var _a3;
-                      return key === atomUpdate.key || key === ((_a3 = atomUpdate.family) == null ? void 0 : _a3.key);
-                    }
-                  ) : false;
-                });
-                const timelineTransactionUpdate = __spreadProps(__spreadValues({
-                  type: `transaction_update`,
-                  timestamp: currentTransactionTime
-                }, update2), {
-                  atomUpdates
-                });
-                const willCapture = (_b2 = (_a2 = tl.shouldCapture) == null ? void 0 : _a2.call(tl, timelineTransactionUpdate, tl)) != null ? _b2 : true;
-                if (willCapture) {
-                  tl.history.push(timelineTransactionUpdate);
-                  tl.at = tl.history.length;
-                  tl.subject.next(timelineTransactionUpdate);
-                }
-              }
-              tl.transactionKey = null;
-              store.logger.info(
-                `\u231B`,
-                `timeline`,
-                tl.key,
-                `got a transaction_update "${update2.key}"`
-              );
-            }
-          );
-        }
-      } else if (currentSelectorKey && currentSelectorTime) {
-        let latestUpdate = tl.history.at(-1);
-        if (currentSelectorTime !== tl.selectorTime) {
-          latestUpdate = {
-            type: `selector_update`,
-            timestamp: currentSelectorTime,
-            key: currentSelectorKey,
-            atomUpdates: []
-          };
-          latestUpdate.atomUpdates.push(__spreadValues({
-            key: atom.key,
-            type: `atom_update`
-          }, update));
-          if (tl.at !== tl.history.length) {
-            tl.history.splice(tl.at);
-          }
-          tl.history.push(latestUpdate);
-          store.logger.info(
-            `\u231B`,
-            `timeline`,
-            tl.key,
-            `got a selector_update "${currentSelectorKey}" with`,
-            latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-          );
-          tl.at = tl.history.length;
-          tl.selectorTime = currentSelectorTime;
-        } else {
-          if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
-            latestUpdate.atomUpdates.push(__spreadValues({
-              key: atom.key,
-              type: `atom_update`
-            }, update));
-            store.logger.info(
-              `\u231B`,
-              `timeline`,
-              tl.key,
-              `set selector_update "${currentSelectorKey}" to`,
-              latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-            );
-          }
-        }
-        if (latestUpdate) {
-          const willCaptureSelectorUpdate = (_b = (_a = tl.shouldCapture) == null ? void 0 : _a.call(tl, latestUpdate, tl)) != null ? _b : true;
-          if (willCaptureSelectorUpdate) {
-            tl.subject.next(latestUpdate);
-          } else {
-            tl.history.pop();
-            tl.at = tl.history.length;
-          }
-        }
-      } else {
-        const timestamp = Date.now();
-        tl.selectorTime = null;
-        if (tl.at !== tl.history.length) {
-          tl.history.splice(tl.at);
-        }
-        const atomUpdate = {
-          type: `atom_update`,
-          timestamp,
-          key: atom.key,
-          oldValue: update.oldValue,
-          newValue: update.newValue
-        };
-        if (atom.family) {
-          atomUpdate.family = atom.family;
-        }
-        const willCapture = (_d = (_c = tl.shouldCapture) == null ? void 0 : _c.call(tl, atomUpdate, tl)) != null ? _d : true;
-        store.logger.info(
-          `\u231B`,
-          `timeline`,
-          tl.key,
-          `got an atom_update to "${atom.key}"`
-        );
-        if (willCapture) {
-          tl.history.push(atomUpdate);
-          tl.at = tl.history.length;
-          tl.subject.next(atomUpdate);
+    const target = newest(store);
+    const family = target.families.get(token.family.key);
+    if (family) {
+      const jsonSubKey = JSON.parse(token.family.subKey);
+      family(jsonSubKey);
+      const state = withdraw(token, store);
+      return state;
+    }
+  }
+  return void 0;
+}
+
+// src/families/create-atom-family.ts
+function createAtomFamily(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 = createAtom(individualOptions, family, store);
+        subject.next(token);
       }
+      return token;
+    },
+    {
+      key: options.key,
+      type: `atom_family`,
+      subject
     }
-  });
-};
+  );
+  const target = newest(store);
+  target.families.set(options.key, atomFamily);
+  return atomFamily;
+}
 
-// src/timeline/create-timeline.ts
-function createTimeline(options, store, data) {
-  var _a, _b;
-  const tl = __spreadProps(__spreadValues({
-    type: `timeline`,
-    key: options.key,
-    at: 0,
-    timeTraveling: null,
-    selectorTime: null,
-    transactionKey: null
-  }, data), {
-    history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
-    install: (store2) => createTimeline(options, store2, tl),
-    subject: new Subject()
-  });
-  if (options.shouldCapture) {
-    tl.shouldCapture = options.shouldCapture;
-  }
-  const core = target(store);
-  for (const tokenOrFamily of options.atoms) {
-    const timelineKey = core.timelineAtoms.getRelatedKey(tokenOrFamily.key);
-    if (timelineKey) {
-      store.logger.error(
-        `\u274C`,
-        `timeline`,
-        options.key,
-        `Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`
-      );
-      continue;
-    }
-    if (tokenOrFamily.type === `atom_family`) {
-      const family = tokenOrFamily;
-      family.subject.subscribe(`timeline:${options.key}`, (token2) => {
-        addAtomToTimeline(token2, tl, store);
-      });
-      for (const atom of core.atoms.values()) {
-        if (((_b = atom.family) == null ? void 0 : _b.key) === family.key) {
-          addAtomToTimeline(atom, tl, store);
-        }
-      }
-    } else {
-      const token2 = tokenOrFamily;
-      if (`family` in token2 && token2.family) {
-        const familyTimelineKey = core.timelineAtoms.getRelatedKey(
-          token2.family.key
-        );
-        if (familyTimelineKey) {
-          store.logger.error(
-            `\u274C`,
-            `timeline`,
-            options.key,
-            `Failed to add atom "${token2.key}" because its family "${token2.family.key}" already belongs to timeline "${familyTimelineKey}"`
-          );
-          continue;
-        }
-      }
-      addAtomToTimeline(token2, tl, store);
-    }
-    core.timelineAtoms = core.timelineAtoms.set({
-      atomKey: tokenOrFamily.key,
-      timelineKey: options.key
-    });
+// src/operation.ts
+var openOperation = (token, store) => {
+  const target = newest(store);
+  if (target.operation.open) {
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `failed to setState during a setState for "${target.operation.token.key}"`
+    );
+    return `rejection`;
   }
-  store.timelines.set(options.key, tl);
-  const token = {
-    key: options.key,
-    type: `timeline`
+  target.operation = {
+    open: true,
+    done: /* @__PURE__ */ new Set(),
+    prev: /* @__PURE__ */ new Map(),
+    time: Date.now(),
+    token
   };
-  store.subject.timelineCreation.next(token);
-  return token;
-}
-var timeTravel = (direction, token, store) => {
-  const action = direction === `forward` ? `redo` : `undo`;
   store.logger.info(
-    direction === `forward` ? `\u23E9` : `\u23EA`,
-    `timeline`,
+    `\u2B55`,
+    token.type,
     token.key,
-    action
+    `operation start in store "${store.config.name}"${target.transactionMeta === null ? `` : ` ${target.transactionMeta.phase} "${target.transactionMeta.update.key}"`}`
   );
-  const timelineData = store.timelines.get(token.key);
-  if (!timelineData) {
-    store.logger.error(
+};
+var closeOperation = (store) => {
+  const target = newest(store);
+  if (target.operation.open) {
+    store.logger.info(
+      `\u{1F534}`,
+      target.operation.token.type,
+      target.operation.token.key,
+      `operation done in store "${store.config.name}"`
+    );
+  }
+  target.operation = { open: false };
+  store.subject.operationStatus.next(target.operation);
+};
+var isDone = (key, store) => {
+  const target = newest(store);
+  if (!target.operation.open) {
+    store.logger.warn(
       `\u{1F41E}`,
-      `timeline`,
-      token.key,
-      `Failed to ${action}. This timeline has not been initialized.`
+      `unknown`,
+      key,
+      `isDone called outside of an operation. This is probably a bug.`
     );
-    return;
+    return true;
   }
-  if (direction === `forward` && timelineData.at === timelineData.history.length || direction === `backward` && timelineData.at === 0) {
+  return target.operation.done.has(key);
+};
+var markDone = (key, store) => {
+  const target = newest(store);
+  if (!target.operation.open) {
     store.logger.warn(
-      `\u{1F481}`,
-      `timeline`,
-      token.key,
-      `Failed to ${action} at the ${direction === `forward` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `markDone called outside of an operation. This is probably a bug.`
     );
     return;
   }
-  timelineData.timeTraveling = direction === `forward` ? `into_future` : `into_past`;
-  if (direction === `backward`) {
-    --timelineData.at;
-  }
-  const update = timelineData.history[timelineData.at];
-  const updateValues = (atomUpdate) => {
-    const { key, newValue, oldValue } = atomUpdate;
-    const value = direction === `forward` ? newValue : oldValue;
-    atom_io.setState({ key, type: `atom` }, value, store);
-  };
-  switch (update.type) {
-    case `atom_update`: {
-      updateValues(update);
-      break;
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      const updates = direction === `forward` ? update.atomUpdates : [...update.atomUpdates].reverse();
-      for (const atomUpdate of updates) {
-        updateValues(atomUpdate);
-      }
-      break;
-    }
+  target.operation.done.add(key);
+};
+
+// src/set-state/become.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+
+// src/read-or-compute-value.ts
+var readOrComputeValue = (state, store) => {
+  if (isValueCached(state.key, store)) {
+    store.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
+    return readCachedValue(state.key, store);
   }
-  if (direction === `forward`) {
-    ++timelineData.at;
+  if (state.type !== `atom`) {
+    store.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
+    return state.get();
   }
-  timelineData.subject.next(action);
-  timelineData.timeTraveling = null;
+  const fallback = state.default instanceof Function ? state.default() : state.default;
   store.logger.info(
-    `\u23F9\uFE0F`,
-    `timeline`,
-    token.key,
-    `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+    `\u{1F481}`,
+    `atom`,
+    state.key,
+    `could not find cached value; using default`,
+    fallback
   );
+  return state.default instanceof Function ? state.default() : state.default;
 };
 
-// src/store/withdraw.ts
-function withdraw(token, store) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  let core = target(store);
-  let state = (_d = (_c = (_b = (_a = core.atoms.get(token.key)) != null ? _a : core.selectors.get(token.key)) != null ? _b : core.readonlySelectors.get(token.key)) != null ? _c : core.transactions.get(token.key)) != null ? _d : core.timelines.get(token.key);
-  if (state) {
-    return state;
-  }
-  if (store.transactionStatus.phase === `applying`) {
-    core = store.transactionStatus.core;
-    state = (_h = (_g = (_f = (_e = core.atoms.get(token.key)) != null ? _e : core.selectors.get(token.key)) != null ? _f : core.readonlySelectors.get(token.key)) != null ? _g : core.transactions.get(token.key)) != null ? _h : core.timelines.get(token.key);
-    if (state) {
-      store.logger.info(
-        `\u{1F6E0}\uFE0F`,
-        token.type,
-        token.key,
-        `add ${token.type} "${token.key}"`
-      );
-      switch (state.type) {
-        case `atom`: {
-          store.atoms.set(token.key, state);
-          store.valueMap.set(token.key, state.default);
-          const stateKey = state.key;
-          const familyKey = (_i = state.family) == null ? void 0 : _i.key;
-          let timelineKey = core.timelineAtoms.getRelatedKey(stateKey);
-          if (timelineKey === void 0 && typeof familyKey === `string`) {
-            timelineKey = core.timelineAtoms.getRelatedKey(familyKey);
-          }
-          const timeline = typeof timelineKey === `string` ? store.timelines.get(timelineKey) : void 0;
-          if (timeline) {
-            addAtomToTimeline(state, timeline, store);
-          }
-          break;
-        }
-        case `selector`:
-          core.selectors.set(token.key, state);
-          break;
-        case `readonly_selector`:
-          core.readonlySelectors.set(token.key, state);
-          break;
-        case `transaction`:
-          core.transactions.set(token.key, state);
-          break;
-        case `timeline`:
-          core.timelines.set(token.key, state);
-          break;
-      }
-      return state;
-    }
+// src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, transform, origin, target) {
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
+    const jsonValue = transform.toJson(originValue);
+    const copiedValue = transform.fromJson(jsonValue);
+    target.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
   }
-  return void 0;
+  return targetValue;
 }
 
-// src/store/withdraw-new-family-member.ts
-function withdrawNewFamilyMember(token, store) {
-  if (token.family) {
-    store.logger.info(
-      `\u{1F46A}`,
-      token.type,
-      token.key,
-      `creating new family member in store "${store.config.name}"`
-    );
-    const core = target(store);
-    const family = core.families.get(token.family.key);
-    if (family) {
-      const jsonSubKey = JSON.parse(token.family.subKey);
-      family(jsonSubKey);
-      const state = withdraw(token, store);
-      return state;
+// src/set-state/copy-mutable-in-transaction.ts
+function copyMutableIfWithinTransaction(oldValue, atom, store) {
+  const target = newest(store);
+  const parent = target.parent;
+  if (parent !== null) {
+    if (`toJson` in atom && `fromJson` in atom) {
+      const copiedValue = copyMutableIfNeeded(atom, atom, parent, target);
+      return copiedValue;
     }
-  }
-  return void 0;
-}
-
-// src/transaction/apply-transaction.ts
-var applyTransaction = (output, store) => {
-  if (store.transactionStatus.phase !== `building`) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  store.transactionStatus.phase = `applying`;
-  store.transactionStatus.output = output;
-  const { atomUpdates } = store.transactionStatus;
-  store.logger.info(
-    `\u{1F6C4}`,
-    `transaction`,
-    store.transactionStatus.key,
-    `Applying transaction with ${atomUpdates.length} updates:`,
-    atomUpdates
-  );
-  for (const { key, newValue } of atomUpdates) {
-    const token = { key, type: `atom` };
-    if (!store.valueMap.has(token.key)) {
-      if (token.family) {
-        const family = store.families.get(token.family.key);
-        if (family) {
-          family(token.family.subKey);
-        }
-      } else {
-        const newAtom = store.transactionStatus.core.atoms.get(token.key);
-        if (!newAtom) {
-          throw new Error(
-            `Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`
-          );
-        }
-        store.atoms.set(newAtom.key, newAtom);
-        store.valueMap.set(newAtom.key, newAtom.default);
-        store.logger.info(
-          `\u{1F528}`,
-          `transaction`,
-          store.transactionStatus.key,
-          `Adding atom "${newAtom.key}"`
+    if (`family` in atom) {
+      const family = parent.families.get(atom.family.key);
+      if (family && family.type === `atom_family`) {
+        const result = copyMutableFamilyMemberWithinTransaction(
+          atom,
+          family,
+          parent,
+          target
         );
+        if (result) {
+          return result;
+        }
       }
     }
-    atom_io.setState(token, newValue, store);
   }
-  const myTransaction = withdraw(
-    { key: store.transactionStatus.key, type: `transaction` },
-    store
-  );
-  if (myTransaction === void 0) {
-    throw new Error(
-      `Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`
-    );
+  return oldValue;
+}
+function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target) {
+  if (`toJson` in family && `fromJson` in family) {
+    const copyCreated = copyMutableIfNeeded(atom, family, origin, target);
+    return copyCreated;
   }
-  myTransaction.subject.next({
-    key: store.transactionStatus.key,
-    atomUpdates,
-    output,
-    params: store.transactionStatus.params
-  });
-  store.logger.info(
-    `\u{1F6EC}`,
-    `transaction`,
-    store.transactionStatus.key,
-    `Finished applying transaction.`
-  );
-  store.transactionStatus = { phase: `idle` };
-};
+  return null;
+}
 
-// src/transaction/build-transaction.ts
-var buildTransaction = (key, params, store) => {
-  store.transactionStatus = {
-    key,
-    phase: `building`,
-    time: Date.now(),
-    core: {
-      atoms: new Map(store.atoms),
-      atomsThatAreDefault: new Set(store.atomsThatAreDefault),
-      families: new Map(store.families),
-      operation: { open: false },
-      readonlySelectors: new Map(store.readonlySelectors),
-      timelines: new Map(store.timelines),
-      timelineAtoms: new Junction(store.timelineAtoms.toJSON()),
-      trackers: /* @__PURE__ */ new Map(),
-      transactions: new Map(store.transactions),
-      selectorAtoms: new Junction(store.selectorAtoms.toJSON()),
-      selectorGraph: new Junction(store.selectorGraph.toJSON(), {
-        makeContentKey: (...keys) => keys.sort().join(`:`)
-      }),
-      selectors: new Map(store.selectors),
-      valueMap: new Map(store.valueMap)
-    },
-    atomUpdates: [],
-    params,
-    output: void 0
-  };
+// src/set-state/emit-update.ts
+var emitUpdate = (state, update, store) => {
   store.logger.info(
-    `\u{1F6EB}`,
-    `transaction`,
-    key,
-    `Building transaction with params:`,
-    params
+    `\u{1F4E2}`,
+    state.type,
+    state.key,
+    `went (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `) subscribers:`,
+    state.subject.subscribers
   );
+  state.subject.next(update);
 };
-function createTransaction(options, store) {
-  const newTransaction = {
-    key: options.key,
-    type: `transaction`,
-    run: (...params) => {
-      buildTransaction(options.key, params, store);
-      try {
-        const output = options.do(
-          {
-            get: (token2) => atom_io.getState(token2, store),
-            set: (token2, value) => atom_io.setState(token2, value, store)
-          },
-          ...params
-        );
-        applyTransaction(output, store);
-        return output;
-      } catch (thrown) {
-        abortTransaction(store);
-        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
-        throw thrown;
-      }
-    },
-    install: (store2) => createTransaction(options, store2),
-    subject: new Subject()
-  };
-  const core = target(store);
-  core.transactions.set(newTransaction.key, newTransaction);
-  const token = deposit(newTransaction);
-  store.subject.transactionCreation.next(token);
-  return token;
-}
-var target = (store) => store.transactionStatus.phase === `building` ? store.transactionStatus.core : store;
-var redoTransactionUpdate = (update, store) => {
-  store.logger.info(`\u23ED\uFE0F`, `transaction`, update.key, `Redo`);
-  for (const { key, newValue } of update.atomUpdates) {
-    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.`
-      );
-    }
-    atom_io.setState(state, newValue, store);
-  }
-};
-var undoTransactionUpdate = (update, store) => {
+
+// src/set-state/evict-downstream.ts
+var evictDownStream = (atom, store) => {
+  const target = newest(store);
+  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
   store.logger.info(
-    `\u23EE\uFE0F`,
-    `transaction`,
-    update.key,
-    `Undoing transaction update`,
-    update
+    `\u{1F9F9}`,
+    atom.type,
+    atom.key,
+    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
+    downstreamKeys != null ? downstreamKeys : `to evict`
   );
-  for (const { key, oldValue } of update.atomUpdates) {
-    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.`
+  if (downstreamKeys) {
+    if (target.operation.open) {
+      store.logger.info(
+        `\u{1F9F9}`,
+        atom.type,
+        atom.key,
+        `[ ${[...target.operation.done].join(`, `)} ] already done`
       );
     }
-    atom_io.setState(state, oldValue, store);
+    for (const key of downstreamKeys) {
+      if (isDone(key, store)) {
+        continue;
+      }
+      evictCachedValue(key, store);
+      markDone(key, store);
+    }
   }
 };
 
-// src/transaction/index.ts
-var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
-
-// src/caching.ts
-function cacheValue(key, value, subject, store) {
-  const currentValue = target(store).valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
+// src/set-state/stow-update.ts
+function shouldUpdateBeStowed(key, update) {
+  if (isTransceiver(update.newValue)) {
+    return false;
   }
-  if (value instanceof Promise) {
-    const future = new Future(value);
-    target(store).valueMap.set(key, future);
-    future.then((resolved) => {
-      if (future.isCanceled) {
-        return;
-      }
-      cacheValue(key, resolved, subject, store);
-      subject.next({ newValue: resolved, oldValue: future });
-    }).catch((thrown) => {
-      if (thrown !== `canceled`) {
-        store.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
-      }
-    });
-    return future;
+  if (key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+    return false;
   }
-  target(store).valueMap.set(key, value);
-  return value;
+  return true;
 }
-var readCachedValue = (key, store) => target(store).valueMap.get(key);
-var isValueCached = (key, store) => target(store).valueMap.has(key);
-var evictCachedValue = (key, store) => {
-  const core = target(store);
-  const currentValue = core.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
-  }
-  if (core.operation.open) {
-    core.operation.prev.set(key, currentValue);
-  }
-  core.valueMap.delete(key);
-  store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
-};
-var Tracker = class {
-  constructor(mutableState, store) {
-    this.unsubscribeFromInnerValue = null;
-    this.mutableState = mutableState;
-    this.latestUpdateState = this.initializeState(mutableState, store);
-    this.observeCore(mutableState, this.latestUpdateState, store);
-    this.updateCore(mutableState, this.latestUpdateState, store);
-    const core = target(store);
-    core.trackers.set(mutableState.key, this);
-  }
-  initializeState(mutableState, store) {
-    const latestUpdateStateKey = `*${mutableState.key}`;
-    deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store);
-    const familyMetaData = mutableState.family ? {
-      key: `*${mutableState.family.key}`,
-      subKey: mutableState.family.subKey
-    } : void 0;
-    const latestUpdateState = createAtom(
-      {
-        key: latestUpdateStateKey,
-        default: null
-      },
-      familyMetaData,
-      store
+var stowUpdate = (state, update, store) => {
+  const { key } = state;
+  const target = newest(store);
+  if (target.transactionMeta === null || target.transactionMeta.phase !== `building`) {
+    store.logger.error(
+      `\u{1F41E}`,
+      `atom`,
+      key,
+      `stowUpdate called outside of a transaction. This is probably a bug.`
     );
-    return latestUpdateState;
+    return;
   }
-  observeCore(mutableState, latestUpdateState, store) {
-    const originalInnerValue = atom_io.getState(mutableState, store);
-    this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
-      `tracker:${store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`,
-      (update) => {
-        const unsubscribe = store.subject.operationStatus.subscribe(
-          mutableState.key,
-          () => {
-            unsubscribe();
-            atom_io.setState(latestUpdateState, update, store);
-          }
-        );
-      }
-    );
-    atom_io.subscribe(
-      mutableState,
-      (update) => {
-        var _a;
-        if (update.newValue !== update.oldValue) {
-          (_a = this.unsubscribeFromInnerValue) == null ? void 0 : _a.call(this);
-          this.unsubscribeFromInnerValue = update.newValue.subscribe(
-            `tracker:${store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`,
-            (update2) => {
-              const unsubscribe = store.subject.operationStatus.subscribe(
-                mutableState.key,
-                () => {
-                  unsubscribe();
-                  atom_io.setState(latestUpdateState, update2, store);
-                }
-              );
-            }
-          );
-        }
-      },
-      `${store.config.name}: tracker observing inner value`,
-      store
-    );
+  const shouldStow = shouldUpdateBeStowed(key, update);
+  if (!shouldStow) {
+    return;
   }
-  updateCore(mutableState, latestUpdateState, store) {
-    atom_io.subscribe(
-      latestUpdateState,
-      ({ newValue, oldValue }) => {
-        const timelineId = store.timelineAtoms.getRelatedKey(
-          latestUpdateState.key
-        );
-        if (timelineId) {
-          const timelineData = store.timelines.get(timelineId);
-          if (timelineData == null ? void 0 : timelineData.timeTraveling) {
-            const unsubscribe2 = atom_io.subscribeToTimeline(
-              { key: timelineId, type: `timeline` },
-              (update) => {
-                unsubscribe2();
-                atom_io.setState(
-                  mutableState,
-                  (transceiver) => {
-                    if (update === `redo` && newValue) {
-                      transceiver.do(newValue);
-                    } else if (update === `undo` && oldValue) {
-                      transceiver.undo(oldValue);
-                    }
-                    return transceiver;
-                  },
-                  store
-                );
-              }
-            );
-            return;
-          }
-        }
-        const unsubscribe = store.subject.operationStatus.subscribe(
-          latestUpdateState.key,
-          () => {
-            unsubscribe();
-            const mutable = atom_io.getState(mutableState, store);
-            const updateNumber = mutable.getUpdateNumber(newValue);
-            const eventOffset = updateNumber - mutable.cacheUpdateNumber;
-            if (newValue && eventOffset === 1) {
-              atom_io.setState(
-                mutableState,
-                (transceiver) => (transceiver.do(newValue), transceiver),
-                store
-              );
-            }
-          }
-        );
-      },
-      `${store.config.name}: tracker observing latest update`,
-      store
-    );
+  const atomUpdate = __spreadValues({ key }, update);
+  if (state.family) {
+    atomUpdate.family = state.family;
   }
-};
-
-// src/mutable/create-mutable-atom.ts
-function createMutableAtom(options, store) {
+  target.transactionMeta.update.updates.push(atomUpdate);
   store.logger.info(
-    `\u{1F527}`,
+    `\u{1F4C1}`,
     `atom`,
-    options.key,
-    `creating in store "${store.config.name}"`
-  );
-  const coreState = createAtom(options, void 0, store);
-  new Tracker(coreState, store);
-  const jsonState = json.selectJson(coreState, options, store);
-  atom_io.subscribe(
-    jsonState,
-    () => {
-      const trackerHasBeenInitialized = target(store).trackers.has(coreState.key);
-      if (!trackerHasBeenInitialized) {
-        new Tracker(coreState, store);
-      }
-    },
-    `tracker-initializer:${store == null ? void 0 : store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`
-  );
-  return coreState;
-}
-function createAtomFamily(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 = createAtom(individualOptions, family, store);
-        subject.next(token);
-      }
-      return token;
-    },
-    {
-      key: options.key,
-      type: `atom_family`,
-      subject
-    }
+    key,
+    `stowed (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `)`
   );
-  const core = target(store);
-  core.families.set(options.key, atomFamily);
-  return atomFamily;
-}
+};
+
+// 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);
+  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);
+  }
+  markDone(atom.key, store);
+  evictDownStream(atom, store);
+  const update = { oldValue, newValue };
+  if (target.transactionMeta === null || target.transactionMeta.phase === `applying`) {
+    emitUpdate(atom, update, store);
+  } else {
+    stowUpdate(atom, update, store);
+  }
+};
+
+// src/set-state/set-atom-or-selector.ts
+var setAtomOrSelector = (state, value, store) => {
+  if (state.type === `selector`) {
+    state.set(value);
+  } else {
+    setAtom(state, value, store);
+  }
+};
 
-// src/operation.ts
-var openOperation = (token, store) => {
-  const core = target(store);
-  if (core.operation.open) {
-    store.logger.error(
-      `\u274C`,
-      token.type,
-      token.key,
-      `failed to setState during a setState for "${core.operation.token.key}"`
-    );
-    return `rejection`;
+// src/keys.ts
+var isAtomKey = (key, store) => newest(store).atoms.has(key);
+var isSelectorKey = (key, store) => newest(store).selectors.has(key);
+var isReadonlySelectorKey = (key, store) => newest(store).readonlySelectors.has(key);
+var isStateKey = (key, store) => isAtomKey(key, store) || isSelectorKey(key, store) || isReadonlySelectorKey(key, store);
+
+// src/selector/get-selector-dependency-keys.ts
+var getSelectorDependencyKeys = (key, store) => {
+  const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(source, store));
+  return sources;
+};
+
+// src/selector/trace-selector-atoms.ts
+var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
+  const rootKeys = [];
+  const indirectDependencyKeys = getSelectorDependencyKeys(
+    directDependencyKey,
+    store
+  );
+  let depth = 0;
+  while (indirectDependencyKeys.length > 0) {
+    const indirectDependencyKey = indirectDependencyKeys.shift();
+    ++depth;
+    if (depth > 99999) {
+      throw new Error(
+        `Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`
+      );
+    }
+    if (!isAtomKey(indirectDependencyKey, store)) {
+      indirectDependencyKeys.push(
+        ...getSelectorDependencyKeys(indirectDependencyKey, store)
+      );
+    } else if (!rootKeys.includes(indirectDependencyKey)) {
+      rootKeys.push(indirectDependencyKey);
+    }
   }
-  core.operation = {
-    open: true,
-    done: /* @__PURE__ */ new Set(),
-    prev: /* @__PURE__ */ new Map(),
-    time: Date.now(),
-    token
-  };
-  store.logger.info(
-    `\u2B55`,
-    token.type,
-    token.key,
-    `operation start in store "${store.config.name}"${store.transactionStatus.phase === `idle` ? `` : ` ${store.transactionStatus.phase} "${store.transactionStatus.key}"`}`
+  return rootKeys;
+};
+var traceAllSelectorAtoms = (selectorKey, store) => {
+  const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
+  return directDependencyKeys.flatMap(
+    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(selectorKey, depKey, store)
   );
 };
-var closeOperation = (store) => {
-  const core = target(store);
-  if (core.operation.open) {
+
+// src/selector/update-selector-atoms.ts
+var updateSelectorAtoms = (selectorKey, dependency, store) => {
+  const core = newest(store);
+  if (dependency.type === `atom`) {
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key
+    });
     store.logger.info(
-      `\u{1F534}`,
-      core.operation.token.type,
-      core.operation.token.key,
-      `operation done in store "${store.config.name}"`
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atom "${dependency.key}"`
+    );
+  } else {
+    const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store);
+    store.logger.info(
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`
     );
+    for (const atomKey of rootKeys) {
+      core.selectorAtoms = core.selectorAtoms.set({
+        selectorKey,
+        atomKey
+      });
+    }
   }
-  core.operation = { open: false };
-  store.subject.operationStatus.next(core.operation);
 };
-var isDone = (key, store) => {
-  const core = target(store);
-  if (!core.operation.open) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `unknown`,
-      key,
-      `isDone called outside of an operation. This is probably a bug.`
+
+// src/selector/register-selector.ts
+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(
+        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    const dependencyValue = readOrComputeValue(dependencyState, store);
+    store.logger.info(
+      `\u{1F50C}`,
+      `selector`,
+      selectorKey,
+      `registers dependency ( "${dependency.key}" =`,
+      dependencyValue,
+      `)`
     );
-    return true;
+    if (!alreadyRegistered) {
+      target.selectorGraph = target.selectorGraph.set(
+        {
+          upstreamSelectorKey: dependency.key,
+          downstreamSelectorKey: selectorKey
+        },
+        {
+          source: dependency.key
+        }
+      );
+    }
+    updateSelectorAtoms(selectorKey, dependency, store);
+    return dependencyValue;
+  },
+  set: (stateToken, newValue) => {
+    const state = withdraw(stateToken, store);
+    if (state === void 0) {
+      throw new Error(
+        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    setAtomOrSelector(state, newValue, store);
   }
-  return core.operation.done.has(key);
-};
-var markDone = (key, store) => {
-  const core = target(store);
-  if (!core.operation.open) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `unknown`,
-      key,
-      `markDone called outside of an operation. This is probably a bug.`
+});
+
+// src/selector/create-read-write-selector.ts
+var createReadWriteSelector = (options, family, store) => {
+  const target = newest(store);
+  const subject = new Subject();
+  const { get, set } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    cacheValue(options.key, value, subject, store);
+    return value;
+  };
+  const setSelf = (next) => {
+    const oldValue = getSelf();
+    const newValue = become(next)(oldValue);
+    store.logger.info(
+      `\u{1F4DD}`,
+      `selector`,
+      options.key,
+      `set (`,
+      oldValue,
+      `->`,
+      newValue,
+      `)`
     );
-    return;
+    cacheValue(options.key, newValue, subject, store);
+    markDone(options.key, store);
+    if (target.transactionMeta === null) {
+      subject.next({ newValue, oldValue });
+    }
+    options.set({ get, set }, newValue);
+  };
+  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => createSelector(options, family, s),
+    get: getSelf,
+    set: setSelf,
+    type: `selector`
+  }), family && { family });
+  target.selectors.set(options.key, mySelector);
+  const initialValue = getSelf();
+  store.logger.info(`\u2728`, mySelector.type, mySelector.key, `=`, initialValue);
+  const token = {
+    key: options.key,
+    type: `selector`
+  };
+  if (family) {
+    token.family = family;
   }
-  core.operation.done.add(key);
+  store.subject.selectorCreation.next(token);
+  return token;
 };
 
-// src/set-state/become.ts
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
-  originalThing instanceof Function ? originalThing() : originalThing
-) : nextVersionOfThing;
-
-// src/read-or-compute-value.ts
-var readOrComputeValue = (state, store) => {
-  if (isValueCached(state.key, store)) {
-    store.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
-    return readCachedValue(state.key, store);
-  }
-  if (state.type !== `atom`) {
-    store.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
-    return state.get();
-  }
-  const fallback = state.default instanceof Function ? state.default() : state.default;
+// src/selector/create-readonly-selector.ts
+var createReadonlySelector = (options, family, store) => {
+  const target = newest(store);
+  const subject = new Subject();
+  const { get } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    cacheValue(options.key, value, subject, store);
+    return value;
+  };
+  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => createSelector(options, family, s),
+    get: getSelf,
+    type: `readonly_selector`
+  }), family && { family });
+  target.readonlySelectors.set(options.key, readonlySelector);
+  const initialValue = getSelf();
   store.logger.info(
-    `\u{1F481}`,
-    `atom`,
-    state.key,
-    `could not find cached value; using default`,
-    fallback
+    `\u2728`,
+    readonlySelector.type,
+    readonlySelector.key,
+    `=`,
+    initialValue
   );
-  return state.default instanceof Function ? state.default() : state.default;
+  const token = {
+    key: options.key,
+    type: `readonly_selector`
+  };
+  if (family) {
+    token.family = family;
+  }
+  store.subject.selectorCreation.next(token);
+  return token;
 };
 
-// src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, transform, origin, target2) {
-  const originValue = origin.valueMap.get(atom.key);
-  const targetValue = target2.valueMap.get(atom.key);
-  if (originValue === targetValue) {
-    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom.key}`, `copying`);
-    const copiedValue = transform.fromJson(transform.toJson(originValue));
-    target2.valueMap.set(atom.key, copiedValue);
-    new Tracker(atom, origin);
-    return copiedValue;
+// src/selector/create-selector.ts
+function createSelector(options, family, store) {
+  const target = newest(store);
+  const existingWritable = target.selectors.get(options.key);
+  const existingReadonly = target.readonlySelectors.get(options.key);
+  if (existingWritable || existingReadonly) {
+    store.logger.error(
+      `\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.)`
+    );
   }
-  return targetValue;
+  if (`set` in options) {
+    return createReadWriteSelector(options, family, store);
+  }
+  return createReadonlySelector(options, family, store);
 }
 
-// src/set-state/copy-mutable-in-transaction.ts
-function copyMutableIfWithinTransaction(oldValue, atom, store) {
-  if (store.transactionStatus.phase === `building` || store.transactionStatus.phase === `applying`) {
-    if (`toJson` in atom && `fromJson` in atom) {
-      const copiedValue = copyMutableIfNeeded(
-        atom,
-        atom,
-        store,
-        store.transactionStatus.core
-      );
-      return copiedValue;
+// src/selector/delete-selector.ts
+function deleteSelector(selectorToken, store) {
+  const target = newest(store);
+  const { key } = selectorToken;
+  switch (selectorToken.type) {
+    case `selector`:
+      target.selectors.delete(key);
+      break;
+    case `readonly_selector`:
+      target.readonlySelectors.delete(key);
+      break;
+  }
+  target.valueMap.delete(key);
+  target.selectorAtoms.delete(key);
+  const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
+    ([downstreamSelectorKey]) => {
+      var _a;
+      return (_a = target.selectors.get(downstreamSelectorKey)) != null ? _a : target.readonlySelectors.get(downstreamSelectorKey);
     }
-    if (`family` in atom) {
-      const family = store.transactionStatus.core.families.get(atom.family.key);
-      if (family && family.type === `atom_family`) {
-        const result = copyMutableFamilyMemberWithinTransaction(
-          atom,
-          family,
-          store,
-          store.transactionStatus.core
-        );
-        if (result) {
-          return result;
-        }
-      }
+  );
+  for (const downstreamToken of downstreamTokens) {
+    if (downstreamToken) {
+      deleteSelector(downstreamToken, store);
     }
   }
-  return oldValue;
-}
-function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target2) {
-  if (`toJson` in family && `fromJson` in family) {
-    const copyCreated = copyMutableIfNeeded(atom, family, origin, target2);
-    return copyCreated;
-  }
-  return null;
+  target.selectorGraph.delete(key);
+  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
 }
 
-// src/set-state/emit-update.ts
-var emitUpdate = (state, update, store) => {
-  store.logger.info(
-    `\u{1F4E2}`,
-    state.type,
-    state.key,
-    `went (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `) subscribers:`,
-    state.subject.subscribers
-  );
-  state.subject.next(update);
-};
-
-// src/set-state/evict-downstream.ts
-var evictDownStream = (atom, store) => {
-  const core = target(store);
-  const downstreamKeys = core.selectorAtoms.getRelatedKeys(atom.key);
-  store.logger.info(
-    `\u{1F9F9}`,
-    atom.type,
-    atom.key,
-    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
-    downstreamKeys != null ? downstreamKeys : `to evict`
-  );
-  if (downstreamKeys) {
-    if (core.operation.open) {
-      store.logger.info(
-        `\u{1F9F9}`,
-        atom.type,
-        atom.key,
-        `[ ${[...core.operation.done].join(`, `)} ] already done`
+// src/families/create-readonly-selector-family.ts
+function createReadonlySelectorFamily(options, store) {
+  const subject = new Subject();
+  return 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 createSelector(
+        {
+          key: fullKey,
+          get: options.get(key)
+        },
+        family,
+        store
       );
+    },
+    {
+      key: options.key,
+      type: `readonly_selector_family`,
+      subject
     }
-    for (const key of downstreamKeys) {
-      if (isDone(key, store)) {
-        continue;
+  );
+}
+function createSelectorFamily(options, store) {
+  const isReadonly = !(`set` in options);
+  if (isReadonly) {
+    return createReadonlySelectorFamily(options, store);
+  }
+  const target = newest(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 = target.selectors.get(fullKey);
+      if (existing) {
+        return deposit(existing);
       }
-      evictCachedValue(key, store);
-      markDone(key, store);
+      const token = createSelector(
+        {
+          key: fullKey,
+          get: options.get(key),
+          set: options.set(key)
+        },
+        family,
+        store
+      );
+      subject.next(token);
+      return token;
+    },
+    {
+      key: options.key,
+      type: `selector_family`
     }
+  );
+  target.families.set(options.key, selectorFamily);
+  return selectorFamily;
+}
+
+// src/mutable/tracker-family.ts
+var FamilyTracker = class {
+  constructor(findMutableState, store) {
+    this.findLatestUpdateState = createAtomFamily(
+      {
+        key: `*${findMutableState.key}`,
+        default: null
+      },
+      store
+    );
+    this.findMutableState = findMutableState;
+    this.findMutableState.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (atomToken) => {
+        if (atomToken.family) {
+          const key = json.parseJson(atomToken.family.subKey);
+          this.findLatestUpdateState(key);
+          new Tracker(atomToken, store);
+        }
+      }
+    );
+    this.findLatestUpdateState.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (atomToken) => {
+        if (atomToken.family) {
+          const key = json.parseJson(atomToken.family.subKey);
+          const mutableAtomToken = this.findMutableState(key);
+          new Tracker(mutableAtomToken, store);
+        }
+      }
+    );
   }
 };
 
-// src/set-state/stow-update.ts
-function shouldUpdateBeStowed(key, update) {
-  if (isTransceiver(update.newValue)) {
-    return false;
-  }
-  if (key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-    return false;
-  }
-  return true;
+// src/mutable/create-mutable-atom-family.ts
+function createMutableAtomFamily(options, store) {
+  const coreFamily = Object.assign(
+    createAtomFamily(options, store),
+    options
+  );
+  json.selectJsonFamily(coreFamily, options);
+  new FamilyTracker(coreFamily, store);
+  return coreFamily;
 }
-var stowUpdate = (state, update, store) => {
-  const { key } = state;
-  if (store.transactionStatus.phase !== `building`) {
-    store.logger.error(
-      `\u{1F41E}`,
-      `atom`,
-      key,
-      `stowUpdate called outside of a transaction. This is probably a bug.`
-    );
-    return;
-  }
-  const shouldStow = shouldUpdateBeStowed(key, update);
-  if (!shouldStow) {
-    return;
-  }
-  const atomUpdate = __spreadValues({ key }, update);
-  if (state.family) {
-    atomUpdate.family = state.family;
-  }
-  store.transactionStatus.atomUpdates.push(atomUpdate);
-  store.logger.info(
-    `\u{1F4C1}`,
-    `atom`,
-    key,
-    `stowed (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `)`
+
+// src/mutable/get-json-family.ts
+var getJsonFamily = (mutableAtomFamily, store) => {
+  const target = newest(store);
+  const key = `${mutableAtomFamily.key}:JSON`;
+  const jsonFamily = target.families.get(
+    key
   );
+  return jsonFamily;
 };
 
-// src/set-state/set-atom.ts
-var setAtom = (atom, next, store) => {
-  const oldValue = readOrComputeValue(atom, store);
-  let newValue = copyMutableIfWithinTransaction(oldValue, atom, store);
-  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);
-  }
-  markDone(atom.key, store);
-  evictDownStream(atom, store);
-  const update = { oldValue, newValue };
-  if (store.transactionStatus.phase !== `building`) {
-    emitUpdate(atom, update, store);
-  } else {
-    stowUpdate(atom, update, store);
+// src/mutable/get-json-token.ts
+var getJsonToken = (mutableAtomToken) => {
+  const key = mutableAtomToken.family ? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})` : `${mutableAtomToken.key}:JSON`;
+  const jsonToken = { type: `selector`, key };
+  if (mutableAtomToken.family) {
+    jsonToken.family = {
+      key: `${mutableAtomToken.family.key}:JSON`,
+      subKey: mutableAtomToken.family.subKey
+    };
   }
+  return jsonToken;
 };
 
-// src/set-state/set-atom-or-selector.ts
-var setAtomOrSelector = (state, value, store) => {
-  if (state.type === `selector`) {
-    state.set(value);
-  } else {
-    setAtom(state, value, store);
+// src/mutable/get-update-token.ts
+var getUpdateToken = (mutableAtomToken) => {
+  const key = `*${mutableAtomToken.key}`;
+  const updateToken = { type: `atom`, key };
+  if (mutableAtomToken.family) {
+    updateToken.family = {
+      key: `*${mutableAtomToken.family.key}`,
+      subKey: mutableAtomToken.family.subKey
+    };
   }
+  return updateToken;
 };
 
-// src/keys.ts
-var isAtomKey = (key, store) => target(store).atoms.has(key);
-var isSelectorKey = (key, store) => target(store).selectors.has(key);
-var isReadonlySelectorKey = (key, store) => target(store).readonlySelectors.has(key);
-var isStateKey = (key, store) => isAtomKey(key, store) || isSelectorKey(key, store) || isReadonlySelectorKey(key, store);
+// src/mutable/is-atom-token-mutable.ts
+function isAtomTokenMutable(token) {
+  return token.key.endsWith(`::mutable`);
+}
 
-// src/selector/get-selector-dependency-keys.ts
-var getSelectorDependencyKeys = (key, store) => {
-  const sources = target(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(source, store));
-  return sources;
-};
+// src/mutable/transceiver.ts
+function isTransceiver(value) {
+  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+}
 
-// src/selector/trace-selector-atoms.ts
-var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
-  const rootKeys = [];
-  const indirectDependencyKeys = getSelectorDependencyKeys(
-    directDependencyKey,
-    store
-  );
-  let depth = 0;
-  while (indirectDependencyKeys.length > 0) {
-    const indirectDependencyKey = indirectDependencyKeys.shift();
-    ++depth;
-    if (depth > 99999) {
-      throw new Error(
-        `Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`
-      );
-    }
-    if (!isAtomKey(indirectDependencyKey, store)) {
-      indirectDependencyKeys.push(
-        ...getSelectorDependencyKeys(indirectDependencyKey, store)
-      );
-    } else if (!rootKeys.includes(indirectDependencyKey)) {
-      rootKeys.push(indirectDependencyKey);
-    }
-  }
-  return rootKeys;
+// src/mutable/index.ts
+var isAtomMutable = (atom) => `isMutable` in atom;
+
+// src/atom/is-default.ts
+var isAtomDefault = (key, store) => {
+  const core = newest(store);
+  return core.atomsThatAreDefault.has(key);
 };
-var traceAllSelectorAtoms = (selectorKey, store) => {
-  const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
-  return directDependencyKeys.flatMap(
-    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(selectorKey, depKey, store)
-  );
+var markAtomAsDefault = (key, store) => {
+  const core = newest(store);
+  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
 };
-
-// src/selector/update-selector-atoms.ts
-var updateSelectorAtoms = (selectorKey, dependency, store) => {
-  const core = target(store);
-  if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: dependency.key
-    });
-    store.logger.info(
-      `\u{1F50D}`,
-      `selector`,
-      selectorKey,
-      `discovers root atom "${dependency.key}"`
-    );
-  } else {
-    const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store);
-    store.logger.info(
-      `\u{1F50D}`,
-      `selector`,
-      selectorKey,
-      `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`
-    );
-    for (const atomKey of rootKeys) {
-      core.selectorAtoms = core.selectorAtoms.set({
-        selectorKey,
-        atomKey
-      });
-    }
-  }
+var markAtomAsNotDefault = (key, store) => {
+  const core = newest(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));
 };
 
-// src/selector/register-selector.ts
-var registerSelector = (selectorKey, store) => ({
-  get: (dependency) => {
-    const core = target(store);
-    const alreadyRegistered = core.selectorGraph.getRelationEntries({ downstreamSelectorKey: selectorKey }).some(([_, { source }]) => source === dependency.key);
-    const dependencyState = withdraw(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?`
-      );
-    }
-    const dependencyValue = readOrComputeValue(dependencyState, store);
-    store.logger.info(
-      `\u{1F50C}`,
-      `selector`,
-      selectorKey,
-      `registers dependency ( "${dependency.key}" =`,
-      dependencyValue,
-      `)`
-    );
-    if (!alreadyRegistered) {
-      core.selectorGraph = core.selectorGraph.set(
-        {
-          upstreamSelectorKey: dependency.key,
-          downstreamSelectorKey: selectorKey
-        },
-        {
-          source: dependency.key
-        }
-      );
-    }
-    updateSelectorAtoms(selectorKey, dependency, store);
-    return dependencyValue;
-  },
-  set: (stateToken, newValue) => {
-    const state = withdraw(stateToken, store);
-    if (state === void 0) {
-      throw new Error(
-        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      );
-    }
-    setAtomOrSelector(state, newValue, store);
-  }
-});
-
-// src/selector/create-read-write-selector.ts
-var createReadWriteSelector = (options, family, store, core) => {
-  const subject = new Subject();
-  const { get, set } = registerSelector(options.key, store);
-  const getSelf = () => {
-    const value = options.get({ get });
-    cacheValue(options.key, value, subject, store);
-    return value;
-  };
-  const setSelf = (next) => {
-    const oldValue = getSelf();
-    const newValue = become(next)(oldValue);
-    store.logger.info(
-      `\u{1F4DD}`,
-      `selector`,
+// src/atom/create-atom.ts
+function createAtom(options, family, store) {
+  store.logger.info(
+    `\u{1F528}`,
+    `atom`,
+    options.key,
+    `creating in store "${store.config.name}"`
+  );
+  const target = newest(store);
+  const existing = target.atoms.get(options.key);
+  if (existing) {
+    store.logger.error(
+      `\u274C`,
+      `atom`,
       options.key,
-      `set (`,
-      oldValue,
-      `->`,
-      newValue,
-      `)`
+      `Tried to create atom, but it already exists in the store.`,
+      `(Ignore if you are in development using hot module replacement.)`
     );
-    cacheValue(options.key, newValue, subject, store);
-    markDone(options.key, store);
-    if (store.transactionStatus.phase === `idle`) {
-      subject.next({ newValue, oldValue });
-    }
-    options.set({ get, set }, newValue);
-  };
-  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
-    subject,
-    install: (s) => createSelector(options, family, s),
-    get: getSelf,
-    set: setSelf,
-    type: `selector`
-  }), family && { family });
-  core.selectors.set(options.key, mySelector);
-  const initialValue = getSelf();
-  store.logger.info(`\u2728`, mySelector.type, mySelector.key, `=`, initialValue);
-  const token = {
-    key: options.key,
-    type: `selector`
-  };
-  if (family) {
-    token.family = family;
+    return deposit(existing);
   }
-  store.subject.selectorCreation.next(token);
-  return token;
-};
-
-// src/selector/create-readonly-selector.ts
-var createReadonlySelector = (options, family, store, core) => {
   const subject = new Subject();
-  const { get } = registerSelector(options.key, store);
-  const getSelf = () => {
-    const value = options.get({ get });
-    cacheValue(options.key, value, subject, store);
-    return value;
-  };
-  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
-    subject,
-    install: (s) => createSelector(options, family, s),
-    get: getSelf,
-    type: `readonly_selector`
+  const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    type: `atom`,
+    install: (store2) => {
+      store2.logger.info(
+        `\u{1F6E0}\uFE0F`,
+        `atom`,
+        options.key,
+        `installing in store "${store2.config.name}"`
+      );
+      return `mutable` in options ? createMutableAtom(options, store2) : createAtom(options, void 0, store2);
+    },
+    subject
   }), family && { family });
-  core.readonlySelectors.set(options.key, readonlySelector);
-  const initialValue = getSelf();
-  store.logger.info(
-    `\u2728`,
-    readonlySelector.type,
-    readonlySelector.key,
-    `=`,
-    initialValue
-  );
-  const token = {
-    key: options.key,
-    type: `readonly_selector`
-  };
-  if (family) {
-    token.family = family;
+  let initialValue = options.default;
+  if (options.default instanceof Function) {
+    initialValue = options.default();
   }
-  store.subject.selectorCreation.next(token);
+  target.atoms.set(newAtom.key, newAtom);
+  markAtomAsDefault(options.key, store);
+  cacheValue(options.key, initialValue, subject, store);
+  const token = deposit(newAtom);
+  if (options.effects) {
+    let effectIndex = 0;
+    const cleanupFunctions = [];
+    for (const effect of options.effects) {
+      const cleanup = effect({
+        setSelf: (next) => atom_io.setState(token, next, store),
+        onSet: (handle) => atom_io.subscribe(token, handle, `effect[${effectIndex}]`, store)
+      });
+      if (cleanup) {
+        cleanupFunctions.push(cleanup);
+      }
+      ++effectIndex;
+    }
+    newAtom.cleanup = () => {
+      for (const cleanup of cleanupFunctions) {
+        cleanup();
+      }
+    };
+  }
+  store.subject.atomCreation.next(token);
   return token;
-};
+}
 
-// src/selector/create-selector.ts
-function createSelector(options, family, store) {
-  const core = target(store);
-  const existingWritable = core.selectors.get(options.key);
-  const existingReadonly = core.readonlySelectors.get(options.key);
-  if (existingWritable || existingReadonly) {
+// src/atom/delete-atom.ts
+function deleteAtom(atomToken, store) {
+  var _a, _b;
+  const target = newest(store);
+  const { key } = atomToken;
+  const atom = target.atoms.get(key);
+  if (!atom) {
     store.logger.error(
       `\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.)`
+      `atom`,
+      `${key}`,
+      `Tried to delete atom, but it does not exist in the store.`
     );
   }
-  if (`set` in options) {
-    return createReadWriteSelector(options, family, store, core);
+  (_a = atom == null ? void 0 : atom.cleanup) == null ? void 0 : _a.call(atom);
+  target.atoms.delete(key);
+  target.valueMap.delete(key);
+  const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
+  if (selectorKeys) {
+    for (const selectorKey of selectorKeys) {
+      const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
+      if (token) {
+        deleteSelector(token, store);
+      }
+    }
   }
-  return createReadonlySelector(options, family, store, core);
+  target.selectorAtoms.delete(key);
+  target.atomsThatAreDefault.delete(key);
+  target.timelineAtoms.delete(key);
+  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
-// src/selector/delete-selector.ts
-function deleteSelector(selectorToken, store) {
-  const core = target(store);
-  const { key } = selectorToken;
-  switch (selectorToken.type) {
-    case `selector`:
-      core.selectors.delete(key);
-      break;
-    case `readonly_selector`:
-      core.readonlySelectors.delete(key);
-      break;
-  }
-  core.valueMap.delete(key);
-  core.selectorAtoms.delete(key);
-  const downstreamTokens = core.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
-    ([downstreamSelectorKey]) => {
-      var _a;
-      return (_a = core.selectors.get(downstreamSelectorKey)) != null ? _a : core.readonlySelectors.get(downstreamSelectorKey);
+// src/lazy-map.ts
+var LazyMap = class extends Map {
+  constructor(source) {
+    super();
+    this.source = source;
+    this.deleted = /* @__PURE__ */ new Set();
+  }
+  get(key) {
+    const has = super.has(key);
+    if (has) {
+      return super.get(key);
     }
-  );
-  for (const downstreamToken of downstreamTokens) {
-    if (downstreamToken) {
-      deleteSelector(downstreamToken, store);
+    if (!this.deleted.has(key) && this.source.has(key)) {
+      const value = this.source.get(key);
+      return value;
     }
+    return void 0;
   }
-  core.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
+  set(key, value) {
+    this.deleted.delete(key);
+    return super.set(key, value);
+  }
+  hasOwn(key) {
+    return super.has(key);
+  }
+  has(key) {
+    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+  }
+  delete(key) {
+    this.deleted.add(key);
+    return super.delete(key);
+  }
+};
+
+// 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}".`
+    );
+  }
+};
 
-// src/families/create-readonly-selector-family.ts
-function createReadonlySelectorFamily(options, store) {
-  const core = target(store);
-  const subject = new Subject();
-  return Object.assign(
-    (key) => {
-      const subKey = json.stringifyJson(key);
-      const family = { key: options.key, subKey };
-      const fullKey = `${options.key}(${subKey})`;
-      const existing = core.readonlySelectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
+// src/subscribe/recall-state.ts
+var recallState = (state, store) => {
+  const target = newest(store);
+  if (!target.operation.open) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      state.type,
+      state.key,
+      `recall called outside of an operation. This is probably a bug.`
+    );
+    return target.valueMap.get(state.key);
+  }
+  return target.operation.prev.get(state.key);
+};
+
+// src/subscribe/subscribe-to-root-atoms.ts
+var subscribeToRootAtoms = (state, store) => {
+  const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomKey) => {
+    const atom = store.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}".`
+      );
+    }
+    return atom.subject.subscribe(
+      `${state.type}:${state.key}`,
+      (atomChange) => {
+        store.logger.info(
+          `\u{1F4E2}`,
+          state.type,
+          state.key,
+          `root`,
+          atomKey,
+          `went`,
+          atomChange.oldValue,
+          `->`,
+          atomChange.newValue
+        );
+        const oldValue = recallState(state, store);
+        const newValue = readOrComputeValue(state, store);
+        store.logger.info(
+          `\u2728`,
+          state.type,
+          state.key,
+          `went`,
+          oldValue,
+          `->`,
+          newValue
+        );
+        state.subject.next({ newValue, oldValue });
+      }
+    );
+  });
+  return dependencySubscriptions;
+};
+
+// src/timeline/add-atom-to-timeline.ts
+var addAtomToTimeline = (atomToken, tl, store) => {
+  const atom = withdraw(atomToken, store);
+  if (atom === void 0) {
+    throw new Error(
+      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
+    );
+  }
+  atom.subject.subscribe(`timeline`, (update) => {
+    var _a, _b, _c, _d, _e, _f;
+    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.subject.transactionApplying.state) == null ? void 0 : _a.update.key;
+    const currentTransactionTime = (_b = target.subject.transactionApplying.state) == null ? void 0 : _b.time;
+    store.logger.info(
+      `\u23F3`,
+      `timeline`,
+      tl.key,
+      `atom`,
+      atomToken.key,
+      `went`,
+      update.oldValue,
+      `->`,
+      update.newValue,
+      currentTransactionKey ? `in transaction "${currentTransactionKey}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
+    );
+    if (tl.timeTraveling === null) {
+      if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
+        const mostRecentUpdate = tl.history.at(-1);
+        if (mostRecentUpdate === void 0) {
+          throw new Error(
+            `Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`
+          );
+        }
+      }
+      if (currentTransactionKey) {
+        const currentTransaction = withdraw(
+          { key: currentTransactionKey, type: `transaction` },
+          store
+        );
+        if (currentTransaction === void 0) {
+          throw new Error(
+            `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
+          );
+        }
+        if (tl.transactionKey !== currentTransactionKey) {
+          if (tl.transactionKey) {
+            store.logger.error(
+              `\u{1F41E}`,
+              `timeline`,
+              tl.key,
+              `unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`
+            );
+          }
+          tl.transactionKey = currentTransactionKey;
+          const unsubscribe = currentTransaction.subject.subscribe(
+            `timeline:${tl.key}`,
+            (update2) => {
+              var _a2, _b2;
+              unsubscribe();
+              if (tl.timeTraveling === null && currentTransactionTime) {
+                if (tl.at !== tl.history.length) {
+                  tl.history.splice(tl.at);
+                }
+                const filterUpdates = (updates2) => updates2.filter((updateFromTx) => {
+                  const target2 = newest(store);
+                  if (`updates` in updateFromTx) {
+                    return true;
+                  }
+                  const atomOrFamilyKeys = target2.timelineAtoms.getRelatedKeys(tl.key);
+                  return atomOrFamilyKeys ? [...atomOrFamilyKeys].some(
+                    (key) => {
+                      var _a3;
+                      return key === updateFromTx.key || key === ((_a3 = updateFromTx.family) == null ? void 0 : _a3.key);
+                    }
+                  ) : false;
+                }).map((updateFromTx) => {
+                  if (`updates` in updateFromTx) {
+                    return __spreadProps(__spreadValues({}, updateFromTx), {
+                      updates: filterUpdates(updateFromTx.updates)
+                    });
+                  }
+                  return updateFromTx;
+                });
+                const updates = filterUpdates(update2.updates);
+                const timelineTransactionUpdate = __spreadProps(__spreadValues({
+                  type: `transaction_update`,
+                  timestamp: currentTransactionTime
+                }, update2), {
+                  updates
+                });
+                const willCapture = (_b2 = (_a2 = tl.shouldCapture) == null ? void 0 : _a2.call(tl, timelineTransactionUpdate, tl)) != null ? _b2 : true;
+                if (willCapture) {
+                  tl.history.push(timelineTransactionUpdate);
+                  tl.at = tl.history.length;
+                  tl.subject.next(timelineTransactionUpdate);
+                }
+              }
+              tl.transactionKey = null;
+              store.logger.info(
+                `\u231B`,
+                `timeline`,
+                tl.key,
+                `got a transaction_update "${update2.key}"`
+              );
+            }
+          );
+        }
+      } else if (currentSelectorKey && currentSelectorTime) {
+        let latestUpdate = tl.history.at(-1);
+        if (currentSelectorTime !== tl.selectorTime) {
+          latestUpdate = {
+            type: `selector_update`,
+            timestamp: currentSelectorTime,
+            key: currentSelectorKey,
+            atomUpdates: []
+          };
+          latestUpdate.atomUpdates.push(__spreadValues({
+            key: atom.key,
+            type: `atom_update`
+          }, update));
+          if (tl.at !== tl.history.length) {
+            tl.history.splice(tl.at);
+          }
+          tl.history.push(latestUpdate);
+          store.logger.info(
+            `\u231B`,
+            `timeline`,
+            tl.key,
+            `got a selector_update "${currentSelectorKey}" with`,
+            latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+          );
+          tl.at = tl.history.length;
+          tl.selectorTime = currentSelectorTime;
+        } else {
+          if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
+            latestUpdate.atomUpdates.push(__spreadValues({
+              key: atom.key,
+              type: `atom_update`
+            }, update));
+            store.logger.info(
+              `\u231B`,
+              `timeline`,
+              tl.key,
+              `set selector_update "${currentSelectorKey}" to`,
+              latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            );
+          }
+        }
+        if (latestUpdate) {
+          const willCaptureSelectorUpdate = (_d = (_c = tl.shouldCapture) == null ? void 0 : _c.call(tl, latestUpdate, tl)) != null ? _d : true;
+          if (willCaptureSelectorUpdate) {
+            tl.subject.next(latestUpdate);
+          } else {
+            tl.history.pop();
+            tl.at = tl.history.length;
+          }
+        }
+      } else {
+        const timestamp = Date.now();
+        tl.selectorTime = null;
+        if (tl.at !== tl.history.length) {
+          tl.history.splice(tl.at);
+        }
+        const atomUpdate = {
+          type: `atom_update`,
+          timestamp,
+          key: atom.key,
+          oldValue: update.oldValue,
+          newValue: update.newValue
+        };
+        if (atom.family) {
+          atomUpdate.family = atom.family;
+        }
+        const willCapture = (_f = (_e = tl.shouldCapture) == null ? void 0 : _e.call(tl, atomUpdate, tl)) != null ? _f : true;
+        store.logger.info(
+          `\u231B`,
+          `timeline`,
+          tl.key,
+          `got an atom_update to "${atom.key}"`
+        );
+        if (willCapture) {
+          tl.history.push(atomUpdate);
+          tl.at = tl.history.length;
+          tl.subject.next(atomUpdate);
+        }
       }
-      return createSelector(
-        {
-          key: fullKey,
-          get: options.get(key)
-        },
-        family,
-        store
-      );
-    },
-    {
-      key: options.key,
-      type: `readonly_selector_family`,
-      subject
     }
-  );
-}
-function createSelectorFamily(options, store) {
-  const isReadonly = !(`set` in options);
-  if (isReadonly) {
-    return createReadonlySelectorFamily(options, store);
+  });
+};
+
+// src/timeline/create-timeline.ts
+function createTimeline(options, store, data) {
+  var _a, _b;
+  const tl = __spreadProps(__spreadValues({
+    type: `timeline`,
+    key: options.key,
+    at: 0,
+    timeTraveling: null,
+    selectorTime: null,
+    transactionKey: null
+  }, data), {
+    history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
+    install: (store2) => createTimeline(options, store2, tl),
+    subject: new Subject()
+  });
+  if (options.shouldCapture) {
+    tl.shouldCapture = options.shouldCapture;
   }
-  const core = target(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 = core.selectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
-      const token = createSelector(
-        {
-          key: fullKey,
-          get: options.get(key),
-          set: options.set(key)
-        },
-        family,
-        store
+  const target = newest(store);
+  for (const tokenOrFamily of options.atoms) {
+    const timelineKey = target.timelineAtoms.getRelatedKey(tokenOrFamily.key);
+    if (timelineKey) {
+      store.logger.error(
+        `\u274C`,
+        `timeline`,
+        options.key,
+        `Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`
       );
-      subject.next(token);
-      return token;
-    },
-    {
-      key: options.key,
-      type: `selector_family`
+      continue;
     }
-  );
-  core.families.set(options.key, selectorFamily);
-  return selectorFamily;
-}
-
-// src/mutable/tracker-family.ts
-var FamilyTracker = class {
-  constructor(findMutableState, store) {
-    this.findLatestUpdateState = createAtomFamily(
-      {
-        key: `*${findMutableState.key}`,
-        default: null
-      },
-      store
-    );
-    this.findMutableState = findMutableState;
-    this.findMutableState.subject.subscribe(
-      `store=${store.config.name}::tracker-atom-family`,
-      (atomToken) => {
-        if (atomToken.family) {
-          const key = json.parseJson(atomToken.family.subKey);
-          this.findLatestUpdateState(key);
-          new Tracker(atomToken, store);
+    if (tokenOrFamily.type === `atom_family`) {
+      const family = tokenOrFamily;
+      family.subject.subscribe(`timeline:${options.key}`, (token2) => {
+        addAtomToTimeline(token2, tl, store);
+      });
+      for (const atom of target.atoms.values()) {
+        if (((_b = atom.family) == null ? void 0 : _b.key) === family.key) {
+          addAtomToTimeline(atom, tl, store);
         }
       }
-    );
-    this.findLatestUpdateState.subject.subscribe(
-      `store=${store.config.name}::tracker-atom-family`,
-      (atomToken) => {
-        if (atomToken.family) {
-          const key = json.parseJson(atomToken.family.subKey);
-          const mutableAtomToken = this.findMutableState(key);
-          new Tracker(mutableAtomToken, store);
+    } else {
+      const token2 = tokenOrFamily;
+      if (`family` in token2 && token2.family) {
+        const familyTimelineKey = target.timelineAtoms.getRelatedKey(
+          token2.family.key
+        );
+        if (familyTimelineKey) {
+          store.logger.error(
+            `\u274C`,
+            `timeline`,
+            options.key,
+            `Failed to add atom "${token2.key}" because its family "${token2.family.key}" already belongs to timeline "${familyTimelineKey}"`
+          );
+          continue;
         }
       }
-    );
-  }
-};
-
-// src/mutable/create-mutable-atom-family.ts
-function createMutableAtomFamily(options, store) {
-  const coreFamily = Object.assign(
-    createAtomFamily(options, store),
-    options
-  );
-  json.selectJsonFamily(coreFamily, options);
-  new FamilyTracker(coreFamily, store);
-  return coreFamily;
-}
-
-// src/mutable/get-json-family.ts
-var getJsonFamily = (mutableAtomFamily, store) => {
-  const core = target(store);
-  const key = `${mutableAtomFamily.key}:JSON`;
-  const jsonFamily = core.families.get(
-    key
-  );
-  return jsonFamily;
-};
-
-// src/mutable/get-json-token.ts
-var getJsonToken = (mutableAtomToken) => {
-  const key = mutableAtomToken.family ? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})` : `${mutableAtomToken.key}:JSON`;
-  const jsonToken = { type: `selector`, key };
-  if (mutableAtomToken.family) {
-    jsonToken.family = {
-      key: `${mutableAtomToken.family.key}:JSON`,
-      subKey: mutableAtomToken.family.subKey
-    };
-  }
-  return jsonToken;
-};
-
-// src/mutable/get-update-token.ts
-var getUpdateToken = (mutableAtomToken) => {
-  const key = `*${mutableAtomToken.key}`;
-  const updateToken = { type: `atom`, key };
-  if (mutableAtomToken.family) {
-    updateToken.family = {
-      key: `*${mutableAtomToken.family.key}`,
-      subKey: mutableAtomToken.family.subKey
-    };
+      addAtomToTimeline(token2, tl, store);
+    }
+    target.timelineAtoms = target.timelineAtoms.set({
+      atomKey: tokenOrFamily.key,
+      timelineKey: options.key
+    });
   }
-  return updateToken;
-};
-
-// src/mutable/is-atom-token-mutable.ts
-function isAtomTokenMutable(token) {
-  return token.key.endsWith(`::mutable`);
-}
-
-// src/mutable/transceiver.ts
-function isTransceiver(value) {
-  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+  store.timelines.set(options.key, tl);
+  const token = {
+    key: options.key,
+    type: `timeline`
+  };
+  store.subject.timelineCreation.next(token);
+  return token;
 }
-
-// src/mutable/index.ts
-var isAtomMutable = (atom) => `isMutable` in atom;
-
-// src/atom/is-default.ts
-var isAtomDefault = (key, store) => {
-  const core = target(store);
-  return core.atomsThatAreDefault.has(key);
-};
-var markAtomAsDefault = (key, store) => {
-  const core = target(store);
-  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
-};
-var markAtomAsNotDefault = (key, store) => {
-  const core = target(store);
-  core.atomsThatAreDefault = new Set(target(store).atomsThatAreDefault);
-  core.atomsThatAreDefault.delete(key);
-};
-var isSelectorDefault = (key, store) => {
-  const rootKeys = traceAllSelectorAtoms(key, store);
-  return rootKeys.every((rootKey) => isAtomDefault(rootKey, store));
-};
-
-// src/atom/create-atom.ts
-function createAtom(options, family, store) {
+var timeTravel = (direction, token, store) => {
+  const action = direction === `forward` ? `redo` : `undo`;
   store.logger.info(
-    `\u{1F528}`,
-    `atom`,
-    options.key,
-    `creating in store "${store.config.name}"`
+    direction === `forward` ? `\u23E9` : `\u23EA`,
+    `timeline`,
+    token.key,
+    action
   );
-  const core = target(store);
-  const existing = core.atoms.get(options.key);
-  if (existing) {
-    store.logger.error(
-      `\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.)`
+  const timelineData = store.timelines.get(token.key);
+  if (!timelineData) {
+    store.logger.error(
+      `\u{1F41E}`,
+      `timeline`,
+      token.key,
+      `Failed to ${action}. This timeline has not been initialized.`
     );
-    return deposit(existing);
+    return;
   }
-  const subject = new Subject();
-  const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
-    type: `atom`,
-    install: (store2) => {
-      store2.logger.info(
-        `\u{1F6E0}\uFE0F`,
-        `atom`,
-        options.key,
-        `installing in store "${store2.config.name}"`
-      );
-      return `mutable` in options ? createMutableAtom(options, store2) : createAtom(options, void 0, store2);
-    },
-    subject
-  }), family && { family });
-  let initialValue = options.default;
-  if (options.default instanceof Function) {
-    initialValue = options.default();
+  if (direction === `forward` && timelineData.at === timelineData.history.length || direction === `backward` && timelineData.at === 0) {
+    store.logger.warn(
+      `\u{1F481}`,
+      `timeline`,
+      token.key,
+      `Failed to ${action} at the ${direction === `forward` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`
+    );
+    return;
   }
-  core.atoms.set(newAtom.key, newAtom);
-  markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, subject, store);
-  const token = deposit(newAtom);
-  if (options.effects) {
-    let effectIndex = 0;
-    const cleanupFunctions = [];
-    for (const effect of options.effects) {
-      const cleanup = effect({
-        setSelf: (next) => atom_io.setState(token, next, store),
-        onSet: (handle) => atom_io.subscribe(token, handle, `effect[${effectIndex}]`, store)
-      });
-      if (cleanup) {
-        cleanupFunctions.push(cleanup);
+  timelineData.timeTraveling = direction === `forward` ? `into_future` : `into_past`;
+  if (direction === `backward`) {
+    --timelineData.at;
+  }
+  const update = timelineData.history[timelineData.at];
+  const updateValues = (atomUpdate) => {
+    const { key, newValue, oldValue } = atomUpdate;
+    const value = direction === `forward` ? newValue : oldValue;
+    atom_io.setState({ key, type: `atom` }, value, store);
+  };
+  const updateValuesFromTransactionUpdate = (transactionUpdate) => {
+    const updates = direction === `forward` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
+    for (const updateFromTransaction of updates) {
+      if (`newValue` in updateFromTransaction) {
+        updateValues(updateFromTransaction);
+      } else {
+        updateValuesFromTransactionUpdate(updateFromTransaction);
       }
-      ++effectIndex;
     }
-    newAtom.cleanup = () => {
-      for (const cleanup of cleanupFunctions) {
-        cleanup();
+  };
+  switch (update.type) {
+    case `atom_update`: {
+      updateValues(update);
+      break;
+    }
+    case `selector_update`: {
+      const updates = direction === `forward` ? update.atomUpdates : [...update.atomUpdates].reverse();
+      for (const atomUpdate of updates) {
+        updateValues(atomUpdate);
       }
-    };
+      break;
+    }
+    case `transaction_update`: {
+      updateValuesFromTransactionUpdate(update);
+      break;
+    }
   }
-  store.subject.atomCreation.next(token);
-  return token;
-}
+  if (direction === `forward`) {
+    ++timelineData.at;
+  }
+  timelineData.subject.next(action);
+  timelineData.timeTraveling = null;
+  store.logger.info(
+    `\u23F9\uFE0F`,
+    `timeline`,
+    token.key,
+    `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  );
+};
 
-// src/atom/delete-atom.ts
-function deleteAtom(atomToken, store) {
-  var _a, _b;
-  const core = target(store);
-  const { key } = atomToken;
-  const atom = core.atoms.get(key);
-  if (!atom) {
-    store.logger.error(
-      `\u274C`,
-      `atom`,
-      `${key}`,
-      `Tried to delete atom, but it does not exist in the store.`
+// src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  const target = newest(store);
+  if (target.transactionMeta === null || target.parent === null) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
     );
+    return;
   }
-  (_a = atom == null ? void 0 : atom.cleanup) == null ? void 0 : _a.call(atom);
-  core.atoms.delete(key);
-  core.valueMap.delete(key);
-  const selectorKeys = core.selectorAtoms.getRelatedKeys(key);
-  if (selectorKeys) {
-    for (const selectorKey of selectorKeys) {
-      const token = (_b = core.selectors.get(selectorKey)) != null ? _b : core.readonlySelectors.get(selectorKey);
-      if (token) {
-        deleteSelector(token, store);
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
+  );
+  target.parent.child = null;
+};
+function ingestAtomUpdate(update, parent, child) {
+  var _a, _b, _c;
+  const { key, newValue } = update;
+  const token = { key, type: `atom` };
+  if (!parent.valueMap.has(token.key)) {
+    if (token.family) {
+      const family = parent.families.get(token.family.key);
+      if (family) {
+        family(token.family.subKey);
+      }
+    } else {
+      const newAtom = child.atoms.get(token.key);
+      if (!newAtom) {
+        throw new Error(
+          `Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${(_a = child.transactionMeta) == null ? void 0 : _a.update.key}" to store "${parent.config.name}"`
+        );
       }
+      parent.atoms.set(newAtom.key, newAtom);
+      parent.valueMap.set(newAtom.key, newAtom.default);
+      parent.logger.info(
+        `\u{1F528}`,
+        `transaction`,
+        (_c = (_b = child.transactionMeta) == null ? void 0 : _b.update.key) != null ? _c : `???`,
+        `Adding atom "${newAtom.key}"`
+      );
     }
   }
-  core.selectorAtoms.delete(key);
-  core.atomsThatAreDefault.delete(key);
-  core.timelineAtoms.delete(key);
-  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
+  atom_io.setState(token, newValue, parent);
 }
-
-// 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`;
+function ingestTransactionUpdate(transactionUpdate, parent, child) {
+  for (const update of transactionUpdate.updates) {
+    if (`newValue` in update) {
+      ingestAtomUpdate(update, parent, child);
+    } else {
+      ingestTransactionUpdate(update, parent, child);
+    }
   }
-  return capitalize(token.type);
 }
-var NotFoundError = class extends Error {
-  constructor(token, store) {
-    super(
-      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
-    );
-  }
-};
-
-// src/subscribe/recall-state.ts
-var recallState = (state, store) => {
-  const core = target(store);
-  if (!core.operation.open) {
+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`) {
     store.logger.warn(
       `\u{1F41E}`,
-      state.type,
-      state.key,
-      `recall called outside of an operation. This is probably a bug.`
+      `transaction`,
+      `???`,
+      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
+  }
+  child.transactionMeta.phase = `applying`;
+  child.transactionMeta.update.output = output;
+  parent.child = null;
+  parent.subject.transactionApplying.next(child.transactionMeta);
+  const { updates } = child.transactionMeta.update;
+  store.logger.info(
+    `\u{1F6C4}`,
+    `transaction`,
+    child.transactionMeta.update.key,
+    `Applying transaction with ${updates.length} updates:`,
+    updates
+  );
+  if (parent.transactionMeta === null) {
+    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
+    const myTransaction = withdraw(
+      { key: child.transactionMeta.update.key, type: `transaction` },
+      store
+    );
+    myTransaction == null ? void 0 : myTransaction.subject.next(child.transactionMeta.update);
+    store.logger.info(
+      `\u{1F6EC}`,
+      `transaction`,
+      child.transactionMeta.update.key,
+      `Finished applying transaction.`
     );
-    return core.valueMap.get(state.key);
+  } else {
+    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
+    parent.transactionMeta.update.updates.push(child.transactionMeta.update);
   }
-  return core.operation.prev.get(state.key);
+  parent.subject.transactionApplying.next(null);
 };
 
-// src/subscribe/subscribe-to-root-atoms.ts
-var subscribeToRootAtoms = (state, store) => {
-  const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomKey) => {
-    const atom = store.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}".`
-      );
-    }
-    return atom.subject.subscribe(
-      `${state.type}:${state.key}`,
-      (atomChange) => {
-        store.logger.info(
-          `\u{1F4E2}`,
-          state.type,
-          state.key,
-          `root`,
-          atomKey,
-          `went`,
-          atomChange.oldValue,
-          `->`,
-          atomChange.newValue
+// src/transaction/build-transaction.ts
+var buildTransaction = (key, params, store) => {
+  const parent = newest(store);
+  parent.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
+      }
+    },
+    atoms: new LazyMap(parent.atoms),
+    atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
+    families: new LazyMap(parent.families),
+    operation: { open: false },
+    readonlySelectors: new LazyMap(parent.readonlySelectors),
+    timelines: new LazyMap(parent.timelines),
+    timelineAtoms: new Junction(parent.timelineAtoms.toJSON()),
+    trackers: /* @__PURE__ */ new Map(),
+    transactions: new LazyMap(parent.transactions),
+    selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
+    selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
+      makeContentKey: (...keys) => keys.sort().join(`:`)
+    }),
+    selectors: new LazyMap(parent.selectors),
+    valueMap: new LazyMap(parent.valueMap)
+  };
+  store.logger.info(
+    `\u{1F6EB}`,
+    `transaction`,
+    key,
+    `Building transaction with params:`,
+    params
+  );
+};
+function createTransaction(options, store) {
+  const newTransaction = {
+    key: options.key,
+    type: `transaction`,
+    run: (...params) => {
+      buildTransaction(options.key, params, store);
+      try {
+        const output = options.do(
+          {
+            get: (token2) => atom_io.getState(token2, store),
+            set: (token2, value) => atom_io.setState(token2, value, store),
+            run: (token2) => atom_io.runTransaction(token2, store)
+          },
+          ...params
         );
-        const oldValue = recallState(state, store);
-        const newValue = readOrComputeValue(state, store);
-        store.logger.info(
-          `\u2728`,
-          state.type,
-          state.key,
-          `went`,
-          oldValue,
-          `->`,
-          newValue
+        applyTransaction(output, store);
+        return output;
+      } catch (thrown) {
+        abortTransaction(store);
+        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
+        throw thrown;
+      }
+    },
+    install: (store2) => createTransaction(options, store2),
+    subject: new Subject()
+  };
+  const target = newest(store);
+  target.transactions.set(newTransaction.key, newTransaction);
+  const token = deposit(newTransaction);
+  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.`
         );
-        state.subject.next({ newValue, oldValue });
       }
-    );
-  });
-  return dependencySubscriptions;
+      atom_io.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.`
+        );
+      }
+      atom_io.setState(state, newValue, store);
+    } else {
+      undoTransactionUpdate(update, store);
+    }
+  }
 };
 
+// src/transaction/index.ts
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+
 exports.FamilyTracker = FamilyTracker;
 exports.Future = Future;
 exports.IMPLICIT = IMPLICIT;
+exports.LazyMap = LazyMap;
 exports.NotFoundError = NotFoundError;
+exports.StatefulSubject = StatefulSubject;
 exports.Store = Store;
 exports.Subject = Subject;
 exports.TRANSACTION_PHASES = TRANSACTION_PHASES;
@@ -2120,6 +2200,7 @@ exports.createTransaction = createTransaction;
 exports.deleteAtom = deleteAtom;
 exports.deleteSelector = deleteSelector;
 exports.deposit = deposit;
+exports.eldest = eldest;
 exports.evictCachedValue = evictCachedValue;
 exports.getJsonFamily = getJsonFamily;
 exports.getJsonToken = getJsonToken;
@@ -2139,6 +2220,7 @@ exports.isValueCached = isValueCached;
 exports.markAtomAsDefault = markAtomAsDefault;
 exports.markAtomAsNotDefault = markAtomAsNotDefault;
 exports.markDone = markDone;
+exports.newest = newest;
 exports.openOperation = openOperation;
 exports.readCachedValue = readCachedValue;
 exports.readOrComputeValue = readOrComputeValue;
@@ -2146,7 +2228,6 @@ exports.redoTransactionUpdate = redoTransactionUpdate;
 exports.registerSelector = registerSelector;
 exports.setAtomOrSelector = setAtomOrSelector;
 exports.subscribeToRootAtoms = subscribeToRootAtoms;
-exports.target = target;
 exports.timeTravel = timeTravel;
 exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
 exports.traceSelectorAtoms = traceSelectorAtoms;