atom.io 0.14.4 → 0.14.5

package/react-devtools/dist/index.cjs

@@ -1,2094 +1,64 @@
 'use strict';
 
-var React2 = require('react');
-var jsxRuntime = require('react/jsx-runtime');
-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
-    }
-  );
-}
-
-// 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;
-}
+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 jsxRuntime = require('react/jsx-runtime');
+var react$1 = require('@floating-ui/react');
 
-// 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);
-        }
+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/mutable/create-mutable-atom-family.ts
-function createMutableAtomFamily(options, store) {
-  const coreFamily = Object.assign(
-    createAtomFamily(options, store),
-    options
-  );
-  selectJsonFamily(coreFamily, options);
-  new FamilyTracker(coreFamily, store);
-  return coreFamily;
-}
-
-// internal/src/mutable/transceiver.ts
-function isTransceiver(value) {
-  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
+  n.default = e;
+  return Object.freeze(n);
 }
 
-// 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);
-};
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-// 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;
+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]);
     }
-    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}".`
-    );
-  }
+  return a2;
 };
-
-// internal/src/timeline/time-travel.ts
-var timeTravel = (direction, token, store) => {
-  const action = direction === `forward` ? `redo` : `undo`;
-  store.logger.info(
-    direction === `forward` ? `\u23E9` : `\u23EA`,
-    `timeline`,
-    token.key,
-    action
-  );
-  const timelineData = store.timelines.get(token.key);
-  if (!timelineData) {
-    store.logger.error(
-      `\u{1F41E}`,
-      `timeline`,
-      token.key,
-      `Failed to ${action}. This timeline has not been initialized.`
-    );
-    return;
-  }
-  if (direction === `forward` && timelineData.at === timelineData.history.length || direction === `backward` && timelineData.at === 0) {
-    store.logger.warn(
-      `\u{1F481}`,
-      `timeline`,
-      token.key,
-      `Failed to ${action} at the ${direction === `forward` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`
-    );
-    return;
-  }
-  timelineData.timeTraveling = direction === `forward` ? `into_future` : `into_past`;
-  if (direction === `backward`) {
-    --timelineData.at;
-  }
-  const update = timelineData.history[timelineData.at];
-  const updateValues = (atomUpdate) => {
-    const { key, newValue, oldValue } = atomUpdate;
-    const value = direction === `forward` ? newValue : oldValue;
-    setState({ key, type: `atom` }, value, store);
-  };
-  const updateValuesFromTransactionUpdate = (transactionUpdate) => {
-    const updates = direction === `forward` ? transactionUpdate.updates : [...transactionUpdate.updates].reverse();
-    for (const updateFromTransaction of updates) {
-      if (`newValue` in updateFromTransaction) {
-        updateValues(updateFromTransaction);
-      } else {
-        updateValuesFromTransactionUpdate(updateFromTransaction);
-      }
-    }
-  };
-  switch (update.type) {
-    case `atom_update`: {
-      updateValues(update);
-      break;
-    }
-    case `selector_update`: {
-      const updates = direction === `forward` ? update.atomUpdates : [...update.atomUpdates].reverse();
-      for (const atomUpdate of updates) {
-        updateValues(atomUpdate);
-      }
-      break;
-    }
-    case `transaction_update`: {
-      updateValuesFromTransactionUpdate(update);
-      break;
+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];
     }
-  }
-  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;
-};
-
-// 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)
-  };
+  return target;
 };
 
 // __unstable__/web-effects/src/storage.ts
@@ -2139,7 +109,7 @@ function pipe(a2, ab, bc, cd, de, ef, fg, gh, hi) {
 
 // ../anvl/src/function/index.ts
 var doNothing = () => void 0;
-var become2 = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
   originalThing instanceof Function ? originalThing() : originalThing
 ) : nextVersionOfThing;
 var isModifier = (validate) => (sample) => {
@@ -2446,24 +416,36 @@ 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
 var JSON_PROTOTYPES = [
@@ -2854,12 +836,12 @@ var Join = class _Join {
     );
   }
 };
-var ElasticInput = React2.forwardRef(function ElasticInputFC(props, ref) {
+var ElasticInput = React.forwardRef(function ElasticInputFC(props, ref) {
   var _a2, _b, _c, _d;
-  const inputRef = React2.useRef(null);
-  const spanRef = React2.useRef(null);
-  const [inputWidth, setInputWidth] = React2.useState(`auto`);
-  React2.useImperativeHandle(
+  const inputRef = React.useRef(null);
+  const spanRef = React.useRef(null);
+  const [inputWidth, setInputWidth] = React.useState(`auto`);
+  React.useImperativeHandle(
     ref,
     () => ({
       focus: () => {
@@ -2869,7 +851,7 @@ var ElasticInput = React2.forwardRef(function ElasticInputFC(props, ref) {
     })
   );
   const extraWidth = props.type === `number` ? 15 : 0;
-  React2.useLayoutEffect(() => {
+  React.useLayoutEffect(() => {
     if (spanRef.current) {
       setInputWidth(`${spanRef.current.offsetWidth + extraWidth}px`);
       const interval = setInterval(() => {
@@ -2979,9 +961,9 @@ var NumberInput = ({
   testId,
   value = null
 }) => {
-  const id = React2.useId();
-  const [temporaryEntry, setTemporaryEntry] = React2.useState(null);
-  const userHasMadeDeliberateChange = React2.useRef(false);
+  const id = React.useId();
+  const [temporaryEntry, setTemporaryEntry] = React.useState(null);
+  const userHasMadeDeliberateChange = React.useRef(false);
   const refine = initRefinery({ max, min, decimalPlaces, nullable: true });
   const allowDecimal = decimalPlaces === void 0 || decimalPlaces > 0;
   const handleBlur = () => {
@@ -3155,7 +1137,7 @@ var JsonEditor_INTERNAL = ({
 var makeElementSetters = (data, set) => data.map(
   (value, index) => (newValue) => set(() => {
     const newData = [...data];
-    newData[index] = become2(newValue)(value);
+    newData[index] = become(newValue)(value);
     return newData;
   })
 );
@@ -3636,7 +1618,7 @@ var castToJson = (input) => {
 // ../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]: become2(newValue)(value[key]) }))
+  (value, key) => (newValue) => set(__spreadProps(__spreadValues({}, data), { [key]: become(newValue)(value[key]) }))
 );
 var makePropertyRenamers = (data, set, stableKeyMapRef) => mapObject(
   data,
@@ -3695,7 +1677,7 @@ var ObjectEditor = ({
 }) => {
   var _a2;
   const disabled = isReadonly(path);
-  const stableKeyMap = React2.useRef(
+  const stableKeyMap = React.useRef(
     Object.keys(data).reduce(
       (acc, key) => {
         acc[key] = key;
@@ -3861,7 +1843,7 @@ var DefaultFallback = ({ error, errorInfo }) => {
     }
   );
 };
-var ErrorBoundary = class extends React2.Component {
+var ErrorBoundary = class extends React.Component {
   constructor(props) {
     super(props);
     this.state = {};
@@ -4301,14 +2283,14 @@ WAYFORGE_CORE_COLOR_NAMES.reduce(
   {}
 );
 var Id = ({ id }) => {
-  const [isOpen, setIsOpen] = React2__namespace.useState(false);
-  const { refs, floatingStyles, context } = react.useFloating({
+  const [isOpen, setIsOpen] = React__namespace.useState(false);
+  const { refs, floatingStyles, context } = react$1.useFloating({
     open: isOpen,
     onOpenChange: setIsOpen,
     placement: `bottom-start`
   });
-  const click = react.useClick(context);
-  const { getReferenceProps, getFloatingProps } = react.useInteractions([click]);
+  const click = react$1.useClick(context);
+  const { getReferenceProps, getFloatingProps } = react$1.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);
@@ -4336,7 +2318,7 @@ var Id = ({ id }) => {
         children: id.substring(0, 3)
       })
     ),
-    isOpen && /* @__PURE__ */ jsxRuntime.jsx(react.FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(
+    isOpen && /* @__PURE__ */ jsxRuntime.jsx(react$1.FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(
       "span",
       __spreadProps(__spreadValues({
         role: "popup",
@@ -4374,8 +2356,8 @@ var RelationEditor = (props) => {
   ] })) });
 };
 var StateEditor = ({ token }) => {
-  const set = useI(token);
-  const data = useO(token);
+  const set = react.useI(token);
+  const data = react.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,
     {
@@ -4385,7 +2367,7 @@ var StateEditor = ({ token }) => {
   ) });
 };
 var ReadonlySelectorViewer = ({ token }) => {
-  const data = useO(token);
+  const data = react.useO(token);
   return isJson(data) ? /* @__PURE__ */ jsxRuntime.jsx(
     JsonEditor,
     {
@@ -4408,7 +2390,7 @@ var StoreEditor = ({ token }) => {
   }
   return /* @__PURE__ */ jsxRuntime.jsx(StateEditor, { token });
 };
-var findStateTypeState = selectorFamily({
+var findStateTypeState = atom_io.selectorFamily({
   key: `\u{1F441}\u200D\u{1F5E8} State Type`,
   get: (token) => ({ get }) => {
     let state;
@@ -4426,10 +2408,10 @@ var findStateTypeState = selectorFamily({
 });
 var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
   var _a2, _b;
-  const setIsOpen = useI(isOpenState);
-  const isOpen = useO(isOpenState);
-  const state = useO(node);
-  const stateType = useO(typeState);
+  const setIsOpen = react.useI(isOpenState);
+  const isOpen = react.useO(isOpenState);
+  const state = react.useO(node);
+  const stateType = react.useO(typeState);
   const isPrimitive = Boolean(primitiveRefinery.refine(state));
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs("header", { children: [
@@ -4444,8 +2426,8 @@ var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
       /* @__PURE__ */ jsxRuntime.jsxs(
         "label",
         {
-          onClick: () => console.log(node, getState(node)),
-          onKeyUp: () => console.log(node, getState(node)),
+          onClick: () => console.log(node, atom_io.getState(node)),
+          onKeyUp: () => console.log(node, atom_io.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: [
@@ -4462,8 +2444,8 @@ var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
   ] });
 };
 var StateIndexTreeNode = ({ node, isOpenState }) => {
-  const setIsOpen = useI(isOpenState);
-  const isOpen = useO(isOpenState);
+  const setIsOpen = react.useI(isOpenState);
+  const isOpen = react.useO(isOpenState);
   for (const [key, childNode] of recordToEntries(node.familyMembers)) {
     findViewIsOpenState(key);
     findStateTypeState(childNode);
@@ -4501,7 +2483,7 @@ var StateIndexNode = ({ node, isOpenState, typeState }) => {
   ) : /* @__PURE__ */ jsxRuntime.jsx(StateIndexTreeNode, { node, isOpenState }) });
 };
 var StateIndex = ({ tokenIndex }) => {
-  const tokenIds = useO(tokenIndex);
+  const tokenIds = react.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,
@@ -4641,9 +2623,9 @@ var YouAreHere = () => {
   return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "you_are_here", children: "you are here" });
 };
 var TimelineLog = ({ token, isOpenState, timelineState }) => {
-  const timeline = useO(timelineState);
-  const isOpen = useO(isOpenState);
-  const setIsOpen = useI(isOpenState);
+  const timeline = react.useO(timelineState);
+  const isOpen = react.useO(isOpenState);
+  const setIsOpen = react.useI(isOpenState);
   return /* @__PURE__ */ jsxRuntime.jsxs("section", { className: "node timeline_log", children: [
     /* @__PURE__ */ jsxRuntime.jsxs("header", { children: [
       /* @__PURE__ */ jsxRuntime.jsx(button.OpenClose, { isOpen, setIsOpen }),
@@ -4662,7 +2644,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
             "button",
             {
               type: "button",
-              onClick: () => undo(token),
+              onClick: () => atom_io.undo(token),
               disabled: timeline.at === 0,
               children: "undo"
             }
@@ -4671,7 +2653,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
             "button",
             {
               type: "button",
-              onClick: () => redo(token),
+              onClick: () => atom_io.redo(token),
               disabled: timeline.at === timeline.history.length,
               children: "redo"
             }
@@ -4679,7 +2661,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
         ] })
       ] })
     ] }),
-    isOpen ? /* @__PURE__ */ jsxRuntime.jsx("main", { children: timeline.history.map((update, index) => /* @__PURE__ */ jsxRuntime.jsxs(React2.Fragment, { children: [
+    isOpen ? /* @__PURE__ */ jsxRuntime.jsx("main", { children: timeline.history.map((update, index) => /* @__PURE__ */ jsxRuntime.jsxs(React.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
@@ -4687,7 +2669,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
   ] });
 };
 var TimelineIndex = () => {
-  const tokenIds = useO(timelineIndex);
+  const tokenIds = react.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,
@@ -4701,9 +2683,9 @@ var TimelineIndex = () => {
   }) });
 };
 var TransactionLog = ({ token, isOpenState, logState }) => {
-  const log = useO(logState);
-  const isOpen = useO(isOpenState);
-  const setIsOpen = useI(isOpenState);
+  const log = react.useO(logState);
+  const isOpen = react.useO(isOpenState);
+  const setIsOpen = react.useI(isOpenState);
   return /* @__PURE__ */ jsxRuntime.jsxs("section", { className: "node transaction_log", children: [
     /* @__PURE__ */ jsxRuntime.jsxs("header", { children: [
       /* @__PURE__ */ jsxRuntime.jsx(button.OpenClose, { isOpen, setIsOpen }),
@@ -4727,7 +2709,7 @@ var TransactionLog = ({ token, isOpenState, logState }) => {
   ] });
 };
 var TransactionIndex = () => {
-  const tokenIds = useO(transactionIndex);
+  const tokenIds = react.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,
@@ -4741,13 +2723,13 @@ var TransactionIndex = () => {
   }) });
 };
 var AtomIODevtools = () => {
-  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);
+  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);
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsx(
       framerMotion.motion.span,
@@ -4823,23 +2805,23 @@ var {
   findTransactionLogState,
   timelineIndex,
   findTimelineState
-} = attachIntrospectionStates();
-var devtoolsAreOpenState = atom({
+} = introspection.attachIntrospectionStates();
+var devtoolsAreOpenState = atom_io.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({
+var devtoolsViewSelectionState = atom_io.atom({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Selection`,
   default: `atoms`,
   effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View`)]
 });
-var devtoolsViewOptionsState = atom({
+var devtoolsViewOptionsState = atom_io.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 = atomFamily({
+var findViewIsOpenState = atom_io.atomFamily({
   key: `\u{1F441}\u200D\u{1F5E8} Devtools View Is Open`,
   default: false,
   effects: (key) => [lazyLocalStorageEffect(key + `:view-is-open`)]