atom.io 0.14.0 → 0.14.1

package/realtime-testing/dist/index.cjs

@@ -2,14 +2,11 @@
 
 var http = require('http');
 var react = require('@testing-library/react');
-var AtomIO = require('atom.io');
-var Internal = require('atom.io/internal');
-var AR = require('atom.io/react');
-var RTC = require('atom.io/realtime-react');
+var React2 = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var socket_ioClient = require('socket.io-client');
 var Happy = require('happy-dom');
 var SocketIO = require('socket.io');
-var socket_ioClient = require('socket.io-client');
-var jsxRuntime = require('react/jsx-runtime');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -30,10 +27,7 @@ function _interopNamespace(e) {
 }
 
 var http__namespace = /*#__PURE__*/_interopNamespace(http);
-var AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
-var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
-var AR__namespace = /*#__PURE__*/_interopNamespace(AR);
-var RTC__namespace = /*#__PURE__*/_interopNamespace(RTC);
+var React2__namespace = /*#__PURE__*/_interopNamespace(React2);
 var Happy__namespace = /*#__PURE__*/_interopNamespace(Happy);
 var SocketIO__namespace = /*#__PURE__*/_interopNamespace(SocketIO);
 
@@ -57,7 +51,2349 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
-// ../../anvl/src/object/entries.ts
+// internal/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;
+  }
+};
+
+// internal/src/lineage.ts
+function newest(scion) {
+  while (scion.child !== null) {
+    scion = scion.child;
+  }
+  return scion;
+}
+
+// internal/src/caching.ts
+function cacheValue(key, value, subject, store) {
+  const target = newest(store);
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    currentValue.cancel();
+  }
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    newest(store).valueMap.set(key, future);
+    future.then((resolved) => {
+      if (future.isCanceled) {
+        return;
+      }
+      cacheValue(key, resolved, subject, store);
+      subject.next({ newValue: resolved, oldValue: future });
+    }).catch((thrown) => {
+      if (thrown !== `canceled`) {
+        store.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+      }
+    });
+    return future;
+  }
+  target.valueMap.set(key, value);
+  return value;
+}
+var readCachedValue = (key, store) => {
+  return newest(store).valueMap.get(key);
+};
+var isValueCached = (key, store) => {
+  return newest(store).valueMap.has(key);
+};
+var evictCachedValue = (key, store) => {
+  const core = newest(store);
+  const currentValue = core.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    currentValue.cancel();
+  }
+  if (core.operation.open) {
+    core.operation.prev.set(key, currentValue);
+  }
+  core.valueMap.delete(key);
+  store.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+};
+
+// ../anvl/src/json/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+
+// json/src/select-json.ts
+var selectJson = (atom2, transform, store = IMPLICIT.STORE) => {
+  return createSelector(
+    {
+      key: `${atom2.key}:JSON`,
+      get: ({ get }) => transform.toJson(get(atom2)),
+      set: ({ set }, newValue) => set(atom2, transform.fromJson(newValue))
+    },
+    void 0,
+    store
+  );
+};
+
+// json/src/select-json-family.ts
+var selectJsonFamily = (atomFamily, transform, store = IMPLICIT.STORE) => {
+  const jsonFamily = createSelectorFamily(
+    {
+      key: `${atomFamily.key}:JSON`,
+      get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
+      set: (key) => ({ set }, newValue) => set(atomFamily(key), transform.fromJson(newValue))
+    },
+    store
+  );
+  atomFamily.subject.subscribe(
+    `store=${store.config.name}::json-selector-family`,
+    (token) => {
+      if (token.family) {
+        jsonFamily(parseJson(token.family.subKey));
+      }
+    }
+  );
+  return jsonFamily;
+};
+
+// internal/src/read-or-compute-value.ts
+var readOrComputeValue = (state, store) => {
+  if (isValueCached(state.key, store)) {
+    store.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
+    return readCachedValue(state.key, store);
+  }
+  if (state.type !== `atom`) {
+    store.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
+    return state.get();
+  }
+  const fallback = state.default instanceof Function ? state.default() : state.default;
+  store.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) => {
+  const target = newest(store);
+  if (target.operation.open) {
+    store.logger.error(
+      `\u274C`,
+      token.type,
+      token.key,
+      `failed to setState during a setState for "${target.operation.token.key}"`
+    );
+    return `rejection`;
+  }
+  target.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}"${target.transactionMeta === null ? `` : ` ${target.transactionMeta.phase} "${target.transactionMeta.update.key}"`}`
+  );
+};
+var closeOperation = (store) => {
+  const target = newest(store);
+  if (target.operation.open) {
+    store.logger.info(
+      `\u{1F534}`,
+      target.operation.token.type,
+      target.operation.token.key,
+      `operation done in store "${store.config.name}"`
+    );
+  }
+  target.operation = { open: false };
+  store.subject.operationStatus.next(target.operation);
+};
+var isDone = (key, store) => {
+  const target = newest(store);
+  if (!target.operation.open) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `isDone called outside of an operation. This is probably a bug.`
+    );
+    return true;
+  }
+  return target.operation.done.has(key);
+};
+var markDone = (key, store) => {
+  const target = newest(store);
+  if (!target.operation.open) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `unknown`,
+      key,
+      `markDone called outside of an operation. This is probably a bug.`
+    );
+    return;
+  }
+  target.operation.done.add(key);
+};
+
+// internal/src/set-state/become.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+
+// 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) {
+    for (const subscriber of this.subscribers.values()) {
+      subscriber(value);
+    }
+  }
+};
+var StatefulSubject = class extends Subject {
+  constructor(initialState) {
+    super();
+    this.state = initialState;
+  }
+  next(value) {
+    this.state = value;
+    super.next(value);
+  }
+};
+
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom2, transform, origin, target) {
+  const originValue = origin.valueMap.get(atom2.key);
+  const targetValue = target.valueMap.get(atom2.key);
+  if (originValue === targetValue) {
+    origin.logger.info(`\u{1F4C3}`, `atom`, `${atom2.key}`, `copying`);
+    const jsonValue = transform.toJson(originValue);
+    const copiedValue = transform.fromJson(jsonValue);
+    target.valueMap.set(atom2.key, copiedValue);
+    new Tracker(atom2, origin);
+    return copiedValue;
+  }
+  return targetValue;
+}
+
+// internal/src/set-state/copy-mutable-in-transaction.ts
+function copyMutableIfWithinTransaction(oldValue, atom2, store) {
+  const target = newest(store);
+  const parent = target.parent;
+  if (parent !== null) {
+    if (`toJson` in atom2 && `fromJson` in atom2) {
+      const copiedValue = copyMutableIfNeeded(atom2, atom2, parent, target);
+      return copiedValue;
+    }
+    if (`family` in atom2) {
+      const family = parent.families.get(atom2.family.key);
+      if (family && family.type === `atom_family`) {
+        const result = copyMutableFamilyMemberWithinTransaction(
+          atom2,
+          family,
+          parent,
+          target
+        );
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+  return oldValue;
+}
+function copyMutableFamilyMemberWithinTransaction(atom2, family, origin, target) {
+  if (`toJson` in family && `fromJson` in family) {
+    const copyCreated = copyMutableIfNeeded(atom2, family, origin, target);
+    return copyCreated;
+  }
+  return null;
+}
+
+// internal/src/set-state/emit-update.ts
+var emitUpdate = (state, update, store) => {
+  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 = (atom2, store) => {
+  const target = newest(store);
+  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom2.key);
+  store.logger.info(
+    `\u{1F9F9}`,
+    atom2.type,
+    atom2.key,
+    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
+    downstreamKeys != null ? downstreamKeys : `to evict`
+  );
+  if (downstreamKeys) {
+    if (target.operation.open) {
+      store.logger.info(
+        `\u{1F9F9}`,
+        atom2.type,
+        atom2.key,
+        `[ ${[...target.operation.done].join(`, `)} ] already done`
+      );
+    }
+    for (const key of downstreamKeys) {
+      if (isDone(key, store)) {
+        continue;
+      }
+      evictCachedValue(key, store);
+      markDone(key, store);
+    }
+  }
+};
+
+// 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 (target.transactionMeta === null || 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({ 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 = (atom2, next, store) => {
+  const target = newest(store);
+  const oldValue = readOrComputeValue(atom2, store);
+  let newValue = copyMutableIfWithinTransaction(oldValue, atom2, store);
+  newValue = become(next)(newValue);
+  store.logger.info(`\u{1F4DD}`, `atom`, atom2.key, `set to`, newValue);
+  newValue = cacheValue(atom2.key, newValue, atom2.subject, store);
+  if (isAtomDefault(atom2.key, store)) {
+    markAtomAsNotDefault(atom2.key, store);
+  }
+  markDone(atom2.key, store);
+  evictDownStream(atom2, store);
+  const update = { oldValue, newValue };
+  if (target.transactionMeta === null || target.transactionMeta.phase === `applying`) {
+    emitUpdate(atom2, update, store);
+  } else {
+    stowUpdate(atom2, update, store);
+  }
+};
+
+// internal/src/set-state/set-atom-or-selector.ts
+var setAtomOrSelector = (state, value, store) => {
+  if (state.type === `selector`) {
+    state.set(value);
+  } else {
+    setAtom(state, value, store);
+  }
+};
+
+// 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 a2 of bRelations) {
+          this.delete(a2, b);
+        }
+      }
+    }
+    if (typeof a === `string` && b === void 0) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        for (const b2 of aRelations) {
+          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;
+      }
+    }
+  }
+  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((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);
+  }
+};
+
+// internal/src/store/store.ts
+var Store = class {
+  constructor(name, 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.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(),
+      transactionApplying: new StatefulSubject(null),
+      operationStatus: new Subject()
+    };
+    this.operation = { open: false };
+    this.transactionMeta = null;
+    this.config = {
+      name: `IMPLICIT_STORE`
+    };
+    this.loggers = [
+      new 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);
+      }
+    };
+    if (store !== null) {
+      this.valueMap = new Map(store == null ? void 0 : store.valueMap);
+      this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
+      this.transactionMeta = (store == null ? void 0 : store.transactionMeta) ? __spreadValues({}, store == null ? void 0 : store.transactionMeta) : null;
+      this.config = __spreadProps(__spreadValues({}, store == null ? void 0 : store.config), {
+        name
+      });
+      for (const [, atom2] of store.atoms) {
+        atom2.install(this);
+      }
+      for (const [, selector2] of store.readonlySelectors) {
+        selector2.install(this);
+      }
+      for (const [, selector2] of store.selectors) {
+        selector2.install(this);
+      }
+      for (const [, tx] of store.transactions) {
+        tx.install(this);
+      }
+      for (const [, timeline] of store.timelines) {
+        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) => {
+  const { config } = store;
+  Object.assign(store, new Store(config.name));
+  store.config = config;
+};
+
+// internal/src/store/withdraw.ts
+function withdraw(token, store) {
+  var _a, _b, _c, _d;
+  const target = newest(store);
+  const state = (_d = (_c = (_b = (_a = target.atoms.get(token.key)) != null ? _a : target.selectors.get(token.key)) != null ? _b : target.readonlySelectors.get(token.key)) != null ? _c : target.transactions.get(token.key)) != null ? _d : target.timelines.get(token.key);
+  if (state) {
+    return state;
+  }
+  return void 0;
+}
+
+// internal/src/store/withdraw-new-family-member.ts
+function withdrawNewFamilyMember(token, store) {
+  if (token.family) {
+    store.logger.info(
+      `\u{1F46A}`,
+      token.type,
+      token.key,
+      `creating new family member in store "${store.config.name}"`
+    );
+    const target = newest(store);
+    const family = target.families.get(token.family.key);
+    if (family) {
+      const jsonSubKey = JSON.parse(token.family.subKey);
+      family(jsonSubKey);
+      const state = withdraw(token, store);
+      return state;
+    }
+  }
+  return void 0;
+}
+
+// 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 = (selectorKey, directDependencyKey, store) => {
+  const rootKeys = [];
+  const indirectDependencyKeys = getSelectorDependencyKeys(
+    directDependencyKey,
+    store
+  );
+  let depth = 0;
+  while (indirectDependencyKeys.length > 0) {
+    const indirectDependencyKey = indirectDependencyKeys.shift();
+    ++depth;
+    if (depth > 99999) {
+      throw new Error(
+        `Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`
+      );
+    }
+    if (!isAtomKey(indirectDependencyKey, store)) {
+      indirectDependencyKeys.push(
+        ...getSelectorDependencyKeys(indirectDependencyKey, store)
+      );
+    } else if (!rootKeys.includes(indirectDependencyKey)) {
+      rootKeys.push(indirectDependencyKey);
+    }
+  }
+  return rootKeys;
+};
+var traceAllSelectorAtoms = (selectorKey, store) => {
+  const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
+  return directDependencyKeys.flatMap(
+    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(selectorKey, depKey, store)
+  );
+};
+
+// internal/src/selector/update-selector-atoms.ts
+var updateSelectorAtoms = (selectorKey, dependency, store) => {
+  const target = newest(store);
+  if (dependency.type === `atom`) {
+    target.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key
+    });
+    store.logger.info(
+      `\u{1F50D}`,
+      `selector`,
+      selectorKey,
+      `discovers root atom "${dependency.key}"`
+    );
+  } else {
+    const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, 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
+      });
+    }
+  }
+};
+
+// internal/src/selector/register-selector.ts
+var registerSelector = (selectorKey, store) => ({
+  get: (dependency) => {
+    const target = newest(store);
+    const alreadyRegistered = target.selectorGraph.getRelationEntries({ downstreamSelectorKey: selectorKey }).some(([_, { source }]) => source === dependency.key);
+    const dependencyState = withdraw(dependency, store);
+    if (dependencyState === void 0) {
+      throw new Error(
+        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    const dependencyValue = readOrComputeValue(dependencyState, store);
+    store.logger.info(
+      `\u{1F50C}`,
+      `selector`,
+      selectorKey,
+      `registers dependency ( "${dependency.key}" =`,
+      dependencyValue,
+      `)`
+    );
+    if (!alreadyRegistered) {
+      target.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 === void 0) {
+      throw new Error(
+        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      );
+    }
+    setAtomOrSelector(state, newValue, store);
+  }
+});
+
+// internal/src/selector/create-read-write-selector.ts
+var createReadWriteSelector = (options, family, store) => {
+  const target = newest(store);
+  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) => {
+    const oldValue = getSelf();
+    const newValue = become(next)(oldValue);
+    store.logger.info(
+      `\u{1F4DD}`,
+      `selector`,
+      options.key,
+      `set (`,
+      oldValue,
+      `->`,
+      newValue,
+      `)`
+    );
+    cacheValue(options.key, newValue, subject, store);
+    markDone(options.key, store);
+    if (target.transactionMeta === null) {
+      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 });
+  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;
+  }
+  store.subject.selectorCreation.next(token);
+  return token;
+};
+
+// internal/src/selector/create-readonly-selector.ts
+var createReadonlySelector = (options, family, store) => {
+  const target = newest(store);
+  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 });
+  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;
+  }
+  store.subject.selectorCreation.next(token);
+  return token;
+};
+
+// internal/src/selector/create-selector.ts
+function createSelector(options, family, store) {
+  const target = newest(store);
+  const existingWritable = target.selectors.get(options.key);
+  const existingReadonly = target.readonlySelectors.get(options.key);
+  if (existingWritable || existingReadonly) {
+    store.logger.error(
+      `\u274C`,
+      existingReadonly ? `readonly_selector` : `selector`,
+      options.key,
+      `Tried to create selector, but it already exists in the store. (Ignore if you are in development using hot module replacement.)`
+    );
+  }
+  if (`set` in options) {
+    return createReadWriteSelector(options, family, store);
+  }
+  return createReadonlySelector(options, family, store);
+}
+
+// internal/src/selector/delete-selector.ts
+function deleteSelector(selectorToken, store) {
+  const target = newest(store);
+  const { key } = selectorToken;
+  switch (selectorToken.type) {
+    case `selector`:
+      target.selectors.delete(key);
+      break;
+    case `readonly_selector`:
+      target.readonlySelectors.delete(key);
+      break;
+  }
+  target.valueMap.delete(key);
+  target.selectorAtoms.delete(key);
+  const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
+    ([downstreamSelectorKey]) => {
+      var _a;
+      return (_a = target.selectors.get(downstreamSelectorKey)) != null ? _a : target.readonlySelectors.get(downstreamSelectorKey);
+    }
+  );
+  for (const downstreamToken of downstreamTokens) {
+    if (downstreamToken) {
+      deleteSelector(downstreamToken, store);
+    }
+  }
+  target.selectorGraph.delete(key);
+  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
+}
+
+// internal/src/subscribe/recall-state.ts
+var recallState = (state, store) => {
+  const target = newest(store);
+  if (!target.operation.open) {
+    return target.valueMap.get(state.key);
+  }
+  return target.operation.prev.get(state.key);
+};
+
+// internal/src/subscribe/subscribe-to-root-atoms.ts
+var subscribeToRootAtoms = (state, store) => {
+  const dependencySubscriptions = `default` in state ? null : traceAllSelectorAtoms(state.key, store).map((atomKey) => {
+    const atom2 = store.atoms.get(atomKey);
+    if (atom2 === void 0) {
+      throw new Error(
+        `Atom "${atomKey}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
+      );
+    }
+    return atom2.subject.subscribe(
+      `${state.type}:${state.key}`,
+      (atomChange) => {
+        store.logger.info(
+          `\u{1F4E2}`,
+          state.type,
+          state.key,
+          `root`,
+          atomKey,
+          `went`,
+          atomChange.oldValue,
+          `->`,
+          atomChange.newValue
+        );
+        const oldValue = recallState(state, store);
+        const newValue = readOrComputeValue(state, store);
+        store.logger.info(
+          `\u2728`,
+          state.type,
+          state.key,
+          `went`,
+          oldValue,
+          `->`,
+          newValue
+        );
+        state.subject.next({ newValue, oldValue });
+      }
+    );
+  });
+  return dependencySubscriptions;
+};
+
+// internal/src/subscribe/subscribe-to-state.ts
+function subscribeToState(token, handleUpdate, key, store) {
+  const state = withdraw(token, store);
+  if (state === void 0) {
+    throw new Error(
+      `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+    );
+  }
+  const unsubFunction = state.subject.subscribe(key, handleUpdate);
+  store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
+  const dependencyUnsubFunctions = state.type !== `atom` ? subscribeToRootAtoms(state, store) : null;
+  const unsubscribe = dependencyUnsubFunctions === null ? () => {
+    store.logger.info(
+      `\u{1F648}`,
+      state.type,
+      state.key,
+      `Removing subscription "${key}"`
+    );
+    unsubFunction();
+  } : () => {
+    store.logger.info(
+      `\u{1F648}`,
+      state.type,
+      state.key,
+      `Removing subscription "${key}"`
+    );
+    unsubFunction();
+    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);
+  if (tl === void 0) {
+    throw new Error(
+      `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
+    );
+  }
+  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);
+  if (tx === void 0) {
+    throw new Error(
+      `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
+    );
+  }
+  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 {
+  constructor(mutableState, store) {
+    this.unsubscribeFromInnerValue = null;
+    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);
+  }
+  initializeState(mutableState, store) {
+    const latestUpdateStateKey = `*${mutableState.key}`;
+    deleteAtom({ type: `atom`, key: latestUpdateStateKey }, 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) {
+    const originalInnerValue = getState(mutableState, store);
+    const target = newest(store);
+    this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
+      `tracker:${store.config.name}:${target.transactionMeta === null ? `main` : target.transactionMeta.update.key}`,
+      (update) => {
+        const unsubscribe = store.subject.operationStatus.subscribe(
+          mutableState.key,
+          () => {
+            unsubscribe();
+            setState(latestUpdateState, update, store);
+          }
+        );
+      }
+    );
+    subscribeToState(
+      mutableState,
+      (update) => {
+        var _a;
+        if (update.newValue !== update.oldValue) {
+          (_a = this.unsubscribeFromInnerValue) == null ? void 0 : _a.call(this);
+          const target2 = newest(store);
+          this.unsubscribeFromInnerValue = update.newValue.subscribe(
+            `tracker:${store.config.name}:${target2.transactionMeta === null ? `main` : target2.transactionMeta.update.key}`,
+            (update2) => {
+              const unsubscribe = store.subject.operationStatus.subscribe(
+                mutableState.key,
+                () => {
+                  unsubscribe();
+                  setState(latestUpdateState, update2, store);
+                }
+              );
+            }
+          );
+        }
+      },
+      `${store.config.name}: tracker observing inner value`,
+      store
+    );
+  }
+  updateCore(mutableState, latestUpdateState, store) {
+    subscribeToState(
+      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 = subscribeToTimeline(
+              { key: timelineId, type: `timeline` },
+              (update) => {
+                unsubscribe2();
+                setState(
+                  mutableState,
+                  (transceiver) => {
+                    if (update === `redo` && newValue) {
+                      transceiver.do(newValue);
+                    } else if (update === `undo` && oldValue) {
+                      transceiver.undo(oldValue);
+                    }
+                    return transceiver;
+                  },
+                  store
+                );
+              },
+              `${mutableState.key}: tracker observing timeline`,
+              store
+            );
+            return;
+          }
+        }
+        const unsubscribe = store.subject.operationStatus.subscribe(
+          latestUpdateState.key,
+          () => {
+            unsubscribe();
+            const mutable = getState(mutableState, store);
+            const updateNumber = mutable.getUpdateNumber(newValue);
+            const eventOffset = updateNumber - mutable.cacheUpdateNumber;
+            if (newValue && eventOffset === 1) {
+              setState(
+                mutableState,
+                (transceiver) => (transceiver.do(newValue), transceiver),
+                store
+              );
+            }
+          }
+        );
+      },
+      `${store.config.name}: tracker observing latest update`,
+      store
+    );
+  }
+};
+
+// internal/src/mutable/create-mutable-atom.ts
+function createMutableAtom(options, store) {
+  store.logger.info(
+    `\u{1F527}`,
+    `atom`,
+    options.key,
+    `creating in store "${store.config.name}"`
+  );
+  const coreState = createAtom(options, void 0, store);
+  new Tracker(coreState, store);
+  const jsonState = selectJson(coreState, options, store);
+  const target = newest(store);
+  subscribeToState(
+    jsonState,
+    () => {
+      const trackerHasBeenInitialized = newest(store).trackers.has(coreState.key);
+      if (!trackerHasBeenInitialized) {
+        new Tracker(coreState, store);
+      }
+    },
+    `tracker-initializer:${store == null ? void 0 : store.config.name}:${target.transactionMeta === null ? `main` : `${target.transactionMeta.update.key}`}`,
+    store
+  );
+  return coreState;
+}
+
+// internal/src/families/create-atom-family.ts
+function createAtomFamily(options, store) {
+  const subject = new Subject();
+  const atomFamily = Object.assign(
+    (key) => {
+      const subKey = 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 target = newest(store);
+  target.families.set(options.key, atomFamily);
+  return atomFamily;
+}
+
+// internal/src/families/create-readonly-selector-family.ts
+function createReadonlySelectorFamily(options, store) {
+  const subject = new Subject();
+  return Object.assign(
+    (key) => {
+      const target = newest(store);
+      const subKey = stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const existing = target.readonlySelectors.get(fullKey);
+      if (existing) {
+        return deposit(existing);
+      }
+      return createSelector(
+        {
+          key: fullKey,
+          get: options.get(key)
+        },
+        family,
+        store
+      );
+    },
+    {
+      key: options.key,
+      type: `readonly_selector_family`,
+      subject
+    }
+  );
+}
+
+// internal/src/families/create-selector-family.ts
+function createSelectorFamily(options, store) {
+  const isReadonly = !(`set` in options);
+  if (isReadonly) {
+    return createReadonlySelectorFamily(options, store);
+  }
+  const target = newest(store);
+  const subject = new Subject();
+  const selectorFamily = Object.assign(
+    (key) => {
+      const subKey = stringifyJson(key);
+      const family = { key: options.key, subKey };
+      const fullKey = `${options.key}(${subKey})`;
+      const existing = target.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`
+    }
+  );
+  target.families.set(options.key, selectorFamily);
+  return selectorFamily;
+}
+
+// internal/src/mutable/tracker-family.ts
+var FamilyTracker = class {
+  constructor(findMutableState, 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 = 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 = parseJson(atomToken.family.subKey);
+          const mutableAtomToken = this.findMutableState(key);
+          new Tracker(mutableAtomToken, store);
+        }
+      }
+    );
+  }
+};
+
+// internal/src/mutable/create-mutable-atom-family.ts
+function createMutableAtomFamily(options, store) {
+  const coreFamily = Object.assign(
+    createAtomFamily(options, store),
+    options
+  );
+  selectJsonFamily(coreFamily, options);
+  new FamilyTracker(coreFamily, store);
+  return coreFamily;
+}
+
+// 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/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-atom.ts
+function createAtom(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) {
+    store.logger.error(
+      `\u274C`,
+      `atom`,
+      options.key,
+      `Tried to create atom, but it already exists in the store.`,
+      `(Ignore if you are in development using hot module replacement.)`
+    );
+    return deposit(existing);
+  }
+  const subject = new Subject();
+  const newAtom = __spreadValues(__spreadProps(__spreadValues({}, options), {
+    type: `atom`,
+    install: (store2) => {
+      store2.logger.info(
+        `\u{1F6E0}\uFE0F`,
+        `atom`,
+        options.key,
+        `installing in store "${store2.config.name}"`
+      );
+      return `mutable` in options ? createMutableAtom(options, store2) : createAtom(options, void 0, store2);
+    },
+    subject
+  }), 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, store);
+  const token = deposit(newAtom);
+  if (options.effects) {
+    let effectIndex = 0;
+    const cleanupFunctions = [];
+    for (const effect of options.effects) {
+      const cleanup = effect({
+        setSelf: (next) => setState(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();
+      }
+    };
+  }
+  store.subject.atomCreation.next(token);
+  return token;
+}
+
+// internal/src/atom/delete-atom.ts
+function deleteAtom(atomToken, store) {
+  var _a, _b;
+  const target = newest(store);
+  const { key } = atomToken;
+  const atom2 = target.atoms.get(key);
+  if (!atom2) {
+    store.logger.error(
+      `\u274C`,
+      `atom`,
+      `${key}`,
+      `Tried to delete atom, but it does not exist in the store.`
+    );
+  }
+  (_a = atom2 == null ? void 0 : atom2.cleanup) == null ? void 0 : _a.call(atom2);
+  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) {
+        deleteSelector(token, store);
+      }
+    }
+  }
+  target.selectorAtoms.delete(key);
+  target.atomsThatAreDefault.delete(key);
+  target.timelineAtoms.delete(key);
+  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
+}
+
+// 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/not-found-error.ts
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+function prettyPrintTokenType(token) {
+  if (token.type === `readonly_selector`) {
+    return `Readonly Selector`;
+  }
+  return capitalize(token.type);
+}
+var NotFoundError = class extends Error {
+  constructor(token, store) {
+    super(
+      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
+    );
+  }
+};
+
+// internal/src/timeline/add-atom-to-timeline.ts
+var addAtomToTimeline = (atomToken, tl, store) => {
+  const atom2 = withdraw(atomToken, store);
+  if (atom2 === void 0) {
+    throw new Error(
+      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
+    );
+  }
+  atom2.subject.subscribe(`timeline`, (update) => {
+    var _a, _b, _c, _d, _e, _f;
+    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 currentTransactionKey = (_a = target.subject.transactionApplying.state) == null ? void 0 : _a.update.key;
+    const currentTransactionTime = (_b = target.subject.transactionApplying.state) == null ? void 0 : _b.time;
+    store.logger.info(
+      `\u23F3`,
+      `timeline`,
+      tl.key,
+      `atom`,
+      atomToken.key,
+      `went`,
+      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) {
+        const currentTransaction = withdraw(
+          { key: currentTransactionKey, type: `transaction` },
+          store
+        );
+        if (currentTransaction === void 0) {
+          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) {
+            store.logger.error(
+              `\u{1F41E}`,
+              `timeline`,
+              tl.key,
+              `unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`
+            );
+          }
+          tl.transactionKey = currentTransactionKey;
+          const unsubscribe = currentTransaction.subject.subscribe(
+            `timeline:${tl.key}`,
+            (update2) => {
+              var _a2, _b2;
+              unsubscribe();
+              if (tl.timeTraveling === null && currentTransactionTime) {
+                if (tl.at !== tl.history.length) {
+                  tl.history.splice(tl.at);
+                }
+                const filterUpdates = (updates2) => updates2.filter((updateFromTx) => {
+                  const target2 = newest(store);
+                  if (`updates` in updateFromTx) {
+                    return true;
+                  }
+                  const atomOrFamilyKeys = target2.timelineAtoms.getRelatedKeys(tl.key);
+                  return atomOrFamilyKeys ? [...atomOrFamilyKeys].some(
+                    (key) => {
+                      var _a3;
+                      return key === updateFromTx.key || key === ((_a3 = updateFromTx.family) == null ? void 0 : _a3.key);
+                    }
+                  ) : false;
+                }).map((updateFromTx) => {
+                  if (`updates` in updateFromTx) {
+                    return __spreadProps(__spreadValues({}, updateFromTx), {
+                      updates: filterUpdates(updateFromTx.updates)
+                    });
+                  }
+                  return updateFromTx;
+                });
+                const updates = filterUpdates(update2.updates);
+                const timelineTransactionUpdate = __spreadProps(__spreadValues({
+                  type: `transaction_update`,
+                  timestamp: currentTransactionTime
+                }, update2), {
+                  updates
+                });
+                const willCapture = (_b2 = (_a2 = tl.shouldCapture) == null ? void 0 : _a2.call(tl, timelineTransactionUpdate, tl)) != null ? _b2 : true;
+                if (willCapture) {
+                  tl.history.push(timelineTransactionUpdate);
+                  tl.at = tl.history.length;
+                  tl.subject.next(timelineTransactionUpdate);
+                }
+              }
+              tl.transactionKey = null;
+              store.logger.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: atom2.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: atom2.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 = (_d = (_c = tl.shouldCapture) == null ? void 0 : _c.call(tl, latestUpdate, tl)) != null ? _d : 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: atom2.key,
+          oldValue: update.oldValue,
+          newValue: update.newValue
+        };
+        if (atom2.family) {
+          atomUpdate.family = atom2.family;
+        }
+        const willCapture = (_f = (_e = tl.shouldCapture) == null ? void 0 : _e.call(tl, atomUpdate, tl)) != null ? _f : true;
+        store.logger.info(
+          `\u231B`,
+          `timeline`,
+          tl.key,
+          `got an atom_update to "${atom2.key}"`
+        );
+        if (willCapture) {
+          tl.history.push(atomUpdate);
+          tl.at = tl.history.length;
+          tl.subject.next(atomUpdate);
+        }
+      }
+    }
+  });
+};
+
+// internal/src/timeline/create-timeline.ts
+function createTimeline(options, store, data) {
+  var _a, _b;
+  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) => createTimeline(options, store2, tl),
+    subject: new Subject()
+  });
+  if (options.shouldCapture) {
+    tl.shouldCapture = options.shouldCapture;
+  }
+  const target = newest(store);
+  for (const tokenOrFamily of options.atoms) {
+    const timelineKey = target.timelineAtoms.getRelatedKey(tokenOrFamily.key);
+    if (timelineKey) {
+      store.logger.error(
+        `\u274C`,
+        `timeline`,
+        options.key,
+        `Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`
+      );
+      continue;
+    }
+    if (tokenOrFamily.type === `atom_family`) {
+      const family = tokenOrFamily;
+      family.subject.subscribe(`timeline:${options.key}`, (token2) => {
+        addAtomToTimeline(token2, tl, store);
+      });
+      for (const atom2 of target.atoms.values()) {
+        if (((_b = atom2.family) == null ? void 0 : _b.key) === family.key) {
+          addAtomToTimeline(atom2, tl, store);
+        }
+      }
+    } else {
+      const token2 = tokenOrFamily;
+      if (`family` in token2 && token2.family) {
+        const familyTimelineKey = target.timelineAtoms.getRelatedKey(
+          token2.family.key
+        );
+        if (familyTimelineKey) {
+          store.logger.error(
+            `\u274C`,
+            `timeline`,
+            options.key,
+            `Failed to add atom "${token2.key}" because its family "${token2.family.key}" already belongs to timeline "${familyTimelineKey}"`
+          );
+          continue;
+        }
+      }
+      addAtomToTimeline(token2, tl, store);
+    }
+    target.timelineAtoms = target.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;
+}
+
+// internal/src/timeline/time-travel.ts
+var timeTravel = (direction, token, store) => {
+  const action = direction === `forward` ? `redo` : `undo`;
+  store.logger.info(
+    direction === `forward` ? `\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 (direction === `forward` && timelineData.at === timelineData.history.length || direction === `backward` && timelineData.at === 0) {
+    store.logger.warn(
+      `\u{1F481}`,
+      `timeline`,
+      token.key,
+      `Failed to ${action} at the ${direction === `forward` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`
+    );
+    return;
+  }
+  timelineData.timeTraveling = direction === `forward` ? `into_future` : `into_past`;
+  if (direction === `backward`) {
+    --timelineData.at;
+  }
+  const update = timelineData.history[timelineData.at];
+  const updateValues = (atomUpdate) => {
+    const { key, newValue, oldValue } = atomUpdate;
+    const value = direction === `forward` ? newValue : oldValue;
+    setState({ key, type: `atom` }, value, store);
+  };
+  const updateValuesFromTransactionUpdate = (transactionUpdate) => {
+    const updates = direction === `forward` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
+    for (const updateFromTransaction of updates) {
+      if (`newValue` in updateFromTransaction) {
+        updateValues(updateFromTransaction);
+      } else {
+        updateValuesFromTransactionUpdate(updateFromTransaction);
+      }
+    }
+  };
+  switch (update.type) {
+    case `atom_update`: {
+      updateValues(update);
+      break;
+    }
+    case `selector_update`: {
+      const updates = direction === `forward` ? update.atomUpdates : [...update.atomUpdates].reverse();
+      for (const atomUpdate of updates) {
+        updateValues(atomUpdate);
+      }
+      break;
+    }
+    case `transaction_update`: {
+      updateValuesFromTransactionUpdate(update);
+      break;
+    }
+  }
+  if (direction === `forward`) {
+    ++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}`
+  );
+};
+
+// internal/src/transaction/abort-transaction.ts
+var abortTransaction = (store) => {
+  const target = newest(store);
+  if (target.transactionMeta === null || target.parent === null) {
+    store.logger.warn(
+      `\u{1F41E}`,
+      `transaction`,
+      `???`,
+      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
+    );
+    return;
+  }
+  store.logger.info(
+    `\u{1FA82}`,
+    `transaction`,
+    target.transactionMeta.update.key,
+    `Aborting transaction`
+  );
+  target.parent.child = null;
+};
+
+// internal/src/transaction/apply-transaction.ts
+function ingestAtomUpdate(update, parent, child) {
+  var _a, _b, _c;
+  const { key, newValue } = update;
+  const token = { key, type: `atom` };
+  if (!parent.valueMap.has(token.key)) {
+    if (token.family) {
+      const family = parent.families.get(token.family.key);
+      if (family) {
+        family(token.family.subKey);
+      }
+    } else {
+      const newAtom = child.atoms.get(token.key);
+      if (!newAtom) {
+        throw new Error(
+          `Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${(_a = child.transactionMeta) == null ? void 0 : _a.update.key}" to store "${parent.config.name}"`
+        );
+      }
+      parent.atoms.set(newAtom.key, newAtom);
+      parent.valueMap.set(newAtom.key, newAtom.default);
+      parent.logger.info(
+        `\u{1F528}`,
+        `transaction`,
+        (_c = (_b = child.transactionMeta) == null ? void 0 : _b.update.key) != null ? _c : `???`,
+        `Adding atom "${newAtom.key}"`
+      );
+    }
+  }
+  setState(token, newValue, parent);
+}
+function ingestTransactionUpdate(transactionUpdate, parent, child) {
+  for (const update of transactionUpdate.updates) {
+    if (`newValue` in update) {
+      ingestAtomUpdate(update, parent, child);
+    } else {
+      ingestTransactionUpdate(update, parent, child);
+    }
+  }
+}
+var applyTransaction = (output, store) => {
+  var _a;
+  const child = newest(store);
+  const { parent } = child;
+  if (parent === null || child.transactionMeta === null || ((_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.subject.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
+  );
+  if (parent.transactionMeta === null) {
+    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
+    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 {
+    ingestTransactionUpdate(child.transactionMeta.update, parent, child);
+    parent.transactionMeta.update.updates.push(child.transactionMeta.update);
+  }
+  parent.subject.transactionApplying.next(null);
+};
+
+// internal/src/transaction/build-transaction.ts
+var buildTransaction = (key, params, store) => {
+  const parent = newest(store);
+  parent.child = {
+    parent,
+    child: null,
+    subject: parent.subject,
+    loggers: parent.loggers,
+    logger: parent.logger,
+    config: parent.config,
+    transactionMeta: {
+      phase: `building`,
+      time: Date.now(),
+      update: {
+        key,
+        updates: [],
+        params,
+        output: void 0
+      }
+    },
+    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),
+    timelineAtoms: new Junction(parent.timelineAtoms.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)
+  };
+  store.logger.info(
+    `\u{1F6EB}`,
+    `transaction`,
+    key,
+    `Building transaction with params:`,
+    params
+  );
+};
+
+// internal/src/transaction/create-transaction.ts
+function createTransaction(options, store) {
+  const newTransaction = {
+    key: options.key,
+    type: `transaction`,
+    run: (...params) => {
+      buildTransaction(options.key, params, store);
+      try {
+        const output = options.do(
+          {
+            get: (token2) => getState(token2, store),
+            set: (token2, value) => setState(token2, value, store),
+            run: (token2) => runTransaction(token2, store)
+          },
+          ...params
+        );
+        applyTransaction(output, store);
+        return output;
+      } catch (thrown) {
+        abortTransaction(store);
+        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
+        throw thrown;
+      }
+    },
+    install: (store2) => createTransaction(options, store2),
+    subject: new Subject()
+  };
+  const target = newest(store);
+  target.transactions.set(newTransaction.key, newTransaction);
+  const token = deposit(newTransaction);
+  store.subject.transactionCreation.next(token);
+  return token;
+}
+
+// src/atom.ts
+function atom(options) {
+  if (`mutable` in options) {
+    return createMutableAtom(options, IMPLICIT.STORE);
+  }
+  return createAtom(options, void 0, IMPLICIT.STORE);
+}
+
+// src/get-state.ts
+function getState(token, store = IMPLICIT.STORE) {
+  var _a;
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  return readOrComputeValue(state, store);
+}
+
+// src/logger.ts
+var simpleLog = (logLevel) => (icon, tokenType, tokenKey, message, ...rest) => {
+  console[logLevel](`${icon} ${tokenType} "${tokenKey}" ${message}`, ...rest);
+};
+var simpleLogger = {
+  error: simpleLog(`error`),
+  info: simpleLog(`info`),
+  warn: simpleLog(`warn`)
+};
+var AtomIOLogger = class {
+  constructor(logLevel, filter, logger = simpleLogger) {
+    this.logLevel = logLevel;
+    this.filter = filter;
+    this.logger = logger;
+    this.error = (...args) => {
+      var _a, _b;
+      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== null) {
+        this.logger.error(...args);
+      }
+    };
+    this.info = (...args) => {
+      var _a, _b;
+      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel === `info`) {
+        this.logger.info(...args);
+      }
+    };
+    this.warn = (...args) => {
+      var _a, _b;
+      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== `error` && this.logLevel !== null) {
+        this.logger.warn(...args);
+      }
+    };
+  }
+};
+
+// src/selector.ts
+function selector(options) {
+  return createSelector(options, void 0, IMPLICIT.STORE);
+}
+
+// src/set-state.ts
+function setState(token, value, store = IMPLICIT.STORE) {
+  var _a;
+  const rejection = openOperation(token, store);
+  if (rejection) {
+    return;
+  }
+  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
+// src/silo.ts
+var Silo = class {
+  constructor(name, fromStore = null) {
+    const s = new Store(name, fromStore);
+    this.store = s;
+    this.atom = (options) => {
+      if (`mutable` in options) {
+        return createMutableAtom(options, s);
+      }
+      return createAtom(options, void 0, s);
+    };
+    this.atomFamily = (options) => {
+      if (`mutable` in options) {
+        return createMutableAtomFamily(options, s);
+      }
+      return createAtomFamily(options, s);
+    };
+    this.selector = (options) => createSelector(options, void 0, s);
+    this.selectorFamily = (options) => createSelectorFamily(options, s);
+    this.transaction = (options) => createTransaction(options, s);
+    this.timeline = (options) => createTimeline(options, s);
+    this.getState = (token) => getState(token, s);
+    this.setState = (token, newValue) => setState(token, newValue, s);
+    this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
+    this.undo = (token) => timeTravel(`backward`, token, s);
+    this.redo = (token) => timeTravel(`forward`, token, s);
+  }
+};
+
+// src/subscribe.ts
+function subscribe(token, handleUpdate, key = Math.random().toString(36).slice(2), store = IMPLICIT.STORE) {
+  switch (token.type) {
+    case `atom`:
+    case `readonly_selector`:
+    case `selector`:
+      return subscribeToState(token, handleUpdate, key, store);
+    case `transaction`:
+      return subscribeToTransaction(token, handleUpdate, key, store);
+    case `timeline`:
+      return subscribeToTimeline(token, handleUpdate, key, store);
+  }
+}
+
+// src/transaction.ts
+var runTransaction = (token, store = IMPLICIT.STORE) => (...parameters) => {
+  const tx = withdraw(token, store);
+  if (tx) {
+    return tx.run(...parameters);
+  }
+  throw new Error(
+    `Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`
+  );
+};
+var StoreContext = React2__namespace.createContext(IMPLICIT.STORE);
+var StoreProvider = ({ children, store = IMPLICIT.STORE }) => /* @__PURE__ */ jsxRuntime.jsx(StoreContext.Provider, { value: store, children });
+function useI(token) {
+  const store = React2__namespace.useContext(StoreContext);
+  const setter = React2__namespace.useRef(null);
+  if (setter.current === null) {
+    setter.current = (next) => setState(token, next, store);
+  }
+  return setter.current;
+}
+
+// realtime-client/src/realtime-state.ts
+var myIdState__INTERNAL = atom({
+  key: `myId__INTERNAL`,
+  default: null
+});
+selector({
+  key: `myId`,
+  get: ({ get }) => get(myIdState__INTERNAL)
+});
+var RealtimeContext = React2__namespace.createContext({
+  socket: socket_ioClient.io()
+});
+var RealtimeProvider = ({ children, socket }) => {
+  const setMyId = useI(myIdState__INTERNAL);
+  React2__namespace.useEffect(() => {
+    socket.on(`connect`, () => {
+      setMyId(socket.id);
+    });
+    socket.on(`disconnect`, () => {
+      setMyId(null);
+    });
+  }, [socket, setMyId]);
+  return /* @__PURE__ */ jsxRuntime.jsx(RealtimeContext.Provider, { value: { socket }, children });
+};
+
+// ../anvl/src/object/entries.ts
 var recordToEntries = (obj) => Object.entries(obj);
 var setupRealtimeTestServer = (options) => {
   const httpServer = http__namespace.createServer((_, res) => res.end(`Hello World!`));
@@ -66,13 +2402,13 @@ var setupRealtimeTestServer = (options) => {
   if (port === null)
     throw new Error(`Could not determine port for test server`);
   const server = new SocketIO__namespace.Server(httpServer);
-  const silo = new AtomIO__namespace.Silo(`SERVER`, Internal__namespace.IMPLICIT.STORE);
+  const silo = new Silo(`SERVER`, IMPLICIT.STORE);
   server.on(`connection`, (socket) => {
     options.server({ socket, silo });
   });
   const dispose = () => {
     server.close();
-    Internal__namespace.clearStore(silo.store);
+    clearStore(silo.store);
   };
   return {
     name: `SERVER`,
@@ -83,11 +2419,11 @@ var setupRealtimeTestServer = (options) => {
 };
 var setupRealtimeTestClient = (options, name, port) => {
   const socket = socket_ioClient.io(`http://localhost:${port}/`);
-  const silo = new AtomIO__namespace.Silo(name, Internal__namespace.IMPLICIT.STORE);
+  const silo = new Silo(name, IMPLICIT.STORE);
   const { document } = new Happy__namespace.Window();
   document.body.innerHTML = `<div id="app"></div>`;
   const renderResult = react.render(
-    /* @__PURE__ */ jsxRuntime.jsx(AR__namespace.StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsxRuntime.jsx(RTC__namespace.RealtimeProvider, { socket, children: /* @__PURE__ */ jsxRuntime.jsx(options.client, {}) }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsxRuntime.jsx(RealtimeProvider, { socket, children: /* @__PURE__ */ jsxRuntime.jsx(options.client, {}) }) }),
     {
       container: document.querySelector(`#app`)
     }
@@ -97,7 +2433,7 @@ var setupRealtimeTestClient = (options, name, port) => {
   const reconnect = () => socket.connect();
   const dispose = () => {
     socket.disconnect();
-    Internal__namespace.clearStore(silo.store);
+    clearStore(silo.store);
   };
   return {
     name,