atom.io 0.22.0 → 0.23.1

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
@@ -143,6 +158,7 @@ var Store = class {
       }
     );
     this.molecules = /* @__PURE__ */ new Map();
+    this.moleculeFamilies = /* @__PURE__ */ new Map();
     this.miscResources = /* @__PURE__ */ new Map();
     this.on = {
       atomCreation: new Subject(),
@@ -154,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 = {
@@ -249,8 +268,6 @@ var clearStore = (store) => {
   Object.assign(store, new Store(config));
   store.config = config;
 };
-
-// internal/src/store/withdraw.ts
 function withdraw(token, store) {
   let withdrawn;
   let target = store;
@@ -278,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;
@@ -324,7 +347,7 @@ function createRegularAtomFamily(options, store) {
         individualOptions.effects = options.effects(key);
       }
       const token = createRegularAtom(individualOptions, family, target);
-      subject.next(token);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -362,7 +385,7 @@ function createReadonlySelectorFamily(options, store) {
         family,
         target
       );
-      subject.next(token);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -392,7 +415,7 @@ function createWritableSelectorFamily(options, store) {
         family,
         target
       );
-      subject.next(token);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -414,6 +437,21 @@ 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);
@@ -421,6 +459,8 @@ function prettyPrintTokenType(token) {
   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`:
@@ -439,53 +479,36 @@ var NotFoundError = class extends Error {
   }
 };
 
-// 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);
-  return state;
-}
-function seekInStore(token, key, store) {
-  const subKey = stringifyJson(key);
-  const fullKey = `${token.key}(${subKey})`;
+// internal/src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
   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;
-  }
-  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\`.`
+  if (!isChildStore(target)) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
     );
+    return;
   }
-  let state = seekInStore(token, key, store);
-  if (state) {
-    return state;
-  }
-  state = initFamilyMember(token, key, store);
-  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
@@ -641,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;
   }
@@ -734,162 +760,613 @@ function setIntoStore(token, 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 = 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
+}
+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 = withdraw(WritableToken, store);
-    setAtomOrSelector(state, newValue, store);
-  },
-  find: (token, key) => findInStore(token, key, store),
-  seek: (token, key) => seekInStore(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, seek } = registerSelector(options.key, target);
-  const getSelf = () => {
-    const value = options.get({ get, find, seek });
-    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;
-};
-
-// 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, seek } = transactors;
-  const readonlyTransactors = { find, get, seek };
-  const getSelf = () => {
-    const value = options.get(readonlyTransactors);
+}
+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/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) => 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, seek, json } = transactors;
+  const readonlyTransactors = { find, get, seek, json };
+  const getSelf = () => {
+    const value = options.get(readonlyTransactors);
     cacheValue(options.key, value, subject, newest(store));
     return value;
   };
@@ -930,7 +1407,6 @@ var createWritableSelector = (options, family, store) => {
   if (family) {
     token.family = family;
   }
-  store.on.selectorCreation.next(token);
   return token;
 };
 
@@ -938,19 +1414,23 @@ 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;
   const selector = (_a = target.selectors.get(key)) != null ? _a : target.readonlySelectors.get(key);
   if (!selector) {
-    store.logger.error(
+    store.logger.info(
       `\u274C`,
       `selector`,
       key,
@@ -966,10 +1446,30 @@ function disposeSelector(selectorToken, store) {
   } else {
     switch (selectorToken.type) {
       case `selector`:
-        target.selectors.delete(key);
+        {
+          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);
+        {
+          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;
     }
     target.valueMap.delete(key);
@@ -982,12 +1482,19 @@ function disposeSelector(selectorToken, store) {
     );
     for (const downstreamToken of downstreamTokens) {
       if (downstreamToken) {
-        disposeSelector(downstreamToken, store);
+        disposeSelector2(downstreamToken, store);
       }
     }
     target.selectorGraph.delete(key);
     store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
-    store.on.selectorDisposal.next(selectorToken);
+    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+      target.transactionMeta.update.updates.push({
+        type: `state_disposal`,
+        token: selectorToken
+      });
+    } else {
+      store.on.selectorDisposal.next(selectorToken);
+    }
   }
 }
 
@@ -1323,7 +1830,6 @@ function createMutableAtom(options, family, store) {
   if (!family) {
     selectJson(token, options, store);
   }
-  store.on.atomCreation.next(token);
   return token;
 }
 var FamilyTracker = class {
@@ -1338,19 +1844,19 @@ var FamilyTracker = class {
     this.mutableAtoms = mutableAtoms;
     this.mutableAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
-      (atomToken) => {
-        if (atomToken.family) {
-          const key = parseJson(atomToken.family.subKey);
+      (event) => {
+        if (event.token.family) {
+          const key = parseJson$1(event.token.family.subKey);
           seekInStore(this.latestUpdateAtoms, key, store);
-          new Tracker(atomToken, store);
+          new Tracker(event.token, store);
         }
       }
     );
     this.latestUpdateAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
-      (atomToken) => {
-        if (atomToken.family) {
-          const key = parseJson(atomToken.family.subKey);
+      (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);
@@ -1381,7 +1887,7 @@ function createMutableAtomFamily(options, store) {
         individualOptions.effects = options.effects(key);
       }
       const token = createMutableAtom(individualOptions, family, target);
-      subject.next(token);
+      subject.next({ type: `state_creation`, token });
       return token;
     },
     {
@@ -1597,7 +2103,6 @@ function createRegularAtom(options, family, store) {
       }
     };
   }
-  store.on.atomCreation.next(token);
   return token;
 }
 
@@ -1605,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;
@@ -1627,6 +2136,13 @@ function disposeAtom(atomToken, store) {
     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);
@@ -1634,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);
         }
       }
     }
@@ -1643,94 +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 = withdraw(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);
@@ -1740,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;
                     }
-                  ) : false;
-                }).map((updateFromTx) => {
-                  if (`updates` in updateFromTx) {
-                    return __spreadProps(__spreadValues({}, updateFromTx), {
-                      updates: filterUpdates(updateFromTx.updates)
-                    });
+                    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;
+                    }
+                    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({
@@ -1934,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) {
-          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}"`
+    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);
+              }
+            )
           );
-          continue;
+          for (const atom of target.atoms.values()) {
+            if (((_b = atom.family) == null ? void 0 : _b.key) === familyKey) {
+              addAtomToTimeline(atom, tl, store);
+            }
+          }
         }
-      }
-      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;
+      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);
+        }
+        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;
+                  }
+                }
+              )
+            );
+          }
+        }
+        break;
     }
   }
   store.timelines.set(options.key, tl);
@@ -1998,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) => {
@@ -2045,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;
@@ -2059,251 +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),
-    molecules: new LazyMap(parent.molecules),
-    miscResources: new LazyMap(parent.miscResources)
-  };
-  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),
-      seek: (token, k) => seekInStore(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, 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 };
+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 };