flightdeck 0.2.14 → 0.2.15

package/dist/chunk-XIZZKICH.js

@@ -0,0 +1,4778 @@
+import { execSync, spawn } 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 = undefined;
+    }
+  }
+};
+
+// ../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: (...ps) => getFromStore(store, ...ps),
+        find: (token, k) => findInStore(store, token, k),
+        seek: (token, k) => seekInStore(store, token, k),
+        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/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;
+}
+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/atom.ts
+function atom(options) {
+  return createStandaloneAtom(IMPLICIT.STORE, options);
+}
+function atomFamily(options) {
+  return createAtomFamily(IMPLICIT.STORE, options);
+}
+
+// ../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 {
+  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);
+    }
+  };
+};
+
+// ../atom.io/src/selector.ts
+function selectorFamily(options) {
+  return createSelectorFamily(IMPLICIT.STORE, options);
+}
+
+// ../atom.io/src/transaction.ts
+function transaction(options) {
+  return createTransaction(options, IMPLICIT.STORE);
+}
+
+// ../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 : undefined;
+    let b = a === undefined ? x : undefined;
+    if (xRelationsPrev) {
+      for (const y of xRelationsPrev) {
+        a ??= y;
+        b ??= y;
+        const yRelations = this.relations.get(y);
+        if (yRelations) {
+          if (yRelations.size === 1) {
+            this.relations.delete(y);
+          } else {
+            yRelations.delete(x);
+          }
+          this.contents.delete(this.makeContentKey(a, b));
+        }
+      }
+    }
+    this.relations.set(x, new Set(ys));
+    for (const y of ys) {
+      let yRelations = this.relations.get(y);
+      if (yRelations) {
+        yRelations.add(x);
+      } else {
+        yRelations = (/* @__PURE__ */ new Set()).add(x);
+        this.relations.set(y, yRelations);
+      }
+    }
+  }
+  getContentInternal(contentKey) {
+    return this.contents.get(contentKey);
+  }
+  setContent(contentKey, content) {
+    this.contents.set(contentKey, content);
+  }
+  deleteContent(contentKey) {
+    this.contents.delete(contentKey);
+  }
+  constructor(data, config) {
+    this.a = data.between[0];
+    this.b = data.between[1];
+    this.cardinality = data.cardinality;
+    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 : undefined;
+        let b = a === undefined ? x : undefined;
+        for (const y of ys) {
+          a ??= y;
+          b ??= y;
+          this.addRelation(a, b);
+        }
+      }
+      for (const [contentKey, content] of data.contents ?? []) {
+        this.setContent(contentKey, content);
+      }
+    }
+    if (config?.warn) {
+      this.warn = config.warn;
+    }
+  }
+  toJSON() {
+    return {
+      between: [this.a, this.b],
+      cardinality: this.cardinality,
+      relations: [...this.relations.entries()].map(
+        ([a, b]) => [a, [...b]]
+      ),
+      contents: [...this.contents.entries()]
+    };
+  }
+  set(...params) {
+    let a;
+    let b;
+    let content;
+    switch (params.length) {
+      case 1: {
+        const relation = params[0];
+        a = relation[this.a];
+        b = relation[this.b];
+        content = undefined;
+        break;
+      }
+      case 2: {
+        const zeroth = params[0];
+        if (typeof zeroth === `string`) {
+          [a, b] = params;
+        } else {
+          a = zeroth[this.a];
+          b = zeroth[this.b];
+          content = params[1];
+        }
+        break;
+      }
+      default: {
+        a = params[0];
+        b = params[1];
+        content = params[2];
+        break;
+      }
+    }
+    switch (this.cardinality) {
+      // 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);
+      }
+    }
+    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 === undefined && typeof b === `string`) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        for (const bRelation of bRelations) {
+          this.delete(bRelation, b);
+        }
+      }
+    }
+    if (typeof a === `string` && b === undefined) {
+      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 !== undefined && b === undefined) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        return [...aRelations].map((aRelation) => {
+          return [aRelation, this.getContent(a, aRelation)];
+        });
+      }
+    }
+    if (a === undefined && b !== undefined) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        return [...bRelations].map((bRelation) => {
+          return [bRelation, this.getContent(bRelation, b)];
+        });
+      }
+    }
+    return [];
+  }
+  has(a, b) {
+    if (b) {
+      const setA = this.getRelatedKeys(a);
+      return setA?.has(b) ?? false;
+    }
+    return this.relations.has(a);
+  }
+};
+
+// ../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/pretty-print.ts
+var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
+function prettyPrintTokenType(token) {
+  return token.type.split(`_`).map(capitalize).join(` `);
+}
+
+// ../atom.io/internal/src/not-found-error.ts
+var NotFoundError = class extends Error {
+  constructor(...params) {
+    const token = params[0];
+    const store = params.length === 2 ? params[1] : params[2];
+    if (params.length === 2) {
+      super(
+        `${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${store.config.name}".`
+      );
+    } else {
+      const key = params[1];
+      super(
+        `${prettyPrintTokenType(token)} "${token.key}" member ${stringifyJson(key)} not found in store "${store.config.name}".`
+      );
+    }
+  }
+};
+
+// ../atom.io/internal/src/transaction/act-upon-store.ts
+function actUponStore(token, id, store) {
+  return (...parameters) => {
+    const tx = withdraw(token, store);
+    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 = (state, target) => {
+  if (target.valueMap.has(state.key)) {
+    target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
+    return readCachedValue(state, target);
+  }
+  if (state.type === `selector` || state.type === `readonly_selector`) {
+    target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
+    return state.get();
+  }
+  const fallback = state.default instanceof Function ? state.default() : state.default;
+  target.logger.info(
+    `\u{1F481}`,
+    `atom`,
+    state.key,
+    `could not find cached value; using default`,
+    fallback
+  );
+  return state.default instanceof Function ? state.default() : state.default;
+};
+
+// ../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 = (state, update, store) => {
+  switch (state.type) {
+    case `mutable_atom`:
+      store.logger.info(
+        `\u{1F4E2}`,
+        state.type,
+        state.key,
+        `is now (`,
+        update.newValue,
+        `) subscribers:`,
+        state.subject.subscribers
+      );
+      break;
+    default:
+      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 = (atom2, store) => {
+  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/stow-update.ts
+function shouldUpdateBeStowed(key, update) {
+  if (isTransceiver(update.newValue)) {
+    return false;
+  }
+  if (key.includes(`\u{1F50D}`)) {
+    return false;
+  }
+  return true;
+}
+var stowUpdate = (state, update, store) => {
+  const { key } = state;
+  const target = newest(store);
+  if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
+    store.logger.error(
+      `\u{1F41E}`,
+      `atom`,
+      key,
+      `stowUpdate called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  const shouldStow = shouldUpdateBeStowed(key, update);
+  if (!shouldStow) {
+    return;
+  }
+  const atomUpdate = {
+    type: `atom_update`,
+    key,
+    ...update
+  };
+  if (state.family) {
+    atomUpdate.family = state.family;
+  }
+  target.transactionMeta.update.updates.push(atomUpdate);
+  store.logger.info(
+    `\u{1F4C1}`,
+    `atom`,
+    key,
+    `stowed (`,
+    update.oldValue,
+    `->`,
+    update.newValue,
+    `)`
+  );
+};
+
+// ../atom.io/internal/src/set-state/set-atom.ts
+var setAtom = (atom2, next, target) => {
+  const oldValue = readOrComputeValue(atom2, target);
+  let newValue = oldValue;
+  if (atom2.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(atom2, parent, target);
+    newValue = copiedValue;
+  }
+  newValue = become(next)(newValue);
+  target.logger.info(`\u{1F4DD}`, `atom`, atom2.key, `set to`, newValue);
+  newValue = cacheValue(atom2.key, newValue, atom2.subject, target);
+  if (isAtomDefault(atom2.key, target)) {
+    markAtomAsNotDefault(atom2.key, target);
+  }
+  markDone(target, atom2.key);
+  evictDownStream(atom2, target);
+  const update = { oldValue, newValue };
+  if (isRootStore(target)) {
+    emitUpdate(atom2, update, target);
+  } else if (target.parent) {
+    if (target.on.transactionApplying.state === null) {
+      stowUpdate(atom2, update, target);
+    } 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(mutableAtom, parent, target);
+        transceiver = copiedValue;
+      }
+      const accepted = transceiver.do(update.newValue) === null;
+      if (accepted) evictDownStream(mutableAtom, target);
+    }
+  }
+};
+
+// ../atom.io/internal/src/set-state/set-atom-or-selector.ts
+var setAtomOrSelector = (state, value, store) => {
+  switch (state.type) {
+    case `atom`:
+    case `mutable_atom`:
+      setAtom(state, value, store);
+      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(token, store);
+  setAtomOrSelector(state, value, store);
+  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/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/set-epoch-number.ts
+function setEpochNumberOfAction(transactionKey, newEpoch, store) {
+  const isRoot = isRootStore(store);
+  if (!isRoot) {
+    return;
+  }
+  const continuityKey = store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+  if (continuityKey !== undefined) {
+    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(
+      child.transactionMeta.update.key,
+      child.transactionMeta.update.epoch,
+      parent
+    );
+    const myTransaction = withdraw(
+      { key: child.transactionMeta.update.key, type: `transaction` },
+      store
+    );
+    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(family, store).default(subKey);
+        store.defaults.set(family.key, defaultValue);
+        return defaultValue;
+      }
+    }
+  }
+  return readOrComputeValue(withdraw(token, store), store);
+}
+
+// ../atom.io/internal/src/lazy-map.ts
+var LazyMap = class extends Map {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+  deleted = /* @__PURE__ */ new Set();
+  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 undefined;
+  }
+  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 = (key, params, store, 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(key, store);
+  const transactionMeta = {
+    phase: `building`,
+    update: {
+      type: `transaction_update`,
+      key,
+      id,
+      epoch: epoch === undefined ? Number.NaN : epoch + 1,
+      updates: [],
+      params,
+      output: undefined
+    },
+    toolkit: {
+      get: (...ps) => getFromStore(child, ...ps),
+      set: (...ps) => {
+        setIntoStore(child, ...ps);
+      },
+      run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
+      find: (token, k) => findInStore(child, token, k),
+      seek: (token, k) => seekInStore(child, token, k),
+      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(options, store) {
+  const newTransaction = {
+    key: options.key,
+    type: `transaction`,
+    run: (params, id) => {
+      const childStore = buildTransaction(options.key, params, store, 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(options, s),
+    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/internal/src/transaction/get-epoch-number.ts
+function getEpochNumberOfAction(transactionKey, store) {
+  const isRoot = isRootStore(store);
+  const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : undefined;
+  const epoch = isRoot && continuity !== undefined ? store.transactionMeta.epoch.get(continuity) : undefined;
+  return epoch;
+}
+
+// ../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) => !key.includes(`\u{1F50D}`))
+  ];
+  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() {
+    if (!globalThis.ATOM_IO_IMPLICIT_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(token, store) {
+  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 === undefined) {
+    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(token, store);
+  } 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}".`
+      // disposal
+      // 	? `\n   This state was most recently disposed\n${disposal.trace}`
+      // 	: `No previous disposal trace was found.`,
+    );
+    return;
+  }
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      disposeAtom(token, store);
+      break;
+    case `selector`:
+    case `readonly_selector`:
+      disposeSelector(token, store);
+      break;
+  }
+}
+
+// ../atom.io/internal/src/keys.ts
+var isAtomKey = (key, store) => newest(store).atoms.has(key);
+var isSelectorKey = (key, store) => newest(store).selectors.has(key);
+var isReadonlySelectorKey = (key, store) => newest(store).readonlySelectors.has(key);
+var isStateKey = (key, store) => isAtomKey(key, store) || isSelectorKey(key, store) || isReadonlySelectorKey(key, store);
+
+// ../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(source, store));
+  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(indirectDependencyKey, store)) {
+      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(depKey, store) ? 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(dependency, store);
+    const dependencyValue = readOrComputeValue(dependencyState, store);
+    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];
+      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(store, family, key) : seekInStore(store, family, key);
+      if (!maybeToken) {
+        throw new NotFoundError(family, key, store);
+      }
+      token = maybeToken;
+    }
+    const target = newest(store);
+    const state = withdraw(token, target);
+    setAtomOrSelector(state, value, target);
+  },
+  find: (token, key) => findInStore(store, token, key),
+  seek: (token, key) => seekInStore(store, token, key),
+  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, seek, json } = registerSelector(
+    options.key,
+    covered,
+    target
+  );
+  const getSelf = () => {
+    const value = options.get({ get, find, seek, json });
+    cacheValue(options.key, value, subject, newest(store));
+    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, seek, json } = setterToolkit;
+  const getterToolkit = { find, get, seek, json };
+  const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
+    const value = getFn(getterToolkit);
+    cacheValue(options.key, value, subject, innerTarget);
+    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(options.key, newValue, subject, innerTarget);
+    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, undefined);
+    store.on.selectorCreation.next(state2);
+    return state2;
+  }
+  const state = createReadonlySelector(store, options, undefined);
+  store.on.selectorCreation.next(state);
+  return state;
+}
+
+// ../atom.io/internal/src/selector/dispose-selector.ts
+function disposeSelector(selectorToken, store) {
+  const target = newest(store);
+  const { key } = selectorToken;
+  const selector = withdraw(selectorToken, target);
+  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);
+    }
+    switch (selectorToken.type) {
+      case `selector`:
+        {
+          target.selectors.delete(key);
+          withdraw(
+            { key: selector.family.key, type: `selector_family` },
+            store
+          );
+        }
+        break;
+      case `readonly_selector`:
+        {
+          target.readonlySelectors.delete(key);
+          const family = withdraw(
+            { key: selector.family.key, type: `readonly_selector_family` },
+            store
+          );
+          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: (...ps) => getFromStore(store, ...ps),
+        find: (token, k) => findInStore(store, token, k),
+        seek: (token, k) => seekInStore(store, token, k),
+        json: (token) => getJsonToken(store, token)
+      });
+    }
+  });
+  store.families.set(options.key, selectorFamily2);
+  return familyToken;
+}
+
+// ../atom.io/json/src/select-json-family.ts
+function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
+  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`]
+  );
+  const atomFamily2 = withdraw(atomFamilyToken, store);
+  atomFamily2.subject.subscribe(
+    `store=${store.config.name}::json-selector-family`,
+    (event) => {
+      if (event.token.family) {
+        seekInStore(store, jsonFamily, parseJson(event.token.family.subKey));
+      }
+    }
+  );
+  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 = (state, store) => {
+  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 = (selector, store) => {
+  const target = newest(store);
+  const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
+    (atomKey) => {
+      const atom2 = target.atoms.get(atomKey);
+      if (atom2 === undefined) {
+        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(selector, target);
+          const newValue = readOrComputeValue(selector, target);
+          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(token, handleUpdate, key, store) {
+  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(token, store);
+  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(state, store);
+    updateHandler = (update) => {
+      if (dependencyUnsubFunctions) {
+        dependencyUnsubFunctions.length = 0;
+        dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
+      }
+      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 = (token, handleUpdate, key, store) => {
+  const tl = withdraw(token, store);
+  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
+    } : undefined;
+    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(
+      mutableState,
+      (update) => {
+        if (update.newValue !== update.oldValue) {
+          this.unsubscribeFromInnerValue();
+          this.unsubscribeFromInnerValue = update.newValue.subscribe(
+            subscriptionKey,
+            (transceiverUpdate) => {
+              setIntoStore(target, latestUpdateState, transceiverUpdate);
+            }
+          );
+        }
+      },
+      subscriptionKey,
+      target
+    );
+  }
+  updateCore(mutableState, latestUpdateState, target) {
+    const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
+    subscribeToState(
+      latestUpdateState,
+      ({ newValue, oldValue }) => {
+        const timelineId = target.timelineTopics.getRelatedKey(
+          latestUpdateState.key
+        );
+        if (timelineId) {
+          const timelineData = target.timelines.get(timelineId);
+          if (timelineData?.timeTraveling) {
+            const unsubscribe2 = subscribeToTimeline(
+              { key: timelineId, type: `timeline` },
+              (update) => {
+                unsubscribe2();
+                setIntoStore(target, mutableState, (transceiver) => {
+                  if (update === `redo` && newValue) {
+                    transceiver.do(newValue);
+                  } else if (update === `undo` && oldValue) {
+                    transceiver.undo(oldValue);
+                  }
+                  return transceiver;
+                });
+              },
+              subscriptionKey,
+              target
+            );
+            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}`
+              );
+            }
+          }
+        );
+      },
+      subscriptionKey,
+      target
+    );
+  }
+  mutableState;
+  latestUpdateState;
+  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.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(options.key, store);
+  cacheValue(options.key, initialValue, subject, target);
+  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(token, handle, `effect[${effectIndex}]`, store)
+      });
+      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 {
+  Update;
+  latestUpdateAtoms;
+  mutableAtoms;
+  constructor(mutableAtoms, store) {
+    const updateAtoms = createRegularAtomFamily(
+      store,
+      {
+        key: `*${mutableAtoms.key}`,
+        default: null
+      },
+      [`mutable`, `updates`]
+    );
+    this.latestUpdateAtoms = withdraw(updateAtoms, store);
+    this.mutableAtoms = mutableAtoms;
+    this.mutableAtoms.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (event) => {
+        if (event.token.family) {
+          const key = parseJson(event.token.family.subKey);
+          seekInStore(store, this.latestUpdateAtoms, key);
+          new Tracker(event.token, store);
+        }
+      }
+    );
+    this.latestUpdateAtoms.subject.subscribe(
+      `store=${store.config.name}::tracker-atom-family`,
+      (event) => {
+        if (event.token.family) {
+          const key = parseJson(event.token.family.subKey);
+          const mutableAtomToken = seekInStore(store, this.mutableAtoms, key);
+          if (mutableAtomToken) {
+            new Tracker(mutableAtomToken, store);
+          }
+        }
+      }
+    );
+  }
+};
+
+// ../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(atomFamily2, options, store);
+  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(jsonFamilyToken, target);
+    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(atom2, origin, target) {
+  const originValue = origin.valueMap.get(atom2.key);
+  const targetValue = target.valueMap.get(atom2.key);
+  if (originValue === targetValue) {
+    if (originValue === undefined) {
+      return typeof atom2.default === `function` ? atom2.default() : 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;
+  }
+  return targetValue;
+}
+
+// ../atom.io/internal/src/caching.ts
+function cacheValue(key, value, subject, target) {
+  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(key, resolved, subject, target);
+      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(token, parent, target);
+    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 = (key, store) => {
+  const core = newest(store);
+  return core.atomsThatAreDefault.has(key);
+};
+var markAtomAsDefault = (key, store) => {
+  const core = newest(store);
+  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
+};
+var markAtomAsNotDefault = (key, store) => {
+  const core = newest(store);
+  core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
+  core.atomsThatAreDefault.delete(key);
+};
+
+// ../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(options.key, store);
+  cacheValue(options.key, initialValue, subject, target);
+  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(token, handle, `effect[${effectIndex}]`, store)
+      });
+      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, undefined);
+    store.on.atomCreation.next(state2);
+    return state2;
+  }
+  const state = createRegularAtom(store, options, undefined);
+  store.on.atomCreation.next(state);
+  return state;
+}
+
+// ../atom.io/internal/src/atom/dispose-atom.ts
+function disposeAtom(atomToken, store) {
+  const target = newest(store);
+  const { key, family } = atomToken;
+  const atom2 = withdraw(atomToken, target);
+  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({ key: family.key, type: `atom_family` }, store);
+    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(updateToken, store);
+      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/internal/src/get-trace.ts
+function getTrace(error) {
+  const { stack } = error;
+  if (stack) {
+    return `
+` + stack.split(`
+`)?.slice(1)?.join(`
+`);
+  }
+  return ``;
+}
+
+// ../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 === undefined) {
+    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 === undefined) {
+        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 === undefined) {
+        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/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.error(`Failed to apply transaction to SetRTX:`, 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/data/src/join.ts
+function capitalize2(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+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),
+      seek: (...ps) => seekInStore(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 : undefined;
+            let b = a === undefined ? x : undefined;
+            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 : undefined;
+            let b = a === undefined ? x : undefined;
+            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${capitalize2(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize2(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: singleRelatedKeySelectors
+        };
+        let states;
+        if (defaultContent) {
+          const singleEntrySelectors = createSingleEntrySelectorFamily();
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize2(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize2(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${capitalize2(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize2(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
+        };
+        let states;
+        if (defaultContent) {
+          const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
+          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize2(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize2(
+            aSide
+          )}`;
+          const contentStates = {
+            [entriesStateKeyA]: singleRelatedEntrySelectors,
+            [entriesStateKeyB]: multipleRelatedEntriesSelectors
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+        break;
+      }
+      default: {
+        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
+        const stateKeyA = `${aSide}KeysOf${capitalize2(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize2(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: multipleRelatedKeysSelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
+        };
+        let states;
+        if (defaultContent) {
+          const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize2(
+            bSide
+          )}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize2(
+            aSide
+          )}`;
+          const contentStates = {
+            [entriesStateKeyA]: multipleRelatedEntriesSelectors,
+            [entriesStateKeyB]: multipleRelatedEntriesSelectors
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+      }
+    }
+  }
+};
+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 getJoin(token, store) {
+  let myJoin = store.joins.get(token.key);
+  if (myJoin === undefined) {
+    const rootJoinMap = IMPLICIT.STORE.joins;
+    const rootJoin = rootJoinMap.get(token.key);
+    if (rootJoin === undefined) {
+      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;
+}
+function editRelationsInStore(token, change, store) {
+  const myJoin = getJoin(token, store);
+  const target = newest(store);
+  if (isChildStore(target)) {
+    const { toolkit } = target.transactionMeta;
+    myJoin.transact(toolkit, ({ relations }) => {
+      change(relations);
+    });
+  } else {
+    change(myJoin.relations);
+  }
+}
+function getInternalRelationsFromStore(token, store) {
+  const myJoin = getJoin(token, store);
+  const family = myJoin.core.relatedKeysAtoms;
+  return family;
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+
+// ../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 {
+  constructor(emit) {
+    this.emit = emit;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.globalListeners = /* @__PURE__ */ new Set();
+  }
+  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`;
+  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;
+      }
+    }
+  }
+  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 {
+  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,
+      undefined,
+      { 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 === undefined) {
+      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`, () => {
+          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) {
+              this.updateAvailabilityChecker?.stop();
+              this.seekUpdate(versionForeignInput);
+              const updatePhase = this.storage.getItem(`updatePhase`);
+              this.logger.info(`> storage("updatePhase") >`, updatePhase);
+              if (updatePhase === `notified`) {
+                this.updateAvailabilityChecker = new CronJob(
+                  `30 * * * * *`,
+                  () => {
+                    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);
+      }
+    });
+  }
+  safety = 0;
+  storage;
+  webhookServer;
+  services;
+  serviceIdx;
+  defaultServicesReadyToUpdate;
+  servicesReadyToUpdate;
+  autoRespawnDeadServices;
+  logger;
+  serviceLoggers;
+  updateAvailabilityChecker = null;
+  servicesLive;
+  servicesDead;
+  live = new Future(() => {
+  });
+  dead = new Future(() => {
+  });
+  restartTimes = [];
+  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());
+      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-XIZZKICH.js.map
+//# sourceMappingURL=chunk-XIZZKICH.js.map