atom.io 0.27.1 → 0.27.3

package/dist/chunk-ETCFHO7J.js

@@ -0,0 +1,3087 @@
+import { Junction } from './chunk-IBTHB2PI.js';
+import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
+import { AtomIOLogger } from 'atom.io';
+import { getJoin, findRelations } from 'atom.io/data';
+
+// internal/src/arbitrary.ts
+function arbitrary(random = Math.random) {
+  return random().toString(36).slice(2);
+}
+
+// internal/src/future.ts
+var Future = class extends Promise {
+  fate;
+  resolve;
+  reject;
+  constructor(executor) {
+    let superResolve;
+    let superReject;
+    super((resolve, reject) => {
+      superResolve = resolve;
+      superReject = reject;
+    });
+    this.resolve = superResolve;
+    this.reject = superReject;
+    this.use(executor instanceof Promise ? executor : new Promise(executor));
+  }
+  pass(promise, value) {
+    if (promise === this.fate) {
+      this.resolve(value);
+    }
+  }
+  fail(promise, reason) {
+    if (promise === this.fate) {
+      this.reject(reason);
+    }
+  }
+  use(value) {
+    if (value instanceof Promise) {
+      const promise = value;
+      this.fate = promise;
+      promise.then(
+        (resolved) => {
+          this.pass(promise, resolved);
+        },
+        (reason) => {
+          this.fail(promise, reason);
+        }
+      );
+    } else {
+      this.resolve(value);
+      this.fate = void 0;
+    }
+  }
+};
+
+// internal/src/lineage.ts
+function newest(scion) {
+  while (scion.child !== null) {
+    scion = scion.child;
+  }
+  return scion;
+}
+function eldest(scion) {
+  while (scion.parent !== null) {
+    scion = scion.parent;
+  }
+  return scion;
+}
+
+// internal/src/store/deposit.ts
+function deposit(state) {
+  const token = {
+    key: state.key,
+    type: state.type
+  };
+  if (`family` in state) {
+    token.family = state.family;
+  }
+  return token;
+}
+
+// internal/src/subject.ts
+var Subject = class {
+  Subscriber;
+  subscribers = /* @__PURE__ */ new Map();
+  subscribe(key, subscriber) {
+    this.subscribers.set(key, subscriber);
+    const unsubscribe = () => {
+      this.unsubscribe(key);
+    };
+    return unsubscribe;
+  }
+  unsubscribe(key) {
+    this.subscribers.delete(key);
+  }
+  next(value) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
+      subscriber(value);
+    }
+  }
+};
+var StatefulSubject = class extends Subject {
+  state;
+  constructor(initialState) {
+    super();
+    this.state = initialState;
+  }
+  next(value) {
+    this.state = value;
+    super.next(value);
+  }
+};
+
+// internal/src/transaction/is-root-store.ts
+function isRootStore(store) {
+  return `epoch` in store.transactionMeta;
+}
+function isChildStore(store) {
+  return `phase` in store.transactionMeta;
+}
+
+// internal/src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  const target = newest(store);
+  if (!isChildStore(target)) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
+  }
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
+  );
+  target.parent.child = null;
+};
+
+// internal/src/pretty-print.ts
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+function prettyPrintTokenType(token) {
+  switch (token.type) {
+    case `atom_family`:
+      return `Atom Family`;
+    case `molecule_family`:
+      return `Molecule Family`;
+    case `mutable_atom_family`:
+      return `Mutable 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);
+  }
+}
+
+// internal/src/not-found-error.ts
+var NotFoundError = class extends Error {
+  constructor(...params) {
+    const token = params[0];
+    const store = params.length === 2 ? params[1] : params[2];
+    if (params.length === 2) {
+      super(
+        `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
+      );
+    } else {
+      const key = params[1];
+      super(
+        `${prettyPrintTokenType(token)} "${token.key}" member ${stringifyJson(key)} not found in store "${store.config.name}".`
+      );
+    }
+  }
+};
+
+// internal/src/transaction/act-upon-store.ts
+function actUponStore(token, id, store) {
+  return (...parameters) => {
+    const tx = withdraw(token, store);
+    if (tx) {
+      return tx.run(parameters, id);
+    }
+    throw new NotFoundError(token, store);
+  };
+}
+
+// internal/src/set-state/become.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+
+// internal/src/get-state/read-or-compute-value.ts
+var readOrComputeValue = (state, target) => {
+  if (target.valueMap.has(state.key)) {
+    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
+    return readCachedValue(state, target);
+  }
+  if (state.type !== `atom` && state.type !== `mutable_atom`) {
+    target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
+    return state.get();
+  }
+  const fallback = state.default instanceof Function ? state.default() : state.default;
+  target.logger.info(
+    `\u{1F481}`,
+    `atom`,
+    state.key,
+    `could not find cached value; using default`,
+    fallback
+  );
+  return state.default instanceof Function ? state.default() : state.default;
+};
+
+// internal/src/operation.ts
+var openOperation = (token, store) => {
+  if (store.operation.open) {
+    const rejectionTime = performance.now();
+    store.logger.info(
+      `\u2757`,
+      token.type,
+      token.key,
+      `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`
+    );
+    return rejectionTime;
+  }
+  store.operation = {
+    open: true,
+    done: /* @__PURE__ */ new Set(),
+    prev: /* @__PURE__ */ new Map(),
+    time: Date.now(),
+    token
+  };
+  store.logger.info(
+    `\u2B55`,
+    token.type,
+    token.key,
+    `operation start in store "${store.config.name}"${!isChildStore(store) ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
+  );
+};
+var closeOperation = (store) => {
+  if (store.operation.open) {
+    store.logger.info(
+      `\u{1F534}`,
+      store.operation.token.type,
+      store.operation.token.key,
+      `operation done in store "${store.config.name}"`
+    );
+  }
+  store.operation = { open: false };
+  store.on.operationClose.next(store.operation);
+};
+var isDone = (key, store) => {
+  if (!store.operation.open) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `isDone called outside of an operation. This is probably a bug.`
+    );
+    return true;
+  }
+  return store.operation.done.has(key);
+};
+var markDone = (key, store) => {
+  if (!store.operation.open) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `markDone called outside of an operation. This is probably a bug.`
+    );
+    return;
+  }
+  store.operation.done.add(key);
+};
+
+// internal/src/set-state/emit-update.ts
+var emitUpdate = (state, update, store) => {
+  switch (state.type) {
+    case `mutable_atom`:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `is now (`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+      break;
+    default:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `went (`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+  }
+  state.subject.next(update);
+};
+
+// internal/src/set-state/evict-downstream.ts
+var evictDownStream = (atom, store) => {
+  const target = newest(store);
+  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key);
+  target.logger.info(
+    `\u{1F9F9}`,
+    atom.type,
+    atom.key,
+    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
+    downstreamKeys ?? `to evict`
+  );
+  if (downstreamKeys) {
+    if (target.operation.open) {
+      target.logger.info(
+        `\u{1F9F9}`,
+        atom.type,
+        atom.key,
+        `[ ${[...target.operation.done].join(`, `)} ] already done`
+      );
+    }
+    for (const key of downstreamKeys) {
+      if (isDone(key, target)) {
+        continue;
+      }
+      evictCachedValue(key, target);
+      markDone(key, target);
+    }
+  }
+};
+
+// internal/src/set-state/stow-update.ts
+function shouldUpdateBeStowed(key, update) {
+  if (isTransceiver(update.newValue)) {
+    return false;
+  }
+  if (key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+    return false;
+  }
+  return true;
+}
+var stowUpdate = (state, update, store) => {
+  const { key } = state;
+  const target = newest(store);
+  if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
+    store.logger.error(
+      `\u{1F41E}`,
+      `atom`,
+      key,
+      `stowUpdate called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  const shouldStow = shouldUpdateBeStowed(key, update);
+  if (!shouldStow) {
+    return;
+  }
+  const atomUpdate = {
+    type: `atom_update`,
+    key,
+    ...update
+  };
+  if (state.family) {
+    atomUpdate.family = state.family;
+  }
+  target.transactionMeta.update.updates.push(atomUpdate);
+  store.logger.info(
+    `\u{1F4C1}`,
+    `atom`,
+    key,
+    `stowed (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `)`
+  );
+};
+
+// internal/src/set-state/set-atom.ts
+var setAtom = (atom, next, target) => {
+  const oldValue = readOrComputeValue(atom, target);
+  let newValue = oldValue;
+  if (atom.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(atom, parent, target);
+    newValue = copiedValue;
+  }
+  newValue = become(next)(newValue);
+  target.logger.info(`\u{1F4DD}`, `atom`, atom.key, `set to`, newValue);
+  newValue = cacheValue(atom.key, newValue, atom.subject, target);
+  if (isAtomDefault(atom.key, target)) {
+    markAtomAsNotDefault(atom.key, target);
+  }
+  markDone(atom.key, target);
+  evictDownStream(atom, target);
+  const update = { oldValue, newValue };
+  if (isRootStore(target)) {
+    emitUpdate(atom, update, target);
+  } else if (target.parent) {
+    if (target.on.transactionApplying.state === null) {
+      stowUpdate(atom, update, target);
+    } else if (atom.key.startsWith(`*`)) {
+      const mutableKey = atom.key.slice(1);
+      const mutableAtom = target.atoms.get(mutableKey);
+      let transceiver = target.valueMap.get(mutableKey);
+      if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
+        const { parent } = target;
+        const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target);
+        transceiver = copiedValue;
+      }
+      const accepted = transceiver.do(update.newValue) === null;
+      if (accepted) evictDownStream(mutableAtom, target);
+    }
+  }
+};
+
+// internal/src/set-state/set-atom-or-selector.ts
+var setAtomOrSelector = (state, value, store) => {
+  switch (state.type) {
+    case `atom`:
+    case `mutable_atom`:
+      setAtom(state, value, store);
+      break;
+    case `selector`:
+      state.set(value);
+      break;
+  }
+};
+
+// internal/src/families/throw-in-case-of-conflicting-family.ts
+function throwInCaseOfConflictingFamily(family, store) {
+  const existingFamily = store.families.get(family.key);
+  if (existingFamily) {
+    throw new Error(
+      `Tried to create ${family.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(family)} with key "${family.key}", but "${family.key}" already exists in store "${store.config.name}" as ${existingFamily.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(
+        existingFamily
+      )}`
+    );
+  }
+}
+
+// internal/src/families/create-regular-atom-family.ts
+function createRegularAtomFamily(options, store, internalRoles) {
+  const familyToken = {
+    key: options.key,
+    type: `atom_family`
+  };
+  throwInCaseOfConflictingFamily(familyToken, store);
+  const subject = new Subject();
+  const familyFunction = (key) => {
+    const subKey = stringifyJson(key);
+    const family = { key: options.key, subKey };
+    const fullKey = `${options.key}(${subKey})`;
+    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({ type: `state_creation`, token });
+    return token;
+  };
+  const atomFamily = Object.assign(familyFunction, familyToken, {
+    subject,
+    install: (s) => createRegularAtomFamily(options, s),
+    internalRoles
+  });
+  store.families.set(options.key, atomFamily);
+  return familyToken;
+}
+
+// internal/src/families/create-atom-family.ts
+function createAtomFamily(options, store) {
+  const isMutable = `mutable` in options;
+  if (isMutable) {
+    return createMutableAtomFamily(options, store);
+  }
+  return createRegularAtomFamily(options, store);
+}
+
+// internal/src/get-state/get-from-store.ts
+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;
+  }
+}
+
+// internal/src/keys.ts
+var isAtomKey = (key, store) => newest(store).atoms.has(key);
+var isSelectorKey = (key, store) => newest(store).selectors.has(key);
+var isReadonlySelectorKey = (key, store) => newest(store).readonlySelectors.has(key);
+var isStateKey = (key, store) => isAtomKey(key, store) || isSelectorKey(key, store) || isReadonlySelectorKey(key, store);
+
+// internal/src/selector/get-selector-dependency-keys.ts
+var getSelectorDependencyKeys = (key, store) => {
+  const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(source, store));
+  return sources;
+};
+
+// internal/src/selector/trace-selector-atoms.ts
+var traceSelectorAtoms = (directDependencyKey, covered, store) => {
+  const rootKeys = [];
+  const indirectDependencyKeys = getSelectorDependencyKeys(
+    directDependencyKey,
+    store
+  );
+  while (indirectDependencyKeys.length > 0) {
+    const indirectDependencyKey = indirectDependencyKeys.shift();
+    if (covered.has(indirectDependencyKey)) {
+      continue;
+    }
+    covered.add(indirectDependencyKey);
+    if (!isAtomKey(indirectDependencyKey, store)) {
+      indirectDependencyKeys.push(
+        ...getSelectorDependencyKeys(indirectDependencyKey, store)
+      );
+    } else if (!rootKeys.includes(indirectDependencyKey)) {
+      rootKeys.push(indirectDependencyKey);
+    }
+  }
+  return rootKeys;
+};
+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(depKey, covered, store)
+  );
+};
+
+// internal/src/selector/update-selector-atoms.ts
+var updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
+  const target = newest(store);
+  if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
+    target.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key
+    });
+    store.logger.info(
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atom "${dependency.key}"`
+    );
+  } else {
+    const rootKeys = traceSelectorAtoms(dependency.key, covered, store);
+    store.logger.info(
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`
+    );
+    for (const atomKey of rootKeys) {
+      target.selectorAtoms = target.selectorAtoms.set({
+        selectorKey,
+        atomKey
+      });
+    }
+  }
+  covered.add(dependency.key);
+};
+
+// internal/src/selector/register-selector.ts
+var registerSelector = (selectorKey, covered, store) => ({
+  get: (...params) => {
+    const target = newest(store);
+    let dependency;
+    if (params.length === 2) {
+      const [family, key] = params;
+      switch (family.type) {
+        case `molecule_family`:
+          return getFromStore(family, key, store);
+        default:
+          if (store.config.lifespan === `ephemeral`) {
+            dependency = findInStore(family, key, store);
+          } else {
+            const maybeDependency = seekInStore(family, key, store);
+            if (maybeDependency) {
+              dependency = maybeDependency;
+            } else {
+              throw new NotFoundError(family, key, store);
+            }
+          }
+      }
+    } else {
+      [dependency] = params;
+    }
+    if (dependency.type === `molecule`) {
+      return getFromStore(dependency, store);
+    }
+    const dependencyState = withdraw(dependency, store);
+    const dependencyValue = readOrComputeValue(dependencyState, store);
+    store.logger.info(
+      `\u{1F50C}`,
+      `selector`,
+      selectorKey,
+      `registers dependency ( "${dependency.key}" =`,
+      dependencyValue,
+      `)`
+    );
+    target.selectorGraph.set(
+      {
+        upstreamSelectorKey: dependency.key,
+        downstreamSelectorKey: selectorKey
+      },
+      {
+        source: dependency.key
+      }
+    );
+    updateSelectorAtoms(selectorKey, dependency, covered, store);
+    return dependencyValue;
+  },
+  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(token, target);
+    setAtomOrSelector(state, value, target);
+  },
+  find: (token, key) => findInStore(token, key, store),
+  seek: (token, key) => seekInStore(token, key, store),
+  json: (token) => getJsonToken(token, store)
+});
+
+// internal/src/selector/create-readonly-selector.ts
+var createReadonlySelector = (options, family, store) => {
+  const target = newest(store);
+  const subject = new Subject();
+  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 = {
+    ...options,
+    subject,
+    install: (s) => createReadonlySelector(options, family, s),
+    get: getSelf,
+    type: `readonly_selector`,
+    ...family && { family }
+  };
+  target.readonlySelectors.set(options.key, readonlySelector);
+  const initialValue = getSelf();
+  store.logger.info(
+    `\u2728`,
+    readonlySelector.type,
+    readonlySelector.key,
+    `=`,
+    initialValue
+  );
+  const token = {
+    key: options.key,
+    type: `readonly_selector`
+  };
+  if (family) {
+    token.family = family;
+  }
+  return token;
+};
+
+// internal/src/selector/create-writable-selector.ts
+var createWritableSelector = (options, family, store) => {
+  const target = newest(store);
+  const subject = new Subject();
+  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(getterToolkit);
+    cacheValue(options.key, value, subject, innerTarget);
+    covered.clear();
+    return value;
+  };
+  const setSelf = (next) => {
+    const innerTarget = newest(store);
+    const oldValue = getSelf(innerTarget);
+    const newValue = become(next)(oldValue);
+    store.logger.info(
+      `\u{1F4DD}`,
+      `selector`,
+      options.key,
+      `set (`,
+      oldValue,
+      `->`,
+      newValue,
+      `)`
+    );
+    cacheValue(options.key, newValue, subject, innerTarget);
+    markDone(options.key, innerTarget);
+    if (isRootStore(innerTarget)) {
+      subject.next({ newValue, oldValue });
+    }
+    options.set(toolkit, newValue);
+  };
+  const mySelector = {
+    ...options,
+    subject,
+    install: (s) => createWritableSelector(options, family, s),
+    get: getSelf,
+    set: setSelf,
+    type: `selector`,
+    ...family && { family }
+  };
+  target.selectors.set(options.key, mySelector);
+  const initialValue = getSelf();
+  store.logger.info(`\u2728`, mySelector.type, mySelector.key, `=`, initialValue);
+  const token = {
+    key: options.key,
+    type: `selector`
+  };
+  if (family) {
+    token.family = family;
+  }
+  return token;
+};
+
+// internal/src/selector/create-standalone-selector.ts
+function createStandaloneSelector(options, store) {
+  const isWritable = `set` in options;
+  if (isWritable) {
+    const state2 = createWritableSelector(options, void 0, store);
+    store.on.selectorCreation.next(state2);
+    return state2;
+  }
+  const state = createReadonlySelector(options, void 0, store);
+  store.on.selectorCreation.next(state);
+  return state;
+}
+
+// internal/src/selector/dispose-selector.ts
+function disposeSelector(selectorToken, store) {
+  const target = newest(store);
+  const { key } = selectorToken;
+  const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key);
+  if (!selector) {
+    store.logger.info(
+      `\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 {
+    const molecule = target.molecules.get(selector.family.subKey);
+    if (molecule) {
+      molecule.tokens.delete(key);
+    }
+    switch (selectorToken.type) {
+      case `selector`:
+        {
+          target.selectors.delete(key);
+          const family = withdraw(
+            { key: selector.family.key, type: `selector_family` },
+            store
+          );
+          family.subject.next({
+            type: `state_disposal`,
+            token: selectorToken
+          });
+        }
+        break;
+      case `readonly_selector`:
+        {
+          target.readonlySelectors.delete(key);
+          const family = withdraw(
+            { key: selector.family.key, type: `readonly_selector_family` },
+            store
+          );
+          family.subject.next({
+            type: `state_disposal`,
+            token: selectorToken
+          });
+        }
+        break;
+    }
+    target.valueMap.delete(key);
+    target.selectorAtoms.delete(key);
+    const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
+      ([downstreamSelectorKey]) => target.selectors.get(downstreamSelectorKey) ?? 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`);
+    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+      target.transactionMeta.update.updates.push({
+        type: `state_disposal`,
+        token: selectorToken
+      });
+    } else {
+      store.on.selectorDisposal.next(selectorToken);
+    }
+  }
+}
+
+// internal/src/families/create-readonly-selector-family.ts
+function createReadonlySelectorFamily(options, store, internalRoles) {
+  const familyToken = {
+    key: options.key,
+    type: `readonly_selector_family`
+  };
+  throwInCaseOfConflictingFamily(familyToken, store);
+  const subject = new Subject();
+  const familyFunction = (key) => {
+    const subKey = stringifyJson(key);
+    const family = { key: options.key, subKey };
+    const fullKey = `${options.key}(${subKey})`;
+    const target = newest(store);
+    const token = createReadonlySelector(
+      {
+        key: fullKey,
+        get: options.get(key)
+      },
+      family,
+      target
+    );
+    subject.next({ type: `state_creation`, token });
+    return token;
+  };
+  const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+    subject,
+    install: (s) => createReadonlySelectorFamily(options, s),
+    internalRoles
+  });
+  store.families.set(options.key, readonlySelectorFamily);
+  return familyToken;
+}
+function createWritableSelectorFamily(options, store, internalRoles) {
+  const familyToken = {
+    key: options.key,
+    type: `selector_family`
+  };
+  throwInCaseOfConflictingFamily(familyToken, store);
+  const subject = new Subject();
+  const familyFunction = (key) => {
+    const subKey = stringifyJson(key);
+    const family = { key: options.key, subKey };
+    const fullKey = `${options.key}(${subKey})`;
+    const target = newest(store);
+    const token = createWritableSelector(
+      {
+        key: fullKey,
+        get: options.get(key),
+        set: options.set(key)
+      },
+      family,
+      target
+    );
+    subject.next({ type: `state_creation`, token });
+    return token;
+  };
+  const selectorFamily = Object.assign(familyFunction, familyToken, {
+    subject,
+    install: (s) => createWritableSelectorFamily(options, s),
+    internalRoles
+  });
+  store.families.set(options.key, selectorFamily);
+  return familyToken;
+}
+
+// internal/src/families/create-selector-family.ts
+function createSelectorFamily(options, store) {
+  const isWritable = `set` in options;
+  if (isWritable) {
+    return createWritableSelectorFamily(options, store);
+  }
+  return createReadonlySelectorFamily(options, store);
+}
+
+// internal/src/molecule/dispose-molecule.ts
+function disposeMolecule(token, store) {
+  let molecule;
+  try {
+    molecule = withdraw(token, store);
+  } catch (thrown) {
+    if (thrown instanceof Error) {
+      store.logger.error(
+        `\u{1F41E}`,
+        `molecule`,
+        JSON.stringify(token.key),
+        `Failed to dispose molecule, because it was not found in the store.`,
+        thrown.message
+      );
+    }
+    return;
+  }
+  const { family } = token;
+  const context = [];
+  for (const above of molecule.above.values()) {
+    context.push(deposit(above));
+  }
+  const values = [];
+  for (const stateToken of molecule.tokens.values()) {
+    const tokenFamily = stateToken.family;
+    values.push([tokenFamily.key, store.valueMap.get(stateToken.key)]);
+  }
+  if (family) {
+    const Formula = withdraw(family, store);
+    const disposalEvent = {
+      type: `molecule_disposal`,
+      token,
+      family,
+      context,
+      values
+    };
+    if (token.family) {
+      disposalEvent.family = token.family;
+    }
+    for (const state of molecule.tokens.values()) {
+      disposeFromStore(state, store);
+    }
+    for (const child of molecule.below.values()) {
+      if (child.family?.dependsOn === `all`) {
+        disposeMolecule(child, store);
+      } else {
+        child.above.delete(molecule.stringKey);
+        if (child.above.size === 0) {
+          disposeMolecule(child, store);
+        }
+      }
+    }
+    molecule.below.clear();
+    const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
+    if (isTransaction) {
+      store.transactionMeta.update.updates.push(disposalEvent);
+    } else {
+      Formula.subject.next(disposalEvent);
+    }
+    store.molecules.delete(molecule.stringKey);
+  }
+  for (const join of molecule.joins.values()) {
+    join.molecules.delete(molecule.stringKey);
+  }
+  for (const parent of molecule.above.values()) {
+    parent.below.delete(molecule.stringKey);
+  }
+}
+
+// internal/src/families/init-family-member.ts
+function initFamilyMemberInStore(token, key, store) {
+  const familyKey = token.key;
+  const family = store.families.get(familyKey);
+  if (family === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  const state = family(key);
+  const target = newest(store);
+  if (state.family && target.moleculeInProgress === null) {
+    if (isRootStore(target)) {
+      switch (state.type) {
+        case `atom`:
+        case `mutable_atom`:
+          store.on.atomCreation.next(state);
+          break;
+        case `selector`:
+        case `readonly_selector`:
+          store.on.selectorCreation.next(state);
+          break;
+      }
+    } else if (isChildStore(target) && target.on.transactionApplying.state === null) {
+      target.transactionMeta.update.updates.push({
+        type: `state_creation`,
+        token: state
+      });
+    }
+  }
+  return state;
+}
+function seekInStore(token, key, store) {
+  const subKey = 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;
+    case `molecule_family`:
+      state = target.molecules.get(stringifyJson(key));
+      if (state) {
+        return deposit(state);
+      }
+  }
+  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 = initFamilyMemberInStore(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) {
+  const subject = new Subject();
+  const token = {
+    type: `molecule_family`,
+    key: options.key,
+    dependsOn: options.dependsOn ?? `all`
+  };
+  const family = {
+    ...token,
+    subject,
+    new: options.new
+  };
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
+
+// internal/src/molecule/grow-molecule-in-store.ts
+function growMoleculeInStore(molecule, family, store) {
+  const stateToken = initFamilyMemberInStore(family, molecule.key, store);
+  molecule.tokens.set(stateToken.key, stateToken);
+  const isTransaction = isChildStore(store) && store.transactionMeta.phase === `building`;
+  const moleculeInProgress = store.moleculeInProgress === molecule.key;
+  if (!isTransaction && !moleculeInProgress) {
+    molecule.subject.next({ type: `state_creation`, token: stateToken });
+  }
+  return stateToken;
+}
+
+// internal/src/get-environment-data.ts
+function getEnvironmentData(store) {
+  return {
+    store
+  };
+}
+var Molecule = class {
+  constructor(ctx, key, family) {
+    this.key = key;
+    this.stringKey = stringifyJson(key);
+    if (family) {
+      this.family = family;
+    }
+    if (ctx) {
+      if (Array.isArray(ctx)) {
+        for (const molecule of ctx) {
+          this.above.set(molecule.stringKey, molecule);
+        }
+      } else {
+        this.above.set(ctx.stringKey, ctx);
+      }
+    }
+  }
+  type = `molecule`;
+  stringKey;
+  family;
+  subject = new Subject();
+  tokens = /* @__PURE__ */ new Map();
+  above = /* @__PURE__ */ new Map();
+  below = /* @__PURE__ */ new Map();
+  joins = /* @__PURE__ */ new Map();
+  instance;
+};
+
+// 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);
+  const stringKey = stringifyJson(key);
+  target.moleculeInProgress = stringKey;
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => {
+    if (ctx instanceof Molecule) {
+      return ctx;
+    }
+    const ctxStringKey = stringifyJson(ctx.key);
+    const molecule2 = store.molecules.get(ctxStringKey);
+    if (!molecule2) {
+      throw new Error(
+        `Molecule ${ctxStringKey} not found in store "${store.config.name}"`
+      );
+    }
+    return molecule2;
+  });
+  const molecule = new Molecule(owners, key, familyToken);
+  target.molecules.set(stringKey, molecule);
+  for (const owner of owners) {
+    owner.below.set(molecule.stringKey, molecule);
+  }
+  const toolkit = {
+    get: (...ps) => getFromStore(...ps, newest(rootStore)),
+    set: (...ps) => {
+      setIntoStore(...ps, newest(rootStore));
+    },
+    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(rootStore), ctx, f, k, ...args),
+    dispose: (t) => {
+      disposeFromStore(t, newest(rootStore));
+    },
+    env: () => getEnvironmentData(newest(rootStore)),
+    bond: (token2, maybeRole) => {
+      if (token2.type === `join`) {
+        const { as: role } = maybeRole;
+        const join = 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` && 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 = 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)
+      );
+    },
+    claim: (below, options) => {
+      const { exclusive } = options;
+      const belowMolecule = newest(store).molecules.get(stringifyJson(below.key));
+      if (belowMolecule) {
+        if (exclusive) {
+          for (const value of belowMolecule.above.values()) {
+            value.below.delete(belowMolecule.stringKey);
+          }
+          belowMolecule.above.clear();
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        } else {
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        }
+      }
+    },
+    spawn: (f, k, ...p) => makeMoleculeInStore(
+      newest(store),
+      [molecule],
+      withdraw(f, store),
+      k,
+      ...p
+    )
+  };
+  const family = withdraw(familyToken, store);
+  const Constructor = family.new;
+  molecule.instance = new Constructor(toolkit, key, ...params);
+  const token = {
+    type: `molecule`,
+    key,
+    family: familyToken
+  };
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family: familyToken,
+    context: contextArray,
+    params
+  };
+  if (isRootStore(target)) {
+    family.subject.next(update);
+  } else if (isChildStore(target) && target.on.transactionApplying.state === null) {
+    target.transactionMeta.update.updates.push(update);
+  }
+  target.moleculeInProgress = null;
+  return token;
+}
+
+// internal/src/ingest-updates/ingest-creation-disposal.ts
+function ingestCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`: {
+      createInStore(update.token, store);
+      break;
+    }
+    case `oldValue`: {
+      disposeFromStore(update.token, store);
+      break;
+    }
+  }
+}
+function ingestDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`: {
+      disposeFromStore(update.token, store);
+      break;
+    }
+    case `oldValue`: {
+      createInStore(update.token, store);
+      store.valueMap.set(update.token.key, update.value);
+      break;
+    }
+  }
+}
+function createInStore(token, store) {
+  if (token.family) {
+    const family = store.families.get(token.family.key);
+    if (family) {
+      const molecule = store.molecules.get(token.family.subKey);
+      if (molecule) {
+        growMoleculeInStore(molecule, family, store);
+        return;
+      }
+      if (store.config.lifespan === `immortal`) {
+        throw new Error(`No molecule found for key "${token.family.subKey}"`);
+      }
+      initFamilyMemberInStore(family, parseJson(token.family.subKey), store);
+    }
+  }
+}
+function ingestMoleculeCreationEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      makeMoleculeInStore(
+        store,
+        update.context,
+        update.family,
+        update.token.key,
+        ...update.params
+      );
+      break;
+    case `oldValue`:
+      disposeFromStore(update.token, store);
+      break;
+  }
+}
+function ingestMoleculeDisposalEvent(update, applying, store) {
+  switch (applying) {
+    case `newValue`:
+      disposeFromStore(update.token, store);
+      break;
+    case `oldValue`:
+      {
+        const moleculeToken = makeMoleculeInStore(
+          store,
+          update.context,
+          update.family,
+          update.token.key
+        );
+        for (const [familyKey, value] of update.values) {
+          const memberKey = `${familyKey}(${stringifyJson(moleculeToken.key)})`;
+          const molecule = withdraw(moleculeToken, store);
+          const alreadyCreated = molecule.tokens.has(memberKey);
+          const family = store.families.get(familyKey);
+          if (family && !alreadyCreated) {
+            growMoleculeInStore(molecule, family, store);
+          }
+          store.valueMap.set(memberKey, value);
+        }
+      }
+      break;
+  }
+}
+
+// internal/src/ingest-updates/ingest-selector-update.ts
+function ingestSelectorUpdate(applying, selectorUpdate, store) {
+  const updates = applying === `newValue` ? selectorUpdate.atomUpdates : selectorUpdate.atomUpdates.toReversed();
+  for (const atomUpdate of updates) {
+    ingestAtomUpdate(applying, atomUpdate, store);
+  }
+}
+
+// internal/src/ingest-updates/ingest-transaction-update.ts
+function ingestTransactionUpdate(applying, transactionUpdate, store) {
+  const updates = applying === `newValue` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
+  for (const updateFromTransaction of updates) {
+    switch (updateFromTransaction.type) {
+      case `atom_update`:
+      case `selector_update`:
+        ingestAtomUpdate(applying, updateFromTransaction, store);
+        break;
+      case `state_creation`:
+        ingestCreationEvent(updateFromTransaction, applying, store);
+        break;
+      case `state_disposal`:
+        ingestDisposalEvent(updateFromTransaction, applying, store);
+        break;
+      case `molecule_creation`:
+        ingestMoleculeCreationEvent(updateFromTransaction, applying, store);
+        break;
+      case `molecule_disposal`:
+        ingestMoleculeDisposalEvent(updateFromTransaction, applying, store);
+        break;
+      case `transaction_update`:
+        ingestTransactionUpdate(applying, updateFromTransaction, store);
+        break;
+    }
+  }
+}
+
+// internal/src/transaction/set-epoch-number.ts
+function setEpochNumberOfContinuity(continuityKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (isRoot && continuityKey) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+function setEpochNumberOfAction(transactionKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+  if (continuityKey !== void 0) {
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+  }
+}
+
+// internal/src/transaction/apply-transaction.ts
+var applyTransaction = (output, store) => {
+  const child = newest(store);
+  const { parent } = child;
+  if (parent === null || !isChildStore(child) || child.transactionMeta?.phase !== `building`) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
+  }
+  child.transactionMeta.phase = `applying`;
+  child.transactionMeta.update.output = output;
+  parent.child = null;
+  parent.on.transactionApplying.next(child.transactionMeta);
+  const { updates } = child.transactionMeta.update;
+  store.logger.info(
+    `\u{1F6C4}`,
+    `transaction`,
+    child.transactionMeta.update.key,
+    `Applying transaction with ${updates.length} updates:`,
+    updates
+  );
+  ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
+  if (isRootStore(parent)) {
+    setEpochNumberOfAction(
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch,
+      parent
+    );
+    const myTransaction = withdraw(
+      { key: child.transactionMeta.update.key, type: `transaction` },
+      store
+    );
+    myTransaction?.subject.next(child.transactionMeta.update);
+    store.logger.info(
+      `\u{1F6EC}`,
+      `transaction`,
+      child.transactionMeta.update.key,
+      `Finished applying transaction.`
+    );
+  } else if (isChildStore(parent)) {
+    parent.transactionMeta.update.updates.push(child.transactionMeta.update);
+  }
+  parent.on.transactionApplying.next(null);
+};
+
+// internal/src/transaction/assign-transaction-to-continuity.ts
+function assignTransactionToContinuity(continuityKey, transactionKey, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const { epoch, actionContinuities } = store.transactionMeta;
+  actionContinuities.set(continuityKey, transactionKey);
+  if (!epoch.has(continuityKey)) {
+    epoch.set(continuityKey, -1);
+  }
+}
+
+// internal/src/lazy-map.ts
+var LazyMap = class extends Map {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+  deleted = /* @__PURE__ */ new Set();
+  get(key) {
+    const has = super.has(key);
+    if (has) {
+      return super.get(key);
+    }
+    if (!this.deleted.has(key) && this.source.has(key)) {
+      const value = this.source.get(key);
+      return value;
+    }
+    return void 0;
+  }
+  set(key, value) {
+    this.deleted.delete(key);
+    return super.set(key, value);
+  }
+  hasOwn(key) {
+    return super.has(key);
+  }
+  has(key) {
+    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+  }
+  delete(key) {
+    this.deleted.add(key);
+    return super.delete(key);
+  }
+};
+
+// internal/src/transaction/build-transaction.ts
+var buildTransaction = (key, params, store, id) => {
+  const parent = newest(store);
+  const childBase = {
+    parent,
+    child: null,
+    on: parent.on,
+    loggers: parent.loggers,
+    logger: parent.logger,
+    config: parent.config,
+    atoms: new LazyMap(parent.atoms),
+    atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
+    families: new LazyMap(parent.families),
+    operation: { open: false },
+    readonlySelectors: new LazyMap(parent.readonlySelectors),
+    timelines: new LazyMap(parent.timelines),
+    timelineTopics: new Junction(parent.timelineTopics.toJSON()),
+    trackers: /* @__PURE__ */ new Map(),
+    transactions: new LazyMap(parent.transactions),
+    selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
+    selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
+      makeContentKey: (...keys) => keys.sort().join(`:`)
+    }),
+    selectors: new LazyMap(parent.selectors),
+    valueMap: new LazyMap(parent.valueMap),
+    molecules: new LazyMap(parent.molecules),
+    moleculeFamilies: new LazyMap(parent.moleculeFamilies),
+    moleculeInProgress: parent.moleculeInProgress,
+    miscResources: new LazyMap(parent.miscResources)
+  };
+  const epoch = getEpochNumberOfAction(key, store);
+  const transactionMeta = {
+    phase: `building`,
+    update: {
+      type: `transaction_update`,
+      key,
+      id,
+      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
+      updates: [],
+      params,
+      output: void 0
+    },
+    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: (...ps) => {
+        disposeFromStore(...ps, child);
+      },
+      env: () => getEnvironmentData(child)
+    }
+  };
+  const child = Object.assign(childBase, {
+    transactionMeta
+  });
+  parent.child = child;
+  store.logger.info(
+    `\u{1F6EB}`,
+    `transaction`,
+    key,
+    `Building transaction with params:`,
+    params
+  );
+  return child;
+};
+
+// internal/src/transaction/create-transaction.ts
+function createTransaction(options, store) {
+  const newTransaction = {
+    key: options.key,
+    type: `transaction`,
+    run: (params, id) => {
+      const childStore = buildTransaction(options.key, params, store, id);
+      try {
+        const target2 = newest(store);
+        const { toolkit } = childStore.transactionMeta;
+        const output = options.do(toolkit, ...params);
+        applyTransaction(output, target2);
+        return output;
+      } catch (thrown) {
+        abortTransaction(target);
+        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
+        throw thrown;
+      }
+    },
+    install: (s) => createTransaction(options, s),
+    subject: new Subject()
+  };
+  const target = newest(store);
+  target.transactions.set(newTransaction.key, newTransaction);
+  const token = deposit(newTransaction);
+  store.on.transactionCreation.next(token);
+  return token;
+}
+
+// internal/src/transaction/get-epoch-number.ts
+function getContinuityKey(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  return continuity;
+}
+function getEpochNumberOfContinuity(continuityKey, store) {
+  const isRoot = isRootStore(store);
+  const epoch = isRoot && continuityKey ? store.transactionMeta.epoch.get(continuityKey) : void 0;
+  return epoch;
+}
+function getEpochNumberOfAction(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : void 0;
+  const epoch = isRoot && continuity !== void 0 ? store.transactionMeta.epoch.get(continuity) : void 0;
+  return epoch;
+}
+
+// internal/src/transaction/index.ts
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+
+// internal/src/store/store.ts
+var Store = class {
+  parent = null;
+  child = null;
+  valueMap = /* @__PURE__ */ new Map();
+  atoms = /* @__PURE__ */ new Map();
+  selectors = /* @__PURE__ */ new Map();
+  readonlySelectors = /* @__PURE__ */ new Map();
+  atomsThatAreDefault = /* @__PURE__ */ new Set();
+  selectorAtoms = new Junction({
+    between: [`selectorKey`, `atomKey`],
+    cardinality: `n:n`
+  });
+  selectorGraph = new Junction(
+    {
+      between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
+      cardinality: `n:n`
+    },
+    {
+      makeContentKey: (...keys) => keys.sort().join(`:`)
+    }
+  );
+  trackers = /* @__PURE__ */ new Map();
+  families = /* @__PURE__ */ new Map();
+  transactions = /* @__PURE__ */ new Map();
+  transactionMeta = {
+    epoch: /* @__PURE__ */ new Map(),
+    actionContinuities: new Junction({
+      between: [`continuity`, `action`],
+      cardinality: `1:n`
+    })
+  };
+  timelines = /* @__PURE__ */ new Map();
+  timelineTopics = new Junction({
+    between: [`timelineKey`, `topicKey`],
+    cardinality: `1:n`
+  });
+  molecules = /* @__PURE__ */ new Map();
+  moleculeFamilies = /* @__PURE__ */ new Map();
+  moleculeInProgress = null;
+  miscResources = /* @__PURE__ */ new Map();
+  on = {
+    atomCreation: new Subject(),
+    atomDisposal: new Subject(),
+    selectorCreation: new Subject(),
+    selectorDisposal: new Subject(),
+    timelineCreation: new Subject(),
+    transactionCreation: new Subject(),
+    transactionApplying: new StatefulSubject(
+      null
+    ),
+    operationClose: new Subject(),
+    moleculeCreationStart: new Subject(),
+    moleculeCreationDone: new Subject(),
+    moleculeDisposal: new Subject()
+  };
+  operation = { open: false };
+  config = {
+    name: `IMPLICIT_STORE`,
+    lifespan: `ephemeral`
+  };
+  loggers = [
+    new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
+  ];
+  logger = {
+    error: (...messages) => {
+      for (const logger of this.loggers) logger.error(...messages);
+    },
+    info: (...messages) => {
+      for (const logger of this.loggers) logger.info(...messages);
+    },
+    warn: (...messages) => {
+      for (const logger of this.loggers) logger.warn(...messages);
+    }
+  };
+  constructor(config, store = null) {
+    this.config = {
+      ...store?.config,
+      ...config
+    };
+    if (store !== null) {
+      this.valueMap = new Map(store?.valueMap);
+      this.operation = { ...store?.operation };
+      if (isRootStore(store)) {
+        this.transactionMeta = {
+          epoch: new Map(store?.transactionMeta.epoch),
+          actionContinuities: new Junction(
+            store?.transactionMeta.actionContinuities.toJSON()
+          )
+        };
+      }
+      for (const [, family] of store.families) {
+        if (family.internalRoles?.includes(`mutable`) || family.internalRoles?.includes(`join`)) {
+          continue;
+        }
+        family.install(this);
+      }
+      const mutableHelpers = /* @__PURE__ */ new Set();
+      for (const [, atom] of store.atoms) {
+        if (mutableHelpers.has(atom.key)) {
+          continue;
+        }
+        atom.install(this);
+        if (atom.type === `mutable_atom`) {
+          const originalJsonToken = getJsonToken(atom, store);
+          const originalUpdateToken = getUpdateToken(atom);
+          mutableHelpers.add(originalJsonToken.key);
+          mutableHelpers.add(originalUpdateToken.key);
+        }
+      }
+      for (const [, selector] of store.readonlySelectors) {
+        selector.install(this);
+      }
+      for (const [, selector] of store.selectors) {
+        if (mutableHelpers.has(selector.key)) {
+          continue;
+        }
+        selector.install(this);
+      }
+      for (const [, tx] of store.transactions) {
+        tx.install(this);
+      }
+      for (const [, timeline] of store.timelines) {
+        timeline.install(this);
+      }
+    }
+  }
+};
+var IMPLICIT = {
+  get STORE() {
+    if (!globalThis.ATOM_IO_IMPLICIT_STORE) {
+      globalThis.ATOM_IO_IMPLICIT_STORE = new Store({
+        name: `IMPLICIT_STORE`,
+        lifespan: `ephemeral`
+      });
+    }
+    return globalThis.ATOM_IO_IMPLICIT_STORE;
+  }
+};
+var clearStore = (store) => {
+  const { config } = store;
+  for (const disposable of store.miscResources.values()) {
+    disposable[Symbol.dispose]();
+  }
+  Object.assign(store, new Store(config));
+  store.config = config;
+};
+function withdraw(token, store) {
+  let withdrawn;
+  let target = store;
+  while (target !== null) {
+    switch (token.type) {
+      case `atom`:
+      case `mutable_atom`:
+        withdrawn = target.atoms.get(token.key);
+        break;
+      case `selector`:
+        withdrawn = target.selectors.get(token.key);
+        break;
+      case `readonly_selector`:
+        withdrawn = target.readonlySelectors.get(token.key);
+        break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+      case `selector_family`:
+      case `readonly_selector_family`:
+        withdrawn = target.families.get(token.key);
+        break;
+      case `timeline`:
+        withdrawn = target.timelines.get(token.key);
+        break;
+      case `transaction`:
+        withdrawn = target.transactions.get(token.key);
+        break;
+      case `molecule`:
+        withdrawn = target.molecules.get(stringifyJson(token.key));
+        break;
+      case `molecule_family`:
+        withdrawn = target.moleculeFamilies.get(token.key);
+        break;
+    }
+    if (withdrawn) {
+      return withdrawn;
+    }
+    target = target.child;
+  }
+  throw new NotFoundError(token, store);
+}
+
+// internal/src/subscribe/recall-state.ts
+var recallState = (state, store) => {
+  const target = newest(store);
+  if (target.operation.open) {
+    return target.operation.prev.get(state.key);
+  }
+  return target.valueMap.get(state.key);
+};
+
+// internal/src/subscribe/subscribe-to-root-atoms.ts
+var subscribeToRootAtoms = (selector, store) => {
+  const target = newest(store);
+  const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
+    (atomKey) => {
+      const atom = target.atoms.get(atomKey);
+      if (atom === void 0) {
+        throw new Error(
+          `Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`
+        );
+      }
+      return atom.subject.subscribe(
+        `${selector.type}:${selector.key}`,
+        (atomChange) => {
+          store.logger.info(
+            `\u{1F4E2}`,
+            selector.type,
+            selector.key,
+            `root`,
+            atomKey,
+            `went`,
+            atomChange.oldValue,
+            `->`,
+            atomChange.newValue
+          );
+          const oldValue = recallState(selector, target);
+          const newValue = readOrComputeValue(selector, target);
+          store.logger.info(
+            `\u2728`,
+            selector.type,
+            selector.key,
+            `went`,
+            oldValue,
+            `->`,
+            newValue
+          );
+          selector.subject.next({ newValue, oldValue });
+        }
+      );
+    }
+  );
+  return dependencySubscriptions;
+};
+
+// internal/src/subscribe/subscribe-to-state.ts
+function subscribeToState(token, handleUpdate, key, 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 = safelyHandleUpdate;
+  if (isSelector) {
+    dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
+    updateHandler = (update) => {
+      if (dependencyUnsubFunctions) {
+        dependencyUnsubFunctions.length = 0;
+        dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
+      }
+      safelyHandleUpdate(update);
+    };
+  }
+  const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
+  const unsubscribe = () => {
+    store.logger.info(
+      `\u{1F648}`,
+      state.type,
+      state.key,
+      `Removing subscription "${key}"`
+    );
+    mainUnsubFunction();
+    if (dependencyUnsubFunctions) {
+      for (const unsubFromDependency of dependencyUnsubFunctions) {
+        unsubFromDependency();
+      }
+    }
+  };
+  return unsubscribe;
+}
+
+// internal/src/subscribe/subscribe-to-timeline.ts
+var subscribeToTimeline = (token, handleUpdate, key, store) => {
+  const tl = withdraw(token, store);
+  store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
+  const unsubscribe = tl.subject.subscribe(key, handleUpdate);
+  return () => {
+    store.logger.info(
+      `\u{1F648}`,
+      `timeline`,
+      token.key,
+      `Removing subscription "${key}" from timeline`
+    );
+    unsubscribe();
+  };
+};
+
+// internal/src/subscribe/subscribe-to-transaction.ts
+var subscribeToTransaction = (token, handleUpdate, key, store) => {
+  const tx = withdraw(token, store);
+  store.logger.info(
+    `\u{1F440}`,
+    `transaction`,
+    token.key,
+    `Adding subscription "${key}"`
+  );
+  const unsubscribe = tx.subject.subscribe(key, handleUpdate);
+  return () => {
+    store.logger.info(
+      `\u{1F648}`,
+      `transaction`,
+      token.key,
+      `Removing subscription "${key}"`
+    );
+    unsubscribe();
+  };
+};
+
+// internal/src/mutable/tracker.ts
+var Tracker = class {
+  Update;
+  initializeState(mutableState, store) {
+    const latestUpdateStateKey = `*${mutableState.key}`;
+    store.atoms.delete(latestUpdateStateKey);
+    store.valueMap.delete(latestUpdateStateKey);
+    const familyMetaData = mutableState.family ? {
+      key: `*${mutableState.family.key}`,
+      subKey: mutableState.family.subKey
+    } : void 0;
+    const latestUpdateState = createRegularAtom(
+      {
+        key: latestUpdateStateKey,
+        default: null
+      },
+      familyMetaData,
+      store
+    );
+    if (store.parent?.valueMap.has(latestUpdateStateKey)) {
+      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
+      store.valueMap.set(latestUpdateStateKey, parentValue);
+    }
+    return latestUpdateState;
+  }
+  unsubscribeFromInnerValue;
+  unsubscribeFromState;
+  observeCore(mutableState, latestUpdateState, target) {
+    const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+    const originalInnerValue = getFromStore(mutableState, target);
+    this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
+      subscriptionKey,
+      (update) => {
+        setIntoStore(latestUpdateState, update, target);
+      }
+    );
+    this.unsubscribeFromState = subscribeToState(
+      mutableState,
+      (update) => {
+        if (update.newValue !== update.oldValue) {
+          this.unsubscribeFromInnerValue();
+          this.unsubscribeFromInnerValue = update.newValue.subscribe(
+            subscriptionKey,
+            (transceiverUpdate) => {
+              setIntoStore(latestUpdateState, transceiverUpdate, target);
+            }
+          );
+        }
+      },
+      subscriptionKey,
+      target
+    );
+  }
+  updateCore(mutableState, latestUpdateState, target) {
+    const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+    subscribeToState(
+      latestUpdateState,
+      ({ newValue, oldValue }) => {
+        const timelineId = target.timelineTopics.getRelatedKey(
+          latestUpdateState.key
+        );
+        if (timelineId) {
+          const timelineData = target.timelines.get(timelineId);
+          if (timelineData?.timeTraveling) {
+            const unsubscribe2 = subscribeToTimeline(
+              { key: timelineId, type: `timeline` },
+              (update) => {
+                unsubscribe2();
+                setIntoStore(
+                  mutableState,
+                  (transceiver) => {
+                    if (update === `redo` && newValue) {
+                      transceiver.do(newValue);
+                    } else if (update === `undo` && oldValue) {
+                      transceiver.undo(oldValue);
+                    }
+                    return transceiver;
+                  },
+                  target
+                );
+              },
+              subscriptionKey,
+              target
+            );
+            return;
+          }
+        }
+        const unsubscribe = target.on.operationClose.subscribe(
+          subscriptionKey,
+          () => {
+            unsubscribe();
+            const mutable = getFromStore(mutableState, target);
+            const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
+            const eventOffset = updateNumber - mutable.cacheUpdateNumber;
+            if (newValue && eventOffset === 1) {
+              setIntoStore(
+                mutableState,
+                (transceiver) => (transceiver.do(newValue), transceiver),
+                target
+              );
+            } else {
+              target.logger.info(
+                `\u274C`,
+                `mutable_atom`,
+                mutableState.key,
+                `could not be updated. Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${updateNumber}`
+              );
+            }
+          }
+        );
+      },
+      subscriptionKey,
+      target
+    );
+  }
+  mutableState;
+  latestUpdateState;
+  dispose;
+  constructor(mutableState, store) {
+    this.mutableState = mutableState;
+    const target = newest(store);
+    this.latestUpdateState = this.initializeState(mutableState, target);
+    this.observeCore(mutableState, this.latestUpdateState, target);
+    this.updateCore(mutableState, this.latestUpdateState, target);
+    target.trackers.set(mutableState.key, this);
+    this.dispose = () => {
+      this.unsubscribeFromInnerValue();
+      this.unsubscribeFromState();
+      target.trackers.delete(mutableState.key);
+    };
+  }
+};
+
+// internal/src/mutable/create-mutable-atom.ts
+function createMutableAtom(options, family, store) {
+  store.logger.info(
+    `\u{1F528}`,
+    `atom`,
+    options.key,
+    `creating in store "${store.config.name}"`
+  );
+  const target = newest(store);
+  const existing = target.atoms.get(options.key);
+  if (existing && existing.type === `mutable_atom`) {
+    store.logger.error(
+      `\u274C`,
+      `atom`,
+      options.key,
+      `Tried to create atom, but it already exists in the store.`
+    );
+    return deposit(existing);
+  }
+  const subject = new Subject();
+  const newAtom = {
+    ...options,
+    type: `mutable_atom`,
+    install: (s) => {
+      s.logger.info(
+        `\u{1F6E0}\uFE0F`,
+        `atom`,
+        options.key,
+        `installing in store "${s.config.name}"`
+      );
+      return createMutableAtom(options, family, s);
+    },
+    subject
+  };
+  if (family) {
+    newAtom.family = family;
+  }
+  const initialValue = options.default();
+  target.atoms.set(newAtom.key, newAtom);
+  markAtomAsDefault(options.key, store);
+  cacheValue(options.key, initialValue, subject, target);
+  const token = deposit(newAtom);
+  if (options.effects) {
+    let effectIndex = 0;
+    const cleanupFunctions = [];
+    for (const effect of options.effects) {
+      const cleanup = effect({
+        setSelf: (next) => {
+          setIntoStore(token, next, store);
+        },
+        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+      });
+      if (cleanup) {
+        cleanupFunctions.push(cleanup);
+      }
+      ++effectIndex;
+    }
+    newAtom.cleanup = () => {
+      for (const cleanup of cleanupFunctions) {
+        cleanup();
+      }
+    };
+  }
+  new Tracker(token, store);
+  if (!family) {
+    selectJson(token, options, store);
+  }
+  return token;
+}
+var FamilyTracker = class {
+  Update;
+  latestUpdateAtoms;
+  mutableAtoms;
+  constructor(mutableAtoms, store) {
+    const updateAtoms = createRegularAtomFamily(
+      {
+        key: `*${mutableAtoms.key}`,
+        default: null
+      },
+      store,
+      [`mutable`, `updates`]
+    );
+    this.latestUpdateAtoms = withdraw(updateAtoms, store);
+    this.mutableAtoms = mutableAtoms;
+    this.mutableAtoms.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (event) => {
+        if (event.token.family) {
+          const key = parseJson(event.token.family.subKey);
+          seekInStore(this.latestUpdateAtoms, key, store);
+          new Tracker(event.token, store);
+        }
+      }
+    );
+    this.latestUpdateAtoms.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (event) => {
+        if (event.token.family) {
+          const key = parseJson(event.token.family.subKey);
+          const mutableAtomToken = seekInStore(this.mutableAtoms, key, store);
+          if (mutableAtomToken) {
+            new Tracker(mutableAtomToken, store);
+          }
+        }
+      }
+    );
+  }
+};
+
+// internal/src/mutable/create-mutable-atom-family.ts
+function createMutableAtomFamily(options, store, internalRoles) {
+  const familyToken = {
+    key: options.key,
+    type: `mutable_atom_family`
+  };
+  throwInCaseOfConflictingFamily(familyToken, store);
+  const subject = new Subject();
+  const familyFunction = (key) => {
+    const subKey = stringifyJson(key);
+    const family = { key: options.key, subKey };
+    const fullKey = `${options.key}(${subKey})`;
+    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({ type: `state_creation`, token });
+    return token;
+  };
+  const atomFamily = Object.assign(familyFunction, familyToken, {
+    subject,
+    install: (s) => createMutableAtomFamily(options, s),
+    toJson: options.toJson,
+    fromJson: options.fromJson,
+    internalRoles
+  });
+  store.families.set(options.key, atomFamily);
+  selectJsonFamily(atomFamily, options, store);
+  new FamilyTracker(atomFamily, store);
+  return familyToken;
+}
+
+// internal/src/mutable/get-json-family.ts
+var getJsonFamily = (mutableAtomFamily, store) => {
+  const target = newest(store);
+  const key = `${mutableAtomFamily.key}:JSON`;
+  const jsonFamily = target.families.get(key);
+  return jsonFamily;
+};
+
+// internal/src/mutable/get-json-token.ts
+var getJsonToken = (mutableAtomToken, store) => {
+  if (mutableAtomToken.family) {
+    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;
+  }
+  const token = {
+    type: `selector`,
+    key: `${mutableAtomToken.key}:JSON`
+  };
+  return token;
+};
+
+// internal/src/mutable/get-update-family.ts
+var getUpdateFamily = (mutableAtomFamily, store) => {
+  const target = newest(store);
+  const key = `*${mutableAtomFamily.key}`;
+  const updateFamily = target.families.get(
+    key
+  );
+  return updateFamily;
+};
+
+// internal/src/mutable/get-update-token.ts
+var getUpdateToken = (mutableAtomToken) => {
+  const key = `*${mutableAtomToken.key}`;
+  const updateToken = { type: `atom`, key };
+  if (mutableAtomToken.family) {
+    updateToken.family = {
+      key: `*${mutableAtomToken.family.key}`,
+      subKey: mutableAtomToken.family.subKey
+    };
+  }
+  return updateToken;
+};
+
+// internal/src/mutable/transceiver.ts
+function isTransceiver(value) {
+  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+}
+
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, origin, target) {
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    if (originValue === void 0) {
+      return typeof atom.default === `function` ? atom.default() : atom.default;
+    }
+    origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
+    const jsonValue = atom.toJson(originValue);
+    const copiedValue = atom.fromJson(jsonValue);
+    target.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
+  }
+  return targetValue;
+}
+
+// internal/src/caching.ts
+function cacheValue(key, value, subject, target) {
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    const future = currentValue;
+    future.use(value);
+  }
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    target.valueMap.set(key, future);
+    future.then((resolved) => {
+      cacheValue(key, resolved, subject, target);
+      subject.next({ newValue: resolved, oldValue: future });
+    }).catch((thrown) => {
+      target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+    });
+    return future;
+  }
+  target.valueMap.set(key, value);
+  return value;
+}
+var readCachedValue = (token, target) => {
+  let value = target.valueMap.get(token.key);
+  if (token.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    value = copiedValue;
+  }
+  return value;
+};
+var evictCachedValue = (key, target) => {
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    const future = currentValue;
+    const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key);
+    if (selector) {
+      future.use(selector.get());
+    }
+    return;
+  }
+  if (target.operation.open) {
+    target.operation.prev.set(key, currentValue);
+  }
+  target.valueMap.delete(key);
+  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+};
+
+// internal/src/atom/is-default.ts
+var isAtomDefault = (key, store) => {
+  const core = newest(store);
+  return core.atomsThatAreDefault.has(key);
+};
+var markAtomAsDefault = (key, store) => {
+  const core = newest(store);
+  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
+};
+var markAtomAsNotDefault = (key, store) => {
+  const core = newest(store);
+  core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
+  core.atomsThatAreDefault.delete(key);
+};
+
+// internal/src/atom/create-regular-atom.ts
+function createRegularAtom(options, family, store) {
+  store.logger.info(
+    `\u{1F528}`,
+    `atom`,
+    options.key,
+    `creating in store "${store.config.name}"`
+  );
+  const target = newest(store);
+  const existing = target.atoms.get(options.key);
+  if (existing && existing.type === `atom`) {
+    store.logger.error(
+      `\u274C`,
+      `atom`,
+      options.key,
+      `Tried to create atom, but it already exists in the store.`
+    );
+    return deposit(existing);
+  }
+  const subject = new Subject();
+  const newAtom = {
+    ...options,
+    type: `atom`,
+    install: (s) => {
+      s.logger.info(
+        `\u{1F6E0}\uFE0F`,
+        `atom`,
+        options.key,
+        `installing in store "${s.config.name}"`
+      );
+      return createRegularAtom(options, family, s);
+    },
+    subject
+  };
+  if (family) {
+    newAtom.family = family;
+  }
+  let initialValue = options.default;
+  if (options.default instanceof Function) {
+    initialValue = options.default();
+  }
+  target.atoms.set(newAtom.key, newAtom);
+  markAtomAsDefault(options.key, store);
+  cacheValue(options.key, initialValue, subject, target);
+  const token = deposit(newAtom);
+  if (options.effects) {
+    let effectIndex = 0;
+    const cleanupFunctions = [];
+    for (const effect of options.effects) {
+      const cleanup = effect({
+        setSelf: (next) => {
+          setIntoStore(token, next, store);
+        },
+        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+      });
+      if (cleanup) {
+        cleanupFunctions.push(cleanup);
+      }
+      ++effectIndex;
+    }
+    newAtom.cleanup = () => {
+      for (const cleanup of cleanupFunctions) {
+        cleanup();
+      }
+    };
+  }
+  return token;
+}
+
+// internal/src/atom/create-standalone-atom.ts
+function createStandaloneAtom(options, store) {
+  const isMutable = `mutable` in options;
+  if (isMutable) {
+    const state2 = createMutableAtom(options, void 0, store);
+    store.on.atomCreation.next(state2);
+    return state2;
+  }
+  const state = createRegularAtom(options, void 0, store);
+  store.on.atomCreation.next(state);
+  return state;
+}
+
+// internal/src/atom/dispose-atom.ts
+function disposeAtom(atomToken, store) {
+  const target = newest(store);
+  const { key } = atomToken;
+  const atom = target.atoms.get(key);
+  if (!atom) {
+    store.logger.error(
+      `\u274C`,
+      `atom`,
+      key,
+      `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 {
+    atom.cleanup?.();
+    const lastValue = store.valueMap.get(atom.key);
+    const family = withdraw({ key: atom.family.key, type: `atom_family` }, store);
+    family.subject.next({
+      type: `state_disposal`,
+      token: atomToken,
+      value: lastValue
+    });
+    const molecule = target.molecules.get(atom.family.subKey);
+    if (molecule) {
+      molecule.tokens.delete(key);
+    }
+    target.atoms.delete(key);
+    target.valueMap.delete(key);
+    const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
+    if (selectorKeys) {
+      for (const selectorKey of selectorKeys) {
+        const token = target.selectors.get(selectorKey) ?? target.readonlySelectors.get(selectorKey);
+        if (token) {
+          disposeSelector(token, store);
+        }
+      }
+    }
+    target.selectorAtoms.delete(key);
+    target.atomsThatAreDefault.delete(key);
+    target.timelineTopics.delete(key);
+    if (atomToken.type === `mutable_atom`) {
+      const updateToken = getUpdateToken(atomToken);
+      disposeAtom(updateToken, store);
+      store.trackers.delete(key);
+    }
+    store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
+    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
+      target.transactionMeta.update.updates.push({
+        type: `state_disposal`,
+        token: atomToken
+      });
+    } else {
+      store.on.atomDisposal.next(atomToken);
+    }
+  }
+}
+function createTimeline(options, store, data) {
+  const tl = {
+    type: `timeline`,
+    key: options.key,
+    at: 0,
+    timeTraveling: null,
+    selectorTime: null,
+    transactionKey: null,
+    ...data,
+    history: data?.history.map((update) => ({ ...update })) ?? [],
+    install: (s) => createTimeline(options, s, tl),
+    subject: new Subject(),
+    subscriptions: /* @__PURE__ */ new Map()
+  };
+  if (options.shouldCapture) {
+    tl.shouldCapture = options.shouldCapture;
+  }
+  const timelineKey = options.key;
+  const target = newest(store);
+  for (const initialTopic of options.scope) {
+    switch (initialTopic.type) {
+      case `atom`:
+      case `mutable_atom`:
+        {
+          const atomToken = initialTopic;
+          const atomKey = atomToken.key;
+          let existingTimelineKey = target.timelineTopics.getRelatedKey(atomKey);
+          if (`family` in atomToken) {
+            const familyKey = atomToken.family.key;
+            existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+            if (existingTimelineKey) {
+              store.logger.error(
+                `\u274C`,
+                `timeline`,
+                options.key,
+                `Failed to add atom "${atomKey}" because its family "${familyKey}" already belongs to timeline "${existingTimelineKey}"`
+              );
+              continue;
+            }
+          }
+          if (existingTimelineKey) {
+            store.logger.error(
+              `\u274C`,
+              `timeline`,
+              options.key,
+              `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`
+            );
+            continue;
+          }
+          addAtomToTimeline(atomToken, tl, store);
+        }
+        break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+        {
+          const familyToken = initialTopic;
+          const familyKey = familyToken.key;
+          const existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+          if (existingTimelineKey) {
+            store.logger.error(
+              `\u274C`,
+              `timeline`,
+              options.key,
+              `Failed to add atom family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`
+            );
+            continue;
+          }
+          addAtomFamilyToTimeline(familyToken, tl, store);
+        }
+        break;
+      case `molecule_family`:
+        {
+          const familyToken = initialTopic;
+          const familyKey = familyToken.key;
+          const existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
+          if (existingTimelineKey) {
+            store.logger.error(
+              `\u274C`,
+              `timeline`,
+              options.key,
+              `Failed to add molecule family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`
+            );
+            continue;
+          }
+          addMoleculeFamilyToTimeline(familyToken, tl, store);
+        }
+        break;
+    }
+  }
+  store.timelines.set(options.key, tl);
+  const token = {
+    key: timelineKey,
+    type: `timeline`
+  };
+  store.on.timelineCreation.next(token);
+  return token;
+}
+function addAtomToTimeline(atomToken, tl, store) {
+  let maybeAtom = withdraw(atomToken, store);
+  if (maybeAtom.type === `mutable_atom`) {
+    const updateToken = getUpdateToken(maybeAtom);
+    maybeAtom = withdraw(updateToken, store);
+  }
+  const atom = maybeAtom;
+  store.timelineTopics.set(
+    { topicKey: atom.key, timelineKey: tl.key },
+    { topicType: `atom` }
+  );
+  tl.subscriptions.set(
+    atom.key,
+    atom.subject.subscribe(`timeline`, (update) => {
+      const target = newest(store);
+      const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
+      const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
+      const txUpdateInProgress = target.on.transactionApplying.state?.update;
+      store.logger.info(
+        `\u23F3`,
+        `timeline`,
+        tl.key,
+        `atom`,
+        atomToken.key,
+        `went`,
+        update.oldValue,
+        `->`,
+        update.newValue,
+        txUpdateInProgress ? `in transaction "${txUpdateInProgress.key}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``
+      );
+      if (tl.timeTraveling === null) {
+        if (txUpdateInProgress) {
+          joinTransaction(tl, txUpdateInProgress, store);
+        } else if (currentSelectorKey && currentSelectorTime) {
+          let latestUpdate = tl.history.at(-1);
+          if (currentSelectorTime !== tl.selectorTime) {
+            latestUpdate = {
+              type: `selector_update`,
+              timestamp: currentSelectorTime,
+              key: currentSelectorKey,
+              atomUpdates: []
+            };
+            latestUpdate.atomUpdates.push({
+              key: atom.key,
+              type: `atom_update`,
+              ...update
+            });
+            if (tl.at !== tl.history.length) {
+              tl.history.splice(tl.at);
+            }
+            tl.history.push(latestUpdate);
+            store.logger.info(
+              `\u231B`,
+              `timeline`,
+              tl.key,
+              `got a selector_update "${currentSelectorKey}" with`,
+              latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            );
+            tl.at = tl.history.length;
+            tl.selectorTime = currentSelectorTime;
+          } else {
+            if (latestUpdate?.type === `selector_update`) {
+              latestUpdate.atomUpdates.push({
+                key: atom.key,
+                type: `atom_update`,
+                ...update
+              });
+              store.logger.info(
+                `\u231B`,
+                `timeline`,
+                tl.key,
+                `set selector_update "${currentSelectorKey}" to`,
+                latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key)
+              );
+            }
+          }
+          if (latestUpdate) {
+            const willCaptureSelectorUpdate = tl.shouldCapture?.(latestUpdate, tl) ?? true;
+            if (willCaptureSelectorUpdate) {
+              tl.subject.next(latestUpdate);
+            } else {
+              tl.history.pop();
+              tl.at = tl.history.length;
+            }
+          }
+        } else {
+          const timestamp = Date.now();
+          tl.selectorTime = null;
+          if (tl.at !== tl.history.length) {
+            tl.history.splice(tl.at);
+          }
+          const atomUpdate = {
+            type: `atom_update`,
+            timestamp,
+            key: atom.key,
+            oldValue: update.oldValue,
+            newValue: update.newValue
+          };
+          if (atom.family) {
+            atomUpdate.family = atom.family;
+          }
+          const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true;
+          store.logger.info(
+            `\u231B`,
+            `timeline`,
+            tl.key,
+            `got an atom_update to "${atom.key}"`
+          );
+          if (willCapture) {
+            tl.history.push(atomUpdate);
+            tl.at = tl.history.length;
+            tl.subject.next(atomUpdate);
+          }
+        }
+      }
+    })
+  );
+}
+function addAtomFamilyToTimeline(atomFamilyToken, tl, store) {
+  const family = withdraw(atomFamilyToken, store);
+  store.timelineTopics.set(
+    { topicKey: family.key, timelineKey: tl.key },
+    { topicType: `atom_family` }
+  );
+  tl.subscriptions.set(
+    family.key,
+    family.subject.subscribe(`timeline`, (creationOrDisposal) => {
+      handleStateLifecycleEvent(creationOrDisposal, tl, store);
+    })
+  );
+  for (const atom of store.atoms.values()) {
+    if (atom.family?.key === family.key) {
+      addAtomToTimeline(atom, tl, store);
+    }
+  }
+}
+function addMoleculeFamilyToTimeline(familyToken, tl, store) {
+  store.timelineTopics.set(
+    { topicKey: familyToken.key, timelineKey: tl.key },
+    { topicType: `molecule_family` }
+  );
+  const family = store.moleculeFamilies.get(familyToken.key);
+  if (family) {
+    tl.subscriptions.set(
+      familyToken.key,
+      family.subject.subscribe(`timeline:${tl.key}`, (creationOrDisposal) => {
+        store.logger.info(
+          `\u{1F41E}`,
+          `timeline`,
+          tl.key,
+          `got a molecule creation or disposal`,
+          creationOrDisposal
+        );
+        switch (creationOrDisposal.type) {
+          case `molecule_creation`:
+            {
+              store.timelineTopics.set(
+                {
+                  topicKey: creationOrDisposal.token.key,
+                  timelineKey: tl.key
+                },
+                { topicType: `molecule` }
+              );
+              const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
+              if (txUpdateInProgress) {
+                joinTransaction(tl, txUpdateInProgress, store);
+              } else if (tl.timeTraveling === null) {
+                const event = Object.assign(creationOrDisposal, {
+                  timestamp: Date.now()
+                });
+                tl.history.push(event);
+                tl.at = tl.history.length;
+                tl.subject.next(event);
+              }
+              const molecule = withdraw(creationOrDisposal.token, store);
+              for (const token of molecule.tokens.values()) {
+                switch (token.type) {
+                  case `atom`:
+                  case `mutable_atom`:
+                    addAtomToTimeline(token, tl, store);
+                    break;
+                }
+              }
+              tl.subscriptions.set(
+                molecule.key,
+                molecule.subject.subscribe(
+                  `timeline:${tl.key}`,
+                  (stateCreationOrDisposal) => {
+                    handleStateLifecycleEvent(stateCreationOrDisposal, tl, store);
+                  }
+                )
+              );
+            }
+            break;
+          case `molecule_disposal`:
+            {
+              const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
+              if (txUpdateInProgress) {
+                joinTransaction(tl, txUpdateInProgress, store);
+              } else if (tl.timeTraveling === null) {
+                const event = Object.assign(creationOrDisposal, {
+                  timestamp: Date.now()
+                });
+                tl.history.push(event);
+                tl.at = tl.history.length;
+                tl.subject.next(event);
+              }
+              const moleculeKey = creationOrDisposal.token.key;
+              tl.subscriptions.get(moleculeKey)?.();
+              tl.subscriptions.delete(moleculeKey);
+              for (const [familyKey] of creationOrDisposal.values) {
+                const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`;
+                tl.subscriptions.get(stateKey)?.();
+                tl.subscriptions.delete(stateKey);
+                store.timelineTopics.delete(stateKey);
+              }
+            }
+            break;
+        }
+      })
+    );
+  }
+}
+function joinTransaction(tl, txUpdateInProgress, store) {
+  const currentTxKey = txUpdateInProgress.key;
+  const currentTxInstanceId = txUpdateInProgress.id;
+  const currentTxToken = {
+    key: currentTxKey,
+    type: `transaction`
+  };
+  const currentTransaction = withdraw(currentTxToken, store);
+  if (currentTxKey && tl.transactionKey === null) {
+    tl.transactionKey = currentTxKey;
+    const unsubscribe = currentTransaction.subject.subscribe(
+      `timeline:${tl.key}`,
+      (transactionUpdate) => {
+        unsubscribe();
+        tl.transactionKey = null;
+        if (tl.timeTraveling === null && currentTxInstanceId) {
+          if (tl.at !== tl.history.length) {
+            tl.history.splice(tl.at);
+          }
+          const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key);
+          const updates = filterTransactionUpdates(
+            transactionUpdate.updates,
+            timelineTopics
+          );
+          const timelineTransactionUpdate = {
+            timestamp: Date.now(),
+            ...transactionUpdate,
+            updates
+          };
+          const willCapture = tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true;
+          if (willCapture) {
+            tl.history.push(timelineTransactionUpdate);
+            tl.at = tl.history.length;
+            tl.subject.next(timelineTransactionUpdate);
+          }
+        }
+      }
+    );
+  }
+}
+function filterTransactionUpdates(updates, timelineTopics) {
+  return updates.filter((updateFromTx) => {
+    if (updateFromTx.type === `transaction_update`) {
+      return true;
+    }
+    let key;
+    switch (updateFromTx.type) {
+      case `state_creation`:
+      case `state_disposal`:
+      case `molecule_creation`:
+      case `molecule_disposal`:
+        key = updateFromTx.token.key;
+        break;
+      default:
+        key = updateFromTx.key;
+        break;
+    }
+    return timelineTopics.has(key);
+  }).map((updateFromTx) => {
+    if (`updates` in updateFromTx) {
+      return {
+        ...updateFromTx,
+        updates: filterTransactionUpdates(
+          updateFromTx.updates,
+          timelineTopics
+        )
+      };
+    }
+    return updateFromTx;
+  });
+}
+function handleStateLifecycleEvent(event, tl, store) {
+  const timestamp = Date.now();
+  const timelineEvent = Object.assign(event, {
+    timestamp
+  });
+  if (!tl.timeTraveling) {
+    const txUpdateInProgress = newest(store).on.transactionApplying.state?.update;
+    if (txUpdateInProgress) {
+      joinTransaction(tl, txUpdateInProgress, store);
+    } else {
+      tl.history.push(timelineEvent);
+      tl.at = tl.history.length;
+      tl.subject.next(timelineEvent);
+    }
+  }
+  switch (event.type) {
+    case `state_creation`:
+      addAtomToTimeline(event.token, tl, store);
+      break;
+    case `state_disposal`:
+      tl.subscriptions.get(event.token.key)?.();
+      tl.subscriptions.delete(event.token.key);
+      break;
+  }
+}
+
+// internal/src/timeline/time-travel.ts
+var timeTravel = (action, token, store) => {
+  store.logger.info(
+    action === `redo` ? `\u23E9` : `\u23EA`,
+    `timeline`,
+    token.key,
+    action
+  );
+  const timelineData = store.timelines.get(token.key);
+  if (!timelineData) {
+    store.logger.error(
+      `\u{1F41E}`,
+      `timeline`,
+      token.key,
+      `Failed to ${action}. This timeline has not been initialized.`
+    );
+    return;
+  }
+  if (action === `redo` && timelineData.at === timelineData.history.length || action === `undo` && timelineData.at === 0) {
+    store.logger.warn(
+      `\u{1F481}`,
+      `timeline`,
+      token.key,
+      `Failed to ${action} at the ${action === `redo` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`
+    );
+    return;
+  }
+  timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`;
+  if (action === `undo`) {
+    --timelineData.at;
+  }
+  const update = timelineData.history[timelineData.at];
+  const applying = action === `redo` ? `newValue` : `oldValue`;
+  switch (update.type) {
+    case `atom_update`: {
+      ingestAtomUpdate(applying, update, store);
+      break;
+    }
+    case `selector_update`: {
+      ingestSelectorUpdate(applying, update, store);
+      break;
+    }
+    case `transaction_update`: {
+      ingestTransactionUpdate(applying, update, store);
+      break;
+    }
+    case `state_creation`: {
+      ingestCreationEvent(update, applying, store);
+      break;
+    }
+    case `state_disposal`: {
+      ingestDisposalEvent(update, applying, store);
+      break;
+    }
+    case `molecule_creation`: {
+      ingestMoleculeCreationEvent(update, applying, store);
+      break;
+    }
+    case `molecule_disposal`: {
+      ingestMoleculeDisposalEvent(update, applying, store);
+      break;
+    }
+  }
+  if (action === `redo`) {
+    ++timelineData.at;
+  }
+  timelineData.subject.next(action);
+  timelineData.timeTraveling = null;
+  store.logger.info(
+    `\u23F9\uFE0F`,
+    `timeline`,
+    token.key,
+    `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  );
+};
+
+export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, 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, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };