create-atom.io 0.0.1 → 0.0.3

package/templates/base/node_modules/.vite/deps/chunk-6VZTUEOV.js

@@ -1,3777 +0,0 @@
-// ../../../../node_modules/.pnpm/atom.io@0.44.0_@floating-ui+react-dom@2.1.6_@preact+compat@18.3.1_preact@10.27.2__@prea_a385030eab0fd5c9f5ef9e758818d457/node_modules/atom.io/dist/json/index.js
-function parseJson(str) {
-  return JSON.parse(str);
-}
-var stringifyJson = (json) => JSON.stringify(json);
-var JSON_PROTOTYPES = [
-  Array.prototype,
-  Boolean.prototype,
-  Number.prototype,
-  Object.prototype,
-  String.prototype
-];
-
-// ../../../../node_modules/.pnpm/atom.io@0.44.0_@floating-ui+react-dom@2.1.6_@preact+compat@18.3.1_preact@10.27.2__@prea_a385030eab0fd5c9f5ef9e758818d457/node_modules/atom.io/dist/struct/index.js
-function enumeration(values) {
-  const result = {};
-  let i = 0;
-  for (const value of values) {
-    result[value] = i;
-    result[i] = value;
-    ++i;
-  }
-  return result;
-}
-var BOOL = `
`;
-var NULL = ``;
-var STRING = ``;
-var NUMBER = ``;
-var packValue = (value) => {
-  switch (typeof value) {
-    case `string`:
-      return STRING + value;
-    case `number`:
-      return NUMBER + value;
-    case `boolean`:
-      return BOOL + +value;
-    case `object`:
-      return NULL;
-  }
-};
-var unpackValue = (value) => {
-  switch (value[0]) {
-    case STRING:
-      return value.slice(1);
-    case NUMBER:
-      return +value.slice(1);
-    case BOOL:
-      return value.slice(1) === `1`;
-    case NULL:
-      return null;
-  }
-};
-
-// ../../../../node_modules/.pnpm/atom.io@0.44.0_@floating-ui+react-dom@2.1.6_@preact+compat@18.3.1_preact@10.27.2__@prea_a385030eab0fd5c9f5ef9e758818d457/node_modules/atom.io/dist/transceivers/u-list/index.js
-var SET_UPDATE_ENUM = enumeration([
-  `add`,
-  `delete`,
-  `clear`
-]);
-var UList = class UList2 extends Set {
-  mode = `record`;
-  subject = new Subject();
-  constructor(values) {
-    super(values);
-    if (values instanceof UList2) {
-    }
-  }
-  READONLY_VIEW = this;
-  toJSON() {
-    return [...this];
-  }
-  static fromJSON(json) {
-    return new UList2(json);
-  }
-  add(value) {
-    const result = super.add(value);
-    if (this.mode === `record`) this.emit({
-      type: `add`,
-      value
-    });
-    return result;
-  }
-  clear() {
-    const capturedContents = this.mode === `record` ? [...this] : null;
-    super.clear();
-    if (capturedContents) this.emit({
-      type: `clear`,
-      values: capturedContents
-    });
-  }
-  delete(value) {
-    const result = super.delete(value);
-    if (this.mode === `record`) this.emit({
-      type: `delete`,
-      value
-    });
-    return result;
-  }
-  subscribe(key, fn) {
-    return this.subject.subscribe(key, fn);
-  }
-  emit(update) {
-    this.subject.next(UList2.packUpdate(update));
-  }
-  do(packed) {
-    this.mode = `playback`;
-    const update = UList2.unpackUpdate(packed);
-    switch (update.type) {
-      case `add`:
-        this.add(update.value);
-        break;
-      case `delete`:
-        this.delete(update.value);
-        break;
-      case `clear`:
-        this.clear();
-    }
-    this.mode = `record`;
-    return null;
-  }
-  undo(packed) {
-    const update = UList2.unpackUpdate(packed);
-    this.mode = `playback`;
-    switch (update.type) {
-      case `add`:
-        this.delete(update.value);
-        break;
-      case `delete`:
-        this.add(update.value);
-        break;
-      case `clear`: {
-        const values = update.values;
-        for (const v of values) this.add(v);
-      }
-    }
-    this.mode = `record`;
-    return null;
-  }
-  static packUpdate(update) {
-    const head = SET_UPDATE_ENUM[update.type] + ``;
-    if (update.type === `clear`) return head + update.values.map(packValue).join(``);
-    return head + packValue(update.value);
-  }
-  static unpackUpdate(packed) {
-    const [type, tail] = packed.split(``);
-    const head = SET_UPDATE_ENUM[type];
-    if (head === `clear`) return {
-      type: `clear`,
-      values: tail.split(``).map(unpackValue)
-    };
-    return {
-      type: head,
-      value: unpackValue(tail)
-    };
-  }
-};
-
-// ../../../../node_modules/.pnpm/atom.io@0.44.0_@floating-ui+react-dom@2.1.6_@preact+compat@18.3.1_preact@10.27.2__@prea_a385030eab0fd5c9f5ef9e758818d457/node_modules/atom.io/dist/internal/index.js
-function arbitrary(random = Math.random) {
-  return random().toString(36).slice(2);
-}
-function newest(scion) {
-  while (scion.child !== null) scion = scion.child;
-  return scion;
-}
-function eldest(scion) {
-  while (scion.parent !== null) scion = scion.parent;
-  return scion;
-}
-var NON_CTOR_FN_REGEX = /^\[object (?:Async|Generator|AsyncGenerator)?Function\]$/;
-function isFn(input) {
-  const protoString = Object.prototype.toString.call(input);
-  return NON_CTOR_FN_REGEX.test(protoString);
-}
-function become(nextVersionOfThing, originalThing) {
-  if (isFn(nextVersionOfThing)) return nextVersionOfThing(originalThing);
-  return nextVersionOfThing;
-}
-var Future = class extends Promise {
-  fate;
-  resolve;
-  reject;
-  done = false;
-  constructor(executor) {
-    let superResolve;
-    let superReject;
-    super((resolve, reject) => {
-      superResolve = resolve;
-      superReject = reject;
-    });
-    this.resolve = superResolve;
-    this.reject = superReject;
-    this.use(executor instanceof Promise ? executor : new Promise(executor));
-  }
-  pass(promise, value) {
-    if (promise === this.fate) {
-      this.resolve(value);
-      this.done = true;
-    }
-  }
-  fail(promise, reason) {
-    if (promise === this.fate) {
-      this.reject(reason);
-      this.done = true;
-    }
-  }
-  use(value) {
-    if (this === value) return;
-    if (value instanceof Promise) {
-      const promise = value;
-      this.fate = promise;
-      promise.then((resolved) => {
-        this.pass(promise, resolved);
-      }, (reason) => {
-        this.fail(promise, reason);
-      });
-    } else {
-      this.resolve(value);
-      this.fate = void 0;
-    }
-  }
-};
-var Subject = class {
-  Subscriber;
-  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 {
-  state;
-  constructor(initialState) {
-    super();
-    this.state = initialState;
-  }
-  next(value) {
-    this.state = value;
-    super.next(value);
-  }
-};
-var CircularBuffer = class CircularBuffer2 {
-  _buffer;
-  _index = 0;
-  constructor(lengthOrArray) {
-    let length;
-    if (typeof lengthOrArray === `number`) length = lengthOrArray;
-    else length = lengthOrArray.length;
-    this._buffer = Array.from({ length });
-  }
-  get buffer() {
-    return this._buffer;
-  }
-  get index() {
-    return this._index;
-  }
-  add(item) {
-    this._buffer[this._index] = item;
-    this._index = (this._index + 1) % this._buffer.length;
-  }
-  copy() {
-    const copy = new CircularBuffer2([...this._buffer]);
-    copy._index = this._index;
-    return copy;
-  }
-};
-function deposit(state) {
-  const token = {
-    key: state.key,
-    type: state.type
-  };
-  if (`family` in state) token.family = state.family;
-  return token;
-}
-var MapOverlay = class extends Map {
-  deleted = /* @__PURE__ */ new Set();
-  changed = /* @__PURE__ */ new Set();
-  source;
-  constructor(source) {
-    super();
-    this.source = source;
-  }
-  get(key) {
-    if (super.has(key)) return super.get(key);
-    if (!this.deleted.has(key) && this.source.has(key)) return this.source.get(key);
-  }
-  set(key, value) {
-    this.deleted.delete(key);
-    if (this.source.has(key)) this.changed.add(key);
-    return super.set(key, value);
-  }
-  hasOwn(key) {
-    return super.has(key);
-  }
-  has(key) {
-    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
-  }
-  delete(key) {
-    if (this.source.has(key)) {
-      this.deleted.add(key);
-      this.changed.delete(key);
-    }
-    return super.delete(key);
-  }
-  clear() {
-    this.deleted = new Set(this.source.keys());
-    this.changed.clear();
-    super.clear();
-  }
-  *[Symbol.iterator]() {
-    yield* super[Symbol.iterator]();
-    for (const [key, value] of this.source) if (!this.deleted.has(key) && !this.changed.has(key)) yield [key, value];
-  }
-  *entries() {
-    yield* this[Symbol.iterator]();
-  }
-  *keys() {
-    yield* super.keys();
-    for (const key of this.source.keys()) if (!this.deleted.has(key) && !this.changed.has(key)) yield key;
-  }
-  *values() {
-    for (const [, value] of this[Symbol.iterator]()) yield value;
-  }
-  forEach(callbackfn) {
-    for (const [key, value] of this[Symbol.iterator]()) callbackfn(value, key, this);
-  }
-  get size() {
-    return super.size + this.source.size - this.changed.size - this.deleted.size;
-  }
-};
-var SetOverlay = class extends Set {
-  deleted = /* @__PURE__ */ new Set();
-  source;
-  constructor(source) {
-    super();
-    this.source = source;
-  }
-  add(value) {
-    if (this.source.has(value)) {
-      this.deleted.delete(value);
-      return this;
-    }
-    return super.add(value);
-  }
-  hasOwn(member) {
-    return super.has(member);
-  }
-  has(key) {
-    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
-  }
-  delete(key) {
-    if (this.source.has(key)) {
-      this.deleted.add(key);
-      return true;
-    }
-    return super.delete(key);
-  }
-  clear() {
-    this.deleted = new Set(this.source);
-    super.clear();
-  }
-  *[Symbol.iterator]() {
-    yield* super[Symbol.iterator]();
-    for (const value of this.source) if (!this.deleted.has(value)) yield value;
-  }
-  *iterateOwn() {
-    yield* super[Symbol.iterator]();
-  }
-  get size() {
-    return super.size + this.source.size - this.deleted.size;
-  }
-};
-var RelationsOverlay = class extends Map {
-  deleted = /* @__PURE__ */ new Set();
-  source;
-  constructor(source) {
-    super();
-    this.source = source;
-  }
-  get(key) {
-    if (super.has(key)) return super.get(key);
-    if (!this.deleted.has(key) && this.source.has(key)) {
-      const valueOverlay = new SetOverlay(this.source.get(key));
-      super.set(key, valueOverlay);
-      return valueOverlay;
-    }
-  }
-  set(key, value) {
-    this.deleted.delete(key);
-    return super.set(key, value);
-  }
-  has(key) {
-    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
-  }
-  delete(key) {
-    this.deleted.add(key);
-    return super.delete(key);
-  }
-};
-var Junction = class Junction2 {
-  a;
-  b;
-  cardinality;
-  relations = /* @__PURE__ */ new Map();
-  contents = /* @__PURE__ */ new Map();
-  isAType;
-  isBType;
-  isContent;
-  makeContentKey = (a, b) => `${a}:${b}`;
-  warn;
-  getRelatedKeys(key) {
-    return this.relations.get(key);
-  }
-  addRelation(a, b) {
-    let aRelations = this.relations.get(a);
-    let bRelations = this.relations.get(b);
-    if (aRelations) aRelations.add(b);
-    else {
-      aRelations = /* @__PURE__ */ new Set([b]);
-      this.relations.set(a, aRelations);
-    }
-    if (bRelations) bRelations.add(a);
-    else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  deleteRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    if (aRelations) {
-      aRelations.delete(b);
-      if (aRelations.size === 0) this.relations.delete(a);
-      const bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.delete(a);
-        if (bRelations.size === 0) this.relations.delete(b);
-      }
-    }
-  }
-  replaceRelationsUnsafely(x, ys) {
-    this.relations.set(x, new Set(ys));
-    for (const y of ys) {
-      const yRelations = (/* @__PURE__ */ new Set()).add(x);
-      this.relations.set(y, yRelations);
-    }
-  }
-  replaceRelationsSafely(x, ys) {
-    const xRelationsPrev = this.relations.get(x);
-    let a = this.isAType?.(x) ? x : void 0;
-    let b = a === void 0 ? x : void 0;
-    if (xRelationsPrev) for (const y of xRelationsPrev) {
-      a ??= y;
-      b ??= y;
-      const yRelations = this.relations.get(y);
-      if (yRelations) {
-        if (yRelations.size === 1) this.relations.delete(y);
-        else yRelations.delete(x);
-        this.contents.delete(this.makeContentKey(a, b));
-      }
-    }
-    this.relations.set(x, new Set(ys));
-    for (const y of ys) {
-      let yRelations = this.relations.get(y);
-      if (yRelations) yRelations.add(x);
-      else {
-        yRelations = (/* @__PURE__ */ new Set()).add(x);
-        this.relations.set(y, yRelations);
-      }
-    }
-  }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
-  }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
-  }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
-  }
-  constructor(data, config) {
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    this.isAType = config?.isAType ?? null;
-    this.isBType = config?.isBType ?? null;
-    this.isContent = config?.isContent ?? null;
-    if (config?.makeContentKey) this.makeContentKey = config.makeContentKey;
-    if (!config?.externalStore) {
-      const source = config?.source;
-      if (source === void 0) {
-        this.relations = new Map(data.relations?.map(([x, ys]) => [x, new Set(ys)]));
-        this.contents = new Map(data.contents);
-      }
-      if (source) {
-        this.relations = new RelationsOverlay(source.relations);
-        this.contents = new MapOverlay(source.contents);
-      }
-    }
-    if (config?.externalStore) {
-      const externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = ((key) => externalStore.getRelatedKeys(key));
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of data.relations ?? []) {
-        let a = this.isAType?.(x) ? x : void 0;
-        let b = a === void 0 ? x : void 0;
-        for (const y of ys) {
-          a ??= y;
-          b ??= y;
-          this.addRelation(a, b);
-        }
-      }
-      for (const [contentKey, content] of data.contents ?? []) this.setContent(contentKey, content);
-    }
-    if (config?.warn) this.warn = config.warn;
-  }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
-      contents: [...this.contents.entries()]
-    };
-  }
-  set(...params) {
-    let a;
-    let b;
-    let content;
-    switch (params.length) {
-      case 1: {
-        const relation = params[0];
-        a = relation[this.a];
-        b = relation[this.b];
-        content = void 0;
-        break;
-      }
-      case 2: {
-        const zeroth = params[0];
-        if (typeof zeroth === `string`) [a, b] = params;
-        else {
-          a = zeroth[this.a];
-          b = zeroth[this.b];
-          content = params[1];
-        }
-        break;
-      }
-      default:
-        a = params[0];
-        b = params[1];
-        content = params[2];
-        break;
-    }
-    switch (this.cardinality) {
-      case `1:1`: {
-        const bPrev = this.getRelatedKey(a);
-        if (bPrev && bPrev !== b) this.delete(a, bPrev);
-      }
-      case `1:n`:
-        {
-          const aPrev = this.getRelatedKey(b);
-          if (aPrev && aPrev !== a) this.delete(aPrev, b);
-        }
-        break;
-      case `n:n`:
-    }
-    if (content) {
-      const contentKey = this.makeContentKey(a, b);
-      this.setContent(contentKey, content);
-    }
-    this.addRelation(a, b);
-    return this;
-  }
-  delete(x, b) {
-    b = typeof b === `string` ? b : x[this.b];
-    const a = typeof x === `string` ? x : x[this.a];
-    if (a === void 0 && typeof b === `string`) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) for (const bRelation of bRelations) this.delete(bRelation, b);
-    } else if (typeof a === `string` && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) for (const aRelation of aRelations) this.delete(a, aRelation);
-    } else if (typeof a === `string` && typeof b === `string`) {
-      this.deleteRelation(a, b);
-      const contentKey = this.makeContentKey(a, b);
-      this.deleteContent(contentKey);
-    }
-    return this;
-  }
-  getRelatedKey(key) {
-    const relations = this.getRelatedKeys(key);
-    if (relations) {
-      if (relations.size > 1) this.warn?.(`${relations.size} related keys were found for key "${key}": (${[...relations].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`);
-      let singleRelation;
-      for (const relation of relations) {
-        singleRelation = relation;
-        break;
-      }
-      return singleRelation;
-    }
-  }
-  replaceRelations(x, relations, config) {
-    const hasContent = !Array.isArray(relations);
-    const ys = hasContent ? Object.keys(relations) : relations;
-    if (config?.reckless) this.replaceRelationsUnsafely(x, ys);
-    else this.replaceRelationsSafely(x, ys);
-    if (hasContent) for (const y of ys) {
-      const contentKey = this.makeContentKey(x, y);
-      const content = relations[y];
-      this.setContent(contentKey, content);
-    }
-    return this;
-  }
-  getContent(a, b) {
-    const contentKey = this.makeContentKey(a, b);
-    return this.getContentInternal(contentKey);
-  }
-  getRelationEntries(input) {
-    const a = input[this.a];
-    const b = input[this.b];
-    if (a !== void 0 && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) return [...aRelations].map((aRelation) => {
-        return [aRelation, this.getContent(a, aRelation)];
-      });
-    }
-    if (a === void 0 && b !== void 0) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) return [...bRelations].map((bRelation) => {
-        return [bRelation, this.getContent(bRelation, b)];
-      });
-    }
-    return [];
-  }
-  has(a, b) {
-    if (b) return this.getRelatedKeys(a)?.has(b) ?? false;
-    return this.relations.has(a);
-  }
-  overlay() {
-    const config = {
-      source: this,
-      makeContentKey: this.makeContentKey
-    };
-    if (this.isAType) config.isAType = this.isAType;
-    if (this.isBType) config.isBType = this.isBType;
-    if (this.isContent) config.isContent = this.isContent;
-    if (this.warn) config.warn = this.warn;
-    return new Junction2({
-      between: [this.a, this.b],
-      cardinality: this.cardinality
-    }, config);
-  }
-  incorporate(overlay) {
-    const { relations, contents } = overlay;
-    for (const [key, value] of relations) if (value instanceof SetOverlay) {
-      const { source } = value;
-      for (const keyAdded of value.iterateOwn()) source.add(keyAdded);
-    } else this.relations.set(key, value);
-    for (const key of relations.deleted) this.relations.delete(key);
-    for (const [key, value] of contents) this.contents.set(key, value);
-    for (const key of contents.deleted) this.contents.delete(key);
-  }
-};
-function isReservedIntrospectionKey(value) {
-  return value.startsWith(`🔍 `);
-}
-var abortTransaction = (target) => {
-  target.logger.info(`🪂`, `transaction`, target.transactionMeta.update.token.key, `Aborting transaction`);
-  target.parent.child = null;
-};
-function actUponStore(store, token, id) {
-  return (...parameters) => {
-    return withdraw(store, token).run(parameters, id);
-  };
-}
-function ingestAtomUpdateEvent(store, event, applying) {
-  const { token, update: { newValue, oldValue } } = event;
-  setIntoStore(store, token, applying === `newValue` ? newValue : oldValue);
-}
-function getTrace(error) {
-  const { stack } = error;
-  if (stack) return `
-` + stack.split(`
-`)?.slice(1)?.join(`
-`);
-  return ``;
-}
-function makeRootMoleculeInStore(store, key) {
-  const molecule = {
-    key,
-    stringKey: stringifyJson(key),
-    dependsOn: `any`,
-    subject: new Subject()
-  };
-  store.molecules.set(stringifyJson(key), molecule);
-  return key;
-}
-function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
-  const origin = provenance;
-  const stringKey = stringifyJson(key);
-  const invalidKeys = [];
-  const target = newest(store);
-  if (Array.isArray(origin)) for (const formerClaim of origin) {
-    const claimString = stringifyJson(formerClaim);
-    if (target.molecules.get(claimString)) store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-    else invalidKeys.push(claimString);
-  }
-  else {
-    const claimString = stringifyJson(origin);
-    if (target.molecules.get(claimString)) store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-    else invalidKeys.push(claimString);
-  }
-  const subject = new Subject();
-  if (invalidKeys.length === 0) target.molecules.set(stringKey, {
-    key,
-    stringKey,
-    dependsOn,
-    subject
-  });
-  const creationEvent = {
-    type: `molecule_creation`,
-    key,
-    provenance: origin,
-    timestamp: Date.now()
-  };
-  if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.subEvents.push(creationEvent);
-  else target.on.moleculeCreation.next(creationEvent);
-  for (const claim of invalidKeys) {
-    const disposal = store.disposalTraces.buffer.find((item) => item?.key === claim);
-    store.logger.error(`❌`, `key`, key, `allocation failed:`, `Could not allocate to ${claim} in store "${store.config.name}".`, disposal ? `
-   ${claim} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${claim} was found.`);
-  }
-  return key;
-}
-function fuseWithinStore(store, type, sideA, sideB) {
-  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
-  allocateIntoStore(store, [sideA, sideB], compoundKey, `all`);
-  return compoundKey;
-}
-function createDeallocateTX(store) {
-  return createTransaction(store, {
-    key: `[Internal] deallocate`,
-    do: (_, claim) => {
-      deallocateFromStore(newest(store), claim);
-    }
-  });
-}
-function deallocateFromStore(target, claim) {
-  const stringKey = stringifyJson(claim);
-  const molecule = target.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = target.disposalTraces.buffer.find((item) => item?.key === stringKey);
-    target.logger.error(`❌`, `key`, claim, `deallocation failed:`, `Could not find allocation for ${stringKey} in store "${target.config.name}".`, disposal ? `
-   This state was most recently deallocated
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
-    return;
-  }
-  molecule.subject.next();
-  const joinKeys = target.keyRefsInJoins.getRelatedKeys(stringKey);
-  if (joinKeys) for (const joinKey of joinKeys) {
-    const join$1 = target.joins.get(joinKey);
-    if (join$1) join$1.relations.delete(claim);
-  }
-  else {
-    const compound = decomposeCompound(claim);
-    if (compound) {
-      const [, a, b] = compound;
-      const joinKey = target.keyRefsInJoins.getRelatedKey(simpleCompound(a, b));
-      if (joinKey) {
-        const join$1 = target.joins.get(joinKey);
-        if (join$1) join$1.relations.delete(a, b);
-      }
-    }
-  }
-  target.keyRefsInJoins.delete(stringKey);
-  const provenance = [];
-  const values = [];
-  const relatedMolecules = target.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: stringKey });
-  if (relatedMolecules) for (const [relatedStringKey, { source }] of relatedMolecules) if (source === stringKey) deallocateFromStore(target, parseJson(relatedStringKey));
-  else provenance.push(source);
-  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
-  if (familyKeys) for (const familyKey of familyKeys) {
-    const family = target.families.get(familyKey);
-    const value = getFromStore(target, family, claim);
-    values.push([family.key, value]);
-    disposeFromStore(target, family, claim);
-  }
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    key: molecule.key,
-    values,
-    provenance,
-    timestamp: Date.now()
-  };
-  target.molecules.delete(stringKey);
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) target.transactionMeta.update.subEvents.push(disposalEvent);
-  target.moleculeGraph.delete(molecule.stringKey);
-  target.keyRefsInJoins.delete(molecule.stringKey);
-  target.moleculeData.delete(molecule.stringKey);
-  if (!isTransaction) target.on.moleculeDisposal.next(disposalEvent);
-  target.molecules.delete(molecule.stringKey);
-  const trace = getTrace(new Error());
-  target.disposalTraces.add({
-    key: stringKey,
-    trace
-  });
-}
-function createClaimTX(store) {
-  return createTransaction(store, {
-    key: `[Internal] claim`,
-    do: (_, newProvenance, claim, exclusive) => {
-      claimWithinStore(store, newProvenance, claim, exclusive);
-    }
-  });
-}
-function claimWithinStore(store, newProvenance, claim, exclusive) {
-  const stringKey = stringifyJson(claim);
-  const target = newest(store);
-  const molecule = target.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = store.disposalTraces.buffer.find((item) => item?.key === stringKey);
-    store.logger.error(`❌`, `key`, stringKey, `claim failed:`, `Could not allocate to ${stringKey} in store "${store.config.name}".`, disposal ? `
-   ${stringKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
-    return claim;
-  }
-  const newProvenanceKey = stringifyJson(newProvenance);
-  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
-  if (!newProvenanceMolecule) {
-    const disposal = store.disposalTraces.buffer.find((item) => item?.key === newProvenanceKey);
-    store.logger.error(`❌`, `key`, claim, `claim failed:`, `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`, disposal ? `
-   ${newProvenanceKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`);
-    return claim;
-  }
-  const priorProvenance = store.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: molecule.stringKey }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
-  if (exclusive) target.moleculeGraph.delete(stringKey);
-  target.moleculeGraph.set({
-    upstreamMoleculeKey: newProvenanceMolecule.stringKey,
-    downstreamMoleculeKey: molecule.stringKey
-  }, { source: newProvenanceMolecule.stringKey });
-  const transferEvent = {
-    type: `molecule_transfer`,
-    key: molecule.key,
-    exclusive: Boolean(exclusive),
-    from: priorProvenance,
-    to: [newProvenanceMolecule.key],
-    timestamp: Date.now()
-  };
-  if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.subEvents.push(transferEvent);
-  return claim;
-}
-function ingestCreationEvent(store, event, applying) {
-  switch (applying) {
-    case `newValue`:
-      createInStore(store, event);
-      break;
-    case `oldValue`:
-      disposeFromStore(store, event.token);
-      break;
-  }
-}
-function ingestDisposalEvent(store, event, applying) {
-  switch (applying) {
-    case `newValue`:
-      disposeFromStore(store, event.token);
-      break;
-    case `oldValue`:
-      createInStore(store, event);
-      if (event.subType === `atom`) store.valueMap.set(event.token.key, event.value);
-      break;
-  }
-}
-function createInStore(store, event) {
-  const { token } = event;
-  if (event.subType === `writable` && event.value) setIntoStore(store, token, event.value);
-  else getFromStore(store, token);
-}
-function ingestMoleculeCreationEvent(store, event, applying) {
-  switch (applying) {
-    case `newValue`:
-      allocateIntoStore(store, event.provenance, event.key);
-      break;
-    case `oldValue`:
-      deallocateFromStore(store, event.key);
-      break;
-  }
-}
-function ingestMoleculeDisposalEvent(store, event, applying) {
-  switch (applying) {
-    case `newValue`:
-      deallocateFromStore(store, event.key);
-      break;
-    case `oldValue`:
-      allocateIntoStore(store, event.provenance.map(parseJson), event.key);
-      for (const [familyKey, value] of event.values) {
-        const family = store.families.get(familyKey);
-        if (family) {
-          getFromStore(store, family, event.key);
-          const memberKey = `${familyKey}(${stringifyJson(event.key)})`;
-          store.valueMap.set(memberKey, value);
-        }
-      }
-      break;
-  }
-}
-function ingestMoleculeTransferEvent(store, event, applying) {
-  switch (applying) {
-    case `newValue`:
-      for (const newOwner of event.to) claimWithinStore(store, newOwner, event.key, event.exclusive ? `exclusive` : void 0);
-      break;
-    case `oldValue`:
-      {
-        let exclusivity = `exclusive`;
-        for (const previousOwner of event.from) {
-          claimWithinStore(store, previousOwner, event.key, exclusivity);
-          exclusivity = void 0;
-        }
-      }
-      break;
-  }
-}
-function ingestSelectorUpdateEvent(store, selectorUpdate, applying) {
-  let updates;
-  if (applying === `newValue`) updates = selectorUpdate.subEvents;
-  else updates = selectorUpdate.subEvents.toReversed();
-  for (const atomUpdate of updates) if (atomUpdate.type === `state_creation`) ingestCreationEvent(store, atomUpdate, applying);
-  else ingestAtomUpdateEvent(store, atomUpdate, applying);
-}
-function ingestTransactionOutcomeEvent(store, event, applying) {
-  const subEvents = applying === `newValue` ? event.subEvents : [...event.subEvents].reverse();
-  for (const subEvent of subEvents) switch (subEvent.type) {
-    case `atom_update`:
-      ingestAtomUpdateEvent(store, subEvent, applying);
-      break;
-    case `state_creation`:
-      ingestCreationEvent(store, subEvent, applying);
-      break;
-    case `state_disposal`:
-      ingestDisposalEvent(store, subEvent, applying);
-      break;
-    case `molecule_creation`:
-      ingestMoleculeCreationEvent(store, subEvent, applying);
-      break;
-    case `molecule_disposal`:
-      ingestMoleculeDisposalEvent(store, subEvent, applying);
-      break;
-    case `molecule_transfer`:
-      ingestMoleculeTransferEvent(store, subEvent, applying);
-      break;
-    case `transaction_outcome`:
-      ingestTransactionOutcomeEvent(store, subEvent, applying);
-      break;
-  }
-}
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
-}
-function isChildStore(store) {
-  return `phase` in store.transactionMeta;
-}
-function getContinuityKey(store, transactionKey) {
-  return store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
-}
-function getEpochNumberOfContinuity(store, continuityKey) {
-  return store.transactionMeta.epoch.get(continuityKey);
-}
-function getEpochNumberOfAction(store, transactionKey) {
-  const continuityKey = getContinuityKey(store, transactionKey);
-  if (continuityKey === void 0) return;
-  return getEpochNumberOfContinuity(store, continuityKey);
-}
-function setEpochNumberOfAction(store, transactionKey, newEpoch) {
-  const continuityKey = getContinuityKey(store, transactionKey);
-  if (continuityKey !== void 0) store.transactionMeta.epoch.set(continuityKey, newEpoch);
-}
-function applyTransaction(store, output) {
-  const child = newest(store);
-  const { parent } = child;
-  child.transactionMeta.phase = `applying`;
-  child.transactionMeta.update.output = output;
-  parent.child = null;
-  parent.on.transactionApplying.next(child.transactionMeta);
-  const { subEvents: updates } = child.transactionMeta.update;
-  store.logger.info(`🛄`, `transaction`, child.transactionMeta.update.token.key, `applying ${updates.length} subEvents:`, updates);
-  ingestTransactionOutcomeEvent(parent, child.transactionMeta.update, `newValue`);
-  if (isRootStore(parent)) {
-    setEpochNumberOfAction(parent, child.transactionMeta.update.token.key, child.transactionMeta.update.epoch);
-    withdraw(store, {
-      key: child.transactionMeta.update.token.key,
-      type: `transaction`
-    })?.subject.next(child.transactionMeta.update);
-    store.logger.info(`🛬`, `transaction`, child.transactionMeta.update.token.key, `applied`);
-  } else if (isChildStore(parent)) parent.transactionMeta.update.subEvents.push(child.transactionMeta.update);
-  parent.on.transactionApplying.next(null);
-}
-function getEnvironmentData(store) {
-  return { store };
-}
-var buildTransaction = (store, token, params, id) => {
-  const parent = newest(store);
-  const childBase = {
-    parent,
-    child: null,
-    on: parent.on,
-    loggers: parent.loggers,
-    logger: parent.logger,
-    config: parent.config,
-    atoms: new MapOverlay(parent.atoms),
-    atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
-    families: new MapOverlay(parent.families),
-    joins: new MapOverlay(parent.joins),
-    operation: { open: false },
-    readonlySelectors: new MapOverlay(parent.readonlySelectors),
-    timelines: new MapOverlay(parent.timelines),
-    timelineTopics: parent.timelineTopics.overlay(),
-    trackers: /* @__PURE__ */ new Map(),
-    transactions: new MapOverlay(parent.transactions),
-    selectorAtoms: parent.selectorAtoms.overlay(),
-    selectorGraph: parent.selectorGraph.overlay(),
-    writableSelectors: new MapOverlay(parent.writableSelectors),
-    valueMap: new MapOverlay(parent.valueMap),
-    defaults: parent.defaults,
-    disposalTraces: store.disposalTraces.copy(),
-    molecules: new MapOverlay(parent.molecules),
-    moleculeGraph: parent.moleculeGraph.overlay(),
-    moleculeData: parent.moleculeData.overlay(),
-    keyRefsInJoins: parent.keyRefsInJoins.overlay(),
-    miscResources: new MapOverlay(parent.miscResources)
-  };
-  const epoch = getEpochNumberOfAction(store, token.key);
-  const transactionMeta = {
-    phase: `building`,
-    update: {
-      type: `transaction_outcome`,
-      token,
-      id,
-      epoch: epoch === void 0 ? NaN : epoch + 1,
-      timestamp: Date.now(),
-      subEvents: [],
-      params,
-      output: void 0
-    },
-    toolkit: {
-      get: ((...ps) => getFromStore(child, ...ps)),
-      set: ((...ps) => {
-        setIntoStore(child, ...ps);
-      }),
-      reset: ((...ps) => {
-        resetInStore(child, ...ps);
-      }),
-      run: (t, identifier = arbitrary()) => actUponStore(child, t, identifier),
-      find: ((...ps) => findInStore(store, ...ps)),
-      json: (t) => getJsonToken(child, t),
-      dispose: ((...ps) => {
-        disposeFromStore(child, ...ps);
-      }),
-      env: () => getEnvironmentData(child)
-    }
-  };
-  const child = Object.assign(childBase, { transactionMeta });
-  parent.child = child;
-  store.logger.info(`🛫`, `transaction`, token.key, `building with params:`, params);
-  return child;
-};
-function createTransaction(store, options) {
-  const { key } = options;
-  const transactionAlreadyExists = store.transactions.has(key);
-  const newTransaction = {
-    key,
-    type: `transaction`,
-    run: (params, id) => {
-      const target = buildTransaction(store, deposit(newTransaction), params, id);
-      try {
-        const { toolkit } = target.transactionMeta;
-        const output = options.do(toolkit, ...params);
-        applyTransaction(target, output);
-        return output;
-      } catch (thrown) {
-        abortTransaction(target);
-        store.logger.warn(`💥`, `transaction`, key, `caught:`, thrown);
-        throw thrown;
-      }
-    },
-    install: (s) => createTransaction(s, options),
-    subject: new Subject()
-  };
-  newest(store).transactions.set(key, newTransaction);
-  const token = deposit(newTransaction);
-  if (!transactionAlreadyExists) store.on.transactionCreation.next(token);
-  return token;
-}
-var Store = class {
-  parent = null;
-  child = null;
-  valueMap = /* @__PURE__ */ new Map();
-  defaults = /* @__PURE__ */ new Map();
-  atoms = /* @__PURE__ */ new Map();
-  writableSelectors = /* @__PURE__ */ new Map();
-  readonlySelectors = /* @__PURE__ */ new Map();
-  atomsThatAreDefault = /* @__PURE__ */ new Set();
-  selectorAtoms = new Junction({
-    between: [`selectorKey`, `atomKey`],
-    cardinality: `n:n`
-  });
-  selectorGraph = new Junction({
-    between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
-    cardinality: `n:n`
-  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
-  trackers = /* @__PURE__ */ new Map();
-  families = /* @__PURE__ */ new Map();
-  joins = /* @__PURE__ */ new Map();
-  transactions = /* @__PURE__ */ new Map();
-  transactionMeta = {
-    epoch: /* @__PURE__ */ new Map(),
-    actionContinuities: new Junction({
-      between: [`continuity`, `action`],
-      cardinality: `1:n`
-    })
-  };
-  timelines = /* @__PURE__ */ new Map();
-  timelineTopics = new Junction({
-    between: [`timelineKey`, `topicKey`],
-    cardinality: `1:n`
-  });
-  disposalTraces = new CircularBuffer(100);
-  molecules = /* @__PURE__ */ new Map();
-  moleculeGraph = new Junction({
-    between: [`upstreamMoleculeKey`, `downstreamMoleculeKey`],
-    cardinality: `n:n`
-  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
-  moleculeData = new Junction({
-    between: [`moleculeKey`, `stateFamilyKey`],
-    cardinality: `n:n`
-  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
-  keyRefsInJoins = new Junction({
-    between: [`moleculeKey`, `joinKey`],
-    cardinality: `n:n`
-  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
-  miscResources = /* @__PURE__ */ new Map();
-  on = {
-    atomCreation: new Subject(),
-    atomDisposal: new Subject(),
-    selectorCreation: new Subject(),
-    selectorDisposal: new Subject(),
-    timelineCreation: new Subject(),
-    transactionCreation: new Subject(),
-    transactionApplying: new StatefulSubject(null),
-    operationClose: new Subject(),
-    moleculeCreation: new Subject(),
-    moleculeDisposal: new Subject()
-  };
-  operation = { open: false };
-  config = {
-    name: `IMPLICIT_STORE`,
-    lifespan: `ephemeral`,
-    isProduction: globalThis.process?.env?.[`NODE_ENV`] === `production`
-  };
-  loggers = [new AtomIOLogger(`warn`, (_, __, key) => !isReservedIntrospectionKey(key))];
-  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);
-    }
-  };
-  constructor(config, store = null) {
-    this.config = {
-      ...store?.config,
-      ...config
-    };
-    if (store !== null) {
-      this.operation = { ...store?.operation };
-      if (isRootStore(store)) this.transactionMeta = {
-        epoch: new Map(store?.transactionMeta.epoch),
-        actionContinuities: new Junction(store?.transactionMeta.actionContinuities.toJSON())
-      };
-      for (const [, family] of store.families) {
-        if (family.internalRoles?.includes(`mutable`) || family.internalRoles?.includes(`join`)) continue;
-        family.install(this);
-      }
-      const mutableHelpers = /* @__PURE__ */ new Set();
-      for (const [, atom2] of store.atoms) {
-        if (mutableHelpers.has(atom2.key)) continue;
-        atom2.install(this);
-        if (atom2.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(store, atom2);
-          const originalUpdateToken = getUpdateToken(atom2);
-          mutableHelpers.add(originalJsonToken.key);
-          mutableHelpers.add(originalUpdateToken.key);
-        }
-      }
-      for (const [, selector2] of store.readonlySelectors) selector2.install(this);
-      for (const [, selector2] of store.writableSelectors) {
-        if (mutableHelpers.has(selector2.key)) continue;
-        selector2.install(this);
-      }
-      for (const [, tx] of store.transactions) tx.install(this);
-      for (const [, timeline2] of store.timelines) timeline2.install(this);
-    }
-  }
-};
-var IMPLICIT = { get STORE() {
-  globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
-    name: `IMPLICIT_STORE`,
-    lifespan: `ephemeral`,
-    isProduction: globalThis.process?.env?.[`NODE_ENV`] === `production`
-  });
-  return globalThis.ATOM_IO_IMPLICIT_STORE;
-} };
-var NotFoundError = class extends Error {
-  constructor(token, store) {
-    super(`${PRETTY_TOKEN_TYPES[token.type]} ${stringifyJson(token.key)} not found in store "${store.config.name}".`);
-  }
-};
-function withdraw(store, token) {
-  let withdrawn;
-  let target = store;
-  while (target !== null) {
-    switch (token.type) {
-      case `atom`:
-      case `mutable_atom`:
-        withdrawn = target.atoms.get(token.key);
-        break;
-      case `writable_pure_selector`:
-      case `writable_held_selector`:
-        withdrawn = target.writableSelectors.get(token.key);
-        break;
-      case `readonly_pure_selector`:
-      case `readonly_held_selector`:
-        withdrawn = target.readonlySelectors.get(token.key);
-        break;
-      case `atom_family`:
-      case `mutable_atom_family`:
-      case `writable_pure_selector_family`:
-      case `readonly_pure_selector_family`:
-      case `writable_held_selector_family`:
-      case `readonly_held_selector_family`:
-        withdrawn = target.families.get(token.key);
-        break;
-      case `timeline`:
-        withdrawn = target.timelines.get(token.key);
-        break;
-      case `transaction`:
-        withdrawn = target.transactions.get(token.key);
-        break;
-    }
-    if (withdrawn) return withdrawn;
-    target = target.child;
-  }
-  throw new NotFoundError(token, store);
-}
-function getFallback(store, token, family, subKey) {
-  const disposal = store.disposalTraces.buffer.find((item) => item?.key === stringifyJson(subKey));
-  store.logger.error(`❌`, token.type, token.key, `gets a fallback value because key`, subKey, `is not allocated`, disposal ? `This key was previously disposed:
-${disposal.trace}` : `(no previous disposal trace found)`);
-  switch (family.type) {
-    case `mutable_atom_family`: {
-      if (store.defaults.has(family.key)) return store.defaults.get(family.key);
-      const defaultValue = new family.class();
-      store.defaults.set(family.key, defaultValue);
-      return defaultValue.READONLY_VIEW;
-    }
-    case `atom_family`: {
-      if (store.defaults.has(family.key)) return store.defaults.get(family.key);
-      const def = family.default;
-      const defaultValue = def(subKey);
-      store.defaults.set(family.key, defaultValue);
-      return defaultValue;
-    }
-    case `readonly_pure_selector_family`:
-    case `writable_pure_selector_family`:
-    case `readonly_held_selector_family`:
-    case `writable_held_selector_family`: {
-      if (store.defaults.has(family.key)) return store.defaults.get(family.key);
-      const defaultValue = family.default(subKey);
-      store.defaults.set(family.key, defaultValue);
-      return defaultValue;
-    }
-  }
-}
-function safeCompute(target, state) {
-  const { type, key, catch: canCatch } = state;
-  switch (type) {
-    case `readonly_pure_selector`:
-    case `writable_pure_selector`: {
-      let val;
-      target.logger.info(`🧮`, type, key, `computing value`);
-      try {
-        val = state.getFrom(target);
-        if (val instanceof Promise) return val.catch((thrown) => {
-          target.logger.error(`💥`, type, key, `rejected:`, thrown);
-          if (canCatch) {
-            for (const Class of canCatch) if (thrown instanceof Class) return thrown;
-          }
-          throw thrown;
-        });
-      } catch (e) {
-        target.logger.error(`💥`, type, key, `rejected:`, e);
-        if (canCatch) {
-          for (const Class of canCatch) if (e instanceof Class) return writeToCache(target, state, e);
-        }
-        throw e;
-      }
-      return writeToCache(target, state, val);
-    }
-    case `atom`: {
-      let def;
-      if (isFn(state.default)) try {
-        def = state.default();
-        if (def instanceof Promise) def = def.catch((thrown) => {
-          target.logger.error(`💥`, type, key, `rejected:`, thrown);
-          if (canCatch) {
-            for (const Class of canCatch) if (thrown instanceof Class) return thrown;
-          }
-          throw thrown;
-        });
-      } catch (e) {
-        target.logger.error(`💥`, type, key, `rejected:`, e);
-        if (canCatch) {
-          for (const Class of canCatch) if (e instanceof Class) {
-            def = writeToCache(target, state, e);
-            target.logger.info(`✨`, state.type, key, `computed default`, def);
-            return def;
-          }
-        }
-        throw e;
-      }
-      else {
-        def = state.default;
-        target.logger.info(`✨`, state.type, key, `using static default`, def);
-      }
-      return writeToCache(target, state, def);
-    }
-  }
-}
-function readOrComputeValue(target, state, mut) {
-  if (target.valueMap.has(state.key)) return readFromCache(target, state, mut);
-  target.logger.info(`❔`, state.type, state.key, `value not found in cache`);
-  const { key } = state;
-  switch (state.type) {
-    case `readonly_held_selector`:
-    case `writable_held_selector`:
-      target.logger.info(`🧮`, state.type, key, `computing value`);
-      return state.getFrom(target);
-    case `writable_pure_selector`:
-    case `readonly_pure_selector`:
-    case `atom`:
-      return safeCompute(target, state);
-    case `mutable_atom`: {
-      const instance = new state.class();
-      target.logger.info(`✨`, state.type, key, `created new instance`, instance);
-      return writeToCache(target, state, instance);
-    }
-  }
-}
-function getFamilyOfToken(store, token) {
-  return withdraw(store, {
-    key: token.family.key,
-    type: `${token.type}_family`
-  });
-}
-var FAMILY_MEMBER_TOKEN_TYPES = {
-  atom_family: `atom`,
-  molecule_family: `molecule`,
-  mutable_atom_family: `mutable_atom`,
-  readonly_held_selector_family: `readonly_held_selector`,
-  readonly_pure_selector_family: `readonly_pure_selector`,
-  writable_held_selector_family: `writable_held_selector`,
-  writable_pure_selector_family: `writable_pure_selector`
-};
-var MUST_CREATE = Symbol(`MUST_CREATE`);
-var DO_NOT_CREATE = Symbol(`DO_NOT_CREATE`);
-function mintInStore(mustCreate, store, family, key) {
-  const stringKey = stringifyJson(key);
-  const molecule = store.molecules.get(stringKey);
-  if (!molecule && store.config.lifespan === `immortal`) {
-    const { type: familyType, key: familyKey } = family;
-    store.logger.warn(`💣`, `key`, stringKey, `was used to mint a counterfeit token for`, familyType, `"${familyKey}"`);
-    return {
-      counterfeit: true,
-      key: `${familyKey}(${stringKey})`,
-      type: FAMILY_MEMBER_TOKEN_TYPES[familyType],
-      family: {
-        key: familyKey,
-        subKey: stringKey
-      }
-    };
-  }
-  let token;
-  if (mustCreate === MUST_CREATE) {
-    store.logger.info(`👪`, family.type, family.key, `adds member`, typeof key === `string` ? `\`${key}\`` : key);
-    token = family.create(key);
-    if (molecule) store.moleculeData.set(stringKey, family.key);
-  } else {
-    const { type: familyType, key: familyKey } = family;
-    return {
-      key: `${familyKey}(${stringKey})`,
-      type: FAMILY_MEMBER_TOKEN_TYPES[familyType],
-      family: {
-        key: familyKey,
-        subKey: stringKey
-      }
-    };
-  }
-  return token;
-}
-function reduceReference(store, ...params) {
-  let existingToken;
-  let brandNewToken;
-  let family;
-  let subKey;
-  let token;
-  if (params.length === 1) {
-    token = params[0];
-    if (`family` in token) {
-      const familyToken = getFamilyOfToken(store, token);
-      family = withdraw(store, familyToken);
-      subKey = parseJson(token.family.subKey);
-      existingToken = seekInStore(store, familyToken, subKey);
-      if (`counterfeit` in token) return {
-        token,
-        family,
-        subKey,
-        isNew: false
-      };
-      if (!existingToken) {
-        brandNewToken = mintInStore(MUST_CREATE, store, familyToken, subKey);
-        token = brandNewToken;
-      } else token = existingToken;
-    }
-  } else {
-    family = withdraw(store, params[0]);
-    subKey = params[1];
-    existingToken = seekInStore(store, family, subKey);
-    if (!existingToken) {
-      brandNewToken = mintInStore(MUST_CREATE, store, family, subKey);
-      token = brandNewToken;
-    } else token = existingToken;
-  }
-  const isCounterfeit = `counterfeit` in token;
-  if (Boolean(brandNewToken) && isCounterfeit === false && family) {
-    let subType;
-    switch (token.type) {
-      case `readonly_pure_selector`:
-      case `readonly_held_selector`:
-        subType = `readable`;
-        break;
-      case `atom`:
-      case `mutable_atom`:
-      case `writable_pure_selector`:
-      case `writable_held_selector`:
-        subType = `writable`;
-        break;
-    }
-    const stateCreationEvent = {
-      type: `state_creation`,
-      subType,
-      token,
-      timestamp: Date.now()
-    };
-    family.subject.next(stateCreationEvent);
-    const target = newest(store);
-    if (token.family) {
-      if (isRootStore(target)) switch (token.type) {
-        case `atom`:
-        case `mutable_atom`:
-          store.on.atomCreation.next(token);
-          break;
-        case `writable_pure_selector`:
-        case `readonly_pure_selector`:
-        case `writable_held_selector`:
-        case `readonly_held_selector`:
-          store.on.selectorCreation.next(token);
-          break;
-      }
-      else if (isChildStore(target) && target.on.transactionApplying.state === null) target.transactionMeta.update.subEvents.push(stateCreationEvent);
-    }
-  }
-  return {
-    token,
-    family,
-    subKey,
-    isNew: Boolean(brandNewToken)
-  };
-}
-function getFromStore(store, ...params) {
-  const { token, family, subKey } = reduceReference(store, ...params);
-  if (`counterfeit` in token && family && subKey) return getFallback(store, token, family, subKey);
-  return readOrComputeValue(store, withdraw(store, token));
-}
-function seekInStore(store, token, key) {
-  const subKey = stringifyJson(key);
-  const fullKey = `${token.key}(${subKey})`;
-  const target = newest(store);
-  let state;
-  switch (token.type) {
-    case `atom_family`:
-    case `mutable_atom_family`:
-      state = target.atoms.get(fullKey);
-      break;
-    case `writable_held_selector_family`:
-    case `writable_pure_selector_family`:
-      state = target.writableSelectors.get(fullKey);
-      break;
-    case `readonly_held_selector_family`:
-    case `readonly_pure_selector_family`:
-      state = target.readonlySelectors.get(fullKey);
-      break;
-  }
-  if (state) return deposit(state);
-  return state;
-}
-function findInStore(store, familyToken, key) {
-  const family = withdraw(store, familyToken);
-  const existingStateToken = seekInStore(store, familyToken, key);
-  if (existingStateToken) return existingStateToken;
-  return mintInStore(DO_NOT_CREATE, store, family, key);
-}
-function createReadonlyPureSelectorFamily(store, options, internalRoles) {
-  const familyKey = options.key;
-  const type = `readonly_pure_selector_family`;
-  const familyToken = {
-    key: familyKey,
-    type
-  };
-  const existing = store.families.get(familyKey);
-  if (existing && store.config.isProduction === true) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
-  const subject = new Subject();
-  const create = (key) => {
-    const subKey = stringifyJson(key);
-    const family = {
-      key: familyKey,
-      subKey
-    };
-    const fullKey = `${familyKey}(${subKey})`;
-    const target = newest(store);
-    const individualOptions = {
-      key: fullKey,
-      get: options.get(key)
-    };
-    if (options.catch) individualOptions.catch = options.catch;
-    return createReadonlyPureSelector(target, individualOptions, family);
-  };
-  const readonlySelectorFamily = {
-    ...familyToken,
-    create,
-    internalRoles,
-    subject,
-    install: (s) => createReadonlyPureSelectorFamily(s, options),
-    default: (key) => {
-      return options.get(key)({
-        get: ((...args) => getFromStore(store, ...args)),
-        find: ((...args) => findInStore(store, ...args)),
-        json: (token) => getJsonToken(store, token)
-      });
-    }
-  };
-  store.families.set(familyKey, readonlySelectorFamily);
-  return familyToken;
-}
-function createRegularAtomFamily(store, options, internalRoles) {
-  const familyToken = {
-    key: options.key,
-    type: `atom_family`
-  };
-  const existing = store.families.get(options.key);
-  if (existing && store.config.isProduction === true) store.logger.error(`❗`, `atom_family`, options.key, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
-  const subject = new Subject();
-  const create = (key) => {
-    const subKey = stringifyJson(key);
-    const family = {
-      key: options.key,
-      subKey
-    };
-    const fullKey = `${options.key}(${subKey})`;
-    const target = newest(store);
-    const def = options.default;
-    const individualOptions = {
-      key: fullKey,
-      default: isFn(def) ? () => def(key) : def
-    };
-    if (options.effects) individualOptions.effects = options.effects(key);
-    if (options.catch) individualOptions.catch = options.catch;
-    return createRegularAtom(target, individualOptions, family);
-  };
-  const atomFamily$1 = {
-    ...familyToken,
-    create,
-    default: options.default,
-    subject,
-    install: (s) => createRegularAtomFamily(s, options),
-    internalRoles
-  };
-  store.families.set(options.key, atomFamily$1);
-  if (isFn(options.default) === false) store.defaults.set(options.key, options.default);
-  return familyToken;
-}
-function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
-  const familyKey = options.key;
-  const type = `readonly_held_selector_family`;
-  const familyToken = {
-    key: familyKey,
-    type
-  };
-  const existing = store.families.get(familyKey);
-  if (existing && store.config.isProduction === true) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
-  const subject = new Subject();
-  const create = (key) => {
-    const subKey = stringifyJson(key);
-    const family = {
-      key: familyKey,
-      subKey
-    };
-    const fullKey = `${familyKey}(${subKey})`;
-    return createReadonlyHeldSelector(newest(store), {
-      key: fullKey,
-      const: options.const(key),
-      get: options.get(key)
-    }, family);
-  };
-  const readonlySelectorFamily = {
-    ...familyToken,
-    create,
-    internalRoles,
-    subject,
-    install: (s) => createReadonlyHeldSelectorFamily(s, options),
-    default: options.const
-  };
-  store.families.set(familyKey, readonlySelectorFamily);
-  return familyToken;
-}
-function createWritableHeldSelectorFamily(store, options, internalRoles) {
-  const familyKey = options.key;
-  const type = `writable_held_selector_family`;
-  const familyToken = {
-    key: familyKey,
-    type
-  };
-  const existing = store.families.get(familyKey);
-  if (existing && store.config.isProduction === true) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
-  const subject = new Subject();
-  const create = (key) => {
-    const subKey = stringifyJson(key);
-    const family = {
-      key: familyKey,
-      subKey
-    };
-    const fullKey = `${familyKey}(${subKey})`;
-    return createWritableHeldSelector(newest(store), {
-      key: fullKey,
-      const: options.const(key),
-      get: options.get(key),
-      set: options.set(key)
-    }, family);
-  };
-  const selectorFamily$1 = {
-    ...familyToken,
-    create,
-    internalRoles,
-    subject,
-    install: (s) => createWritableHeldSelectorFamily(s, options),
-    default: options.const
-  };
-  store.families.set(familyKey, selectorFamily$1);
-  return familyToken;
-}
-function createWritablePureSelectorFamily(store, options, internalRoles) {
-  const familyKey = options.key;
-  const type = `writable_pure_selector_family`;
-  const familyToken = {
-    key: familyKey,
-    type
-  };
-  const existing = store.families.get(familyKey);
-  if (existing && store.config.isProduction === true) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
-  const subject = new Subject();
-  const create = (key) => {
-    const subKey = stringifyJson(key);
-    const family = {
-      key: familyKey,
-      subKey
-    };
-    const fullKey = `${familyKey}(${subKey})`;
-    const target = newest(store);
-    const individualOptions = {
-      key: fullKey,
-      get: options.get(key),
-      set: options.set(key)
-    };
-    if (options.catch) individualOptions.catch = options.catch;
-    return createWritablePureSelector(target, individualOptions, family);
-  };
-  const selectorFamily$1 = {
-    ...familyToken,
-    create,
-    internalRoles,
-    subject,
-    install: (s) => createWritablePureSelectorFamily(s, options),
-    default: (key) => {
-      return options.get(key)({
-        get: ((...args) => getFromStore(store, ...args)),
-        find: ((...args) => findInStore(store, ...args)),
-        json: (token) => getJsonToken(store, token)
-      });
-    }
-  };
-  store.families.set(familyKey, selectorFamily$1);
-  return familyToken;
-}
-function createSelectorFamily(store, options) {
-  const isWritable = `set` in options;
-  const isHeld = `const` in options;
-  if (isHeld && isWritable) return createWritableHeldSelectorFamily(store, options, void 0);
-  if (isHeld) return createReadonlyHeldSelectorFamily(store, options, void 0);
-  if (isWritable) return createWritablePureSelectorFamily(store, options);
-  return createReadonlyPureSelectorFamily(store, options);
-}
-function disposeFromStore(store, ...params) {
-  let token;
-  if (params.length === 1) token = params[0];
-  else {
-    const family = params[0];
-    const key = params[1];
-    token = findInStore(store, family, key);
-  }
-  try {
-    withdraw(store, token);
-  } catch (_) {
-    store.logger.error(`❌`, token.type, token.key, `could not be disposed because it was not found in the store "${store.config.name}".`);
-    return;
-  }
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      disposeAtom(store, token);
-      break;
-    case `writable_pure_selector`:
-    case `readonly_pure_selector`:
-    case `writable_held_selector`:
-    case `readonly_held_selector`:
-      disposeSelector(store, token);
-      break;
-  }
-}
-function openOperation(store, token) {
-  if (store.operation.open) {
-    const rejectionTime = performance.now();
-    store.logger.info(`🚫`, token.type, token.key, `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`);
-    return rejectionTime;
-  }
-  store.operation = {
-    open: true,
-    done: /* @__PURE__ */ new Set(),
-    prev: /* @__PURE__ */ new Map(),
-    timestamp: Date.now(),
-    token,
-    subEvents: []
-  };
-  store.logger.info(`⭕`, token.type, token.key, `operation start in store "${store.config.name}"${isChildStore(store) ? ` ${store.transactionMeta.phase} "${store.transactionMeta.update.token.key}"` : ``}`);
-  return store;
-}
-function closeOperation(store) {
-  if (store.operation.open) store.logger.info(`🔴`, store.operation.token.type, store.operation.token.key, `operation done in store "${store.config.name}"`);
-  store.operation = { open: false };
-  store.on.operationClose.next(store.operation);
-}
-var isDone = (store, key) => {
-  if (!store.operation.open) {
-    store.logger.error(`🐞`, `unknown`, key, `isDone called outside of an operation. This is probably a bug in AtomIO.`);
-    return true;
-  }
-  return store.operation.done.has(key);
-};
-var markDone = (store, key) => {
-  if (!store.operation.open) {
-    store.logger.error(`🐞`, `unknown`, key, `markDone called outside of an operation. This is probably a bug in AtomIO.`);
-    return;
-  }
-  store.operation.done.add(key);
-};
-function dispatchOrDeferStateUpdate(target, state, { oldValue, newValue }, stateIsNewlyCreated, family) {
-  const token = deposit(state);
-  if (stateIsNewlyCreated && family) {
-    state.subject.next({ newValue });
-    const stateCreationEvent = {
-      checkpoint: true,
-      type: `state_creation`,
-      subType: `writable`,
-      token,
-      timestamp: Date.now(),
-      value: newValue
-    };
-    target.operation.subEvents.push(stateCreationEvent);
-    family.subject.next(stateCreationEvent);
-    const innerTarget = newest(target);
-    if (token.family) {
-      if (isRootStore(innerTarget)) switch (token.type) {
-        case `atom`:
-        case `mutable_atom`:
-          target.on.atomCreation.next(token);
-          break;
-        case `writable_pure_selector`:
-        case `writable_held_selector`:
-          target.on.selectorCreation.next(token);
-          break;
-      }
-      else if (isChildStore(innerTarget) && innerTarget.on.transactionApplying.state === null) innerTarget.transactionMeta.update.subEvents.push(stateCreationEvent);
-    }
-    return;
-  }
-  const { key, subject, type } = state;
-  const update = {
-    oldValue: isTransceiver(oldValue) ? oldValue.READONLY_VIEW : oldValue,
-    newValue: isTransceiver(newValue) ? newValue.READONLY_VIEW : newValue
-  };
-  if (isRootStore(target)) {
-    switch (type) {
-      case `mutable_atom`:
-        target.logger.info(`📢`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers.keys());
-        break;
-      case `atom`:
-      case `writable_pure_selector`:
-      case `writable_held_selector`:
-        target.logger.info(`📢`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers.keys());
-    }
-    subject.next(update);
-  }
-  if (isChildStore(target) && (type === `mutable_atom` || type === `atom`)) {
-    if (target.on.transactionApplying.state === null) {
-      if (isTransceiver(newValue)) return;
-      const { timestamp } = target.operation;
-      const atomUpdate = {
-        type: `atom_update`,
-        token,
-        timestamp,
-        update
-      };
-      target.transactionMeta.update.subEvents.push(atomUpdate);
-      target.logger.info(`📁`, `atom`, key, `stowed (`, oldValue, `->`, newValue, `)`);
-      return;
-    }
-    if (hasRole(state, `tracker:signal`)) {
-      const keyOfMutable = key.slice(1);
-      const mutable = target.atoms.get(keyOfMutable);
-      if (readOrComputeValue(target, mutable, `mut`).do(update.newValue) === null === true) evictDownstreamFromAtom(target, mutable);
-    }
-  }
-}
-var setAtom = (target, atom2, next) => {
-  const oldValue = readOrComputeValue(target, atom2, `mut`);
-  let newValue = become(next, oldValue);
-  target.logger.info(`⭐`, `atom`, atom2.key, `setting value`, newValue);
-  newValue = writeToCache(target, atom2, newValue);
-  markDone(target, atom2.key);
-  evictDownstreamFromAtom(target, atom2);
-  return {
-    oldValue,
-    newValue
-  };
-};
-function resetAtom(target, atom2) {
-  switch (atom2.type) {
-    case `mutable_atom`:
-      return setAtom(target, atom2, new atom2.class());
-    case `atom`: {
-      let def;
-      if (isFn(atom2.default)) def = safeCompute(target, atom2);
-      else def = atom2.default;
-      return setAtom(target, atom2, def);
-    }
-  }
-}
-function resetAtomOrSelector(target, state) {
-  let protoUpdate;
-  switch (state.type) {
-    case `atom`:
-    case `mutable_atom`:
-      protoUpdate = resetAtom(target, state);
-      break;
-    case `writable_held_selector`:
-      {
-        const atoms = traceRootSelectorAtoms(target, state.key);
-        for (const atom2 of atoms.values()) dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom2), false);
-        const value = state.getFrom(target);
-        protoUpdate = {
-          oldValue: value,
-          newValue: value
-        };
-      }
-      break;
-    case `writable_pure_selector`:
-      {
-        const oldValue = safeCompute(target, state);
-        const atoms = traceRootSelectorAtoms(target, state.key);
-        for (const atom2 of atoms.values()) dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom2), false);
-        protoUpdate = {
-          oldValue,
-          newValue: safeCompute(target, state)
-        };
-      }
-      break;
-  }
-  return protoUpdate;
-}
-function setIntoStore(store, ...params) {
-  operateOnStore(OWN_OP, store, ...params);
-}
-var RESET_STATE = Symbol(`RESET`);
-function resetInStore(store, ...params) {
-  setIntoStore(store, ...[...params, RESET_STATE]);
-}
-function setSelector(target, selector2, next) {
-  let oldValue;
-  let newValue;
-  let constant;
-  const { type, key } = selector2;
-  switch (selector2.type) {
-    case `writable_pure_selector`:
-      oldValue = readOrComputeValue(target, selector2, `mut`);
-      newValue = become(next, oldValue);
-      newValue = writeToCache(target, selector2, newValue);
-      break;
-    case `writable_held_selector`:
-      constant = selector2.const;
-      become(next, constant);
-      oldValue = constant;
-      newValue = constant;
-  }
-  target.logger.info(`⭐`, type, key, `setting to`, newValue);
-  markDone(target, key);
-  selector2.setSelf(newValue);
-  return {
-    oldValue,
-    newValue
-  };
-}
-var setAtomOrSelector = (target, state, value) => {
-  let protoUpdate;
-  switch (state.type) {
-    case `atom`:
-    case `mutable_atom`:
-      protoUpdate = setAtom(target, state, value);
-      break;
-    case `writable_pure_selector`:
-    case `writable_held_selector`:
-      protoUpdate = setSelector(target, state, value);
-      break;
-  }
-  return protoUpdate;
-};
-var OWN_OP = Symbol(`OWN_OP`);
-var JOIN_OP = Symbol(`JOIN_OP`);
-function operateOnStore(opMode, store, ...params) {
-  let existingToken;
-  let brandNewToken;
-  let token;
-  let family;
-  let key;
-  let value;
-  if (params.length === 2) {
-    token = params[0];
-    value = params[1];
-    if (`family` in token) {
-      family = getFamilyOfToken(store, token);
-      key = parseJson(token.family.subKey);
-      existingToken = seekInStore(store, family, key);
-      if (!existingToken) token = brandNewToken = mintInStore(MUST_CREATE, store, family, key);
-      else token = existingToken;
-    }
-  } else {
-    family = withdraw(store, params[0]);
-    key = params[1];
-    value = params[2];
-    existingToken = seekInStore(store, family, key);
-    if (!existingToken) token = brandNewToken = mintInStore(MUST_CREATE, store, family, key);
-    else token = existingToken;
-  }
-  const action = value === RESET_STATE ? `reset` : `set`;
-  let target;
-  if (opMode === OWN_OP) {
-    const result = openOperation(store, token);
-    if (typeof result === `number`) {
-      const rejectionTime = result;
-      const unsubscribe = store.on.operationClose.subscribe(`waiting to ${action} "${token.key}" at T-${rejectionTime}`, function waitUntilOperationCloseToSetState() {
-        unsubscribe();
-        store.logger.info(`🟢`, token.type, token.key, `resuming deferred`, action, `from T-${rejectionTime}`);
-        operateOnStore(opMode, store, token, value);
-      });
-      return;
-    }
-    target = result;
-  } else target = store;
-  if (`counterfeit` in token && `family` in token) {
-    const subKey = token.family.subKey;
-    const disposal = store.disposalTraces.buffer.find((item) => item?.key === subKey);
-    store.logger.error(`❌`, token.type, token.key, `could not be`, action, `because key`, subKey, `is not allocated.`, disposal ? `this key was previously disposed:${disposal.trace}` : `(no previous disposal trace found)`);
-    return;
-  }
-  const state = withdraw(target, token);
-  let protoUpdate;
-  if (value === RESET_STATE) protoUpdate = resetAtomOrSelector(target, state);
-  else protoUpdate = setAtomOrSelector(target, state, value);
-  dispatchOrDeferStateUpdate(target, state, protoUpdate, Boolean(brandNewToken), family);
-  if (opMode === OWN_OP) closeOperation(target);
-}
-var isAtomKey = (store, key) => newest(store).atoms.has(key);
-var isSelectorKey = (store, key) => newest(store).writableSelectors.has(key);
-var isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
-var isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
-function getSelectorDependencyKeys(store, key) {
-  return newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
-}
-function traceRootSelectorAtoms(store, selectorKey, covered = /* @__PURE__ */ new Set()) {
-  const dependencies = getSelectorDependencyKeys(store, selectorKey);
-  const roots = /* @__PURE__ */ new Map();
-  while (dependencies.length > 0) {
-    const dependencyKey = dependencies.pop();
-    if (covered.has(dependencyKey)) continue;
-    covered.add(dependencyKey);
-    if (isAtomKey(store, dependencyKey)) {
-      const atom2 = store.atoms.get(dependencyKey);
-      roots.set(atom2.key, atom2);
-    } else dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
-  }
-  return roots;
-}
-function updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered) {
-  const target = newest(store);
-  const { type: dependencyType, key: dependencyKey } = dependency;
-  if (dependencyType === `atom` || dependencyType === `mutable_atom`) {
-    target.selectorAtoms.set({
-      selectorKey,
-      atomKey: dependencyKey
-    });
-    store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atom "${dependencyKey}"`);
-  } else {
-    const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered);
-    store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atoms: [ ${[...rootKeys.values()].map((root) => `"${root.key}"`).join(`, `)} ]`);
-    for (const { key: atomKey } of rootKeys.values()) target.selectorAtoms = target.selectorAtoms.set({
-      selectorKey,
-      atomKey
-    });
-  }
-  covered.add(dependencyKey);
-}
-function registerSelector(store, selectorType, selectorKey, covered) {
-  return {
-    get: (...params) => {
-      const target = newest(store);
-      const { token, family, subKey } = reduceReference(store, ...params);
-      let dependencyValue;
-      if (`counterfeit` in token && family && subKey) dependencyValue = getFallback(store, token, family, subKey);
-      else dependencyValue = readOrComputeValue(store, withdraw(store, token));
-      store.logger.info(`🔌`, selectorType, selectorKey, `registers dependency ( "${token.key}" =`, dependencyValue, `)`);
-      target.selectorGraph.set({
-        upstreamSelectorKey: token.key,
-        downstreamSelectorKey: selectorKey
-      }, { source: token.key });
-      updateSelectorAtoms(store, selectorType, selectorKey, token, covered);
-      return dependencyValue;
-    },
-    set: ((...params) => {
-      operateOnStore(JOIN_OP, newest(store), ...params);
-    }),
-    find: ((...args) => findInStore(store, ...args)),
-    json: (token) => getJsonToken(store, token)
-  };
-}
-function createReadonlyHeldSelector(store, options, family) {
-  const target = newest(store);
-  const subject = new Subject();
-  const covered = /* @__PURE__ */ new Set();
-  const { key, const: constant } = options;
-  const type = `readonly_held_selector`;
-  store.logger.info(`🔨`, type, key, `is being created`);
-  const { get, find, json } = registerSelector(target, type, key, covered);
-  const getFrom = (innerTarget) => {
-    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-    for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-    innerTarget.selectorAtoms.delete(key);
-    options.get({
-      get,
-      find,
-      json
-    }, constant);
-    writeToCache(innerTarget, readonlySelector, constant);
-    store.logger.info(`✨`, type, key, `=`, constant);
-    covered.clear();
-    return constant;
-  };
-  const readonlySelector = {
-    ...options,
-    type,
-    subject,
-    getFrom,
-    install: (s) => createReadonlyHeldSelector(s, options, family)
-  };
-  if (family) readonlySelector.family = family;
-  target.readonlySelectors.set(key, readonlySelector);
-  const token = {
-    key,
-    type
-  };
-  if (family) token.family = family;
-  return token;
-}
-function createReadonlyPureSelector(store, options, family) {
-  const target = newest(store);
-  const subject = new Subject();
-  const covered = /* @__PURE__ */ new Set();
-  const key = options.key;
-  const type = `readonly_pure_selector`;
-  store.logger.info(`🔨`, type, key, `is being created`);
-  const { get, find, json } = registerSelector(target, type, key, covered);
-  const getFrom = () => {
-    const innerTarget = newest(store);
-    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-    for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-    innerTarget.selectorAtoms.delete(key);
-    const cached = writeToCache(innerTarget, readonlySelector, options.get({
-      get,
-      find,
-      json
-    }));
-    store.logger.info(`✨`, type, key, `=`, cached);
-    covered.clear();
-    return cached;
-  };
-  const readonlySelector = {
-    ...options,
-    type,
-    subject,
-    getFrom,
-    install: (s) => createReadonlyPureSelector(s, options, family)
-  };
-  if (family) readonlySelector.family = family;
-  target.readonlySelectors.set(key, readonlySelector);
-  const token = {
-    key,
-    type
-  };
-  if (family) token.family = family;
-  return token;
-}
-function createWritableHeldSelector(store, options, family) {
-  const target = newest(store);
-  const subject = new Subject();
-  const covered = /* @__PURE__ */ new Set();
-  const { key, const: constant } = options;
-  const type = `writable_held_selector`;
-  store.logger.info(`🔨`, type, key, `is being created`);
-  const setterToolkit = registerSelector(target, type, key, covered);
-  const { find, get, json } = setterToolkit;
-  const getterToolkit = {
-    find,
-    get,
-    json
-  };
-  const getFrom = (innerTarget) => {
-    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-    for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-    innerTarget.selectorAtoms.delete(key);
-    options.get(getterToolkit, constant);
-    writeToCache(innerTarget, mySelector, constant);
-    store.logger.info(`✨`, type, key, `=`, constant);
-    covered.clear();
-    return constant;
-  };
-  const setSelf = () => {
-    options.set(setterToolkit, constant);
-  };
-  const mySelector = {
-    ...options,
-    type,
-    subject,
-    getFrom,
-    setSelf,
-    install: (s) => createWritableHeldSelector(s, options, family)
-  };
-  if (family) mySelector.family = family;
-  target.writableSelectors.set(key, mySelector);
-  const token = {
-    key,
-    type
-  };
-  if (family) token.family = family;
-  return token;
-}
-function createWritablePureSelector(store, options, family) {
-  const target = newest(store);
-  const subject = new Subject();
-  const covered = /* @__PURE__ */ new Set();
-  const key = options.key;
-  const type = `writable_pure_selector`;
-  store.logger.info(`🔨`, type, key, `is being created`);
-  const setterToolkit = registerSelector(target, type, key, covered);
-  const { find, get, json } = setterToolkit;
-  const getterToolkit = {
-    find,
-    get,
-    json
-  };
-  const getFrom = (innerTarget) => {
-    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
-    for (const [downstreamSelectorKey, { source }] of upstreamStates) if (source !== key) innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
-    innerTarget.selectorAtoms.delete(key);
-    const cached = writeToCache(innerTarget, mySelector, options.get(getterToolkit));
-    store.logger.info(`✨`, type, key, `=`, cached);
-    covered.clear();
-    return cached;
-  };
-  const setSelf = (newValue) => {
-    options.set(setterToolkit, newValue);
-  };
-  const mySelector = {
-    ...options,
-    type,
-    subject,
-    getFrom,
-    setSelf,
-    install: (s) => createWritablePureSelector(s, options, family)
-  };
-  if (family) mySelector.family = family;
-  target.writableSelectors.set(key, mySelector);
-  const token = {
-    key,
-    type
-  };
-  if (family) token.family = family;
-  return token;
-}
-function createStandaloneSelector(store, options) {
-  const isWritable = `set` in options;
-  const isHeld = `const` in options;
-  if (isHeld && isWritable) {
-    const state$1 = createWritableHeldSelector(store, options, void 0);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
-  }
-  if (isHeld) {
-    const state$1 = createReadonlyHeldSelector(store, options, void 0);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
-  }
-  if (isWritable) {
-    const state$1 = createWritablePureSelector(store, options, void 0);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
-  }
-  const state = createReadonlyPureSelector(store, options, void 0);
-  store.on.selectorCreation.next(state);
-  return state;
-}
-function disposeSelector(store, selectorToken) {
-  const target = newest(store);
-  const { key, type, family: familyMeta } = selectorToken;
-  if (!familyMeta) store.logger.error(`❌`, type, key, `Standalone selectors cannot be disposed.`);
-  else {
-    if (target.molecules.get(familyMeta.subKey)) target.moleculeData.delete(familyMeta.subKey, familyMeta.key);
-    let familyToken;
-    switch (selectorToken.type) {
-      case `writable_held_selector`:
-        target.writableSelectors.delete(key);
-        familyToken = {
-          key: familyMeta.key,
-          type: `writable_held_selector_family`
-        };
-        withdraw(store, familyToken).subject.next({
-          type: `state_disposal`,
-          subType: `selector`,
-          token: selectorToken,
-          timestamp: Date.now()
-        });
-        break;
-      case `writable_pure_selector`:
-        target.writableSelectors.delete(key);
-        familyToken = {
-          key: familyMeta.key,
-          type: `writable_pure_selector_family`
-        };
-        withdraw(store, familyToken).subject.next({
-          type: `state_disposal`,
-          subType: `selector`,
-          token: selectorToken,
-          timestamp: Date.now()
-        });
-        break;
-      case `readonly_held_selector`:
-        target.readonlySelectors.delete(key);
-        familyToken = {
-          key: familyMeta.key,
-          type: `readonly_held_selector_family`
-        };
-        withdraw(store, familyToken).subject.next({
-          type: `state_disposal`,
-          subType: `selector`,
-          token: selectorToken,
-          timestamp: Date.now()
-        });
-        break;
-      case `readonly_pure_selector`:
-        target.readonlySelectors.delete(key);
-        familyToken = {
-          key: familyMeta.key,
-          type: `readonly_pure_selector_family`
-        };
-        withdraw(store, familyToken).subject.next({
-          type: `state_disposal`,
-          subType: `selector`,
-          token: selectorToken,
-          timestamp: Date.now()
-        });
-        break;
-    }
-    target.valueMap.delete(key);
-    target.selectorAtoms.delete(key);
-    target.selectorGraph.delete(key);
-    target.moleculeData.delete(familyMeta.key, familyMeta.subKey);
-    store.logger.info(`🔥`, selectorToken.type, key, `deleted`);
-    if (isChildStore(target) && target.transactionMeta.phase === `building`) target.transactionMeta.update.subEvents.push({
-      type: `state_disposal`,
-      subType: `selector`,
-      token: selectorToken,
-      timestamp: Date.now()
-    });
-    else store.on.selectorDisposal.next(selectorToken);
-  }
-}
-var recallState = (store, state) => {
-  const target = newest(store);
-  if (target.operation.open) return target.operation.prev.get(state.key);
-  return target.valueMap.get(state.key);
-};
-var subscribeToRootDependency = (target, selector2, atom2) => {
-  return atom2.subject.subscribe(`${selector2.type}:${selector2.key}`, (atomChange) => {
-    target.logger.info(`📢`, selector2.type, selector2.key, `root`, atom2.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
-    const oldValue = recallState(target, selector2);
-    const newValue = readOrComputeValue(target, selector2);
-    target.logger.info(`✨`, selector2.type, selector2.key, `went`, oldValue, `->`, newValue);
-    selector2.subject.next({
-      newValue,
-      oldValue
-    });
-  });
-};
-function subscribeToState(store, token, key, handleUpdate) {
-  function safelyHandleUpdate(update) {
-    if (store.operation.open) {
-      if (state?.type === `atom` && hasRole(state, `tracker:signal`) && `*` + store.operation.token.key === token.key && `inboundTracker` in handleUpdate) return;
-      const unsubscribe$1 = store.on.operationClose.subscribe(`state subscription ${key}`, () => {
-        unsubscribe$1();
-        handleUpdate(update);
-      });
-    } else handleUpdate(update);
-  }
-  reduceReference(store, token);
-  const state = withdraw(store, token);
-  store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`);
-  const isSelector = state.type === `writable_pure_selector` || state.type === `readonly_pure_selector`;
-  const rootSubs = /* @__PURE__ */ new Map();
-  let updateHandler = safelyHandleUpdate;
-  if (isSelector) {
-    readOrComputeValue(store, state);
-    for (const [atomKey, atom2] of traceRootSelectorAtoms(store, state.key)) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom2));
-    updateHandler = function updateRootsBeforeHandlingUpdate(update) {
-      const dependencies = traceRootSelectorAtoms(store, state.key);
-      for (const [previousRootKey, unsub] of rootSubs) if (dependencies.get(previousRootKey)) dependencies.delete(previousRootKey);
-      else {
-        unsub();
-        rootSubs.delete(previousRootKey);
-      }
-      for (const [atomKey, atom2] of dependencies) rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom2));
-      safelyHandleUpdate(update);
-    };
-  }
-  const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
-  const unsubscribe = () => {
-    store.logger.info(`🙈`, state.type, state.key, `Removing subscription "${key}"`);
-    mainUnsubFunction();
-    for (const unsubFromDependency of rootSubs.values()) unsubFromDependency();
-  };
-  return unsubscribe;
-}
-var subscribeToTimeline = (store, token, key, handleUpdate) => {
-  const tl = withdraw(store, token);
-  store.logger.info(`👀`, `timeline`, token.key, `Adding subscription "${key}"`);
-  const unsubscribe = tl.subject.subscribe(key, handleUpdate);
-  return () => {
-    store.logger.info(`🙈`, `timeline`, token.key, `Removing subscription "${key}" from timeline`);
-    unsubscribe();
-  };
-};
-var subscribeToTransaction = (store, token, key, handleUpdate) => {
-  const tx = withdraw(store, token);
-  store.logger.info(`👀`, `transaction`, token.key, `Adding subscription "${key}"`);
-  const unsubscribe = tx.subject.subscribe(key, handleUpdate);
-  return () => {
-    store.logger.info(`🙈`, `transaction`, token.key, `Removing subscription "${key}"`);
-    unsubscribe();
-  };
-};
-function subscribeInStore(store, token, handleUpdate, key = arbitrary()) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-    case `readonly_pure_selector`:
-    case `readonly_held_selector`:
-    case `writable_pure_selector`:
-    case `writable_held_selector`:
-      return subscribeToState(store, token, key, handleUpdate);
-    case `transaction`:
-      return subscribeToTransaction(store, token, key, handleUpdate);
-    case `timeline`:
-      return subscribeToTimeline(store, token, key, handleUpdate);
-  }
-}
-var Tracker = class {
-  initializeSignalAtom(mutableState, store) {
-    const latestSignalStateKey = `*${mutableState.key}`;
-    store.atoms.delete(latestSignalStateKey);
-    store.valueMap.delete(latestSignalStateKey);
-    const familyMetaData = mutableState.family ? {
-      key: `*${mutableState.family.key}`,
-      subKey: mutableState.family.subKey
-    } : void 0;
-    const latestSignalState = createRegularAtom(store, {
-      key: latestSignalStateKey,
-      default: null
-    }, familyMetaData, [`tracker:signal`]);
-    if (store.parent?.valueMap.has(latestSignalStateKey)) {
-      const parentValue = store.parent.valueMap.get(latestSignalStateKey);
-      store.valueMap.set(latestSignalStateKey, parentValue);
-    }
-    return latestSignalState;
-  }
-  unsubscribeFromInnerValue;
-  unsubscribeFromState;
-  captureSignalsFromCore(mutableState, latestSignalState, target) {
-    const stateKey = mutableState.key;
-    const subscriptionKey = `tracker-from-core:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.token.key : `main`}:${stateKey}`;
-    const trackerCapturesOutboundSignal = (update) => {
-      operateOnStore(JOIN_OP, target, latestSignalState, update);
-    };
-    this.unsubscribeFromInnerValue = getFromStore(target, mutableState).subscribe(subscriptionKey, trackerCapturesOutboundSignal);
-    this.unsubscribeFromState = subscribeToState(target, mutableState, subscriptionKey, (function trackerLooksForNewReference(update) {
-      if (update.newValue !== update.oldValue) {
-        this.unsubscribeFromInnerValue();
-        this.unsubscribeFromInnerValue = update.newValue.subscribe(subscriptionKey, trackerCapturesOutboundSignal);
-      }
-    }).bind(this));
-  }
-  supplySignalsToCore(mutableState, latestSignalState, target) {
-    const stateKey = mutableState.key;
-    const subscriptionKey = `tracker-to-core:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.token.key : `main`}:${stateKey}`;
-    subscribeToState(target, latestSignalState, subscriptionKey, Object.assign(function trackerCapturesInboundSignal({ newValue, oldValue }) {
-      const timelineId = target.timelineTopics.getRelatedKey(latestSignalState.key);
-      if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
-        const unsubscribe = subscribeToTimeline(target, {
-          key: timelineId,
-          type: `timeline`
-        }, subscriptionKey, function trackerWaitsForTimeTravelToFinish(update) {
-          unsubscribe();
-          setIntoStore(target, mutableState, (transceiver) => {
-            if (update === `redo` && newValue) transceiver.do(newValue);
-            else if (update === `undo` && oldValue) transceiver.undo(oldValue);
-            return transceiver;
-          });
-        });
-        return;
-      }
-      setIntoStore(target, mutableState, (transceiver) => (transceiver.do(newValue), transceiver));
-    }, { inboundTracker: true }));
-  }
-  mutableAtomToken;
-  latestSignalToken;
-  [Symbol.dispose];
-  constructor(mutableAtomToken, store) {
-    const target = newest(store);
-    const latestSignalToken = this.initializeSignalAtom(mutableAtomToken, target);
-    this.mutableAtomToken = mutableAtomToken;
-    this.latestSignalToken = latestSignalToken;
-    this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target);
-    this.supplySignalsToCore(mutableAtomToken, latestSignalToken, target);
-    target.trackers.set(mutableAtomToken.key, this);
-    this[Symbol.dispose] = () => {
-      this.unsubscribeFromInnerValue();
-      this.unsubscribeFromState();
-      target.trackers.delete(mutableAtomToken.key);
-    };
-  }
-};
-function createMutableAtom(store, options, family) {
-  store.logger.info(`🔨`, `atom`, options.key, `creating in store "${store.config.name}"`);
-  const target = newest(store);
-  const { key } = options;
-  const existing = target.atoms.get(key);
-  const type = `mutable_atom`;
-  if (existing?.type === type && store.config.isProduction === true) {
-    store.logger.error(`❌`, type, key, `Tried to create atom, but it already exists in the store.`);
-    return deposit(existing);
-  }
-  const subject = new Subject();
-  const newAtom = {
-    ...options,
-    type,
-    install: (s) => {
-      s.logger.info(`🛠️`, `atom`, key, `installing in store "${s.config.name}"`);
-      return createMutableAtom(s, options, family);
-    },
-    subject
-  };
-  if (family) newAtom.family = family;
-  target.atoms.set(newAtom.key, newAtom);
-  const token = deposit(newAtom);
-  new Tracker(token, store);
-  if (!family) createStandaloneSelector(store, {
-    key: `${key}:JSON`,
-    get: ({ get }) => get(token).toJSON(),
-    set: ({ set }, newValue) => {
-      set(token, options.class.fromJSON(newValue));
-    }
-  });
-  if (options.effects) {
-    let effectIndex = 0;
-    const cleanupFunctions = [];
-    for (const effect of options.effects) {
-      const cleanup = effect({
-        resetSelf: () => {
-          resetInStore(store, token);
-        },
-        setSelf: (next) => {
-          setIntoStore(store, token, next);
-        },
-        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle),
-        token,
-        store: eldest(store)
-      });
-      if (cleanup) cleanupFunctions.push(cleanup);
-      ++effectIndex;
-    }
-    newAtom.cleanup = () => {
-      for (const cleanup of cleanupFunctions) cleanup();
-    };
-  }
-  store.on.atomCreation.next(token);
-  return token;
-}
-var FamilyTracker = class {
-  trackers = /* @__PURE__ */ new Map();
-  latestSignalAtoms;
-  mutableAtoms;
-  constructor(mutableAtoms, store) {
-    this.latestSignalAtoms = withdraw(store, createRegularAtomFamily(store, {
-      key: `*${mutableAtoms.key}`,
-      default: null
-    }, [`mutable`, `updates`]));
-    this.mutableAtoms = mutableAtoms;
-    const trackerFamilyWatchesForCreationAndDisposalEvents = (event) => {
-      const { type, token } = event;
-      if (token.family) {
-        const key = parseJson(token.family.subKey);
-        switch (type) {
-          case `state_creation`:
-            this.trackers.set(key, new Tracker(token, store));
-            break;
-          case `state_disposal`: {
-            const tracker = this.trackers.get(key);
-            if (tracker) {
-              tracker[Symbol.dispose]();
-              this.trackers.delete(key);
-            }
-          }
-        }
-      }
-    };
-    this.mutableAtoms.subject.subscribe(`store=${store.config.name}::tracker-atom-family`, trackerFamilyWatchesForCreationAndDisposalEvents);
-  }
-};
-function createMutableAtomFamily(store, options, internalRoles) {
-  const familyToken = {
-    key: options.key,
-    type: `mutable_atom_family`
-  };
-  const existing = store.families.get(options.key);
-  if (existing && store.config.isProduction === true) store.logger.error(`❗`, `mutable_atom_family`, options.key, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
-  const subject = new Subject();
-  const create = (key) => {
-    const subKey = stringifyJson(key);
-    const family = {
-      key: options.key,
-      subKey
-    };
-    const fullKey = `${options.key}(${subKey})`;
-    const target = newest(store);
-    const individualOptions = {
-      key: fullKey,
-      class: options.class
-    };
-    if (options.effects) individualOptions.effects = options.effects(key);
-    return createMutableAtom(target, individualOptions, family);
-  };
-  const atomFamily$1 = {
-    ...familyToken,
-    create,
-    class: options.class,
-    subject,
-    install: (s) => createMutableAtomFamily(s, options),
-    internalRoles
-  };
-  store.families.set(options.key, atomFamily$1);
-  createWritablePureSelectorFamily(store, {
-    key: `${options.key}:JSON`,
-    get: (key) => ({ get }) => get(familyToken, key).toJSON(),
-    set: (key) => ({ set }, newValue) => {
-      set(familyToken, key, options.class.fromJSON(newValue));
-    }
-  }, [`mutable`, `json`]);
-  new FamilyTracker(atomFamily$1, store);
-  return familyToken;
-}
-var getJsonFamily = (mutableAtomFamily2, store) => {
-  const target = newest(store);
-  const key = `${mutableAtomFamily2.key}:JSON`;
-  return target.families.get(key);
-};
-var getJsonToken = (store, mutableAtomToken) => {
-  if (mutableAtomToken.family) return findInStore(store, withdraw(newest(store), {
-    key: `${mutableAtomToken.family.key}:JSON`,
-    type: `writable_pure_selector_family`
-  }), parseJson(mutableAtomToken.family.subKey));
-  return {
-    type: `writable_pure_selector`,
-    key: `${mutableAtomToken.key}:JSON`
-  };
-};
-var getUpdateToken = (mutableAtomToken) => {
-  const updateToken = {
-    type: `atom`,
-    key: `*${mutableAtomToken.key}`
-  };
-  if (mutableAtomToken.family) updateToken.family = {
-    key: `*${mutableAtomToken.family.key}`,
-    subKey: mutableAtomToken.family.subKey
-  };
-  return updateToken;
-};
-function isTransceiver(value) {
-  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value && `READONLY_VIEW` in value && `toJSON` in value;
-}
-function writeToCache(target, state, value) {
-  const { key, subject, type } = state;
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future && !currentValue.done) {
-    const future = currentValue;
-    if (value instanceof Promise) {
-      future.use(value);
-      return future;
-    }
-    target.valueMap.set(key, value);
-    return value;
-  }
-  if (value instanceof Promise) {
-    const future = new Future(value);
-    target.valueMap.set(key, future);
-    future.then(function handleResolvedFuture(resolved) {
-      if (target.valueMap.get(key) === future) {
-        openOperation(target, state);
-        writeToCache(target, state, resolved);
-        switch (type) {
-          case `atom`:
-            evictDownstreamFromAtom(target, state);
-            break;
-          case `readonly_pure_selector`:
-          case `writable_pure_selector`:
-            evictDownstreamFromSelector(target, key);
-            break;
-        }
-        closeOperation(target);
-        subject.next({
-          newValue: resolved,
-          oldValue: future
-        });
-      }
-    }).catch((thrown) => {
-      target.logger.error(`💥`, state.type, key, `rejected:`, thrown);
-    });
-    return future;
-  }
-  target.logger.info(`📝`, state.type, state.key, `writing to cache`, value);
-  target.valueMap.set(key, value);
-  return value;
-}
-function readFromCache(target, state, mut) {
-  target.logger.info(`📖`, state.type, state.key, `reading cached value`);
-  let value = target.valueMap.get(state.key);
-  if (mut === `mut` && state.type === `mutable_atom` && isChildStore(target)) {
-    const mutableAtom$1 = state;
-    const { parent } = target;
-    if (target.valueMap.hasOwn(mutableAtom$1.key)) return value;
-    const parentValue = parent.valueMap.get(mutableAtom$1.key);
-    target.logger.info(`📃`, `atom`, mutableAtom$1.key, `copying`);
-    const jsonValue = parentValue.toJSON();
-    const copiedValue = mutableAtom$1.class.fromJSON(jsonValue);
-    target.valueMap.set(mutableAtom$1.key, copiedValue);
-    new Tracker(mutableAtom$1, parent);
-    value = copiedValue;
-  }
-  return value;
-}
-function evictCachedValue(target, key) {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    const selector2 = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
-    if (selector2) selector2.getFrom(target);
-    return;
-  }
-  if (target.operation.open) target.operation.prev.set(key, currentValue);
-  target.valueMap.delete(key);
-  target.logger.info(`🗑`, `state`, key, `evicted`);
-}
-function evictDownstreamFromAtom(store, atom2) {
-  const target = newest(store);
-  const { key, type } = atom2;
-  const downstreamKeys = target.selectorAtoms.getRelatedKeys(key);
-  target.logger.info(`🧹`, type, key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
-  if (downstreamKeys) {
-    if (target.operation.open) target.logger.info(`🧹`, type, key, `[ ${[...target.operation.done].join(`, `)} ] already done`);
-    for (const downstreamKey of downstreamKeys) {
-      if (isDone(target, downstreamKey)) continue;
-      evictCachedValue(target, downstreamKey);
-      markDone(target, downstreamKey);
-    }
-  }
-}
-function evictDownstreamFromSelector(store, selectorKey) {
-  const target = newest(store);
-  const relationEntries = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: selectorKey }).filter(([_, { source }]) => source === selectorKey);
-  for (const [downstreamSelectorKey] of relationEntries) {
-    if (isDone(target, downstreamSelectorKey)) continue;
-    evictCachedValue(target, downstreamSelectorKey);
-    markDone(target, downstreamSelectorKey);
-    evictDownstreamFromSelector(store, downstreamSelectorKey);
-  }
-}
-function createRegularAtom(store, options, family, internalRoles) {
-  const type = `atom`;
-  const { key } = options;
-  store.logger.info(`🔨`, type, key, `is being created`);
-  const target = newest(store);
-  const existing = target.atoms.get(key);
-  if (existing?.type === type && store.config.isProduction === true) {
-    store.logger.error(`❌`, `atom`, key, `Tried to create atom, but it already exists in the store.`);
-    return deposit(existing);
-  }
-  const subject = new Subject();
-  const newAtom = {
-    ...options,
-    type,
-    install: (s) => {
-      s.logger.info(`🛠️`, type, key, `installing in store "${s.config.name}"`);
-      return createRegularAtom(s, options, family);
-    },
-    subject
-  };
-  if (family) newAtom.family = family;
-  if (internalRoles) newAtom.internalRoles = internalRoles;
-  target.atoms.set(key, newAtom);
-  const token = deposit(newAtom);
-  if (options.effects) {
-    let effectIndex = 0;
-    const cleanupFunctions = [];
-    for (const effect of options.effects) {
-      const cleanup = effect({
-        resetSelf: () => {
-          resetInStore(store, token);
-        },
-        setSelf: (next) => {
-          setIntoStore(store, token, next);
-        },
-        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle),
-        token,
-        store: eldest(store)
-      });
-      if (cleanup) cleanupFunctions.push(cleanup);
-      ++effectIndex;
-    }
-    newAtom.cleanup = () => {
-      for (const cleanup of cleanupFunctions) cleanup();
-    };
-  }
-  store.on.atomCreation.next(token);
-  return token;
-}
-function hasRole(atom2, role) {
-  if (`internalRoles` in atom2 === false) return false;
-  return atom2.internalRoles.includes(role);
-}
-function disposeAtom(store, atomToken) {
-  const target = newest(store);
-  const { key, family } = atomToken;
-  const atom2 = withdraw(target, atomToken);
-  if (!family) store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`);
-  else {
-    atom2.cleanup?.();
-    const lastValue = store.valueMap.get(atom2.key);
-    const subject = withdraw(store, getFamilyOfToken(store, atomToken)).subject;
-    const disposalEvent = {
-      type: `state_disposal`,
-      subType: `atom`,
-      token: atomToken,
-      value: lastValue,
-      timestamp: Date.now()
-    };
-    subject.next(disposalEvent);
-    const isChild = isChildStore(target);
-    target.atoms.delete(key);
-    target.valueMap.delete(key);
-    target.selectorAtoms.delete(key);
-    target.atomsThatAreDefault.delete(key);
-    target.moleculeData.delete(family.key, family.subKey);
-    store.timelineTopics.delete(key);
-    if (atomToken.type === `mutable_atom`) {
-      disposeAtom(store, getUpdateToken(atomToken));
-      store.trackers.delete(key);
-    }
-    store.logger.info(`🔥`, `atom`, key, `deleted`);
-    if (isChild && target.transactionMeta.phase === `building`) {
-      const mostRecentUpdate = target.transactionMeta.update.subEvents.at(-1);
-      const updateAlreadyCaptured = mostRecentUpdate?.type === `molecule_disposal` && mostRecentUpdate.values.some(([k]) => k === atom2.family?.key);
-      const isTracker = hasRole(atom2, `tracker:signal`);
-      if (!updateAlreadyCaptured && !isTracker) target.transactionMeta.update.subEvents.push(disposalEvent);
-    } else store.on.atomDisposal.next(atomToken);
-  }
-}
-function capitalize(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
-function installIntoStore(tokens, target, source) {
-  const sourceNewest = newest(source);
-  if (isChildStore(sourceNewest)) {
-    source.logger.error(`❌`, `transaction`, sourceNewest.transactionMeta.update.token.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${sourceNewest.config.name} is undergoing a transaction.`);
-    return;
-  }
-  const targetNewest = newest(target);
-  if (isChildStore(targetNewest)) {
-    target.logger.error(`❌`, `transaction`, targetNewest.transactionMeta.update.token.key, `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`, tokens, `${targetNewest.config.name} is undergoing a transaction.`);
-    return;
-  }
-  for (const token of tokens) withdraw(source, token).install(target);
-}
-var Join = class {
-  toolkit;
-  options;
-  relations;
-  states;
-  relatedKeysAtoms;
-  transact(toolkit, run) {
-    const originalToolkit = this.toolkit;
-    this.toolkit = toolkit;
-    run(this);
-    this.toolkit = originalToolkit;
-  }
-  store;
-  [Symbol.dispose]() {
-  }
-  constructor(options, store = IMPLICIT.STORE) {
-    this.store = store;
-    this.options = options;
-    this.store.miscResources.set(`join:${options.key}`, this);
-    this.toolkit = {
-      get: ((...ps) => getFromStore(store, ...ps)),
-      set: ((...ps) => {
-        setIntoStore(store, ...ps);
-      }),
-      find: ((...ps) => findInStore(store, ...ps)),
-      json: (token) => getJsonToken(store, token)
-    };
-    const aSide = options.between[0];
-    const bSide = options.between[1];
-    const relatedKeysAtoms = createMutableAtomFamily(store, {
-      key: `${options.key}/relatedKeys`,
-      class: UList
-    }, [`join`, `relations`]);
-    this.relatedKeysAtoms = relatedKeysAtoms;
-    const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
-      const { find, get, set } = toolkit;
-      const relationsOfAState = find(relatedKeysAtoms, a);
-      const currentRelationsOfA = get(relationsOfAState);
-      for (const currentRelationB of currentRelationsOfA) {
-        if (newRelationsOfA.includes(currentRelationB)) continue;
-        set(relatedKeysAtoms, currentRelationB, (relationsOfB) => {
-          relationsOfB.delete(a);
-          return relationsOfB;
-        });
-      }
-      set(relationsOfAState, (relationsOfA) => {
-        relationsOfA.clear();
-        for (const newRelationB of newRelationsOfA) {
-          const relationsOfBAtom = find(relatedKeysAtoms, newRelationB);
-          const relationsOfB = get(relationsOfBAtom);
-          const newRelationBIsAlreadyRelated = relationsOfB.has(a);
-          if (this.relations.cardinality === `1:n`) {
-            const previousOwnersToDispose = [];
-            for (const previousOwner of relationsOfB) {
-              if (previousOwner === a) continue;
-              let previousOwnerSize;
-              operateOnStore(JOIN_OP, this.store, relatedKeysAtoms, previousOwner, (relations$1) => {
-                relations$1.delete(newRelationB);
-                previousOwnerSize = relations$1.size;
-                return relations$1;
-              });
-              if (previousOwnerSize === 0) previousOwnersToDispose.push(previousOwner);
-            }
-            if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) set(relationsOfBAtom, (relations$1) => {
-              relations$1.clear();
-              return relations$1;
-            });
-            for (const previousOwner of previousOwnersToDispose) store.keyRefsInJoins.delete(simpleCompound(newRelationB, previousOwner));
-          }
-          if (!newRelationBIsAlreadyRelated) set(relationsOfBAtom, (relations$1) => {
-            relations$1.add(a);
-            return relations$1;
-          });
-          relationsOfA.add(newRelationB);
-        }
-        return relationsOfA;
-      });
-    };
-    const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
-      const { set } = toolkit;
-      set(relatedKeysAtoms, a, (relationsOfA) => {
-        for (const newRelationB of newRelationsOfA) relationsOfA.add(newRelationB);
-        return relationsOfA;
-      });
-      for (const newRelationB of newRelationsOfA) set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
-        newRelationsB.add(a);
-        return newRelationsB;
-      });
-      return true;
-    };
-    const relations = new Junction(options, {
-      externalStore: {
-        getRelatedKeys: (key) => this.toolkit.get(relatedKeysAtoms, key),
-        addRelation: (a, b) => {
-          this.store.keyRefsInJoins.set(`"${a}"`, options.key);
-          this.store.keyRefsInJoins.set(`"${b}"`, options.key);
-          this.store.keyRefsInJoins.set(simpleCompound(a, b), options.key);
-          this.toolkit.set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
-          this.toolkit.set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
-        },
-        deleteRelation: (a, b) => {
-          this.toolkit.set(relatedKeysAtoms, a, (aKeys) => {
-            aKeys.delete(b);
-            return aKeys;
-          });
-          this.toolkit.set(relatedKeysAtoms, b, (bKeys) => {
-            bKeys.delete(a);
-            return bKeys;
-          });
-          const compositeKey = simpleCompound(a, b);
-          this.store.keyRefsInJoins.delete(compositeKey);
-        },
-        replaceRelationsSafely: (a, bs) => {
-          replaceRelationsSafely(this.toolkit, a, bs);
-        },
-        replaceRelationsUnsafely: (a, bs) => {
-          replaceRelationsUnsafely(this.toolkit, a, bs);
-        },
-        has: (a, b) => {
-          const aKeys = this.toolkit.get(relatedKeysAtoms, a);
-          return b ? aKeys.has(b) : aKeys.size > 0;
-        }
-      },
-      isAType: options.isAType,
-      isBType: options.isBType
-    });
-    const createSingleKeySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
-      key: `${options.key}/singleRelatedKey`,
-      get: (key) => ({ get }) => {
-        const relatedKeys = get(relatedKeysAtoms, key);
-        for (const relatedKey of relatedKeys) return relatedKey;
-        return null;
-      }
-    }, [`join`, `keys`]);
-    const getMultipleKeySelectorFamily = () => {
-      return createReadonlyPureSelectorFamily(store, {
-        key: `${options.key}/multipleRelatedKeys`,
-        get: (key) => ({ get }) => {
-          return get(getJsonFamily(relatedKeysAtoms, store), key);
-        }
-      }, [`join`, `keys`]);
-    };
-    switch (options.cardinality) {
-      case `1:1`: {
-        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
-        this.relations = relations;
-        this.states = {
-          [stateKeyA]: singleRelatedKeySelectors,
-          [stateKeyB]: singleRelatedKeySelectors
-        };
-        break;
-      }
-      case `1:n`: {
-        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
-        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: singleRelatedKeySelectors,
-          [stateKeyB]: multipleRelatedKeysSelectors
-        };
-        this.relations = relations;
-        this.states = baseStates;
-        break;
-      }
-      case `n:n`: {
-        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-        this.relations = relations;
-        this.states = {
-          [stateKeyA]: multipleRelatedKeysSelectors,
-          [stateKeyB]: multipleRelatedKeysSelectors
-        };
-      }
-    }
-  }
-};
-function createJoin(store, options) {
-  store.joins.set(options.key, new Join(options));
-  return {
-    key: options.key,
-    type: `join`,
-    a: options.between[0],
-    b: options.between[1],
-    cardinality: options.cardinality
-  };
-}
-function getJoin(token, store) {
-  let myJoin = store.joins.get(token.key);
-  if (myJoin === void 0) {
-    const rootJoin = IMPLICIT.STORE.joins.get(token.key);
-    if (rootJoin === void 0) throw new Error(`Join "${token.key}" not found in store "${store.config.name}"`);
-    const root = eldest(store);
-    myJoin = new Join(rootJoin.options, root);
-    store.joins.set(token.key, myJoin);
-  }
-  return myJoin;
-}
-function editRelationsInStore(token, change, store) {
-  const myJoin = getJoin(token, store);
-  const target = newest(store);
-  if (isChildStore(target)) {
-    const { toolkit } = target.transactionMeta;
-    myJoin.transact(toolkit, ({ relations }) => {
-      change(relations);
-    });
-  } else change(myJoin.relations);
-}
-function findRelationsInStore(token, key, store) {
-  const myJoin = getJoin(token, store);
-  let relations;
-  switch (token.cardinality) {
-    case `1:1`: {
-      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
-      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
-      relations = {
-        get [keyAB]() {
-          const familyAB = myJoin.states[keyAB];
-          return findInStore(store, familyAB, key);
-        },
-        get [keyBA]() {
-          const familyBA = myJoin.states[keyBA];
-          return findInStore(store, familyBA, key);
-        }
-      };
-      break;
-    }
-    case `1:n`: {
-      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
-      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
-      relations = {
-        get [keyAB]() {
-          const familyAB = myJoin.states[keyAB];
-          return findInStore(store, familyAB, key);
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          return findInStore(store, familyBA, key);
-        }
-      };
-      break;
-    }
-    case `n:n`: {
-      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
-      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
-      relations = {
-        get [keysAB]() {
-          const familyAB = myJoin.states[keysAB];
-          return findInStore(store, familyAB, key);
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          return findInStore(store, familyBA, key);
-        }
-      };
-    }
-  }
-  return relations;
-}
-function getInternalRelationsFromStore(token, store) {
-  return getJoin(token, store).relatedKeysAtoms;
-}
-function createTimeline(store, options, data) {
-  const tl = {
-    type: `timeline`,
-    key: options.key,
-    at: 0,
-    timeTraveling: null,
-    selectorTime: null,
-    transactionKey: null,
-    ...data,
-    history: data?.history.map((update) => ({ ...update })) ?? [],
-    install: (s) => createTimeline(s, options, tl),
-    subject: new Subject(),
-    subscriptions: /* @__PURE__ */ new Map()
-  };
-  const timelineKey = options.key;
-  const target = newest(store);
-  for (const initialTopic of options.scope) switch (initialTopic.type) {
-    case `atom`:
-    case `mutable_atom`:
-      {
-        const atomToken = initialTopic;
-        const atomKey = atomToken.key;
-        let existingTimelineKey = target.timelineTopics.getRelatedKey(atomKey);
-        if (`family` in atomToken) {
-          const familyKey = atomToken.family.key;
-          existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
-          if (existingTimelineKey) {
-            store.logger.error(`❌`, `timeline`, options.key, `Failed to add atom "${atomKey}" because its family "${familyKey}" already belongs to timeline "${existingTimelineKey}"`);
-            continue;
-          }
-        }
-        if (existingTimelineKey) {
-          store.logger.error(`❌`, `timeline`, options.key, `Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`);
-          continue;
-        }
-        addAtomToTimeline(store, atomToken, tl);
-      }
-      break;
-    case `atom_family`:
-    case `mutable_atom_family`:
-      {
-        const familyToken = initialTopic;
-        const familyKey = familyToken.key;
-        const existingTimelineKey = target.timelineTopics.getRelatedKey(familyKey);
-        if (existingTimelineKey) {
-          store.logger.error(`❌`, `timeline`, options.key, `Failed to add atom family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`);
-          continue;
-        }
-        addAtomFamilyToTimeline(store, familyToken, tl);
-      }
-      break;
-  }
-  store.timelines.set(options.key, tl);
-  const token = {
-    key: timelineKey,
-    type: `timeline`
-  };
-  store.on.timelineCreation.next(token);
-  return token;
-}
-function addAtomToTimeline(store, atomToken, tl) {
-  reduceReference(store, atomToken);
-  let maybeAtom = withdraw(store, atomToken);
-  if (maybeAtom.type === `mutable_atom`) maybeAtom = withdraw(store, getUpdateToken(maybeAtom));
-  const atom2 = maybeAtom;
-  store.timelineTopics.set({
-    topicKey: atom2.key,
-    timelineKey: tl.key
-  }, { topicType: `atom` });
-  tl.subscriptions.set(atom2.key, atom2.subject.subscribe(`timeline`, function timelineCapturesAtomUpdate(update) {
-    const target = newest(store);
-    const currentSelectorToken = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.token : null;
-    const currentSelectorTime = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.timestamp : null;
-    const txUpdateInProgress = target.on.transactionApplying.state?.update;
-    store.logger.info(`⏳`, `timeline`, tl.key, `atom`, atomToken.key, `went`, update.oldValue, `->`, update.newValue, txUpdateInProgress ? `in transaction "${txUpdateInProgress.token.key}"` : currentSelectorToken ? `in selector "${currentSelectorToken.key}"` : ``);
-    if (tl.timeTraveling === null) if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress);
-    else if (currentSelectorToken && currentSelectorTime) buildSelectorUpdate(store, tl, atomToken, update, currentSelectorToken, currentSelectorTime);
-    else {
-      const timestamp = Date.now();
-      tl.selectorTime = null;
-      const atomUpdate = {
-        checkpoint: true,
-        type: `atom_update`,
-        token: deposit(atom2),
-        update,
-        timestamp
-      };
-      store.logger.info(`⌛`, `timeline`, tl.key, `got an atom_update to "${atom2.key}"`);
-      addToHistory(tl, atomUpdate);
-    }
-  }));
-}
-function addAtomFamilyToTimeline(store, atomFamilyToken, tl) {
-  const family = withdraw(store, atomFamilyToken);
-  store.timelineTopics.set({
-    topicKey: family.key,
-    timelineKey: tl.key
-  }, { topicType: `atom_family` });
-  tl.subscriptions.set(family.key, family.subject.subscribe(`timeline`, function timelineCapturesStateLifecycleEvent(creationOrDisposal) {
-    handleStateLifecycleEvent(store, creationOrDisposal, tl);
-  }));
-  for (const atom2 of store.atoms.values()) if (atom2.family?.key === family.key) addAtomToTimeline(store, atom2, tl);
-}
-function joinTransaction(store, tl, txUpdateInProgress) {
-  const currentTxKey = txUpdateInProgress.token.key;
-  const currentTxInstanceId = txUpdateInProgress.id;
-  const currentTransaction = withdraw(store, {
-    key: currentTxKey,
-    type: `transaction`
-  });
-  if (currentTxKey && tl.transactionKey === null) {
-    tl.transactionKey = currentTxKey;
-    const unsubscribe = currentTransaction.subject.subscribe(`timeline:${tl.key}`, (transactionUpdate) => {
-      unsubscribe();
-      tl.transactionKey = null;
-      if (tl.timeTraveling === null && currentTxInstanceId) {
-        const timelineTopics = store.timelineTopics.getRelatedKeys(tl.key);
-        const subEventsFiltered = filterTransactionSubEvents(transactionUpdate.subEvents, timelineTopics);
-        addToHistory(tl, {
-          checkpoint: true,
-          ...transactionUpdate,
-          subEvents: subEventsFiltered
-        });
-      }
-    });
-  }
-}
-function buildSelectorUpdate(store, tl, atomToken, eventOrUpdate, currentSelectorToken, currentSelectorTime) {
-  let latestUpdate = tl.history.at(-1);
-  if (currentSelectorTime !== tl.selectorTime) {
-    const selectorUpdate = latestUpdate = {
-      checkpoint: true,
-      type: `selector_update`,
-      timestamp: currentSelectorTime,
-      token: currentSelectorToken,
-      subEvents: []
-    };
-    if (`type` in eventOrUpdate) latestUpdate.subEvents.push(eventOrUpdate);
-    else latestUpdate.subEvents.push({
-      type: `atom_update`,
-      token: atomToken,
-      update: eventOrUpdate,
-      timestamp: Date.now()
-    });
-    addToHistory(tl, latestUpdate);
-    tl.selectorTime = currentSelectorTime;
-    store.logger.info(`⌛`, `timeline`, tl.key, `got a selector_update "${currentSelectorToken.key}" with`, latestUpdate.subEvents.map((event) => event.token.key));
-    const operation = store.operation;
-    const unsub = store.on.operationClose.subscribe(`timeline:${tl.key} (needs to gather nested selector creations)`, () => {
-      unsub();
-      if (operation.open) selectorUpdate.subEvents = [...operation.subEvents, ...selectorUpdate.subEvents];
-    });
-  } else if (latestUpdate?.type === `selector_update`) {
-    if (`type` in eventOrUpdate) latestUpdate.subEvents.push(eventOrUpdate);
-    else latestUpdate.subEvents.push({
-      type: `atom_update`,
-      token: atomToken,
-      update: eventOrUpdate,
-      timestamp: Date.now()
-    });
-    store.logger.info(`⌛`, `timeline`, tl.key, `set selector_update "${currentSelectorToken.key}" to`, latestUpdate?.subEvents.map((event) => event.token.key));
-  }
-  if (latestUpdate) tl.subject.next(latestUpdate);
-}
-function filterTransactionSubEvents(updates, timelineTopics) {
-  return updates.filter((updateFromTx) => {
-    if (updateFromTx.type === `transaction_outcome`) return true;
-    let key;
-    let familyKey;
-    switch (updateFromTx.type) {
-      case `atom_update`:
-      case `state_creation`:
-      case `state_disposal`:
-        key = updateFromTx.token.key;
-        familyKey = updateFromTx.token.family?.key;
-        break;
-      case `molecule_creation`:
-      case `molecule_disposal`:
-      case `molecule_transfer`:
-        return true;
-    }
-    timelineTopics.has(key);
-    if (familyKey && timelineTopics.has(familyKey)) return true;
-    return timelineTopics.has(key);
-  }).map((updateFromTx) => {
-    if (`subEvents` in updateFromTx) return {
-      ...updateFromTx,
-      subEvents: filterTransactionSubEvents(updateFromTx.subEvents, timelineTopics)
-    };
-    return updateFromTx;
-  });
-}
-function handleStateLifecycleEvent(store, event, tl) {
-  const currentSelectorToken = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.token : null;
-  const currentSelectorTime = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.timestamp : null;
-  if (!tl.timeTraveling) {
-    const target = newest(store);
-    if (isChildStore(target)) {
-    } else {
-      const txUpdateInProgress = target.on.transactionApplying.state;
-      if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress.update);
-      else if (currentSelectorToken && currentSelectorTime && event.type === `state_creation`) buildSelectorUpdate(store, tl, event.token, event, currentSelectorToken, currentSelectorTime);
-      else addToHistory(tl, event);
-    }
-  }
-  switch (event.type) {
-    case `state_creation`:
-      addAtomToTimeline(store, event.token, tl);
-      break;
-    case `state_disposal`:
-      tl.subscriptions.get(event.token.key)?.();
-      tl.subscriptions.delete(event.token.key);
-      break;
-  }
-}
-function addToHistory(tl, event) {
-  if (tl.at !== tl.history.length) tl.history.splice(tl.at);
-  tl.history.push(event);
-  tl.at = tl.history.length;
-  tl.subject.next(event);
-}
-var timeTravel = (store, action, token) => {
-  store.logger.info(action === `redo` ? `⏩` : `⏪`, `timeline`, token.key, action);
-  const timelineData = store.timelines.get(token.key);
-  if (!timelineData) {
-    store.logger.error(`🐞`, `timeline`, token.key, `Failed to ${action}. This timeline has not been initialized.`);
-    return;
-  }
-  if (action === `redo` && timelineData.at === timelineData.history.length || action === `undo` && timelineData.at === 0) {
-    store.logger.warn(`💁`, `timeline`, token.key, `Failed to ${action} at the ${action === `redo` ? `end` : `beginning`} of timeline "${token.key}". There is nothing to ${action}.`);
-    return;
-  }
-  timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`;
-  let nextIndex = timelineData.at;
-  let events;
-  switch (action) {
-    case `undo`:
-      --nextIndex;
-      while (nextIndex !== 0 && timelineData.history[nextIndex].checkpoint !== true) --nextIndex;
-      events = timelineData.history.slice(nextIndex, timelineData.at).reverse();
-      break;
-    case `redo`:
-      ++nextIndex;
-      events = timelineData.history.slice(timelineData.at, nextIndex);
-  }
-  timelineData.at = nextIndex;
-  const applying = action === `redo` ? `newValue` : `oldValue`;
-  for (const event of events) switch (event.type) {
-    case `atom_update`:
-      ingestAtomUpdateEvent(store, event, applying);
-      break;
-    case `selector_update`:
-      ingestSelectorUpdateEvent(store, event, applying);
-      break;
-    case `transaction_outcome`:
-      ingestTransactionOutcomeEvent(store, event, applying);
-      break;
-    case `state_creation`:
-      ingestCreationEvent(store, event, applying);
-      break;
-    case `state_disposal`:
-      ingestDisposalEvent(store, event, applying);
-      break;
-  }
-  timelineData.subject.next(action);
-  timelineData.timeTraveling = null;
-  store.logger.info(`⏸️`, `timeline`, token.key, `"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`);
-};
-
-// ../../../../node_modules/.pnpm/atom.io@0.44.0_@floating-ui+react-dom@2.1.6_@preact+compat@18.3.1_preact@10.27.2__@prea_a385030eab0fd5c9f5ef9e758818d457/node_modules/atom.io/dist/main/index.js
-function atom(options) {
-  return createRegularAtom(IMPLICIT.STORE, options, void 0);
-}
-function mutableAtom(options) {
-  return createMutableAtom(IMPLICIT.STORE, options, void 0);
-}
-function atomFamily(options) {
-  return createRegularAtomFamily(IMPLICIT.STORE, options);
-}
-function mutableAtomFamily(options) {
-  return createMutableAtomFamily(IMPLICIT.STORE, options);
-}
-function disposeState(...params) {
-  disposeFromStore(IMPLICIT.STORE, ...params);
-}
-function findState(token, key) {
-  return findInStore(IMPLICIT.STORE, token, key);
-}
-function getState(...params) {
-  return getFromStore(IMPLICIT.STORE, ...params);
-}
-function join(options) {
-  return createJoin(IMPLICIT.STORE, options);
-}
-function findRelations(token, key) {
-  return findRelationsInStore(token, key, IMPLICIT.STORE);
-}
-function editRelations(token, change) {
-  editRelationsInStore(token, change, IMPLICIT.STORE);
-}
-function getInternalRelations(token) {
-  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
-}
-var PRETTY_TOKEN_TYPES = {
-  atom_family: `atom family`,
-  atom: `atom`,
-  continuity: `continuity`,
-  key: `key`,
-  mutable_atom_family: `atom family [m]`,
-  mutable_atom: `atom [m]`,
-  readonly_held_selector_family: `selector family [h]`,
-  readonly_held_selector: `selector [h]`,
-  readonly_pure_selector_family: `selector family`,
-  readonly_pure_selector: `selector`,
-  state: `state`,
-  timeline: `timeline`,
-  transaction: `transaction`,
-  unknown: `unknown`,
-  writable_held_selector_family: `selector family [wh]`,
-  writable_held_selector: `selector [wh]`,
-  writable_pure_selector_family: `selector family [w]`,
-  writable_pure_selector: `selector [w]`
-};
-var LOG_LEVELS = [
-  `info`,
-  `warn`,
-  `error`
-];
-var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
-  console[logLevel](`${icon} ${PRETTY_TOKEN_TYPES[denomination]} \`${tokenKey}\` ${message}`, ...rest);
-};
-var simpleLogger = {
-  error: simpleLog(`error`),
-  info: simpleLog(`info`),
-  warn: simpleLog(`warn`)
-};
-var AtomIOLogger = class {
-  logLevel;
-  filter;
-  logger;
-  constructor(logLevel, filter, logger = simpleLogger) {
-    this.logLevel = logLevel;
-    this.filter = filter;
-    this.logger = logger;
-  }
-  error = (...args) => {
-    if (this.logLevel !== null) {
-      const filterResult = this.filter?.(...args) ?? true;
-      if (filterResult === true) this.logger.error(...args);
-      else if (filterResult) this.logger.error(...filterResult);
-    }
-  };
-  info = (...args) => {
-    if (this.logLevel === `info`) {
-      const filterResult = this.filter?.(...args) ?? true;
-      if (filterResult === true) this.logger.info(...args);
-      else if (filterResult) this.logger.info(...filterResult);
-    }
-  };
-  warn = (...args) => {
-    if (this.logLevel !== `error` && this.logLevel !== null) {
-      const filterResult = this.filter?.(...args) ?? true;
-      if (filterResult === true) this.logger.warn(...args);
-      else if (filterResult) this.logger.warn(...filterResult);
-    }
-  };
-};
-var $validatedKey = Symbol.for(`claim`);
-function simpleCompound(a, b) {
-  return [a, b].sort().join(``);
-}
-var Realm = class {
-  store;
-  deallocateTX;
-  claimTX;
-  /**
-  * @param store - The store to which the realm will be attached
-  */
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    this.deallocateTX = createDeallocateTX(store);
-    this.claimTX = createClaimTX(store);
-    makeRootMoleculeInStore(store, `root`);
-  }
-  /**
-  * Make space for a new subject of the realm
-  * @param provenance - A key for an owner {@link Above} the new subject in the realm's {@link Hierarchy}
-  * @param key - A unique identifier for the new subject
-  * @param attachmentStyle - The attachment style of new subject to its owner(s). `any` means that if any owners remain, the subject will be retained. `all` means that the subject be retained only if all owners remain .
-  * @returns
-  * The subject's key, given status as a true {@link ValidKey}
-  */
-  allocate(provenance, key, attachmentStyle) {
-    return allocateIntoStore(this.store, provenance, key, attachmentStyle);
-  }
-  /**
-  * Fuse two reagents into a compound
-  * @param type - the name of the compound that is being fused
-  * @param reagentA - the left reagent of the compound
-  * @param reagentB - the right reagent of the compound
-  * @returns
-  * The compound's key, given status as a {@link ValidKey}
-  */
-  fuse(type, reagentA, reagentB) {
-    return fuseWithinStore(this.store, type, reagentA, reagentB);
-  }
-  /**
-  * Remove a subject from the realm
-  * @param claim - The subject to be deallocated
-  */
-  deallocate(claim) {
-    actUponStore(this.store, this.deallocateTX, arbitrary())(claim);
-  }
-  /**
-  * Transfer a subject of the realm from one owner to another
-  * @param newProvenance - A key for an owner {@link Above} the new subject in the realm's {@link Hierarchy}
-  * @param claim - The subject to be claimed
-  * @param exclusive - Whether the subjects previous owners should be detached from it
-  * @returns
-  * The subject's key, given status as a true {@link ValidKey}
-  */
-  claim(newProvenance, claim, exclusive) {
-    actUponStore(this.store, this.claimTX, arbitrary())(newProvenance, claim, exclusive);
-  }
-};
-var Anarchy = class {
-  store;
-  deallocateTX;
-  claimTX;
-  /**
-  * @param store - The store to which the anarchy-realm will be attached
-  */
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    this.deallocateTX = createDeallocateTX(store);
-    this.claimTX = createClaimTX(store);
-    makeRootMoleculeInStore(store, `root`);
-  }
-  /**
-  * Declare a new entity
-  * @param provenance - A key for an owner of the entity
-  * @param key - A unique identifier for the new entity
-  * @param attachmentStyle - The attachment style of new entity to its owner(s). `any` means that if any owners remain, the subject will be retained. `all` means that the subject be retained only if all owners remain .
-  */
-  allocate(provenance, key, attachmentStyle) {
-    allocateIntoStore(this.store, provenance, key, attachmentStyle);
-  }
-  /**
-  * Remove an entity
-  * @param key - The entity to be deallocated
-  */
-  deallocate(key) {
-    actUponStore(this.store, this.deallocateTX, arbitrary())(key);
-  }
-  /**
-  * Transfer an entity from one owner to another
-  * @param newProvenance - A key for an owner of the entity
-  * @param key - The entity to be claimed
-  * @param exclusive - Whether the entity's previous owners should be detached from it
-  */
-  claim(newProvenance, key, exclusive) {
-    claimWithinStore(this.store, newProvenance, key, exclusive);
-  }
-  /**
-  * Fuse two reagents into a compound
-  * @param type - the name of the compound that is being fused
-  * @param reagentA - the left reagent of the compound
-  * @param reagentB - the right reagent of the compound
-  * @returns
-  * The compound's key, given status as a {@link ValidKey}
-  */
-  fuse(type, reagentA, reagentB) {
-    return fuseWithinStore(this.store, type, reagentA, reagentB);
-  }
-};
-function decomposeCompound(compound) {
-  if (typeof compound === `string` === false) return null;
-  const [typeTag, components] = compound.split(`==`);
-  if (!components) return null;
-  const type = typeTag.slice(4);
-  const [a, b] = components.split(`++`);
-  if (type && a && b) return [
-    type,
-    a,
-    b
-  ];
-  return null;
-}
-function resetState(...params) {
-  resetInStore(IMPLICIT.STORE, ...params);
-}
-function selector(options) {
-  return createStandaloneSelector(IMPLICIT.STORE, options);
-}
-function selectorFamily(options) {
-  return createSelectorFamily(IMPLICIT.STORE, options);
-}
-function setState(...params) {
-  setIntoStore(IMPLICIT.STORE, ...params);
-}
-var Silo = class {
-  store;
-  atom;
-  mutableAtom;
-  atomFamily;
-  mutableAtomFamily;
-  selector;
-  selectorFamily;
-  transaction;
-  timeline;
-  findState;
-  getState;
-  setState;
-  resetState;
-  disposeState;
-  subscribe;
-  undo;
-  redo;
-  runTransaction;
-  install;
-  constructor(config, fromStore = null) {
-    const s = this.store = new Store(config, fromStore);
-    this.atom = ((options) => createRegularAtom(s, options, void 0));
-    this.mutableAtom = ((options) => createMutableAtom(s, options, void 0));
-    this.atomFamily = ((options) => createRegularAtomFamily(s, options));
-    this.mutableAtomFamily = ((options) => createMutableAtomFamily(s, options));
-    this.selector = ((options) => createStandaloneSelector(s, options));
-    this.selectorFamily = ((options) => createSelectorFamily(s, options));
-    this.transaction = (options) => createTransaction(s, options);
-    this.timeline = (options) => createTimeline(s, options);
-    this.findState = ((...params) => findInStore(s, ...params));
-    this.getState = ((...params) => getFromStore(s, ...params));
-    this.setState = ((...params) => {
-      setIntoStore(s, ...params);
-    });
-    this.resetState = ((...params) => {
-      resetInStore(s, ...params);
-    });
-    this.disposeState = ((...params) => {
-      disposeFromStore(s, ...params);
-    });
-    this.subscribe = ((...params) => subscribeInStore(s, ...params));
-    this.undo = (token) => {
-      timeTravel(s, `undo`, token);
-    };
-    this.redo = (token) => {
-      timeTravel(s, `redo`, token);
-    };
-    this.runTransaction = (token, id = arbitrary()) => actUponStore(s, token, id);
-    this.install = (tokens, source = IMPLICIT.STORE) => {
-      installIntoStore(tokens, s, source);
-    };
-  }
-};
-function subscribe(token, handleUpdate, key = arbitrary()) {
-  return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key);
-}
-var redo = (timeline$1) => {
-  timeTravel(IMPLICIT.STORE, `redo`, timeline$1);
-};
-var undo = (timeline$1) => {
-  timeTravel(IMPLICIT.STORE, `undo`, timeline$1);
-};
-var timeline = (options) => {
-  return createTimeline(IMPLICIT.STORE, options);
-};
-function transaction(options) {
-  return createTransaction(IMPLICIT.STORE, options);
-}
-function runTransaction(token, id = arbitrary()) {
-  return actUponStore(IMPLICIT.STORE, token, id);
-}
-function isToken(knownToken, unknownToken) {
-  return knownToken.key === unknownToken.key;
-}
-function belongsTo(family, unknownToken) {
-  return family.key === unknownToken.family?.key;
-}
-
-export {
-  IMPLICIT,
-  withdraw,
-  getFromStore,
-  findInStore,
-  setIntoStore,
-  subscribeToState,
-  subscribeToTimeline,
-  getJsonToken,
-  atom,
-  mutableAtom,
-  atomFamily,
-  mutableAtomFamily,
-  disposeState,
-  findState,
-  getState,
-  join,
-  findRelations,
-  editRelations,
-  getInternalRelations,
-  PRETTY_TOKEN_TYPES,
-  LOG_LEVELS,
-  simpleLog,
-  simpleLogger,
-  AtomIOLogger,
-  $validatedKey,
-  simpleCompound,
-  Realm,
-  Anarchy,
-  decomposeCompound,
-  resetState,
-  selector,
-  selectorFamily,
-  setState,
-  Silo,
-  subscribe,
-  redo,
-  undo,
-  timeline,
-  transaction,
-  runTransaction,
-  isToken,
-  belongsTo
-};
-//# sourceMappingURL=chunk-6VZTUEOV.js.map