atom.io 0.6.5 → 0.6.7

package/dist/index.mjs

@@ -41,7 +41,6 @@ var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 var internal_exports = {};
 __export(internal_exports, {
   IMPLICIT: () => IMPLICIT,
-  META: () => meta_exports,
   Subject: () => Subject,
   TRANSACTION_PHASES: () => TRANSACTION_PHASES,
   abortTransaction: () => abortTransaction,
@@ -98,21 +97,17 @@ __export(internal_exports, {
   withdraw: () => withdraw
 });
 
-// src/internal/atom-internal.ts
-import HAMT5 from "hamt_plus";
-
 // src/internal/get.ts
-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`;
+  const type = core.atoms.has(key) ? `atom` : core.selectors.has(key) ? `selector` : `readonly_selector`;
   return { key, type };
 }
 function withdraw(token, store) {
   var _a, _b, _c, _d, _e;
   const core = target(store);
-  return (_e = (_d = (_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)) != null ? _d : HAMT.get(token.key, core.timelines)) != null ? _e : null;
+  return (_e = (_d = (_c = (_b = (_a = core.atoms.get(token.key)) != null ? _a : core.selectors.get(token.key)) != null ? _b : core.readonlySelectors.get(token.key)) != null ? _c : core.transactions.get(token.key)) != null ? _d : core.timelines.get(token.key)) != null ? _e : null;
 }
 function deposit(state) {
   return __spreadValues({
@@ -155,12 +150,6 @@ var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
   return roots.every((root) => isAtomDefault(root.key, store));
 };
 
-// src/internal/operation.ts
-import HAMT3 from "hamt_plus";
-
-// src/internal/store.ts
-import HAMT2 from "hamt_plus";
-
 // ../anvl/src/function/index.ts
 var doNothing = () => void 0;
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
@@ -168,62 +157,8 @@ var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing insta
 ) : nextVersionOfThing;
 var pass = (...params) => (fn) => fn(...params);
 
-// ../../node_modules/.pnpm/fp-ts@2.16.0/node_modules/fp-ts/es6/function.js
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
-  switch (arguments.length) {
-    case 1:
-      return a;
-    case 2:
-      return ab(a);
-    case 3:
-      return bc(ab(a));
-    case 4:
-      return cd(bc(ab(a)));
-    case 5:
-      return de(cd(bc(ab(a))));
-    case 6:
-      return ef(de(cd(bc(ab(a)))));
-    case 7:
-      return fg(ef(de(cd(bc(ab(a))))));
-    case 8:
-      return gh(fg(ef(de(cd(bc(ab(a)))))));
-    case 9:
-      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    default: {
-      var ret = arguments[0];
-      for (var i = 1; i < arguments.length; i++) {
-        ret = arguments[i](ret);
-      }
-      return ret;
-    }
-  }
-}
-
-// ../../node_modules/.pnpm/fp-ts@2.16.0/node_modules/fp-ts/es6/string.js
-var Eq = {
-  equals: function(first, second) {
-    return first === second;
-  }
-};
-var Semigroup = {
-  concat: function(first, second) {
-    return first + second;
-  }
-};
-var empty = "";
-var Monoid = {
-  concat: Semigroup.concat,
-  empty
-};
-var Ord = {
-  equals: Eq.equals,
-  compare: function(first, second) {
-    return first < second ? -1 : first > second ? 1 : 0;
-  }
-};
-var isString = function(u) {
-  return typeof u === "string";
-};
+// ../anvl/src/join/core-relation-data.ts
+import { isString } from "fp-ts/string";
 
 // ../anvl/src/array/venn.ts
 var includesAll = (items) => (array) => {
@@ -244,6 +179,9 @@ var addTo = (a) => (x) => a.includes(x) ? a : [...a, x];
 var isEmptyArray = (input) => Array.isArray(input) && input.length === 0;
 var isOneOf = (...args) => (input) => args.includes(input);
 
+// ../anvl/src/object/refinement.ts
+import { pipe as pipe2 } from "fp-ts/function";
+
 // ../anvl/src/object/access.ts
 var access = (k) => Object.assign((obj) => obj[k], {
   in: (obj) => obj[k]
@@ -254,6 +192,7 @@ var recordToEntries = (obj) => Object.entries(obj);
 var entriesToRecord = (entries) => Object.fromEntries(entries);
 
 // ../anvl/src/object/mapObject.ts
+import { pipe } from "fp-ts/function";
 var mapObject = (obj, fn) => pipe(
   obj,
   recordToEntries,
@@ -276,14 +215,14 @@ var hasProperties = (isValue, options = { allowExtraProperties: false }) => {
     isValue
   ).map(([k, v]) => String(k) + `:` + v.name).join(`,`)}}`;
   const _ = {
-    [name]: (input) => isPlainObject(input) && pipe(
+    [name]: (input) => isPlainObject(input) && pipe2(
       isValue,
       Object.entries,
       every(([key, val]) => key in input || val(void 0))
-    ) && pipe(
+    ) && pipe2(
       input,
       mob(
-        (val, key) => pipe(
+        (val, key) => pipe2(
           isValue,
           access(key),
           ifNullish(() => options.allowExtraProperties),
@@ -401,6 +340,9 @@ var makeJsonInterface = (join, ...params) => {
   };
 };
 
+// ../anvl/src/join/relation-contents.ts
+import { pipe as pipe5 } from "fp-ts/function";
+
 // ../anvl/src/join/relation-record.ts
 var getRelationEntries = (relationMap, idA) => getRelatedIds(relationMap, idA).map((idB) => [
   idB,
@@ -408,7 +350,12 @@ var getRelationEntries = (relationMap, idA) => getRelatedIds(relationMap, idA).m
 ]);
 var getRelationRecord = (relationMap, id) => Object.fromEntries(getRelationEntries(relationMap, id));
 
+// ../anvl/src/join/remove-relation.ts
+import { pipe as pipe4 } from "fp-ts/function";
+import { isString as isString2 } from "fp-ts/string";
+
 // ../anvl/src/object/index.ts
+import { pipe as pipe3 } from "fp-ts/function";
 var treeShake = (shouldDiscard = isUndefined) => (obj) => {
   const newObj = {};
   const entries = Object.entries(obj);
@@ -425,7 +372,7 @@ var split = (separator) => (str) => str.split(separator);
 var removeSpecific = (current, idA, idB) => {
   const isIdForRemoval = isOneOf(idA, idB);
   return __spreadProps(__spreadValues({}, current), {
-    relations: pipe(
+    relations: pipe4(
       current.relations,
       recordToEntries,
       map(([id, relations]) => [
@@ -435,17 +382,17 @@ var removeSpecific = (current, idA, idB) => {
       entriesToRecord,
       treeShake(isEmptyArray)
     ),
-    contents: pipe(
+    contents: pipe4(
       current.contents,
       treeShake(
-        (_, key) => isString(key) && pipe(key, split(`/`), comprises([idA, idB]))
+        (_, key) => isString2(key) && pipe4(key, split(`/`), comprises([idA, idB]))
       )
     )
   });
 };
 var removeAll = (current, idToRemove) => {
   const next = __spreadProps(__spreadValues({}, current), {
-    relations: pipe(
+    relations: pipe4(
       current.relations,
       recordToEntries,
       map(([id, relations]) => [
@@ -455,10 +402,10 @@ var removeAll = (current, idToRemove) => {
       entriesToRecord,
       treeShake((val, key) => key === idToRemove || isEmptyArray(val))
     ),
-    contents: pipe(
+    contents: pipe4(
       current.contents,
       treeShake(
-        (_, key) => isString(key) && key.split(`/`).includes(idToRemove)
+        (_, key) => isString2(key) && key.split(`/`).includes(idToRemove)
       )
     )
   });
@@ -540,7 +487,7 @@ var getRelations = (relationMap, id) => getRelationEntries(relationMap, id).map(
 var setRelations = (current, subject, relations) => {
   const idA = subject[current.a];
   const idB = subject[current.b];
-  return pipe(
+  return pipe5(
     current,
     (relationData) => {
       const relatedIds = getRelatedIds(current, idA);
@@ -655,24 +602,25 @@ var Join = class _Join {
 // src/internal/store.ts
 var createStore = (name, store = null) => {
   var _a;
-  const copiedStore = __spreadProps(__spreadValues({}, store != null ? store : (() => ({
+  const created = __spreadProps(__spreadValues({}, store != null ? store : (() => ({
     atomsThatAreDefault: /* @__PURE__ */ new Set(),
     selectorAtoms: new Join({ relationType: `n:n` }).from(`selectorKey`).to(`atomKey`),
-    selectorGraph: new Join({ relationType: `n:n` }),
-    valueMap: HAMT2.make()
+    selectorGraph: new Join({ relationType: `n:n` })
   }))()), {
-    atoms: HAMT2.make(),
-    readonlySelectors: HAMT2.make(),
-    selectors: HAMT2.make(),
-    transactions: HAMT2.make(),
-    timelines: HAMT2.make(),
+    valueMap: new Map(store == null ? void 0 : store.valueMap),
+    atoms: /* @__PURE__ */ new Map(),
+    readonlySelectors: /* @__PURE__ */ new Map(),
+    selectors: /* @__PURE__ */ new Map(),
+    transactions: /* @__PURE__ */ new Map(),
+    timelines: /* @__PURE__ */ new Map(),
     timelineAtoms: new Join({ relationType: `1:n` }).from(`timelineKey`).to(`atomKey`),
-    subject: __spreadValues({
+    subject: {
       atomCreation: new Subject(),
       selectorCreation: new Subject(),
       transactionCreation: new Subject(),
-      timelineCreation: new Subject()
-    }, store == null ? void 0 : store.subject),
+      timelineCreation: new Subject(),
+      operationStatus: new Subject()
+    },
     operation: __spreadValues({
       open: false
     }, store == null ? void 0 : store.operation),
@@ -690,21 +638,21 @@ var createStore = (name, store = null) => {
   });
   store == null ? void 0 : store.atoms.forEach((atom2) => {
     const copiedAtom = __spreadProps(__spreadValues({}, atom2), { subject: new Subject() });
-    copiedStore.atoms = HAMT2.set(atom2.key, copiedAtom, copiedStore.atoms);
+    created.atoms.set(atom2.key, copiedAtom);
   });
   store == null ? void 0 : store.readonlySelectors.forEach((selector2) => {
-    selector2.install(copiedStore);
+    selector2.install(created);
   });
   store == null ? void 0 : store.selectors.forEach((selector2) => {
-    selector2.install(copiedStore);
+    selector2.install(created);
   });
   store == null ? void 0 : store.transactions.forEach((tx) => {
-    tx.install(copiedStore);
+    tx.install(created);
   });
   store == null ? void 0 : store.timelines.forEach((timeline2) => {
-    timeline2.install(copiedStore);
+    timeline2.install(created);
   });
-  return copiedStore;
+  return created;
 };
 var IMPLICIT = {
   STORE_INTERNAL: void 0,
@@ -732,7 +680,7 @@ var openOperation = (token, store) => {
   core.operation = {
     open: true,
     done: /* @__PURE__ */ new Set(),
-    prev: store.valueMap,
+    prev: new Map(store.valueMap),
     time: Date.now(),
     token
   };
@@ -745,6 +693,7 @@ var closeOperation = (store) => {
   const core = target(store);
   core.operation = { open: false };
   (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F534} operation done`);
+  store.subject.operationStatus.next(core.operation);
 };
 var isDone = (key, store = IMPLICIT.STORE) => {
   var _a;
@@ -775,43 +724,38 @@ var recallState = (state, store = IMPLICIT.STORE) => {
     (_a = store.config.logger) == null ? void 0 : _a.warn(
       `recall called outside of an operation. This is probably a bug.`
     );
-    return HAMT3.get(state.key, core.valueMap);
+    return core.valueMap.get(state.key);
   }
-  return HAMT3.get(state.key, core.operation.prev);
+  return core.operation.prev.get(state.key);
 };
 var cacheValue = (key, value, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.valueMap = HAMT3.set(key, value, core.valueMap);
+  core.valueMap.set(key, value);
 };
 var evictCachedValue = (key, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.valueMap = HAMT3.remove(key, core.valueMap);
+  core.valueMap.delete(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 readCachedValue = (key, store = IMPLICIT.STORE) => target(store).valueMap.get(key);
+var isValueCached = (key, store = IMPLICIT.STORE) => target(store).valueMap.has(key);
 var storeAtom = (atom2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.atoms = HAMT3.set(atom2.key, atom2, core.atoms);
+  core.atoms.set(atom2.key, atom2);
 };
 var storeSelector = (selector2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.selectors = HAMT3.set(selector2.key, selector2, core.selectors);
+  core.selectors.set(selector2.key, selector2);
 };
 var storeReadonlySelector = (selector2, store = IMPLICIT.STORE) => {
   const core = target(store);
-  core.readonlySelectors = HAMT3.set(
-    selector2.key,
-    selector2,
-    core.readonlySelectors
-  );
+  core.readonlySelectors.set(selector2.key, selector2);
 };
 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);
+  return core.atoms.has(key) || core.selectors.has(key) || core.readonlySelectors.has(key);
 };
 
 // src/internal/transaction-internal.ts
-import HAMT4 from "hamt_plus";
 function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
   const newTransaction = {
     key: options.key,
@@ -839,11 +783,7 @@ function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
     subject: new Subject()
   };
   const core = target(store);
-  core.transactions = HAMT4.set(
-    newTransaction.key,
-    newTransaction,
-    core.transactions
-  );
+  core.transactions.set(newTransaction.key, newTransaction);
   const token = deposit(newTransaction);
   store.subject.transactionCreation.next(token);
   return token;
@@ -854,12 +794,13 @@ var target = (store = IMPLICIT.STORE) => store.transactionStatus.phase === `buil
 function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a, _b, _c;
   const core = target(store);
-  if (hasKeyBeenUsed(options.key, store)) {
+  const existing = core.atoms.get(options.key);
+  if (existing) {
     (_b = (_a = store.config.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
       _a,
       `Key "${options.key}" already exists in the store.`
     );
-    return deposit(core.atoms.get(options.key));
+    return deposit(existing);
   }
   const subject = new Subject();
   const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
@@ -867,7 +808,7 @@ function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
     type: `atom`
   }), family && { family });
   const initialValue = options.default instanceof Function ? options.default() : options.default;
-  core.atoms = HAMT5.set(newAtom.key, newAtom, core.atoms);
+  core.atoms.set(newAtom.key, newAtom);
   markAtomAsDefault(options.key, store);
   cacheValue(options.key, initialValue, store);
   const token = deposit(newAtom);
@@ -882,6 +823,7 @@ function atom__INTERNAL(options, family, store = IMPLICIT.STORE) {
 }
 
 // ../anvl/src/json/index.ts
+import { pipe as pipe6 } from "fp-ts/function";
 var stringifyJson = (json) => JSON.stringify(json);
 
 // src/internal/families-internal.ts
@@ -976,125 +918,7 @@ 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
-import HAMT9 from "hamt_plus";
-
 // src/internal/selector/create-read-write-selector.ts
-import HAMT6 from "hamt_plus";
 var createReadWriteSelector = (options, family, store, core) => {
   var _a;
   const subject = new Subject();
@@ -1106,8 +930,14 @@ var createReadWriteSelector = (options, family, store, core) => {
   };
   const setSelf = (next) => {
     var _a2;
-    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   <- "${options.key}" became`, next);
     const oldValue = getSelf();
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+      `   <- "${options.key}" went (`,
+      oldValue,
+      `->`,
+      next,
+      `)`
+    );
     const newValue = become(next)(oldValue);
     cacheValue(options.key, newValue, store);
     markDone(options.key, store);
@@ -1123,7 +953,7 @@ var createReadWriteSelector = (options, family, store, core) => {
     set: setSelf,
     type: `selector`
   }), family && { family });
-  core.selectors = HAMT6.set(options.key, mySelector, core.selectors);
+  core.selectors.set(options.key, mySelector);
   const initialValue = getSelf();
   (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
   const token = {
@@ -1135,9 +965,6 @@ var createReadWriteSelector = (options, family, store, core) => {
   return token;
 };
 
-// src/internal/selector/create-readonly-selector.ts
-import HAMT8 from "hamt_plus";
-
 // src/internal/selector/lookup-selector-sources.ts
 var lookupSelectorSources = (key, store) => target(store).selectorGraph.getRelations(key).filter(({ source }) => source !== key).map(({ source }) => lookup(source, store));
 
@@ -1197,7 +1024,6 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 };
 
 // src/internal/set.ts
-import HAMT7 from "hamt_plus";
 var evictDownStream = (state, store = IMPLICIT.STORE) => {
   var _a, _b;
   const core = target(store);
@@ -1216,7 +1042,7 @@ var evictDownStream = (state, store = IMPLICIT.STORE) => {
       (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   || ${stateKey} already done`);
       return;
     }
-    const state2 = (_b2 = HAMT7.get(stateKey, core.selectors)) != null ? _b2 : HAMT7.get(stateKey, core.readonlySelectors);
+    const state2 = (_b2 = core.selectors.get(stateKey)) != null ? _b2 : core.readonlySelectors.get(stateKey);
     if (!state2) {
       (_c = store.config.logger) == null ? void 0 : _c.info(
         `   || ${stateKey} is an atom, and can't be downstream`
@@ -1326,11 +1152,7 @@ var createReadonlySelector = (options, family, store, core) => {
     get: getSelf,
     type: `readonly_selector`
   }), family && { family });
-  core.readonlySelectors = HAMT8.set(
-    options.key,
-    readonlySelector,
-    core.readonlySelectors
-  );
+  core.readonlySelectors.set(options.key, readonlySelector);
   const initialValue = getSelf();
   (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
   const token = {
@@ -1346,7 +1168,7 @@ var createReadonlySelector = (options, family, store, core) => {
 function selector__INTERNAL(options, family, store = IMPLICIT.STORE) {
   var _a;
   const core = target(store);
-  if (HAMT9.has(options.key, core.selectors)) {
+  if (core.selectors.has(options.key)) {
     (_a = store.config.logger) == null ? void 0 : _a.error(
       `Key "${options.key}" already exists in the store.`
     );
@@ -1430,7 +1252,13 @@ var subscribeToRootAtoms = (state, store) => {
       );
       const oldValue = recallState(state, store);
       const newValue = getState__INTERNAL(state, store);
-      (_b = store.config.logger) == null ? void 0 : _b.info(`   <- ${state.key} became`, newValue);
+      (_b = store.config.logger) == null ? void 0 : _b.info(
+        `   <- "${state.key}" went (`,
+        oldValue,
+        `->`,
+        newValue,
+        `)`
+      );
       state.subject.next({ newValue, oldValue });
     });
   });
@@ -1472,6 +1300,7 @@ var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
     }
   }
   ++timelineData.at;
+  timelineData.subject.next(`redo`);
   timelineData.timeTraveling = false;
   (_d = store.config.logger) == null ? void 0 : _d.info(
     `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
@@ -1511,15 +1340,13 @@ var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
       break;
     }
   }
+  timelineData.subject.next(`undo`);
   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 HAMT10 from "hamt_plus";
-
 // src/internal/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
   const atom2 = withdraw(atomToken, store);
@@ -1549,9 +1376,6 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
             `Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`
           );
         }
-        if (mostRecentUpdate.type === `selector_update`) {
-          tl.subject.next(mostRecentUpdate);
-        }
       }
       if (currentTransactionKey && store.transactionStatus.phase === `applying`) {
         const currentTransaction = withdraw(
@@ -1572,6 +1396,7 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
           tl.transactionKey = currentTransactionKey;
           const subscription = currentTransaction.subject.subscribe((update2) => {
             var _a2;
+            subscription.unsubscribe();
             if (tl.timeTraveling === false && currentTransactionTime) {
               if (tl.at !== tl.history.length) {
                 tl.history.splice(tl.at);
@@ -1585,10 +1410,9 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
                 )
               });
               tl.history.push(timelineTransactionUpdate);
+              tl.at = tl.history.length;
               tl.subject.next(timelineTransactionUpdate);
             }
-            tl.at = tl.history.length;
-            subscription.unsubscribe();
             tl.transactionKey = null;
             (_a2 = store.config.logger) == null ? void 0 : _a2.info(
               `\u231B timeline "${tl.key}" got a transaction_update "${update2.key}"`
@@ -1596,29 +1420,29 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
           });
         }
       } else if (currentSelectorKey && currentSelectorTime) {
+        let latestUpdate = tl.history.at(-1);
         if (currentSelectorTime !== tl.selectorTime) {
-          const newSelectorUpdate = {
+          latestUpdate = {
             type: `selector_update`,
             timestamp: currentSelectorTime,
             key: currentSelectorKey,
             atomUpdates: []
           };
-          newSelectorUpdate.atomUpdates.push(__spreadValues({
+          latestUpdate.atomUpdates.push(__spreadValues({
             key: atom2.key,
             type: `atom_update`
           }, update));
           if (tl.at !== tl.history.length) {
             tl.history.splice(tl.at);
           }
-          tl.history.push(newSelectorUpdate);
+          tl.history.push(latestUpdate);
           (_c = store.config.logger) == null ? void 0 : _c.info(
             `\u231B timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
-            newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
           );
           tl.at = tl.history.length;
           tl.selectorTime = currentSelectorTime;
         } else {
-          const latestUpdate = tl.history.at(-1);
           if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
             latestUpdate.atomUpdates.push(__spreadValues({
               key: atom2.key,
@@ -1630,6 +1454,8 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
             );
           }
         }
+        if (latestUpdate)
+          tl.subject.next(latestUpdate);
       } else {
         const timestamp = Date.now();
         tl.selectorTime = null;
@@ -1646,7 +1472,7 @@ var addAtomToTimeline = (atomToken, atoms, tl, store = IMPLICIT.STORE) => {
         tl.history.push(atomUpdate);
         tl.subject.next(atomUpdate);
         (_e = store.config.logger) == null ? void 0 : _e.info(
-          `\u231B timeline "${tl.key}" got a state_update to "${atom2.key}"`
+          `\u231B timeline "${tl.key}" got an atom_update to "${atom2.key}"`
         );
         tl.at = tl.history.length;
       }
@@ -1702,7 +1528,7 @@ function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
       timelineKey: options.key
     });
   }
-  store.timelines = HAMT10.set(options.key, tl, store.timelines);
+  store.timelines.set(options.key, tl);
   const token = {
     key: options.key,
     type: `timeline`
@@ -1725,7 +1551,6 @@ var abortTransaction = (store) => {
 };
 
 // src/internal/transaction/apply-transaction.ts
-import HAMT11 from "hamt_plus";
 var applyTransaction = (output, store) => {
   var _a, _b, _c, _d;
   if (store.transactionStatus.phase !== `building`) {
@@ -1742,10 +1567,15 @@ var applyTransaction = (output, store) => {
   const { atomUpdates } = store.transactionStatus;
   for (const { key, newValue } of atomUpdates) {
     const token = { key, type: `atom` };
-    if (!HAMT11.has(token.key, store.valueMap)) {
-      const newAtom = HAMT11.get(token.key, store.transactionStatus.core.atoms);
-      store.atoms = HAMT11.set(newAtom.key, newAtom, store.atoms);
-      store.valueMap = HAMT11.set(newAtom.key, newAtom.default, store.valueMap);
+    if (!store.valueMap.has(token.key)) {
+      const newAtom = store.transactionStatus.core.atoms.get(token.key);
+      if (!newAtom) {
+        throw new Error(
+          `Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`
+        );
+      }
+      store.atoms.set(newAtom.key, newAtom);
+      store.valueMap.set(newAtom.key, newAtom.default);
       (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F527}`, `add atom "${newAtom.key}"`);
     }
     setState(token, newValue, store);
@@ -1777,17 +1607,17 @@ var buildTransaction = (key, params, store) => {
     phase: `building`,
     time: Date.now(),
     core: {
-      atoms: store.atoms,
+      atoms: new Map(store.atoms),
       atomsThatAreDefault: store.atomsThatAreDefault,
       operation: { open: false },
-      readonlySelectors: store.readonlySelectors,
-      timelines: store.timelines,
+      readonlySelectors: new Map(store.readonlySelectors),
+      timelines: new Map(store.timelines),
       timelineAtoms: store.timelineAtoms,
-      transactions: store.transactions,
+      transactions: new Map(store.transactions),
       selectorAtoms: store.selectorAtoms,
       selectorGraph: store.selectorGraph,
-      selectors: store.selectors,
-      valueMap: store.valueMap
+      selectors: new Map(store.selectors),
+      valueMap: new Map(store.valueMap)
     },
     atomUpdates: [],
     params,