atom.io 0.14.8 → 0.15.1

package/internal/dist/index.cjs

@@ -1,8 +1,28 @@
 'use strict';
 
-var atom_io = require('atom.io');
 var json = require('atom.io/json');
-var internal = require('atom.io/internal');
+var atom_io = require('atom.io');
+var Internal2 = require('atom.io/internal');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Internal2__namespace = /*#__PURE__*/_interopNamespace(Internal2);
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -24,6 +44,20 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
+// internal/src/lineage.ts
+function newest(scion) {
+  while (scion.child !== null) {
+    scion = scion.child;
+  }
+  return scion;
+}
+function eldest(scion) {
+  while (scion.parent !== null) {
+    scion = scion.parent;
+  }
+  return scion;
+}
+
 // internal/src/future.ts
 var Future = class extends Promise {
   constructor(executor) {
@@ -43,39 +77,24 @@ var Future = class extends Promise {
   }
 };
 
-// internal/src/lineage.ts
-function newest(scion) {
-  while (scion.child !== null) {
-    scion = scion.child;
-  }
-  return scion;
-}
-function eldest(scion) {
-  while (scion.parent !== null) {
-    scion = scion.parent;
-  }
-  return scion;
-}
-
 // internal/src/caching.ts
-function cacheValue(key, value, subject, store) {
-  const target = newest(store);
+function cacheValue(key, value, subject, target) {
   const currentValue = target.valueMap.get(key);
   if (currentValue instanceof Future) {
     currentValue.cancel();
   }
   if (value instanceof Promise) {
     const future = new Future(value);
-    newest(store).valueMap.set(key, future);
+    target.valueMap.set(key, future);
     future.then((resolved) => {
       if (future.isCanceled) {
         return;
       }
-      cacheValue(key, resolved, subject, store);
+      cacheValue(key, resolved, subject, target);
       subject.next({ newValue: resolved, oldValue: future });
     }).catch((thrown) => {
       if (thrown !== `canceled`) {
-        store.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+        target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
       }
     });
     return future;
@@ -83,23 +102,22 @@ function cacheValue(key, value, subject, store) {
   target.valueMap.set(key, value);
   return value;
 }
-var readCachedValue = (key, store) => {
-  return newest(store).valueMap.get(key);
+var readCachedValue = (key, target) => {
+  return target.valueMap.get(key);
 };
-var isValueCached = (key, store) => {
-  return newest(store).valueMap.has(key);
+var isValueCached = (key, target) => {
+  return target.valueMap.has(key);
 };
-var evictCachedValue = (key, store) => {
-  const core = newest(store);
-  const currentValue = core.valueMap.get(key);
+var evictCachedValue = (key, target) => {
+  const currentValue = target.valueMap.get(key);
   if (currentValue instanceof Future) {
     currentValue.cancel();
   }
-  if (core.operation.open) {
-    core.operation.prev.set(key, currentValue);
+  if (target.operation.open) {
+    target.operation.prev.set(key, currentValue);
   }
-  core.valueMap.delete(key);
-  store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+  target.valueMap.delete(key);
+  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
 };
 
 // internal/src/read-or-compute-value.ts
@@ -125,17 +143,16 @@ var readOrComputeValue = (state, store) => {
 
 // internal/src/operation.ts
 var openOperation = (token, store) => {
-  const target = newest(store);
-  if (target.operation.open) {
+  if (store.operation.open) {
     store.logger.error(
       `\u274C`,
       token.type,
       token.key,
-      `failed to setState during a setState for "${target.operation.token.key}"`
+      `failed to setState during a setState for "${store.operation.token.key}"`
     );
     return `rejection`;
   }
-  target.operation = {
+  store.operation = {
     open: true,
     done: /* @__PURE__ */ new Set(),
     prev: /* @__PURE__ */ new Map(),
@@ -146,25 +163,23 @@ var openOperation = (token, store) => {
     `\u2B55`,
     token.type,
     token.key,
-    `operation start in store "${store.config.name}"${target.transactionMeta === null ? `` : ` ${target.transactionMeta.phase} "${target.transactionMeta.update.key}"`}`
+    `operation start in store "${store.config.name}"${store.transactionMeta === null ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
   );
 };
 var closeOperation = (store) => {
-  const target = newest(store);
-  if (target.operation.open) {
+  if (store.operation.open) {
     store.logger.info(
       `\u{1F534}`,
-      target.operation.token.type,
-      target.operation.token.key,
+      store.operation.token.type,
+      store.operation.token.key,
       `operation done in store "${store.config.name}"`
     );
   }
-  target.operation = { open: false };
-  store.subject.operationStatus.next(target.operation);
+  store.operation = { open: false };
+  store.subject.operationStatus.next(store.operation);
 };
 var isDone = (key, store) => {
-  const target = newest(store);
-  if (!target.operation.open) {
+  if (!store.operation.open) {
     store.logger.warn(
       `\u{1F41E}`,
       `unknown`,
@@ -173,11 +188,10 @@ var isDone = (key, store) => {
     );
     return true;
   }
-  return target.operation.done.has(key);
+  return store.operation.done.has(key);
 };
 var markDone = (key, store) => {
-  const target = newest(store);
-  if (!target.operation.open) {
+  if (!store.operation.open) {
     store.logger.warn(
       `\u{1F41E}`,
       `unknown`,
@@ -186,7 +200,7 @@ var markDone = (key, store) => {
     );
     return;
   }
-  target.operation.done.add(key);
+  store.operation.done.add(key);
 };
 
 // internal/src/set-state/become.ts
@@ -292,8 +306,7 @@ var emitUpdate = (state, update, store) => {
 
 // internal/src/set-state/evict-downstream.ts
 var evictDownStream = (atom, store) => {
-  const target = newest(store);
-  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
+  const downstreamKeys = store.selectorAtoms.getRelatedKeys(atom.key);
   store.logger.info(
     `\u{1F9F9}`,
     atom.type,
@@ -302,12 +315,12 @@ var evictDownStream = (atom, store) => {
     downstreamKeys != null ? downstreamKeys : `to evict`
   );
   if (downstreamKeys) {
-    if (target.operation.open) {
+    if (store.operation.open) {
       store.logger.info(
         `\u{1F9F9}`,
         atom.type,
         atom.key,
-        `[ ${[...target.operation.done].join(`, `)} ] already done`
+        `[ ${[...store.operation.done].join(`, `)} ] already done`
       );
     }
     for (const key of downstreamKeys) {
@@ -364,23 +377,24 @@ var stowUpdate = (state, update, store) => {
 };
 
 // internal/src/set-state/set-atom.ts
-var setAtom = (atom, next, store) => {
-  const target = newest(store);
-  const oldValue = readOrComputeValue(atom, store);
-  let newValue = copyMutableIfWithinTransaction(oldValue, atom, store);
+var setAtom = (atom, next, target) => {
+  const oldValue = readOrComputeValue(atom, target);
+  let newValue = copyMutableIfWithinTransaction(oldValue, atom, target);
   newValue = become(next)(newValue);
-  store.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
-  newValue = cacheValue(atom.key, newValue, atom.subject, store);
-  if (isAtomDefault(atom.key, store)) {
-    markAtomAsNotDefault(atom.key, store);
+  target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
+  newValue = cacheValue(atom.key, newValue, atom.subject, target);
+  if (isAtomDefault(atom.key, target)) {
+    markAtomAsNotDefault(atom.key, target);
   }
-  markDone(atom.key, store);
-  evictDownStream(atom, store);
+  markDone(atom.key, target);
+  evictDownStream(atom, target);
   const update = { oldValue, newValue };
-  if (target.transactionMeta === null || target.transactionMeta.phase === `applying`) {
-    emitUpdate(atom, update, store);
+  if (target.transactionMeta === null) {
+    emitUpdate(atom, update, target);
+  } else if (target.transactionMeta.phase === `applying` && target.parent) {
+    emitUpdate(atom, update, target.parent);
   } else {
-    stowUpdate(atom, update, store);
+    stowUpdate(atom, update, target);
   }
 };
 
@@ -731,13 +745,29 @@ var Store = class {
       this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
         name
       });
+      for (const [, family] of store.families) {
+        family.install(this);
+      }
+      const mutableHelpers = /* @__PURE__ */ new Set();
       for (const [, atom] of store.atoms) {
+        if (mutableHelpers.has(atom.key)) {
+          continue;
+        }
         atom.install(this);
+        if (`mutable` in atom) {
+          const originalJsonToken = getJsonToken(atom);
+          const originalUpdateToken = getUpdateToken(atom);
+          mutableHelpers.add(originalJsonToken.key);
+          mutableHelpers.add(originalUpdateToken.key);
+        }
       }
       for (const [, selector] of store.readonlySelectors) {
         selector.install(this);
       }
       for (const [, selector] of store.selectors) {
+        if (mutableHelpers.has(selector.key)) {
+          continue;
+        }
         selector.install(this);
       }
       for (const [, tx] of store.transactions) {
@@ -764,13 +794,31 @@ var clearStore = (store) => {
 
 // internal/src/store/withdraw.ts
 function withdraw(token, store) {
-  var _a, _b, _c, _d;
-  const target = newest(store);
-  const state = (_d = (_c = (_b = (_a = target.atoms.get(token.key)) != null ? _a : target.selectors.get(token.key)) != null ? _b : target.readonlySelectors.get(token.key)) != null ? _c : target.transactions.get(token.key)) != null ? _d : target.timelines.get(token.key);
-  if (state) {
-    return state;
+  let withdrawn;
+  let target = store;
+  while (target !== null) {
+    switch (token.type) {
+      case `atom`:
+        withdrawn = target.atoms.get(token.key);
+        break;
+      case `selector`:
+        withdrawn = target.selectors.get(token.key);
+        break;
+      case `readonly_selector`:
+        withdrawn = target.readonlySelectors.get(token.key);
+        break;
+      case `timeline`:
+        withdrawn = target.timelines.get(token.key);
+        break;
+      case `transaction`:
+        withdrawn = target.transactions.get(token.key);
+        break;
+    }
+    if (withdrawn) {
+      return withdrawn;
+    }
+    target = target.child;
   }
-  return void 0;
 }
 
 // internal/src/store/withdraw-new-family-member.ts
@@ -874,7 +922,6 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
     const target = newest(store);
-    const alreadyRegistered = target.selectorGraph.getRelationEntries({ downstreamSelectorKey: selectorKey }).some(([_, { source }]) => source === dependency.key);
     const dependencyState = withdraw(dependency, store);
     if (dependencyState === void 0) {
       throw new Error(
@@ -890,17 +937,15 @@ var registerSelector = (selectorKey, store) => ({
       dependencyValue,
       `)`
     );
-    if (!alreadyRegistered) {
-      target.selectorGraph.set(
-        {
-          upstreamSelectorKey: dependency.key,
-          downstreamSelectorKey: selectorKey
-        },
-        {
-          source: dependency.key
-        }
-      );
-    }
+    target.selectorGraph.set(
+      {
+        upstreamSelectorKey: dependency.key,
+        downstreamSelectorKey: selectorKey
+      },
+      {
+        source: dependency.key
+      }
+    );
     updateSelectorAtoms(selectorKey, dependency, store);
     return dependencyValue;
   },
@@ -922,7 +967,7 @@ var createReadWriteSelector = (options, family, store) => {
   const { get, set } = registerSelector(options.key, store);
   const getSelf = () => {
     const value = options.get({ get });
-    cacheValue(options.key, value, subject, store);
+    cacheValue(options.key, value, subject, newest(store));
     return value;
   };
   const setSelf = (next) => {
@@ -1012,7 +1057,7 @@ function createSelector(options, family, store) {
       `\u274C`,
       existingReadonly ? `readonly_selector` : `selector`,
       options.key,
-      `Tried to create selector, but it already exists in the store. (Ignore if you are in development using hot module replacement.)`
+      `Tried to create selector, but it already exists in the store.`
     );
   }
   if (`set` in options) {
@@ -1061,8 +1106,9 @@ var recallState = (state, store) => {
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
 var subscribeToRootAtoms = (state, store) => {
+  const target = newest(store);
   const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomKey) => {
-    const atom = store.atoms.get(atomKey);
+    const atom = target.atoms.get(atomKey);
     if (atom === void 0) {
       throw new Error(
         `Atom "${atomKey}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
@@ -1082,8 +1128,8 @@ var subscribeToRootAtoms = (state, store) => {
           `->`,
           atomChange.newValue
         );
-        const oldValue = recallState(state, store);
-        const newValue = readOrComputeValue(state, store);
+        const oldValue = recallState(state, target);
+        const newValue = readOrComputeValue(state, target);
         store.logger.info(
           `\u2728`,
           state.type,
@@ -1099,8 +1145,11 @@ 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);
+  var _a;
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(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?`
@@ -1108,7 +1157,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}`,
@@ -1132,7 +1181,7 @@ function subscribeToState(token, handleUpdate, key, store) {
   return unsubscribe;
 }
 var subscribeToTimeline = (token, handleUpdate, key, store) => {
-  const tl = internal.withdraw(token, store);
+  const tl = Internal2.withdraw(token, store);
   if (tl === void 0) {
     throw new Error(
       `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
@@ -1151,7 +1200,7 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
   };
 };
 var subscribeToTransaction = (token, handleUpdate, key, store) => {
-  const tx = internal.withdraw(token, store);
+  const tx = Internal2.withdraw(token, store);
   if (tx === void 0) {
     throw new Error(
       `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
@@ -1185,6 +1234,7 @@ var Tracker = class {
     target.trackers.set(mutableState.key, this);
   }
   initializeState(mutableState, store) {
+    var _a;
     const latestUpdateStateKey = `*${mutableState.key}`;
     store.atoms.delete(latestUpdateStateKey);
     store.valueMap.delete(latestUpdateStateKey);
@@ -1192,7 +1242,7 @@ var Tracker = class {
       key: `*${mutableState.family.key}`,
       subKey: mutableState.family.subKey
     } : void 0;
-    const latestUpdateState = createAtom(
+    const latestUpdateState = createRegularAtom(
       {
         key: latestUpdateStateKey,
         default: null
@@ -1200,7 +1250,7 @@ var Tracker = class {
       familyMetaData,
       store
     );
-    if (store.parent) {
+    if ((_a = store.parent) == null ? void 0 : _a.valueMap.has(latestUpdateStateKey)) {
       const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
       store.valueMap.set(latestUpdateStateKey, parentValue);
     }
@@ -1212,11 +1262,11 @@ var Tracker = class {
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
       (update) => {
-        const unsubscribe = store.subject.operationStatus.subscribe(
+        const unsubscribe = target.subject.operationStatus.subscribe(
           mutableState.key,
           () => {
             unsubscribe();
-            atom_io.setState(latestUpdateState, update, store);
+            atom_io.setState(latestUpdateState, update, target);
           }
         );
       }
@@ -1303,14 +1353,14 @@ var Tracker = class {
 };
 
 // internal/src/mutable/create-mutable-atom.ts
-function createMutableAtom(options, store) {
+function createMutableAtom(options, family, store) {
   store.logger.info(
     `\u{1F527}`,
     `atom`,
     options.key,
     `creating in store "${store.config.name}"`
   );
-  const coreState = createAtom(options, void 0, store);
+  const coreState = createRegularAtom(options, family, store);
   new Tracker(coreState, store);
   const jsonState = json.selectJson(coreState, options, store);
   const target = newest(store);
@@ -1327,7 +1377,7 @@ function createMutableAtom(options, store) {
   );
   return coreState;
 }
-function createAtomFamily(options, store) {
+function createRegularAtomFamily(options, store) {
   const subject = new Subject();
   const atomFamily = Object.assign(
     (key) => {
@@ -1346,7 +1396,16 @@ function createAtomFamily(options, store) {
         if (options.effects) {
           individualOptions.effects = options.effects(key);
         }
-        token = createAtom(individualOptions, family, store);
+        if (`mutable` in options) {
+          const mutableOptions = __spreadProps(__spreadValues({}, individualOptions), {
+            mutable: true,
+            toJson: options.toJson,
+            fromJson: options.fromJson
+          });
+          token = createMutableAtom(mutableOptions, family, store);
+        } else {
+          token = createRegularAtom(individualOptions, family, store);
+        }
         subject.next(token);
       }
       return token;
@@ -1354,7 +1413,8 @@ function createAtomFamily(options, store) {
     {
       key: options.key,
       type: `atom_family`,
-      subject
+      subject,
+      install: (store2) => createRegularAtomFamily(options, store2)
     }
   );
   if (`mutable` in options && typeof options.mutable === `boolean`) {
@@ -1364,9 +1424,17 @@ function createAtomFamily(options, store) {
   target.families.set(options.key, atomFamily);
   return atomFamily;
 }
+
+// internal/src/families/create-atom-family.ts
+function createAtomFamily(options, store) {
+  if (`mutable` in options) {
+    return createMutableAtomFamily(options, store);
+  }
+  return createRegularAtomFamily(options, store);
+}
 function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
-  return Object.assign(
+  const readonlySelectorFamily = Object.assign(
     (key) => {
       const target = newest(store);
       const subKey = json.stringifyJson(key);
@@ -1388,9 +1456,12 @@ function createReadonlySelectorFamily(options, store) {
     {
       key: options.key,
       type: `readonly_selector_family`,
-      subject
+      subject,
+      install: (store2) => createReadonlySelectorFamily(options, store2)
     }
   );
+  store.families.set(options.key, readonlySelectorFamily);
+  return readonlySelectorFamily;
 }
 function createSelectorFamily(options, store) {
   const isReadonly = !(`set` in options);
@@ -1422,7 +1493,9 @@ function createSelectorFamily(options, store) {
     },
     {
       key: options.key,
-      type: `selector_family`
+      type: `selector_family`,
+      subject,
+      install: (store2) => createSelectorFamily(options, store2)
     }
   );
   target.families.set(options.key, selectorFamily);
@@ -1432,7 +1505,7 @@ function createSelectorFamily(options, store) {
 // internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
   constructor(findMutableState, store) {
-    this.findLatestUpdateState = createAtomFamily(
+    this.findLatestUpdateState = createRegularAtomFamily(
       {
         key: `*${findMutableState.key}`,
         default: null
@@ -1466,7 +1539,7 @@ var FamilyTracker = class {
 // internal/src/mutable/create-mutable-atom-family.ts
 function createMutableAtomFamily(options, store) {
   const coreFamily = Object.assign(
-    createAtomFamily(options, store),
+    createRegularAtomFamily(options, store),
     options
   );
   json.selectJsonFamily(coreFamily, options);
@@ -1537,13 +1610,9 @@ var markAtomAsNotDefault = (key, store) => {
   core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
   core.atomsThatAreDefault.delete(key);
 };
-var isSelectorDefault = (key, store) => {
-  const rootKeys = traceAllSelectorAtoms(key, store);
-  return rootKeys.every((rootKey) => isAtomDefault(rootKey, store));
-};
 
-// internal/src/atom/create-atom.ts
-function createAtom(options, family, store) {
+// internal/src/atom/create-regular-atom.ts
+function createRegularAtom(options, family, store) {
   store.logger.info(
     `\u{1F528}`,
     `atom`,
@@ -1557,13 +1626,12 @@ function createAtom(options, family, store) {
       `\u274C`,
       `atom`,
       options.key,
-      `Tried to create atom, but it already exists in the store.`,
-      `(Ignore if you are in development using hot module replacement.)`
+      `Tried to create atom, but it already exists in the store.`
     );
     return deposit(existing);
   }
   const subject = new Subject();
-  const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
+  const newAtom = __spreadProps(__spreadValues({}, options), {
     type: `atom`,
     install: (store2) => {
       store2.logger.info(
@@ -1572,17 +1640,20 @@ function createAtom(options, family, store) {
         options.key,
         `installing in store "${store2.config.name}"`
       );
-      return `mutable` in options ? createMutableAtom(options, store2) : createAtom(options, void 0, store2);
+      return `mutable` in options ? createMutableAtom(options, family, store2) : createRegularAtom(options, family, store2);
     },
     subject
-  }), family && { family });
+  });
+  if (family) {
+    newAtom.family = family;
+  }
   let initialValue = options.default;
   if (options.default instanceof Function) {
     initialValue = options.default();
   }
   target.atoms.set(newAtom.key, newAtom);
   markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, subject, store);
+  cacheValue(options.key, initialValue, subject, target);
   const token = deposit(newAtom);
   if (options.effects) {
     let effectIndex = 0;
@@ -1607,6 +1678,14 @@ function createAtom(options, family, store) {
   return token;
 }
 
+// internal/src/atom/create-atom.ts
+function createAtom(options, family, store) {
+  if (`mutable` in options) {
+    return createMutableAtom(options, family, store);
+  }
+  return createRegularAtom(options, family, store);
+}
+
 // internal/src/atom/delete-atom.ts
 function deleteAtom2(atomToken, store) {
   var _a, _b;
@@ -1888,26 +1967,10 @@ var addAtomToTimeline = (atomToken, tl, store) => {
 };
 
 // internal/src/mutable/is-mutable.ts
-function isMutable(atomOrTokenOrFamily, store) {
+function isMutable(atomOrTokenOrFamily) {
   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;
 }
 
@@ -2168,8 +2231,27 @@ var applyTransaction = (output, store) => {
     `Applying transaction with ${updates.length} updates:`,
     updates
   );
+  for (const tracker of child.trackers.values()) {
+    const mutableKey = tracker.mutableState.key;
+    if (!parent.atoms.has(mutableKey)) {
+      const atom = child.atoms.get(mutableKey);
+      atom == null ? void 0 : atom.install(parent);
+    }
+  }
+  for (const atom of child.atoms.values()) {
+    if (!parent.atoms.has(atom.key)) {
+      parent.atoms.set(atom.key, atom);
+      parent.valueMap.set(atom.key, atom.default);
+      parent.logger.info(
+        `\u{1F528}`,
+        `transaction`,
+        child.transactionMeta.update.key,
+        `Adding atom "${atom.key}"`
+      );
+    }
+  }
+  ingestTransactionUpdate(child.transactionMeta.update, parent, child);
   if (parent.transactionMeta === null) {
-    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
     const myTransaction = withdraw(
       { key: child.transactionMeta.update.key, type: `transaction` },
       store
@@ -2182,32 +2264,51 @@ var applyTransaction = (output, store) => {
       `Finished applying transaction.`
     );
   } else {
-    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
     parent.transactionMeta.update.updates.push(child.transactionMeta.update);
   }
   parent.subject.transactionApplying.next(null);
 };
+function getState2(token, store = Internal2__namespace.IMPLICIT.STORE) {
+  var _a;
+  const state = (_a = Internal2__namespace.withdraw(token, store)) != null ? _a : Internal2__namespace.withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new Internal2__namespace.NotFoundError(token, store);
+  }
+  return Internal2__namespace.readOrComputeValue(state, store);
+}
+function setState5(token, value, store = Internal2__namespace.IMPLICIT.STORE) {
+  const rejection = Internal2__namespace.openOperation(token, store);
+  if (rejection) {
+    return;
+  }
+  const state = Internal2__namespace.withdraw(token, store);
+  if (state === void 0) {
+    throw new Internal2__namespace.NotFoundError(token, store);
+  }
+  Internal2__namespace.setAtomOrSelector(state, value, store);
+  Internal2__namespace.closeOperation(store);
+}
+var runTransaction = (token, store = Internal2.IMPLICIT.STORE) => (...parameters) => {
+  const tx = Internal2.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/transaction/build-transaction.ts
 var buildTransaction = (key, params, store) => {
   const parent = newest(store);
-  parent.child = {
+  const child = {
     parent,
     child: null,
     subject: parent.subject,
     loggers: parent.loggers,
     logger: parent.logger,
     config: parent.config,
-    transactionMeta: {
-      phase: `building`,
-      time: Date.now(),
-      update: {
-        key,
-        updates: [],
-        params,
-        output: void 0
-      }
-    },
+    transactionMeta: null,
     atoms: new LazyMap(parent.atoms),
     atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
     families: new LazyMap(parent.families),
@@ -2224,6 +2325,22 @@ var buildTransaction = (key, params, store) => {
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap)
   };
+  child.transactionMeta = {
+    phase: `building`,
+    time: Date.now(),
+    update: {
+      key,
+      updates: [],
+      params,
+      output: void 0
+    },
+    transactors: {
+      get: (token) => getState2(token, child),
+      set: (token, value) => setState5(token, value, child),
+      run: (token) => runTransaction(token, child)
+    }
+  };
+  parent.child = child;
   store.logger.info(
     `\u{1F6EB}`,
     `transaction`,
@@ -2232,30 +2349,27 @@ var buildTransaction = (key, params, store) => {
     params
   );
 };
-function createTransaction(options, store) {
+
+// internal/src/transaction/create-transaction.ts
+function createTransaction2(options, store) {
   const newTransaction = {
     key: options.key,
     type: `transaction`,
     run: (...params) => {
       buildTransaction(options.key, params, 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)
-          },
-          ...params
-        );
-        applyTransaction(output, store);
+        const target2 = newest(store);
+        const { transactors } = target2.transactionMeta;
+        const output = options.do(transactors, ...params);
+        applyTransaction(output, target2);
         return output;
       } catch (thrown) {
-        abortTransaction(store);
+        abortTransaction(target);
         store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
         throw thrown;
       }
     },
-    install: (store2) => createTransaction(options, store2),
+    install: (store2) => createTransaction2(options, store2),
     subject: new Subject()
   };
   const target = newest(store);
@@ -2264,42 +2378,6 @@ function createTransaction(options, store) {
   store.subject.transactionCreation.next(token);
   return token;
 }
-var redoTransactionUpdate = (transactionUpdate, store) => {
-  store.logger.info(`\u23ED\uFE0F`, `transaction`, transactionUpdate.key, `Redo`);
-  for (const update of transactionUpdate.updates) {
-    if (`newValue` in update) {
-      const { key, newValue } = update;
-      const token = { key, type: `atom` };
-      const state = withdraw(token, store);
-      if (state === void 0) {
-        throw new Error(
-          `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);
-    } else {
-      redoTransactionUpdate(update, store);
-    }
-  }
-};
-var undoTransactionUpdate = (transactionUpdate, store) => {
-  store.logger.info(`\u23EE\uFE0F`, `transaction`, transactionUpdate.key, `Undo`);
-  for (const update of transactionUpdate.updates.reverse()) {
-    if (`newValue` in update) {
-      const { key, newValue } = update;
-      const token = { key, type: `atom` };
-      const state = withdraw(token, store);
-      if (state === void 0) {
-        throw new Error(
-          `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);
-    } else {
-      undoTransactionUpdate(update, store);
-    }
-  }
-};
 
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
@@ -2327,10 +2405,12 @@ exports.createAtomFamily = createAtomFamily;
 exports.createMutableAtom = createMutableAtom;
 exports.createMutableAtomFamily = createMutableAtomFamily;
 exports.createReadonlySelectorFamily = createReadonlySelectorFamily;
+exports.createRegularAtom = createRegularAtom;
+exports.createRegularAtomFamily = createRegularAtomFamily;
 exports.createSelector = createSelector;
 exports.createSelectorFamily = createSelectorFamily;
 exports.createTimeline = createTimeline;
-exports.createTransaction = createTransaction;
+exports.createTransaction = createTransaction2;
 exports.deleteAtom = deleteAtom2;
 exports.deleteSelector = deleteSelector;
 exports.deposit = deposit;
@@ -2345,7 +2425,6 @@ exports.isAtomDefault = isAtomDefault;
 exports.isAtomKey = isAtomKey;
 exports.isDone = isDone;
 exports.isReadonlySelectorKey = isReadonlySelectorKey;
-exports.isSelectorDefault = isSelectorDefault;
 exports.isSelectorKey = isSelectorKey;
 exports.isStateKey = isStateKey;
 exports.isTransceiver = isTransceiver;
@@ -2357,7 +2436,6 @@ exports.newest = newest;
 exports.openOperation = openOperation;
 exports.readCachedValue = readCachedValue;
 exports.readOrComputeValue = readOrComputeValue;
-exports.redoTransactionUpdate = redoTransactionUpdate;
 exports.registerSelector = registerSelector;
 exports.setAtomOrSelector = setAtomOrSelector;
 exports.subscribeToRootAtoms = subscribeToRootAtoms;
@@ -2367,7 +2445,6 @@ exports.subscribeToTransaction = subscribeToTransaction;
 exports.timeTravel = timeTravel;
 exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
 exports.traceSelectorAtoms = traceSelectorAtoms;
-exports.undoTransactionUpdate = undoTransactionUpdate;
 exports.updateSelectorAtoms = updateSelectorAtoms;
 exports.withdraw = withdraw;
 exports.withdrawNewFamilyMember = withdrawNewFamilyMember;