atom.io 0.21.1 → 0.23.0

package/internal/dist/index.js

@@ -1,7 +1,10 @@
 import { Junction } from '../../dist/chunk-FTONNX2R.js';
+import { parseJson } from '../../dist/chunk-OAYGID5B.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-F2X4B4VY.js';
-import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
+import { stringifyJson, selectJson, parseJson as parseJson$1, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
+import { disposeMolecule, makeMoleculeInStore } from 'atom.io/immortal';
+import * as Internal from 'atom.io/internal';
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -60,14 +63,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;
 }
 
 // internal/src/subject.ts
@@ -113,7 +128,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();
@@ -142,6 +157,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(),
@@ -152,7 +170,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 = {
@@ -163,7 +184,8 @@ var Store = class {
       })
     };
     this.config = {
-      name: `IMPLICIT_STORE`
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
     };
     this.loggers = [
       new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
@@ -193,9 +215,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);
       }
@@ -206,7 +226,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);
@@ -234,16 +254,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;
@@ -271,6 +295,12 @@ function withdraw(token, store) {
       case `transaction`:
         withdrawn = target.transactions.get(token.key);
         break;
+      case `molecule`:
+        withdrawn = target.molecules.get(stringifyJson(token.key));
+        break;
+      case `molecule_family`:
+        withdrawn = target.moleculeFamilies.get(token.key);
+        break;
     }
     if (withdrawn) {
       return withdrawn;
@@ -280,36 +310,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)) {
@@ -337,22 +337,17 @@ function createRegularAtomFamily(options, store) {
       const subKey = 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;
     },
     {
@@ -362,8 +357,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;
 }
 
@@ -379,22 +373,20 @@ function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
   const readonlySelectorFamily = Object.assign(
     (key) => {
-      const target = newest(store);
       const subKey = 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,
@@ -413,10 +405,7 @@ function createWritableSelectorFamily(options, store) {
       const subKey = 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,
@@ -424,9 +413,9 @@ function createWritableSelectorFamily(options, store) {
           set: options.set(key)
         },
         family,
-        store
+        target
       );
-      subject.next(token);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -448,14 +437,39 @@ function createSelectorFamily(options, store) {
   }
   return createReadonlySelectorFamily(options, store);
 }
+function disposeFromStore(token, store = Internal.IMPLICIT.STORE) {
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      Internal.disposeAtom(token, store);
+      break;
+    case `selector`:
+    case `readonly_selector`:
+      Internal.disposeSelector(token, store);
+      break;
+    case `molecule`:
+      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) {
@@ -465,15 +479,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
@@ -629,7 +664,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;
   }
@@ -717,164 +755,616 @@ 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/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.`
-      );
+// 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);
+}
+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)
-});
+      if (store.config.lifespan === `immortal`) {
+        throw new Error(`No molecule found for key "${token.family.subKey}"`);
+      }
+      initFamilyMember(family, parseJson(token.family.subKey), store);
+    }
+  }
+}
+function ingestMoleculeCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      makeMoleculeInStore(
+        store,
+        update.context[0],
+        update.family,
+        update.token.key,
+        ...update.params
+      );
+      break;
+    case `oldValue`:
+      disposeMolecule(update.token, store);
+      break;
+  }
+}
+function ingestMoleculeDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      disposeMolecule(update.token, store);
+      break;
+    case `oldValue`:
+      makeMoleculeInStore(
+        store,
+        update.context[0],
+        update.family,
+        update.token.key
+      );
+      break;
+  }
+}
 
-// 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;
+// 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);
   }
-  store.on.selectorCreation.next(token);
-  return token;
-};
+}
 
-// internal/src/selector/create-writable-selector.ts
-var createWritableSelector = (options, family, 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) => 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 = 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(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));
@@ -917,7 +1407,6 @@ var createWritableSelector = (options, family, store) => {
   if (family) {
     token.family = family;
   }
-  store.on.selectorCreation.next(token);
   return token;
 };
 
@@ -925,39 +1414,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
@@ -1028,7 +1566,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;
@@ -1289,37 +1827,40 @@ function createMutableAtom(options, family, store) {
     };
   }
   new Tracker(token, store);
-  selectJson(token, options, store);
-  store.on.atomCreation.next(token);
+  if (!family) {
+    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 = parseJson(atomToken.family.subKey);
-          this.findLatestUpdateState(key);
-          new Tracker(atomToken, store);
+      (event) => {
+        if (event.token.family) {
+          const key = parseJson$1(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 = parseJson(atomToken.family.subKey);
-          const mutableAtomToken = this.findMutableState(key);
-          new Tracker(mutableAtomToken, store);
+      (event) => {
+        if (event.token.family) {
+          const key = parseJson$1(event.token.family.subKey);
+          const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
+          if (mutableAtomToken) {
+            new Tracker(mutableAtomToken, store);
+          }
         }
       }
     );
@@ -1334,25 +1875,19 @@ function createMutableAtomFamily(options, store) {
       const subKey = 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;
     },
     {
@@ -1364,8 +1899,7 @@ function createMutableAtomFamily(options, store) {
       fromJson: options.fromJson
     }
   );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily);
   selectJsonFamily(atomFamily, options, store);
   new FamilyTracker(atomFamily, store);
   return atomFamily;
@@ -1380,19 +1914,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
@@ -1564,7 +2103,6 @@ function createRegularAtom(options, family, store) {
       }
     };
   }
-  store.on.atomCreation.next(token);
   return token;
 }
 
@@ -1572,13 +2110,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;
@@ -1588,10 +2130,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);
@@ -1599,7 +2150,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);
         }
       }
     }
@@ -1608,93 +2159,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);
@@ -1704,188 +2183,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;
                     }
-                  ) : false;
-                }).map((updateFromTx) => {
-                  if (`updates` in updateFromTx) {
-                    return __spreadProps(__spreadValues({}, updateFromTx), {
-                      updates: filterUpdates(updateFromTx.updates)
-                    });
+                    if (atomOrFamilyKeys.has(key)) {
+                      return true;
+                    }
+                    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({
@@ -1898,60 +2401,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(
+                          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}(${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);
@@ -1962,6 +2546,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) => {
@@ -2009,6 +2614,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;
@@ -2023,248 +2644,4 @@ 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`];
-
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom2 as disposeAtom, disposeFromStore, disposeSelector2 as disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMember, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };