flightdeck 0.2.27 → 0.2.29

package/dist/chunk-FIIAJE2K.js

@@ -1,4780 +0,0 @@
-import { spawn, execSync } from 'node:child_process';
-import { createServer } from 'node:http';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { inspect } from 'node:util';
-import { CronJob } from 'cron';
-import { FilesystemStorage } from 'safedeposit';
-import { z } from 'zod';
-import { createEnv } from '@t3-oss/env-core';
-
-// src/flightdeck.lib.ts
-
-// ../atom.io/internal/src/arbitrary.ts
-function arbitrary(random = Math.random) {
-  return random().toString(36).slice(2);
-}
-
-// ../atom.io/internal/src/future.ts
-var Future = class extends Promise {
-  fate;
-  resolve;
-  reject;
-  done = false;
-  constructor(executor) {
-    let superResolve;
-    let superReject;
-    super((resolve2, reject) => {
-      superResolve = resolve2;
-      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 (value instanceof Promise) {
-      const promise = value;
-      this.fate = promise;
-      promise.then(
-        (resolved) => {
-          this.pass(promise, resolved);
-        },
-        (reason) => {
-          this.fail(promise, reason);
-        }
-      );
-    } else {
-      this.resolve(value);
-      this.fate = void 0;
-    }
-  }
-};
-
-// ../atom.io/json/src/entries.ts
-function fromEntries(entries) {
-  return Object.fromEntries(entries);
-}
-function toEntries(obj) {
-  return Object.entries(obj);
-}
-
-// ../atom.io/json/src/select-json.ts
-var selectJson = (atom2, transform, store = IMPLICIT.STORE) => {
-  return createStandaloneSelector(store, {
-    key: `${atom2.key}:JSON`,
-    get: ({ get }) => transform.toJson(get(atom2)),
-    set: ({ set }, newValue) => {
-      set(atom2, transform.fromJson(newValue));
-    }
-  });
-};
-
-// ../atom.io/internal/src/lineage.ts
-function newest(scion) {
-  while (scion.child !== null) {
-    scion = scion.child;
-  }
-  return scion;
-}
-
-// ../atom.io/internal/src/subject.ts
-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);
-  }
-};
-
-// ../atom.io/internal/src/families/create-regular-atom-family.ts
-function createRegularAtomFamily(store, options, internalRoles) {
-  const familyToken = {
-    key: options.key,
-    type: `atom_family`
-  };
-  const existing = store.families.get(options.key);
-  if (existing) {
-    store.logger.error(
-      `\u2757`,
-      `atom_family`,
-      options.key,
-      `Overwriting an existing ${prettyPrintTokenType(
-        existing
-      )} "${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 familyFunction = (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: def instanceof Function ? def(key) : def
-    };
-    if (options.effects) {
-      individualOptions.effects = options.effects(key);
-    }
-    const token = createRegularAtom(target, individualOptions, family);
-    subject.next({ type: `state_creation`, token });
-    return token;
-  };
-  const atomFamily2 = Object.assign(familyFunction, familyToken, {
-    subject,
-    install: (s) => createRegularAtomFamily(s, options),
-    internalRoles
-  });
-  store.families.set(options.key, atomFamily2);
-  store.defaults.set(options.key, options.default);
-  return familyToken;
-}
-
-// ../atom.io/internal/src/families/create-atom-family.ts
-function createAtomFamily(store, options) {
-  const isMutable = `mutable` in options;
-  if (isMutable) {
-    return createMutableAtomFamily(store, options);
-  }
-  return createRegularAtomFamily(store, options);
-}
-
-// ../atom.io/internal/src/families/create-readonly-selector-family.ts
-function createReadonlySelectorFamily(store, options, internalRoles) {
-  const familyToken = {
-    key: options.key,
-    type: `readonly_selector_family`
-  };
-  const existing = store.families.get(options.key);
-  if (existing) {
-    store.logger.error(
-      `\u2757`,
-      `readonly_selector_family`,
-      options.key,
-      `Overwriting an existing ${prettyPrintTokenType(
-        existing
-      )} "${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 familyFunction = (key) => {
-    const subKey = stringifyJson(key);
-    const family = { key: options.key, subKey };
-    const fullKey = `${options.key}(${subKey})`;
-    const target = newest(store);
-    const token = createReadonlySelector(
-      target,
-      {
-        key: fullKey,
-        get: options.get(key)
-      },
-      family
-    );
-    subject.next({ type: `state_creation`, token });
-    return token;
-  };
-  const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
-    internalRoles,
-    subject,
-    install: (s) => createReadonlySelectorFamily(s, options),
-    default: (key) => {
-      const getFn = options.get(key);
-      return getFn({
-        get: (...args) => getFromStore(store, ...args),
-        find: (...args) => findInStore(store, ...args),
-        json: (token) => getJsonToken(store, token)
-      });
-    }
-  });
-  store.families.set(options.key, readonlySelectorFamily);
-  return familyToken;
-}
-
-// ../atom.io/internal/src/families/create-selector-family.ts
-function createSelectorFamily(store, options) {
-  const isWritable = `set` in options;
-  if (isWritable) {
-    return createWritableSelectorFamily(store, options);
-  }
-  return createReadonlySelectorFamily(store, options);
-}
-
-// ../atom.io/internal/src/store/circular-buffer.ts
-var CircularBuffer = class _CircularBuffer {
-  _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 _CircularBuffer([...this._buffer]);
-    copy._index = this._index;
-    return copy;
-  }
-};
-
-// ../atom.io/internal/src/store/counterfeit.ts
-var FAMILY_MEMBER_TOKEN_TYPES = {
-  atom_family: `atom`,
-  mutable_atom_family: `mutable_atom`,
-  selector_family: `selector`,
-  readonly_selector_family: `readonly_selector`,
-  molecule_family: `molecule`
-};
-function counterfeit(token, key) {
-  const subKey = stringifyJson(key);
-  const fullKey = `${token.key}(${subKey})`;
-  const type = FAMILY_MEMBER_TOKEN_TYPES[token.type];
-  const stateToken = {
-    key: fullKey,
-    type
-  };
-  Object.assign(stateToken, {
-    family: {
-      key: token.key,
-      subKey
-    }
-  });
-  Object.assign(stateToken, { counterfeit: true });
-  return stateToken;
-}
-
-// ../atom.io/internal/src/store/deposit.ts
-function deposit(state) {
-  const token = {
-    key: state.key,
-    type: state.type
-  };
-  if (`family` in state) {
-    token.family = state.family;
-  }
-  return token;
-}
-
-// ../atom.io/src/atom.ts
-function atom(options) {
-  return createStandaloneAtom(IMPLICIT.STORE, options);
-}
-function atomFamily(options) {
-  return createAtomFamily(IMPLICIT.STORE, options);
-}
-
-// ../atom.io/src/join.ts
-function join(options, defaultContent, store = IMPLICIT.STORE) {
-  store.joins.set(options.key, new Join(options, defaultContent, store));
-  const token = {
-    key: options.key,
-    type: `join`,
-    a: options.between[0],
-    b: options.between[1],
-    cardinality: options.cardinality
-  };
-  return token;
-}
-function getInternalRelations(token) {
-  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
-}
-
-// ../atom.io/src/logger.ts
-var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
-  console[logLevel](
-    `${icon} ${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.filter?.(...args) ?? true) && this.logLevel !== null) {
-      this.logger.error(...args);
-    }
-  };
-  info = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel === `info`) {
-      this.logger.info(...args);
-    }
-  };
-  warn = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel !== `error` && this.logLevel !== null) {
-      this.logger.warn(...args);
-    }
-  };
-};
-var Realm = class {
-  store;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    makeRootMoleculeInStore(`root`, store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    return allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  fuse(type, reagentA, reagentB) {
-    return fuseWithinStore(this.store, type, reagentA, reagentB);
-  }
-  deallocate(claim) {
-    deallocateFromStore(this.store, claim);
-  }
-  claim(newProvenance, claim, exclusive) {
-    return claimWithinStore(this.store, newProvenance, claim, exclusive);
-  }
-};
-var Anarchy = class {
-  store;
-  realm;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    this.realm = new Realm(store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  deallocate(key) {
-    deallocateFromStore(this.store, key);
-  }
-  claim(newProvenance, key, exclusive) {
-    claimWithinStore(this.store, newProvenance, key, exclusive);
-  }
-};
-
-// ../atom.io/src/selector.ts
-function selectorFamily(options) {
-  return createSelectorFamily(IMPLICIT.STORE, options);
-}
-
-// ../atom.io/internal/src/transaction/is-root-store.ts
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
-}
-function isChildStore(store) {
-  return `phase` in store.transactionMeta;
-}
-
-// ../atom.io/internal/src/transaction/abort-transaction.ts
-var abortTransaction = (store) => {
-  const target = newest(store);
-  if (!isChildStore(target)) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  store.logger.info(
-    `\u{1FA82}`,
-    `transaction`,
-    target.transactionMeta.update.key,
-    `Aborting transaction`
-  );
-  target.parent.child = null;
-};
-
-// ../atom.io/internal/src/capitalize.ts
-function capitalize(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
-
-// ../atom.io/internal/src/pretty-print.ts
-function prettyPrintTokenType(token) {
-  return token.type.split(`_`).map(capitalize).join(` `);
-}
-
-// ../atom.io/internal/src/not-found-error.ts
-var NotFoundError = class extends Error {
-  constructor(token, store) {
-    super(
-      `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
-    );
-  }
-};
-
-// ../atom.io/internal/src/transaction/act-upon-store.ts
-function actUponStore(store, token, id) {
-  return (...parameters) => {
-    const tx = withdraw(store, token);
-    if (tx) {
-      return tx.run(parameters, id);
-    }
-    throw new NotFoundError(token, store);
-  };
-}
-
-// ../atom.io/internal/src/set-state/become.ts
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
-
-// ../atom.io/internal/src/get-state/read-or-compute-value.ts
-var readOrComputeValue = (target, state) => {
-  if (target.valueMap.has(state.key)) {
-    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
-    return readCachedValue(state, target);
-  }
-  switch (state.type) {
-    case `selector`:
-    case `readonly_selector`:
-      target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
-      return state.get();
-    case `atom`:
-    case `mutable_atom`: {
-      const def = state.default;
-      let fallback;
-      if (def instanceof Function) {
-        fallback = def();
-      } else {
-        fallback = def;
-      }
-      target.logger.info(
-        `\u{1F481}`,
-        `atom`,
-        state.key,
-        `could not find cached value; using default`,
-        fallback
-      );
-      return fallback;
-    }
-  }
-};
-
-// ../atom.io/internal/src/operation.ts
-var openOperation = (store, token) => {
-  if (store.operation.open) {
-    const rejectionTime = performance.now();
-    store.logger.info(
-      `\u2757`,
-      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(),
-    time: Date.now(),
-    token
-  };
-  store.logger.info(
-    `\u2B55`,
-    token.type,
-    token.key,
-    `operation start in store "${store.config.name}"${!isChildStore(store) ? `` : ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`}`
-  );
-};
-var closeOperation = (store) => {
-  if (store.operation.open) {
-    store.logger.info(
-      `\u{1F534}`,
-      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(
-      `\u{1F41E}`,
-      `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(
-      `\u{1F41E}`,
-      `unknown`,
-      key,
-      `markDone called outside of an operation. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  store.operation.done.add(key);
-};
-
-// ../atom.io/internal/src/set-state/emit-update.ts
-var emitUpdate = (store, state, update) => {
-  switch (state.type) {
-    case `mutable_atom`:
-      store.logger.info(
-        `\u{1F4E2}`,
-        state.type,
-        state.key,
-        `is now (`,
-        update.newValue,
-        `) subscribers:`,
-        state.subject.subscribers
-      );
-      break;
-    case `atom`:
-    case `selector`:
-    case `readonly_selector`:
-      store.logger.info(
-        `\u{1F4E2}`,
-        state.type,
-        state.key,
-        `went (`,
-        update.oldValue,
-        `->`,
-        update.newValue,
-        `) subscribers:`,
-        state.subject.subscribers
-      );
-  }
-  state.subject.next(update);
-};
-
-// ../atom.io/internal/src/set-state/evict-downstream.ts
-var evictDownStream = (store, atom2) => {
-  const target = newest(store);
-  const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom2.key);
-  target.logger.info(
-    `\u{1F9F9}`,
-    atom2.type,
-    atom2.key,
-    downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`,
-    downstreamKeys ?? `to evict`
-  );
-  if (downstreamKeys) {
-    if (target.operation.open) {
-      target.logger.info(
-        `\u{1F9F9}`,
-        atom2.type,
-        atom2.key,
-        `[ ${[...target.operation.done].join(`, `)} ] already done`
-      );
-    }
-    for (const key of downstreamKeys) {
-      if (isDone(target, key)) {
-        continue;
-      }
-      evictCachedValue(key, target);
-      markDone(target, key);
-    }
-  }
-};
-
-// ../atom.io/internal/src/set-state/set-atom.ts
-var setAtom = (target, atom2, next) => {
-  const oldValue = readOrComputeValue(target, atom2);
-  let newValue = oldValue;
-  if (atom2.type === `mutable_atom` && isChildStore(target)) {
-    const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(target, atom2, parent);
-    newValue = copiedValue;
-  }
-  newValue = become(next)(newValue);
-  target.logger.info(`\u{1F4DD}`, `atom`, atom2.key, `set to`, newValue);
-  newValue = cacheValue(target, atom2.key, newValue, atom2.subject);
-  if (isAtomDefault(target, atom2.key)) {
-    markAtomAsNotDefault(target, atom2.key);
-  }
-  markDone(target, atom2.key);
-  evictDownStream(target, atom2);
-  const update = { oldValue, newValue };
-  if (!isChildStore(target)) {
-    emitUpdate(target, atom2, update);
-    return;
-  }
-  if (target.on.transactionApplying.state === null) {
-    const { key } = atom2;
-    if (isTransceiver(update.newValue)) {
-      return;
-    }
-    const atomUpdate = {
-      type: `atom_update`,
-      key,
-      ...update
-    };
-    if (atom2.family) {
-      atomUpdate.family = atom2.family;
-    }
-    target.transactionMeta.update.updates.push(atomUpdate);
-    target.logger.info(
-      `\u{1F4C1}`,
-      `atom`,
-      key,
-      `stowed (`,
-      update.oldValue,
-      `->`,
-      update.newValue,
-      `)`
-    );
-  } else if (atom2.key.startsWith(`*`)) {
-    const mutableKey = atom2.key.slice(1);
-    const mutableAtom = target.atoms.get(mutableKey);
-    let transceiver = target.valueMap.get(mutableKey);
-    if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
-      const { parent } = target;
-      const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent);
-      transceiver = copiedValue;
-    }
-    const accepted = transceiver.do(update.newValue) === null;
-    if (accepted) evictDownStream(target, mutableAtom);
-  }
-};
-
-// ../atom.io/internal/src/set-state/set-atom-or-selector.ts
-var setAtomOrSelector = (store, state, value) => {
-  switch (state.type) {
-    case `atom`:
-    case `mutable_atom`:
-      setAtom(store, state, value);
-      break;
-    case `selector`:
-      state.set(value);
-      break;
-  }
-};
-
-// ../atom.io/internal/src/families/get-family-of-token.ts
-function getFamilyOfToken(store, token) {
-  if (token.family) {
-    const family = store.families.get(token.family.key);
-    if (family) {
-      return family;
-    }
-  }
-}
-
-// ../atom.io/internal/src/set-state/set-into-store.ts
-function setIntoStore(store, ...params) {
-  let token;
-  let family;
-  let key;
-  let value;
-  if (params.length === 2) {
-    token = params[0];
-    value = params[1];
-    family = getFamilyOfToken(store, token) ?? null;
-    if (family) {
-      key = token.family ? parseJson(token.family.subKey) : null;
-      token = findInStore(store, family, key);
-    }
-  } else {
-    family = params[0];
-    key = params[1];
-    value = params[2];
-    token = findInStore(store, family, key);
-  }
-  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 set because it was not found in the store "${store.config.name}".`,
-      disposal ? `This state was previously disposed:
-${disposal.trace}` : `No previous disposal trace was found.`
-    );
-    return;
-  }
-  const rejectionTime = openOperation(store, token);
-  if (rejectionTime) {
-    const unsubscribe = store.on.operationClose.subscribe(
-      `waiting to set "${token.key}" at T-${rejectionTime}`,
-      () => {
-        unsubscribe();
-        store.logger.info(
-          `\u{1F7E2}`,
-          token.type,
-          token.key,
-          `resuming deferred setState from T-${rejectionTime}`
-        );
-        setIntoStore(store, token, value);
-      }
-    );
-    return;
-  }
-  const state = withdraw(store, token);
-  setAtomOrSelector(store, state, value);
-  closeOperation(store);
-}
-
-// ../atom.io/internal/src/ingest-updates/ingest-atom-update.ts
-function ingestAtomUpdate(applying, atomUpdate, store) {
-  const { key, newValue, oldValue } = atomUpdate;
-  const value = newValue ;
-  const token = { key, type: `atom` };
-  if (atomUpdate.family) {
-    Object.assign(token, { family: atomUpdate.family });
-  }
-  setIntoStore(store, token, value);
-}
-
-// ../atom.io/internal/src/get-trace.ts
-function getTrace(error) {
-  const { stack } = error;
-  if (stack) {
-    return `
-` + stack.split(`
-`)?.slice(1)?.join(`
-`);
-  }
-  return ``;
-}
-
-// ../atom.io/internal/src/molecule.ts
-function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
-  const molecule = {
-    key,
-    stringKey: stringifyJson(key),
-    dependsOn: `any`
-  };
-  store.molecules.set(stringifyJson(key), molecule);
-  return key;
-}
-function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
-  const origin = provenance;
-  const stringKey = stringifyJson(key);
-  const invalidKeys = [];
-  const target = newest(store);
-  if (Array.isArray(origin)) {
-    for (const formerClaim of origin) {
-      const claimString = stringifyJson(formerClaim);
-      const claim = target.molecules.get(claimString);
-      if (claim) {
-        store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-      } else {
-        invalidKeys.push(claimString);
-      }
-    }
-  } else {
-    const claimString = stringifyJson(origin);
-    const claim = target.molecules.get(claimString);
-    if (claim) {
-      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-    } else {
-      invalidKeys.push(claimString);
-    }
-  }
-  if (invalidKeys.length === 0) {
-    target.molecules.set(stringKey, { key, stringKey, dependsOn });
-  }
-  const creationEvent = {
-    type: `molecule_creation`,
-    key,
-    provenance: origin
-  };
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(creationEvent);
-  } else {
-    target.on.moleculeCreation.next(creationEvent);
-  }
-  for (const claim of invalidKeys) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === claim
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      key,
-      `allocation failed:`,
-      `Could not allocate to ${claim} in store "${store.config.name}".`,
-      disposal ? `
-   ${claim} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${claim} was found.`
-    );
-  }
-  return key;
-}
-function fuseWithinStore(store, type, sideA, sideB) {
-  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
-  const above = [sideA, sideB];
-  allocateIntoStore(
-    store,
-    above,
-    compoundKey,
-    `all`
-  );
-  return compoundKey;
-}
-function deallocateFromStore(store, claim) {
-  const stringKey = stringifyJson(claim);
-  const molecule = store.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === stringKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `deallocation failed:`,
-      `Could not find allocation for ${stringKey} in store "${store.config.name}".`,
-      disposal ? `
-   This state was most recently deallocated
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
-    );
-    return;
-  }
-  const joinKeys = store.moleculeJoins.getRelatedKeys(
-    molecule.key
-  );
-  if (joinKeys) {
-    for (const joinKey of joinKeys) {
-      const join2 = store.joins.get(joinKey);
-      if (join2) {
-        join2.relations.delete(molecule.key);
-        join2.molecules.delete(molecule.stringKey);
-      }
-    }
-  }
-  store.moleculeJoins.delete(molecule.stringKey);
-  const provenance = [];
-  const values = [];
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    key: molecule.key,
-    values,
-    provenance
-  };
-  const target = newest(store);
-  target.molecules.delete(stringKey);
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(disposalEvent);
-  }
-  const relatedMolecules = store.moleculeGraph.getRelationEntries({
-    downstreamMoleculeKey: molecule.stringKey
-  });
-  if (relatedMolecules) {
-    for (const [relatedStringKey, { source }] of relatedMolecules) {
-      if (source === molecule.stringKey) {
-        const relatedKey = parseJson(relatedStringKey);
-        deallocateFromStore(store, relatedKey);
-      } else {
-        provenance.push(source);
-      }
-    }
-  }
-  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
-  if (familyKeys) {
-    for (const familyKey of familyKeys) {
-      const family = target.families.get(familyKey);
-      const token = findInStore(store, family, molecule.key);
-      values.push([family.key, token]);
-      disposeFromStore(store, token);
-    }
-  }
-  target.moleculeGraph.delete(molecule.stringKey);
-  target.moleculeJoins.delete(molecule.stringKey);
-  target.moleculeData.delete(molecule.stringKey);
-  if (!isTransaction) {
-    target.on.moleculeDisposal.next(disposalEvent);
-  }
-  target.molecules.delete(molecule.stringKey);
-  const trace = getTrace(new Error());
-  store.disposalTraces.add({ key: stringKey, trace });
-}
-function claimWithinStore(store, newProvenance, claim, exclusive) {
-  const stringKey = stringifyJson(claim);
-  const target = newest(store);
-  const molecule = target.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === stringKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `claim failed:`,
-      `Could not allocate to ${stringKey} in store "${store.config.name}".`,
-      disposal ? `
-   ${stringKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
-    );
-    return claim;
-  }
-  const newProvenanceKey = stringifyJson(newProvenance);
-  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
-  if (!newProvenanceMolecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === newProvenanceKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `claim failed:`,
-      `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
-      disposal ? `
-   ${newProvenanceKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`
-    );
-    return claim;
-  }
-  const priorProvenance = store.moleculeGraph.getRelationEntries({
-    downstreamMoleculeKey: molecule.stringKey
-  }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
-  if (exclusive) {
-    target.moleculeGraph.delete(stringKey);
-  }
-  target.moleculeGraph.set(
-    {
-      upstreamMoleculeKey: newProvenanceMolecule.stringKey,
-      downstreamMoleculeKey: molecule.stringKey
-    },
-    {
-      source: newProvenanceMolecule.stringKey
-    }
-  );
-  const transferEvent = {
-    type: `molecule_transfer`,
-    key: molecule.key,
-    from: priorProvenance,
-    to: [newProvenanceMolecule.key]
-  };
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(transferEvent);
-  }
-  return claim;
-}
-
-// ../atom.io/internal/src/ingest-updates/ingest-creation-disposal.ts
-function ingestCreationEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`: {
-      createInStore(update, store);
-      break;
-    }
-    case `oldValue`: {
-      disposeFromStore(store, update.token);
-      break;
-    }
-  }
-}
-function ingestDisposalEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`: {
-      disposeFromStore(store, update.token);
-      break;
-    }
-    case `oldValue`: {
-      createInStore(update, store);
-      if (update.subType === `atom`) {
-        store.valueMap.set(update.token.key, update.value);
-      }
-      break;
-    }
-  }
-}
-function createInStore(update, store) {
-  const { family: familyMeta } = update.token;
-  if (familyMeta) {
-    const family = store.families.get(familyMeta.key);
-    if (family) {
-      findInStore(store, family, parseJson(familyMeta.subKey));
-    }
-  }
-}
-function ingestMoleculeCreationEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`:
-      allocateIntoStore(store, update.provenance, update.key);
-      break;
-    case `oldValue`:
-      deallocateFromStore(store, update.key);
-      break;
-  }
-}
-function ingestMoleculeDisposalEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`:
-      deallocateFromStore(store, update.key);
-      break;
-    case `oldValue`:
-      {
-        const provenanceJson = update.provenance.map(parseJson);
-        allocateIntoStore(store, provenanceJson, update.key);
-        for (const [familyKey, value] of update.values) {
-          const family = store.families.get(familyKey);
-          if (family) {
-            findInStore(store, family, update.key);
-            const memberKey = `${familyKey}(${stringifyJson(update.key)})`;
-            store.valueMap.set(memberKey, value);
-          }
-        }
-      }
-      break;
-  }
-}
-function ingestMoleculeTransferEvent(update, applying, store) {
-  switch (applying) {
-    case `newValue`:
-      {
-        const provenance = update.to.length === 1 ? update.to[0] : update.to;
-        claimWithinStore(
-          store,
-          provenance,
-          update.key,
-          `exclusive`
-        );
-      }
-      break;
-    case `oldValue`:
-      {
-        const provenance = update.from.length === 1 ? update.from[0] : update.from;
-        claimWithinStore(
-          store,
-          provenance,
-          update.key,
-          `exclusive`
-        );
-      }
-      break;
-  }
-}
-
-// ../atom.io/internal/src/ingest-updates/ingest-transaction-update.ts
-function ingestTransactionUpdate(applying, transactionUpdate, store) {
-  const updates = transactionUpdate.updates ;
-  for (const updateFromTransaction of updates) {
-    switch (updateFromTransaction.type) {
-      case `atom_update`:
-      case `selector_update`:
-        ingestAtomUpdate(applying, updateFromTransaction, store);
-        break;
-      case `state_creation`:
-        ingestCreationEvent(updateFromTransaction, applying, store);
-        break;
-      case `state_disposal`:
-        ingestDisposalEvent(updateFromTransaction, applying, store);
-        break;
-      case `molecule_creation`:
-        ingestMoleculeCreationEvent(updateFromTransaction, applying, store);
-        break;
-      case `molecule_disposal`:
-        ingestMoleculeDisposalEvent(updateFromTransaction, applying, store);
-        break;
-      case `molecule_transfer`:
-        ingestMoleculeTransferEvent(updateFromTransaction, applying, store);
-        break;
-      case `transaction_update`:
-        ingestTransactionUpdate(applying, updateFromTransaction, store);
-        break;
-    }
-  }
-}
-
-// ../atom.io/internal/src/transaction/get-epoch-number.ts
-function getContinuityKey(store, transactionKey) {
-  const continuity = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
-  return continuity;
-}
-function getEpochNumberOfContinuity(store, continuityKey) {
-  const epoch = store.transactionMeta.epoch.get(continuityKey);
-  return epoch;
-}
-function getEpochNumberOfAction(store, transactionKey) {
-  const isRoot = isRootStore(store);
-  if (!isRoot) {
-    return void 0;
-  }
-  const continuityKey = getContinuityKey(store, transactionKey);
-  if (continuityKey === void 0) {
-    return void 0;
-  }
-  return getEpochNumberOfContinuity(store, continuityKey);
-}
-
-// ../atom.io/internal/src/transaction/set-epoch-number.ts
-function setEpochNumberOfAction(store, transactionKey, newEpoch) {
-  const isRoot = isRootStore(store);
-  if (!isRoot) {
-    return;
-  }
-  const continuityKey = getContinuityKey(store, transactionKey);
-  if (continuityKey !== void 0) {
-    store.transactionMeta.epoch.set(continuityKey, newEpoch);
-  }
-}
-
-// ../atom.io/internal/src/transaction/apply-transaction.ts
-var applyTransaction = (output, store) => {
-  const child = newest(store);
-  const { parent } = child;
-  if (parent === null || !isChildStore(child) || child.transactionMeta?.phase !== `building`) {
-    store.logger.warn(
-      `\u{1F41E}`,
-      `transaction`,
-      `???`,
-      `applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`
-    );
-    return;
-  }
-  child.transactionMeta.phase = `applying`;
-  child.transactionMeta.update.output = output;
-  parent.child = null;
-  parent.on.transactionApplying.next(child.transactionMeta);
-  const { updates } = child.transactionMeta.update;
-  store.logger.info(
-    `\u{1F6C4}`,
-    `transaction`,
-    child.transactionMeta.update.key,
-    `Applying transaction with ${updates.length} updates:`,
-    updates
-  );
-  ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
-  if (isRootStore(parent)) {
-    setEpochNumberOfAction(
-      parent,
-      child.transactionMeta.update.key,
-      child.transactionMeta.update.epoch
-    );
-    const myTransaction = withdraw(store, {
-      key: child.transactionMeta.update.key,
-      type: `transaction`
-    });
-    myTransaction?.subject.next(child.transactionMeta.update);
-    store.logger.info(
-      `\u{1F6EC}`,
-      `transaction`,
-      child.transactionMeta.update.key,
-      `Finished applying transaction.`
-    );
-  } else if (isChildStore(parent)) {
-    parent.transactionMeta.update.updates.push(child.transactionMeta.update);
-  }
-  parent.on.transactionApplying.next(null);
-};
-
-// ../atom.io/internal/src/get-environment-data.ts
-function getEnvironmentData(store) {
-  return {
-    store
-  };
-}
-
-// ../atom.io/internal/src/get-state/get-from-store.ts
-function getFromStore(store, ...params) {
-  let token;
-  let family;
-  let key;
-  if (params.length === 1) {
-    token = params[0];
-  } else {
-    family = params[0];
-    key = params[1];
-    token = findInStore(store, family, key);
-  }
-  if (`counterfeit` in token && `family` in token) {
-    family = store.families.get(token.family.key);
-    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 retrieved because it was not found in the store "${store.config.name}".`,
-      disposal ? `This state was previously disposed:
-${disposal.trace}` : `No previous disposal trace was found.`
-    );
-    switch (family.type) {
-      case `atom_family`:
-      case `mutable_atom_family`:
-        return store.defaults.get(family.key);
-      case `selector_family`:
-      case `readonly_selector_family`: {
-        if (store.defaults.has(family.key)) {
-          return store.defaults.get(token.family.key);
-        }
-        const defaultValue = withdraw(store, family).default(subKey);
-        store.defaults.set(family.key, defaultValue);
-        return defaultValue;
-      }
-    }
-  }
-  return readOrComputeValue(store, withdraw(store, token));
-}
-
-// ../atom.io/internal/src/junction.ts
-var Junction = class {
-  a;
-  b;
-  cardinality;
-  relations = /* @__PURE__ */ new Map();
-  contents = /* @__PURE__ */ new Map();
-  isAType;
-  isBType;
-  isContent;
-  makeContentKey = (a, b) => `${a}:${b}`;
-  warn;
-  getRelatedKeys(key) {
-    return this.relations.get(key);
-  }
-  addRelation(a, b) {
-    let aRelations = this.relations.get(a);
-    let bRelations = this.relations.get(b);
-    if (aRelations) {
-      aRelations.add(b);
-    } else {
-      aRelations = /* @__PURE__ */ new Set([b]);
-      this.relations.set(a, aRelations);
-    }
-    if (bRelations) {
-      bRelations.add(a);
-    } else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  deleteRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    if (aRelations) {
-      aRelations.delete(b);
-      if (aRelations.size === 0) {
-        this.relations.delete(a);
-      }
-      const bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.delete(a);
-        if (bRelations.size === 0) {
-          this.relations.delete(b);
-        }
-      }
-    }
-  }
-  replaceRelationsUnsafely(x, ys) {
-    this.relations.set(x, new Set(ys));
-    for (const y of ys) {
-      const yRelations = (/* @__PURE__ */ new Set()).add(x);
-      this.relations.set(y, yRelations);
-    }
-  }
-  replaceRelationsSafely(x, ys) {
-    const xRelationsPrev = this.relations.get(x);
-    let a = this.isAType?.(x) ? x : void 0;
-    let b = a === void 0 ? x : void 0;
-    if (xRelationsPrev) {
-      for (const y of xRelationsPrev) {
-        a ??= y;
-        b ??= y;
-        const yRelations = this.relations.get(y);
-        if (yRelations) {
-          if (yRelations.size === 1) {
-            this.relations.delete(y);
-          } else {
-            yRelations.delete(x);
-          }
-          this.contents.delete(this.makeContentKey(a, b));
-        }
-      }
-    }
-    this.relations.set(x, new Set(ys));
-    for (const y of ys) {
-      let yRelations = this.relations.get(y);
-      if (yRelations) {
-        yRelations.add(x);
-      } else {
-        yRelations = (/* @__PURE__ */ new Set()).add(x);
-        this.relations.set(y, yRelations);
-      }
-    }
-  }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
-  }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
-  }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
-  }
-  constructor(data, config) {
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    if (!config?.externalStore) {
-      this.relations = new Map(
-        data.relations?.map(([x, ys]) => [x, new Set(ys)])
-      );
-      this.contents = new Map(data.contents);
-    }
-    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 externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(
-        key
-      );
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of data.relations ?? []) {
-        let a = this.isAType?.(x) ? x : void 0;
-        let b = a === void 0 ? x : void 0;
-        for (const y of ys) {
-          a ??= y;
-          b ??= y;
-          this.addRelation(a, b);
-        }
-      }
-      for (const [contentKey, content] of data.contents ?? []) {
-        this.setContent(contentKey, content);
-      }
-    }
-    if (config?.warn) {
-      this.warn = config.warn;
-    }
-  }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(
-        ([a, b]) => [a, [...b]]
-      ),
-      contents: [...this.contents.entries()]
-    };
-  }
-  set(...params) {
-    let a;
-    let b;
-    let content;
-    switch (params.length) {
-      case 1: {
-        const relation = params[0];
-        a = relation[this.a];
-        b = relation[this.b];
-        content = void 0;
-        break;
-      }
-      case 2: {
-        const zeroth = params[0];
-        if (typeof zeroth === `string`) {
-          [a, b] = params;
-        } else {
-          a = zeroth[this.a];
-          b = zeroth[this.b];
-          content = params[1];
-        }
-        break;
-      }
-      default: {
-        a = params[0];
-        b = params[1];
-        content = params[2];
-        break;
-      }
-    }
-    switch (this.cardinality) {
-      // biome-ignore lint/suspicious/noFallthroughSwitchClause: perfect here
-      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;
-    }
-    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 = (
-      // @ts-expect-error we deduce that this.a may index x
-      typeof x === `string` ? x : x[this.a]
-    );
-    if (a === void 0 && typeof b === `string`) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        for (const bRelation of bRelations) {
-          this.delete(bRelation, b);
-        }
-      }
-    }
-    if (typeof a === `string` && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        for (const aRelation of aRelations) {
-          this.delete(a, aRelation);
-        }
-      }
-    }
-    if (typeof a === `string` && typeof b === `string`) {
-      this.deleteRelation(a, b);
-      const contentKey = this.makeContentKey(a, b);
-      this.deleteContent(contentKey);
-    }
-    return this;
-  }
-  getRelatedKey(key) {
-    const relations = this.getRelatedKeys(key);
-    if (relations) {
-      if (relations.size > 1) {
-        this.warn?.(
-          `${relations.size} related keys were found for key "${key}": (${[
-            ...relations
-          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
-        );
-      }
-      let singleRelation;
-      for (const relation of relations) {
-        singleRelation = relation;
-        break;
-      }
-      return singleRelation;
-    }
-  }
-  replaceRelations(x, relations, config) {
-    const hasContent = !Array.isArray(relations);
-    const ys = hasContent ? Object.keys(relations) : relations;
-    if (config?.reckless) {
-      this.replaceRelationsUnsafely(x, ys);
-    } else {
-      this.replaceRelationsSafely(x, ys);
-    }
-    if (hasContent) {
-      for (const y of ys) {
-        const contentKey = this.makeContentKey(x, y);
-        const content = relations[y];
-        this.setContent(contentKey, content);
-      }
-    }
-    return this;
-  }
-  getContent(a, b) {
-    const contentKey = this.makeContentKey(a, b);
-    return this.getContentInternal(contentKey);
-  }
-  getRelationEntries(input) {
-    const a = input[this.a];
-    const b = input[this.b];
-    if (a !== void 0 && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        return [...aRelations].map((aRelation) => {
-          return [aRelation, this.getContent(a, aRelation)];
-        });
-      }
-    }
-    if (a === void 0 && b !== void 0) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        return [...bRelations].map((bRelation) => {
-          return [bRelation, this.getContent(bRelation, b)];
-        });
-      }
-    }
-    return [];
-  }
-  has(a, b) {
-    if (b) {
-      const setA = this.getRelatedKeys(a);
-      return setA?.has(b) ?? false;
-    }
-    return this.relations.has(a);
-  }
-};
-
-// ../atom.io/internal/src/lazy-map.ts
-var LazyMap = class extends Map {
-  deleted = /* @__PURE__ */ new Set();
-  source;
-  constructor(source) {
-    super();
-    this.source = source;
-  }
-  get(key) {
-    const has = super.has(key);
-    if (has) {
-      return super.get(key);
-    }
-    if (!this.deleted.has(key) && this.source.has(key)) {
-      const value = this.source.get(key);
-      return value;
-    }
-    return void 0;
-  }
-  set(key, value) {
-    this.deleted.delete(key);
-    return super.set(key, value);
-  }
-  hasOwn(key) {
-    return super.has(key);
-  }
-  has(key) {
-    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
-  }
-  delete(key) {
-    this.deleted.add(key);
-    return super.delete(key);
-  }
-};
-
-// ../atom.io/internal/src/transaction/build-transaction.ts
-var buildTransaction = (store, key, params, id) => {
-  const parent = newest(store);
-  const childBase = {
-    parent,
-    child: null,
-    on: parent.on,
-    loggers: parent.loggers,
-    logger: parent.logger,
-    config: parent.config,
-    atoms: new LazyMap(parent.atoms),
-    atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
-    families: new LazyMap(parent.families),
-    joins: new LazyMap(parent.joins),
-    operation: { open: false },
-    readonlySelectors: new LazyMap(parent.readonlySelectors),
-    timelines: new LazyMap(parent.timelines),
-    timelineTopics: new Junction(parent.timelineTopics.toJSON()),
-    trackers: /* @__PURE__ */ new Map(),
-    transactions: new LazyMap(parent.transactions),
-    selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
-    selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
-      makeContentKey: (...keys) => keys.sort().join(`:`)
-    }),
-    selectors: new LazyMap(parent.selectors),
-    valueMap: new LazyMap(parent.valueMap),
-    defaults: parent.defaults,
-    disposalTraces: store.disposalTraces.copy(),
-    molecules: new LazyMap(parent.molecules),
-    moleculeGraph: new Junction(parent.moleculeGraph.toJSON(), {
-      makeContentKey: parent.moleculeGraph.makeContentKey
-    }),
-    moleculeData: new Junction(parent.moleculeData.toJSON(), {
-      makeContentKey: parent.moleculeData.makeContentKey
-    }),
-    moleculeJoins: new Junction(parent.moleculeJoins.toJSON(), {
-      makeContentKey: parent.moleculeJoins.makeContentKey
-    }),
-    miscResources: new LazyMap(parent.miscResources)
-  };
-  const epoch = getEpochNumberOfAction(store, key);
-  const transactionMeta = {
-    phase: `building`,
-    update: {
-      type: `transaction_update`,
-      key,
-      id,
-      epoch: epoch === void 0 ? Number.NaN : epoch + 1,
-      updates: [],
-      params,
-      output: void 0
-    },
-    toolkit: {
-      get: (...ps) => getFromStore(child, ...ps),
-      set: (...ps) => {
-        setIntoStore(child, ...ps);
-      },
-      run: (token, identifier = arbitrary()) => actUponStore(child, token, identifier),
-      find: (...ps) => findInStore(store, ...ps),
-      json: (token) => getJsonToken(child, token),
-      dispose: (...ps) => {
-        disposeFromStore(child, ...ps);
-      },
-      env: () => getEnvironmentData(child)
-    }
-  };
-  const child = Object.assign(childBase, {
-    transactionMeta
-  });
-  parent.child = child;
-  store.logger.info(
-    `\u{1F6EB}`,
-    `transaction`,
-    key,
-    `Building transaction with params:`,
-    params
-  );
-  return child;
-};
-
-// ../atom.io/internal/src/transaction/create-transaction.ts
-function createTransaction(store, options) {
-  const newTransaction = {
-    key: options.key,
-    type: `transaction`,
-    run: (params, id) => {
-      const childStore = buildTransaction(store, options.key, params, id);
-      try {
-        const target2 = newest(store);
-        const { toolkit } = childStore.transactionMeta;
-        const output = options.do(toolkit, ...params);
-        applyTransaction(output, target2);
-        return output;
-      } catch (thrown) {
-        abortTransaction(target);
-        store.logger.warn(`\u{1F4A5}`, `transaction`, options.key, `caught:`, thrown);
-        throw thrown;
-      }
-    },
-    install: (s) => createTransaction(s, options),
-    subject: new Subject()
-  };
-  const target = newest(store);
-  target.transactions.set(newTransaction.key, newTransaction);
-  const token = deposit(newTransaction);
-  store.on.transactionCreation.next(token);
-  return token;
-}
-
-// ../atom.io/src/transaction.ts
-function transaction(options) {
-  return createTransaction(IMPLICIT.STORE, options);
-}
-
-// ../atom.io/internal/src/store/store.ts
-var Store = class {
-  parent = null;
-  child = null;
-  valueMap = /* @__PURE__ */ new Map();
-  defaults = /* @__PURE__ */ new Map();
-  atoms = /* @__PURE__ */ new Map();
-  selectors = /* @__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();
-  moleculeJoins = new Junction(
-    {
-      between: [`moleculeKey`, `joinKey`],
-      cardinality: `n:n`
-    },
-    {
-      makeContentKey: (...keys) => keys.sort().join(`:`)
-    }
-  );
-  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(`:`)
-    }
-  );
-  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`
-  };
-  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.valueMap = new Map(store?.valueMap);
-      this.operation = { ...store?.operation };
-      if (isRootStore(store)) {
-        this.transactionMeta = {
-          epoch: new Map(store?.transactionMeta.epoch),
-          actionContinuities: new Junction(
-            store?.transactionMeta.actionContinuities.toJSON()
-          )
-        };
-      }
-      for (const [, family] of store.families) {
-        if (family.internalRoles?.includes(`mutable`) || family.internalRoles?.includes(`join`)) {
-          continue;
-        }
-        family.install(this);
-      }
-      const mutableHelpers = /* @__PURE__ */ new Set();
-      for (const [, atom2] of store.atoms) {
-        if (mutableHelpers.has(atom2.key)) {
-          continue;
-        }
-        atom2.install(this);
-        if (atom2.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(store, atom2);
-          const originalUpdateToken = getUpdateToken(atom2);
-          mutableHelpers.add(originalJsonToken.key);
-          mutableHelpers.add(originalUpdateToken.key);
-        }
-      }
-      for (const [, selector] of store.readonlySelectors) {
-        selector.install(this);
-      }
-      for (const [, selector] of store.selectors) {
-        if (mutableHelpers.has(selector.key)) {
-          continue;
-        }
-        selector.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`
-    });
-    return globalThis.ATOM_IO_IMPLICIT_STORE;
-  }
-};
-
-// ../atom.io/internal/src/store/withdraw.ts
-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 `selector`:
-        withdrawn = target.selectors.get(token.key);
-        break;
-      case `readonly_selector`:
-        withdrawn = target.readonlySelectors.get(token.key);
-        break;
-      case `atom_family`:
-      case `mutable_atom_family`:
-      case `selector_family`:
-      case `readonly_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);
-}
-
-// ../atom.io/internal/src/families/init-family-member.ts
-function initFamilyMemberInStore(store, token, key) {
-  const family = store.families.get(token.key);
-  if (family === void 0) {
-    throw new NotFoundError(token, store);
-  }
-  const state = family(key);
-  const target = newest(store);
-  if (state.family) {
-    if (isRootStore(target)) {
-      switch (state.type) {
-        case `atom`:
-        case `mutable_atom`:
-          store.on.atomCreation.next(state);
-          break;
-        case `selector`:
-        case `readonly_selector`:
-          store.on.selectorCreation.next(state);
-          break;
-      }
-    } else if (isChildStore(target) && target.on.transactionApplying.state === null) {
-      target.transactionMeta.update.updates.push({
-        type: `state_creation`,
-        token: state
-      });
-    }
-  }
-  return state;
-}
-
-// ../atom.io/internal/src/families/seek-in-store.ts
-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 `selector_family`:
-      state = target.selectors.get(fullKey);
-      break;
-    case `readonly_selector_family`:
-      state = target.readonlySelectors.get(fullKey);
-      break;
-  }
-  if (state) {
-    return deposit(state);
-  }
-  return state;
-}
-
-// ../atom.io/internal/src/families/find-in-store.ts
-function findInStore(store, token, key) {
-  let state = seekInStore(store, token, key);
-  if (state) {
-    return state;
-  }
-  const stringKey = stringifyJson(key);
-  const molecule = store.molecules.get(stringKey);
-  if (!molecule && store.config.lifespan === `immortal`) {
-    const fakeToken = counterfeit(token, key);
-    store.logger.error(
-      `\u274C`,
-      fakeToken.type,
-      fakeToken.key,
-      `was not found in store "${store.config.name}"; returned a counterfeit token.`
-    );
-    return fakeToken;
-  }
-  state = initFamilyMemberInStore(store, token, key);
-  if (molecule) {
-    const target = newest(store);
-    target.moleculeData.set(stringKey, token.key);
-  }
-  return state;
-}
-
-// ../atom.io/internal/src/families/dispose-from-store.ts
-function disposeFromStore(store, ...params) {
-  let token;
-  if (params.length === 1) {
-    token = params[0];
-  } else {
-    const family = params[0];
-    const key = params[1];
-    const maybeToken = findInStore(store, family, key);
-    token = maybeToken;
-  }
-  try {
-    withdraw(store, token);
-  } catch (thrown) {
-    store.logger.error(
-      `\u274C`,
-      token.type,
-      token.key,
-      `could not be disposed because it was not found in the store "${store.config.name}".`
-    );
-    return;
-  }
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      disposeAtom(store, token);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      disposeSelector(store, token);
-      break;
-  }
-}
-
-// ../atom.io/internal/src/keys.ts
-var isAtomKey = (store, key) => newest(store).atoms.has(key);
-var isSelectorKey = (store, key) => newest(store).selectors.has(key);
-var isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
-var isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
-
-// ../atom.io/internal/src/selector/get-selector-dependency-keys.ts
-var getSelectorDependencyKeys = (key, store) => {
-  const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
-  return sources;
-};
-
-// ../atom.io/internal/src/selector/trace-selector-atoms.ts
-var traceSelectorAtoms = (directDependencyKey, covered, store) => {
-  const rootKeys = [];
-  const indirectDependencyKeys = getSelectorDependencyKeys(
-    directDependencyKey,
-    store
-  );
-  while (indirectDependencyKeys.length > 0) {
-    const indirectDependencyKey = indirectDependencyKeys.shift();
-    if (covered.has(indirectDependencyKey)) {
-      continue;
-    }
-    covered.add(indirectDependencyKey);
-    if (!isAtomKey(store, indirectDependencyKey)) {
-      indirectDependencyKeys.push(
-        ...getSelectorDependencyKeys(indirectDependencyKey, store)
-      );
-    } else if (!rootKeys.includes(indirectDependencyKey)) {
-      rootKeys.push(indirectDependencyKey);
-    }
-  }
-  return rootKeys;
-};
-var traceAllSelectorAtoms = (selector, store) => {
-  const selectorKey = selector.key;
-  const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
-  const covered = /* @__PURE__ */ new Set();
-  return directDependencyKeys.flatMap(
-    (depKey) => isAtomKey(store, depKey) ? depKey : traceSelectorAtoms(depKey, covered, store)
-  );
-};
-
-// ../atom.io/internal/src/selector/update-selector-atoms.ts
-var updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
-  const target = newest(store);
-  if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
-    target.selectorAtoms.set({
-      selectorKey,
-      atomKey: dependency.key
-    });
-    store.logger.info(
-      `\u{1F50D}`,
-      `selector`,
-      selectorKey,
-      `discovers root atom "${dependency.key}"`
-    );
-  } else {
-    const rootKeys = traceSelectorAtoms(dependency.key, covered, store);
-    store.logger.info(
-      `\u{1F50D}`,
-      `selector`,
-      selectorKey,
-      `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`
-    );
-    for (const atomKey of rootKeys) {
-      target.selectorAtoms = target.selectorAtoms.set({
-        selectorKey,
-        atomKey
-      });
-    }
-  }
-  covered.add(dependency.key);
-};
-
-// ../atom.io/internal/src/selector/register-selector.ts
-var registerSelector = (selectorKey, covered, store) => ({
-  get: (...params) => {
-    const target = newest(store);
-    let dependency;
-    if (params.length === 2) {
-      const [family, key] = params;
-      dependency = findInStore(store, family, key);
-    } else {
-      [dependency] = params;
-    }
-    const dependencyState = withdraw(store, dependency);
-    const dependencyValue = readOrComputeValue(store, dependencyState);
-    store.logger.info(
-      `\u{1F50C}`,
-      `selector`,
-      selectorKey,
-      `registers dependency ( "${dependency.key}" =`,
-      dependencyValue,
-      `)`
-    );
-    target.selectorGraph.set(
-      {
-        upstreamSelectorKey: dependency.key,
-        downstreamSelectorKey: selectorKey
-      },
-      {
-        source: dependency.key
-      }
-    );
-    updateSelectorAtoms(selectorKey, dependency, covered, store);
-    return dependencyValue;
-  },
-  set: (...params) => {
-    let token;
-    let value;
-    if (params.length === 2) {
-      token = params[0];
-      value = params[1];
-    } else {
-      const family = params[0];
-      const key = params[1];
-      value = params[2];
-      token = findInStore(store, family, key);
-    }
-    const target = newest(store);
-    const state = withdraw(target, token);
-    setAtomOrSelector(target, state, value);
-  },
-  find: (...args) => findInStore(store, ...args),
-  json: (token) => getJsonToken(store, token)
-});
-
-// ../atom.io/internal/src/selector/create-readonly-selector.ts
-var createReadonlySelector = (store, options, family) => {
-  const target = newest(store);
-  const subject = new Subject();
-  const covered = /* @__PURE__ */ new Set();
-  const { get, find, json } = registerSelector(options.key, covered, target);
-  const getSelf = () => {
-    const value = options.get({ get, find, json });
-    cacheValue(newest(store), options.key, value, subject);
-    covered.clear();
-    return value;
-  };
-  const readonlySelector = {
-    ...options,
-    subject,
-    install: (s) => createReadonlySelector(s, options, family),
-    get: getSelf,
-    type: `readonly_selector`,
-    ...family && { family }
-  };
-  target.readonlySelectors.set(options.key, readonlySelector);
-  const initialValue = getSelf();
-  store.logger.info(
-    `\u2728`,
-    readonlySelector.type,
-    readonlySelector.key,
-    `=`,
-    initialValue
-  );
-  const token = {
-    key: options.key,
-    type: `readonly_selector`
-  };
-  if (family) {
-    token.family = family;
-  }
-  return token;
-};
-
-// ../atom.io/internal/src/selector/create-writable-selector.ts
-var createWritableSelector = (store, options, family) => {
-  const target = newest(store);
-  const subject = new Subject();
-  const covered = /* @__PURE__ */ new Set();
-  const setterToolkit = registerSelector(options.key, covered, target);
-  const { find, get, json } = setterToolkit;
-  const getterToolkit = { find, get, json };
-  const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
-    const value = getFn(getterToolkit);
-    cacheValue(innerTarget, options.key, value, subject);
-    covered.clear();
-    return value;
-  };
-  const setSelf = (next) => {
-    const innerTarget = newest(store);
-    const oldValue = getSelf(options.get, innerTarget);
-    const newValue = become(next)(oldValue);
-    store.logger.info(
-      `\u{1F4DD}`,
-      `selector`,
-      options.key,
-      `set (`,
-      oldValue,
-      `->`,
-      newValue,
-      `)`
-    );
-    cacheValue(innerTarget, options.key, newValue, subject);
-    markDone(innerTarget, options.key);
-    if (isRootStore(innerTarget)) {
-      subject.next({ newValue, oldValue });
-    }
-    options.set(setterToolkit, newValue);
-  };
-  const mySelector = {
-    ...options,
-    subject,
-    install: (s) => createWritableSelector(s, options, family),
-    get: getSelf,
-    set: setSelf,
-    type: `selector`,
-    ...family && { family }
-  };
-  target.selectors.set(options.key, mySelector);
-  const initialValue = getSelf();
-  store.logger.info(`\u2728`, mySelector.type, mySelector.key, `=`, initialValue);
-  const token = {
-    key: options.key,
-    type: `selector`
-  };
-  if (family) {
-    token.family = family;
-  }
-  return token;
-};
-
-// ../atom.io/internal/src/selector/create-standalone-selector.ts
-function createStandaloneSelector(store, options) {
-  const isWritable = `set` in options;
-  if (isWritable) {
-    const state2 = createWritableSelector(store, options, void 0);
-    store.on.selectorCreation.next(state2);
-    return state2;
-  }
-  const state = createReadonlySelector(store, options, void 0);
-  store.on.selectorCreation.next(state);
-  return state;
-}
-
-// ../atom.io/internal/src/selector/dispose-selector.ts
-function disposeSelector(store, selectorToken) {
-  const target = newest(store);
-  const { key } = selectorToken;
-  const selector = withdraw(target, selectorToken);
-  if (!selector.family) {
-    store.logger.error(
-      `\u274C`,
-      `selector`,
-      key,
-      `Standalone selectors cannot be disposed.`
-    );
-  } else {
-    const molecule = target.molecules.get(selector.family.subKey);
-    if (molecule) {
-      target.moleculeData.delete(selector.family.subKey, selector.family.key);
-    }
-    let familyToken;
-    switch (selectorToken.type) {
-      case `selector`:
-        {
-          target.selectors.delete(key);
-          familyToken = {
-            key: selector.family.key,
-            type: `selector_family`
-          };
-          const family = withdraw(store, familyToken);
-          family.subject.next({
-            type: `state_disposal`,
-            subType: `selector`,
-            token: selectorToken
-          });
-        }
-        break;
-      case `readonly_selector`:
-        {
-          target.readonlySelectors.delete(key);
-          familyToken = {
-            key: selector.family.key,
-            type: `readonly_selector_family`
-          };
-          const family = withdraw(store, familyToken);
-          family.subject.next({
-            type: `state_disposal`,
-            subType: `selector`,
-            token: selectorToken
-          });
-        }
-        break;
-    }
-    target.valueMap.delete(key);
-    target.selectorAtoms.delete(key);
-    target.selectorGraph.delete(key);
-    store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
-    if (isChildStore(target) && target.transactionMeta.phase === `building`) {
-      target.transactionMeta.update.updates.push({
-        type: `state_disposal`,
-        subType: `selector`,
-        token: selectorToken
-      });
-    } else {
-      store.on.selectorDisposal.next(selectorToken);
-    }
-  }
-}
-
-// ../atom.io/internal/src/families/create-writable-selector-family.ts
-function createWritableSelectorFamily(store, options, internalRoles) {
-  const familyToken = {
-    key: options.key,
-    type: `selector_family`
-  };
-  const existing = store.families.get(options.key);
-  if (existing) {
-    store.logger.error(
-      `\u2757`,
-      `selector_family`,
-      options.key,
-      `Overwriting an existing ${prettyPrintTokenType(
-        existing
-      )} "${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 familyFunction = (key) => {
-    const subKey = stringifyJson(key);
-    const family = { key: options.key, subKey };
-    const fullKey = `${options.key}(${subKey})`;
-    const target = newest(store);
-    const token = createWritableSelector(
-      target,
-      {
-        key: fullKey,
-        get: options.get(key),
-        set: options.set(key)
-      },
-      family
-    );
-    subject.next({ type: `state_creation`, token });
-    return token;
-  };
-  const selectorFamily2 = Object.assign(familyFunction, familyToken, {
-    internalRoles,
-    subject,
-    install: (s) => createWritableSelectorFamily(s, options),
-    default: (key) => {
-      const getFn = options.get(key);
-      return getFn({
-        get: (...args) => getFromStore(store, ...args),
-        find: (...args) => findInStore(store, ...args),
-        json: (token) => getJsonToken(store, token)
-      });
-    }
-  });
-  store.families.set(options.key, selectorFamily2);
-  return familyToken;
-}
-
-// ../atom.io/json/src/select-json-family.ts
-function selectJsonFamily(store, atomFamilyToken, transform) {
-  const jsonFamily = createWritableSelectorFamily(
-    store,
-    {
-      key: `${atomFamilyToken.key}:JSON`,
-      get: (key) => ({ get }) => {
-        const baseState = get(atomFamilyToken, key);
-        return transform.toJson(baseState);
-      },
-      set: (key) => ({ set }, newValue) => {
-        set(atomFamilyToken, key, transform.fromJson(newValue));
-      }
-    },
-    [`mutable`, `json`]
-  );
-  return jsonFamily;
-}
-
-// ../atom.io/json/src/index.ts
-var parseJson = (str) => JSON.parse(str);
-var stringifyJson = (json) => JSON.stringify(json);
-
-// ../atom.io/internal/src/subscribe/recall-state.ts
-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);
-};
-
-// ../atom.io/internal/src/subscribe/subscribe-to-root-atoms.ts
-var subscribeToRootAtoms = (store, selector) => {
-  const target = newest(store);
-  const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
-    (atomKey) => {
-      const atom2 = target.atoms.get(atomKey);
-      if (atom2 === void 0) {
-        throw new Error(
-          `Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`
-        );
-      }
-      return atom2.subject.subscribe(
-        `${selector.type}:${selector.key}`,
-        (atomChange) => {
-          store.logger.info(
-            `\u{1F4E2}`,
-            selector.type,
-            selector.key,
-            `root`,
-            atomKey,
-            `went`,
-            atomChange.oldValue,
-            `->`,
-            atomChange.newValue
-          );
-          const oldValue = recallState(target, selector);
-          const newValue = readOrComputeValue(target, selector);
-          store.logger.info(
-            `\u2728`,
-            selector.type,
-            selector.key,
-            `went`,
-            oldValue,
-            `->`,
-            newValue
-          );
-          selector.subject.next({ newValue, oldValue });
-        }
-      );
-    }
-  );
-  return dependencySubscriptions;
-};
-
-// ../atom.io/internal/src/subscribe/subscribe-to-state.ts
-function subscribeToState(store, token, key, handleUpdate) {
-  function safelyHandleUpdate(update) {
-    if (store.operation.open) {
-      const unsubscribe2 = store.on.operationClose.subscribe(
-        `state subscription ${key}`,
-        () => {
-          unsubscribe2();
-          handleUpdate(update);
-        }
-      );
-    } else {
-      handleUpdate(update);
-    }
-  }
-  const state = withdraw(store, token);
-  store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
-  const isSelector = state.type === `selector` || state.type === `readonly_selector`;
-  let dependencyUnsubFunctions = null;
-  let updateHandler = safelyHandleUpdate;
-  if (isSelector) {
-    dependencyUnsubFunctions = subscribeToRootAtoms(store, state);
-    updateHandler = (update) => {
-      if (dependencyUnsubFunctions) {
-        dependencyUnsubFunctions.length = 0;
-        dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state));
-      }
-      safelyHandleUpdate(update);
-    };
-  }
-  const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
-  const unsubscribe = () => {
-    store.logger.info(
-      `\u{1F648}`,
-      state.type,
-      state.key,
-      `Removing subscription "${key}"`
-    );
-    mainUnsubFunction();
-    if (dependencyUnsubFunctions) {
-      for (const unsubFromDependency of dependencyUnsubFunctions) {
-        unsubFromDependency();
-      }
-    }
-  };
-  return unsubscribe;
-}
-
-// ../atom.io/internal/src/subscribe/subscribe-to-timeline.ts
-var subscribeToTimeline = (store, token, key, handleUpdate) => {
-  const tl = withdraw(store, token);
-  store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
-  const unsubscribe = tl.subject.subscribe(key, handleUpdate);
-  return () => {
-    store.logger.info(
-      `\u{1F648}`,
-      `timeline`,
-      token.key,
-      `Removing subscription "${key}" from timeline`
-    );
-    unsubscribe();
-  };
-};
-
-// ../atom.io/internal/src/mutable/tracker.ts
-var Tracker = class {
-  Update;
-  initializeState(mutableState, store) {
-    const latestUpdateStateKey = `*${mutableState.key}`;
-    store.atoms.delete(latestUpdateStateKey);
-    store.valueMap.delete(latestUpdateStateKey);
-    const familyMetaData = mutableState.family ? {
-      key: `*${mutableState.family.key}`,
-      subKey: mutableState.family.subKey
-    } : void 0;
-    const latestUpdateState = createRegularAtom(
-      store,
-      {
-        key: latestUpdateStateKey,
-        default: null
-      },
-      familyMetaData
-    );
-    if (store.parent?.valueMap.has(latestUpdateStateKey)) {
-      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
-      store.valueMap.set(latestUpdateStateKey, parentValue);
-    }
-    return latestUpdateState;
-  }
-  unsubscribeFromInnerValue;
-  unsubscribeFromState;
-  observeCore(mutableState, latestUpdateState, target) {
-    const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-    const originalInnerValue = getFromStore(target, mutableState);
-    this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
-      subscriptionKey,
-      (update) => {
-        setIntoStore(target, latestUpdateState, update);
-      }
-    );
-    this.unsubscribeFromState = subscribeToState(
-      target,
-      mutableState,
-      subscriptionKey,
-      (update) => {
-        if (update.newValue !== update.oldValue) {
-          this.unsubscribeFromInnerValue();
-          this.unsubscribeFromInnerValue = update.newValue.subscribe(
-            subscriptionKey,
-            (transceiverUpdate) => {
-              setIntoStore(target, latestUpdateState, transceiverUpdate);
-            }
-          );
-        }
-      }
-    );
-  }
-  updateCore(mutableState, latestUpdateState, target) {
-    const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
-    subscribeToState(
-      target,
-      latestUpdateState,
-      subscriptionKey,
-      ({ newValue, oldValue }) => {
-        const timelineId = target.timelineTopics.getRelatedKey(
-          latestUpdateState.key
-        );
-        if (timelineId) {
-          const timelineData = target.timelines.get(timelineId);
-          if (timelineData?.timeTraveling) {
-            const unsubscribe2 = subscribeToTimeline(
-              target,
-              { key: timelineId, type: `timeline` },
-              subscriptionKey,
-              (update) => {
-                unsubscribe2();
-                setIntoStore(target, mutableState, (transceiver) => {
-                  if (update === `redo` && newValue) {
-                    transceiver.do(newValue);
-                  } else if (update === `undo` && oldValue) {
-                    transceiver.undo(oldValue);
-                  }
-                  return transceiver;
-                });
-              }
-            );
-            return;
-          }
-        }
-        const unsubscribe = target.on.operationClose.subscribe(
-          subscriptionKey,
-          () => {
-            unsubscribe();
-            const mutable = getFromStore(target, mutableState);
-            const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
-            const eventOffset = updateNumber - mutable.cacheUpdateNumber;
-            if (newValue && eventOffset === 1) {
-              setIntoStore(
-                target,
-                mutableState,
-                (transceiver) => (transceiver.do(newValue), transceiver)
-              );
-            } else {
-              target.logger.info(
-                `\u274C`,
-                `mutable_atom`,
-                mutableState.key,
-                `could not be updated. Expected update number ${mutable.cacheUpdateNumber + 1}, but got ${updateNumber}`
-              );
-            }
-          }
-        );
-      }
-    );
-  }
-  mutableState;
-  latestUpdateState;
-  [Symbol.dispose];
-  constructor(mutableState, store) {
-    this.mutableState = mutableState;
-    const target = newest(store);
-    this.latestUpdateState = this.initializeState(mutableState, target);
-    this.observeCore(mutableState, this.latestUpdateState, target);
-    this.updateCore(mutableState, this.latestUpdateState, target);
-    target.trackers.set(mutableState.key, this);
-    this[Symbol.dispose] = () => {
-      this.unsubscribeFromInnerValue();
-      this.unsubscribeFromState();
-      target.trackers.delete(mutableState.key);
-    };
-  }
-};
-
-// ../atom.io/internal/src/mutable/create-mutable-atom.ts
-function createMutableAtom(store, options, family) {
-  store.logger.info(
-    `\u{1F528}`,
-    `atom`,
-    options.key,
-    `creating in store "${store.config.name}"`
-  );
-  const target = newest(store);
-  const existing = target.atoms.get(options.key);
-  if (existing && existing.type === `mutable_atom`) {
-    store.logger.error(
-      `\u274C`,
-      `atom`,
-      options.key,
-      `Tried to create atom, but it already exists in the store.`
-    );
-    return deposit(existing);
-  }
-  const subject = new Subject();
-  const newAtom = {
-    ...options,
-    type: `mutable_atom`,
-    install: (s) => {
-      s.logger.info(
-        `\u{1F6E0}\uFE0F`,
-        `atom`,
-        options.key,
-        `installing in store "${s.config.name}"`
-      );
-      return createMutableAtom(s, options, family);
-    },
-    subject
-  };
-  if (family) {
-    newAtom.family = family;
-  }
-  const initialValue = options.default();
-  target.atoms.set(newAtom.key, newAtom);
-  markAtomAsDefault(store, options.key);
-  cacheValue(target, options.key, initialValue, subject);
-  const token = deposit(newAtom);
-  if (options.effects) {
-    let effectIndex = 0;
-    const cleanupFunctions = [];
-    for (const effect of options.effects) {
-      const cleanup = effect({
-        setSelf: (next) => {
-          setIntoStore(store, token, next);
-        },
-        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
-      });
-      if (cleanup) {
-        cleanupFunctions.push(cleanup);
-      }
-      ++effectIndex;
-    }
-    newAtom.cleanup = () => {
-      for (const cleanup of cleanupFunctions) {
-        cleanup();
-      }
-    };
-  }
-  new Tracker(token, store);
-  if (!family) {
-    selectJson(token, options, store);
-  }
-  return token;
-}
-
-// ../atom.io/internal/src/mutable/tracker-family.ts
-var FamilyTracker = class {
-  trackers = /* @__PURE__ */ new Map();
-  Update;
-  latestUpdateAtoms;
-  mutableAtoms;
-  constructor(mutableAtoms, store) {
-    const updateAtoms = createRegularAtomFamily(
-      store,
-      {
-        key: `*${mutableAtoms.key}`,
-        default: null
-      },
-      [`mutable`, `updates`]
-    );
-    this.latestUpdateAtoms = withdraw(store, updateAtoms);
-    this.mutableAtoms = mutableAtoms;
-    this.mutableAtoms.subject.subscribe(
-      `store=${store.config.name}::tracker-atom-family`,
-      (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);
-                }
-              }
-              break;
-          }
-        }
-      }
-    );
-  }
-};
-
-// ../atom.io/internal/src/mutable/create-mutable-atom-family.ts
-function createMutableAtomFamily(store, options, internalRoles) {
-  const familyToken = {
-    key: options.key,
-    type: `mutable_atom_family`
-  };
-  const existing = store.families.get(options.key);
-  if (existing) {
-    store.logger.error(
-      `\u2757`,
-      `mutable_atom_family`,
-      options.key,
-      `Overwriting an existing ${prettyPrintTokenType(
-        existing
-      )} "${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 familyFunction = (key) => {
-    const subKey = stringifyJson(key);
-    const family = { key: options.key, subKey };
-    const fullKey = `${options.key}(${subKey})`;
-    const target = newest(store);
-    const individualOptions = {
-      key: fullKey,
-      default: () => options.default(key),
-      toJson: options.toJson,
-      fromJson: options.fromJson,
-      mutable: true
-    };
-    if (options.effects) {
-      individualOptions.effects = options.effects(key);
-    }
-    const token = createMutableAtom(target, individualOptions, family);
-    subject.next({ type: `state_creation`, token });
-    return token;
-  };
-  const atomFamily2 = Object.assign(familyFunction, familyToken, {
-    subject,
-    install: (s) => createMutableAtomFamily(s, options),
-    toJson: options.toJson,
-    fromJson: options.fromJson,
-    internalRoles
-  });
-  store.families.set(options.key, atomFamily2);
-  selectJsonFamily(store, atomFamily2, options);
-  new FamilyTracker(atomFamily2, store);
-  return familyToken;
-}
-
-// ../atom.io/internal/src/mutable/get-json-family.ts
-var getJsonFamily = (mutableAtomFamily, store) => {
-  const target = newest(store);
-  const key = `${mutableAtomFamily.key}:JSON`;
-  const jsonFamily = target.families.get(key);
-  return jsonFamily;
-};
-
-// ../atom.io/internal/src/mutable/get-json-token.ts
-var getJsonToken = (store, mutableAtomToken) => {
-  if (mutableAtomToken.family) {
-    const target = newest(store);
-    const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
-    const jsonFamilyToken = {
-      key: jsonFamilyKey,
-      type: `selector_family`
-    };
-    const family = withdraw(target, jsonFamilyToken);
-    const subKey = JSON.parse(mutableAtomToken.family.subKey);
-    const jsonToken = findInStore(store, family, subKey);
-    return jsonToken;
-  }
-  const token = {
-    type: `selector`,
-    key: `${mutableAtomToken.key}:JSON`
-  };
-  return token;
-};
-
-// ../atom.io/internal/src/mutable/get-update-token.ts
-var getUpdateToken = (mutableAtomToken) => {
-  const key = `*${mutableAtomToken.key}`;
-  const updateToken = { type: `atom`, key };
-  if (mutableAtomToken.family) {
-    updateToken.family = {
-      key: `*${mutableAtomToken.family.key}`,
-      subKey: mutableAtomToken.family.subKey
-    };
-  }
-  return updateToken;
-};
-
-// ../atom.io/internal/src/mutable/transceiver.ts
-function isTransceiver(value) {
-  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
-}
-
-// ../atom.io/internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(target, atom2, origin) {
-  const originValue = origin.valueMap.get(atom2.key);
-  const targetValue = target.valueMap.get(atom2.key);
-  if (originValue !== targetValue) {
-    return targetValue;
-  }
-  if (originValue === void 0) {
-    return atom2.default();
-  }
-  origin.logger.info(`\u{1F4C3}`, `atom`, atom2.key, `copying`);
-  const jsonValue = atom2.toJson(originValue);
-  const copiedValue = atom2.fromJson(jsonValue);
-  target.valueMap.set(atom2.key, copiedValue);
-  new Tracker(atom2, origin);
-  return copiedValue;
-}
-
-// ../atom.io/internal/src/caching.ts
-function cacheValue(target, key, value, subject) {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    const future = currentValue;
-    future.use(value);
-  }
-  if (value instanceof Promise) {
-    const future = new Future(value);
-    target.valueMap.set(key, future);
-    future.then((resolved) => {
-      cacheValue(target, key, resolved, subject);
-      subject.next({ newValue: resolved, oldValue: future });
-    }).catch((thrown) => {
-      target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
-    });
-    return future;
-  }
-  target.valueMap.set(key, value);
-  return value;
-}
-var readCachedValue = (token, target) => {
-  let value = target.valueMap.get(token.key);
-  if (token.type === `mutable_atom` && isChildStore(target)) {
-    const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(target, token, parent);
-    value = copiedValue;
-  }
-  return value;
-};
-var evictCachedValue = (key, target) => {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    const future = currentValue;
-    const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key);
-    if (selector) {
-      future.use(selector.get());
-    }
-    return;
-  }
-  if (target.operation.open) {
-    target.operation.prev.set(key, currentValue);
-  }
-  target.valueMap.delete(key);
-  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
-};
-
-// ../atom.io/internal/src/atom/is-default.ts
-var isAtomDefault = (store, key) => {
-  const core = newest(store);
-  return core.atomsThatAreDefault.has(key);
-};
-var markAtomAsDefault = (store, key) => {
-  const core = newest(store);
-  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
-};
-var markAtomAsNotDefault = (store, key) => {
-  const core = newest(store);
-  core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
-  core.atomsThatAreDefault.delete(key);
-};
-
-// ../atom.io/internal/src/atom/create-regular-atom.ts
-function createRegularAtom(store, options, family) {
-  store.logger.info(
-    `\u{1F528}`,
-    `atom`,
-    options.key,
-    `creating in store "${store.config.name}"`
-  );
-  const target = newest(store);
-  const existing = target.atoms.get(options.key);
-  if (existing && existing.type === `atom`) {
-    store.logger.error(
-      `\u274C`,
-      `atom`,
-      options.key,
-      `Tried to create atom, but it already exists in the store.`
-    );
-    return deposit(existing);
-  }
-  const subject = new Subject();
-  const newAtom = {
-    ...options,
-    type: `atom`,
-    install: (s) => {
-      s.logger.info(
-        `\u{1F6E0}\uFE0F`,
-        `atom`,
-        options.key,
-        `installing in store "${s.config.name}"`
-      );
-      return createRegularAtom(s, options, family);
-    },
-    subject
-  };
-  if (family) {
-    newAtom.family = family;
-  }
-  let initialValue = options.default;
-  if (options.default instanceof Function) {
-    initialValue = options.default();
-  }
-  target.atoms.set(newAtom.key, newAtom);
-  markAtomAsDefault(store, options.key);
-  cacheValue(target, options.key, initialValue, subject);
-  const token = deposit(newAtom);
-  if (options.effects) {
-    let effectIndex = 0;
-    const cleanupFunctions = [];
-    for (const effect of options.effects) {
-      const cleanup = effect({
-        setSelf: (next) => {
-          setIntoStore(store, token, next);
-        },
-        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
-      });
-      if (cleanup) {
-        cleanupFunctions.push(cleanup);
-      }
-      ++effectIndex;
-    }
-    newAtom.cleanup = () => {
-      for (const cleanup of cleanupFunctions) {
-        cleanup();
-      }
-    };
-  }
-  return token;
-}
-
-// ../atom.io/internal/src/atom/create-standalone-atom.ts
-function createStandaloneAtom(store, options) {
-  const isMutable = `mutable` in options;
-  if (isMutable) {
-    const state2 = createMutableAtom(store, options, void 0);
-    store.on.atomCreation.next(state2);
-    return state2;
-  }
-  const state = createRegularAtom(store, options, void 0);
-  store.on.atomCreation.next(state);
-  return state;
-}
-
-// ../atom.io/internal/src/atom/dispose-atom.ts
-function disposeAtom(store, atomToken) {
-  const target = newest(store);
-  const { key, family } = atomToken;
-  const atom2 = withdraw(target, atomToken);
-  if (!family) {
-    store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
-  } else {
-    atom2.cleanup?.();
-    const lastValue = store.valueMap.get(atom2.key);
-    const atomFamily2 = withdraw(store, { key: family.key, type: `atom_family` });
-    const disposal = {
-      type: `state_disposal`,
-      subType: `atom`,
-      token: atomToken,
-      value: lastValue
-    };
-    atomFamily2.subject.next(disposal);
-    const isChild = isChildStore(target);
-    target.atoms.delete(key);
-    target.valueMap.delete(key);
-    target.selectorAtoms.delete(key);
-    target.atomsThatAreDefault.delete(key);
-    store.timelineTopics.delete(key);
-    if (atomToken.type === `mutable_atom`) {
-      const updateToken = getUpdateToken(atomToken);
-      disposeAtom(store, updateToken);
-      store.trackers.delete(key);
-    }
-    store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
-    if (isChild && target.transactionMeta.phase === `building`) {
-      const mostRecentUpdate = target.transactionMeta.update.updates.at(-1);
-      const wasMoleculeDisposal = mostRecentUpdate?.type === `molecule_disposal`;
-      const updateAlreadyCaptured = wasMoleculeDisposal && mostRecentUpdate.values.some(([k]) => k === atom2.family?.key);
-      if (!updateAlreadyCaptured) {
-        target.transactionMeta.update.updates.push(disposal);
-      }
-    } else {
-      store.on.atomDisposal.next(atomToken);
-    }
-  }
-}
-
-// ../atom.io/transceivers/set-rtx/src/set-rtx.ts
-var SetRTX = class _SetRTX extends Set {
-  mode = `record`;
-  subject = new Subject();
-  cacheLimit = 0;
-  cache = [];
-  cacheIdx = -1;
-  cacheUpdateNumber = -1;
-  constructor(values, cacheLimit = 0) {
-    super(values);
-    if (values instanceof _SetRTX) {
-      this.parent = values;
-      this.cacheUpdateNumber = values.cacheUpdateNumber;
-    }
-    if (cacheLimit) {
-      this.cacheLimit = cacheLimit;
-      this.cache = new Array(cacheLimit);
-      this.subscribe(`auto cache`, (update) => {
-        this.cacheIdx++;
-        this.cacheIdx %= this.cacheLimit;
-        this.cache[this.cacheIdx] = update;
-      });
-    }
-  }
-  toJSON() {
-    return {
-      members: [...this],
-      cache: this.cache,
-      cacheLimit: this.cacheLimit,
-      cacheIdx: this.cacheIdx,
-      cacheUpdateNumber: this.cacheUpdateNumber
-    };
-  }
-  static fromJSON(json) {
-    const set = new _SetRTX(json.members, json.cacheLimit);
-    set.cache = json.cache;
-    set.cacheIdx = json.cacheIdx;
-    set.cacheUpdateNumber = json.cacheUpdateNumber;
-    return set;
-  }
-  add(value) {
-    const result = super.add(value);
-    if (this.mode === `record`) {
-      this.cacheUpdateNumber++;
-      this.emit(`add:${stringifyJson(value)}`);
-    }
-    return result;
-  }
-  clear() {
-    const capturedContents = this.mode === `record` ? [...this] : null;
-    super.clear();
-    if (capturedContents) {
-      this.cacheUpdateNumber++;
-      this.emit(`clear:${JSON.stringify(capturedContents)}`);
-    }
-  }
-  delete(value) {
-    const result = super.delete(value);
-    if (this.mode === `record`) {
-      this.cacheUpdateNumber++;
-      this.emit(`del:${stringifyJson(value)}`);
-    }
-    return result;
-  }
-  parent;
-  child = null;
-  transactionUpdates = null;
-  transaction(run) {
-    this.mode = `transaction`;
-    this.transactionUpdates = [];
-    this.child = new _SetRTX(this);
-    const unsubscribe = this.child._subscribe(`transaction`, (update) => {
-      this.transactionUpdates?.push(update);
-    });
-    try {
-      const shouldCommit = run(this.child);
-      if (shouldCommit) {
-        for (const update of this.transactionUpdates) {
-          this.doStep(update);
-        }
-        this.cacheUpdateNumber++;
-        this.emit(`tx:${this.transactionUpdates.join(`;`)}`);
-      }
-    } catch (thrown) {
-      console.warn(
-        `Did not apply transaction to SetRTX; this error was thrown:`,
-        thrown
-      );
-      throw thrown;
-    } finally {
-      unsubscribe();
-      this.child = null;
-      this.transactionUpdates = null;
-      this.mode = `record`;
-    }
-  }
-  _subscribe(key, fn) {
-    return this.subject.subscribe(key, fn);
-  }
-  subscribe(key, fn) {
-    return this.subject.subscribe(key, (update) => {
-      fn(`${this.cacheUpdateNumber}=${update}`);
-    });
-  }
-  emit(update) {
-    this.subject.next(update);
-  }
-  doStep(update) {
-    const typeValueBreak = update.indexOf(`:`);
-    const type = update.substring(0, typeValueBreak);
-    const value = update.substring(typeValueBreak + 1);
-    switch (type) {
-      case `add`:
-        this.add(JSON.parse(value));
-        break;
-      case `clear`:
-        this.clear();
-        break;
-      case `del`:
-        this.delete(JSON.parse(value));
-        break;
-      case `tx`:
-        for (const subUpdate of value.split(`;`)) {
-          this.doStep(subUpdate);
-        }
-    }
-  }
-  getUpdateNumber(update) {
-    const breakpoint = update.indexOf(`=`);
-    return Number(update.substring(0, breakpoint));
-  }
-  do(update) {
-    const breakpoint = update.indexOf(`=`);
-    const updateNumber = Number(update.substring(0, breakpoint));
-    const eventOffset = updateNumber - this.cacheUpdateNumber;
-    const isFuture = eventOffset > 0;
-    if (isFuture) {
-      if (eventOffset === 1) {
-        this.mode = `playback`;
-        const innerUpdate = update.substring(breakpoint + 1);
-        this.doStep(innerUpdate);
-        this.mode = `record`;
-        this.cacheUpdateNumber = updateNumber;
-        return null;
-      }
-      return this.cacheUpdateNumber + 1;
-    }
-    if (Math.abs(eventOffset) < this.cacheLimit) {
-      const eventIdx = this.cacheIdx + eventOffset;
-      const cachedUpdate = this.cache[eventIdx];
-      if (cachedUpdate === update) {
-        return null;
-      }
-      this.mode = `playback`;
-      let done = false;
-      while (!done) {
-        this.cacheIdx %= this.cacheLimit;
-        const u = this.cache[this.cacheIdx];
-        this.cacheIdx--;
-        if (!u) {
-          return `OUT_OF_RANGE`;
-        }
-        this.undo(u);
-        done = this.cacheIdx === eventIdx - 1;
-      }
-      const innerUpdate = update.substring(breakpoint + 1);
-      this.doStep(innerUpdate);
-      this.mode = `record`;
-      this.cacheUpdateNumber = updateNumber;
-      return null;
-    }
-    return `OUT_OF_RANGE`;
-  }
-  undoStep(update) {
-    const breakpoint = update.indexOf(`:`);
-    const type = update.substring(0, breakpoint);
-    const value = update.substring(breakpoint + 1);
-    switch (type) {
-      case `add`:
-        this.delete(JSON.parse(value));
-        break;
-      case `del`:
-        this.add(JSON.parse(value));
-        break;
-      case `clear`: {
-        const values = JSON.parse(value);
-        for (const v of values) this.add(v);
-        break;
-      }
-      case `tx`: {
-        const updates = value.split(`;`);
-        for (let i = updates.length - 1; i >= 0; i--) {
-          this.undoStep(updates[i]);
-        }
-      }
-    }
-  }
-  undo(update) {
-    const breakpoint = update.indexOf(`=`);
-    const updateNumber = Number(update.substring(0, breakpoint));
-    if (updateNumber === this.cacheUpdateNumber) {
-      this.mode = `playback`;
-      const innerUpdate = update.substring(breakpoint + 1);
-      this.undoStep(innerUpdate);
-      this.mode = `record`;
-      this.cacheUpdateNumber--;
-      return null;
-    }
-    return this.cacheUpdateNumber;
-  }
-};
-
-// ../atom.io/internal/src/join/join-internal.ts
-var Join = class {
-  toolkit;
-  options;
-  defaultContent;
-  molecules = /* @__PURE__ */ new Map();
-  relations;
-  states;
-  core;
-  transact(toolkit, run) {
-    const originalToolkit = this.toolkit;
-    this.toolkit = toolkit;
-    run(this);
-    this.toolkit = originalToolkit;
-  }
-  store;
-  realm;
-  [Symbol.dispose]() {
-  }
-  constructor(options, defaultContent, store = IMPLICIT.STORE) {
-    this.store = store;
-    this.realm = new Anarchy(store);
-    this.options = options;
-    this.defaultContent = defaultContent;
-    this.store.miscResources.set(`join:${options.key}`, this);
-    this.realm.allocate(`root`, options.key);
-    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`,
-        default: () => new SetRTX(),
-        mutable: true,
-        fromJson: (json) => SetRTX.fromJSON(json),
-        toJson: (set) => set.toJSON()
-      },
-      [`join`, `relations`]
-    );
-    this.core = { relatedKeysAtoms };
-    const getRelatedKeys = ({ get }, key) => get(relatedKeysAtoms, key);
-    const addRelation = ({ set }, a, b) => {
-      if (!this.store.molecules.has(stringifyJson(a))) {
-        this.realm.allocate(options.key, a);
-      }
-      set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
-      set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
-    };
-    const deleteRelation = ({ set }, a, b) => {
-      set(relatedKeysAtoms, a, (aKeys) => {
-        aKeys.delete(b);
-        return aKeys;
-      });
-      set(relatedKeysAtoms, b, (bKeys) => {
-        bKeys.delete(a);
-        return bKeys;
-      });
-    };
-    const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
-      const { find, get, set } = toolkit;
-      const relationsOfAState = find(relatedKeysAtoms, a);
-      const currentRelationsOfA = get(relationsOfAState);
-      for (const currentRelationB of currentRelationsOfA) {
-        const remainsRelated = newRelationsOfA.includes(currentRelationB);
-        if (remainsRelated) {
-          continue;
-        }
-        set(relatedKeysAtoms, currentRelationB, (relationsOfB) => {
-          relationsOfB.delete(a);
-          return relationsOfB;
-        });
-      }
-      set(relationsOfAState, (relationsOfA) => {
-        relationsOfA.transaction((nextRelationsOfA) => {
-          nextRelationsOfA.clear();
-          for (const newRelationB of newRelationsOfA) {
-            const relationsOfB = getRelatedKeys(toolkit, newRelationB);
-            const newRelationBIsAlreadyRelated = relationsOfB.has(a);
-            if (this.relations.cardinality === `1:n`) {
-              const previousOwnersToDispose = [];
-              for (const previousOwner of relationsOfB) {
-                if (previousOwner === a) {
-                  continue;
-                }
-                const previousOwnerRelations = getRelatedKeys(
-                  toolkit,
-                  previousOwner
-                );
-                previousOwnerRelations.delete(newRelationB);
-                if (previousOwnerRelations.size === 0) {
-                  previousOwnersToDispose.push(previousOwner);
-                }
-              }
-              if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
-                relationsOfB.clear();
-              }
-              for (const previousOwner of previousOwnersToDispose) {
-                const sorted = [newRelationB, previousOwner].sort();
-                const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
-                this.molecules.delete(compositeKey);
-              }
-            }
-            if (!newRelationBIsAlreadyRelated) {
-              relationsOfB.add(a);
-            }
-            nextRelationsOfA.add(newRelationB);
-          }
-          return true;
-        });
-        return relationsOfA;
-      });
-    };
-    const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
-      const { set } = toolkit;
-      set(relatedKeysAtoms, a, (relationsOfA) => {
-        relationsOfA.transaction((nextRelationsOfA) => {
-          for (const newRelationB of newRelationsOfA) {
-            nextRelationsOfA.add(newRelationB);
-          }
-          return true;
-        });
-        return relationsOfA;
-      });
-      for (const newRelationB of newRelationsOfA) {
-        set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
-          newRelationsB.add(a);
-          return newRelationsB;
-        });
-      }
-      return true;
-    };
-    const has = (toolkit, a, b) => {
-      const aKeys = getRelatedKeys(toolkit, a);
-      return b ? aKeys.has(b) : aKeys.size > 0;
-    };
-    const baseExternalStoreConfiguration = {
-      getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
-      addRelation: (a, b) => {
-        this.store.moleculeJoins.set(
-          a,
-          options.key
-        );
-        this.store.moleculeJoins.set(
-          b,
-          options.key
-        );
-        addRelation(this.toolkit, a, b);
-      },
-      deleteRelation: (a, b) => {
-        deleteRelation(this.toolkit, a, b);
-      },
-      replaceRelationsSafely: (a, bs) => {
-        replaceRelationsSafely(this.toolkit, a, bs);
-      },
-      replaceRelationsUnsafely: (a, bs) => {
-        replaceRelationsUnsafely(this.toolkit, a, bs);
-      },
-      has: (a, b) => has(this.toolkit, a, b)
-    };
-    let externalStore;
-    let contentAtoms;
-    if (defaultContent) {
-      contentAtoms = createRegularAtomFamily(
-        store,
-        {
-          key: `${options.key}/content`,
-          default: defaultContent
-        },
-        [`join`, `content`]
-      );
-      const getContent = ({ get }, key) => get(contentAtoms, key);
-      const setContent = ({ set }, key, content) => {
-        set(contentAtoms, key, content);
-      };
-      const externalStoreWithContentConfiguration = {
-        getContent: (contentKey) => {
-          const content = getContent(this.toolkit, contentKey);
-          return content;
-        },
-        setContent: (contentKey, content) => {
-          setContent(this.toolkit, contentKey, content);
-        },
-        deleteContent: (contentKey) => {
-          this.realm.deallocate(contentKey);
-        }
-      };
-      externalStore = Object.assign(
-        baseExternalStoreConfiguration,
-        externalStoreWithContentConfiguration
-      );
-    } else {
-      externalStore = baseExternalStoreConfiguration;
-    }
-    const relations = new Junction(
-      options,
-      {
-        externalStore,
-        isAType: options.isAType,
-        isBType: options.isBType,
-        makeContentKey: (...args) => {
-          const [a, b] = args;
-          const sorted = args.sort();
-          const compositeKey = `${sorted[0]}:${sorted[1]}`;
-          const aMolecule = store.molecules.get(stringifyJson(a));
-          const bMolecule = store.molecules.get(stringifyJson(b));
-          if (!aMolecule) {
-            this.realm.allocate(options.key, a);
-          }
-          if (!bMolecule) {
-            this.realm.allocate(options.key, b);
-          }
-          this.realm.allocate(a, compositeKey, `all`);
-          this.realm.claim(b, compositeKey);
-          this.store.moleculeJoins.set(compositeKey, options.key);
-          return compositeKey;
-        }
-      }
-    );
-    const createSingleKeySelectorFamily = () => createReadonlySelectorFamily(
-      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 createReadonlySelectorFamily(
-        store,
-        {
-          key: `${options.key}/multipleRelatedKeys`,
-          get: (key) => ({ get }) => {
-            const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-            const json = get(jsonFamily, key);
-            return json.members;
-          }
-        },
-        [`join`, `keys`]
-      );
-    };
-    const createSingleEntrySelectorFamily = () => createReadonlySelectorFamily(
-      store,
-      {
-        key: `${options.key}/singleRelatedEntry`,
-        get: (x) => ({ get }) => {
-          const relatedKeys = get(relatedKeysAtoms, x);
-          for (const y of relatedKeys) {
-            let a = relations.isAType?.(x) ? x : void 0;
-            let b = a === void 0 ? x : void 0;
-            a ??= y;
-            b ??= y;
-            const contentKey = relations.makeContentKey(a, b);
-            const content = get(contentAtoms, contentKey);
-            return [y, content];
-          }
-          return null;
-        }
-      },
-      [`join`, `entries`]
-    );
-    const getMultipleEntrySelectorFamily = () => createReadonlySelectorFamily(
-      store,
-      {
-        key: `${options.key}/multipleRelatedEntries`,
-        get: (x) => ({ get }) => {
-          const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-          const json = get(jsonFamily, x);
-          return json.members.map((y) => {
-            let a = relations.isAType?.(x) ? x : void 0;
-            let b = a === void 0 ? x : void 0;
-            a ??= y;
-            b ??= y;
-            const contentKey = relations.makeContentKey(a, b);
-            const content = get(contentAtoms, contentKey);
-            return [y, content];
-          });
-        }
-      },
-      [`join`, `entries`]
-    );
-    switch (options.cardinality) {
-      case `1:1`: {
-        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: singleRelatedKeySelectors,
-          [stateKeyB]: singleRelatedKeySelectors
-        };
-        let states;
-        if (defaultContent) {
-          const singleEntrySelectors = createSingleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
-          const contentStates = {
-            [entriesStateKeyA]: singleEntrySelectors,
-            [entriesStateKeyB]: singleEntrySelectors
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-        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
-        };
-        let states;
-        if (defaultContent) {
-          const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
-          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
-            aSide
-          )}`;
-          const contentStates = {
-            [entriesStateKeyA]: singleRelatedEntrySelectors,
-            [entriesStateKeyB]: multipleRelatedEntriesSelectors
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-        break;
-      }
-      case `n:n`: {
-        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: multipleRelatedKeysSelectors,
-          [stateKeyB]: multipleRelatedKeysSelectors
-        };
-        let states;
-        if (defaultContent) {
-          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
-            bSide
-          )}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
-            aSide
-          )}`;
-          const contentStates = {
-            [entriesStateKeyA]: multipleRelatedEntriesSelectors,
-            [entriesStateKeyB]: multipleRelatedEntriesSelectors
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-      }
-    }
-  }
-};
-
-// ../atom.io/internal/src/join/get-join.ts
-function getJoin(token, store) {
-  let myJoin = store.joins.get(token.key);
-  if (myJoin === void 0) {
-    const rootJoinMap = IMPLICIT.STORE.joins;
-    const rootJoin = rootJoinMap.get(token.key);
-    if (rootJoin === void 0) {
-      throw new Error(
-        `Join "${token.key}" not found in store "${store.config.name}"`
-      );
-    }
-    myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store);
-    store.joins.set(token.key, myJoin);
-  }
-  return myJoin;
-}
-
-// ../atom.io/internal/src/join/edit-relations-in-store.ts
-function editRelationsInStore(token, change, store) {
-  const myJoin = getJoin(token, store);
-  const target = newest(store);
-  if (isChildStore(target)) {
-    const { toolkit } = target.transactionMeta;
-    myJoin.transact(toolkit, ({ relations }) => {
-      change(relations);
-    });
-  } else {
-    change(myJoin.relations);
-  }
-}
-
-// ../atom.io/internal/src/join/get-internal-relations-from-store.ts
-function getInternalRelationsFromStore(token, store) {
-  const myJoin = getJoin(token, store);
-  const family = myJoin.core.relatedKeysAtoms;
-  return family;
-}
-
-// ../atom.io/internal/src/reserved-keys.ts
-function isReservedIntrospectionKey(value) {
-  return value.startsWith(`\u{1F50D} `);
-}
-
-// ../atom.io/introspection/src/refinery.ts
-var Refinery = class {
-  supported;
-  constructor(supported) {
-    this.supported = supported;
-  }
-  refine(input) {
-    for (const [key, refiner] of Object.entries(this.supported)) {
-      try {
-        if (
-          // @ts-expect-error that's the point
-          refiner(input) === true && refiner !== Boolean
-        ) {
-          return { type: key, data: input };
-        }
-      } catch (_) {
-        try {
-          if (input instanceof refiner) {
-            return { type: key, data: input };
-          }
-        } catch (__) {
-        }
-      }
-    }
-    return null;
-  }
-};
-var primitiveRefinery = new Refinery({
-  number: (input) => typeof input === `number`,
-  string: (input) => typeof input === `string`,
-  boolean: (input) => typeof input === `boolean`,
-  null: (input) => input === null
-});
-function isPlainObject(input) {
-  if (!input) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(input);
-  return prototype === Object.prototype;
-}
-var jsonTreeRefinery = new Refinery({
-  object: isPlainObject,
-  array: (input) => Array.isArray(input)
-});
-var jsonRefinery = new Refinery({
-  ...primitiveRefinery.supported,
-  ...jsonTreeRefinery.supported
-});
-var discoverType = (input) => {
-  if (input === void 0) {
-    return `undefined`;
-  }
-  const refined = jsonRefinery.refine(input);
-  if (refined) {
-    return refined.type;
-  }
-  return Object.getPrototypeOf(input).constructor.name;
-};
-
-// ../atom.io/introspection/src/sprawl.ts
-var sprawl = (tree, inspector) => {
-  const walk = (path, node) => {
-    const inspect2 = (p, n) => {
-      const result2 = inspector(p, n);
-      if (result2) return result2;
-      return null;
-    };
-    const result = inspect2(path, node);
-    if (result?.jobComplete ?? result?.pathComplete) {
-      return result;
-    }
-    const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
-    for (const [k, v] of childEntries) {
-      const subResult = walk([...path, k], v);
-      if (subResult?.jobComplete) {
-        return subResult;
-      }
-    }
-    return {};
-  };
-  walk([], tree);
-};
-
-// ../atom.io/introspection/src/differ.ts
-function diffNumber(a, b) {
-  const sign = a < b ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
-  };
-}
-function diffString(a, b) {
-  const sign = a.length < b.length ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
-  };
-}
-function diffBoolean(a, b) {
-  return {
-    summary: `${a} \u2192 ${b}`
-  };
-}
-function diffObject(a, b, recurse) {
-  let summary = ``;
-  const added = [];
-  const removed = [];
-  const changed = [];
-  sprawl(a, (path, nodeA) => {
-    let key;
-    for (key of path) {
-      const nodeB = b[key];
-      if (nodeB === void 0) {
-        removed.push([key, JSON.stringify(nodeA)]);
-      } else {
-        const delta = recurse(nodeA, nodeB);
-        if (delta.summary !== `No Change`) {
-          changed.push([key, delta]);
-        }
-      }
-    }
-  });
-  sprawl(b, (path, nodeB) => {
-    let key;
-    for (key of path) {
-      const nodeA = a[key];
-      if (nodeA === void 0) {
-        added.push([key, JSON.stringify(nodeB)]);
-      }
-    }
-  });
-  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${removed.length}`;
-  return {
-    summary,
-    added,
-    removed,
-    changed
-  };
-}
-function diffArray(a, b, recurse) {
-  return diffObject(a, b, recurse);
-}
-var Differ = class {
-  leafRefinery;
-  treeRefinery;
-  leafDiffers;
-  treeDiffers;
-  constructor(leafRefinery, treeRefinery, diffFunctions) {
-    this.leafRefinery = leafRefinery;
-    this.treeRefinery = treeRefinery;
-    this.leafDiffers = {};
-    this.treeDiffers = {};
-    for (const key of Object.keys(leafRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.leafDiffers[key] = diffFunction;
-    }
-    for (const key of Object.keys(treeRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.treeDiffers[key] = diffFunction;
-    }
-  }
-  diff(a, b) {
-    if (a === b) {
-      return { summary: `No Change` };
-    }
-    const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a);
-    const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b);
-    if (aRefined !== null && bRefined !== null) {
-      if (aRefined.type === bRefined.type) {
-        if (aRefined.type in this.leafDiffers) {
-          const delta = this.leafDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data
-          );
-          return delta;
-        }
-        if (aRefined.type in this.treeDiffers) {
-          const delta = this.treeDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data,
-            (x, y) => this.diff(x, y)
-          );
-          return delta;
-        }
-      }
-    }
-    const typeA = discoverType(a);
-    const typeB = discoverType(b);
-    if (typeA === typeB) {
-      return {
-        summary: `${typeA} \u2192 ${typeB}`
-      };
-    }
-    return {
-      summary: `Type change: ${typeA} \u2192 ${typeB}`
-    };
-  }
-};
-new Differ(primitiveRefinery, jsonTreeRefinery, {
-  number: diffNumber,
-  string: diffString,
-  boolean: diffBoolean,
-  null: () => ({ summary: `No Change` }),
-  object: diffObject,
-  array: diffArray
-});
-
-// ../atom.io/realtime/src/shared-room-store.ts
-atom({
-  key: `usersInRoomIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var roomIndex = atom({
-  key: `roomIndex`,
-  default: () => new SetRTX(),
-  mutable: true,
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var DEFAULT_USER_IN_ROOM_META = {
-  enteredAtEpoch: 0
-};
-var usersInRooms = join(
-  {
-    key: `usersInRooms`,
-    between: [`room`, `user`],
-    cardinality: `1:n`,
-    isAType: (input) => typeof input === `string`,
-    isBType: (input) => typeof input === `string`
-  },
-  DEFAULT_USER_IN_ROOM_META
-);
-selectorFamily({
-  key: `usersInMyRoomView`,
-  get: (myUsername) => ({ find }) => {
-    const usersInRoomsAtoms = getInternalRelations(usersInRooms);
-    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
-    return [myRoomIndex];
-  }
-});
-
-// ../atom.io/realtime-server/src/ipc-sockets/custom-socket.ts
-var CustomSocket = class {
-  listeners;
-  globalListeners;
-  handleEvent(event, ...args) {
-    for (const listener of this.globalListeners) {
-      listener(event, ...args);
-    }
-    const listeners = this.listeners.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        listener(...args);
-      }
-    }
-  }
-  id = `no_id_retrieved`;
-  emit;
-  constructor(emit) {
-    this.emit = emit;
-    this.listeners = /* @__PURE__ */ new Map();
-    this.globalListeners = /* @__PURE__ */ new Set();
-  }
-  on(event, listener) {
-    const listeners = this.listeners.get(event);
-    if (listeners) {
-      listeners.add(listener);
-    } else {
-      this.listeners.set(event, /* @__PURE__ */ new Set([listener]));
-    }
-    return this;
-  }
-  onAny(listener) {
-    this.globalListeners.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;
-  }
-};
-
-// ../atom.io/realtime-server/src/ipc-sockets/child-socket.ts
-var ChildSocket = class extends CustomSocket {
-  incompleteData = ``;
-  unprocessedEvents = [];
-  incompleteLog = ``;
-  unprocessedLogs = [];
-  id = `#####`;
-  process;
-  key;
-  logger;
-  handleLog(arg) {
-    if (Array.isArray(arg)) {
-      const [level, ...rest] = arg;
-      switch (level) {
-        case `i`:
-          this.logger.info(...rest);
-          break;
-        case `w`:
-          this.logger.warn(...rest);
-          break;
-        case `e`:
-          this.logger.error(...rest);
-          break;
-        default:
-          return;
-      }
-    }
-  }
-  constructor(process2, key, logger) {
-    super((event, ...args) => {
-      const stringifiedEvent = JSON.stringify([event, ...args]) + ``;
-      const errorHandler = (err) => {
-        if (err.code === `EPIPE`) {
-          console.error(`EPIPE error during write`, this.process.stdin);
-        }
-        this.process.stdin.removeListener(`error`, errorHandler);
-      };
-      this.process.stdin.once(`error`, errorHandler);
-      this.process.stdin.write(stringifiedEvent);
-      return this;
-    });
-    this.process = process2;
-    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.process.stdout.on(
-      `data`,
-      (buffer) => {
-        const chunk = buffer.toString();
-        if (chunk === `ALIVE`) {
-          return;
-        }
-        this.unprocessedEvents.push(...chunk.split(``));
-        const newInput = this.unprocessedEvents.shift();
-        this.incompleteData += newInput ?? ``;
-        try {
-          if (this.incompleteData.startsWith(`error`)) {
-            console.log(`\u2757`, this.incompleteData);
-          }
-          let parsedEvent = parseJson(this.incompleteData);
-          this.handleEvent(...parsedEvent);
-          while (this.unprocessedEvents.length > 0) {
-            const event = this.unprocessedEvents.shift();
-            if (event) {
-              if (this.unprocessedEvents.length === 0) {
-                this.incompleteData = event;
-              }
-              parsedEvent = parseJson(event);
-              this.handleEvent(...parsedEvent);
-            }
-          }
-          this.incompleteData = ``;
-        } catch (error) {
-          console.warn(`\u26A0\uFE0F----------------\u26A0\uFE0F`);
-          console.warn(this.incompleteData);
-          console.warn(`\u26A0\uFE0F----------------\u26A0\uFE0F`);
-          console.error(error);
-        }
-      }
-    );
-    this.process.stderr.on(`data`, (buf) => {
-      const chunk = buf.toString();
-      this.unprocessedLogs.push(...chunk.split(``));
-      const newInput = this.unprocessedLogs.shift();
-      this.incompleteLog += newInput ?? ``;
-      try {
-        let parsedLog = parseJson(this.incompleteLog);
-        this.handleLog(parsedLog);
-        while (this.unprocessedLogs.length > 0) {
-          this.incompleteLog = this.unprocessedLogs.shift() ?? ``;
-          if (this.incompleteLog) {
-            parsedLog = parseJson(this.incompleteLog);
-            this.handleLog(parsedLog);
-          }
-        }
-      } catch (error) {
-        console.error(`\u274C\u274C\u274C`);
-        console.error(this.incompleteLog);
-        console.error(error);
-        console.error(`\u274C\u274C\u274C\uFE0F`);
-      }
-    });
-    if (process2.pid) {
-      this.id = process2.pid.toString();
-    }
-  }
-};
-
-// ../atom.io/realtime-server/src/realtime-server-stores/server-room-external-store.ts
-var roomArgumentsAtoms = atomFamily({
-  key: `roomArguments`,
-  default: [`echo`, [`Hello World!`]]
-});
-var roomSelectors = selectorFamily({
-  key: `room`,
-  get: (roomId) => async ({ get, find }) => {
-    const argumentsState = find(roomArgumentsAtoms, roomId);
-    const args = get(argumentsState);
-    const [script, options] = args;
-    const child = await new Promise(
-      (resolve2) => {
-        const room = spawn(script, options, { env: process.env });
-        const resolver = (data) => {
-          if (data.toString() === `ALIVE`) {
-            room.stdout.off(`data`, resolver);
-            resolve2(room);
-          }
-        };
-        room.stdout.on(`data`, resolver);
-      }
-    );
-    return new ChildSocket(child, roomId);
-  }
-});
-
-// ../atom.io/realtime-server/src/realtime-server-stores/server-room-external-actions.ts
-transaction({
-  key: `createRoom`,
-  do: ({ get, set, find }, roomId, script, options) => {
-    const args = options ? [script, options] : [script];
-    const roomArgumentsState = find(roomArgumentsAtoms, roomId);
-    set(roomArgumentsState, args);
-    set(roomIndex, (s) => s.add(roomId));
-    const roomState = find(roomSelectors, roomId);
-    const room = get(roomState);
-    return room;
-  }
-});
-transaction({
-  key: `joinRoom`,
-  do: (tools, roomId, userId, enteredAtEpoch) => {
-    const meta = { enteredAtEpoch };
-    editRelationsInStore(
-      usersInRooms,
-      (relations) => {
-        relations.set({ room: roomId, user: userId }, meta);
-      },
-      tools.env().store
-    );
-    return meta;
-  }
-});
-transaction({
-  key: `leaveRoom`,
-  do: (tools, roomId, userId) => {
-    editRelationsInStore(
-      usersInRooms,
-      (relations) => {
-        relations.delete({ room: roomId, user: userId });
-      },
-      tools.env().store
-    );
-  }
-});
-transaction({
-  key: `destroyRoom`,
-  do: (tools, roomId) => {
-    editRelationsInStore(
-      usersInRooms,
-      (relations) => {
-        relations.delete({ room: roomId });
-      },
-      tools.env().store
-    );
-    tools.set(roomIndex, (s) => (s.delete(roomId), s));
-  }
-});
-
-// ../atom.io/realtime-server/src/realtime-server-stores/server-sync-store.ts
-atomFamily({
-  key: `redactor`,
-  default: { occlude: (updates) => updates }
-});
-atomFamily({
-  key: `unacknowledgedUpdates`,
-  default: () => []
-});
-
-// ../atom.io/realtime-server/src/realtime-server-stores/server-user-store.ts
-atomFamily({
-  key: `sockets`,
-  default: null
-});
-atom({
-  key: `socketsIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-atom({
-  key: `usersIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-join({
-  key: `usersOfSockets`,
-  between: [`user`, `socket`],
-  cardinality: `1:1`,
-  isAType: (s) => s.startsWith(`user::`),
-  isBType: (s) => s.startsWith(`socket::`)
-});
-var env = createEnv({
-  server: { FLIGHTDECK_SECRET: z.string().optional() },
-  clientPrefix: `NEVER`,
-  client: {},
-  runtimeEnv: import.meta.env,
-  emptyStringAsUndefined: true
-});
-
-// src/flightdeck.lib.ts
-var FLIGHTDECK_SETUP_PHASES = [`downloaded`, `installed`];
-var FLIGHTDECK_UPDATE_PHASES = [`notified`, `confirmed`];
-function isVersionNumber(version) {
-  return /^\d+\.\d+\.\d+$/.test(version) || !Number.isNaN(Number.parseFloat(version));
-}
-var FlightDeck = class {
-  options;
-  safety = 0;
-  storage;
-  webhookServer;
-  services;
-  serviceIdx;
-  defaultServicesReadyToUpdate;
-  servicesReadyToUpdate;
-  autoRespawnDeadServices;
-  logger;
-  serviceLoggers;
-  updateAvailabilityChecker = null;
-  servicesLive;
-  servicesDead;
-  live = new Future(() => {
-  });
-  dead = new Future(() => {
-  });
-  restartTimes = [];
-  constructor(options) {
-    this.options = options;
-    const { FLIGHTDECK_SECRET } = env;
-    const { flightdeckRootDir = resolve(homedir(), `.flightdeck`) } = options;
-    const port = options.port ?? 8080;
-    const origin = `http://localhost:${port}`;
-    const servicesEntries = toEntries(options.services);
-    this.services = fromEntries(
-      servicesEntries.map(([serviceName]) => [serviceName, null])
-    );
-    this.serviceIdx = fromEntries(
-      servicesEntries.map(([serviceName], idx) => [serviceName, idx])
-    );
-    this.defaultServicesReadyToUpdate = fromEntries(
-      servicesEntries.map(([serviceName, { waitFor }]) => [
-        serviceName,
-        !waitFor
-      ])
-    );
-    this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate };
-    this.autoRespawnDeadServices = true;
-    this.logger = new FlightDeckLogger(
-      this.options.packageName,
-      process.pid,
-      void 0,
-      { jsonLogging: this.options.jsonLogging ?? false }
-    );
-    this.serviceLoggers = fromEntries(
-      servicesEntries.map(([serviceName]) => [
-        serviceName,
-        new FlightDeckLogger(
-          this.options.packageName,
-          process.pid,
-          serviceName,
-          { jsonLogging: this.options.jsonLogging ?? false }
-        )
-      ])
-    );
-    this.servicesLive = servicesEntries.map(() => new Future(() => {
-    }));
-    this.servicesDead = servicesEntries.map(() => new Future(() => {
-    }));
-    this.live.use(Promise.all(this.servicesLive));
-    this.dead.use(Promise.all(this.servicesDead));
-    this.storage = new FilesystemStorage({
-      path: resolve(flightdeckRootDir, `storage`, options.packageName)
-    });
-    if (FLIGHTDECK_SECRET === void 0) {
-      this.logger.warn(
-        `No FLIGHTDECK_SECRET environment variable found. FlightDeck will not run an update server.`
-      );
-    } else {
-      createServer((req, res) => {
-        let data = [];
-        req.on(`data`, (chunk) => {
-          data.push(chunk instanceof Buffer ? chunk : Buffer.from(chunk));
-        }).on(`end`, async () => {
-          const authHeader = req.headers.authorization;
-          try {
-            if (typeof req.url === `undefined`) throw 400;
-            const expectedAuthHeader = `Bearer ${FLIGHTDECK_SECRET}`;
-            if (authHeader !== `Bearer ${FLIGHTDECK_SECRET}`) {
-              this.logger.info(
-                `Unauthorized: needed \`${expectedAuthHeader}\`, got \`${authHeader}\``
-              );
-              throw 401;
-            }
-            const url = new URL(req.url, origin);
-            this.logger.info(req.method, url.pathname);
-            const versionForeignInput = Buffer.concat(data).toString();
-            if (!isVersionNumber(versionForeignInput)) {
-              throw 400;
-            }
-            res.writeHead(200);
-            res.end();
-            this.storage.setItem(`updatePhase`, `notified`);
-            this.storage.setItem(`updateAwaitedVersion`, versionForeignInput);
-            const { checkAvailability } = options.scripts;
-            if (checkAvailability) {
-              await this.updateAvailabilityChecker?.stop();
-              await this.seekUpdate(versionForeignInput);
-              const updatePhase = this.storage.getItem(`updatePhase`);
-              this.logger.info(`> storage("updatePhase") >`, updatePhase);
-              if (updatePhase === `notified`) {
-                this.updateAvailabilityChecker = new CronJob(
-                  `30 * * * * *`,
-                  async () => {
-                    await this.seekUpdate(versionForeignInput);
-                  }
-                );
-                this.updateAvailabilityChecker.start();
-              }
-            } else {
-              this.downloadPackage();
-            }
-          } catch (thrown) {
-            this.logger.error(thrown, req.url);
-            if (typeof thrown === `number`) {
-              res.writeHead(thrown);
-              res.end();
-            }
-          } finally {
-            data = [];
-          }
-        });
-      }).listen(port, () => {
-        this.logger.info(`Server started on port ${port}`);
-      });
-    }
-    this.startAllServices().then(() => {
-      this.logger.info(`All services started.`);
-    }).catch((thrown) => {
-      if (thrown instanceof Error) {
-        this.logger.error(`Failed to start all services:`, thrown.message);
-      }
-    });
-  }
-  async seekUpdate(version) {
-    this.logger.info(`Checking for updates...`);
-    const { checkAvailability } = this.options.scripts;
-    if (!checkAvailability) {
-      this.logger.info(`No checkAvailability script found.`);
-      return;
-    }
-    try {
-      const out = execSync(`${checkAvailability} ${version}`);
-      this.logger.info(`Check stdout:`, out.toString());
-      await this.updateAvailabilityChecker?.stop();
-      this.storage.setItem(`updatePhase`, `confirmed`);
-      this.downloadPackage();
-      this.announceUpdate();
-    } catch (thrown) {
-      if (thrown instanceof Error) {
-        this.logger.error(`Check failed:`, thrown.message);
-      } else {
-        const thrownType = discoverType(thrown);
-        this.logger.error(`Check threw`, thrownType, thrown);
-      }
-    }
-  }
-  announceUpdate() {
-    for (const entry of toEntries(this.services)) {
-      const [serviceName, service] = entry;
-      if (service) {
-        if (this.options.services[serviceName].waitFor) {
-          service.emit(`updatesReady`);
-        }
-      } else {
-        this.startService(serviceName);
-      }
-    }
-  }
-  tryUpdate() {
-    if (toEntries(this.servicesReadyToUpdate).every(([, isReady]) => isReady)) {
-      this.logger.info(`All services are ready to update.`);
-      this.stopAllServices().then(() => {
-        this.logger.info(`All services stopped; starting up fresh...`);
-        this.startAllServices().then(() => {
-          this.logger.info(`All services started; we're back online.`);
-        }).catch((thrown) => {
-          if (thrown instanceof Error) {
-            this.logger.error(
-              `Failed to start all services:`,
-              thrown.message
-            );
-          }
-        });
-      }).catch((thrown) => {
-        if (thrown instanceof Error) {
-          this.logger.error(`Failed to stop all services:`, thrown.message);
-        }
-      });
-    }
-  }
-  startAllServices() {
-    this.logger.info(`Starting all services...`);
-    this.autoRespawnDeadServices = true;
-    const setupPhase = this.storage.getItem(`setupPhase`);
-    this.logger.info(`> storage("setupPhase") >`, setupPhase);
-    switch (setupPhase) {
-      case null:
-        this.logger.info(`Starting from scratch.`);
-        this.downloadPackage();
-        this.installPackage();
-        return this.startAllServices();
-      case `downloaded`:
-        this.logger.info(`Found package downloaded but not installed.`);
-        this.installPackage();
-        return this.startAllServices();
-      case `installed`: {
-        for (const [serviceName] of toEntries(this.services)) {
-          this.startService(serviceName);
-        }
-        return this.live;
-      }
-    }
-  }
-  startService(serviceName) {
-    this.logger.info(
-      `Starting service ${this.options.packageName}::${serviceName}, try ${this.safety}/2...`
-    );
-    if (this.safety >= 2) {
-      throw new Error(`Out of tries...`);
-    }
-    this.safety++;
-    const [exe, ...args] = this.options.services[serviceName].run.split(` `);
-    const serviceProcess = spawn(exe, args, {
-      cwd: this.options.flightdeckRootDir,
-      env: import.meta.env
-    });
-    const serviceLogger = this.serviceLoggers[serviceName];
-    const service = this.services[serviceName] = new ChildSocket(
-      serviceProcess,
-      `${this.options.packageName}::${serviceName}`,
-      serviceLogger
-    );
-    serviceLogger.processCode = service.process.pid ?? -1;
-    this.services[serviceName].onAny((...messages) => {
-      serviceLogger.info(`\u{1F4AC}`, ...messages);
-    });
-    this.services[serviceName].on(`readyToUpdate`, () => {
-      this.logger.info(`Service "${serviceName}" is ready to update.`);
-      this.servicesReadyToUpdate[serviceName] = true;
-      this.tryUpdate();
-    });
-    this.services[serviceName].on(`alive`, () => {
-      this.servicesLive[this.serviceIdx[serviceName]].use(Promise.resolve());
-      this.servicesDead[this.serviceIdx[serviceName]] = new Future(() => {
-      });
-      if (this.dead.done) {
-        this.dead = new Future(() => {
-        });
-      }
-      this.dead.use(Promise.all(this.servicesDead));
-    });
-    this.services[serviceName].process.once(`close`, (exitCode) => {
-      this.logger.info(
-        `Auto-respawn saw "${serviceName}" exit with code ${exitCode}`
-      );
-      this.services[serviceName] = null;
-      if (!this.autoRespawnDeadServices) {
-        this.logger.info(`Auto-respawn is off; "${serviceName}" rests.`);
-        return;
-      }
-      const updatePhase = this.storage.getItem(`updatePhase`);
-      this.logger.info(`> storage("updatePhase") >`, updatePhase);
-      const updatesAreReady = updatePhase === `confirmed`;
-      if (updatesAreReady) {
-        this.serviceLoggers[serviceName].info(`Updating before startup...`);
-        this.restartTimes = [];
-        this.installPackage();
-        this.startService(serviceName);
-      } else {
-        const now = Date.now();
-        const fiveMinutesAgo = now - 5 * 60 * 1e3;
-        this.restartTimes = this.restartTimes.filter(
-          (time) => time > fiveMinutesAgo
-        );
-        this.restartTimes.push(now);
-        if (this.restartTimes.length < 5) {
-          this.serviceLoggers[serviceName].info(`Crashed. Restarting...`);
-          this.startService(serviceName);
-        } else {
-          this.serviceLoggers[serviceName].info(
-            `Crashed 5 times in 5 minutes. Not restarting.`
-          );
-        }
-      }
-    });
-    this.safety = 0;
-  }
-  downloadPackage() {
-    this.logger.info(`Downloading...`);
-    try {
-      const out = execSync(this.options.scripts.download);
-      this.logger.info(`Download stdout:`, out.toString());
-      this.storage.setItem(`setupPhase`, `downloaded`);
-      this.logger.info(`Downloaded!`);
-    } catch (thrown) {
-      if (thrown instanceof Error) {
-        this.logger.error(`Failed to get the latest release: ${thrown.message}`);
-      }
-      return;
-    }
-  }
-  installPackage() {
-    this.logger.info(`Installing...`);
-    try {
-      const out = execSync(this.options.scripts.install);
-      this.logger.info(`Install stdout:`, out.toString());
-      this.storage.setItem(`setupPhase`, `installed`);
-      this.logger.info(`Installed!`);
-    } catch (thrown) {
-      if (thrown instanceof Error) {
-        this.logger.error(`Failed to get the latest release: ${thrown.message}`);
-      }
-      return;
-    }
-  }
-  stopAllServices() {
-    this.logger.info(`Stopping all services... auto-respawn disabled.`);
-    this.autoRespawnDeadServices = false;
-    for (const [serviceName] of toEntries(this.services)) {
-      this.stopService(serviceName);
-    }
-    return this.dead;
-  }
-  stopService(serviceName) {
-    const service = this.services[serviceName];
-    if (service) {
-      this.logger.info(`Stopping service "${serviceName}"...`);
-      this.servicesDead[this.serviceIdx[serviceName]].use(
-        new Promise((pass) => {
-          service.emit(`timeToStop`);
-          service.process.once(`close`, (exitCode) => {
-            this.logger.info(
-              `Stopped service "${serviceName}"; exited with code ${exitCode}`
-            );
-            this.services[serviceName] = null;
-            pass();
-          });
-        })
-      );
-      this.dead.use(Promise.all(this.servicesDead));
-      this.servicesLive[this.serviceIdx[serviceName]] = new Future(() => {
-      });
-      if (this.live.done) {
-        this.live = new Future(() => {
-        });
-      }
-      this.live.use(Promise.all(this.servicesLive));
-    } else {
-      this.serviceLoggers[serviceName].error(
-        `Tried to stop service, but it wasn't running.`
-      );
-    }
-  }
-};
-var FLIGHTDECK_INFO = `info`;
-var FLIGHTDECK_WARN = `warn`;
-var FLIGHTDECK_ERROR = `ERR!`;
-var flightDeckLogSchema = z.object({
-  level: z.union([
-    z.literal(FLIGHTDECK_INFO),
-    z.literal(FLIGHTDECK_WARN),
-    z.literal(FLIGHTDECK_ERROR)
-  ]),
-  timestamp: z.number(),
-  package: z.string(),
-  service: z.string().optional(),
-  process: z.number(),
-  body: z.string()
-});
-var LINE_FORMAT = `line-format`;
-var VALUE = `value`;
-var FLIGHTDECK_LNAV_FORMAT = {
-  title: `FlightDeck Log`,
-  description: `Format for events logged by the FlightDeck process manager.`,
-  "file-type": `json`,
-  "timestamp-field": `timestamp`,
-  "timestamp-divisor": 1e3,
-  "module-field": `package`,
-  "opid-field": `service`,
-  "level-field": `level`,
-  level: {
-    info: FLIGHTDECK_INFO,
-    warning: FLIGHTDECK_WARN,
-    error: FLIGHTDECK_ERROR
-  },
-  [LINE_FORMAT]: [
-    {
-      field: `level`
-    },
-    {
-      prefix: ` `,
-      field: `__timestamp__`,
-      "timestamp-format": `%Y-%m-%dT%H:%M:%S.%L%Z`
-    },
-    {
-      prefix: ` `,
-      field: `process`,
-      "min-width": 5
-    },
-    {
-      prefix: `:`,
-      field: `package`
-    },
-    {
-      prefix: `:`,
-      field: `service`,
-      "default-value": ``
-    },
-    {
-      prefix: `: `,
-      field: `body`
-    }
-  ],
-  [VALUE]: {
-    timestamp: {
-      kind: `integer`
-    },
-    level: {
-      kind: `string`
-    },
-    package: {
-      kind: `string`
-    },
-    service: {
-      kind: `string`
-    },
-    process: {
-      kind: `integer`
-    },
-    body: {
-      kind: `string`
-    }
-  }
-};
-var FlightDeckLogger = class {
-  packageName;
-  serviceName;
-  jsonLogging;
-  processCode;
-  constructor(packageName, processCode, serviceName, options) {
-    this.packageName = packageName;
-    if (serviceName) {
-      this.serviceName = serviceName;
-    }
-    this.processCode = processCode;
-    this.jsonLogging = options?.jsonLogging ?? false;
-  }
-  log(level, ...messages) {
-    if (this.jsonLogging) {
-      let body = messages.map(
-        (message) => typeof message === `string` ? message : inspect(message, false, null, true)
-      ).join(` `);
-      if (body.includes(`
-`)) {
-        body = `
-  ${body.split(`
-`).join(`
-  `)}`;
-      }
-      const log = {
-        timestamp: Date.now(),
-        level,
-        process: this.processCode,
-        package: this.packageName,
-        body
-      };
-      if (this.serviceName) {
-        log.service = this.serviceName;
-      }
-      process.stdout.write(JSON.stringify(log) + `
-`);
-    } else {
-      const source = this.serviceName ? `${this.packageName}:${this.serviceName}` : this.packageName;
-      switch (level) {
-        case FLIGHTDECK_INFO:
-          console.log(`${source}:`, ...messages);
-          break;
-        case FLIGHTDECK_WARN:
-          console.warn(`${source}:`, ...messages);
-          break;
-        case FLIGHTDECK_ERROR:
-          console.error(`${source}:`, ...messages);
-          break;
-      }
-    }
-  }
-  info(...messages) {
-    this.log(FLIGHTDECK_INFO, ...messages);
-  }
-  warn(...messages) {
-    this.log(FLIGHTDECK_WARN, ...messages);
-  }
-  error(...messages) {
-    this.log(FLIGHTDECK_ERROR, ...messages);
-  }
-};
-
-export { FLIGHTDECK_ERROR, FLIGHTDECK_INFO, FLIGHTDECK_LNAV_FORMAT, FLIGHTDECK_SETUP_PHASES, FLIGHTDECK_UPDATE_PHASES, FLIGHTDECK_WARN, FlightDeck, FlightDeckLogger, flightDeckLogSchema, isVersionNumber };
-//# sourceMappingURL=chunk-FIIAJE2K.js.map
-//# sourceMappingURL=chunk-FIIAJE2K.js.map