atom.io 0.29.0 → 0.29.2

package/dist/{chunk-XPYU2HY2.js → chunk-J4B56MM5.js}

@@ -14,6 +14,7 @@ var Future = class extends Promise {
   fate;
   resolve;
   reject;
+  done = false;
   constructor(executor) {
     let superResolve;
     let superReject;
@@ -28,11 +29,13 @@ var Future = class extends Promise {
   pass(promise, value) {
     if (promise === this.fate) {
       this.resolve(value);
+      this.done = true;
     }
   }
   fail(promise, reason) {
     if (promise === this.fate) {
       this.reject(reason);
+      this.done = true;
     }
   }
   use(value) {
@@ -505,14 +508,33 @@ function createAtomFamily(store, options) {
   return createRegularAtomFamily(store, options);
 }
 
+// internal/src/families/get-family-of-token.ts
+function getFamilyOfToken(store, token) {
+  if (token.family) {
+    const family = store.families.get(token.family.key);
+    if (family) {
+      return family;
+    }
+  }
+}
+
 // 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];
+    if (token.type !== `molecule`) {
+      family = getFamilyOfToken(store, token) ?? null;
+      if (family) {
+        key = token.family ? parseJson(token.family.subKey) : null;
+        token = findInStore(store, family, key);
+      }
+    }
   } else {
-    const family = params[0];
-    const key = params[1];
+    family = params[0];
+    key = params[1];
     let maybeToken;
     if (family.type === `molecule_family`) {
       maybeToken = seekInStore(store, family, key) ?? counterfeit(family, key);
@@ -522,7 +544,7 @@ function getFromStore(store, ...params) {
     token = maybeToken;
   }
   if (`counterfeit` in token && `family` in token) {
-    const family = token.type === `molecule` ? withdraw(token.family, store) : (
+    family = token.type === `molecule` ? withdraw(token.family, store) : (
       // biome-ignore lint/style/noNonNullAssertion: family must be present
       store.families.get(token.family.key)
     );
@@ -1248,8 +1270,7 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
 
 // internal/src/families/init-family-member.ts
 function initFamilyMemberInStore(store, token, key) {
-  const familyKey = token.key;
-  const family = store.families.get(familyKey);
+  const family = store.families.get(token.key);
   if (family === void 0) {
     throw new NotFoundError(token, store);
   }
@@ -1379,16 +1400,22 @@ ${disposal.trace}` : `No previous disposal trace was found.`
 // internal/src/set-state/set-into-store.ts
 function setIntoStore(store, ...params) {
   let token;
+  let family;
+  let key;
   let value;
   if (params.length === 2) {
     token = params[0];
     value = params[1];
+    family = getFamilyOfToken(store, token) ?? null;
+    if (family) {
+      key = token.family ? parseJson(token.family.subKey) : null;
+      token = findInStore(store, family, key);
+    }
   } else {
-    const family = params[0];
-    const key = params[1];
+    family = params[0];
+    key = params[1];
     value = params[2];
-    const maybeToken = findInStore(store, family, key);
-    token = maybeToken;
+    token = findInStore(store, family, key);
   }
   if (`counterfeit` in token) {
     const disposal = store.disposalTraces.buffer.find(

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Transceiver, Func, EnvironmentData, Flat, Subject, Store, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
-import { Json, JsonInterface, Canonical } from 'atom.io/json';
+import { Json, JsonInterface, Canonical, stringified } from 'atom.io/json';
 import { MoleculeConstructor as MoleculeConstructor$1, MoleculeToken as MoleculeToken$1, MoleculeFamilyToken as MoleculeFamilyToken$1, MoleculeParams as MoleculeParams$1, getState as getState$1, setState as setState$1, makeMolecule as makeMolecule$1, ActorToolkit as ActorToolkit$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, MoleculeCreation as MoleculeCreation$1, MoleculeDisposal as MoleculeDisposal$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
 import { seekState } from 'atom.io/immortal';
@@ -391,40 +391,40 @@ declare function belongsTo<Family extends ReadonlySelectorFamilyToken$1<any, any
 declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is WritableToken$1<TokenType<Family>>;
 declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
 
-type RegularAtomToken<T> = {
+type RegularAtomToken<T, K extends Canonical = any> = {
     key: string;
     type: `atom`;
-    family?: FamilyMetadata;
+    family?: FamilyMetadata<K>;
     __T?: T;
 };
-type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable> = {
+type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
     key: string;
     type: `mutable_atom`;
-    family?: FamilyMetadata;
+    family?: FamilyMetadata<K>;
     __J?: J;
     __U?: T extends Transceiver<infer Update> ? Update : never;
 };
-type AtomToken<T> = MutableAtomToken<T extends Transceiver<any> ? T : never, any> | RegularAtomToken<T>;
-type WritableSelectorToken<T> = {
+type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+type WritableSelectorToken<T, K extends Canonical = any> = {
     key: string;
     type: `selector`;
-    family?: FamilyMetadata;
+    family?: FamilyMetadata<K>;
     __T?: T;
 };
-type ReadonlySelectorToken<T> = {
+type ReadonlySelectorToken<T, K extends Canonical = any> = {
     key: string;
     type: `readonly_selector`;
-    family?: FamilyMetadata;
+    family?: FamilyMetadata<K>;
     __T?: T;
 };
-type SelectorToken<T> = ReadonlySelectorToken<T> | WritableSelectorToken<T>;
-type WritableToken<T> = AtomToken<T> | WritableSelectorToken<T>;
-type ReadableToken<T> = AtomToken<T> | SelectorToken<T>;
+type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
+type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
 type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
 type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
-type FamilyMetadata = {
+type FamilyMetadata<K extends Canonical = any> = {
     key: string;
-    subKey: string;
+    subKey: stringified<K>;
 };
 
 export { type ActorToolkit, type AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, type SelectorFamilyToken, type SelectorToken, type SetterToolkit, Silo, type StateCreation, type StateDisposal, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type UpdateHandler, type WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/ephemeral/dist/index.d.ts

@@ -10,7 +10,7 @@ import { Json, Canonical } from 'atom.io/json';
  * @returns
  * The current value of the state.
  */
-declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -18,7 +18,7 @@ declare function findState<T extends Transceiver<any>, J extends Json.Serializab
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -26,7 +26,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Regular
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -34,7 +34,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Writabl
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -42,7 +42,7 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Readonl
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
 /**
  * @public
  * Finds a {@link ReadableToken} in the store.
@@ -52,6 +52,6 @@ declare function findState<T, K extends Canonical, Key extends K>(token: Writabl
  * The current value of the state.
  * @overload Unknown
  */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
 
 export { findState };

package/ephemeral/src/find-state.ts

@@ -29,7 +29,7 @@ export function findState<
 	J extends Json.Serializable,
 	K extends Canonical,
 	Key extends K,
->(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
+>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -40,7 +40,7 @@ export function findState<
 export function findState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T>
+): RegularAtomToken<T, K>
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -51,7 +51,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T>
+): WritableSelectorToken<T, K>
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -62,7 +62,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T>
+): ReadonlySelectorToken<T, K>
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -73,7 +73,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T>
+): WritableToken<T, K>
 /**
  * @public
  * Finds a {@link ReadableToken} in the store.
@@ -86,7 +86,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T>
+): ReadableToken<T, K>
 
 export function findState(
 	token: ReadableFamilyToken<any, any>,

package/immortal/dist/index.d.ts

@@ -2,12 +2,12 @@ import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, Regul
 import { Transceiver } from 'atom.io/internal';
 import { Json, Canonical } from 'atom.io/json';
 
-declare function seekState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
+declare function seekState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
 declare function seekState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeToken<M> | undefined;
 
 export { seekState };

package/immortal/src/seek-state.ts

@@ -28,32 +28,32 @@ export function seekState<
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-): MutableAtomToken<T, J> | undefined
+): MutableAtomToken<T, J, K> | undefined
 
 export function seekState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T> | undefined
+): RegularAtomToken<T, K> | undefined
 
 export function seekState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T> | undefined
+): WritableSelectorToken<T, K> | undefined
 
 export function seekState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T> | undefined
+): ReadonlySelectorToken<T, K> | undefined
 
 export function seekState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T> | undefined
+): WritableToken<T, K> | undefined
 
 export function seekState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T> | undefined
+): ReadableToken<T, K> | undefined
 
 export function seekState<M extends MoleculeConstructor>(
 	token: MoleculeFamilyToken<M>,

package/internal/dist/index.d.ts

@@ -426,6 +426,7 @@ declare class Future<T> extends Promise<T> {
     private fate;
     private resolve;
     private reject;
+    done: boolean;
     constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
     private pass;
     private fail;
@@ -451,32 +452,32 @@ declare function disposeFromStore(store: Store, token: MoleculeToken<any> | Read
 declare function disposeFromStore<K extends Canonical>(store: Store, token: ReadableFamilyToken<any, K>, key: K): void;
 declare function disposeFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
 
-declare function findInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
-
-declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
-
-declare function seekInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
+declare function findInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
+
+declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
+
+declare function seekInStore<T extends Transceiver<any>, J extends Json$1.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
 declare function seekInStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeKey<M> | undefined;
 
 type EnvironmentData = {

package/internal/dist/index.js

@@ -1,3 +1,3 @@
-export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-XPYU2HY2.js';
+export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-J4B56MM5.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';

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

@@ -49,7 +49,7 @@ export function disposeFromStore(
 		const key = params[1]
 		const maybeToken =
 			family.type === `molecule_family`
-				? seekInStore(store, family, key) ?? counterfeit(family, key)
+				? (seekInStore(store, family, key) ?? counterfeit(family, key))
 				: findInStore(store, family, key)
 		token = maybeToken
 	}

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

@@ -33,49 +33,49 @@ export function findInStore<
 	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-): MutableAtomToken<T, J>
+): MutableAtomToken<T, J, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T>
+): RegularAtomToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-): AtomToken<T>
+): AtomToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T>
+): WritableSelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T>
+): ReadonlySelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-): SelectorToken<T>
+): SelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T>
+): WritableToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T>
+): ReadableToken<T, K>
 
 export function findInStore(
 	store: Store,

package/internal/src/families/get-family-of-token.ts

@@ -0,0 +1,64 @@
+import type {
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Canonical, Json } from "atom.io/json"
+
+import type { Transceiver } from "../mutable"
+import type { Store } from "../store"
+
+export function getFamilyOfToken<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Canonical,
+>(
+	store: Store,
+	token: MutableAtomToken<T, J, K>,
+): MutableAtomFamilyToken<T, J, K> | undefined
+
+export function getFamilyOfToken<T, K extends Canonical>(
+	store: Store,
+	token: RegularAtomToken<T, K>,
+): RegularAtomFamilyToken<T, K> | undefined
+
+export function getFamilyOfToken<T, K extends Canonical>(
+	store: Store,
+	token: WritableSelectorToken<T, K>,
+): WritableSelectorFamilyToken<T, K> | undefined
+
+export function getFamilyOfToken<T, K extends Canonical>(
+	store: Store,
+	token: ReadonlySelectorToken<T, K>,
+): ReadonlySelectorFamilyToken<T, K> | undefined
+
+export function getFamilyOfToken<T, K extends Canonical>(
+	store: Store,
+	token: WritableToken<T, K>,
+): WritableFamilyToken<T, K> | undefined
+
+export function getFamilyOfToken<T, K extends Canonical>(
+	store: Store,
+	token: ReadableToken<T, K>,
+): ReadableFamilyToken<T, K> | undefined
+
+export function getFamilyOfToken(
+	store: Store,
+	token: ReadableToken<any, any>,
+): ReadableFamilyToken<any, any> | undefined {
+	if (token.family) {
+		const family = store.families.get(token.family.key)
+		if (family) {
+			return family
+		}
+	}
+}

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

@@ -33,57 +33,56 @@ export function initFamilyMemberInStore<
 	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-): MutableAtomToken<T, J>
+): MutableAtomToken<T, J, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T>
+): RegularAtomToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-): AtomToken<T>
+): AtomToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T>
+): WritableSelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T>
+): ReadonlySelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-): SelectorToken<T>
+): SelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T>
+): WritableToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T>
+): ReadableToken<T, K>
 
 export function initFamilyMemberInStore(
 	store: Store,
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 ): ReadableToken<any> {
-	const familyKey = token.key
-	const family = store.families.get(familyKey)
+	const family = store.families.get(token.key)
 	if (family === undefined) {
 		throw new NotFoundError(token, store)
 	}