tempest.games 0.2.105 → 0.3.1

package/bin/backend.worker.game.bun.js

@@ -1,3393 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// ../../packages/atom.io/dist/main/index.js
-function mutableAtom(options) {
-  return createMutableAtom(IMPLICIT.STORE, options, undefined);
-}
-function atomFamily(options) {
-  return createRegularAtomFamily(IMPLICIT.STORE, options);
-}
-function getState(...params) {
-  return getFromStore(IMPLICIT.STORE, ...params);
-}
-function join(options) {
-  return createJoin(IMPLICIT.STORE, options);
-}
-function getInternalRelations(token, split) {
-  return getInternalRelationsFromStore(IMPLICIT.STORE, token, split);
-}
-var PRETTY_ENTITY_NAMES = {
-  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`,
-  socket: `socket`,
-  state: `state`,
-  timeline: `timeline`,
-  transaction: `transaction`,
-  unknown: `unknown`,
-  user: `\uD83D\uDC64`,
-  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 simpleLog = (logLevel, prefix) => (icon, denomination, tokenKey, message, ...rest) => {
-  console[logLevel](`${prefix ? `${prefix} ` : ``}${icon} ${PRETTY_ENTITY_NAMES[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(`\x1F`);
-}
-function selectorFamily(options) {
-  return createSelectorFamily(IMPLICIT.STORE, options);
-}
-
-// ../../packages/atom.io/dist/json/index.js
-var BOOL = `\x01`;
-var NULL = `\x02`;
-var STRING = `\x03`;
-var NUMBER = `\x04`;
-var packCanonical = (value) => {
-  if (value === null)
-    return NULL;
-  switch (typeof value) {
-    case `string`:
-      return STRING + value;
-    case `number`:
-      return NUMBER + value;
-    case `boolean`:
-      return BOOL + +value;
-    case `object`:
-      return JSON.stringify(value);
-  }
-};
-var unpackCanonical = (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;
-    case `[`:
-      return JSON.parse(value);
-  }
-};
-function enumeration(values) {
-  const result = {};
-  let i = 0;
-  for (const value of values) {
-    result[value] = i;
-    result[i] = value;
-    ++i;
-  }
-  return result;
-}
-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
-];
-
-// ../../packages/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] + `\x1F`;
-    if (update.type === `clear`)
-      return head + update.values.map(packCanonical).join(`\x1E`);
-    return head + packCanonical(update.value);
-  }
-  static unpackUpdate(packed) {
-    const [type, tail] = packed.split(`\x1F`);
-    const head = SET_UPDATE_ENUM[type];
-    if (head === `clear`)
-      return {
-        type: `clear`,
-        values: tail.split(`\x1E`).map(unpackCanonical)
-      };
-    return {
-      type: head,
-      value: unpackCanonical(tail)
-    };
-  }
-};
-
-// ../../packages/atom.io/dist/internal/index.js
-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 = undefined;
-    }
-  }
-};
-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 = new Set([b]);
-      this.relations.set(a, aRelations);
-    }
-    if (bRelations)
-      bRelations.add(a);
-    else {
-      bRelations = 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 : undefined;
-    let b = a === undefined ? x : undefined;
-    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 === undefined) {
-        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 : undefined;
-        let b = a === undefined ? x : undefined;
-        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 = undefined;
-        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 === undefined && 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 === undefined) {
-      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 !== undefined && b === undefined) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations)
-        return [...aRelations].map((aRelation) => {
-          return [aRelation, this.getContent(a, aRelation)];
-        });
-    }
-    if (a === undefined && b !== undefined) {
-      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(`\uD83D\uDD0D `);
-}
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
-}
-function isChildStore(store) {
-  return `phase` in store.transactionMeta;
-}
-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 [, atom$1] of store.atoms) {
-        if (mutableHelpers.has(atom$1.key))
-          continue;
-        atom$1.install(this);
-        if (atom$1.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(store, atom$1);
-          const originalUpdateToken = getUpdateToken(atom$1);
-          mutableHelpers.add(originalJsonToken.key);
-          mutableHelpers.add(originalUpdateToken.key);
-        }
-      }
-      for (const [, selector$1] of store.readonlySelectors)
-        selector$1.install(this);
-      for (const [, selector$1] of store.writableSelectors) {
-        if (mutableHelpers.has(selector$1.key))
-          continue;
-        selector$1.install(this);
-      }
-      for (const [, tx] of store.transactions)
-        tx.install(this);
-      for (const [, timeline] of store.timelines)
-        timeline.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_ENTITY_NAMES[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(`\u274C`, 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(`\uD83E\uDDEE`, type, key, `computing value`);
-      try {
-        val = state.getFrom(target);
-        if (val instanceof Promise)
-          val = val.catch((thrown) => {
-            target.logger.error(`\uD83D\uDCA5`, type, key, `rejected:`, thrown);
-            if (canCatch) {
-              for (const Class of canCatch)
-                if (thrown instanceof Class)
-                  return thrown;
-            }
-            throw thrown;
-          });
-      } catch (e) {
-        target.logger.error(`\uD83D\uDCA5`, 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(`\uD83D\uDCA5`, type, key, `rejected:`, thrown);
-              if (canCatch) {
-                for (const Class of canCatch)
-                  if (thrown instanceof Class)
-                    return thrown;
-              }
-              throw thrown;
-            });
-        } catch (e) {
-          target.logger.error(`\uD83D\uDCA5`, type, key, `rejected:`, e);
-          if (canCatch) {
-            for (const Class of canCatch)
-              if (e instanceof Class) {
-                def = writeToCache(target, state, e);
-                target.logger.info(`\u2728`, state.type, key, `computed default`, def);
-                return def;
-              }
-          }
-          throw e;
-        }
-      else {
-        def = state.default;
-        target.logger.info(`\u2728`, 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(`\u2754`, 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(`\uD83E\uDDEE`, 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(`\u2728`, 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(`\uD83D\uDCA3`, `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(`\uD83D\uDC6A`, 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(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_ENTITY_NAMES[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(`\u2757`, `atom_family`, options.key, `Overwriting an existing ${PRETTY_ENTITY_NAMES[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(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_ENTITY_NAMES[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(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_ENTITY_NAMES[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(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_ENTITY_NAMES[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, undefined);
-  if (isHeld)
-    return createReadonlyHeldSelectorFamily(store, options, undefined);
-  if (isWritable)
-    return createWritablePureSelectorFamily(store, options);
-  return createReadonlyPureSelectorFamily(store, options);
-}
-function openOperation(store, token) {
-  if (store.operation.open) {
-    const rejectionTime = performance.now();
-    store.logger.info(`\uD83D\uDEAB`, 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(`\u2B55`, 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(`\uD83D\uDD34`, 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(`\uD83D\uDC1E`, `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(`\uD83D\uDC1E`, `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, proto, stateIsNewlyCreated, family) {
-  const { oldValue, newValue } = proto;
-  const hasOldValue = `oldValue` in proto;
-  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;
-  let update;
-  if (hasOldValue)
-    update = {
-      oldValue: isTransceiver(oldValue) ? oldValue.READONLY_VIEW : oldValue,
-      newValue: isTransceiver(newValue) ? newValue.READONLY_VIEW : newValue
-    };
-  else
-    update = { newValue: isTransceiver(newValue) ? newValue.READONLY_VIEW : newValue };
-  if (isRootStore(target)) {
-    switch (type) {
-      case `mutable_atom`:
-        target.logger.info(`\uD83D\uDCE2`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers.keys());
-        break;
-      case `atom`:
-      case `writable_pure_selector`:
-      case `writable_held_selector`:
-        target.logger.info(`\uD83D\uDCE2`, 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(`\uD83D\uDCC1`, `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 UNSET = Symbol(`UNSET`);
-var setAtom = (target, atom$1, next) => {
-  let oldValue;
-  let newValue;
-  if (isFn(next)) {
-    const prev = readOrComputeValue(target, atom$1, `mut`);
-    oldValue = prev;
-    newValue = next(prev);
-  } else {
-    if (target.valueMap.has(atom$1.key))
-      oldValue = readFromCache(target, atom$1, `mut`);
-    else if (atom$1.type === `atom` && !isFn(atom$1.default))
-      oldValue = atom$1.default;
-    else
-      oldValue = UNSET;
-    newValue = next;
-  }
-  target.logger.info(`\u2B50`, `atom`, atom$1.key, `setting value`, newValue);
-  newValue = writeToCache(target, atom$1, newValue);
-  markDone(target, atom$1.key);
-  evictDownstreamFromAtom(target, atom$1);
-  if (oldValue === UNSET)
-    return { newValue };
-  return {
-    oldValue,
-    newValue
-  };
-};
-function resetAtom(target, atom$1) {
-  switch (atom$1.type) {
-    case `mutable_atom`:
-      return setAtom(target, atom$1, new atom$1.class);
-    case `atom`: {
-      let def;
-      if (isFn(atom$1.default))
-        def = safeCompute(target, atom$1);
-      else
-        def = atom$1.default;
-      return setAtom(target, atom$1, 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 atom$1 of atoms.values())
-          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom$1), 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 atom$1 of atoms.values())
-          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom$1), 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, selector$1, next) {
-  let oldValue;
-  let newValue;
-  let constant;
-  const { type, key } = selector$1;
-  switch (selector$1.type) {
-    case `writable_pure_selector`:
-      oldValue = readOrComputeValue(target, selector$1, `mut`);
-      newValue = become(next, oldValue);
-      newValue = writeToCache(target, selector$1, newValue);
-      break;
-    case `writable_held_selector`:
-      constant = selector$1.const;
-      become(next, constant);
-      oldValue = constant;
-      newValue = constant;
-  }
-  target.logger.info(`\u2B50`, type, key, `setting to`, newValue);
-  markDone(target, key);
-  selector$1.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(`\uD83D\uDFE2`, 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(`\u274C`, 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 atom$1 = store.atoms.get(dependencyKey);
-      roots.set(atom$1.key, atom$1);
-    } 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(`\uD83D\uDD0D`, selectorType, selectorKey, `discovers root atom "${dependencyKey}"`);
-  } else {
-    const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered);
-    store.logger.info(`\uD83D\uDD0D`, 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(`\uD83D\uDD0C`, 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(`\uD83D\uDD28`, 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(`\u2728`, 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(`\uD83D\uDD28`, 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 value = options.get({
-      get,
-      find,
-      json
-    });
-    store.logger.info(`\u2728`, type, key, `=`, value);
-    covered.clear();
-    return value;
-  };
-  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(`\uD83D\uDD28`, 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(`\u2728`, 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(`\uD83D\uDD28`, 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 value = options.get(getterToolkit);
-    store.logger.info(`\u2728`, type, key, `=`, value);
-    covered.clear();
-    return value;
-  };
-  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, undefined);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
-  }
-  if (isHeld) {
-    const state$1 = createReadonlyHeldSelector(store, options, undefined);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
-  }
-  if (isWritable) {
-    const state$1 = createWritablePureSelector(store, options, undefined);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
-  }
-  const state = createReadonlyPureSelector(store, options, undefined);
-  store.on.selectorCreation.next(state);
-  return state;
-}
-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, selector$1, atom$1) => {
-  return atom$1.subject.subscribe(`${selector$1.type}:${selector$1.key}`, (atomChange) => {
-    target.logger.info(`\uD83D\uDCE2`, selector$1.type, selector$1.key, `root`, atom$1.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
-    const oldValue = recallState(target, selector$1);
-    const newValue = readOrComputeValue(target, selector$1);
-    target.logger.info(`\u2728`, selector$1.type, selector$1.key, `went`, oldValue, `->`, newValue);
-    selector$1.subject.next({
-      newValue,
-      oldValue
-    });
-  });
-};
-function subscribeToState(store, token, key, handleUpdate) {
-  function safelyHandleUpdate(update) {
-    if (store.operation.open && state?.type === `atom` && hasRole(state, `tracker:signal`) && `*` + store.operation.token.key === token.key && `inboundTracker` in handleUpdate)
-      return;
-    handleUpdate(update);
-  }
-  reduceReference(store, token);
-  const state = withdraw(store, token);
-  store.logger.info(`\uD83D\uDC40`, 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, atom$1] of traceRootSelectorAtoms(store, state.key))
-      rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
-    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, atom$1] of dependencies)
-        rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
-      safelyHandleUpdate(update);
-    };
-  }
-  const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
-  const unsubscribe = () => {
-    store.logger.info(`\uD83D\uDE48`, 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(`\uD83D\uDC40`, `timeline`, token.key, `Adding subscription "${key}"`);
-  const unsubscribe = tl.subject.subscribe(key, handleUpdate);
-  return () => {
-    store.logger.info(`\uD83D\uDE48`, `timeline`, token.key, `Removing subscription "${key}" from timeline`);
-    unsubscribe();
-  };
-};
-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
-    } : undefined;
-    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(`\uD83D\uDD28`, `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(`\u274C`, 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(`\uD83D\uDEE0\uFE0F`, `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(`\u2757`, `mutable_atom_family`, options.key, `Overwriting an existing ${PRETTY_ENTITY_NAMES[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 = (mutableAtomFamily, store) => {
-  const target = newest(store);
-  const key = `${mutableAtomFamily.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(`\uD83D\uDCA5`, state.type, key, `rejected:`, thrown);
-    });
-    return future;
-  }
-  target.logger.info(`\uD83D\uDCDD`, state.type, state.key, `writing to cache`, value);
-  target.valueMap.set(key, value);
-  return value;
-}
-function readFromCache(target, state, mut) {
-  target.logger.info(`\uD83D\uDCD6`, 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(`\uD83D\uDCC3`, `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)
-    return;
-  if (target.operation.open)
-    target.operation.prev.set(key, currentValue);
-  target.valueMap.delete(key);
-  target.logger.info(`\uD83D\uDDD1`, `state`, key, `evicted`);
-}
-function evictDownstreamFromAtom(store, atom$1) {
-  const target = newest(store);
-  const { key, type } = atom$1;
-  const downstreamKeys = target.selectorAtoms.getRelatedKeys(key);
-  target.logger.info(`\uD83E\uDDF9`, type, key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
-  if (downstreamKeys) {
-    if (target.operation.open)
-      target.logger.info(`\uD83E\uDDF9`, 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(`\uD83D\uDD28`, 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(`\u274C`, `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(`\uD83D\uDEE0\uFE0F`, 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(atom$1, role) {
-  if (`internalRoles` in atom$1 === false)
-    return false;
-  return atom$1.internalRoles.includes(role);
-}
-function capitalize(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
-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(store, options) {
-    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(store, options));
-  return {
-    key: options.key,
-    type: `join`,
-    a: options.between[0],
-    b: options.between[1],
-    cardinality: options.cardinality
-  };
-}
-function getJoin(store, token) {
-  let myJoin = store.joins.get(token.key);
-  if (myJoin === undefined) {
-    const rootJoin = IMPLICIT.STORE.joins.get(token.key);
-    if (rootJoin === undefined)
-      throw new Error(`Join "${token.key}" not found in store "${store.config.name}"`);
-    myJoin = new Join(eldest(store), rootJoin.options);
-    store.joins.set(token.key, myJoin);
-  }
-  return myJoin;
-}
-function editRelationsInStore(store, token, change) {
-  const myJoin = getJoin(store, token);
-  const target = newest(store);
-  if (isChildStore(target)) {
-    const { toolkit } = target.transactionMeta;
-    myJoin.transact(toolkit, ({ relations }) => {
-      change(relations);
-    });
-  } else
-    change(myJoin.relations);
-}
-function findRelationsInStore(store, token, key) {
-  const myJoin = getJoin(store, token);
-  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(store, token, split) {
-  const myJoin = getJoin(store, token);
-  if (split === `split`)
-    return [myJoin.relatedKeysAtoms, myJoin.relatedKeysAtoms];
-  return myJoin.relatedKeysAtoms;
-}
-
-// ../../packages/atom.io/dist/realtime/index.js
-var mutexAtoms = atomFamily({
-  key: `mutex`,
-  default: false
-});
-var InvariantMap = class extends Map {
-  set(key, value) {
-    if (this.has(key)) {
-      console.warn(`Tried to set a key that already exists in an InvariantMap`, {
-        key,
-        value
-      });
-      return this;
-    }
-    return super.set(key, value);
-  }
-};
-var SyncGroup = class SyncGroup2 {
-  type = `continuity`;
-  globals = [];
-  actions = [];
-  perspectives = [];
-  key;
-  constructor(key) {
-    this.key = key;
-  }
-  static existing = new InvariantMap;
-  static create(key, builder) {
-    const { type, globals, actions, perspectives } = builder(new SyncGroup2(key));
-    const token = {
-      type,
-      key,
-      globals,
-      actions,
-      perspectives
-    };
-    SyncGroup2.existing.set(key, token);
-    return token;
-  }
-  add(...args) {
-    switch (args[0].type) {
-      case `atom`:
-      case `mutable_atom`:
-        this.globals.push(...args);
-        break;
-      case `transaction`:
-        this.actions.push(...args);
-        break;
-      case `atom_family`:
-      case `mutable_atom_family`:
-        {
-          const [family, index] = args;
-          this.perspectives.push({
-            type: `realtime_perspective`,
-            resourceAtoms: family,
-            viewAtoms: index
-          });
-        }
-        break;
-    }
-    return this;
-  }
-};
-var isSocketKey = (key) => key.startsWith(`socket::`);
-var isUserKey = (key) => key.startsWith(`user::`);
-var isRoomKey = (key) => key.startsWith(`room::`);
-var roomKeysAtom = mutableAtom({
-  key: `roomKeys`,
-  class: UList
-});
-var usersInRooms = join({
-  key: `usersInRooms`,
-  between: [`room`, `user`],
-  cardinality: `1:n`,
-  isAType: isRoomKey,
-  isBType: isUserKey
-});
-var visibleUsersInRoomsSelector = selectorFamily({
-  key: `visibleUsersInRooms`,
-  get: (userKey) => ({ get }) => {
-    const [, roomsOfUsersAtoms] = getInternalRelations(usersInRooms, `split`);
-    return [userKey, ...get(roomsOfUsersAtoms, userKey)];
-  }
-});
-var visibilityFromRoomSelector = selectorFamily({
-  key: `visibilityFromRoom`,
-  get: (roomKey) => ({ get }) => {
-    const [usersOfRoomsAtoms] = getInternalRelations(usersInRooms, `split`);
-    return [roomKey, ...get(usersOfRoomsAtoms, roomKey)];
-  }
-});
-var mutualUsersSelector = selectorFamily({
-  key: `mutualUsers`,
-  get: (userKey) => ({ get }) => {
-    const [usersOfRoomsAtoms, roomsOfUsersAtoms] = getInternalRelations(usersInRooms, `split`);
-    const rooms = get(roomsOfUsersAtoms, userKey);
-    for (const room of rooms)
-      return [...get(usersOfRoomsAtoms, room)];
-    return [userKey];
-  }
-});
-var ownersOfRooms = join({
-  key: `ownersOfRooms`,
-  between: [`user`, `room`],
-  cardinality: `1:n`,
-  isAType: isUserKey,
-  isBType: isRoomKey
-});
-
-// ../../packages/atom.io/dist/realtime-server/index.js
-var redactorAtoms = atomFamily({
-  key: `redactor`,
-  default: { occlude: (updates) => updates }
-});
-var unacknowledgedUpdatesAtoms = atomFamily({
-  key: `unacknowledgedUpdates`,
-  default: () => []
-});
-var CustomSocket = class {
-  listeners;
-  globalListeners;
-  globalListenersOutgoing;
-  handleEvent(...args) {
-    const [event, ...rest] = args;
-    for (const listener of this.globalListeners)
-      listener(event, ...rest);
-    const listeners = this.listeners.get(event);
-    if (listeners)
-      for (const listener of listeners)
-        listener(...rest);
-  }
-  id = `no_id_retrieved`;
-  emit;
-  constructor(emit) {
-    this.emit = (...args) => {
-      for (const listener of this.globalListenersOutgoing)
-        listener(...args);
-      return emit(...args);
-    };
-    this.listeners = /* @__PURE__ */ new Map;
-    this.globalListeners = /* @__PURE__ */ new Set;
-    this.globalListenersOutgoing = /* @__PURE__ */ new Set;
-  }
-  on(event, listener) {
-    const listeners = this.listeners.get(event);
-    if (listeners)
-      listeners.add(listener);
-    else
-      this.listeners.set(event, new Set([listener]));
-    return this;
-  }
-  onAny(listener) {
-    this.globalListeners.add(listener);
-    return this;
-  }
-  onAnyOutgoing(listener) {
-    this.globalListenersOutgoing.add(listener);
-    return this;
-  }
-  off(event, listener) {
-    const listeners = this.listeners.get(event);
-    if (listeners)
-      if (listener)
-        listeners.delete(listener);
-      else
-        this.listeners.delete(event);
-    return this;
-  }
-  offAny(listener) {
-    this.globalListeners.delete(listener);
-    return this;
-  }
-};
-var PROOF_OF_LIFE_SIGNAL = `ALIVE`;
-var SubjectSocket = class extends CustomSocket {
-  in;
-  out;
-  id = `no_id_retrieved`;
-  disposalEffects = [];
-  constructor(id) {
-    super((...args) => {
-      this.out.next(args);
-      return this;
-    });
-    this.id = id;
-    this.in = new Subject;
-    this.out = new Subject;
-    this.in.subscribe(`socket`, (event) => {
-      this.handleEvent(...event);
-    });
-  }
-  dispose() {
-    for (const dispose of this.disposalEffects)
-      dispose();
-  }
-};
-var ParentSocket = class extends CustomSocket {
-  incompleteData = ``;
-  unprocessedEvents = [];
-  relays;
-  initRelay;
-  proc;
-  id = `#####`;
-  log(...args) {
-    this.proc.stderr.write(stringifyJson(args.map((arg) => arg instanceof UList ? `{ ${arg.toJSON().join(` | `)} }` : arg)) + `\x03`);
-  }
-  logger = {
-    info: (...args) => {
-      this.log(`i`, ...args);
-    },
-    warn: (...args) => {
-      this.log(`w`, ...args);
-    },
-    error: (...args) => {
-      this.log(`e`, ...args);
-    }
-  };
-  constructor(proc) {
-    super((event, ...args) => {
-      const stringifiedEvent = JSON.stringify([event, ...args]);
-      this.proc.stdout.write(stringifiedEvent + `\x03`);
-      return this;
-    });
-    this.proc = proc;
-    this.proc.stdin.resume();
-    this.relays = /* @__PURE__ */ new Map;
-    this.initRelay = () => {
-      this.logger.info(`\uD83D\uDD17`, `nothing to relay`);
-    };
-    this.proc.stdin.on(`data`, (buffer) => {
-      const pieces = buffer.toString().split(`\x03`);
-      const initialMaybeWellFormed = pieces[0];
-      pieces[0] = this.incompleteData + initialMaybeWellFormed;
-      let idx = 0;
-      for (const piece of pieces) {
-        if (piece === ``)
-          continue;
-        try {
-          const jsonPiece = parseJson(piece);
-          this.logger.info(`\uD83C\uDFB0`, `received`, jsonPiece);
-          this.handleEvent(...jsonPiece);
-          this.incompleteData = ``;
-        } catch (thrown0) {
-          if (thrown0 instanceof Error)
-            this.logger.error([
-              `received malformed data from parent process:`,
-              ``,
-              piece,
-              ``,
-              thrown0.message
-            ].join(`
-\u274C	`));
-          try {
-            if (idx === 0) {
-              this.incompleteData = piece;
-              const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
-              this.logger.info(`\uD83C\uDFB0`, `received`, maybeActualJsonPiece);
-              this.handleEvent(...maybeActualJsonPiece);
-              this.incompleteData = ``;
-            } else
-              this.incompleteData += piece;
-          } catch (thrown1) {
-            if (thrown1 instanceof Error)
-              this.logger.error([
-                `received malformed data from parent process:`,
-                ``,
-                initialMaybeWellFormed,
-                ``,
-                thrown1.message
-              ].join(`
-\u274C	`));
-          }
-        }
-        ++idx;
-      }
-    });
-    this.on(`exit`, () => {
-      this.logger.info(`\uD83D\uDD25`, this.id, `received "exit"`);
-      this.proc.exit(0);
-    });
-    if (this.proc.pid)
-      this.id = this.proc.pid?.toString();
-    this.on(`user-joins`, (userKey) => {
-      this.logger.info(`\uD83D\uDC64`, userKey, `joined`);
-      const existingRelay = this.relays.get(userKey);
-      if (existingRelay) {
-        this.logger.info(`\uD83D\uDD17`, `reattaching relay services for`, userKey);
-        const cleanupRelay$1 = this.initRelay(existingRelay, userKey);
-        if (cleanupRelay$1)
-          existingRelay.disposalEffects.push(cleanupRelay$1);
-        this.on(userKey, (...data) => {
-          relay.in.next(data);
-        });
-        existingRelay.disposalEffects.push(existingRelay.out.subscribe(`socket`, (data) => {
-          this.emit(userKey, ...data);
-        }));
-        return;
-      }
-      const relay = new SubjectSocket(userKey);
-      this.relays.set(userKey, relay);
-      this.logger.info(`\uD83D\uDD17`, `attaching relay services for`, userKey);
-      const cleanupRelay = this.initRelay(relay, userKey);
-      if (cleanupRelay)
-        relay.disposalEffects.push(cleanupRelay);
-      this.on(userKey, (...data) => {
-        relay.in.next(data);
-      });
-      relay.disposalEffects.push(relay.out.subscribe(`socket`, (data) => {
-        this.emit(userKey, ...data);
-      }));
-    });
-    this.on(`user-leaves`, (userKey) => {
-      const relay = this.relays.get(userKey);
-      this.off(userKey);
-      if (relay) {
-        relay.dispose();
-        this.relays.delete(userKey);
-      }
-    });
-    this.proc.stdout.write(PROOF_OF_LIFE_SIGNAL);
-  }
-  receiveRelay(attachServices) {
-    this.initRelay = attachServices;
-    this.logger.info(`\uD83D\uDD17`, `ready to relay`);
-  }
-};
-var ChildSocket = class extends CustomSocket {
-  incompleteData = ``;
-  unprocessedEvents = [];
-  incompleteLog = ``;
-  unprocessedLogs = [];
-  id = `#####`;
-  proc;
-  key;
-  logger;
-  handleLog(log) {
-    if (Array.isArray(log)) {
-      const [level, ...rest] = log;
-      switch (level) {
-        case `i`:
-          this.logger.info(...rest);
-          break;
-        case `w`:
-          this.logger.warn(...rest);
-          break;
-        case `e`:
-          this.logger.error(...rest);
-          break;
-      }
-    }
-  }
-  constructor(proc, key, logger) {
-    super((event, ...args) => {
-      const stringifiedEvent = JSON.stringify([event, ...args]) + `\x03`;
-      this.proc.stdin.write(stringifiedEvent);
-      return this;
-    });
-    this.proc = proc;
-    this.key = key;
-    this.logger = logger ?? {
-      info: (...args) => {
-        console.info(this.id, this.key, ...args);
-      },
-      warn: (...args) => {
-        console.warn(this.id, this.key, ...args);
-      },
-      error: (...args) => {
-        console.error(this.id, this.key, ...args);
-      }
-    };
-    this.proc.stdout.on(`data`, (buffer) => {
-      if (buffer[0] === 27 && buffer[1] === 91 && buffer[2] === 50) {
-        this.logger.info(`STDOUT TERMINAL CLEAR`, buffer);
-        return;
-      }
-      const chunk = buffer.toString();
-      if (chunk === PROOF_OF_LIFE_SIGNAL)
-        return;
-      const pieces = chunk.split(`\x03`);
-      const initialMaybeWellFormed = pieces[0];
-      pieces[0] = this.incompleteData + initialMaybeWellFormed;
-      let idx = 0;
-      for (const piece of pieces) {
-        if (piece === ``)
-          continue;
-        try {
-          const jsonPiece = parseJson(piece);
-          this.logger.info(`\uD83D\uDCB8`, `emitted`, jsonPiece);
-          this.handleEvent(...jsonPiece);
-          this.incompleteData = ``;
-        } catch (thrown0) {
-          if (thrown0 instanceof Error)
-            console.error([
-              `\u274C Malformed data received from child process:`,
-              ``,
-              ...piece.split(`
-`),
-              ``,
-              thrown0.message
-            ].join(`
-\u274C	`) + `
-`);
-          try {
-            if (idx === 0) {
-              this.incompleteData = piece;
-              const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
-              this.logger.info(`\uD83D\uDCB8`, `emitted`, maybeActualJsonPiece);
-              this.handleEvent(...maybeActualJsonPiece);
-              this.incompleteData = ``;
-            } else
-              this.incompleteData += piece;
-          } catch (thrown1) {
-            if (thrown1 instanceof Error)
-              console.error([
-                `\u274C Malformed data received from child process:`,
-                ``,
-                ...initialMaybeWellFormed.split(`
-`),
-                ``,
-                thrown1.message
-              ].join(`
-\u274C	`) + `
-`);
-          }
-        }
-        ++idx;
-      }
-    });
-    this.proc.stderr.on(`data`, (buffer) => {
-      if (buffer[0] === 27 && buffer[1] === 91 && buffer[2] === 50) {
-        this.logger.info(`STDERR TERMINAL CLEAR`, buffer);
-        return;
-      }
-      const pieces = buffer.toString().split(`\x03`);
-      const initialMaybeWellFormed = pieces[0];
-      pieces[0] = this.incompleteData + initialMaybeWellFormed;
-      let idx = 0;
-      for (const piece of pieces) {
-        if (piece === ``)
-          continue;
-        try {
-          const jsonPiece = parseJson(piece);
-          this.handleLog(jsonPiece);
-          this.incompleteData = ``;
-        } catch (thrown0) {
-          if (thrown0 instanceof Error)
-            this.logger.error([
-              `\u274C Malformed log received from child process:`,
-              ``,
-              ...piece.split(`
-`),
-              ``,
-              thrown0.message
-            ].join(`
-\u274C	`) + `
-`);
-          try {
-            if (idx === 0) {
-              this.incompleteData = piece;
-              const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
-              this.handleLog(maybeActualJsonPiece);
-              this.incompleteData = ``;
-            } else
-              this.incompleteData += piece;
-          } catch (thrown1) {
-            if (thrown1 instanceof Error)
-              this.logger.error([
-                `\u274C Malformed log received from child process:`,
-                ``,
-                ...initialMaybeWellFormed.split(`
-`),
-                ``,
-                thrown1.message
-              ].join(`
-\u274C	`) + `
-`);
-          }
-        }
-        ++idx;
-      }
-    });
-    this.proc.stdin.once(`error`, (err) => {
-      if (err.code === `EPIPE`)
-        console.error(`EPIPE error during write`, this.proc.stdin);
-    });
-    if (proc.pid)
-      this.id = proc.pid.toString();
-  }
-};
-var ROOMS = globalThis.ATOM_IO_REALTIME_SERVER_ROOMS ?? (globalThis.ATOM_IO_REALTIME_SERVER_ROOMS = /* @__PURE__ */ new Map);
-var socketAtoms = atomFamily({
-  key: `sockets`,
-  default: null
-});
-var socketKeysAtom = mutableAtom({
-  key: `socketKeys`,
-  class: UList
-});
-var onlineUsersAtom = mutableAtom({
-  key: `onlineUsers`,
-  class: UList
-});
-var usersOfSockets = join({
-  key: `usersOfSockets`,
-  between: [`user`, `socket`],
-  cardinality: `1:1`,
-  isAType: isUserKey,
-  isBType: isSocketKey
-});
-
-// src/backend.worker.game.bun.ts
-var parent = new ParentSocket(process);
-Object.assign(console, parent.logger, { log: parent.logger.info });
-parent.on(`timeToStop`, function gracefulExit() {
-  parent.logger.info(`\uD83D\uDEEC game worker exiting`);
-  process.exit(0);
-});
-parent.logger.info(`\uD83D\uDEEB game worker ready`);