atom.io 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -18,63 +18,153 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
-  var target = {};
+  var target3 = {};
   for (var prop in source)
     if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
+      target3[prop] = source[prop];
   if (source != null && __getOwnPropSymbols)
     for (var prop of __getOwnPropSymbols(source)) {
       if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
+        target3[prop] = source[prop];
     }
-  return target;
+  return target3;
 };
-var __export = (target, all) => {
+var __export = (target3, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+    __defProp(target3, name, { get: all[name], enumerable: true });
 };
 
 // src/internal/index.ts
 var internal_exports = {};
 __export(internal_exports, {
   IMPLICIT: () => IMPLICIT,
+  LOG_LEVELS: () => LOG_LEVELS,
+  TRANSACTION_PHASES: () => TRANSACTION_PHASES,
   abortTransaction: () => abortTransaction,
+  applyTransaction: () => applyTransaction,
+  atomFamily__INTERNAL: () => atomFamily__INTERNAL,
+  atom__INTERNAL: () => atom__INTERNAL,
+  buildTransaction: () => buildTransaction,
+  cacheValue: () => cacheValue,
   clearStore: () => clearStore,
-  configure: () => configure,
+  closeOperation: () => closeOperation,
+  computeSelectorState: () => computeSelectorState,
   createStore: () => createStore,
   deposit: () => deposit,
+  emitUpdate: () => emitUpdate,
+  evictCachedValue: () => evictCachedValue,
   evictDownStream: () => evictDownStream,
-  finishAction: () => finishAction,
-  finishTransaction: () => finishTransaction,
-  getCachedState: () => getCachedState,
-  getSelectorState: () => getSelectorState,
   getState__INTERNAL: () => getState__INTERNAL,
+  hasKeyBeenUsed: () => hasKeyBeenUsed,
   isAtomDefault: () => isAtomDefault,
   isDone: () => isDone,
   isSelectorDefault: () => isSelectorDefault,
+  isValueCached: () => isValueCached,
   lookup: () => lookup,
   lookupSelectorSources: () => lookupSelectorSources,
+  markAtomAsDefault: () => markAtomAsDefault,
+  markAtomAsNotDefault: () => markAtomAsNotDefault,
   markDone: () => markDone,
+  openOperation: () => openOperation,
+  prepareUpdate: () => prepareUpdate,
+  readCachedValue: () => readCachedValue,
+  readonlySelectorFamily__INTERNAL: () => readonlySelectorFamily__INTERNAL,
   recallState: () => recallState,
+  redoTransactionUpdate: () => redoTransactionUpdate,
+  redo__INTERNAL: () => redo__INTERNAL,
   registerSelector: () => registerSelector,
+  selectorFamily__INTERNAL: () => selectorFamily__INTERNAL,
+  selector__INTERNAL: () => selector__INTERNAL,
   setAtomState: () => setAtomState,
+  setLogLevel: () => setLogLevel,
   setSelectorState: () => setSelectorState,
   setState__INTERNAL: () => setState__INTERNAL,
-  startAction: () => startAction,
-  startTransaction: () => startTransaction,
+  storeAtom: () => storeAtom,
+  storeReadonlySelector: () => storeReadonlySelector,
+  storeSelector: () => storeSelector,
+  stowUpdate: () => stowUpdate,
   subscribeToRootAtoms: () => subscribeToRootAtoms,
+  target: () => target,
+  timeline__INTERNAL: () => timeline__INTERNAL,
   traceAllSelectorAtoms: () => traceAllSelectorAtoms,
   traceSelectorAtoms: () => traceSelectorAtoms,
+  transaction__INTERNAL: () => transaction__INTERNAL,
+  undoTransactionUpdate: () => undoTransactionUpdate,
+  undo__INTERNAL: () => undo__INTERNAL,
   updateSelectorAtoms: () => updateSelectorAtoms,
+  useLogger: () => useLogger,
   withdraw: () => withdraw
 });
 
+// src/internal/atom-internal.ts
+import * as Rx2 from "rxjs";
+
 // src/internal/get.ts
-import { pipe as pipe6 } from "fp-ts/function";
-import HAMT2 from "hamt_plus";
+import HAMT from "hamt_plus";
+var computeSelectorState = (selector2) => selector2.get();
+function lookup(key, store) {
+  const core = target(store);
+  const type = HAMT.has(key, core.atoms) ? `atom` : HAMT.has(key, core.selectors) ? `selector` : `readonly_selector`;
+  return { key, type };
+}
+function withdraw(token, store) {
+  var _a, _b, _c;
+  const core = target(store);
+  return (_c = (_b = (_a = HAMT.get(token.key, core.atoms)) != null ? _a : HAMT.get(token.key, core.selectors)) != null ? _b : HAMT.get(token.key, core.readonlySelectors)) != null ? _c : HAMT.get(token.key, core.transactions);
+}
+function deposit(state) {
+  return __spreadValues({
+    key: state.key,
+    type: state.type
+  }, `family` in state && { family: state.family });
+}
+var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
+  var _a, _b, _c;
+  if (isValueCached(state.key, store)) {
+    (_a = store.config.logger) == null ? void 0 : _a.info(`>> read "${state.key}"`);
+    return readCachedValue(state.key, store);
+  }
+  if (`get` in state) {
+    (_b = store.config.logger) == null ? void 0 : _b.info(`-> calc "${state.key}"`);
+    return computeSelectorState(state);
+  }
+  (_c = store.config.logger) == null ? void 0 : _c.error(
+    `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
+  );
+  return state.default;
+};
+
+// src/internal/is-default.ts
+var isAtomDefault = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  return core.atomsThatAreDefault.has(key);
+};
+var markAtomAsDefault = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
+};
+var markAtomAsNotDefault = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.atomsThatAreDefault = new Set(target(store).atomsThatAreDefault);
+  core.atomsThatAreDefault.delete(key);
+};
+var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
+  const roots = traceAllSelectorAtoms(key, store);
+  return roots.every((root) => isAtomDefault(root.key, store));
+};
+
+// src/internal/operation.ts
+import HAMT3 from "hamt_plus";
 
 // src/internal/store.ts
-import HAMT from "hamt_plus";
+import HAMT2 from "hamt_plus";
+
+// ../anvl/src/function/index.ts
+var doNothing = () => void 0;
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+var pass = (...params) => (fn) => fn(...params);
 
 // ../anvl/src/join/core-relation-data.ts
 import { isString } from "fp-ts/string";
@@ -120,12 +210,6 @@ var mapObject = (obj, fn) => pipe(
 );
 var mob = (fn) => (obj) => mapObject(obj, fn);
 
-// ../anvl/src/function/index.ts
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
-  originalThing instanceof Function ? originalThing() : originalThing
-) : nextVersionOfThing;
-var pass = (...params) => (fn) => fn(...params);
-
 // ../anvl/src/nullish/index.ts
 var isUndefined = (input) => input === void 0;
 var ifNullish = (alt) => (input) => input != null ? input : alt;
@@ -464,22 +548,29 @@ var Join = class {
 
 // src/internal/store.ts
 var createStore = (name) => ({
-  valueMap: HAMT.make(),
-  selectorGraph: new Join({ relationType: `n:n` }),
+  atoms: HAMT2.make(),
+  atomsThatAreDefault: /* @__PURE__ */ new Set(),
+  readonlySelectors: HAMT2.make(),
   selectorAtoms: new Join({ relationType: `n:n` }),
-  atoms: HAMT.make(),
-  atomsAreDefault: HAMT.make(),
-  selectors: HAMT.make(),
-  readonlySelectors: HAMT.make(),
+  selectorGraph: new Join({ relationType: `n:n` }),
+  selectors: HAMT2.make(),
+  timelines: HAMT2.make(),
+  timelineAtoms: new Join({ relationType: `1:n` }),
+  timelineStore: HAMT2.make(),
+  transactions: HAMT2.make(),
+  valueMap: HAMT2.make(),
   operation: {
     open: false
   },
-  transaction: {
-    open: false
+  transactionStatus: {
+    phase: `idle`
   },
   config: {
     name,
-    logger: null
+    logger: __spreadProps(__spreadValues({}, console), {
+      info: doNothing
+    }),
+    logger__INTERNAL: console
   }
 });
 var IMPLICIT = {
@@ -489,189 +580,381 @@ var IMPLICIT = {
     return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = createStore(`DEFAULT`);
   }
 };
-var configure = (config, store = IMPLICIT.STORE) => {
-  Object.assign(store.config, config);
-};
 var clearStore = (store = IMPLICIT.STORE) => {
   const { config } = store;
   Object.assign(store, createStore(config.name));
   store.config = config;
 };
 
-// src/internal/get.ts
-var getCachedState = (state, store = IMPLICIT.STORE) => {
-  const path = [];
-  if (`default` in state) {
-    const atomKey = state.key;
-    store.selectorAtoms = pipe6(store.selectorAtoms, (oldValue) => {
-      let newValue = oldValue;
-      for (const selectorKey of path) {
-        newValue = newValue.set(selectorKey, atomKey);
-      }
-      return newValue;
-    });
-  }
-  const value = HAMT2.get(state.key, store.valueMap);
-  return value;
-};
-var getSelectorState = (selector2) => selector2.get();
-function lookup(key, store) {
-  const type = HAMT2.has(key, store.atoms) ? `atom` : HAMT2.has(key, store.selectors) ? `selector` : `readonly_selector`;
-  return { key, type };
-}
-function withdraw(token, store) {
-  var _a, _b;
-  return (_b = (_a = HAMT2.get(token.key, store.atoms)) != null ? _a : HAMT2.get(token.key, store.selectors)) != null ? _b : HAMT2.get(token.key, store.readonlySelectors);
-}
-function deposit(state) {
-  if (`get` in state) {
-    if (`set` in state) {
-      return { key: state.key, type: `selector` };
-    }
-    return { key: state.key, type: `readonly_selector` };
-  }
-  return { key: state.key, type: `atom` };
-}
-var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
-  var _a, _b, _c;
-  if (HAMT2.has(state.key, store.valueMap)) {
-    (_a = store.config.logger) == null ? void 0 : _a.info(`>> read "${state.key}"`);
-    return getCachedState(state, store);
-  }
-  if (`get` in state) {
-    (_b = store.config.logger) == null ? void 0 : _b.info(`-> calc "${state.key}"`);
-    return getSelectorState(state);
-  }
-  (_c = store.config.logger) == null ? void 0 : _c.error(
-    `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
-  );
-  return state.default;
-};
-
-// src/internal/set.ts
-import HAMT4 from "hamt_plus";
-
 // src/internal/operation.ts
-import HAMT3 from "hamt_plus";
-var startAction = (store) => {
+var openOperation = (store) => {
   var _a;
-  store.operation = {
+  const core = target(store);
+  core.operation = {
     open: true,
     done: /* @__PURE__ */ new Set(),
     prev: store.valueMap
   };
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u2B55`, `operation start`);
 };
-var finishAction = (store) => {
+var closeOperation = (store) => {
   var _a;
-  store.operation = { open: false };
+  const core = target(store);
+  core.operation = { open: false };
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F534}`, `operation done`);
 };
 var isDone = (key, store = IMPLICIT.STORE) => {
   var _a;
-  if (!store.operation.open) {
+  const core = target(store);
+  if (!core.operation.open) {
     (_a = store.config.logger) == null ? void 0 : _a.warn(
-      `isDone called outside of an action. This is probably a bug.`
+      `isDone called outside of an operation. This is probably a bug.`
     );
     return true;
   }
-  return store.operation.done.has(key);
+  return core.operation.done.has(key);
 };
 var markDone = (key, store = IMPLICIT.STORE) => {
   var _a;
-  if (!store.operation.open) {
+  const core = target(store);
+  if (!core.operation.open) {
     (_a = store.config.logger) == null ? void 0 : _a.warn(
-      `markDone called outside of an action. This is probably a bug.`
+      `markDone called outside of an operation. This is probably a bug.`
     );
     return;
   }
-  store.operation.done.add(key);
+  core.operation.done.add(key);
 };
 var recallState = (state, store = IMPLICIT.STORE) => {
   var _a;
-  if (!store.operation.open) {
+  const core = target(store);
+  if (!core.operation.open) {
     (_a = store.config.logger) == null ? void 0 : _a.warn(
-      `recall called outside of an action. This is probably a bug.`
+      `recall called outside of an operation. This is probably a bug.`
     );
-    return HAMT3.get(state.key, store.valueMap);
+    return HAMT3.get(state.key, core.valueMap);
   }
-  return HAMT3.get(state.key, store.operation.prev);
+  return HAMT3.get(state.key, core.operation.prev);
+};
+var cacheValue = (key, value, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.valueMap = HAMT3.set(key, value, core.valueMap);
+};
+var evictCachedValue = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.valueMap = HAMT3.remove(key, core.valueMap);
+};
+var readCachedValue = (key, store = IMPLICIT.STORE) => HAMT3.get(key, target(store).valueMap);
+var isValueCached = (key, store = IMPLICIT.STORE) => HAMT3.has(key, target(store).valueMap);
+var storeAtom = (atom2, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.atoms = HAMT3.set(atom2.key, atom2, core.atoms);
+};
+var storeSelector = (selector2, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.selectors = HAMT3.set(selector2.key, selector2, core.selectors);
+};
+var storeReadonlySelector = (selector2, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.readonlySelectors = HAMT3.set(
+    selector2.key,
+    selector2,
+    core.readonlySelectors
+  );
+};
+var hasKeyBeenUsed = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  return HAMT3.has(key, core.atoms) || HAMT3.has(key, core.selectors) || HAMT3.has(key, core.readonlySelectors);
 };
 
-// src/internal/set.ts
-var evictDownStream = (state, store = IMPLICIT.STORE) => {
-  var _a, _b;
-  const downstream = store.selectorAtoms.getRelations(state.key);
-  const downstreamKeys = downstream.map(({ id }) => id);
-  (_a = store.config.logger) == null ? void 0 : _a.info(
-    `   || ${downstreamKeys.length} downstream:`,
-    downstreamKeys
+// src/internal/transaction-internal.ts
+import HAMT4 from "hamt_plus";
+import * as Rx from "rxjs";
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+var buildTransaction = (key, params, store) => {
+  var _a;
+  store.transactionStatus = {
+    key,
+    phase: `building`,
+    core: {
+      atoms: store.atoms,
+      atomsThatAreDefault: store.atomsThatAreDefault,
+      operation: { open: false },
+      readonlySelectors: store.readonlySelectors,
+      timelines: store.timelines,
+      timelineAtoms: store.timelineAtoms,
+      transactions: store.transactions,
+      selectorAtoms: store.selectorAtoms,
+      selectorGraph: store.selectorGraph,
+      selectors: store.selectors,
+      valueMap: store.valueMap
+    },
+    atomUpdates: [],
+    params,
+    output: void 0
+  };
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F6EB}`, `transaction "${key}" started`);
+};
+var applyTransaction = (output, store) => {
+  var _a, _b, _c;
+  if (store.transactionStatus.phase !== `building`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `abortTransaction called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    ` \u25B6\uFE0F apply transaction "${store.transactionStatus.key}" (init)`
   );
-  if (store.operation.open) {
-    (_b = store.config.logger) == null ? void 0 : _b.info(`   ||`, [...store.operation.done], `already done`);
+  store.transactionStatus.phase = `applying`;
+  store.transactionStatus.output = output;
+  const { atomUpdates } = store.transactionStatus;
+  for (const { key, oldValue, newValue } of atomUpdates) {
+    const token = { key, type: `atom` };
+    const state = withdraw(token, store);
+    setState(state, newValue, store);
   }
-  downstream.forEach(({ id: stateKey }) => {
-    var _a2, _b2, _c, _d;
-    if (isDone(stateKey, store)) {
-      (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   || ${stateKey} already done`);
-      return;
-    }
-    const state2 = (_b2 = HAMT4.get(stateKey, store.selectors)) != null ? _b2 : HAMT4.get(stateKey, store.readonlySelectors);
-    if (!state2) {
-      (_c = store.config.logger) == null ? void 0 : _c.info(
-        `   || ${stateKey} is an atom, and can't be downstream`
-      );
-      return;
-    }
-    store.valueMap = HAMT4.remove(stateKey, store.valueMap);
-    (_d = store.config.logger) == null ? void 0 : _d.info(`   xx evicted "${stateKey}"`);
-    markDone(stateKey, store);
+  const myTransaction = withdraw(
+    { key: store.transactionStatus.key, type: `transaction` },
+    store
+  );
+  myTransaction.subject.next({
+    key: store.transactionStatus.key,
+    atomUpdates,
+    output,
+    params: store.transactionStatus.params
   });
+  store.transactionStatus = { phase: `idle` };
+  (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F6EC}`, `transaction done`);
 };
-var setAtomState = (atom2, next, store = IMPLICIT.STORE) => {
-  var _a, _b;
-  const oldValue = getState__INTERNAL(atom2, store);
-  const newValue = become(next)(oldValue);
-  (_a = store.config.logger) == null ? void 0 : _a.info(`-> setting atom "${atom2.key}" to`, newValue);
-  store.valueMap = HAMT4.set(atom2.key, newValue, store.valueMap);
-  if (isAtomDefault(atom2.key)) {
-    store.atomsAreDefault = HAMT4.set(atom2.key, false, store.atomsAreDefault);
+var undoTransactionUpdate = (update, store) => {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23EE undo transaction "${update.key}" (undo)`);
+  for (const { key, oldValue, newValue } of update.atomUpdates) {
+    const token = { key, type: `atom` };
+    const state = withdraw(token, store);
+    setState(state, oldValue, store);
   }
-  markDone(atom2.key, store);
-  (_b = store.config.logger) == null ? void 0 : _b.info(
-    `   || evicting caches downstream from "${atom2.key}"`
-  );
-  evictDownStream(atom2, store);
-  atom2.subject.next({ newValue, oldValue });
 };
-var setSelectorState = (selector2, next, store = IMPLICIT.STORE) => {
-  var _a, _b;
-  const oldValue = getState__INTERNAL(selector2, store);
-  const newValue = become(next)(oldValue);
-  (_a = store.config.logger) == null ? void 0 : _a.info(`-> setting selector "${selector2.key}" to`, newValue);
-  (_b = store.config.logger) == null ? void 0 : _b.info(`   || propagating change made to "${selector2.key}"`);
-  selector2.set(newValue);
+var redoTransactionUpdate = (update, store) => {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23ED redo transaction "${update.key}" (redo)`);
+  for (const { key, oldValue, newValue } of update.atomUpdates) {
+    const token = { key, type: `atom` };
+    const state = withdraw(token, store);
+    setState(state, newValue, store);
+  }
 };
-var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
-  if (`set` in state) {
-    setSelectorState(state, value, store);
-  } else {
-    setAtomState(state, value, store);
+var abortTransaction = (store) => {
+  var _a, _b;
+  if (store.transactionStatus.phase === `idle`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `abortTransaction called outside of a transaction. This is probably a bug.`
+    );
+    return;
   }
+  store.transactionStatus = { phase: `idle` };
+  (_b = store.config.logger) == null ? void 0 : _b.info(`\u{1FA82}`, `transaction fail`);
 };
+function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
+  const newTransaction = {
+    key: options.key,
+    type: `transaction`,
+    run: (...params) => {
+      var _a;
+      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);
+        (_a = store.config.logger) == null ? void 0 : _a.error(`Transaction ${options.key} failed`, thrown);
+        throw thrown;
+      }
+    },
+    subject: new Rx.Subject()
+  };
+  const core = target(store);
+  core.transactions = HAMT4.set(
+    newTransaction.key,
+    newTransaction,
+    core.transactions
+  );
+  const token = deposit(newTransaction);
+  return token;
+}
+var target = (store = IMPLICIT.STORE) => store.transactionStatus.phase === `building` ? store.transactionStatus.core : store;
 
-// src/internal/is-default.ts
-import HAMT5 from "hamt_plus";
-var isAtomDefault = (key, store = IMPLICIT.STORE) => {
-  return HAMT5.get(key, store.atomsAreDefault);
+// src/internal/atom-internal.ts
+function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
+  var _a, _b, _c;
+  const core = target(store);
+  if (hasKeyBeenUsed(options.key, store)) {
+    (_b = (_a = store.config.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
+      _a,
+      `Key "${options.key}" already exists in the store.`
+    );
+    return deposit(core.atoms.get(options.key));
+  }
+  const subject = new Rx2.Subject();
+  const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    type: `atom`
+  }), family && { family });
+  const initialValue = options.default instanceof Function ? options.default() : options.default;
+  storeAtom(newAtom, store);
+  markAtomAsDefault(options.key, store);
+  cacheValue(options.key, initialValue, store);
+  const token = deposit(newAtom);
+  const setSelf = (next) => setState(token, next, store);
+  const onSet = (handle) => subscribe(token, handle, store);
+  (_c = options.effects) == null ? void 0 : _c.forEach((effect) => effect({ setSelf, onSet }));
+  return token;
+}
+
+// src/internal/families-internal.ts
+import * as Rx3 from "rxjs";
+
+// ../anvl/src/json/index.ts
+import { pipe as pipe6 } from "fp-ts/function";
+var stringifyJson = (json) => JSON.stringify(json);
+
+// src/internal/families-internal.ts
+function atomFamily__INTERNAL(options, store = IMPLICIT.STORE) {
+  const subject = new Rx3.Subject();
+  return Object.assign(
+    (key) => {
+      var _a;
+      const subKey = stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}__${subKey}`;
+      const existing = withdraw({ key: fullKey, type: `atom` }, store);
+      const token = existing ? deposit(existing) : atom__INTERNAL(
+        {
+          key: fullKey,
+          default: options.default instanceof Function ? options.default(key) : options.default,
+          effects: (_a = options.effects) == null ? void 0 : _a.call(options, key)
+        },
+        family,
+        store
+      );
+      subject.next(token);
+      return token;
+    },
+    {
+      key: options.key,
+      type: `atom_family`,
+      subject
+    }
+  );
+}
+function readonlySelectorFamily__INTERNAL(options, store) {
+  const core = target(store);
+  const subject = new Rx3.Subject();
+  return Object.assign(
+    (key) => {
+      const subKey = stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}__${subKey}`;
+      const existing = core.readonlySelectors.get(fullKey);
+      if (existing) {
+        return deposit(existing);
+      }
+      return selector__INTERNAL(
+        {
+          key: fullKey,
+          get: options.get(key)
+        },
+        family,
+        store
+      );
+    },
+    {
+      key: options.key,
+      type: `readonly_selector_family`,
+      subject
+    }
+  );
+}
+function selectorFamily__INTERNAL(options, store = IMPLICIT.STORE) {
+  const isReadonly = !(`set` in options);
+  if (isReadonly) {
+    return readonlySelectorFamily__INTERNAL(options, store);
+  }
+  const core = target(store);
+  const subject = new Rx3.Subject();
+  return Object.assign(
+    (key) => {
+      const subKey = 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 = selector__INTERNAL(
+        {
+          key: fullKey,
+          get: options.get(key),
+          set: options.set(key)
+        },
+        family,
+        store
+      );
+      subject.next(token);
+      return token;
+    },
+    {
+      key: options.key,
+      type: `selector_family`
+    }
+  );
+}
+
+// src/internal/logger.ts
+var LOG_LEVELS = [
+  `info`,
+  `warn`,
+  `error`
+];
+var setLogLevel = (preferredLevel, store = IMPLICIT.STORE) => {
+  const { logger__INTERNAL } = store.config;
+  if (preferredLevel === null) {
+    store.config.logger = null;
+  } else {
+    store.config.logger = __spreadValues({}, console);
+    LOG_LEVELS.forEach((logLevel) => {
+      if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
+        store.config.logger[logLevel] = doNothing;
+      } else {
+        store.config.logger[logLevel] = logger__INTERNAL[logLevel];
+      }
+    });
+  }
 };
-var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
-  const roots = traceAllSelectorAtoms(key, store);
-  return roots.every((root) => isAtomDefault(root.key, store));
+var useLogger = (logger, store = IMPLICIT.STORE) => {
+  var _a;
+  const currentLogLevel = store.config.logger === null ? null : (_a = LOG_LEVELS.find(
+    (logLevel) => {
+      var _a2;
+      return ((_a2 = store.config.logger) == null ? void 0 : _a2[logLevel]) !== doNothing;
+    }
+  )) != null ? _a : null;
+  store.config.logger__INTERNAL = __spreadValues({}, logger);
+  setLogLevel(currentLogLevel, store);
 };
 
 // src/internal/selector-internal.ts
-var lookupSelectorSources = (key, store) => store.selectorGraph.getRelations(key).filter(({ source }) => source !== key).map(({ source }) => lookup(source, store));
+import HAMT5 from "hamt_plus";
+import * as Rx4 from "rxjs";
+var lookupSelectorSources = (key, store) => target(store).selectorGraph.getRelations(key).filter(({ source }) => source !== key).map(({ source }) => lookup(source, store));
 var traceSelectorAtoms = (selectorKey, dependency, store) => {
   const roots = [];
   const sources = lookupSelectorSources(dependency.key, store);
@@ -700,23 +983,28 @@ var traceAllSelectorAtoms = (selectorKey, store) => {
 };
 var updateSelectorAtoms = (selectorKey, dependency, store) => {
   var _a, _b;
+  const core = target(store);
   if (dependency.type === `atom`) {
-    store.selectorAtoms = store.selectorAtoms.set(selectorKey, dependency.key);
+    core.selectorAtoms = core.selectorAtoms.set(selectorKey, dependency.key);
     (_a = store.config.logger) == null ? void 0 : _a.info(
       `   || adding root for "${selectorKey}": ${dependency.key}`
     );
     return;
   }
   const roots = traceSelectorAtoms(selectorKey, dependency, store);
-  (_b = store.config.logger) == null ? void 0 : _b.info(`   || adding roots for "${selectorKey}":`, roots);
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   || adding roots for "${selectorKey}":`,
+    roots.map((r) => r.key)
+  );
   for (const root of roots) {
-    store.selectorAtoms = store.selectorAtoms.set(selectorKey, root.key);
+    core.selectorAtoms = core.selectorAtoms.set(selectorKey, root.key);
   }
 };
 var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
   get: (dependency) => {
     var _a, _b;
-    const alreadyRegistered = store.selectorGraph.getRelations(selectorKey).some(({ source }) => source === dependency.key);
+    const core = target(store);
+    const alreadyRegistered = core.selectorGraph.getRelations(selectorKey).some(({ source }) => source === dependency.key);
     const dependencyState = withdraw(dependency, store);
     const dependencyValue = getState__INTERNAL(dependencyState, store);
     if (alreadyRegistered) {
@@ -729,13 +1017,9 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
         `\u{1F50C} registerSelector "${selectorKey}" <- "${dependency.key}" =`,
         dependencyValue
       );
-      store.selectorGraph = store.selectorGraph.set(
-        selectorKey,
-        dependency.key,
-        {
-          source: dependency.key
-        }
-      );
+      core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
+        source: dependency.key
+      });
     }
     updateSelectorAtoms(selectorKey, dependency, store);
     return dependencyValue;
@@ -745,19 +1029,171 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
     setState__INTERNAL(state, newValue, store);
   }
 });
+function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
+  var _a, _b, _c;
+  const core = target(store);
+  if (HAMT5.has(options.key, core.selectors)) {
+    (_a = store.config.logger) == null ? void 0 : _a.error(
+      `Key "${options.key}" already exists in the store.`
+    );
+  }
+  const subject = new Rx4.Subject();
+  const { get, set } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    cacheValue(options.key, value, store);
+    return value;
+  };
+  if (!(`set` in options)) {
+    const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+      subject,
+      get: getSelf,
+      type: `readonly_selector`
+    }), family && { family });
+    core.readonlySelectors = HAMT5.set(
+      options.key,
+      readonlySelector,
+      core.readonlySelectors
+    );
+    const initialValue2 = getSelf();
+    (_b = store.config.logger) == null ? void 0 : _b.info(`   \u2728 "${options.key}" =`, initialValue2);
+    return __spreadProps(__spreadValues({}, readonlySelector), { type: `readonly_selector` });
+  }
+  const setSelf = (next) => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
+    const oldValue = getSelf();
+    const newValue = become(next)(oldValue);
+    cacheValue(options.key, newValue, 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,
+    get: getSelf,
+    set: setSelf,
+    type: `selector`
+  }), family && { family });
+  core.selectors = HAMT5.set(options.key, mySelector, core.selectors);
+  const initialValue = getSelf();
+  (_c = store.config.logger) == null ? void 0 : _c.info(`   \u2728 "${options.key}" =`, initialValue);
+  return __spreadProps(__spreadValues({}, mySelector), { type: `selector` });
+}
+
+// src/internal/set.ts
+import HAMT6 from "hamt_plus";
+var evictDownStream = (state, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const core = target(store);
+  const downstream = core.selectorAtoms.getRelations(state.key);
+  const downstreamKeys = downstream.map(({ id }) => id);
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `   || ${downstreamKeys.length} downstream:`,
+    downstreamKeys
+  );
+  if (core.operation.open) {
+    (_b = store.config.logger) == null ? void 0 : _b.info(`   ||`, [...core.operation.done], `already done`);
+  }
+  downstream.forEach(({ id: stateKey }) => {
+    var _a2, _b2, _c, _d;
+    if (isDone(stateKey, store)) {
+      (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   || ${stateKey} already done`);
+      return;
+    }
+    const state2 = (_b2 = HAMT6.get(stateKey, core.selectors)) != null ? _b2 : HAMT6.get(stateKey, core.readonlySelectors);
+    if (!state2) {
+      (_c = store.config.logger) == null ? void 0 : _c.info(
+        `   || ${stateKey} is an atom, and can't be downstream`
+      );
+      return;
+    }
+    evictCachedValue(stateKey, store);
+    (_d = store.config.logger) == null ? void 0 : _d.info(`   xx evicted "${stateKey}"`);
+    markDone(stateKey, store);
+  });
+};
+var setAtomState = (atom2, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(atom2, store);
+  const newValue = become(next)(oldValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`<< setting atom "${atom2.key}" to`, newValue);
+  cacheValue(atom2.key, newValue, store);
+  if (isAtomDefault(atom2.key)) {
+    markAtomAsNotDefault(atom2.key, store);
+  }
+  markDone(atom2.key, store);
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   || evicting caches downstream from "${atom2.key}"`
+  );
+  evictDownStream(atom2, store);
+  const update = { oldValue, newValue };
+  if (store.transactionStatus.phase !== `building`) {
+    emitUpdate(atom2, update, store);
+  } else {
+    stowUpdate(atom2, update, store);
+  }
+};
+var setSelectorState = (selector2, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(selector2, store);
+  const newValue = become(next)(oldValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`<< setting selector "${selector2.key}" to`, newValue);
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   || propagating change made to "${selector2.key}"`);
+  selector2.set(newValue);
+};
+var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
+  if (`set` in state) {
+    setSelectorState(state, value, store);
+  } else {
+    setAtomState(state, value, store);
+  }
+};
 
 // src/internal/subscribe-internal.ts
-var subscribeToRootAtoms = (state, store = IMPLICIT.STORE) => {
+var prepareUpdate = (state, store) => {
+  const oldValue = recallState(state, store);
+  const newValue = getState__INTERNAL(state, store);
+  return { newValue, oldValue };
+};
+var stowUpdate = (state, update, store) => {
+  var _a;
+  const { key } = state;
+  const { logger } = store.config;
+  if (store.transactionStatus.phase !== `building`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `stowUpdate called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  store.transactionStatus.atomUpdates.push(__spreadValues({ key }, update));
+  logger == null ? void 0 : logger.info(`\u{1F4DD} ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`);
+};
+var emitUpdate = (state, update, store) => {
+  const { key } = state;
+  const { logger } = store.config;
+  logger == null ? void 0 : logger.info(
+    `\u{1F4E2} ${state.type} "${key}" went (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `)`
+  );
+  state.subject.next(update);
+};
+var subscribeToRootAtoms = (state, store) => {
   const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
     const atom2 = withdraw(atomToken, store);
     return atom2.subject.subscribe((atomChange) => {
       var _a, _b;
       (_a = store.config.logger) == null ? void 0 : _a.info(
-        `\u{1F4E2} atom changed: "${atomToken.key}" (`,
+        `\u{1F4E2} selector "${state.key}" saw root "${atomToken.key}" go (`,
         atomChange.oldValue,
         `->`,
         atomChange.newValue,
-        `) re-evaluating "${state.key}"`
+        `)`
       );
       const oldValue = recallState(state, store);
       const newValue = getState__INTERNAL(state, store);
@@ -768,208 +1204,198 @@ var subscribeToRootAtoms = (state, store = IMPLICIT.STORE) => {
   return dependencySubscriptions;
 };
 
-// src/internal/transaction-internal.ts
-var finishTransaction = (store) => {
-  var _a;
-  store.transaction = { open: false };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F6EC}`, `transaction done`);
-};
-var startTransaction = (store) => {
-  var _a;
-  store.transaction = {
-    open: true,
-    prev: {
-      atoms: store.atoms,
-      readonlySelectors: store.readonlySelectors,
-      selectorGraph: store.selectorGraph,
-      selectors: store.selectors,
-      valueMap: store.valueMap
+// src/internal/timeline-internal.ts
+import HAMT7 from "hamt_plus";
+function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
+  let incompleteTransactionKey = null;
+  const timelineData = {
+    at: 0,
+    timeTraveling: false,
+    history: []
+  };
+  const subscribeToAtom = (token) => {
+    const state = withdraw(token, store);
+    state.subject.subscribe((update) => {
+      var _a, _b, _c;
+      const storeCurrentTransactionKey = store.transactionStatus.phase === `applying` ? store.transactionStatus.key : null;
+      (_a = store.config.logger) == null ? void 0 : _a.info(
+        `\u23F3 timeline "${options.key}" saw atom "${token.key}" go (`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        storeCurrentTransactionKey ? `) in "${storeCurrentTransactionKey}"` : `) independently`
+      );
+      if (storeCurrentTransactionKey && store.transactionStatus.phase === `applying`) {
+        const currentTransaction = withdraw(
+          { key: storeCurrentTransactionKey, type: `transaction` },
+          store
+        );
+        if (incompleteTransactionKey !== storeCurrentTransactionKey) {
+          if (incompleteTransactionKey) {
+            (_b = store.config.logger) == null ? void 0 : _b.error(
+              `Timeline "${options.key}" was unable to resolve transaction "${incompleteTransactionKey}. This is probably a bug.`
+            );
+          }
+          incompleteTransactionKey = storeCurrentTransactionKey;
+          const subscription = currentTransaction.subject.subscribe((update2) => {
+            var _a2;
+            if (timelineData.timeTraveling === false) {
+              timelineData.history.push(__spreadProps(__spreadValues({
+                type: `transaction_update`
+              }, update2), {
+                atomUpdates: update2.atomUpdates.filter(
+                  (atomUpdate) => options.atoms.some((atom2) => atom2.key === atomUpdate.key)
+                )
+              }));
+            }
+            timelineData.at = timelineData.history.length;
+            subscription.unsubscribe();
+            incompleteTransactionKey = null;
+            (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+              `\u231B timeline "${options.key}" pushed a transaction_update from "${update2.key}"`
+            );
+          });
+        }
+      } else {
+        if (timelineData.timeTraveling === false) {
+          timelineData.history.push({
+            type: `state_update`,
+            key: token.key,
+            oldValue: update.oldValue,
+            newValue: update.newValue
+          });
+          (_c = store.config.logger) == null ? void 0 : _c.info(
+            `\u231B timeline "${options.key}" pushed a state_update to "${token.key}"`
+          );
+          timelineData.at = timelineData.history.length;
+        }
+      }
+    });
+  };
+  for (const tokenOrFamily of options.atoms) {
+    if (tokenOrFamily.type === `atom_family`) {
+      const family = tokenOrFamily;
+      family.subject.subscribe((token) => subscribeToAtom(token));
+    } else {
+      const token = tokenOrFamily;
+      subscribeToAtom(token);
     }
+  }
+  store.timelineStore = HAMT7.set(options.key, timelineData, store.timelineStore);
+  return {
+    key: options.key,
+    type: `timeline`
   };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F6EB}`, `transaction start`);
-};
-var abortTransaction = (store) => {
+}
+var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   var _a, _b;
-  if (!store.transaction.open) {
-    (_a = store.config.logger) == null ? void 0 : _a.warn(
-      `abortTransaction called outside of a transaction. This is probably a bug.`
+  const timelineData = store.timelineStore.get(token.key);
+  if (!timelineData) {
+    (_a = store.config.logger) == null ? void 0 : _a.error(
+      `Tried to redo on timeline "${token.key}" has not been initialized.`
     );
     return;
   }
-  store.atoms = store.transaction.prev.atoms;
-  store.readonlySelectors = store.transaction.prev.readonlySelectors;
-  store.selectorGraph = store.transaction.prev.selectorGraph;
-  store.selectors = store.transaction.prev.selectors;
-  store.valueMap = store.transaction.prev.valueMap;
-  store.transaction = { open: false };
-  (_b = store.config.logger) == null ? void 0 : _b.info(`\u{1FA82}`, `transaction fail`);
-};
-
-// src/atom.ts
-import HAMT6 from "hamt_plus";
-import * as Rx from "rxjs";
-
-// ../anvl/src/json/index.ts
-import { pipe as pipe7 } from "fp-ts/function";
-var stringifyJson = (json) => JSON.stringify(json);
-
-// src/atom.ts
-var atom = (options, store = IMPLICIT.STORE) => {
-  var _a, _b, _c;
-  if (HAMT6.has(options.key, store.atoms)) {
-    (_b = (_a = store.config.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
-      _a,
-      `Key "${options.key}" already exists in the store.`
+  if (timelineData.at === timelineData.history.length) {
+    (_b = store.config.logger) == null ? void 0 : _b.warn(
+      `Tried to redo on timeline "${token.key}" but there is nothing to redo.`
     );
-    return deposit(store.atoms.get(options.key));
+    return;
   }
-  const subject = new Rx.Subject();
-  const newAtom = __spreadProps(__spreadValues({}, options), { subject });
-  const initialValue = options.default instanceof Function ? options.default() : options.default;
-  store.atoms = HAMT6.set(options.key, newAtom, store.atoms);
-  store.atomsAreDefault = HAMT6.set(options.key, true, store.atomsAreDefault);
-  store.valueMap = HAMT6.set(options.key, initialValue, store.valueMap);
-  const token = deposit(newAtom);
-  const setSelf = (next) => setState(token, next, store);
-  const onSet = (observe) => subscribe(token, observe, store);
-  (_c = options.effects) == null ? void 0 : _c.forEach((effect) => effect({ setSelf, onSet }));
-  return token;
-};
-var atomFamily = (options, store = IMPLICIT.STORE) => (key) => {
-  var _a;
-  const fullKey = `${options.key}__${stringifyJson(key)}`;
-  const existing = store.atoms.get(fullKey);
-  if (existing) {
-    return deposit(existing);
+  timelineData.timeTraveling = true;
+  const update = timelineData.history[timelineData.at];
+  switch (update.type) {
+    case `state_update`: {
+      const { key, newValue } = update;
+      setState({ key, type: `atom` }, newValue);
+      break;
+    }
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, newValue } = atomUpdate;
+        setState({ key, type: `atom` }, newValue);
+      }
+      break;
+    }
   }
-  return atom(
-    {
-      key: fullKey,
-      default: options.default instanceof Function ? options.default(key) : options.default,
-      effects: (_a = options.effects) == null ? void 0 : _a.call(options, key)
-    },
-    store
-  );
+  ++timelineData.at;
+  timelineData.timeTraveling = false;
 };
-
-// src/selector.ts
-import HAMT7 from "hamt_plus";
-import * as Rx2 from "rxjs";
-function selector(options, store = IMPLICIT.STORE) {
+var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   var _a, _b;
-  if (HAMT7.has(options.key, store.selectors)) {
-    throw new Error(`Key "${options.key}" already exists in the store.`);
+  const timelineData = store.timelineStore.get(token.key);
+  if (!timelineData) {
+    (_a = store.config.logger) == null ? void 0 : _a.error(
+      `Tried to undo on timeline "${token.key}" has not been initialized.`
+    );
+    return;
   }
-  const subject = new Rx2.Subject();
-  const { get, set } = registerSelector(options.key, store);
-  const getSelf = () => {
-    const value = options.get({ get });
-    store.valueMap = HAMT7.set(options.key, value, store.valueMap);
-    return value;
-  };
-  if (!(`set` in options)) {
-    const readonlySelector = __spreadProps(__spreadValues({}, options), {
-      subject,
-      get: getSelf
-    });
-    store.readonlySelectors = HAMT7.set(
-      options.key,
-      readonlySelector,
-      store.readonlySelectors
+  if (timelineData.at === 0) {
+    (_b = store.config.logger) == null ? void 0 : _b.warn(
+      `Tried to undo on timeline "${token.key}" but there is nothing to undo.`
     );
-    const initialValue2 = getSelf();
-    (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue2);
-    return __spreadProps(__spreadValues({}, readonlySelector), { type: `readonly_selector` });
+    return;
   }
-  const setSelf = (next) => {
-    var _a2;
-    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
-    const oldValue = getSelf();
-    const newValue = become(next)(oldValue);
-    store.valueMap = HAMT7.set(options.key, newValue, store.valueMap);
-    markDone(options.key, store);
-    subject.next({ newValue, oldValue });
-    options.set({ get, set }, newValue);
-  };
-  const mySelector = __spreadProps(__spreadValues({}, options), {
-    subject,
-    get: getSelf,
-    set: setSelf
-  });
-  store.selectors = HAMT7.set(options.key, mySelector, store.selectors);
-  const initialValue = getSelf();
-  (_b = store.config.logger) == null ? void 0 : _b.info(`   \u2728 "${options.key}" =`, initialValue);
-  return __spreadProps(__spreadValues({}, mySelector), { type: `selector` });
-}
-function selectorFamily(options, store = IMPLICIT.STORE) {
-  return (key) => {
-    var _a;
-    const fullKey = `${options.key}__${stringifyJson(key)}`;
-    const existing = (_a = store.selectors.get(fullKey)) != null ? _a : store.readonlySelectors.get(fullKey);
-    if (existing) {
-      return deposit(existing);
+  timelineData.timeTraveling = true;
+  --timelineData.at;
+  const update = timelineData.history[timelineData.at];
+  switch (update.type) {
+    case `state_update`: {
+      const { key, oldValue } = update;
+      setState({ key, type: `atom` }, oldValue);
+      break;
     }
-    const readonlySelectorOptions = {
-      key: fullKey,
-      get: options.get(key)
-    };
-    if (!(`set` in options)) {
-      return selector(
-        __spreadValues({}, readonlySelectorOptions),
-        store
-      );
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, oldValue } = atomUpdate;
+        setState({ key, type: `atom` }, oldValue);
+      }
+      break;
     }
-    return selector(
-      __spreadProps(__spreadValues({}, readonlySelectorOptions), {
-        set: options.set(key)
-      }),
-      store
-    );
-  };
+  }
+  timelineData.timeTraveling = false;
+};
+
+// src/atom.ts
+function atom(options) {
+  return atom__INTERNAL(options);
+}
+function atomFamily(options) {
+  return atomFamily__INTERNAL(options);
 }
 
-// src/transaction.ts
-var transaction = (options, store = IMPLICIT.STORE) => Object.assign(
-  (...parameters) => {
-    var _a;
-    startTransaction(store);
-    try {
-      const result = options.do(
-        {
-          get: (token) => getState(token, store),
-          set: (token, value) => setState(token, value, store)
-        },
-        ...parameters
-      );
-      finishTransaction(store);
-      return result;
-    } catch (thrown) {
-      abortTransaction(store);
-      (_a = store.config.logger) == null ? void 0 : _a.error(`Transaction ${options.key} failed`, thrown);
-      throw thrown;
-    }
-  },
-  { key: options.key }
-);
+// src/selector.ts
+function selector(options) {
+  return selector__INTERNAL(options);
+}
+function selectorFamily(options) {
+  return selectorFamily__INTERNAL(options);
+}
 
-// src/index.ts
-var getState = (token, store = IMPLICIT.STORE) => {
-  const state = withdraw(token, store);
-  return getState__INTERNAL(state, store);
+// src/timeline.ts
+var timeline = (options) => {
+  return timeline__INTERNAL(options);
 };
-var setState = (token, value, store = IMPLICIT.STORE) => {
-  startAction(store);
-  const state = withdraw(token, store);
-  setState__INTERNAL(state, value, store);
-  finishAction(store);
+var redo = (token) => {
+  return redo__INTERNAL(token, IMPLICIT.STORE);
 };
-var isDefault = (token, store = IMPLICIT.STORE) => token.type === `atom` ? isAtomDefault(token.key, store) : isSelectorDefault(token.key, store);
-var subscribe = (token, observe, store = IMPLICIT.STORE) => {
+var undo = (token) => {
+  return undo__INTERNAL(token, IMPLICIT.STORE);
+};
+
+// src/transaction.ts
+function transaction(options) {
+  return transaction__INTERNAL(options);
+}
+var runTransaction = (token, store = IMPLICIT.STORE) => (...parameters) => withdraw(token, store).run(...parameters);
+
+// src/subscribe.ts
+var subscribe = (token, handleUpdate, store = IMPLICIT.STORE) => {
   var _a;
   const state = withdraw(token, store);
-  const subscription = state.subject.subscribe(observe);
+  const subscription = state.subject.subscribe(handleUpdate);
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F440} subscribe to "${state.key}"`);
-  const dependencySubscriptions = subscribeToRootAtoms(state, store);
+  const dependencySubscriptions = `get` in state ? subscribeToRootAtoms(state, store) : null;
   const unsubscribe = dependencySubscriptions === null ? () => {
     var _a2;
     (_a2 = store.config.logger) == null ? void 0 : _a2.info(`\u{1F648} unsubscribe from "${state.key}"`);
@@ -986,17 +1412,48 @@ var subscribe = (token, observe, store = IMPLICIT.STORE) => {
   };
   return unsubscribe;
 };
+var subscribeToTransaction = (token, handleUpdate, store = IMPLICIT.STORE) => {
+  var _a;
+  const tx = withdraw(token, store);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F440} subscribe to transaction "${token.key}"`);
+  const subscription = tx.subject.subscribe(handleUpdate);
+  const unsubscribe = () => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`\u{1F648} unsubscribe from transaction "${token.key}"`);
+    subscription.unsubscribe();
+  };
+  return unsubscribe;
+};
+
+// src/index.ts
+var getState = (token, store = IMPLICIT.STORE) => {
+  const state = withdraw(token, store);
+  return getState__INTERNAL(state, store);
+};
+var setState = (token, value, store = IMPLICIT.STORE) => {
+  openOperation(store);
+  const state = withdraw(token, store);
+  setState__INTERNAL(state, value, store);
+  closeOperation(store);
+};
+var isDefault = (token, store = IMPLICIT.STORE) => token.type === `atom` ? isAtomDefault(token.key, store) : isSelectorDefault(token.key, store);
 export {
   internal_exports as __INTERNAL__,
   atom,
   atomFamily,
-  configure,
   getState,
   isDefault,
+  redo,
+  runTransaction,
   selector,
   selectorFamily,
+  setLogLevel,
   setState,
   subscribe,
-  transaction
+  subscribeToTransaction,
+  timeline,
+  transaction,
+  undo,
+  useLogger
 };
 //# sourceMappingURL=index.mjs.map