atom.io 0.24.7 → 0.25.0

package/internal/dist/index.cjs

@@ -407,8 +407,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 +425,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)} "${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 +697,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 +738,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
@@ -792,21 +778,18 @@ var getSelectorDependencyKeys = (key, store) => {
 };
 
 // internal/src/selector/trace-selector-atoms.ts
-var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
+var traceSelectorAtoms = (directDependencyKey, covered, store) => {
   const rootKeys = [];
   const indirectDependencyKeys = getSelectorDependencyKeys(
     directDependencyKey,
     store
   );
-  let depth = 0;
   while (indirectDependencyKeys.length > 0) {
     const indirectDependencyKey = indirectDependencyKeys.shift();
-    ++depth;
-    if (depth > 99999) {
-      throw new Error(
-        `Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`
-      );
+    if (covered.has(indirectDependencyKey)) {
+      continue;
     }
+    covered.add(indirectDependencyKey);
     if (!isAtomKey(indirectDependencyKey, store)) {
       indirectDependencyKeys.push(
         ...getSelectorDependencyKeys(indirectDependencyKey, store)
@@ -820,13 +803,14 @@ var traceSelectorAtoms = (selectorKey, directDependencyKey, store) => {
 var traceAllSelectorAtoms = (selector, store) => {
   const selectorKey = selector.key;
   const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
+  const covered = /* @__PURE__ */ new Set();
   return directDependencyKeys.flatMap(
-    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(selectorKey, depKey, store)
+    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(depKey, covered, store)
   );
 };
 
 // internal/src/selector/update-selector-atoms.ts
-var updateSelectorAtoms = (selectorKey, dependency, store) => {
+var updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
   const target = newest(store);
   if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
     target.selectorAtoms.set({
@@ -840,7 +824,7 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
       `discovers root atom "${dependency.key}"`
     );
   } else {
-    const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store);
+    const rootKeys = traceSelectorAtoms(dependency.key, covered, store);
     store.logger.info(
       `\u{1F50D}`,
       `selector`,
@@ -854,12 +838,21 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
       });
     }
   }
+  covered.add(dependency.key);
 };
 
 // internal/src/selector/register-selector.ts
-var registerSelector = (selectorKey, store) => ({
-  get: (dependency) => {
+var registerSelector = (selectorKey, covered, store) => ({
+  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);
     }
@@ -882,13 +875,28 @@ var registerSelector = (selectorKey, store) => ({
         source: dependency.key
       }
     );
-    updateSelectorAtoms(selectorKey, dependency, 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),
@@ -899,10 +907,16 @@ var registerSelector = (selectorKey, store) => ({
 var createReadonlySelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
-  const { get, find, seek, json } = registerSelector(options.key, target);
+  const covered = /* @__PURE__ */ new Set();
+  const { get, find, seek, json } = registerSelector(
+    options.key,
+    covered,
+    target
+  );
   const getSelf = () => {
     const value = options.get({ get, find, seek, json });
     cacheValue(options.key, value, subject, newest(store));
+    covered.clear();
     return value;
   };
   const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
@@ -934,12 +948,14 @@ var createReadonlySelector = (options, family, store) => {
 var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
-  const transactors = registerSelector(options.key, target);
-  const { find, get, seek, json } = transactors;
-  const readonlyTransactors = { find, get, seek, json };
+  const covered = /* @__PURE__ */ new Set();
+  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;
   };
   const setSelf = (next) => {
@@ -961,7 +977,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,
@@ -1215,23 +1231,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;
@@ -1305,6 +1304,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;
@@ -1366,30 +1450,34 @@ 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 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)),
+  const toolkit = {
+    get: (t) => getFromStore(t, void 0, newest(store)),
     set: (t, newValue) => {
       setIntoStore(t, newValue, newest(store));
     },
@@ -1401,11 +1489,36 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
       disposeFromStore(t, newest(store));
     },
     env: () => getEnvironmentData(newest(store)),
-    bond: (f) => growMoleculeInStore(
-      molecule,
-      withdraw(f, store),
-      newest(store)
-    ),
+    bond: (token2, maybeRole) => {
+      if (token2.type === `join`) {
+        const { as: role } = maybeRole;
+        const join = data.getJoin(token2, store);
+        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, store), newest(store));
+    },
     claim: (below, options) => {
       const { exclusive } = options;
       const belowMolecule = newest(store).molecules.get(json.stringifyJson(below.key));
@@ -1423,12 +1536,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],
@@ -1439,7 +1546,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,
@@ -1740,18 +1847,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)
     }
@@ -1779,8 +1886,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) {
@@ -1896,6 +2003,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);
@@ -1907,7 +2015,6 @@ var Store = class {
           )
         };
       }
-      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
       for (const [, family] of store.families) {
         family.install(this);
       }

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>;
@@ -397,7 +397,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 +436,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 +513,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,12 +527,12 @@ declare function disposeSelector(selectorToken: ReadonlySelectorToken<unknown> |
 
 declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
 
-declare const registerSelector: (selectorKey: string, store: Store) => Transactors;
+declare const registerSelector: (selectorKey: string, covered: Set<string>, store: Store) => SetterToolkit;
 
-declare const traceSelectorAtoms: (selectorKey: string, directDependencyKey: StateKey<unknown>, store: Store) => AtomKey<unknown>[];
+declare const traceSelectorAtoms: (directDependencyKey: StateKey<unknown>, covered: Set<string>, store: Store) => AtomKey<unknown>[];
 declare const traceAllSelectorAtoms: (selector: Selector<any>, store: Store) => AtomKey<unknown>[];
 
-declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, store: Store) => void;
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, covered: Set<string>, store: Store) => void;
 
 type Modify<T> = (thing: T) => T;
 declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing: T) => T;
@@ -536,6 +540,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)[];