atom.io 0.14.0 → 0.14.2

package/react-devtools/dist/index.cjs

@@ -1,67 +1,2097 @@
 'use strict';
 
-var atom_io = require('atom.io');
-var introspection = require('atom.io/introspection');
-var react = require('atom.io/react');
-var framerMotion = require('framer-motion');
-var React = require('react');
+var React2 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
-var react$1 = require('@floating-ui/react');
+var framerMotion = require('framer-motion');
+var react = require('@floating-ui/react');
+
+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 React2__namespace = /*#__PURE__*/_interopNamespace(React2);
+
+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 = (a2, b2) => {
+  for (var prop in b2 || (b2 = {}))
+    if (__hasOwnProp.call(b2, prop))
+      __defNormalProp(a2, prop, b2[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b2)) {
+      if (__propIsEnum.call(b2, prop))
+        __defNormalProp(a2, prop, b2[prop]);
+    }
+  return a2;
+};
+var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
+var __restKey = (key) => typeof key === "symbol" ? key : key + "";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// internal/src/future.ts
+var Future = class extends Promise {
+  constructor(executor) {
+    super((resolve, reject) => {
+      const pass2 = (value) => this.isCanceled ? reject(`canceled`) : resolve(value);
+      const fail = (reason) => this.isCanceled ? reject(`canceled`) : reject(reason);
+      if (typeof executor === `function`) {
+        executor(pass2, fail);
+      } else {
+        executor.then(pass2, 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);
+var JSON_TYPE_NAMES = [
+  `array`,
+  `boolean`,
+  `null`,
+  `number`,
+  `object`,
+  `string`
+];
+var JSON_DEFAULTS = {
+  array: [],
+  boolean: false,
+  null: null,
+  number: 0,
+  object: {},
+  string: ``
+};
+
+// ../anvl/src/primitive/index.ts
+var isString = (input) => {
+  return typeof input === `string`;
+};
+var isNumber = (input) => {
+  return typeof input === `number`;
+};
+var isBoolean = (input) => {
+  return typeof input === `boolean`;
+};
+
+// 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 = (atomFamily2, transform, store = IMPLICIT.STORE) => {
+  const jsonFamily = createSelectorFamily(
+    {
+      key: `${atomFamily2.key}:JSON`,
+      get: (key) => ({ get }) => transform.toJson(get(atomFamily2(key))),
+      set: (key) => ({ set }, newValue) => set(atomFamily2(key), transform.fromJson(newValue))
+    },
+    store
+  );
+  atomFamily2.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 fallback2 = state.default instanceof Function ? state.default() : state.default;
+  store.logger.info(
+    `\u{1F481}`,
+    `atom`,
+    state.key,
+    `could not find cached value; using default`,
+    fallback2
+  );
+  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) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
+      subscriber(value);
+    }
+  }
+};
+var StatefulSubject = class extends Subject {
+  constructor(initialState) {
+    super();
+    this.state = initialState;
+  }
+  next(value) {
+    this.state = value;
+    super.next(value);
+  }
+};
+
+// internal/src/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 = (a2, b2) => `${a2}:${b2}`;
+    var _a2, _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((_a2 = data.relations) == null ? void 0 : _a2.map(([a2, b2]) => [a2, new Set(b2)]));
+      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 = (a2, b2) => externalStore.has(a2, b2);
+      this.addRelation = (a2, b2) => {
+        externalStore.addRelation(a2, b2);
+      };
+      this.deleteRelation = (a2, b2) => {
+        externalStore.deleteRelation(a2, b2);
+      };
+      this.replaceRelationsSafely = (a2, bs) => {
+        externalStore.replaceRelationsSafely(a2, bs);
+      };
+      this.replaceRelationsUnsafely = (a2, bs) => {
+        externalStore.replaceRelationsUnsafely(a2, 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(a2, b2) {
+    let aRelations = this.relations.get(a2);
+    let bRelations = this.relations.get(b2);
+    if (aRelations) {
+      aRelations.add(b2);
+    } else {
+      aRelations = /* @__PURE__ */ new Set([b2]);
+      this.relations.set(a2, aRelations);
+    }
+    if (bRelations) {
+      bRelations.add(a2);
+    } else {
+      bRelations = /* @__PURE__ */ new Set([a2]);
+      this.relations.set(b2, bRelations);
+    }
+  }
+  deleteRelation(a2, b2) {
+    const aRelations = this.relations.get(a2);
+    if (aRelations) {
+      aRelations.delete(b2);
+      if (aRelations.size === 0) {
+        this.relations.delete(a2);
+      }
+      const bRelations = this.relations.get(b2);
+      if (bRelations) {
+        bRelations.delete(a2);
+        if (bRelations.size === 0) {
+          this.relations.delete(b2);
+        }
+      }
+    }
+  }
+  replaceRelationsUnsafely(a2, bs) {
+    this.relations.set(a2, new Set(bs));
+    for (const b2 of bs) {
+      const bRelations = /* @__PURE__ */ new Set([a2]);
+      this.relations.set(b2, bRelations);
+    }
+  }
+  replaceRelationsSafely(a2, bs) {
+    const aRelationsPrev = this.relations.get(a2);
+    if (aRelationsPrev) {
+      for (const b2 of aRelationsPrev) {
+        const bRelations = this.relations.get(b2);
+        if (bRelations) {
+          if (bRelations.size === 1) {
+            this.relations.delete(b2);
+          } else {
+            bRelations.delete(a2);
+          }
+          this.contents.delete(this.makeContentKey(a2, b2));
+        }
+      }
+    }
+    this.relations.set(a2, new Set(bs));
+    for (const b2 of bs) {
+      let bRelations = this.relations.get(b2);
+      if (bRelations) {
+        bRelations.add(a2);
+      } else {
+        bRelations = /* @__PURE__ */ new Set([a2]);
+        this.relations.set(b2, 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(([a2, b2]) => [a2, [...b2]]),
+      contents: [...this.contents.entries()]
+    };
+  }
+  set(a2, ...rest) {
+    var _a2;
+    const b2 = typeof rest[0] === `string` ? rest[0] : a2[this.b];
+    const content = ((_a2 = rest[1]) != null ? _a2 : typeof rest[0] === `string`) ? void 0 : rest[0];
+    a2 = typeof a2 === `string` ? a2 : a2[this.a];
+    switch (this.cardinality) {
+      case `1:1`: {
+        const bPrev = this.getRelatedKey(a2);
+        if (bPrev && bPrev !== b2)
+          this.delete(bPrev, a2);
+      }
+      case `1:n`: {
+        const aPrev = this.getRelatedKey(b2);
+        if (aPrev && aPrev !== a2)
+          this.delete(aPrev, b2);
+      }
+    }
+    if (content) {
+      const contentKey = this.makeContentKey(a2, b2);
+      this.setContent(contentKey, content);
+    }
+    this.addRelation(a2, b2);
+    return this;
+  }
+  delete(x, b2) {
+    b2 = typeof b2 === `string` ? b2 : x[this.b];
+    const a2 = typeof x === `string` ? x : x[this.a];
+    if (a2 === void 0 && typeof b2 === `string`) {
+      const bRelations = this.getRelatedKeys(b2);
+      if (bRelations) {
+        for (const a3 of bRelations) {
+          this.delete(a3, b2);
+        }
+      }
+    }
+    if (typeof a2 === `string` && b2 === void 0) {
+      const aRelations = this.getRelatedKeys(a2);
+      if (aRelations) {
+        for (const b3 of aRelations) {
+          this.delete(a2, b3);
+        }
+      }
+    }
+    if (typeof a2 === `string` && typeof b2 === `string`) {
+      this.deleteRelation(a2, b2);
+      const contentKey = this.makeContentKey(a2, b2);
+      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(a2, relations, config) {
+    const hasContent = !Array.isArray(relations);
+    const bs = hasContent ? Object.keys(relations) : relations;
+    if (config == null ? void 0 : config.reckless) {
+      this.replaceRelationsUnsafely(a2, bs);
+    } else {
+      this.replaceRelationsSafely(a2, bs);
+    }
+    if (hasContent) {
+      for (const b2 of bs) {
+        const contentKey = this.makeContentKey(a2, b2);
+        const content = relations[b2];
+        this.setContent(contentKey, content);
+      }
+    }
+    return this;
+  }
+  getContent(a2, b2) {
+    const contentKey = this.makeContentKey(a2, b2);
+    return this.getContentInternal(contentKey);
+  }
+  getRelationEntries(input) {
+    const a2 = input[this.a];
+    const b2 = input[this.b];
+    if (a2 !== void 0 && b2 === void 0) {
+      const aRelations = this.getRelatedKeys(a2);
+      if (aRelations) {
+        return [...aRelations].map((b3) => {
+          var _a2;
+          return [b3, (_a2 = this.getContent(a2, b3)) != null ? _a2 : null];
+        });
+      }
+    }
+    if (a2 === void 0 && b2 !== void 0) {
+      const bRelations = this.getRelatedKeys(b2);
+      if (bRelations) {
+        return [...bRelations].map((a3) => {
+          var _a2;
+          return [a3, (_a2 = this.getContent(a3, b2)) != null ? _a2 : null];
+        });
+      }
+    }
+    return [];
+  }
+  has(a2, b2) {
+    var _a2;
+    if (b2) {
+      const setA = this.getRelatedKeys(a2);
+      return (_a2 = setA == null ? void 0 : setA.has(b2)) != null ? _a2 : false;
+    }
+    return this.relations.has(a2);
+  }
+};
+
+// 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 [, selector] of store.readonlySelectors) {
+        selector.install(this);
+      }
+      for (const [, selector] of store.selectors) {
+        selector.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 _a2;
+    return (_a2 = this.STORE_INTERNAL) != null ? _a2 : this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`);
+  }
+};
+
+// internal/src/store/withdraw.ts
+function withdraw(token, store) {
+  var _a2, _b, _c, _d;
+  const target = newest(store);
+  const state = (_d = (_c = (_b = (_a2 = target.atoms.get(token.key)) != null ? _a2 : 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/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/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}`;
+    store.atoms.delete(latestUpdateStateKey);
+    store.valueMap.delete(latestUpdateStateKey);
+    const familyMetaData = mutableState.family ? {
+      key: `*${mutableState.family.key}`,
+      subKey: mutableState.family.subKey
+    } : void 0;
+    const latestUpdateState = createAtom(
+      {
+        key: latestUpdateStateKey,
+        default: null
+      },
+      familyMetaData,
+      store
+    );
+    if (store.parent) {
+      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
+      store.valueMap.set(latestUpdateStateKey, parentValue);
+    }
+    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 _a2;
+        if (update.newValue !== update.oldValue) {
+          (_a2 = this.unsubscribeFromInnerValue) == null ? void 0 : _a2.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 = newValue === null ? -1 : 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 atomFamily2 = 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
+    }
+  );
+  if (`mutable` in options && typeof options.mutable === `boolean`) {
+    Object.assign(atomFamily2, { mutable: options.mutable });
+  }
+  const target = newest(store);
+  target.families.set(options.key, atomFamily2);
+  return atomFamily2;
+}
+
+// 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
+    }
+  );
+}
 
-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]; }
-        });
+// 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 selectorFamily2 = 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, selectorFamily2);
+  return selectorFamily2;
+}
+
+// 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);
+        }
+      }
+    );
   }
-  n.default = e;
-  return Object.freeze(n);
+};
+
+// 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;
 }
 
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
+// internal/src/mutable/transceiver.ts
+function isTransceiver(value) {
+  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+}
 
-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 = (a2, b2) => {
-  for (var prop in b2 || (b2 = {}))
-    if (__hasOwnProp.call(b2, prop))
-      __defNormalProp(a2, prop, b2[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b2)) {
-      if (__propIsEnum.call(b2, prop))
-        __defNormalProp(a2, prop, b2[prop]);
+// 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;
     }
-  return a2;
+    newAtom.cleanup = () => {
+      for (const cleanup of cleanupFunctions) {
+        cleanup();
+      }
+    };
+  }
+  store.subject.atomCreation.next(token);
+  return token;
+}
+
+// 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}".`
+    );
+  }
 };
-var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
-var __restKey = (key) => typeof key === "symbol" ? key : key + "";
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
+
+// 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);
+      }
     }
-  return target;
+  };
+  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}`
+  );
+};
+
+// src/atom.ts
+function atom(options) {
+  if (`mutable` in options) {
+    return createMutableAtom(options, IMPLICIT.STORE);
+  }
+  return createAtom(options, void 0, IMPLICIT.STORE);
+}
+function atomFamily(options) {
+  if (`mutable` in options) {
+    return createMutableAtomFamily(options, IMPLICIT.STORE);
+  }
+  return createAtomFamily(options, IMPLICIT.STORE);
+}
+
+// src/get-state.ts
+function getState(token, store = IMPLICIT.STORE) {
+  var _a2;
+  const state = (_a2 = withdraw(token, store)) != null ? _a2 : 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 _a2, _b;
+      if (((_b = (_a2 = this.filter) == null ? void 0 : _a2.call(this, ...args)) != null ? _b : true) && this.logLevel !== null) {
+        this.logger.error(...args);
+      }
+    };
+    this.info = (...args) => {
+      var _a2, _b;
+      if (((_b = (_a2 = this.filter) == null ? void 0 : _a2.call(this, ...args)) != null ? _b : true) && this.logLevel === `info`) {
+        this.logger.info(...args);
+      }
+    };
+    this.warn = (...args) => {
+      var _a2, _b;
+      if (((_b = (_a2 = this.filter) == null ? void 0 : _a2.call(this, ...args)) != null ? _b : true) && this.logLevel !== `error` && this.logLevel !== null) {
+        this.logger.warn(...args);
+      }
+    };
+  }
+};
+
+// src/selector.ts
+function selectorFamily(options) {
+  return createSelectorFamily(options, IMPLICIT.STORE);
+}
+
+// src/set-state.ts
+function setState(token, value, store = IMPLICIT.STORE) {
+  var _a2;
+  const rejection = openOperation(token, store);
+  if (rejection) {
+    return;
+  }
+  const state = (_a2 = withdraw(token, store)) != null ? _a2 : withdrawNewFamilyMember(token, store);
+  if (state === void 0) {
+    throw new NotFoundError(token, store);
+  }
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
+// src/timeline.ts
+var redo = (timeline) => {
+  timeTravel(`forward`, timeline, IMPLICIT.STORE);
+};
+var undo = (timeline) => {
+  timeTravel(`backward`, timeline, IMPLICIT.STORE);
+};
+
+// introspection/src/attach-atom-index.ts
+var attachAtomIndex = (store = IMPLICIT.STORE) => {
+  const atomTokenIndexState__INTERNAL = createAtom(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
+      default: () => {
+        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key]) => {
+          acc[key] = { key, type: `atom` };
+          return acc;
+        }, {});
+        return defaultAtomIndex;
+      },
+      effects: [
+        ({ setSelf }) => {
+          store.subject.atomCreation.subscribe(`introspection`, (atomToken) => {
+            if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+              return;
+            }
+            const set = () => setSelf((state) => {
+              const { key, family } = atomToken;
+              if (family) {
+                const { key: familyKey, subKey } = family;
+                const current = state[familyKey];
+                if (current === void 0 || `familyMembers` in current) {
+                  const familyKeyState = current || {
+                    key: familyKey,
+                    familyMembers: {}
+                  };
+                  return __spreadProps(__spreadValues({}, state), {
+                    [familyKey]: __spreadProps(__spreadValues({}, familyKeyState), {
+                      familyMembers: __spreadProps(__spreadValues({}, familyKeyState.familyMembers), {
+                        [subKey]: atomToken
+                      })
+                    })
+                  });
+                }
+              }
+              return __spreadProps(__spreadValues({}, state), {
+                [key]: atomToken
+              });
+            });
+            if (newest(store).operation.open) {
+              const unsubscribe = store.subject.operationStatus.subscribe(
+                `introspection: waiting to update atom index`,
+                () => {
+                  unsubscribe();
+                  set();
+                }
+              );
+            } else {
+              set();
+            }
+          });
+        }
+      ]
+    },
+    void 0,
+    store
+  );
+  return createSelector(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index`,
+      get: ({ get }) => get(atomTokenIndexState__INTERNAL)
+    },
+    void 0,
+    store
+  );
+};
+
+// introspection/src/attach-selector-index.ts
+var attachSelectorIndex = (store = IMPLICIT.STORE) => {
+  const readonlySelectorTokenIndexState__INTERNAL = createAtom(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index (Internal)`,
+      default: () => Object.assign(
+        [...store.readonlySelectors].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key]) => {
+          acc[key] = { key, type: `readonly_selector` };
+          return acc;
+        }, {}),
+        [...store.selectors].reduce((acc, [key]) => {
+          acc[key] = { key, type: `selector` };
+          return acc;
+        }, {})
+      ),
+      effects: [
+        ({ setSelf }) => {
+          store.subject.selectorCreation.subscribe(
+            `introspection`,
+            (selectorToken) => {
+              if (selectorToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+                return;
+              }
+              const set = () => setSelf((state) => {
+                const { key, family } = selectorToken;
+                if (family) {
+                  const { key: familyKey, subKey } = family;
+                  const current = state[familyKey];
+                  if (current === void 0 || `familyMembers` in current) {
+                    const familyKeyState = current || {
+                      key: familyKey,
+                      familyMembers: {}
+                    };
+                    return __spreadProps(__spreadValues({}, state), {
+                      [familyKey]: __spreadProps(__spreadValues({}, familyKeyState), {
+                        familyMembers: __spreadProps(__spreadValues({}, familyKeyState.familyMembers), {
+                          [subKey]: selectorToken
+                        })
+                      })
+                    });
+                  }
+                }
+                return __spreadProps(__spreadValues({}, state), {
+                  [key]: selectorToken
+                });
+              });
+              if (newest(store).operation.open) {
+                const unsubscribe = store.subject.operationStatus.subscribe(
+                  `introspection: waiting to update selector index`,
+                  () => {
+                    unsubscribe();
+                    set();
+                  }
+                );
+              } else {
+                set();
+              }
+            }
+          );
+        }
+      ]
+    },
+    void 0,
+    store
+  );
+  return createSelector(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index`,
+      get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
+    },
+    void 0,
+    IMPLICIT.STORE
+  );
+};
+
+// introspection/src/attach-timeline-family.ts
+var attachTimelineFamily = (store = IMPLICIT.STORE) => {
+  const findTimelineLogState__INTERNAL = createAtomFamily(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log (Internal)`,
+      default: (key) => {
+        var _a2;
+        return (_a2 = store.timelines.get(key)) != null ? _a2 : {
+          type: `timeline`,
+          key: ``,
+          at: 0,
+          timeTraveling: null,
+          history: [],
+          selectorTime: null,
+          transactionKey: null,
+          install: () => {
+          },
+          subject: new Subject()
+        };
+      },
+      effects: (key) => [
+        ({ setSelf }) => {
+          const tl = store.timelines.get(key);
+          tl == null ? void 0 : tl.subject.subscribe(`introspection`, (_) => {
+            if (store.operation.open === true) {
+              const unsubscribe = store.subject.operationStatus.subscribe(
+                `introspection`,
+                (operationStatus) => {
+                  if (operationStatus.open === false) {
+                    unsubscribe();
+                    setSelf(__spreadValues({}, tl));
+                  }
+                }
+              );
+            } else {
+              setSelf(__spreadValues({}, tl));
+            }
+          });
+        }
+      ]
+    },
+    store
+  );
+  const findTimelineLogState = createSelectorFamily(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log`,
+      get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL(key))
+    },
+    store
+  );
+  return findTimelineLogState;
+};
+
+// introspection/src/attach-timeline-index.ts
+var attachTimelineIndex = (store = IMPLICIT.STORE) => {
+  const timelineTokenIndexState__INTERNAL = createAtom(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index (Internal)`,
+      default: () => [...store.timelines].map(([key]) => {
+        return { key, type: `timeline` };
+      }),
+      effects: [
+        ({ setSelf }) => {
+          store.subject.timelineCreation.subscribe(
+            `introspection`,
+            (timelineToken) => {
+              setSelf((state) => [...state, timelineToken]);
+            }
+          );
+        }
+      ]
+    },
+    void 0,
+    store
+  );
+  const timelineTokenIndex = createSelector(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index`,
+      get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
+    },
+    void 0,
+    store
+  );
+  return timelineTokenIndex;
+};
+
+// introspection/src/attach-transaction-index.ts
+var attachTransactionIndex = (store = IMPLICIT.STORE) => {
+  const transactionTokenIndexState__INTERNAL = createAtom(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index (Internal)`,
+      default: () => [...store.transactions].map(([key]) => {
+        return { key, type: `transaction` };
+      }),
+      effects: [
+        ({ setSelf }) => {
+          store.subject.transactionCreation.subscribe(
+            `introspection`,
+            (transactionToken) => {
+              setSelf((state) => [...state, transactionToken]);
+            }
+          );
+        }
+      ]
+    },
+    void 0,
+    store
+  );
+  const transactionTokenIndex = createSelector(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index`,
+      get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
+    },
+    void 0,
+    store
+  );
+  return transactionTokenIndex;
 };
 
-// ../__unstable__/web-effects/src/storage.ts
+// introspection/src/attach-transaction-logs.ts
+var attachTransactionLogs = (store = IMPLICIT.STORE) => {
+  const findTransactionUpdateLog = createAtomFamily(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
+      default: () => [],
+      effects: (key) => [
+        ({ setSelf }) => {
+          const tx = store.transactions.get(key);
+          tx == null ? void 0 : tx.subject.subscribe(`introspection`, (transactionUpdate) => {
+            if (transactionUpdate.key === key) {
+              setSelf((state) => [...state, transactionUpdate]);
+            }
+          });
+        }
+      ]
+    },
+    store
+  );
+  const findTransactionUpdateLogState = createSelectorFamily(
+    {
+      key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log`,
+      get: (key) => ({ get }) => get(findTransactionUpdateLog(key))
+    },
+    store
+  );
+  return findTransactionUpdateLogState;
+};
+
+// introspection/src/attach-introspection-states.ts
+var attachIntrospectionStates = (store = IMPLICIT.STORE) => {
+  return {
+    atomIndex: attachAtomIndex(store),
+    selectorIndex: attachSelectorIndex(store),
+    transactionIndex: attachTransactionIndex(store),
+    findTransactionLogState: attachTransactionLogs(store),
+    timelineIndex: attachTimelineIndex(store),
+    findTimelineState: attachTimelineFamily(store)
+  };
+};
+
+// __unstable__/web-effects/src/storage.ts
 var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, onSet }) => {
   const savedValue = storage.getItem(key);
   if (savedValue != null)
@@ -76,7 +2106,7 @@ var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, on
 };
 var lazyLocalStorageEffect = persistAtom(localStorage)(JSON);
 
-// ../../anvl/src/function/pipe.ts
+// ../anvl/src/function/pipe.ts
 function pipe(a2, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
@@ -107,9 +2137,9 @@ function pipe(a2, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// ../../anvl/src/function/index.ts
+// ../anvl/src/function/index.ts
 var doNothing = () => void 0;
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+var become2 = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
   originalThing instanceof Function ? originalThing() : originalThing
 ) : nextVersionOfThing;
 var isModifier = (validate) => (sample) => {
@@ -136,7 +2166,7 @@ var fallback = (fn, fallbackValue) => {
   }
 };
 
-// ../../anvl/src/array/venn.ts
+// ../anvl/src/array/venn.ts
 var includesAll = (items) => (array) => {
   for (const item of items) {
     if (!array.includes(item))
@@ -146,7 +2176,7 @@ var includesAll = (items) => (array) => {
 };
 var comprises = (items) => (array) => includesAll(items)(array) && includesAll(array)(items);
 
-// ../../anvl/src/array/index.ts
+// ../anvl/src/array/index.ts
 var isArray = (isType) => (input) => Array.isArray(input) && input.every((item) => isType(item));
 var map = (f) => (a2) => a2.map(f);
 var every = (f = Boolean) => (a2) => a2.every(f);
@@ -155,21 +2185,21 @@ var addTo = (a2) => (x) => a2.includes(x) ? a2 : [...a2, x];
 var isEmptyArray = (input) => Array.isArray(input) && input.length === 0;
 var isOneOf = (...args) => (input) => args.includes(input);
 
-// ../../anvl/src/nullish/index.ts
+// ../anvl/src/nullish/index.ts
 var isUndefined = (input) => input === void 0;
 var ifDefined = (validate) => (input) => isUndefined(input) || validate(input);
 var ifNullish = (alt) => (input) => input != null ? input : alt;
 
-// ../../anvl/src/object/access.ts
+// ../anvl/src/object/access.ts
 var access = (k) => Object.assign((obj) => obj[k], {
   in: (obj) => obj[k]
 });
 
-// ../../anvl/src/object/entries.ts
+// ../anvl/src/object/entries.ts
 var recordToEntries = (obj) => Object.entries(obj);
 var entriesToRecord = (entries) => Object.fromEntries(entries);
 
-// ../../anvl/src/object/mapObject.ts
+// ../anvl/src/object/mapObject.ts
 var mapObject = (obj, fn) => pipe(
   obj,
   recordToEntries,
@@ -178,7 +2208,7 @@ var mapObject = (obj, fn) => pipe(
 );
 var mob = (fn) => (obj) => mapObject(obj, fn);
 
-// ../../anvl/src/object/refinement.ts
+// ../anvl/src/object/refinement.ts
 var isNonNullObject = (input) => typeof input === `object` && input !== null;
 var isPlainObject = (input) => isNonNullObject(input) && Object.getPrototypeOf(input) === Object.prototype;
 var isEmptyObject = (input) => isPlainObject(input) && Object.keys(input).length === 0;
@@ -213,7 +2243,7 @@ var doesExtend = (isValue) => hasProperties(isValue, ALLOW_EXTENSION);
 var DO_NOT_ALLOW_EXTENSION = { allowExtraProperties: false };
 var hasExactProperties = (isValue) => hasProperties(isValue, DO_NOT_ALLOW_EXTENSION);
 
-// ../../anvl/src/object/sprawl.ts
+// ../anvl/src/object/sprawl.ts
 var sprawl = (tree, inspector) => {
   const walk = (path, node) => {
     const inspect = (path2, node2) => {
@@ -238,7 +2268,7 @@ var sprawl = (tree, inspector) => {
   walk([], tree);
 };
 
-// ../../anvl/src/object/index.ts
+// ../anvl/src/object/index.ts
 var treeShake = (shouldDiscard = isUndefined) => (obj) => {
   const newObj = {};
   const entries = Object.entries(obj);
@@ -254,7 +2284,7 @@ var delve = (obj, path) => {
   return found === void 0 ? new Error(`Not found`) : { found };
 };
 
-// ../../anvl/src/refinement/refinery.ts
+// ../anvl/src/refinement/refinery.ts
 var Refinery = class {
   constructor(supported) {
     this.supported = supported;
@@ -299,7 +2329,7 @@ var discoverType = (input) => {
   return Object.getPrototypeOf(input).constructor.name;
 };
 
-// ../../anvl/src/tree/differ.ts
+// ../anvl/src/tree/differ.ts
 function diffNumber(a2, b2) {
   const sign = a2 < b2 ? `+` : `-`;
   return {
@@ -416,38 +2446,26 @@ var Differ = class {
     };
   }
 };
+var StoreContext = React2__namespace.createContext(IMPLICIT.STORE);
+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;
+}
+function useO(token) {
+  const store = React2__namespace.useContext(StoreContext);
+  const id = React2__namespace.useId();
+  return React2__namespace.useSyncExternalStore(
+    (dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
+    () => getState(token, store),
+    () => getState(token, store)
+  );
+}
 
-// ../../anvl/src/json/index.ts
-var stringifyJson = (json) => JSON.stringify(json);
-var JSON_TYPE_NAMES = [
-  `array`,
-  `boolean`,
-  `null`,
-  `number`,
-  `object`,
-  `string`
-];
-var JSON_DEFAULTS = {
-  array: [],
-  boolean: false,
-  null: null,
-  number: 0,
-  object: {},
-  string: ``
-};
-
-// ../../anvl/src/primitive/index.ts
-var isString = (input) => {
-  return typeof input === `string`;
-};
-var isNumber = (input) => {
-  return typeof input === `number`;
-};
-var isBoolean = (input) => {
-  return typeof input === `boolean`;
-};
-
-// ../../anvl/src/refinement/refine-json.ts
+// ../anvl/src/refinement/refine-json.ts
 var JSON_PROTOTYPES = [
   `Array`,
   `Boolean`,
@@ -484,13 +2502,13 @@ var button = {
   OpenClose
 };
 
-// ../../anvl/src/refinement/can-exist.ts
+// ../anvl/src/refinement/can-exist.ts
 var canExist = (_) => true;
 
-// ../../anvl/src/refinement/cannot-exist.ts
+// ../anvl/src/refinement/cannot-exist.ts
 var cannotExist = (_) => false;
 
-// ../../anvl/src/refinement/is-union.ts
+// ../anvl/src/refinement/is-union.ts
 var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isTypeA]) => {
   const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` | `)})`;
   const _ = {
@@ -514,7 +2532,7 @@ var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isT
 };
 var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
 
-// ../../anvl/src/refinement/is-intersection.ts
+// ../anvl/src/refinement/is-intersection.ts
 function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [isTypeA]) {
   const name = `(${refinements.map((r) => (r == null ? void 0 : r.name) || `anon`).join(` & `)})`;
   const _ = {
@@ -538,11 +2556,11 @@ function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [i
 }
 var isIntersection = mustSatisfyAllOfTheFollowing(canExist);
 
-// ../../anvl/src/refinement/index.ts
+// ../anvl/src/refinement/index.ts
 var isLiteral = (value) => (input) => input === value;
 var isWithin = (args) => (input) => args.includes(input);
 
-// ../../anvl/src/join/core-relation-data.ts
+// ../anvl/src/join/core-relation-data.ts
 var RELATION_TYPES = [`1:1`, `1:n`, `n:n`];
 var isRelationType = (x) => RELATION_TYPES.includes(x);
 var EMPTY_RELATION_DATA = {
@@ -566,7 +2584,7 @@ var isRelationData = ({
   })(input);
 };
 
-// ../../anvl/src/join/get-related-ids.ts
+// ../anvl/src/join/get-related-ids.ts
 var getRelatedIds = (relationMap, id) => {
   var _a2;
   return (_a2 = relationMap.relations[id]) != null ? _a2 : [];
@@ -581,7 +2599,7 @@ var getRelatedId = (relationMap, id) => {
   return relations[0];
 };
 
-// ../../anvl/src/join/make-json-interface.ts
+// ../anvl/src/join/make-json-interface.ts
 var makeJsonInterface = (join, ...params) => {
   const isContent = params[0];
   const { a: a2, b: b2 } = join;
@@ -596,17 +2614,17 @@ var makeJsonInterface = (join, ...params) => {
   };
 };
 
-// ../../anvl/src/join/relation-record.ts
+// ../anvl/src/join/relation-record.ts
 var getRelationEntries = (relationMap, idA) => getRelatedIds(relationMap, idA).map((idB) => [
   idB,
   getContent(relationMap, idA, idB)
 ]);
 var getRelationRecord = (relationMap, id) => Object.fromEntries(getRelationEntries(relationMap, id));
 
-// ../../anvl/src/string/split.ts
+// ../anvl/src/string/split.ts
 var split = (separator) => (str) => str.split(separator);
 
-// ../../anvl/src/join/remove-relation.ts
+// ../anvl/src/join/remove-relation.ts
 var removeSpecific = (current, idA, idB) => {
   const isIdForRemoval = isOneOf(idA, idB);
   return __spreadProps(__spreadValues({}, current), {
@@ -655,7 +2673,7 @@ var removeRelation = (current, relation) => {
   return idB ? removeSpecific(current, idA, idB) : removeAll(current, idA);
 };
 
-// ../../anvl/src/join/set-relation.ts
+// ../anvl/src/join/set-relation.ts
 var setManyToMany = (map2, idA, idB, ...rest) => {
   var _a2, _b;
   const next = __spreadProps(__spreadValues({}, map2), {
@@ -709,7 +2727,7 @@ var setRelationWithContent = (current, relation, ...rest) => {
   }
 };
 
-// ../../anvl/src/join/relation-contents.ts
+// ../anvl/src/join/relation-contents.ts
 var makeContentId = (idA, idB) => [idA, idB].sort().join(`/`);
 var getContent = (relationMap, idA, idB) => relationMap.contents[makeContentId(idA, idB)];
 var setContent = (map2, idA, idB, content) => __spreadProps(__spreadValues({}, map2), {
@@ -767,7 +2785,7 @@ var setRelations = (current, subject, relations) => {
   );
 };
 
-// ../../anvl/src/join/index.ts
+// ../anvl/src/join/index.ts
 var Join = class _Join {
   constructor(json) {
     this.a = `from`;
@@ -836,12 +2854,12 @@ var Join = class _Join {
     );
   }
 };
-var ElasticInput = React.forwardRef(function ElasticInputFC(props, ref) {
+var ElasticInput = React2.forwardRef(function ElasticInputFC(props, ref) {
   var _a2, _b, _c, _d;
-  const inputRef = React.useRef(null);
-  const spanRef = React.useRef(null);
-  const [inputWidth, setInputWidth] = React.useState(`auto`);
-  React.useImperativeHandle(
+  const inputRef = React2.useRef(null);
+  const spanRef = React2.useRef(null);
+  const [inputWidth, setInputWidth] = React2.useState(`auto`);
+  React2.useImperativeHandle(
     ref,
     () => ({
       focus: () => {
@@ -851,7 +2869,7 @@ var ElasticInput = React.forwardRef(function ElasticInputFC(props, ref) {
     })
   );
   const extraWidth = props.type === `number` ? 15 : 0;
-  React.useLayoutEffect(() => {
+  React2.useLayoutEffect(() => {
     if (spanRef.current) {
       setInputWidth(`${spanRef.current.offsetWidth + extraWidth}px`);
       const interval = setInterval(() => {
@@ -896,10 +2914,10 @@ var ElasticInput = React.forwardRef(function ElasticInputFC(props, ref) {
   ] });
 });
 
-// ../../anvl/src/number/clamp.ts
+// ../anvl/src/number/clamp.ts
 var clampInto = (min, max) => (value) => value < min ? min : value > max ? max : value;
 
-// ../../anvl/src/number/wrap.ts
+// ../anvl/src/number/wrap.ts
 var wrapInto = (min, max) => (value) => value < min ? max - (min - value) % (max - min) : min + (value - min) % (max - min);
 function round(value, decimalPlaces) {
   if (decimalPlaces === void 0)
@@ -961,9 +2979,9 @@ var NumberInput = ({
   testId,
   value = null
 }) => {
-  const id = React.useId();
-  const [temporaryEntry, setTemporaryEntry] = React.useState(null);
-  const userHasMadeDeliberateChange = React.useRef(false);
+  const id = React2.useId();
+  const [temporaryEntry, setTemporaryEntry] = React2.useState(null);
+  const userHasMadeDeliberateChange = React2.useRef(false);
   const refine = initRefinery({ max, min, decimalPlaces, nullable: true });
   const allowDecimal = decimalPlaces === void 0 || decimalPlaces > 0;
   const handleBlur = () => {
@@ -1133,11 +3151,11 @@ var JsonEditor_INTERNAL = ({
   ] }) });
 };
 
-// ../../hamr/src/react-json-editor/editors-by-type/utilities/array-elements.ts
+// ../hamr/src/react-json-editor/editors-by-type/utilities/array-elements.ts
 var makeElementSetters = (data, set) => data.map(
   (value, index) => (newValue) => set(() => {
     const newData = [...data];
-    newData[index] = become(newValue)(value);
+    newData[index] = become2(newValue)(value);
     return newData;
   })
 );
@@ -1167,7 +3185,7 @@ var ArrayEditor = ({
   }) });
 };
 
-// ../../anvl/src/json-schema/integer.ts
+// ../anvl/src/json-schema/integer.ts
 var isInteger = (input) => Number.isInteger(input);
 var parseInteger = (input) => {
   if (isInteger(input))
@@ -1228,7 +3246,7 @@ asNumber(new Fraction(1, 2));
 asNumber([new Fraction(1, 2)]);
 asNumber({ a: new Fraction(1, 2) });
 
-// ../../anvl/src/json-schema/refs.ts
+// ../anvl/src/json-schema/refs.ts
 function isJsonSchemaRef(input) {
   return doesExtend({
     $ref: isString
@@ -1281,7 +3299,7 @@ var retrieveRef = ({
   throw new TypeError(`The refNode is not a JsonSchema`);
 };
 
-// ../../anvl/src/json-schema/string-formats.ts
+// ../anvl/src/json-schema/string-formats.ts
 var JSON_SCHEMA_STRING_FORMATS = [
   `date-time`,
   `date`,
@@ -1297,7 +3315,7 @@ var JSON_SCHEMA_STRING_FORMATS = [
   `uuid`
 ];
 
-// ../../anvl/src/json-schema/json-schema.ts
+// ../anvl/src/json-schema/json-schema.ts
 var JSON_SCHEMA_TYPE_NAMES = [...JSON_TYPE_NAMES, `integer`];
 [
   ...JSON_SCHEMA_TYPE_NAMES,
@@ -1420,7 +3438,7 @@ function isJsonSchema(input) {
   return mustSatisfyOneOfTheFollowing(isBoolean).or(isJsonSchemaObject).or(isJsonSchemaRef)(input);
 }
 
-// ../../anvl/src/json-schema/path-into.ts
+// ../anvl/src/json-schema/path-into.ts
 var expandPathForSchema = (path) => {
   try {
     return path.flatMap((key) => {
@@ -1448,7 +3466,7 @@ var expandPathForSchema = (path) => {
   }
 };
 
-// ../../anvl/src/json-schema/find-sub-schema.ts
+// ../anvl/src/json-schema/find-sub-schema.ts
 var findSubSchema = (schema) => {
   if (typeof schema === `boolean`) {
     throw new Error(`The schema does not contain subSchemas`);
@@ -1479,7 +3497,7 @@ var findSubSchema = (schema) => {
   };
 };
 
-// ../../anvl/src/json/cast-json.ts
+// ../anvl/src/json/cast-json.ts
 var stringToBoolean = (str) => str === `true`;
 var stringToNumber = (str) => Number(str);
 var stringToArray = (str) => str.split(`,`);
@@ -1525,7 +3543,7 @@ var nullToBoolean = () => false;
 var nullToArray = () => [];
 var nullToObject = () => ({});
 
-// ../../anvl/src/refinement/smart-cast-json.ts
+// ../anvl/src/refinement/smart-cast-json.ts
 var castToJson = (input) => {
   const json = refineJsonType(input);
   return {
@@ -1615,10 +3633,10 @@ var castToJson = (input) => {
   };
 };
 
-// ../../hamr/src/react-json-editor/editors-by-type/utilities/object-properties.ts
+// ../hamr/src/react-json-editor/editors-by-type/utilities/object-properties.ts
 var makePropertySetters = (data, set) => mapObject(
   data,
-  (value, key) => (newValue) => set(__spreadProps(__spreadValues({}, data), { [key]: become(newValue)(value[key]) }))
+  (value, key) => (newValue) => set(__spreadProps(__spreadValues({}, data), { [key]: become2(newValue)(value[key]) }))
 );
 var makePropertyRenamers = (data, set, stableKeyMapRef) => mapObject(
   data,
@@ -1677,7 +3695,7 @@ var ObjectEditor = ({
 }) => {
   var _a2;
   const disabled = isReadonly(path);
-  const stableKeyMap = React.useRef(
+  const stableKeyMap = React2.useRef(
     Object.keys(data).reduce(
       (acc, key) => {
         acc[key] = key;
@@ -1843,7 +3861,7 @@ var DefaultFallback = ({ error, errorInfo }) => {
     }
   );
 };
-var ErrorBoundary = class extends React.Component {
+var ErrorBoundary = class extends React2.Component {
   constructor(props) {
     super(props);
     this.state = {};
@@ -1941,7 +3959,7 @@ var JsonEditor = ({
   );
 };
 
-// ../../hamr/src/react-json-editor/index.ts
+// ../hamr/src/react-json-editor/index.ts
 var SubEditors = {
   array: ArrayEditor,
   boolean: BooleanEditor,
@@ -1951,7 +3969,7 @@ var SubEditors = {
   string: StringEditor
 };
 
-// ../../anvl/src/string/string-to-color.ts
+// ../anvl/src/string/string-to-color.ts
 function stringToColor(input) {
   let hash = 0;
   for (let i = 0; i < input.length; i++) {
@@ -1966,20 +3984,20 @@ function stringToColor(input) {
   return `#${hexColor}`;
 }
 
-// ../../luum/src/constants/index.ts
+// ../luum/src/constants/index.ts
 var CHANNEL_SPECIFIC_LUM = {
   R: 0.3,
   G: 0.5,
   B: 0.2
 };
 
-// ../../luum/src/constants/filters.ts
+// ../luum/src/constants/filters.ts
 var unfiltered = [
   { sat: 255, hue: 0 },
   { sat: 255, hue: 360 }
 ];
 
-// ../../luum/src/export/channelsToHex.ts
+// ../luum/src/export/channelsToHex.ts
 var channelsToHex = (channels) => `#${Object.values(channels).map((channel) => {
   let channelHex = channel.toString(16);
   if (channelHex.length === 1)
@@ -1988,7 +4006,7 @@ var channelsToHex = (channels) => `#${Object.values(channels).map((channel) => {
 }).join(``)}`;
 var channelsToHex_default = channelsToHex;
 
-// ../../luum/src/import/hueToRelativeChannels.ts
+// ../luum/src/import/hueToRelativeChannels.ts
 var hueToRelativeChannels_default = (hue) => {
   const hueWrapped = wrapInto(0, 360)(hue);
   const hueReduced = hueWrapped / 60;
@@ -2014,7 +4032,7 @@ var hueToRelativeChannels_default = (hue) => {
   }
 };
 
-// ../../luum/src/solveFor/hueFromChannels.ts
+// ../luum/src/solveFor/hueFromChannels.ts
 var hueFromChannels = ({ R, G, B }) => {
   let hue = 0;
   if (R > G && G >= B)
@@ -2033,14 +4051,14 @@ var hueFromChannels = ({ R, G, B }) => {
 };
 var hueFromChannels_default = hueFromChannels;
 
-// ../../luum/src/solveFor/lumFromChannels.ts
+// ../luum/src/solveFor/lumFromChannels.ts
 var lumFromChannels = ({ R, G, B }) => {
   const lum = CHANNEL_SPECIFIC_LUM.R * R / 255 + CHANNEL_SPECIFIC_LUM.G * G / 255 + CHANNEL_SPECIFIC_LUM.B * B / 255;
   return lum;
 };
 var lumFromChannels_default = lumFromChannels;
 
-// ../../luum/src/solveFor/maxSatForHueInFilter.ts
+// ../luum/src/solveFor/maxSatForHueInFilter.ts
 var maxSatForHueInFilter_default = (hue, filter) => {
   let maxSat = 255;
   const hueWrapped = wrapInto(0, 360)(hue);
@@ -2063,14 +4081,14 @@ var maxSatForHueInFilter_default = (hue, filter) => {
   return maxSat;
 };
 
-// ../../luum/src/solveFor/satFromChannels.ts
+// ../luum/src/solveFor/satFromChannels.ts
 var satFromChannels = ({ R, G, B }) => {
   const sat = Math.max(R, G, B) - Math.min(R, G, B);
   return sat;
 };
 var satFromChannels_default = satFromChannels;
 
-// ../../luum/src/solveFor/specificLumFromHue.ts
+// ../luum/src/solveFor/specificLumFromHue.ts
 var specificLumFromHue_default = (hue) => {
   const [factorR, factorG, factorB] = hueToRelativeChannels_default(hue);
   const lumR = CHANNEL_SPECIFIC_LUM.R * factorR;
@@ -2080,7 +4098,7 @@ var specificLumFromHue_default = (hue) => {
   return specificLum;
 };
 
-// ../../luum/src/export/specToChannelsFixLimit.ts
+// ../luum/src/export/specToChannelsFixLimit.ts
 var minChannelsForSaturationFromHue = (hue) => {
   const relativeChannels = hueToRelativeChannels_default(hue);
   const channelSpreader = (trueSaturation) => {
@@ -2164,7 +4182,7 @@ var specToChannelsFixLimit = ({ hue, sat, lum, prefer = `lum` }, filter = unfilt
 };
 var specToChannelsFixLimit_default = specToChannelsFixLimit;
 
-// ../../luum/src/export/specToHexFixLimit.ts
+// ../luum/src/export/specToHexFixLimit.ts
 var specToHexFixLimit = ({ hue, sat, lum, prefer }, filter) => {
   const { channels, fix, limit } = specToChannelsFixLimit_default(
     {
@@ -2181,14 +4199,14 @@ var specToHexFixLimit = ({ hue, sat, lum, prefer }, filter) => {
 };
 var specToHexFixLimit_default = specToHexFixLimit;
 
-// ../../luum/src/export/specToHex.ts
+// ../luum/src/export/specToHex.ts
 var specToHex = ({ hue, sat, lum, prefer }, filter) => {
   const { hex } = specToHexFixLimit_default({ hue, sat, lum, prefer }, filter);
   return hex;
 };
 var specToHex_default = specToHex;
 
-// ../../luum/src/import/channelsToSpec.ts
+// ../luum/src/import/channelsToSpec.ts
 var channelsToSpec = ({ R, G, B }) => {
   const hue = hueFromChannels_default({ R, G, B });
   const sat = satFromChannels_default({ R, G, B });
@@ -2197,7 +4215,7 @@ var channelsToSpec = ({ R, G, B }) => {
 };
 var channelsToSpec_default = channelsToSpec;
 
-// ../../luum/src/import/normalizeHex.ts
+// ../luum/src/import/normalizeHex.ts
 var BASE_16_CHAR_SET = `[a-fA-F0-9]+`;
 var miniHexToHex = (miniHex) => {
   const miniHexArray = miniHex.split(``);
@@ -2219,7 +4237,7 @@ var normalizeHex = (maybeHex) => {
 };
 var normalizeHex_default = normalizeHex;
 
-// ../../luum/src/import/hexToChannels.ts
+// ../luum/src/import/hexToChannels.ts
 var hexToChannels_default = (maybeHex) => {
   const hex = normalizeHex_default(maybeHex);
   return {
@@ -2229,7 +4247,7 @@ var hexToChannels_default = (maybeHex) => {
   };
 };
 
-// ../../luum/src/import/hexToSpec.ts
+// ../luum/src/import/hexToSpec.ts
 var hexToSpec = (hex) => {
   const { R, G, B } = hexToChannels_default(hex);
   const { hue, sat, lum } = channelsToSpec_default({ R, G, B });
@@ -2237,7 +4255,7 @@ var hexToSpec = (hex) => {
 };
 var hexToSpec_default = hexToSpec;
 
-// ../../luum/src/mixers/contrast.ts
+// ../luum/src/mixers/contrast.ts
 var contrastMax = (color) => __spreadProps(__spreadValues({}, color), {
   lum: color.lum > 0.666 ? 0 : 1
 });
@@ -2245,7 +4263,7 @@ var offset = (offsetAmount) => (color) => __spreadProps(__spreadValues({}, color
   lum: color.lum > 0.666 ? color.lum - offsetAmount : color.lum + offsetAmount
 });
 
-// ../../luum/src/constants/luum-spec.ts
+// ../luum/src/constants/luum-spec.ts
 var defaultSpec = {
   hue: 0,
   lum: 0,
@@ -2253,7 +4271,7 @@ var defaultSpec = {
   prefer: `lum`
 };
 
-// ../../luum/src/scheme/index.ts
+// ../luum/src/scheme/index.ts
 var isLuumSpec = (input) => typeof input === `object` && input !== null && typeof input.hue === `number` && typeof input.sat === `number` && typeof input.lum === `number` && [`sat`, `lum`].includes(input.prefer);
 isModifier(isLuumSpec)(defaultSpec);
 var WAYFORGE_CORE_COLOR_NAMES = [
@@ -2283,14 +4301,14 @@ WAYFORGE_CORE_COLOR_NAMES.reduce(
   {}
 );
 var Id = ({ id }) => {
-  const [isOpen, setIsOpen] = React__namespace.useState(false);
-  const { refs, floatingStyles, context } = react$1.useFloating({
+  const [isOpen, setIsOpen] = React2__namespace.useState(false);
+  const { refs, floatingStyles, context } = react.useFloating({
     open: isOpen,
     onOpenChange: setIsOpen,
     placement: `bottom-start`
   });
-  const click = react$1.useClick(context);
-  const { getReferenceProps, getFloatingProps } = react$1.useInteractions([click]);
+  const click = react.useClick(context);
+  const { getReferenceProps, getFloatingProps } = react.useInteractions([click]);
   const bgColor = stringToColor(id);
   const contrastColor = pipe(bgColor, hexToSpec_default, contrastMax, specToHex_default);
   const offsetColor = pipe(bgColor, hexToSpec_default, offset(0.25), specToHex_default);
@@ -2318,7 +4336,7 @@ var Id = ({ id }) => {
         children: id.substring(0, 3)
       })
     ),
-    isOpen && /* @__PURE__ */ jsxRuntime.jsx(react$1.FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(
+    isOpen && /* @__PURE__ */ jsxRuntime.jsx(react.FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(
       "span",
       __spreadProps(__spreadValues({
         role: "popup",
@@ -2336,7 +4354,7 @@ var Id = ({ id }) => {
   ] });
 };
 
-// ../../hamr/src/react-data-designer/RelationEditor.module.scss
+// ../hamr/src/react-data-designer/RelationEditor.module.scss
 var RelationEditor_module_default = {};
 var RelationEditor = (props) => {
   const seen = /* @__PURE__ */ new Set();
@@ -2356,8 +4374,8 @@ var RelationEditor = (props) => {
   ] })) });
 };
 var StateEditor = ({ token }) => {
-  const set = react.useI(token);
-  const data = react.useO(token);
+  const set = useI(token);
+  const data = useO(token);
   return isJson(data) ? /* @__PURE__ */ jsxRuntime.jsx(JsonEditor, { data, set, schema: true }) : data instanceof Join ? /* @__PURE__ */ jsxRuntime.jsx(RelationEditor, { data, set }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "json_editor", children: /* @__PURE__ */ jsxRuntime.jsx(
     ElasticInput,
     {
@@ -2367,7 +4385,7 @@ var StateEditor = ({ token }) => {
   ) });
 };
 var ReadonlySelectorViewer = ({ token }) => {
-  const data = react.useO(token);
+  const data = useO(token);
   return isJson(data) ? /* @__PURE__ */ jsxRuntime.jsx(
     JsonEditor,
     {
@@ -2390,7 +4408,7 @@ var StoreEditor = ({ token }) => {
   }
   return /* @__PURE__ */ jsxRuntime.jsx(StateEditor, { token });
 };
-var findStateTypeState = atom_io.selectorFamily({
+var findStateTypeState = selectorFamily({
   key: `\u{1F441}\u200D\u{1F5E8} State Type`,
   get: (token) => ({ get }) => {
     let state;
@@ -2408,10 +4426,10 @@ var findStateTypeState = atom_io.selectorFamily({
 });
 var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
   var _a2, _b;
-  const setIsOpen = react.useI(isOpenState);
-  const isOpen = react.useO(isOpenState);
-  const state = react.useO(node);
-  const stateType = react.useO(typeState);
+  const setIsOpen = useI(isOpenState);
+  const isOpen = useO(isOpenState);
+  const state = useO(node);
+  const stateType = useO(typeState);
   const isPrimitive = Boolean(primitiveRefinery.refine(state));
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs("header", { children: [
@@ -2426,8 +4444,8 @@ var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
       /* @__PURE__ */ jsxRuntime.jsxs(
         "label",
         {
-          onClick: () => console.log(node, atom_io.getState(node)),
-          onKeyUp: () => console.log(node, atom_io.getState(node)),
+          onClick: () => console.log(node, getState(node)),
+          onKeyUp: () => console.log(node, getState(node)),
           children: [
             /* @__PURE__ */ jsxRuntime.jsx("h2", { children: (_b = (_a2 = node.family) == null ? void 0 : _a2.subKey) != null ? _b : node.key }),
             /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "type detail", children: [
@@ -2444,8 +4462,8 @@ var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
   ] });
 };
 var StateIndexTreeNode = ({ node, isOpenState }) => {
-  const setIsOpen = react.useI(isOpenState);
-  const isOpen = react.useO(isOpenState);
+  const setIsOpen = useI(isOpenState);
+  const isOpen = useO(isOpenState);
   for (const [key, childNode] of recordToEntries(node.familyMembers)) {
     findViewIsOpenState(key);
     findStateTypeState(childNode);
@@ -2483,7 +4501,7 @@ var StateIndexNode = ({ node, isOpenState, typeState }) => {
   ) : /* @__PURE__ */ jsxRuntime.jsx(StateIndexTreeNode, { node, isOpenState }) });
 };
 var StateIndex = ({ tokenIndex }) => {
-  const tokenIds = react.useO(tokenIndex);
+  const tokenIds = useO(tokenIndex);
   return /* @__PURE__ */ jsxRuntime.jsx("article", { className: "index state_index", children: Object.entries(tokenIds).filter(([key]) => !key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).sort().map(([key, node]) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       StateIndexNode,
@@ -2623,9 +4641,9 @@ var YouAreHere = () => {
   return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "you_are_here", children: "you are here" });
 };
 var TimelineLog = ({ token, isOpenState, timelineState }) => {
-  const timeline = react.useO(timelineState);
-  const isOpen = react.useO(isOpenState);
-  const setIsOpen = react.useI(isOpenState);
+  const timeline = useO(timelineState);
+  const isOpen = useO(isOpenState);
+  const setIsOpen = useI(isOpenState);
   return /* @__PURE__ */ jsxRuntime.jsxs("section", { className: "node timeline_log", children: [
     /* @__PURE__ */ jsxRuntime.jsxs("header", { children: [
       /* @__PURE__ */ jsxRuntime.jsx(button.OpenClose, { isOpen, setIsOpen }),
@@ -2644,7 +4662,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
             "button",
             {
               type: "button",
-              onClick: () => atom_io.undo(token),
+              onClick: () => undo(token),
               disabled: timeline.at === 0,
               children: "undo"
             }
@@ -2653,7 +4671,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
             "button",
             {
               type: "button",
-              onClick: () => atom_io.redo(token),
+              onClick: () => redo(token),
               disabled: timeline.at === timeline.history.length,
               children: "redo"
             }
@@ -2661,7 +4679,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
         ] })
       ] })
     ] }),
-    isOpen ? /* @__PURE__ */ jsxRuntime.jsx("main", { children: timeline.history.map((update, index) => /* @__PURE__ */ jsxRuntime.jsxs(React.Fragment, { children: [
+    isOpen ? /* @__PURE__ */ jsxRuntime.jsx("main", { children: timeline.history.map((update, index) => /* @__PURE__ */ jsxRuntime.jsxs(React2.Fragment, { children: [
       index === timeline.at ? /* @__PURE__ */ jsxRuntime.jsx(YouAreHere, {}) : null,
       /* @__PURE__ */ jsxRuntime.jsx(article.TimelineUpdate, { timelineUpdate: update }),
       index === timeline.history.length - 1 && timeline.at === timeline.history.length ? /* @__PURE__ */ jsxRuntime.jsx(YouAreHere, {}) : null
@@ -2669,7 +4687,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
   ] });
 };
 var TimelineIndex = () => {
-  const tokenIds = react.useO(timelineIndex);
+  const tokenIds = useO(timelineIndex);
   return /* @__PURE__ */ jsxRuntime.jsx("article", { className: "index timeline_index", children: tokenIds.filter((token) => !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).map((token) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       TimelineLog,
@@ -2683,9 +4701,9 @@ var TimelineIndex = () => {
   }) });
 };
 var TransactionLog = ({ token, isOpenState, logState }) => {
-  const log = react.useO(logState);
-  const isOpen = react.useO(isOpenState);
-  const setIsOpen = react.useI(isOpenState);
+  const log = useO(logState);
+  const isOpen = useO(isOpenState);
+  const setIsOpen = useI(isOpenState);
   return /* @__PURE__ */ jsxRuntime.jsxs("section", { className: "node transaction_log", children: [
     /* @__PURE__ */ jsxRuntime.jsxs("header", { children: [
       /* @__PURE__ */ jsxRuntime.jsx(button.OpenClose, { isOpen, setIsOpen }),
@@ -2709,7 +4727,7 @@ var TransactionLog = ({ token, isOpenState, logState }) => {
   ] });
 };
 var TransactionIndex = () => {
-  const tokenIds = react.useO(transactionIndex);
+  const tokenIds = useO(transactionIndex);
   return /* @__PURE__ */ jsxRuntime.jsx("article", { className: "index transaction_index", children: tokenIds.filter((token) => !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).map((token) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       TransactionLog,
@@ -2723,13 +4741,13 @@ var TransactionIndex = () => {
   }) });
 };
 var AtomIODevtools = () => {
-  const constraintsRef = React.useRef(null);
-  const setDevtoolsAreOpen = react.useI(devtoolsAreOpenState);
-  const devtoolsAreOpen = react.useO(devtoolsAreOpenState);
-  const setDevtoolsView = react.useI(devtoolsViewSelectionState);
-  const devtoolsView = react.useO(devtoolsViewSelectionState);
-  const devtoolsViewOptions = react.useO(devtoolsViewOptionsState);
-  const mouseHasMoved = React.useRef(false);
+  const constraintsRef = React2.useRef(null);
+  const setDevtoolsAreOpen = useI(devtoolsAreOpenState);
+  const devtoolsAreOpen = useO(devtoolsAreOpenState);
+  const setDevtoolsView = useI(devtoolsViewSelectionState);
+  const devtoolsView = useO(devtoolsViewSelectionState);
+  const devtoolsViewOptions = useO(devtoolsViewOptionsState);
+  const mouseHasMoved = React2.useRef(false);
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsx(
       framerMotion.motion.span,
@@ -2797,7 +4815,7 @@ var AtomIODevtools = () => {
   ] });
 };
 
-// src/index.ts
+// react-devtools/src/index.ts
 var {
   atomIndex,
   selectorIndex,
@@ -2805,23 +4823,23 @@ var {
   findTransactionLogState,
   timelineIndex,
   findTimelineState
-} = introspection.attachIntrospectionStates();
-var devtoolsAreOpenState = atom_io.atom({
+} = attachIntrospectionStates();
+var devtoolsAreOpenState = atom({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools Are Open`,
   default: true,
   effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools Are Open`)]
 });
-var devtoolsViewSelectionState = atom_io.atom({
+var devtoolsViewSelectionState = atom({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Selection`,
   default: `atoms`,
   effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View`)]
 });
-var devtoolsViewOptionsState = atom_io.atom({
+var devtoolsViewOptionsState = atom({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Options`,
   default: [`atoms`, `selectors`, `transactions`, `timelines`],
   effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View Options`)]
 });
-var findViewIsOpenState = atom_io.atomFamily({
+var findViewIsOpenState = atomFamily({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Is Open`,
   default: false,
   effects: (key) => [lazyLocalStorageEffect(key + `:view-is-open`)]