atom.io 0.30.7 → 0.31.1

package/dist/{chunk-UDHCFTYT.js → chunk-Y5MBNTVU.js}

@@ -1,7 +1,5 @@
-import { deallocateFromStore, allocateIntoStore } from './chunk-ADMEAXYU.js';
 import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
-import { getJoin, findRelations } from 'atom.io/data';
 import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1 } from 'atom.io/internal';
 
 // internal/src/arbitrary.ts
@@ -52,7 +50,7 @@ var Future = class extends Promise {
       );
     } else {
       this.resolve(value);
-      this.fate = void 0;
+      this.fate = undefined;
     }
   }
 };
@@ -64,12 +62,6 @@ function newest(scion) {
   }
   return scion;
 }
-function eldest(scion) {
-  while (scion.parent !== null) {
-    scion = scion.parent;
-  }
-  return scion;
-}
 
 // internal/src/store/circular-buffer.ts
 var CircularBuffer = class _CircularBuffer {
@@ -115,19 +107,12 @@ function counterfeit(token, key) {
     key: fullKey,
     type
   };
-  if (type === `molecule`) {
-    Object.assign(stateToken, {
-      key,
-      family: token
-    });
-  } else {
-    Object.assign(stateToken, {
-      family: {
-        key: token.key,
-        subKey
-      }
-    });
-  }
+  Object.assign(stateToken, {
+    family: {
+      key: token.key,
+      subKey
+    }
+  });
   Object.assign(stateToken, { counterfeit: true });
   return stateToken;
 }
@@ -200,8 +185,8 @@ var Junction = class {
   }
   replaceRelationsSafely(x, ys) {
     const xRelationsPrev = this.relations.get(x);
-    let a = this.isAType?.(x) ? x : void 0;
-    let b = a === void 0 ? x : void 0;
+    let a = this.isAType?.(x) ? x : undefined;
+    let b = a === undefined ? x : undefined;
     if (xRelationsPrev) {
       for (const y of xRelationsPrev) {
         a ??= y;
@@ -283,8 +268,8 @@ var Junction = class {
         };
       }
       for (const [x, ys] of data.relations ?? []) {
-        let a = this.isAType?.(x) ? x : void 0;
-        let b = a === void 0 ? x : void 0;
+        let a = this.isAType?.(x) ? x : undefined;
+        let b = a === undefined ? x : undefined;
         for (const y of ys) {
           a ??= y;
           b ??= y;
@@ -309,10 +294,36 @@ var Junction = class {
       contents: [...this.contents.entries()]
     };
   }
-  set(a, ...rest) {
-    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
-    const content = rest[1] ?? typeof rest[0] === `string` ? void 0 : rest[0];
-    a = typeof a === `string` ? a : a[this.a];
+  set(...params) {
+    let a;
+    let b;
+    let content;
+    switch (params.length) {
+      case 1: {
+        const relation = params[0];
+        a = relation[this.a];
+        b = relation[this.b];
+        content = undefined;
+        break;
+      }
+      case 2: {
+        const zeroth = params[0];
+        if (typeof zeroth === `string`) {
+          [a, b] = params;
+        } else {
+          a = zeroth[this.a];
+          b = zeroth[this.b];
+          content = params[1];
+        }
+        break;
+      }
+      default: {
+        a = params[0];
+        b = params[1];
+        content = params[2];
+        break;
+      }
+    }
     switch (this.cardinality) {
       // biome-ignore lint/suspicious/noFallthroughSwitchClause: perfect here
       case `1:1`: {
@@ -337,7 +348,7 @@ var Junction = class {
       // @ts-expect-error we deduce that this.a may index x
       typeof x === `string` ? x : x[this.a]
     );
-    if (a === void 0 && typeof b === `string`) {
+    if (a === undefined && typeof b === `string`) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
         for (const bRelation of bRelations) {
@@ -345,7 +356,7 @@ var Junction = class {
         }
       }
     }
-    if (typeof a === `string` && b === void 0) {
+    if (typeof a === `string` && b === undefined) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
         for (const aRelation of aRelations) {
@@ -402,7 +413,7 @@ var Junction = class {
   getRelationEntries(input) {
     const a = input[this.a];
     const b = input[this.b];
-    if (a !== void 0 && b === void 0) {
+    if (a !== undefined && b === undefined) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
         return [...aRelations].map((aRelation) => {
@@ -410,7 +421,7 @@ var Junction = class {
         });
       }
     }
-    if (a === void 0 && b !== void 0) {
+    if (a === undefined && b !== undefined) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
         return [...bRelations].map((bRelation) => {
@@ -499,19 +510,10 @@ function prettyPrintTokenType(token) {
 
 // internal/src/not-found-error.ts
 var NotFoundError = class extends Error {
-  constructor(...params) {
-    const token = params[0];
-    const store = params.length === 2 ? params[1] : params[2];
-    if (params.length === 2) {
-      super(
-        `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
-      );
-    } else {
-      const key = params[1];
-      super(
-        `${prettyPrintTokenType(token)} "${token.key}" member ${stringifyJson(key)} not found in store "${store.config.name}".`
-      );
-    }
+  constructor(token, store) {
+    super(
+      `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
+    );
   }
 };
 
@@ -823,86 +825,6 @@ function createAtomFamily(store, options) {
   return createRegularAtomFamily(store, options);
 }
 
-// internal/src/families/get-family-of-token.ts
-function getFamilyOfToken(store, token) {
-  if (token.family) {
-    const family = store.families.get(token.family.key);
-    if (family) {
-      return family;
-    }
-  }
-}
-
-// internal/src/get-state/get-from-store.ts
-function getFromStore(store, ...params) {
-  let token;
-  let family;
-  let key;
-  if (params.length === 1) {
-    token = params[0];
-    if (token.type !== `molecule`) {
-      family = getFamilyOfToken(store, token) ?? null;
-      if (family) {
-        key = token.family ? parseJson(token.family.subKey) : null;
-        token = findInStore(store, family, key);
-      }
-    }
-  } else {
-    family = params[0];
-    key = params[1];
-    let maybeToken;
-    if (family.type === `molecule_family`) {
-      maybeToken = seekInStore(store, family, key) ?? counterfeit(family, key);
-    } else {
-      maybeToken = findInStore(store, family, key);
-    }
-    token = maybeToken;
-  }
-  if (`counterfeit` in token && `family` in token) {
-    family = token.type === `molecule` ? withdraw(token.family, store) : (
-      // biome-ignore lint/style/noNonNullAssertion: family must be present
-      store.families.get(token.family.key)
-    );
-    const subKey = token.type === `molecule` ? token.key : token.family.subKey;
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === token.key
-    );
-    store.logger.error(
-      `\u274C`,
-      token.type,
-      token.key,
-      `could not be retrieved because it was not found in the store "${store.config.name}".`,
-      disposal ? `This state was previously disposed:
-${disposal.trace}` : `No previous disposal trace was found.`
-    );
-    switch (family.type) {
-      case `atom_family`:
-      case `mutable_atom_family`:
-        return store.defaults.get(family.key);
-      case `selector_family`:
-      case `readonly_selector_family`: {
-        if (store.defaults.has(family.key)) {
-          return store.defaults.get(token.family.key);
-        }
-        const defaultValue = withdraw(family, store).default(subKey);
-        store.defaults.set(family.key, defaultValue);
-        return defaultValue;
-      }
-      case `molecule_family`:
-        throw new NotFoundError(family, subKey, store);
-    }
-  }
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-    case `selector`:
-    case `readonly_selector`:
-      return readOrComputeValue(withdraw(token, store), store);
-    case `molecule`:
-      return withdraw(token, store).instance;
-  }
-}
-
 // internal/src/keys.ts
 var isAtomKey = (key, store) => newest(store).atoms.has(key);
 var isSelectorKey = (key, store) => newest(store).selectors.has(key);
@@ -986,27 +908,10 @@ var registerSelector = (selectorKey, covered, store) => ({
     let dependency;
     if (params.length === 2) {
       const [family, key] = params;
-      switch (family.type) {
-        case `molecule_family`:
-          return getFromStore(store, family, key);
-        default:
-          if (store.config.lifespan === `ephemeral`) {
-            dependency = findInStore(store, family, key);
-          } else {
-            const maybeDependency = seekInStore(store, family, key);
-            if (maybeDependency) {
-              dependency = maybeDependency;
-            } else {
-              throw new NotFoundError(family, key, store);
-            }
-          }
-      }
+      dependency = findInStore(store, family, key);
     } else {
       [dependency] = params;
     }
-    if (dependency.type === `molecule`) {
-      return getFromStore(store, dependency);
-    }
     const dependencyState = withdraw(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
     store.logger.info(
@@ -1039,11 +944,7 @@ var registerSelector = (selectorKey, covered, store) => ({
       const family = params[0];
       const key = params[1];
       value = params[2];
-      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(store, family, key) : seekInStore(store, family, key);
-      if (!maybeToken) {
-        throw new NotFoundError(family, key, store);
-      }
-      token = maybeToken;
+      token = findInStore(store, family, key);
     }
     const target = newest(store);
     const state = withdraw(token, target);
@@ -1158,11 +1059,11 @@ var createWritableSelector = (store, options, family) => {
 function createStandaloneSelector(store, options) {
   const isWritable = `set` in options;
   if (isWritable) {
-    const state2 = createWritableSelector(store, options, void 0);
+    const state2 = createWritableSelector(store, options, undefined);
     store.on.selectorCreation.next(state2);
     return state2;
   }
-  const state = createReadonlySelector(store, options, void 0);
+  const state = createReadonlySelector(store, options, undefined);
   store.on.selectorCreation.next(state);
   return state;
 }
@@ -1182,20 +1083,16 @@ function disposeSelector(selectorToken, store) {
   } else {
     const molecule = target.molecules.get(selector.family.subKey);
     if (molecule) {
-      molecule.tokens.delete(key);
+      target.moleculeData.delete(selector.family.subKey, selector.family.key);
     }
     switch (selectorToken.type) {
       case `selector`:
         {
           target.selectors.delete(key);
-          const family = withdraw(
+          withdraw(
             { key: selector.family.key, type: `selector_family` },
             store
           );
-          family.subject.next({
-            type: `state_disposal`,
-            token: selectorToken
-          });
         }
         break;
       case `readonly_selector`:
@@ -1207,6 +1104,7 @@ function disposeSelector(selectorToken, store) {
           );
           family.subject.next({
             type: `state_disposal`,
+            subType: `selector`,
             token: selectorToken
           });
         }
@@ -1219,6 +1117,7 @@ function disposeSelector(selectorToken, store) {
     if (isChildStore(target) && target.transactionMeta.phase === `building`) {
       target.transactionMeta.update.updates.push({
         type: `state_disposal`,
+        subType: `selector`,
         token: selectorToken
       });
     } else {
@@ -1339,267 +1238,15 @@ function createSelectorFamily(store, options) {
   return createReadonlySelectorFamily(store, options);
 }
 
-// internal/src/molecule/dispose-molecule.ts
-function disposeMolecule(token, store) {
-  let molecule;
-  molecule = withdraw(token, store);
-  const { family } = token;
-  for (const join of molecule.joins.values()) {
-    join.relations.delete(molecule.key);
-    join.molecules.delete(molecule.stringKey);
-  }
-  const context = [];
-  for (const above of molecule.above.values()) {
-    context.push(deposit(above));
-  }
-  const values = [];
-  for (const stateToken of molecule.tokens.values()) {
-    const tokenFamily = stateToken.family;
-    values.push([tokenFamily.key, store.valueMap.get(stateToken.key)]);
-  }
-  if (family) {
-    const Formula = withdraw(family, store);
-    const disposalEvent = {
-      type: `molecule_disposal`,
-      subType: `classic`,
-      token,
-      family,
-      context,
-      values
-    };
-    if (token.family) {
-      disposalEvent.family = token.family;
-    }
-    for (const state of molecule.tokens.values()) {
-      disposeFromStore(store, state);
-    }
-    for (const child of molecule.below.values()) {
-      if (child.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);
-    } else {
-      Formula.subject.next(disposalEvent);
-    }
-    store.molecules.delete(molecule.stringKey);
-  }
-  for (const parent of molecule.above.values()) {
-    parent.below.delete(molecule.stringKey);
-  }
-}
-
-// internal/src/molecule/create-molecule-family.ts
-function createMoleculeFamily(store, options) {
-  const subject = new Subject();
-  const token = {
-    type: `molecule_family`,
-    key: options.key,
-    dependsOn: options.dependsOn ?? `all`
-  };
-  const family = {
-    ...token,
-    subject,
-    new: options.new
-  };
-  store.moleculeFamilies.set(options.key, family);
-  return token;
-}
-
-// internal/src/molecule/grow-molecule-in-store.ts
-function growMoleculeInStore(molecule, family, store) {
-  const stateToken = initFamilyMemberInStore(store, family, molecule.key);
-  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/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    store
-  };
-}
-var Molecule = class {
-  constructor(ctx, key, family) {
-    this.key = key;
-    this.stringKey = stringifyJson(key);
-    if (family) {
-      this.family = family;
-      this._dependsOn = family.dependsOn;
-    }
-    if (ctx) {
-      for (const molecule of ctx) {
-        this.above.set(molecule.stringKey, molecule);
-      }
-    }
-  }
-  type = `molecule`;
-  stringKey;
-  family;
-  _dependsOn;
-  get dependsOn() {
-    if (this.family) {
-      return this.family.dependsOn;
-    }
-    return this._dependsOn;
-  }
-  subject = new Subject();
-  tokens = /* @__PURE__ */ new Map();
-  above = /* @__PURE__ */ new Map();
-  below = /* @__PURE__ */ new Map();
-  joins = /* @__PURE__ */ new Map();
-  instance;
-};
-
-// internal/src/molecule/make-molecule-in-store.ts
-function capitalize2(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
-function makeMoleculeInStore(store, context, familyToken, key, ...params) {
-  const rootStore = eldest(store);
-  const target = newest(store);
-  const stringKey = stringifyJson(key);
-  target.moleculeInProgress = stringKey;
-  const contextArray = Array.isArray(context) ? context : [context];
-  const owners = contextArray.map((ctx) => {
-    if (ctx instanceof Molecule) {
-      return ctx;
-    }
-    const ctxStringKey = stringifyJson(ctx.key);
-    const molecule2 = store.molecules.get(ctxStringKey);
-    if (!molecule2) {
-      throw new Error(
-        `Molecule ${ctxStringKey} not found in store "${store.config.name}"`
-      );
-    }
-    return molecule2;
-  });
-  const molecule = new Molecule(owners, key, familyToken);
-  target.molecules.set(stringKey, molecule);
-  for (const owner of owners) {
-    owner.below.set(molecule.stringKey, molecule);
-  }
-  const toolkit = {
-    get: (...ps) => getFromStore(newest(rootStore), ...ps),
-    set: (...ps) => {
-      setIntoStore(newest(rootStore), ...ps);
-    },
-    seek: (t, k) => seekInStore(newest(rootStore), t, k),
-    json: (t) => getJsonToken(newest(rootStore), t),
-    run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
-    make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
-    dispose: (t) => {
-      disposeFromStore(newest(rootStore), t);
-    },
-    env: () => getEnvironmentData(newest(rootStore)),
-    bond: (token2, maybeRole) => {
-      if (token2.type === `join`) {
-        const { as: role } = maybeRole;
-        const join = getJoin(token2, rootStore);
-        join.molecules.set(stringKey, molecule);
-        molecule.joins.set(token2.key, join);
-        const unsubFromFamily = family.subject.subscribe(
-          `join:${token2.key}-${stringKey}`,
-          (event) => {
-            if (event.type === `molecule_disposal`) {
-              if (stringifyJson(event.token.key) === stringKey) {
-                unsubFromFamily();
-                join.molecules.delete(stringKey);
-              }
-            }
-          }
-        );
-        if (role === null) {
-          return;
-        }
-        const otherRole = token2.a === role ? token2.b : token2.a;
-        const relations = findRelations(token2, key);
-        const relatedKeys = relations[`${otherRole}KeysOf${capitalize2(role)}`];
-        const relatedEntries = relations[`${otherRole}EntriesOf${capitalize2(role)}`];
-        let tokens = { relatedKeys };
-        if (relatedEntries) {
-          tokens = Object.assign(tokens, { relatedEntries });
-        }
-        return tokens;
-      }
-      return growMoleculeInStore(
-        molecule,
-        withdraw(token2, rootStore),
-        newest(rootStore)
-      );
-    },
-    claim: (below, options) => {
-      const { exclusive } = options;
-      const belowMolecule = newest(store).molecules.get(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);
-        }
-      }
-    },
-    spawn: (f, k, ...p) => makeMoleculeInStore(
-      newest(store),
-      [molecule],
-      withdraw(f, store),
-      k,
-      ...p
-    )
-  };
-  const family = withdraw(familyToken, store);
-  const Constructor = family.new;
-  molecule.instance = new Constructor(toolkit, key, ...params);
-  const token = {
-    type: `molecule`,
-    key,
-    family: familyToken
-  };
-  const update = {
-    type: `molecule_creation`,
-    subType: `classic`,
-    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/families/init-family-member.ts
 function initFamilyMemberInStore(store, token, key) {
   const family = store.families.get(token.key);
-  if (family === void 0) {
+  if (family === undefined) {
     throw new NotFoundError(token, store);
   }
   const state = family(key);
   const target = newest(store);
-  if (state.family && target.moleculeInProgress === null) {
+  if (state.family) {
     if (isRootStore(target)) {
       switch (state.type) {
         case `atom`:
@@ -1636,8 +1283,6 @@ function seekInStore(store, token, key) {
     case `readonly_selector_family`:
       state = target.readonlySelectors.get(fullKey);
       break;
-    case `molecule_family`:
-      state = target.molecules.get(stringifyJson(key));
   }
   if (state) {
     return deposit(state);
@@ -1651,11 +1296,9 @@ function findInStore(store, token, key) {
   if (state) {
     return state;
   }
-  const molecule = store.molecules.get(stringifyJson(key));
-  if (molecule) {
-    return growMoleculeInStore(molecule, token, store);
-  }
-  if (store.config.lifespan === `immortal`) {
+  const stringKey = stringifyJson(key);
+  const molecule = store.molecules.get(stringKey);
+  if (!molecule && store.config.lifespan === `immortal`) {
     const fakeToken = counterfeit(token, key);
     store.logger.error(
       `\u274C`,
@@ -1666,6 +1309,10 @@ function findInStore(store, token, key) {
     return fakeToken;
   }
   state = initFamilyMemberInStore(store, token, key);
+  if (molecule) {
+    const target = newest(store);
+    target.moleculeData.set(stringKey, token.key);
+  }
   return state;
 }
 
@@ -1674,27 +1321,23 @@ function disposeFromStore(store, ...params) {
   let token;
   if (params.length === 1) {
     token = params[0];
-    token.key;
   } else {
     const family = params[0];
     const key = params[1];
-    const maybeToken = family.type === `molecule_family` ? seekInStore(store, family, key) ?? counterfeit(family, key) : findInStore(store, family, key);
+    const maybeToken = findInStore(store, family, key);
     token = maybeToken;
   }
   try {
     withdraw(token, store);
   } catch (thrown) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === token.key
-    );
     store.logger.error(
       `\u274C`,
       token.type,
       token.key,
-      `could not be disposed because it was not found in the store "${store.config.name}".`,
-      disposal ? `
-   This state was most recently disposed
-${disposal.trace}` : `No previous disposal trace was found.`
+      `could not be disposed because it was not found in the store "${store.config.name}".`
+      // disposal
+      // 	? `\n   This state was most recently disposed\n${disposal.trace}`
+      // 	: `No previous disposal trace was found.`,
     );
     return;
   }
@@ -1707,16 +1350,16 @@ ${disposal.trace}` : `No previous disposal trace was found.`
     case `readonly_selector`:
       disposeSelector(token, store);
       break;
-    case `molecule`:
-      disposeMolecule(token, store);
-      break;
   }
-  const { stack } = new Error();
-  if (stack) {
-    const trace = stack?.split(`
-`)?.slice(3)?.join(`
-`);
-    store.disposalTraces.add({ key: token.key, trace });
+}
+
+// internal/src/families/get-family-of-token.ts
+function getFamilyOfToken(store, token) {
+  if (token.family) {
+    const family = store.families.get(token.family.key);
+    if (family) {
+      return family;
+    }
   }
 }
 
@@ -1740,9 +1383,10 @@ function setIntoStore(store, ...params) {
     value = params[2];
     token = findInStore(store, family, key);
   }
-  if (`counterfeit` in token) {
+  if (`counterfeit` in token && `family` in token) {
+    const subKey = token.family.subKey;
     const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === token.key
+      (item) => item?.key === subKey
     );
     store.logger.error(
       `\u274C`,
@@ -1786,6 +1430,240 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
   }
   setIntoStore(store, token, value);
 }
+
+// internal/src/get-trace.ts
+function getTrace(error) {
+  const { stack } = error;
+  if (stack) {
+    return `
+` + stack.split(`
+`)?.slice(1)?.join(`
+`);
+  }
+  return ``;
+}
+
+// internal/src/molecule.ts
+function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
+  const molecule = {
+    key,
+    stringKey: stringifyJson(key),
+    dependsOn: `any`
+  };
+  store.molecules.set(stringifyJson(key), molecule);
+  return key;
+}
+function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
+  const origin = provenance;
+  const stringKey = stringifyJson(key);
+  const invalidKeys = [];
+  const target = newest(store);
+  if (Array.isArray(origin)) {
+    for (const formerClaim of origin) {
+      const claimString = stringifyJson(formerClaim);
+      const claim = target.molecules.get(claimString);
+      if (claim) {
+        store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+      } else {
+        invalidKeys.push(claimString);
+      }
+    }
+  } else {
+    const claimString = stringifyJson(origin);
+    const claim = target.molecules.get(claimString);
+    if (claim) {
+      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+    } else {
+      invalidKeys.push(claimString);
+    }
+  }
+  if (invalidKeys.length === 0) {
+    target.molecules.set(stringKey, { key, stringKey, dependsOn });
+  }
+  const creationEvent = {
+    type: `molecule_creation`,
+    key,
+    provenance: origin
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(creationEvent);
+  } else {
+    target.on.moleculeCreation.next(creationEvent);
+  }
+  for (const claim of invalidKeys) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === claim
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      key,
+      `allocation failed:`,
+      `Could not allocate to ${claim} in store "${store.config.name}".`,
+      disposal ? `
+   ${claim} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${claim} was found.`
+    );
+  }
+  return key;
+}
+function fuseWithinStore(store, type, sideA, sideB) {
+  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
+  const above = [sideA, sideB];
+  allocateIntoStore(
+    store,
+    above,
+    compoundKey,
+    `all`
+  );
+  return compoundKey;
+}
+function deallocateFromStore(store, claim) {
+  const stringKey = stringifyJson(claim);
+  const molecule = store.molecules.get(stringKey);
+  if (!molecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === stringKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `deallocation failed:`,
+      `Could not find allocation for ${stringKey} in store "${store.config.name}".`,
+      disposal ? `
+   This state was most recently deallocated
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
+    );
+    return;
+  }
+  const joinKeys = store.moleculeJoins.getRelatedKeys(
+    molecule.key
+  );
+  if (joinKeys) {
+    for (const joinKey of joinKeys) {
+      const join = store.joins.get(joinKey);
+      if (join) {
+        join.relations.delete(molecule.key);
+        join.molecules.delete(molecule.stringKey);
+      }
+    }
+  }
+  store.moleculeJoins.delete(molecule.stringKey);
+  const provenance = [];
+  const values = [];
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    key: molecule.key,
+    values,
+    provenance
+  };
+  const target = newest(store);
+  target.molecules.delete(stringKey);
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(disposalEvent);
+  }
+  const relatedMolecules = store.moleculeGraph.getRelationEntries({
+    downstreamMoleculeKey: molecule.stringKey
+  });
+  if (relatedMolecules) {
+    for (const [relatedStringKey, { source }] of relatedMolecules) {
+      if (source === molecule.stringKey) {
+        const relatedKey = parseJson(relatedStringKey);
+        deallocateFromStore(store, relatedKey);
+      } else {
+        provenance.push(source);
+      }
+    }
+  }
+  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
+  if (familyKeys) {
+    for (const familyKey of familyKeys) {
+      const family = target.families.get(familyKey);
+      const token = findInStore(store, family, molecule.key);
+      values.push([family.key, token]);
+      disposeFromStore(store, token);
+    }
+  }
+  target.moleculeGraph.delete(molecule.stringKey);
+  target.moleculeJoins.delete(molecule.stringKey);
+  target.moleculeData.delete(molecule.stringKey);
+  if (!isTransaction) {
+    target.on.moleculeDisposal.next(disposalEvent);
+  }
+  target.molecules.delete(molecule.stringKey);
+  const trace = getTrace(new Error());
+  store.disposalTraces.add({ key: stringKey, trace });
+}
+function claimWithinStore(store, newProvenance, claim, exclusive) {
+  const stringKey = stringifyJson(claim);
+  const target = newest(store);
+  const molecule = target.molecules.get(stringKey);
+  if (!molecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === stringKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `claim failed:`,
+      `Could not allocate to ${stringKey} in store "${store.config.name}".`,
+      disposal ? `
+   ${stringKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
+    );
+    return claim;
+  }
+  const newProvenanceKey = stringifyJson(newProvenance);
+  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
+  if (!newProvenanceMolecule) {
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === newProvenanceKey
+    );
+    store.logger.error(
+      `\u274C`,
+      `molecule`,
+      claim,
+      `claim failed:`,
+      `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
+      disposal ? `
+   ${newProvenanceKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`
+    );
+    return claim;
+  }
+  const priorProvenance = store.moleculeGraph.getRelationEntries({
+    downstreamMoleculeKey: molecule.stringKey
+  }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
+  if (exclusive) {
+    target.moleculeGraph.delete(stringKey);
+  }
+  target.moleculeGraph.set(
+    {
+      upstreamMoleculeKey: newProvenanceMolecule.stringKey,
+      downstreamMoleculeKey: molecule.stringKey
+    },
+    {
+      source: newProvenanceMolecule.stringKey
+    }
+  );
+  const transferEvent = {
+    type: `molecule_transfer`,
+    key: molecule.key,
+    from: priorProvenance,
+    to: [newProvenanceMolecule.key]
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(transferEvent);
+  }
+  return claim;
+}
+
+// internal/src/ingest-updates/ingest-creation-disposal.ts
 function ingestCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
@@ -1806,7 +1684,9 @@ function ingestDisposalEvent(update, applying, store) {
     }
     case `oldValue`: {
       createInStore(update, store);
-      store.valueMap.set(update.token.key, update.value);
+      if (update.subType === `atom`) {
+        store.valueMap.set(update.token.key, update.value);
+      }
       break;
     }
   }
@@ -1823,88 +1703,60 @@ function createInStore(update, store) {
 function ingestMoleculeCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      switch (update.subType) {
-        case `classic`:
-          makeMoleculeInStore(
-            store,
-            update.context,
-            update.family,
-            update.token.key,
-            ...update.params
-          );
-          break;
-        case `modern`:
-          allocateIntoStore(store, update.provenance, update.key);
-          break;
-      }
+      allocateIntoStore(store, update.provenance, update.key);
       break;
     case `oldValue`:
-      switch (update.subType) {
-        case `classic`:
-          disposeFromStore(store, update.token);
-          break;
-        case `modern`:
-          deallocateFromStore(store, update.key);
-          break;
-      }
+      deallocateFromStore(store, update.key);
       break;
   }
 }
 function ingestMoleculeDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      switch (update.subType) {
-        case `classic`:
-          disposeFromStore(store, update.token);
-          break;
-        case `modern`:
-          deallocateFromStore(store, update.key);
-          break;
-      }
+      deallocateFromStore(store, update.key);
       break;
     case `oldValue`:
       {
-        switch (update.subType) {
-          case `classic`:
-            {
-              const moleculeToken = makeMoleculeInStore(
-                store,
-                update.context,
-                update.family,
-                update.token.key
-              );
-              for (const [familyKey, value] of update.values) {
-                const memberKey = `${familyKey}(${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;
-          case `modern`: {
-            allocateIntoStore(
-              store,
-              update.provenance,
-              update.key
-            );
-            for (const [familyKey, value] of update.values) {
-              const family = store.families.get(familyKey);
-              if (family) {
-                findInStore(store, family, update.key);
-                const memberKey = `${familyKey}(${stringifyJson(update.key)})`;
-                store.valueMap.set(memberKey, value);
-              }
-            }
+        const provenanceJson = update.provenance.map(parseJson);
+        allocateIntoStore(store, provenanceJson, update.key);
+        for (const [familyKey, value] of update.values) {
+          const family = store.families.get(familyKey);
+          if (family) {
+            findInStore(store, family, update.key);
+            const memberKey = `${familyKey}(${stringifyJson(update.key)})`;
+            store.valueMap.set(memberKey, value);
           }
         }
       }
       break;
   }
 }
+function ingestMoleculeTransferEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      {
+        const provenance = update.to.length === 1 ? update.to[0] : update.to;
+        claimWithinStore(
+          store,
+          provenance,
+          update.key,
+          `exclusive`
+        );
+      }
+      break;
+    case `oldValue`:
+      {
+        const provenance = update.from.length === 1 ? update.from[0] : update.from;
+        claimWithinStore(
+          store,
+          provenance,
+          update.key,
+          `exclusive`
+        );
+      }
+      break;
+  }
+}
 
 // internal/src/ingest-updates/ingest-selector-update.ts
 function ingestSelectorUpdate(applying, selectorUpdate, store) {
@@ -1935,6 +1787,9 @@ function ingestTransactionUpdate(applying, transactionUpdate, store) {
       case `molecule_disposal`:
         ingestMoleculeDisposalEvent(updateFromTransaction, applying, store);
         break;
+      case `molecule_transfer`:
+        ingestMoleculeTransferEvent(updateFromTransaction, applying, store);
+        break;
       case `transaction_update`:
         ingestTransactionUpdate(applying, updateFromTransaction, store);
         break;
@@ -1955,7 +1810,7 @@ function setEpochNumberOfAction(transactionKey, newEpoch, store) {
     return;
   }
   const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
-  if (continuityKey !== void 0) {
+  if (continuityKey !== undefined) {
     store.transactionMeta.epoch.set(continuityKey, newEpoch);
   }
 }
@@ -2022,6 +1877,57 @@ function assignTransactionToContinuity(continuityKey, transactionKey, store) {
   }
 }
 
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    store
+  };
+}
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(store, ...params) {
+  let token;
+  let family;
+  let key;
+  if (params.length === 1) {
+    token = params[0];
+  } else {
+    family = params[0];
+    key = params[1];
+    token = findInStore(store, family, key);
+  }
+  if (`counterfeit` in token && `family` in token) {
+    family = store.families.get(token.family.key);
+    const subKey = token.family.subKey;
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === subKey
+    );
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `could not be retrieved because it was not found in the store "${store.config.name}".`,
+      disposal ? `This state was previously disposed:
+${disposal.trace}` : `No previous disposal trace was found.`
+    );
+    switch (family.type) {
+      case `atom_family`:
+      case `mutable_atom_family`:
+        return store.defaults.get(family.key);
+      case `selector_family`:
+      case `readonly_selector_family`: {
+        if (store.defaults.has(family.key)) {
+          return store.defaults.get(token.family.key);
+        }
+        const defaultValue = withdraw(family, store).default(subKey);
+        store.defaults.set(family.key, defaultValue);
+        return defaultValue;
+      }
+    }
+  }
+  return readOrComputeValue(withdraw(token, store), store);
+}
+
 // internal/src/lazy-map.ts
 var LazyMap = class extends Map {
   constructor(source) {
@@ -2038,7 +1944,7 @@ var LazyMap = class extends Map {
       const value = this.source.get(key);
       return value;
     }
-    return void 0;
+    return undefined;
   }
   set(key, value) {
     this.deleted.delete(key);
@@ -2069,6 +1975,7 @@ var buildTransaction = (key, params, store, id) => {
     atoms: new LazyMap(parent.atoms),
     atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
     families: new LazyMap(parent.families),
+    joins: new LazyMap(parent.joins),
     operation: { open: false },
     readonlySelectors: new LazyMap(parent.readonlySelectors),
     timelines: new LazyMap(parent.timelines),
@@ -2084,8 +1991,15 @@ var buildTransaction = (key, params, store, id) => {
     defaults: parent.defaults,
     disposalTraces: store.disposalTraces.copy(),
     molecules: new LazyMap(parent.molecules),
-    moleculeFamilies: new LazyMap(parent.moleculeFamilies),
-    moleculeInProgress: parent.moleculeInProgress,
+    moleculeGraph: new Junction(parent.moleculeGraph.toJSON(), {
+      makeContentKey: parent.moleculeGraph.makeContentKey
+    }),
+    moleculeData: new Junction(parent.moleculeData.toJSON(), {
+      makeContentKey: parent.moleculeData.makeContentKey
+    }),
+    moleculeJoins: new Junction(parent.moleculeJoins.toJSON(), {
+      makeContentKey: parent.moleculeJoins.makeContentKey
+    }),
     miscResources: new LazyMap(parent.miscResources)
   };
   const epoch = getEpochNumberOfAction(key, store);
@@ -2095,10 +2009,10 @@ var buildTransaction = (key, params, store, id) => {
       type: `transaction_update`,
       key,
       id,
-      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
+      epoch: epoch === undefined ? Number.NaN : epoch + 1,
       updates: [],
       params,
-      output: void 0
+      output: undefined
     },
     toolkit: {
       get: (...ps) => getFromStore(child, ...ps),
@@ -2109,7 +2023,6 @@ var buildTransaction = (key, params, store, id) => {
       find: (token, k) => findInStore(child, token, k),
       seek: (token, k) => seekInStore(child, token, k),
       json: (token) => getJsonToken(child, token),
-      make: (context, family, k, ...args) => makeMoleculeInStore(child, context, family, k, ...args),
       dispose: (...ps) => {
         disposeFromStore(child, ...ps);
       },
@@ -2162,18 +2075,18 @@ function createTransaction(options, store) {
 // 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;
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : undefined;
   return continuity;
 }
 function getEpochNumberOfContinuity(continuityKey, store) {
   const isRoot = isRootStore(store);
-  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : void 0;
+  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : undefined;
   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;
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : undefined;
+  const epoch = isRoot && continuity !== undefined ? store.transactionMeta.epoch.get(continuity) : undefined;
   return epoch;
 }
 
@@ -2205,6 +2118,7 @@ var Store = class {
   );
   trackers = /* @__PURE__ */ new Map();
   families = /* @__PURE__ */ new Map();
+  joins = /* @__PURE__ */ new Map();
   transactions = /* @__PURE__ */ new Map();
   transactionMeta = {
     epoch: /* @__PURE__ */ new Map(),
@@ -2220,8 +2134,33 @@ var Store = class {
   });
   disposalTraces = new CircularBuffer(100);
   molecules = /* @__PURE__ */ new Map();
-  moleculeFamilies = /* @__PURE__ */ new Map();
-  moleculeInProgress = null;
+  moleculeJoins = new Junction(
+    {
+      between: [`moleculeKey`, `joinKey`],
+      cardinality: `n:n`
+    },
+    {
+      makeContentKey: (...keys) => keys.sort().join(`:`)
+    }
+  );
+  moleculeGraph = new Junction(
+    {
+      between: [`upstreamMoleculeKey`, `downstreamMoleculeKey`],
+      cardinality: `n:n`
+    },
+    {
+      makeContentKey: (...keys) => keys.sort().join(`:`)
+    }
+  );
+  moleculeData = new Junction(
+    {
+      between: [`moleculeKey`, `stateFamilyKey`],
+      cardinality: `n:n`
+    },
+    {
+      makeContentKey: (...keys) => keys.sort().join(`:`)
+    }
+  );
   miscResources = /* @__PURE__ */ new Map();
   on = {
     atomCreation: new Subject(),
@@ -2234,8 +2173,7 @@ var Store = class {
       null
     ),
     operationClose: new Subject(),
-    moleculeCreationStart: new Subject(),
-    moleculeCreationDone: new Subject(),
+    moleculeCreation: new Subject(),
     moleculeDisposal: new Subject()
   };
   operation = { open: false };
@@ -2329,6 +2267,8 @@ var clearStore = (store) => {
   Object.assign(store, new Store(config));
   store.config = config;
 };
+
+// internal/src/store/withdraw.ts
 function withdraw(token, store) {
   let withdrawn;
   let target = store;
@@ -2356,12 +2296,6 @@ function withdraw(token, store) {
       case `transaction`:
         withdrawn = target.transactions.get(token.key);
         break;
-      case `molecule`:
-        withdrawn = target.molecules.get(stringifyJson(token.key));
-        break;
-      case `molecule_family`:
-        withdrawn = target.moleculeFamilies.get(token.key);
-        break;
     }
     if (withdrawn) {
       return withdrawn;
@@ -2399,7 +2333,7 @@ var subscribeToRootAtoms = (selector, store) => {
   const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
     (atomKey) => {
       const atom = target.atoms.get(atomKey);
-      if (atom === void 0) {
+      if (atom === undefined) {
         throw new Error(
           `Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`
         );
@@ -2532,7 +2466,7 @@ var Tracker = class {
     const familyMetaData = mutableState.family ? {
       key: `*${mutableState.family.key}`,
       subKey: mutableState.family.subKey
-    } : void 0;
+    } : undefined;
     const latestUpdateState = createRegularAtom(
       store,
       {
@@ -2872,7 +2806,7 @@ function copyMutableIfNeeded(atom, origin, target) {
   const originValue = origin.valueMap.get(atom.key);
   const targetValue = target.valueMap.get(atom.key);
   if (originValue === targetValue) {
-    if (originValue === void 0) {
+    if (originValue === undefined) {
       return typeof atom.default === `function` ? atom.default() : atom.default;
     }
     origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
@@ -3020,11 +2954,11 @@ function createRegularAtom(store, options, family) {
 function createStandaloneAtom(store, options) {
   const isMutable = `mutable` in options;
   if (isMutable) {
-    const state2 = createMutableAtom(store, options, void 0);
+    const state2 = createMutableAtom(store, options, undefined);
     store.on.atomCreation.next(state2);
     return state2;
   }
-  const state = createRegularAtom(store, options, void 0);
+  const state = createRegularAtom(store, options, undefined);
   store.on.atomCreation.next(state);
   return state;
 }
@@ -3032,23 +2966,22 @@ function createStandaloneAtom(store, options) {
 // internal/src/atom/dispose-atom.ts
 function disposeAtom(atomToken, store) {
   const target = newest(store);
-  const { key } = atomToken;
+  const { key, family } = atomToken;
   const atom = withdraw(atomToken, target);
-  if (!atom.family) {
+  if (!family) {
     store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
     atom.cleanup?.();
     const lastValue = store.valueMap.get(atom.key);
-    const family = withdraw({ key: atom.family.key, type: `atom_family` }, store);
-    family.subject.next({
+    const atomFamily = withdraw({ key: family.key, type: `atom_family` }, store);
+    const disposal = {
       type: `state_disposal`,
+      subType: `atom`,
       token: atomToken,
       value: lastValue
-    });
-    const molecule = target.molecules.get(atom.family.subKey);
-    if (molecule) {
-      molecule.tokens.delete(key);
-    }
+    };
+    atomFamily.subject.next(disposal);
+    const isChild = isChildStore(target);
     target.atoms.delete(key);
     target.valueMap.delete(key);
     target.selectorAtoms.delete(key);
@@ -3060,16 +2993,20 @@ function disposeAtom(atomToken, store) {
       store.trackers.delete(key);
     }
     store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
-    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
-      target.transactionMeta.update.updates.push({
-        type: `state_disposal`,
-        token: atomToken
-      });
+    if (isChild && target.transactionMeta.phase === `building`) {
+      const mostRecentUpdate = target.transactionMeta.update.updates.at(-1);
+      const wasMoleculeDisposal = mostRecentUpdate?.type === `molecule_disposal`;
+      const updateAlreadyCaptured = wasMoleculeDisposal && mostRecentUpdate.values.some(([k]) => k === atom.family?.key);
+      if (!updateAlreadyCaptured) {
+        target.transactionMeta.update.updates.push(disposal);
+      }
     } else {
       store.on.atomDisposal.next(atomToken);
     }
   }
 }
+
+// internal/src/timeline/create-timeline.ts
 function createTimeline(options, store, data) {
   const tl = {
     type: `timeline`,
@@ -3140,23 +3077,6 @@ function createTimeline(options, store, data) {
           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);
@@ -3180,109 +3100,112 @@ function addAtomToTimeline(atomToken, tl, store) {
   );
   tl.subscriptions.set(
     atom.key,
-    atom.subject.subscribe(`timeline`, (update) => {
-      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 txUpdateInProgress = target.on.transactionApplying.state?.update;
-      store.logger.info(
-        `\u23F3`,
-        `timeline`,
-        tl.key,
-        `atom`,
-        atomToken.key,
-        `went`,
-        update.oldValue,
-        `->`,
-        update.newValue,
-        txUpdateInProgress ? `in transaction "${txUpdateInProgress.key}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
-      );
-      if (tl.timeTraveling === null) {
-        if (txUpdateInProgress) {
-          joinTransaction(tl, txUpdateInProgress, store);
-        } else if (currentSelectorKey && currentSelectorTime) {
-          let latestUpdate = tl.history.at(-1);
-          if (currentSelectorTime !== tl.selectorTime) {
-            latestUpdate = {
-              type: `selector_update`,
-              timestamp: currentSelectorTime,
-              key: currentSelectorKey,
-              atomUpdates: []
-            };
-            latestUpdate.atomUpdates.push({
-              key: atom.key,
-              type: `atom_update`,
-              ...update
-            });
-            if (tl.at !== tl.history.length) {
-              tl.history.splice(tl.at);
-            }
-            tl.history.push(latestUpdate);
-            store.logger.info(
-              `\u231B`,
-              `timeline`,
-              tl.key,
-              `got a selector_update "${currentSelectorKey}" with`,
-              latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-            );
-            tl.at = tl.history.length;
-            tl.selectorTime = currentSelectorTime;
-          } else {
-            if (latestUpdate?.type === `selector_update`) {
+    atom.subject.subscribe(
+      `timeline`,
+      function timelineCapturesAtomUpdate(update) {
+        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 txUpdateInProgress = target.on.transactionApplying.state?.update;
+        store.logger.info(
+          `\u23F3`,
+          `timeline`,
+          tl.key,
+          `atom`,
+          atomToken.key,
+          `went`,
+          update.oldValue,
+          `->`,
+          update.newValue,
+          txUpdateInProgress ? `in transaction "${txUpdateInProgress.key}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
+        );
+        if (tl.timeTraveling === null) {
+          if (txUpdateInProgress) {
+            joinTransaction(tl, txUpdateInProgress, store);
+          } else if (currentSelectorKey && currentSelectorTime) {
+            let latestUpdate = tl.history.at(-1);
+            if (currentSelectorTime !== tl.selectorTime) {
+              latestUpdate = {
+                type: `selector_update`,
+                timestamp: currentSelectorTime,
+                key: currentSelectorKey,
+                atomUpdates: []
+              };
               latestUpdate.atomUpdates.push({
                 key: atom.key,
                 type: `atom_update`,
                 ...update
               });
+              if (tl.at !== tl.history.length) {
+                tl.history.splice(tl.at);
+              }
+              tl.history.push(latestUpdate);
               store.logger.info(
                 `\u231B`,
                 `timeline`,
                 tl.key,
-                `set selector_update "${currentSelectorKey}" to`,
-                latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key)
+                `got a selector_update "${currentSelectorKey}" with`,
+                latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
               );
-            }
-          }
-          if (latestUpdate) {
-            const willCaptureSelectorUpdate = tl.shouldCapture?.(latestUpdate, tl) ?? true;
-            if (willCaptureSelectorUpdate) {
-              tl.subject.next(latestUpdate);
+              tl.at = tl.history.length;
+              tl.selectorTime = currentSelectorTime;
             } else {
-              tl.history.pop();
+              if (latestUpdate?.type === `selector_update`) {
+                latestUpdate.atomUpdates.push({
+                  key: atom.key,
+                  type: `atom_update`,
+                  ...update
+                });
+                store.logger.info(
+                  `\u231B`,
+                  `timeline`,
+                  tl.key,
+                  `set selector_update "${currentSelectorKey}" to`,
+                  latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key)
+                );
+              }
+            }
+            if (latestUpdate) {
+              const willCaptureSelectorUpdate = tl.shouldCapture?.(latestUpdate, tl) ?? true;
+              if (willCaptureSelectorUpdate) {
+                tl.subject.next(latestUpdate);
+              } else {
+                tl.history.pop();
+                tl.at = tl.history.length;
+              }
+            }
+          } else {
+            const timestamp = Date.now();
+            tl.selectorTime = null;
+            if (tl.at !== tl.history.length) {
+              tl.history.splice(tl.at);
+            }
+            const atomUpdate = {
+              type: `atom_update`,
+              timestamp,
+              key: atom.key,
+              oldValue: update.oldValue,
+              newValue: update.newValue
+            };
+            if (atom.family) {
+              atomUpdate.family = atom.family;
+            }
+            const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
+            store.logger.info(
+              `\u231B`,
+              `timeline`,
+              tl.key,
+              `got an atom_update to "${atom.key}"`
+            );
+            if (willCapture) {
+              tl.history.push(atomUpdate);
               tl.at = tl.history.length;
+              tl.subject.next(atomUpdate);
             }
           }
-        } else {
-          const timestamp = Date.now();
-          tl.selectorTime = null;
-          if (tl.at !== tl.history.length) {
-            tl.history.splice(tl.at);
-          }
-          const atomUpdate = {
-            type: `atom_update`,
-            timestamp,
-            key: atom.key,
-            oldValue: update.oldValue,
-            newValue: update.newValue
-          };
-          if (atom.family) {
-            atomUpdate.family = atom.family;
-          }
-          const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
-          store.logger.info(
-            `\u231B`,
-            `timeline`,
-            tl.key,
-            `got an atom_update to "${atom.key}"`
-          );
-          if (willCapture) {
-            tl.history.push(atomUpdate);
-            tl.at = tl.history.length;
-            tl.subject.next(atomUpdate);
-          }
         }
       }
-    })
+    )
   );
 }
 function addAtomFamilyToTimeline(atomFamilyToken, tl, store) {
@@ -3293,9 +3216,12 @@ function addAtomFamilyToTimeline(atomFamilyToken, tl, store) {
   );
   tl.subscriptions.set(
     family.key,
-    family.subject.subscribe(`timeline`, (creationOrDisposal) => {
-      handleStateLifecycleEvent(creationOrDisposal, tl, store);
-    })
+    family.subject.subscribe(
+      `timeline`,
+      function timelineCapturesStateLifecycleEvent(creationOrDisposal) {
+        handleStateLifecycleEvent(creationOrDisposal, tl, store);
+      }
+    )
   );
   for (const atom of store.atoms.values()) {
     if (atom.family?.key === family.key) {
@@ -3303,99 +3229,6 @@ function addAtomFamilyToTimeline(atomFamilyToken, 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) => {
-        store.logger.info(
-          `\u{1F41E}`,
-          `timeline`,
-          tl.key,
-          `got a molecule creation or disposal`,
-          creationOrDisposal
-        );
-        if (creationOrDisposal.subType === `classic`) {
-          switch (creationOrDisposal.type) {
-            case `molecule_creation`:
-              {
-                store.timelineTopics.set(
-                  {
-                    topicKey: creationOrDisposal.token.key,
-                    timelineKey: tl.key
-                  },
-                  { topicType: `molecule` }
-                );
-                const txUpdateInProgress = newest(store).on.transactionApplying.state?.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 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
-                      );
-                    }
-                  )
-                );
-              }
-              break;
-            case `molecule_disposal`:
-              {
-                const txUpdateInProgress = newest(store).on.transactionApplying.state?.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 = stringifyJson(creationOrDisposal.token.key);
-                tl.subscriptions.get(moleculeKey)?.();
-                tl.subscriptions.delete(moleculeKey);
-                for (const [familyKey] of creationOrDisposal.values) {
-                  const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`;
-                  tl.subscriptions.get(stateKey)?.();
-                  tl.subscriptions.delete(stateKey);
-                  store.timelineTopics.delete(stateKey);
-                }
-              }
-              break;
-          }
-        }
-      })
-    );
-  }
-}
 function joinTransaction(tl, txUpdateInProgress, store) {
   const currentTxKey = txUpdateInProgress.key;
   const currentTxInstanceId = txUpdateInProgress.id;
@@ -3451,14 +3284,9 @@ function filterTransactionUpdates(updates, timelineTopics) {
         break;
       case `molecule_creation`:
       case `molecule_disposal`:
-        switch (updateFromTx.subType) {
-          case `classic`:
-            key = updateFromTx.token.key;
-            break;
-          case `modern`:
-            return true;
-        }
-        break;
+      case `molecule_transfer`:
+        return true;
+      // always include
       default:
         key = updateFromTx.key;
         familyKey = updateFromTx.family?.key;
@@ -3565,14 +3393,6 @@ var timeTravel = (store, action, token) => {
       ingestDisposalEvent(update, applying, store);
       break;
     }
-    case `molecule_creation`: {
-      ingestMoleculeCreationEvent(update, applying, store);
-      break;
-    }
-    case `molecule_disposal`: {
-      ingestMoleculeDisposalEvent(update, applying, store);
-      break;
-    }
   }
   if (action === `redo`) {
     ++timelineData.at;
@@ -3587,4 +3407,4 @@ var timeTravel = (store, action, token) => {
   );
 };
 
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };