atom.io 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -18,27 +18,27 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
-  var target3 = {};
+  var target2 = {};
   for (var prop in source)
     if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target3[prop] = source[prop];
+      target2[prop] = source[prop];
   if (source != null && __getOwnPropSymbols)
     for (var prop of __getOwnPropSymbols(source)) {
       if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target3[prop] = source[prop];
+        target2[prop] = source[prop];
     }
-  return target3;
+  return target2;
 };
-var __export = (target3, all) => {
+var __export = (target2, all) => {
   for (var name in all)
-    __defProp(target3, name, { get: all[name], enumerable: true });
+    __defProp(target2, name, { get: all[name], enumerable: true });
 };
 
 // src/internal/index.ts
 var internal_exports = {};
 __export(internal_exports, {
   IMPLICIT: () => IMPLICIT,
-  LOG_LEVELS: () => LOG_LEVELS,
+  META: () => meta_exports,
   TRANSACTION_PHASES: () => TRANSACTION_PHASES,
   abortTransaction: () => abortTransaction,
   applyTransaction: () => applyTransaction,
@@ -76,7 +76,6 @@ __export(internal_exports, {
   selectorFamily__INTERNAL: () => selectorFamily__INTERNAL,
   selector__INTERNAL: () => selector__INTERNAL,
   setAtomState: () => setAtomState,
-  setLogLevel: () => setLogLevel,
   setSelectorState: () => setSelectorState,
   setState__INTERNAL: () => setState__INTERNAL,
   storeAtom: () => storeAtom,
@@ -92,12 +91,12 @@ __export(internal_exports, {
   undoTransactionUpdate: () => undoTransactionUpdate,
   undo__INTERNAL: () => undo__INTERNAL,
   updateSelectorAtoms: () => updateSelectorAtoms,
-  useLogger: () => useLogger,
   withdraw: () => withdraw
 });
 
 // src/internal/atom-internal.ts
-import * as Rx2 from "rxjs";
+import HAMT5 from "hamt_plus";
+import * as Rx3 from "rxjs";
 
 // src/internal/get.ts
 import HAMT from "hamt_plus";
@@ -124,7 +123,7 @@ var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
     (_a = store.config.logger) == null ? void 0 : _a.info(`>> read "${state.key}"`);
     return readCachedValue(state.key, store);
   }
-  if (`get` in state) {
+  if (state.type !== `atom`) {
     (_b = store.config.logger) == null ? void 0 : _b.info(`-> calc "${state.key}"`);
     return computeSelectorState(state);
   }
@@ -158,6 +157,7 @@ import HAMT3 from "hamt_plus";
 
 // src/internal/store.ts
 import HAMT2 from "hamt_plus";
+import * as Rx from "rxjs";
 
 // ../anvl/src/function/index.ts
 var doNothing = () => void 0;
@@ -249,18 +249,68 @@ var hasExactProperties = (
   (isValue) => hasProperties(isValue, { allowExtraProperties: false })
 );
 
+// ../anvl/src/refinement/index.ts
+var canExist = (_) => true;
+var cannotExist = (_) => false;
+var isLiteral = (value) => (input) => input === value;
+var couldBe = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => r.name || `anon`).join(` | `)})`;
+  const _ = {
+    [name]: (input) => refinements.some(
+      (refinement) => {
+        var _a;
+        return logging && console.log(
+          refinements.map((r) => r.name || `anon`).join(` | `),
+          `>`,
+          (_a = refinement.name) != null ? _a : `anon`,
+          `:`,
+          refinement(input)
+        ), refinement(input);
+      }
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    or: (isTypeB) => couldBe(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isUnion = couldBe(cannotExist);
+var mustBe = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => r.name || `anon`).join(` & `)})`;
+  const _ = {
+    [name]: (input) => refinements.every(
+      (refinement) => (logging && console.log(
+        refinements.map((r) => r.name || `anon`).join(` & `),
+        `>`,
+        refinement.name || `anon`,
+        `:`,
+        refinement(input)
+      ), refinement(input))
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    and: (isTypeB) => mustBe(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isIntersection = mustBe(canExist);
+
 // ../anvl/src/join/core-relation-data.ts
 var RELATION_TYPES = [`1:1`, `1:n`, `n:n`];
 var isRelationType = (x) => RELATION_TYPES.includes(x);
 var EMPTY_RELATION_DATA = {
   contents: {},
   relations: {},
-  relationType: `n:n`
+  relationType: `n:n`,
+  a: `from`,
+  b: `to`
 };
-var isRelationData = (isContent) => (input) => hasExactProperties({
+var isRelationData = (isContent, a = `from`, b = `to`) => (input) => hasExactProperties({
   contents: isContent ? isRecord(isString, isContent) : hasExactProperties({}),
   relations: isRecord(isString, isArray(isString)),
-  relationType: isRelationType
+  relationType: isRelationType,
+  a: isLiteral(a),
+  b: isLiteral(b)
 })(input);
 
 // ../anvl/src/join/get-related-ids.ts
@@ -349,7 +399,11 @@ var removeAll = (current, idToRemove) => {
   });
   return next;
 };
-var removeRelation = (current, idA, idB) => idB ? removeSpecific(current, idA, idB) : removeAll(current, idA);
+var removeRelation = (current, relation) => {
+  const idA = relation[current.a];
+  const idB = relation[current.b];
+  return idB ? removeSpecific(current, idA, idB) : removeAll(current, idA);
+};
 
 // ../anvl/src/join/set-relation.ts
 var setManyToMany = (map2, idA, idB, ...rest) => {
@@ -393,7 +447,8 @@ var set1To1 = (current, wifeId, husbandId, ...rest) => {
   const content = rest[0];
   return content ? setContent(next, wifeId, husbandId, content) : next;
 };
-var setRelationWithContent = (current, idA, idB, ...rest) => {
+var setRelationWithContent = (current, relation, ...rest) => {
+  const { [current.a]: idA, [current.b]: idB } = relation;
   switch (current.relationType) {
     case `1:1`:
       return set1To1(current, idA, idB, ...rest);
@@ -417,96 +472,69 @@ var getRelations = (relationMap, id) => getRelationEntries(relationMap, id).map(
     id: id2
   }, content)
 );
-var setRelations = (current, idA, relations) => pipe5(
-  current,
-  (relationData) => {
-    const relatedIds = getRelatedIds(current, idA);
-    const removedIds = relatedIds.filter(
-      (id) => !relations.some((r) => r.id === id)
-    );
-    let step = relationData;
-    for (const idB of removedIds)
-      step = removeRelation(step, idA, idB);
-    return step;
-  },
-  (relationData) => {
-    let step = relationData;
-    for (const _a of relations) {
-      const _b = _a, { id: idB } = _b, rest = __objRest(_b, ["id"]);
-      const content = isEmptyObject(rest) ? void 0 : rest;
-      step = setRelationWithContent(step, idA, idB, content);
-    }
-    return step;
-  },
-  (relationData) => {
-    const newlyOrderedIds = relations.map((r) => r.id);
-    return __spreadProps(__spreadValues({}, relationData), {
-      relations: __spreadProps(__spreadValues({}, relationData.relations), {
-        [idA]: newlyOrderedIds
-      })
-    });
-  }
-);
-
-// ../anvl/src/refinement/index.ts
-var canExist = (_) => true;
-var cannotExist = (_) => false;
-var couldBe = (isTypeA, logging = false, refinements = [isTypeA]) => {
-  const name = `(${refinements.map((r) => r.name || `anon`).join(` | `)})`;
-  const _ = {
-    [name]: (input) => refinements.some(
-      (refinement) => {
-        var _a;
-        return logging && console.log(
-          refinements.map((r) => r.name || `anon`).join(` | `),
-          `>`,
-          (_a = refinement.name) != null ? _a : `anon`,
-          `:`,
-          refinement(input)
-        ), refinement(input);
+var setRelations = (current, subject, relations) => {
+  const idA = subject[current.a];
+  const idB = subject[current.b];
+  return pipe5(
+    current,
+    (relationData) => {
+      const relatedIds = getRelatedIds(current, idA);
+      const removedIds = relatedIds.filter(
+        (id) => !relations.some((r) => r.id === id)
+      );
+      let step = relationData;
+      for (const id of removedIds) {
+        const remove = {
+          [current.a]: idA != null ? idA : id,
+          [current.b]: idB != null ? idB : id
+        };
+        step = removeRelation(step, remove);
       }
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    or: (isTypeB) => couldBe(isTypeB, logging, [...refinements, isTypeB])
-  });
-  return checkTypes;
-};
-var isUnion = couldBe(cannotExist);
-var mustBe = (isTypeA, logging = false, refinements = [isTypeA]) => {
-  const name = `(${refinements.map((r) => r.name || `anon`).join(` & `)})`;
-  const _ = {
-    [name]: (input) => refinements.every(
-      (refinement) => (logging && console.log(
-        refinements.map((r) => r.name || `anon`).join(` & `),
-        `>`,
-        refinement.name || `anon`,
-        `:`,
-        refinement(input)
-      ), refinement(input))
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    and: (isTypeB) => mustBe(isTypeB, logging, [...refinements, isTypeB])
-  });
-  return checkTypes;
+      return step;
+    },
+    (relationData) => {
+      let step = relationData;
+      for (const _a of relations) {
+        const _b = _a, { id } = _b, rest = __objRest(_b, ["id"]);
+        const content = isEmptyObject(rest) ? void 0 : rest;
+        step = setRelationWithContent(
+          step,
+          { [current.a]: idA != null ? idA : id, [current.b]: idB != null ? idB : id },
+          // @ts-expect-error hacky
+          content
+        );
+      }
+      return step;
+    },
+    (relationData) => {
+      const newlyOrderedIds = relations.map((r) => r.id);
+      return __spreadProps(__spreadValues({}, relationData), {
+        relations: __spreadProps(__spreadValues({}, relationData.relations), {
+          [idA != null ? idA : idB]: newlyOrderedIds
+        })
+      });
+    }
+  );
 };
-var isIntersection = mustBe(canExist);
 
 // ../anvl/src/join/index.ts
 var Join = class {
   constructor(json) {
+    this.a = `from`;
+    this.b = `to`;
     Object.assign(this, __spreadValues(__spreadValues({}, EMPTY_RELATION_DATA), json));
   }
   toJSON() {
     return {
       relationType: this.relationType,
       relations: this.relations,
-      contents: this.contents
+      contents: this.contents,
+      a: this.a,
+      b: this.b
     };
   }
-  static fromJSON(json, isContent = cannotExist) {
-    const isValid = isRelationData(isContent)(json);
+  static fromJSON(json, isContent = cannotExist, a = `from`, b = `to`) {
+    const isValid = isRelationData(isContent, a, b)(json);
     if (isValid) {
       return new Join(json);
     }
@@ -514,6 +542,12 @@ var Join = class {
       `Saved JSON for this Join is invalid: ${JSON.stringify(json)}`
     );
   }
+  from(newA) {
+    return new Join(__spreadProps(__spreadValues({}, this), { a: newA }));
+  }
+  to(newB) {
+    return new Join(__spreadProps(__spreadValues({}, this), { b: newB }));
+  }
   getRelatedId(id) {
     return getRelatedId(this, id);
   }
@@ -535,14 +569,16 @@ var Join = class {
   getRelations(id) {
     return getRelations(this, id);
   }
-  setRelations(id, relations) {
-    return new Join(setRelations(this, id, relations));
+  setRelations(subject, relations) {
+    return new Join(setRelations(this, subject, relations));
   }
-  set(idA, idB, ...rest) {
-    return new Join(setRelationWithContent(this, idA, idB, ...rest));
+  set(relation, ...rest) {
+    return new Join(setRelationWithContent(this, relation, ...rest));
   }
-  remove(idA, idB) {
-    return new Join(removeRelation(this, idA, idB));
+  remove(relation) {
+    return new Join(
+      removeRelation(this, relation)
+    );
   }
 };
 
@@ -551,14 +587,20 @@ var createStore = (name) => ({
   atoms: HAMT2.make(),
   atomsThatAreDefault: /* @__PURE__ */ new Set(),
   readonlySelectors: HAMT2.make(),
-  selectorAtoms: new Join({ relationType: `n:n` }),
+  selectorAtoms: new Join({ relationType: `n:n` }).from(`selectorKey`).to(`atomKey`),
   selectorGraph: new Join({ relationType: `n:n` }),
   selectors: HAMT2.make(),
   timelines: HAMT2.make(),
-  timelineAtoms: new Join({ relationType: `1:n` }),
+  timelineAtoms: new Join({ relationType: `1:n` }).from(`timelineKey`).to(`atomKey`),
   timelineStore: HAMT2.make(),
   transactions: HAMT2.make(),
   valueMap: HAMT2.make(),
+  subject: {
+    atomCreation: new Rx.Subject(),
+    selectorCreation: new Rx.Subject(),
+    transactionCreation: new Rx.Subject(),
+    timelineCreation: new Rx.Subject()
+  },
   operation: {
     open: false
   },
@@ -587,21 +629,29 @@ var clearStore = (store = IMPLICIT.STORE) => {
 };
 
 // src/internal/operation.ts
-var openOperation = (store) => {
-  var _a;
+var openOperation = (token, store) => {
+  var _a, _b;
   const core = target(store);
+  if (core.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.error(
+      `\u274C failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`
+    );
+    throw Symbol(`violation`);
+  }
   core.operation = {
     open: true,
     done: /* @__PURE__ */ new Set(),
-    prev: store.valueMap
+    prev: store.valueMap,
+    time: Date.now(),
+    token
   };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u2B55`, `operation start`);
+  (_b = store.config.logger) == null ? void 0 : _b.info(`\u2B55 operation start from "${token.key}"`);
 };
 var closeOperation = (store) => {
   var _a;
   const core = target(store);
   core.operation = { open: false };
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F534}`, `operation done`);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F534} operation done`);
 };
 var isDone = (key, store = IMPLICIT.STORE) => {
   var _a;
@@ -669,7 +719,7 @@ var hasKeyBeenUsed = (key, store = IMPLICIT.STORE) => {
 
 // src/internal/transaction-internal.ts
 import HAMT4 from "hamt_plus";
-import * as Rx from "rxjs";
+import * as Rx2 from "rxjs";
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 var buildTransaction = (key, params, store) => {
   var _a;
@@ -696,7 +746,7 @@ var buildTransaction = (key, params, store) => {
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F6EB}`, `transaction "${key}" started`);
 };
 var applyTransaction = (output, store) => {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   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.`
@@ -704,13 +754,19 @@ var applyTransaction = (output, store) => {
     return;
   }
   (_b = store.config.logger) == null ? void 0 : _b.info(
-    ` \u25B6\uFE0F apply transaction "${store.transactionStatus.key}" (init)`
+    `\u{1F6C3} apply transaction "${store.transactionStatus.key}"`
   );
   store.transactionStatus.phase = `applying`;
   store.transactionStatus.output = output;
   const { atomUpdates } = store.transactionStatus;
-  for (const { key, oldValue, newValue } of atomUpdates) {
+  for (const { key, newValue } of atomUpdates) {
     const token = { key, type: `atom` };
+    if (!HAMT4.has(token.key, store.valueMap)) {
+      const atom2 = HAMT4.get(token.key, store.transactionStatus.core.atoms);
+      store.atoms = HAMT4.set(atom2.key, atom2, store.atoms);
+      store.valueMap = HAMT4.set(atom2.key, atom2.default, store.valueMap);
+      (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F527}`, `add atom "${atom2.key}"`);
+    }
     const state = withdraw(token, store);
     setState(state, newValue, store);
   }
@@ -725,12 +781,12 @@ var applyTransaction = (output, store) => {
     params: store.transactionStatus.params
   });
   store.transactionStatus = { phase: `idle` };
-  (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F6EC}`, `transaction done`);
+  (_d = store.config.logger) == null ? void 0 : _d.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) {
+  for (const { key, oldValue } of update.atomUpdates) {
     const token = { key, type: `atom` };
     const state = withdraw(token, store);
     setState(state, oldValue, store);
@@ -739,7 +795,7 @@ var undoTransactionUpdate = (update, 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) {
+  for (const { key, newValue } of update.atomUpdates) {
     const token = { key, type: `atom` };
     const state = withdraw(token, store);
     setState(state, newValue, store);
@@ -779,7 +835,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
         throw thrown;
       }
     },
-    subject: new Rx.Subject()
+    subject: new Rx2.Subject()
   };
   const core = target(store);
   core.transactions = HAMT4.set(
@@ -788,6 +844,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
     core.transactions
   );
   const token = deposit(newTransaction);
+  store.subject.transactionCreation.next(token);
   return token;
 }
 var target = (store = IMPLICIT.STORE) => store.transactionStatus.phase === `building` ? store.transactionStatus.core : store;
@@ -803,24 +860,28 @@ function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
     );
     return deposit(core.atoms.get(options.key));
   }
-  const subject = new Rx2.Subject();
+  const subject = new Rx3.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);
+  core.atoms = HAMT5.set(newAtom.key, newAtom, core.atoms);
   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 }));
+  (_c = options.effects) == null ? void 0 : _c.forEach(
+    (effect) => effect({
+      setSelf: (next) => setState(token, next, store),
+      onSet: (handle) => subscribe(token, handle, store)
+    })
+  );
+  store.subject.atomCreation.next(token);
   return token;
 }
 
 // src/internal/families-internal.ts
-import * as Rx3 from "rxjs";
+import * as Rx4 from "rxjs";
 
 // ../anvl/src/json/index.ts
 import { pipe as pipe6 } from "fp-ts/function";
@@ -828,13 +889,13 @@ var stringifyJson = (json) => JSON.stringify(json);
 
 // src/internal/families-internal.ts
 function atomFamily__INTERNAL(options, store = IMPLICIT.STORE) {
-  const subject = new Rx3.Subject();
+  const subject = new Rx4.Subject();
   return Object.assign(
     (key) => {
       var _a;
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
-      const fullKey = `${options.key}__${subKey}`;
+      const fullKey = `${options.key}(${subKey})`;
       const existing = withdraw({ key: fullKey, type: `atom` }, store);
       const token = existing ? deposit(existing) : atom__INTERNAL(
         {
@@ -857,12 +918,12 @@ function atomFamily__INTERNAL(options, store = IMPLICIT.STORE) {
 }
 function readonlySelectorFamily__INTERNAL(options, store) {
   const core = target(store);
-  const subject = new Rx3.Subject();
+  const subject = new Rx4.Subject();
   return Object.assign(
     (key) => {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
-      const fullKey = `${options.key}__${subKey}`;
+      const fullKey = `${options.key}(${subKey})`;
       const existing = core.readonlySelectors.get(fullKey);
       if (existing) {
         return deposit(existing);
@@ -889,12 +950,12 @@ function selectorFamily__INTERNAL(options, store = IMPLICIT.STORE) {
     return readonlySelectorFamily__INTERNAL(options, store);
   }
   const core = target(store);
-  const subject = new Rx3.Subject();
+  const subject = new Rx4.Subject();
   return Object.assign(
     (key) => {
       const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
-      const fullKey = `${options.key}__${subKey}`;
+      const fullKey = `${options.key}(${subKey})`;
       const existing = core.selectors.get(fullKey);
       if (existing) {
         return deposit(existing);
@@ -918,42 +979,123 @@ function selectorFamily__INTERNAL(options, store = IMPLICIT.STORE) {
   );
 }
 
-// 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];
+// src/internal/meta/index.ts
+var meta_exports = {};
+__export(meta_exports, {
+  attachMetaAtoms: () => attachMetaAtoms,
+  attachMetaSelectors: () => attachMetaSelectors,
+  attachMetaState: () => attachMetaState
+});
+
+// src/internal/meta/meta-state.ts
+var attachMetaAtoms = (store = IMPLICIT.STORE) => {
+  const atomTokenIndexState__INTERNAL = atom({
+    key: `\u{1F441}\u200D\u{1F5E8}_atom_token_index__INTERNAL`,
+    default: () => [...store.atoms].reduce((acc, [key]) => {
+      acc[key] = { key, type: `atom` };
+      return acc;
+    }, {}),
+    effects: [
+      ({ setSelf }) => {
+        store.subject.atomCreation.subscribe((atomToken) => {
+          if (store.operation.open) {
+            return;
+          }
+          setSelf((state) => {
+            const { key, family } = atomToken;
+            if (family) {
+              const { key: familyKey, subKey } = family;
+              const current = state[familyKey];
+              if (current === void 0 || `familyMembers` in current) {
+                const familyKeyState = current || {
+                  key: familyKey,
+                  familyMembers: {}
+                };
+                return __spreadProps(__spreadValues({}, state), {
+                  [familyKey]: __spreadProps(__spreadValues({}, familyKeyState), {
+                    familyMembers: __spreadProps(__spreadValues({}, familyKeyState.familyMembers), {
+                      [subKey]: atomToken
+                    })
+                  })
+                });
+              }
+            }
+            return __spreadProps(__spreadValues({}, state), {
+              [key]: atomToken
+            });
+          });
+        });
       }
-    });
-  }
+    ]
+  });
+  return selector({
+    key: `\u{1F441}\u200D\u{1F5E8}_atom_token_index`,
+    get: ({ get }) => get(atomTokenIndexState__INTERNAL)
+  });
 };
-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);
+var attachMetaSelectors = (store = IMPLICIT.STORE) => {
+  const readonlySelectorTokenIndexState__INTERNAL = atom({
+    key: `\u{1F441}\u200D\u{1F5E8}_selector_token_index__INTERNAL`,
+    default: () => Object.assign(
+      [...store.readonlySelectors].reduce((acc, [key]) => {
+        acc[key] = { key, type: `readonly_selector` };
+        return acc;
+      }, {}),
+      [...store.selectors].reduce((acc, [key]) => {
+        acc[key] = { key, type: `selector` };
+        return acc;
+      }, {})
+    ),
+    effects: [
+      ({ setSelf }) => {
+        store.subject.selectorCreation.subscribe((selectorToken) => {
+          if (store.operation.open) {
+            return;
+          }
+          setSelf((state) => {
+            const { key, family } = selectorToken;
+            if (family) {
+              const { key: familyKey, subKey } = family;
+              const current = state[familyKey];
+              if (current === void 0 || `familyMembers` in current) {
+                const familyKeyState = current || {
+                  key: familyKey,
+                  familyMembers: {}
+                };
+                return __spreadProps(__spreadValues({}, state), {
+                  [familyKey]: __spreadProps(__spreadValues({}, familyKeyState), {
+                    familyMembers: __spreadProps(__spreadValues({}, familyKeyState.familyMembers), {
+                      [subKey]: selectorToken
+                    })
+                  })
+                });
+              }
+            }
+            return __spreadProps(__spreadValues({}, state), {
+              [key]: selectorToken
+            });
+          });
+        });
+      }
+    ]
+  });
+  return selector({
+    key: `\u{1F441}\u200D\u{1F5E8}_selector_token_index`,
+    get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
+  });
+};
+
+// src/internal/meta/attach-meta.ts
+var attachMetaState = (store = IMPLICIT.STORE) => {
+  return {
+    atomTokenIndexState: attachMetaAtoms(store),
+    selectorTokenIndexState: attachMetaSelectors(store)
+  };
 };
 
 // src/internal/selector-internal.ts
-import HAMT5 from "hamt_plus";
-import * as Rx4 from "rxjs";
+import HAMT6 from "hamt_plus";
+import * as Rx5 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 = [];
@@ -985,7 +1127,10 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
   var _a, _b;
   const core = target(store);
   if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set(selectorKey, dependency.key);
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key
+    });
     (_a = store.config.logger) == null ? void 0 : _a.info(
       `   || adding root for "${selectorKey}": ${dependency.key}`
     );
@@ -997,7 +1142,10 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
     roots.map((r) => r.key)
   );
   for (const root of roots) {
-    core.selectorAtoms = core.selectorAtoms.set(selectorKey, root.key);
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: root.key
+    });
   }
 };
 var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
@@ -1014,12 +1162,16 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
       );
     } else {
       (_b = store.config.logger) == null ? void 0 : _b.info(
-        `\u{1F50C} registerSelector "${selectorKey}" <- "${dependency.key}" =`,
-        dependencyValue
+        `\u{1F50C} registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
+        dependencyValue,
+        `)`
+      );
+      core.selectorGraph = core.selectorGraph.set(
+        { from: dependency.key, to: selectorKey },
+        {
+          source: dependency.key
+        }
       );
-      core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
-        source: dependency.key
-      });
     }
     updateSelectorAtoms(selectorKey, dependency, store);
     return dependencyValue;
@@ -1032,12 +1184,12 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
 function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a, _b, _c;
   const core = target(store);
-  if (HAMT5.has(options.key, core.selectors)) {
+  if (HAMT6.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 subject = new Rx5.Subject();
   const { get, set } = registerSelector(options.key, store);
   const getSelf = () => {
     const value = options.get({ get });
@@ -1050,14 +1202,20 @@ function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
       get: getSelf,
       type: `readonly_selector`
     }), family && { family });
-    core.readonlySelectors = HAMT5.set(
+    core.readonlySelectors = HAMT6.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 token2 = {
+      key: options.key,
+      type: `readonly_selector`,
+      family
+    };
+    store.subject.selectorCreation.next(token2);
+    return token2;
   }
   const setSelf = (next) => {
     var _a2;
@@ -1077,14 +1235,20 @@ function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
     set: setSelf,
     type: `selector`
   }), family && { family });
-  core.selectors = HAMT5.set(options.key, mySelector, core.selectors);
+  core.selectors = HAMT6.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` });
+  const token = {
+    key: options.key,
+    type: `selector`,
+    family
+  };
+  store.subject.selectorCreation.next(token);
+  return token;
 }
 
 // src/internal/set.ts
-import HAMT6 from "hamt_plus";
+import HAMT7 from "hamt_plus";
 var evictDownStream = (state, store = IMPLICIT.STORE) => {
   var _a, _b;
   const core = target(store);
@@ -1103,7 +1267,7 @@ var evictDownStream = (state, store = IMPLICIT.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);
+    const state2 = (_b2 = HAMT7.get(stateKey, core.selectors)) != null ? _b2 : HAMT7.get(stateKey, core.readonlySelectors);
     if (!state2) {
       (_c = store.config.logger) == null ? void 0 : _c.info(
         `   || ${stateKey} is an atom, and can't be downstream`
@@ -1204,112 +1368,32 @@ var subscribeToRootAtoms = (state, store) => {
   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: []
-  };
-  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`
-  };
-}
+// src/internal/time-travel-internal.ts
 var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
-  var _a, _b;
+  var _a, _b, _c, _d;
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u23E9 redo "${token.key}"`);
   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.`
+    (_b = store.config.logger) == null ? void 0 : _b.error(
+      `Failed to redo on timeline "${token.key}". This timeline 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.`
+    (_c = store.config.logger) == null ? void 0 : _c.warn(
+      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
     );
     return;
   }
   timelineData.timeTraveling = true;
   const update = timelineData.history[timelineData.at];
   switch (update.type) {
-    case `state_update`: {
+    case `atom_update`: {
       const { key, newValue } = update;
       setState({ key, type: `atom` }, newValue);
       break;
     }
+    case `selector_update`:
     case `transaction_update`: {
       for (const atomUpdate of update.atomUpdates) {
         const { key, newValue } = atomUpdate;
@@ -1320,19 +1404,23 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   }
   ++timelineData.at;
   timelineData.timeTraveling = false;
+  (_d = store.config.logger) == null ? void 0 : _d.info(
+    `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  );
 };
 var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
-  var _a, _b;
+  var _a, _b, _c, _d;
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u23EA undo "${token.key}"`);
   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.`
+    (_b = store.config.logger) == null ? void 0 : _b.error(
+      `Failed to undo on timeline "${token.key}". This timeline 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.`
+    (_c = store.config.logger) == null ? void 0 : _c.warn(
+      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
     );
     return;
   }
@@ -1340,11 +1428,12 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
   --timelineData.at;
   const update = timelineData.history[timelineData.at];
   switch (update.type) {
-    case `state_update`: {
+    case `atom_update`: {
       const { key, oldValue } = update;
       setState({ key, type: `atom` }, oldValue);
       break;
     }
+    case `selector_update`:
     case `transaction_update`: {
       for (const atomUpdate of update.atomUpdates) {
         const { key, oldValue } = atomUpdate;
@@ -1354,8 +1443,167 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
     }
   }
   timelineData.timeTraveling = false;
+  (_d = store.config.logger) == null ? void 0 : _d.info(
+    `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  );
 };
 
+// src/internal/timeline-internal.ts
+import HAMT8 from "hamt_plus";
+function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
+  var _a, _b;
+  const timelineData = {
+    at: 0,
+    timeTraveling: false,
+    history: [],
+    selectorTime: null,
+    transactionKey: null
+  };
+  const subscribeToAtom = (token2) => {
+    const state = withdraw(token2, store);
+    state.subject.subscribe((update) => {
+      var _a2, _b2, _c, _d, _e;
+      const storeCurrentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
+      const storeCurrentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
+      const storeCurrentTransactionKey = store.transactionStatus.phase === `applying` ? store.transactionStatus.key : null;
+      (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+        `\u23F3 timeline "${options.key}" saw atom "${token2.key}" go (`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        storeCurrentTransactionKey ? `) in transaction "${storeCurrentTransactionKey}"` : storeCurrentSelectorKey ? `) in selector "${storeCurrentSelectorKey}"` : `)`
+      );
+      if (storeCurrentTransactionKey && store.transactionStatus.phase === `applying`) {
+        const currentTransaction = withdraw(
+          { key: storeCurrentTransactionKey, type: `transaction` },
+          store
+        );
+        if (timelineData.transactionKey !== storeCurrentTransactionKey) {
+          if (timelineData.transactionKey) {
+            (_b2 = store.config.logger) == null ? void 0 : _b2.error(
+              `Timeline "${options.key}" was unable to resolve transaction "${timelineData.transactionKey}. This is probably a bug.`
+            );
+          }
+          timelineData.transactionKey = storeCurrentTransactionKey;
+          const subscription = currentTransaction.subject.subscribe((update2) => {
+            var _a3;
+            if (timelineData.timeTraveling === false) {
+              if (timelineData.at !== timelineData.history.length) {
+                timelineData.history.splice(timelineData.at);
+              }
+              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();
+            timelineData.transactionKey = null;
+            (_a3 = store.config.logger) == null ? void 0 : _a3.info(
+              `\u231B timeline "${options.key}" got a transaction_update "${update2.key}"`
+            );
+          });
+        }
+      } else if (storeCurrentSelectorKey) {
+        if (timelineData.timeTraveling === false) {
+          if (storeCurrentSelectorTime !== timelineData.selectorTime) {
+            const newSelectorUpdate = {
+              type: `selector_update`,
+              key: storeCurrentSelectorKey,
+              atomUpdates: []
+            };
+            newSelectorUpdate.atomUpdates.push(__spreadValues({
+              key: token2.key,
+              type: `atom_update`
+            }, update));
+            if (timelineData.at !== timelineData.history.length) {
+              timelineData.history.splice(timelineData.at);
+            }
+            timelineData.history.push(newSelectorUpdate);
+            (_c = store.config.logger) == null ? void 0 : _c.info(
+              `\u231B timeline "${options.key}" got a selector_update "${storeCurrentSelectorKey}" with`,
+              newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            );
+            timelineData.at = timelineData.history.length;
+            timelineData.selectorTime = storeCurrentSelectorTime;
+          } else {
+            const latestUpdate = timelineData.history.at(-1);
+            if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
+              latestUpdate.atomUpdates.push(__spreadValues({
+                key: token2.key,
+                type: `atom_update`
+              }, update));
+              (_d = store.config.logger) == null ? void 0 : _d.info(
+                `   \u231B timeline "${options.key}" set selector_update "${storeCurrentSelectorKey}" to`,
+                latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+              );
+            }
+          }
+        }
+      } else {
+        if (timelineData.timeTraveling === false) {
+          timelineData.selectorTime = null;
+          if (timelineData.at !== timelineData.history.length) {
+            timelineData.history.splice(timelineData.at);
+          }
+          timelineData.history.push({
+            type: `atom_update`,
+            key: token2.key,
+            oldValue: update.oldValue,
+            newValue: update.newValue
+          });
+          (_e = store.config.logger) == null ? void 0 : _e.info(
+            `\u231B timeline "${options.key}" got a state_update to "${token2.key}"`
+          );
+          timelineData.at = timelineData.history.length;
+        }
+      }
+    });
+  };
+  const core = target(store);
+  for (const tokenOrFamily of options.atoms) {
+    const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key);
+    if (timelineKey) {
+      (_a = store.config.logger) == null ? void 0 : _a.error(
+        `\u274C Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`
+      );
+      continue;
+    }
+    if (tokenOrFamily.type === `atom_family`) {
+      const family = tokenOrFamily;
+      family.subject.subscribe((token2) => subscribeToAtom(token2));
+    } else {
+      const token2 = tokenOrFamily;
+      if (`family` in token2 && token2.family) {
+        const familyTimelineKey = core.timelineAtoms.getRelatedId(
+          token2.family.key
+        );
+        if (familyTimelineKey) {
+          (_b = store.config.logger) == null ? void 0 : _b.error(
+            `\u274C Failed to add atom "${token2.key}" to timeline "${options.key}" because its family "${token2.family.key}" belongs to timeline "${familyTimelineKey}"`
+          );
+          continue;
+        }
+      }
+      subscribeToAtom(token2);
+    }
+    core.timelineAtoms = core.timelineAtoms.set({
+      atomKey: tokenOrFamily.key,
+      timelineKey: options.key
+    });
+  }
+  store.timelineStore = HAMT8.set(options.key, timelineData, store.timelineStore);
+  const token = {
+    key: options.key,
+    type: `timeline`
+  };
+  store.subject.timelineCreation.next(token);
+  return token;
+}
+
 // src/atom.ts
 function atom(options) {
   return atom__INTERNAL(options);
@@ -1364,6 +1612,39 @@ function atomFamily(options) {
   return atomFamily__INTERNAL(options);
 }
 
+// src/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
 function selector(options) {
   return selector__INTERNAL(options);
@@ -1372,30 +1653,13 @@ 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
-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 dependencySubscriptions = state.type !== `atom` ? 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}"`);
@@ -1425,19 +1689,44 @@ var subscribeToTransaction = (token, handleUpdate, store = IMPLICIT.STORE) => {
   return unsubscribe;
 };
 
+// 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
+function transaction(options) {
+  return transaction__INTERNAL(options);
+}
+var runTransaction = (token, store = IMPLICIT.STORE) => (...parameters) => withdraw(token, store).run(...parameters);
+
 // 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);
+  try {
+    openOperation(token, store);
+  } catch (thrown) {
+    if (!(typeof thrown === `symbol`)) {
+      throw thrown;
+    }
+    return;
+  }
   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 {
+  LOG_LEVELS,
   internal_exports as __INTERNAL__,
   atom,
   atomFamily,