flightdeck 0.2.15 → 0.2.17

package/dist/{chunk-XIZZKICH.js → chunk-7KMVUPT3.js}

@@ -218,9 +218,8 @@ function createReadonlySelectorFamily(store, options, internalRoles) {
     default: (key) => {
       const getFn = options.get(key);
       return getFn({
-        get: (...ps) => getFromStore(store, ...ps),
-        find: (token, k) => findInStore(store, token, k),
-        seek: (token, k) => seekInStore(store, token, k),
+        get: (...args) => getFromStore(store, ...args),
+        find: (...args) => findInStore(store, ...args),
         json: (token) => getJsonToken(store, token)
       });
     }
@@ -306,976 +305,938 @@ function deposit(state) {
   return token;
 }
 
-// ../atom.io/src/molecule.ts
-function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
-  const molecule = {
-    key,
-    stringKey: stringifyJson(key),
-    dependsOn: `any`
+// ../atom.io/src/atom.ts
+function atom(options) {
+  return createStandaloneAtom(IMPLICIT.STORE, options);
+}
+function atomFamily(options) {
+  return createAtomFamily(IMPLICIT.STORE, options);
+}
+
+// ../atom.io/src/join.ts
+function join(options, defaultContent, store = IMPLICIT.STORE) {
+  store.joins.set(options.key, new Join(options, defaultContent, store));
+  const token = {
+    key: options.key,
+    type: `join`,
+    a: options.between[0],
+    b: options.between[1],
+    cardinality: options.cardinality
   };
-  store.molecules.set(stringifyJson(key), molecule);
-  return key;
+  return token;
 }
-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);
-      }
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+
+// ../atom.io/src/logger.ts
+var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
+  console[logLevel](
+    `${icon} ${denomination} "${tokenKey}" ${message}`,
+    ...rest
+  );
+};
+var simpleLogger = {
+  error: simpleLog(`error`),
+  info: simpleLog(`info`),
+  warn: simpleLog(`warn`)
+};
+var AtomIOLogger = class {
+  constructor(logLevel, filter, logger = simpleLogger) {
+    this.logLevel = logLevel;
+    this.filter = filter;
+    this.logger = logger;
+  }
+  error = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel !== null) {
+      this.logger.error(...args);
     }
-  } else {
-    const claimString = stringifyJson(origin);
-    const claim = target.molecules.get(claimString);
-    if (claim) {
-      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-    } else {
-      invalidKeys.push(claimString);
+  };
+  info = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel === `info`) {
+      this.logger.info(...args);
     }
-  }
-  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);
+  warn = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel !== `error` && this.logLevel !== null) {
+      this.logger.warn(...args);
+    }
+  };
+};
+var Realm = class {
+  store;
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    makeRootMoleculeInStore(`root`, store);
   }
-  for (const claim of invalidKeys) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === claim
+  allocate(provenance, key, attachmentStyle) {
+    return allocateIntoStore(
+      this.store,
+      provenance,
+      key,
+      attachmentStyle
     );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
+  }
+  fuse(type, reagentA, reagentB) {
+    return fuseWithinStore(this.store, type, reagentA, reagentB);
+  }
+  deallocate(claim) {
+    deallocateFromStore(this.store, claim);
+  }
+  claim(newProvenance, claim, exclusive) {
+    return claimWithinStore(this.store, newProvenance, claim, exclusive);
+  }
+};
+var Anarchy = class {
+  store;
+  realm;
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    this.realm = new Realm(store);
+  }
+  allocate(provenance, key, attachmentStyle) {
+    allocateIntoStore(
+      this.store,
+      provenance,
       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.`
+      attachmentStyle
     );
   }
-  return key;
+  deallocate(key) {
+    deallocateFromStore(this.store, key);
+  }
+  claim(newProvenance, key, exclusive) {
+    claimWithinStore(this.store, newProvenance, key, exclusive);
+  }
+};
+
+// ../atom.io/src/selector.ts
+function selectorFamily(options) {
+  return createSelectorFamily(IMPLICIT.STORE, options);
 }
-function fuseWithinStore(store, type, sideA, sideB) {
-  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
-  const above = [sideA, sideB];
-  allocateIntoStore(
-    store,
-    above,
-    compoundKey,
-    `all`
-  );
-  return compoundKey;
+
+// ../atom.io/internal/src/transaction/is-root-store.ts
+function isRootStore(store) {
+  return `epoch` in store.transactionMeta;
 }
-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.`
+function isChildStore(store) {
+  return `phase` in store.transactionMeta;
+}
+
+// ../atom.io/internal/src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  const target = newest(store);
+  if (!isChildStore(target)) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
     );
     return;
   }
-  const joinKeys = store.moleculeJoins.getRelatedKeys(
-    molecule.key
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
   );
-  if (joinKeys) {
-    for (const joinKey of joinKeys) {
-      const join2 = store.joins.get(joinKey);
-      if (join2) {
-        join2.relations.delete(molecule.key);
-        join2.molecules.delete(molecule.stringKey);
-      }
-    }
+  target.parent.child = null;
+};
+
+// ../atom.io/internal/src/capitalize.ts
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+
+// ../atom.io/internal/src/pretty-print.ts
+function prettyPrintTokenType(token) {
+  return token.type.split(`_`).map(capitalize).join(` `);
+}
+
+// ../atom.io/internal/src/not-found-error.ts
+var NotFoundError = class extends Error {
+  constructor(token, store) {
+    super(
+      `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
+    );
   }
-  store.moleculeJoins.delete(molecule.stringKey);
-  const provenance = [];
-  const values = [];
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    key: molecule.key,
-    values,
-    provenance
+};
+
+// ../atom.io/internal/src/transaction/act-upon-store.ts
+function actUponStore(store, token, id) {
+  return (...parameters) => {
+    const tx = withdraw(store, token);
+    if (tx) {
+      return tx.run(parameters, id);
+    }
+    throw new NotFoundError(token, store);
   };
-  const target = newest(store);
-  target.molecules.delete(stringKey);
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(disposalEvent);
+}
+
+// ../atom.io/internal/src/set-state/become.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
+
+// ../atom.io/internal/src/get-state/read-or-compute-value.ts
+var readOrComputeValue = (target, state) => {
+  if (target.valueMap.has(state.key)) {
+    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
+    return readCachedValue(state, target);
   }
-  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);
-    }
+  if (state.type === `selector` || state.type === `readonly_selector`) {
+    target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
+    return state.get();
   }
-  target.moleculeGraph.delete(molecule.stringKey);
-  target.moleculeJoins.delete(molecule.stringKey);
-  target.moleculeData.delete(molecule.stringKey);
-  if (!isTransaction) {
-    target.on.moleculeDisposal.next(disposalEvent);
+  const fallback = state.default instanceof Function ? state.default() : state.default;
+  target.logger.info(
+    `\u{1F481}`,
+    `atom`,
+    state.key,
+    `could not find cached value; using default`,
+    fallback
+  );
+  return state.default instanceof Function ? state.default() : state.default;
+};
+
+// ../atom.io/internal/src/operation.ts
+var openOperation = (store, token) => {
+  if (store.operation.open) {
+    const rejectionTime = performance.now();
+    store.logger.info(
+      `\u2757`,
+      token.type,
+      token.key,
+      `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`
+    );
+    return rejectionTime;
   }
-  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.operation = {
+    open: true,
+    done: /* @__PURE__ */ new Set(),
+    prev: /* @__PURE__ */ new Map(),
+    time: Date.now(),
+    token
+  };
+  store.logger.info(
+    `\u2B55`,
+    token.type,
+    token.key,
+    `operation start in store "${store.config.name}"${!isChildStore(store) ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
+  );
+};
+var closeOperation = (store) => {
+  if (store.operation.open) {
+    store.logger.info(
+      `\u{1F534}`,
+      store.operation.token.type,
+      store.operation.token.key,
+      `operation done in store "${store.config.name}"`
     );
+  }
+  store.operation = { open: false };
+  store.on.operationClose.next(store.operation);
+};
+var isDone = (store, key) => {
+  if (!store.operation.open) {
     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.`
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `isDone called outside of an operation. This is probably a bug in AtomIO.`
     );
-    return claim;
+    return true;
   }
-  const newProvenanceKey = stringifyJson(newProvenance);
-  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
-  if (!newProvenanceMolecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === newProvenanceKey
-    );
+  return store.operation.done.has(key);
+};
+var markDone = (store, key) => {
+  if (!store.operation.open) {
     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.`
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `markDone called outside of an operation. This is probably a bug in AtomIO.`
     );
-    return claim;
+    return;
   }
-  const priorProvenance = store.moleculeGraph.getRelationEntries({
-    downstreamMoleculeKey: molecule.stringKey
-  }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
-  if (exclusive) {
-    target.moleculeGraph.delete(stringKey);
+  store.operation.done.add(key);
+};
+
+// ../atom.io/internal/src/set-state/emit-update.ts
+var emitUpdate = (store, state, update) => {
+  switch (state.type) {
+    case `mutable_atom`:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `is now (`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+      break;
+    default:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `went (`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
   }
-  target.moleculeGraph.set(
-    {
-      upstreamMoleculeKey: newProvenanceMolecule.stringKey,
-      downstreamMoleculeKey: molecule.stringKey
-    },
-    {
-      source: newProvenanceMolecule.stringKey
-    }
+  state.subject.next(update);
+};
+
+// ../atom.io/internal/src/set-state/evict-downstream.ts
+var evictDownStream = (store, atom2) => {
+  const target = newest(store);
+  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom2.key);
+  target.logger.info(
+    `\u{1F9F9}`,
+    atom2.type,
+    atom2.key,
+    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
+    downstreamKeys ?? `to evict`
   );
-  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);
+  if (downstreamKeys) {
+    if (target.operation.open) {
+      target.logger.info(
+        `\u{1F9F9}`,
+        atom2.type,
+        atom2.key,
+        `[ ${[...target.operation.done].join(`, `)} ] already done`
+      );
+    }
+    for (const key of downstreamKeys) {
+      if (isDone(target, key)) {
+        continue;
+      }
+      evictCachedValue(key, target);
+      markDone(target, key);
+    }
   }
-  return claim;
-}
-var Realm = class {
-  store;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    makeRootMoleculeInStore(`root`, store);
+};
+
+// ../atom.io/internal/src/set-state/stow-update.ts
+function shouldUpdateBeStowed(key, update) {
+  if (isTransceiver(update.newValue)) {
+    return false;
   }
-  allocate(provenance, key, attachmentStyle) {
-    return allocateIntoStore(
-      this.store,
-      provenance,
+  if (key.includes(`\u{1F50D}`)) {
+    return false;
+  }
+  return true;
+}
+var stowUpdate = (store, state, update) => {
+  const { key } = state;
+  const target = newest(store);
+  if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
+    store.logger.error(
+      `\u{1F41E}`,
+      `atom`,
       key,
-      attachmentStyle
+      `stowUpdate called outside of a transaction. This is probably a bug.`
     );
+    return;
   }
-  fuse(type, reagentA, reagentB) {
-    return fuseWithinStore(this.store, type, reagentA, reagentB);
-  }
-  deallocate(claim) {
-    deallocateFromStore(this.store, claim);
+  const shouldStow = shouldUpdateBeStowed(key, update);
+  if (!shouldStow) {
+    return;
   }
-  claim(newProvenance, claim, exclusive) {
-    return claimWithinStore(this.store, newProvenance, claim, exclusive);
+  const atomUpdate = {
+    type: `atom_update`,
+    key,
+    ...update
+  };
+  if (state.family) {
+    atomUpdate.family = state.family;
   }
-};
-var Anarchy = class {
-  store;
-  realm;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    this.realm = new Realm(store);
+  target.transactionMeta.update.updates.push(atomUpdate);
+  store.logger.info(
+    `\u{1F4C1}`,
+    `atom`,
+    key,
+    `stowed (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `)`
+  );
+};
+
+// ../atom.io/internal/src/set-state/set-atom.ts
+var setAtom = (atom2, next, target) => {
+  const oldValue = readOrComputeValue(target, atom2);
+  let newValue = oldValue;
+  if (atom2.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(target, atom2, parent);
+    newValue = copiedValue;
   }
-  allocate(provenance, key, attachmentStyle) {
-    allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
+  newValue = become(next)(newValue);
+  target.logger.info(`\u{1F4DD}`, `atom`, atom2.key, `set to`, newValue);
+  newValue = cacheValue(target, atom2.key, newValue, atom2.subject);
+  if (isAtomDefault(target, atom2.key)) {
+    markAtomAsNotDefault(target, atom2.key);
   }
-  deallocate(key) {
-    deallocateFromStore(this.store, key);
+  markDone(target, atom2.key);
+  evictDownStream(target, atom2);
+  const update = { oldValue, newValue };
+  if (isRootStore(target)) {
+    emitUpdate(target, atom2, update);
+  } else if (target.parent) {
+    if (target.on.transactionApplying.state === null) {
+      stowUpdate(target, atom2, update);
+    } else if (atom2.key.startsWith(`*`)) {
+      const mutableKey = atom2.key.slice(1);
+      const mutableAtom = target.atoms.get(mutableKey);
+      let transceiver = target.valueMap.get(mutableKey);
+      if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
+        const { parent } = target;
+        const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent);
+        transceiver = copiedValue;
+      }
+      const accepted = transceiver.do(update.newValue) === null;
+      if (accepted) evictDownStream(target, mutableAtom);
+    }
   }
-  claim(newProvenance, key, exclusive) {
-    claimWithinStore(this.store, newProvenance, key, exclusive);
+};
+
+// ../atom.io/internal/src/set-state/set-atom-or-selector.ts
+var setAtomOrSelector = (store, state, value) => {
+  switch (state.type) {
+    case `atom`:
+    case `mutable_atom`:
+      setAtom(state, value, store);
+      break;
+    case `selector`:
+      state.set(value);
+      break;
   }
 };
 
-// ../atom.io/src/atom.ts
-function atom(options) {
-  return createStandaloneAtom(IMPLICIT.STORE, options);
-}
-function atomFamily(options) {
-  return createAtomFamily(IMPLICIT.STORE, options);
+// ../atom.io/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;
+    }
+  }
 }
 
-// ../atom.io/src/logger.ts
-var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
-  console[logLevel](
-    `${icon} ${denomination} "${tokenKey}" ${message}`,
-    ...rest
-  );
-};
-var simpleLogger = {
-  error: simpleLog(`error`),
-  info: simpleLog(`info`),
-  warn: simpleLog(`warn`)
-};
-var AtomIOLogger = class {
-  constructor(logLevel, filter, logger = simpleLogger) {
-    this.logLevel = logLevel;
-    this.filter = filter;
-    this.logger = logger;
-  }
-  error = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel !== null) {
-      this.logger.error(...args);
-    }
-  };
-  info = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel === `info`) {
-      this.logger.info(...args);
-    }
-  };
-  warn = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel !== `error` && this.logLevel !== null) {
-      this.logger.warn(...args);
+// ../atom.io/internal/src/set-state/set-into-store.ts
+function setIntoStore(store, ...params) {
+  let token;
+  let family;
+  let key;
+  let value;
+  if (params.length === 2) {
+    token = params[0];
+    value = params[1];
+    family = getFamilyOfToken(store, token) ?? null;
+    if (family) {
+      key = token.family ? parseJson(token.family.subKey) : null;
+      token = findInStore(store, family, key);
     }
-  };
-};
-
-// ../atom.io/src/selector.ts
-function selectorFamily(options) {
-  return createSelectorFamily(IMPLICIT.STORE, options);
+  } else {
+    family = params[0];
+    key = params[1];
+    value = params[2];
+    token = findInStore(store, family, key);
+  }
+  if (`counterfeit` in token && `family` in token) {
+    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 set 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.`
+    );
+    return;
+  }
+  const rejectionTime = openOperation(store, token);
+  if (rejectionTime) {
+    const unsubscribe = store.on.operationClose.subscribe(
+      `waiting to set "${token.key}" at T-${rejectionTime}`,
+      () => {
+        unsubscribe();
+        store.logger.info(
+          `\u{1F7E2}`,
+          token.type,
+          token.key,
+          `resuming deferred setState from T-${rejectionTime}`
+        );
+        setIntoStore(store, token, value);
+      }
+    );
+    return;
+  }
+  const state = withdraw(store, token);
+  setAtomOrSelector(store, state, value);
+  closeOperation(store);
 }
 
-// ../atom.io/src/transaction.ts
-function transaction(options) {
-  return createTransaction(options, IMPLICIT.STORE);
+// ../atom.io/internal/src/ingest-updates/ingest-atom-update.ts
+function ingestAtomUpdate(applying, atomUpdate, store) {
+  const { key, newValue, oldValue } = atomUpdate;
+  const value = newValue ;
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(store, token, value);
 }
 
-// ../atom.io/internal/src/junction.ts
-var Junction = class {
-  a;
-  b;
-  cardinality;
-  relations = /* @__PURE__ */ new Map();
-  contents = /* @__PURE__ */ new Map();
-  isAType;
-  isBType;
-  isContent;
-  makeContentKey = (a, b) => `${a}:${b}`;
-  warn;
-  getRelatedKeys(key) {
-    return this.relations.get(key);
+// ../atom.io/internal/src/get-trace.ts
+function getTrace(error) {
+  const { stack } = error;
+  if (stack) {
+    return `
+` + stack.split(`
+`)?.slice(1)?.join(`
+`);
   }
-  addRelation(a, b) {
-    let aRelations = this.relations.get(a);
-    let bRelations = this.relations.get(b);
-    if (aRelations) {
-      aRelations.add(b);
-    } else {
-      aRelations = /* @__PURE__ */ new Set([b]);
-      this.relations.set(a, aRelations);
+  return ``;
+}
+
+// ../atom.io/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);
+      }
     }
-    if (bRelations) {
-      bRelations.add(a);
+  } else {
+    const claimString = stringifyJson(origin);
+    const claim = target.molecules.get(claimString);
+    if (claim) {
+      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
     } else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  deleteRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    if (aRelations) {
-      aRelations.delete(b);
-      if (aRelations.size === 0) {
-        this.relations.delete(a);
-      }
-      const bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.delete(a);
-        if (bRelations.size === 0) {
-          this.relations.delete(b);
-        }
-      }
+      invalidKeys.push(claimString);
     }
   }
-  replaceRelationsUnsafely(x, ys) {
-    this.relations.set(x, new Set(ys));
-    for (const y of ys) {
-      const yRelations = (/* @__PURE__ */ new Set()).add(x);
-      this.relations.set(y, yRelations);
-    }
-  }
-  replaceRelationsSafely(x, ys) {
-    const xRelationsPrev = this.relations.get(x);
-    let a = this.isAType?.(x) ? x : undefined;
-    let b = a === undefined ? x : undefined;
-    if (xRelationsPrev) {
-      for (const y of xRelationsPrev) {
-        a ??= y;
-        b ??= y;
-        const yRelations = this.relations.get(y);
-        if (yRelations) {
-          if (yRelations.size === 1) {
-            this.relations.delete(y);
-          } else {
-            yRelations.delete(x);
-          }
-          this.contents.delete(this.makeContentKey(a, b));
-        }
-      }
-    }
-    this.relations.set(x, new Set(ys));
-    for (const y of ys) {
-      let yRelations = this.relations.get(y);
-      if (yRelations) {
-        yRelations.add(x);
-      } else {
-        yRelations = (/* @__PURE__ */ new Set()).add(x);
-        this.relations.set(y, yRelations);
-      }
-    }
+  if (invalidKeys.length === 0) {
+    target.molecules.set(stringKey, { key, stringKey, dependsOn });
   }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
+  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);
   }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
+  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.`
+    );
   }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
+  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;
   }
-  constructor(data, config) {
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    if (!config?.externalStore) {
-      this.relations = new Map(
-        data.relations?.map(([x, ys]) => [x, new Set(ys)])
-      );
-      this.contents = new Map(data.contents);
-    }
-    this.isAType = config?.isAType ?? null;
-    this.isBType = config?.isBType ?? null;
-    this.isContent = config?.isContent ?? null;
-    if (config?.makeContentKey) {
-      this.makeContentKey = config.makeContentKey;
-    }
-    if (config?.externalStore) {
-      const externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(
-        key
-      );
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of data.relations ?? []) {
-        let a = this.isAType?.(x) ? x : undefined;
-        let b = a === undefined ? x : undefined;
-        for (const y of ys) {
-          a ??= y;
-          b ??= y;
-          this.addRelation(a, b);
-        }
-      }
-      for (const [contentKey, content] of data.contents ?? []) {
-        this.setContent(contentKey, content);
+  const joinKeys = store.moleculeJoins.getRelatedKeys(
+    molecule.key
+  );
+  if (joinKeys) {
+    for (const joinKey of joinKeys) {
+      const join2 = store.joins.get(joinKey);
+      if (join2) {
+        join2.relations.delete(molecule.key);
+        join2.molecules.delete(molecule.stringKey);
       }
     }
-    if (config?.warn) {
-      this.warn = config.warn;
-    }
   }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(
-        ([a, b]) => [a, [...b]]
-      ),
-      contents: [...this.contents.entries()]
-    };
+  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);
   }
-  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`: {
-        const bPrev = this.getRelatedKey(a);
-        if (bPrev && bPrev !== b) this.delete(a, bPrev);
-      }
-      case `1:n`: {
-        const aPrev = this.getRelatedKey(b);
-        if (aPrev && aPrev !== a) this.delete(aPrev, b);
+  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);
       }
     }
-    if (content) {
-      const contentKey = this.makeContentKey(a, b);
-      this.setContent(contentKey, content);
+  }
+  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);
     }
-    this.addRelation(a, b);
-    return this;
   }
-  delete(x, b) {
-    b = typeof b === `string` ? b : x[this.b];
-    const a = (
-      // @ts-expect-error we deduce that this.a may index x
-      typeof x === `string` ? x : x[this.a]
+  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
     );
-    if (a === undefined && typeof b === `string`) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        for (const bRelation of bRelations) {
-          this.delete(bRelation, b);
-        }
-      }
-    }
-    if (typeof a === `string` && b === undefined) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        for (const aRelation of aRelations) {
-          this.delete(a, aRelation);
-        }
-      }
-    }
-    if (typeof a === `string` && typeof b === `string`) {
-      this.deleteRelation(a, b);
-      const contentKey = this.makeContentKey(a, b);
-      this.deleteContent(contentKey);
-    }
-    return this;
+    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;
   }
-  getRelatedKey(key) {
-    const relations = this.getRelatedKeys(key);
-    if (relations) {
-      if (relations.size > 1) {
-        this.warn?.(
-          `${relations.size} related keys were found for key "${key}": (${[
-            ...relations
-          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
-        );
-      }
-      let singleRelation;
-      for (const relation of relations) {
-        singleRelation = relation;
-        break;
-      }
-      return singleRelation;
+  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);
   }
-  replaceRelations(x, relations, config) {
-    const hasContent = !Array.isArray(relations);
-    const ys = hasContent ? Object.keys(relations) : relations;
-    if (config?.reckless) {
-      this.replaceRelationsUnsafely(x, ys);
-    } else {
-      this.replaceRelationsSafely(x, ys);
+  return claim;
+}
+
+// ../atom.io/internal/src/ingest-updates/ingest-creation-disposal.ts
+function ingestCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`: {
+      createInStore(update, store);
+      break;
     }
-    if (hasContent) {
-      for (const y of ys) {
-        const contentKey = this.makeContentKey(x, y);
-        const content = relations[y];
-        this.setContent(contentKey, content);
-      }
+    case `oldValue`: {
+      disposeFromStore(store, update.token);
+      break;
     }
-    return this;
-  }
-  getContent(a, b) {
-    const contentKey = this.makeContentKey(a, b);
-    return this.getContentInternal(contentKey);
   }
-  getRelationEntries(input) {
-    const a = input[this.a];
-    const b = input[this.b];
-    if (a !== undefined && b === undefined) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        return [...aRelations].map((aRelation) => {
-          return [aRelation, this.getContent(a, aRelation)];
-        });
-      }
+}
+function ingestDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`: {
+      disposeFromStore(store, update.token);
+      break;
     }
-    if (a === undefined && b !== undefined) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        return [...bRelations].map((bRelation) => {
-          return [bRelation, this.getContent(bRelation, b)];
-        });
+    case `oldValue`: {
+      createInStore(update, store);
+      if (update.subType === `atom`) {
+        store.valueMap.set(update.token.key, update.value);
       }
+      break;
     }
-    return [];
   }
-  has(a, b) {
-    if (b) {
-      const setA = this.getRelatedKeys(a);
-      return setA?.has(b) ?? false;
+}
+function createInStore(update, store) {
+  const { family: familyMeta } = update.token;
+  if (familyMeta) {
+    const family = store.families.get(familyMeta.key);
+    if (family) {
+      findInStore(store, family, parseJson(familyMeta.subKey));
     }
-    return this.relations.has(a);
   }
-};
-
-// ../atom.io/internal/src/transaction/is-root-store.ts
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
-}
-function isChildStore(store) {
-  return `phase` in store.transactionMeta;
 }
-
-// ../atom.io/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;
+function ingestMoleculeCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      allocateIntoStore(store, update.provenance, update.key);
+      break;
+    case `oldValue`:
+      deallocateFromStore(store, update.key);
+      break;
   }
-  store.logger.info(
-    `\u{1FA82}`,
-    `transaction`,
-    target.transactionMeta.update.key,
-    `Aborting transaction`
-  );
-  target.parent.child = null;
-};
-
-// ../atom.io/internal/src/pretty-print.ts
-var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
-function prettyPrintTokenType(token) {
-  return token.type.split(`_`).map(capitalize).join(` `);
 }
-
-// ../atom.io/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}".`
-      );
-    }
+function ingestMoleculeDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      deallocateFromStore(store, update.key);
+      break;
+    case `oldValue`:
+      {
+        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;
   }
-};
-
-// ../atom.io/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);
-  };
 }
-
-// ../atom.io/internal/src/set-state/become.ts
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
-
-// ../atom.io/internal/src/get-state/read-or-compute-value.ts
-var readOrComputeValue = (state, target) => {
-  if (target.valueMap.has(state.key)) {
-    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
-    return readCachedValue(state, target);
-  }
-  if (state.type === `selector` || state.type === `readonly_selector`) {
-    target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
-    return state.get();
-  }
-  const fallback = state.default instanceof Function ? state.default() : state.default;
-  target.logger.info(
-    `\u{1F481}`,
-    `atom`,
-    state.key,
-    `could not find cached value; using default`,
-    fallback
-  );
-  return state.default instanceof Function ? state.default() : state.default;
-};
-
-// ../atom.io/internal/src/operation.ts
-var openOperation = (store, token) => {
-  if (store.operation.open) {
-    const rejectionTime = performance.now();
-    store.logger.info(
-      `\u2757`,
-      token.type,
-      token.key,
-      `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`
-    );
-    return rejectionTime;
-  }
-  store.operation = {
-    open: true,
-    done: /* @__PURE__ */ new Set(),
-    prev: /* @__PURE__ */ new Map(),
-    time: Date.now(),
-    token
-  };
-  store.logger.info(
-    `\u2B55`,
-    token.type,
-    token.key,
-    `operation start in store "${store.config.name}"${!isChildStore(store) ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
-  );
-};
-var closeOperation = (store) => {
-  if (store.operation.open) {
-    store.logger.info(
-      `\u{1F534}`,
-      store.operation.token.type,
-      store.operation.token.key,
-      `operation done in store "${store.config.name}"`
-    );
-  }
-  store.operation = { open: false };
-  store.on.operationClose.next(store.operation);
-};
-var isDone = (store, key) => {
-  if (!store.operation.open) {
-    store.logger.error(
-      `\u{1F41E}`,
-      `unknown`,
-      key,
-      `isDone called outside of an operation. This is probably a bug in AtomIO.`
-    );
-    return true;
-  }
-  return store.operation.done.has(key);
-};
-var markDone = (store, key) => {
-  if (!store.operation.open) {
-    store.logger.error(
-      `\u{1F41E}`,
-      `unknown`,
-      key,
-      `markDone called outside of an operation. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  store.operation.done.add(key);
-};
-
-// ../atom.io/internal/src/set-state/emit-update.ts
-var emitUpdate = (state, update, store) => {
-  switch (state.type) {
-    case `mutable_atom`:
-      store.logger.info(
-        `\u{1F4E2}`,
-        state.type,
-        state.key,
-        `is now (`,
-        update.newValue,
-        `) subscribers:`,
-        state.subject.subscribers
-      );
+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;
-    default:
-      store.logger.info(
-        `\u{1F4E2}`,
-        state.type,
-        state.key,
-        `went (`,
-        update.oldValue,
-        `->`,
-        update.newValue,
-        `) subscribers:`,
-        state.subject.subscribers
-      );
   }
-  state.subject.next(update);
-};
+}
 
-// ../atom.io/internal/src/set-state/evict-downstream.ts
-var evictDownStream = (atom2, store) => {
-  const target = newest(store);
-  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom2.key);
-  target.logger.info(
-    `\u{1F9F9}`,
-    atom2.type,
-    atom2.key,
-    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
-    downstreamKeys ?? `to evict`
-  );
-  if (downstreamKeys) {
-    if (target.operation.open) {
-      target.logger.info(
-        `\u{1F9F9}`,
-        atom2.type,
-        atom2.key,
-        `[ ${[...target.operation.done].join(`, `)} ] already done`
-      );
-    }
-    for (const key of downstreamKeys) {
-      if (isDone(target, key)) {
-        continue;
-      }
-      evictCachedValue(key, target);
-      markDone(target, key);
+// ../atom.io/internal/src/ingest-updates/ingest-transaction-update.ts
+function ingestTransactionUpdate(applying, transactionUpdate, store) {
+  const updates = transactionUpdate.updates ;
+  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 `molecule_transfer`:
+        ingestMoleculeTransferEvent(updateFromTransaction, applying, store);
+        break;
+      case `transaction_update`:
+        ingestTransactionUpdate(applying, updateFromTransaction, store);
+        break;
     }
   }
-};
+}
 
-// ../atom.io/internal/src/set-state/stow-update.ts
-function shouldUpdateBeStowed(key, update) {
-  if (isTransceiver(update.newValue)) {
-    return false;
+// ../atom.io/internal/src/transaction/set-epoch-number.ts
+function setEpochNumberOfAction(store, transactionKey, newEpoch) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
   }
-  if (key.includes(`\u{1F50D}`)) {
-    return false;
+  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+  if (continuityKey !== undefined) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
   }
-  return true;
 }
-var stowUpdate = (state, update, store) => {
-  const { key } = state;
-  const target = newest(store);
-  if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
-    store.logger.error(
+
+// ../atom.io/internal/src/transaction/apply-transaction.ts
+var applyTransaction = (output, store) => {
+  const child = newest(store);
+  const { parent } = child;
+  if (parent === null || !isChildStore(child) || child.transactionMeta?.phase !== `building`) {
+    store.logger.warn(
       `\u{1F41E}`,
-      `atom`,
-      key,
-      `stowUpdate called outside of a transaction. This is probably a bug.`
+      `transaction`,
+      `???`,
+      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
     );
     return;
   }
-  const shouldStow = shouldUpdateBeStowed(key, update);
-  if (!shouldStow) {
-    return;
-  }
-  const atomUpdate = {
-    type: `atom_update`,
-    key,
-    ...update
-  };
-  if (state.family) {
-    atomUpdate.family = state.family;
-  }
-  target.transactionMeta.update.updates.push(atomUpdate);
+  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{1F4C1}`,
-    `atom`,
-    key,
-    `stowed (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `)`
+    `\u{1F6C4}`,
+    `transaction`,
+    child.transactionMeta.update.key,
+    `Applying transaction with ${updates.length} updates:`,
+    updates
   );
-};
-
-// ../atom.io/internal/src/set-state/set-atom.ts
-var setAtom = (atom2, next, target) => {
-  const oldValue = readOrComputeValue(atom2, target);
-  let newValue = oldValue;
-  if (atom2.type === `mutable_atom` && isChildStore(target)) {
-    const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(atom2, parent, target);
-    newValue = copiedValue;
-  }
-  newValue = become(next)(newValue);
-  target.logger.info(`\u{1F4DD}`, `atom`, atom2.key, `set to`, newValue);
-  newValue = cacheValue(atom2.key, newValue, atom2.subject, target);
-  if (isAtomDefault(atom2.key, target)) {
-    markAtomAsNotDefault(atom2.key, target);
-  }
-  markDone(target, atom2.key);
-  evictDownStream(atom2, target);
-  const update = { oldValue, newValue };
-  if (isRootStore(target)) {
-    emitUpdate(atom2, update, target);
-  } else if (target.parent) {
-    if (target.on.transactionApplying.state === null) {
-      stowUpdate(atom2, update, target);
-    } else if (atom2.key.startsWith(`*`)) {
-      const mutableKey = atom2.key.slice(1);
-      const mutableAtom = target.atoms.get(mutableKey);
-      let transceiver = target.valueMap.get(mutableKey);
-      if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
-        const { parent } = target;
-        const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target);
-        transceiver = copiedValue;
-      }
-      const accepted = transceiver.do(update.newValue) === null;
-      if (accepted) evictDownStream(mutableAtom, target);
-    }
-  }
-};
-
-// ../atom.io/internal/src/set-state/set-atom-or-selector.ts
-var setAtomOrSelector = (state, value, store) => {
-  switch (state.type) {
-    case `atom`:
-    case `mutable_atom`:
-      setAtom(state, value, store);
-      break;
-    case `selector`:
-      state.set(value);
-      break;
+  ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
+  if (isRootStore(parent)) {
+    setEpochNumberOfAction(
+      parent,
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch
+    );
+    const myTransaction = withdraw(store, {
+      key: child.transactionMeta.update.key,
+      type: `transaction`
+    });
+    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);
 };
 
-// ../atom.io/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;
-    }
-  }
+// ../atom.io/internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    store
+  };
 }
 
-// ../atom.io/internal/src/set-state/set-into-store.ts
-function setIntoStore(store, ...params) {
+// ../atom.io/internal/src/get-state/get-from-store.ts
+function getFromStore(store, ...params) {
   let token;
   let family;
   let key;
-  let value;
-  if (params.length === 2) {
+  if (params.length === 1) {
     token = params[0];
-    value = params[1];
-    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];
-    value = params[2];
     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
@@ -1284,282 +1245,338 @@ function setIntoStore(store, ...params) {
       `\u274C`,
       token.type,
       token.key,
-      `could not be set because it was not found in the store "${store.config.name}".`,
+      `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.`
     );
-    return;
-  }
-  const rejectionTime = openOperation(store, token);
-  if (rejectionTime) {
-    const unsubscribe = store.on.operationClose.subscribe(
-      `waiting to set "${token.key}" at T-${rejectionTime}`,
-      () => {
-        unsubscribe();
-        store.logger.info(
-          `\u{1F7E2}`,
-          token.type,
-          token.key,
-          `resuming deferred setState from T-${rejectionTime}`
-        );
-        setIntoStore(store, token, value);
+    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(store, family).default(subKey);
+        store.defaults.set(family.key, defaultValue);
+        return defaultValue;
       }
-    );
-    return;
+    }
   }
-  const state = withdraw(token, store);
-  setAtomOrSelector(state, value, store);
-  closeOperation(store);
+  return readOrComputeValue(store, withdraw(store, token));
 }
 
-// ../atom.io/internal/src/ingest-updates/ingest-atom-update.ts
-function ingestAtomUpdate(applying, atomUpdate, store) {
-  const { key, newValue, oldValue } = atomUpdate;
-  const value = newValue ;
-  const token = { key, type: `atom` };
-  if (atomUpdate.family) {
-    Object.assign(token, { family: atomUpdate.family });
+// ../atom.io/internal/src/junction.ts
+var Junction = class {
+  a;
+  b;
+  cardinality;
+  relations = /* @__PURE__ */ new Map();
+  contents = /* @__PURE__ */ new Map();
+  isAType;
+  isBType;
+  isContent;
+  makeContentKey = (a, b) => `${a}:${b}`;
+  warn;
+  getRelatedKeys(key) {
+    return this.relations.get(key);
   }
-  setIntoStore(store, token, value);
-}
-
-// ../atom.io/internal/src/ingest-updates/ingest-creation-disposal.ts
-function ingestCreationEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`: {
-      createInStore(update, store);
-      break;
+  addRelation(a, b) {
+    let aRelations = this.relations.get(a);
+    let bRelations = this.relations.get(b);
+    if (aRelations) {
+      aRelations.add(b);
+    } else {
+      aRelations = /* @__PURE__ */ new Set([b]);
+      this.relations.set(a, aRelations);
     }
-    case `oldValue`: {
-      disposeFromStore(store, update.token);
-      break;
+    if (bRelations) {
+      bRelations.add(a);
+    } else {
+      bRelations = /* @__PURE__ */ new Set([a]);
+      this.relations.set(b, bRelations);
     }
   }
-}
-function ingestDisposalEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`: {
-      disposeFromStore(store, update.token);
-      break;
+  deleteRelation(a, b) {
+    const aRelations = this.relations.get(a);
+    if (aRelations) {
+      aRelations.delete(b);
+      if (aRelations.size === 0) {
+        this.relations.delete(a);
+      }
+      const bRelations = this.relations.get(b);
+      if (bRelations) {
+        bRelations.delete(a);
+        if (bRelations.size === 0) {
+          this.relations.delete(b);
+        }
+      }
     }
-    case `oldValue`: {
-      createInStore(update, store);
-      if (update.subType === `atom`) {
-        store.valueMap.set(update.token.key, update.value);
+  }
+  replaceRelationsUnsafely(x, ys) {
+    this.relations.set(x, new Set(ys));
+    for (const y of ys) {
+      const yRelations = (/* @__PURE__ */ new Set()).add(x);
+      this.relations.set(y, yRelations);
+    }
+  }
+  replaceRelationsSafely(x, ys) {
+    const xRelationsPrev = this.relations.get(x);
+    let a = this.isAType?.(x) ? x : undefined;
+    let b = a === undefined ? x : undefined;
+    if (xRelationsPrev) {
+      for (const y of xRelationsPrev) {
+        a ??= y;
+        b ??= y;
+        const yRelations = this.relations.get(y);
+        if (yRelations) {
+          if (yRelations.size === 1) {
+            this.relations.delete(y);
+          } else {
+            yRelations.delete(x);
+          }
+          this.contents.delete(this.makeContentKey(a, b));
+        }
+      }
+    }
+    this.relations.set(x, new Set(ys));
+    for (const y of ys) {
+      let yRelations = this.relations.get(y);
+      if (yRelations) {
+        yRelations.add(x);
+      } else {
+        yRelations = (/* @__PURE__ */ new Set()).add(x);
+        this.relations.set(y, yRelations);
       }
-      break;
     }
   }
-}
-function createInStore(update, store) {
-  const { family: familyMeta } = update.token;
-  if (familyMeta) {
-    const family = store.families.get(familyMeta.key);
-    if (family) {
-      findInStore(store, family, parseJson(familyMeta.subKey));
+  getContentInternal(contentKey) {
+    return this.contents.get(contentKey);
+  }
+  setContent(contentKey, content) {
+    this.contents.set(contentKey, content);
+  }
+  deleteContent(contentKey) {
+    this.contents.delete(contentKey);
+  }
+  constructor(data, config) {
+    this.a = data.between[0];
+    this.b = data.between[1];
+    this.cardinality = data.cardinality;
+    if (!config?.externalStore) {
+      this.relations = new Map(
+        data.relations?.map(([x, ys]) => [x, new Set(ys)])
+      );
+      this.contents = new Map(data.contents);
+    }
+    this.isAType = config?.isAType ?? null;
+    this.isBType = config?.isBType ?? null;
+    this.isContent = config?.isContent ?? null;
+    if (config?.makeContentKey) {
+      this.makeContentKey = config.makeContentKey;
+    }
+    if (config?.externalStore) {
+      const externalStore = config.externalStore;
+      this.has = (a, b) => externalStore.has(a, b);
+      this.addRelation = (a, b) => {
+        externalStore.addRelation(a, b);
+      };
+      this.deleteRelation = (a, b) => {
+        externalStore.deleteRelation(a, b);
+      };
+      this.replaceRelationsSafely = (a, bs) => {
+        externalStore.replaceRelationsSafely(a, bs);
+      };
+      this.replaceRelationsUnsafely = (a, bs) => {
+        externalStore.replaceRelationsUnsafely(a, bs);
+      };
+      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(
+        key
+      );
+      if (externalStore.getContent) {
+        this.getContentInternal = (contentKey) => {
+          return externalStore.getContent(contentKey);
+        };
+        this.setContent = (contentKey, content) => {
+          externalStore.setContent(contentKey, content);
+        };
+        this.deleteContent = (contentKey) => {
+          externalStore.deleteContent(contentKey);
+        };
+      }
+      for (const [x, ys] of data.relations ?? []) {
+        let a = this.isAType?.(x) ? x : undefined;
+        let b = a === undefined ? x : undefined;
+        for (const y of ys) {
+          a ??= y;
+          b ??= y;
+          this.addRelation(a, b);
+        }
+      }
+      for (const [contentKey, content] of data.contents ?? []) {
+        this.setContent(contentKey, content);
+      }
+    }
+    if (config?.warn) {
+      this.warn = config.warn;
     }
   }
-}
-function ingestMoleculeCreationEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`:
-      allocateIntoStore(store, update.provenance, update.key);
-      break;
-    case `oldValue`:
-      deallocateFromStore(store, update.key);
-      break;
+  toJSON() {
+    return {
+      between: [this.a, this.b],
+      cardinality: this.cardinality,
+      relations: [...this.relations.entries()].map(
+        ([a, b]) => [a, [...b]]
+      ),
+      contents: [...this.contents.entries()]
+    };
+  }
+  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`: {
+        const bPrev = this.getRelatedKey(a);
+        if (bPrev && bPrev !== b) this.delete(a, bPrev);
+      }
+      case `1:n`: {
+        const aPrev = this.getRelatedKey(b);
+        if (aPrev && aPrev !== a) this.delete(aPrev, b);
+      }
+    }
+    if (content) {
+      const contentKey = this.makeContentKey(a, b);
+      this.setContent(contentKey, content);
+    }
+    this.addRelation(a, b);
+    return this;
   }
-}
-function ingestMoleculeDisposalEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`:
-      deallocateFromStore(store, update.key);
-      break;
-    case `oldValue`:
-      {
-        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);
-          }
+  delete(x, b) {
+    b = typeof b === `string` ? b : x[this.b];
+    const a = (
+      // @ts-expect-error we deduce that this.a may index x
+      typeof x === `string` ? x : x[this.a]
+    );
+    if (a === undefined && typeof b === `string`) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        for (const bRelation of bRelations) {
+          this.delete(bRelation, b);
         }
       }
-      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`
-        );
+    }
+    if (typeof a === `string` && b === undefined) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        for (const aRelation of aRelations) {
+          this.delete(a, aRelation);
+        }
       }
-      break;
-    case `oldValue`:
-      {
-        const provenance = update.from.length === 1 ? update.from[0] : update.from;
-        claimWithinStore(
-          store,
-          provenance,
-          update.key,
-          `exclusive`
+    }
+    if (typeof a === `string` && typeof b === `string`) {
+      this.deleteRelation(a, b);
+      const contentKey = this.makeContentKey(a, b);
+      this.deleteContent(contentKey);
+    }
+    return this;
+  }
+  getRelatedKey(key) {
+    const relations = this.getRelatedKeys(key);
+    if (relations) {
+      if (relations.size > 1) {
+        this.warn?.(
+          `${relations.size} related keys were found for key "${key}": (${[
+            ...relations
+          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
         );
       }
-      break;
-  }
-}
-
-// ../atom.io/internal/src/ingest-updates/ingest-transaction-update.ts
-function ingestTransactionUpdate(applying, transactionUpdate, store) {
-  const updates = transactionUpdate.updates ;
-  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 `molecule_transfer`:
-        ingestMoleculeTransferEvent(updateFromTransaction, applying, store);
-        break;
-      case `transaction_update`:
-        ingestTransactionUpdate(applying, updateFromTransaction, store);
+      let singleRelation;
+      for (const relation of relations) {
+        singleRelation = relation;
         break;
+      }
+      return singleRelation;
     }
   }
-}
-
-// ../atom.io/internal/src/transaction/set-epoch-number.ts
-function setEpochNumberOfAction(transactionKey, newEpoch, store) {
-  const isRoot = isRootStore(store);
-  if (!isRoot) {
-    return;
-  }
-  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
-  if (continuityKey !== undefined) {
-    store.transactionMeta.epoch.set(continuityKey, newEpoch);
-  }
-}
-
-// ../atom.io/internal/src/transaction/apply-transaction.ts
-var applyTransaction = (output, store) => {
-  const child = newest(store);
-  const { parent } = child;
-  if (parent === null || !isChildStore(child) || child.transactionMeta?.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
-  );
-  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?.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);
+  replaceRelations(x, relations, config) {
+    const hasContent = !Array.isArray(relations);
+    const ys = hasContent ? Object.keys(relations) : relations;
+    if (config?.reckless) {
+      this.replaceRelationsUnsafely(x, ys);
+    } else {
+      this.replaceRelationsSafely(x, ys);
+    }
+    if (hasContent) {
+      for (const y of ys) {
+        const contentKey = this.makeContentKey(x, y);
+        const content = relations[y];
+        this.setContent(contentKey, content);
+      }
+    }
+    return this;
   }
-  parent.on.transactionApplying.next(null);
-};
-
-// ../atom.io/internal/src/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    store
-  };
-}
-
-// ../atom.io/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);
+  getContent(a, b) {
+    const contentKey = this.makeContentKey(a, b);
+    return this.getContentInternal(contentKey);
   }
-  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;
+  getRelationEntries(input) {
+    const a = input[this.a];
+    const b = input[this.b];
+    if (a !== undefined && b === undefined) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        return [...aRelations].map((aRelation) => {
+          return [aRelation, this.getContent(a, aRelation)];
+        });
+      }
+    }
+    if (a === undefined && b !== undefined) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        return [...bRelations].map((bRelation) => {
+          return [bRelation, this.getContent(bRelation, b)];
+        });
       }
     }
+    return [];
+  }
+  has(a, b) {
+    if (b) {
+      const setA = this.getRelatedKeys(a);
+      return setA?.has(b) ?? false;
+    }
+    return this.relations.has(a);
   }
-  return readOrComputeValue(withdraw(token, store), store);
-}
+};
 
 // ../atom.io/internal/src/lazy-map.ts
 var LazyMap = class extends Map {
@@ -1596,7 +1613,7 @@ var LazyMap = class extends Map {
 };
 
 // ../atom.io/internal/src/transaction/build-transaction.ts
-var buildTransaction = (key, params, store, id) => {
+var buildTransaction = (store, key, params, id) => {
   const parent = newest(store);
   const childBase = {
     parent,
@@ -1635,7 +1652,7 @@ var buildTransaction = (key, params, store, id) => {
     }),
     miscResources: new LazyMap(parent.miscResources)
   };
-  const epoch = getEpochNumberOfAction(key, store);
+  const epoch = getEpochNumberOfAction(store, key);
   const transactionMeta = {
     phase: `building`,
     update: {
@@ -1652,9 +1669,8 @@ var buildTransaction = (key, params, store, id) => {
       set: (...ps) => {
         setIntoStore(child, ...ps);
       },
-      run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
+      run: (token, identifier = arbitrary()) => actUponStore(child, token, identifier),
       find: (token, k) => findInStore(child, token, k),
-      seek: (token, k) => seekInStore(child, token, k),
       json: (token) => getJsonToken(child, token),
       dispose: (...ps) => {
         disposeFromStore(child, ...ps);
@@ -1677,12 +1693,12 @@ var buildTransaction = (key, params, store, id) => {
 };
 
 // ../atom.io/internal/src/transaction/create-transaction.ts
-function createTransaction(options, store) {
+function createTransaction(store, options) {
   const newTransaction = {
     key: options.key,
     type: `transaction`,
     run: (params, id) => {
-      const childStore = buildTransaction(options.key, params, store, id);
+      const childStore = buildTransaction(store, options.key, params, id);
       try {
         const target2 = newest(store);
         const { toolkit } = childStore.transactionMeta;
@@ -1695,7 +1711,7 @@ function createTransaction(options, store) {
         throw thrown;
       }
     },
-    install: (s) => createTransaction(options, s),
+    install: (s) => createTransaction(s, options),
     subject: new Subject()
   };
   const target = newest(store);
@@ -1706,13 +1722,18 @@ function createTransaction(options, store) {
 }
 
 // ../atom.io/internal/src/transaction/get-epoch-number.ts
-function getEpochNumberOfAction(transactionKey, store) {
+function getEpochNumberOfAction(store, transactionKey) {
   const isRoot = isRootStore(store);
   const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : undefined;
   const epoch = isRoot && continuity !== undefined ? store.transactionMeta.epoch.get(continuity) : undefined;
   return epoch;
 }
 
+// ../atom.io/src/transaction.ts
+function transaction(options) {
+  return createTransaction(IMPLICIT.STORE, options);
+}
+
 // ../atom.io/internal/src/store/store.ts
 var Store = class {
   parent = null;
@@ -1881,7 +1902,7 @@ var IMPLICIT = {
 };
 
 // ../atom.io/internal/src/store/withdraw.ts
-function withdraw(token, store) {
+function withdraw(store, token) {
   let withdrawn;
   let target = store;
   while (target !== null) {
@@ -2009,40 +2030,37 @@ function disposeFromStore(store, ...params) {
     token = maybeToken;
   }
   try {
-    withdraw(token, store);
+    withdraw(store, token);
   } catch (thrown) {
     store.logger.error(
       `\u274C`,
       token.type,
       token.key,
       `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;
   }
   switch (token.type) {
     case `atom`:
     case `mutable_atom`:
-      disposeAtom(token, store);
+      disposeAtom(store, token);
       break;
     case `selector`:
     case `readonly_selector`:
-      disposeSelector(token, store);
+      disposeSelector(store, token);
       break;
   }
 }
 
 // ../atom.io/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);
+var isAtomKey = (store, key) => newest(store).atoms.has(key);
+var isSelectorKey = (store, key) => newest(store).selectors.has(key);
+var isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
+var isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
 
 // ../atom.io/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));
+  const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
   return sources;
 };
 
@@ -2059,7 +2077,7 @@ var traceSelectorAtoms = (directDependencyKey, covered, store) => {
       continue;
     }
     covered.add(indirectDependencyKey);
-    if (!isAtomKey(indirectDependencyKey, store)) {
+    if (!isAtomKey(store, indirectDependencyKey)) {
       indirectDependencyKeys.push(
         ...getSelectorDependencyKeys(indirectDependencyKey, store)
       );
@@ -2074,7 +2092,7 @@ var traceAllSelectorAtoms = (selector, store) => {
   const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
   const covered = /* @__PURE__ */ new Set();
   return directDependencyKeys.flatMap(
-    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(depKey, covered, store)
+    (depKey) => isAtomKey(store, depKey) ? depKey : traceSelectorAtoms(depKey, covered, store)
   );
 };
 
@@ -2121,8 +2139,8 @@ var registerSelector = (selectorKey, covered, store) => ({
     } else {
       [dependency] = params;
     }
-    const dependencyState = withdraw(dependency, store);
-    const dependencyValue = readOrComputeValue(dependencyState, store);
+    const dependencyState = withdraw(store, dependency);
+    const dependencyValue = readOrComputeValue(store, dependencyState);
     store.logger.info(
       `\u{1F50C}`,
       `selector`,
@@ -2153,18 +2171,13 @@ 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);
-    setAtomOrSelector(state, value, target);
+    const state = withdraw(target, token);
+    setAtomOrSelector(target, state, value);
   },
   find: (token, key) => findInStore(store, token, key),
-  seek: (token, key) => seekInStore(store, token, key),
   json: (token) => getJsonToken(store, token)
 });
 
@@ -2173,14 +2186,10 @@ var createReadonlySelector = (store, options, family) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
-  const { get, find, seek, json } = registerSelector(
-    options.key,
-    covered,
-    target
-  );
+  const { get, find, json } = registerSelector(options.key, covered, target);
   const getSelf = () => {
-    const value = options.get({ get, find, seek, json });
-    cacheValue(options.key, value, subject, newest(store));
+    const value = options.get({ get, find, json });
+    cacheValue(newest(store), options.key, value, subject);
     covered.clear();
     return value;
   };
@@ -2217,11 +2226,11 @@ var createWritableSelector = (store, options, family) => {
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
   const setterToolkit = registerSelector(options.key, covered, target);
-  const { find, get, seek, json } = setterToolkit;
-  const getterToolkit = { find, get, seek, json };
+  const { find, get, json } = setterToolkit;
+  const getterToolkit = { find, get, json };
   const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
     const value = getFn(getterToolkit);
-    cacheValue(options.key, value, subject, innerTarget);
+    cacheValue(innerTarget, options.key, value, subject);
     covered.clear();
     return value;
   };
@@ -2239,7 +2248,7 @@ var createWritableSelector = (store, options, family) => {
       newValue,
       `)`
     );
-    cacheValue(options.key, newValue, subject, innerTarget);
+    cacheValue(innerTarget, options.key, newValue, subject);
     markDone(innerTarget, options.key);
     if (isRootStore(innerTarget)) {
       subject.next({ newValue, oldValue });
@@ -2282,10 +2291,10 @@ function createStandaloneSelector(store, options) {
 }
 
 // ../atom.io/internal/src/selector/dispose-selector.ts
-function disposeSelector(selectorToken, store) {
+function disposeSelector(store, selectorToken) {
   const target = newest(store);
   const { key } = selectorToken;
-  const selector = withdraw(selectorToken, target);
+  const selector = withdraw(target, selectorToken);
   if (!selector.family) {
     store.logger.error(
       `\u274C`,
@@ -2298,23 +2307,31 @@ function disposeSelector(selectorToken, store) {
     if (molecule) {
       target.moleculeData.delete(selector.family.subKey, selector.family.key);
     }
+    let familyToken;
     switch (selectorToken.type) {
       case `selector`:
         {
           target.selectors.delete(key);
-          withdraw(
-            { key: selector.family.key, type: `selector_family` },
-            store
-          );
+          familyToken = {
+            key: selector.family.key,
+            type: `selector_family`
+          };
+          const family = withdraw(store, familyToken);
+          family.subject.next({
+            type: `state_disposal`,
+            subType: `selector`,
+            token: selectorToken
+          });
         }
         break;
       case `readonly_selector`:
         {
           target.readonlySelectors.delete(key);
-          const family = withdraw(
-            { key: selector.family.key, type: `readonly_selector_family` },
-            store
-          );
+          familyToken = {
+            key: selector.family.key,
+            type: `readonly_selector_family`
+          };
+          const family = withdraw(store, familyToken);
           family.subject.next({
             type: `state_disposal`,
             subType: `selector`,
@@ -2383,7 +2400,6 @@ function createWritableSelectorFamily(store, options, internalRoles) {
       return getFn({
         get: (...ps) => getFromStore(store, ...ps),
         find: (token, k) => findInStore(store, token, k),
-        seek: (token, k) => seekInStore(store, token, k),
         json: (token) => getJsonToken(store, token)
       });
     }
@@ -2393,7 +2409,7 @@ function createWritableSelectorFamily(store, options, internalRoles) {
 }
 
 // ../atom.io/json/src/select-json-family.ts
-function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
+function selectJsonFamily(store, atomFamilyToken, transform) {
   const jsonFamily = createWritableSelectorFamily(
     store,
     {
@@ -2408,15 +2424,6 @@ function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
     },
     [`mutable`, `json`]
   );
-  const atomFamily2 = withdraw(atomFamilyToken, store);
-  atomFamily2.subject.subscribe(
-    `store=${store.config.name}::json-selector-family`,
-    (event) => {
-      if (event.token.family) {
-        seekInStore(store, jsonFamily, parseJson(event.token.family.subKey));
-      }
-    }
-  );
   return jsonFamily;
 }
 
@@ -2425,7 +2432,7 @@ var parseJson = (str) => JSON.parse(str);
 var stringifyJson = (json) => JSON.stringify(json);
 
 // ../atom.io/internal/src/subscribe/recall-state.ts
-var recallState = (state, store) => {
+var recallState = (store, state) => {
   const target = newest(store);
   if (target.operation.open) {
     return target.operation.prev.get(state.key);
@@ -2434,7 +2441,7 @@ var recallState = (state, store) => {
 };
 
 // ../atom.io/internal/src/subscribe/subscribe-to-root-atoms.ts
-var subscribeToRootAtoms = (selector, store) => {
+var subscribeToRootAtoms = (store, selector) => {
   const target = newest(store);
   const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
     (atomKey) => {
@@ -2458,8 +2465,8 @@ var subscribeToRootAtoms = (selector, store) => {
             `->`,
             atomChange.newValue
           );
-          const oldValue = recallState(selector, target);
-          const newValue = readOrComputeValue(selector, target);
+          const oldValue = recallState(target, selector);
+          const newValue = readOrComputeValue(target, selector);
           store.logger.info(
             `\u2728`,
             selector.type,
@@ -2478,7 +2485,7 @@ var subscribeToRootAtoms = (selector, store) => {
 };
 
 // ../atom.io/internal/src/subscribe/subscribe-to-state.ts
-function subscribeToState(token, handleUpdate, key, store) {
+function subscribeToState(store, token, key, handleUpdate) {
   function safelyHandleUpdate(update) {
     if (store.operation.open) {
       const unsubscribe2 = store.on.operationClose.subscribe(
@@ -2492,17 +2499,17 @@ function subscribeToState(token, handleUpdate, key, store) {
       handleUpdate(update);
     }
   }
-  const state = withdraw(token, store);
+  const state = withdraw(store, token);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
   const isSelector = state.type === `selector` || state.type === `readonly_selector`;
   let dependencyUnsubFunctions = null;
   let updateHandler = safelyHandleUpdate;
   if (isSelector) {
-    dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
+    dependencyUnsubFunctions = subscribeToRootAtoms(store, state);
     updateHandler = (update) => {
       if (dependencyUnsubFunctions) {
         dependencyUnsubFunctions.length = 0;
-        dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
+        dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state));
       }
       safelyHandleUpdate(update);
     };
@@ -2526,8 +2533,8 @@ function subscribeToState(token, handleUpdate, key, store) {
 }
 
 // ../atom.io/internal/src/subscribe/subscribe-to-timeline.ts
-var subscribeToTimeline = (token, handleUpdate, key, store) => {
-  const tl = withdraw(token, store);
+var subscribeToTimeline = (store, token, key, handleUpdate) => {
+  const tl = withdraw(store, token);
   store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
   const unsubscribe = tl.subject.subscribe(key, handleUpdate);
   return () => {
@@ -2578,7 +2585,9 @@ var Tracker = class {
       }
     );
     this.unsubscribeFromState = subscribeToState(
+      target,
       mutableState,
+      subscriptionKey,
       (update) => {
         if (update.newValue !== update.oldValue) {
           this.unsubscribeFromInnerValue();
@@ -2589,15 +2598,15 @@ var Tracker = class {
             }
           );
         }
-      },
-      subscriptionKey,
-      target
+      }
     );
   }
   updateCore(mutableState, latestUpdateState, target) {
     const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
     subscribeToState(
+      target,
       latestUpdateState,
+      subscriptionKey,
       ({ newValue, oldValue }) => {
         const timelineId = target.timelineTopics.getRelatedKey(
           latestUpdateState.key
@@ -2606,7 +2615,9 @@ var Tracker = class {
           const timelineData = target.timelines.get(timelineId);
           if (timelineData?.timeTraveling) {
             const unsubscribe2 = subscribeToTimeline(
+              target,
               { key: timelineId, type: `timeline` },
+              subscriptionKey,
               (update) => {
                 unsubscribe2();
                 setIntoStore(target, mutableState, (transceiver) => {
@@ -2617,9 +2628,7 @@ var Tracker = class {
                   }
                   return transceiver;
                 });
-              },
-              subscriptionKey,
-              target
+              }
             );
             return;
           }
@@ -2647,14 +2656,12 @@ var Tracker = class {
             }
           }
         );
-      },
-      subscriptionKey,
-      target
+      }
     );
   }
   mutableState;
   latestUpdateState;
-  dispose;
+  [Symbol.dispose];
   constructor(mutableState, store) {
     this.mutableState = mutableState;
     const target = newest(store);
@@ -2662,7 +2669,7 @@ var Tracker = class {
     this.observeCore(mutableState, this.latestUpdateState, target);
     this.updateCore(mutableState, this.latestUpdateState, target);
     target.trackers.set(mutableState.key, this);
-    this.dispose = () => {
+    this[Symbol.dispose] = () => {
       this.unsubscribeFromInnerValue();
       this.unsubscribeFromState();
       target.trackers.delete(mutableState.key);
@@ -2709,8 +2716,8 @@ function createMutableAtom(store, options, family) {
   }
   const initialValue = options.default();
   target.atoms.set(newAtom.key, newAtom);
-  markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, subject, target);
+  markAtomAsDefault(store, options.key);
+  cacheValue(target, options.key, initialValue, subject);
   const token = deposit(newAtom);
   if (options.effects) {
     let effectIndex = 0;
@@ -2720,7 +2727,7 @@ function createMutableAtom(store, options, family) {
         setSelf: (next) => {
           setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2742,6 +2749,7 @@ function createMutableAtom(store, options, family) {
 
 // ../atom.io/internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
+  trackers = /* @__PURE__ */ new Map();
   Update;
   latestUpdateAtoms;
   mutableAtoms;
@@ -2754,26 +2762,27 @@ var FamilyTracker = class {
       },
       [`mutable`, `updates`]
     );
-    this.latestUpdateAtoms = withdraw(updateAtoms, store);
+    this.latestUpdateAtoms = withdraw(store, updateAtoms);
     this.mutableAtoms = mutableAtoms;
     this.mutableAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
       (event) => {
-        if (event.token.family) {
-          const key = parseJson(event.token.family.subKey);
-          seekInStore(store, this.latestUpdateAtoms, key);
-          new Tracker(event.token, store);
-        }
-      }
-    );
-    this.latestUpdateAtoms.subject.subscribe(
-      `store=${store.config.name}::tracker-atom-family`,
-      (event) => {
-        if (event.token.family) {
-          const key = parseJson(event.token.family.subKey);
-          const mutableAtomToken = seekInStore(store, this.mutableAtoms, key);
-          if (mutableAtomToken) {
-            new Tracker(mutableAtomToken, store);
+        const { type, token } = event;
+        if (token.family) {
+          const key = parseJson(token.family.subKey);
+          switch (type) {
+            case `state_creation`:
+              this.trackers.set(key, new Tracker(token, store));
+              break;
+            case `state_disposal`:
+              {
+                const tracker = this.trackers.get(key);
+                if (tracker) {
+                  tracker[Symbol.dispose]();
+                  this.trackers.delete(key);
+                }
+              }
+              break;
           }
         }
       }
@@ -2826,7 +2835,7 @@ function createMutableAtomFamily(store, options, internalRoles) {
     internalRoles
   });
   store.families.set(options.key, atomFamily2);
-  selectJsonFamily(atomFamily2, options, store);
+  selectJsonFamily(store, atomFamily2, options);
   new FamilyTracker(atomFamily2, store);
   return familyToken;
 }
@@ -2848,7 +2857,7 @@ var getJsonToken = (store, mutableAtomToken) => {
       key: jsonFamilyKey,
       type: `selector_family`
     };
-    const family = withdraw(jsonFamilyToken, target);
+    const family = withdraw(target, jsonFamilyToken);
     const subKey = JSON.parse(mutableAtomToken.family.subKey);
     const jsonToken = findInStore(store, family, subKey);
     return jsonToken;
@@ -2879,7 +2888,7 @@ function isTransceiver(value) {
 }
 
 // ../atom.io/internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom2, origin, target) {
+function copyMutableIfNeeded(target, atom2, origin) {
   const originValue = origin.valueMap.get(atom2.key);
   const targetValue = target.valueMap.get(atom2.key);
   if (originValue === targetValue) {
@@ -2897,7 +2906,7 @@ function copyMutableIfNeeded(atom2, origin, target) {
 }
 
 // ../atom.io/internal/src/caching.ts
-function cacheValue(key, value, subject, target) {
+function cacheValue(target, key, value, subject) {
   const currentValue = target.valueMap.get(key);
   if (currentValue instanceof Future) {
     const future = currentValue;
@@ -2907,7 +2916,7 @@ function cacheValue(key, value, subject, target) {
     const future = new Future(value);
     target.valueMap.set(key, future);
     future.then((resolved) => {
-      cacheValue(key, resolved, subject, target);
+      cacheValue(target, key, resolved, subject);
       subject.next({ newValue: resolved, oldValue: future });
     }).catch((thrown) => {
       target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
@@ -2921,7 +2930,7 @@ var readCachedValue = (token, target) => {
   let value = target.valueMap.get(token.key);
   if (token.type === `mutable_atom` && isChildStore(target)) {
     const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    const copiedValue = copyMutableIfNeeded(target, token, parent);
     value = copiedValue;
   }
   return value;
@@ -2944,15 +2953,15 @@ var evictCachedValue = (key, target) => {
 };
 
 // ../atom.io/internal/src/atom/is-default.ts
-var isAtomDefault = (key, store) => {
+var isAtomDefault = (store, key) => {
   const core = newest(store);
   return core.atomsThatAreDefault.has(key);
 };
-var markAtomAsDefault = (key, store) => {
+var markAtomAsDefault = (store, key) => {
   const core = newest(store);
   core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
 };
-var markAtomAsNotDefault = (key, store) => {
+var markAtomAsNotDefault = (store, key) => {
   const core = newest(store);
   core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
   core.atomsThatAreDefault.delete(key);
@@ -3000,8 +3009,8 @@ function createRegularAtom(store, options, family) {
     initialValue = options.default();
   }
   target.atoms.set(newAtom.key, newAtom);
-  markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, subject, target);
+  markAtomAsDefault(store, options.key);
+  cacheValue(target, options.key, initialValue, subject);
   const token = deposit(newAtom);
   if (options.effects) {
     let effectIndex = 0;
@@ -3011,7 +3020,7 @@ function createRegularAtom(store, options, family) {
         setSelf: (next) => {
           setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -3041,16 +3050,16 @@ function createStandaloneAtom(store, options) {
 }
 
 // ../atom.io/internal/src/atom/dispose-atom.ts
-function disposeAtom(atomToken, store) {
+function disposeAtom(store, atomToken) {
   const target = newest(store);
   const { key, family } = atomToken;
-  const atom2 = withdraw(atomToken, target);
+  const atom2 = withdraw(target, atomToken);
   if (!family) {
     store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
     atom2.cleanup?.();
     const lastValue = store.valueMap.get(atom2.key);
-    const atomFamily2 = withdraw({ key: family.key, type: `atom_family` }, store);
+    const atomFamily2 = withdraw(store, { key: family.key, type: `atom_family` });
     const disposal = {
       type: `state_disposal`,
       subType: `atom`,
@@ -3063,242 +3072,25 @@ function disposeAtom(atomToken, store) {
     target.valueMap.delete(key);
     target.selectorAtoms.delete(key);
     target.atomsThatAreDefault.delete(key);
-    store.timelineTopics.delete(key);
-    if (atomToken.type === `mutable_atom`) {
-      const updateToken = getUpdateToken(atomToken);
-      disposeAtom(updateToken, store);
-      store.trackers.delete(key);
-    }
-    store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
-    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 === atom2.family?.key);
-      if (!updateAlreadyCaptured) {
-        target.transactionMeta.update.updates.push(disposal);
-      }
-    } else {
-      store.on.atomDisposal.next(atomToken);
-    }
-  }
-}
-
-// ../atom.io/internal/src/get-trace.ts
-function getTrace(error) {
-  const { stack } = error;
-  if (stack) {
-    return `
-` + stack.split(`
-`)?.slice(1)?.join(`
-`);
-  }
-  return ``;
-}
-
-// ../atom.io/introspection/src/refinery.ts
-var Refinery = class {
-  supported;
-  constructor(supported) {
-    this.supported = supported;
-  }
-  refine(input) {
-    for (const [key, refiner] of Object.entries(this.supported)) {
-      try {
-        if (
-          // @ts-expect-error that's the point
-          refiner(input) === true && refiner !== Boolean
-        ) {
-          return { type: key, data: input };
-        }
-      } catch (_) {
-        try {
-          if (input instanceof refiner) {
-            return { type: key, data: input };
-          }
-        } catch (__) {
-        }
-      }
-    }
-    return null;
-  }
-};
-var primitiveRefinery = new Refinery({
-  number: (input) => typeof input === `number`,
-  string: (input) => typeof input === `string`,
-  boolean: (input) => typeof input === `boolean`,
-  null: (input) => input === null
-});
-function isPlainObject(input) {
-  if (!input) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(input);
-  return prototype === Object.prototype;
-}
-var jsonTreeRefinery = new Refinery({
-  object: isPlainObject,
-  array: (input) => Array.isArray(input)
-});
-var jsonRefinery = new Refinery({
-  ...primitiveRefinery.supported,
-  ...jsonTreeRefinery.supported
-});
-var discoverType = (input) => {
-  if (input === undefined) {
-    return `undefined`;
-  }
-  const refined = jsonRefinery.refine(input);
-  if (refined) {
-    return refined.type;
-  }
-  return Object.getPrototypeOf(input).constructor.name;
-};
-
-// ../atom.io/introspection/src/sprawl.ts
-var sprawl = (tree, inspector) => {
-  const walk = (path, node) => {
-    const inspect2 = (p, n) => {
-      const result2 = inspector(p, n);
-      if (result2) return result2;
-      return null;
-    };
-    const result = inspect2(path, node);
-    if (result?.jobComplete ?? result?.pathComplete) {
-      return result;
-    }
-    const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
-    for (const [k, v] of childEntries) {
-      const subResult = walk([...path, k], v);
-      if (subResult?.jobComplete) {
-        return subResult;
-      }
-    }
-    return {};
-  };
-  walk([], tree);
-};
-
-// ../atom.io/introspection/src/differ.ts
-function diffNumber(a, b) {
-  const sign = a < b ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
-  };
-}
-function diffString(a, b) {
-  const sign = a.length < b.length ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
-  };
-}
-function diffBoolean(a, b) {
-  return {
-    summary: `${a} \u2192 ${b}`
-  };
-}
-function diffObject(a, b, recurse) {
-  let summary = ``;
-  const added = [];
-  const removed = [];
-  const changed = [];
-  sprawl(a, (path, nodeA) => {
-    let key;
-    for (key of path) {
-      const nodeB = b[key];
-      if (nodeB === undefined) {
-        removed.push([key, JSON.stringify(nodeA)]);
-      } else {
-        const delta = recurse(nodeA, nodeB);
-        if (delta.summary !== `No Change`) {
-          changed.push([key, delta]);
-        }
-      }
-    }
-  });
-  sprawl(b, (path, nodeB) => {
-    let key;
-    for (key of path) {
-      const nodeA = a[key];
-      if (nodeA === undefined) {
-        added.push([key, JSON.stringify(nodeB)]);
-      }
-    }
-  });
-  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${removed.length}`;
-  return {
-    summary,
-    added,
-    removed,
-    changed
-  };
-}
-function diffArray(a, b, recurse) {
-  return diffObject(a, b, recurse);
-}
-var Differ = class {
-  leafRefinery;
-  treeRefinery;
-  leafDiffers;
-  treeDiffers;
-  constructor(leafRefinery, treeRefinery, diffFunctions) {
-    this.leafRefinery = leafRefinery;
-    this.treeRefinery = treeRefinery;
-    this.leafDiffers = {};
-    this.treeDiffers = {};
-    for (const key of Object.keys(leafRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.leafDiffers[key] = diffFunction;
-    }
-    for (const key of Object.keys(treeRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.treeDiffers[key] = diffFunction;
-    }
-  }
-  diff(a, b) {
-    if (a === b) {
-      return { summary: `No Change` };
-    }
-    const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a);
-    const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b);
-    if (aRefined !== null && bRefined !== null) {
-      if (aRefined.type === bRefined.type) {
-        if (aRefined.type in this.leafDiffers) {
-          const delta = this.leafDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data
-          );
-          return delta;
-        }
-        if (aRefined.type in this.treeDiffers) {
-          const delta = this.treeDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data,
-            (x, y) => this.diff(x, y)
-          );
-          return delta;
-        }
-      }
+    store.timelineTopics.delete(key);
+    if (atomToken.type === `mutable_atom`) {
+      const updateToken = getUpdateToken(atomToken);
+      disposeAtom(store, updateToken);
+      store.trackers.delete(key);
     }
-    const typeA = discoverType(a);
-    const typeB = discoverType(b);
-    if (typeA === typeB) {
-      return {
-        summary: `${typeA} \u2192 ${typeB}`
-      };
+    store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
+    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 === atom2.family?.key);
+      if (!updateAlreadyCaptured) {
+        target.transactionMeta.update.updates.push(disposal);
+      }
+    } else {
+      store.on.atomDisposal.next(atomToken);
     }
-    return {
-      summary: `Type change: ${typeA} \u2192 ${typeB}`
-    };
   }
-};
-new Differ(primitiveRefinery, jsonTreeRefinery, {
-  number: diffNumber,
-  string: diffString,
-  boolean: diffBoolean,
-  null: () => ({ summary: `No Change` }),
-  object: diffObject,
-  array: diffArray
-});
+}
 
 // ../atom.io/transceivers/set-rtx/src/set-rtx.ts
 var SetRTX = class _SetRTX extends Set {
@@ -3384,7 +3176,10 @@ var SetRTX = class _SetRTX extends Set {
         this.emit(`tx:${this.transactionUpdates.join(`;`)}`);
       }
     } catch (thrown) {
-      console.error(`Failed to apply transaction to SetRTX:`, thrown);
+      console.warn(
+        `Did not apply transaction to SetRTX; this error was thrown:`,
+        thrown
+      );
       throw thrown;
     } finally {
       unsubscribe();
@@ -3509,10 +3304,7 @@ var SetRTX = class _SetRTX extends Set {
   }
 };
 
-// ../atom.io/data/src/join.ts
-function capitalize2(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
+// ../atom.io/internal/src/join/join-internal.ts
 var Join = class {
   toolkit;
   options;
@@ -3544,7 +3336,6 @@ var Join = class {
         setIntoStore(store, ...ps);
       },
       find: (...ps) => findInStore(store, ...ps),
-      seek: (...ps) => seekInStore(store, ...ps),
       json: (token) => getJsonToken(store, token)
     };
     const aSide = options.between[0];
@@ -3810,8 +3601,8 @@ var Join = class {
     switch (options.cardinality) {
       case `1:1`: {
         const singleRelatedKeySelectors = createSingleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize2(bSide)}`;
-        const stateKeyB = `${bSide}KeyOf${capitalize2(aSide)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: singleRelatedKeySelectors,
           [stateKeyB]: singleRelatedKeySelectors
@@ -3819,8 +3610,8 @@ var Join = class {
         let states;
         if (defaultContent) {
           const singleEntrySelectors = createSingleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize2(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntryOf${capitalize2(aSide)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
           const contentStates = {
             [entriesStateKeyA]: singleEntrySelectors,
             [entriesStateKeyB]: singleEntrySelectors
@@ -3836,8 +3627,8 @@ var Join = class {
       case `1:n`: {
         const singleRelatedKeySelectors = createSingleKeySelectorFamily();
         const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize2(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize2(aSide)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: singleRelatedKeySelectors,
           [stateKeyB]: multipleRelatedKeysSelectors
@@ -3846,8 +3637,8 @@ var Join = class {
         if (defaultContent) {
           const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
           const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize2(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize2(
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
             aSide
           )}`;
           const contentStates = {
@@ -3864,8 +3655,8 @@ var Join = class {
       }
       default: {
         const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeysOf${capitalize2(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize2(aSide)}`;
+        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: multipleRelatedKeysSelectors,
           [stateKeyB]: multipleRelatedKeysSelectors
@@ -3873,10 +3664,10 @@ var Join = class {
         let states;
         if (defaultContent) {
           const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntriesOf${capitalize2(
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
             bSide
           )}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize2(
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
             aSide
           )}`;
           const contentStates = {
@@ -3893,17 +3684,8 @@ var Join = class {
     }
   }
 };
-function join(options, defaultContent, store = IMPLICIT.STORE) {
-  store.joins.set(options.key, new Join(options, defaultContent, store));
-  const token = {
-    key: options.key,
-    type: `join`,
-    a: options.between[0],
-    b: options.between[1],
-    cardinality: options.cardinality
-  };
-  return token;
-}
+
+// ../atom.io/internal/src/join/get-join.ts
 function getJoin(token, store) {
   let myJoin = store.joins.get(token.key);
   if (myJoin === undefined) {
@@ -3919,6 +3701,8 @@ function getJoin(token, store) {
   }
   return myJoin;
 }
+
+// ../atom.io/internal/src/join/edit-relations-in-store.ts
 function editRelationsInStore(token, change, store) {
   const myJoin = getJoin(token, store);
   const target = newest(store);
@@ -3931,14 +3715,218 @@ function editRelationsInStore(token, change, store) {
     change(myJoin.relations);
   }
 }
+
+// ../atom.io/internal/src/join/get-internal-relations-from-store.ts
 function getInternalRelationsFromStore(token, store) {
   const myJoin = getJoin(token, store);
   const family = myJoin.core.relatedKeysAtoms;
   return family;
 }
-function getInternalRelations(token) {
-  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+
+// ../atom.io/introspection/src/refinery.ts
+var Refinery = class {
+  supported;
+  constructor(supported) {
+    this.supported = supported;
+  }
+  refine(input) {
+    for (const [key, refiner] of Object.entries(this.supported)) {
+      try {
+        if (
+          // @ts-expect-error that's the point
+          refiner(input) === true && refiner !== Boolean
+        ) {
+          return { type: key, data: input };
+        }
+      } catch (_) {
+        try {
+          if (input instanceof refiner) {
+            return { type: key, data: input };
+          }
+        } catch (__) {
+        }
+      }
+    }
+    return null;
+  }
+};
+var primitiveRefinery = new Refinery({
+  number: (input) => typeof input === `number`,
+  string: (input) => typeof input === `string`,
+  boolean: (input) => typeof input === `boolean`,
+  null: (input) => input === null
+});
+function isPlainObject(input) {
+  if (!input) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(input);
+  return prototype === Object.prototype;
+}
+var jsonTreeRefinery = new Refinery({
+  object: isPlainObject,
+  array: (input) => Array.isArray(input)
+});
+var jsonRefinery = new Refinery({
+  ...primitiveRefinery.supported,
+  ...jsonTreeRefinery.supported
+});
+var discoverType = (input) => {
+  if (input === undefined) {
+    return `undefined`;
+  }
+  const refined = jsonRefinery.refine(input);
+  if (refined) {
+    return refined.type;
+  }
+  return Object.getPrototypeOf(input).constructor.name;
+};
+
+// ../atom.io/introspection/src/sprawl.ts
+var sprawl = (tree, inspector) => {
+  const walk = (path, node) => {
+    const inspect2 = (p, n) => {
+      const result2 = inspector(p, n);
+      if (result2) return result2;
+      return null;
+    };
+    const result = inspect2(path, node);
+    if (result?.jobComplete ?? result?.pathComplete) {
+      return result;
+    }
+    const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
+    for (const [k, v] of childEntries) {
+      const subResult = walk([...path, k], v);
+      if (subResult?.jobComplete) {
+        return subResult;
+      }
+    }
+    return {};
+  };
+  walk([], tree);
+};
+
+// ../atom.io/introspection/src/differ.ts
+function diffNumber(a, b) {
+  const sign = a < b ? `+` : `-`;
+  return {
+    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
+  };
+}
+function diffString(a, b) {
+  const sign = a.length < b.length ? `+` : `-`;
+  return {
+    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
+  };
+}
+function diffBoolean(a, b) {
+  return {
+    summary: `${a} \u2192 ${b}`
+  };
+}
+function diffObject(a, b, recurse) {
+  let summary = ``;
+  const added = [];
+  const removed = [];
+  const changed = [];
+  sprawl(a, (path, nodeA) => {
+    let key;
+    for (key of path) {
+      const nodeB = b[key];
+      if (nodeB === undefined) {
+        removed.push([key, JSON.stringify(nodeA)]);
+      } else {
+        const delta = recurse(nodeA, nodeB);
+        if (delta.summary !== `No Change`) {
+          changed.push([key, delta]);
+        }
+      }
+    }
+  });
+  sprawl(b, (path, nodeB) => {
+    let key;
+    for (key of path) {
+      const nodeA = a[key];
+      if (nodeA === undefined) {
+        added.push([key, JSON.stringify(nodeB)]);
+      }
+    }
+  });
+  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${removed.length}`;
+  return {
+    summary,
+    added,
+    removed,
+    changed
+  };
+}
+function diffArray(a, b, recurse) {
+  return diffObject(a, b, recurse);
 }
+var Differ = class {
+  leafRefinery;
+  treeRefinery;
+  leafDiffers;
+  treeDiffers;
+  constructor(leafRefinery, treeRefinery, diffFunctions) {
+    this.leafRefinery = leafRefinery;
+    this.treeRefinery = treeRefinery;
+    this.leafDiffers = {};
+    this.treeDiffers = {};
+    for (const key of Object.keys(leafRefinery.supported)) {
+      const diffFunction = diffFunctions[key];
+      this.leafDiffers[key] = diffFunction;
+    }
+    for (const key of Object.keys(treeRefinery.supported)) {
+      const diffFunction = diffFunctions[key];
+      this.treeDiffers[key] = diffFunction;
+    }
+  }
+  diff(a, b) {
+    if (a === b) {
+      return { summary: `No Change` };
+    }
+    const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a);
+    const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b);
+    if (aRefined !== null && bRefined !== null) {
+      if (aRefined.type === bRefined.type) {
+        if (aRefined.type in this.leafDiffers) {
+          const delta = this.leafDiffers[aRefined.type](
+            aRefined.data,
+            bRefined.data
+          );
+          return delta;
+        }
+        if (aRefined.type in this.treeDiffers) {
+          const delta = this.treeDiffers[aRefined.type](
+            aRefined.data,
+            bRefined.data,
+            (x, y) => this.diff(x, y)
+          );
+          return delta;
+        }
+      }
+    }
+    const typeA = discoverType(a);
+    const typeB = discoverType(b);
+    if (typeA === typeB) {
+      return {
+        summary: `${typeA} \u2192 ${typeB}`
+      };
+    }
+    return {
+      summary: `Type change: ${typeA} \u2192 ${typeB}`
+    };
+  }
+};
+new Differ(primitiveRefinery, jsonTreeRefinery, {
+  number: diffNumber,
+  string: diffString,
+  boolean: diffBoolean,
+  null: () => ({ summary: `No Change` }),
+  object: diffObject,
+  array: diffArray
+});
 
 // ../atom.io/realtime/src/shared-room-store.ts
 atom({
@@ -4774,5 +4762,5 @@ var FlightDeckLogger = class {
 };
 
 export { FLIGHTDECK_ERROR, FLIGHTDECK_INFO, FLIGHTDECK_LNAV_FORMAT, FLIGHTDECK_SETUP_PHASES, FLIGHTDECK_UPDATE_PHASES, FLIGHTDECK_WARN, FlightDeck, FlightDeckLogger, flightDeckLogSchema, isVersionNumber };
-//# sourceMappingURL=chunk-XIZZKICH.js.map
-//# sourceMappingURL=chunk-XIZZKICH.js.map
+//# sourceMappingURL=chunk-7KMVUPT3.js.map
+//# sourceMappingURL=chunk-7KMVUPT3.js.map