atom.io 0.3.1 → 0.4.1

package/dist/index.js

@@ -83,6 +83,7 @@ module.exports = __toCommonJS(src_exports);
 var internal_exports = {};
 __export(internal_exports, {
   IMPLICIT: () => IMPLICIT,
+  META: () => meta_exports,
   TRANSACTION_PHASES: () => TRANSACTION_PHASES,
   abortTransaction: () => abortTransaction,
   applyTransaction: () => applyTransaction,
@@ -139,7 +140,8 @@ __export(internal_exports, {
 });
 
 // src/internal/atom-internal.ts
-var Rx2 = __toESM(require("rxjs"));
+var import_hamt_plus5 = __toESM(require("hamt_plus"));
+var Rx3 = __toESM(require("rxjs"));
 
 // src/internal/get.ts
 var import_hamt_plus = __toESM(require("hamt_plus"));
@@ -200,6 +202,7 @@ var import_hamt_plus3 = __toESM(require("hamt_plus"));
 
 // src/internal/store.ts
 var import_hamt_plus2 = __toESM(require("hamt_plus"));
+var Rx = __toESM(require("rxjs"));
 
 // ../anvl/src/function/index.ts
 var doNothing = () => void 0;
@@ -291,18 +294,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(import_string.isString, isContent) : hasExactProperties({}),
   relations: isRecord(import_string.isString, isArray(import_string.isString)),
-  relationType: isRelationType
+  relationType: isRelationType,
+  a: isLiteral(a),
+  b: isLiteral(b)
 })(input);
 
 // ../anvl/src/join/get-related-ids.ts
@@ -391,7 +444,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) => {
@@ -435,7 +492,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);
@@ -459,96 +517,69 @@ var getRelations = (relationMap, id) => getRelationEntries(relationMap, id).map(
     id: id2
   }, content)
 );
-var setRelations = (current, idA, relations) => (0, import_function6.pipe)(
-  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 (0, import_function6.pipe)(
+    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);
     }
@@ -556,6 +587,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);
   }
@@ -577,14 +614,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)
+    );
   }
 };
 
@@ -593,14 +632,20 @@ var createStore = (name) => ({
   atoms: import_hamt_plus2.default.make(),
   atomsThatAreDefault: /* @__PURE__ */ new Set(),
   readonlySelectors: import_hamt_plus2.default.make(),
-  selectorAtoms: new Join({ relationType: `n:n` }),
+  selectorAtoms: new Join({ relationType: `n:n` }).from(`selectorKey`).to(`atomKey`),
   selectorGraph: new Join({ relationType: `n:n` }),
   selectors: import_hamt_plus2.default.make(),
   timelines: import_hamt_plus2.default.make(),
-  timelineAtoms: new Join({ relationType: `1:n` }),
+  timelineAtoms: new Join({ relationType: `1:n` }).from(`timelineKey`).to(`atomKey`),
   timelineStore: import_hamt_plus2.default.make(),
   transactions: import_hamt_plus2.default.make(),
   valueMap: import_hamt_plus2.default.make(),
+  subject: {
+    atomCreation: new Rx.Subject(),
+    selectorCreation: new Rx.Subject(),
+    transactionCreation: new Rx.Subject(),
+    timelineCreation: new Rx.Subject()
+  },
   operation: {
     open: false
   },
@@ -633,7 +678,6 @@ var openOperation = (token, store) => {
   var _a, _b;
   const core = target(store);
   if (core.operation.open) {
-    console.warn(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}"`
     );
@@ -720,7 +764,7 @@ var hasKeyBeenUsed = (key, store = IMPLICIT.STORE) => {
 
 // src/internal/transaction-internal.ts
 var import_hamt_plus4 = __toESM(require("hamt_plus"));
-var Rx = __toESM(require("rxjs"));
+var Rx2 = __toESM(require("rxjs"));
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 var buildTransaction = (key, params, store) => {
   var _a;
@@ -747,7 +791,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.`
@@ -755,13 +799,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 (!import_hamt_plus4.default.has(token.key, store.valueMap)) {
+      const atom2 = import_hamt_plus4.default.get(token.key, store.transactionStatus.core.atoms);
+      store.atoms = import_hamt_plus4.default.set(atom2.key, atom2, store.atoms);
+      store.valueMap = import_hamt_plus4.default.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);
   }
@@ -776,12 +826,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);
@@ -790,7 +840,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);
@@ -830,7 +880,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
         throw thrown;
       }
     },
-    subject: new Rx.Subject()
+    subject: new Rx2.Subject()
   };
   const core = target(store);
   core.transactions = import_hamt_plus4.default.set(
@@ -839,6 +889,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;
@@ -854,24 +905,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 = import_hamt_plus5.default.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
-var Rx3 = __toESM(require("rxjs"));
+var Rx4 = __toESM(require("rxjs"));
 
 // ../anvl/src/json/index.ts
 var import_function8 = require("fp-ts/function");
@@ -879,7 +934,7 @@ 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;
@@ -908,7 +963,7 @@ 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);
@@ -940,7 +995,7 @@ 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);
@@ -969,9 +1024,123 @@ function selectorFamily__INTERNAL(options, store = IMPLICIT.STORE) {
   );
 }
 
+// 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 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
-var import_hamt_plus5 = __toESM(require("hamt_plus"));
-var Rx4 = __toESM(require("rxjs"));
+var import_hamt_plus6 = __toESM(require("hamt_plus"));
+var Rx5 = __toESM(require("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 = [];
@@ -1003,7 +1172,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}`
     );
@@ -1015,7 +1187,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) => ({
@@ -1036,9 +1211,12 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
         dependencyValue,
         `)`
       );
-      core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
-        source: dependency.key
-      });
+      core.selectorGraph = core.selectorGraph.set(
+        { from: dependency.key, to: selectorKey },
+        {
+          source: dependency.key
+        }
+      );
     }
     updateSelectorAtoms(selectorKey, dependency, store);
     return dependencyValue;
@@ -1051,12 +1229,12 @@ var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
 function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a, _b, _c;
   const core = target(store);
-  if (import_hamt_plus5.default.has(options.key, core.selectors)) {
+  if (import_hamt_plus6.default.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 });
@@ -1069,14 +1247,20 @@ function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
       get: getSelf,
       type: `readonly_selector`
     }), family && { family });
-    core.readonlySelectors = import_hamt_plus5.default.set(
+    core.readonlySelectors = import_hamt_plus6.default.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;
@@ -1096,14 +1280,20 @@ function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
     set: setSelf,
     type: `selector`
   }), family && { family });
-  core.selectors = import_hamt_plus5.default.set(options.key, mySelector, core.selectors);
+  core.selectors = import_hamt_plus6.default.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
-var import_hamt_plus6 = __toESM(require("hamt_plus"));
+var import_hamt_plus7 = __toESM(require("hamt_plus"));
 var evictDownStream = (state, store = IMPLICIT.STORE) => {
   var _a, _b;
   const core = target(store);
@@ -1122,7 +1312,7 @@ var evictDownStream = (state, store = IMPLICIT.STORE) => {
       (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   || ${stateKey} already done`);
       return;
     }
-    const state2 = (_b2 = import_hamt_plus6.default.get(stateKey, core.selectors)) != null ? _b2 : import_hamt_plus6.default.get(stateKey, core.readonlySelectors);
+    const state2 = (_b2 = import_hamt_plus7.default.get(stateKey, core.selectors)) != null ? _b2 : import_hamt_plus7.default.get(stateKey, core.readonlySelectors);
     if (!state2) {
       (_c = store.config.logger) == null ? void 0 : _c.info(
         `   || ${stateKey} is an atom, and can't be downstream`
@@ -1223,43 +1413,123 @@ var subscribeToRootAtoms = (state, store) => {
   return dependencySubscriptions;
 };
 
+// src/internal/time-travel-internal.ts
+var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
+  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) {
+    (_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) {
+    (_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 `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;
+        setState({ key, type: `atom` }, newValue);
+      }
+      break;
+    }
+  }
+  ++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, _c, _d;
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u23EA undo "${token.key}"`);
+  const timelineData = store.timelineStore.get(token.key);
+  if (!timelineData) {
+    (_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) {
+    (_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;
+  }
+  timelineData.timeTraveling = true;
+  --timelineData.at;
+  const update = timelineData.history[timelineData.at];
+  switch (update.type) {
+    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;
+        setState({ key, type: `atom` }, oldValue);
+      }
+      break;
+    }
+  }
+  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
-var import_hamt_plus7 = __toESM(require("hamt_plus"));
+var import_hamt_plus8 = __toESM(require("hamt_plus"));
 function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
   var _a, _b;
-  let incompleteSelectorTime = null;
-  let incompleteTransactionKey = null;
   const timelineData = {
     at: 0,
     timeTraveling: false,
-    history: []
+    history: [],
+    selectorTime: null,
+    transactionKey: null
   };
-  const subscribeToAtom = (token) => {
-    const state = withdraw(token, store);
+  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 "${token.key}" go (`,
+        `\u23F3 timeline "${options.key}" saw atom "${token2.key}" go (`,
         update.oldValue,
         `->`,
         update.newValue,
-        storeCurrentTransactionKey ? `) in "${storeCurrentTransactionKey}"` : `) independently`
+        storeCurrentTransactionKey ? `) in transaction "${storeCurrentTransactionKey}"` : storeCurrentSelectorKey ? `) in selector "${storeCurrentSelectorKey}"` : `)`
       );
       if (storeCurrentTransactionKey && store.transactionStatus.phase === `applying`) {
         const currentTransaction = withdraw(
           { key: storeCurrentTransactionKey, type: `transaction` },
           store
         );
-        if (incompleteTransactionKey !== storeCurrentTransactionKey) {
-          if (incompleteTransactionKey) {
+        if (timelineData.transactionKey !== storeCurrentTransactionKey) {
+          if (timelineData.transactionKey) {
             (_b2 = store.config.logger) == null ? void 0 : _b2.error(
-              `Timeline "${options.key}" was unable to resolve transaction "${incompleteTransactionKey}. This is probably a bug.`
+              `Timeline "${options.key}" was unable to resolve transaction "${timelineData.transactionKey}. This is probably a bug.`
             );
           }
-          incompleteTransactionKey = storeCurrentTransactionKey;
+          timelineData.transactionKey = storeCurrentTransactionKey;
           const subscription = currentTransaction.subject.subscribe((update2) => {
             var _a3;
             if (timelineData.timeTraveling === false) {
@@ -1276,7 +1546,7 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
             }
             timelineData.at = timelineData.history.length;
             subscription.unsubscribe();
-            incompleteTransactionKey = null;
+            timelineData.transactionKey = null;
             (_a3 = store.config.logger) == null ? void 0 : _a3.info(
               `\u231B timeline "${options.key}" got a transaction_update "${update2.key}"`
             );
@@ -1284,14 +1554,14 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
         }
       } else if (storeCurrentSelectorKey) {
         if (timelineData.timeTraveling === false) {
-          if (storeCurrentSelectorTime !== incompleteSelectorTime) {
+          if (storeCurrentSelectorTime !== timelineData.selectorTime) {
             const newSelectorUpdate = {
               type: `selector_update`,
               key: storeCurrentSelectorKey,
               atomUpdates: []
             };
             newSelectorUpdate.atomUpdates.push(__spreadValues({
-              key: token.key,
+              key: token2.key,
               type: `atom_update`
             }, update));
             if (timelineData.at !== timelineData.history.length) {
@@ -1303,12 +1573,12 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
               newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
             );
             timelineData.at = timelineData.history.length;
-            incompleteSelectorTime = storeCurrentSelectorTime;
+            timelineData.selectorTime = storeCurrentSelectorTime;
           } else {
             const latestUpdate = timelineData.history.at(-1);
             if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
               latestUpdate.atomUpdates.push(__spreadValues({
-                key: token.key,
+                key: token2.key,
                 type: `atom_update`
               }, update));
               (_d = store.config.logger) == null ? void 0 : _d.info(
@@ -1320,18 +1590,18 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
         }
       } else {
         if (timelineData.timeTraveling === false) {
-          incompleteSelectorTime = null;
+          timelineData.selectorTime = null;
           if (timelineData.at !== timelineData.history.length) {
             timelineData.history.splice(timelineData.at);
           }
           timelineData.history.push({
             type: `atom_update`,
-            key: token.key,
+            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 "${token.key}"`
+            `\u231B timeline "${options.key}" got a state_update to "${token2.key}"`
           );
           timelineData.at = timelineData.history.length;
         }
@@ -1349,108 +1619,35 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE) {
     }
     if (tokenOrFamily.type === `atom_family`) {
       const family = tokenOrFamily;
-      family.subject.subscribe((token) => subscribeToAtom(token));
+      family.subject.subscribe((token2) => subscribeToAtom(token2));
     } else {
-      const token = tokenOrFamily;
-      if (`family` in token && token.family) {
+      const token2 = tokenOrFamily;
+      if (`family` in token2 && token2.family) {
         const familyTimelineKey = core.timelineAtoms.getRelatedId(
-          token.family.key
+          token2.family.key
         );
         if (familyTimelineKey) {
           (_b = store.config.logger) == null ? void 0 : _b.error(
-            `\u274C Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`
+            `\u274C Failed to add atom "${token2.key}" to timeline "${options.key}" because its family "${token2.family.key}" belongs to timeline "${familyTimelineKey}"`
           );
           continue;
         }
       }
-      subscribeToAtom(token);
+      subscribeToAtom(token2);
     }
-    core.timelineAtoms = core.timelineAtoms.set(tokenOrFamily.key, options.key);
+    core.timelineAtoms = core.timelineAtoms.set({
+      atomKey: tokenOrFamily.key,
+      timelineKey: options.key
+    });
   }
-  store.timelineStore = import_hamt_plus7.default.set(options.key, timelineData, store.timelineStore);
-  return {
+  store.timelineStore = import_hamt_plus8.default.set(options.key, timelineData, store.timelineStore);
+  const token = {
     key: options.key,
     type: `timeline`
   };
+  store.subject.timelineCreation.next(token);
+  return token;
 }
-var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
-  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) {
-    (_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) {
-    (_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 `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;
-        setState({ key, type: `atom` }, newValue);
-      }
-      break;
-    }
-  }
-  ++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, _c, _d;
-  (_a = store.config.logger) == null ? void 0 : _a.info(`\u23EA undo "${token.key}"`);
-  const timelineData = store.timelineStore.get(token.key);
-  if (!timelineData) {
-    (_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) {
-    (_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;
-  }
-  timelineData.timeTraveling = true;
-  --timelineData.at;
-  const update = timelineData.history[timelineData.at];
-  switch (update.type) {
-    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;
-        setState({ key, type: `atom` }, oldValue);
-      }
-      break;
-    }
-  }
-  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/atom.ts
 function atom(options) {