atom.io 0.11.0 → 0.12.1

package/internal/dist/{index.mjs → index.cjs}

@@ -1,5 +1,7 @@
-import { AtomIOLogger, setState, getState, subscribe, subscribeToTimeline } from 'atom.io';
-import { selectJson, stringifyJson, parseJson, selectJsonFamily } from 'atom.io/json';
+'use strict';
+
+var atom_io = require('atom.io');
+var json = require('atom.io/json');
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -40,6 +42,26 @@ 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.`
+    );
+    return;
+  }
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    store.transactionStatus.key,
+    `Aborting transaction`
+  );
+  store.transactionStatus = { phase: `idle` };
+};
+
 // src/store/deposit.ts
 function deposit(state) {
   const token = {
@@ -58,12 +80,14 @@ var Junction = class {
     this.relations = /* @__PURE__ */ new Map();
     this.contents = /* @__PURE__ */ new Map();
     this.makeContentKey = (a, b) => `${a}:${b}`;
-    var _a, _b;
+    var _a, _b, _c, _d;
     this.a = data.between[0];
     this.b = data.between[1];
     this.cardinality = data.cardinality;
-    this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
-    this.contents = new Map(data.contents);
+    if (!(config == null ? void 0 : config.externalStore)) {
+      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
+      this.contents = new Map(data.contents);
+    }
     this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
     if (config == null ? void 0 : config.makeContentKey) {
       this.makeContentKey = config.makeContentKey;
@@ -73,11 +97,15 @@ var Junction = class {
       this.has = (a, b) => externalStore.has(a, b);
       this.addRelation = (a, b) => {
         externalStore.addRelation(a, b);
-        return this;
       };
       this.deleteRelation = (a, b) => {
         externalStore.deleteRelation(a, b);
-        return this;
+      };
+      this.replaceRelationsSafely = (a, bs) => {
+        externalStore.replaceRelationsSafely(a, bs);
+      };
+      this.replaceRelationsUnsafely = (a, bs) => {
+        externalStore.replaceRelationsUnsafely(a, bs);
       };
       this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
       if (externalStore.getContent) {
@@ -86,30 +114,37 @@ var Junction = class {
         };
         this.setContent = (contentKey, content) => {
           externalStore.setContent(contentKey, content);
-          return this;
         };
         this.deleteContent = (contentKey) => {
           externalStore.deleteContent(contentKey);
-          return this;
         };
       }
+      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
+        for (const y of ys)
+          this.addRelation(x, y);
+      }
+      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
+        this.setContent(contentKey, content);
+      }
     }
   }
   getRelatedKeys(key) {
     return this.relations.get(key);
   }
   addRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    const bRelations = this.relations.get(b);
+    let aRelations = this.relations.get(a);
+    let bRelations = this.relations.get(b);
     if (aRelations) {
       aRelations.add(b);
     } else {
-      this.relations.set(a, /* @__PURE__ */ new Set([b]));
+      aRelations = /* @__PURE__ */ new Set([b]);
+      this.relations.set(a, aRelations);
     }
     if (bRelations) {
       bRelations.add(a);
     } else {
-      this.relations.set(b, /* @__PURE__ */ new Set([a]));
+      bRelations = /* @__PURE__ */ new Set([a]);
+      this.relations.set(b, bRelations);
     }
   }
   deleteRelation(a, b) {
@@ -128,6 +163,39 @@ var Junction = class {
       }
     }
   }
+  replaceRelationsUnsafely(a, bs) {
+    this.relations.set(a, new Set(bs));
+    for (const b of bs) {
+      const bRelations = /* @__PURE__ */ new Set([a]);
+      this.relations.set(b, bRelations);
+    }
+  }
+  replaceRelationsSafely(a, bs) {
+    const aRelationsPrev = this.relations.get(a);
+    if (aRelationsPrev) {
+      for (const b of aRelationsPrev) {
+        const bRelations = this.relations.get(b);
+        if (bRelations) {
+          if (bRelations.size === 1) {
+            this.relations.delete(b);
+          } else {
+            bRelations.delete(a);
+          }
+          this.contents.delete(this.makeContentKey(a, b));
+        }
+      }
+    }
+    this.relations.set(a, new Set(bs));
+    for (const b of bs) {
+      let bRelations = this.relations.get(b);
+      if (bRelations) {
+        bRelations.add(a);
+      } else {
+        bRelations = /* @__PURE__ */ new Set([a]);
+        this.relations.set(b, bRelations);
+      }
+    }
+  }
   getContentInternal(contentKey) {
     return this.contents.get(contentKey);
   }
@@ -147,10 +215,7 @@ var Junction = class {
   }
   set(a, ...rest) {
     var _a;
-    const b = (
-      // @ts-expect-error we deduce hereby that this.b may index a
-      typeof rest[0] === `string` ? rest[0] : a[this.b]
-    );
+    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
     const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
     a = typeof a === `string` ? a : a[this.a];
     switch (this.cardinality) {
@@ -165,11 +230,11 @@ var Junction = class {
           this.delete(aPrev, b);
       }
     }
-    this.addRelation(a, b);
     if (content) {
       const contentKey = this.makeContentKey(a, b);
       this.setContent(contentKey, content);
     }
+    this.addRelation(a, b);
     return this;
   }
   delete(x, b) {
@@ -213,6 +278,23 @@ var Junction = class {
       }
     }
   }
+  replaceRelations(a, relations, config) {
+    const hasContent = !Array.isArray(relations);
+    const bs = hasContent ? Object.keys(relations) : relations;
+    if (config == null ? void 0 : config.reckless) {
+      this.replaceRelationsUnsafely(a, bs);
+    } else {
+      this.replaceRelationsSafely(a, bs);
+    }
+    if (hasContent) {
+      for (const b of bs) {
+        const contentKey = this.makeContentKey(a, b);
+        const content = relations[b];
+        this.setContent(contentKey, content);
+      }
+    }
+    return this;
+  }
   getContent(a, b) {
     const contentKey = this.makeContentKey(a, b);
     return this.getContentInternal(contentKey);
@@ -312,7 +394,7 @@ var Store = class {
       name: `IMPLICIT_STORE`
     };
     this.loggers = [
-      new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
+      new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
     ];
     this.logger = {
       error: (...messages) => {
@@ -360,209 +442,14 @@ var IMPLICIT = {
     return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
   }
 };
-var clearStore = (store = IMPLICIT.STORE) => {
+var clearStore = (store) => {
   const { config } = store;
   Object.assign(store, new Store(config.name));
   store.config = config;
 };
 
-// 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.`
-    );
-    return;
-  }
-  store.logger.info(
-    `\u{1FA82}`,
-    `transaction`,
-    store.transactionStatus.key,
-    `Aborting transaction`
-  );
-  store.transactionStatus = { phase: `idle` };
-};
-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}"`
-        );
-      }
-    }
-    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?`
-    );
-  }
-  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` };
-};
-
-// 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
-  };
-  store.logger.info(
-    `\u{1F6EB}`,
-    `transaction`,
-    key,
-    `Building transaction with params:`,
-    params
-  );
-};
-
-// src/transaction/transaction-internal.ts
-function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
-  const newTransaction = {
-    key: options.key,
-    type: `transaction`,
-    run: (...params) => {
-      buildTransaction(options.key, params, store);
-      try {
-        const output = options.do(
-          {
-            get: (token2) => getState(token2, store),
-            set: (token2, value) => 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) => transaction__INTERNAL(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 = IMPLICIT.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.`
-      );
-    }
-    setState(state, newValue, store);
-  }
-};
-var undoTransactionUpdate = (update, store) => {
-  store.logger.info(
-    `\u23EE\uFE0F`,
-    `transaction`,
-    update.key,
-    `Undoing transaction update`,
-    update
-  );
-  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.`
-      );
-    }
-    setState(state, oldValue, store);
-  }
-};
-
-// src/transaction/index.ts
-var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
-
 // src/timeline/add-atom-to-timeline.ts
-var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
+var addAtomToTimeline = (atomToken, tl, store) => {
   const atom = withdraw(atomToken, store);
   if (atom === void 0) {
     throw new Error(
@@ -742,105 +629,9 @@ var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
     }
   });
 };
-var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
-  store.logger.info(`\u23E9`, `timeline`, token.key, `redo`);
-  const timelineData = store.timelines.get(token.key);
-  if (!timelineData) {
-    store.logger.error(
-      `\u{1F41E}`,
-      `timeline`,
-      token.key,
-      `Failed to redo. This timeline has not been initialized.`
-    );
-    return;
-  }
-  if (timelineData.at === timelineData.history.length) {
-    store.logger.warn(
-      `\u{1F481}`,
-      `timeline`,
-      token.key,
-      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
-    );
-    return;
-  }
-  timelineData.timeTraveling = `into_future`;
-  const update = timelineData.history[timelineData.at];
-  switch (update.type) {
-    case `atom_update`: {
-      const { key, newValue } = update;
-      setState({ key, type: `atom` }, newValue, store);
-      break;
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of update.atomUpdates) {
-        const { key, newValue } = atomUpdate;
-        setState({ key, type: `atom` }, newValue, store);
-      }
-      break;
-    }
-  }
-  ++timelineData.at;
-  timelineData.subject.next(`redo`);
-  timelineData.timeTraveling = null;
-  store.logger.info(
-    `\u23F9\uFE0F`,
-    `timeline`,
-    token.key,
-    `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  );
-};
-var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
-  store.logger.info(`\u23EA`, `timeline`, token.key, `undo`);
-  const timelineData = store.timelines.get(token.key);
-  if (!timelineData) {
-    store.logger.error(
-      `\u{1F41E}`,
-      `timeline`,
-      token.key,
-      `Failed to undo. This timeline has not been initialized.`
-    );
-    return;
-  }
-  if (timelineData.at === 0) {
-    store.logger.warn(
-      `\u{1F481}`,
-      `timeline`,
-      token.key,
-      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
-    );
-    return;
-  }
-  timelineData.timeTraveling = `into_past`;
-  --timelineData.at;
-  const update = timelineData.history[timelineData.at];
-  switch (update.type) {
-    case `atom_update`: {
-      const { key, oldValue } = update;
-      setState({ key, type: `atom` }, oldValue, store);
-      break;
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of [...update.atomUpdates].reverse()) {
-        const { key, oldValue } = atomUpdate;
-        setState({ key, type: `atom` }, oldValue, store);
-      }
-      break;
-    }
-  }
-  timelineData.subject.next(`undo`);
-  timelineData.timeTraveling = null;
-  store.logger.info(
-    `\u23F9\uFE0F`,
-    `timeline`,
-    token.key,
-    `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  );
-};
 
-// src/timeline/timeline-internal.ts
-function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
+// src/timeline/create-timeline.ts
+function createTimeline(options, store, data) {
   var _a, _b;
   const tl = __spreadProps(__spreadValues({
     type: `timeline`,
@@ -851,7 +642,7 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
     transactionKey: null
   }, data), {
     history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
-    install: (store2) => timeline__INTERNAL(options, store2, tl),
+    install: (store2) => createTimeline(options, store2, tl),
     subject: new Subject()
   });
   if (options.shouldCapture) {
@@ -897,96 +688,365 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
       }
       addAtomToTimeline(token2, tl, store);
     }
-    core.timelineAtoms = core.timelineAtoms.set({
-      atomKey: tokenOrFamily.key,
-      timelineKey: options.key
-    });
+    core.timelineAtoms = core.timelineAtoms.set({
+      atomKey: tokenOrFamily.key,
+      timelineKey: options.key
+    });
+  }
+  store.timelines.set(options.key, tl);
+  const token = {
+    key: options.key,
+    type: `timeline`
+  };
+  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`,
+    token.key,
+    action
+  );
+  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;
+  }
+  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;
+  }
+  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;
+    }
+  }
+  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/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;
+    }
+  }
+  return void 0;
+}
+
+// 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;
+    }
+  }
+  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}"`
+        );
+      }
+    }
+    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?`
+    );
+  }
+  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` };
+};
+
+// 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);
+    }
+    if (!this.deleted.has(key) && this.source.has(key)) {
+      const value = this.source.get(key);
+      super.set(key, value);
+      return value;
+    }
+    return void 0;
   }
-  store.timelines.set(options.key, tl);
-  const token = {
+  _has(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/transaction/build-transaction.ts
+var buildTransaction = (key, params, store) => {
+  store.transactionStatus = {
+    key,
+    phase: `building`,
+    time: Date.now(),
+    core: {
+      atoms: new LazyMap(store.atoms),
+      atomsThatAreDefault: new Set(store.atomsThatAreDefault),
+      families: new LazyMap(store.families),
+      operation: { open: false },
+      readonlySelectors: new LazyMap(store.readonlySelectors),
+      timelines: new LazyMap(store.timelines),
+      timelineAtoms: new Junction(store.timelineAtoms.toJSON()),
+      trackers: /* @__PURE__ */ new Map(),
+      transactions: new LazyMap(store.transactions),
+      selectorAtoms: new Junction(store.selectorAtoms.toJSON()),
+      selectorGraph: new Junction(store.selectorGraph.toJSON(), {
+        makeContentKey: (...keys) => keys.sort().join(`:`)
+      }),
+      selectors: new LazyMap(store.selectors),
+      valueMap: new LazyMap(store.valueMap)
+    },
+    atomUpdates: [],
+    params,
+    output: void 0
+  };
+  store.logger.info(
+    `\u{1F6EB}`,
+    `transaction`,
+    key,
+    `Building transaction with params:`,
+    params
+  );
+};
+function createTransaction(options, store) {
+  const newTransaction = {
     key: options.key,
-    type: `timeline`
+    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()
   };
-  store.subject.timelineCreation.next(token);
+  const core = target(store);
+  core.transactions.set(newTransaction.key, newTransaction);
+  const token = deposit(newTransaction);
+  store.subject.transactionCreation.next(token);
   return token;
 }
-
-// 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}"`
+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.`
       );
-      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;
     }
+    atom_io.setState(state, newValue, store);
   }
-  return void 0;
-}
-
-// src/store/withdraw-new-family-member.ts
-function withdrawNewFamilyMember(token, store) {
+};
+var undoTransactionUpdate = (update, store) => {
   store.logger.info(
-    `\u{1F46A}`,
-    token.type,
-    token.key,
-    `creating new family member in store "${store.config.name}"`
+    `\u23EE\uFE0F`,
+    `transaction`,
+    update.key,
+    `Undoing transaction update`,
+    update
   );
-  if (token.family) {
-    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;
+  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.`
+      );
     }
+    atom_io.setState(state, oldValue, store);
   }
-  return void 0;
-}
+};
+
+// src/transaction/index.ts
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
 // src/caching.ts
-var cacheValue = (key, value, subject, store = IMPLICIT.STORE) => {
+function cacheValue(key, value, subject, store) {
   const currentValue = target(store).valueMap.get(key);
   if (currentValue instanceof Future) {
     currentValue.cancel();
@@ -994,24 +1054,25 @@ var cacheValue = (key, value, subject, store = IMPLICIT.STORE) => {
   if (value instanceof Promise) {
     const future = new Future(value);
     target(store).valueMap.set(key, future);
-    future.then((value2) => {
+    future.then((resolved) => {
       if (future.isCanceled) {
         return;
       }
-      cacheValue(key, value2, subject, store);
-      subject.next({ newValue: value2, oldValue: value2 });
+      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);
       }
     });
-  } else {
-    target(store).valueMap.set(key, value);
+    return future;
   }
-};
-var readCachedValue = (key, store = IMPLICIT.STORE) => target(store).valueMap.get(key);
-var isValueCached = (key, store = IMPLICIT.STORE) => target(store).valueMap.has(key);
-var evictCachedValue = (key, store = IMPLICIT.STORE) => {
+  target(store).valueMap.set(key, value);
+  return value;
+}
+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) {
@@ -1024,7 +1085,7 @@ var evictCachedValue = (key, store = IMPLICIT.STORE) => {
   store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
 };
 var Tracker = class {
-  constructor(mutableState, store = IMPLICIT.STORE) {
+  constructor(mutableState, store) {
     this.unsubscribeFromInnerValue = null;
     this.mutableState = mutableState;
     this.latestUpdateState = this.initializeState(mutableState, store);
@@ -1033,7 +1094,7 @@ var Tracker = class {
     const core = target(store);
     core.trackers.set(mutableState.key, this);
   }
-  initializeState(mutableState, store = IMPLICIT.STORE) {
+  initializeState(mutableState, store) {
     const latestUpdateStateKey = `*${mutableState.key}`;
     deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store);
     const familyMetaData = mutableState.family ? {
@@ -1050,8 +1111,8 @@ var Tracker = class {
     );
     return latestUpdateState;
   }
-  observeCore(mutableState, latestUpdateState, store = IMPLICIT.STORE) {
-    const originalInnerValue = getState(mutableState, store);
+  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) => {
@@ -1059,12 +1120,12 @@ var Tracker = class {
           mutableState.key,
           () => {
             unsubscribe();
-            setState(latestUpdateState, update, store);
+            atom_io.setState(latestUpdateState, update, store);
           }
         );
       }
     );
-    subscribe(
+    atom_io.subscribe(
       mutableState,
       (update) => {
         var _a;
@@ -1077,7 +1138,7 @@ var Tracker = class {
                 mutableState.key,
                 () => {
                   unsubscribe();
-                  setState(latestUpdateState, update2, store);
+                  atom_io.setState(latestUpdateState, update2, store);
                 }
               );
             }
@@ -1088,8 +1149,8 @@ var Tracker = class {
       store
     );
   }
-  updateCore(mutableState, latestUpdateState, store = IMPLICIT.STORE) {
-    subscribe(
+  updateCore(mutableState, latestUpdateState, store) {
+    atom_io.subscribe(
       latestUpdateState,
       ({ newValue, oldValue }) => {
         const timelineId = store.timelineAtoms.getRelatedKey(
@@ -1098,11 +1159,11 @@ var Tracker = class {
         if (timelineId) {
           const timelineData = store.timelines.get(timelineId);
           if (timelineData == null ? void 0 : timelineData.timeTraveling) {
-            const unsubscribe2 = subscribeToTimeline(
+            const unsubscribe2 = atom_io.subscribeToTimeline(
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                setState(
+                atom_io.setState(
                   mutableState,
                   (transceiver) => {
                     if (update === `redo` && newValue) {
@@ -1123,8 +1184,11 @@ var Tracker = class {
           latestUpdateState.key,
           () => {
             unsubscribe();
-            if (newValue) {
-              setState(
+            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
@@ -1140,7 +1204,7 @@ var Tracker = class {
 };
 
 // src/mutable/create-mutable-atom.ts
-function createMutableAtom(options, store = IMPLICIT.STORE) {
+function createMutableAtom(options, store) {
   store.logger.info(
     `\u{1F527}`,
     `atom`,
@@ -1149,8 +1213,8 @@ function createMutableAtom(options, store = IMPLICIT.STORE) {
   );
   const coreState = createAtom(options, void 0, store);
   new Tracker(coreState, store);
-  const jsonState = selectJson(coreState, options, store);
-  subscribe(
+  const jsonState = json.selectJson(coreState, options, store);
+  atom_io.subscribe(
     jsonState,
     () => {
       const trackerHasBeenInitialized = target(store).trackers.has(coreState.key);
@@ -1162,11 +1226,11 @@ function createMutableAtom(options, store = IMPLICIT.STORE) {
   );
   return coreState;
 }
-function createAtomFamily(options, store = IMPLICIT.STORE) {
+function createAtomFamily(options, store) {
   const subject = new Subject();
   const atomFamily = Object.assign(
     (key) => {
-      const subKey = stringifyJson(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);
@@ -1197,37 +1261,6 @@ function createAtomFamily(options, store = IMPLICIT.STORE) {
   return atomFamily;
 }
 
-// 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/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/get-state-internal.ts
-var getState__INTERNAL = (state, store = IMPLICIT.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, `calculating value`);
-    return state.get();
-  }
-  store.logger.error(`\u{1F41E}`, `atom`, state.key, `could not find cached value`);
-  return state.default;
-};
-
-// src/set-state/become.ts
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
-  originalThing instanceof Function ? originalThing() : originalThing
-) : nextVersionOfThing;
-
 // src/operation.ts
 var openOperation = (token, store) => {
   const core = target(store);
@@ -1267,7 +1300,7 @@ var closeOperation = (store) => {
   core.operation = { open: false };
   store.subject.operationStatus.next(core.operation);
 };
-var isDone = (key, store = IMPLICIT.STORE) => {
+var isDone = (key, store) => {
   const core = target(store);
   if (!core.operation.open) {
     store.logger.warn(
@@ -1280,7 +1313,7 @@ var isDone = (key, store = IMPLICIT.STORE) => {
   }
   return core.operation.done.has(key);
 };
-var markDone = (key, store = IMPLICIT.STORE) => {
+var markDone = (key, store) => {
   const core = target(store);
   if (!core.operation.open) {
     store.logger.warn(
@@ -1294,6 +1327,32 @@ var markDone = (key, store = IMPLICIT.STORE) => {
   core.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 (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;
+  store.logger.info(
+    `\u{1F481}`,
+    `atom`,
+    state.key,
+    `could not find cached value; using default`,
+    fallback
+  );
+  return state.default instanceof Function ? state.default() : state.default;
+};
+
 // src/set-state/copy-mutable-if-needed.ts
 function copyMutableIfNeeded(atom, transform, origin, target2) {
   const originValue = origin.valueMap.get(atom.key);
@@ -1309,7 +1368,7 @@ function copyMutableIfNeeded(atom, transform, origin, target2) {
 }
 
 // src/set-state/copy-mutable-in-transaction.ts
-function copyMutableIfWithinTransaction(atom, store) {
+function copyMutableIfWithinTransaction(oldValue, atom, store) {
   if (store.transactionStatus.phase === `building` || store.transactionStatus.phase === `applying`) {
     if (`toJson` in atom && `fromJson` in atom) {
       const copiedValue = copyMutableIfNeeded(
@@ -1335,7 +1394,7 @@ function copyMutableIfWithinTransaction(atom, store) {
       }
     }
   }
-  return getState__INTERNAL(atom, store);
+  return oldValue;
 }
 function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target2) {
   if (`toJson` in family && `fromJson` in family) {
@@ -1347,8 +1406,7 @@ function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target2)
 
 // src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
-  const { logger } = store;
-  logger.info(
+  store.logger.info(
     `\u{1F4E2}`,
     state.type,
     state.key,
@@ -1363,18 +1421,17 @@ var emitUpdate = (state, update, store) => {
 };
 
 // src/set-state/evict-downstream.ts
-var evictDownStream = (atom, store = IMPLICIT.STORE) => {
-  var _a;
+var evictDownStream = (atom, store) => {
   const core = target(store);
   const downstreamKeys = core.selectorAtoms.getRelatedKeys(atom.key);
   store.logger.info(
     `\u{1F9F9}`,
     atom.type,
     atom.key,
-    `evicting ${(_a = downstreamKeys == null ? void 0 : downstreamKeys.size) != null ? _a : 0} states downstream:`,
-    downstreamKeys
+    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
+    downstreamKeys != null ? downstreamKeys : `to evict`
   );
-  if (downstreamKeys !== void 0) {
+  if (downstreamKeys) {
     if (core.operation.open) {
       store.logger.info(
         `\u{1F9F9}`,
@@ -1436,12 +1493,12 @@ var stowUpdate = (state, update, store) => {
 };
 
 // src/set-state/set-atom.ts
-var setAtom = (atom, next, store = IMPLICIT.STORE) => {
-  const oldValue = getState__INTERNAL(atom, store);
-  let newValue = copyMutableIfWithinTransaction(atom, store);
+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);
-  cacheValue(atom.key, newValue, atom.subject, store);
+  newValue = cacheValue(atom.key, newValue, atom.subject, store);
   if (isAtomDefault(atom.key, store)) {
     markAtomAsNotDefault(atom.key, store);
   }
@@ -1455,8 +1512,8 @@ var setAtom = (atom, next, store = IMPLICIT.STORE) => {
   }
 };
 
-// src/set-state/set-state-internal.ts
-var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
+// src/set-state/set-atom-or-selector.ts
+var setAtomOrSelector = (state, value, store) => {
   if (state.type === `selector`) {
     state.set(value);
   } else {
@@ -1464,6 +1521,18 @@ var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
   }
 };
 
+// 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/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/selector/trace-selector-atoms.ts
 var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
   const rootKeys = [];
@@ -1529,7 +1598,7 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 };
 
 // src/selector/register-selector.ts
-var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
+var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
     const core = target(store);
     const alreadyRegistered = core.selectorGraph.getRelationEntries({ downstreamSelectorKey: selectorKey }).some(([_, { source }]) => source === dependency.key);
@@ -1539,7 +1608,7 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
         `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
       );
     }
-    const dependencyValue = getState__INTERNAL(dependencyState, store);
+    const dependencyValue = readOrComputeValue(dependencyState, store);
     store.logger.info(
       `\u{1F50C}`,
       `selector`,
@@ -1569,7 +1638,7 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
         `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
       );
     }
-    setState__INTERNAL(state, newValue, store);
+    setAtomOrSelector(state, newValue, store);
   }
 });
 
@@ -1659,7 +1728,7 @@ var createReadonlySelector = (options, family, store, core) => {
 };
 
 // src/selector/create-selector.ts
-function createSelector(options, family, store = IMPLICIT.STORE) {
+function createSelector(options, family, store) {
   const core = target(store);
   const existingWritable = core.selectors.get(options.key);
   const existingReadonly = core.readonlySelectors.get(options.key);
@@ -1677,13 +1746,42 @@ function createSelector(options, family, store = IMPLICIT.STORE) {
   return createReadonlySelector(options, family, store, core);
 }
 
+// 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);
+    }
+  );
+  for (const downstreamToken of downstreamTokens) {
+    if (downstreamToken) {
+      deleteSelector(downstreamToken, store);
+    }
+  }
+  core.selectorGraph.delete(key);
+  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
+}
+
 // 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 = stringifyJson(key);
+      const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
       const existing = core.readonlySelectors.get(fullKey);
@@ -1706,7 +1804,7 @@ function createReadonlySelectorFamily(options, store) {
     }
   );
 }
-function createSelectorFamily(options, store = IMPLICIT.STORE) {
+function createSelectorFamily(options, store) {
   const isReadonly = !(`set` in options);
   if (isReadonly) {
     return createReadonlySelectorFamily(options, store);
@@ -1715,7 +1813,7 @@ function createSelectorFamily(options, store = IMPLICIT.STORE) {
   const subject = new Subject();
   const selectorFamily = Object.assign(
     (key) => {
-      const subKey = stringifyJson(key);
+      const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
       const existing = core.selectors.get(fullKey);
@@ -1745,7 +1843,7 @@ function createSelectorFamily(options, store = IMPLICIT.STORE) {
 
 // src/mutable/tracker-family.ts
 var FamilyTracker = class {
-  constructor(findMutableState, store = IMPLICIT.STORE) {
+  constructor(findMutableState, store) {
     this.findLatestUpdateState = createAtomFamily(
       {
         key: `*${findMutableState.key}`,
@@ -1758,7 +1856,7 @@ var FamilyTracker = class {
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
-          const key = parseJson(atomToken.family.subKey);
+          const key = json.parseJson(atomToken.family.subKey);
           this.findLatestUpdateState(key);
           new Tracker(atomToken, store);
         }
@@ -1768,7 +1866,7 @@ var FamilyTracker = class {
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
-          const key = parseJson(atomToken.family.subKey);
+          const key = json.parseJson(atomToken.family.subKey);
           const mutableAtomToken = this.findMutableState(key);
           new Tracker(mutableAtomToken, store);
         }
@@ -1778,16 +1876,26 @@ var FamilyTracker = class {
 };
 
 // src/mutable/create-mutable-atom-family.ts
-function createMutableAtomFamily(options, store = IMPLICIT.STORE) {
+function createMutableAtomFamily(options, store) {
   const coreFamily = Object.assign(
     createAtomFamily(options, store),
     options
   );
-  selectJsonFamily(coreFamily, 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`;
@@ -1828,27 +1936,26 @@ function isTransceiver(value) {
 var isAtomMutable = (atom) => `isMutable` in atom;
 
 // src/atom/is-default.ts
-var isAtomDefault = (key, store = IMPLICIT.STORE) => {
+var isAtomDefault = (key, store) => {
   const core = target(store);
   return core.atomsThatAreDefault.has(key);
 };
-var markAtomAsDefault = (key, store = IMPLICIT.STORE) => {
+var markAtomAsDefault = (key, store) => {
   const core = target(store);
   core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
 };
-var markAtomAsNotDefault = (key, store = IMPLICIT.STORE) => {
+var markAtomAsNotDefault = (key, store) => {
   const core = target(store);
   core.atomsThatAreDefault = new Set(target(store).atomsThatAreDefault);
   core.atomsThatAreDefault.delete(key);
 };
-var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
+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 = IMPLICIT.STORE) {
-  var _a;
+function createAtom(options, family, store) {
   store.logger.info(
     `\u{1F528}`,
     `atom`,
@@ -1881,35 +1988,87 @@ function createAtom(options, family, store = IMPLICIT.STORE) {
     },
     subject
   }), family && { family });
-  const initialValue = options.default instanceof Function ? options.default() : options.default;
+  let initialValue = options.default;
+  if (options.default instanceof Function) {
+    initialValue = options.default();
+  }
   core.atoms.set(newAtom.key, newAtom);
   markAtomAsDefault(options.key, store);
   cacheValue(options.key, initialValue, subject, store);
   const token = deposit(newAtom);
-  for (const effect of (_a = options.effects) != null ? _a : []) {
-    effect({
-      setSelf: (next) => setState(token, next, store),
-      onSet: (handle) => subscribe(token, handle, `effect[${subject.subscribers.size}]`, store)
-    });
+  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/atom/delete-atom.ts
-function deleteAtom(atomToken, store = IMPLICIT.STORE) {
+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.`
+    );
+  }
+  (_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);
+      }
+    }
+  }
   core.selectorAtoms.delete(key);
   core.atomsThatAreDefault.delete(key);
   core.timelineAtoms.delete(key);
   store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
+// 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/subscribe/recall-state.ts
-var recallState = (state, store = IMPLICIT.STORE) => {
+var recallState = (state, store) => {
   const core = target(store);
   if (!core.operation.open) {
     store.logger.warn(
@@ -1947,7 +2106,7 @@ var subscribeToRootAtoms = (state, store) => {
           atomChange.newValue
         );
         const oldValue = recallState(state, store);
-        const newValue = getState__INTERNAL(state, store);
+        const newValue = readOrComputeValue(state, store);
         store.logger.info(
           `\u2728`,
           state.type,
@@ -1964,6 +2123,68 @@ var subscribeToRootAtoms = (state, store) => {
   return dependencySubscriptions;
 };
 
-export { FamilyTracker, Future, IMPLICIT, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, deleteAtom, deposit, evictCachedValue, getJsonToken, getSelectorDependencyKeys, getState__INTERNAL, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, openOperation, readCachedValue, redoTransactionUpdate, redo__INTERNAL, registerSelector, setState__INTERNAL, subscribeToRootAtoms, target, timeline__INTERNAL, traceAllSelectorAtoms, traceSelectorAtoms, transaction__INTERNAL, undoTransactionUpdate, undo__INTERNAL, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+exports.FamilyTracker = FamilyTracker;
+exports.Future = Future;
+exports.IMPLICIT = IMPLICIT;
+exports.LazyMap = LazyMap;
+exports.NotFoundError = NotFoundError;
+exports.Store = Store;
+exports.Subject = Subject;
+exports.TRANSACTION_PHASES = TRANSACTION_PHASES;
+exports.Tracker = Tracker;
+exports.abortTransaction = abortTransaction;
+exports.addAtomToTimeline = addAtomToTimeline;
+exports.applyTransaction = applyTransaction;
+exports.become = become;
+exports.buildTransaction = buildTransaction;
+exports.cacheValue = cacheValue;
+exports.clearStore = clearStore;
+exports.closeOperation = closeOperation;
+exports.createAtom = createAtom;
+exports.createAtomFamily = createAtomFamily;
+exports.createMutableAtom = createMutableAtom;
+exports.createMutableAtomFamily = createMutableAtomFamily;
+exports.createReadonlySelectorFamily = createReadonlySelectorFamily;
+exports.createSelector = createSelector;
+exports.createSelectorFamily = createSelectorFamily;
+exports.createTimeline = createTimeline;
+exports.createTransaction = createTransaction;
+exports.deleteAtom = deleteAtom;
+exports.deleteSelector = deleteSelector;
+exports.deposit = deposit;
+exports.evictCachedValue = evictCachedValue;
+exports.getJsonFamily = getJsonFamily;
+exports.getJsonToken = getJsonToken;
+exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
+exports.getUpdateToken = getUpdateToken;
+exports.isAtomDefault = isAtomDefault;
+exports.isAtomKey = isAtomKey;
+exports.isAtomMutable = isAtomMutable;
+exports.isAtomTokenMutable = isAtomTokenMutable;
+exports.isDone = isDone;
+exports.isReadonlySelectorKey = isReadonlySelectorKey;
+exports.isSelectorDefault = isSelectorDefault;
+exports.isSelectorKey = isSelectorKey;
+exports.isStateKey = isStateKey;
+exports.isTransceiver = isTransceiver;
+exports.isValueCached = isValueCached;
+exports.markAtomAsDefault = markAtomAsDefault;
+exports.markAtomAsNotDefault = markAtomAsNotDefault;
+exports.markDone = markDone;
+exports.openOperation = openOperation;
+exports.readCachedValue = readCachedValue;
+exports.readOrComputeValue = readOrComputeValue;
+exports.redoTransactionUpdate = redoTransactionUpdate;
+exports.registerSelector = registerSelector;
+exports.setAtomOrSelector = setAtomOrSelector;
+exports.subscribeToRootAtoms = subscribeToRootAtoms;
+exports.target = target;
+exports.timeTravel = timeTravel;
+exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
+exports.traceSelectorAtoms = traceSelectorAtoms;
+exports.undoTransactionUpdate = undoTransactionUpdate;
+exports.updateSelectorAtoms = updateSelectorAtoms;
+exports.withdraw = withdraw;
+exports.withdrawNewFamilyMember = withdrawNewFamilyMember;
 //# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.cjs.map