atom.io 0.29.0 → 0.29.1

package/dist/{chunk-XPYU2HY2.js → chunk-4WXELLFT.js}

@@ -505,14 +505,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 +541,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 +1267,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 +1397,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

@@ -451,32 +451,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-4WXELLFT.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';

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)
 	}

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

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

package/internal/src/get-state/get-from-store.ts

@@ -6,9 +6,11 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import { type Canonical, stringifyJson } from "atom.io/json"
+import { type Canonical, parseJson } from "atom.io/json"
+import { M } from "vitest/dist/chunks/environment.0M5R1SX_.js"
 
 import { findInStore, seekInStore } from "../families"
+import { getFamilyOfToken } from "../families/get-family-of-token"
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { counterfeit, withdraw } from "../store"
@@ -58,11 +60,23 @@ export function getFromStore(
 		| [token: ReadableToken<any>]
 ): any {
 	let token: MoleculeToken<any> | ReadableToken<any>
+	let family:
+		| MoleculeFamilyToken<any>
+		| ReadableFamilyToken<any, Canonical>
+		| null
+	let key: Canonical | null
 	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: MoleculeToken<any> | ReadableToken<any>
 		if (family.type === `molecule_family`) {
 			maybeToken = seekInStore(store, family, key) ?? counterfeit(family, key)
@@ -72,7 +86,7 @@ export function getFromStore(
 		token = maybeToken
 	}
 	if (`counterfeit` in token && `family` in token) {
-		const family =
+		family =
 			token.type === `molecule`
 				? withdraw(token.family, store)
 				: // biome-ignore lint/style/noNonNullAssertion: family must be present

package/internal/src/set-state/set-into-store.ts

@@ -1,7 +1,8 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
-import { type Canonical, stringifyJson } from "atom.io/json"
+import { type Canonical, parseJson, stringifyJson } from "atom.io/json"
 
 import { findInStore } from "../families"
+import { getFamilyOfToken } from "../families/get-family-of-token"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
 import { withdraw } from "../store"
@@ -31,17 +32,24 @@ export function setIntoStore<T, New extends T>(
 		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
 	let token: WritableToken<T>
+	let family: WritableFamilyToken<T, Canonical> | null
+	let key: Canonical | null
 	let value: New | ((oldValue: T) => New)
 	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(
 			(item) => item?.key === token.key,

package/json/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Range, Flat, Store, Transceiver } from 'atom.io/internal';
 import * as AtomIO from 'atom.io';
 
-type Entries<K extends keyof any = keyof any, V = any> = [K, V][];
+type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][];
 type KeyOfEntries<E extends Entries> = E extends [infer K, any][] ? K : never;
 type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
     [P in Range<E[`length`]>]: E[P] extends [K, infer V] ? V : never;
@@ -32,8 +32,8 @@ declare namespace Json {
     type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
     type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
 }
-type stringified<J extends Json.Serializable> = string & {
-    __json: J;
+type stringified<J extends Json.Serializable> = J extends string ? `"${J}"` : J extends number ? `${J}` : J extends true ? `true` : J extends false ? `false` : J extends boolean ? `false` | `true` : J extends null ? `null` : string & {
+    __json?: J;
 };
 declare const parseJson: <S extends stringified<Json.Serializable>>(str: S | string) => S extends stringified<infer J> ? J : Json.Serializable;
 declare const stringifyJson: <J extends Json.Serializable>(json: J) => stringified<J>;

package/json/dist/index.js

@@ -1,4 +1,4 @@
-import { createWritableSelectorFamily } from '../../dist/chunk-XPYU2HY2.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-4WXELLFT.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';

package/json/src/entries.ts

@@ -1,6 +1,6 @@
 import type { Flat, Range } from "atom.io/internal"
 
-export type Entries<K extends keyof any = keyof any, V = any> = [K, V][]
+export type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][]
 
 export type KeyOfEntries<E extends Entries> = E extends [infer K, any][]
 	? K

package/json/src/index.ts

@@ -27,7 +27,19 @@ export namespace Json {
 		ReadonlyArray<Element>
 }
 
-export type stringified<J extends Json.Serializable> = string & { __json: J }
+export type stringified<J extends Json.Serializable> = J extends string
+	? `"${J}"`
+	: J extends number
+		? `${J}`
+		: J extends true
+			? `true`
+			: J extends false
+				? `false`
+				: J extends boolean
+					? `false` | `true`
+					: J extends null
+						? `null`
+						: string & { __json?: J }
 
 export const parseJson = <S extends stringified<Json.Serializable>>(
 	str: S | string,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.29.0",
+  "version": "0.29.1",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -59,30 +59,30 @@
     "@types/npmlog": "7.0.0",
     "@types/react": "18.3.5",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.4.0",
-    "@typescript-eslint/rule-tester": "8.4.0",
+    "@typescript-eslint/parser": "8.5.0",
+    "@typescript-eslint/rule-tester": "8.5.0",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
-    "concurrently": "8.2.2",
+    "concurrently": "9.0.1",
     "drizzle-kit": "0.24.2",
     "drizzle-orm": "0.33.0",
-    "eslint": "9.9.1",
-    "framer-motion": "11.5.2",
-    "happy-dom": "15.7.3",
+    "eslint": "9.10.0",
+    "framer-motion": "11.5.4",
+    "happy-dom": "15.7.4",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
     "preact": "10.23.2",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.26.1",
+    "react-router-dom": "6.26.2",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
     "tsup": "8.2.4",
-    "tsx": "4.19.0",
-    "typescript": "5.5.4",
-    "vite": "5.4.3",
+    "tsx": "4.19.1",
+    "typescript": "5.6.2",
+    "vite": "5.4.4",
     "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },

package/realtime-server/dist/index.d.ts

@@ -14,21 +14,19 @@ interface EventBuffer<Key extends string, Params extends Json.Serializable[]> ex
     toString(): StringifiedEvent<Key, Params>;
 }
 declare class CustomSocket<I extends Events, O extends Events> implements Socket {
-    emit: <Event extends keyof O>(event: Event, ...args: O[Event]) => CustomSocket<I, O>;
-    protected listeners: Map<keyof I, Set<(...args: Json.Array) => void>>;
+    emit: <Event extends keyof I>(event: Event, ...args: I[Event]) => CustomSocket<I, O>;
+    protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>;
     protected globalListeners: Set<(event: string, ...args: Json.Array) => void>;
     protected handleEvent<Event extends keyof I>(event: string, ...args: I[Event]): void;
     id: string;
-    constructor(emit: <Event extends keyof O>(event: Event, ...args: O[Event]) => CustomSocket<I, O>);
-    on<Event extends keyof I>(event: Event, listener: (...args: I[Event]) => void): this;
+    constructor(emit: <Event extends keyof I>(event: Event, ...args: I[Event]) => CustomSocket<I, O>);
+    on<Event extends keyof O>(event: Event, listener: (...args: O[Event]) => void): this;
     onAny(listener: (event: string, ...args: Json.Array) => void): this;
-    off<Event extends keyof I>(event: Event, listener?: (...args: I[Event]) => void): this;
+    off<Event extends keyof O>(event: Event, listener?: (...args: O[Event]) => void): this;
     offAny(listener: (event: string, ...args: Json.Array) => void): this;
 }
 
-declare class ChildSocket<I extends Events, O extends Events & {
-    "setup-relay": [string];
-}> extends CustomSocket<I, O> {
+declare class ChildSocket<I extends Events, O extends Events> extends CustomSocket<I, O> {
     process: ChildProcessWithoutNullStreams;
     key: string;
     logger: {
@@ -58,12 +56,12 @@ declare class SubjectSocket<I extends Events, O extends Events> extends CustomSo
     dispose(): void;
 }
 declare class ParentSocket<I extends Events & {
+    [id in string as `relay:${id}`]: [string, ...Json.Serializable[]];
+}, O extends Events & {
     [id in string as `user:${id}`]: [string, ...Json.Serializable[]];
 } & {
     "user-joins": [string];
     "user-leaves": [string];
-}, O extends Events & {
-    [id in string as `relay:${id}`]: [string, ...Json.Serializable[]];
 }> extends CustomSocket<I, O> {
     protected incompleteData: string;
     protected unprocessedEvents: string[];

package/realtime-server/src/ipc-sockets/child-socket.ts

@@ -10,11 +10,7 @@ import { CustomSocket } from "./custom-socket"
 
 export class ChildSocket<
 	I extends Events,
-	O extends Events & {
-		/* eslint-disable quotes */
-		"setup-relay": [string]
-		/* eslint-enable quotes */
-	},
+	O extends Events,
 > extends CustomSocket<I, O> {
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []

package/realtime-server/src/ipc-sockets/custom-socket.ts

@@ -17,7 +17,7 @@ export interface EventBuffer<
 }
 
 export class CustomSocket<I extends Events, O extends Events> implements Socket {
-	protected listeners: Map<keyof I, Set<(...args: Json.Array) => void>>
+	protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>
 	protected globalListeners: Set<(event: string, ...args: Json.Array) => void>
 	protected handleEvent<Event extends keyof I>(
 		event: string,
@@ -37,18 +37,18 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 	public id = `no_id_retrieved`
 
 	public constructor(
-		public emit: <Event extends keyof O>(
+		public emit: <Event extends keyof I>(
 			event: Event,
-			...args: O[Event]
+			...args: I[Event]
 		) => CustomSocket<I, O>,
 	) {
 		this.listeners = new Map()
 		this.globalListeners = new Set()
 	}
 
-	public on<Event extends keyof I>(
+	public on<Event extends keyof O>(
 		event: Event,
-		listener: (...args: I[Event]) => void,
+		listener: (...args: O[Event]) => void,
 	): this {
 		const listeners = this.listeners.get(event)
 		if (listeners) {
@@ -64,9 +64,9 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 		return this
 	}
 
-	public off<Event extends keyof I>(
+	public off<Event extends keyof O>(
 		event: Event,
-		listener?: (...args: I[Event]) => void,
+		listener?: (...args: O[Event]) => void,
 	): this {
 		const listeners = this.listeners.get(event)
 		if (listeners) {

package/realtime-server/src/ipc-sockets/parent-socket.ts

@@ -37,6 +37,9 @@ export class SubjectSocket<
 
 export class ParentSocket<
 	I extends Events & {
+		[id in string as `relay:${id}`]: [string, ...Json.Serializable[]]
+	},
+	O extends Events & {
 		[id in string as `user:${id}`]: [string, ...Json.Serializable[]]
 	} & {
 		/* eslint-disable quotes */
@@ -44,9 +47,6 @@ export class ParentSocket<
 		"user-leaves": [string]
 		/* eslint-enable quotes */
 	},
-	O extends Events & {
-		[id in string as `relay:${id}`]: [string, ...Json.Serializable[]]
-	},
 > extends CustomSocket<I, O> {
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []
@@ -167,7 +167,7 @@ export class ParentSocket<
 				relay.in.next(data)
 			})
 			relay.out.subscribe(`socket`, (data) => {
-				this.emit(...(data as [string, ...O[keyof O]]))
+				this.emit(...(data as [string, ...I[keyof I]]))
 			})
 		})
 

package/src/index.ts

@@ -1,5 +1,5 @@
 import type { Transceiver } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical, Json, stringified } from "atom.io/json"
 
 import type { AtomFamilyToken } from "./atom"
 import type {
@@ -20,44 +20,49 @@ export * from "./timeline"
 export * from "./transaction"
 export * from "./validators"
 
-export type RegularAtomToken<T> = {
+export type RegularAtomToken<T, K extends Canonical = any> = {
 	key: string
 	type: `atom`
-	family?: FamilyMetadata
+	family?: FamilyMetadata<K>
 	__T?: T
 }
 export 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
 }
-export type AtomToken<T> =
-	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
-	| RegularAtomToken<T>
+export type AtomToken<T, K extends Canonical = any> =
+	| MutableAtomToken<T extends Transceiver<any> ? T : never, any, K>
+	| RegularAtomToken<T, K>
 
-export type WritableSelectorToken<T> = {
+export type WritableSelectorToken<T, K extends Canonical = any> = {
 	key: string
 	type: `selector`
-	family?: FamilyMetadata
+	family?: FamilyMetadata<K>
 	__T?: T
 }
-export type ReadonlySelectorToken<T> = {
+export type ReadonlySelectorToken<T, K extends Canonical = any> = {
 	key: string
 	type: `readonly_selector`
-	family?: FamilyMetadata
+	family?: FamilyMetadata<K>
 	__T?: T
 }
-export type SelectorToken<T> =
-	| ReadonlySelectorToken<T>
-	| WritableSelectorToken<T>
+export type SelectorToken<T, K extends Canonical = any> =
+	| ReadonlySelectorToken<T, K>
+	| WritableSelectorToken<T, K>
 
-export type WritableToken<T> = AtomToken<T> | WritableSelectorToken<T>
-export type ReadableToken<T> = AtomToken<T> | SelectorToken<T>
+export type WritableToken<T, K extends Canonical = any> =
+	| AtomToken<T, K>
+	| WritableSelectorToken<T, K>
+export type ReadableToken<T, K extends Canonical = any> =
+	| AtomToken<T, K>
+	| SelectorToken<T, K>
 
 export type WritableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
@@ -66,4 +71,7 @@ export type ReadableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
 	| SelectorFamilyToken<T, K>
 
-export type FamilyMetadata = { key: string; subKey: string }
+export type FamilyMetadata<K extends Canonical = any> = {
+	key: string
+	subKey: stringified<K>
+}

package/transceivers/set-rtx/dist/index.js

@@ -1,6 +1,6 @@
 import '../../../dist/chunk-XWL6SNVU.js';
 import { Subject } from 'atom.io/internal';
-import { stringifyJson, parseJson } from 'atom.io/json';
+import { stringifyJson } from 'atom.io/json';
 
 var SetRTX = class _SetRTX extends Set {
   mode = `record`;
@@ -111,13 +111,13 @@ var SetRTX = class _SetRTX extends Set {
     const value = update.substring(typeValueBreak + 1);
     switch (type) {
       case `add`:
-        this.add(parseJson(value));
+        this.add(JSON.parse(value));
         break;
       case `clear`:
         this.clear();
         break;
       case `del`:
-        this.delete(parseJson(value));
+        this.delete(JSON.parse(value));
         break;
       case `tx`:
         for (const subUpdate of value.split(`;`)) {
@@ -177,10 +177,10 @@ var SetRTX = class _SetRTX extends Set {
     const value = update.substring(breakpoint + 1);
     switch (type) {
       case `add`:
-        this.delete(parseJson(value));
+        this.delete(JSON.parse(value));
         break;
       case `del`:
-        this.add(parseJson(value));
+        this.add(JSON.parse(value));
         break;
       case `clear`: {
         const values = JSON.parse(value);

package/transceivers/set-rtx/src/set-rtx.ts

@@ -1,7 +1,7 @@
 import type { Lineage, Transceiver, TransceiverMode } from "atom.io/internal"
 import { Subject } from "atom.io/internal"
-import type { Json, primitive, stringified } from "atom.io/json"
-import { parseJson, stringifyJson } from "atom.io/json"
+import type { Json, primitive } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
 export type SetUpdate =
 	| `add:${string}`
@@ -146,13 +146,13 @@ export class SetRTX<P extends primitive>
 		const value = update.substring(typeValueBreak + 1)
 		switch (type) {
 			case `add`:
-				this.add(parseJson(value as stringified<P>))
+				this.add(JSON.parse(value))
 				break
 			case `clear`:
 				this.clear()
 				break
 			case `del`:
-				this.delete(parseJson(value as stringified<P>))
+				this.delete(JSON.parse(value))
 				break
 			case `tx`:
 				for (const subUpdate of value.split(`;`)) {
@@ -215,10 +215,10 @@ export class SetRTX<P extends primitive>
 		const value = update.substring(breakpoint + 1)
 		switch (type) {
 			case `add`:
-				this.delete(parseJson(value as stringified<P>))
+				this.delete(JSON.parse(value))
 				break
 			case `del`:
-				this.add(parseJson(value as stringified<P>))
+				this.add(JSON.parse(value))
 				break
 			case `clear`: {
 				const values = JSON.parse(value) as P[]