atom.io 0.25.6 → 0.26.0

package/internal/dist/index.cjs

@@ -1,3405 +0,0 @@
-'use strict';
-
-var json = require('atom.io/json');
-var atom_io = require('atom.io');
-var data = require('atom.io/data');
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-// internal/src/arbitrary.ts
-function arbitrary(random = Math.random) {
-  return random().toString(36).slice(2);
-}
-
-// internal/src/future.ts
-var Future = class extends Promise {
-  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;
-}
-
-// ../rel8/junction/src/junction.ts
-var Junction = class {
-  constructor(data, config) {
-    this.relations = /* @__PURE__ */ new Map();
-    this.contents = /* @__PURE__ */ new Map();
-    this.makeContentKey = (a, b) => `${a}:${b}`;
-    var _a, _b, _c, _d;
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    if (!(config == null ? void 0 : config.externalStore)) {
-      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
-      this.contents = new Map(data.contents);
-    }
-    this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
-    if (config == null ? void 0 : config.makeContentKey) {
-      this.makeContentKey = config.makeContentKey;
-    }
-    if (config == null ? void 0 : config.externalStore) {
-      const externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
-        for (const y of ys) this.addRelation(x, y);
-      }
-      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
-        this.setContent(contentKey, content);
-      }
-    }
-  }
-  getRelatedKeys(key) {
-    return this.relations.get(key);
-  }
-  addRelation(a, b) {
-    let aRelations = this.relations.get(a);
-    let bRelations = this.relations.get(b);
-    if (aRelations) {
-      aRelations.add(b);
-    } else {
-      aRelations = /* @__PURE__ */ new Set([b]);
-      this.relations.set(a, aRelations);
-    }
-    if (bRelations) {
-      bRelations.add(a);
-    } else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  deleteRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    if (aRelations) {
-      aRelations.delete(b);
-      if (aRelations.size === 0) {
-        this.relations.delete(a);
-      }
-      const bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.delete(a);
-        if (bRelations.size === 0) {
-          this.relations.delete(b);
-        }
-      }
-    }
-  }
-  replaceRelationsUnsafely(a, bs) {
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      const bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  replaceRelationsSafely(a, bs) {
-    const aRelationsPrev = this.relations.get(a);
-    if (aRelationsPrev) {
-      for (const b of aRelationsPrev) {
-        const bRelations = this.relations.get(b);
-        if (bRelations) {
-          if (bRelations.size === 1) {
-            this.relations.delete(b);
-          } else {
-            bRelations.delete(a);
-          }
-          this.contents.delete(this.makeContentKey(a, b));
-        }
-      }
-    }
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      let bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.add(a);
-      } else {
-        bRelations = /* @__PURE__ */ new Set([a]);
-        this.relations.set(b, bRelations);
-      }
-    }
-  }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
-  }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
-  }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
-  }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
-      contents: [...this.contents.entries()]
-    };
-  }
-  set(a, ...rest) {
-    var _a;
-    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
-    const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
-    a = typeof a === `string` ? a : a[this.a];
-    switch (this.cardinality) {
-      case `1:1`: {
-        const bPrev = this.getRelatedKey(a);
-        if (bPrev && bPrev !== b) this.delete(bPrev, a);
-      }
-      case `1:n`: {
-        const aPrev = this.getRelatedKey(b);
-        if (aPrev && aPrev !== a) this.delete(aPrev, b);
-      }
-    }
-    if (content) {
-      const contentKey = this.makeContentKey(a, b);
-      this.setContent(contentKey, content);
-    }
-    this.addRelation(a, b);
-    return this;
-  }
-  delete(x, b) {
-    b = typeof b === `string` ? b : x[this.b];
-    const a = typeof x === `string` ? x : x[this.a];
-    if (a === void 0 && typeof b === `string`) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        for (const bRelation of bRelations) {
-          this.delete(bRelation, b);
-        }
-      }
-    }
-    if (typeof a === `string` && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        for (const aRelation of aRelations) {
-          this.delete(a, aRelation);
-        }
-      }
-    }
-    if (typeof a === `string` && typeof b === `string`) {
-      this.deleteRelation(a, b);
-      const contentKey = this.makeContentKey(a, b);
-      this.deleteContent(contentKey);
-    }
-    return this;
-  }
-  getRelatedKey(key) {
-    const relations = this.getRelatedKeys(key);
-    if (relations) {
-      if (relations.size > 1) {
-        console.warn(
-          `${relations.size} related keys were found for key "${key}": (${[
-            ...relations
-          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
-        );
-      }
-      for (const relation of relations) {
-        return relation;
-      }
-    }
-  }
-  replaceRelations(a, relations, config) {
-    const hasContent = !Array.isArray(relations);
-    const bs = hasContent ? Object.keys(relations) : relations;
-    if (config == null ? void 0 : config.reckless) {
-      this.replaceRelationsUnsafely(a, bs);
-    } else {
-      this.replaceRelationsSafely(a, bs);
-    }
-    if (hasContent) {
-      for (const b of bs) {
-        const contentKey = this.makeContentKey(a, b);
-        const content = relations[b];
-        this.setContent(contentKey, content);
-      }
-    }
-    return this;
-  }
-  getContent(a, b) {
-    const contentKey = this.makeContentKey(a, b);
-    return this.getContentInternal(contentKey);
-  }
-  getRelationEntries(input) {
-    const a = input[this.a];
-    const b = input[this.b];
-    if (a !== void 0 && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        return [...aRelations].map((aRelation) => {
-          var _a;
-          return [aRelation, (_a = this.getContent(a, aRelation)) != null ? _a : null];
-        });
-      }
-    }
-    if (a === void 0 && b !== void 0) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        return [...bRelations].map((bRelation) => {
-          var _a;
-          return [bRelation, (_a = this.getContent(bRelation, b)) != null ? _a : null];
-        });
-      }
-    }
-    return [];
-  }
-  has(a, b) {
-    var _a;
-    if (b) {
-      const setA = this.getRelatedKeys(a);
-      return (_a = setA == null ? void 0 : setA.has(b)) != null ? _a : false;
-    }
-    return this.relations.has(a);
-  }
-};
-
-// internal/src/subject.ts
-var Subject = class {
-  constructor() {
-    this.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 {
-  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;
-};
-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 `readonly_selector`:
-      return `Readonly Selector`;
-    case `readonly_selector_family`:
-      return `Readonly Selector Family`;
-    case `selector_family`:
-      return `Selector Family`;
-    default:
-      return capitalize(token.type);
-  }
-}
-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)} ${json.stringifyJson(token.key)} not found in store "${store.config.name}".`
-      );
-    } else {
-      const key = params[1];
-      super(
-        `${prettyPrintTokenType(token)} "${token.key}" member ${json.stringifyJson(key)} not found in store "${store.config.name}".`
-      );
-    }
-  }
-};
-
-// 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 != null ? 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 = __spreadValues({
-    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;
-  }
-};
-function createRegularAtomFamily(options, store) {
-  const subject = new Subject();
-  const atomFamily = Object.assign(
-    (key) => {
-      const subKey = json.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;
-    },
-    {
-      key: options.key,
-      type: `atom_family`,
-      subject,
-      install: (s) => createRegularAtomFamily(options, s)
-    }
-  );
-  store.families.set(options.key, atomFamily);
-  return atomFamily;
-}
-
-// internal/src/families/create-atom-family.ts
-function createAtomFamily(options, store) {
-  const isMutable2 = `mutable` in options;
-  if (isMutable2) {
-    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 = __spreadValues(__spreadProps(__spreadValues({}, 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 = __spreadValues(__spreadProps(__spreadValues({}, 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) {
-  var _a;
-  const target = newest(store);
-  const { key } = selectorToken;
-  const selector = (_a = target.selectors.get(key)) != null ? _a : 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]) => {
-        var _a2;
-        return (_a2 = target.selectors.get(downstreamSelectorKey)) != null ? _a2 : target.readonlySelectors.get(downstreamSelectorKey);
-      }
-    );
-    for (const downstreamToken of downstreamTokens) {
-      if (downstreamToken) {
-        disposeSelector(downstreamToken, store);
-      }
-    }
-    target.selectorGraph.delete(key);
-    store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
-    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) {
-  const subject = new Subject();
-  const readonlySelectorFamily = Object.assign(
-    (key) => {
-      const subKey = json.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;
-    },
-    {
-      key: options.key,
-      type: `readonly_selector_family`,
-      subject,
-      install: (s) => createReadonlySelectorFamily(options, s)
-    }
-  );
-  store.families.set(options.key, readonlySelectorFamily);
-  return readonlySelectorFamily;
-}
-function createWritableSelectorFamily(options, store) {
-  const subject = new Subject();
-  const selectorFamily = Object.assign(
-    (key) => {
-      const subKey = json.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;
-    },
-    {
-      key: options.key,
-      type: `selector_family`,
-      subject,
-      install: (s) => createWritableSelectorFamily(options, s)
-    }
-  );
-  store.families.set(options.key, selectorFamily);
-  return selectorFamily;
-}
-
-// 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) {
-  var _a;
-  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 (((_a = child.family) == null ? void 0 : _a.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 = json.stringifyJson(key);
-  const fullKey = `${token.key}(${subKey})`;
-  const target = newest(store);
-  let state;
-  switch (token.type) {
-    case `atom_family`:
-    case `mutable_atom_family`:
-      state = target.atoms.get(fullKey);
-      break;
-    case `selector_family`:
-      state = target.selectors.get(fullKey);
-      break;
-    case `readonly_selector_family`:
-      state = target.readonlySelectors.get(fullKey);
-      break;
-    case `molecule_family`:
-      state = target.molecules.get(json.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) {
-  var _a;
-  const subject = new Subject();
-  const token = {
-    type: `molecule_family`,
-    key: options.key,
-    dependsOn: (_a = options.dependsOn) != null ? _a : `all`
-  };
-  const family = __spreadProps(__spreadValues({}, 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.type = `molecule`;
-    this.subject = new Subject();
-    this.tokens = /* @__PURE__ */ new Map();
-    this.above = /* @__PURE__ */ new Map();
-    this.below = /* @__PURE__ */ new Map();
-    this.joins = /* @__PURE__ */ new Map();
-    this.stringKey = json.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);
-      }
-    }
-  }
-};
-
-// 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 = json.stringifyJson(key);
-  target.moleculeInProgress = stringKey;
-  const contextArray = Array.isArray(context) ? context : [context];
-  const owners = contextArray.map((ctx) => {
-    if (ctx instanceof Molecule) {
-      return ctx;
-    }
-    const ctxStringKey = json.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 = data.getJoin(token2, rootStore);
-        join.molecules.set(stringKey, molecule);
-        molecule.joins.set(token2.key, join);
-        const unsubFromFamily = family.subject.subscribe(
-          `join:${token2.key}-${stringKey}`,
-          (event) => {
-            if (event.type === `molecule_disposal` && json.stringifyJson(event.token.key) === stringKey) {
-              unsubFromFamily();
-              join.molecules.delete(stringKey);
-            }
-          }
-        );
-        if (role === null) {
-          return;
-        }
-        const otherRole = token2.a === role ? token2.b : token2.a;
-        const relations = data.findRelations(token2, key);
-        const relatedKeys = relations[`${otherRole}KeysOf${capitalize2(role)}`];
-        const relatedEntries = relations[`${otherRole}EntriesOf${capitalize2(role)}`];
-        let tokens = { relatedKeys };
-        if (relatedEntries) {
-          tokens = Object.assign(tokens, { relatedEntries });
-        }
-        return tokens;
-      }
-      return growMoleculeInStore(
-        molecule,
-        withdraw(token2, rootStore),
-        newest(rootStore)
-      );
-    },
-    claim: (below, options) => {
-      const { exclusive } = options;
-      const belowMolecule = newest(store).molecules.get(json.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, json.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}(${json.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].reverse();
-  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) => {
-  var _a;
-  const child = newest(store);
-  const { parent } = child;
-  if (parent === null || !isChildStore(child) || ((_a = child.transactionMeta) == null ? void 0 : _a.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 == null ? void 0 : 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;
-    this.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 {
-  constructor(config, store = null) {
-    this.parent = null;
-    this.child = null;
-    this.valueMap = /* @__PURE__ */ new Map();
-    this.atoms = /* @__PURE__ */ new Map();
-    this.selectors = /* @__PURE__ */ new Map();
-    this.readonlySelectors = /* @__PURE__ */ new Map();
-    this.atomsThatAreDefault = /* @__PURE__ */ new Set();
-    this.selectorAtoms = new Junction({
-      between: [`selectorKey`, `atomKey`],
-      cardinality: `n:n`
-    });
-    this.selectorGraph = new Junction(
-      {
-        between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
-        cardinality: `n:n`
-      },
-      {
-        makeContentKey: (...keys) => keys.sort().join(`:`)
-      }
-    );
-    this.trackers = /* @__PURE__ */ new Map();
-    this.families = /* @__PURE__ */ new Map();
-    this.transactions = /* @__PURE__ */ new Map();
-    this.transactionMeta = {
-      epoch: /* @__PURE__ */ new Map(),
-      actionContinuities: new Junction({
-        between: [`continuity`, `action`],
-        cardinality: `1:n`
-      })
-    };
-    this.timelines = /* @__PURE__ */ new Map();
-    this.timelineTopics = new Junction({
-      between: [`timelineKey`, `topicKey`],
-      cardinality: `1:n`
-    });
-    this.molecules = /* @__PURE__ */ new Map();
-    this.moleculeFamilies = /* @__PURE__ */ new Map();
-    this.moleculeInProgress = null;
-    this.miscResources = /* @__PURE__ */ new Map();
-    this.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()
-    };
-    this.operation = { open: false };
-    this.config = {
-      name: `IMPLICIT_STORE`,
-      lifespan: `ephemeral`
-    };
-    this.loggers = [
-      new atom_io.AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
-    ];
-    this.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);
-      }
-    };
-    this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
-    if (store !== null) {
-      this.valueMap = new Map(store == null ? void 0 : store.valueMap);
-      this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
-      if (isRootStore(store)) {
-        this.transactionMeta = {
-          epoch: new Map(store == null ? void 0 : store.transactionMeta.epoch),
-          actionContinuities: new Junction(
-            store == null ? void 0 : store.transactionMeta.actionContinuities.toJSON()
-          )
-        };
-      }
-      for (const [, family] of store.families) {
-        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(json.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 {
-  initializeState(mutableState, store) {
-    var _a;
-    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 ((_a = store.parent) == null ? void 0 : _a.valueMap.has(latestUpdateStateKey)) {
-      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
-      store.valueMap.set(latestUpdateStateKey, parentValue);
-    }
-    return latestUpdateState;
-  }
-  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 == null ? void 0 : 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
-    );
-  }
-  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 = __spreadProps(__spreadValues({}, 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) {
-    json.selectJson(token, options, store);
-  }
-  return token;
-}
-var FamilyTracker = class {
-  constructor(mutableAtoms, store) {
-    this.latestUpdateAtoms = createRegularAtomFamily(
-      {
-        key: `*${mutableAtoms.key}`,
-        default: null
-      },
-      store
-    );
-    this.mutableAtoms = mutableAtoms;
-    this.mutableAtoms.subject.subscribe(
-      `store=${store.config.name}::tracker-atom-family`,
-      (event) => {
-        if (event.token.family) {
-          const key = json.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 = json.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) {
-  const subject = new Subject();
-  const atomFamily = Object.assign(
-    (key) => {
-      const subKey = json.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;
-    },
-    {
-      key: options.key,
-      type: `mutable_atom_family`,
-      subject,
-      install: (s) => createMutableAtomFamily(options, s),
-      toJson: options.toJson,
-      fromJson: options.fromJson
-    }
-  );
-  store.families.set(options.key, atomFamily);
-  json.selectJsonFamily(atomFamily, options, store);
-  new FamilyTracker(atomFamily, store);
-  return atomFamily;
-}
-
-// 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-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/is-mutable.ts
-function isMutable(atomOrTokenOrFamily) {
-  return atomOrTokenOrFamily.type === `mutable_atom` || atomOrTokenOrFamily.type === `mutable_atom_family`;
-}
-
-// 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) => {
-  var _a;
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    const future = currentValue;
-    const selector = (_a = target.selectors.get(key)) != null ? _a : 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 = __spreadProps(__spreadValues({}, 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 isMutable2 = `mutable` in options;
-  if (isMutable2) {
-    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) {
-  var _a, _b;
-  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 {
-    (_a = atom.cleanup) == null ? void 0 : _a.call(atom);
-    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 = (_b = target.selectors.get(selectorKey)) != null ? _b : 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) {
-  var _a;
-  const tl = __spreadProps(__spreadValues({
-    type: `timeline`,
-    key: options.key,
-    at: 0,
-    timeTraveling: null,
-    selectorTime: null,
-    transactionKey: null
-  }, data), {
-    history: (_a = data == null ? void 0 : data.history.map((update) => __spreadValues({}, update))) != null ? _a : [],
-    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) => {
-      var _a, _b, _c, _d, _e;
-      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 = (_a = target.on.transactionApplying.state) == null ? void 0 : _a.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(__spreadValues({
-              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 == null ? void 0 : latestUpdate.type) === `selector_update`) {
-              latestUpdate.atomUpdates.push(__spreadValues({
-                key: atom.key,
-                type: `atom_update`
-              }, update));
-              store.logger.info(
-                `\u231B`,
-                `timeline`,
-                tl.key,
-                `set selector_update "${currentSelectorKey}" to`,
-                latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-              );
-            }
-          }
-          if (latestUpdate) {
-            const willCaptureSelectorUpdate = (_c = (_b = tl.shouldCapture) == null ? void 0 : _b.call(tl, latestUpdate, tl)) != null ? _c : 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 = (_e = (_d = tl.shouldCapture) == null ? void 0 : _d.call(tl, atomUpdate, tl)) != null ? _e : 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) {
-  var _a;
-  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 (((_a = atom.family) == null ? void 0 : _a.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) => {
-        var _a, _b, _c, _d;
-        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 = (_a = newest(store).on.transactionApplying.state) == null ? void 0 : _a.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 = (_b = newest(store).on.transactionApplying.state) == null ? void 0 : _b.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;
-              (_c = tl.subscriptions.get(moleculeKey)) == null ? void 0 : _c();
-              tl.subscriptions.delete(moleculeKey);
-              for (const [familyKey] of creationOrDisposal.values) {
-                const stateKey = `${familyKey}(${json.stringifyJson(moleculeKey)})`;
-                (_d = tl.subscriptions.get(stateKey)) == null ? void 0 : _d();
-                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) => {
-        var _a, _b;
-        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 = __spreadProps(__spreadValues({
-            timestamp: Date.now()
-          }, transactionUpdate), {
-            updates
-          });
-          const willCapture = (_b = (_a = tl.shouldCapture) == null ? void 0 : _a.call(tl, timelineTransactionUpdate, tl)) != null ? _b : 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 __spreadProps(__spreadValues({}, updateFromTx), {
-        updates: filterTransactionUpdates(
-          updateFromTx.updates,
-          timelineTopics
-        )
-      });
-    }
-    return updateFromTx;
-  });
-}
-function handleStateLifecycleEvent(event, tl, store) {
-  var _a, _b;
-  const timestamp = Date.now();
-  const timelineEvent = Object.assign(event, {
-    timestamp
-  });
-  if (!tl.timeTraveling) {
-    const txUpdateInProgress = (_a = newest(store).on.transactionApplying.state) == null ? void 0 : _a.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`:
-      (_b = tl.subscriptions.get(event.token.key)) == null ? void 0 : _b();
-      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}`
-  );
-};
-
-exports.FamilyTracker = FamilyTracker;
-exports.Future = Future;
-exports.IMPLICIT = IMPLICIT;
-exports.LazyMap = LazyMap;
-exports.Molecule = Molecule;
-exports.NotFoundError = NotFoundError;
-exports.StatefulSubject = StatefulSubject;
-exports.Store = Store;
-exports.Subject = Subject;
-exports.TRANSACTION_PHASES = TRANSACTION_PHASES;
-exports.Tracker = Tracker;
-exports.abortTransaction = abortTransaction;
-exports.actUponStore = actUponStore;
-exports.applyTransaction = applyTransaction;
-exports.arbitrary = arbitrary;
-exports.assignTransactionToContinuity = assignTransactionToContinuity;
-exports.become = become;
-exports.buildTransaction = buildTransaction;
-exports.cacheValue = cacheValue;
-exports.clearStore = clearStore;
-exports.closeOperation = closeOperation;
-exports.createAtomFamily = createAtomFamily;
-exports.createMoleculeFamily = createMoleculeFamily;
-exports.createMutableAtom = createMutableAtom;
-exports.createMutableAtomFamily = createMutableAtomFamily;
-exports.createReadonlySelector = createReadonlySelector;
-exports.createReadonlySelectorFamily = createReadonlySelectorFamily;
-exports.createRegularAtom = createRegularAtom;
-exports.createRegularAtomFamily = createRegularAtomFamily;
-exports.createSelectorFamily = createSelectorFamily;
-exports.createStandaloneAtom = createStandaloneAtom;
-exports.createStandaloneSelector = createStandaloneSelector;
-exports.createTimeline = createTimeline;
-exports.createTransaction = createTransaction;
-exports.createWritableSelector = createWritableSelector;
-exports.deposit = deposit;
-exports.disposeAtom = disposeAtom;
-exports.disposeFromStore = disposeFromStore;
-exports.disposeMolecule = disposeMolecule;
-exports.disposeSelector = disposeSelector;
-exports.eldest = eldest;
-exports.evictCachedValue = evictCachedValue;
-exports.findInStore = findInStore;
-exports.getContinuityKey = getContinuityKey;
-exports.getEnvironmentData = getEnvironmentData;
-exports.getEpochNumberOfAction = getEpochNumberOfAction;
-exports.getEpochNumberOfContinuity = getEpochNumberOfContinuity;
-exports.getFromStore = getFromStore;
-exports.getJsonFamily = getJsonFamily;
-exports.getJsonToken = getJsonToken;
-exports.getSelectorDependencyKeys = getSelectorDependencyKeys;
-exports.getUpdateToken = getUpdateToken;
-exports.growMoleculeInStore = growMoleculeInStore;
-exports.ingestAtomUpdate = ingestAtomUpdate;
-exports.ingestCreationEvent = ingestCreationEvent;
-exports.ingestDisposalEvent = ingestDisposalEvent;
-exports.ingestMoleculeCreationEvent = ingestMoleculeCreationEvent;
-exports.ingestMoleculeDisposalEvent = ingestMoleculeDisposalEvent;
-exports.ingestSelectorUpdate = ingestSelectorUpdate;
-exports.ingestTransactionUpdate = ingestTransactionUpdate;
-exports.initFamilyMemberInStore = initFamilyMemberInStore;
-exports.isAtomDefault = isAtomDefault;
-exports.isAtomKey = isAtomKey;
-exports.isChildStore = isChildStore;
-exports.isDone = isDone;
-exports.isMutable = isMutable;
-exports.isReadonlySelectorKey = isReadonlySelectorKey;
-exports.isRootStore = isRootStore;
-exports.isSelectorKey = isSelectorKey;
-exports.isStateKey = isStateKey;
-exports.isTransceiver = isTransceiver;
-exports.makeMoleculeInStore = makeMoleculeInStore;
-exports.markAtomAsDefault = markAtomAsDefault;
-exports.markAtomAsNotDefault = markAtomAsNotDefault;
-exports.markDone = markDone;
-exports.newest = newest;
-exports.openOperation = openOperation;
-exports.readCachedValue = readCachedValue;
-exports.readOrComputeValue = readOrComputeValue;
-exports.registerSelector = registerSelector;
-exports.seekInStore = seekInStore;
-exports.setAtomOrSelector = setAtomOrSelector;
-exports.setEpochNumberOfAction = setEpochNumberOfAction;
-exports.setEpochNumberOfContinuity = setEpochNumberOfContinuity;
-exports.setIntoStore = setIntoStore;
-exports.subscribeToRootAtoms = subscribeToRootAtoms;
-exports.subscribeToState = subscribeToState;
-exports.subscribeToTimeline = subscribeToTimeline;
-exports.subscribeToTransaction = subscribeToTransaction;
-exports.timeTravel = timeTravel;
-exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
-exports.traceSelectorAtoms = traceSelectorAtoms;
-exports.updateSelectorAtoms = updateSelectorAtoms;
-exports.withdraw = withdraw;