atom.io 0.6.9 → 0.8.0

package/internal/dist/index.js

@@ -0,0 +1,1906 @@
+'use strict';
+
+var AtomIO = require('atom.io');
+var json = require('atom.io/json');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
+
+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));
+
+// src/future.ts
+var Future = class extends Promise {
+  constructor(executor) {
+    super((resolve, reject) => {
+      const pass = (value) => this.isCanceled ? reject(`canceled`) : resolve(value);
+      const fail = (reason) => this.isCanceled ? reject(`canceled`) : reject(reason);
+      if (typeof executor === `function`) {
+        executor(pass, fail);
+      } else {
+        executor.then(pass, fail);
+      }
+    });
+    this.isCanceled = false;
+  }
+  cancel() {
+    this.isCanceled = true;
+  }
+};
+
+// 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;
+}
+
+// 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) {
+    for (const subscriber of this.subscribers.values()) {
+      subscriber(value);
+    }
+  }
+};
+
+// src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  var _a, _b;
+  if (store.transactionStatus.phase === `idle`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `abortTransaction called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  store.transactionStatus = { phase: `idle` };
+  (_b = store.config.logger) == null ? void 0 : _b.info(`\u{1FA82}`, `transaction fail`);
+};
+var applyTransaction = (output, store) => {
+  var _a, _b, _c, _d, _e;
+  if (store.transactionStatus.phase !== `building`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `abortTransaction called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  store.transactionStatus.phase = `applying`;
+  store.transactionStatus.output = output;
+  const { atomUpdates } = store.transactionStatus;
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `\u{1F6C3} applying transaction "${store.transactionStatus.key}" with ${atomUpdates.length} updates.`
+  );
+  (_c = store.config.logger) == null ? void 0 : _c.info(`\u{1F6C3} the updates are:`, atomUpdates);
+  for (const { key, newValue } of atomUpdates) {
+    const token = { key, type: `atom` };
+    if (!store.valueMap.has(token.key)) {
+      if (token.family) {
+        const family = store.families.get(token.family.key);
+        if (family) {
+          family(token.family.subKey);
+        }
+      } else {
+        const newAtom = store.transactionStatus.core.atoms.get(token.key);
+        if (!newAtom) {
+          throw new Error(
+            `Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`
+          );
+        }
+        store.atoms.set(newAtom.key, newAtom);
+        store.valueMap.set(newAtom.key, newAtom.default);
+        (_d = store.config.logger) == null ? void 0 : _d.info(`\u{1F527}`, `add atom "${newAtom.key}"`);
+      }
+    }
+    AtomIO.setState(token, newValue, store);
+  }
+  const myTransaction = withdraw(
+    { key: store.transactionStatus.key, type: `transaction` },
+    store
+  );
+  if (myTransaction === null) {
+    throw new Error(
+      `Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`
+    );
+  }
+  myTransaction.subject.next({
+    key: store.transactionStatus.key,
+    atomUpdates,
+    output,
+    params: store.transactionStatus.params
+  });
+  store.transactionStatus = { phase: `idle` };
+  (_e = store.config.logger) == null ? void 0 : _e.info(`\u{1F6EC}`, `transaction "${myTransaction.key}" applied`);
+};
+
+// ../../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;
+    this.a = data.between[0];
+    this.b = data.between[1];
+    this.cardinality = data.cardinality;
+    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);
+        return this;
+      };
+      this.deleteRelation = (a, b) => {
+        externalStore.deleteRelation(a, b);
+        return this;
+      };
+      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
+      if (externalStore.getContent) {
+        this.getContentInternal = (contentKey) => {
+          return externalStore.getContent(contentKey);
+        };
+        this.setContent = (contentKey, content) => {
+          externalStore.setContent(contentKey, content);
+          return this;
+        };
+        this.deleteContent = (contentKey) => {
+          externalStore.deleteContent(contentKey);
+          return this;
+        };
+      }
+    }
+  }
+  getRelatedKeys(key) {
+    return this.relations.get(key);
+  }
+  addRelation(a, b) {
+    const aRelations = this.relations.get(a);
+    const bRelations = this.relations.get(b);
+    if (aRelations) {
+      aRelations.add(b);
+    } else {
+      this.relations.set(a, /* @__PURE__ */ new Set([b]));
+    }
+    if (bRelations) {
+      bRelations.add(a);
+    } else {
+      this.relations.set(b, /* @__PURE__ */ new Set([a]));
+    }
+  }
+  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);
+        }
+      }
+    }
+  }
+  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 = (
+      // @ts-expect-error we deduce hereby that this.b may index a
+      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);
+      }
+    }
+    this.addRelation(a, b);
+    if (content) {
+      const contentKey = this.makeContentKey(a, b);
+      this.setContent(contentKey, content);
+    }
+    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) {
+        bRelations.forEach((a2) => this.delete(a2, b));
+      }
+    }
+    if (typeof a === `string` && b === void 0) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        aRelations.forEach((b2) => {
+          this.delete(a, b2);
+        });
+      }
+    }
+    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;
+      }
+    }
+  }
+  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((b2) => {
+          var _a;
+          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
+        });
+      }
+    }
+    if (a === void 0 && b !== void 0) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        return [...bRelations].map((a2) => {
+          var _a;
+          return [a2, (_a = this.getContent(a2, 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);
+  }
+};
+
+// src/transaction/build-transaction.ts
+var buildTransaction = (key, params, store) => {
+  var _a;
+  store.transactionStatus = {
+    key,
+    phase: `building`,
+    time: Date.now(),
+    core: {
+      atoms: new Map(store.atoms),
+      atomsThatAreDefault: new Set(store.atomsThatAreDefault),
+      families: new Map(store.families),
+      operation: { open: false },
+      readonlySelectors: new Map(store.readonlySelectors),
+      timelines: new Map(store.timelines),
+      timelineAtoms: new Junction(store.timelineAtoms.toJSON()),
+      trackers: /* @__PURE__ */ new Map(),
+      transactions: new Map(store.transactions),
+      selectorAtoms: new Junction(store.selectorAtoms.toJSON()),
+      selectorGraph: new Junction(store.selectorGraph.toJSON(), {
+        makeContentKey: (...keys) => keys.sort().join(`:`)
+      }),
+      selectors: new Map(store.selectors),
+      valueMap: new Map(store.valueMap)
+    },
+    atomUpdates: [],
+    params,
+    output: void 0
+  };
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `\u{1F6EB}`,
+    `transaction "${key}" building in store "${store.config.name}"`
+  );
+};
+
+// src/transaction/transaction-internal.ts
+function transaction__INTERNAL(options, store = IMPLICIT.STORE) {
+  const newTransaction = {
+    key: options.key,
+    type: `transaction`,
+    run: (...params) => {
+      var _a;
+      buildTransaction(options.key, params, store);
+      try {
+        const output = options.do(
+          {
+            get: (token2) => AtomIO.getState(token2, store),
+            set: (token2, value) => AtomIO.setState(token2, value, store)
+          },
+          ...params
+        );
+        applyTransaction(output, store);
+        return output;
+      } catch (thrown) {
+        abortTransaction(store);
+        (_a = store.config.logger) == null ? void 0 : _a.error(
+          `Transaction "${options.key}" failed in store "${store.config.name}":`,
+          thrown
+        );
+        throw thrown;
+      }
+    },
+    install: (store2) => transaction__INTERNAL(options, store2),
+    subject: new Subject()
+  };
+  const core = target(store);
+  core.transactions.set(newTransaction.key, newTransaction);
+  const token = deposit(newTransaction);
+  store.subject.transactionCreation.next(token);
+  return token;
+}
+var target = (store = IMPLICIT.STORE) => store.transactionStatus.phase === `building` ? store.transactionStatus.core : store;
+var redoTransactionUpdate = (update, store) => {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23ED redo transaction "${update.key}" (redo)`);
+  for (const { key, newValue } of update.atomUpdates) {
+    const token = { key, type: `atom` };
+    const state = withdraw(token, store);
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      );
+    }
+    AtomIO.setState(state, newValue, store);
+  }
+};
+var undoTransactionUpdate = (update, store) => {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(` \u23EE undo transaction "${update.key}" (undo)`);
+  for (const { key, oldValue } of update.atomUpdates) {
+    const token = { key, type: `atom` };
+    const state = withdraw(token, store);
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      );
+    }
+    AtomIO.setState(state, oldValue, store);
+  }
+};
+
+// src/transaction/index.ts
+var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
+
+// src/store/lookup.ts
+function lookup(key, store) {
+  var _a;
+  const core = target(store);
+  let type = core.atoms.has(key) ? `atom` : core.selectors.has(key) ? `selector` : core.readonlySelectors.has(key) ? `readonly_selector` : ``;
+  if (!type) {
+    const errorId = Math.random().toString(36);
+    type = `\u{1F6A8} This state could not be found by lookup! Check the console for "${errorId}"`;
+    (_a = store.config.logger) == null ? void 0 : _a.error(
+      `${errorId}: Key "${key}" does not exist in the store.`
+    );
+  }
+  return { key, type };
+}
+
+// src/store/store.ts
+var Store = class {
+  constructor(name, store = null) {
+    this.valueMap = /* @__PURE__ */ new Map();
+    this.atoms = /* @__PURE__ */ new Map();
+    this.selectors = /* @__PURE__ */ new Map();
+    this.readonlySelectors = /* @__PURE__ */ new Map();
+    this.trackers = /* @__PURE__ */ new Map();
+    this.families = /* @__PURE__ */ new Map();
+    this.timelines = /* @__PURE__ */ new Map();
+    this.transactions = /* @__PURE__ */ new Map();
+    this.atomsThatAreDefault = /* @__PURE__ */ new Set();
+    this.timelineAtoms = new Junction({
+      between: [`timelineKey`, `atomKey`],
+      cardinality: `1:n`
+    });
+    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.subject = {
+      atomCreation: new Subject(),
+      selectorCreation: new Subject(),
+      transactionCreation: new Subject(),
+      timelineCreation: new Subject(),
+      operationStatus: new Subject()
+    };
+    this.operation = { open: false };
+    this.transactionStatus = { phase: `idle` };
+    this.config = {
+      name: `IMPLICIT_STORE`,
+      logger: __spreadProps(__spreadValues({}, console), { info: () => void 0 }),
+      logger__INTERNAL: console
+    };
+    var _a;
+    if (store !== null) {
+      this.valueMap = new Map(store == null ? void 0 : store.valueMap);
+      this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
+      this.transactionStatus = __spreadValues({}, store == null ? void 0 : store.transactionStatus);
+      this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
+        logger__INTERNAL: console,
+        logger: __spreadValues(__spreadProps(__spreadValues({}, console), {
+          info: () => void 0
+        }), (_a = store == null ? void 0 : store.config) == null ? void 0 : _a.logger),
+        name
+      });
+    }
+    store == null ? void 0 : store.atoms.forEach((atom) => {
+      atom.install(this);
+    });
+    store == null ? void 0 : store.readonlySelectors.forEach((selector) => {
+      selector.install(this);
+    });
+    store == null ? void 0 : store.selectors.forEach((selector) => {
+      selector.install(this);
+    });
+    store == null ? void 0 : store.transactions.forEach((tx) => {
+      tx.install(this);
+    });
+    store == null ? void 0 : store.timelines.forEach((timeline) => {
+      timeline.install(this);
+    });
+  }
+};
+var IMPLICIT = {
+  STORE_INTERNAL: void 0,
+  get STORE() {
+    var _a;
+    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
+  }
+};
+var clearStore = (store = IMPLICIT.STORE) => {
+  const { config } = store;
+  Object.assign(store, new Store(config.name));
+  store.config = config;
+};
+
+// src/timeline/add-atom-to-timeline.ts
+var addAtomToTimeline = (atomToken, tl, store = IMPLICIT.STORE) => {
+  const atom = withdraw(atomToken, store);
+  if (atom === null) {
+    throw new Error(
+      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
+    );
+  }
+  atom.subject.subscribe(`timeline`, (update) => {
+    var _a, _b, _c, _d, _e;
+    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 currentTransactionKey = store.transactionStatus.phase === `applying` ? store.transactionStatus.key : null;
+    const currentTransactionTime = store.transactionStatus.phase === `applying` ? store.transactionStatus.time : null;
+    (_a = store.config.logger) == null ? void 0 : _a.info(
+      `\u23F3 timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
+      update.oldValue,
+      `->`,
+      update.newValue,
+      currentTransactionKey ? `) in transaction "${currentTransactionKey}"` : currentSelectorKey ? `) in selector "${currentSelectorKey}"` : `)`
+    );
+    if (tl.timeTraveling === null) {
+      if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
+        const mostRecentUpdate = tl.history.at(-1);
+        if (mostRecentUpdate === void 0) {
+          throw new Error(
+            `Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`
+          );
+        }
+      }
+      if (currentTransactionKey && store.transactionStatus.phase === `applying`) {
+        const currentTransaction = withdraw(
+          { key: currentTransactionKey, type: `transaction` },
+          store
+        );
+        if (currentTransaction === null) {
+          throw new Error(
+            `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
+          );
+        }
+        if (tl.transactionKey !== currentTransactionKey) {
+          if (tl.transactionKey) {
+            (_b = store.config.logger) == null ? void 0 : _b.error(
+              `Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`
+            );
+          }
+          tl.transactionKey = currentTransactionKey;
+          const unsubscribe = currentTransaction.subject.subscribe(
+            `timeline:${tl.key}`,
+            (update2) => {
+              var _a2;
+              unsubscribe();
+              if (tl.timeTraveling === null && currentTransactionTime) {
+                if (tl.at !== tl.history.length) {
+                  tl.history.splice(tl.at);
+                }
+                const atomUpdates = update2.atomUpdates.filter((atomUpdate) => {
+                  const core = target(store);
+                  const atomOrFamilyKeys = core.timelineAtoms.getRelatedKeys(
+                    tl.key
+                  );
+                  return atomOrFamilyKeys ? [...atomOrFamilyKeys].some(
+                    (key) => {
+                      var _a3;
+                      return key === atomUpdate.key || key === ((_a3 = atomUpdate.family) == null ? void 0 : _a3.key);
+                    }
+                  ) : false;
+                });
+                const timelineTransactionUpdate = __spreadProps(__spreadValues({
+                  type: `transaction_update`,
+                  timestamp: currentTransactionTime
+                }, update2), {
+                  atomUpdates
+                });
+                tl.history.push(timelineTransactionUpdate);
+                tl.at = tl.history.length;
+                tl.subject.next(timelineTransactionUpdate);
+              }
+              tl.transactionKey = null;
+              (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+                `\u231B timeline "${tl.key}" got a transaction_update "${update2.key}"`
+              );
+            }
+          );
+        }
+      } 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);
+          (_c = store.config.logger) == null ? void 0 : _c.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));
+            (_d = store.config.logger) == null ? void 0 : _d.info(
+              `   \u231B timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
+              latestUpdate == null ? void 0 : latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            );
+          }
+        }
+        if (latestUpdate)
+          tl.subject.next(latestUpdate);
+      } 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;
+        }
+        tl.history.push(atomUpdate);
+        tl.subject.next(atomUpdate);
+        (_e = store.config.logger) == null ? void 0 : _e.info(
+          `\u231B timeline "${tl.key}" got an atom_update to "${atom.key}"`
+        );
+        tl.at = tl.history.length;
+      }
+    }
+  });
+};
+var redo__INTERNAL = (token, store = IMPLICIT.STORE) => {
+  var _a, _b, _c, _d;
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u23E9 redo "${token.key}"`);
+  const timelineData = store.timelines.get(token.key);
+  if (!timelineData) {
+    (_b = store.config.logger) == null ? void 0 : _b.error(
+      `Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
+    );
+    return;
+  }
+  if (timelineData.at === timelineData.history.length) {
+    (_c = store.config.logger) == null ? void 0 : _c.warn(
+      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
+    );
+    return;
+  }
+  timelineData.timeTraveling = `into_future`;
+  const update = timelineData.history[timelineData.at];
+  switch (update.type) {
+    case `atom_update`: {
+      const { key, newValue } = update;
+      AtomIO.setState({ key, type: `atom` }, newValue, store);
+      break;
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, newValue } = atomUpdate;
+        AtomIO.setState({ key, type: `atom` }, newValue, store);
+      }
+      break;
+    }
+  }
+  ++timelineData.at;
+  timelineData.subject.next(`redo`);
+  timelineData.timeTraveling = null;
+  (_d = store.config.logger) == null ? void 0 : _d.info(
+    `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  );
+};
+var undo__INTERNAL = (token, store = IMPLICIT.STORE) => {
+  var _a, _b, _c, _d;
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u23EA undo "${token.key}"`);
+  const timelineData = store.timelines.get(token.key);
+  if (!timelineData) {
+    (_b = store.config.logger) == null ? void 0 : _b.error(
+      `Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
+    );
+    return;
+  }
+  if (timelineData.at === 0) {
+    (_c = store.config.logger) == null ? void 0 : _c.warn(
+      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
+    );
+    return;
+  }
+  timelineData.timeTraveling = `into_past`;
+  --timelineData.at;
+  const update = timelineData.history[timelineData.at];
+  switch (update.type) {
+    case `atom_update`: {
+      const { key, oldValue } = update;
+      AtomIO.setState({ key, type: `atom` }, oldValue, store);
+      break;
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of [...update.atomUpdates].reverse()) {
+        const { key, oldValue } = atomUpdate;
+        AtomIO.setState({ key, type: `atom` }, oldValue, store);
+      }
+      break;
+    }
+  }
+  timelineData.subject.next(`undo`);
+  timelineData.timeTraveling = null;
+  (_d = store.config.logger) == null ? void 0 : _d.info(
+    `\u23F9\uFE0F "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  );
+};
+
+// src/timeline/timeline-internal.ts
+function timeline__INTERNAL(options, store = IMPLICIT.STORE, data = null) {
+  var _a, _b, _c;
+  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: (store2) => timeline__INTERNAL(options, store2, tl),
+    subject: new Subject()
+  });
+  const core = target(store);
+  for (const tokenOrFamily of options.atoms) {
+    const timelineKey = core.timelineAtoms.getRelatedKey(tokenOrFamily.key);
+    if (timelineKey) {
+      (_b = store.config.logger) == null ? void 0 : _b.error(
+        `\u274C Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`
+      );
+      continue;
+    }
+    if (tokenOrFamily.type === `atom_family`) {
+      const family = tokenOrFamily;
+      family.subject.subscribe(`timeline:${options.key}`, (token2) => {
+        if (!core.atoms.has(token2.key)) {
+          addAtomToTimeline(token2, tl, store);
+        }
+      });
+    } else {
+      const token2 = tokenOrFamily;
+      if (`family` in token2 && token2.family) {
+        const familyTimelineKey = core.timelineAtoms.getRelatedKey(
+          token2.family.key
+        );
+        if (familyTimelineKey) {
+          (_c = store.config.logger) == null ? void 0 : _c.error(
+            `\u274C Failed to add atom "${token2.key}" to timeline "${options.key}" because its family "${token2.family.key}" belongs to timeline "${familyTimelineKey}"`
+          );
+          continue;
+        }
+      }
+      addAtomToTimeline(token2, tl, store);
+    }
+    core.timelineAtoms = core.timelineAtoms.set({
+      atomKey: tokenOrFamily.key,
+      timelineKey: options.key
+    });
+  }
+  store.timelines.set(options.key, tl);
+  const token = {
+    key: options.key,
+    type: `timeline`
+  };
+  store.subject.timelineCreation.next(token);
+  return token;
+}
+
+// src/store/withdraw.ts
+function withdraw(token, store) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  let core = target(store);
+  let state = (_d = (_c = (_b = (_a = core.atoms.get(token.key)) != null ? _a : core.selectors.get(token.key)) != null ? _b : core.readonlySelectors.get(token.key)) != null ? _c : core.transactions.get(token.key)) != null ? _d : core.timelines.get(token.key);
+  if (state) {
+    return state;
+  }
+  if (store.transactionStatus.phase === `applying`) {
+    core = store.transactionStatus.core;
+    state = (_h = (_g = (_f = (_e = core.atoms.get(token.key)) != null ? _e : core.selectors.get(token.key)) != null ? _f : core.readonlySelectors.get(token.key)) != null ? _g : core.transactions.get(token.key)) != null ? _h : core.timelines.get(token.key);
+    if (state) {
+      (_i = store.config.logger) == null ? void 0 : _i.info(`\u{1F6E0}\uFE0F add ${token.type} "${token.key}"`);
+      switch (state.type) {
+        case `atom`: {
+          store.atoms.set(token.key, state);
+          store.valueMap.set(token.key, state.default);
+          const stateKey = state.key;
+          const familyKey = (_j = state.family) == null ? void 0 : _j.key;
+          let timelineKey = core.timelineAtoms.getRelatedKey(stateKey);
+          if (timelineKey === void 0 && typeof familyKey === `string`) {
+            timelineKey = core.timelineAtoms.getRelatedKey(familyKey);
+          }
+          const timeline = typeof timelineKey === `string` ? store.timelines.get(timelineKey) : void 0;
+          if (timeline) {
+            addAtomToTimeline(state, timeline, store);
+          }
+          break;
+        }
+        case `selector`:
+          core.selectors.set(token.key, state);
+          break;
+        case `readonly_selector`:
+          core.readonlySelectors.set(token.key, state);
+          break;
+        case `transaction`:
+          core.transactions.set(token.key, state);
+          break;
+        case `timeline`:
+          core.timelines.set(token.key, state);
+          break;
+      }
+      return state;
+    }
+  }
+  return null;
+}
+
+// src/store/withdraw-new-family-member.ts
+function withdrawNewFamilyMember(token, store) {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `\u{1F46A} creating new family member "${token.key}" in store "${store.config.name}"`
+  );
+  if (token.family) {
+    const core = target(store);
+    const family = core.families.get(token.family.key);
+    if (family) {
+      const jsonSubKey = JSON.parse(token.family.subKey);
+      family(jsonSubKey);
+      const state = withdraw(token, store);
+      return state;
+    }
+  }
+  return null;
+}
+
+// src/caching.ts
+var cacheValue = (key, value, subject, store = IMPLICIT.STORE) => {
+  const currentValue = target(store).valueMap.get(key);
+  if (currentValue instanceof Future) {
+    currentValue.cancel();
+  }
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    target(store).valueMap.set(key, future);
+    future.then((value2) => {
+      cacheValue(key, value2, subject, store);
+      subject.next({ newValue: value2, oldValue: value2 });
+    });
+  } else {
+    target(store).valueMap.set(key, value);
+  }
+};
+var readCachedValue = (key, store = IMPLICIT.STORE) => target(store).valueMap.get(key);
+var isValueCached = (key, store = IMPLICIT.STORE) => target(store).valueMap.has(key);
+var Tracker = class {
+  constructor(mutableState, store = IMPLICIT.STORE) {
+    this.unsubscribeFromInnerValue = null;
+    this.mutableState = mutableState;
+    this.latestUpdateState = this.initializeState(mutableState, store);
+    this.observeCore(mutableState, this.latestUpdateState, store);
+    this.updateCore(mutableState, this.latestUpdateState, store);
+    const core = target(store);
+    core.trackers.set(mutableState.key, this);
+  }
+  initializeState(mutableState, store = IMPLICIT.STORE) {
+    const latestUpdateStateKey = `*${mutableState.key}`;
+    deleteAtom(latestUpdateStateKey, target(store));
+    const familyMetaData = mutableState.family ? {
+      key: `*${mutableState.family.key}`,
+      subKey: mutableState.family.subKey
+    } : void 0;
+    const latestUpdateState = createAtom(
+      {
+        key: latestUpdateStateKey,
+        default: null
+      },
+      familyMetaData,
+      store
+    );
+    return latestUpdateState;
+  }
+  observeCore(mutableState, latestUpdateState, store = IMPLICIT.STORE) {
+    const originalInnerValue = AtomIO__namespace.getState(mutableState, store);
+    this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
+      `tracker:${store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`,
+      (update) => {
+        const unsubscribe = store.subject.operationStatus.subscribe(
+          mutableState.key,
+          () => {
+            unsubscribe();
+            AtomIO__namespace.setState(latestUpdateState, update, store);
+          }
+        );
+      }
+    );
+    AtomIO__namespace.subscribe(
+      mutableState,
+      (update) => {
+        var _a;
+        if (update.newValue !== update.oldValue) {
+          (_a = this.unsubscribeFromInnerValue) == null ? void 0 : _a.call(this);
+          this.unsubscribeFromInnerValue = update.newValue.subscribe(
+            `tracker:${store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`,
+            (update2) => {
+              const unsubscribe = store.subject.operationStatus.subscribe(
+                mutableState.key,
+                () => {
+                  unsubscribe();
+                  AtomIO__namespace.setState(latestUpdateState, update2, store);
+                }
+              );
+            }
+          );
+        }
+      },
+      `${store.config.name}: tracker observing inner value`,
+      store
+    );
+  }
+  updateCore(mutableState, latestUpdateState, store = IMPLICIT.STORE) {
+    AtomIO__namespace.subscribe(
+      latestUpdateState,
+      ({ newValue, oldValue }) => {
+        const timelineId = store.timelineAtoms.getRelatedKey(
+          latestUpdateState.key
+        );
+        if (timelineId) {
+          const timelineData = store.timelines.get(timelineId);
+          if (timelineData == null ? void 0 : timelineData.timeTraveling) {
+            const unsubscribe2 = AtomIO__namespace.subscribeToTimeline(
+              { key: timelineId, type: `timeline` },
+              (update) => {
+                unsubscribe2();
+                AtomIO__namespace.setState(
+                  mutableState,
+                  (transceiver) => {
+                    if (update === `redo` && newValue) {
+                      transceiver.do(newValue);
+                    } else if (update === `undo` && oldValue) {
+                      transceiver.undo(oldValue);
+                    }
+                    return transceiver;
+                  },
+                  store
+                );
+              }
+            );
+            return;
+          }
+        }
+        const unsubscribe = store.subject.operationStatus.subscribe(
+          latestUpdateState.key,
+          () => {
+            unsubscribe();
+            if (newValue) {
+              AtomIO__namespace.setState(
+                mutableState,
+                (transceiver) => (transceiver.do(newValue), transceiver),
+                store
+              );
+            }
+          }
+        );
+      },
+      `${store.config.name}: tracker observing latest update`,
+      store
+    );
+  }
+};
+
+// src/mutable/create-mutable-atom.ts
+function createMutableAtom(options, store = IMPLICIT.STORE) {
+  var _a;
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `\u{1F527} creating mutable atom "${options.key}" in store "${store.config.name}"`
+  );
+  const coreState = createAtom(options, void 0, store);
+  new Tracker(coreState, store);
+  const jsonState = json.selectJson(coreState, options, store);
+  AtomIO__namespace.subscribe(
+    jsonState,
+    () => {
+      var _a2;
+      (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+        `\u{1F50D} tracker-initializer:${store == null ? void 0 : store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`,
+        `Initializing tracker for ${coreState.key}`
+      );
+      const trackerHasBeenInitialized = target(store).trackers.has(coreState.key);
+      if (!trackerHasBeenInitialized) {
+        new Tracker(coreState, store);
+      }
+    },
+    `tracker-initializer:${store == null ? void 0 : store.config.name}:${store.transactionStatus.phase === `idle` ? `main` : store.transactionStatus.key}`
+  );
+  return coreState;
+}
+function createAtomFamily(options, store = IMPLICIT.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 existing = withdraw({ key: fullKey, type: `atom` }, store);
+      let token;
+      if (existing) {
+        token = deposit(existing);
+      } else {
+        const individualOptions = {
+          key: fullKey,
+          default: options.default instanceof Function ? options.default(key) : options.default
+        };
+        if (options.effects) {
+          individualOptions.effects = options.effects(key);
+        }
+        token = createAtom(individualOptions, family, store);
+        subject.next(token);
+      }
+      return token;
+    },
+    {
+      key: options.key,
+      type: `atom_family`,
+      subject
+    }
+  );
+  const core = target(store);
+  core.families.set(options.key, atomFamily);
+  return atomFamily;
+}
+
+// src/selector/lookup-selector-sources.ts
+var lookupSelectorSources = (key, store) => {
+  const sources = target(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => lookup(source, store));
+  return sources;
+};
+
+// src/get-state-internal.ts
+var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
+  var _a, _b, _c;
+  if (isValueCached(state.key, store)) {
+    (_a = store.config.logger) == null ? void 0 : _a.info(`>> read "${state.key}"`);
+    return readCachedValue(state.key, store);
+  }
+  if (state.type !== `atom`) {
+    (_b = store.config.logger) == null ? void 0 : _b.info(`-> calc "${state.key}"`);
+    return state.get();
+  }
+  (_c = store.config.logger) == null ? void 0 : _c.error(
+    `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
+  );
+  return state.default;
+};
+
+// src/set-state/become.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+
+// src/operation.ts
+var openOperation = (token, store) => {
+  var _a, _b;
+  const core = target(store);
+  if (core.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.error(
+      `\u274C failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`
+    );
+    throw Symbol(`violation`);
+  }
+  core.operation = {
+    open: true,
+    done: /* @__PURE__ */ new Set(),
+    prev: new Map(store.valueMap),
+    time: Date.now(),
+    token
+  };
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `\u2B55 operation start from "${token.key}" in store "${store.config.name}"${store.transactionStatus.phase === `idle` ? `` : ` ${store.transactionStatus.phase} "${store.transactionStatus.key}"`}`
+  );
+};
+var closeOperation = (store) => {
+  var _a;
+  const core = target(store);
+  core.operation = { open: false };
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F534} operation done`);
+  store.subject.operationStatus.next(core.operation);
+};
+var isDone = (key, store = IMPLICIT.STORE) => {
+  var _a;
+  const core = target(store);
+  if (!core.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `isDone called outside of an operation. This is probably a bug.`
+    );
+    return true;
+  }
+  return core.operation.done.has(key);
+};
+var markDone = (key, store = IMPLICIT.STORE) => {
+  var _a;
+  const core = target(store);
+  if (!core.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `markDone called outside of an operation. This is probably a bug.`
+    );
+    return;
+  }
+  core.operation.done.add(key);
+};
+
+// src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, transform, origin, target3) {
+  var _a;
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target3.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    (_a = origin.config.logger) == null ? void 0 : _a.info(`\u{1F4C3} copying`, `${atom.key}`);
+    const copiedValue = transform.fromJson(transform.toJson(originValue));
+    target3.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
+  }
+  return targetValue;
+}
+
+// src/set-state/copy-mutable-in-transaction.ts
+function copyMutableIfWithinTransaction(atom, store) {
+  var _a;
+  if (store.transactionStatus.phase === `building` || store.transactionStatus.phase === `applying`) {
+    if (`toJson` in atom && `fromJson` in atom) {
+      (_a = store.config.logger) == null ? void 0 : _a.info(
+        `\u{1F4C4} copyMutableIfWithinTransaction: ${atom.key} is mutable`
+      );
+      const copiedValue = copyMutableIfNeeded(
+        atom,
+        atom,
+        store,
+        store.transactionStatus.core
+      );
+      return copiedValue;
+    }
+    if (`family` in atom) {
+      const family = store.transactionStatus.core.families.get(atom.family.key);
+      if (family && family.type === `atom_family`) {
+        const result = copyMutableFamilyMemberWithinTransaction(
+          atom,
+          family,
+          store,
+          store.transactionStatus.core
+        );
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+  return getState__INTERNAL(atom, store);
+}
+function copyMutableFamilyMemberWithinTransaction(atom, family, origin, target3) {
+  if (`toJson` in family && `fromJson` in family) {
+    const copyCreated = copyMutableIfNeeded(atom, family, origin, target3);
+    return copyCreated;
+  }
+  return null;
+}
+
+// src/set-state/emit-update.ts
+var emitUpdate = (state, update, store) => {
+  const { key } = state;
+  const { logger } = store.config;
+  logger == null ? void 0 : logger.info(
+    `\u{1F4E2} ${state.type} "${key}" went (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `)`
+  );
+  logger == null ? void 0 : logger.info(`\u{1F4E2} notifying subscribers:`, state.subject.subscribers);
+  state.subject.next(update);
+};
+
+// src/set-state/evict-downstream.ts
+var evictDownStream = (state, store = IMPLICIT.STORE) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const core = target(store);
+  const downstreamKeys = core.selectorAtoms.getRelatedKeys(state.key);
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   || ${(_a = downstreamKeys == null ? void 0 : downstreamKeys.size) != null ? _a : `none`} downstream:`,
+    downstreamKeys
+  );
+  if (core.operation.open) {
+    (_c = store.config.logger) == null ? void 0 : _c.info(`   ||`, [...core.operation.done], `already done`);
+  }
+  if (downstreamKeys) {
+    for (const key of downstreamKeys) {
+      if (isDone(key, store)) {
+        (_d = store.config.logger) == null ? void 0 : _d.info(`   || ${key} already done`);
+        continue;
+      }
+      const state2 = (_e = core.selectors.get(key)) != null ? _e : core.readonlySelectors.get(key);
+      if (!state2) {
+        (_f = store.config.logger) == null ? void 0 : _f.info(
+          `   || ${key} was not found in selectors or readonlySelectors`
+        );
+        return;
+      }
+      core.valueMap.delete(key);
+      (_g = store.config.logger) == null ? void 0 : _g.info(`   xx evicted "${key}"`);
+      markDone(key, store);
+    }
+  }
+};
+
+// 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) => {
+  var _a;
+  const { key } = state;
+  const { logger } = store.config;
+  if (store.transactionStatus.phase !== `building`) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `stowUpdate called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  const shouldStow = shouldUpdateBeStowed(key, update);
+  if (!shouldStow) {
+    return;
+  }
+  const atomUpdate = __spreadValues({ key }, update);
+  if (state.family) {
+    atomUpdate.family = state.family;
+  }
+  store.transactionStatus.atomUpdates.push(atomUpdate);
+  logger == null ? void 0 : logger.info(`\u{1F4DD} ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`);
+};
+
+// src/set-state/set-atom-state.ts
+var setAtomState = (atom, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(atom, store);
+  let newValue = copyMutableIfWithinTransaction(atom, store);
+  newValue = become(next)(newValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`<< setting atom "${atom.key}" to`, newValue);
+  cacheValue(atom.key, newValue, atom.subject, store);
+  if (isAtomDefault(atom.key, store)) {
+    markAtomAsNotDefault(atom.key, store);
+  }
+  markDone(atom.key, store);
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   || evicting caches downstream from "${atom.key}"`
+  );
+  evictDownStream(atom, store);
+  const update = { oldValue, newValue };
+  if (store.transactionStatus.phase !== `building`) {
+    emitUpdate(atom, update, store);
+  } else {
+    stowUpdate(atom, update, store);
+  }
+};
+
+// src/set-state/set-selector-state.ts
+var setSelectorState = (selector, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(selector, store);
+  const newValue = become(next)(oldValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(`<< setting selector "${selector.key}" to`, newValue);
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   || propagating change made to "${selector.key}"`);
+  selector.set(newValue);
+};
+
+// src/set-state/set-state-internal.ts
+var setState__INTERNAL = (state, value, store = IMPLICIT.STORE) => {
+  if (`set` in state) {
+    setSelectorState(state, value, store);
+  } else {
+    setAtomState(state, value, store);
+  }
+};
+
+// src/selector/trace-selector-atoms.ts
+var traceSelectorAtoms = (selectorKey, dependency, store) => {
+  const roots = [];
+  const sources = lookupSelectorSources(dependency.key, store);
+  let depth = 0;
+  while (sources.length > 0) {
+    const source = sources.shift();
+    ++depth;
+    if (depth > 999) {
+      throw new Error(
+        `Maximum selector dependency depth exceeded in selector "${selectorKey}".`
+      );
+    }
+    if (source.type !== `atom`) {
+      sources.push(...lookupSelectorSources(source.key, store));
+    } else {
+      roots.push(source);
+    }
+  }
+  return roots;
+};
+var traceAllSelectorAtoms = (selectorKey, store) => {
+  const sources = lookupSelectorSources(selectorKey, store);
+  return sources.flatMap(
+    (source) => source.type === `atom` ? source : traceSelectorAtoms(selectorKey, source, store)
+  );
+};
+
+// src/selector/update-selector-atoms.ts
+var updateSelectorAtoms = (selectorKey, dependency, store) => {
+  var _a, _b;
+  const core = target(store);
+  if (dependency.type === `atom`) {
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key
+    });
+    (_a = store.config.logger) == null ? void 0 : _a.info(
+      `   || adding root for "${selectorKey}": ${dependency.key}`
+    );
+    return;
+  }
+  const roots = traceSelectorAtoms(selectorKey, dependency, store);
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   || adding roots for "${selectorKey}":`,
+    roots.map((r) => r.key)
+  );
+  for (const root of roots) {
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: root.key
+    });
+  }
+};
+
+// src/selector/register-selector.ts
+var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
+  get: (dependency) => {
+    var _a, _b;
+    const core = target(store);
+    const alreadyRegistered = core.selectorGraph.getRelationEntries({ downstreamSelectorKey: selectorKey }).some(([_, { source }]) => source === dependency.key);
+    const dependencyState = withdraw(dependency, store);
+    if (dependencyState === null) {
+      throw new Error(
+        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    const dependencyValue = getState__INTERNAL(dependencyState, store);
+    if (alreadyRegistered) {
+      (_a = store.config.logger) == null ? void 0 : _a.info(
+        `   || ${selectorKey} <- ${dependency.key} =`,
+        dependencyValue
+      );
+    } else {
+      (_b = store.config.logger) == null ? void 0 : _b.info(
+        `\u{1F50C} registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
+        dependencyValue,
+        `)`
+      );
+      core.selectorGraph = core.selectorGraph.set(
+        {
+          upstreamSelectorKey: dependency.key,
+          downstreamSelectorKey: selectorKey
+        },
+        {
+          source: dependency.key
+        }
+      );
+    }
+    updateSelectorAtoms(selectorKey, dependency, store);
+    return dependencyValue;
+  },
+  set: (stateToken, newValue) => {
+    const state = withdraw(stateToken, store);
+    if (state === null) {
+      throw new Error(
+        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    setState__INTERNAL(state, newValue, store);
+  }
+});
+
+// src/selector/create-read-write-selector.ts
+var createReadWriteSelector = (options, family, store, core) => {
+  var _a;
+  const subject = new Subject();
+  const { get, set } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    cacheValue(options.key, value, subject, store);
+    return value;
+  };
+  const setSelf = (next) => {
+    var _a2;
+    const oldValue = getSelf();
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(
+      `   <- "${options.key}" went (`,
+      oldValue,
+      `->`,
+      next,
+      `)`
+    );
+    const newValue = become(next)(oldValue);
+    cacheValue(options.key, newValue, subject, store);
+    markDone(options.key, store);
+    if (store.transactionStatus.phase === `idle`) {
+      subject.next({ newValue, oldValue });
+    }
+    options.set({ get, set }, newValue);
+  };
+  const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => createSelector(options, family, s),
+    get: getSelf,
+    set: setSelf,
+    type: `selector`
+  }), family && { family });
+  core.selectors.set(options.key, mySelector);
+  const initialValue = getSelf();
+  (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
+  const token = {
+    key: options.key,
+    type: `selector`
+  };
+  if (family) {
+    token.family = family;
+  }
+  store.subject.selectorCreation.next(token);
+  return token;
+};
+
+// src/selector/create-readonly-selector.ts
+var createReadonlySelector = (options, family, store, core) => {
+  var _a;
+  const subject = new Subject();
+  const { get } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    cacheValue(options.key, value, subject, store);
+    return value;
+  };
+  const readonlySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    subject,
+    install: (s) => createSelector(options, family, s),
+    get: getSelf,
+    type: `readonly_selector`
+  }), family && { family });
+  core.readonlySelectors.set(options.key, readonlySelector);
+  const initialValue = getSelf();
+  (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728 "${options.key}" =`, initialValue);
+  const token = {
+    key: options.key,
+    type: `readonly_selector`
+  };
+  if (family) {
+    token.family = family;
+  }
+  store.subject.selectorCreation.next(token);
+  return token;
+};
+
+// src/selector/create-selector.ts
+function createSelector(options, family, store = IMPLICIT.STORE) {
+  var _a, _b;
+  const core = target(store);
+  const existingWritable = core.selectors.get(options.key);
+  const existingReadonly = core.readonlySelectors.get(options.key);
+  if (existingWritable || existingReadonly) {
+    (_b = (_a = store.config.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
+      _a,
+      `Tried to create ${existingReadonly ? `readonly selector` : `selector`}`,
+      `"${options.key}", but it already exists in the store.`,
+      `(Ignore if you are using hot module replacement.)`
+    );
+  }
+  if (`set` in options) {
+    return createReadWriteSelector(options, family, store, core);
+  }
+  return createReadonlySelector(options, family, store, core);
+}
+
+// src/families/create-readonly-selector-family.ts
+function createReadonlySelectorFamily(options, store) {
+  const core = target(store);
+  const subject = new Subject();
+  return Object.assign(
+    (key) => {
+      const subKey = json.stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const existing = core.readonlySelectors.get(fullKey);
+      if (existing) {
+        return deposit(existing);
+      }
+      return createSelector(
+        {
+          key: fullKey,
+          get: options.get(key)
+        },
+        family,
+        store
+      );
+    },
+    {
+      key: options.key,
+      type: `readonly_selector_family`,
+      subject
+    }
+  );
+}
+function createSelectorFamily(options, store = IMPLICIT.STORE) {
+  const isReadonly = !(`set` in options);
+  if (isReadonly) {
+    return createReadonlySelectorFamily(options, store);
+  }
+  const core = target(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 existing = core.selectors.get(fullKey);
+      if (existing) {
+        return deposit(existing);
+      }
+      const token = createSelector(
+        {
+          key: fullKey,
+          get: options.get(key),
+          set: options.set(key)
+        },
+        family,
+        store
+      );
+      subject.next(token);
+      return token;
+    },
+    {
+      key: options.key,
+      type: `selector_family`
+    }
+  );
+  core.families.set(options.key, selectorFamily);
+  return selectorFamily;
+}
+
+// src/mutable/tracker-family.ts
+var FamilyTracker = class {
+  constructor(findMutableState, store = IMPLICIT.STORE) {
+    this.findLatestUpdateState = createAtomFamily(
+      {
+        key: `*${findMutableState.key}`,
+        default: null
+      },
+      store
+    );
+    this.findMutableState = findMutableState;
+    this.findMutableState.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (atomToken) => {
+        if (atomToken.family) {
+          const key = json.parseJson(atomToken.family.subKey);
+          this.findLatestUpdateState(key);
+          new Tracker(atomToken, store);
+        }
+      }
+    );
+    this.findLatestUpdateState.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (atomToken) => {
+        if (atomToken.family) {
+          const key = json.parseJson(atomToken.family.subKey);
+          const mutableAtomToken = this.findMutableState(key);
+          new Tracker(mutableAtomToken, store);
+        }
+      }
+    );
+  }
+};
+
+// src/mutable/create-mutable-atom-family.ts
+function createMutableAtomFamily(options, store = IMPLICIT.STORE) {
+  const coreFamily = Object.assign(
+    createAtomFamily(options, store),
+    options
+  );
+  json.selectJsonFamily(coreFamily, options);
+  new FamilyTracker(coreFamily, store);
+  return coreFamily;
+}
+
+// src/mutable/get-json-token.ts
+var getJsonToken = (mutableAtomToken) => {
+  const key = mutableAtomToken.family ? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})` : `${mutableAtomToken.key}:JSON`;
+  const jsonToken = { type: `selector`, key };
+  if (mutableAtomToken.family) {
+    jsonToken.family = {
+      key: `${mutableAtomToken.family.key}:JSON`,
+      subKey: mutableAtomToken.family.subKey
+    };
+  }
+  return jsonToken;
+};
+
+// 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;
+};
+
+// src/mutable/is-atom-token-mutable.ts
+function isAtomTokenMutable(token) {
+  return token.key.endsWith(`::mutable`);
+}
+
+// src/mutable/transceiver.ts
+function isTransceiver(value) {
+  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+}
+
+// src/mutable/index.ts
+var isAtomMutable = (atom) => `isMutable` in atom;
+
+// src/atom/is-default.ts
+var isAtomDefault = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  return core.atomsThatAreDefault.has(key);
+};
+var markAtomAsDefault = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
+};
+var markAtomAsNotDefault = (key, store = IMPLICIT.STORE) => {
+  const core = target(store);
+  core.atomsThatAreDefault = new Set(target(store).atomsThatAreDefault);
+  core.atomsThatAreDefault.delete(key);
+};
+var isSelectorDefault = (key, store = IMPLICIT.STORE) => {
+  const roots = traceAllSelectorAtoms(key, store);
+  return roots.every((root) => isAtomDefault(root.key, store));
+};
+
+// src/atom/create-atom.ts
+function createAtom(options, family, store = IMPLICIT.STORE) {
+  var _a, _b, _c, _d, _e;
+  (_b = (_a = store.config.logger) == null ? void 0 : _a.info) == null ? void 0 : _b.call(
+    _a,
+    `\u{1F528} creating atom "${options.key}" in store "${store.config.name}"`
+  );
+  const core = target(store);
+  const existing = core.atoms.get(options.key);
+  if (existing) {
+    (_d = (_c = store.config.logger) == null ? void 0 : _c.error) == null ? void 0 : _d.call(
+      _c,
+      `Tried to create atom "${options.key}",`,
+      `but it already exists in the store.`,
+      `(Ignore if you are using hot module replacement.)`
+    );
+    return deposit(existing);
+  }
+  const subject = new Subject();
+  const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    type: `atom`,
+    install: (store2) => {
+      var _a2, _b2;
+      (_b2 = (_a2 = store2.config.logger) == null ? void 0 : _a2.info) == null ? void 0 : _b2.call(
+        _a2,
+        `\u{1F6E0}\uFE0F  installing atom "${options.key}" in store "${store2.config.name}"`
+      );
+      return `mutable` in options ? createMutableAtom(options, store2) : createAtom(options, void 0, store2);
+    },
+    subject
+  }), family && { family });
+  const initialValue = options.default instanceof Function ? options.default() : options.default;
+  core.atoms.set(newAtom.key, newAtom);
+  markAtomAsDefault(options.key, store);
+  cacheValue(options.key, initialValue, subject, store);
+  const token = deposit(newAtom);
+  for (const effect of (_e = options.effects) != null ? _e : []) {
+    effect({
+      setSelf: (next) => AtomIO.setState(token, next, store),
+      onSet: (handle) => AtomIO.subscribe(token, handle, `effect[${subject.subscribers.size}]`, store)
+    });
+  }
+  store.subject.atomCreation.next(token);
+  return token;
+}
+
+// src/atom/delete-atom.ts
+function deleteAtom(key, core = IMPLICIT.STORE) {
+  core.atoms.delete(key);
+  core.valueMap.delete(key);
+  core.selectorAtoms.delete(key);
+  core.atomsThatAreDefault.delete(key);
+  core.timelineAtoms.delete(key);
+}
+
+// src/subscribe/recall-state.ts
+var recallState = (state, store = IMPLICIT.STORE) => {
+  var _a;
+  const core = target(store);
+  if (!core.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `recall called outside of an operation. This is probably a bug.`
+    );
+    return core.valueMap.get(state.key);
+  }
+  return core.operation.prev.get(state.key);
+};
+
+// src/subscribe/subscribe-to-root-atoms.ts
+var subscribeToRootAtoms = (state, store) => {
+  const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+    const atom = withdraw(atomToken, store);
+    if (atom === null) {
+      throw new Error(
+        `Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
+      );
+    }
+    return atom.subject.subscribe(
+      `${state.type}:${state.key}`,
+      (atomChange) => {
+        var _a, _b;
+        (_a = store.config.logger) == null ? void 0 : _a.info(
+          `\u{1F4E2} selector "${state.key}" saw root "${atomToken.key}" go (`,
+          atomChange.oldValue,
+          `->`,
+          atomChange.newValue,
+          `)`
+        );
+        const oldValue = recallState(state, store);
+        const newValue = getState__INTERNAL(state, store);
+        (_b = store.config.logger) == null ? void 0 : _b.info(
+          `   <- "${state.key}" went (`,
+          oldValue,
+          `->`,
+          newValue,
+          `)`
+        );
+        state.subject.next({ newValue, oldValue });
+      }
+    );
+  });
+  return dependencySubscriptions;
+};
+
+exports.FamilyTracker = FamilyTracker;
+exports.Future = Future;
+exports.IMPLICIT = IMPLICIT;
+exports.Store = Store;
+exports.Subject = Subject;
+exports.TRANSACTION_PHASES = TRANSACTION_PHASES;
+exports.Tracker = Tracker;
+exports.abortTransaction = abortTransaction;
+exports.addAtomToTimeline = addAtomToTimeline;
+exports.applyTransaction = applyTransaction;
+exports.become = become;
+exports.buildTransaction = buildTransaction;
+exports.cacheValue = cacheValue;
+exports.clearStore = clearStore;
+exports.closeOperation = closeOperation;
+exports.createAtom = createAtom;
+exports.createAtomFamily = createAtomFamily;
+exports.createMutableAtom = createMutableAtom;
+exports.createMutableAtomFamily = createMutableAtomFamily;
+exports.createReadonlySelectorFamily = createReadonlySelectorFamily;
+exports.createSelector = createSelector;
+exports.createSelectorFamily = createSelectorFamily;
+exports.deleteAtom = deleteAtom;
+exports.deposit = deposit;
+exports.getJsonToken = getJsonToken;
+exports.getState__INTERNAL = getState__INTERNAL;
+exports.getUpdateToken = getUpdateToken;
+exports.isAtomDefault = isAtomDefault;
+exports.isAtomMutable = isAtomMutable;
+exports.isAtomTokenMutable = isAtomTokenMutable;
+exports.isDone = isDone;
+exports.isSelectorDefault = isSelectorDefault;
+exports.isTransceiver = isTransceiver;
+exports.isValueCached = isValueCached;
+exports.lookup = lookup;
+exports.lookupSelectorSources = lookupSelectorSources;
+exports.markAtomAsDefault = markAtomAsDefault;
+exports.markAtomAsNotDefault = markAtomAsNotDefault;
+exports.markDone = markDone;
+exports.openOperation = openOperation;
+exports.readCachedValue = readCachedValue;
+exports.redoTransactionUpdate = redoTransactionUpdate;
+exports.redo__INTERNAL = redo__INTERNAL;
+exports.registerSelector = registerSelector;
+exports.setState__INTERNAL = setState__INTERNAL;
+exports.subscribeToRootAtoms = subscribeToRootAtoms;
+exports.target = target;
+exports.timeline__INTERNAL = timeline__INTERNAL;
+exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
+exports.traceSelectorAtoms = traceSelectorAtoms;
+exports.transaction__INTERNAL = transaction__INTERNAL;
+exports.undoTransactionUpdate = undoTransactionUpdate;
+exports.undo__INTERNAL = undo__INTERNAL;
+exports.updateSelectorAtoms = updateSelectorAtoms;
+exports.withdraw = withdraw;
+exports.withdrawNewFamilyMember = withdrawNewFamilyMember;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map