atom.io 0.31.1 → 0.32.0

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

@@ -1,6 +1,10 @@
-import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
-import { AtomIOLogger } from 'atom.io';
-import { subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary as arbitrary$1 } from 'atom.io/internal';
+// json/src/entries.ts
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function toEntries(obj) {
+  return Object.entries(obj);
+}
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -92,6 +96,8 @@ var CircularBuffer = class _CircularBuffer {
     return copy;
   }
 };
+
+// internal/src/store/counterfeit.ts
 var FAMILY_MEMBER_TOKEN_TYPES = {
   atom_family: `atom`,
   mutable_atom_family: `mutable_atom`,
@@ -129,349 +135,161 @@ function deposit(state) {
   return token;
 }
 
-// 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);
-  }
-  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);
-    }
-    if (bRelations) {
-      bRelations.add(a);
-    } else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
+// src/atom.ts
+function atom(options) {
+  return createStandaloneAtom(IMPLICIT.STORE, options);
+}
+function atomFamily(options) {
+  return createAtomFamily(IMPLICIT.STORE, options);
+}
+
+// src/dispose-state.ts
+function disposeState(...[token, key]) {
+  if (key) {
+    disposeFromStore(IMPLICIT.STORE, token, key);
+  } else {
+    disposeFromStore(IMPLICIT.STORE, token);
   }
-  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);
-        }
-      }
-    }
+}
+
+// src/find-state.ts
+function findState(token, key) {
+  const state = findInStore(IMPLICIT.STORE, token, key);
+  return state;
+}
+
+// src/get-state.ts
+function getState(...params) {
+  if (params.length === 2) {
+    return getFromStore(IMPLICIT.STORE, ...params);
   }
-  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);
+  return getFromStore(IMPLICIT.STORE, ...params);
+}
+
+// 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
+  };
+  return token;
+}
+function findRelations(token, key) {
+  return findRelationsInStore(token, key, IMPLICIT.STORE);
+}
+function editRelations(token, change) {
+  editRelationsInStore(token, change, IMPLICIT.STORE);
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+
+// src/logger.ts
+var LOG_LEVELS = [`info`, `warn`, `error`];
+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);
     }
-  }
-  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));
-        }
-      }
+  };
+  info = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel === `info`) {
+      this.logger.info(...args);
     }
-    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);
-      }
+  };
+  warn = (...args) => {
+    if ((this.filter?.(...args) ?? true) && this.logLevel !== `error` && this.logLevel !== null) {
+      this.logger.warn(...args);
     }
+  };
+};
+
+// src/realm.ts
+var $claim = Symbol(`claim`);
+var Realm = class {
+  store;
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    makeRootMoleculeInStore(`root`, store);
+  }
+  allocate(provenance, key, attachmentStyle) {
+    return allocateIntoStore(
+      this.store,
+      provenance,
+      key,
+      attachmentStyle
+    );
   }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
+  fuse(type, reagentA, reagentB) {
+    return fuseWithinStore(this.store, type, reagentA, reagentB);
   }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
+  deallocate(claim) {
+    deallocateFromStore(this.store, claim);
   }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
+  claim(newProvenance, claim, exclusive) {
+    return claimWithinStore(this.store, newProvenance, claim, exclusive);
   }
-  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;
-    }
+};
+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,
+      attachmentStyle
+    );
   }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(
-        ([a, b]) => [a, [...b]]
-      ),
-      contents: [...this.contents.entries()]
-    };
+  deallocate(key) {
+    deallocateFromStore(this.store, key);
   }
-  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;
-  }
-  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);
-        }
-      }
-    }
-    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;
-  }
-  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;
-    }
-  }
-  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;
-  }
-  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)];
-        });
-      }
-    }
-    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);
+  claim(newProvenance, key, exclusive) {
+    claimWithinStore(this.store, newProvenance, key, exclusive);
   }
 };
+var T$ = `T$`;
 
-// internal/src/subject.ts
-var Subject = class {
-  Subscriber;
-  subscribers = /* @__PURE__ */ new Map();
-  subscribe(key, subscriber) {
-    this.subscribers.set(key, subscriber);
-    const unsubscribe = () => {
-      this.unsubscribe(key);
-    };
-    return unsubscribe;
-  }
-  unsubscribe(key) {
-    this.subscribers.delete(key);
-  }
-  next(value) {
-    const subscribers = this.subscribers.values();
-    for (const subscriber of subscribers) {
-      subscriber(value);
-    }
-  }
-};
-var StatefulSubject = class extends Subject {
-  state;
-  constructor(initialState) {
-    super();
-    this.state = initialState;
-  }
-  next(value) {
-    this.state = value;
-    super.next(value);
+// src/selector.ts
+function selector(options) {
+  return createStandaloneSelector(IMPLICIT.STORE, options);
+}
+function selectorFamily(options) {
+  return createSelectorFamily(IMPLICIT.STORE, options);
+}
+
+// src/set-state.ts
+function setState(...params) {
+  if (params.length === 2) {
+    setIntoStore(IMPLICIT.STORE, ...params);
+  } else {
+    setIntoStore(IMPLICIT.STORE, ...params);
   }
-};
+}
 
 // internal/src/transaction/is-root-store.ts
 function isRootStore(store) {
@@ -502,8 +320,12 @@ var abortTransaction = (store) => {
   target.parent.child = null;
 };
 
+// internal/src/capitalize.ts
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+
 // internal/src/pretty-print.ts
-var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
   return token.type.split(`_`).map(capitalize).join(` `);
 }
@@ -518,9 +340,9 @@ var NotFoundError = class extends Error {
 };
 
 // internal/src/transaction/act-upon-store.ts
-function actUponStore(token, id, store) {
+function actUponStore(store, token, id) {
   return (...parameters) => {
-    const tx = withdraw(token, store);
+    const tx = withdraw(store, token);
     if (tx) {
       return tx.run(parameters, id);
     }
@@ -532,7 +354,7 @@ function actUponStore(token, id, store) {
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
 
 // internal/src/get-state/read-or-compute-value.ts
-var readOrComputeValue = (state, target) => {
+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);
@@ -616,7 +438,7 @@ var markDone = (store, key) => {
 };
 
 // internal/src/set-state/emit-update.ts
-var emitUpdate = (state, update, store) => {
+var emitUpdate = (store, state, update) => {
   switch (state.type) {
     case `mutable_atom`:
       store.logger.info(
@@ -646,13 +468,13 @@ var emitUpdate = (state, update, store) => {
 };
 
 // internal/src/set-state/evict-downstream.ts
-var evictDownStream = (atom, store) => {
+var evictDownStream = (store, atom2) => {
   const target = newest(store);
-  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
+  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom2.key);
   target.logger.info(
     `\u{1F9F9}`,
-    atom.type,
-    atom.key,
+    atom2.type,
+    atom2.key,
     downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
     downstreamKeys ?? `to evict`
   );
@@ -660,8 +482,8 @@ var evictDownStream = (atom, store) => {
     if (target.operation.open) {
       target.logger.info(
         `\u{1F9F9}`,
-        atom.type,
-        atom.key,
+        atom2.type,
+        atom2.key,
         `[ ${[...target.operation.done].join(`, `)} ] already done`
       );
     }
@@ -685,7 +507,7 @@ function shouldUpdateBeStowed(key, update) {
   }
   return true;
 }
-var stowUpdate = (state, update, store) => {
+var stowUpdate = (store, state, update) => {
   const { key } = state;
   const target = newest(store);
   if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
@@ -723,45 +545,45 @@ var stowUpdate = (state, update, store) => {
 };
 
 // internal/src/set-state/set-atom.ts
-var setAtom = (atom, next, target) => {
-  const oldValue = readOrComputeValue(atom, target);
+var setAtom = (atom2, next, target) => {
+  const oldValue = readOrComputeValue(target, atom2);
   let newValue = oldValue;
-  if (atom.type === `mutable_atom` && isChildStore(target)) {
+  if (atom2.type === `mutable_atom` && isChildStore(target)) {
     const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(atom, parent, target);
+    const copiedValue = copyMutableIfNeeded(target, atom2, parent);
     newValue = copiedValue;
   }
   newValue = become(next)(newValue);
-  target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
-  newValue = cacheValue(atom.key, newValue, atom.subject, target);
-  if (isAtomDefault(atom.key, target)) {
-    markAtomAsNotDefault(atom.key, target);
+  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);
   }
-  markDone(target, atom.key);
-  evictDownStream(atom, target);
+  markDone(target, atom2.key);
+  evictDownStream(target, atom2);
   const update = { oldValue, newValue };
   if (isRootStore(target)) {
-    emitUpdate(atom, update, target);
+    emitUpdate(target, atom2, update);
   } else if (target.parent) {
     if (target.on.transactionApplying.state === null) {
-      stowUpdate(atom, update, target);
-    } else if (atom.key.startsWith(`*`)) {
-      const mutableKey = atom.key.slice(1);
+      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(mutableAtom, parent, target);
+        const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent);
         transceiver = copiedValue;
       }
       const accepted = transceiver.do(update.newValue) === null;
-      if (accepted) evictDownStream(mutableAtom, target);
+      if (accepted) evictDownStream(target, mutableAtom);
     }
   }
 };
 
 // internal/src/set-state/set-atom-or-selector.ts
-var setAtomOrSelector = (state, value, store) => {
+var setAtomOrSelector = (store, state, value) => {
   switch (state.type) {
     case `atom`:
     case `mutable_atom`:
@@ -772,6 +594,41 @@ var setAtomOrSelector = (state, value, store) => {
       break;
   }
 };
+
+// internal/src/subject.ts
+var Subject = class {
+  Subscriber;
+  subscribers = /* @__PURE__ */ new Map();
+  subscribe(key, subscriber) {
+    this.subscribers.set(key, subscriber);
+    const unsubscribe = () => {
+      this.unsubscribe(key);
+    };
+    return unsubscribe;
+  }
+  unsubscribe(key) {
+    this.subscribers.delete(key);
+  }
+  next(value) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
+      subscriber(value);
+    }
+  }
+};
+var StatefulSubject = class extends Subject {
+  state;
+  constructor(initialState) {
+    super();
+    this.state = initialState;
+  }
+  next(value) {
+    this.state = value;
+    super.next(value);
+  }
+};
+
+// internal/src/families/create-regular-atom-family.ts
 function createRegularAtomFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
@@ -806,12 +663,12 @@ function createRegularAtomFamily(store, options, internalRoles) {
     subject.next({ type: `state_creation`, token });
     return token;
   };
-  const atomFamily = Object.assign(familyFunction, familyToken, {
+  const atomFamily2 = Object.assign(familyFunction, familyToken, {
     subject,
     install: (s) => createRegularAtomFamily(s, options),
     internalRoles
   });
-  store.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily2);
   store.defaults.set(options.key, options.default);
   return familyToken;
 }
@@ -826,14 +683,14 @@ function createAtomFamily(store, options) {
 }
 
 // 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);
 
 // 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;
 };
 
@@ -850,7 +707,7 @@ var traceSelectorAtoms = (directDependencyKey, covered, store) => {
       continue;
     }
     covered.add(indirectDependencyKey);
-    if (!isAtomKey(indirectDependencyKey, store)) {
+    if (!isAtomKey(store, indirectDependencyKey)) {
       indirectDependencyKeys.push(
         ...getSelectorDependencyKeys(indirectDependencyKey, store)
       );
@@ -860,12 +717,12 @@ var traceSelectorAtoms = (directDependencyKey, covered, store) => {
   }
   return rootKeys;
 };
-var traceAllSelectorAtoms = (selector, store) => {
-  const selectorKey = selector.key;
+var traceAllSelectorAtoms = (selector2, store) => {
+  const selectorKey = selector2.key;
   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)
   );
 };
 
@@ -912,8 +769,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`,
@@ -947,11 +804,10 @@ var registerSelector = (selectorKey, covered, store) => ({
       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)
 });
 
@@ -960,14 +816,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;
   };
@@ -1004,11 +856,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;
   };
@@ -1026,7 +878,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 });
@@ -1069,11 +921,11 @@ function createStandaloneSelector(store, options) {
 }
 
 // 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);
-  if (!selector.family) {
+  const selector2 = withdraw(target, selectorToken);
+  if (!selector2.family) {
     store.logger.error(
       `\u274C`,
       `selector`,
@@ -1081,27 +933,35 @@ function disposeSelector(selectorToken, store) {
       `Standalone selectors cannot be disposed.`
     );
   } else {
-    const molecule = target.molecules.get(selector.family.subKey);
+    const molecule = target.molecules.get(selector2.family.subKey);
     if (molecule) {
-      target.moleculeData.delete(selector.family.subKey, selector.family.key);
+      target.moleculeData.delete(selector2.family.subKey, selector2.family.key);
     }
+    let familyToken;
     switch (selectorToken.type) {
       case `selector`:
         {
           target.selectors.delete(key);
-          withdraw(
-            { key: selector.family.key, type: `selector_family` },
-            store
-          );
+          familyToken = {
+            key: selector2.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: selector2.family.key,
+            type: `readonly_selector_family`
+          };
+          const family = withdraw(store, familyToken);
           family.subject.next({
             type: `state_disposal`,
             subType: `selector`,
@@ -1167,9 +1027,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)
       });
     }
@@ -1177,6 +1036,8 @@ function createReadonlySelectorFamily(store, options, internalRoles) {
   store.families.set(options.key, readonlySelectorFamily);
   return familyToken;
 }
+
+// internal/src/families/create-writable-selector-family.ts
 function createWritableSelectorFamily(store, options, internalRoles) {
   const familyToken = {
     key: options.key,
@@ -1211,7 +1072,7 @@ function createWritableSelectorFamily(store, options, internalRoles) {
     subject.next({ type: `state_creation`, token });
     return token;
   };
-  const selectorFamily = Object.assign(familyFunction, familyToken, {
+  const selectorFamily2 = Object.assign(familyFunction, familyToken, {
     internalRoles,
     subject,
     install: (s) => createWritableSelectorFamily(s, options),
@@ -1220,12 +1081,11 @@ 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)
       });
     }
   });
-  store.families.set(options.key, selectorFamily);
+  store.families.set(options.key, selectorFamily2);
   return familyToken;
 }
 
@@ -1267,6 +1127,8 @@ function initFamilyMemberInStore(store, token, key) {
   }
   return state;
 }
+
+// internal/src/families/seek-in-store.ts
 function seekInStore(store, token, key) {
   const subKey = stringifyJson(key);
   const fullKey = `${token.key}(${subKey})`;
@@ -1328,27 +1190,24 @@ 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;
   }
 }
@@ -1415,8 +1274,8 @@ ${disposal.trace}` : `No previous disposal trace was found.`
     );
     return;
   }
-  const state = withdraw(token, store);
-  setAtomOrSelector(state, value, store);
+  const state = withdraw(store, token);
+  setAtomOrSelector(store, state, value);
   closeOperation(store);
 }
 
@@ -1543,10 +1402,10 @@ ${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
   );
   if (joinKeys) {
     for (const joinKey of joinKeys) {
-      const join = store.joins.get(joinKey);
-      if (join) {
-        join.relations.delete(molecule.key);
-        join.molecules.delete(molecule.stringKey);
+      const join2 = store.joins.get(joinKey);
+      if (join2) {
+        join2.relations.delete(molecule.key);
+        join2.molecules.delete(molecule.stringKey);
       }
     }
   }
@@ -1795,138 +1654,449 @@ function ingestTransactionUpdate(applying, transactionUpdate, store) {
         break;
     }
   }
-}
-
-// internal/src/transaction/set-epoch-number.ts
-function setEpochNumberOfContinuity(continuityKey, newEpoch, store) {
-  const isRoot = isRootStore(store);
-  if (isRoot && continuityKey) {
-    store.transactionMeta.epoch.set(continuityKey, newEpoch);
-  }
-}
-function setEpochNumberOfAction(transactionKey, newEpoch, store) {
-  const isRoot = isRootStore(store);
-  if (!isRoot) {
-    return;
-  }
-  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
-  if (continuityKey !== undefined) {
-    store.transactionMeta.epoch.set(continuityKey, newEpoch);
-  }
-}
-
-// 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.`
+}
+
+// internal/src/transaction/set-epoch-number.ts
+function setEpochNumberOfContinuity(store, continuityKey, newEpoch) {
+  const isRoot = isRootStore(store);
+  if (isRoot && continuityKey) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+function setEpochNumberOfAction(store, transactionKey, newEpoch) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+  if (continuityKey !== undefined) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+
+// 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(
+      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);
+};
+
+// internal/src/transaction/assign-transaction-to-continuity.ts
+function assignTransactionToContinuity(store, continuityKey, transactionKey) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const { epoch, actionContinuities } = store.transactionMeta;
+  actionContinuities.set(continuityKey, transactionKey);
+  if (!epoch.has(continuityKey)) {
+    epoch.set(continuityKey, -1);
+  }
+}
+
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    store
+  };
+}
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(store, ...params) {
+  let token;
+  let family;
+  let key;
+  if (params.length === 1) {
+    token = params[0];
+  } else {
+    family = params[0];
+    key = params[1];
+    token = findInStore(store, family, key);
+  }
+  if (`counterfeit` in token && `family` in token) {
+    family = store.families.get(token.family.key);
+    const subKey = token.family.subKey;
+    const disposal = store.disposalTraces.buffer.find(
+      (item) => item?.key === subKey
+    );
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `could not be retrieved because it was not found in the store "${store.config.name}".`,
+      disposal ? `This state was previously disposed:
+${disposal.trace}` : `No previous disposal trace was found.`
+    );
+    switch (family.type) {
+      case `atom_family`:
+      case `mutable_atom_family`:
+        return store.defaults.get(family.key);
+      case `selector_family`:
+      case `readonly_selector_family`: {
+        if (store.defaults.has(family.key)) {
+          return store.defaults.get(token.family.key);
+        }
+        const defaultValue = withdraw(store, family).default(subKey);
+        store.defaults.set(family.key, defaultValue);
+        return defaultValue;
+      }
+    }
+  }
+  return readOrComputeValue(store, withdraw(store, token));
+}
+
+// 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);
+  }
+  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);
+    }
+    if (bRelations) {
+      bRelations.add(a);
+    } 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);
+        }
+      }
+    }
+  }
+  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);
+      }
+    }
+  }
+  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;
+    }
+  }
+  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;
+  }
+  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]
     );
-  } else if (isChildStore(parent)) {
-    parent.transactionMeta.update.updates.push(child.transactionMeta.update);
+    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;
   }
-  parent.on.transactionApplying.next(null);
-};
-
-// internal/src/transaction/assign-transaction-to-continuity.ts
-function assignTransactionToContinuity(continuityKey, transactionKey, store) {
-  const isRoot = isRootStore(store);
-  if (!isRoot) {
-    return;
+  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 { epoch, actionContinuities } = store.transactionMeta;
-  actionContinuities.set(continuityKey, transactionKey);
-  if (!epoch.has(continuityKey)) {
-    epoch.set(continuityKey, -1);
+  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;
   }
-}
-
-// internal/src/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    store
-  };
-}
-
-// internal/src/get-state/get-from-store.ts
-function getFromStore(store, ...params) {
-  let token;
-  let family;
-  let key;
-  if (params.length === 1) {
-    token = params[0];
-  } else {
-    family = params[0];
-    key = params[1];
-    token = findInStore(store, family, key);
+  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 [];
   }
-  return readOrComputeValue(withdraw(token, store), store);
-}
+  has(a, b) {
+    if (b) {
+      const setA = this.getRelatedKeys(a);
+      return setA?.has(b) ?? false;
+    }
+    return this.relations.has(a);
+  }
+};
 
 // internal/src/lazy-map.ts
 var LazyMap = class extends Map {
@@ -1963,7 +2133,7 @@ var LazyMap = class extends Map {
 };
 
 // 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,
@@ -2002,7 +2172,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: {
@@ -2019,9 +2189,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);
@@ -2044,12 +2213,12 @@ var buildTransaction = (key, params, store, id) => {
 };
 
 // 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;
@@ -2062,7 +2231,7 @@ function createTransaction(options, store) {
         throw thrown;
       }
     },
-    install: (s) => createTransaction(options, s),
+    install: (s) => createTransaction(s, options),
     subject: new Subject()
   };
   const target = newest(store);
@@ -2072,26 +2241,138 @@ function createTransaction(options, store) {
   return token;
 }
 
-// internal/src/transaction/get-epoch-number.ts
-function getContinuityKey(transactionKey, store) {
-  const isRoot = isRootStore(store);
-  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : undefined;
-  return continuity;
+// internal/src/transaction/get-epoch-number.ts
+function getContinuityKey(store, transactionKey) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : undefined;
+  return continuity;
+}
+function getEpochNumberOfContinuity(store, continuityKey) {
+  const isRoot = isRootStore(store);
+  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : undefined;
+  return epoch;
+}
+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;
+}
+
+// internal/src/transaction/index.ts
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+
+// internal/src/install-into-store.ts
+function installIntoStore(tokens, target, source) {
+  const sourceNewest = newest(source);
+  if (isChildStore(sourceNewest)) {
+    source.logger.error(
+      `\u274C`,
+      `transaction`,
+      sourceNewest.transactionMeta.update.key,
+      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+      tokens,
+      `${sourceNewest.config.name} is undergoing a transaction.`
+    );
+    return;
+  }
+  const targetNewest = newest(target);
+  if (isChildStore(targetNewest)) {
+    target.logger.error(
+      `\u274C`,
+      `transaction`,
+      targetNewest.transactionMeta.update.key,
+      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+      tokens,
+      `${targetNewest.config.name} is undergoing a transaction.`
+    );
+    return;
+  }
+  for (const token of tokens) {
+    const resource = withdraw(source, token);
+    resource.install(target);
+  }
+}
+
+// src/silo.ts
+var Silo = class {
+  store;
+  atom;
+  atomFamily;
+  selector;
+  selectorFamily;
+  transaction;
+  timeline;
+  findState;
+  getState;
+  setState;
+  disposeState;
+  subscribe;
+  undo;
+  redo;
+  runTransaction;
+  install;
+  constructor(config, fromStore = null) {
+    const s = this.store = new Store(config, fromStore);
+    this.atom = (options) => createStandaloneAtom(s, options);
+    this.atomFamily = (options) => createAtomFamily(s, options);
+    this.selector = (options) => createStandaloneSelector(s, options);
+    this.selectorFamily = (options) => createSelectorFamily(s, options);
+    this.transaction = (options) => createTransaction(s, options);
+    this.timeline = (options) => createTimeline(s, options);
+    this.findState = (...params) => findInStore(s, ...params);
+    this.getState = (...params) => getFromStore(s, ...params);
+    this.setState = (...params) => {
+      setIntoStore(s, ...params);
+    };
+    this.disposeState = (...params) => {
+      disposeFromStore(s, ...params);
+    };
+    this.subscribe = (...params) => subscribeInStore(s, ...params);
+    this.undo = (token) => {
+      timeTravel(s, `undo`, token);
+    };
+    this.redo = (token) => {
+      timeTravel(s, `redo`, token);
+    };
+    this.runTransaction = (token, id = arbitrary()) => actUponStore(s, token, id);
+    this.install = (tokens, source = IMPLICIT.STORE) => {
+      installIntoStore(tokens, s, source);
+    };
+  }
+};
+
+// src/subscribe.ts
+function subscribe(token, handleUpdate, key = arbitrary()) {
+  return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key);
 }
-function getEpochNumberOfContinuity(continuityKey, store) {
-  const isRoot = isRootStore(store);
-  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : undefined;
-  return epoch;
+
+// src/timeline.ts
+var timeline = (options) => {
+  return createTimeline(IMPLICIT.STORE, options);
+};
+var redo = (tl) => {
+  timeTravel(IMPLICIT.STORE, `redo`, tl);
+};
+var undo = (tl) => {
+  timeTravel(IMPLICIT.STORE, `undo`, tl);
+};
+
+// src/transaction.ts
+function transaction(options) {
+  return createTransaction(IMPLICIT.STORE, options);
 }
-function getEpochNumberOfAction(transactionKey, store) {
-  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;
+function runTransaction(token, id = arbitrary()) {
+  return actUponStore(IMPLICIT.STORE, token, id);
 }
 
-// internal/src/transaction/index.ts
-var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+// src/validators.ts
+function isToken(knownToken, unknownToken) {
+  return knownToken.key === unknownToken.key;
+}
+function belongsTo(family, unknownToken) {
+  return family.key === unknownToken.family?.key;
+}
 
 // internal/src/store/store.ts
 var Store = class {
@@ -2218,32 +2499,32 @@ var Store = class {
         family.install(this);
       }
       const mutableHelpers = /* @__PURE__ */ new Set();
-      for (const [, atom] of store.atoms) {
-        if (mutableHelpers.has(atom.key)) {
+      for (const [, atom2] of store.atoms) {
+        if (mutableHelpers.has(atom2.key)) {
           continue;
         }
-        atom.install(this);
-        if (atom.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(store, atom);
-          const originalUpdateToken = getUpdateToken(atom);
+        atom2.install(this);
+        if (atom2.type === `mutable_atom`) {
+          const originalJsonToken = getJsonToken(store, atom2);
+          const originalUpdateToken = getUpdateToken(atom2);
           mutableHelpers.add(originalJsonToken.key);
           mutableHelpers.add(originalUpdateToken.key);
         }
       }
-      for (const [, selector] of store.readonlySelectors) {
-        selector.install(this);
+      for (const [, selector2] of store.readonlySelectors) {
+        selector2.install(this);
       }
-      for (const [, selector] of store.selectors) {
-        if (mutableHelpers.has(selector.key)) {
+      for (const [, selector2] of store.selectors) {
+        if (mutableHelpers.has(selector2.key)) {
           continue;
         }
-        selector.install(this);
+        selector2.install(this);
       }
       for (const [, tx] of store.transactions) {
         tx.install(this);
       }
-      for (const [, timeline] of store.timelines) {
-        timeline.install(this);
+      for (const [, timeline2] of store.timelines) {
+        timeline2.install(this);
       }
     }
   }
@@ -2269,7 +2550,7 @@ var clearStore = (store) => {
 };
 
 // internal/src/store/withdraw.ts
-function withdraw(token, store) {
+function withdraw(store, token) {
   let withdrawn;
   let target = store;
   while (target !== null) {
@@ -2306,45 +2587,47 @@ function withdraw(token, store) {
 }
 
 // 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);
   }
   return target.valueMap.get(state.key);
 };
-function subscribeInStore(store, token, handleUpdate, key = arbitrary$1()) {
+
+// internal/src/subscribe/subscribe-in-store.ts
+function subscribeInStore(store, token, handleUpdate, key = arbitrary()) {
   switch (token.type) {
     case `atom`:
     case `mutable_atom`:
     case `readonly_selector`:
     case `selector`:
-      return subscribeToState(token, handleUpdate, key, store);
+      return subscribeToState(store, token, key, handleUpdate);
     case `transaction`:
-      return subscribeToTransaction(token, handleUpdate, key, store);
+      return subscribeToTransaction(store, token, key, handleUpdate);
     case `timeline`:
-      return subscribeToTimeline(token, handleUpdate, key, store);
+      return subscribeToTimeline(store, token, key, handleUpdate);
   }
 }
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
-var subscribeToRootAtoms = (selector, store) => {
+var subscribeToRootAtoms = (store, selector2) => {
   const target = newest(store);
-  const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
+  const dependencySubscriptions = traceAllSelectorAtoms(selector2, store).map(
     (atomKey) => {
-      const atom = target.atoms.get(atomKey);
-      if (atom === undefined) {
+      const atom2 = target.atoms.get(atomKey);
+      if (atom2 === undefined) {
         throw new Error(
-          `Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`
+          `Atom "${atomKey}", a dependency of selector "${selector2.key}", not found in store "${store.config.name}".`
         );
       }
-      return atom.subject.subscribe(
-        `${selector.type}:${selector.key}`,
+      return atom2.subject.subscribe(
+        `${selector2.type}:${selector2.key}`,
         (atomChange) => {
           store.logger.info(
             `\u{1F4E2}`,
-            selector.type,
-            selector.key,
+            selector2.type,
+            selector2.key,
             `root`,
             atomKey,
             `went`,
@@ -2352,18 +2635,18 @@ var subscribeToRootAtoms = (selector, store) => {
             `->`,
             atomChange.newValue
           );
-          const oldValue = recallState(selector, target);
-          const newValue = readOrComputeValue(selector, target);
+          const oldValue = recallState(target, selector2);
+          const newValue = readOrComputeValue(target, selector2);
           store.logger.info(
             `\u2728`,
-            selector.type,
-            selector.key,
+            selector2.type,
+            selector2.key,
             `went`,
             oldValue,
             `->`,
             newValue
           );
-          selector.subject.next({ newValue, oldValue });
+          selector2.subject.next({ newValue, oldValue });
         }
       );
     }
@@ -2372,7 +2655,7 @@ var subscribeToRootAtoms = (selector, store) => {
 };
 
 // internal/src/subscribe/subscribe-to-state.ts
-function subscribeToState2(token, handleUpdate, key, store) {
+function subscribeToState(store, token, key, handleUpdate) {
   function safelyHandleUpdate(update) {
     if (store.operation.open) {
       const unsubscribe2 = store.on.operationClose.subscribe(
@@ -2386,17 +2669,17 @@ function subscribeToState2(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);
     };
@@ -2420,8 +2703,8 @@ function subscribeToState2(token, handleUpdate, key, store) {
 }
 
 // internal/src/subscribe/subscribe-to-timeline.ts
-var subscribeToTimeline2 = (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 () => {
@@ -2436,8 +2719,8 @@ var subscribeToTimeline2 = (token, handleUpdate, key, store) => {
 };
 
 // internal/src/subscribe/subscribe-to-transaction.ts
-var subscribeToTransaction2 = (token, handleUpdate, key, store) => {
-  const tx = withdraw(token, store);
+var subscribeToTransaction = (store, token, key, handleUpdate) => {
+  const tx = withdraw(store, token);
   store.logger.info(
     `\u{1F440}`,
     `transaction`,
@@ -2492,8 +2775,10 @@ var Tracker = class {
         setIntoStore(target, latestUpdateState, update);
       }
     );
-    this.unsubscribeFromState = subscribeToState2(
+    this.unsubscribeFromState = subscribeToState(
+      target,
       mutableState,
+      subscriptionKey,
       (update) => {
         if (update.newValue !== update.oldValue) {
           this.unsubscribeFromInnerValue();
@@ -2504,15 +2789,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}`;
-    subscribeToState2(
+    subscribeToState(
+      target,
       latestUpdateState,
+      subscriptionKey,
       ({ newValue, oldValue }) => {
         const timelineId = target.timelineTopics.getRelatedKey(
           latestUpdateState.key
@@ -2520,8 +2805,10 @@ var Tracker = class {
         if (timelineId) {
           const timelineData = target.timelines.get(timelineId);
           if (timelineData?.timeTraveling) {
-            const unsubscribe2 = subscribeToTimeline2(
+            const unsubscribe2 = subscribeToTimeline(
+              target,
               { key: timelineId, type: `timeline` },
+              subscriptionKey,
               (update) => {
                 unsubscribe2();
                 setIntoStore(target, mutableState, (transceiver) => {
@@ -2532,9 +2819,7 @@ var Tracker = class {
                   }
                   return transceiver;
                 });
-              },
-              subscriptionKey,
-              target
+              }
             );
             return;
           }
@@ -2562,14 +2847,12 @@ var Tracker = class {
             }
           }
         );
-      },
-      subscriptionKey,
-      target
+      }
     );
   }
   mutableState;
   latestUpdateState;
-  dispose;
+  [Symbol.dispose];
   constructor(mutableState, store) {
     this.mutableState = mutableState;
     const target = newest(store);
@@ -2577,7 +2860,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);
@@ -2624,8 +2907,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;
@@ -2635,7 +2918,7 @@ function createMutableAtom(store, options, family) {
         setSelf: (next) => {
           setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState2(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2654,7 +2937,10 @@ function createMutableAtom(store, options, family) {
   }
   return token;
 }
+
+// internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
+  trackers = /* @__PURE__ */ new Map();
   Update;
   latestUpdateAtoms;
   mutableAtoms;
@@ -2667,26 +2953,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;
           }
         }
       }
@@ -2731,16 +3018,16 @@ function createMutableAtomFamily(store, options, internalRoles) {
     subject.next({ type: `state_creation`, token });
     return token;
   };
-  const atomFamily = Object.assign(familyFunction, familyToken, {
+  const atomFamily2 = Object.assign(familyFunction, familyToken, {
     subject,
     install: (s) => createMutableAtomFamily(s, options),
     toJson: options.toJson,
     fromJson: options.fromJson,
     internalRoles
   });
-  store.families.set(options.key, atomFamily);
-  selectJsonFamily(atomFamily, options, store);
-  new FamilyTracker(atomFamily, store);
+  store.families.set(options.key, atomFamily2);
+  selectJsonFamily(store, atomFamily2, options);
+  new FamilyTracker(atomFamily2, store);
   return familyToken;
 }
 
@@ -2761,7 +3048,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;
@@ -2802,25 +3089,25 @@ function isTransceiver(value) {
 }
 
 // internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, origin, target) {
-  const originValue = origin.valueMap.get(atom.key);
-  const targetValue = target.valueMap.get(atom.key);
+function copyMutableIfNeeded(target, atom2, origin) {
+  const originValue = origin.valueMap.get(atom2.key);
+  const targetValue = target.valueMap.get(atom2.key);
   if (originValue === targetValue) {
     if (originValue === undefined) {
-      return typeof atom.default === `function` ? atom.default() : atom.default;
+      return typeof atom2.default === `function` ? atom2.default() : atom2.default;
     }
-    origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
-    const jsonValue = atom.toJson(originValue);
-    const copiedValue = atom.fromJson(jsonValue);
-    target.valueMap.set(atom.key, copiedValue);
-    new Tracker(atom, origin);
+    origin.logger.info(`\u{1F4C3}`, `atom`, atom2.key, `copying`);
+    const jsonValue = atom2.toJson(originValue);
+    const copiedValue = atom2.fromJson(jsonValue);
+    target.valueMap.set(atom2.key, copiedValue);
+    new Tracker(atom2, origin);
     return copiedValue;
   }
   return targetValue;
 }
 
 // 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;
@@ -2830,7 +3117,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);
@@ -2844,7 +3131,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;
@@ -2853,9 +3140,9 @@ var evictCachedValue = (key, target) => {
   const currentValue = target.valueMap.get(key);
   if (currentValue instanceof Future) {
     const future = currentValue;
-    const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key);
-    if (selector) {
-      future.use(selector.get());
+    const selector2 = target.selectors.get(key) ?? target.readonlySelectors.get(key);
+    if (selector2) {
+      future.use(selector2.get());
     }
     return;
   }
@@ -2867,15 +3154,15 @@ var evictCachedValue = (key, target) => {
 };
 
 // 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);
@@ -2923,8 +3210,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;
@@ -2934,7 +3221,7 @@ function createRegularAtom(store, options, family) {
         setSelf: (next) => {
           setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState2(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2964,23 +3251,23 @@ function createStandaloneAtom(store, options) {
 }
 
 // internal/src/atom/dispose-atom.ts
-function disposeAtom(atomToken, store) {
+function disposeAtom(store, atomToken) {
   const target = newest(store);
   const { key, family } = atomToken;
-  const atom = withdraw(atomToken, target);
+  const atom2 = withdraw(target, atomToken);
   if (!family) {
     store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
-    atom.cleanup?.();
-    const lastValue = store.valueMap.get(atom.key);
-    const atomFamily = withdraw({ key: family.key, type: `atom_family` }, store);
+    atom2.cleanup?.();
+    const lastValue = store.valueMap.get(atom2.key);
+    const atomFamily2 = withdraw(store, { key: family.key, type: `atom_family` });
     const disposal = {
       type: `state_disposal`,
       subType: `atom`,
       token: atomToken,
       value: lastValue
     };
-    atomFamily.subject.next(disposal);
+    atomFamily2.subject.next(disposal);
     const isChild = isChildStore(target);
     target.atoms.delete(key);
     target.valueMap.delete(key);
@@ -2989,14 +3276,14 @@ function disposeAtom(atomToken, store) {
     store.timelineTopics.delete(key);
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
-      disposeAtom(updateToken, store);
+      disposeAtom(store, updateToken);
       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 === atom.family?.key);
+      const updateAlreadyCaptured = wasMoleculeDisposal && mostRecentUpdate.values.some(([k]) => k === atom2.family?.key);
       if (!updateAlreadyCaptured) {
         target.transactionMeta.update.updates.push(disposal);
       }
@@ -3006,8 +3293,746 @@ function disposeAtom(atomToken, store) {
   }
 }
 
+// transceivers/set-rtx/src/set-rtx.ts
+var SetRTX = class _SetRTX extends Set {
+  mode = `record`;
+  subject = new Subject();
+  cacheLimit = 0;
+  cache = [];
+  cacheIdx = -1;
+  cacheUpdateNumber = -1;
+  constructor(values, cacheLimit = 0) {
+    super(values);
+    if (values instanceof _SetRTX) {
+      this.parent = values;
+      this.cacheUpdateNumber = values.cacheUpdateNumber;
+    }
+    if (cacheLimit) {
+      this.cacheLimit = cacheLimit;
+      this.cache = new Array(cacheLimit);
+      this.subscribe(`auto cache`, (update) => {
+        this.cacheIdx++;
+        this.cacheIdx %= this.cacheLimit;
+        this.cache[this.cacheIdx] = update;
+      });
+    }
+  }
+  toJSON() {
+    return {
+      members: [...this],
+      cache: this.cache,
+      cacheLimit: this.cacheLimit,
+      cacheIdx: this.cacheIdx,
+      cacheUpdateNumber: this.cacheUpdateNumber
+    };
+  }
+  static fromJSON(json) {
+    const set = new _SetRTX(json.members, json.cacheLimit);
+    set.cache = json.cache;
+    set.cacheIdx = json.cacheIdx;
+    set.cacheUpdateNumber = json.cacheUpdateNumber;
+    return set;
+  }
+  add(value) {
+    const result = super.add(value);
+    if (this.mode === `record`) {
+      this.cacheUpdateNumber++;
+      this.emit(`add:${stringifyJson(value)}`);
+    }
+    return result;
+  }
+  clear() {
+    const capturedContents = this.mode === `record` ? [...this] : null;
+    super.clear();
+    if (capturedContents) {
+      this.cacheUpdateNumber++;
+      this.emit(`clear:${JSON.stringify(capturedContents)}`);
+    }
+  }
+  delete(value) {
+    const result = super.delete(value);
+    if (this.mode === `record`) {
+      this.cacheUpdateNumber++;
+      this.emit(`del:${stringifyJson(value)}`);
+    }
+    return result;
+  }
+  parent;
+  child = null;
+  transactionUpdates = null;
+  transaction(run) {
+    this.mode = `transaction`;
+    this.transactionUpdates = [];
+    this.child = new _SetRTX(this);
+    const unsubscribe = this.child._subscribe(`transaction`, (update) => {
+      this.transactionUpdates?.push(update);
+    });
+    try {
+      const shouldCommit = run(this.child);
+      if (shouldCommit) {
+        for (const update of this.transactionUpdates) {
+          this.doStep(update);
+        }
+        this.cacheUpdateNumber++;
+        this.emit(`tx:${this.transactionUpdates.join(`;`)}`);
+      }
+    } catch (thrown) {
+      console.warn(
+        `Did not apply transaction to SetRTX; this error was thrown:`,
+        thrown
+      );
+      throw thrown;
+    } finally {
+      unsubscribe();
+      this.child = null;
+      this.transactionUpdates = null;
+      this.mode = `record`;
+    }
+  }
+  _subscribe(key, fn) {
+    return this.subject.subscribe(key, fn);
+  }
+  subscribe(key, fn) {
+    return this.subject.subscribe(key, (update) => {
+      fn(`${this.cacheUpdateNumber}=${update}`);
+    });
+  }
+  emit(update) {
+    this.subject.next(update);
+  }
+  doStep(update) {
+    const typeValueBreak = update.indexOf(`:`);
+    const type = update.substring(0, typeValueBreak);
+    const value = update.substring(typeValueBreak + 1);
+    switch (type) {
+      case `add`:
+        this.add(JSON.parse(value));
+        break;
+      case `clear`:
+        this.clear();
+        break;
+      case `del`:
+        this.delete(JSON.parse(value));
+        break;
+      case `tx`:
+        for (const subUpdate of value.split(`;`)) {
+          this.doStep(subUpdate);
+        }
+    }
+  }
+  getUpdateNumber(update) {
+    const breakpoint = update.indexOf(`=`);
+    return Number(update.substring(0, breakpoint));
+  }
+  do(update) {
+    const breakpoint = update.indexOf(`=`);
+    const updateNumber = Number(update.substring(0, breakpoint));
+    const eventOffset = updateNumber - this.cacheUpdateNumber;
+    const isFuture = eventOffset > 0;
+    if (isFuture) {
+      if (eventOffset === 1) {
+        this.mode = `playback`;
+        const innerUpdate = update.substring(breakpoint + 1);
+        this.doStep(innerUpdate);
+        this.mode = `record`;
+        this.cacheUpdateNumber = updateNumber;
+        return null;
+      }
+      return this.cacheUpdateNumber + 1;
+    }
+    if (Math.abs(eventOffset) < this.cacheLimit) {
+      const eventIdx = this.cacheIdx + eventOffset;
+      const cachedUpdate = this.cache[eventIdx];
+      if (cachedUpdate === update) {
+        return null;
+      }
+      this.mode = `playback`;
+      let done = false;
+      while (!done) {
+        this.cacheIdx %= this.cacheLimit;
+        const u = this.cache[this.cacheIdx];
+        this.cacheIdx--;
+        if (!u) {
+          return `OUT_OF_RANGE`;
+        }
+        this.undo(u);
+        done = this.cacheIdx === eventIdx - 1;
+      }
+      const innerUpdate = update.substring(breakpoint + 1);
+      this.doStep(innerUpdate);
+      this.mode = `record`;
+      this.cacheUpdateNumber = updateNumber;
+      return null;
+    }
+    return `OUT_OF_RANGE`;
+  }
+  undoStep(update) {
+    const breakpoint = update.indexOf(`:`);
+    const type = update.substring(0, breakpoint);
+    const value = update.substring(breakpoint + 1);
+    switch (type) {
+      case `add`:
+        this.delete(JSON.parse(value));
+        break;
+      case `del`:
+        this.add(JSON.parse(value));
+        break;
+      case `clear`: {
+        const values = JSON.parse(value);
+        for (const v of values) this.add(v);
+        break;
+      }
+      case `tx`: {
+        const updates = value.split(`;`);
+        for (let i = updates.length - 1; i >= 0; i--) {
+          this.undoStep(updates[i]);
+        }
+      }
+    }
+  }
+  undo(update) {
+    const breakpoint = update.indexOf(`=`);
+    const updateNumber = Number(update.substring(0, breakpoint));
+    if (updateNumber === this.cacheUpdateNumber) {
+      this.mode = `playback`;
+      const innerUpdate = update.substring(breakpoint + 1);
+      this.undoStep(innerUpdate);
+      this.mode = `record`;
+      this.cacheUpdateNumber--;
+      return null;
+    }
+    return this.cacheUpdateNumber;
+  }
+};
+
+// internal/src/join/join-internal.ts
+var Join = class {
+  toolkit;
+  options;
+  defaultContent;
+  molecules = /* @__PURE__ */ new Map();
+  relations;
+  states;
+  core;
+  transact(toolkit, run) {
+    const originalToolkit = this.toolkit;
+    this.toolkit = toolkit;
+    run(this);
+    this.toolkit = originalToolkit;
+  }
+  store;
+  realm;
+  [Symbol.dispose]() {
+  }
+  constructor(options, defaultContent, store = IMPLICIT.STORE) {
+    this.store = store;
+    this.realm = new Anarchy(store);
+    this.options = options;
+    this.defaultContent = defaultContent;
+    this.store.miscResources.set(`join:${options.key}`, this);
+    this.realm.allocate(`root`, options.key);
+    this.toolkit = {
+      get: (...ps) => getFromStore(store, ...ps),
+      set: (...ps) => {
+        setIntoStore(store, ...ps);
+      },
+      find: (...ps) => findInStore(store, ...ps),
+      json: (token) => getJsonToken(store, token)
+    };
+    const aSide = options.between[0];
+    const bSide = options.between[1];
+    const relatedKeysAtoms = createMutableAtomFamily(
+      store,
+      {
+        key: `${options.key}/relatedKeys`,
+        default: () => new SetRTX(),
+        mutable: true,
+        fromJson: (json) => SetRTX.fromJSON(json),
+        toJson: (set) => set.toJSON()
+      },
+      [`join`, `relations`]
+    );
+    this.core = { relatedKeysAtoms };
+    const getRelatedKeys = ({ get }, key) => get(relatedKeysAtoms, key);
+    const addRelation = ({ set }, a, b) => {
+      if (!this.store.molecules.has(stringifyJson(a))) {
+        this.realm.allocate(options.key, a);
+      }
+      set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
+      set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
+    };
+    const deleteRelation = ({ set }, a, b) => {
+      set(relatedKeysAtoms, a, (aKeys) => {
+        aKeys.delete(b);
+        return aKeys;
+      });
+      set(relatedKeysAtoms, b, (bKeys) => {
+        bKeys.delete(a);
+        return bKeys;
+      });
+    };
+    const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
+      const { find, get, set } = toolkit;
+      const relationsOfAState = find(relatedKeysAtoms, a);
+      const currentRelationsOfA = get(relationsOfAState);
+      for (const currentRelationB of currentRelationsOfA) {
+        const remainsRelated = newRelationsOfA.includes(currentRelationB);
+        if (remainsRelated) {
+          continue;
+        }
+        set(relatedKeysAtoms, currentRelationB, (relationsOfB) => {
+          relationsOfB.delete(a);
+          return relationsOfB;
+        });
+      }
+      set(relationsOfAState, (relationsOfA) => {
+        relationsOfA.transaction((nextRelationsOfA) => {
+          nextRelationsOfA.clear();
+          for (const newRelationB of newRelationsOfA) {
+            const relationsOfB = getRelatedKeys(toolkit, newRelationB);
+            const newRelationBIsAlreadyRelated = relationsOfB.has(a);
+            if (this.relations.cardinality === `1:n`) {
+              const previousOwnersToDispose = [];
+              for (const previousOwner of relationsOfB) {
+                if (previousOwner === a) {
+                  continue;
+                }
+                const previousOwnerRelations = getRelatedKeys(
+                  toolkit,
+                  previousOwner
+                );
+                previousOwnerRelations.delete(newRelationB);
+                if (previousOwnerRelations.size === 0) {
+                  previousOwnersToDispose.push(previousOwner);
+                }
+              }
+              if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
+                relationsOfB.clear();
+              }
+              for (const previousOwner of previousOwnersToDispose) {
+                const sorted = [newRelationB, previousOwner].sort();
+                const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
+                this.molecules.delete(compositeKey);
+              }
+            }
+            if (!newRelationBIsAlreadyRelated) {
+              relationsOfB.add(a);
+            }
+            nextRelationsOfA.add(newRelationB);
+          }
+          return true;
+        });
+        return relationsOfA;
+      });
+    };
+    const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
+      const { set } = toolkit;
+      set(relatedKeysAtoms, a, (relationsOfA) => {
+        relationsOfA.transaction((nextRelationsOfA) => {
+          for (const newRelationB of newRelationsOfA) {
+            nextRelationsOfA.add(newRelationB);
+          }
+          return true;
+        });
+        return relationsOfA;
+      });
+      for (const newRelationB of newRelationsOfA) {
+        set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
+          newRelationsB.add(a);
+          return newRelationsB;
+        });
+      }
+      return true;
+    };
+    const has = (toolkit, a, b) => {
+      const aKeys = getRelatedKeys(toolkit, a);
+      return b ? aKeys.has(b) : aKeys.size > 0;
+    };
+    const baseExternalStoreConfiguration = {
+      getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
+      addRelation: (a, b) => {
+        this.store.moleculeJoins.set(
+          a,
+          options.key
+        );
+        this.store.moleculeJoins.set(
+          b,
+          options.key
+        );
+        addRelation(this.toolkit, a, b);
+      },
+      deleteRelation: (a, b) => {
+        deleteRelation(this.toolkit, a, b);
+      },
+      replaceRelationsSafely: (a, bs) => {
+        replaceRelationsSafely(this.toolkit, a, bs);
+      },
+      replaceRelationsUnsafely: (a, bs) => {
+        replaceRelationsUnsafely(this.toolkit, a, bs);
+      },
+      has: (a, b) => has(this.toolkit, a, b)
+    };
+    let externalStore;
+    let contentAtoms;
+    if (defaultContent) {
+      contentAtoms = createRegularAtomFamily(
+        store,
+        {
+          key: `${options.key}/content`,
+          default: defaultContent
+        },
+        [`join`, `content`]
+      );
+      const getContent = ({ get }, key) => get(contentAtoms, key);
+      const setContent = ({ set }, key, content) => {
+        set(contentAtoms, key, content);
+      };
+      const externalStoreWithContentConfiguration = {
+        getContent: (contentKey) => {
+          const content = getContent(this.toolkit, contentKey);
+          return content;
+        },
+        setContent: (contentKey, content) => {
+          setContent(this.toolkit, contentKey, content);
+        },
+        deleteContent: (contentKey) => {
+          this.realm.deallocate(contentKey);
+        }
+      };
+      externalStore = Object.assign(
+        baseExternalStoreConfiguration,
+        externalStoreWithContentConfiguration
+      );
+    } else {
+      externalStore = baseExternalStoreConfiguration;
+    }
+    const relations = new Junction(
+      options,
+      {
+        externalStore,
+        isAType: options.isAType,
+        isBType: options.isBType,
+        makeContentKey: (...args) => {
+          const [a, b] = args;
+          const sorted = args.sort();
+          const compositeKey = `${sorted[0]}:${sorted[1]}`;
+          const aMolecule = store.molecules.get(stringifyJson(a));
+          const bMolecule = store.molecules.get(stringifyJson(b));
+          if (!aMolecule) {
+            this.realm.allocate(options.key, a);
+          }
+          if (!bMolecule) {
+            this.realm.allocate(options.key, b);
+          }
+          this.realm.allocate(a, compositeKey, `all`);
+          this.realm.claim(b, compositeKey);
+          this.store.moleculeJoins.set(compositeKey, options.key);
+          return compositeKey;
+        }
+      }
+    );
+    const createSingleKeySelectorFamily = () => createReadonlySelectorFamily(
+      store,
+      {
+        key: `${options.key}/singleRelatedKey`,
+        get: (key) => ({ get }) => {
+          const relatedKeys = get(relatedKeysAtoms, key);
+          for (const relatedKey of relatedKeys) {
+            return relatedKey;
+          }
+          return null;
+        }
+      },
+      [`join`, `keys`]
+    );
+    const getMultipleKeySelectorFamily = () => {
+      return createReadonlySelectorFamily(
+        store,
+        {
+          key: `${options.key}/multipleRelatedKeys`,
+          get: (key) => ({ get }) => {
+            const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+            const json = get(jsonFamily, key);
+            return json.members;
+          }
+        },
+        [`join`, `keys`]
+      );
+    };
+    const createSingleEntrySelectorFamily = () => createReadonlySelectorFamily(
+      store,
+      {
+        key: `${options.key}/singleRelatedEntry`,
+        get: (x) => ({ get }) => {
+          const relatedKeys = get(relatedKeysAtoms, x);
+          for (const y of relatedKeys) {
+            let a = relations.isAType?.(x) ? x : undefined;
+            let b = a === undefined ? x : undefined;
+            a ??= y;
+            b ??= y;
+            const contentKey = relations.makeContentKey(a, b);
+            const content = get(contentAtoms, contentKey);
+            return [y, content];
+          }
+          return null;
+        }
+      },
+      [`join`, `entries`]
+    );
+    const getMultipleEntrySelectorFamily = () => createReadonlySelectorFamily(
+      store,
+      {
+        key: `${options.key}/multipleRelatedEntries`,
+        get: (x) => ({ get }) => {
+          const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+          const json = get(jsonFamily, x);
+          return json.members.map((y) => {
+            let a = relations.isAType?.(x) ? x : undefined;
+            let b = a === undefined ? x : undefined;
+            a ??= y;
+            b ??= y;
+            const contentKey = relations.makeContentKey(a, b);
+            const content = get(contentAtoms, contentKey);
+            return [y, content];
+          });
+        }
+      },
+      [`join`, `entries`]
+    );
+    switch (options.cardinality) {
+      case `1:1`: {
+        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: singleRelatedKeySelectors
+        };
+        let states;
+        if (defaultContent) {
+          const singleEntrySelectors = createSingleEntrySelectorFamily();
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
+          const contentStates = {
+            [entriesStateKeyA]: singleEntrySelectors,
+            [entriesStateKeyB]: singleEntrySelectors
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+        break;
+      }
+      case `1:n`: {
+        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
+        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
+        };
+        let states;
+        if (defaultContent) {
+          const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
+          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
+          const contentStates = {
+            [entriesStateKeyA]: singleRelatedEntrySelectors,
+            [entriesStateKeyB]: multipleRelatedEntriesSelectors
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+        break;
+      }
+      default: {
+        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
+        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: multipleRelatedKeysSelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
+        };
+        let states;
+        if (defaultContent) {
+          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
+            bSide
+          )}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
+          const contentStates = {
+            [entriesStateKeyA]: multipleRelatedEntriesSelectors,
+            [entriesStateKeyB]: multipleRelatedEntriesSelectors
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+      }
+    }
+  }
+};
+
+// internal/src/join/get-join.ts
+function getJoin(token, store) {
+  let myJoin = store.joins.get(token.key);
+  if (myJoin === undefined) {
+    const rootJoinMap = IMPLICIT.STORE.joins;
+    const rootJoin = rootJoinMap.get(token.key);
+    if (rootJoin === undefined) {
+      throw new Error(
+        `Join "${token.key}" not found in store "${store.config.name}"`
+      );
+    }
+    myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store);
+    store.joins.set(token.key, myJoin);
+  }
+  return myJoin;
+}
+
+// internal/src/join/edit-relations-in-store.ts
+function editRelationsInStore(token, change, store) {
+  const myJoin = getJoin(token, store);
+  const target = newest(store);
+  if (isChildStore(target)) {
+    const { toolkit } = target.transactionMeta;
+    myJoin.transact(toolkit, ({ relations }) => {
+      change(relations);
+    });
+  } else {
+    change(myJoin.relations);
+  }
+}
+
+// internal/src/join/find-relations-in-store.ts
+function findRelationsInStore(token, key, store) {
+  const myJoin = getJoin(token, store);
+  let relations;
+  switch (token.cardinality) {
+    case `1:1`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = myJoin.states[keyAB];
+          const state = findInStore(store, familyAB, key);
+          return state;
+        },
+        get [keyBA]() {
+          const familyBA = myJoin.states[keyBA];
+          const state = findInStore(store, familyBA, key);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in myJoin.states) {
+        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = myJoin.states[entryAB];
+            const state = findInStore(store, familyAB, key);
+            return state;
+          },
+          get [entryBA]() {
+            const familyBA = myJoin.states[entryBA];
+            const state = findInStore(store, familyBA, key);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `1:n`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = myJoin.states[keyAB];
+          const state = findInStore(store, familyAB, key);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = myJoin.states[keysBA];
+          const state = findInStore(store, familyBA, key);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in myJoin.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = myJoin.states[entryAB];
+            const state = findInStore(store, familyAB, key);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = myJoin.states[entriesBA];
+            const state = findInStore(store, familyBA, key);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `n:n`: {
+      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keysAB]() {
+          const familyAB = myJoin.states[keysAB];
+          const state = findInStore(store, familyAB, key);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = myJoin.states[keysBA];
+          const state = findInStore(store, familyBA, key);
+          return state;
+        }
+      };
+      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
+      if (entriesAB in myJoin.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entriesAB]() {
+            const familyAB = myJoin.states[entriesAB];
+            const state = findInStore(store, familyAB, key);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = myJoin.states[entriesBA];
+            const state = findInStore(store, familyBA, key);
+            return state;
+          }
+        });
+      }
+    }
+  }
+  return relations;
+}
+
+// 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;
+}
+
 // internal/src/timeline/create-timeline.ts
-function createTimeline(options, store, data) {
+function createTimeline(store, options, data) {
   const tl = {
     type: `timeline`,
     key: options.key,
@@ -3017,7 +4042,7 @@ function createTimeline(options, store, data) {
     transactionKey: null,
     ...data,
     history: data?.history.map((update) => ({ ...update })) ?? [],
-    install: (s) => createTimeline(options, s, tl),
+    install: (s) => createTimeline(s, options, tl),
     subject: new Subject(),
     subscriptions: /* @__PURE__ */ new Map()
   };
@@ -3056,7 +4081,7 @@ function createTimeline(options, store, data) {
             );
             continue;
           }
-          addAtomToTimeline(atomToken, tl, store);
+          addAtomToTimeline(store, atomToken, tl);
         }
         break;
       case `atom_family`:
@@ -3074,7 +4099,7 @@ function createTimeline(options, store, data) {
             );
             continue;
           }
-          addAtomFamilyToTimeline(familyToken, tl, store);
+          addAtomFamilyToTimeline(store, familyToken, tl);
         }
         break;
     }
@@ -3087,20 +4112,20 @@ function createTimeline(options, store, data) {
   store.on.timelineCreation.next(token);
   return token;
 }
-function addAtomToTimeline(atomToken, tl, store) {
-  let maybeAtom = withdraw(atomToken, store);
+function addAtomToTimeline(store, atomToken, tl) {
+  let maybeAtom = withdraw(store, atomToken);
   if (maybeAtom.type === `mutable_atom`) {
     const updateToken = getUpdateToken(maybeAtom);
-    maybeAtom = withdraw(updateToken, store);
+    maybeAtom = withdraw(store, updateToken);
   }
-  const atom = maybeAtom;
+  const atom2 = maybeAtom;
   store.timelineTopics.set(
-    { topicKey: atom.key, timelineKey: tl.key },
+    { topicKey: atom2.key, timelineKey: tl.key },
     { topicType: `atom` }
   );
   tl.subscriptions.set(
-    atom.key,
-    atom.subject.subscribe(
+    atom2.key,
+    atom2.subject.subscribe(
       `timeline`,
       function timelineCapturesAtomUpdate(update) {
         const target = newest(store);
@@ -3121,7 +4146,7 @@ function addAtomToTimeline(atomToken, tl, store) {
         );
         if (tl.timeTraveling === null) {
           if (txUpdateInProgress) {
-            joinTransaction(tl, txUpdateInProgress, store);
+            joinTransaction(store, tl, txUpdateInProgress);
           } else if (currentSelectorKey && currentSelectorTime) {
             let latestUpdate = tl.history.at(-1);
             if (currentSelectorTime !== tl.selectorTime) {
@@ -3132,7 +4157,7 @@ function addAtomToTimeline(atomToken, tl, store) {
                 atomUpdates: []
               };
               latestUpdate.atomUpdates.push({
-                key: atom.key,
+                key: atom2.key,
                 type: `atom_update`,
                 ...update
               });
@@ -3152,7 +4177,7 @@ function addAtomToTimeline(atomToken, tl, store) {
             } else {
               if (latestUpdate?.type === `selector_update`) {
                 latestUpdate.atomUpdates.push({
-                  key: atom.key,
+                  key: atom2.key,
                   type: `atom_update`,
                   ...update
                 });
@@ -3183,19 +4208,19 @@ function addAtomToTimeline(atomToken, tl, store) {
             const atomUpdate = {
               type: `atom_update`,
               timestamp,
-              key: atom.key,
+              key: atom2.key,
               oldValue: update.oldValue,
               newValue: update.newValue
             };
-            if (atom.family) {
-              atomUpdate.family = atom.family;
+            if (atom2.family) {
+              atomUpdate.family = atom2.family;
             }
             const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
             store.logger.info(
               `\u231B`,
               `timeline`,
               tl.key,
-              `got an atom_update to "${atom.key}"`
+              `got an atom_update to "${atom2.key}"`
             );
             if (willCapture) {
               tl.history.push(atomUpdate);
@@ -3208,8 +4233,8 @@ function addAtomToTimeline(atomToken, tl, store) {
     )
   );
 }
-function addAtomFamilyToTimeline(atomFamilyToken, tl, store) {
-  const family = withdraw(atomFamilyToken, store);
+function addAtomFamilyToTimeline(store, atomFamilyToken, tl) {
+  const family = withdraw(store, atomFamilyToken);
   store.timelineTopics.set(
     { topicKey: family.key, timelineKey: tl.key },
     { topicType: `atom_family` }
@@ -3219,24 +4244,24 @@ function addAtomFamilyToTimeline(atomFamilyToken, tl, store) {
     family.subject.subscribe(
       `timeline`,
       function timelineCapturesStateLifecycleEvent(creationOrDisposal) {
-        handleStateLifecycleEvent(creationOrDisposal, tl, store);
+        handleStateLifecycleEvent(store, creationOrDisposal, tl);
       }
     )
   );
-  for (const atom of store.atoms.values()) {
-    if (atom.family?.key === family.key) {
-      addAtomToTimeline(atom, tl, store);
+  for (const atom2 of store.atoms.values()) {
+    if (atom2.family?.key === family.key) {
+      addAtomToTimeline(store, atom2, tl);
     }
   }
 }
-function joinTransaction(tl, txUpdateInProgress, store) {
+function joinTransaction(store, tl, txUpdateInProgress) {
   const currentTxKey = txUpdateInProgress.key;
   const currentTxInstanceId = txUpdateInProgress.id;
   const currentTxToken = {
     key: currentTxKey,
     type: `transaction`
   };
-  const currentTransaction = withdraw(currentTxToken, store);
+  const currentTransaction = withdraw(store, currentTxToken);
   if (currentTxKey && tl.transactionKey === null) {
     tl.transactionKey = currentTxKey;
     const unsubscribe = currentTransaction.subject.subscribe(
@@ -3310,7 +4335,7 @@ function filterTransactionUpdates(updates, timelineTopics) {
     return updateFromTx;
   });
 }
-function handleStateLifecycleEvent(event, tl, store) {
+function handleStateLifecycleEvent(store, event, tl) {
   const timestamp = Date.now();
   const timelineEvent = Object.assign(event, {
     timestamp
@@ -3320,7 +4345,7 @@ function handleStateLifecycleEvent(event, tl, store) {
     if (isChildStore(target)) ; else {
       const txUpdateInProgress = target.on.transactionApplying.state;
       if (txUpdateInProgress) {
-        joinTransaction(tl, txUpdateInProgress.update, store);
+        joinTransaction(store, tl, txUpdateInProgress.update);
       } else {
         tl.history.push(timelineEvent);
         tl.at = tl.history.length;
@@ -3330,7 +4355,7 @@ function handleStateLifecycleEvent(event, tl, store) {
   }
   switch (event.type) {
     case `state_creation`:
-      addAtomToTimeline(event.token, tl, store);
+      addAtomToTimeline(store, event.token, tl);
       break;
     case `state_disposal`:
       tl.subscriptions.get(event.token.key)?.();
@@ -3407,4 +4432,67 @@ var timeTravel = (store, action, token) => {
   );
 };
 
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState2 as subscribeToState, subscribeToTimeline2 as subscribeToTimeline, subscribeToTransaction2 as subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+// json/src/select-json.ts
+var selectJson = (atom2, transform, store = IMPLICIT.STORE) => {
+  return createStandaloneSelector(store, {
+    key: `${atom2.key}:JSON`,
+    get: ({ get }) => transform.toJson(get(atom2)),
+    set: ({ set }, newValue) => {
+      set(atom2, transform.fromJson(newValue));
+    }
+  });
+};
+
+// json/src/select-json-family.ts
+function selectJsonFamily(store, atomFamilyToken, transform) {
+  const jsonFamily = createWritableSelectorFamily(
+    store,
+    {
+      key: `${atomFamilyToken.key}:JSON`,
+      get: (key) => ({ get }) => {
+        const baseState = get(atomFamilyToken, key);
+        return transform.toJson(baseState);
+      },
+      set: (key) => ({ set }, newValue) => {
+        set(atomFamilyToken, key, transform.fromJson(newValue));
+      }
+    },
+    [`mutable`, `json`]
+  );
+  return jsonFamily;
+}
+
+// json/src/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_PROTOTYPES = [
+  Array.prototype,
+  Boolean.prototype,
+  Number.prototype,
+  Object.prototype,
+  String.prototype
+];
+var isJson = (input) => {
+  if (input === null) return true;
+  if (input === undefined) return false;
+  const prototype = Object.getPrototypeOf(input);
+  return JSON_PROTOTYPES.includes(prototype);
+};
+var JSON_TYPE_NAMES = [
+  `array`,
+  `boolean`,
+  `null`,
+  `number`,
+  `object`,
+  `string`
+];
+var JSON_DEFAULTS = {
+  array: [],
+  boolean: false,
+  null: null,
+  number: 0,
+  object: {},
+  string: ``
+};
+
+export { $claim, Anarchy, AtomIOLogger, CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, JSON_DEFAULTS, JSON_TYPE_NAMES, Join, Junction, LOG_LEVELS, LazyMap, NotFoundError, Realm, SetRTX, Silo, StatefulSubject, Store, Subject, T$, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, atom, atomFamily, become, belongsTo, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, disposeState, editRelations, editRelationsInStore, evictCachedValue, findInStore, findRelations, findRelationsInStore, findState, fromEntries, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getState, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isJson, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isToken, isTransceiver, join, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, parseJson, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, redo, registerSelector, runTransaction, seekInStore, selectJson, selectJsonFamily, selector, selectorFamily, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, setState, simpleLog, simpleLogger, stringifyJson, subscribe, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, timeline, toEntries, traceAllSelectorAtoms, traceSelectorAtoms, transaction, undo, updateSelectorAtoms, withdraw };