atom.io 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -18,53 +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,
-  finishAction: () => finishAction,
-  finishTransaction: () => finishTransaction,
-  getCachedState: () => getCachedState,
-  getSelectorState: () => getSelectorState,
+  emitUpdate: () => emitUpdate,
+  evictCachedValue: () => evictCachedValue,
+  evictDownStream: () => evictDownStream,
   getState__INTERNAL: () => getState__INTERNAL,
+  hasKeyBeenUsed: () => hasKeyBeenUsed,
+  isAtomDefault: () => isAtomDefault,
   isDone: () => isDone,
+  isSelectorDefault: () => isSelectorDefault,
+  isValueCached: () => isValueCached,
+  lookup: () => lookup,
+  lookupSelectorSources: () => lookupSelectorSources,
+  markAtomAsDefault: () => markAtomAsDefault,
+  markAtomAsNotDefault: () => markAtomAsNotDefault,
   markDone: () => markDone,
-  propagateDown: () => propagateDown,
-  recall: () => recall,
+  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 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";
@@ -110,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;
@@ -454,20 +548,29 @@ var Join = class {
 
 // src/internal/store.ts
 var createStore = (name) => ({
-  valueMap: HAMT.make(),
+  atoms: HAMT2.make(),
+  atomsThatAreDefault: /* @__PURE__ */ new Set(),
+  readonlySelectors: HAMT2.make(),
+  selectorAtoms: new Join({ relationType: `n:n` }),
   selectorGraph: new Join({ relationType: `n:n` }),
-  atoms: HAMT.make(),
-  selectors: HAMT.make(),
-  readonlySelectors: HAMT.make(),
+  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 = {
@@ -477,420 +580,880 @@ 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 value = HAMT2.get(state.key, store.valueMap);
-  return value;
-};
-var getSelectorState = (selector2) => selector2.get();
-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;
-  if (HAMT2.has(state.key, store.valueMap)) {
-    return getCachedState(state, store);
-  }
-  if (`get` in state) {
-    return getSelectorState(state);
-  }
-  (_a = store.config.logger) == null ? void 0 : _a.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(`\u2610`, `operation start`);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u2B55`, `operation start`);
 };
-var finishAction = (store) => {
+var closeOperation = (store) => {
   var _a;
-  store.operation = { open: false };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u2611\uFE0F`, `operation done`);
+  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 recall = (state, store = IMPLICIT.STORE) => {
+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);
 };
-
-// src/internal/set.ts
-var propagateDown = (state, store = IMPLICIT.STORE) => {
-  var _a, _b;
-  const relatedStateKeys = store.selectorGraph.getRelations(state.key);
-  (_a = store.config.logger) == null ? void 0 : _a.info(
-    `   ||`,
-    `bumping`,
-    relatedStateKeys.length,
-    `states:`,
-    relatedStateKeys.map(({ id }) => id)
-  );
-  if (store.operation.open) {
-    (_b = store.config.logger) == null ? void 0 : _b.info(`   ||`, `done:`, store.operation.done);
-  }
-  relatedStateKeys.forEach(({ id: stateKey }) => {
-    var _a2, _b2, _c, _d, _e;
-    if (isDone(stateKey, store)) {
-      (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   ||`, stateKey, `already done`);
-      return;
-    }
-    (_b2 = store.config.logger) == null ? void 0 : _b2.info(`->`, `bumping`, stateKey);
-    const state2 = (_c = HAMT4.get(stateKey, store.selectors)) != null ? _c : HAMT4.get(stateKey, store.readonlySelectors);
-    if (!state2) {
-      (_d = store.config.logger) == null ? void 0 : _d.info(
-        `   ||`,
-        stateKey,
-        `is an atom - no need to propagate down`
-      );
-      return;
-    }
-    store.valueMap = HAMT4.remove(stateKey, store.valueMap);
-    const newValue = getState__INTERNAL(state2, store);
-    (_e = store.config.logger) == null ? void 0 : _e.info(`   <-`, stateKey, `became`, newValue);
-    const oldValue = recall(state2, store);
-    state2.subject.next({ newValue, oldValue });
-    markDone(stateKey, store);
-    if (`set` in state2)
-      propagateDown(state2, store);
-  });
+var cacheValue = (key, value, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.valueMap = HAMT3.set(key, value, core.valueMap);
 };
-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);
-  markDone(atom2.key, store);
-  atom2.subject.next({ newValue, oldValue });
-  (_b = store.config.logger) == null ? void 0 : _b.info(
-    `   ||`,
-    `propagating change made to`,
-    `"${atom2.key}"`
-  );
-  propagateDown(atom2, store);
+var evictCachedValue = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.valueMap = HAMT3.remove(key, core.valueMap);
 };
-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}"`
+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
   );
-  selector2.set(newValue);
-  propagateDown(selector2, store);
 };
-var setState__INTERNAL = (token, value, store = IMPLICIT.STORE) => {
-  const state = withdraw(token, store);
-  if (`set` in state) {
-    setSelectorState(state, value, store);
-  } else {
-    setAtomState(state, value, store);
-  }
+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/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) => {
+import HAMT4 from "hamt_plus";
+import * as Rx from "rxjs";
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+var buildTransaction = (key, params, store) => {
   var _a;
-  store.transaction = {
-    open: true,
-    prev: {
+  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 start`);
+  (_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)`
+  );
+  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);
+  }
+  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 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);
+  }
+};
+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 abortTransaction = (store) => {
   var _a, _b;
-  if (!store.transaction.open) {
+  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.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 };
+  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/atom.ts
-import HAMT5 from "hamt_plus";
-import * as Rx from "rxjs";
-
-// ../anvl/src/json/index.ts
-import { pipe as pipe6 } from "fp-ts/function";
-var stringifyJson = (json) => JSON.stringify(json);
-
-// src/atom.ts
-var atom = (options, store = IMPLICIT.STORE) => {
+// src/internal/atom-internal.ts
+function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a, _b, _c;
-  if (HAMT5.has(options.key, store.atoms)) {
+  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(store.atoms.get(options.key));
+    return deposit(core.atoms.get(options.key));
   }
-  const subject = new Rx.Subject();
-  const newAtom = __spreadProps(__spreadValues({}, options), { subject });
-  store.atoms = HAMT5.set(options.key, newAtom, store.atoms);
-  store.valueMap = HAMT5.set(options.key, options.default, store.valueMap);
+  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 = (observe) => subscribe(token, observe, store);
-  setSelf(options.default);
+  const onSet = (handle) => subscribe(token, handle, 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);
-  }
-  return atom(
+}
+
+// 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: fullKey,
-      default: options.default instanceof Function ? options.default(key) : options.default,
-      effects: (_a = options.effects) == null ? void 0 : _a.call(options, key)
+      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
+      );
     },
-    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 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/selector.ts
-import HAMT6 from "hamt_plus";
-import * as Rx2 from "rxjs";
-function selector(options, store = IMPLICIT.STORE) {
+// src/internal/selector-internal.ts
+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);
+  let depth = 0;
+  while (sources.length > 0) {
+    const source = sources.shift();
+    ++depth;
+    if (depth > 999) {
+      throw new Error(
+        `Maximum selector dependency depth exceeded in selector "${selectorKey}".`
+      );
+    }
+    if (source.type !== `atom`) {
+      sources.push(...lookupSelectorSources(source.key, store));
+    } else {
+      roots.push(source);
+    }
+  }
+  return roots;
+};
+var traceAllSelectorAtoms = (selectorKey, store) => {
+  const sources = lookupSelectorSources(selectorKey, store);
+  return sources.flatMap(
+    (source) => source.type === `atom` ? source : traceSelectorAtoms(selectorKey, source, store)
+  );
+};
+var updateSelectorAtoms = (selectorKey, dependency, store) => {
   var _a, _b;
-  if (HAMT6.has(options.key, store.selectors)) {
-    throw new Error(`Key "${options.key}" already exists in the store.`);
+  const core = target(store);
+  if (dependency.type === `atom`) {
+    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 subject = new Rx2.Subject();
+  const roots = traceSelectorAtoms(selectorKey, dependency, store);
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   || adding roots for "${selectorKey}":`,
+    roots.map((r) => r.key)
+  );
+  for (const root of roots) {
+    core.selectorAtoms = core.selectorAtoms.set(selectorKey, root.key);
+  }
+};
+var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
+  get: (dependency) => {
+    var _a, _b;
+    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) {
+      (_a = store.config.logger) == null ? void 0 : _a.info(
+        `   || ${selectorKey} <- ${dependency.key} =`,
+        dependencyValue
+      );
+    } else {
+      (_b = store.config.logger) == null ? void 0 : _b.info(
+        `\u{1F50C} registerSelector "${selectorKey}" <- "${dependency.key}" =`,
+        dependencyValue
+      );
+      core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
+        source: dependency.key
+      });
+    }
+    updateSelectorAtoms(selectorKey, dependency, store);
+    return dependencyValue;
+  },
+  set: (stateToken, newValue) => {
+    const state = withdraw(stateToken, 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 });
-    store.valueMap = HAMT6.set(options.key, value, store.valueMap);
+    cacheValue(options.key, value, store);
     return value;
   };
   if (!(`set` in options)) {
-    const readonlySelector = __spreadProps(__spreadValues({}, options), {
+    const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
       subject,
-      get: getSelf
-    });
-    store.readonlySelectors = HAMT6.set(
+      get: getSelf,
+      type: `readonly_selector`
+    }), family && { family });
+    core.readonlySelectors = HAMT5.set(
       options.key,
       readonlySelector,
-      store.readonlySelectors
+      core.readonlySelectors
     );
     const initialValue2 = getSelf();
-    (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728`, options.key, `=`, initialValue2);
+    (_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}.set`, next);
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
     const oldValue = getSelf();
     const newValue = become(next)(oldValue);
-    store.valueMap = HAMT6.set(options.key, newValue, store.valueMap);
+    cacheValue(options.key, newValue, store);
     markDone(options.key, store);
-    subject.next({ newValue, oldValue });
+    if (store.transactionStatus.phase === `idle`) {
+      subject.next({ newValue, oldValue });
+    }
     options.set({ get, set }, newValue);
   };
-  const mySelector = __spreadProps(__spreadValues({}, options), {
+  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
     subject,
     get: getSelf,
-    set: setSelf
-  });
-  store.selectors = HAMT6.set(options.key, mySelector, store.selectors);
+    set: setSelf,
+    type: `selector`
+  }), family && { family });
+  core.selectors = HAMT5.set(options.key, mySelector, core.selectors);
   const initialValue = getSelf();
-  (_b = store.config.logger) == null ? void 0 : _b.info(`   \u2728`, options.key, `=`, initialValue);
+  (_c = store.config.logger) == null ? void 0 : _c.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);
+
+// 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 readonlySelectorOptions = {
-      key: fullKey,
-      get: options.get(key)
-    };
-    if (!(`set` in options)) {
-      return selector(
-        __spreadValues({}, readonlySelectorOptions),
-        store
+    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;
     }
-    return selector(
-      __spreadProps(__spreadValues({}, readonlySelectorOptions), {
-        set: options.set(key)
-      }),
-      store
+    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 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} selector "${state.key}" saw root "${atomToken.key}" go (`,
+        atomChange.oldValue,
+        `->`,
+        atomChange.newValue,
+        `)`
+      );
+      const oldValue = recallState(state, store);
+      const newValue = getState__INTERNAL(state, store);
+      (_b = store.config.logger) == null ? void 0 : _b.info(`   <- ${state.key} became`, newValue);
+      state.subject.next({ newValue, oldValue });
+    });
+  });
+  return dependencySubscriptions;
+};
+
+// 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: []
   };
-}
-var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
-  get: (state) => {
-    var _a, _b, _c;
-    const isRegistered = store.selectorGraph.getRelatedIds(selectorKey).includes(state.key);
-    if (isRegistered) {
-      (_a = store.config.logger) == null ? void 0 : _a.info(`   ||`, selectorKey, `<-`, state.key);
-    } else {
-      (_b = store.config.logger) == null ? void 0 : _b.info(
-        `\u{1F50C} registerSelector`,
-        selectorKey,
-        `<-`,
-        state.key
+  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`
       );
-      store.selectorGraph = store.selectorGraph.set(selectorKey, state.key);
+      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);
     }
-    const currentValue = getState(state, store);
-    (_c = store.config.logger) == null ? void 0 : _c.info(`   ||`, state.key, `=`, currentValue);
-    return currentValue;
-  },
-  set: (token, newValue) => {
-    store.selectorGraph.set(token.key, selectorKey);
-    setState__INTERNAL(token, newValue, store);
   }
-});
+  store.timelineStore = HAMT7.set(options.key, timelineData, store.timelineStore);
+  return {
+    key: options.key,
+    type: `timeline`
+  };
+}
+var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  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;
+  }
+  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;
+  }
+  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;
+    }
+  }
+  ++timelineData.at;
+  timelineData.timeTraveling = false;
+};
+var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  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;
+  }
+  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.`
+    );
+    return;
+  }
+  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;
+    }
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, oldValue } = atomUpdate;
+        setState({ key, type: `atom` }, oldValue);
+      }
+      break;
+    }
+  }
+  timelineData.timeTraveling = false;
+};
+
+// src/atom.ts
+function atom(options) {
+  return atom__INTERNAL(options);
+}
+function atomFamily(options) {
+  return atomFamily__INTERNAL(options);
+}
+
+// src/selector.ts
+function selector(options) {
+  return selector__INTERNAL(options);
+}
+function selectorFamily(options) {
+  return selectorFamily__INTERNAL(options);
+}
+
+// src/timeline.ts
+var timeline = (options) => {
+  return timeline__INTERNAL(options);
+};
+var redo = (token) => {
+  return redo__INTERNAL(token, IMPLICIT.STORE);
+};
+var undo = (token) => {
+  return undo__INTERNAL(token, IMPLICIT.STORE);
+};
 
 // 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;
+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(handleUpdate);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F440} subscribe to "${state.key}"`);
+  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}"`);
+    subscription.unsubscribe();
+  } : () => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+      `\u{1F648} unsubscribe from "${state.key}" and its dependencies`
+    );
+    subscription.unsubscribe();
+    for (const dependencySubscription of dependencySubscriptions) {
+      dependencySubscription.unsubscribe();
     }
-  },
-  { key: options.key }
-);
+  };
+  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 = (state, value, store = IMPLICIT.STORE) => {
-  startAction(store);
-  setState__INTERNAL(state, value, store);
-  finishAction(store);
-};
-var subscribe = (token, observe, store = IMPLICIT.STORE) => {
+var setState = (token, value, store = IMPLICIT.STORE) => {
+  openOperation(store);
   const state = withdraw(token, store);
-  const subscription = state.subject.subscribe(observe);
-  return () => subscription.unsubscribe();
+  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,
-  registerSelector,
+  isDefault,
+  redo,
+  runTransaction,
   selector,
   selectorFamily,
+  setLogLevel,
   setState,
   subscribe,
-  transaction
+  subscribeToTransaction,
+  timeline,
+  transaction,
+  undo,
+  useLogger
 };
 //# sourceMappingURL=index.mjs.map