atom.io 0.14.0 → 0.14.2

package/internal/dist/index.cjs

@@ -1,9 +1,5 @@
 'use strict';
 
-var atom_io = require('atom.io');
-var json = require('atom.io/json');
-var internal = require('atom.io/internal');
-
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -24,7 +20,78 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
-// src/future.ts
+// src/get-state.ts
+function getState(token, store = IMPLICIT.STORE) {
+  var _a;
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  return readOrComputeValue(state, store);
+}
+
+// src/logger.ts
+var simpleLog = (logLevel) => (icon, tokenType, tokenKey, message, ...rest) => {
+  console[logLevel](`${icon} ${tokenType} "${tokenKey}" ${message}`, ...rest);
+};
+var simpleLogger = {
+  error: simpleLog(`error`),
+  info: simpleLog(`info`),
+  warn: simpleLog(`warn`)
+};
+var AtomIOLogger = class {
+  constructor(logLevel, filter, logger = simpleLogger) {
+    this.logLevel = logLevel;
+    this.filter = filter;
+    this.logger = logger;
+    this.error = (...args) => {
+      var _a, _b;
+      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== null) {
+        this.logger.error(...args);
+      }
+    };
+    this.info = (...args) => {
+      var _a, _b;
+      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel === `info`) {
+        this.logger.info(...args);
+      }
+    };
+    this.warn = (...args) => {
+      var _a, _b;
+      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== `error` && this.logLevel !== null) {
+        this.logger.warn(...args);
+      }
+    };
+  }
+};
+
+// src/set-state.ts
+function setState(token, value, store = IMPLICIT.STORE) {
+  var _a;
+  const rejection = openOperation(token, store);
+  if (rejection) {
+    return;
+  }
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
+// src/transaction.ts
+var runTransaction = (token, store = IMPLICIT.STORE) => (...parameters) => {
+  const tx = withdraw(token, store);
+  if (tx) {
+    return tx.run(...parameters);
+  }
+  throw new Error(
+    `Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`
+  );
+};
+
+// internal/src/future.ts
 var Future = class extends Promise {
   constructor(executor) {
     super((resolve, reject) => {
@@ -43,7 +110,7 @@ var Future = class extends Promise {
   }
 };
 
-// src/lineage.ts
+// internal/src/lineage.ts
 function newest(scion) {
   while (scion.child !== null) {
     scion = scion.child;
@@ -57,7 +124,7 @@ function eldest(scion) {
   return scion;
 }
 
-// src/caching.ts
+// internal/src/caching.ts
 function cacheValue(key, value, subject, store) {
   const target = newest(store);
   const currentValue = target.valueMap.get(key);
@@ -102,7 +169,45 @@ var evictCachedValue = (key, store) => {
   store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
 };
 
-// src/read-or-compute-value.ts
+// ../anvl/src/json/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+
+// json/src/select-json.ts
+var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
+  return createSelector(
+    {
+      key: `${atom.key}:JSON`,
+      get: ({ get }) => transform.toJson(get(atom)),
+      set: ({ set }, newValue) => set(atom, transform.fromJson(newValue))
+    },
+    void 0,
+    store
+  );
+};
+
+// json/src/select-json-family.ts
+var selectJsonFamily = (atomFamily, transform, store = IMPLICIT.STORE) => {
+  const jsonFamily = createSelectorFamily(
+    {
+      key: `${atomFamily.key}:JSON`,
+      get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
+      set: (key) => ({ set }, newValue) => set(atomFamily(key), transform.fromJson(newValue))
+    },
+    store
+  );
+  atomFamily.subject.subscribe(
+    `store=${store.config.name}::json-selector-family`,
+    (token) => {
+      if (token.family) {
+        jsonFamily(parseJson(token.family.subKey));
+      }
+    }
+  );
+  return jsonFamily;
+};
+
+// internal/src/read-or-compute-value.ts
 var readOrComputeValue = (state, store) => {
   if (isValueCached(state.key, store)) {
     store.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
@@ -123,7 +228,7 @@ var readOrComputeValue = (state, store) => {
   return state.default instanceof Function ? state.default() : state.default;
 };
 
-// src/operation.ts
+// internal/src/operation.ts
 var openOperation = (token, store) => {
   const target = newest(store);
   if (target.operation.open) {
@@ -189,12 +294,12 @@ var markDone = (key, store) => {
   target.operation.done.add(key);
 };
 
-// src/set-state/become.ts
+// internal/src/set-state/become.ts
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
   originalThing instanceof Function ? originalThing() : originalThing
 ) : nextVersionOfThing;
 
-// src/subject.ts
+// internal/src/subject.ts
 var Subject = class {
   constructor() {
     this.subscribers = /* @__PURE__ */ new Map();
@@ -208,7 +313,8 @@ var Subject = class {
     this.subscribers.delete(key);
   }
   next(value) {
-    for (const subscriber of this.subscribers.values()) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
       subscriber(value);
     }
   }
@@ -224,7 +330,7 @@ var StatefulSubject = class extends Subject {
   }
 };
 
-// src/set-state/copy-mutable-if-needed.ts
+// internal/src/set-state/copy-mutable-if-needed.ts
 function copyMutableIfNeeded(atom, transform, origin, target) {
   const originValue = origin.valueMap.get(atom.key);
   const targetValue = target.valueMap.get(atom.key);
@@ -239,7 +345,7 @@ function copyMutableIfNeeded(atom, transform, origin, target) {
   return targetValue;
 }
 
-// src/set-state/copy-mutable-in-transaction.ts
+// internal/src/set-state/copy-mutable-in-transaction.ts
 function copyMutableIfWithinTransaction(oldValue, atom, store) {
   const target = newest(store);
   const parent = target.parent;
@@ -273,7 +379,7 @@ function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target)
   return null;
 }
 
-// src/set-state/emit-update.ts
+// internal/src/set-state/emit-update.ts
 var emitUpdate = (state, update, store) => {
   store.logger.info(
     `\u{1F4E2}`,
@@ -289,7 +395,7 @@ var emitUpdate = (state, update, store) => {
   state.subject.next(update);
 };
 
-// src/set-state/evict-downstream.ts
+// internal/src/set-state/evict-downstream.ts
 var evictDownStream = (atom, store) => {
   const target = newest(store);
   const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
@@ -319,7 +425,7 @@ var evictDownStream = (atom, store) => {
   }
 };
 
-// src/set-state/stow-update.ts
+// internal/src/set-state/stow-update.ts
 function shouldUpdateBeStowed(key, update) {
   if (isTransceiver(update.newValue)) {
     return false;
@@ -362,7 +468,7 @@ var stowUpdate = (state, update, store) => {
   );
 };
 
-// src/set-state/set-atom.ts
+// internal/src/set-state/set-atom.ts
 var setAtom = (atom, next, store) => {
   const target = newest(store);
   const oldValue = readOrComputeValue(atom, store);
@@ -383,7 +489,7 @@ var setAtom = (atom, next, store) => {
   }
 };
 
-// src/set-state/set-atom-or-selector.ts
+// internal/src/set-state/set-atom-or-selector.ts
 var setAtomOrSelector = (state, value, store) => {
   if (state.type === `selector`) {
     state.set(value);
@@ -392,7 +498,7 @@ var setAtomOrSelector = (state, value, store) => {
   }
 };
 
-// src/store/deposit.ts
+// internal/src/store/deposit.ts
 function deposit(state) {
   const token = {
     key: state.key,
@@ -404,7 +510,7 @@ function deposit(state) {
   return token;
 }
 
-// ../../rel8/junction/src/junction.ts
+// ../rel8/junction/src/junction.ts
 var Junction = class {
   constructor(data, config) {
     this.relations = /* @__PURE__ */ new Map();
@@ -662,7 +768,7 @@ var Junction = class {
   }
 };
 
-// src/store/store.ts
+// internal/src/store/store.ts
 var Store = class {
   constructor(name, store = null) {
     this.parent = null;
@@ -707,7 +813,7 @@ var Store = class {
       name: `IMPLICIT_STORE`
     };
     this.loggers = [
-      new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
+      new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
     ];
     this.logger = {
       error: (...messages) => {
@@ -761,7 +867,7 @@ var clearStore = (store) => {
   store.config = config;
 };
 
-// src/store/withdraw.ts
+// internal/src/store/withdraw.ts
 function withdraw(token, store) {
   var _a, _b, _c, _d;
   const target = newest(store);
@@ -772,7 +878,7 @@ function withdraw(token, store) {
   return void 0;
 }
 
-// src/store/withdraw-new-family-member.ts
+// internal/src/store/withdraw-new-family-member.ts
 function withdrawNewFamilyMember(token, store) {
   if (token.family) {
     store.logger.info(
@@ -793,19 +899,19 @@ function withdrawNewFamilyMember(token, store) {
   return void 0;
 }
 
-// src/keys.ts
+// internal/src/keys.ts
 var isAtomKey = (key, store) => newest(store).atoms.has(key);
 var isSelectorKey = (key, store) => newest(store).selectors.has(key);
 var isReadonlySelectorKey = (key, store) => newest(store).readonlySelectors.has(key);
 var isStateKey = (key, store) => isAtomKey(key, store) || isSelectorKey(key, store) || isReadonlySelectorKey(key, store);
 
-// src/selector/get-selector-dependency-keys.ts
+// internal/src/selector/get-selector-dependency-keys.ts
 var getSelectorDependencyKeys = (key, store) => {
   const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(source, store));
   return sources;
 };
 
-// src/selector/trace-selector-atoms.ts
+// internal/src/selector/trace-selector-atoms.ts
 var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
   const rootKeys = [];
   const indirectDependencyKeys = getSelectorDependencyKeys(
@@ -838,7 +944,7 @@ var traceAllSelectorAtoms = (selectorKey, store) => {
   );
 };
 
-// src/selector/update-selector-atoms.ts
+// internal/src/selector/update-selector-atoms.ts
 var updateSelectorAtoms = (selectorKey, dependency, store) => {
   const target = newest(store);
   if (dependency.type === `atom`) {
@@ -869,7 +975,7 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
   }
 };
 
-// src/selector/register-selector.ts
+// internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
     const target = newest(store);
@@ -914,7 +1020,7 @@ var registerSelector = (selectorKey, store) => ({
   }
 });
 
-// src/selector/create-read-write-selector.ts
+// internal/src/selector/create-read-write-selector.ts
 var createReadWriteSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
@@ -965,7 +1071,7 @@ var createReadWriteSelector = (options, family, store) => {
   return token;
 };
 
-// src/selector/create-readonly-selector.ts
+// internal/src/selector/create-readonly-selector.ts
 var createReadonlySelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
@@ -1001,7 +1107,7 @@ var createReadonlySelector = (options, family, store) => {
   return token;
 };
 
-// src/selector/create-selector.ts
+// internal/src/selector/create-selector.ts
 function createSelector(options, family, store) {
   const target = newest(store);
   const existingWritable = target.selectors.get(options.key);
@@ -1020,7 +1126,7 @@ function createSelector(options, family, store) {
   return createReadonlySelector(options, family, store);
 }
 
-// src/selector/delete-selector.ts
+// internal/src/selector/delete-selector.ts
 function deleteSelector(selectorToken, store) {
   const target = newest(store);
   const { key } = selectorToken;
@@ -1049,7 +1155,7 @@ function deleteSelector(selectorToken, store) {
   store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
 }
 
-// src/subscribe/recall-state.ts
+// internal/src/subscribe/recall-state.ts
 var recallState = (state, store) => {
   const target = newest(store);
   if (!target.operation.open) {
@@ -1058,7 +1164,7 @@ var recallState = (state, store) => {
   return target.operation.prev.get(state.key);
 };
 
-// src/subscribe/subscribe-to-root-atoms.ts
+// internal/src/subscribe/subscribe-to-root-atoms.ts
 var subscribeToRootAtoms = (state, store) => {
   const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomKey) => {
     const atom = store.atoms.get(atomKey);
@@ -1098,8 +1204,10 @@ var subscribeToRootAtoms = (state, store) => {
   });
   return dependencySubscriptions;
 };
+
+// internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
-  const state = internal.withdraw(token, store);
+  const state = withdraw(token, store);
   if (state === void 0) {
     throw new Error(
       `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
@@ -1107,7 +1215,7 @@ function subscribeToState(token, handleUpdate, key, store) {
   }
   const unsubFunction = state.subject.subscribe(key, handleUpdate);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
-  const dependencyUnsubFunctions = state.type !== `atom` ? internal.subscribeToRootAtoms(state, store) : null;
+  const dependencyUnsubFunctions = state.type !== `atom` ? subscribeToRootAtoms(state, store) : null;
   const unsubscribe = dependencyUnsubFunctions === null ? () => {
     store.logger.info(
       `\u{1F648}`,
@@ -1130,8 +1238,10 @@ function subscribeToState(token, handleUpdate, key, store) {
   };
   return unsubscribe;
 }
+
+// internal/src/subscribe/subscribe-to-timeline.ts
 var subscribeToTimeline = (token, handleUpdate, key, store) => {
-  const tl = internal.withdraw(token, store);
+  const tl = withdraw(token, store);
   if (tl === void 0) {
     throw new Error(
       `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
@@ -1149,8 +1259,10 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/subscribe/subscribe-to-transaction.ts
 var subscribeToTransaction = (token, handleUpdate, key, store) => {
-  const tx = internal.withdraw(token, store);
+  const tx = withdraw(token, store);
   if (tx === void 0) {
     throw new Error(
       `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
@@ -1173,6 +1285,8 @@ var subscribeToTransaction = (token, handleUpdate, key, store) => {
     unsubscribe();
   };
 };
+
+// internal/src/mutable/tracker.ts
 var Tracker = class {
   constructor(mutableState, store) {
     this.unsubscribeFromInnerValue = null;
@@ -1185,7 +1299,8 @@ var Tracker = class {
   }
   initializeState(mutableState, store) {
     const latestUpdateStateKey = `*${mutableState.key}`;
-    deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store);
+    store.atoms.delete(latestUpdateStateKey);
+    store.valueMap.delete(latestUpdateStateKey);
     const familyMetaData = mutableState.family ? {
       key: `*${mutableState.family.key}`,
       subKey: mutableState.family.subKey
@@ -1198,10 +1313,14 @@ var Tracker = class {
       familyMetaData,
       store
     );
+    if (store.parent) {
+      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
+      store.valueMap.set(latestUpdateStateKey, parentValue);
+    }
     return latestUpdateState;
   }
   observeCore(mutableState, latestUpdateState, store) {
-    const originalInnerValue = atom_io.getState(mutableState, store);
+    const originalInnerValue = getState(mutableState, store);
     const target = newest(store);
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
@@ -1210,7 +1329,7 @@ var Tracker = class {
           mutableState.key,
           () => {
             unsubscribe();
-            atom_io.setState(latestUpdateState, update, store);
+            setState(latestUpdateState, update, store);
           }
         );
       }
@@ -1229,7 +1348,7 @@ var Tracker = class {
                 mutableState.key,
                 () => {
                   unsubscribe();
-                  atom_io.setState(latestUpdateState, update2, store);
+                  setState(latestUpdateState, update2, store);
                 }
               );
             }
@@ -1254,7 +1373,7 @@ var Tracker = class {
               { key: timelineId, type: `timeline` },
               (update) => {
                 unsubscribe2();
-                atom_io.setState(
+                setState(
                   mutableState,
                   (transceiver) => {
                     if (update === `redo` && newValue) {
@@ -1277,11 +1396,11 @@ var Tracker = class {
           latestUpdateState.key,
           () => {
             unsubscribe();
-            const mutable = atom_io.getState(mutableState, store);
-            const updateNumber = mutable.getUpdateNumber(newValue);
+            const mutable = getState(mutableState, store);
+            const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
-              atom_io.setState(
+              setState(
                 mutableState,
                 (transceiver) => (transceiver.do(newValue), transceiver),
                 store
@@ -1296,7 +1415,7 @@ var Tracker = class {
   }
 };
 
-// src/mutable/create-mutable-atom.ts
+// internal/src/mutable/create-mutable-atom.ts
 function createMutableAtom(options, store) {
   store.logger.info(
     `\u{1F527}`,
@@ -1306,7 +1425,7 @@ function createMutableAtom(options, store) {
   );
   const coreState = createAtom(options, void 0, store);
   new Tracker(coreState, store);
-  const jsonState = json.selectJson(coreState, options, store);
+  const jsonState = selectJson(coreState, options, store);
   const target = newest(store);
   subscribeToState(
     jsonState,
@@ -1321,11 +1440,13 @@ function createMutableAtom(options, store) {
   );
   return coreState;
 }
+
+// internal/src/families/create-atom-family.ts
 function createAtomFamily(options, store) {
   const subject = new Subject();
   const atomFamily = Object.assign(
     (key) => {
-      const subKey = json.stringifyJson(key);
+      const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
       const existing = withdraw({ key: fullKey, type: `atom` }, store);
@@ -1351,16 +1472,21 @@ function createAtomFamily(options, store) {
       subject
     }
   );
+  if (`mutable` in options && typeof options.mutable === `boolean`) {
+    Object.assign(atomFamily, { mutable: options.mutable });
+  }
   const target = newest(store);
   target.families.set(options.key, atomFamily);
   return atomFamily;
 }
+
+// internal/src/families/create-readonly-selector-family.ts
 function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
   return Object.assign(
     (key) => {
       const target = newest(store);
-      const subKey = json.stringifyJson(key);
+      const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
       const existing = target.readonlySelectors.get(fullKey);
@@ -1383,6 +1509,8 @@ function createReadonlySelectorFamily(options, store) {
     }
   );
 }
+
+// internal/src/families/create-selector-family.ts
 function createSelectorFamily(options, store) {
   const isReadonly = !(`set` in options);
   if (isReadonly) {
@@ -1392,7 +1520,7 @@ function createSelectorFamily(options, store) {
   const subject = new Subject();
   const selectorFamily = Object.assign(
     (key) => {
-      const subKey = json.stringifyJson(key);
+      const subKey = stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
       const existing = target.selectors.get(fullKey);
@@ -1420,7 +1548,7 @@ function createSelectorFamily(options, store) {
   return selectorFamily;
 }
 
-// src/mutable/tracker-family.ts
+// internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
   constructor(findMutableState, store) {
     this.findLatestUpdateState = createAtomFamily(
@@ -1435,7 +1563,7 @@ var FamilyTracker = class {
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
-          const key = json.parseJson(atomToken.family.subKey);
+          const key = parseJson(atomToken.family.subKey);
           this.findLatestUpdateState(key);
           new Tracker(atomToken, store);
         }
@@ -1445,7 +1573,7 @@ var FamilyTracker = class {
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
-          const key = json.parseJson(atomToken.family.subKey);
+          const key = parseJson(atomToken.family.subKey);
           const mutableAtomToken = this.findMutableState(key);
           new Tracker(mutableAtomToken, store);
         }
@@ -1454,18 +1582,18 @@ var FamilyTracker = class {
   }
 };
 
-// src/mutable/create-mutable-atom-family.ts
+// internal/src/mutable/create-mutable-atom-family.ts
 function createMutableAtomFamily(options, store) {
   const coreFamily = Object.assign(
     createAtomFamily(options, store),
     options
   );
-  json.selectJsonFamily(coreFamily, options);
+  selectJsonFamily(coreFamily, options);
   new FamilyTracker(coreFamily, store);
   return coreFamily;
 }
 
-// src/mutable/get-json-family.ts
+// internal/src/mutable/get-json-family.ts
 var getJsonFamily = (mutableAtomFamily, store) => {
   const target = newest(store);
   const key = `${mutableAtomFamily.key}:JSON`;
@@ -1475,7 +1603,7 @@ var getJsonFamily = (mutableAtomFamily, store) => {
   return jsonFamily;
 };
 
-// src/mutable/get-json-token.ts
+// internal/src/mutable/get-json-token.ts
 var getJsonToken = (mutableAtomToken) => {
   const key = mutableAtomToken.family ? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})` : `${mutableAtomToken.key}:JSON`;
   const jsonToken = { type: `selector`, key };
@@ -1488,7 +1616,7 @@ var getJsonToken = (mutableAtomToken) => {
   return jsonToken;
 };
 
-// src/mutable/get-update-token.ts
+// internal/src/mutable/get-update-token.ts
 var getUpdateToken = (mutableAtomToken) => {
   const key = `*${mutableAtomToken.key}`;
   const updateToken = { type: `atom`, key };
@@ -1501,20 +1629,20 @@ var getUpdateToken = (mutableAtomToken) => {
   return updateToken;
 };
 
-// src/mutable/is-atom-token-mutable.ts
-function isAtomTokenMutable(token) {
-  return token.key.endsWith(`::mutable`);
-}
+// internal/src/mutable/get-update-family.ts
+var getUpdateFamily = (mutableAtomFamily, store) => {
+  const target = newest(store);
+  const key = `*${mutableAtomFamily.key}`;
+  const updateFamily = target.families.get(key);
+  return updateFamily;
+};
 
-// src/mutable/transceiver.ts
+// internal/src/mutable/transceiver.ts
 function isTransceiver(value) {
   return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
 }
 
-// src/mutable/index.ts
-var isAtomMutable = (atom) => `isMutable` in atom;
-
-// src/atom/is-default.ts
+// internal/src/atom/is-default.ts
 var isAtomDefault = (key, store) => {
   const core = newest(store);
   return core.atomsThatAreDefault.has(key);
@@ -1533,7 +1661,7 @@ var isSelectorDefault = (key, store) => {
   return rootKeys.every((rootKey) => isAtomDefault(rootKey, store));
 };
 
-// src/atom/create-atom.ts
+// internal/src/atom/create-atom.ts
 function createAtom(options, family, store) {
   store.logger.info(
     `\u{1F528}`,
@@ -1580,7 +1708,7 @@ function createAtom(options, family, store) {
     const cleanupFunctions = [];
     for (const effect of options.effects) {
       const cleanup = effect({
-        setSelf: (next) => atom_io.setState(token, next, store),
+        setSelf: (next) => setState(token, next, store),
         onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
       });
       if (cleanup) {
@@ -1598,8 +1726,8 @@ function createAtom(options, family, store) {
   return token;
 }
 
-// src/atom/delete-atom.ts
-function deleteAtom(atomToken, store) {
+// internal/src/atom/delete-atom.ts
+function deleteAtom2(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -1630,7 +1758,7 @@ function deleteAtom(atomToken, store) {
   store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
 }
 
-// src/lazy-map.ts
+// internal/src/lazy-map.ts
 var LazyMap = class extends Map {
   constructor(source) {
     super();
@@ -1664,7 +1792,7 @@ var LazyMap = class extends Map {
   }
 };
 
-// src/not-found-error.ts
+// internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
   if (token.type === `readonly_selector`) {
@@ -1680,9 +1808,15 @@ var NotFoundError = class extends Error {
   }
 };
 
-// src/timeline/add-atom-to-timeline.ts
+// internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
-  const atom = withdraw(atomToken, store);
+  let maybeAtom = withdraw(atomToken, store);
+  if (maybeAtom == null ? void 0 : maybeAtom.mutable) {
+    console.log(`adding transceiver to timeline`, atomToken.key);
+    const updateToken = getUpdateToken(atomToken);
+    maybeAtom = withdraw(updateToken, store);
+  }
+  const atom = maybeAtom;
   if (atom === void 0) {
     throw new Error(
       `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
@@ -1872,7 +2006,31 @@ var addAtomToTimeline = (atomToken, tl, store) => {
   });
 };
 
-// src/timeline/create-timeline.ts
+// internal/src/mutable/is-mutable.ts
+function isMutable(atomOrTokenOrFamily, store) {
+  if (`mutable` in atomOrTokenOrFamily) {
+    return atomOrTokenOrFamily.mutable;
+  }
+  if (atomOrTokenOrFamily.type === `atom_family`) {
+    return false;
+  }
+  if (`default` in atomOrTokenOrFamily) {
+    return false;
+  }
+  if (!store) {
+    throw new Error(`Cannot check mutability without a store`);
+  }
+  const atom = withdraw(atomOrTokenOrFamily, store);
+  if (!atom) {
+    throw new Error(`Cannot check mutability without an atom`);
+  }
+  if (`mutable` in atom) {
+    return atom.mutable;
+  }
+  return false;
+}
+
+// internal/src/timeline/create-timeline.ts
 function createTimeline(options, store, data) {
   var _a, _b;
   const tl = __spreadProps(__spreadValues({
@@ -1890,20 +2048,26 @@ function createTimeline(options, store, data) {
   if (options.shouldCapture) {
     tl.shouldCapture = options.shouldCapture;
   }
+  const timelineKey = options.key;
   const target = newest(store);
   for (const tokenOrFamily of options.atoms) {
-    const timelineKey = target.timelineAtoms.getRelatedKey(tokenOrFamily.key);
-    if (timelineKey) {
+    let atomKey = tokenOrFamily.key;
+    const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey);
+    if (existingTimelineKey) {
       store.logger.error(
         `\u274C`,
         `timeline`,
         options.key,
-        `Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`
+        `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
       );
       continue;
     }
     if (tokenOrFamily.type === `atom_family`) {
-      const family = tokenOrFamily;
+      let family = tokenOrFamily;
+      if (isMutable(family)) {
+        family = getUpdateFamily(family, store);
+        atomKey = family.key;
+      }
       family.subject.subscribe(`timeline:${options.key}`, (token2) => {
         addAtomToTimeline(token2, tl, store);
       });
@@ -1913,36 +2077,58 @@ function createTimeline(options, store, data) {
         }
       }
     } else {
-      const token2 = tokenOrFamily;
-      if (`family` in token2 && token2.family) {
+      let atom = withdraw(tokenOrFamily, store);
+      if (atom === void 0) {
+        store.logger.error(
+          `\u274C`,
+          `timeline`,
+          options.key,
+          `Failed to add atom "${atomKey}" because it does not exist in the store`
+        );
+        continue;
+      }
+      if (isMutable(atom)) {
+        const updateAtom = withdraw(getUpdateToken(atom), store);
+        if (updateAtom === void 0) {
+          store.logger.error(
+            `\u274C`,
+            `timeline`,
+            options.key,
+            `Failed to add update atom "${atomKey}" because it does not exist in the store`
+          );
+          continue;
+        }
+        atom = updateAtom;
+        atomKey = atom.key;
+      }
+      if (`family` in atom) {
         const familyTimelineKey = target.timelineAtoms.getRelatedKey(
-          token2.family.key
+          atom.family.key
         );
         if (familyTimelineKey) {
           store.logger.error(
             `\u274C`,
             `timeline`,
             options.key,
-            `Failed to add atom "${token2.key}" because its family "${token2.family.key}" already belongs to timeline "${familyTimelineKey}"`
+            `Failed to add atom "${atom.key}" because its family "${atom.family.key}" already belongs to timeline "${familyTimelineKey}"`
           );
           continue;
         }
       }
-      addAtomToTimeline(token2, tl, store);
+      addAtomToTimeline(atom, tl, store);
     }
-    target.timelineAtoms = target.timelineAtoms.set({
-      atomKey: tokenOrFamily.key,
-      timelineKey: options.key
-    });
+    target.timelineAtoms.set({ atomKey, timelineKey });
   }
   store.timelines.set(options.key, tl);
   const token = {
-    key: options.key,
+    key: timelineKey,
     type: `timeline`
   };
   store.subject.timelineCreation.next(token);
   return token;
 }
+
+// internal/src/timeline/time-travel.ts
 var timeTravel = (direction, token, store) => {
   const action = direction === `forward` ? `redo` : `undo`;
   store.logger.info(
@@ -1978,7 +2164,7 @@ var timeTravel = (direction, token, store) => {
   const updateValues = (atomUpdate) => {
     const { key, newValue, oldValue } = atomUpdate;
     const value = direction === `forward` ? newValue : oldValue;
-    atom_io.setState({ key, type: `atom` }, value, store);
+    setState({ key, type: `atom` }, value, store);
   };
   const updateValuesFromTransactionUpdate = (transactionUpdate) => {
     const updates = direction === `forward` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
@@ -2020,7 +2206,7 @@ var timeTravel = (direction, token, store) => {
   );
 };
 
-// src/transaction/abort-transaction.ts
+// internal/src/transaction/abort-transaction.ts
 var abortTransaction = (store) => {
   const target = newest(store);
   if (target.transactionMeta === null || target.parent === null) {
@@ -2040,6 +2226,8 @@ var abortTransaction = (store) => {
   );
   target.parent.child = null;
 };
+
+// internal/src/transaction/apply-transaction.ts
 function ingestAtomUpdate(update, parent, child) {
   var _a, _b, _c;
   const { key, newValue } = update;
@@ -2067,7 +2255,7 @@ function ingestAtomUpdate(update, parent, child) {
       );
     }
   }
-  atom_io.setState(token, newValue, parent);
+  setState(token, newValue, parent);
 }
 function ingestTransactionUpdate(transactionUpdate, parent, child) {
   for (const update of transactionUpdate.updates) {
@@ -2123,7 +2311,7 @@ var applyTransaction = (output, store) => {
   parent.subject.transactionApplying.next(null);
 };
 
-// src/transaction/build-transaction.ts
+// internal/src/transaction/build-transaction.ts
 var buildTransaction = (key, params, store) => {
   const parent = newest(store);
   parent.child = {
@@ -2167,6 +2355,8 @@ var buildTransaction = (key, params, store) => {
     params
   );
 };
+
+// internal/src/transaction/create-transaction.ts
 function createTransaction(options, store) {
   const newTransaction = {
     key: options.key,
@@ -2176,9 +2366,9 @@ function createTransaction(options, store) {
       try {
         const output = options.do(
           {
-            get: (token2) => atom_io.getState(token2, store),
-            set: (token2, value) => atom_io.setState(token2, value, store),
-            run: (token2) => atom_io.runTransaction(token2, store)
+            get: (token2) => getState(token2, store),
+            set: (token2, value) => setState(token2, value, store),
+            run: (token2) => runTransaction(token2, store)
           },
           ...params
         );
@@ -2199,6 +2389,8 @@ function createTransaction(options, store) {
   store.subject.transactionCreation.next(token);
   return token;
 }
+
+// internal/src/transaction/redo-transaction.ts
 var redoTransactionUpdate = (transactionUpdate, store) => {
   store.logger.info(`\u23ED\uFE0F`, `transaction`, transactionUpdate.key, `Redo`);
   for (const update of transactionUpdate.updates) {
@@ -2211,12 +2403,14 @@ var redoTransactionUpdate = (transactionUpdate, store) => {
           `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
         );
       }
-      atom_io.setState(state, newValue, store);
+      setState(state, newValue, store);
     } else {
       redoTransactionUpdate(update, store);
     }
   }
 };
+
+// internal/src/transaction/undo-transaction.ts
 var undoTransactionUpdate = (transactionUpdate, store) => {
   store.logger.info(`\u23EE\uFE0F`, `transaction`, transactionUpdate.key, `Undo`);
   for (const update of transactionUpdate.updates.reverse()) {
@@ -2229,14 +2423,14 @@ var undoTransactionUpdate = (transactionUpdate, store) => {
           `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
         );
       }
-      atom_io.setState(state, newValue, store);
+      setState(state, newValue, store);
     } else {
       undoTransactionUpdate(update, store);
     }
   }
 };
 
-// src/transaction/index.ts
+// internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
 exports.FamilyTracker = FamilyTracker;
@@ -2266,7 +2460,7 @@ exports.createSelector = createSelector;
 exports.createSelectorFamily = createSelectorFamily;
 exports.createTimeline = createTimeline;
 exports.createTransaction = createTransaction;
-exports.deleteAtom = deleteAtom;
+exports.deleteAtom = deleteAtom2;
 exports.deleteSelector = deleteSelector;
 exports.deposit = deposit;
 exports.eldest = eldest;
@@ -2274,11 +2468,10 @@ exports.evictCachedValue = evictCachedValue;
 exports.getJsonFamily = getJsonFamily;
 exports.getJsonToken = getJsonToken;
 exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
+exports.getUpdateFamily = getUpdateFamily;
 exports.getUpdateToken = getUpdateToken;
 exports.isAtomDefault = isAtomDefault;
 exports.isAtomKey = isAtomKey;
-exports.isAtomMutable = isAtomMutable;
-exports.isAtomTokenMutable = isAtomTokenMutable;
 exports.isDone = isDone;
 exports.isReadonlySelectorKey = isReadonlySelectorKey;
 exports.isSelectorDefault = isSelectorDefault;