atom.io 0.21.0 → 0.22.0

package/internal/dist/index.cjs

@@ -31,44 +31,30 @@ function arbitrary(random = Math.random) {
 // internal/src/future.ts
 var Future = class extends Promise {
   constructor(executor) {
-    let promise;
     let superResolve;
     let superReject;
     super((resolve, reject) => {
       superResolve = resolve;
       superReject = reject;
-      promise = executor instanceof Promise ? executor : new Promise(executor);
-      promise.then(
-        (value) => {
-          if (promise) {
-            this.pass(promise, value);
-          }
-        },
-        (reason) => {
-          if (promise) {
-            this.fail(promise, reason);
-          }
-        }
-      );
     });
-    this.destiny = promise;
     this.resolve = superResolve;
     this.reject = superReject;
+    this.use(executor instanceof Promise ? executor : new Promise(executor));
   }
   pass(promise, value) {
-    if (promise === this.destiny) {
+    if (promise === this.fate) {
       this.resolve(value);
     }
   }
   fail(promise, reason) {
-    if (promise === this.destiny) {
+    if (promise === this.fate) {
       this.reject(reason);
     }
   }
   use(value) {
     if (value instanceof Promise) {
       const promise = value;
-      this.destiny = promise;
+      this.fate = promise;
       promise.then(
         (resolved) => {
           this.pass(promise, resolved);
@@ -79,7 +65,7 @@ var Future = class extends Promise {
       );
     } else {
       this.resolve(value);
-      this.destiny = void 0;
+      this.fate = void 0;
     }
   }
 };
@@ -405,7 +391,7 @@ function isChildStore(store) {
 
 // internal/src/store/store.ts
 var Store = class {
-  constructor(name, store = null) {
+  constructor(config, store = null) {
     this.parent = null;
     this.child = null;
     this.valueMap = /* @__PURE__ */ new Map();
@@ -434,6 +420,8 @@ var Store = class {
         makeContentKey: (...keys) => keys.sort().join(`:`)
       }
     );
+    this.molecules = /* @__PURE__ */ new Map();
+    this.miscResources = /* @__PURE__ */ new Map();
     this.on = {
       atomCreation: new Subject(),
       atomDisposal: new Subject(),
@@ -455,7 +443,8 @@ var Store = class {
       })
     };
     this.config = {
-      name: `IMPLICIT_STORE`
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
     };
     this.loggers = [
       new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
@@ -485,9 +474,7 @@ var Store = class {
           )
         };
       }
-      this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
-        name
-      });
+      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
       for (const [, family] of store.families) {
         family.install(this);
       }
@@ -498,7 +485,7 @@ var Store = class {
         }
         atom.install(this);
         if (atom.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(atom);
+          const originalJsonToken = getJsonToken(atom, store);
           const originalUpdateToken = getUpdateToken(atom);
           mutableHelpers.add(originalJsonToken.key);
           mutableHelpers.add(originalUpdateToken.key);
@@ -526,12 +513,18 @@ var IMPLICIT = {
   STORE_INTERNAL: void 0,
   get STORE() {
     var _a;
-    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
+    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store({
+      name: `IMPLICIT_STORE`,
+      lifespan: `ephemeral`
+    });
   }
 };
 var clearStore = (store) => {
   const { config } = store;
-  Object.assign(store, new Store(config.name));
+  for (const disposable of store.miscResources.values()) {
+    disposable[Symbol.dispose]();
+  }
+  Object.assign(store, new Store(config));
   store.config = config;
 };
 
@@ -572,36 +565,6 @@ function withdraw(token, store) {
   throw new NotFoundError(token, store);
 }
 
-// internal/src/store/withdraw-new-family-member.ts
-function withdrawOrCreate(token, store) {
-  try {
-    const state = withdraw(token, store);
-    return state;
-  } catch (notFoundError) {
-    if (token.family) {
-      store.logger.info(
-        `\u{1F46A}`,
-        token.type,
-        token.key,
-        `creating new family member in store "${store.config.name}"`
-      );
-      const target = newest(store);
-      const family = target.families.get(token.family.key);
-      if (family) {
-        const jsonSubKey = JSON.parse(token.family.subKey);
-        family(jsonSubKey);
-        const state = withdraw(token, store);
-        return state;
-      }
-      throw new NotFoundError(
-        { key: token.family.key, type: `${token.type}_family` },
-        store
-      );
-    }
-    throw notFoundError;
-  }
-}
-
 // internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
@@ -629,22 +592,17 @@ function createRegularAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const target2 = newest(store);
-      const atomAlreadyCreated = target2.atoms.has(fullKey);
-      let token;
-      if (atomAlreadyCreated) {
-        token = { type: `atom`, key: fullKey, family };
-      } else {
-        const individualOptions = {
-          key: fullKey,
-          default: options.default instanceof Function ? options.default(key) : options.default
-        };
-        if (options.effects) {
-          individualOptions.effects = options.effects(key);
-        }
-        token = createRegularAtom(individualOptions, family, store);
-        subject.next(token);
+      const target = newest(store);
+      const def = options.default;
+      const individualOptions = {
+        key: fullKey,
+        default: def instanceof Function ? def(key) : def
+      };
+      if (options.effects) {
+        individualOptions.effects = options.effects(key);
       }
+      const token = createRegularAtom(individualOptions, family, target);
+      subject.next(token);
       return token;
     },
     {
@@ -654,8 +612,7 @@ function createRegularAtomFamily(options, store) {
       install: (s) => createRegularAtomFamily(options, s)
     }
   );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily);
   return atomFamily;
 }
 
@@ -671,22 +628,20 @@ function createReadonlySelectorFamily(options, store) {
   const subject = new Subject();
   const readonlySelectorFamily = Object.assign(
     (key) => {
-      const target = newest(store);
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = target.readonlySelectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
-      return createReadonlySelector(
+      const target = newest(store);
+      const token = createReadonlySelector(
         {
           key: fullKey,
           get: options.get(key)
         },
         family,
-        store
+        target
       );
+      subject.next(token);
+      return token;
     },
     {
       key: options.key,
@@ -705,10 +660,7 @@ function createWritableSelectorFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = store.selectors.get(fullKey);
-      if (existing) {
-        return deposit(existing);
-      }
+      const target = newest(store);
       const token = createWritableSelector(
         {
           key: fullKey,
@@ -716,7 +668,7 @@ function createWritableSelectorFamily(options, store) {
           set: options.set(key)
         },
         family,
-        store
+        target
       );
       subject.next(token);
       return token;
@@ -744,10 +696,18 @@ function createSelectorFamily(options, store) {
 // internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
-  if (token.type === `readonly_selector`) {
-    return `Readonly Selector`;
+  switch (token.type) {
+    case `atom_family`:
+      return `Atom Family`;
+    case `readonly_selector`:
+      return `Readonly Selector`;
+    case `readonly_selector_family`:
+      return `Readonly Selector Family`;
+    case `selector_family`:
+      return `Selector Family`;
+    default:
+      return capitalize(token.type);
   }
-  return capitalize(token.type);
 }
 var NotFoundError = class extends Error {
   constructor(token, store) {
@@ -757,8 +717,8 @@ var NotFoundError = class extends Error {
   }
 };
 
-// internal/src/families/find-in-store.ts
-function findInStore(token, key, store) {
+// internal/src/families/init-family-member.ts
+function initFamilyMember(token, key, store) {
   const familyKey = token.key;
   const family = store.families.get(familyKey);
   if (family === void 0) {
@@ -767,6 +727,44 @@ function findInStore(token, key, store) {
   const state = family(key);
   return state;
 }
+function seekInStore(token, key, store) {
+  const subKey = json.stringifyJson(key);
+  const fullKey = `${token.key}(${subKey})`;
+  const target = newest(store);
+  let state;
+  switch (token.type) {
+    case `atom_family`:
+    case `mutable_atom_family`:
+      state = target.atoms.get(fullKey);
+      break;
+    case `selector_family`: {
+      state = target.selectors.get(fullKey);
+      break;
+    }
+    case `readonly_selector_family`:
+      state = target.readonlySelectors.get(fullKey);
+      break;
+  }
+  if (state) {
+    return deposit(state);
+  }
+  return state;
+}
+
+// internal/src/families/find-in-store.ts
+function findInStore(token, key, store) {
+  if (store.config.lifespan === `immortal`) {
+    throw new Error(
+      `Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`
+    );
+  }
+  let state = seekInStore(token, key, store);
+  if (state) {
+    return state;
+  }
+  state = initFamilyMember(token, key, store);
+  return state;
+}
 
 // internal/src/set-state/become.ts
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
@@ -1009,7 +1007,7 @@ function setIntoStore(token, value, store) {
     );
     return;
   }
-  const state = withdrawOrCreate(token, store);
+  const state = withdraw(token, store);
   setAtomOrSelector(state, value, store);
   closeOperation(store);
 }
@@ -1095,7 +1093,7 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
     const target = newest(store);
-    const dependencyState = withdrawOrCreate(dependency, store);
+    const dependencyState = withdraw(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
     store.logger.info(
       `\u{1F50C}`,
@@ -1118,19 +1116,20 @@ var registerSelector = (selectorKey, store) => ({
     return dependencyValue;
   },
   set: (WritableToken, newValue) => {
-    const state = withdrawOrCreate(WritableToken, store);
+    const state = withdraw(WritableToken, store);
     setAtomOrSelector(state, newValue, store);
   },
-  find: (token, key) => findInStore(token, key, store)
+  find: (token, key) => findInStore(token, key, store),
+  seek: (token, key) => seekInStore(token, key, store)
 });
 
 // internal/src/selector/create-readonly-selector.ts
 var createReadonlySelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
-  const { get, find } = registerSelector(options.key, target);
+  const { get, find, seek } = registerSelector(options.key, target);
   const getSelf = () => {
-    const value = options.get({ get, find });
+    const value = options.get({ get, find, seek });
     cacheValue(options.key, value, subject, newest(store));
     return value;
   };
@@ -1165,8 +1164,8 @@ var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
   const transactors = registerSelector(options.key, target);
-  const { find, get } = transactors;
-  const readonlyTransactors = { find, get };
+  const { find, get, seek } = transactors;
+  const readonlyTransactors = { find, get, seek };
   const getSelf = () => {
     const value = options.get(readonlyTransactors);
     cacheValue(options.key, value, subject, newest(store));
@@ -1224,41 +1223,59 @@ function createStandaloneSelector(options, store) {
 
 // internal/src/selector/dispose-selector.ts
 function disposeSelector(selectorToken, store) {
+  var _a;
   const target = newest(store);
   const { key } = selectorToken;
-  switch (selectorToken.type) {
-    case `selector`:
-      target.selectors.delete(key);
-      break;
-    case `readonly_selector`:
-      target.readonlySelectors.delete(key);
-      break;
-  }
-  target.valueMap.delete(key);
-  target.selectorAtoms.delete(key);
-  const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
-    ([downstreamSelectorKey]) => {
-      var _a;
-      return (_a = target.selectors.get(downstreamSelectorKey)) != null ? _a : target.readonlySelectors.get(downstreamSelectorKey);
+  const selector = (_a = target.selectors.get(key)) != null ? _a : target.readonlySelectors.get(key);
+  if (!selector) {
+    store.logger.error(
+      `\u274C`,
+      `selector`,
+      key,
+      `Tried to dispose selector, but it does not exist in the store.`
+    );
+  } else if (!selector.family) {
+    store.logger.error(
+      `\u274C`,
+      `selector`,
+      key,
+      `Standalone selectors cannot be disposed.`
+    );
+  } else {
+    switch (selectorToken.type) {
+      case `selector`:
+        target.selectors.delete(key);
+        break;
+      case `readonly_selector`:
+        target.readonlySelectors.delete(key);
+        break;
     }
-  );
-  for (const downstreamToken of downstreamTokens) {
-    if (downstreamToken) {
-      disposeSelector(downstreamToken, store);
+    target.valueMap.delete(key);
+    target.selectorAtoms.delete(key);
+    const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
+      ([downstreamSelectorKey]) => {
+        var _a2;
+        return (_a2 = target.selectors.get(downstreamSelectorKey)) != null ? _a2 : target.readonlySelectors.get(downstreamSelectorKey);
+      }
+    );
+    for (const downstreamToken of downstreamTokens) {
+      if (downstreamToken) {
+        disposeSelector(downstreamToken, store);
+      }
     }
+    target.selectorGraph.delete(key);
+    store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
+    store.on.selectorDisposal.next(selectorToken);
   }
-  target.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
-  store.on.selectorDisposal.next(selectorToken);
 }
 
 // internal/src/subscribe/recall-state.ts
 var recallState = (state, store) => {
   const target = newest(store);
-  if (!target.operation.open) {
-    return target.valueMap.get(state.key);
+  if (target.operation.open) {
+    return target.operation.prev.get(state.key);
   }
-  return target.operation.prev.get(state.key);
+  return target.valueMap.get(state.key);
 };
 
 // internal/src/subscribe/subscribe-to-root-atoms.ts
@@ -1307,11 +1324,24 @@ var subscribeToRootAtoms = (selector, store) => {
 
 // internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
-  const state = withdrawOrCreate(token, store);
+  function safelyHandleUpdate(update) {
+    if (store.operation.open) {
+      const unsubscribe2 = store.on.operationClose.subscribe(
+        `state subscription ${key}`,
+        () => {
+          unsubscribe2();
+          handleUpdate(update);
+        }
+      );
+    } else {
+      handleUpdate(update);
+    }
+  }
+  const state = withdraw(token, store);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
   const isSelector = state.type === `selector` || state.type === `readonly_selector`;
   let dependencyUnsubFunctions = null;
-  let updateHandler = handleUpdate;
+  let updateHandler = safelyHandleUpdate;
   if (isSelector) {
     dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
     updateHandler = (update) => {
@@ -1319,7 +1349,7 @@ function subscribeToState(token, handleUpdate, key, store) {
         dependencyUnsubFunctions.length = 0;
         dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
       }
-      handleUpdate(update);
+      safelyHandleUpdate(update);
     };
   }
   const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
@@ -1408,18 +1438,7 @@ var Tracker = class {
     this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
       subscriptionKey,
       (update) => {
-        if (target.operation.open) {
-          const unsubscribe = target.on.operationClose.subscribe(
-            subscriptionKey,
-            () => {
-              unsubscribe();
-              setIntoStore(latestUpdateState, update, target);
-            }
-          );
-        } else {
-          setIntoStore(mutableState, (current) => current, target);
-          setIntoStore(latestUpdateState, update, target);
-        }
+        setIntoStore(latestUpdateState, update, target);
       }
     );
     this.unsubscribeFromState = subscribeToState(
@@ -1430,18 +1449,7 @@ var Tracker = class {
           this.unsubscribeFromInnerValue = update.newValue.subscribe(
             subscriptionKey,
             (transceiverUpdate) => {
-              if (target.operation.open) {
-                const unsubscribe = target.on.operationClose.subscribe(
-                  subscriptionKey,
-                  () => {
-                    unsubscribe();
-                    setIntoStore(latestUpdateState, transceiverUpdate, target);
-                  }
-                );
-              } else {
-                setIntoStore(mutableState, (current) => current, target);
-                setIntoStore(latestUpdateState, transceiverUpdate, target);
-              }
+              setIntoStore(latestUpdateState, transceiverUpdate, target);
             }
           );
         }
@@ -1590,37 +1598,41 @@ function createMutableAtom(options, family, store) {
     };
   }
   new Tracker(token, store);
-  json.selectJson(token, options, store);
+  if (!family) {
+    json.selectJson(token, options, store);
+  }
   store.on.atomCreation.next(token);
   return token;
 }
 var FamilyTracker = class {
-  constructor(findMutableState, store) {
-    this.findLatestUpdateState = createRegularAtomFamily(
+  constructor(mutableAtoms, store) {
+    this.latestUpdateAtoms = createRegularAtomFamily(
       {
-        key: `*${findMutableState.key}`,
+        key: `*${mutableAtoms.key}`,
         default: null
       },
       store
     );
-    this.findMutableState = findMutableState;
-    this.findMutableState.subject.subscribe(
+    this.mutableAtoms = mutableAtoms;
+    this.mutableAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
           const key = json.parseJson(atomToken.family.subKey);
-          this.findLatestUpdateState(key);
+          seekInStore(this.latestUpdateAtoms, key, store);
           new Tracker(atomToken, store);
         }
       }
     );
-    this.findLatestUpdateState.subject.subscribe(
+    this.latestUpdateAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
       (atomToken) => {
         if (atomToken.family) {
           const key = json.parseJson(atomToken.family.subKey);
-          const mutableAtomToken = this.findMutableState(key);
-          new Tracker(mutableAtomToken, store);
+          const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
+          if (mutableAtomToken) {
+            new Tracker(mutableAtomToken, store);
+          }
         }
       }
     );
@@ -1635,25 +1647,19 @@ function createMutableAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const target2 = newest(store);
-      const atomAlreadyCreated = target2.atoms.has(fullKey);
-      let token;
-      if (atomAlreadyCreated) {
-        token = { type: `mutable_atom`, key: fullKey, family };
-      } else {
-        const individualOptions = {
-          key: fullKey,
-          default: () => options.default(key),
-          toJson: options.toJson,
-          fromJson: options.fromJson,
-          mutable: true
-        };
-        if (options.effects) {
-          individualOptions.effects = options.effects(key);
-        }
-        token = createMutableAtom(individualOptions, family, store);
-        subject.next(token);
+      const target = newest(store);
+      const individualOptions = {
+        key: fullKey,
+        default: () => options.default(key),
+        toJson: options.toJson,
+        fromJson: options.fromJson,
+        mutable: true
+      };
+      if (options.effects) {
+        individualOptions.effects = options.effects(key);
       }
+      const token = createMutableAtom(individualOptions, family, target);
+      subject.next(token);
       return token;
     },
     {
@@ -1665,8 +1671,7 @@ function createMutableAtomFamily(options, store) {
       fromJson: options.fromJson
     }
   );
-  const target = newest(store);
-  target.families.set(options.key, atomFamily);
+  store.families.set(options.key, atomFamily);
   json.selectJsonFamily(atomFamily, options, store);
   new FamilyTracker(atomFamily, store);
   return atomFamily;
@@ -1681,19 +1686,24 @@ var getJsonFamily = (mutableAtomFamily, store) => {
 };
 
 // internal/src/mutable/get-json-token.ts
-var getJsonToken = (mutableAtomToken) => {
-  const key = mutableAtomToken.family ? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})` : `${mutableAtomToken.key}:JSON`;
-  const jsonToken = {
-    type: `selector`,
-    key
-  };
+var getJsonToken = (mutableAtomToken, store) => {
   if (mutableAtomToken.family) {
-    jsonToken.family = {
-      key: `${mutableAtomToken.family.key}:JSON`,
-      subKey: mutableAtomToken.family.subKey
+    const target = newest(store);
+    const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
+    const jsonFamilyToken = {
+      key: jsonFamilyKey,
+      type: `selector_family`
     };
+    const family = withdraw(jsonFamilyToken, target);
+    const subKey = JSON.parse(mutableAtomToken.family.subKey);
+    const jsonToken = findInStore(family, subKey, store);
+    return jsonToken;
   }
-  return jsonToken;
+  const token = {
+    type: `selector`,
+    key: `${mutableAtomToken.key}:JSON`
+  };
+  return token;
 };
 
 // internal/src/mutable/get-update-token.ts
@@ -1889,8 +1899,10 @@ function disposeAtom(atomToken, store) {
       `\u274C`,
       `atom`,
       key,
-      `Tried to delete atom, but it does not exist in the store.`
+      `Tried to dispose atom, but it does not exist in the store.`
     );
+  } else if (!atom.family) {
+    store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
     (_a = atom.cleanup) == null ? void 0 : _a.call(atom);
     target.atoms.delete(key);
@@ -1910,6 +1922,7 @@ function disposeAtom(atomToken, store) {
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
       disposeAtom(updateToken, store);
+      store.trackers.delete(key);
     }
     store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
     store.on.atomDisposal.next(atomToken);
@@ -1927,7 +1940,7 @@ function getEnvironmentData(store) {
 
 // internal/src/get-state/get-from-store.ts
 function getFromStore(token, store) {
-  const state = withdrawOrCreate(token, store);
+  const state = withdraw(token, store);
   return readOrComputeValue(state, store);
 }
 
@@ -2481,7 +2494,9 @@ var buildTransaction = (key, params, store, id) => {
       makeContentKey: (...keys) => keys.sort().join(`:`)
     }),
     selectors: new LazyMap(parent.selectors),
-    valueMap: new LazyMap(parent.valueMap)
+    valueMap: new LazyMap(parent.valueMap),
+    molecules: new LazyMap(parent.molecules),
+    miscResources: new LazyMap(parent.miscResources)
   };
   const epoch = getEpochNumberOfAction(key, store);
   const transactionMeta = {
@@ -2501,6 +2516,7 @@ var buildTransaction = (key, params, store, id) => {
       },
       run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
       find: (token, k) => findInStore(token, k, child),
+      seek: (token, k) => seekInStore(token, k, child),
       env: () => getEnvironmentData(child)
     }
   };
@@ -2619,6 +2635,7 @@ exports.getUpdateToken = getUpdateToken;
 exports.ingestAtomUpdate = ingestAtomUpdate;
 exports.ingestSelectorUpdate = ingestSelectorUpdate;
 exports.ingestTransactionUpdate = ingestTransactionUpdate;
+exports.initFamilyMember = initFamilyMember;
 exports.isAtomDefault = isAtomDefault;
 exports.isAtomKey = isAtomKey;
 exports.isChildStore = isChildStore;
@@ -2637,6 +2654,7 @@ exports.openOperation = openOperation;
 exports.readCachedValue = readCachedValue;
 exports.readOrComputeValue = readOrComputeValue;
 exports.registerSelector = registerSelector;
+exports.seekInStore = seekInStore;
 exports.setAtomOrSelector = setAtomOrSelector;
 exports.setEpochNumberOfAction = setEpochNumberOfAction;
 exports.setEpochNumberOfContinuity = setEpochNumberOfContinuity;
@@ -2650,4 +2668,3 @@ exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
 exports.traceSelectorAtoms = traceSelectorAtoms;
 exports.updateSelectorAtoms = updateSelectorAtoms;
 exports.withdraw = withdraw;
-exports.withdrawOrCreate = withdrawOrCreate;