atom.io 0.23.5 → 0.24.0

package/internal/dist/index.js

@@ -1,10 +1,8 @@
 import { Junction } from '../../dist/chunk-FTONNX2R.js';
-import { parseJson } from '../../dist/chunk-OAYGID5B.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-F2X4B4VY.js';
-import { stringifyJson, selectJson, parseJson as parseJson$1, selectJsonFamily } from 'atom.io/json';
+import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
-import { disposeMolecule, makeMoleculeInStore } from 'atom.io/immortal';
-import * as Internal from 'atom.io/internal';
+import { getJoin } from 'atom.io/data';
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -63,26 +61,14 @@ function newest(scion) {
 
 // internal/src/store/deposit.ts
 function deposit(state) {
-  const { type } = state;
-  switch (type) {
-    case `atom`:
-    case `molecule_family`:
-    case `mutable_atom`:
-    case `selector`:
-    case `readonly_selector`:
-    case `transaction`: {
-      const token = {
-        key: state.key,
-        type: state.type
-      };
-      if (`family` in state) {
-        token.family = state.family;
-      }
-      return token;
-    }
-    case `molecule`:
-      return state.token;
+  const token = {
+    key: state.key,
+    type: state.type
+  };
+  if (`family` in state) {
+    token.family = state.family;
   }
+  return token;
 }
 
 // internal/src/subject.ts
@@ -437,21 +423,27 @@ function createSelectorFamily(options, store) {
   }
   return createReadonlySelectorFamily(options, store);
 }
-function disposeFromStore(token, store = Internal.IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      Internal.disposeAtom(token, store);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      Internal.disposeSelector(token, store);
-      break;
-    case `molecule`:
-      disposeMolecule(token, store);
-      break;
+
+// internal/src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  const target = newest(store);
+  if (!isChildStore(target)) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
   }
-}
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
+  );
+  target.parent.child = null;
+};
 
 // internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
@@ -479,27 +471,6 @@ var NotFoundError = class extends Error {
   }
 };
 
-// internal/src/transaction/abort-transaction.ts
-var abortTransaction = (store) => {
-  const target = newest(store);
-  if (!isChildStore(target)) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  store.logger.info(
-    `\u{1FA82}`,
-    `transaction`,
-    target.transactionMeta.update.key,
-    `Aborting transaction`
-  );
-  target.parent.child = null;
-};
-
 // internal/src/transaction/act-upon-store.ts
 function actUponStore(token, id, store) {
   return (...parameters) => {
@@ -770,6 +741,155 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
   }
   setIntoStore(token, value, store);
 }
+
+// internal/src/molecule/create-molecule-family.ts
+function createMoleculeFamily(options, store) {
+  var _a;
+  const subject = new Subject();
+  const token = {
+    type: `molecule_family`,
+    key: options.key,
+    dependsOn: (_a = options.dependsOn) != null ? _a : `all`
+  };
+  const family = __spreadProps(__spreadValues({}, token), {
+    subject,
+    new: options.new
+  });
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
+
+// internal/src/molecule/grow-molecule-in-store.ts
+function growMoleculeInStore(molecule, family, store) {
+  const stateToken = initFamilyMemberInStore(family, molecule.key, store);
+  molecule.tokens.set(stateToken.key, stateToken);
+  const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    store.transactionMeta.update.updates.push({
+      type: `state_creation`,
+      token: stateToken
+    });
+  } else {
+    molecule.subject.next({ type: `state_creation`, token: stateToken });
+  }
+  return stateToken;
+}
+
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    store
+  };
+}
+
+// internal/src/get-state/get-from-store.ts
+function getFromStore(token, store) {
+  const state = withdraw(token, store);
+  return readOrComputeValue(state, store);
+}
+var Molecule = class {
+  constructor(ctx, key, family) {
+    this.key = key;
+    this.type = `molecule`;
+    this.subject = new Subject();
+    this.tokens = /* @__PURE__ */ new Map();
+    this.above = /* @__PURE__ */ new Map();
+    this.below = /* @__PURE__ */ new Map();
+    this.joins = /* @__PURE__ */ new Map();
+    this.stringKey = stringifyJson(key);
+    if (family) {
+      this.family = family;
+    }
+    if (ctx) {
+      if (Array.isArray(ctx)) {
+        for (const molecule of ctx) {
+          this.above.set(molecule.stringKey, molecule);
+        }
+      } else {
+        this.above.set(ctx.stringKey, ctx);
+      }
+    }
+  }
+};
+
+// internal/src/molecule/make-molecule-in-store.ts
+function makeMoleculeInStore(store, context, familyToken, key, ...params) {
+  const target = newest(store);
+  const token = {
+    type: `molecule`,
+    key,
+    family: familyToken
+  };
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => {
+    if (ctx instanceof Molecule) {
+      return ctx;
+    }
+    const stringKey = stringifyJson(ctx.key);
+    const molecule2 = store.molecules.get(stringKey);
+    if (!molecule2) {
+      throw new Error(
+        `Molecule ${stringKey} not found in store "${store.config.name}"`
+      );
+    }
+    return molecule2;
+  });
+  const family = withdraw(familyToken, store);
+  const molecule = new Molecule(owners, key, family);
+  target.molecules.set(stringifyJson(key), molecule);
+  for (const owner of owners) {
+    owner.below.set(molecule.stringKey, molecule);
+  }
+  const transactors = {
+    get: (t) => getFromStore(t, newest(store)),
+    set: (t, newValue) => {
+      setIntoStore(t, newValue, newest(store));
+    },
+    seek: (t, k) => seekInStore(t, k, newest(store)),
+    json: (t) => getJsonToken(t, newest(store)),
+    run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
+    make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(store), ctx, f, k, ...args),
+    dispose: (t) => {
+      disposeFromStore(t, newest(store));
+    },
+    env: () => getEnvironmentData(newest(store)),
+    bond: (f) => growMoleculeInStore(
+      molecule,
+      withdraw(f, store),
+      newest(store)
+    ),
+    join: (joinToken) => {
+      const join = getJoin(joinToken, store);
+      join.molecules.set(stringifyJson(key), molecule);
+      molecule.joins.set(joinToken.key, join);
+    },
+    spawn: (f, k, ...p) => makeMoleculeInStore(
+      newest(store),
+      [molecule],
+      withdraw(f, store),
+      k,
+      ...p
+    )
+  };
+  const Constructor = family.new;
+  molecule.instance = new Constructor(transactors, token.key, ...params);
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family,
+    context: contextArray,
+    params
+  };
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(update);
+  } else {
+    family.subject.next(update);
+  }
+  return token;
+}
+
+// internal/src/ingest-updates/ingest-creation-disposal.ts
 function ingestCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
@@ -801,13 +921,13 @@ function createInStore(token, store) {
     if (family) {
       const molecule = store.molecules.get(token.family.subKey);
       if (molecule) {
-        molecule.bond(family);
+        growMoleculeInStore(molecule, family, store);
         return;
       }
       if (store.config.lifespan === `immortal`) {
         throw new Error(`No molecule found for key "${token.family.subKey}"`);
       }
-      initFamilyMember(family, parseJson(token.family.subKey), store);
+      initFamilyMemberInStore(family, parseJson(token.family.subKey), store);
     }
   }
 }
@@ -823,14 +943,14 @@ function ingestMoleculeCreationEvent(update, applying, store) {
       );
       break;
     case `oldValue`:
-      disposeMolecule(update.token, store);
+      disposeFromStore(update.token, store);
       break;
   }
 }
 function ingestMoleculeDisposalEvent(update, applying, store) {
   switch (applying) {
     case `newValue`:
-      disposeMolecule(update.token, store);
+      disposeFromStore(update.token, store);
       break;
     case `oldValue`:
       makeMoleculeInStore(
@@ -968,21 +1088,6 @@ function assignTransactionToContinuity(continuityKey, transactionKey, store) {
   }
 }
 
-// internal/src/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    window: typeof window === `undefined` ? void 0 : window,
-    global: typeof global === `undefined` ? void 0 : global,
-    store
-  };
-}
-
-// internal/src/get-state/get-from-store.ts
-function getFromStore(token, store) {
-  const state = withdraw(token, store);
-  return readOrComputeValue(state, store);
-}
-
 // internal/src/lazy-map.ts
 var LazyMap = class extends Map {
   constructor(source) {
@@ -1138,8 +1243,88 @@ function getEpochNumberOfAction(transactionKey, store) {
 // internal/src/transaction/index.ts
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
+// internal/src/molecule/dispose-molecule.ts
+function disposeMolecule(token, store) {
+  var _a;
+  let molecule;
+  try {
+    molecule = withdraw(token, store);
+  } catch (thrown) {
+    if (thrown instanceof Error) {
+      store.logger.error(
+        `\u{1F41E}`,
+        `molecule`,
+        JSON.stringify(token.key),
+        `Failed to dispose molecule, because it was not found in the store.`,
+        thrown.message
+      );
+    }
+    return;
+  }
+  const { family } = token;
+  if (family) {
+    const Formula = withdraw(family, store);
+    const disposalEvent = {
+      type: `molecule_disposal`,
+      token,
+      family,
+      context: [...molecule.above.values()].map((m) => deposit(m)),
+      familyKeys: [...molecule.tokens.values()].map((t) => {
+        var _a2;
+        return (_a2 = t.family) == null ? void 0 : _a2.key;
+      }).filter((k) => typeof k === `string`)
+    };
+    if (token.family) {
+      disposalEvent.family = token.family;
+    }
+    const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
+    if (isTransaction) {
+      store.transactionMeta.update.updates.push(disposalEvent);
+    } else {
+      Formula.subject.next(disposalEvent);
+    }
+    store.molecules.delete(molecule.stringKey);
+  }
+  for (const state of molecule.tokens.values()) {
+    disposeFromStore(state, store);
+  }
+  for (const child of molecule.below.values()) {
+    if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
+      disposeMolecule(child, store);
+    } else {
+      child.above.delete(molecule.stringKey);
+      if (child.above.size === 0) {
+        disposeMolecule(child, store);
+      }
+    }
+  }
+  for (const join of molecule.joins.values()) {
+    join.molecules.delete(molecule.stringKey);
+  }
+  for (const parent of molecule.above.values()) {
+    parent.below.delete(molecule.stringKey);
+  }
+}
+
+// internal/src/families/dispose-from-store.ts
+function disposeFromStore(token, store = IMPLICIT.STORE) {
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      disposeAtom(token, store);
+      break;
+    case `selector`:
+    case `readonly_selector`:
+      disposeSelector(token, store);
+      break;
+    case `molecule`:
+      disposeMolecule(token, store);
+      break;
+  }
+}
+
 // internal/src/families/init-family-member.ts
-function initFamilyMember(token, key, store) {
+function initFamilyMemberInStore(token, key, store) {
   const familyKey = token.key;
   const family = store.families.get(familyKey);
   if (family === void 0) {
@@ -1207,7 +1392,7 @@ function findInStore(token, key, store) {
   if (state) {
     return state;
   }
-  state = initFamilyMember(token, key, store);
+  state = initFamilyMemberInStore(token, key, store);
   return state;
 }
 
@@ -1424,7 +1609,7 @@ function createStandaloneSelector(options, store) {
 }
 
 // internal/src/selector/dispose-selector.ts
-function disposeSelector2(selectorToken, store) {
+function disposeSelector(selectorToken, store) {
   var _a;
   const target = newest(store);
   const { key } = selectorToken;
@@ -1482,7 +1667,7 @@ function disposeSelector2(selectorToken, store) {
     );
     for (const downstreamToken of downstreamTokens) {
       if (downstreamToken) {
-        disposeSelector2(downstreamToken, store);
+        disposeSelector(downstreamToken, store);
       }
     }
     target.selectorGraph.delete(key);
@@ -1846,7 +2031,7 @@ var FamilyTracker = class {
       `store=${store.config.name}::tracker-atom-family`,
       (event) => {
         if (event.token.family) {
-          const key = parseJson$1(event.token.family.subKey);
+          const key = parseJson(event.token.family.subKey);
           seekInStore(this.latestUpdateAtoms, key, store);
           new Tracker(event.token, store);
         }
@@ -1856,7 +2041,7 @@ var FamilyTracker = class {
       `store=${store.config.name}::tracker-atom-family`,
       (event) => {
         if (event.token.family) {
-          const key = parseJson$1(event.token.family.subKey);
+          const key = parseJson(event.token.family.subKey);
           const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
           if (mutableAtomToken) {
             new Tracker(mutableAtomToken, store);
@@ -2120,7 +2305,7 @@ function createStandaloneAtom(options, store) {
 }
 
 // internal/src/atom/dispose-atom.ts
-function disposeAtom2(atomToken, store) {
+function disposeAtom(atomToken, store) {
   var _a, _b;
   const target = newest(store);
   const { key } = atomToken;
@@ -2150,7 +2335,7 @@ function disposeAtom2(atomToken, store) {
       for (const selectorKey of selectorKeys) {
         const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
         if (token) {
-          disposeSelector2(token, store);
+          disposeSelector(token, store);
         }
       }
     }
@@ -2159,7 +2344,7 @@ function disposeAtom2(atomToken, store) {
     target.timelineAtoms.delete(key);
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
-      disposeAtom2(updateToken, store);
+      disposeAtom(updateToken, store);
       store.trackers.delete(key);
     }
     store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
@@ -2494,7 +2679,7 @@ function createTimeline(options, store, data) {
                           tl.history.push(event);
                           tl.at = tl.history.length;
                           tl.subject.next(event);
-                          for (const token2 of molecule.tokens) {
+                          for (const token2 of molecule.tokens.values()) {
                             switch (token2.type) {
                               case `atom`:
                               case `mutable_atom`:
@@ -2644,4 +2829,4 @@ var timeTravel = (action, token, store) => {
   );
 };
 
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom2 as disposeAtom, disposeFromStore, disposeSelector2 as disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMember, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/src/families/dispose-from-store.ts

@@ -1,19 +1,23 @@
-import type { ReadableToken } from "atom.io"
-import { disposeMolecule, type MoleculeToken } from "atom.io/immortal"
-import * as Internal from "atom.io/internal"
+import type { MoleculeToken, ReadableToken } from "atom.io"
+
+import { disposeAtom } from "../atom"
+import { disposeMolecule } from "../molecule/dispose-molecule"
+import { disposeSelector } from "../selector"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
 
 export function disposeFromStore(
-	token: MoleculeToken<any, any, any> | ReadableToken<any>,
-	store: Internal.Store = Internal.IMPLICIT.STORE,
+	token: MoleculeToken<any> | ReadableToken<any>,
+	store: Store = IMPLICIT.STORE,
 ): void {
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:
-			Internal.disposeAtom(token, store)
+			disposeAtom(token, store)
 			break
 		case `selector`:
 		case `readonly_selector`:
-			Internal.disposeSelector(token, store)
+			disposeSelector(token, store)
 			break
 		case `molecule`:
 			disposeMolecule(token, store)

package/internal/src/families/find-in-store.ts

@@ -20,7 +20,7 @@ import type { Json } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
 import type { Store } from "../store"
-import { initFamilyMember } from "./init-family-member"
+import { initFamilyMemberInStore } from "./init-family-member"
 import { seekInStore } from "./seek-in-store"
 
 export function findInStore<
@@ -90,6 +90,6 @@ export function findInStore(
 	if (state) {
 		return state
 	}
-	state = initFamilyMember(token, key, store)
+	state = initFamilyMemberInStore(token, key, store)
 	return state
 }

package/internal/src/families/init-family-member.ts

@@ -24,7 +24,7 @@ import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { isChildStore } from "../transaction"
 
-export function initFamilyMember<
+export function initFamilyMemberInStore<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 	K extends Json.Serializable,
@@ -35,49 +35,61 @@ export function initFamilyMember<
 	store: Store,
 ): MutableAtomToken<T, J>
 
-export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+export function initFamilyMemberInStore<
+	T,
+	K extends Json.Serializable,
+	Key extends K,
+>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): RegularAtomToken<T>
 
-export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
-	token: AtomFamilyToken<T, K>,
-	key: Key,
-	store: Store,
-): AtomToken<T>
+export function initFamilyMemberInStore<
+	T,
+	K extends Json.Serializable,
+	Key extends K,
+>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>
 
-export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+export function initFamilyMemberInStore<
+	T,
+	K extends Json.Serializable,
+	Key extends K,
+>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableSelectorToken<T>
 
-export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+export function initFamilyMemberInStore<
+	T,
+	K extends Json.Serializable,
+	Key extends K,
+>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): ReadonlySelectorToken<T>
 
-export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
-	token: SelectorFamilyToken<T, K>,
-	key: Key,
-	store: Store,
-): SelectorToken<T>
+export function initFamilyMemberInStore<
+	T,
+	K extends Json.Serializable,
+	Key extends K,
+>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>
 
-export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
-	token: WritableFamilyToken<T, K>,
-	key: Key,
-	store: Store,
-): WritableToken<T>
+export function initFamilyMemberInStore<
+	T,
+	K extends Json.Serializable,
+	Key extends K,
+>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>
 
-export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
-	token: ReadableFamilyToken<T, K>,
-	key: Key,
-	store: Store,
-): ReadableToken<T>
+export function initFamilyMemberInStore<
+	T,
+	K extends Json.Serializable,
+	Key extends K,
+>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>
 
-export function initFamilyMember(
+export function initFamilyMemberInStore(
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 	store: Store,