atom.io 0.21.1 → 0.23.0

package/internal/dist/index.cjs

@@ -2,6 +2,28 @@
 
 var json = require('atom.io/json');
 var atom_io = require('atom.io');
+var immortal = require('atom.io/immortal');
+var Internal = 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 Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -80,14 +102,26 @@ function newest(scion) {
 
 // internal/src/store/deposit.ts
 function deposit(state) {
-  const token = {
-    key: state.key,
-    type: state.type
-  };
-  if (`family` in state) {
-    token.family = state.family;
+  const { type } = state;
+  switch (type) {
+    case `atom`:
+    case `molecule_family`:
+    case `mutable_atom`:
+    case `selector`:
+    case `readonly_selector`:
+    case `transaction`: {
+      const token = {
+        key: state.key,
+        type: state.type
+      };
+      if (`family` in state) {
+        token.family = state.family;
+      }
+      return token;
+    }
+    case `molecule`:
+      return state.token;
   }
-  return token;
 }
 
 // ../rel8/junction/src/junction.ts
@@ -391,7 +425,7 @@ function isChildStore(store) {
 
 // internal/src/store/store.ts
 var Store = class {
-  constructor(name, store = null) {
+  constructor(config, store = null) {
     this.parent = null;
     this.child = null;
     this.valueMap = /* @__PURE__ */ new Map();
@@ -420,6 +454,9 @@ var Store = class {
         makeContentKey: (...keys) => keys.sort().join(`:`)
       }
     );
+    this.molecules = /* @__PURE__ */ new Map();
+    this.moleculeFamilies = /* @__PURE__ */ new Map();
+    this.miscResources = /* @__PURE__ */ new Map();
     this.on = {
       atomCreation: new Subject(),
       atomDisposal: new Subject(),
@@ -430,7 +467,10 @@ var Store = class {
       transactionApplying: new StatefulSubject(
         null
       ),
-      operationClose: new Subject()
+      operationClose: new Subject(),
+      moleculeCreationStart: new Subject(),
+      moleculeCreationDone: new Subject(),
+      moleculeDisposal: new Subject()
     };
     this.operation = { open: false };
     this.transactionMeta = {
@@ -441,7 +481,8 @@ var Store = class {
       })
     };
     this.config = {
-      name: `IMPLICIT_STORE`
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
     };
     this.loggers = [
       new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
@@ -471,9 +512,7 @@ var Store = class {
           )
         };
       }
-      this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
-        name
-      });
+      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
       for (const [, family] of store.families) {
         family.install(this);
       }
@@ -484,7 +523,7 @@ var Store = class {
         }
         atom.install(this);
         if (atom.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(atom);
+          const originalJsonToken = getJsonToken(atom, store);
           const originalUpdateToken = getUpdateToken(atom);
           mutableHelpers.add(originalJsonToken.key);
           mutableHelpers.add(originalUpdateToken.key);
@@ -512,16 +551,20 @@ var IMPLICIT = {
   STORE_INTERNAL: void 0,
   get STORE() {
     var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
+    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store({
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
+    });
   }
 };
 var clearStore = (store) => {
   const { config } = store;
-  Object.assign(store, new Store(config.name));
+  for (const disposable of store.miscResources.values()) {
+    disposable[Symbol.dispose]();
+  }
+  Object.assign(store, new Store(config));
   store.config = config;
 };
-
-// internal/src/store/withdraw.ts
 function withdraw(token, store) {
   let withdrawn;
   let target = store;
@@ -549,6 +592,12 @@ function withdraw(token, store) {
       case `transaction`:
         withdrawn = target.transactions.get(token.key);
         break;
+      case `molecule`:
+        withdrawn = target.molecules.get(json.stringifyJson(token.key));
+        break;
+      case `molecule_family`:
+        withdrawn = target.moleculeFamilies.get(token.key);
+        break;
     }
     if (withdrawn) {
       return withdrawn;
@@ -558,36 +607,6 @@ function withdraw(token, store) {
   throw new NotFoundError(token, store);
 }
 
-// internal/src/store/withdraw-new-family-member.ts
-function withdrawOrCreate(token, store) {
-  try {
-    const state = withdraw(token, store);
-    return state;
-  } catch (notFoundError) {
-    if (token.family) {
-      store.logger.info(
-        `\u{1F46A}`,
-        token.type,
-        token.key,
-        `creating new family member in store "${store.config.name}"`
-      );
-      const target = newest(store);
-      const family = target.families.get(token.family.key);
-      if (family) {
-        const jsonSubKey = JSON.parse(token.family.subKey);
-        family(jsonSubKey);
-        const state = withdraw(token, store);
-        return state;
-      }
-      throw new NotFoundError(
-        { key: token.family.key, type: `${token.type}_family` },
-        store
-      );
-    }
-    throw notFoundError;
-  }
-}
-
 // internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
@@ -615,22 +634,17 @@ function createRegularAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const target2 = newest(store);
-      const atomAlreadyCreated = target2.atoms.has(fullKey);
-      let token;
-      if (atomAlreadyCreated) {
-        token = { type: `atom`, key: fullKey, family };
-      } else {
-        const individualOptions = {
-          key: fullKey,
-          default: options.default instanceof Function ? options.default(key) : options.default
-        };
-        if (options.effects) {
-          individualOptions.effects = options.effects(key);
-        }
-        token = createRegularAtom(individualOptions, family, store);
-        subject.next(token);
+      const target = newest(store);
+      const def = options.default;
+      const individualOptions = {
+        key: fullKey,
+        default: def instanceof Function ? def(key) : def
+      };
+      if (options.effects) {
+        individualOptions.effects = options.effects(key);
       }
+      const token = createRegularAtom(individualOptions, family, target);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -640,8 +654,7 @@ function createRegularAtomFamily(options, store) {
       install: (s) => createRegularAtomFamily(options, s)
     }
   );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily);
   return atomFamily;
 }
 
@@ -657,22 +670,20 @@ function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
   const readonlySelectorFamily = Object.assign(
     (key) => {
-      const target = newest(store);
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = target.readonlySelectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
-      return createReadonlySelector(
+      const target = newest(store);
+      const token = createReadonlySelector(
         {
           key: fullKey,
           get: options.get(key)
         },
         family,
-        store
+        target
       );
+      subject.next({ type: `state_creation`, token });
+      return token;
     },
     {
       key: options.key,
@@ -691,10 +702,7 @@ function createWritableSelectorFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = store.selectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
+      const target = newest(store);
       const token = createWritableSelector(
         {
           key: fullKey,
@@ -702,9 +710,9 @@ function createWritableSelectorFamily(options, store) {
           set: options.set(key)
         },
         family,
-        store
+        target
       );
-      subject.next(token);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -726,14 +734,39 @@ function createSelectorFamily(options, store) {
   }
   return createReadonlySelectorFamily(options, store);
 }
+function disposeFromStore(token, store = Internal__namespace.IMPLICIT.STORE) {
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      Internal__namespace.disposeAtom(token, store);
+      break;
+    case `selector`:
+    case `readonly_selector`:
+      Internal__namespace.disposeSelector(token, store);
+      break;
+    case `molecule`:
+      immortal.disposeMolecule(token, store);
+      break;
+  }
+}
 
 // internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
-  if (token.type === `readonly_selector`) {
-    return `Readonly Selector`;
+  switch (token.type) {
+    case `atom_family`:
+      return `Atom Family`;
+    case `molecule_family`:
+      return `Molecule Family`;
+    case `readonly_selector`:
+      return `Readonly Selector`;
+    case `readonly_selector_family`:
+      return `Readonly Selector Family`;
+    case `selector_family`:
+      return `Selector Family`;
+    default:
+      return capitalize(token.type);
   }
-  return capitalize(token.type);
 }
 var NotFoundError = class extends Error {
   constructor(token, store) {
@@ -743,15 +776,36 @@ var NotFoundError = class extends Error {
   }
 };
 
-// internal/src/families/find-in-store.ts
-function findInStore(token, key, store) {
-  const familyKey = token.key;
-  const family = store.families.get(familyKey);
-  if (family === void 0) {
-    throw new NotFoundError(token, store);
+// internal/src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  const target = newest(store);
+  if (!isChildStore(target)) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
   }
-  const state = family(key);
-  return state;
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
+  );
+  target.parent.child = null;
+};
+
+// internal/src/transaction/act-upon-store.ts
+function actUponStore(token, id, store) {
+  return (...parameters) => {
+    const tx = withdraw(token, store);
+    if (tx) {
+      return tx.run(parameters, id);
+    }
+    throw new NotFoundError(token, store);
+  };
 }
 
 // internal/src/set-state/become.ts
@@ -907,7 +961,10 @@ var stowUpdate = (state, update, store) => {
   if (!shouldStow) {
     return;
   }
-  const atomUpdate = __spreadValues({ key }, update);
+  const atomUpdate = __spreadValues({
+    type: `atom_update`,
+    key
+  }, update);
   if (state.family) {
     atomUpdate.family = state.family;
   }
@@ -995,164 +1052,619 @@ function setIntoStore(token, value, store) {
     );
     return;
   }
-  const state = withdrawOrCreate(token, store);
+  const state = withdraw(token, store);
   setAtomOrSelector(state, value, store);
   closeOperation(store);
 }
 
-// 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);
-
-// 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;
-};
+// internal/src/ingest-updates/ingest-atom-update.ts
+function ingestAtomUpdate(applying, atomUpdate, store) {
+  const { key, newValue, oldValue } = atomUpdate;
+  const value = applying === `newValue` ? newValue : oldValue;
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(token, value, store);
+}
 
-// internal/src/selector/trace-selector-atoms.ts
-var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
-  const rootKeys = [];
-  const indirectDependencyKeys = getSelectorDependencyKeys(
-    directDependencyKey,
-    store
-  );
-  let depth = 0;
-  while (indirectDependencyKeys.length > 0) {
-    const indirectDependencyKey = indirectDependencyKeys.shift();
-    ++depth;
-    if (depth > 99999) {
-      throw new Error(
-        `Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`
-      );
+// ../anvl/src/json/index.ts
+var parseJson = (str) => JSON.parse(str);
+function ingestCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`: {
+      createInStore(update.token, store);
+      break;
     }
-    if (!isAtomKey(indirectDependencyKey, store)) {
-      indirectDependencyKeys.push(
-        ...getSelectorDependencyKeys(indirectDependencyKey, store)
-      );
-    } else if (!rootKeys.includes(indirectDependencyKey)) {
-      rootKeys.push(indirectDependencyKey);
+    case `oldValue`: {
+      disposeFromStore(update.token, store);
+      break;
     }
   }
-  return rootKeys;
-};
-var traceAllSelectorAtoms = (selector, store) => {
-  const selectorKey = selector.key;
-  const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
-  return directDependencyKeys.flatMap(
-    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(selectorKey, depKey, store)
-  );
-};
-
-// internal/src/selector/update-selector-atoms.ts
-var updateSelectorAtoms = (selectorKey, dependency, store) => {
-  const target = newest(store);
-  if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
-    target.selectorAtoms.set({
-      selectorKey,
-      atomKey: dependency.key
-    });
-    store.logger.info(
-      `\u{1F50D}`,
-      `selector`,
-      selectorKey,
-      `discovers root atom "${dependency.key}"`
-    );
-  } else {
-    const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store);
-    store.logger.info(
-      `\u{1F50D}`,
-      `selector`,
-      selectorKey,
-      `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`
-    );
-    for (const atomKey of rootKeys) {
-      target.selectorAtoms = target.selectorAtoms.set({
-        selectorKey,
-        atomKey
-      });
+}
+function ingestDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`: {
+      disposeFromStore(update.token, store);
+      break;
+    }
+    case `oldValue`: {
+      createInStore(update.token, store);
+      store.valueMap.set(update.token.key, update.value);
+      break;
     }
   }
-};
-
-// internal/src/selector/register-selector.ts
-var registerSelector = (selectorKey, store) => ({
-  get: (dependency) => {
-    const target = newest(store);
-    const dependencyState = withdrawOrCreate(dependency, store);
-    const dependencyValue = readOrComputeValue(dependencyState, store);
-    store.logger.info(
-      `\u{1F50C}`,
-      `selector`,
-      selectorKey,
-      `registers dependency ( "${dependency.key}" =`,
-      dependencyValue,
-      `)`
-    );
-    target.selectorGraph.set(
-      {
-        upstreamSelectorKey: dependency.key,
-        downstreamSelectorKey: selectorKey
-      },
-      {
-        source: dependency.key
+}
+function createInStore(token, store) {
+  if (token.family) {
+    const family = store.families.get(token.family.key);
+    if (family) {
+      const molecule = store.molecules.get(token.family.subKey);
+      if (molecule) {
+        molecule.bond(family);
+        return;
       }
-    );
-    updateSelectorAtoms(selectorKey, dependency, store);
-    return dependencyValue;
-  },
-  set: (WritableToken, newValue) => {
-    const state = withdrawOrCreate(WritableToken, store);
-    setAtomOrSelector(state, newValue, store);
-  },
-  find: (token, key) => findInStore(token, key, store)
-});
-
-// internal/src/selector/create-readonly-selector.ts
-var createReadonlySelector = (options, family, store) => {
-  const target = newest(store);
-  const subject = new Subject();
-  const { get, find } = registerSelector(options.key, target);
-  const getSelf = () => {
-    const value = options.get({ get, find });
-    cacheValue(options.key, value, subject, newest(store));
-    return value;
-  };
-  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
-    subject,
-    install: (s) => createReadonlySelector(options, family, s),
-    get: getSelf,
-    type: `readonly_selector`
-  }), family && { family });
-  target.readonlySelectors.set(options.key, readonlySelector);
-  const initialValue = getSelf();
-  store.logger.info(
-    `\u2728`,
-    readonlySelector.type,
-    readonlySelector.key,
-    `=`,
-    initialValue
-  );
-  const token = {
-    key: options.key,
-    type: `readonly_selector`
-  };
-  if (family) {
-    token.family = family;
+      if (store.config.lifespan === `immortal`) {
+        throw new Error(`No molecule found for key "${token.family.subKey}"`);
+      }
+      initFamilyMember(family, parseJson(token.family.subKey), store);
+    }
   }
-  store.on.selectorCreation.next(token);
-  return token;
-};
+}
+function ingestMoleculeCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      immortal.makeMoleculeInStore(
+        store,
+        update.context[0],
+        update.family,
+        update.token.key,
+        ...update.params
+      );
+      break;
+    case `oldValue`:
+      immortal.disposeMolecule(update.token, store);
+      break;
+  }
+}
+function ingestMoleculeDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      immortal.disposeMolecule(update.token, store);
+      break;
+    case `oldValue`:
+      immortal.makeMoleculeInStore(
+        store,
+        update.context[0],
+        update.family,
+        update.token.key
+      );
+      break;
+  }
+}
+
+// internal/src/ingest-updates/ingest-selector-update.ts
+function ingestSelectorUpdate(applying, selectorUpdate, store) {
+  const updates = applying === `newValue` ? selectorUpdate.atomUpdates : [...selectorUpdate.atomUpdates].reverse();
+  for (const atomUpdate of updates) {
+    ingestAtomUpdate(applying, atomUpdate, store);
+  }
+}
+
+// internal/src/ingest-updates/ingest-transaction-update.ts
+function ingestTransactionUpdate(applying, transactionUpdate, store) {
+  const updates = applying === `newValue` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
+  for (const updateFromTransaction of updates) {
+    switch (updateFromTransaction.type) {
+      case `atom_update`:
+      case `selector_update`:
+        ingestAtomUpdate(applying, updateFromTransaction, store);
+        break;
+      case `state_creation`:
+        ingestCreationEvent(updateFromTransaction, applying, store);
+        break;
+      case `state_disposal`:
+        ingestDisposalEvent(updateFromTransaction, applying, store);
+        break;
+      case `molecule_creation`:
+        ingestMoleculeCreationEvent(updateFromTransaction, applying, store);
+        break;
+      case `molecule_disposal`:
+        ingestMoleculeDisposalEvent(updateFromTransaction, applying, store);
+        break;
+      case `transaction_update`:
+        ingestTransactionUpdate(applying, updateFromTransaction, store);
+        break;
+    }
+  }
+}
+
+// internal/src/transaction/set-epoch-number.ts
+function setEpochNumberOfContinuity(continuityKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (isRoot && continuityKey) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+function setEpochNumberOfAction(transactionKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+  if (continuityKey !== void 0) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+
+// internal/src/transaction/apply-transaction.ts
+var applyTransaction = (output, store) => {
+  var _a;
+  const child = newest(store);
+  const { parent } = child;
+  if (parent === null || !isChildStore(child) || ((_a = child.transactionMeta) == null ? void 0 : _a.phase) !== `building`) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
+  }
+  child.transactionMeta.phase = `applying`;
+  child.transactionMeta.update.output = output;
+  parent.child = null;
+  parent.on.transactionApplying.next(child.transactionMeta);
+  const { updates } = child.transactionMeta.update;
+  store.logger.info(
+    `\u{1F6C4}`,
+    `transaction`,
+    child.transactionMeta.update.key,
+    `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);
+    }
+    tracker.dispose();
+  }
+  ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
+  if (isRootStore(parent)) {
+    setEpochNumberOfAction(
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch,
+      parent
+    );
+    const myTransaction = withdraw(
+      { key: child.transactionMeta.update.key, type: `transaction` },
+      store
+    );
+    myTransaction == null ? void 0 : myTransaction.subject.next(child.transactionMeta.update);
+    store.logger.info(
+      `\u{1F6EC}`,
+      `transaction`,
+      child.transactionMeta.update.key,
+      `Finished applying transaction.`
+    );
+  } else if (isChildStore(parent)) {
+    parent.transactionMeta.update.updates.push(child.transactionMeta.update);
+  }
+  parent.on.transactionApplying.next(null);
+};
+
+// internal/src/transaction/assign-transaction-to-continuity.ts
+function assignTransactionToContinuity(continuityKey, transactionKey, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const { epoch, actionContinuities } = store.transactionMeta;
+  actionContinuities.set(continuityKey, transactionKey);
+  if (!epoch.has(continuityKey)) {
+    epoch.set(continuityKey, -1);
+  }
+}
+
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    window: typeof window === `undefined` ? void 0 : window,
+    global: typeof global === `undefined` ? void 0 : global,
+    store
+  };
+}
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(token, store) {
+  const state = withdraw(token, store);
+  return readOrComputeValue(state, store);
+}
+
+// internal/src/lazy-map.ts
+var LazyMap = class extends Map {
+  constructor(source) {
+    super();
+    this.source = source;
+    this.deleted = /* @__PURE__ */ new Set();
+  }
+  get(key) {
+    const has = super.has(key);
+    if (has) {
+      return super.get(key);
+    }
+    if (!this.deleted.has(key) && this.source.has(key)) {
+      const value = this.source.get(key);
+      return value;
+    }
+    return void 0;
+  }
+  set(key, value) {
+    this.deleted.delete(key);
+    return super.set(key, value);
+  }
+  hasOwn(key) {
+    return super.has(key);
+  }
+  has(key) {
+    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+  }
+  delete(key) {
+    this.deleted.add(key);
+    return super.delete(key);
+  }
+};
+
+// internal/src/transaction/build-transaction.ts
+var buildTransaction = (key, params, store, id) => {
+  const parent = newest(store);
+  const childBase = {
+    parent,
+    child: null,
+    on: parent.on,
+    loggers: parent.loggers,
+    logger: parent.logger,
+    config: parent.config,
+    atoms: new LazyMap(parent.atoms),
+    atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
+    families: new LazyMap(parent.families),
+    operation: { open: false },
+    readonlySelectors: new LazyMap(parent.readonlySelectors),
+    timelines: new LazyMap(parent.timelines),
+    timelineAtoms: new Junction(parent.timelineAtoms.toJSON()),
+    trackers: /* @__PURE__ */ new Map(),
+    transactions: new LazyMap(parent.transactions),
+    selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
+    selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
+      makeContentKey: (...keys) => keys.sort().join(`:`)
+    }),
+    selectors: new LazyMap(parent.selectors),
+    valueMap: new LazyMap(parent.valueMap),
+    molecules: new LazyMap(parent.molecules),
+    moleculeFamilies: new LazyMap(parent.moleculeFamilies),
+    miscResources: new LazyMap(parent.miscResources)
+  };
+  const epoch = getEpochNumberOfAction(key, store);
+  const transactionMeta = {
+    phase: `building`,
+    update: {
+      type: `transaction_update`,
+      key,
+      id,
+      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
+      updates: [],
+      params,
+      output: void 0
+    },
+    transactors: {
+      get: (token) => getFromStore(token, child),
+      set: (token, value) => {
+        setIntoStore(token, value, child);
+      },
+      run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
+      find: (token, k) => findInStore(token, k, child),
+      seek: (token, k) => seekInStore(token, k, child),
+      json: (token) => getJsonToken(token, child),
+      make: (context, family, k, ...args) => immortal.makeMoleculeInStore(child, context, family, k, ...args),
+      dispose: (token) => {
+        disposeFromStore(token, child);
+      },
+      env: () => getEnvironmentData(child)
+    }
+  };
+  const child = Object.assign(childBase, {
+    transactionMeta
+  });
+  parent.child = child;
+  store.logger.info(
+    `\u{1F6EB}`,
+    `transaction`,
+    key,
+    `Building transaction with params:`,
+    params
+  );
+  return child;
+};
+
+// internal/src/transaction/create-transaction.ts
+function createTransaction(options, store) {
+  const newTransaction = {
+    key: options.key,
+    type: `transaction`,
+    run: (params, id) => {
+      const childStore = buildTransaction(options.key, params, store, id);
+      try {
+        const target2 = newest(store);
+        const { transactors } = childStore.transactionMeta;
+        const output = options.do(transactors, ...params);
+        applyTransaction(output, target2);
+        return output;
+      } catch (thrown) {
+        abortTransaction(target);
+        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
+        throw thrown;
+      }
+    },
+    install: (s) => createTransaction(options, s),
+    subject: new Subject()
+  };
+  const target = newest(store);
+  target.transactions.set(newTransaction.key, newTransaction);
+  const token = deposit(newTransaction);
+  store.on.transactionCreation.next(token);
+  return token;
+}
+
+// internal/src/transaction/get-epoch-number.ts
+function getContinuityKey(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  return continuity;
+}
+function getEpochNumberOfContinuity(continuityKey, store) {
+  const isRoot = isRootStore(store);
+  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : void 0;
+  return epoch;
+}
+function getEpochNumberOfAction(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  const epoch = isRoot && continuity !== void 0 ? store.transactionMeta.epoch.get(continuity) : void 0;
+  return epoch;
+}
+
+// internal/src/transaction/index.ts
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+
+// internal/src/families/init-family-member.ts
+function initFamilyMember(token, key, store) {
+  const familyKey = token.key;
+  const family = store.families.get(familyKey);
+  if (family === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  const state = family(key);
+  const target = newest(store);
+  if (state.family) {
+    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+      target.transactionMeta.update.updates.push({
+        type: `state_creation`,
+        token: state
+      });
+    } else {
+      switch (state.type) {
+        case `atom`:
+        case `mutable_atom`:
+          store.on.atomCreation.next(state);
+          break;
+        case `selector`:
+        case `readonly_selector`:
+          store.on.selectorCreation.next(state);
+          break;
+      }
+    }
+  }
+  return state;
+}
+function seekInStore(token, key, store) {
+  const subKey = json.stringifyJson(key);
+  const fullKey = `${token.key}(${subKey})`;
+  const target = newest(store);
+  let state;
+  switch (token.type) {
+    case `atom_family`:
+    case `mutable_atom_family`:
+      state = target.atoms.get(fullKey);
+      break;
+    case `selector_family`:
+      state = target.selectors.get(fullKey);
+      break;
+    case `readonly_selector_family`:
+      state = target.readonlySelectors.get(fullKey);
+      break;
+    case `molecule_family`:
+      state = target.molecules.get(json.stringifyJson(key));
+      if (state) {
+        return deposit(state);
+      }
+  }
+  if (state) {
+    return deposit(state);
+  }
+  return state;
+}
+
+// internal/src/families/find-in-store.ts
+function findInStore(token, key, store) {
+  if (store.config.lifespan === `immortal`) {
+    throw new Error(
+      `Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`
+    );
+  }
+  let state = seekInStore(token, key, store);
+  if (state) {
+    return state;
+  }
+  state = initFamilyMember(token, key, store);
+  return state;
+}
+
+// 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);
+
+// 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;
+};
+
+// internal/src/selector/trace-selector-atoms.ts
+var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
+  const rootKeys = [];
+  const indirectDependencyKeys = getSelectorDependencyKeys(
+    directDependencyKey,
+    store
+  );
+  let depth = 0;
+  while (indirectDependencyKeys.length > 0) {
+    const indirectDependencyKey = indirectDependencyKeys.shift();
+    ++depth;
+    if (depth > 99999) {
+      throw new Error(
+        `Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`
+      );
+    }
+    if (!isAtomKey(indirectDependencyKey, store)) {
+      indirectDependencyKeys.push(
+        ...getSelectorDependencyKeys(indirectDependencyKey, store)
+      );
+    } else if (!rootKeys.includes(indirectDependencyKey)) {
+      rootKeys.push(indirectDependencyKey);
+    }
+  }
+  return rootKeys;
+};
+var traceAllSelectorAtoms = (selector, store) => {
+  const selectorKey = selector.key;
+  const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
+  return directDependencyKeys.flatMap(
+    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(selectorKey, depKey, store)
+  );
+};
+
+// internal/src/selector/update-selector-atoms.ts
+var updateSelectorAtoms = (selectorKey, dependency, store) => {
+  const target = newest(store);
+  if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
+    target.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key
+    });
+    store.logger.info(
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atom "${dependency.key}"`
+    );
+  } else {
+    const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store);
+    store.logger.info(
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`
+    );
+    for (const atomKey of rootKeys) {
+      target.selectorAtoms = target.selectorAtoms.set({
+        selectorKey,
+        atomKey
+      });
+    }
+  }
+};
+
+// internal/src/selector/register-selector.ts
+var registerSelector = (selectorKey, store) => ({
+  get: (dependency) => {
+    const target = newest(store);
+    const dependencyState = withdraw(dependency, store);
+    const dependencyValue = readOrComputeValue(dependencyState, store);
+    store.logger.info(
+      `\u{1F50C}`,
+      `selector`,
+      selectorKey,
+      `registers dependency ( "${dependency.key}" =`,
+      dependencyValue,
+      `)`
+    );
+    target.selectorGraph.set(
+      {
+        upstreamSelectorKey: dependency.key,
+        downstreamSelectorKey: selectorKey
+      },
+      {
+        source: dependency.key
+      }
+    );
+    updateSelectorAtoms(selectorKey, dependency, store);
+    return dependencyValue;
+  },
+  set: (WritableToken, newValue) => {
+    const state = withdraw(WritableToken, store);
+    setAtomOrSelector(state, newValue, store);
+  },
+  find: (token, key) => findInStore(token, key, store),
+  seek: (token, key) => seekInStore(token, key, store),
+  json: (token) => getJsonToken(token, store)
+});
+
+// internal/src/selector/create-readonly-selector.ts
+var createReadonlySelector = (options, family, store) => {
+  const target = newest(store);
+  const subject = new Subject();
+  const { get, find, seek, json } = registerSelector(options.key, target);
+  const getSelf = () => {
+    const value = options.get({ get, find, seek, json });
+    cacheValue(options.key, value, subject, newest(store));
+    return value;
+  };
+  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => createReadonlySelector(options, family, s),
+    get: getSelf,
+    type: `readonly_selector`
+  }), family && { family });
+  target.readonlySelectors.set(options.key, readonlySelector);
+  const initialValue = getSelf();
+  store.logger.info(
+    `\u2728`,
+    readonlySelector.type,
+    readonlySelector.key,
+    `=`,
+    initialValue
+  );
+  const token = {
+    key: options.key,
+    type: `readonly_selector`
+  };
+  if (family) {
+    token.family = family;
+  }
+  return token;
+};
 
 // internal/src/selector/create-writable-selector.ts
 var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
   const transactors = registerSelector(options.key, target);
-  const { find, get } = transactors;
-  const readonlyTransactors = { find, get };
+  const { find, get, seek, json } = transactors;
+  const readonlyTransactors = { find, get, seek, json };
   const getSelf = () => {
     const value = options.get(readonlyTransactors);
     cacheValue(options.key, value, subject, newest(store));
@@ -1195,7 +1707,6 @@ var createWritableSelector = (options, family, store) => {
   if (family) {
     token.family = family;
   }
-  store.on.selectorCreation.next(token);
   return token;
 };
 
@@ -1203,39 +1714,88 @@ var createWritableSelector = (options, family, store) => {
 function createStandaloneSelector(options, store) {
   const isWritable = `set` in options;
   if (isWritable) {
-    return createWritableSelector(options, void 0, store);
+    const state2 = createWritableSelector(options, void 0, store);
+    store.on.selectorCreation.next(state2);
+    return state2;
   }
-  return createReadonlySelector(options, void 0, store);
+  const state = createReadonlySelector(options, void 0, store);
+  store.on.selectorCreation.next(state);
+  return state;
 }
 
 // internal/src/selector/dispose-selector.ts
-function disposeSelector(selectorToken, store) {
+function disposeSelector2(selectorToken, store) {
+  var _a;
   const target = newest(store);
   const { key } = selectorToken;
-  switch (selectorToken.type) {
-    case `selector`:
-      target.selectors.delete(key);
-      break;
-    case `readonly_selector`:
-      target.readonlySelectors.delete(key);
-      break;
-  }
-  target.valueMap.delete(key);
-  target.selectorAtoms.delete(key);
-  const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
-    ([downstreamSelectorKey]) => {
-      var _a;
-      return (_a = target.selectors.get(downstreamSelectorKey)) != null ? _a : target.readonlySelectors.get(downstreamSelectorKey);
+  const selector = (_a = target.selectors.get(key)) != null ? _a : target.readonlySelectors.get(key);
+  if (!selector) {
+    store.logger.info(
+      `\u274C`,
+      `selector`,
+      key,
+      `Tried to dispose selector, but it does not exist in the store.`
+    );
+  } else if (!selector.family) {
+    store.logger.error(
+      `\u274C`,
+      `selector`,
+      key,
+      `Standalone selectors cannot be disposed.`
+    );
+  } else {
+    switch (selectorToken.type) {
+      case `selector`:
+        {
+          target.selectors.delete(key);
+          const family = withdraw(
+            { key: selector.family.key, type: `selector_family` },
+            store
+          );
+          family.subject.next({
+            type: `state_disposal`,
+            token: selectorToken
+          });
+        }
+        break;
+      case `readonly_selector`:
+        {
+          target.readonlySelectors.delete(key);
+          const family = withdraw(
+            { key: selector.family.key, type: `readonly_selector_family` },
+            store
+          );
+          family.subject.next({
+            type: `state_disposal`,
+            token: selectorToken
+          });
+        }
+        break;
     }
-  );
-  for (const downstreamToken of downstreamTokens) {
-    if (downstreamToken) {
-      disposeSelector(downstreamToken, store);
+    target.valueMap.delete(key);
+    target.selectorAtoms.delete(key);
+    const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
+      ([downstreamSelectorKey]) => {
+        var _a2;
+        return (_a2 = target.selectors.get(downstreamSelectorKey)) != null ? _a2 : target.readonlySelectors.get(downstreamSelectorKey);
+      }
+    );
+    for (const downstreamToken of downstreamTokens) {
+      if (downstreamToken) {
+        disposeSelector2(downstreamToken, store);
+      }
+    }
+    target.selectorGraph.delete(key);
+    store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
+    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+      target.transactionMeta.update.updates.push({
+        type: `state_disposal`,
+        token: selectorToken
+      });
+    } else {
+      store.on.selectorDisposal.next(selectorToken);
     }
   }
-  target.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
-  store.on.selectorDisposal.next(selectorToken);
 }
 
 // internal/src/subscribe/recall-state.ts
@@ -1306,7 +1866,7 @@ function subscribeToState(token, handleUpdate, key, store) {
       handleUpdate(update);
     }
   }
-  const state = withdrawOrCreate(token, store);
+  const state = withdraw(token, store);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
   const isSelector = state.type === `selector` || state.type === `readonly_selector`;
   let dependencyUnsubFunctions = null;
@@ -1567,37 +2127,40 @@ function createMutableAtom(options, family, store) {
     };
   }
   new Tracker(token, store);
-  json.selectJson(token, options, store);
-  store.on.atomCreation.next(token);
+  if (!family) {
+    json.selectJson(token, options, store);
+  }
   return token;
 }
 var FamilyTracker = class {
-  constructor(findMutableState, store) {
-    this.findLatestUpdateState = createRegularAtomFamily(
+  constructor(mutableAtoms, store) {
+    this.latestUpdateAtoms = createRegularAtomFamily(
       {
-        key: `*${findMutableState.key}`,
+        key: `*${mutableAtoms.key}`,
         default: null
       },
       store
     );
-    this.findMutableState = findMutableState;
-    this.findMutableState.subject.subscribe(
+    this.mutableAtoms = mutableAtoms;
+    this.mutableAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
-      (atomToken) => {
-        if (atomToken.family) {
-          const key = json.parseJson(atomToken.family.subKey);
-          this.findLatestUpdateState(key);
-          new Tracker(atomToken, store);
+      (event) => {
+        if (event.token.family) {
+          const key = json.parseJson(event.token.family.subKey);
+          seekInStore(this.latestUpdateAtoms, key, store);
+          new Tracker(event.token, store);
         }
       }
     );
-    this.findLatestUpdateState.subject.subscribe(
+    this.latestUpdateAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
-      (atomToken) => {
-        if (atomToken.family) {
-          const key = json.parseJson(atomToken.family.subKey);
-          const mutableAtomToken = this.findMutableState(key);
-          new Tracker(mutableAtomToken, store);
+      (event) => {
+        if (event.token.family) {
+          const key = json.parseJson(event.token.family.subKey);
+          const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
+          if (mutableAtomToken) {
+            new Tracker(mutableAtomToken, store);
+          }
         }
       }
     );
@@ -1612,25 +2175,19 @@ function createMutableAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const target2 = newest(store);
-      const atomAlreadyCreated = target2.atoms.has(fullKey);
-      let token;
-      if (atomAlreadyCreated) {
-        token = { type: `mutable_atom`, key: fullKey, family };
-      } else {
-        const individualOptions = {
-          key: fullKey,
-          default: () => options.default(key),
-          toJson: options.toJson,
-          fromJson: options.fromJson,
-          mutable: true
-        };
-        if (options.effects) {
-          individualOptions.effects = options.effects(key);
-        }
-        token = createMutableAtom(individualOptions, family, store);
-        subject.next(token);
+      const target = newest(store);
+      const individualOptions = {
+        key: fullKey,
+        default: () => options.default(key),
+        toJson: options.toJson,
+        fromJson: options.fromJson,
+        mutable: true
+      };
+      if (options.effects) {
+        individualOptions.effects = options.effects(key);
       }
+      const token = createMutableAtom(individualOptions, family, target);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -1642,8 +2199,7 @@ function createMutableAtomFamily(options, store) {
       fromJson: options.fromJson
     }
   );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily);
   json.selectJsonFamily(atomFamily, options, store);
   new FamilyTracker(atomFamily, store);
   return atomFamily;
@@ -1658,19 +2214,24 @@ var getJsonFamily = (mutableAtomFamily, store) => {
 };
 
 // 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
-  };
+var getJsonToken = (mutableAtomToken, store) => {
   if (mutableAtomToken.family) {
-    jsonToken.family = {
-      key: `${mutableAtomToken.family.key}:JSON`,
-      subKey: mutableAtomToken.family.subKey
+    const target = newest(store);
+    const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
+    const jsonFamilyToken = {
+      key: jsonFamilyKey,
+      type: `selector_family`
     };
+    const family = withdraw(jsonFamilyToken, target);
+    const subKey = JSON.parse(mutableAtomToken.family.subKey);
+    const jsonToken = findInStore(family, subKey, store);
+    return jsonToken;
   }
-  return jsonToken;
+  const token = {
+    type: `selector`,
+    key: `${mutableAtomToken.key}:JSON`
+  };
+  return token;
 };
 
 // internal/src/mutable/get-update-token.ts
@@ -1842,7 +2403,6 @@ function createRegularAtom(options, family, store) {
       }
     };
   }
-  store.on.atomCreation.next(token);
   return token;
 }
 
@@ -1850,13 +2410,17 @@ function createRegularAtom(options, family, store) {
 function createStandaloneAtom(options, store) {
   const isMutable2 = `mutable` in options;
   if (isMutable2) {
-    return createMutableAtom(options, void 0, store);
+    const state2 = createMutableAtom(options, void 0, store);
+    store.on.atomCreation.next(state2);
+    return state2;
   }
-  return createRegularAtom(options, void 0, store);
+  const state = createRegularAtom(options, void 0, store);
+  store.on.atomCreation.next(state);
+  return state;
 }
 
 // internal/src/atom/dispose-atom.ts
-function disposeAtom(atomToken, store) {
+function disposeAtom2(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -1866,10 +2430,19 @@ function disposeAtom(atomToken, store) {
       `\u274C`,
       `atom`,
       key,
-      `Tried to delete atom, but it does not exist in the store.`
+      `Tried to dispose atom, but it does not exist in the store.`
     );
+  } else if (!atom.family) {
+    store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
     (_a = atom.cleanup) == null ? void 0 : _a.call(atom);
+    const lastValue = store.valueMap.get(atom.key);
+    const family = withdraw({ key: atom.family.key, type: `atom_family` }, store);
+    family.subject.next({
+      type: `state_disposal`,
+      token: atomToken,
+      value: lastValue
+    });
     target.atoms.delete(key);
     target.valueMap.delete(key);
     const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
@@ -1877,7 +2450,7 @@ function disposeAtom(atomToken, store) {
       for (const selectorKey of selectorKeys) {
         const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
         if (token) {
-          disposeSelector(token, store);
+          disposeSelector2(token, store);
         }
       }
     }
@@ -1886,93 +2459,21 @@ function disposeAtom(atomToken, store) {
     target.timelineAtoms.delete(key);
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
-      disposeAtom(updateToken, store);
+      disposeAtom2(updateToken, store);
+      store.trackers.delete(key);
     }
     store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
-    store.on.atomDisposal.next(atomToken);
-  }
-}
-
-// internal/src/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    window: typeof window === `undefined` ? void 0 : window,
-    global: typeof global === `undefined` ? void 0 : global,
-    store
-  };
-}
-
-// internal/src/get-state/get-from-store.ts
-function getFromStore(token, store) {
-  const state = withdrawOrCreate(token, store);
-  return readOrComputeValue(state, store);
-}
-
-// internal/src/ingest-updates/ingest-atom-update.ts
-function ingestAtomUpdate(applying, atomUpdate, store) {
-  const { key, newValue, oldValue } = atomUpdate;
-  const value = applying === `newValue` ? newValue : oldValue;
-  const token = { key, type: `atom` };
-  if (atomUpdate.family) {
-    Object.assign(token, { family: atomUpdate.family });
-  }
-  setIntoStore(token, value, store);
-}
-
-// internal/src/ingest-updates/ingest-selector-update.ts
-function ingestSelectorUpdate(applying, selectorUpdate, store) {
-  const updates = applying === `newValue` ? selectorUpdate.atomUpdates : [...selectorUpdate.atomUpdates].reverse();
-  for (const atomUpdate of updates) {
-    ingestAtomUpdate(applying, atomUpdate, store);
-  }
-}
-
-// internal/src/ingest-updates/ingest-transaction-update.ts
-function ingestTransactionUpdate(applying, transactionUpdate, store) {
-  const updates = applying === `newValue` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
-  for (const updateFromTransaction of updates) {
-    if (`newValue` in updateFromTransaction) {
-      ingestAtomUpdate(applying, updateFromTransaction, store);
+    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+      target.transactionMeta.update.updates.push({
+        type: `state_disposal`,
+        token: atomToken
+      });
     } else {
-      ingestTransactionUpdate(applying, updateFromTransaction, store);
+      store.on.atomDisposal.next(atomToken);
     }
   }
 }
 
-// internal/src/lazy-map.ts
-var LazyMap = class extends Map {
-  constructor(source) {
-    super();
-    this.source = source;
-    this.deleted = /* @__PURE__ */ new Set();
-  }
-  get(key) {
-    const has = super.has(key);
-    if (has) {
-      return super.get(key);
-    }
-    if (!this.deleted.has(key) && this.source.has(key)) {
-      const value = this.source.get(key);
-      return value;
-    }
-    return void 0;
-  }
-  set(key, value) {
-    this.deleted.delete(key);
-    return super.set(key, value);
-  }
-  hasOwn(key) {
-    return super.has(key);
-  }
-  has(key) {
-    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
-  }
-  delete(key) {
-    this.deleted.add(key);
-    return super.delete(key);
-  }
-};
-
 // internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
   let maybeAtom = withdraw(atomToken, store);
@@ -1982,188 +2483,212 @@ var addAtomToTimeline = (atomToken, tl, store) => {
   }
   const atom = maybeAtom;
   store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key });
-  atom.subject.subscribe(`timeline`, (update) => {
-    var _a, _b, _c, _d, _e, _f;
-    const target = newest(store);
-    const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
-    const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
-    const { transactionApplying } = target.on;
-    const currentTransactionKey = (_a = transactionApplying.state) == null ? void 0 : _a.update.key;
-    const currentTransactionInstanceId = (_b = transactionApplying.state) == null ? void 0 : _b.update.id;
-    store.logger.info(
-      `\u23F3`,
-      `timeline`,
-      tl.key,
-      `atom`,
-      atomToken.key,
-      `went`,
-      update.oldValue,
-      `->`,
-      update.newValue,
-      currentTransactionKey ? `in transaction "${currentTransactionKey}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
-    );
-    if (tl.timeTraveling === null) {
-      if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
-        const mostRecentUpdate = tl.history.at(-1);
-        if (mostRecentUpdate === void 0) {
-          throw new Error(
-            `Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`
-          );
-        }
-      }
-      if (currentTransactionKey) {
-        const txToken = {
-          key: currentTransactionKey,
-          type: `transaction`
-        };
-        const currentTransaction = withdraw(txToken, store);
-        if (tl.transactionKey !== currentTransactionKey) {
-          if (tl.transactionKey) {
-            store.logger.error(
-              `\u{1F41E}`,
-              `timeline`,
-              tl.key,
-              `unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`
+  tl.subscriptions.set(
+    atom.key,
+    atom.subject.subscribe(`timeline`, (update) => {
+      var _a, _b, _c, _d, _e, _f;
+      const target = newest(store);
+      const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
+      const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
+      const { transactionApplying } = target.on;
+      const currentTransactionKey = (_a = transactionApplying.state) == null ? void 0 : _a.update.key;
+      const currentTransactionInstanceId = (_b = transactionApplying.state) == null ? void 0 : _b.update.id;
+      store.logger.info(
+        `\u23F3`,
+        `timeline`,
+        tl.key,
+        `atom`,
+        atomToken.key,
+        `went`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        currentTransactionKey ? `in transaction "${currentTransactionKey}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
+      );
+      if (tl.timeTraveling === null) {
+        if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
+          const mostRecentUpdate = tl.history.at(-1);
+          if (mostRecentUpdate === void 0) {
+            throw new Error(
+              `Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`
             );
           }
-          tl.transactionKey = currentTransactionKey;
-          const unsubscribe = currentTransaction.subject.subscribe(
-            `timeline:${tl.key}`,
-            (transactionUpdate) => {
-              var _a2, _b2;
-              unsubscribe();
-              if (tl.timeTraveling === null && currentTransactionInstanceId) {
-                if (tl.at !== tl.history.length) {
-                  tl.history.splice(tl.at);
-                }
-                const filterUpdates = (updates2) => updates2.filter((updateFromTx) => {
-                  const newestStore = newest(store);
-                  if (`updates` in updateFromTx) {
-                    return true;
+        }
+        if (currentTransactionKey) {
+          const txToken = {
+            key: currentTransactionKey,
+            type: `transaction`
+          };
+          const currentTransaction = withdraw(txToken, store);
+          if (tl.transactionKey !== currentTransactionKey) {
+            if (tl.transactionKey) {
+              store.logger.error(
+                `\u{1F41E}`,
+                `timeline`,
+                tl.key,
+                `unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`
+              );
+            }
+            tl.transactionKey = currentTransactionKey;
+            const unsubscribe = currentTransaction.subject.subscribe(
+              `timeline:${tl.key}`,
+              (transactionUpdate) => {
+                var _a2, _b2;
+                unsubscribe();
+                if (tl.timeTraveling === null && currentTransactionInstanceId) {
+                  if (tl.at !== tl.history.length) {
+                    tl.history.splice(tl.at);
                   }
-                  const atomOrFamilyKeys = newestStore.timelineAtoms.getRelatedKeys(tl.key);
-                  return atomOrFamilyKeys ? [...atomOrFamilyKeys].some(
-                    (key) => {
-                      var _a3;
-                      return key === updateFromTx.key || key === ((_a3 = updateFromTx.family) == null ? void 0 : _a3.key);
+                  const filterUpdates = (updates2) => updates2.filter((updateFromTx) => {
+                    var _a3, _b3;
+                    const newestStore = newest(store);
+                    if (`updates` in updateFromTx) {
+                      return true;
+                    }
+                    const atomOrFamilyKeys = newestStore.timelineAtoms.getRelatedKeys(tl.key);
+                    if (!atomOrFamilyKeys) {
+                      return false;
+                    }
+                    let key;
+                    let familyKey;
+                    switch (updateFromTx.type) {
+                      case `state_creation`:
+                      case `state_disposal`:
+                        key = updateFromTx.token.key;
+                        familyKey = (_a3 = updateFromTx.token.family) == null ? void 0 : _a3.key;
+                        break;
+                      case `molecule_creation`:
+                      case `molecule_disposal`:
+                        break;
+                      default:
+                        key = updateFromTx.key;
+                        familyKey = (_b3 = updateFromTx.family) == null ? void 0 : _b3.key;
+                        break;
+                    }
+                    if (key === void 0) {
+                      return false;
+                    }
+                    if (atomOrFamilyKeys.has(key)) {
+                      return true;
                     }
-                  ) : false;
-                }).map((updateFromTx) => {
-                  if (`updates` in updateFromTx) {
-                    return __spreadProps(__spreadValues({}, updateFromTx), {
-                      updates: filterUpdates(updateFromTx.updates)
-                    });
+                    if (familyKey !== void 0) {
+                      return atomOrFamilyKeys.has(familyKey);
+                    }
+                    return false;
+                  }).map((updateFromTx) => {
+                    if (`updates` in updateFromTx) {
+                      return __spreadProps(__spreadValues({}, updateFromTx), {
+                        updates: filterUpdates(updateFromTx.updates)
+                      });
+                    }
+                    return updateFromTx;
+                  });
+                  const updates = filterUpdates(transactionUpdate.updates);
+                  const timelineTransactionUpdate = __spreadProps(__spreadValues({
+                    timestamp: Date.now()
+                  }, transactionUpdate), {
+                    updates
+                  });
+                  const willCapture = (_b2 = (_a2 = tl.shouldCapture) == null ? void 0 : _a2.call(tl, timelineTransactionUpdate, tl)) != null ? _b2 : true;
+                  if (willCapture) {
+                    tl.history.push(timelineTransactionUpdate);
+                    tl.at = tl.history.length;
+                    tl.subject.next(timelineTransactionUpdate);
                   }
-                  return updateFromTx;
-                });
-                const updates = filterUpdates(transactionUpdate.updates);
-                const timelineTransactionUpdate = __spreadProps(__spreadValues({
-                  type: `transaction_update`,
-                  timestamp: Date.now()
-                }, transactionUpdate), {
-                  updates
-                });
-                const willCapture = (_b2 = (_a2 = tl.shouldCapture) == null ? void 0 : _a2.call(tl, timelineTransactionUpdate, tl)) != null ? _b2 : true;
-                if (willCapture) {
-                  tl.history.push(timelineTransactionUpdate);
-                  tl.at = tl.history.length;
-                  tl.subject.next(timelineTransactionUpdate);
                 }
+                tl.transactionKey = null;
+                store.logger.info(
+                  `\u231B`,
+                  `timeline`,
+                  tl.key,
+                  `got a transaction_update "${transactionUpdate.key}"`
+                );
               }
-              tl.transactionKey = null;
+            );
+          }
+        } else if (currentSelectorKey && currentSelectorTime) {
+          let latestUpdate = tl.history.at(-1);
+          if (currentSelectorTime !== tl.selectorTime) {
+            latestUpdate = {
+              type: `selector_update`,
+              timestamp: currentSelectorTime,
+              key: currentSelectorKey,
+              atomUpdates: []
+            };
+            latestUpdate.atomUpdates.push(__spreadValues({
+              key: atom.key,
+              type: `atom_update`
+            }, update));
+            if (tl.at !== tl.history.length) {
+              tl.history.splice(tl.at);
+            }
+            tl.history.push(latestUpdate);
+            store.logger.info(
+              `\u231B`,
+              `timeline`,
+              tl.key,
+              `got a selector_update "${currentSelectorKey}" with`,
+              latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            );
+            tl.at = tl.history.length;
+            tl.selectorTime = currentSelectorTime;
+          } else {
+            if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
+              latestUpdate.atomUpdates.push(__spreadValues({
+                key: atom.key,
+                type: `atom_update`
+              }, update));
               store.logger.info(
                 `\u231B`,
                 `timeline`,
                 tl.key,
-                `got a transaction_update "${transactionUpdate.key}"`
+                `set selector_update "${currentSelectorKey}" to`,
+                latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
               );
             }
-          );
-        }
-      } else if (currentSelectorKey && currentSelectorTime) {
-        let latestUpdate = tl.history.at(-1);
-        if (currentSelectorTime !== tl.selectorTime) {
-          latestUpdate = {
-            type: `selector_update`,
-            timestamp: currentSelectorTime,
-            key: currentSelectorKey,
-            atomUpdates: []
-          };
-          latestUpdate.atomUpdates.push(__spreadValues({
-            key: atom.key,
-            type: `atom_update`
-          }, update));
+          }
+          if (latestUpdate) {
+            const willCaptureSelectorUpdate = (_d = (_c = tl.shouldCapture) == null ? void 0 : _c.call(tl, latestUpdate, tl)) != null ? _d : true;
+            if (willCaptureSelectorUpdate) {
+              tl.subject.next(latestUpdate);
+            } else {
+              tl.history.pop();
+              tl.at = tl.history.length;
+            }
+          }
+        } else {
+          const timestamp = Date.now();
+          tl.selectorTime = null;
           if (tl.at !== tl.history.length) {
             tl.history.splice(tl.at);
           }
-          tl.history.push(latestUpdate);
+          const atomUpdate = {
+            type: `atom_update`,
+            timestamp,
+            key: atom.key,
+            oldValue: update.oldValue,
+            newValue: update.newValue
+          };
+          if (atom.family) {
+            atomUpdate.family = atom.family;
+          }
+          const willCapture = (_f = (_e = tl.shouldCapture) == null ? void 0 : _e.call(tl, atomUpdate, tl)) != null ? _f : true;
           store.logger.info(
             `\u231B`,
             `timeline`,
             tl.key,
-            `got a selector_update "${currentSelectorKey}" with`,
-            latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            `got an atom_update to "${atom.key}"`
           );
-          tl.at = tl.history.length;
-          tl.selectorTime = currentSelectorTime;
-        } else {
-          if ((latestUpdate == null ? void 0 : latestUpdate.type) === `selector_update`) {
-            latestUpdate.atomUpdates.push(__spreadValues({
-              key: atom.key,
-              type: `atom_update`
-            }, update));
-            store.logger.info(
-              `\u231B`,
-              `timeline`,
-              tl.key,
-              `set selector_update "${currentSelectorKey}" to`,
-              latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-            );
-          }
-        }
-        if (latestUpdate) {
-          const willCaptureSelectorUpdate = (_d = (_c = tl.shouldCapture) == null ? void 0 : _c.call(tl, latestUpdate, tl)) != null ? _d : true;
-          if (willCaptureSelectorUpdate) {
-            tl.subject.next(latestUpdate);
-          } else {
-            tl.history.pop();
+          if (willCapture) {
+            tl.history.push(atomUpdate);
             tl.at = tl.history.length;
+            tl.subject.next(atomUpdate);
           }
         }
-      } else {
-        const timestamp = Date.now();
-        tl.selectorTime = null;
-        if (tl.at !== tl.history.length) {
-          tl.history.splice(tl.at);
-        }
-        const atomUpdate = {
-          type: `atom_update`,
-          timestamp,
-          key: atom.key,
-          oldValue: update.oldValue,
-          newValue: update.newValue
-        };
-        if (atom.family) {
-          atomUpdate.family = atom.family;
-        }
-        const willCapture = (_f = (_e = tl.shouldCapture) == null ? void 0 : _e.call(tl, atomUpdate, tl)) != null ? _f : true;
-        store.logger.info(
-          `\u231B`,
-          `timeline`,
-          tl.key,
-          `got an atom_update to "${atom.key}"`
-        );
-        if (willCapture) {
-          tl.history.push(atomUpdate);
-          tl.at = tl.history.length;
-          tl.subject.next(atomUpdate);
-        }
       }
-    }
-  });
+    })
+  );
 };
-
-// internal/src/timeline/create-timeline.ts
 function createTimeline(options, store, data) {
   var _a, _b;
   const tl = __spreadProps(__spreadValues({
@@ -2176,60 +2701,141 @@ function createTimeline(options, store, data) {
   }, data), {
     history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
     install: (s) => createTimeline(options, s, tl),
-    subject: new Subject()
+    subject: new Subject(),
+    subscriptions: /* @__PURE__ */ new Map()
   });
   if (options.shouldCapture) {
     tl.shouldCapture = options.shouldCapture;
   }
   const timelineKey = options.key;
   const target = newest(store);
-  for (const tokenOrFamily of options.atoms) {
+  for (const tokenOrFamily of options.scope) {
     let atomKey = tokenOrFamily.key;
-    if (tokenOrFamily.type === `atom_family` || tokenOrFamily.type === `mutable_atom_family`) {
-      const familyToken = tokenOrFamily;
-      const family = withdraw(familyToken, store);
-      const familyKey = family.key;
-      target.timelineAtoms.set({ atomKey: familyKey, timelineKey });
-      family.subject.subscribe(`timeline:${options.key}`, (token2) => {
-        addAtomToTimeline(token2, tl, store);
-      });
-      for (const atom of target.atoms.values()) {
-        if (((_b = atom.family) == null ? void 0 : _b.key) === familyKey) {
+    switch (tokenOrFamily.type) {
+      case `atom_family`:
+      case `mutable_atom_family`:
+        {
+          const familyToken = tokenOrFamily;
+          const family = withdraw(familyToken, store);
+          const familyKey = family.key;
+          target.timelineAtoms.set({ atomKey: familyKey, timelineKey });
+          tl.subscriptions.set(
+            family.key,
+            family.subject.subscribe(
+              `timeline:${options.key}`,
+              (creationOrDisposal) => {
+                handleStateLifecycleEvent(creationOrDisposal, tl, store);
+              }
+            )
+          );
+          for (const atom of target.atoms.values()) {
+            if (((_b = atom.family) == null ? void 0 : _b.key) === familyKey) {
+              addAtomToTimeline(atom, tl, store);
+            }
+          }
+        }
+        break;
+      case `atom`:
+      case `mutable_atom`:
+        {
+          let atom = withdraw(tokenOrFamily, store);
+          if (isMutable(atom)) {
+            const updateAtom = withdraw(getUpdateToken(atom), store);
+            atom = updateAtom;
+            atomKey = atom.key;
+          }
+          if (`family` in atom) {
+            const familyTimelineKey = target.timelineAtoms.getRelatedKey(
+              atom.family.key
+            );
+            if (familyTimelineKey) {
+              store.logger.error(
+                `\u274C`,
+                `timeline`,
+                options.key,
+                `Failed to add atom "${atom.key}" because its family "${atom.family.key}" already belongs to timeline "${familyTimelineKey}"`
+              );
+              continue;
+            }
+          }
+          const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey);
+          if (existingTimelineKey) {
+            store.logger.error(
+              `\u274C`,
+              `timeline`,
+              options.key,
+              `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
+            );
+            continue;
+          }
           addAtomToTimeline(atom, tl, store);
         }
-      }
-    } else {
-      let atom = withdraw(tokenOrFamily, store);
-      if (isMutable(atom)) {
-        const updateAtom = withdraw(getUpdateToken(atom), store);
-        atom = updateAtom;
-        atomKey = atom.key;
-      }
-      if (`family` in atom) {
-        const familyTimelineKey = target.timelineAtoms.getRelatedKey(
-          atom.family.key
-        );
-        if (familyTimelineKey) {
-          store.logger.error(
-            `\u274C`,
-            `timeline`,
-            options.key,
-            `Failed to add atom "${atom.key}" because its family "${atom.family.key}" already belongs to timeline "${familyTimelineKey}"`
-          );
-          continue;
+        break;
+      case `molecule_family`:
+        {
+          const family = store.moleculeFamilies.get(tokenOrFamily.key);
+          if (family) {
+            tl.subscriptions.set(
+              tokenOrFamily.key,
+              family.subject.subscribe(
+                `timeline:${options.key}`,
+                (creationOrDisposal) => {
+                  var _a2, _b2;
+                  switch (creationOrDisposal.type) {
+                    case `molecule_creation`:
+                      {
+                        const molecule = store.molecules.get(
+                          json.stringifyJson(creationOrDisposal.token.key)
+                        );
+                        if (molecule) {
+                          const event = Object.assign(creationOrDisposal, {
+                            timestamp: Date.now()
+                          });
+                          tl.history.push(event);
+                          tl.at = tl.history.length;
+                          tl.subject.next(event);
+                          for (const token2 of molecule.tokens) {
+                            switch (token2.type) {
+                              case `atom`:
+                              case `mutable_atom`:
+                                addAtomToTimeline(token2, tl, store);
+                                break;
+                            }
+                          }
+                          tl.subscriptions.set(
+                            molecule.key,
+                            molecule.subject.subscribe(
+                              `timeline:${options.key}`,
+                              (stateCreationOrDisposal) => {
+                                handleStateLifecycleEvent(
+                                  stateCreationOrDisposal,
+                                  tl,
+                                  store
+                                );
+                              }
+                            )
+                          );
+                        }
+                      }
+                      break;
+                    case `molecule_disposal`:
+                      (_a2 = tl.subscriptions.get(creationOrDisposal.token.key)) == null ? void 0 : _a2();
+                      tl.subscriptions.delete(creationOrDisposal.token.key);
+                      for (const familyKey of creationOrDisposal.familyKeys) {
+                        const stateKey = `${familyKey}(${json.stringifyJson(
+                          creationOrDisposal.token.key
+                        )})`;
+                        (_b2 = tl.subscriptions.get(stateKey)) == null ? void 0 : _b2();
+                        tl.subscriptions.delete(stateKey);
+                      }
+                      break;
+                  }
+                }
+              )
+            );
+          }
         }
-      }
-      const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey);
-      if (existingTimelineKey) {
-        store.logger.error(
-          `\u274C`,
-          `timeline`,
-          options.key,
-          `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
-        );
-        continue;
-      }
-      addAtomToTimeline(atom, tl, store);
+        break;
     }
   }
   store.timelines.set(options.key, tl);
@@ -2240,6 +2846,27 @@ function createTimeline(options, store, data) {
   store.on.timelineCreation.next(token);
   return token;
 }
+function handleStateLifecycleEvent(event, tl, store) {
+  var _a;
+  const timestamp = Date.now();
+  const timelineEvent = Object.assign(event, {
+    timestamp
+  });
+  if (!tl.timeTraveling) {
+    tl.history.push(timelineEvent);
+    tl.at = tl.history.length;
+    tl.subject.next(timelineEvent);
+  }
+  switch (event.type) {
+    case `state_creation`:
+      addAtomToTimeline(event.token, tl, store);
+      break;
+    case `state_disposal`:
+      (_a = tl.subscriptions.get(event.token.key)) == null ? void 0 : _a();
+      tl.subscriptions.delete(event.token.key);
+      break;
+  }
+}
 
 // internal/src/timeline/time-travel.ts
 var timeTravel = (action, token, store) => {
@@ -2287,6 +2914,22 @@ var timeTravel = (action, token, store) => {
       ingestTransactionUpdate(applying, update, store);
       break;
     }
+    case `state_creation`: {
+      ingestCreationEvent(update, applying, store);
+      break;
+    }
+    case `state_disposal`: {
+      ingestDisposalEvent(update, applying, store);
+      break;
+    }
+    case `molecule_creation`: {
+      ingestMoleculeCreationEvent(update, applying, store);
+      break;
+    }
+    case `molecule_disposal`: {
+      ingestMoleculeDisposalEvent(update, applying, store);
+      break;
+    }
   }
   if (action === `redo`) {
     ++timelineData.at;
@@ -2301,250 +2944,6 @@ var timeTravel = (action, token, store) => {
   );
 };
 
-// internal/src/transaction/abort-transaction.ts
-var abortTransaction = (store) => {
-  const target = newest(store);
-  if (!isChildStore(target)) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  store.logger.info(
-    `\u{1FA82}`,
-    `transaction`,
-    target.transactionMeta.update.key,
-    `Aborting transaction`
-  );
-  target.parent.child = null;
-};
-
-// internal/src/transaction/act-upon-store.ts
-function actUponStore(token, id, store) {
-  return (...parameters) => {
-    const tx = withdraw(token, store);
-    if (tx) {
-      return tx.run(parameters, id);
-    }
-    throw new NotFoundError(token, store);
-  };
-}
-
-// internal/src/transaction/set-epoch-number.ts
-function setEpochNumberOfContinuity(continuityKey, newEpoch, store) {
-  const isRoot = isRootStore(store);
-  if (isRoot && continuityKey) {
-    store.transactionMeta.epoch.set(continuityKey, newEpoch);
-  }
-}
-function setEpochNumberOfAction(transactionKey, newEpoch, store) {
-  const isRoot = isRootStore(store);
-  if (!isRoot) {
-    return;
-  }
-  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
-  if (continuityKey !== void 0) {
-    store.transactionMeta.epoch.set(continuityKey, newEpoch);
-  }
-}
-
-// internal/src/transaction/apply-transaction.ts
-var applyTransaction = (output, store) => {
-  var _a;
-  const child = newest(store);
-  const { parent } = child;
-  if (parent === null || !isChildStore(child) || ((_a = child.transactionMeta) == null ? void 0 : _a.phase) !== `building`) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  child.transactionMeta.phase = `applying`;
-  child.transactionMeta.update.output = output;
-  parent.child = null;
-  parent.on.transactionApplying.next(child.transactionMeta);
-  const { updates } = child.transactionMeta.update;
-  store.logger.info(
-    `\u{1F6C4}`,
-    `transaction`,
-    child.transactionMeta.update.key,
-    `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);
-    }
-    tracker.dispose();
-  }
-  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(`newValue`, child.transactionMeta.update, parent);
-  if (isRootStore(parent)) {
-    setEpochNumberOfAction(
-      child.transactionMeta.update.key,
-      child.transactionMeta.update.epoch,
-      parent
-    );
-    const myTransaction = withdraw(
-      { key: child.transactionMeta.update.key, type: `transaction` },
-      store
-    );
-    myTransaction == null ? void 0 : myTransaction.subject.next(child.transactionMeta.update);
-    store.logger.info(
-      `\u{1F6EC}`,
-      `transaction`,
-      child.transactionMeta.update.key,
-      `Finished applying transaction.`
-    );
-  } else if (isChildStore(parent)) {
-    parent.transactionMeta.update.updates.push(child.transactionMeta.update);
-  }
-  parent.on.transactionApplying.next(null);
-};
-
-// internal/src/transaction/assign-transaction-to-continuity.ts
-function assignTransactionToContinuity(continuityKey, transactionKey, store) {
-  const isRoot = isRootStore(store);
-  if (!isRoot) {
-    return;
-  }
-  const { epoch, actionContinuities } = store.transactionMeta;
-  actionContinuities.set(continuityKey, transactionKey);
-  if (!epoch.has(continuityKey)) {
-    epoch.set(continuityKey, -1);
-  }
-}
-
-// internal/src/transaction/build-transaction.ts
-var buildTransaction = (key, params, store, id) => {
-  const parent = newest(store);
-  const childBase = {
-    parent,
-    child: null,
-    on: parent.on,
-    loggers: parent.loggers,
-    logger: parent.logger,
-    config: parent.config,
-    atoms: new LazyMap(parent.atoms),
-    atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
-    families: new LazyMap(parent.families),
-    operation: { open: false },
-    readonlySelectors: new LazyMap(parent.readonlySelectors),
-    timelines: new LazyMap(parent.timelines),
-    timelineAtoms: new Junction(parent.timelineAtoms.toJSON()),
-    trackers: /* @__PURE__ */ new Map(),
-    transactions: new LazyMap(parent.transactions),
-    selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
-    selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
-      makeContentKey: (...keys) => keys.sort().join(`:`)
-    }),
-    selectors: new LazyMap(parent.selectors),
-    valueMap: new LazyMap(parent.valueMap)
-  };
-  const epoch = getEpochNumberOfAction(key, store);
-  const transactionMeta = {
-    phase: `building`,
-    update: {
-      key,
-      id,
-      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
-      updates: [],
-      params,
-      output: void 0
-    },
-    transactors: {
-      get: (token) => getFromStore(token, child),
-      set: (token, value) => {
-        setIntoStore(token, value, child);
-      },
-      run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
-      find: (token, k) => findInStore(token, k, child),
-      env: () => getEnvironmentData(child)
-    }
-  };
-  const child = Object.assign(childBase, {
-    transactionMeta
-  });
-  parent.child = child;
-  store.logger.info(
-    `\u{1F6EB}`,
-    `transaction`,
-    key,
-    `Building transaction with params:`,
-    params
-  );
-  return child;
-};
-
-// internal/src/transaction/create-transaction.ts
-function createTransaction(options, store) {
-  const newTransaction = {
-    key: options.key,
-    type: `transaction`,
-    run: (params, id) => {
-      const childStore = buildTransaction(options.key, params, store, id);
-      try {
-        const target2 = newest(store);
-        const { transactors } = childStore.transactionMeta;
-        const output = options.do(transactors, ...params);
-        applyTransaction(output, target2);
-        return output;
-      } catch (thrown) {
-        abortTransaction(target);
-        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
-        throw thrown;
-      }
-    },
-    install: (s) => createTransaction(options, s),
-    subject: new Subject()
-  };
-  const target = newest(store);
-  target.transactions.set(newTransaction.key, newTransaction);
-  const token = deposit(newTransaction);
-  store.on.transactionCreation.next(token);
-  return token;
-}
-
-// internal/src/transaction/get-epoch-number.ts
-function getContinuityKey(transactionKey, store) {
-  const isRoot = isRootStore(store);
-  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
-  return continuity;
-}
-function getEpochNumberOfContinuity(continuityKey, store) {
-  const isRoot = isRootStore(store);
-  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : void 0;
-  return epoch;
-}
-function getEpochNumberOfAction(transactionKey, store) {
-  const isRoot = isRootStore(store);
-  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
-  const epoch = isRoot && continuity !== void 0 ? store.transactionMeta.epoch.get(continuity) : void 0;
-  return epoch;
-}
-
-// internal/src/transaction/index.ts
-var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
-
 exports.FamilyTracker = FamilyTracker;
 exports.Future = Future;
 exports.IMPLICIT = IMPLICIT;
@@ -2580,8 +2979,9 @@ exports.createTimeline = createTimeline;
 exports.createTransaction = createTransaction;
 exports.createWritableSelector = createWritableSelector;
 exports.deposit = deposit;
-exports.disposeAtom = disposeAtom;
-exports.disposeSelector = disposeSelector;
+exports.disposeAtom = disposeAtom2;
+exports.disposeFromStore = disposeFromStore;
+exports.disposeSelector = disposeSelector2;
 exports.evictCachedValue = evictCachedValue;
 exports.findInStore = findInStore;
 exports.getContinuityKey = getContinuityKey;
@@ -2594,8 +2994,13 @@ exports.getJsonToken = getJsonToken;
 exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
 exports.getUpdateToken = getUpdateToken;
 exports.ingestAtomUpdate = ingestAtomUpdate;
+exports.ingestCreationEvent = ingestCreationEvent;
+exports.ingestDisposalEvent = ingestDisposalEvent;
+exports.ingestMoleculeCreationEvent = ingestMoleculeCreationEvent;
+exports.ingestMoleculeDisposalEvent = ingestMoleculeDisposalEvent;
 exports.ingestSelectorUpdate = ingestSelectorUpdate;
 exports.ingestTransactionUpdate = ingestTransactionUpdate;
+exports.initFamilyMember = initFamilyMember;
 exports.isAtomDefault = isAtomDefault;
 exports.isAtomKey = isAtomKey;
 exports.isChildStore = isChildStore;
@@ -2614,6 +3019,7 @@ exports.openOperation = openOperation;
 exports.readCachedValue = readCachedValue;
 exports.readOrComputeValue = readOrComputeValue;
 exports.registerSelector = registerSelector;
+exports.seekInStore = seekInStore;
 exports.setAtomOrSelector = setAtomOrSelector;
 exports.setEpochNumberOfAction = setEpochNumberOfAction;
 exports.setEpochNumberOfContinuity = setEpochNumberOfContinuity;
@@ -2627,4 +3033,3 @@ exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
 exports.traceSelectorAtoms = traceSelectorAtoms;
 exports.updateSelectorAtoms = updateSelectorAtoms;
 exports.withdraw = withdraw;
-exports.withdrawOrCreate = withdrawOrCreate;