atom.io 0.24.8 → 0.25.1

package/internal/dist/index.cjs

@@ -78,6 +78,12 @@ function newest(scion) {
   }
   return scion;
 }
+function eldest(scion) {
+  while (scion.parent !== null) {
+    scion = scion.parent;
+  }
+  return scion;
+}
 
 // internal/src/store/deposit.ts
 function deposit(state) {
@@ -407,8 +413,6 @@ var abortTransaction = (store) => {
   );
   target.parent.child = null;
 };
-
-// internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
   switch (token.type) {
@@ -427,10 +431,19 @@ function prettyPrintTokenType(token) {
   }
 }
 var NotFoundError = class extends Error {
-  constructor(token, store) {
-    super(
-      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
-    );
+  constructor(...params) {
+    const token = params[0];
+    const store = params.length === 2 ? params[1] : params[2];
+    if (params.length === 2) {
+      super(
+        `${prettyPrintTokenType(token)} ${json.stringifyJson(token.key)} not found in store "${store.config.name}".`
+      );
+    } else {
+      const key = params[1];
+      super(
+        `${prettyPrintTokenType(token)} "${token.key}" member ${json.stringifyJson(key)} not found in store "${store.config.name}".`
+      );
+    }
   }
 };
 
@@ -690,41 +703,6 @@ var setAtomOrSelector = (state, value, store) => {
       break;
   }
 };
-
-// internal/src/set-state/set-into-store.ts
-function setIntoStore(token, value, store) {
-  const rejectionTime = openOperation(token, store);
-  if (rejectionTime) {
-    const unsubscribe = store.on.operationClose.subscribe(
-      `waiting to set "${token.key}" at T-${rejectionTime}`,
-      () => {
-        unsubscribe();
-        store.logger.info(
-          `\u{1F7E2}`,
-          token.type,
-          token.key,
-          `resuming deferred setState from T-${rejectionTime}`
-        );
-        setIntoStore(token, value, store);
-      }
-    );
-    return;
-  }
-  const state = withdraw(token, store);
-  setAtomOrSelector(state, value, store);
-  closeOperation(store);
-}
-
-// internal/src/ingest-updates/ingest-atom-update.ts
-function ingestAtomUpdate(applying, atomUpdate, store) {
-  const { key, newValue, oldValue } = atomUpdate;
-  const value = applying === `newValue` ? newValue : oldValue;
-  const token = { key, type: `atom` };
-  if (atomUpdate.family) {
-    Object.assign(token, { family: atomUpdate.family });
-  }
-  setIntoStore(token, value, store);
-}
 function createRegularAtomFamily(options, store) {
   const subject = new Subject();
   const atomFamily = Object.assign(
@@ -766,17 +744,31 @@ function createAtomFamily(options, store) {
 }
 
 // internal/src/get-state/get-from-store.ts
-function getFromStore(token, store) {
-  if (token.type === `molecule`) {
-    try {
-      const molecule = withdraw(token, store);
-      return molecule.instance;
-    } catch (_) {
-      return void 0;
+function getFromStore(...params) {
+  let token;
+  let store;
+  if (params.length === 2) {
+    token = params[0];
+    store = params[1];
+  } else {
+    const family = params[0];
+    const key = params[1];
+    store = params[2];
+    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
+    if (!maybeToken) {
+      throw new NotFoundError(family, key, store);
     }
+    token = maybeToken;
+  }
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+    case `selector`:
+    case `readonly_selector`:
+      return readOrComputeValue(withdraw(token, store), store);
+    case `molecule`:
+      return withdraw(token, store).instance;
   }
-  const state = withdraw(token, store);
-  return readOrComputeValue(state, store);
 }
 
 // internal/src/keys.ts
@@ -857,8 +849,16 @@ var updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
 
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, covered, store) => ({
-  get: (dependency) => {
+  get: (dependency, key) => {
     const target = newest(store);
+    if (key) {
+      switch (dependency.type) {
+        case `molecule_family`:
+          return getFromStore(dependency, key, store);
+        case `atom_family`:
+          dependency = seekInStore(dependency, key, store);
+      }
+    }
     if (dependency.type === `molecule`) {
       return getFromStore(dependency, store);
     }
@@ -884,10 +884,25 @@ var registerSelector = (selectorKey, covered, store) => ({
     updateSelectorAtoms(selectorKey, dependency, covered, store);
     return dependencyValue;
   },
-  set: (WritableToken, newValue) => {
+  set: (...params) => {
+    let token;
+    let value;
+    if (params.length === 2) {
+      token = params[0];
+      value = params[1];
+    } else {
+      const family = params[0];
+      const key = params[1];
+      value = params[2];
+      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
+      if (!maybeToken) {
+        throw new NotFoundError(family, key, store);
+      }
+      token = maybeToken;
+    }
     const target = newest(store);
-    const state = withdraw(WritableToken, target);
-    setAtomOrSelector(state, newValue, target);
+    const state = withdraw(token, target);
+    setAtomOrSelector(state, value, target);
   },
   find: (token, key) => findInStore(token, key, store),
   seek: (token, key) => seekInStore(token, key, store),
@@ -940,11 +955,11 @@ var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
-  const transactors = registerSelector(options.key, covered, target);
-  const { find, get, seek, json } = transactors;
-  const readonlyTransactors = { find, get, seek, json };
+  const toolkit = registerSelector(options.key, covered, target);
+  const { find, get, seek, json } = toolkit;
+  const getterToolkit = { find, get, seek, json };
   const getSelf = (innerTarget = newest(store)) => {
-    const value = options.get(readonlyTransactors);
+    const value = options.get(getterToolkit);
     cacheValue(options.key, value, subject, innerTarget);
     covered.clear();
     return value;
@@ -968,7 +983,7 @@ var createWritableSelector = (options, family, store) => {
     if (isRootStore(innerTarget)) {
       subject.next({ newValue, oldValue });
     }
-    options.set(transactors, newValue);
+    options.set(toolkit, newValue);
   };
   const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
     subject,
@@ -1222,23 +1237,6 @@ function disposeMolecule(token, store) {
   }
 }
 
-// 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 initFamilyMemberInStore(token, key, store) {
   const familyKey = token.key;
@@ -1312,6 +1310,91 @@ function findInStore(token, key, store) {
   return state;
 }
 
+// internal/src/families/dispose-from-store.ts
+function disposeFromStore(...params) {
+  let token;
+  let store;
+  if (params.length === 2) {
+    token = params[0];
+    store = params[1];
+  } else {
+    const family = params[0];
+    const key = params[1];
+    store = params[2];
+    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
+    if (!maybeToken) {
+      throw new NotFoundError(family, key, store);
+    }
+    token = maybeToken;
+  }
+  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/set-state/set-into-store.ts
+function setIntoStore(...params) {
+  let token;
+  let value;
+  let store;
+  if (params.length === 3) {
+    token = params[0];
+    value = params[1];
+    store = params[2];
+  } else {
+    const family = params[0];
+    const key = params[1];
+    value = params[2];
+    store = params[3];
+    const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
+    if (!maybeToken) {
+      throw new NotFoundError(family, key, store);
+    }
+    token = maybeToken;
+  }
+  const rejectionTime = openOperation(token, store);
+  if (rejectionTime) {
+    const unsubscribe = store.on.operationClose.subscribe(
+      `waiting to set "${token.key}" at T-${rejectionTime}`,
+      () => {
+        unsubscribe();
+        store.logger.info(
+          `\u{1F7E2}`,
+          token.type,
+          token.key,
+          `resuming deferred setState from T-${rejectionTime}`
+        );
+        setIntoStore(token, value, store);
+      }
+    );
+    return;
+  }
+  const state = withdraw(token, store);
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
+// internal/src/ingest-updates/ingest-atom-update.ts
+function ingestAtomUpdate(applying, atomUpdate, store) {
+  const { key, newValue, oldValue } = atomUpdate;
+  const value = applying === `newValue` ? newValue : oldValue;
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(token, value, store);
+}
+
 // internal/src/molecule/create-molecule-family.ts
 function createMoleculeFamily(options, store) {
   var _a;
@@ -1373,46 +1456,80 @@ var Molecule = class {
 };
 
 // internal/src/molecule/make-molecule-in-store.ts
+function capitalize2(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
 function makeMoleculeInStore(store, context, familyToken, key, ...params) {
+  const rootStore = eldest(store);
   const target = newest(store);
-  target.moleculeInProgress = key;
+  const stringKey = json.stringifyJson(key);
+  target.moleculeInProgress = stringKey;
   const contextArray = Array.isArray(context) ? context : [context];
   const owners = contextArray.map((ctx) => {
     if (ctx instanceof Molecule) {
       return ctx;
     }
-    const stringKey = json.stringifyJson(ctx.key);
-    const molecule2 = store.molecules.get(stringKey);
+    const ctxStringKey = json.stringifyJson(ctx.key);
+    const molecule2 = store.molecules.get(ctxStringKey);
     if (!molecule2) {
       throw new Error(
-        `Molecule ${stringKey} not found in store "${store.config.name}"`
+        `Molecule ${ctxStringKey} not found in store "${store.config.name}"`
       );
     }
     return molecule2;
   });
   const molecule = new Molecule(owners, key, familyToken);
-  target.molecules.set(json.stringifyJson(key), molecule);
+  target.molecules.set(stringKey, 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));
+  const toolkit = {
+    get: (...ps) => getFromStore(...ps, newest(rootStore)),
+    set: (...ps) => {
+      setIntoStore(...ps, newest(rootStore));
     },
-    seek: (t, k) => seekInStore(t, k, newest(store)),
-    json: (t) => getJsonToken(t, newest(store)),
+    seek: (t, k) => seekInStore(t, k, newest(rootStore)),
+    json: (t) => getJsonToken(t, newest(rootStore)),
     run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
-    make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(store), ctx, f, k, ...args),
+    make: (ctx, f, k, ...args) => makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
     dispose: (t) => {
-      disposeFromStore(t, newest(store));
+      disposeFromStore(t, newest(rootStore));
+    },
+    env: () => getEnvironmentData(newest(rootStore)),
+    bond: (token2, maybeRole) => {
+      if (token2.type === `join`) {
+        const { as: role } = maybeRole;
+        const join = data.getJoin(token2, rootStore);
+        join.molecules.set(stringKey, molecule);
+        molecule.joins.set(token2.key, join);
+        const unsubFromFamily = family.subject.subscribe(
+          `join:${token2.key}-${stringKey}`,
+          (event) => {
+            if (event.type === `molecule_disposal` && json.stringifyJson(event.token.key) === stringKey) {
+              unsubFromFamily();
+              join.molecules.delete(stringKey);
+            }
+          }
+        );
+        if (role === null) {
+          return;
+        }
+        const otherRole = token2.a === role ? token2.b : token2.a;
+        const relations = data.findRelations(token2, key);
+        const relatedKeys = relations[`${otherRole}KeysOf${capitalize2(role)}`];
+        const relatedEntries = relations[`${otherRole}EntriesOf${capitalize2(role)}`];
+        let tokens = { relatedKeys };
+        if (relatedEntries) {
+          tokens = Object.assign(tokens, { relatedEntries });
+        }
+        return tokens;
+      }
+      return growMoleculeInStore(
+        molecule,
+        withdraw(token2, rootStore),
+        newest(rootStore)
+      );
     },
-    env: () => getEnvironmentData(newest(store)),
-    bond: (f) => growMoleculeInStore(
-      molecule,
-      withdraw(f, store),
-      newest(store)
-    ),
     claim: (below, options) => {
       const { exclusive } = options;
       const belowMolecule = newest(store).molecules.get(json.stringifyJson(below.key));
@@ -1430,12 +1547,6 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
         }
       }
     },
-    join: (joinToken) => {
-      const join = data.getJoin(joinToken, store);
-      join.molecules.set(json.stringifyJson(key), molecule);
-      molecule.joins.set(joinToken.key, join);
-      return joinToken;
-    },
     spawn: (f, k, ...p) => makeMoleculeInStore(
       newest(store),
       [molecule],
@@ -1446,7 +1557,7 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
   };
   const family = withdraw(familyToken, store);
   const Constructor = family.new;
-  molecule.instance = new Constructor(transactors, key, ...params);
+  molecule.instance = new Constructor(toolkit, key, ...params);
   const token = {
     type: `molecule`,
     key,
@@ -1747,18 +1858,18 @@ var buildTransaction = (key, params, store, id) => {
       params,
       output: void 0
     },
-    transactors: {
-      get: (token) => getFromStore(token, child),
-      set: (token, value) => {
-        setIntoStore(token, value, child);
+    toolkit: {
+      get: (...ps) => getFromStore(...ps, child),
+      set: (...ps) => {
+        setIntoStore(...ps, child);
       },
       run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
       find: (token, k) => findInStore(token, k, child),
       seek: (token, k) => seekInStore(token, k, child),
       json: (token) => getJsonToken(token, child),
       make: (context, family, k, ...args) => makeMoleculeInStore(child, context, family, k, ...args),
-      dispose: (token) => {
-        disposeFromStore(token, child);
+      dispose: (...ps) => {
+        disposeFromStore(...ps, child);
       },
       env: () => getEnvironmentData(child)
     }
@@ -1786,8 +1897,8 @@ function createTransaction(options, store) {
       const childStore = buildTransaction(options.key, params, store, id);
       try {
         const target2 = newest(store);
-        const { transactors } = childStore.transactionMeta;
-        const output = options.do(transactors, ...params);
+        const { toolkit } = childStore.transactionMeta;
+        const output = options.do(toolkit, ...params);
         applyTransaction(output, target2);
         return output;
       } catch (thrown) {
@@ -1903,6 +2014,7 @@ var Store = class {
         for (const logger of this.loggers) logger.warn(...messages);
       }
     };
+    this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
     if (store !== null) {
       this.valueMap = new Map(store == null ? void 0 : store.valueMap);
       this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
@@ -1914,7 +2026,6 @@ var Store = class {
           )
         };
       }
-      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
       for (const [, family] of store.families) {
         family.install(this);
       }
@@ -3224,6 +3335,7 @@ exports.disposeAtom = disposeAtom;
 exports.disposeFromStore = disposeFromStore;
 exports.disposeMolecule = disposeMolecule;
 exports.disposeSelector = disposeSelector;
+exports.eldest = eldest;
 exports.evictCachedValue = evictCachedValue;
 exports.findInStore = findInStore;
 exports.getContinuityKey = getContinuityKey;

package/internal/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as atom_io from 'atom.io';
-import { Func, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, Flat, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MK, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { Func, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, Flat, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MK, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 
@@ -134,7 +134,7 @@ type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
 type TransactionProgress<F extends Func> = {
     phase: `applying` | `building`;
     update: TransactionUpdate<F>;
-    transactors: TransactorsWithRunAndEnv;
+    toolkit: ActorToolkit;
 };
 type TransactionEpoch = {
     epoch: Map<string, number>;
@@ -162,6 +162,7 @@ interface Lineage {
     child: typeof this | null;
 }
 declare function newest<T extends Lineage>(scion: T): T;
+declare function eldest<T extends Lineage>(scion: T): T;
 
 type OperationProgress = {
     open: false;
@@ -397,7 +398,9 @@ declare function createRegularAtomFamily<T, K extends Json.Serializable>(options
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
-declare function disposeFromStore(token: MoleculeToken<any> | ReadableToken<any>, store?: Store): void;
+declare function disposeFromStore(token: MoleculeToken<any> | ReadableToken<any>, store: Store): void;
+declare function disposeFromStore<K extends Json.Serializable>(token: ReadableFamilyToken<any, K>, key: K, store: Store): void;
+declare function disposeFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): void;
 
 declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
@@ -434,7 +437,8 @@ declare function getEnvironmentData(store: Store): EnvironmentData;
 
 declare function getFromStore<T>(token: ReadableToken<T>, store: Store): T;
 declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): InstanceType<M> | undefined;
-declare function getFromStore<T, M extends MoleculeConstructor, Token extends MoleculeToken<M> | ReadableToken<T>>(token: Token, store: Store): InstanceType<M> | T | undefined;
+declare function getFromStore<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, key: K, store: Store): T;
+declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): InstanceType<M>;
 
 declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
 
@@ -510,6 +514,7 @@ declare function makeMoleculeInStore<M extends MoleculeConstructor>(store: Store
 type AtomIOToken = MoleculeFamilyToken<any> | MoleculeToken<any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
+    constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
 }
 
 declare const createReadonlySelector: <T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => ReadonlySelectorToken<T>;
@@ -523,7 +528,7 @@ declare function disposeSelector(selectorToken: ReadonlySelectorToken<unknown> |
 
 declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
 
-declare const registerSelector: (selectorKey: string, covered: Set<string>, store: Store) => Transactors;
+declare const registerSelector: (selectorKey: string, covered: Set<string>, store: Store) => SetterToolkit;
 
 declare const traceSelectorAtoms: (directDependencyKey: StateKey<unknown>, covered: Set<string>, store: Store) => AtomKey<unknown>[];
 declare const traceAllSelectorAtoms: (selector: Selector<any>, store: Store) => AtomKey<unknown>[];
@@ -536,6 +541,7 @@ declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing:
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
 declare function setIntoStore<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New), store: Store): void;
+declare function setIntoStore<T, K extends Json.Serializable, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New), store: Store): void;
 
 declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
 
@@ -578,4 +584,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, 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 };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, 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, eldest, 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 };