atom.io 0.24.4 → 0.24.6

package/internal/dist/index.cjs

@@ -387,187 +387,69 @@ function isChildStore(store) {
   return `phase` in store.transactionMeta;
 }
 
-// internal/src/store/store.ts
-var Store = class {
-  constructor(config, store = null) {
-    this.parent = null;
-    this.child = null;
-    this.valueMap = /* @__PURE__ */ new Map();
-    this.atoms = /* @__PURE__ */ new Map();
-    this.selectors = /* @__PURE__ */ new Map();
-    this.readonlySelectors = /* @__PURE__ */ new Map();
-    this.trackers = /* @__PURE__ */ new Map();
-    this.families = /* @__PURE__ */ new Map();
-    this.timelines = /* @__PURE__ */ new Map();
-    this.transactions = /* @__PURE__ */ new Map();
-    this.atomsThatAreDefault = /* @__PURE__ */ new Set();
-    this.timelineAtoms = new Junction({
-      between: [`timelineKey`, `atomKey`],
-      cardinality: `1:n`
-    });
-    this.selectorAtoms = new Junction({
-      between: [`selectorKey`, `atomKey`],
-      cardinality: `n:n`
-    });
-    this.selectorGraph = new Junction(
-      {
-        between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
-        cardinality: `n:n`
-      },
-      {
-        makeContentKey: (...keys) => keys.sort().join(`:`)
-      }
+// 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.`
     );
-    this.molecules = /* @__PURE__ */ new Map();
-    this.moleculeFamilies = /* @__PURE__ */ new Map();
-    this.miscResources = /* @__PURE__ */ new Map();
-    this.on = {
-      atomCreation: new Subject(),
-      atomDisposal: new Subject(),
-      selectorCreation: new Subject(),
-      selectorDisposal: new Subject(),
-      timelineCreation: new Subject(),
-      transactionCreation: new Subject(),
-      transactionApplying: new StatefulSubject(
-        null
-      ),
-      operationClose: new Subject(),
-      moleculeCreationStart: new Subject(),
-      moleculeCreationDone: new Subject(),
-      moleculeDisposal: new Subject()
-    };
-    this.operation = { open: false };
-    this.transactionMeta = {
-      epoch: /* @__PURE__ */ new Map(),
-      actionContinuities: new Junction({
-        between: [`continuity`, `action`],
-        cardinality: `1:n`
-      })
-    };
-    this.config = {
-      name: `IMPLICIT_STORE`,
-      lifespan: `ephemeral`
-    };
-    this.loggers = [
-      new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
-    ];
-    this.logger = {
-      error: (...messages) => {
-        for (const logger of this.loggers) logger.error(...messages);
-      },
-      info: (...messages) => {
-        for (const logger of this.loggers) logger.info(...messages);
-      },
-      warn: (...messages) => {
-        for (const logger of this.loggers) logger.warn(...messages);
-      }
-    };
-    if (store !== null) {
-      this.valueMap = new Map(store == null ? void 0 : store.valueMap);
-      this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
-      if (isRootStore(store)) {
-        this.transactionMeta = {
-          epoch: new Map(store == null ? void 0 : store.transactionMeta.epoch),
-          actionContinuities: new Junction(
-            store == null ? void 0 : store.transactionMeta.actionContinuities.toJSON()
-          )
-        };
-      }
-      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
-      for (const [, family] of store.families) {
-        family.install(this);
-      }
-      const mutableHelpers = /* @__PURE__ */ new Set();
-      for (const [, atom] of store.atoms) {
-        if (mutableHelpers.has(atom.key)) {
-          continue;
-        }
-        atom.install(this);
-        if (atom.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(atom, store);
-          const originalUpdateToken = getUpdateToken(atom);
-          mutableHelpers.add(originalJsonToken.key);
-          mutableHelpers.add(originalUpdateToken.key);
-        }
-      }
-      for (const [, selector] of store.readonlySelectors) {
-        selector.install(this);
-      }
-      for (const [, selector] of store.selectors) {
-        if (mutableHelpers.has(selector.key)) {
-          continue;
-        }
-        selector.install(this);
-      }
-      for (const [, tx] of store.transactions) {
-        tx.install(this);
-      }
-      for (const [, timeline] of store.timelines) {
-        timeline.install(this);
-      }
-    }
+    return;
   }
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
+  );
+  target.parent.child = null;
 };
-var IMPLICIT = {
-  STORE_INTERNAL: void 0,
-  get STORE() {
-    var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store({
-      name: `IMPLICIT_STORE`,
-      lifespan: `ephemeral`
-    });
+
+// internal/src/not-found-error.ts
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+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`:
+      return `Readonly Selector Family`;
+    case `selector_family`:
+      return `Selector Family`;
+    default:
+      return capitalize(token.type);
   }
-};
-var clearStore = (store) => {
-  const { config } = store;
-  for (const disposable of store.miscResources.values()) {
-    disposable[Symbol.dispose]();
+}
+var NotFoundError = class extends Error {
+  constructor(token, store) {
+    super(
+      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
+    );
   }
-  Object.assign(store, new Store(config));
-  store.config = config;
 };
-function withdraw(token, store) {
-  let withdrawn;
-  let target = store;
-  while (target !== null) {
-    switch (token.type) {
-      case `atom`:
-      case `mutable_atom`:
-        withdrawn = target.atoms.get(token.key);
-        break;
-      case `selector`:
-        withdrawn = target.selectors.get(token.key);
-        break;
-      case `readonly_selector`:
-        withdrawn = target.readonlySelectors.get(token.key);
-        break;
-      case `atom_family`:
-      case `mutable_atom_family`:
-      case `selector_family`:
-      case `readonly_selector_family`:
-        withdrawn = target.families.get(token.key);
-        break;
-      case `timeline`:
-        withdrawn = target.timelines.get(token.key);
-        break;
-      case `transaction`:
-        withdrawn = target.transactions.get(token.key);
-        break;
-      case `molecule`:
-        withdrawn = target.molecules.get(json.stringifyJson(token.key));
-        break;
-      case `molecule_family`:
-        withdrawn = target.moleculeFamilies.get(token.key);
-        break;
-    }
-    if (withdrawn) {
-      return withdrawn;
+
+// 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);
     }
-    target = target.child;
-  }
-  throw new NotFoundError(token, store);
+    throw new NotFoundError(token, store);
+  };
 }
 
+// internal/src/set-state/become.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+
 // internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
@@ -588,176 +470,6 @@ var readOrComputeValue = (state, target) => {
   );
   return state.default instanceof Function ? state.default() : state.default;
 };
-function createRegularAtomFamily(options, store) {
-  const subject = new Subject();
-  const atomFamily = Object.assign(
-    (key) => {
-      const subKey = json.stringifyJson(key);
-      const family = { key: options.key, subKey };
-      const fullKey = `${options.key}(${subKey})`;
-      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;
-    },
-    {
-      key: options.key,
-      type: `atom_family`,
-      subject,
-      install: (s) => createRegularAtomFamily(options, s)
-    }
-  );
-  store.families.set(options.key, atomFamily);
-  return atomFamily;
-}
-
-// internal/src/families/create-atom-family.ts
-function createAtomFamily(options, store) {
-  const isMutable2 = `mutable` in options;
-  if (isMutable2) {
-    return createMutableAtomFamily(options, store);
-  }
-  return createRegularAtomFamily(options, store);
-}
-function createReadonlySelectorFamily(options, store) {
-  const subject = new Subject();
-  const readonlySelectorFamily = Object.assign(
-    (key) => {
-      const subKey = json.stringifyJson(key);
-      const family = { key: options.key, subKey };
-      const fullKey = `${options.key}(${subKey})`;
-      const target = newest(store);
-      const token = createReadonlySelector(
-        {
-          key: fullKey,
-          get: options.get(key)
-        },
-        family,
-        target
-      );
-      subject.next({ type: `state_creation`, token });
-      return token;
-    },
-    {
-      key: options.key,
-      type: `readonly_selector_family`,
-      subject,
-      install: (s) => createReadonlySelectorFamily(options, s)
-    }
-  );
-  store.families.set(options.key, readonlySelectorFamily);
-  return readonlySelectorFamily;
-}
-function createWritableSelectorFamily(options, store) {
-  const subject = new Subject();
-  const selectorFamily = Object.assign(
-    (key) => {
-      const subKey = json.stringifyJson(key);
-      const family = { key: options.key, subKey };
-      const fullKey = `${options.key}(${subKey})`;
-      const target = newest(store);
-      const token = createWritableSelector(
-        {
-          key: fullKey,
-          get: options.get(key),
-          set: options.set(key)
-        },
-        family,
-        target
-      );
-      subject.next({ type: `state_creation`, token });
-      return token;
-    },
-    {
-      key: options.key,
-      type: `selector_family`,
-      subject,
-      install: (s) => createWritableSelectorFamily(options, s)
-    }
-  );
-  store.families.set(options.key, selectorFamily);
-  return selectorFamily;
-}
-
-// internal/src/families/create-selector-family.ts
-function createSelectorFamily(options, store) {
-  const isWritable = `set` in options;
-  if (isWritable) {
-    return createWritableSelectorFamily(options, store);
-  }
-  return createReadonlySelectorFamily(options, 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/not-found-error.ts
-var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
-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`:
-      return `Readonly Selector Family`;
-    case `selector_family`:
-      return `Selector Family`;
-    default:
-      return capitalize(token.type);
-  }
-}
-var NotFoundError = class extends Error {
-  constructor(token, store) {
-    super(
-      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
-    );
-  }
-};
-
-// 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
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
-  originalThing instanceof Function ? originalThing() : originalThing
-) : nextVersionOfThing;
 
 // internal/src/operation.ts
 var openOperation = (token, store) => {
@@ -854,8 +566,9 @@ var emitUpdate = (state, update, store) => {
 
 // internal/src/set-state/evict-downstream.ts
 var evictDownStream = (atom, store) => {
-  const downstreamKeys = store.selectorAtoms.getRelatedKeys(atom.key);
-  store.logger.info(
+  const target = newest(store);
+  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
+  target.logger.info(
     `\u{1F9F9}`,
     atom.type,
     atom.key,
@@ -863,20 +576,20 @@ var evictDownStream = (atom, store) => {
     downstreamKeys != null ? downstreamKeys : `to evict`
   );
   if (downstreamKeys) {
-    if (store.operation.open) {
-      store.logger.info(
+    if (target.operation.open) {
+      target.logger.info(
         `\u{1F9F9}`,
         atom.type,
         atom.key,
-        `[ ${[...store.operation.done].join(`, `)} ] already done`
+        `[ ${[...target.operation.done].join(`, `)} ] already done`
       );
     }
     for (const key of downstreamKeys) {
-      if (isDone(key, store)) {
+      if (isDone(key, target)) {
         continue;
       }
-      evictCachedValue(key, store);
-      markDone(key, store);
+      evictCachedValue(key, target);
+      markDone(key, target);
     }
   }
 };
@@ -1012,582 +725,463 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
   }
   setIntoStore(token, value, store);
 }
-
-// internal/src/molecule/create-molecule-family.ts
-function createMoleculeFamily(options, store) {
-  var _a;
+function createRegularAtomFamily(options, store) {
   const subject = new Subject();
-  const token = {
-    type: `molecule_family`,
-    key: options.key,
-    dependsOn: (_a = options.dependsOn) != null ? _a : `all`
-  };
-  const family = __spreadProps(__spreadValues({}, token), {
-    subject,
-    new: options.new
-  });
-  store.moleculeFamilies.set(options.key, family);
-  return token;
+  const atomFamily = Object.assign(
+    (key) => {
+      const subKey = json.stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      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;
+    },
+    {
+      key: options.key,
+      type: `atom_family`,
+      subject,
+      install: (s) => createRegularAtomFamily(options, s)
+    }
+  );
+  store.families.set(options.key, atomFamily);
+  return atomFamily;
 }
 
-// internal/src/molecule/grow-molecule-in-store.ts
-function growMoleculeInStore(molecule, family, store) {
-  const stateToken = initFamilyMemberInStore(family, molecule.key, store);
-  molecule.tokens.set(stateToken.key, stateToken);
-  const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    store.transactionMeta.update.updates.push({
-      type: `state_creation`,
-      token: stateToken
-    });
-  } else {
-    molecule.subject.next({ type: `state_creation`, token: stateToken });
+// internal/src/families/create-atom-family.ts
+function createAtomFamily(options, store) {
+  const isMutable2 = `mutable` in options;
+  if (isMutable2) {
+    return createMutableAtomFamily(options, store);
   }
-  return stateToken;
+  return createRegularAtomFamily(options, store);
 }
 
-// internal/src/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    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/get-state/get-from-store.ts
-function getFromStore(token, store) {
-  if (token.type === `molecule`) {
-    try {
-      const molecule = withdraw(token, store);
-      return molecule.instance;
-    } catch (_) {
-      return void 0;
-    }
-  }
-  const state = withdraw(token, store);
-  return readOrComputeValue(state, store);
-}
-var Molecule = class {
-  constructor(ctx, key, family) {
-    this.key = key;
-    this.type = `molecule`;
-    this.subject = new Subject();
-    this.tokens = /* @__PURE__ */ new Map();
-    this.above = /* @__PURE__ */ new Map();
-    this.below = /* @__PURE__ */ new Map();
-    this.joins = /* @__PURE__ */ new Map();
-    this.stringKey = json.stringifyJson(key);
-    if (family) {
-      this.family = family;
-    }
-    if (ctx) {
-      if (Array.isArray(ctx)) {
-        for (const molecule of ctx) {
-          this.above.set(molecule.stringKey, molecule);
-        }
-      } else {
-        this.above.set(ctx.stringKey, ctx);
-      }
-    }
-  }
+// 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/molecule/make-molecule-in-store.ts
-function makeMoleculeInStore(store, context, familyToken, key, ...params) {
-  const target = newest(store);
-  const token = {
-    type: `molecule`,
-    key,
-    family: familyToken
-  };
-  const contextArray = Array.isArray(context) ? context : [context];
-  const owners = contextArray.map((ctx) => {
-    if (ctx instanceof Molecule) {
-      return ctx;
-    }
-    const stringKey = json.stringifyJson(ctx.key);
-    const molecule2 = store.molecules.get(stringKey);
-    if (!molecule2) {
+// 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(
-        `Molecule ${stringKey} not found in store "${store.config.name}"`
+        `Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`
       );
     }
-    return molecule2;
-  });
-  const family = withdraw(familyToken, store);
-  const molecule = new Molecule(owners, key, family);
-  target.molecules.set(json.stringifyJson(key), molecule);
-  for (const owner of owners) {
-    owner.below.set(molecule.stringKey, molecule);
+    if (!isAtomKey(indirectDependencyKey, store)) {
+      indirectDependencyKeys.push(
+        ...getSelectorDependencyKeys(indirectDependencyKey, store)
+      );
+    } else if (!rootKeys.includes(indirectDependencyKey)) {
+      rootKeys.push(indirectDependencyKey);
+    }
   }
-  const transactors = {
-    get: (t) => getFromStore(t, newest(store)),
-    set: (t, newValue) => {
-      setIntoStore(t, newValue, newest(store));
-    },
-    seek: (t, k) => seekInStore(t, k, newest(store)),
-    json: (t) => getJsonToken(t, newest(store)),
-    run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
-    make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(store), ctx, f, k, ...args),
-    dispose: (t) => {
-      disposeFromStore(t, newest(store));
-    },
-    env: () => getEnvironmentData(newest(store)),
-    bond: (f) => growMoleculeInStore(
-      molecule,
-      withdraw(f, store),
-      newest(store)
-    ),
-    claim: (below, options) => {
-      const { exclusive } = options;
-      const belowMolecule = newest(store).molecules.get(json.stringifyJson(below.key));
-      if (belowMolecule) {
-        if (exclusive) {
-          for (const value of belowMolecule.above.values()) {
-            value.below.delete(belowMolecule.stringKey);
-          }
-          belowMolecule.above.clear();
-          belowMolecule.above.set(molecule.stringKey, molecule);
-          molecule.below.set(belowMolecule.stringKey, belowMolecule);
-        } else {
-          belowMolecule.above.set(molecule.stringKey, molecule);
-          molecule.below.set(belowMolecule.stringKey, belowMolecule);
-        }
+  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
       }
-    },
-    join: (joinToken) => {
-      const join = data.getJoin(joinToken, store);
-      join.molecules.set(json.stringifyJson(key), molecule);
-      molecule.joins.set(joinToken.key, join);
-      return joinToken;
-    },
-    spawn: (f, k, ...p) => makeMoleculeInStore(
-      newest(store),
-      [molecule],
-      withdraw(f, store),
-      k,
-      ...p
-    )
+    );
+    updateSelectorAtoms(selectorKey, dependency, store);
+    return dependencyValue;
+  },
+  set: (WritableToken, newValue) => {
+    const target = newest(store);
+    const state = withdraw(WritableToken, target);
+    setAtomOrSelector(state, newValue, target);
+  },
+  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 Constructor = family.new;
-  molecule.instance = new Constructor(transactors, token.key, ...params);
-  const update = {
-    type: `molecule_creation`,
-    token,
-    family,
-    context: contextArray,
-    params
+  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`
   };
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(update);
-  } else {
-    family.subject.next(update);
+  if (family) {
+    token.family = family;
   }
   return token;
-}
+};
 
-// internal/src/ingest-updates/ingest-creation-disposal.ts
-function ingestCreationEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`: {
-      createInStore(update.token, store);
-      break;
-    }
-    case `oldValue`: {
-      disposeFromStore(update.token, store);
-      break;
+// 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 = (innerTarget = newest(store)) => {
+    const value = options.get(readonlyTransactors);
+    cacheValue(options.key, value, subject, innerTarget);
+    return value;
+  };
+  const setSelf = (next) => {
+    const innerTarget = newest(store);
+    const oldValue = getSelf(innerTarget);
+    const newValue = become(next)(oldValue);
+    store.logger.info(
+      `\u{1F4DD}`,
+      `selector`,
+      options.key,
+      `set (`,
+      oldValue,
+      `->`,
+      newValue,
+      `)`
+    );
+    cacheValue(options.key, newValue, subject, innerTarget);
+    markDone(options.key, innerTarget);
+    if (isRootStore(innerTarget)) {
+      subject.next({ newValue, oldValue });
     }
+    options.set(transactors, newValue);
+  };
+  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => createWritableSelector(options, family, s),
+    get: getSelf,
+    set: setSelf,
+    type: `selector`
+  }), family && { family });
+  target.selectors.set(options.key, mySelector);
+  const initialValue = getSelf();
+  store.logger.info(`\u2728`, mySelector.type, mySelector.key, `=`, initialValue);
+  const token = {
+    key: options.key,
+    type: `selector`
+  };
+  if (family) {
+    token.family = family;
   }
-}
-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;
-    }
+  return token;
+};
+
+// internal/src/selector/create-standalone-selector.ts
+function createStandaloneSelector(options, store) {
+  const isWritable = `set` in options;
+  if (isWritable) {
+    const state2 = createWritableSelector(options, void 0, store);
+    store.on.selectorCreation.next(state2);
+    return state2;
   }
+  const state = createReadonlySelector(options, void 0, store);
+  store.on.selectorCreation.next(state);
+  return state;
 }
-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) {
-        growMoleculeInStore(molecule, family, store);
-        return;
+
+// internal/src/selector/dispose-selector.ts
+function disposeSelector(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.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 {
+    const molecule = target.molecules.get(selector.family.subKey);
+    if (molecule) {
+      molecule.tokens.delete(key);
+    }
+    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;
+    }
+    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);
       }
-      if (store.config.lifespan === `immortal`) {
-        throw new Error(`No molecule found for key "${token.family.subKey}"`);
+    );
+    for (const downstreamToken of downstreamTokens) {
+      if (downstreamToken) {
+        disposeSelector(downstreamToken, store);
       }
-      initFamilyMemberInStore(family, json.parseJson(token.family.subKey), 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);
     }
   }
 }
-function ingestMoleculeCreationEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`:
-      makeMoleculeInStore(
-        store,
-        update.context[0],
-        update.family,
-        update.token.key,
-        ...update.params
+
+// internal/src/families/create-readonly-selector-family.ts
+function createReadonlySelectorFamily(options, store) {
+  const subject = new Subject();
+  const readonlySelectorFamily = Object.assign(
+    (key) => {
+      const subKey = json.stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const target = newest(store);
+      const token = createReadonlySelector(
+        {
+          key: fullKey,
+          get: options.get(key)
+        },
+        family,
+        target
       );
-      break;
-    case `oldValue`:
-      disposeFromStore(update.token, store);
-      break;
-  }
+      subject.next({ type: `state_creation`, token });
+      return token;
+    },
+    {
+      key: options.key,
+      type: `readonly_selector_family`,
+      subject,
+      install: (s) => createReadonlySelectorFamily(options, s)
+    }
+  );
+  store.families.set(options.key, readonlySelectorFamily);
+  return readonlySelectorFamily;
 }
-function ingestMoleculeDisposalEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`:
-      disposeFromStore(update.token, store);
-      break;
-    case `oldValue`:
-      makeMoleculeInStore(
-        store,
-        update.context[0],
-        update.family,
-        update.token.key
+function createWritableSelectorFamily(options, store) {
+  const subject = new Subject();
+  const selectorFamily = Object.assign(
+    (key) => {
+      const subKey = json.stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const target = newest(store);
+      const token = createWritableSelector(
+        {
+          key: fullKey,
+          get: options.get(key),
+          set: options.set(key)
+        },
+        family,
+        target
       );
-      break;
-  }
+      subject.next({ type: `state_creation`, token });
+      return token;
+    },
+    {
+      key: options.key,
+      type: `selector_family`,
+      subject,
+      install: (s) => createWritableSelectorFamily(options, s)
+    }
+  );
+  store.families.set(options.key, selectorFamily);
+  return selectorFamily;
 }
 
-// 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/families/create-selector-family.ts
+function createSelectorFamily(options, store) {
+  const isWritable = `set` in options;
+  if (isWritable) {
+    return createWritableSelectorFamily(options, store);
   }
+  return createReadonlySelectorFamily(options, 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/molecule/dispose-molecule.ts
+function disposeMolecule(token, store) {
+  var _a;
+  let molecule;
+  try {
+    molecule = withdraw(token, store);
+  } catch (thrown) {
+    if (thrown instanceof Error) {
+      store.logger.error(
+        `\u{1F41E}`,
+        `molecule`,
+        JSON.stringify(token.key),
+        `Failed to dispose molecule, because it was not found in the store.`,
+        thrown.message
+      );
     }
-  }
-}
-
-// 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);
+  const { family } = token;
+  const context = [];
+  for (const above of molecule.above.values()) {
+    context.push(deposit(above));
   }
-}
-
-// 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/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/molecule/dispose-molecule.ts
-function disposeMolecule(token, store) {
-  var _a;
-  let molecule;
-  try {
-    molecule = withdraw(token, store);
-  } catch (thrown) {
-    if (thrown instanceof Error) {
-      store.logger.error(
-        `\u{1F41E}`,
-        `molecule`,
-        JSON.stringify(token.key),
-        `Failed to dispose molecule, because it was not found in the store.`,
-        thrown.message
-      );
-    }
-    return;
-  }
-  const { family } = token;
-  for (const state of molecule.tokens.values()) {
-    disposeFromStore(state, store);
-  }
-  for (const child of molecule.below.values()) {
-    if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
-      disposeMolecule(child, store);
-    } else {
-      child.above.delete(molecule.stringKey);
-      if (child.above.size === 0) {
-        disposeMolecule(child, store);
-      }
-    }
+  const values = [];
+  for (const stateToken of molecule.tokens.values()) {
+    const tokenFamily = stateToken.family;
+    values.push([tokenFamily.key, store.valueMap.get(stateToken.key)]);
   }
-  molecule.below.clear();
   if (family) {
     const Formula = withdraw(family, store);
     const disposalEvent = {
       type: `molecule_disposal`,
       token,
       family,
-      context: [...molecule.above.values()].map((m) => deposit(m)),
-      familyKeys: [...molecule.tokens.values()].map((t) => {
-        var _a2;
-        return (_a2 = t.family) == null ? void 0 : _a2.key;
-      }).filter((k) => typeof k === `string`)
+      context,
+      values
     };
     if (token.family) {
       disposalEvent.family = token.family;
     }
+    for (const state of molecule.tokens.values()) {
+      disposeFromStore(state, store);
+    }
+    for (const child of molecule.below.values()) {
+      if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
+        disposeMolecule(child, store);
+      } else {
+        child.above.delete(molecule.stringKey);
+        if (child.above.size === 0) {
+          disposeMolecule(child, store);
+        }
+      }
+    }
+    molecule.below.clear();
     const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
     if (isTransaction) {
       store.transactionMeta.update.updates.push(disposalEvent);
@@ -1630,13 +1224,8 @@ function initFamilyMemberInStore(token, key, 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 {
+  if (state.family && target.moleculeInProgress === null) {
+    if (isRootStore(target)) {
       switch (state.type) {
         case `atom`:
         case `mutable_atom`:
@@ -1647,9 +1236,14 @@ function initFamilyMemberInStore(token, key, store) {
           store.on.selectorCreation.next(state);
           break;
       }
-    }
-  }
-  return state;
+    } else if (isChildStore(target) && target.on.transactionApplying.state === null) {
+      target.transactionMeta.update.updates.push({
+        type: `state_creation`,
+        token: state
+      });
+    }
+  }
+  return state;
 }
 function seekInStore(token, key, store) {
   const subKey = json.stringifyJson(key);
@@ -1694,291 +1288,715 @@ function findInStore(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/molecule/create-molecule-family.ts
+function createMoleculeFamily(options, store) {
+  var _a;
+  const subject = new Subject();
+  const token = {
+    type: `molecule_family`,
+    key: options.key,
+    dependsOn: (_a = options.dependsOn) != null ? _a : `all`
+  };
+  const family = __spreadProps(__spreadValues({}, token), {
+    subject,
+    new: options.new
+  });
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
 
-// 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/molecule/grow-molecule-in-store.ts
+function growMoleculeInStore(molecule, family, store) {
+  const stateToken = initFamilyMemberInStore(family, molecule.key, store);
+  molecule.tokens.set(stateToken.key, stateToken);
+  const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
+  const moleculeInProgress = store.moleculeInProgress === molecule.key;
+  if (!isTransaction && !moleculeInProgress) {
+    molecule.subject.next({ type: `state_creation`, token: stateToken });
+  }
+  return stateToken;
+}
 
-// internal/src/selector/trace-selector-atoms.ts
-var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
-  const rootKeys = [];
-  const indirectDependencyKeys = getSelectorDependencyKeys(
-    directDependencyKey,
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
     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/get-state/get-from-store.ts
+function getFromStore(token, store) {
+  if (token.type === `molecule`) {
+    try {
+      const molecule = withdraw(token, store);
+      return molecule.instance;
+    } catch (_) {
+      return void 0;
     }
-    if (!isAtomKey(indirectDependencyKey, store)) {
-      indirectDependencyKeys.push(
-        ...getSelectorDependencyKeys(indirectDependencyKey, store)
-      );
-    } else if (!rootKeys.includes(indirectDependencyKey)) {
-      rootKeys.push(indirectDependencyKey);
+  }
+  const state = withdraw(token, store);
+  return readOrComputeValue(state, store);
+}
+var Molecule = class {
+  constructor(ctx, key, family) {
+    this.key = key;
+    this.type = `molecule`;
+    this.subject = new Subject();
+    this.tokens = /* @__PURE__ */ new Map();
+    this.above = /* @__PURE__ */ new Map();
+    this.below = /* @__PURE__ */ new Map();
+    this.joins = /* @__PURE__ */ new Map();
+    this.stringKey = json.stringifyJson(key);
+    if (family) {
+      this.family = family;
+    }
+    if (ctx) {
+      if (Array.isArray(ctx)) {
+        for (const molecule of ctx) {
+          this.above.set(molecule.stringKey, molecule);
+        }
+      } else {
+        this.above.set(ctx.stringKey, ctx);
+      }
     }
   }
-  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) => {
+// internal/src/molecule/make-molecule-in-store.ts
+function makeMoleculeInStore(store, context, familyToken, key, ...params) {
   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
-      });
+  target.moleculeInProgress = key;
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => {
+    if (ctx instanceof Molecule) {
+      return ctx;
+    }
+    const stringKey = json.stringifyJson(ctx.key);
+    const molecule2 = store.molecules.get(stringKey);
+    if (!molecule2) {
+      throw new Error(
+        `Molecule ${stringKey} not found in store "${store.config.name}"`
+      );
     }
+    return molecule2;
+  });
+  const molecule = new Molecule(owners, key, familyToken);
+  target.molecules.set(json.stringifyJson(key), molecule);
+  for (const owner of owners) {
+    owner.below.set(molecule.stringKey, molecule);
   }
-};
-
-// 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
+  const transactors = {
+    get: (t) => getFromStore(t, newest(store)),
+    set: (t, newValue) => {
+      setIntoStore(t, newValue, newest(store));
+    },
+    seek: (t, k) => seekInStore(t, k, newest(store)),
+    json: (t) => getJsonToken(t, newest(store)),
+    run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
+    make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(store), ctx, f, k, ...args),
+    dispose: (t) => {
+      disposeFromStore(t, newest(store));
+    },
+    env: () => getEnvironmentData(newest(store)),
+    bond: (f) => growMoleculeInStore(
+      molecule,
+      withdraw(f, store),
+      newest(store)
+    ),
+    claim: (below, options) => {
+      const { exclusive } = options;
+      const belowMolecule = newest(store).molecules.get(json.stringifyJson(below.key));
+      if (belowMolecule) {
+        if (exclusive) {
+          for (const value of belowMolecule.above.values()) {
+            value.below.delete(belowMolecule.stringKey);
+          }
+          belowMolecule.above.clear();
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        } else {
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        }
       }
-    );
-    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;
+    },
+    join: (joinToken) => {
+      const join = data.getJoin(joinToken, store);
+      join.molecules.set(json.stringifyJson(key), molecule);
+      molecule.joins.set(joinToken.key, join);
+      return joinToken;
+    },
+    spawn: (f, k, ...p) => makeMoleculeInStore(
+      newest(store),
+      [molecule],
+      withdraw(f, store),
+      k,
+      ...p
+    )
   };
-  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 family = withdraw(familyToken, store);
+  const Constructor = family.new;
+  molecule.instance = new Constructor(transactors, key, ...params);
   const token = {
-    key: options.key,
-    type: `readonly_selector`
+    type: `molecule`,
+    key,
+    family: familyToken
   };
-  if (family) {
-    token.family = family;
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family: familyToken,
+    context: contextArray,
+    params
+  };
+  if (isRootStore(target)) {
+    family.subject.next(update);
+  } else if (isChildStore(target) && target.on.transactionApplying.state === null) {
+    target.transactionMeta.update.updates.push(update);
   }
+  target.moleculeInProgress = null;
   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;
-  };
-  const setSelf = (next) => {
-    const oldValue = getSelf();
-    const newValue = become(next)(oldValue);
-    store.logger.info(
-      `\u{1F4DD}`,
-      `selector`,
-      options.key,
-      `set (`,
-      oldValue,
-      `->`,
-      newValue,
-      `)`
-    );
-    cacheValue(options.key, newValue, subject, store);
-    markDone(options.key, store);
-    if (isRootStore(target)) {
-      subject.next({ newValue, oldValue });
+// internal/src/ingest-updates/ingest-creation-disposal.ts
+function ingestCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`: {
+      createInStore(update.token, store);
+      break;
+    }
+    case `oldValue`: {
+      disposeFromStore(update.token, store);
+      break;
     }
-    options.set(transactors, newValue);
-  };
-  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
-    subject,
-    install: (s) => createWritableSelector(options, family, s),
-    get: getSelf,
-    set: setSelf,
-    type: `selector`
-  }), family && { family });
-  target.selectors.set(options.key, mySelector);
-  const initialValue = getSelf();
-  store.logger.info(`\u2728`, mySelector.type, mySelector.key, `=`, initialValue);
-  const token = {
-    key: options.key,
-    type: `selector`
-  };
-  if (family) {
-    token.family = family;
   }
-  return token;
-};
+}
+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;
+    }
+  }
+}
+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) {
+        growMoleculeInStore(molecule, family, store);
+        return;
+      }
+      if (store.config.lifespan === `immortal`) {
+        throw new Error(`No molecule found for key "${token.family.subKey}"`);
+      }
+      initFamilyMemberInStore(family, json.parseJson(token.family.subKey), store);
+    }
+  }
+}
+function ingestMoleculeCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      makeMoleculeInStore(
+        store,
+        update.context,
+        update.family,
+        update.token.key,
+        ...update.params
+      );
+      break;
+    case `oldValue`:
+      disposeFromStore(update.token, store);
+      break;
+  }
+}
+function ingestMoleculeDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      disposeFromStore(update.token, store);
+      break;
+    case `oldValue`:
+      {
+        const moleculeToken = makeMoleculeInStore(
+          store,
+          update.context,
+          update.family,
+          update.token.key
+        );
+        for (const [familyKey, value] of update.values) {
+          const memberKey = `${familyKey}(${json.stringifyJson(moleculeToken.key)})`;
+          const molecule = withdraw(moleculeToken, store);
+          const alreadyCreated = molecule.tokens.has(memberKey);
+          const family = store.families.get(familyKey);
+          if (family && !alreadyCreated) {
+            growMoleculeInStore(molecule, family, store);
+          }
+          store.valueMap.set(memberKey, value);
+        }
+      }
+      break;
+  }
+}
 
-// internal/src/selector/create-standalone-selector.ts
-function createStandaloneSelector(options, store) {
-  const isWritable = `set` in options;
-  if (isWritable) {
-    const state2 = createWritableSelector(options, void 0, store);
-    store.on.selectorCreation.next(state2);
-    return state2;
+// 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);
   }
-  const state = createReadonlySelector(options, void 0, store);
-  store.on.selectorCreation.next(state);
-  return state;
 }
 
-// internal/src/selector/dispose-selector.ts
-function disposeSelector(selectorToken, 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 target = newest(store);
-  const { key } = selectorToken;
-  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.`
+  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.`
     );
-  } else if (!selector.family) {
-    store.logger.error(
-      `\u274C`,
-      `selector`,
-      key,
-      `Standalone selectors cannot be disposed.`
+    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
+  );
+  ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
+  if (isRootStore(parent)) {
+    setEpochNumberOfAction(
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch,
+      parent
     );
-  } 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
-          });
+    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/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),
+    timelineTopics: new Junction(parent.timelineTopics.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),
+    moleculeInProgress: parent.moleculeInProgress,
+    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/store/store.ts
+var Store = class {
+  constructor(config, store = null) {
+    this.parent = null;
+    this.child = null;
+    this.valueMap = /* @__PURE__ */ new Map();
+    this.atoms = /* @__PURE__ */ new Map();
+    this.selectors = /* @__PURE__ */ new Map();
+    this.readonlySelectors = /* @__PURE__ */ new Map();
+    this.atomsThatAreDefault = /* @__PURE__ */ new Set();
+    this.selectorAtoms = new Junction({
+      between: [`selectorKey`, `atomKey`],
+      cardinality: `n:n`
+    });
+    this.selectorGraph = new Junction(
+      {
+        between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
+        cardinality: `n:n`
+      },
+      {
+        makeContentKey: (...keys) => keys.sort().join(`:`)
+      }
+    );
+    this.trackers = /* @__PURE__ */ new Map();
+    this.families = /* @__PURE__ */ new Map();
+    this.transactions = /* @__PURE__ */ new Map();
+    this.transactionMeta = {
+      epoch: /* @__PURE__ */ new Map(),
+      actionContinuities: new Junction({
+        between: [`continuity`, `action`],
+        cardinality: `1:n`
+      })
+    };
+    this.timelines = /* @__PURE__ */ new Map();
+    this.timelineTopics = new Junction({
+      between: [`timelineKey`, `topicKey`],
+      cardinality: `1:n`
+    });
+    this.molecules = /* @__PURE__ */ new Map();
+    this.moleculeFamilies = /* @__PURE__ */ new Map();
+    this.moleculeInProgress = null;
+    this.miscResources = /* @__PURE__ */ new Map();
+    this.on = {
+      atomCreation: new Subject(),
+      atomDisposal: new Subject(),
+      selectorCreation: new Subject(),
+      selectorDisposal: new Subject(),
+      timelineCreation: new Subject(),
+      transactionCreation: new Subject(),
+      transactionApplying: new StatefulSubject(
+        null
+      ),
+      operationClose: new Subject(),
+      moleculeCreationStart: new Subject(),
+      moleculeCreationDone: new Subject(),
+      moleculeDisposal: new Subject()
+    };
+    this.operation = { open: false };
+    this.config = {
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
+    };
+    this.loggers = [
+      new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
+    ];
+    this.logger = {
+      error: (...messages) => {
+        for (const logger of this.loggers) logger.error(...messages);
+      },
+      info: (...messages) => {
+        for (const logger of this.loggers) logger.info(...messages);
+      },
+      warn: (...messages) => {
+        for (const logger of this.loggers) logger.warn(...messages);
+      }
+    };
+    if (store !== null) {
+      this.valueMap = new Map(store == null ? void 0 : store.valueMap);
+      this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
+      if (isRootStore(store)) {
+        this.transactionMeta = {
+          epoch: new Map(store == null ? void 0 : store.transactionMeta.epoch),
+          actionContinuities: new Junction(
+            store == null ? void 0 : store.transactionMeta.actionContinuities.toJSON()
+          )
+        };
+      }
+      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
+      for (const [, family] of store.families) {
+        family.install(this);
+      }
+      const mutableHelpers = /* @__PURE__ */ new Set();
+      for (const [, atom] of store.atoms) {
+        if (mutableHelpers.has(atom.key)) {
+          continue;
         }
+        atom.install(this);
+        if (atom.type === `mutable_atom`) {
+          const originalJsonToken = getJsonToken(atom, store);
+          const originalUpdateToken = getUpdateToken(atom);
+          mutableHelpers.add(originalJsonToken.key);
+          mutableHelpers.add(originalUpdateToken.key);
+        }
+      }
+      for (const [, selector] of store.readonlySelectors) {
+        selector.install(this);
+      }
+      for (const [, selector] of store.selectors) {
+        if (mutableHelpers.has(selector.key)) {
+          continue;
+        }
+        selector.install(this);
+      }
+      for (const [, tx] of store.transactions) {
+        tx.install(this);
+      }
+      for (const [, timeline] of store.timelines) {
+        timeline.install(this);
+      }
+    }
+  }
+};
+var IMPLICIT = {
+  STORE_INTERNAL: void 0,
+  get STORE() {
+    var _a;
+    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store({
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
+    });
+  }
+};
+var clearStore = (store) => {
+  const { config } = store;
+  for (const disposable of store.miscResources.values()) {
+    disposable[Symbol.dispose]();
+  }
+  Object.assign(store, new Store(config));
+  store.config = config;
+};
+function withdraw(token, store) {
+  let withdrawn;
+  let target = store;
+  while (target !== null) {
+    switch (token.type) {
+      case `atom`:
+      case `mutable_atom`:
+        withdrawn = target.atoms.get(token.key);
+        break;
+      case `selector`:
+        withdrawn = target.selectors.get(token.key);
+        break;
+      case `readonly_selector`:
+        withdrawn = target.readonlySelectors.get(token.key);
+        break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+      case `selector_family`:
+      case `readonly_selector_family`:
+        withdrawn = target.families.get(token.key);
+        break;
+      case `timeline`:
+        withdrawn = target.timelines.get(token.key);
+        break;
+      case `transaction`:
+        withdrawn = target.transactions.get(token.key);
         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
-          });
-        }
+      case `molecule`:
+        withdrawn = target.molecules.get(json.stringifyJson(token.key));
+        break;
+      case `molecule_family`:
+        withdrawn = target.moleculeFamilies.get(token.key);
         break;
     }
-    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) {
-        disposeSelector(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);
+    if (withdrawn) {
+      return withdrawn;
     }
+    target = target.child;
   }
+  throw new NotFoundError(token, store);
 }
 
 // internal/src/subscribe/recall-state.ts
@@ -2175,7 +2193,7 @@ var Tracker = class {
     subscribeToState(
       latestUpdateState,
       ({ newValue, oldValue }) => {
-        const timelineId = target.timelineAtoms.getRelatedKey(
+        const timelineId = target.timelineTopics.getRelatedKey(
           latestUpdateState.key
         );
         if (timelineId) {
@@ -2626,6 +2644,10 @@ function disposeAtom(atomToken, store) {
       token: atomToken,
       value: lastValue
     });
+    const molecule = target.molecules.get(atom.family.subKey);
+    if (molecule) {
+      molecule.tokens.delete(key);
+    }
     target.atoms.delete(key);
     target.valueMap.delete(key);
     const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
@@ -2639,7 +2661,7 @@ function disposeAtom(atomToken, store) {
     }
     target.selectorAtoms.delete(key);
     target.atomsThatAreDefault.delete(key);
-    target.timelineAtoms.delete(key);
+    target.timelineTopics.delete(key);
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
       disposeAtom(updateToken, store);
@@ -2656,26 +2678,123 @@ function disposeAtom(atomToken, store) {
     }
   }
 }
-
-// internal/src/timeline/add-atom-to-timeline.ts
-var addAtomToTimeline = (atomToken, tl, store) => {
+function createTimeline(options, store, data) {
+  var _a;
+  const tl = __spreadProps(__spreadValues({
+    type: `timeline`,
+    key: options.key,
+    at: 0,
+    timeTraveling: null,
+    selectorTime: null,
+    transactionKey: null
+  }, data), {
+    history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
+    install: (s) => createTimeline(options, s, tl),
+    subject: new Subject(),
+    subscriptions: /* @__PURE__ */ new Map()
+  });
+  if (options.shouldCapture) {
+    tl.shouldCapture = options.shouldCapture;
+  }
+  const timelineKey = options.key;
+  const target = newest(store);
+  for (const initialTopic of options.scope) {
+    switch (initialTopic.type) {
+      case `atom`:
+      case `mutable_atom`:
+        {
+          const atomToken = initialTopic;
+          const atomKey = atomToken.key;
+          let existingTimelineKey = target.timelineTopics.getRelatedKey(atomKey);
+          if (`family` in atomToken) {
+            const familyKey = atomToken.family.key;
+            existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+            if (existingTimelineKey) {
+              store.logger.error(
+                `\u274C`,
+                `timeline`,
+                options.key,
+                `Failed to add atom "${atomKey}" because its family "${familyKey}" already belongs to timeline "${existingTimelineKey}"`
+              );
+              continue;
+            }
+          }
+          if (existingTimelineKey) {
+            store.logger.error(
+              `\u274C`,
+              `timeline`,
+              options.key,
+              `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
+            );
+            continue;
+          }
+          addAtomToTimeline(atomToken, tl, store);
+        }
+        break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+        {
+          const familyToken = initialTopic;
+          const familyKey = familyToken.key;
+          const existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+          if (existingTimelineKey) {
+            store.logger.error(
+              `\u274C`,
+              `timeline`,
+              options.key,
+              `Failed to add atom family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`
+            );
+            continue;
+          }
+          addAtomFamilyToTimeline(familyToken, tl, store);
+        }
+        break;
+      case `molecule_family`:
+        {
+          const familyToken = initialTopic;
+          const familyKey = familyToken.key;
+          const existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+          if (existingTimelineKey) {
+            store.logger.error(
+              `\u274C`,
+              `timeline`,
+              options.key,
+              `Failed to add molecule family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`
+            );
+            continue;
+          }
+          addMoleculeFamilyToTimeline(familyToken, tl, store);
+        }
+        break;
+    }
+  }
+  store.timelines.set(options.key, tl);
+  const token = {
+    key: timelineKey,
+    type: `timeline`
+  };
+  store.on.timelineCreation.next(token);
+  return token;
+}
+function addAtomToTimeline(atomToken, tl, store) {
   let maybeAtom = withdraw(atomToken, store);
   if (maybeAtom.type === `mutable_atom`) {
     const updateToken = getUpdateToken(maybeAtom);
     maybeAtom = withdraw(updateToken, store);
   }
   const atom = maybeAtom;
-  store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key });
+  store.timelineTopics.set(
+    { topicKey: atom.key, timelineKey: tl.key },
+    { topicType: `atom` }
+  );
   tl.subscriptions.set(
     atom.key,
     atom.subject.subscribe(`timeline`, (update) => {
-      var _a, _b, _c, _d, _e, _f;
+      var _a, _b, _c, _d, _e;
       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;
+      const txUpdateInProgress = (_a = target.on.transactionApplying.state) == null ? void 0 : _a.update;
       store.logger.info(
         `\u23F3`,
         `timeline`,
@@ -2686,109 +2805,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
         update.oldValue,
         `->`,
         update.newValue,
-        currentTransactionKey ? `in transaction "${currentTransactionKey}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
+        txUpdateInProgress ? `in transaction "${txUpdateInProgress.key}"` : 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.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) => {
-                    var _a3, _b3;
-                    const newestStore = newest(store);
-                    if (`updates` in updateFromTx) {
-                      return true;
-                    }
-                    const atomOrFamilyKeys = newestStore.timelineAtoms.getRelatedKeys(tl.key);
-                    if (!atomOrFamilyKeys) {
-                      return false;
-                    }
-                    let key;
-                    let familyKey;
-                    switch (updateFromTx.type) {
-                      case `state_creation`:
-                      case `state_disposal`:
-                        key = updateFromTx.token.key;
-                        familyKey = (_a3 = updateFromTx.token.family) == null ? void 0 : _a3.key;
-                        break;
-                      case `molecule_creation`:
-                      case `molecule_disposal`:
-                        break;
-                      default:
-                        key = updateFromTx.key;
-                        familyKey = (_b3 = updateFromTx.family) == null ? void 0 : _b3.key;
-                        break;
-                    }
-                    if (key === void 0) {
-                      return false;
-                    }
-                    if (atomOrFamilyKeys.has(key)) {
-                      return true;
-                    }
-                    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);
-                  }
-                }
-                tl.transactionKey = null;
-                store.logger.info(
-                  `\u231B`,
-                  `timeline`,
-                  tl.key,
-                  `got a transaction_update "${transactionUpdate.key}"`
-                );
-              }
-            );
-          }
+        if (txUpdateInProgress) {
+          joinTransaction(tl, txUpdateInProgress, store);
         } else if (currentSelectorKey && currentSelectorTime) {
           let latestUpdate = tl.history.at(-1);
           if (currentSelectorTime !== tl.selectorTime) {
@@ -2831,7 +2852,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
             }
           }
           if (latestUpdate) {
-            const willCaptureSelectorUpdate = (_d = (_c = tl.shouldCapture) == null ? void 0 : _c.call(tl, latestUpdate, tl)) != null ? _d : true;
+            const willCaptureSelectorUpdate = (_c = (_b = tl.shouldCapture) == null ? void 0 : _b.call(tl, latestUpdate, tl)) != null ? _c : true;
             if (willCaptureSelectorUpdate) {
               tl.subject.next(latestUpdate);
             } else {
@@ -2855,7 +2876,7 @@ var addAtomToTimeline = (atomToken, tl, store) => {
           if (atom.family) {
             atomUpdate.family = atom.family;
           }
-          const willCapture = (_f = (_e = tl.shouldCapture) == null ? void 0 : _e.call(tl, atomUpdate, tl)) != null ? _f : true;
+          const willCapture = (_e = (_d = tl.shouldCapture) == null ? void 0 : _d.call(tl, atomUpdate, tl)) != null ? _e : true;
           store.logger.info(
             `\u231B`,
             `timeline`,
@@ -2871,181 +2892,207 @@ var addAtomToTimeline = (atomToken, tl, store) => {
       }
     })
   );
-};
-function createTimeline(options, store, data) {
-  var _a, _b;
-  const tl = __spreadProps(__spreadValues({
-    type: `timeline`,
-    key: options.key,
-    at: 0,
-    timeTraveling: null,
-    selectorTime: null,
-    transactionKey: null
-  }, data), {
-    history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
-    install: (s) => createTimeline(options, s, tl),
-    subject: new Subject(),
-    subscriptions: /* @__PURE__ */ new Map()
-  });
-  if (options.shouldCapture) {
-    tl.shouldCapture = options.shouldCapture;
+}
+function addAtomFamilyToTimeline(atomFamilyToken, tl, store) {
+  var _a;
+  const family = withdraw(atomFamilyToken, store);
+  store.timelineTopics.set(
+    { topicKey: family.key, timelineKey: tl.key },
+    { topicType: `atom_family` }
+  );
+  tl.subscriptions.set(
+    family.key,
+    family.subject.subscribe(`timeline`, (creationOrDisposal) => {
+      handleStateLifecycleEvent(creationOrDisposal, tl, store);
+    })
+  );
+  for (const atom of store.atoms.values()) {
+    if (((_a = atom.family) == null ? void 0 : _a.key) === family.key) {
+      addAtomToTimeline(atom, tl, store);
+    }
   }
-  const timelineKey = options.key;
-  const target = newest(store);
-  for (const tokenOrFamily of options.scope) {
-    let atomKey = tokenOrFamily.key;
-    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);
+}
+function addMoleculeFamilyToTimeline(familyToken, tl, store) {
+  store.timelineTopics.set(
+    { topicKey: familyToken.key, timelineKey: tl.key },
+    { topicType: `molecule_family` }
+  );
+  const family = store.moleculeFamilies.get(familyToken.key);
+  if (family) {
+    tl.subscriptions.set(
+      familyToken.key,
+      family.subject.subscribe(`timeline:${tl.key}`, (creationOrDisposal) => {
+        var _a, _b, _c, _d;
+        store.logger.info(
+          `\u{1F41E}`,
+          `timeline`,
+          tl.key,
+          `got a molecule creation or disposal`,
+          creationOrDisposal
+        );
+        switch (creationOrDisposal.type) {
+          case `molecule_creation`:
+            {
+              store.timelineTopics.set(
+                {
+                  topicKey: creationOrDisposal.token.key,
+                  timelineKey: tl.key
+                },
+                { topicType: `molecule` }
+              );
+              const txUpdateInProgress = (_a = newest(store).on.transactionApplying.state) == null ? void 0 : _a.update;
+              if (txUpdateInProgress) {
+                joinTransaction(tl, txUpdateInProgress, store);
+              } else if (tl.timeTraveling === null) {
+                const event = Object.assign(creationOrDisposal, {
+                  timestamp: Date.now()
+                });
+                tl.history.push(event);
+                tl.at = tl.history.length;
+                tl.subject.next(event);
               }
-            )
-          );
-          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}"`
+              const molecule = withdraw(creationOrDisposal.token, store);
+              for (const token of molecule.tokens.values()) {
+                switch (token.type) {
+                  case `atom`:
+                  case `mutable_atom`:
+                    addAtomToTimeline(token, tl, store);
+                    break;
+                }
+              }
+              tl.subscriptions.set(
+                molecule.key,
+                molecule.subject.subscribe(
+                  `timeline:${tl.key}`,
+                  (stateCreationOrDisposal) => {
+                    handleStateLifecycleEvent(stateCreationOrDisposal, tl, store);
+                  }
+                )
               );
-              continue;
             }
+            break;
+          case `molecule_disposal`:
+            {
+              const txUpdateInProgress = (_b = newest(store).on.transactionApplying.state) == null ? void 0 : _b.update;
+              if (txUpdateInProgress) {
+                joinTransaction(tl, txUpdateInProgress, store);
+              } else if (tl.timeTraveling === null) {
+                const event = Object.assign(creationOrDisposal, {
+                  timestamp: Date.now()
+                });
+                tl.history.push(event);
+                tl.at = tl.history.length;
+                tl.subject.next(event);
+              }
+              const moleculeKey = creationOrDisposal.token.key;
+              (_c = tl.subscriptions.get(moleculeKey)) == null ? void 0 : _c();
+              tl.subscriptions.delete(moleculeKey);
+              for (const [familyKey] of creationOrDisposal.values) {
+                const stateKey = `${familyKey}(${json.stringifyJson(moleculeKey)})`;
+                (_d = tl.subscriptions.get(stateKey)) == null ? void 0 : _d();
+                tl.subscriptions.delete(stateKey);
+                store.timelineTopics.delete(stateKey);
+              }
+            }
+            break;
+        }
+      })
+    );
+  }
+}
+function joinTransaction(tl, txUpdateInProgress, store) {
+  const currentTxKey = txUpdateInProgress.key;
+  const currentTxInstanceId = txUpdateInProgress.id;
+  const currentTxToken = {
+    key: currentTxKey,
+    type: `transaction`
+  };
+  const currentTransaction = withdraw(currentTxToken, store);
+  if (currentTxKey && tl.transactionKey === null) {
+    tl.transactionKey = currentTxKey;
+    const unsubscribe = currentTransaction.subject.subscribe(
+      `timeline:${tl.key}`,
+      (transactionUpdate) => {
+        var _a, _b;
+        unsubscribe();
+        tl.transactionKey = null;
+        if (tl.timeTraveling === null && currentTxInstanceId) {
+          if (tl.at !== tl.history.length) {
+            tl.history.splice(tl.at);
           }
-          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;
+          const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key);
+          const updates = filterTransactionUpdates(
+            transactionUpdate.updates,
+            timelineTopics
+          );
+          const timelineTransactionUpdate = __spreadProps(__spreadValues({
+            timestamp: Date.now()
+          }, transactionUpdate), {
+            updates
+          });
+          const willCapture = (_b = (_a = tl.shouldCapture) == null ? void 0 : _a.call(tl, timelineTransactionUpdate, tl)) != null ? _b : true;
+          if (willCapture) {
+            tl.history.push(timelineTransactionUpdate);
+            tl.at = tl.history.length;
+            tl.subject.next(timelineTransactionUpdate);
           }
-          addAtomToTimeline(atom, tl, store);
         }
+      }
+    );
+  }
+}
+function filterTransactionUpdates(updates, timelineTopics) {
+  return updates.filter((updateFromTx) => {
+    if (updateFromTx.type === `transaction_update`) {
+      return true;
+    }
+    let key;
+    switch (updateFromTx.type) {
+      case `state_creation`:
+      case `state_disposal`:
+      case `molecule_creation`:
+      case `molecule_disposal`:
+        key = updateFromTx.token.key;
         break;
-      case `molecule_family`:
-        {
-          const family = store.moleculeFamilies.get(tokenOrFamily.key);
-          if (family) {
-            tl.subscriptions.set(
-              tokenOrFamily.key,
-              family.subject.subscribe(
-                `timeline:${options.key}`,
-                (creationOrDisposal) => {
-                  var _a2, _b2;
-                  switch (creationOrDisposal.type) {
-                    case `molecule_creation`:
-                      {
-                        const molecule = store.molecules.get(
-                          json.stringifyJson(creationOrDisposal.token.key)
-                        );
-                        if (molecule) {
-                          const event = Object.assign(creationOrDisposal, {
-                            timestamp: Date.now()
-                          });
-                          tl.history.push(event);
-                          tl.at = tl.history.length;
-                          tl.subject.next(event);
-                          for (const token2 of molecule.tokens.values()) {
-                            switch (token2.type) {
-                              case `atom`:
-                              case `mutable_atom`:
-                                addAtomToTimeline(token2, tl, store);
-                                break;
-                            }
-                          }
-                          tl.subscriptions.set(
-                            molecule.key,
-                            molecule.subject.subscribe(
-                              `timeline:${options.key}`,
-                              (stateCreationOrDisposal) => {
-                                handleStateLifecycleEvent(
-                                  stateCreationOrDisposal,
-                                  tl,
-                                  store
-                                );
-                              }
-                            )
-                          );
-                        }
-                      }
-                      break;
-                    case `molecule_disposal`:
-                      (_a2 = tl.subscriptions.get(creationOrDisposal.token.key)) == null ? void 0 : _a2();
-                      tl.subscriptions.delete(creationOrDisposal.token.key);
-                      for (const familyKey of creationOrDisposal.familyKeys) {
-                        const stateKey = `${familyKey}(${json.stringifyJson(
-                          creationOrDisposal.token.key
-                        )})`;
-                        (_b2 = tl.subscriptions.get(stateKey)) == null ? void 0 : _b2();
-                        tl.subscriptions.delete(stateKey);
-                      }
-                      break;
-                  }
-                }
-              )
-            );
-          }
-        }
+      default:
+        key = updateFromTx.key;
         break;
     }
-  }
-  store.timelines.set(options.key, tl);
-  const token = {
-    key: timelineKey,
-    type: `timeline`
-  };
-  store.on.timelineCreation.next(token);
-  return token;
+    return timelineTopics.has(key);
+  }).map((updateFromTx) => {
+    if (`updates` in updateFromTx) {
+      return __spreadProps(__spreadValues({}, updateFromTx), {
+        updates: filterTransactionUpdates(
+          updateFromTx.updates,
+          timelineTopics
+        )
+      });
+    }
+    return updateFromTx;
+  });
 }
 function handleStateLifecycleEvent(event, tl, store) {
-  var _a;
+  var _a, _b;
   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);
+    const txUpdateInProgress = (_a = newest(store).on.transactionApplying.state) == null ? void 0 : _a.update;
+    if (txUpdateInProgress) {
+      joinTransaction(tl, txUpdateInProgress, store);
+    } else {
+      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();
+      (_b = tl.subscriptions.get(event.token.key)) == null ? void 0 : _b();
       tl.subscriptions.delete(event.token.key);
       break;
   }
@@ -3140,7 +3187,6 @@ exports.TRANSACTION_PHASES = TRANSACTION_PHASES;
 exports.Tracker = Tracker;
 exports.abortTransaction = abortTransaction;
 exports.actUponStore = actUponStore;
-exports.addAtomToTimeline = addAtomToTimeline;
 exports.applyTransaction = applyTransaction;
 exports.arbitrary = arbitrary;
 exports.assignTransactionToContinuity = assignTransactionToContinuity;