atom.io 0.27.4 → 0.28.0

package/data/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as AtomIO from 'atom.io';
 import { ReadonlySelectorFamilyToken, MutableAtomFamilyToken, SetterToolkit, disposeState, ReadonlySelectorToken } from 'atom.io';
 import { Store, Molecule } from 'atom.io/internal';
-import { Canonical, stringified, Json } from 'atom.io/json';
+import { Canonical, stringified, Json as Json$1 } from 'atom.io/json';
 import { findState } from 'atom.io/ephemeral';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
@@ -10,20 +10,22 @@ declare function dict<State, Key extends Canonical>(family: AtomIO.ReadonlySelec
 }>;
 
 type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+declare namespace Json {
+    type Serializable = primitive | Readonly<{
+        [key: string]: Serializable;
+    }> | ReadonlyArray<Serializable>;
+    type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+    type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
+}
 
 type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
 type Cardinality = `1:1` | `1:n` | `n:n`;
 
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
+interface JunctionEntries<Content extends Json.Object | null> extends Json.Object {
     readonly relations: [string, string[]][];
     readonly contents: [string, Content][];
 }
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
+interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object {
     readonly between: [a: ASide, b: BSide];
     readonly cardinality: Cardinality;
 }
@@ -35,7 +37,7 @@ type BaseExternalStoreConfiguration = {
     getRelatedKeys: (key: string) => Set<string> | undefined;
     has: (a: string, b?: string) => boolean;
 };
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
+type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
     getContent: (contentKey: string) => Content | undefined;
     setContent: (contentKey: string, content: Content) => void;
     deleteContent: (contentKey: string) => void;
@@ -43,14 +45,14 @@ type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
 type Empty<Obj extends object> = {
     [Key in keyof Obj]?: undefined;
 };
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
+type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
+type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
     externalStore?: ExternalStoreConfiguration<Content>;
     isContent?: Refinement<unknown, Content>;
     makeContentKey?: (a: string, b: string) => string;
 };
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
+type JunctionJSON<ASide extends string, BSide extends string, Content extends Json.Object | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
+declare class Junction<const ASide extends string, const BSide extends string, const Content extends Json.Object | null = null> {
     readonly a: ASide;
     readonly b: BSide;
     readonly cardinality: Cardinality;
@@ -83,18 +85,18 @@ declare class Junction<const ASide extends string, const BSide extends string, c
     has(a: string, b?: string): boolean;
 }
 
-interface JoinOptions<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> extends Json.Object, JunctionSchema<ASide, BSide>, Partial<JunctionEntries<Content>> {
+interface JoinOptions<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json$1.Object | null> extends Json$1.Object, JunctionSchema<ASide, BSide>, Partial<JunctionEntries<Content>> {
     readonly key: string;
     readonly cardinality: Cardinality;
 }
-type JoinStateFamilies<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+type JoinStateFamilies<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json$1.Object | null> = Cardinality extends `1:1` ? (Content extends Json$1.Object ? {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntryOf${Capitalize<BSide>}` : `${AB}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
         string,
         Content
     ] | null, string>;
 } : {}) & {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeyOf${Capitalize<BSide>}` : `${AB}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<string | null, string>;
-} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
+} : Cardinality extends `1:n` ? (Content extends Json$1.Object ? {
     readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
         string,
         Content
@@ -108,7 +110,7 @@ type JoinStateFamilies<ASide extends string, BSide extends string, Cardinality e
     readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<string | null, string>;
 } & {
     readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<string[], string>;
-} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
+} : Cardinality extends `n:n` ? (Content extends Json$1.Object ? {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntriesOf${Capitalize<BSide>}` : `${AB}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
         string,
         Content
@@ -116,7 +118,7 @@ type JoinStateFamilies<ASide extends string, BSide extends string, Cardinality e
 } : {}) & {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeysOf${Capitalize<BSide>}` : `${AB}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<string[], string>;
 } : never;
-declare class Join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null> {
+declare class Join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json$1.Object | null = null> {
     private options;
     private defaultContent;
     private toolkit;
@@ -136,7 +138,7 @@ declare class Join<const ASide extends string, const BSide extends string, const
     in(store: Store): Join<ASide, BSide, Cardinality, Content>;
     constructor(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
 }
-type JoinToken<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
+type JoinToken<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json$1.Object | null = null> = {
     key: string;
     type: `join`;
     cardinality: Cardinality;
@@ -145,19 +147,19 @@ type JoinToken<ASide extends string, BSide extends string, Cardinality extends `
     __content?: Content;
 };
 declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, BSide, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, BSide, Cardinality, null>;
-declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, BSide, Cardinality, Content>;
+declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json$1.Object>(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, BSide, Cardinality, Content>;
 declare function getJoinMap(store: Store & {
     joins?: Map<string, Join<any, any, any, any>>;
 }): Map<string, Join<any, any, any, any>>;
-declare function getJoin<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, store: Store): Join<ASide, BSide, Cardinality, Content>;
-type JoinStates<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+declare function getJoin<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json$1.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, store: Store): Join<ASide, BSide, Cardinality, Content>;
+type JoinStates<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json$1.Object | null> = Cardinality extends `1:1` ? (Content extends Json$1.Object ? {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntryOf${Capitalize<BSide>}` : `${AB}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
         string,
         Content
     ] | null>;
 } : {}) & {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeyOf${Capitalize<BSide>}` : `${AB}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string | null>;
-} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
+} : Cardinality extends `1:n` ? (Content extends Json$1.Object ? {
     readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
         string,
         Content
@@ -171,7 +173,7 @@ type JoinStates<ASide extends string, BSide extends string, Cardinality extends
     readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<string | null>;
 } & {
     readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>;
-} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
+} : Cardinality extends `n:n` ? (Content extends Json$1.Object ? {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntriesOf${Capitalize<BSide>}` : `${AB}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
         string,
         Content
@@ -179,12 +181,12 @@ type JoinStates<ASide extends string, BSide extends string, Cardinality extends
 } : {}) & {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeysOf${Capitalize<BSide>}` : `${AB}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>;
 } : never;
-declare function findRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string, store: Store): JoinStates<ASide, BSide, Cardinality, Content>;
-declare function findRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string): JoinStates<ASide, BSide, Cardinality, Content>;
-declare function editRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void, store: Store): void;
-declare function editRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void): void;
+declare function findRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json$1.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string, store: Store): JoinStates<ASide, BSide, Cardinality, Content>;
+declare function findRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json$1.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string): JoinStates<ASide, BSide, Cardinality, Content>;
+declare function editRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json$1.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void, store: Store): void;
+declare function editRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json$1.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void): void;
 declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
-declare function getInternalRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+declare function getInternalRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json$1.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
 
 declare function struct<Struct extends {
     [key: string]: unknown;

package/data/dist/index.js

@@ -1,23 +1,20 @@
 import { Junction } from '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { createStandaloneSelector, findInStore, IMPLICIT, getFromStore, setIntoStore, seekInStore, getJsonToken, disposeFromStore, withdraw, growMoleculeInStore, NotFoundError, initFamilyMemberInStore, createMutableAtomFamily, createRegularAtomFamily, createMoleculeFamily, newest, makeMoleculeInStore, isChildStore, createRegularAtom, createSelectorFamily, createReadonlySelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { createStandaloneSelector, findInStore, IMPLICIT, withdraw, growMoleculeInStore, NotFoundError, initFamilyMemberInStore, getFromStore, setIntoStore, seekInStore, getJsonToken, disposeFromStore, createMutableAtomFamily, createRegularAtomFamily, createMoleculeFamily, newest, makeMoleculeInStore, isChildStore, createRegularAtom, createSelectorFamily, createReadonlySelectorFamily, getJsonFamily } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 function dict(family, index, store = IMPLICIT.STORE) {
-  return createStandaloneSelector(
-    {
-      key: `${family.key}Dict`,
-      get: ({ get }) => {
-        const keys = get(index);
-        return keys.reduce((acc, key) => {
-          acc[key] = get(findInStore(family, key, store));
-          return acc;
-        }, {});
-      }
-    },
-    store
-  );
+  return createStandaloneSelector(store, {
+    key: `${family.key}Dict`,
+    get: ({ get }) => {
+      const keys = get(index);
+      return keys.reduce((acc, key) => {
+        acc[key] = get(findInStore(store, family, key));
+        return acc;
+      }, {});
+    }
+  });
 }
 function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
@@ -60,18 +57,6 @@ var Join = class _Join {
     this.alternates = /* @__PURE__ */ new Map();
     this.alternates.set(store.config.name, this);
     this.store.miscResources.set(`join:${options.key}`, this);
-    this.toolkit = {
-      get: (...ps) => getFromStore(...ps, store),
-      set: (...ps) => {
-        setIntoStore(...ps, store);
-      },
-      find: (token, key) => findInStore(token, key, store),
-      seek: (token, key) => seekInStore(token, key, store),
-      json: (token) => getJsonToken(token, store),
-      dispose: (...ps) => {
-        disposeFromStore(...ps, store);
-      }
-    };
     this.retrieve = (token, key) => {
       const maybeToken = this.toolkit.seek(token, key);
       if (maybeToken) {
@@ -85,11 +70,24 @@ var Join = class _Join {
       if (store.config.lifespan === `immortal`) {
         throw new NotFoundError(token, key, store);
       }
-      return initFamilyMemberInStore(token, key, store);
+      return initFamilyMemberInStore(store, token, key);
+    };
+    this.toolkit = {
+      get: (...ps) => getFromStore(store, ...ps),
+      set: (...ps) => {
+        setIntoStore(store, ...ps);
+      },
+      find: this.retrieve,
+      seek: (...ps) => seekInStore(store, ...ps),
+      json: (token) => getJsonToken(store, token),
+      dispose: (...ps) => {
+        disposeFromStore(store, ...ps);
+      }
     };
     const aSide = options.between[0];
     const bSide = options.between[1];
     const relatedKeysAtoms = createMutableAtomFamily(
+      store,
       {
         key: `${options.key}/relatedKeys`,
         default: () => new SetRTX(),
@@ -97,7 +95,6 @@ var Join = class _Join {
         fromJson: (json) => SetRTX.fromJSON(json),
         toJson: (set) => set.toJSON()
       },
-      store,
       [`join`, `relations`]
     );
     this.core = { findRelatedKeysState: relatedKeysAtoms };
@@ -228,32 +225,28 @@ var Join = class _Join {
     let contentMolecules;
     if (defaultContent) {
       contentAtoms = createRegularAtomFamily(
+        store,
         {
           key: `${options.key}/content`,
           default: defaultContent
         },
-        store,
         [`join`, `content`]
       );
-      const joinToken = {
+      ({
         key: options.key,
         type: `join`,
         a: options.between[0],
         b: options.between[1],
         cardinality: options.cardinality
-      };
-      contentMolecules = createMoleculeFamily(
-        {
-          key: `${options.key}/content-molecules`,
-          new: class ContentMolecule {
-            constructor(toolkit, key) {
-              this.key = key;
-              toolkit.bond(joinToken, { as: null });
-            }
+      });
+      contentMolecules = createMoleculeFamily(store, {
+        key: `${options.key}/content-molecules`,
+        new: class ContentMolecule {
+          constructor(_, key) {
+            this.key = key;
           }
-        },
-        store
-      );
+        }
+      });
       const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
       const setContent = ({ set }, key, content) => {
         set(this.retrieve(contentAtoms, key), content);
@@ -309,6 +302,7 @@ var Join = class _Join {
       }
     });
     const createSingleKeyStateFamily = () => createReadonlySelectorFamily(
+      store,
       {
         key: `${options.key}/singleRelatedKey`,
         get: (key) => ({ get }) => {
@@ -320,11 +314,11 @@ var Join = class _Join {
           return null;
         }
       },
-      store,
       [`join`, `keys`]
     );
     const getMultipleKeyStateFamily = () => {
       return createReadonlySelectorFamily(
+        store,
         {
           key: `${options.key}/multipleRelatedKeys`,
           get: (key) => ({ get }) => {
@@ -334,11 +328,11 @@ var Join = class _Join {
             return json.members;
           }
         },
-        store,
         [`join`, `keys`]
       );
     };
     const createSingleEntryStateFamily = () => createReadonlySelectorFamily(
+      store,
       {
         key: `${options.key}/singleRelatedEntry`,
         get: (key) => ({ get }) => {
@@ -353,10 +347,10 @@ var Join = class _Join {
           return null;
         }
       },
-      store,
       [`join`, `entries`]
     );
     const getMultipleEntryStateFamily = () => createReadonlySelectorFamily(
+      store,
       {
         key: `${options.key}/multipleRelatedEntries`,
         get: (key) => ({ get }) => {
@@ -371,7 +365,6 @@ var Join = class _Join {
           });
         }
       },
-      store,
       [`join`, `entries`]
     );
     switch (options.cardinality) {
@@ -631,27 +624,24 @@ function struct(options, store = IMPLICIT.STORE) {
   const atoms = Object.keys(options.default).reduce((acc, key) => {
     const atomName = options.key + capitalize2(key) + `State`;
     acc[atomName] = createRegularAtom(
+      store,
       {
         key: `${options.key}.${key}`,
         default: options.default[key]
       },
-      void 0,
-      store
+      void 0
     );
     return acc;
   }, {});
-  const structState = createStandaloneSelector(
-    {
-      key: options.key,
-      get: ({ get }) => {
-        return Object.keys(options.default).reduce((acc, key) => {
-          acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
-          return acc;
-        }, {});
-      }
-    },
-    store
-  );
+  const structState = createStandaloneSelector(store, {
+    key: options.key,
+    get: ({ get }) => {
+      return Object.keys(options.default).reduce((acc, key) => {
+        acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
+        return acc;
+      }, {});
+    }
+  });
   return [atoms, structState];
 }
 var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
@@ -659,29 +649,23 @@ var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(
 function structFamily(options) {
   const atoms = Object.keys(options.default).reduce((acc, subKey) => {
     const atomFamilyName = nameFamily(options.key, subKey);
-    acc[atomFamilyName] = createRegularAtomFamily(
-      {
-        key: `${options.key}.${subKey}`,
-        default: options.default[subKey]
-      },
-      IMPLICIT.STORE
-    );
+    acc[atomFamilyName] = createRegularAtomFamily(IMPLICIT.STORE, {
+      key: `${options.key}.${subKey}`,
+      default: options.default[subKey]
+    });
     return acc;
   }, {});
-  const findStructState = createSelectorFamily(
-    {
-      key: options.key,
-      get: (id) => ({ find, get }) => {
-        return Object.keys(options.default).reduce((acc, subKey) => {
-          acc[subKey] = get(
-            find(atoms[nameFamily(options.key, subKey)], id)
-          );
-          return acc;
-        }, {});
-      }
-    },
-    IMPLICIT.STORE
-  );
+  const findStructState = createSelectorFamily(IMPLICIT.STORE, {
+    key: options.key,
+    get: (id) => ({ find, get }) => {
+      return Object.keys(options.default).reduce((acc, subKey) => {
+        acc[subKey] = get(
+          find(atoms[nameFamily(options.key, subKey)], id)
+        );
+        return acc;
+      }, {});
+    }
+  });
   return [atoms, findStructState];
 }
 

package/data/src/dict.ts

@@ -18,17 +18,14 @@ export function dict<State, Key extends Canonical>(
 		| AtomIO.WritableSelectorToken<Key[]>,
 	store: Store = IMPLICIT.STORE,
 ): AtomIO.ReadonlySelectorToken<{ [K in stringified<Key>]: State }> {
-	return createStandaloneSelector(
-		{
-			key: `${family.key}Dict`,
-			get: ({ get }) => {
-				const keys = get(index)
-				return keys.reduce((acc, key) => {
-					acc[key] = get(findInStore(family, key, store))
-					return acc
-				}, {} as any)
-			},
+	return createStandaloneSelector(store, {
+		key: `${family.key}Dict`,
+		get: ({ get }) => {
+			const keys = get(index)
+			return keys.reduce((acc, key) => {
+				acc[key] = get(findInStore(store, family, key))
+				return acc
+			}, {} as any)
 		},
-		store,
-	)
+	})
 }

package/data/src/join.ts

@@ -195,19 +195,6 @@ export class Join<
 
 		this.store.miscResources.set(`join:${options.key}`, this)
 
-		this.toolkit = {
-			get: ((...ps: Parameters<typeof getState>) =>
-				getFromStore(...ps, store)) as typeof getState,
-			set: ((...ps: Parameters<typeof setState>) => {
-				setIntoStore(...ps, store)
-			}) as typeof setState,
-			find: ((token, key) => findInStore(token, key, store)) as typeof findState,
-			seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
-			json: (token) => getJsonToken(token, store),
-			dispose: ((...ps: Parameters<typeof disposeState>) => {
-				disposeFromStore(...ps, store)
-			}) as typeof disposeState,
-		}
 		this.retrieve = ((
 			token: ReadableFamilyToken<any, any>,
 			key: Json.Serializable,
@@ -224,8 +211,23 @@ export class Join<
 			if (store.config.lifespan === `immortal`) {
 				throw new NotFoundError(token, key, store)
 			}
-			return initFamilyMemberInStore(token, key, store)
+			return initFamilyMemberInStore(store, token, key)
 		}) as typeof findState
+		this.toolkit = {
+			get: ((...ps: Parameters<typeof getState>) =>
+				getFromStore(store, ...ps)) as typeof getState,
+			set: ((...ps: Parameters<typeof setState>) => {
+				setIntoStore(store, ...ps)
+			}) as typeof setState,
+			find: this.retrieve,
+			seek: ((...ps: Parameters<typeof seekState>) =>
+				seekInStore(store, ...ps)) as typeof seekState,
+			json: (token) => getJsonToken(store, token),
+			dispose: ((...ps: Parameters<typeof disposeState>) => {
+				disposeFromStore(store, ...ps)
+			}) as typeof disposeState,
+		}
+
 		const aSide: ASide = options.between[0]
 		const bSide: BSide = options.between[1]
 		const relatedKeysAtoms = createMutableAtomFamily<
@@ -233,6 +235,7 @@ export class Join<
 			SetRTXJson<string>,
 			string
 		>(
+			store,
 			{
 				key: `${options.key}/relatedKeys`,
 				default: () => new SetRTX(),
@@ -240,7 +243,6 @@ export class Join<
 				fromJson: (json) => SetRTX.fromJSON(json),
 				toJson: (set) => set.toJSON(),
 			},
-			store,
 			[`join`, `relations`],
 		)
 		this.core = { findRelatedKeysState: relatedKeysAtoms }
@@ -396,11 +398,11 @@ export class Join<
 		>
 		if (defaultContent) {
 			contentAtoms = createRegularAtomFamily<Content, string>(
+				store,
 				{
 					key: `${options.key}/content`,
 					default: defaultContent,
 				},
-				store,
 				[`join`, `content`],
 			)
 			const joinToken = {
@@ -410,20 +412,15 @@ export class Join<
 				b: options.between[1],
 				cardinality: options.cardinality,
 			} as const satisfies JoinToken<ASide, BSide, Cardinality, Content>
-			contentMolecules = createMoleculeFamily(
-				{
-					key: `${options.key}/content-molecules`,
-					new: class ContentMolecule {
-						public constructor(
-							toolkit: CtorToolkit<string>,
-							public key: string,
-						) {
-							toolkit.bond(joinToken, { as: null } as any)
-						}
-					},
+			contentMolecules = createMoleculeFamily(store, {
+				key: `${options.key}/content-molecules`,
+				new: class ContentMolecule {
+					public constructor(
+						_: CtorToolkit<string>,
+						public key: string,
+					) {}
 				},
-				store,
-			)
+			})
 			const getContent: Read<(key: string) => Content | null> = ({ get }, key) =>
 				get(this.retrieve(contentAtoms, key))
 			const setContent: Write<(key: string, content: Content) => void> = (
@@ -490,6 +487,7 @@ export class Join<
 
 		const createSingleKeyStateFamily = () =>
 			createReadonlySelectorFamily<string | null, string>(
+				store,
 				{
 					key: `${options.key}/singleRelatedKey`,
 					get:
@@ -503,11 +501,11 @@ export class Join<
 							return null
 						},
 				},
-				store,
 				[`join`, `keys`],
 			)
 		const getMultipleKeyStateFamily = () => {
 			return createReadonlySelectorFamily<string[], string>(
+				store,
 				{
 					key: `${options.key}/multipleRelatedKeys`,
 					get:
@@ -519,12 +517,12 @@ export class Join<
 							return json.members
 						},
 				},
-				store,
 				[`join`, `keys`],
 			)
 		}
 		const createSingleEntryStateFamily = () =>
 			createReadonlySelectorFamily<[string, Content] | null, string>(
+				store,
 				{
 					key: `${options.key}/singleRelatedEntry`,
 					get:
@@ -541,11 +539,11 @@ export class Join<
 							return null
 						},
 				},
-				store,
 				[`join`, `entries`],
 			)
 		const getMultipleEntryStateFamily = () =>
 			createReadonlySelectorFamily<[string, Content][], string>(
+				store,
 				{
 					key: `${options.key}/multipleRelatedEntries`,
 					get:
@@ -562,7 +560,6 @@ export class Join<
 							})
 						},
 				},
-				store,
 				[`join`, `entries`],
 			)
 

package/data/src/struct-family.ts

@@ -29,31 +29,25 @@ export function structFamily<
 		>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>
 	} = Object.keys(options.default).reduce((acc, subKey) => {
 		const atomFamilyName = nameFamily(options.key, subKey)
-		acc[atomFamilyName] = createRegularAtomFamily(
-			{
-				key: `${options.key}.${subKey}`,
-				default: (options.default as any)[subKey],
-			},
-			IMPLICIT.STORE,
-		)
+		acc[atomFamilyName] = createRegularAtomFamily(IMPLICIT.STORE, {
+			key: `${options.key}.${subKey}`,
+			default: (options.default as any)[subKey],
+		})
 		return acc
 	}, {} as any)
 	const findStructState: AtomIO.ReadonlySelectorFamilyToken<Struct, string> =
-		createSelectorFamily(
-			{
-				key: options.key,
-				get:
-					(id) =>
-					({ find, get }) => {
-						return Object.keys(options.default).reduce((acc, subKey) => {
-							acc[subKey] = get(
-								find((atoms as any)[nameFamily(options.key, subKey)], id),
-							)
-							return acc
-						}, {} as any)
-					},
-			},
-			IMPLICIT.STORE,
-		)
+		createSelectorFamily(IMPLICIT.STORE, {
+			key: options.key,
+			get:
+				(id) =>
+				({ find, get }) => {
+					return Object.keys(options.default).reduce((acc, subKey) => {
+						acc[subKey] = get(
+							find((atoms as any)[nameFamily(options.key, subKey)], id),
+						)
+						return acc
+					}, {} as any)
+				},
+		})
 	return [atoms, findStructState]
 }