atom.io 0.30.7 → 0.31.1

package/data/dist/index.d.ts

@@ -1,9 +1,7 @@
 import * as AtomIO from 'atom.io';
-import { ReadonlySelectorFamilyToken, MutableAtomFamilyToken, SetterToolkit, disposeState, ReadonlySelectorToken } from 'atom.io';
-import { Store, JunctionSchemaBase, JunctionEntriesBase, Molecule, Junction } from 'atom.io/internal';
+import { ReadonlySelectorFamilyToken, SingularTypedKey, Hierarchy, CompoundTypedKey, MutableAtomFamilyToken, SetterToolkit, Anarchy, ReadonlySelectorToken } from 'atom.io';
+import { Store, JunctionSchemaBase, JunctionEntriesBase, Refinement, Molecule, Junction } from 'atom.io/internal';
 import { Canonical, stringified, Json } from 'atom.io/json';
-import { findState } from 'atom.io/ephemeral';
-import { Refinement } from 'atom.io/introspection';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 declare function dict<State, Key extends Canonical>(family: AtomIO.ReadonlySelectorFamilyToken<State, Key> | AtomIO.RegularAtomFamilyToken<State, Key> | AtomIO.WritableSelectorFamilyToken<State, Key>, index: AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.RegularAtomToken<Key[]> | AtomIO.WritableSelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
@@ -59,24 +57,31 @@ type JoinStateFamilies<ASide extends string, AType extends string, BSide extends
 } & {
     readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
 } : never;
-declare class Join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null> {
-    private options;
-    private defaultContent;
+type JoinHierarchy<AType extends SingularTypedKey, BType extends SingularTypedKey> = Hierarchy<[
+    {
+        above: `root`;
+        below: [AType, BType];
+    },
+    {
+        above: [AType, BType];
+        style: `all`;
+        below: CompoundTypedKey<`content`, AType, BType>;
+    }
+]>;
+declare class Join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null, const ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
     private toolkit;
-    retrieve: typeof findState;
+    options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>;
+    defaultContent: Content | undefined;
     molecules: Map<string, Molecule<any>>;
     relations: Junction<ASide, AType, BSide, BType, Content>;
     states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
     core: {
-        findRelatedKeysState: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+        relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
     };
-    transact(toolkit: SetterToolkit & {
-        dispose: typeof disposeState;
-    }, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
+    transact(toolkit: SetterToolkit, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
     store: Store;
-    alternates: Map<string, Join<ASide, AType, BSide, BType, Cardinality, Content>>;
+    realm: Anarchy;
     [Symbol.dispose](): void;
-    in(store: Store): Join<ASide, AType, BSide, BType, Cardinality, Content>;
     constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
 }
 type JoinToken<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
@@ -91,9 +96,6 @@ type JoinToken<ASide extends string, AType extends string, BSide extends string,
 };
 declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, null>;
 declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
-declare function getJoinMap(store: Store & {
-    joins?: Map<string, Join<any, any, any, any, any, any>>;
-}): Map<string, Join<any, any, any, any, any, any>>;
 declare function getJoin<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, store: Store): Join<ASide, AType, BSide, BType, Cardinality, Content>;
 type JoinStates<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
     readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
@@ -177,4 +179,4 @@ type Fated<T, E extends Error = Error> = Loadable<E | T>;
  */
 declare function until<T>(loadable: Loadable<T>, fallback: T): T;
 
-export { type Fated, Join, type JoinOptions, type JoinStateFamilies, type JoinStates, type JoinToken, type Loadable, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join, struct, structFamily, until };
+export { type Fated, Join, type JoinHierarchy, type JoinOptions, type JoinStateFamilies, type JoinStates, type JoinToken, type Loadable, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, join, struct, structFamily, until };

package/data/dist/index.js

@@ -1,5 +1,6 @@
 import '../../dist/chunk-XWL6SNVU.js';
-import { createStandaloneSelector, findInStore, IMPLICIT, withdraw, growMoleculeInStore, NotFoundError, initFamilyMemberInStore, getFromStore, setIntoStore, seekInStore, getJsonToken, disposeFromStore, createMutableAtomFamily, createRegularAtomFamily, createMoleculeFamily, Junction, newest, makeMoleculeInStore, isChildStore, createRegularAtom, createSelectorFamily, createReadonlySelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { createStandaloneSelector, findInStore, IMPLICIT, getFromStore, setIntoStore, seekInStore, getJsonToken, createMutableAtomFamily, createRegularAtomFamily, Junction, newest, isChildStore, createRegularAtom, createSelectorFamily, createReadonlySelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { Anarchy } from 'atom.io';
 import { stringifyJson } from 'atom.io/json';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
@@ -18,11 +19,10 @@ function dict(family, index, store = IMPLICIT.STORE) {
 function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
 }
-var Join = class _Join {
+var Join = class {
+  toolkit;
   options;
   defaultContent;
-  toolkit;
-  retrieve;
   molecules = /* @__PURE__ */ new Map();
   relations;
   states;
@@ -34,54 +34,24 @@ var Join = class _Join {
     this.toolkit = originalToolkit;
   }
   store;
-  alternates;
+  realm;
   [Symbol.dispose]() {
-    this.alternates.delete(this.store.config.name);
-  }
-  in(store) {
-    const key = store.config.name;
-    const alternate = this.alternates.get(key);
-    if (alternate) {
-      return alternate;
-    }
-    const join2 = new _Join(this.options, this.defaultContent, store);
-    this.alternates.set(key, join2);
-    join2.alternates = this.alternates;
-    return join2;
   }
   constructor(options, defaultContent, store = IMPLICIT.STORE) {
     this.store = store;
+    this.realm = new Anarchy(store);
     this.options = options;
     this.defaultContent = defaultContent;
-    this.alternates = /* @__PURE__ */ new Map();
-    this.alternates.set(store.config.name, this);
     this.store.miscResources.set(`join:${options.key}`, this);
-    this.retrieve = (token, key) => {
-      const maybeToken = this.toolkit.seek(token, key);
-      if (maybeToken) {
-        return maybeToken;
-      }
-      const molecule = this.store.molecules.get(stringifyJson(key));
-      if (molecule) {
-        const family = withdraw(token, store);
-        return growMoleculeInStore(molecule, family, store);
-      }
-      if (store.config.lifespan === `immortal`) {
-        throw new NotFoundError(token, key, store);
-      }
-      return initFamilyMemberInStore(store, token, key);
-    };
+    this.realm.allocate(`root`, options.key);
     this.toolkit = {
       get: (...ps) => getFromStore(store, ...ps),
       set: (...ps) => {
         setIntoStore(store, ...ps);
       },
-      find: this.retrieve,
+      find: (...ps) => findInStore(store, ...ps),
       seek: (...ps) => seekInStore(store, ...ps),
-      json: (token) => getJsonToken(store, token),
-      dispose: (...ps) => {
-        disposeFromStore(store, ...ps);
-      }
+      json: (token) => getJsonToken(store, token)
     };
     const aSide = options.between[0];
     const bSide = options.between[1];
@@ -96,44 +66,35 @@ var Join = class _Join {
       },
       [`join`, `relations`]
     );
-    this.core = { findRelatedKeysState: relatedKeysAtoms };
-    const getRelatedKeys = ({ get }, key) => get(this.retrieve(relatedKeysAtoms, key));
-    const addRelation = (toolkit, a, b) => {
-      const { set } = toolkit;
-      const aKeysState = this.retrieve(relatedKeysAtoms, a);
-      const bKeysState = this.retrieve(relatedKeysAtoms, b);
-      set(aKeysState, (aKeys) => aKeys.add(b));
-      set(bKeysState, (bKeys) => bKeys.add(a));
+    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 = (toolkit, a, b) => {
-      const { set } = toolkit;
-      const aKeysState = this.retrieve(relatedKeysAtoms, a);
-      const bKeysState = this.retrieve(relatedKeysAtoms, b);
-      set(aKeysState, (aKeys) => {
+    const deleteRelation = ({ set }, a, b) => {
+      set(relatedKeysAtoms, a, (aKeys) => {
         aKeys.delete(b);
-        if (aKeys.size === 0) ;
         return aKeys;
       });
-      set(bKeysState, (bKeys) => {
+      set(relatedKeysAtoms, b, (bKeys) => {
         bKeys.delete(a);
-        if (bKeys.size === 0) ;
         return bKeys;
       });
     };
     const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
-      const { get, set } = toolkit;
-      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
+      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;
         }
-        const relationsOfBState = this.retrieve(
-          relatedKeysAtoms,
-          currentRelationB
-        );
-        set(relationsOfBState, (relationsOfB) => {
+        set(relatedKeysAtoms, currentRelationB, (relationsOfB) => {
           relationsOfB.delete(a);
           return relationsOfB;
         });
@@ -180,8 +141,7 @@ var Join = class _Join {
     };
     const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
       const { set } = toolkit;
-      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
-      set(relationsOfAState, (relationsOfA) => {
+      set(relatedKeysAtoms, a, (relationsOfA) => {
         relationsOfA.transaction((nextRelationsOfA) => {
           for (const newRelationB of newRelationsOfA) {
             nextRelationsOfA.add(newRelationB);
@@ -191,8 +151,7 @@ var Join = class _Join {
         return relationsOfA;
       });
       for (const newRelationB of newRelationsOfA) {
-        const newRelationsBState = this.retrieve(relatedKeysAtoms, newRelationB);
-        set(newRelationsBState, (newRelationsB) => {
+        set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
           newRelationsB.add(a);
           return newRelationsB;
         });
@@ -206,6 +165,14 @@ var Join = class _Join {
     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) => {
@@ -221,7 +188,6 @@ var Join = class _Join {
     };
     let externalStore;
     let contentAtoms;
-    let contentMolecules;
     if (defaultContent) {
       contentAtoms = createRegularAtomFamily(
         store,
@@ -231,24 +197,9 @@ var Join = class _Join {
         },
         [`join`, `content`]
       );
-      contentMolecules = createMoleculeFamily(store, {
-        key: `${options.key}/content-molecules`,
-        new: class ContentMolecule {
-          constructor(_, key) {
-            this.key = key;
-          }
-        }
-      });
-      const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
+      const getContent = ({ get }, key) => get(contentAtoms, key);
       const setContent = ({ set }, key, content) => {
-        set(this.retrieve(contentAtoms, key), content);
-      };
-      const deleteContent = (_, compositeKey) => {
-        const contentMolecule = store.molecules.get(`"${compositeKey}"`);
-        if (contentMolecule) {
-          this.toolkit.dispose(contentMolecule);
-          this.molecules.delete(`"${compositeKey}"`);
-        }
+        set(contentAtoms, key, content);
       };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {
@@ -259,7 +210,7 @@ var Join = class _Join {
           setContent(this.toolkit, contentKey, content);
         },
         deleteContent: (contentKey) => {
-          deleteContent(this.toolkit, contentKey);
+          this.realm.deallocate(contentKey);
         }
       };
       externalStore = Object.assign(
@@ -276,35 +227,30 @@ var Join = class _Join {
         isAType: options.isAType,
         isBType: options.isBType,
         makeContentKey: (...args) => {
+          const [a, b] = args;
           const sorted = args.sort();
           const compositeKey = `${sorted[0]}:${sorted[1]}`;
-          const [m0, m1] = sorted.map(
-            (key) => this.molecules.get(stringifyJson(key))
-          );
-          if (store.config.lifespan === `immortal` && m0 && m1) {
-            const target = newest(store);
-            const moleculeToken = makeMoleculeInStore(
-              target,
-              [m0, m1],
-              contentMolecules,
-              compositeKey
-            );
-            this.molecules.set(
-              `"${compositeKey}"`,
-              withdraw(moleculeToken, target)
-            );
+          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 createSingleKeyStateFamily = () => createReadonlySelectorFamily(
+    const createSingleKeySelectorFamily = () => createReadonlySelectorFamily(
       store,
       {
         key: `${options.key}/singleRelatedKey`,
         get: (key) => ({ get }) => {
-          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
-          const relatedKeys = get(relatedKeysState);
+          const relatedKeys = get(relatedKeysAtoms, key);
           for (const relatedKey of relatedKeys) {
             return relatedKey;
           }
@@ -313,36 +259,33 @@ var Join = class _Join {
       },
       [`join`, `keys`]
     );
-    const getMultipleKeyStateFamily = () => {
+    const getMultipleKeySelectorFamily = () => {
       return createReadonlySelectorFamily(
         store,
         {
           key: `${options.key}/multipleRelatedKeys`,
           get: (key) => ({ get }) => {
             const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-            const jsonState = this.retrieve(jsonFamily, key);
-            const json = get(jsonState);
+            const json = get(jsonFamily, key);
             return json.members;
           }
         },
         [`join`, `keys`]
       );
     };
-    const createSingleEntryStateFamily = () => createReadonlySelectorFamily(
+    const createSingleEntrySelectorFamily = () => createReadonlySelectorFamily(
       store,
       {
         key: `${options.key}/singleRelatedEntry`,
         get: (x) => ({ get }) => {
-          const relatedKeysState = this.retrieve(relatedKeysAtoms, x);
-          const relatedKeys = get(relatedKeysState);
+          const relatedKeys = get(relatedKeysAtoms, x);
           for (const y of relatedKeys) {
-            let a = relations.isAType?.(x) ? x : void 0;
-            let b = a === void 0 ? x : void 0;
+            let a = relations.isAType?.(x) ? x : undefined;
+            let b = a === undefined ? x : undefined;
             a ??= y;
             b ??= y;
             const contentKey = relations.makeContentKey(a, b);
-            const contentState = this.retrieve(contentAtoms, contentKey);
-            const content = get(contentState);
+            const content = get(contentAtoms, contentKey);
             return [y, content];
           }
           return null;
@@ -350,22 +293,20 @@ var Join = class _Join {
       },
       [`join`, `entries`]
     );
-    const getMultipleEntryStateFamily = () => createReadonlySelectorFamily(
+    const getMultipleEntrySelectorFamily = () => createReadonlySelectorFamily(
       store,
       {
         key: `${options.key}/multipleRelatedEntries`,
         get: (x) => ({ get }) => {
           const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-          const jsonState = this.retrieve(jsonFamily, x);
-          const json = get(jsonState);
+          const json = get(jsonFamily, x);
           return json.members.map((y) => {
-            let a = relations.isAType?.(x) ? x : void 0;
-            let b = a === void 0 ? x : void 0;
+            let a = relations.isAType?.(x) ? x : undefined;
+            let b = a === undefined ? x : undefined;
             a ??= y;
             b ??= y;
             const contentKey = relations.makeContentKey(a, b);
-            const contentState = this.retrieve(contentAtoms, contentKey);
-            const content = get(contentState);
+            const content = get(contentAtoms, contentKey);
             return [y, content];
           });
         }
@@ -374,21 +315,21 @@ var Join = class _Join {
     );
     switch (options.cardinality) {
       case `1:1`: {
-        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
         const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
         const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
         const baseStates = {
-          [stateKeyA]: findSingleRelatedKeyState,
-          [stateKeyB]: findSingleRelatedKeyState
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: singleRelatedKeySelectors
         };
         let states;
         if (defaultContent) {
-          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const singleEntrySelectors = createSingleEntrySelectorFamily();
           const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
           const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
           const contentStates = {
-            [entriesStateKeyA]: findSingleRelatedEntryState,
-            [entriesStateKeyB]: findSingleRelatedEntryState
+            [entriesStateKeyA]: singleEntrySelectors,
+            [entriesStateKeyB]: singleEntrySelectors
           };
           states = Object.assign(baseStates, contentStates);
         } else {
@@ -399,25 +340,25 @@ var Join = class _Join {
         break;
       }
       case `1:n`: {
-        const findSingleRelatedKeyState = createSingleKeyStateFamily();
-        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
+        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
         const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
         const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
-          [stateKeyA]: findSingleRelatedKeyState,
-          [stateKeyB]: findMultipleRelatedKeysState
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
         };
         let states;
         if (defaultContent) {
-          const findSingleRelatedEntryState = createSingleEntryStateFamily();
-          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
+          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
           const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
           const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
             aSide
           )}`;
           const contentStates = {
-            [entriesStateKeyA]: findSingleRelatedEntryState,
-            [entriesStateKeyB]: findMultipleRelatedEntriesState
+            [entriesStateKeyA]: singleRelatedEntrySelectors,
+            [entriesStateKeyB]: multipleRelatedEntriesSelectors
           };
           states = Object.assign(baseStates, contentStates);
         } else {
@@ -428,16 +369,16 @@ var Join = class _Join {
         break;
       }
       default: {
-        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
         const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
         const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
-          [stateKeyA]: findMultipleRelatedKeysState,
-          [stateKeyB]: findMultipleRelatedKeysState
+          [stateKeyA]: multipleRelatedKeysSelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
         };
         let states;
         if (defaultContent) {
-          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
           const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
             bSide
           )}`;
@@ -445,8 +386,8 @@ var Join = class _Join {
             aSide
           )}`;
           const contentStates = {
-            [entriesStateKeyA]: findMultipleRelatedEntriesState,
-            [entriesStateKeyB]: findMultipleRelatedEntriesState
+            [entriesStateKeyA]: multipleRelatedEntriesSelectors,
+            [entriesStateKeyB]: multipleRelatedEntriesSelectors
           };
           states = Object.assign(baseStates, contentStates);
         } else {
@@ -459,8 +400,7 @@ var Join = class _Join {
   }
 };
 function join(options, defaultContent, store = IMPLICIT.STORE) {
-  const joins = getJoinMap(store);
-  joins.set(options.key, new Join(options, defaultContent, store));
+  store.joins.set(options.key, new Join(options, defaultContent, store));
   const token = {
     key: options.key,
     type: `join`,
@@ -470,26 +410,18 @@ function join(options, defaultContent, store = IMPLICIT.STORE) {
   };
   return token;
 }
-function getJoinMap(store) {
-  if (`joins` in store && store.joins instanceof Map) {
-    return store.joins;
-  }
-  const joins = /* @__PURE__ */ new Map();
-  store.joins = joins;
-  return joins;
-}
 function getJoin(token, store) {
-  const joinMap = getJoinMap(store);
-  let myJoin = joinMap.get(token.key);
-  if (myJoin === void 0) {
-    const rootJoinMap = getJoinMap(IMPLICIT.STORE);
-    myJoin = rootJoinMap.get(token.key)?.in(store);
-    if (myJoin === void 0) {
+  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}"`
       );
     }
-    joinMap.set(token.key, myJoin);
+    myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store);
+    store.joins.set(token.key, myJoin);
   }
   return myJoin;
 }
@@ -503,12 +435,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keyAB]() {
           const familyAB = myJoin.states[keyAB];
-          const state = myJoin.retrieve(familyAB, key);
+          const state = findInStore(store, familyAB, key);
           return state;
         },
         get [keyBA]() {
           const familyBA = myJoin.states[keyBA];
-          const state = myJoin.retrieve(familyBA, key);
+          const state = findInStore(store, familyBA, key);
           return state;
         }
       };
@@ -518,12 +450,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entryAB]() {
             const familyAB = myJoin.states[entryAB];
-            const state = myJoin.retrieve(familyAB, key);
+            const state = findInStore(store, familyAB, key);
             return state;
           },
           get [entryBA]() {
             const familyBA = myJoin.states[entryBA];
-            const state = myJoin.retrieve(familyBA, key);
+            const state = findInStore(store, familyBA, key);
             return state;
           }
         });
@@ -536,12 +468,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keyAB]() {
           const familyAB = myJoin.states[keyAB];
-          const state = myJoin.retrieve(familyAB, key);
+          const state = findInStore(store, familyAB, key);
           return state;
         },
         get [keysBA]() {
           const familyBA = myJoin.states[keysBA];
-          const state = myJoin.retrieve(familyBA, key);
+          const state = findInStore(store, familyBA, key);
           return state;
         }
       };
@@ -551,12 +483,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entryAB]() {
             const familyAB = myJoin.states[entryAB];
-            const state = myJoin.retrieve(familyAB, key);
+            const state = findInStore(store, familyAB, key);
             return state;
           },
           get [entriesBA]() {
             const familyBA = myJoin.states[entriesBA];
-            const state = myJoin.retrieve(familyBA, key);
+            const state = findInStore(store, familyBA, key);
             return state;
           }
         });
@@ -569,12 +501,12 @@ function findRelationsInStore(token, key, store) {
       relations = {
         get [keysAB]() {
           const familyAB = myJoin.states[keysAB];
-          const state = myJoin.retrieve(familyAB, key);
+          const state = findInStore(store, familyAB, key);
           return state;
         },
         get [keysBA]() {
           const familyBA = myJoin.states[keysBA];
-          const state = myJoin.retrieve(familyBA, key);
+          const state = findInStore(store, familyBA, key);
           return state;
         }
       };
@@ -584,12 +516,12 @@ function findRelationsInStore(token, key, store) {
         Object.assign(relations, {
           get [entriesAB]() {
             const familyAB = myJoin.states[entriesAB];
-            const state = myJoin.retrieve(familyAB, key);
+            const state = findInStore(store, familyAB, key);
             return state;
           },
           get [entriesBA]() {
             const familyBA = myJoin.states[entriesBA];
-            const state = myJoin.retrieve(familyBA, key);
+            const state = findInStore(store, familyBA, key);
             return state;
           }
         });
@@ -618,7 +550,7 @@ function editRelations(token, change) {
 }
 function getInternalRelationsFromStore(token, store) {
   const myJoin = getJoin(token, store);
-  const family = myJoin.core.findRelatedKeysState;
+  const family = myJoin.core.relatedKeysAtoms;
   return family;
 }
 function getInternalRelations(token) {
@@ -634,7 +566,7 @@ function struct(options, store = IMPLICIT.STORE) {
         key: `${options.key}.${key}`,
         default: options.default[key]
       },
-      void 0
+      undefined
     );
     return acc;
   }, {});
@@ -682,4 +614,4 @@ function until(loadable, fallback) {
   return loadable;
 }
 
-export { Join, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join, struct, structFamily, until };
+export { Join, dict, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, join, struct, structFamily, until };