tempest.games 0.2.67 → 0.2.69

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

@@ -1,21 +1,3940 @@
 #!/usr/bin/env bun
 // @bun
-var SQ=Object.create;var{getPrototypeOf:vQ,defineProperty:B0,getOwnPropertyNames:TQ}=Object;var gQ=Object.prototype.hasOwnProperty;var MZ=(Q,Z,q)=>{q=Q!=null?SQ(vQ(Q)):{};let z=Z||!Q||!Q.__esModule?B0(q,"default",{value:Q,enumerable:!0}):q;for(let H of TQ(Q))if(!gQ.call(z,H))B0(z,H,{get:()=>Q[H],enumerable:!0});return z};var RZ=(Q,Z)=>()=>(Z||Q((Z={exports:{}}).exports,Z),Z.exports);var FZ=(Q,Z)=>{for(var q in Z)B0(Q,q,{get:Z[q],enumerable:!0,configurable:!0,set:(z)=>Z[q]=()=>z})};var UZ=(Q,Z)=>()=>(Q&&(Z=Q(Q=0)),Z);var xZ=import.meta.require;function m(Q){return _0(A.STORE,Q,void 0)}function c(Q){return G0(A.STORE,Q)}function IZ(...Q){return I(A.STORE,...Q)}function H0(Q){return HQ(A.STORE,Q)}function o0(Q){return XQ(Q,A.STORE)}var S={atom_family:"atom family",atom:"atom",continuity:"continuity",key:"key",mutable_atom_family:"atom family [m]",mutable_atom:"atom [m]",readonly_held_selector_family:"selector family [h]",readonly_held_selector:"selector [h]",readonly_pure_selector_family:"selector family",readonly_pure_selector:"selector",state:"state",timeline:"timeline",transaction:"transaction",unknown:"unknown",writable_held_selector_family:"selector family [wh]",writable_held_selector:"selector [wh]",writable_pure_selector_family:"selector family [w]",writable_pure_selector:"selector [w]"};var h0=(Q)=>(Z,q,z,H,...X)=>{console[Q](`${Z} ${S[q]} \`${z}\` ${H}`,...X)},bQ={error:h0("error"),info:h0("info"),warn:h0("warn")},t0=class{logLevel;filter;logger;constructor(Q,Z,q=bQ){this.logLevel=Q,this.filter=Z,this.logger=q}error=(...Q)=>{if(this.logLevel!==null){let Z=this.filter?.(...Q)??!0;if(Z===!0)this.logger.error(...Q);else if(Z)this.logger.error(...Z)}};info=(...Q)=>{if(this.logLevel==="info"){let Z=this.filter?.(...Q)??!0;if(Z===!0)this.logger.info(...Q);else if(Z)this.logger.info(...Z)}};warn=(...Q)=>{if(this.logLevel!=="error"&&this.logLevel!==null){let Z=this.filter?.(...Q)??!0;if(Z===!0)this.logger.warn(...Q);else if(Z)this.logger.warn(...Z)}}};function a(Q,Z){return[Q,Z].sort().join("\x1F")}function e0(Q){if(typeof Q==="string"===!1)return null;let[Z,q]=Q.split("==");if(!q)return null;let z=Z.slice(4),[H,X]=q.split("++");if(z&&H&&X)return[z,H,X];return null}function X0(Q){return qQ(A.STORE,Q)}function Y0(Q){return M0(A.STORE,Q)}function R(Q){return JSON.parse(Q)}var h=(Q)=>JSON.stringify(Q),yZ=[Array.prototype,Boolean.prototype,Number.prototype,Object.prototype,String.prototype];function YQ(Q){let Z={},q=0;for(let z of Q)Z[z]=q,Z[q]=z,++q;return Z}var GQ="\x01",WQ="\x02",_Q="\x03",NQ="\x04",F0=(Q)=>{switch(typeof Q){case"string":return _Q+Q;case"number":return NQ+Q;case"boolean":return GQ+ +Q;case"object":return WQ}},U0=(Q)=>{switch(Q[0]){case _Q:return Q.slice(1);case NQ:return+Q.slice(1);case GQ:return Q.slice(1)==="1";case WQ:return null}};var jQ=YQ(["add","delete","clear"]),v=class Q extends Set{mode="record";subject=new E;constructor(Z){super(Z);if(Z instanceof Q);}READONLY_VIEW=this;toJSON(){return[...this]}static fromJSON(Z){return new Q(Z)}add(Z){let q=super.add(Z);if(this.mode==="record")this.emit({type:"add",value:Z});return q}clear(){let Z=this.mode==="record"?[...this]:null;if(super.clear(),Z)this.emit({type:"clear",values:Z})}delete(Z){let q=super.delete(Z);if(this.mode==="record")this.emit({type:"delete",value:Z});return q}subscribe(Z,q){return this.subject.subscribe(Z,q)}emit(Z){this.subject.next(Q.packUpdate(Z))}do(Z){this.mode="playback";let q=Q.unpackUpdate(Z);switch(q.type){case"add":this.add(q.value);break;case"delete":this.delete(q.value);break;case"clear":this.clear()}return this.mode="record",null}undo(Z){let q=Q.unpackUpdate(Z);switch(this.mode="playback",q.type){case"add":this.delete(q.value);break;case"delete":this.add(q.value);break;case"clear":{let z=q.values;for(let H of z)this.add(H)}}return this.mode="record",null}static packUpdate(Z){let q=jQ[Z.type]+"\x1F";if(Z.type==="clear")return q+Z.values.map(F0).join("\x1E");return q+F0(Z.value)}static unpackUpdate(Z){let[q,z]=Z.split("\x1F"),H=jQ[q];if(H==="clear")return{type:"clear",values:z.split("\x1E").map(U0)};return{type:H,value:U0(z)}}};function QQ(Q=Math.random){return Q().toString(36).slice(2)}function C(Q){while(Q.child!==null)Q=Q.child;return Q}function v0(Q){while(Q.parent!==null)Q=Q.parent;return Q}var yQ=/^\[object (?:Async|Generator|AsyncGenerator)?Function\]$/;function s(Q){let Z=Object.prototype.toString.call(Q);return yQ.test(Z)}function A0(Q,Z){if(s(Q))return Q(Z);return Q}var I0=class extends Promise{fate;resolve;reject;done=!1;constructor(Q){let Z,q;super((z,H)=>{Z=z,q=H});this.resolve=Z,this.reject=q,this.use(Q instanceof Promise?Q:new Promise(Q))}pass(Q,Z){if(Q===this.fate)this.resolve(Z),this.done=!0}fail(Q,Z){if(Q===this.fate)this.reject(Z),this.done=!0}use(Q){if(this===Q)return;if(Q instanceof Promise){let Z=Q;this.fate=Z,Z.then((q)=>{this.pass(Z,q)},(q)=>{this.fail(Z,q)})}else this.resolve(Q),this.fate=void 0}},E=class{Subscriber;subscribers=new Map;subscribe(Q,Z){return this.subscribers.set(Q,Z),()=>{this.unsubscribe(Q)}}unsubscribe(Q){this.subscribers.delete(Q)}next(Q){let Z=this.subscribers.values();for(let q of Z)q(Q)}},pQ=class extends E{state;constructor(Q){super();this.state=Q}next(Q){this.state=Q,super.next(Q)}},mQ=class Q{_buffer;_index=0;constructor(Z){let q;if(typeof Z==="number")q=Z;else q=Z.length;this._buffer=Array.from({length:q})}get buffer(){return this._buffer}get index(){return this._index}add(Z){this._buffer[this._index]=Z,this._index=(this._index+1)%this._buffer.length}copy(){let Z=new Q([...this._buffer]);return Z._index=this._index,Z}};function b(Q){let Z={key:Q.key,type:Q.type};if("family"in Q)Z.family=Q.family;return Z}var K=class extends Map{deleted=new Set;changed=new Set;source;constructor(Q){super();this.source=Q}get(Q){if(super.has(Q))return super.get(Q);if(!this.deleted.has(Q)&&this.source.has(Q))return this.source.get(Q)}set(Q,Z){if(this.deleted.delete(Q),this.source.has(Q))this.changed.add(Q);return super.set(Q,Z)}hasOwn(Q){return super.has(Q)}has(Q){return!this.deleted.has(Q)&&(super.has(Q)||this.source.has(Q))}delete(Q){if(this.source.has(Q))this.deleted.add(Q),this.changed.delete(Q);return super.delete(Q)}clear(){this.deleted=new Set(this.source.keys()),this.changed.clear(),super.clear()}*[Symbol.iterator](){yield*super[Symbol.iterator]();for(let[Q,Z]of this.source)if(!this.deleted.has(Q)&&!this.changed.has(Q))yield[Q,Z]}*entries(){yield*this[Symbol.iterator]()}*keys(){yield*super.keys();for(let Q of this.source.keys())if(!this.deleted.has(Q)&&!this.changed.has(Q))yield Q}*values(){for(let[,Q]of this[Symbol.iterator]())yield Q}forEach(Q){for(let[Z,q]of this[Symbol.iterator]())Q(q,Z,this)}get size(){return super.size+this.source.size-this.changed.size-this.deleted.size}},VQ=class extends Set{deleted=new Set;source;constructor(Q){super();this.source=Q}add(Q){if(this.source.has(Q))return this.deleted.delete(Q),this;return super.add(Q)}hasOwn(Q){return super.has(Q)}has(Q){return!this.deleted.has(Q)&&(super.has(Q)||this.source.has(Q))}delete(Q){if(this.source.has(Q))return this.deleted.add(Q),!0;return super.delete(Q)}clear(){this.deleted=new Set(this.source),super.clear()}*[Symbol.iterator](){yield*super[Symbol.iterator]();for(let Q of this.source)if(!this.deleted.has(Q))yield Q}*iterateOwn(){yield*super[Symbol.iterator]()}get size(){return super.size+this.source.size-this.deleted.size}},cQ=class extends Map{deleted=new Set;source;constructor(Q){super();this.source=Q}get(Q){if(super.has(Q))return super.get(Q);if(!this.deleted.has(Q)&&this.source.has(Q)){let Z=new VQ(this.source.get(Q));return super.set(Q,Z),Z}}set(Q,Z){return this.deleted.delete(Q),super.set(Q,Z)}has(Q){return!this.deleted.has(Q)&&(super.has(Q)||this.source.has(Q))}delete(Q){return this.deleted.add(Q),super.delete(Q)}},T=class Q{a;b;cardinality;relations=new Map;contents=new Map;isAType;isBType;isContent;makeContentKey=(Z,q)=>`${Z}:${q}`;warn;getRelatedKeys(Z){return this.relations.get(Z)}addRelation(Z,q){let z=this.relations.get(Z),H=this.relations.get(q);if(z)z.add(q);else z=new Set([q]),this.relations.set(Z,z);if(H)H.add(Z);else H=new Set([Z]),this.relations.set(q,H)}deleteRelation(Z,q){let z=this.relations.get(Z);if(z){if(z.delete(q),z.size===0)this.relations.delete(Z);let H=this.relations.get(q);if(H){if(H.delete(Z),H.size===0)this.relations.delete(q)}}}replaceRelationsUnsafely(Z,q){this.relations.set(Z,new Set(q));for(let z of q){let H=new Set().add(Z);this.relations.set(z,H)}}replaceRelationsSafely(Z,q){let z=this.relations.get(Z),H=this.isAType?.(Z)?Z:void 0,X=H===void 0?Z:void 0;if(z)for(let Y of z){H??=Y,X??=Y;let G=this.relations.get(Y);if(G){if(G.size===1)this.relations.delete(Y);else G.delete(Z);this.contents.delete(this.makeContentKey(H,X))}}this.relations.set(Z,new Set(q));for(let Y of q){let G=this.relations.get(Y);if(G)G.add(Z);else G=new Set().add(Z),this.relations.set(Y,G)}}getContentInternal(Z){return this.contents.get(Z)}setContent(Z,q){this.contents.set(Z,q)}deleteContent(Z){this.contents.delete(Z)}constructor(Z,q){if(this.a=Z.between[0],this.b=Z.between[1],this.cardinality=Z.cardinality,this.isAType=q?.isAType??null,this.isBType=q?.isBType??null,this.isContent=q?.isContent??null,q?.makeContentKey)this.makeContentKey=q.makeContentKey;if(!q?.externalStore){let z=q?.source;if(z===void 0)this.relations=new Map(Z.relations?.map(([H,X])=>[H,new Set(X)])),this.contents=new Map(Z.contents);if(z)this.relations=new cQ(z.relations),this.contents=new K(z.contents)}if(q?.externalStore){let z=q.externalStore;if(this.has=(H,X)=>z.has(H,X),this.addRelation=(H,X)=>{z.addRelation(H,X)},this.deleteRelation=(H,X)=>{z.deleteRelation(H,X)},this.replaceRelationsSafely=(H,X)=>{z.replaceRelationsSafely(H,X)},this.replaceRelationsUnsafely=(H,X)=>{z.replaceRelationsUnsafely(H,X)},this.getRelatedKeys=(H)=>z.getRelatedKeys(H),z.getContent)this.getContentInternal=(H)=>{return z.getContent(H)},this.setContent=(H,X)=>{z.setContent(H,X)},this.deleteContent=(H)=>{z.deleteContent(H)};for(let[H,X]of Z.relations??[]){let Y=this.isAType?.(H)?H:void 0,G=Y===void 0?H:void 0;for(let N of X)Y??=N,G??=N,this.addRelation(Y,G)}for(let[H,X]of Z.contents??[])this.setContent(H,X)}if(q?.warn)this.warn=q.warn}toJSON(){return{between:[this.a,this.b],cardinality:this.cardinality,relations:[...this.relations.entries()].map(([Z,q])=>[Z,[...q]]),contents:[...this.contents.entries()]}}set(...Z){let q,z,H;switch(Z.length){case 1:{let X=Z[0];q=X[this.a],z=X[this.b],H=void 0;break}case 2:{let X=Z[0];if(typeof X==="string")[q,z]=Z;else q=X[this.a],z=X[this.b],H=Z[1];break}default:q=Z[0],z=Z[1],H=Z[2];break}switch(this.cardinality){case"1:1":{let X=this.getRelatedKey(q);if(X&&X!==z)this.delete(q,X)}case"1:n":{let X=this.getRelatedKey(z);if(X&&X!==q)this.delete(X,z)}break;case"n:n":}if(H){let X=this.makeContentKey(q,z);this.setContent(X,H)}return this.addRelation(q,z),this}delete(Z,q){q=typeof q==="string"?q:Z[this.b];let z=typeof Z==="string"?Z:Z[this.a];if(z===void 0&&typeof q==="string"){let H=this.getRelatedKeys(q);if(H)for(let X of H)this.delete(X,q)}else if(typeof z==="string"&&q===void 0){let H=this.getRelatedKeys(z);if(H)for(let X of H)this.delete(z,X)}else if(typeof z==="string"&&typeof q==="string"){this.deleteRelation(z,q);let H=this.makeContentKey(z,q);this.deleteContent(H)}return this}getRelatedKey(Z){let q=this.getRelatedKeys(Z);if(q){if(q.size>1)this.warn?.(`${q.size} related keys were found for key "${Z}": (${[...q].map((H)=>`"${H}"`).join(", ")}). Only one related key was expected.`);let z;for(let H of q){z=H;break}return z}}replaceRelations(Z,q,z){let H=!Array.isArray(q),X=H?Object.keys(q):q;if(z?.reckless)this.replaceRelationsUnsafely(Z,X);else this.replaceRelationsSafely(Z,X);if(H)for(let Y of X){let G=this.makeContentKey(Z,Y),N=q[Y];this.setContent(G,N)}return this}getContent(Z,q){let z=this.makeContentKey(Z,q);return this.getContentInternal(z)}getRelationEntries(Z){let q=Z[this.a],z=Z[this.b];if(q!==void 0&&z===void 0){let H=this.getRelatedKeys(q);if(H)return[...H].map((X)=>{return[X,this.getContent(q,X)]})}if(q===void 0&&z!==void 0){let H=this.getRelatedKeys(z);if(H)return[...H].map((X)=>{return[X,this.getContent(X,z)]})}return[]}has(Z,q){if(q)return this.getRelatedKeys(Z)?.has(q)??!1;return this.relations.has(Z)}overlay(){let Z={source:this,makeContentKey:this.makeContentKey};if(this.isAType)Z.isAType=this.isAType;if(this.isBType)Z.isBType=this.isBType;if(this.isContent)Z.isContent=this.isContent;if(this.warn)Z.warn=this.warn;return new Q({between:[this.a,this.b],cardinality:this.cardinality},Z)}incorporate(Z){let{relations:q,contents:z}=Z;for(let[H,X]of q)if(X instanceof VQ){let{source:Y}=X;for(let G of X.iterateOwn())Y.add(G)}else this.relations.set(H,X);for(let H of q.deleted)this.relations.delete(H);for(let[H,X]of z)this.contents.set(H,X);for(let H of z.deleted)this.contents.delete(H)}};function uQ(Q){return Q.startsWith("\uD83D\uDD0D ")}var lQ=(Q)=>{Q.logger.info("\uD83E\uDE82","transaction",Q.transactionMeta.update.token.key,"Aborting transaction"),Q.parent.child=null};function L0(Q,Z,q){return(...z)=>{return B(Q,Z).run(z,q)}}function iQ(Q,Z,q){let{token:z,update:{newValue:H,oldValue:X}}=Z;f(Q,z,q==="newValue"?H:X)}function aQ(Q){let{stack:Z}=Q;if(Z)return`
-`+Z.split(`
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// ../../packages/atom.io/dist/main/index.js
+function mutableAtom(options) {
+  return createMutableAtom(IMPLICIT.STORE, options, undefined);
+}
+function atomFamily(options) {
+  return createRegularAtomFamily(IMPLICIT.STORE, options);
+}
+function getState(...params) {
+  return getFromStore(IMPLICIT.STORE, ...params);
+}
+function join(options) {
+  return createJoin(IMPLICIT.STORE, options);
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+var PRETTY_TOKEN_TYPES = {
+  atom_family: `atom family`,
+  atom: `atom`,
+  continuity: `continuity`,
+  key: `key`,
+  mutable_atom_family: `atom family [m]`,
+  mutable_atom: `atom [m]`,
+  readonly_held_selector_family: `selector family [h]`,
+  readonly_held_selector: `selector [h]`,
+  readonly_pure_selector_family: `selector family`,
+  readonly_pure_selector: `selector`,
+  state: `state`,
+  timeline: `timeline`,
+  transaction: `transaction`,
+  unknown: `unknown`,
+  writable_held_selector_family: `selector family [wh]`,
+  writable_held_selector: `selector [wh]`,
+  writable_pure_selector_family: `selector family [w]`,
+  writable_pure_selector: `selector [w]`
+};
+var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
+  console[logLevel](`${icon} ${PRETTY_TOKEN_TYPES[denomination]} \`${tokenKey}\` ${message}`, ...rest);
+};
+var simpleLogger = {
+  error: simpleLog(`error`),
+  info: simpleLog(`info`),
+  warn: simpleLog(`warn`)
+};
+var AtomIOLogger = class {
+  logLevel;
+  filter;
+  logger;
+  constructor(logLevel, filter, logger = simpleLogger) {
+    this.logLevel = logLevel;
+    this.filter = filter;
+    this.logger = logger;
+  }
+  error = (...args) => {
+    if (this.logLevel !== null) {
+      const filterResult = this.filter?.(...args) ?? true;
+      if (filterResult === true)
+        this.logger.error(...args);
+      else if (filterResult)
+        this.logger.error(...filterResult);
+    }
+  };
+  info = (...args) => {
+    if (this.logLevel === `info`) {
+      const filterResult = this.filter?.(...args) ?? true;
+      if (filterResult === true)
+        this.logger.info(...args);
+      else if (filterResult)
+        this.logger.info(...filterResult);
+    }
+  };
+  warn = (...args) => {
+    if (this.logLevel !== `error` && this.logLevel !== null) {
+      const filterResult = this.filter?.(...args) ?? true;
+      if (filterResult === true)
+        this.logger.warn(...args);
+      else if (filterResult)
+        this.logger.warn(...filterResult);
+    }
+  };
+};
+var $validatedKey = Symbol.for(`claim`);
+function simpleCompound(a, b) {
+  return [a, b].sort().join(`\x1F`);
+}
+function decomposeCompound(compound) {
+  if (typeof compound === `string` === false)
+    return null;
+  const [typeTag, components] = compound.split(`==`);
+  if (!components)
+    return null;
+  const type = typeTag.slice(4);
+  const [a, b] = components.split(`++`);
+  if (type && a && b)
+    return [
+      type,
+      a,
+      b
+    ];
+  return null;
+}
+function selectorFamily(options) {
+  return createSelectorFamily(IMPLICIT.STORE, options);
+}
+function transaction(options) {
+  return createTransaction(IMPLICIT.STORE, options);
+}
+
+// ../../packages/atom.io/dist/json/index.js
+function parseJson(str) {
+  return JSON.parse(str);
+}
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_PROTOTYPES = [
+  Array.prototype,
+  Boolean.prototype,
+  Number.prototype,
+  Object.prototype,
+  String.prototype
+];
+
+// ../../packages/atom.io/dist/struct/index.js
+function enumeration(values) {
+  const result = {};
+  let i = 0;
+  for (const value of values) {
+    result[value] = i;
+    result[i] = value;
+    ++i;
+  }
+  return result;
+}
+var BOOL = `\x01`;
+var NULL = `\x02`;
+var STRING = `\x03`;
+var NUMBER = `\x04`;
+var packValue = (value) => {
+  switch (typeof value) {
+    case `string`:
+      return STRING + value;
+    case `number`:
+      return NUMBER + value;
+    case `boolean`:
+      return BOOL + +value;
+    case `object`:
+      return NULL;
+  }
+};
+var unpackValue = (value) => {
+  switch (value[0]) {
+    case STRING:
+      return value.slice(1);
+    case NUMBER:
+      return +value.slice(1);
+    case BOOL:
+      return value.slice(1) === `1`;
+    case NULL:
+      return null;
+  }
+};
+
+// ../../packages/atom.io/dist/transceivers/u-list/index.js
+var SET_UPDATE_ENUM = enumeration([
+  `add`,
+  `delete`,
+  `clear`
+]);
+var UList = class UList2 extends Set {
+  mode = `record`;
+  subject = new Subject;
+  constructor(values) {
+    super(values);
+    if (values instanceof UList2) {}
+  }
+  READONLY_VIEW = this;
+  toJSON() {
+    return [...this];
+  }
+  static fromJSON(json) {
+    return new UList2(json);
+  }
+  add(value) {
+    const result = super.add(value);
+    if (this.mode === `record`)
+      this.emit({
+        type: `add`,
+        value
+      });
+    return result;
+  }
+  clear() {
+    const capturedContents = this.mode === `record` ? [...this] : null;
+    super.clear();
+    if (capturedContents)
+      this.emit({
+        type: `clear`,
+        values: capturedContents
+      });
+  }
+  delete(value) {
+    const result = super.delete(value);
+    if (this.mode === `record`)
+      this.emit({
+        type: `delete`,
+        value
+      });
+    return result;
+  }
+  subscribe(key, fn) {
+    return this.subject.subscribe(key, fn);
+  }
+  emit(update) {
+    this.subject.next(UList2.packUpdate(update));
+  }
+  do(packed) {
+    this.mode = `playback`;
+    const update = UList2.unpackUpdate(packed);
+    switch (update.type) {
+      case `add`:
+        this.add(update.value);
+        break;
+      case `delete`:
+        this.delete(update.value);
+        break;
+      case `clear`:
+        this.clear();
+    }
+    this.mode = `record`;
+    return null;
+  }
+  undo(packed) {
+    const update = UList2.unpackUpdate(packed);
+    this.mode = `playback`;
+    switch (update.type) {
+      case `add`:
+        this.delete(update.value);
+        break;
+      case `delete`:
+        this.add(update.value);
+        break;
+      case `clear`: {
+        const values = update.values;
+        for (const v of values)
+          this.add(v);
+      }
+    }
+    this.mode = `record`;
+    return null;
+  }
+  static packUpdate(update) {
+    const head = SET_UPDATE_ENUM[update.type] + `\x1F`;
+    if (update.type === `clear`)
+      return head + update.values.map(packValue).join(`\x1E`);
+    return head + packValue(update.value);
+  }
+  static unpackUpdate(packed) {
+    const [type, tail] = packed.split(`\x1F`);
+    const head = SET_UPDATE_ENUM[type];
+    if (head === `clear`)
+      return {
+        type: `clear`,
+        values: tail.split(`\x1E`).map(unpackValue)
+      };
+    return {
+      type: head,
+      value: unpackValue(tail)
+    };
+  }
+};
+
+// ../../packages/atom.io/dist/internal/index.js
+function arbitrary(random = Math.random) {
+  return random().toString(36).slice(2);
+}
+function newest(scion) {
+  while (scion.child !== null)
+    scion = scion.child;
+  return scion;
+}
+function eldest(scion) {
+  while (scion.parent !== null)
+    scion = scion.parent;
+  return scion;
+}
+var NON_CTOR_FN_REGEX = /^\[object (?:Async|Generator|AsyncGenerator)?Function\]$/;
+function isFn(input) {
+  const protoString = Object.prototype.toString.call(input);
+  return NON_CTOR_FN_REGEX.test(protoString);
+}
+function become(nextVersionOfThing, originalThing) {
+  if (isFn(nextVersionOfThing))
+    return nextVersionOfThing(originalThing);
+  return nextVersionOfThing;
+}
+var Future = class extends Promise {
+  fate;
+  resolve;
+  reject;
+  done = false;
+  constructor(executor) {
+    let superResolve;
+    let superReject;
+    super((resolve, reject) => {
+      superResolve = resolve;
+      superReject = reject;
+    });
+    this.resolve = superResolve;
+    this.reject = superReject;
+    this.use(executor instanceof Promise ? executor : new Promise(executor));
+  }
+  pass(promise, value) {
+    if (promise === this.fate) {
+      this.resolve(value);
+      this.done = true;
+    }
+  }
+  fail(promise, reason) {
+    if (promise === this.fate) {
+      this.reject(reason);
+      this.done = true;
+    }
+  }
+  use(value) {
+    if (this === value)
+      return;
+    if (value instanceof Promise) {
+      const promise = value;
+      this.fate = promise;
+      promise.then((resolved) => {
+        this.pass(promise, resolved);
+      }, (reason) => {
+        this.fail(promise, reason);
+      });
+    } else {
+      this.resolve(value);
+      this.fate = undefined;
+    }
+  }
+};
+var Subject = class {
+  Subscriber;
+  subscribers = /* @__PURE__ */ new Map;
+  subscribe(key, subscriber) {
+    this.subscribers.set(key, subscriber);
+    const unsubscribe = () => {
+      this.unsubscribe(key);
+    };
+    return unsubscribe;
+  }
+  unsubscribe(key) {
+    this.subscribers.delete(key);
+  }
+  next(value) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers)
+      subscriber(value);
+  }
+};
+var StatefulSubject = class extends Subject {
+  state;
+  constructor(initialState) {
+    super();
+    this.state = initialState;
+  }
+  next(value) {
+    this.state = value;
+    super.next(value);
+  }
+};
+var CircularBuffer = class CircularBuffer2 {
+  _buffer;
+  _index = 0;
+  constructor(lengthOrArray) {
+    let length;
+    if (typeof lengthOrArray === `number`)
+      length = lengthOrArray;
+    else
+      length = lengthOrArray.length;
+    this._buffer = Array.from({ length });
+  }
+  get buffer() {
+    return this._buffer;
+  }
+  get index() {
+    return this._index;
+  }
+  add(item) {
+    this._buffer[this._index] = item;
+    this._index = (this._index + 1) % this._buffer.length;
+  }
+  copy() {
+    const copy = new CircularBuffer2([...this._buffer]);
+    copy._index = this._index;
+    return copy;
+  }
+};
+function deposit(state) {
+  const token = {
+    key: state.key,
+    type: state.type
+  };
+  if (`family` in state)
+    token.family = state.family;
+  return token;
+}
+var MapOverlay = class extends Map {
+  deleted = /* @__PURE__ */ new Set;
+  changed = /* @__PURE__ */ new Set;
+  source;
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+  get(key) {
+    if (super.has(key))
+      return super.get(key);
+    if (!this.deleted.has(key) && this.source.has(key))
+      return this.source.get(key);
+  }
+  set(key, value) {
+    this.deleted.delete(key);
+    if (this.source.has(key))
+      this.changed.add(key);
+    return super.set(key, value);
+  }
+  hasOwn(key) {
+    return super.has(key);
+  }
+  has(key) {
+    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+  }
+  delete(key) {
+    if (this.source.has(key)) {
+      this.deleted.add(key);
+      this.changed.delete(key);
+    }
+    return super.delete(key);
+  }
+  clear() {
+    this.deleted = new Set(this.source.keys());
+    this.changed.clear();
+    super.clear();
+  }
+  *[Symbol.iterator]() {
+    yield* super[Symbol.iterator]();
+    for (const [key, value] of this.source)
+      if (!this.deleted.has(key) && !this.changed.has(key))
+        yield [key, value];
+  }
+  *entries() {
+    yield* this[Symbol.iterator]();
+  }
+  *keys() {
+    yield* super.keys();
+    for (const key of this.source.keys())
+      if (!this.deleted.has(key) && !this.changed.has(key))
+        yield key;
+  }
+  *values() {
+    for (const [, value] of this[Symbol.iterator]())
+      yield value;
+  }
+  forEach(callbackfn) {
+    for (const [key, value] of this[Symbol.iterator]())
+      callbackfn(value, key, this);
+  }
+  get size() {
+    return super.size + this.source.size - this.changed.size - this.deleted.size;
+  }
+};
+var SetOverlay = class extends Set {
+  deleted = /* @__PURE__ */ new Set;
+  source;
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+  add(value) {
+    if (this.source.has(value)) {
+      this.deleted.delete(value);
+      return this;
+    }
+    return super.add(value);
+  }
+  hasOwn(member) {
+    return super.has(member);
+  }
+  has(key) {
+    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+  }
+  delete(key) {
+    if (this.source.has(key)) {
+      this.deleted.add(key);
+      return true;
+    }
+    return super.delete(key);
+  }
+  clear() {
+    this.deleted = new Set(this.source);
+    super.clear();
+  }
+  *[Symbol.iterator]() {
+    yield* super[Symbol.iterator]();
+    for (const value of this.source)
+      if (!this.deleted.has(value))
+        yield value;
+  }
+  *iterateOwn() {
+    yield* super[Symbol.iterator]();
+  }
+  get size() {
+    return super.size + this.source.size - this.deleted.size;
+  }
+};
+var RelationsOverlay = class extends Map {
+  deleted = /* @__PURE__ */ new Set;
+  source;
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+  get(key) {
+    if (super.has(key))
+      return super.get(key);
+    if (!this.deleted.has(key) && this.source.has(key)) {
+      const valueOverlay = new SetOverlay(this.source.get(key));
+      super.set(key, valueOverlay);
+      return valueOverlay;
+    }
+  }
+  set(key, value) {
+    this.deleted.delete(key);
+    return super.set(key, value);
+  }
+  has(key) {
+    return !this.deleted.has(key) && (super.has(key) || this.source.has(key));
+  }
+  delete(key) {
+    this.deleted.add(key);
+    return super.delete(key);
+  }
+};
+var Junction = class Junction2 {
+  a;
+  b;
+  cardinality;
+  relations = /* @__PURE__ */ new Map;
+  contents = /* @__PURE__ */ new Map;
+  isAType;
+  isBType;
+  isContent;
+  makeContentKey = (a, b) => `${a}:${b}`;
+  warn;
+  getRelatedKeys(key) {
+    return this.relations.get(key);
+  }
+  addRelation(a, b) {
+    let aRelations = this.relations.get(a);
+    let bRelations = this.relations.get(b);
+    if (aRelations)
+      aRelations.add(b);
+    else {
+      aRelations = new Set([b]);
+      this.relations.set(a, aRelations);
+    }
+    if (bRelations)
+      bRelations.add(a);
+    else {
+      bRelations = new Set([a]);
+      this.relations.set(b, bRelations);
+    }
+  }
+  deleteRelation(a, b) {
+    const aRelations = this.relations.get(a);
+    if (aRelations) {
+      aRelations.delete(b);
+      if (aRelations.size === 0)
+        this.relations.delete(a);
+      const bRelations = this.relations.get(b);
+      if (bRelations) {
+        bRelations.delete(a);
+        if (bRelations.size === 0)
+          this.relations.delete(b);
+      }
+    }
+  }
+  replaceRelationsUnsafely(x, ys) {
+    this.relations.set(x, new Set(ys));
+    for (const y of ys) {
+      const yRelations = (/* @__PURE__ */ new Set()).add(x);
+      this.relations.set(y, yRelations);
+    }
+  }
+  replaceRelationsSafely(x, ys) {
+    const xRelationsPrev = this.relations.get(x);
+    let a = this.isAType?.(x) ? x : undefined;
+    let b = a === undefined ? x : undefined;
+    if (xRelationsPrev)
+      for (const y of xRelationsPrev) {
+        a ??= y;
+        b ??= y;
+        const yRelations = this.relations.get(y);
+        if (yRelations) {
+          if (yRelations.size === 1)
+            this.relations.delete(y);
+          else
+            yRelations.delete(x);
+          this.contents.delete(this.makeContentKey(a, b));
+        }
+      }
+    this.relations.set(x, new Set(ys));
+    for (const y of ys) {
+      let yRelations = this.relations.get(y);
+      if (yRelations)
+        yRelations.add(x);
+      else {
+        yRelations = (/* @__PURE__ */ new Set()).add(x);
+        this.relations.set(y, yRelations);
+      }
+    }
+  }
+  getContentInternal(contentKey) {
+    return this.contents.get(contentKey);
+  }
+  setContent(contentKey, content) {
+    this.contents.set(contentKey, content);
+  }
+  deleteContent(contentKey) {
+    this.contents.delete(contentKey);
+  }
+  constructor(data, config) {
+    this.a = data.between[0];
+    this.b = data.between[1];
+    this.cardinality = data.cardinality;
+    this.isAType = config?.isAType ?? null;
+    this.isBType = config?.isBType ?? null;
+    this.isContent = config?.isContent ?? null;
+    if (config?.makeContentKey)
+      this.makeContentKey = config.makeContentKey;
+    if (!config?.externalStore) {
+      const source = config?.source;
+      if (source === undefined) {
+        this.relations = new Map(data.relations?.map(([x, ys]) => [x, new Set(ys)]));
+        this.contents = new Map(data.contents);
+      }
+      if (source) {
+        this.relations = new RelationsOverlay(source.relations);
+        this.contents = new MapOverlay(source.contents);
+      }
+    }
+    if (config?.externalStore) {
+      const externalStore = config.externalStore;
+      this.has = (a, b) => externalStore.has(a, b);
+      this.addRelation = (a, b) => {
+        externalStore.addRelation(a, b);
+      };
+      this.deleteRelation = (a, b) => {
+        externalStore.deleteRelation(a, b);
+      };
+      this.replaceRelationsSafely = (a, bs) => {
+        externalStore.replaceRelationsSafely(a, bs);
+      };
+      this.replaceRelationsUnsafely = (a, bs) => {
+        externalStore.replaceRelationsUnsafely(a, bs);
+      };
+      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
+      if (externalStore.getContent) {
+        this.getContentInternal = (contentKey) => {
+          return externalStore.getContent(contentKey);
+        };
+        this.setContent = (contentKey, content) => {
+          externalStore.setContent(contentKey, content);
+        };
+        this.deleteContent = (contentKey) => {
+          externalStore.deleteContent(contentKey);
+        };
+      }
+      for (const [x, ys] of data.relations ?? []) {
+        let a = this.isAType?.(x) ? x : undefined;
+        let b = a === undefined ? x : undefined;
+        for (const y of ys) {
+          a ??= y;
+          b ??= y;
+          this.addRelation(a, b);
+        }
+      }
+      for (const [contentKey, content] of data.contents ?? [])
+        this.setContent(contentKey, content);
+    }
+    if (config?.warn)
+      this.warn = config.warn;
+  }
+  toJSON() {
+    return {
+      between: [this.a, this.b],
+      cardinality: this.cardinality,
+      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+      contents: [...this.contents.entries()]
+    };
+  }
+  set(...params) {
+    let a;
+    let b;
+    let content;
+    switch (params.length) {
+      case 1: {
+        const relation = params[0];
+        a = relation[this.a];
+        b = relation[this.b];
+        content = undefined;
+        break;
+      }
+      case 2: {
+        const zeroth = params[0];
+        if (typeof zeroth === `string`)
+          [a, b] = params;
+        else {
+          a = zeroth[this.a];
+          b = zeroth[this.b];
+          content = params[1];
+        }
+        break;
+      }
+      default:
+        a = params[0];
+        b = params[1];
+        content = params[2];
+        break;
+    }
+    switch (this.cardinality) {
+      case `1:1`: {
+        const bPrev = this.getRelatedKey(a);
+        if (bPrev && bPrev !== b)
+          this.delete(a, bPrev);
+      }
+      case `1:n`:
+        {
+          const aPrev = this.getRelatedKey(b);
+          if (aPrev && aPrev !== a)
+            this.delete(aPrev, b);
+        }
+        break;
+      case `n:n`:
+    }
+    if (content) {
+      const contentKey = this.makeContentKey(a, b);
+      this.setContent(contentKey, content);
+    }
+    this.addRelation(a, b);
+    return this;
+  }
+  delete(x, b) {
+    b = typeof b === `string` ? b : x[this.b];
+    const a = typeof x === `string` ? x : x[this.a];
+    if (a === undefined && typeof b === `string`) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations)
+        for (const bRelation of bRelations)
+          this.delete(bRelation, b);
+    } else if (typeof a === `string` && b === undefined) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations)
+        for (const aRelation of aRelations)
+          this.delete(a, aRelation);
+    } else if (typeof a === `string` && typeof b === `string`) {
+      this.deleteRelation(a, b);
+      const contentKey = this.makeContentKey(a, b);
+      this.deleteContent(contentKey);
+    }
+    return this;
+  }
+  getRelatedKey(key) {
+    const relations = this.getRelatedKeys(key);
+    if (relations) {
+      if (relations.size > 1)
+        this.warn?.(`${relations.size} related keys were found for key "${key}": (${[...relations].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`);
+      let singleRelation;
+      for (const relation of relations) {
+        singleRelation = relation;
+        break;
+      }
+      return singleRelation;
+    }
+  }
+  replaceRelations(x, relations, config) {
+    const hasContent = !Array.isArray(relations);
+    const ys = hasContent ? Object.keys(relations) : relations;
+    if (config?.reckless)
+      this.replaceRelationsUnsafely(x, ys);
+    else
+      this.replaceRelationsSafely(x, ys);
+    if (hasContent)
+      for (const y of ys) {
+        const contentKey = this.makeContentKey(x, y);
+        const content = relations[y];
+        this.setContent(contentKey, content);
+      }
+    return this;
+  }
+  getContent(a, b) {
+    const contentKey = this.makeContentKey(a, b);
+    return this.getContentInternal(contentKey);
+  }
+  getRelationEntries(input) {
+    const a = input[this.a];
+    const b = input[this.b];
+    if (a !== undefined && b === undefined) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations)
+        return [...aRelations].map((aRelation) => {
+          return [aRelation, this.getContent(a, aRelation)];
+        });
+    }
+    if (a === undefined && b !== undefined) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations)
+        return [...bRelations].map((bRelation) => {
+          return [bRelation, this.getContent(bRelation, b)];
+        });
+    }
+    return [];
+  }
+  has(a, b) {
+    if (b)
+      return this.getRelatedKeys(a)?.has(b) ?? false;
+    return this.relations.has(a);
+  }
+  overlay() {
+    const config = {
+      source: this,
+      makeContentKey: this.makeContentKey
+    };
+    if (this.isAType)
+      config.isAType = this.isAType;
+    if (this.isBType)
+      config.isBType = this.isBType;
+    if (this.isContent)
+      config.isContent = this.isContent;
+    if (this.warn)
+      config.warn = this.warn;
+    return new Junction2({
+      between: [this.a, this.b],
+      cardinality: this.cardinality
+    }, config);
+  }
+  incorporate(overlay) {
+    const { relations, contents } = overlay;
+    for (const [key, value] of relations)
+      if (value instanceof SetOverlay) {
+        const { source } = value;
+        for (const keyAdded of value.iterateOwn())
+          source.add(keyAdded);
+      } else
+        this.relations.set(key, value);
+    for (const key of relations.deleted)
+      this.relations.delete(key);
+    for (const [key, value] of contents)
+      this.contents.set(key, value);
+    for (const key of contents.deleted)
+      this.contents.delete(key);
+  }
+};
+function isReservedIntrospectionKey(value) {
+  return value.startsWith(`\uD83D\uDD0D `);
+}
+var abortTransaction = (target) => {
+  target.logger.info(`\uD83E\uDE82`, `transaction`, target.transactionMeta.update.token.key, `Aborting transaction`);
+  target.parent.child = null;
+};
+function actUponStore(store, token, id) {
+  return (...parameters) => {
+    return withdraw(store, token).run(parameters, id);
+  };
+}
+function ingestAtomUpdateEvent(store, event, applying) {
+  const { token, update: { newValue, oldValue } } = event;
+  setIntoStore(store, token, applying === `newValue` ? newValue : oldValue);
+}
+function getTrace(error) {
+  const { stack } = error;
+  if (stack)
+    return `
+` + stack.split(`
 `)?.slice(1)?.join(`
-`);return""}function P0(Q,Z,q,z="any"){let H=Z,X=h(q),Y=[],G=C(Q);if(Array.isArray(H))for(let W of H){let _=h(W);if(G.molecules.get(_))Q.moleculeGraph.set(_,X,{source:_});else Y.push(_)}else{let W=h(H);if(G.molecules.get(W))Q.moleculeGraph.set(W,X,{source:W});else Y.push(W)}let N=new E;if(Y.length===0)G.molecules.set(X,{key:q,stringKey:X,dependsOn:z,subject:N});let j={type:"molecule_creation",key:q,provenance:H,timestamp:Date.now()};if(F(G)&&G.transactionMeta.phase==="building")G.transactionMeta.update.subEvents.push(j);else G.on.moleculeCreation.next(j);for(let W of Y){let _=Q.disposalTraces.buffer.find((D)=>D?.key===W);Q.logger.error("\u274C","key",q,"allocation failed:",`Could not allocate to ${W} in store "${Q.config.name}".`,_?`
-   ${W} was most recently disposed
-${_.trace}`:`No previous disposal trace for ${W} was found.`)}return q}function T0(Q,Z){let q=h(Z),z=Q.molecules.get(q);if(!z){let D=Q.disposalTraces.buffer.find(($)=>$?.key===q);Q.logger.error("\u274C","key",Z,"deallocation failed:",`Could not find allocation for ${q} in store "${Q.config.name}".`,D?`
+`);
+  return ``;
+}
+function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
+  const origin = provenance;
+  const stringKey = stringifyJson(key);
+  const invalidKeys = [];
+  const target = newest(store);
+  if (Array.isArray(origin))
+    for (const formerClaim of origin) {
+      const claimString = stringifyJson(formerClaim);
+      if (target.molecules.get(claimString))
+        store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+      else
+        invalidKeys.push(claimString);
+    }
+  else {
+    const claimString = stringifyJson(origin);
+    if (target.molecules.get(claimString))
+      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
+    else
+      invalidKeys.push(claimString);
+  }
+  const subject = new Subject;
+  if (invalidKeys.length === 0)
+    target.molecules.set(stringKey, {
+      key,
+      stringKey,
+      dependsOn,
+      subject
+    });
+  const creationEvent = {
+    type: `molecule_creation`,
+    key,
+    provenance: origin,
+    timestamp: Date.now()
+  };
+  if (isChildStore(target) && target.transactionMeta.phase === `building`)
+    target.transactionMeta.update.subEvents.push(creationEvent);
+  else
+    target.on.moleculeCreation.next(creationEvent);
+  for (const claim of invalidKeys) {
+    const disposal = store.disposalTraces.buffer.find((item) => item?.key === claim);
+    store.logger.error(`\u274C`, `key`, key, `allocation failed:`, `Could not allocate to ${claim} in store "${store.config.name}".`, disposal ? `
+   ${claim} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${claim} was found.`);
+  }
+  return key;
+}
+function deallocateFromStore(target, claim) {
+  const stringKey = stringifyJson(claim);
+  const molecule = target.molecules.get(stringKey);
+  if (!molecule) {
+    const disposal = target.disposalTraces.buffer.find((item) => item?.key === stringKey);
+    target.logger.error(`\u274C`, `key`, claim, `deallocation failed:`, `Could not find allocation for ${stringKey} in store "${target.config.name}".`, disposal ? `
    This state was most recently deallocated
-${D.trace}`:`No previous disposal trace for ${q} was found.`);return}z.subject.next();let H=Q.keyRefsInJoins.getRelatedKeys(q);if(H)for(let D of H){let $=Q.joins.get(D);if($)$.relations.delete(Z)}else{let D=e0(Z);if(D){let[,$,J]=D,V=Q.keyRefsInJoins.getRelatedKey(a($,J));if(V){let P=Q.joins.get(V);if(P)P.relations.delete($,J)}}}Q.keyRefsInJoins.delete(q);let X=[],Y=[],G=Q.moleculeGraph.getRelationEntries({downstreamMoleculeKey:q});if(G)for(let[D,{source:$}]of G)if($===q)T0(Q,R(D));else X.push($);let N=Q.moleculeData.getRelatedKeys(z.stringKey);if(N)for(let D of N){let $=Q.families.get(D),J=I(Q,$,Z);Y.push([$.key,J]),n(Q,$,Z)}let j={type:"molecule_disposal",key:z.key,values:Y,provenance:X,timestamp:Date.now()};Q.molecules.delete(q);let W=F(Q)&&Q.transactionMeta.phase==="building";if(W)Q.transactionMeta.update.subEvents.push(j);if(Q.moleculeGraph.delete(z.stringKey),Q.keyRefsInJoins.delete(z.stringKey),Q.moleculeData.delete(z.stringKey),!W)Q.on.moleculeDisposal.next(j);Q.molecules.delete(z.stringKey);let _=aQ(Error());Q.disposalTraces.add({key:q,trace:_})}function O0(Q,Z,q,z){let H=h(q),X=C(Q),Y=X.molecules.get(H);if(!Y){let _=Q.disposalTraces.buffer.find((D)=>D?.key===H);return Q.logger.error("\u274C","key",H,"claim failed:",`Could not allocate to ${H} in store "${Q.config.name}".`,_?`
-   ${H} was most recently disposed
-${_.trace}`:`No previous disposal trace for ${H} was found.`),q}let G=h(Z),N=X.molecules.get(G);if(!N){let _=Q.disposalTraces.buffer.find((D)=>D?.key===G);return Q.logger.error("\u274C","key",q,"claim failed:",`Could not allocate to ${G} in store "${Q.config.name}".`,_?`
-   ${G} was most recently disposed
-${_.trace}`:`No previous disposal trace for ${G} was found.`),q}let j=Q.moleculeGraph.getRelationEntries({downstreamMoleculeKey:Y.stringKey}).filter(([,{source:_}])=>_!==H).map(([_])=>R(_));if(z)X.moleculeGraph.delete(H);X.moleculeGraph.set({upstreamMoleculeKey:N.stringKey,downstreamMoleculeKey:Y.stringKey},{source:N.stringKey});let W={type:"molecule_transfer",key:Y.key,exclusive:Boolean(z),from:j,to:[N.key],timestamp:Date.now()};if(F(X)&&X.transactionMeta.phase==="building")X.transactionMeta.update.subEvents.push(W);return q}function nQ(Q,Z,q){switch(q){case"newValue":CQ(Q,Z);break;case"oldValue":n(Q,Z.token);break}}function rQ(Q,Z,q){switch(q){case"newValue":n(Q,Z.token);break;case"oldValue":if(CQ(Q,Z),Z.subType==="atom")Q.valueMap.set(Z.token.key,Z.value);break}}function CQ(Q,Z){let{token:q}=Z;if(Z.subType==="writable"&&Z.value)f(Q,q,Z.value);else I(Q,q)}function sQ(Q,Z,q){switch(q){case"newValue":P0(Q,Z.provenance,Z.key);break;case"oldValue":T0(Q,Z.key);break}}function oQ(Q,Z,q){switch(q){case"newValue":T0(Q,Z.key);break;case"oldValue":P0(Q,Z.provenance.map(R),Z.key);for(let[z,H]of Z.values){let X=Q.families.get(z);if(X){I(Q,X,Z.key);let Y=`${z}(${h(Z.key)})`;Q.valueMap.set(Y,H)}}break}}function tQ(Q,Z,q){switch(q){case"newValue":for(let z of Z.to)O0(Q,z,Z.key,Z.exclusive?"exclusive":void 0);break;case"oldValue":{let z="exclusive";for(let H of Z.from)O0(Q,H,Z.key,z),z=void 0}break}}function EQ(Q,Z,q){let z=q==="newValue"?Z.subEvents:[...Z.subEvents].reverse();for(let H of z)switch(H.type){case"atom_update":iQ(Q,H,q);break;case"state_creation":nQ(Q,H,q);break;case"state_disposal":rQ(Q,H,q);break;case"molecule_creation":sQ(Q,H,q);break;case"molecule_disposal":oQ(Q,H,q);break;case"molecule_transfer":tQ(Q,H,q);break;case"transaction_outcome":EQ(Q,H,q);break}}function u(Q){return"epoch"in Q.transactionMeta}function F(Q){return"phase"in Q.transactionMeta}function BQ(Q,Z){return Q.transactionMeta.actionContinuities.getRelatedKey(Z)}function eQ(Q,Z){return Q.transactionMeta.epoch.get(Z)}function QZ(Q,Z){let q=BQ(Q,Z);if(q===void 0)return;return eQ(Q,q)}function ZZ(Q,Z,q){let z=BQ(Q,Z);if(z!==void 0)Q.transactionMeta.epoch.set(z,q)}function qZ(Q,Z){let q=C(Q),{parent:z}=q;q.transactionMeta.phase="applying",q.transactionMeta.update.output=Z,z.child=null,z.on.transactionApplying.next(q.transactionMeta);let{subEvents:H}=q.transactionMeta.update;if(Q.logger.info("\uD83D\uDEC4","transaction",q.transactionMeta.update.token.key,`applying ${H.length} subEvents:`,H),EQ(z,q.transactionMeta.update,"newValue"),u(z))ZZ(z,q.transactionMeta.update.token.key,q.transactionMeta.update.epoch),B(Q,{key:q.transactionMeta.update.token.key,type:"transaction"})?.subject.next(q.transactionMeta.update),Q.logger.info("\uD83D\uDEEC","transaction",q.transactionMeta.update.token.key,"applied");else if(F(z))z.transactionMeta.update.subEvents.push(q.transactionMeta.update);z.on.transactionApplying.next(null)}function zZ(Q){return{store:Q}}var HZ=(Q,Z,q,z)=>{let H=C(Q),X={parent:H,child:null,on:H.on,loggers:H.loggers,logger:H.logger,config:H.config,atoms:new K(H.atoms),atomsThatAreDefault:new Set(H.atomsThatAreDefault),families:new K(H.families),joins:new K(H.joins),operation:{open:!1},readonlySelectors:new K(H.readonlySelectors),timelines:new K(H.timelines),timelineTopics:H.timelineTopics.overlay(),trackers:new Map,transactions:new K(H.transactions),selectorAtoms:H.selectorAtoms.overlay(),selectorGraph:H.selectorGraph.overlay(),writableSelectors:new K(H.writableSelectors),valueMap:new K(H.valueMap),defaults:H.defaults,disposalTraces:Q.disposalTraces.copy(),molecules:new K(H.molecules),moleculeGraph:H.moleculeGraph.overlay(),moleculeData:H.moleculeData.overlay(),keyRefsInJoins:H.keyRefsInJoins.overlay(),miscResources:new K(H.miscResources)},Y=QZ(Q,Z.key),G={phase:"building",update:{type:"transaction_outcome",token:Z,id:z,epoch:Y===void 0?NaN:Y+1,timestamp:Date.now(),subEvents:[],params:q,output:void 0},toolkit:{get:(...j)=>I(N,...j),set:(...j)=>{f(N,...j)},reset:(...j)=>{W0(N,...j)},run:(j,W=QQ())=>L0(N,j,W),find:(...j)=>M(Q,...j),json:(j)=>p(N,j),dispose:(...j)=>{n(N,...j)},env:()=>zZ(N)}},N=Object.assign(X,{transactionMeta:G});return H.child=N,Q.logger.info("\uD83D\uDEEB","transaction",Z.key,"building with params:",q),N};function M0(Q,Z){let{key:q}=Z,z=Q.transactions.has(q),H={key:q,type:"transaction",run:(Y,G)=>{let N=HZ(Q,b(H),Y,G);try{let{toolkit:j}=N.transactionMeta,W=Z.do(j,...Y);return qZ(N,W),W}catch(j){throw lQ(N),Q.logger.warn("\uD83D\uDCA5","transaction",q,"caught:",j),j}},install:(Y)=>M0(Y,Z),subject:new E};C(Q).transactions.set(q,H);let X=b(H);if(!z)Q.on.transactionCreation.next(X);return X}var ZQ=class{parent=null;child=null;valueMap=new Map;defaults=new Map;atoms=new Map;writableSelectors=new Map;readonlySelectors=new Map;atomsThatAreDefault=new Set;selectorAtoms=new T({between:["selectorKey","atomKey"],cardinality:"n:n"});selectorGraph=new T({between:["upstreamSelectorKey","downstreamSelectorKey"],cardinality:"n:n"},{makeContentKey:(...Q)=>Q.sort().join(":")});trackers=new Map;families=new Map;joins=new Map;transactions=new Map;transactionMeta={epoch:new Map,actionContinuities:new T({between:["continuity","action"],cardinality:"1:n"})};timelines=new Map;timelineTopics=new T({between:["timelineKey","topicKey"],cardinality:"1:n"});disposalTraces=new mQ(100);molecules=new Map;moleculeGraph=new T({between:["upstreamMoleculeKey","downstreamMoleculeKey"],cardinality:"n:n"},{makeContentKey:(...Q)=>Q.sort().join(":")});moleculeData=new T({between:["moleculeKey","stateFamilyKey"],cardinality:"n:n"},{makeContentKey:(...Q)=>Q.sort().join(":")});keyRefsInJoins=new T({between:["moleculeKey","joinKey"],cardinality:"n:n"},{makeContentKey:(...Q)=>Q.sort().join(":")});miscResources=new Map;on={atomCreation:new E,atomDisposal:new E,selectorCreation:new E,selectorDisposal:new E,timelineCreation:new E,transactionCreation:new E,transactionApplying:new pQ(null),operationClose:new E,moleculeCreation:new E,moleculeDisposal:new E};operation={open:!1};config={name:"IMPLICIT_STORE",lifespan:"ephemeral",isProduction:globalThis.process?.env?.NODE_ENV==="production"};loggers=[new t0("warn",(Q,Z,q)=>!uQ(q))];logger={error:(...Q)=>{for(let Z of this.loggers)Z.error(...Q)},info:(...Q)=>{for(let Z of this.loggers)Z.info(...Q)},warn:(...Q)=>{for(let Z of this.loggers)Z.warn(...Q)}};constructor(Q,Z=null){if(this.config={...Z?.config,...Q},Z!==null){if(this.operation={...Z?.operation},u(Z))this.transactionMeta={epoch:new Map(Z?.transactionMeta.epoch),actionContinuities:new T(Z?.transactionMeta.actionContinuities.toJSON())};for(let[,z]of Z.families){if(z.internalRoles?.includes("mutable")||z.internalRoles?.includes("join"))continue;z.install(this)}let q=new Set;for(let[,z]of Z.atoms){if(q.has(z.key))continue;if(z.install(this),z.type==="mutable_atom"){let H=p(Z,z),X=j0(z);q.add(H.key),q.add(X.key)}}for(let[,z]of Z.readonlySelectors)z.install(this);for(let[,z]of Z.writableSelectors){if(q.has(z.key))continue;z.install(this)}for(let[,z]of Z.transactions)z.install(this);for(let[,z]of Z.timelines)z.install(this)}}},A={get STORE(){return globalThis.ATOM_IO_IMPLICIT_STORE??=new ZQ({name:"IMPLICIT_STORE",lifespan:"ephemeral",isProduction:globalThis.process?.env?.NODE_ENV==="production"}),globalThis.ATOM_IO_IMPLICIT_STORE}};var XZ=class extends Error{constructor(Q,Z){super(`${S[Q.type]} ${h(Q.key)} not found in store "${Z.config.name}".`)}};function B(Q,Z){let q,z=Q;while(z!==null){switch(Z.type){case"atom":case"mutable_atom":q=z.atoms.get(Z.key);break;case"writable_pure_selector":case"writable_held_selector":q=z.writableSelectors.get(Z.key);break;case"readonly_pure_selector":case"readonly_held_selector":q=z.readonlySelectors.get(Z.key);break;case"atom_family":case"mutable_atom_family":case"writable_pure_selector_family":case"readonly_pure_selector_family":case"writable_held_selector_family":case"readonly_held_selector_family":q=z.families.get(Z.key);break;case"timeline":q=z.timelines.get(Z.key);break;case"transaction":q=z.transactions.get(Z.key);break}if(q)return q;z=z.child}throw new XZ(Z,Q)}function hQ(Q,Z,q,z){let H=Q.disposalTraces.buffer.find((X)=>X?.key===h(z));switch(Q.logger.error("\u274C",Z.type,Z.key,"gets a fallback value because key",z,"is not allocated",H?`This key was previously disposed:
-${H.trace}`:"(no previous disposal trace found)"),q.type){case"mutable_atom_family":{if(Q.defaults.has(q.key))return Q.defaults.get(q.key);let X=new q.class;return Q.defaults.set(q.key,X),X.READONLY_VIEW}case"atom_family":{if(Q.defaults.has(q.key))return Q.defaults.get(q.key);let X=q.default,Y=X(z);return Q.defaults.set(q.key,Y),Y}case"readonly_pure_selector_family":case"writable_pure_selector_family":case"readonly_held_selector_family":case"writable_held_selector_family":{if(Q.defaults.has(q.key))return Q.defaults.get(q.key);let X=q.default(z);return Q.defaults.set(q.key,X),X}}}function D0(Q,Z){let{type:q,key:z,catch:H}=Z;switch(q){case"readonly_pure_selector":case"writable_pure_selector":{let X;Q.logger.info("\uD83E\uDDEE",q,z,"computing value");try{if(X=Z.getFrom(Q),X instanceof Promise)return X.catch((Y)=>{if(Q.logger.error("\uD83D\uDCA5",q,z,"rejected:",Y),H){for(let G of H)if(Y instanceof G)return Y}throw Y})}catch(Y){if(Q.logger.error("\uD83D\uDCA5",q,z,"rejected:",Y),H){for(let G of H)if(Y instanceof G)return w(Q,Z,Y)}throw Y}return w(Q,Z,X)}case"atom":{let X;if(s(Z.default))try{if(X=Z.default(),X instanceof Promise)X=X.catch((Y)=>{if(Q.logger.error("\uD83D\uDCA5",q,z,"rejected:",Y),H){for(let G of H)if(Y instanceof G)return Y}throw Y})}catch(Y){if(Q.logger.error("\uD83D\uDCA5",q,z,"rejected:",Y),H){for(let G of H)if(Y instanceof G)return X=w(Q,Z,Y),Q.logger.info("\u2728",Z.type,z,"computed default",X),X}throw Y}else X=Z.default,Q.logger.info("\u2728",Z.type,z,"using static default",X);return w(Q,Z,X)}}}function y(Q,Z,q){if(Q.valueMap.has(Z.key))return hZ(Q,Z,q);Q.logger.info("\u2754",Z.type,Z.key,"value not found in cache");let{key:z}=Z;switch(Z.type){case"readonly_held_selector":case"writable_held_selector":return Q.logger.info("\uD83E\uDDEE",Z.type,z,"computing value"),Z.getFrom(Q);case"writable_pure_selector":case"readonly_pure_selector":case"atom":return D0(Q,Z);case"mutable_atom":{let H=new Z.class;return Q.logger.info("\u2728",Z.type,z,"created new instance",H),w(Q,Z,H)}}}function g0(Q,Z){return B(Q,{key:Z.family.key,type:`${Z.type}_family`})}var DQ={atom_family:"atom",molecule_family:"molecule",mutable_atom_family:"mutable_atom",readonly_held_selector_family:"readonly_held_selector",readonly_pure_selector_family:"readonly_pure_selector",writable_held_selector_family:"writable_held_selector",writable_pure_selector_family:"writable_pure_selector"},o=Symbol("MUST_CREATE"),YZ=Symbol("DO_NOT_CREATE");function t(Q,Z,q,z){let H=h(z),X=Z.molecules.get(H);if(!X&&Z.config.lifespan==="immortal"){let{type:G,key:N}=q;return Z.logger.warn("\uD83D\uDCA3","key",H,"was used to mint a counterfeit token for",G,`"${N}"`),{counterfeit:!0,key:`${N}(${H})`,type:DQ[G],family:{key:N,subKey:H}}}let Y;if(Q===o){if(Z.logger.info("\uD83D\uDC6A",q.type,q.key,"adds member",typeof z==="string"?`\`${z}\``:z),Y=q.create(z),X)Z.moleculeData.set(H,q.key)}else{let{type:G,key:N}=q;return{key:`${N}(${H})`,type:DQ[G],family:{key:N,subKey:H}}}return Y}function b0(Q,...Z){let q,z,H,X,Y;if(Z.length===1){if(Y=Z[0],"family"in Y){let N=g0(Q,Y);if(H=B(Q,N),X=R(Y.family.subKey),q=e(Q,N,X),"counterfeit"in Y)return{token:Y,family:H,subKey:X,isNew:!1};if(!q)z=t(o,Q,N,X),Y=z;else Y=q}}else if(H=B(Q,Z[0]),X=Z[1],q=e(Q,H,X),!q)z=t(o,Q,H,X),Y=z;else Y=q;let G="counterfeit"in Y;if(Boolean(z)&&G===!1&&H){let N;switch(Y.type){case"readonly_pure_selector":case"readonly_held_selector":N="readable";break;case"atom":case"mutable_atom":case"writable_pure_selector":case"writable_held_selector":N="writable";break}let j={type:"state_creation",subType:N,token:Y,timestamp:Date.now()};H.subject.next(j);let W=C(Q);if(Y.family){if(u(W))switch(Y.type){case"atom":case"mutable_atom":Q.on.atomCreation.next(Y);break;case"writable_pure_selector":case"readonly_pure_selector":case"writable_held_selector":case"readonly_held_selector":Q.on.selectorCreation.next(Y);break}else if(F(W)&&W.on.transactionApplying.state===null)W.transactionMeta.update.subEvents.push(j)}}return{token:Y,family:H,subKey:X,isNew:Boolean(z)}}function I(Q,...Z){let{token:q,family:z,subKey:H}=b0(Q,...Z);if("counterfeit"in q&&z&&H)return hQ(Q,q,z,H);return y(Q,B(Q,q))}function e(Q,Z,q){let z=h(q),H=`${Z.key}(${z})`,X=C(Q),Y;switch(Z.type){case"atom_family":case"mutable_atom_family":Y=X.atoms.get(H);break;case"writable_held_selector_family":case"writable_pure_selector_family":Y=X.writableSelectors.get(H);break;case"readonly_held_selector_family":case"readonly_pure_selector_family":Y=X.readonlySelectors.get(H);break}if(Y)return b(Y);return Y}function M(Q,Z,q){let z=B(Q,Z),H=e(Q,Z,q);if(H)return H;return t(YZ,Q,z,q)}function $0(Q,Z,q){let z=Z.key,H="readonly_pure_selector_family",X={key:z,type:"readonly_pure_selector_family"},Y=Q.families.get(z);if(Y&&Q.config.isProduction===!0)Q.logger.error("\u2757","readonly_pure_selector_family",z,`Overwriting an existing ${S[Y.type]} "${Y.key}" in store "${Q.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);let G=new E,j={...X,create:(W)=>{let _=h(W),D={key:z,subKey:_},$=`${z}(${_})`,J=C(Q),V={key:$,get:Z.get(W)};if(Z.catch)V.catch=Z.catch;return p0(J,V,D)},internalRoles:q,subject:G,install:(W)=>$0(W,Z),default:(W)=>{return Z.get(W)({get:(..._)=>I(Q,..._),find:(..._)=>M(Q,..._),json:(_)=>p(Q,_)})}};return Q.families.set(z,j),X}function G0(Q,Z,q){let z={key:Z.key,type:"atom_family"},H=Q.families.get(Z.key);if(H&&Q.config.isProduction===!0)Q.logger.error("\u2757","atom_family",Z.key,`Overwriting an existing ${S[H.type]} "${H.key}" in store "${Q.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);let X=new E,G={...z,create:(N)=>{let j=h(N),W={key:Z.key,subKey:j},_=`${Z.key}(${j})`,D=C(Q),$=Z.default,J={key:_,default:s($)?()=>$(N):$};if(Z.effects)J.effects=Z.effects(N);if(Z.catch)J.catch=Z.catch;return N0(D,J,W)},default:Z.default,subject:X,install:(N)=>G0(N,Z),internalRoles:q};if(Q.families.set(Z.key,G),s(Z.default)===!1)Q.defaults.set(Z.key,Z.default);return z}function LQ(Q,Z,q){let z=Z.key,H="readonly_held_selector_family",X={key:z,type:"readonly_held_selector_family"},Y=Q.families.get(z);if(Y&&Q.config.isProduction===!0)Q.logger.error("\u2757","readonly_held_selector_family",z,`Overwriting an existing ${S[Y.type]} "${Y.key}" in store "${Q.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);let G=new E,j={...X,create:(W)=>{let _=h(W),D={key:z,subKey:_},$=`${z}(${_})`;return y0(C(Q),{key:$,const:Z.const(W),get:Z.get(W)},D)},internalRoles:q,subject:G,install:(W)=>LQ(W,Z),default:Z.const};return Q.families.set(z,j),X}function PQ(Q,Z,q){let z=Z.key,H="writable_held_selector_family",X={key:z,type:"writable_held_selector_family"},Y=Q.families.get(z);if(Y&&Q.config.isProduction===!0)Q.logger.error("\u2757","writable_held_selector_family",z,`Overwriting an existing ${S[Y.type]} "${Y.key}" in store "${Q.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);let G=new E,j={...X,create:(W)=>{let _=h(W),D={key:z,subKey:_},$=`${z}(${_})`;return m0(C(Q),{key:$,const:Z.const(W),get:Z.get(W),set:Z.set(W)},D)},internalRoles:q,subject:G,install:(W)=>PQ(W,Z),default:Z.const};return Q.families.set(z,j),X}function d0(Q,Z,q){let z=Z.key,H="writable_pure_selector_family",X={key:z,type:"writable_pure_selector_family"},Y=Q.families.get(z);if(Y&&Q.config.isProduction===!0)Q.logger.error("\u2757","writable_pure_selector_family",z,`Overwriting an existing ${S[Y.type]} "${Y.key}" in store "${Q.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);let G=new E,j={...X,create:(W)=>{let _=h(W),D={key:z,subKey:_},$=`${z}(${_})`,J=C(Q),V={key:$,get:Z.get(W),set:Z.set(W)};if(Z.catch)V.catch=Z.catch;return c0(J,V,D)},internalRoles:q,subject:G,install:(W)=>d0(W,Z),default:(W)=>{return Z.get(W)({get:(..._)=>I(Q,..._),find:(..._)=>M(Q,..._),json:(_)=>p(Q,_)})}};return Q.families.set(z,j),X}function qQ(Q,Z){let q="set"in Z,z="const"in Z;if(z&&q)return PQ(Q,Z,void 0);if(z)return LQ(Q,Z,void 0);if(q)return d0(Q,Z);return $0(Q,Z)}function n(Q,...Z){let q;if(Z.length===1)q=Z[0];else{let z=Z[0],H=Z[1];q=M(Q,z,H)}try{B(Q,q)}catch(z){Q.logger.error("\u274C",q.type,q.key,`could not be disposed because it was not found in the store "${Q.config.name}".`);return}switch(q.type){case"atom":case"mutable_atom":wQ(Q,q);break;case"writable_pure_selector":case"readonly_pure_selector":case"writable_held_selector":case"readonly_held_selector":JZ(Q,q);break}}function OQ(Q,Z){if(Q.operation.open){let q=performance.now();return Q.logger.info("\uD83D\uDEAB",Z.type,Z.key,`deferring setState at T-${q} until setState for "${Q.operation.token.key}" is done`),q}return Q.operation={open:!0,done:new Set,prev:new Map,timestamp:Date.now(),token:Z,subEvents:[]},Q.logger.info("\u2B55",Z.type,Z.key,`operation start in store "${Q.config.name}"${F(Q)?` ${Q.transactionMeta.phase} "${Q.transactionMeta.update.token.key}"`:""}`),Q}function MQ(Q){if(Q.operation.open)Q.logger.info("\uD83D\uDD34",Q.operation.token.type,Q.operation.token.key,`operation done in store "${Q.config.name}"`);Q.operation={open:!1},Q.on.operationClose.next(Q.operation)}var RQ=(Q,Z)=>{if(!Q.operation.open)return Q.logger.error("\uD83D\uDC1E","unknown",Z,"isDone called outside of an operation. This is probably a bug in AtomIO."),!0;return Q.operation.done.has(Z)},V0=(Q,Z)=>{if(!Q.operation.open){Q.logger.error("\uD83D\uDC1E","unknown",Z,"markDone called outside of an operation. This is probably a bug in AtomIO.");return}Q.operation.done.add(Z)};function f0(Q,Z,{oldValue:q,newValue:z},H,X){let Y=b(Z);if(H&&X){Z.subject.next({newValue:z});let _={checkpoint:!0,type:"state_creation",subType:"writable",token:Y,timestamp:Date.now(),value:z};Q.operation.subEvents.push(_),X.subject.next(_);let D=C(Q);if(Y.family){if(u(D))switch(Y.type){case"atom":case"mutable_atom":Q.on.atomCreation.next(Y);break;case"writable_pure_selector":case"writable_held_selector":Q.on.selectorCreation.next(Y);break}else if(F(D)&&D.on.transactionApplying.state===null)D.transactionMeta.update.subEvents.push(_)}return}let{key:G,subject:N,type:j}=Z,W={oldValue:w0(q)?q.READONLY_VIEW:q,newValue:w0(z)?z.READONLY_VIEW:z};if(u(Q)){switch(j){case"mutable_atom":Q.logger.info("\uD83D\uDCE2",j,G,"is now (",z,") subscribers:",N.subscribers.keys());break;case"atom":case"writable_pure_selector":case"writable_held_selector":Q.logger.info("\uD83D\uDCE2",j,G,"went (",q,"->",z,") subscribers:",N.subscribers.keys())}N.next(W)}if(F(Q)&&(j==="mutable_atom"||j==="atom")){if(Q.on.transactionApplying.state===null){if(w0(z))return;let{timestamp:_}=Q.operation,D={type:"atom_update",token:Y,timestamp:_,update:W};Q.transactionMeta.update.subEvents.push(D),Q.logger.info("\uD83D\uDCC1","atom",G,"stowed (",q,"->",z,")");return}if(i0(Z,"tracker:signal")){let _=G.slice(1),D=Q.atoms.get(_);if(y(Q,D,"mut").do(W.newValue)===null===!0)l0(Q,D)}}}var K0=(Q,Z,q)=>{let z=y(Q,Z,"mut"),H=A0(q,z);return Q.logger.info("\u2B50","atom",Z.key,"setting value",H),H=w(Q,Z,H),V0(Q,Z.key),l0(Q,Z),{oldValue:z,newValue:H}};function x0(Q,Z){switch(Z.type){case"mutable_atom":return K0(Q,Z,new Z.class);case"atom":{let q;if(s(Z.default))q=D0(Q,Z);else q=Z.default;return K0(Q,Z,q)}}}function GZ(Q,Z){let q;switch(Z.type){case"atom":case"mutable_atom":q=x0(Q,Z);break;case"writable_held_selector":{let z=Q0(Q,Z.key);for(let X of z.values())f0(Q,Z,x0(Q,X),!1);let H=Z.getFrom(Q);q={oldValue:H,newValue:H}}break;case"writable_pure_selector":{let z=D0(Q,Z),H=Q0(Q,Z.key);for(let X of H.values())f0(Q,Z,x0(Q,X),!1);q={oldValue:z,newValue:D0(Q,Z)}}break}return q}function f(Q,...Z){l(J0,Q,...Z)}var S0=Symbol("RESET");function W0(Q,...Z){f(Q,...[...Z,S0])}function WZ(Q,Z,q){let z,H,X,{type:Y,key:G}=Z;switch(Z.type){case"writable_pure_selector":z=y(Q,Z,"mut"),H=A0(q,z),H=w(Q,Z,H);break;case"writable_held_selector":X=Z.const,A0(q,X),z=X,H=X}return Q.logger.info("\u2B50",Y,G,"setting to",H),V0(Q,G),Z.setSelf(H),{oldValue:z,newValue:H}}var _Z=(Q,Z,q)=>{let z;switch(Z.type){case"atom":case"mutable_atom":z=K0(Q,Z,q);break;case"writable_pure_selector":case"writable_held_selector":z=WZ(Q,Z,q);break}return z},J0=Symbol("OWN_OP"),k0=Symbol("JOIN_OP");function l(Q,Z,...q){let z,H,X,Y,G,N;if(q.length===2){if(X=q[0],N=q[1],"family"in X)if(Y=g0(Z,X),G=R(X.family.subKey),z=e(Z,Y,G),!z)X=H=t(o,Z,Y,G);else X=z}else if(Y=B(Z,q[0]),G=q[1],N=q[2],z=e(Z,Y,G),!z)X=H=t(o,Z,Y,G);else X=z;let j=N===S0?"reset":"set",W;if(Q===J0){let $=OQ(Z,X);if(typeof $==="number"){let J=$,V=Z.on.operationClose.subscribe(`waiting to ${j} "${X.key}" at T-${J}`,function(){V(),Z.logger.info("\uD83D\uDFE2",X.type,X.key,"resuming deferred",j,`from T-${J}`),l(Q,Z,X,N)});return}W=$}else W=Z;if("counterfeit"in X&&"family"in X){let $=X.family.subKey,J=Z.disposalTraces.buffer.find((V)=>V?.key===$);Z.logger.error("\u274C",X.type,X.key,"could not be",j,"because key",$,"is not allocated.",J?`this key was previously disposed:${J.trace}`:"(no previous disposal trace found)");return}let _=B(W,X),D;if(N===S0)D=GZ(W,_);else D=_Z(W,_,N);if(f0(W,_,D,Boolean(H),Y),Q===J0)MQ(W)}var FQ=(Q,Z)=>C(Q).atoms.has(Z),NZ=(Q,Z)=>C(Q).writableSelectors.has(Z),jZ=(Q,Z)=>C(Q).readonlySelectors.has(Z),DZ=(Q,Z)=>FQ(Q,Z)||NZ(Q,Z)||jZ(Q,Z);function $Q(Q,Z){return C(Q).selectorGraph.getRelationEntries({downstreamSelectorKey:Z}).filter(([q,{source:z}])=>z!==Z).map(([q,{source:z}])=>z).filter((q)=>DZ(Q,q))}function Q0(Q,Z,q=new Set){let z=$Q(Q,Z),H=new Map;while(z.length>0){let X=z.pop();if(q.has(X))continue;if(q.add(X),FQ(Q,X)){let Y=Q.atoms.get(X);H.set(Y.key,Y)}else z.push(...$Q(Q,X))}return H}function $Z(Q,Z,q,z,H){let X=C(Q),{type:Y,key:G}=z;if(Y==="atom"||Y==="mutable_atom")X.selectorAtoms.set({selectorKey:q,atomKey:G}),Q.logger.info("\uD83D\uDD0D",Z,q,`discovers root atom "${G}"`);else{let N=Q0(Q,G,H);Q.logger.info("\uD83D\uDD0D",Z,q,`discovers root atoms: [ ${[...N.values()].map((j)=>`"${j.key}"`).join(", ")} ]`);for(let{key:j}of N.values())X.selectorAtoms=X.selectorAtoms.set({selectorKey:q,atomKey:j})}H.add(G)}function C0(Q,Z,q,z){return{get:(...H)=>{let X=C(Q),{token:Y,family:G,subKey:N}=b0(Q,...H),j;if("counterfeit"in Y&&G&&N)j=hQ(Q,Y,G,N);else j=y(Q,B(Q,Y));return Q.logger.info("\uD83D\uDD0C",Z,q,`registers dependency ( "${Y.key}" =`,j,")"),X.selectorGraph.set({upstreamSelectorKey:Y.key,downstreamSelectorKey:q},{source:Y.key}),$Z(Q,Z,q,Y,z),j},set:(...H)=>{l(k0,C(Q),...H)},find:(...H)=>M(Q,...H),json:(H)=>p(Q,H)}}function y0(Q,Z,q){let z=C(Q),H=new E,X=new Set,{key:Y,const:G}=Z,N="readonly_held_selector";Q.logger.info("\uD83D\uDD28","readonly_held_selector",Y,"is being created");let{get:j,find:W,json:_}=C0(z,"readonly_held_selector",Y,X),$={...Z,type:"readonly_held_selector",subject:H,getFrom:(V)=>{let P=V.selectorGraph.getRelationEntries({downstreamSelectorKey:Y});for(let[O,{source:L}]of P)if(L!==Y)V.selectorGraph.delete(O,Y);return V.selectorAtoms.delete(Y),Z.get({get:j,find:W,json:_},G),w(V,$,G),Q.logger.info("\u2728","readonly_held_selector",Y,"=",G),X.clear(),G},install:(V)=>y0(V,Z,q)};if(q)$.family=q;z.readonlySelectors.set(Y,$);let J={key:Y,type:"readonly_held_selector"};if(q)J.family=q;return J}function p0(Q,Z,q){let z=C(Q),H=new E,X=new Set,Y=Z.key,G="readonly_pure_selector";Q.logger.info("\uD83D\uDD28","readonly_pure_selector",Y,"is being created");let{get:N,find:j,json:W}=C0(z,"readonly_pure_selector",Y,X),D={...Z,type:"readonly_pure_selector",subject:H,getFrom:()=>{let J=C(Q),V=J.selectorGraph.getRelationEntries({downstreamSelectorKey:Y});for(let[O,{source:L}]of V)if(L!==Y)J.selectorGraph.delete(O,Y);J.selectorAtoms.delete(Y);let P=w(J,D,Z.get({get:N,find:j,json:W}));return Q.logger.info("\u2728","readonly_pure_selector",Y,"=",P),X.clear(),P},install:(J)=>p0(J,Z,q)};if(q)D.family=q;z.readonlySelectors.set(Y,D);let $={key:Y,type:"readonly_pure_selector"};if(q)$.family=q;return $}function m0(Q,Z,q){let z=C(Q),H=new E,X=new Set,{key:Y,const:G}=Z,N="writable_held_selector";Q.logger.info("\uD83D\uDD28","writable_held_selector",Y,"is being created");let j=C0(z,"writable_held_selector",Y,X),{find:W,get:_,json:D}=j,$={find:W,get:_,json:D},P={...Z,type:"writable_held_selector",subject:H,getFrom:(L)=>{let U=L.selectorGraph.getRelationEntries({downstreamSelectorKey:Y});for(let[d,{source:k}]of U)if(k!==Y)L.selectorGraph.delete(d,Y);return L.selectorAtoms.delete(Y),Z.get($,G),w(L,P,G),Q.logger.info("\u2728","writable_held_selector",Y,"=",G),X.clear(),G},setSelf:()=>{Z.set(j,G)},install:(L)=>m0(L,Z,q)};if(q)P.family=q;z.writableSelectors.set(Y,P);let O={key:Y,type:"writable_held_selector"};if(q)O.family=q;return O}function c0(Q,Z,q){let z=C(Q),H=new E,X=new Set,Y=Z.key,G="writable_pure_selector";Q.logger.info("\uD83D\uDD28","writable_pure_selector",Y,"is being created");let N=C0(z,"writable_pure_selector",Y,X),{find:j,get:W,json:_}=N,D={find:j,get:W,json:_},V={...Z,type:"writable_pure_selector",subject:H,getFrom:(O)=>{let L=O.selectorGraph.getRelationEntries({downstreamSelectorKey:Y});for(let[d,{source:k}]of L)if(k!==Y)O.selectorGraph.delete(d,Y);O.selectorAtoms.delete(Y);let U=w(O,V,Z.get(D));return Q.logger.info("\u2728","writable_pure_selector",Y,"=",U),X.clear(),U},setSelf:(O)=>{Z.set(N,O)},install:(O)=>c0(O,Z,q)};if(q)V.family=q;z.writableSelectors.set(Y,V);let P={key:Y,type:"writable_pure_selector"};if(q)P.family=q;return P}function zQ(Q,Z){let q="set"in Z,z="const"in Z;if(z&&q){let X=m0(Q,Z,void 0);return Q.on.selectorCreation.next(X),X}if(z){let X=y0(Q,Z,void 0);return Q.on.selectorCreation.next(X),X}if(q){let X=c0(Q,Z,void 0);return Q.on.selectorCreation.next(X),X}let H=p0(Q,Z,void 0);return Q.on.selectorCreation.next(H),H}function JZ(Q,Z){let q=C(Q),{key:z,type:H,family:X}=Z;if(!X)Q.logger.error("\u274C",H,z,"Standalone selectors cannot be disposed.");else{if(q.molecules.get(X.subKey))q.moleculeData.delete(X.subKey,X.key);let Y;switch(Z.type){case"writable_held_selector":q.writableSelectors.delete(z),Y={key:X.key,type:"writable_held_selector_family"},B(Q,Y).subject.next({type:"state_disposal",subType:"selector",token:Z,timestamp:Date.now()});break;case"writable_pure_selector":q.writableSelectors.delete(z),Y={key:X.key,type:"writable_pure_selector_family"},B(Q,Y).subject.next({type:"state_disposal",subType:"selector",token:Z,timestamp:Date.now()});break;case"readonly_held_selector":q.readonlySelectors.delete(z),Y={key:X.key,type:"readonly_held_selector_family"},B(Q,Y).subject.next({type:"state_disposal",subType:"selector",token:Z,timestamp:Date.now()});break;case"readonly_pure_selector":q.readonlySelectors.delete(z),Y={key:X.key,type:"readonly_pure_selector_family"},B(Q,Y).subject.next({type:"state_disposal",subType:"selector",token:Z,timestamp:Date.now()});break}if(q.valueMap.delete(z),q.selectorAtoms.delete(z),q.selectorGraph.delete(z),q.moleculeData.delete(X.key,X.subKey),Q.logger.info("\uD83D\uDD25",Z.type,z,"deleted"),F(q)&&q.transactionMeta.phase==="building")q.transactionMeta.update.subEvents.push({type:"state_disposal",subType:"selector",token:Z,timestamp:Date.now()});else Q.on.selectorDisposal.next(Z)}}var VZ=(Q,Z)=>{let q=C(Q);if(q.operation.open)return q.operation.prev.get(Z.key);return q.valueMap.get(Z.key)},JQ=(Q,Z,q)=>{return q.subject.subscribe(`${Z.type}:${Z.key}`,(z)=>{Q.logger.info("\uD83D\uDCE2",Z.type,Z.key,"root",q.key,"went",z.oldValue,"->",z.newValue);let H=VZ(Q,Z),X=y(Q,Z);Q.logger.info("\u2728",Z.type,Z.key,"went",H,"->",X),Z.subject.next({newValue:X,oldValue:H})})};function Z0(Q,Z,q,z){function H(_){if(Q.operation.open){if(X?.type==="atom"&&i0(X,"tracker:signal")&&"*"+Q.operation.token.key===Z.key&&"inboundTracker"in z)return;let D=Q.on.operationClose.subscribe(`state subscription ${q}`,()=>{D(),z(_)})}else z(_)}b0(Q,Z);let X=B(Q,Z);Q.logger.info("\uD83D\uDC40",X.type,X.key,`Adding subscription "${q}"`);let Y=X.type==="writable_pure_selector"||X.type==="readonly_pure_selector",G=new Map,N=H;if(Y){y(Q,X);for(let[_,D]of Q0(Q,X.key))G.set(_,JQ(Q,X,D));N=function(D){let $=Q0(Q,X.key);for(let[J,V]of G)if($.get(J))$.delete(J);else V(),G.delete(J);for(let[J,V]of $)G.set(J,JQ(Q,X,V));H(D)}}let j=X.subject.subscribe(q,N);return()=>{Q.logger.info("\uD83D\uDE48",X.type,X.key,`Removing subscription "${q}"`),j();for(let _ of G.values())_()}}var CZ=(Q,Z,q,z)=>{let H=B(Q,Z);Q.logger.info("\uD83D\uDC40","timeline",Z.key,`Adding subscription "${q}"`);let X=H.subject.subscribe(q,z);return()=>{Q.logger.info("\uD83D\uDE48","timeline",Z.key,`Removing subscription "${q}" from timeline`),X()}};var u0=class{initializeSignalAtom(Q,Z){let q=`*${Q.key}`;Z.atoms.delete(q),Z.valueMap.delete(q);let z=Q.family?{key:`*${Q.family.key}`,subKey:Q.family.subKey}:void 0,H=N0(Z,{key:q,default:null},z,["tracker:signal"]);if(Z.parent?.valueMap.has(q)){let X=Z.parent.valueMap.get(q);Z.valueMap.set(q,X)}return H}unsubscribeFromInnerValue;unsubscribeFromState;captureSignalsFromCore(Q,Z,q){let z=Q.key,H=`tracker-from-core:${q.config.name}:${F(q)?q.transactionMeta.update.token.key:"main"}:${z}`,X=(Y)=>{l(k0,q,Z,Y)};this.unsubscribeFromInnerValue=I(q,Q).subscribe(H,X),this.unsubscribeFromState=Z0(q,Q,H,function(G){if(G.newValue!==G.oldValue)this.unsubscribeFromInnerValue(),this.unsubscribeFromInnerValue=G.newValue.subscribe(H,X)}.bind(this))}supplySignalsToCore(Q,Z,q){let z=Q.key,H=`tracker-to-core:${q.config.name}:${F(q)?q.transactionMeta.update.token.key:"main"}:${z}`;Z0(q,Z,H,Object.assign(function({newValue:Y,oldValue:G}){let N=q.timelineTopics.getRelatedKey(Z.key);if(N&&q.timelines.get(N)?.timeTraveling){let j=CZ(q,{key:N,type:"timeline"},H,function(_){j(),f(q,Q,(D)=>{if(_==="redo"&&Y)D.do(Y);else if(_==="undo"&&G)D.undo(G);return D})});return}f(q,Q,(j)=>(j.do(Y),j))},{inboundTracker:!0}))}mutableAtomToken;latestSignalToken;[Symbol.dispose];constructor(Q,Z){let q=C(Z),z=this.initializeSignalAtom(Q,q);this.mutableAtomToken=Q,this.latestSignalToken=z,this.captureSignalsFromCore(Q,z,q),this.supplySignalsToCore(Q,z,q),q.trackers.set(Q.key,this),this[Symbol.dispose]=()=>{this.unsubscribeFromInnerValue(),this.unsubscribeFromState(),q.trackers.delete(Q.key)}}};function _0(Q,Z,q){Q.logger.info("\uD83D\uDD28","atom",Z.key,`creating in store "${Q.config.name}"`);let z=C(Q),{key:H}=Z,X=z.atoms.get(H),Y="mutable_atom";if(X?.type===Y&&Q.config.isProduction===!0)return Q.logger.error("\u274C",Y,H,"Tried to create atom, but it already exists in the store."),b(X);let G=new E,N={...Z,type:Y,install:(W)=>{return W.logger.info("\uD83D\uDEE0\uFE0F","atom",H,`installing in store "${W.config.name}"`),_0(W,Z,q)},subject:G};if(q)N.family=q;z.atoms.set(N.key,N);let j=b(N);if(new u0(j,Q),!q)zQ(Q,{key:`${H}:JSON`,get:({get:W})=>W(j).toJSON(),set:({set:W},_)=>{W(j,Z.class.fromJSON(_))}});if(Z.effects){let W=0,_=[];for(let D of Z.effects){let $=D({resetSelf:()=>{W0(Q,j)},setSelf:(J)=>{f(Q,j,J)},onSet:(J)=>Z0(Q,j,`effect[${W}]`,J),token:j,store:v0(Q)});if($)_.push($);++W}N.cleanup=()=>{for(let D of _)D()}}return Q.on.atomCreation.next(j),j}var EZ=class{trackers=new Map;latestSignalAtoms;mutableAtoms;constructor(Q,Z){this.latestSignalAtoms=B(Z,G0(Z,{key:`*${Q.key}`,default:null},["mutable","updates"])),this.mutableAtoms=Q;let q=(z)=>{let{type:H,token:X}=z;if(X.family){let Y=R(X.family.subKey);switch(H){case"state_creation":this.trackers.set(Y,new u0(X,Z));break;case"state_disposal":{let G=this.trackers.get(Y);if(G)G[Symbol.dispose](),this.trackers.delete(Y)}}}};this.mutableAtoms.subject.subscribe(`store=${Z.config.name}::tracker-atom-family`,q)}};function R0(Q,Z,q){let z={key:Z.key,type:"mutable_atom_family"},H=Q.families.get(Z.key);if(H&&Q.config.isProduction===!0)Q.logger.error("\u2757","mutable_atom_family",Z.key,`Overwriting an existing ${S[H.type]} "${H.key}" in store "${Q.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);let X=new E,G={...z,create:(N)=>{let j=h(N),W={key:Z.key,subKey:j},_=`${Z.key}(${j})`,D=C(Q),$={key:_,class:Z.class};if(Z.effects)$.effects=Z.effects(N);return _0(D,$,W)},class:Z.class,subject:X,install:(N)=>R0(N,Z),internalRoles:q};return Q.families.set(Z.key,G),d0(Q,{key:`${Z.key}:JSON`,get:(N)=>({get:j})=>j(z,N).toJSON(),set:(N)=>({set:j},W)=>{j(z,N,Z.class.fromJSON(W))}},["mutable","json"]),new EZ(G,Q),z}var BZ=(Q,Z)=>{let q=C(Z),z=`${Q.key}:JSON`;return q.families.get(z)},p=(Q,Z)=>{if(Z.family)return M(Q,B(C(Q),{key:`${Z.family.key}:JSON`,type:"writable_pure_selector_family"}),R(Z.family.subKey));return{type:"writable_pure_selector",key:`${Z.key}:JSON`}};var j0=(Q)=>{let Z={type:"atom",key:`*${Q.key}`};if(Q.family)Z.family={key:`*${Q.family.key}`,subKey:Q.family.subKey};return Z};function w0(Q){return typeof Q==="object"&&Q!==null&&"do"in Q&&"undo"in Q&&"subscribe"in Q&&"READONLY_VIEW"in Q&&"toJSON"in Q}function w(Q,Z,q){let{key:z,subject:H,type:X}=Z,Y=Q.valueMap.get(z);if(Y instanceof I0&&!Y.done){let G=Y;if(q instanceof Promise)return G.use(q),G;return Q.valueMap.set(z,q),q}if(q instanceof Promise){let G=new I0(q);return Q.valueMap.set(z,G),G.then(function(j){if(Q.valueMap.get(z)===G){switch(OQ(Q,Z),w(Q,Z,j),X){case"atom":l0(Q,Z);break;case"readonly_pure_selector":case"writable_pure_selector":xQ(Q,z);break}MQ(Q),H.next({newValue:j,oldValue:G})}}).catch((N)=>{Q.logger.error("\uD83D\uDCA5",Z.type,z,"rejected:",N)}),G}return Q.logger.info("\uD83D\uDCDD",Z.type,Z.key,"writing to cache",q),Q.valueMap.set(z,q),q}function hZ(Q,Z,q){Q.logger.info("\uD83D\uDCD6",Z.type,Z.key,"reading cached value");let z=Q.valueMap.get(Z.key);if(q==="mut"&&Z.type==="mutable_atom"&&F(Q)){let H=Z,{parent:X}=Q;if(Q.valueMap.hasOwn(H.key))return z;let Y=X.valueMap.get(H.key);Q.logger.info("\uD83D\uDCC3","atom",H.key,"copying");let G=Y.toJSON(),N=H.class.fromJSON(G);Q.valueMap.set(H.key,N),new u0(H,X),z=N}return z}function UQ(Q,Z){let q=Q.valueMap.get(Z);if(q instanceof I0){let z=Q.writableSelectors.get(Z)??Q.readonlySelectors.get(Z);if(z)z.getFrom(Q);return}if(Q.operation.open)Q.operation.prev.set(Z,q);Q.valueMap.delete(Z),Q.logger.info("\uD83D\uDDD1","state",Z,"evicted")}function l0(Q,Z){let q=C(Q),{key:z,type:H}=Z,X=q.selectorAtoms.getRelatedKeys(z);if(q.logger.info("\uD83E\uDDF9",H,z,X?`evicting ${X.size} states downstream:`:"no downstream states",X??"to evict"),X){if(q.operation.open)q.logger.info("\uD83E\uDDF9",H,z,`[ ${[...q.operation.done].join(", ")} ] already done`);for(let Y of X){if(RQ(q,Y))continue;UQ(q,Y),V0(q,Y)}}}function xQ(Q,Z){let q=C(Q),z=q.selectorGraph.getRelationEntries({upstreamSelectorKey:Z}).filter(([H,{source:X}])=>X===Z);for(let[H]of z){if(RQ(q,H))continue;UQ(q,H),V0(q,H),xQ(Q,H)}}function N0(Q,Z,q,z){let{key:X}=Z;Q.logger.info("\uD83D\uDD28","atom",X,"is being created");let Y=C(Q),G=Y.atoms.get(X);if(G?.type==="atom"&&Q.config.isProduction===!0)return Q.logger.error("\u274C","atom",X,"Tried to create atom, but it already exists in the store."),b(G);let N=new E,j={...Z,type:"atom",install:(_)=>{return _.logger.info("\uD83D\uDEE0\uFE0F","atom",X,`installing in store "${_.config.name}"`),N0(_,Z,q)},subject:N};if(q)j.family=q;if(z)j.internalRoles=z;Y.atoms.set(X,j);let W=b(j);if(Z.effects){let _=0,D=[];for(let $ of Z.effects){let J=$({resetSelf:()=>{W0(Q,W)},setSelf:(V)=>{f(Q,W,V)},onSet:(V)=>Z0(Q,W,`effect[${_}]`,V),token:W,store:v0(Q)});if(J)D.push(J);++_}j.cleanup=()=>{for(let $ of D)$()}}return Q.on.atomCreation.next(W),W}function i0(Q,Z){if("internalRoles"in Q===!1)return!1;return Q.internalRoles.includes(Z)}function wQ(Q,Z){let q=C(Q),{key:z,family:H}=Z,X=B(q,Z);if(!H)Q.logger.error("\u274C","atom",z,"Standalone atoms cannot be disposed.");else{X.cleanup?.();let Y=Q.valueMap.get(X.key),G=B(Q,g0(Q,Z)).subject,N={type:"state_disposal",subType:"atom",token:Z,value:Y,timestamp:Date.now()};G.next(N);let j=F(q);if(q.atoms.delete(z),q.valueMap.delete(z),q.selectorAtoms.delete(z),q.atomsThatAreDefault.delete(z),q.moleculeData.delete(H.key,H.subKey),Q.timelineTopics.delete(z),Z.type==="mutable_atom")wQ(Q,j0(Z)),Q.trackers.delete(z);if(Q.logger.info("\uD83D\uDD25","atom",z,"deleted"),j&&q.transactionMeta.phase==="building"){let W=q.transactionMeta.update.subEvents.at(-1),_=W?.type==="molecule_disposal"&&W.values.some(([$])=>$===X.family?.key),D=i0(X,"tracker:signal");if(!_&&!D)q.transactionMeta.update.subEvents.push(N)}else Q.on.atomDisposal.next(Z)}}function x(Q){return Q[0].toUpperCase()+Q.slice(1)}var AQ=class{toolkit;options;relations;states;relatedKeysAtoms;transact(Q,Z){let q=this.toolkit;this.toolkit=Q,Z(this),this.toolkit=q}store;[Symbol.dispose](){}constructor(Q,Z=A.STORE){this.store=Z,this.options=Q,this.store.miscResources.set(`join:${Q.key}`,this),this.toolkit={get:(...W)=>I(Z,...W),set:(...W)=>{f(Z,...W)},find:(...W)=>M(Z,...W),json:(W)=>p(Z,W)};let q=Q.between[0],z=Q.between[1],H=R0(Z,{key:`${Q.key}/relatedKeys`,class:v},["join","relations"]);this.relatedKeysAtoms=H;let X=(W,_,D)=>{let{find:$,get:J,set:V}=W,P=$(H,_),O=J(P);for(let L of O){if(D.includes(L))continue;V(H,L,(U)=>{return U.delete(_),U})}V(P,(L)=>{L.clear();for(let U of D){let d=$(H,U),k=J(d),r0=k.has(_);if(this.relations.cardinality==="1:n"){let i=[];for(let g of k){if(g===_)continue;let s0;if(l(k0,this.store,H,g,(E0)=>{return E0.delete(U),s0=E0.size,E0}),s0===0)i.push(g)}if(!r0&&k.size>0)V(d,(g)=>{return g.clear(),g});for(let g of i)Z.keyRefsInJoins.delete(a(U,g))}if(!r0)V(d,(i)=>{return i.add(_),i});L.add(U)}return L})},Y=(W,_,D)=>{let{set:$}=W;$(H,_,(J)=>{for(let V of D)J.add(V);return J});for(let J of D)$(H,J,(V)=>{return V.add(_),V});return!0},G=new T(Q,{externalStore:{getRelatedKeys:(W)=>this.toolkit.get(H,W),addRelation:(W,_)=>{this.store.keyRefsInJoins.set(`"${W}"`,Q.key),this.store.keyRefsInJoins.set(`"${_}"`,Q.key),this.store.keyRefsInJoins.set(a(W,_),Q.key),this.toolkit.set(H,W,(D)=>D.add(_)),this.toolkit.set(H,_,(D)=>D.add(W))},deleteRelation:(W,_)=>{this.toolkit.set(H,W,($)=>{return $.delete(_),$}),this.toolkit.set(H,_,($)=>{return $.delete(W),$});let D=a(W,_);this.store.keyRefsInJoins.delete(D)},replaceRelationsSafely:(W,_)=>{X(this.toolkit,W,_)},replaceRelationsUnsafely:(W,_)=>{Y(this.toolkit,W,_)},has:(W,_)=>{let D=this.toolkit.get(H,W);return _?D.has(_):D.size>0}},isAType:Q.isAType,isBType:Q.isBType}),N=()=>$0(Z,{key:`${Q.key}/singleRelatedKey`,get:(W)=>({get:_})=>{let D=_(H,W);for(let $ of D)return $;return null}},["join","keys"]),j=()=>{return $0(Z,{key:`${Q.key}/multipleRelatedKeys`,get:(W)=>({get:_})=>{return _(BZ(H,Z),W)}},["join","keys"])};switch(Q.cardinality){case"1:1":{let W=N(),_=`${q}KeyOf${x(z)}`,D=`${z}KeyOf${x(q)}`;this.relations=G,this.states={[_]:W,[D]:W};break}case"1:n":{let W=N(),_=j(),D=`${q}KeyOf${x(z)}`,$=`${z}KeysOf${x(q)}`,J={[D]:W,[$]:_};this.relations=G,this.states=J;break}case"n:n":{let W=j(),_=`${q}KeysOf${x(z)}`,D=`${z}KeysOf${x(q)}`;this.relations=G,this.states={[_]:W,[D]:W}}}}};function HQ(Q,Z){return Q.joins.set(Z.key,new AQ(Z)),{key:Z.key,type:"join",a:Z.between[0],b:Z.between[1],cardinality:Z.cardinality}}function a0(Q,Z){let q=Z.joins.get(Q.key);if(q===void 0){let z=A.STORE.joins.get(Q.key);if(z===void 0)throw Error(`Join "${Q.key}" not found in store "${Z.config.name}"`);let H=v0(Z);q=new AQ(z.options,H),Z.joins.set(Q.key,q)}return q}function r(Q,Z,q){let z=a0(Q,q),H=C(q);if(F(H)){let{toolkit:X}=H.transactionMeta;z.transact(X,({relations:Y})=>{Z(Y)})}else Z(z.relations)}function kQ(Q,Z,q){let z=a0(Q,q),H;switch(Q.cardinality){case"1:1":{let X=`${Q.a}KeyOf${x(Q.b)}`,Y=`${Q.b}KeyOf${x(Q.a)}`;H={get[X](){let G=z.states[X];return M(q,G,Z)},get[Y](){let G=z.states[Y];return M(q,G,Z)}};break}case"1:n":{let X=`${Q.a}KeyOf${x(Q.b)}`,Y=`${Q.b}KeysOf${x(Q.a)}`;H={get[X](){let G=z.states[X];return M(q,G,Z)},get[Y](){let G=z.states[Y];return M(q,G,Z)}};break}case"n:n":{let X=`${Q.a}KeysOf${x(Q.b)}`,Y=`${Q.b}KeysOf${x(Q.a)}`;H={get[X](){let G=z.states[X];return M(q,G,Z)},get[Y](){let G=z.states[Y];return M(q,G,Z)}}}}return H}function XQ(Q,Z){return a0(Q,Z).relatedKeysAtoms}var LZ=c({key:"mutex",default:!1}),PZ=class extends Map{set(Q,Z){if(this.has(Q))return console.warn("Tried to set a key that already exists in an InvariantMap",{key:Q,value:Z}),this;return super.set(Q,Z)}},_3=class Q{type="continuity";globals=[];actions=[];perspectives=[];key;constructor(Z){this.key=Z}static existing=new PZ;static create(Z,q){let{type:z,globals:H,actions:X,perspectives:Y}=q(new Q(Z)),G={type:z,key:Z,globals:H,actions:X,perspectives:Y};return Q.existing.set(Z,G),G}add(...Z){switch(Z[0].type){case"atom":case"mutable_atom":this.globals.push(...Z);break;case"transaction":this.actions.push(...Z);break;case"atom_family":case"mutable_atom_family":{let[q,z]=Z;this.perspectives.push({type:"realtime_perspective",resourceAtoms:q,viewAtoms:z})}break}return this}};var N3=m({key:"usersInRoomIndex",class:v}),IQ=m({key:"roomIndex",class:v});var q0=H0({key:"usersInRooms",between:["room","user"],cardinality:"1:n",isAType:(Q)=>typeof Q==="string",isBType:(Q)=>typeof Q==="string"}),j3=X0({key:"usersInMyRoomView",get:(Q)=>({find:Z})=>{return[Z(o0(q0),Q)]}});var P3=c({key:"redactor",default:{occlude:(Q)=>Q}}),O3=c({key:"unacknowledgedUpdates",default:()=>[]});var n0=class{listeners;globalListeners;handleEvent(...Q){let[Z,...q]=Q;for(let H of this.globalListeners)H(Z,...q);let z=this.listeners.get(Z);if(z)for(let H of z)H(...q)}id="no_id_retrieved";emit;constructor(Q){this.emit=Q,this.listeners=new Map,this.globalListeners=new Set}on(Q,Z){let q=this.listeners.get(Q);if(q)q.add(Z);else this.listeners.set(Q,new Set([Z]));return this}onAny(Q){return this.globalListeners.add(Q),this}off(Q,Z){let q=this.listeners.get(Q);if(q)if(Z)q.delete(Z);else this.listeners.delete(Q);return this}offAny(Q){return this.globalListeners.delete(Q),this}},M3=class extends n0{incompleteData="";unprocessedEvents=[];incompleteLog="";unprocessedLogs=[];id="#####";proc;key;logger;handleLog(Q){if(Array.isArray(Q)){let[Z,...q]=Q;switch(Z){case"i":this.logger.info(...q);break;case"w":this.logger.warn(...q);break;case"e":this.logger.error(...q);break}}}constructor(Q,Z,q){super((z,...H)=>{let X=JSON.stringify([z,...H])+"\x03",Y=(G)=>{if(G.code==="EPIPE")console.error("EPIPE error during write",this.proc.stdin);this.proc.stdin.removeListener("error",Y)};return this.proc.stdin.once("error",Y),this.proc.stdin.write(X),this});if(this.proc=Q,this.key=Z,this.logger=q??{info:(...z)=>{console.info(this.id,this.key,...z)},warn:(...z)=>{console.warn(this.id,this.key,...z)},error:(...z)=>{console.error(this.id,this.key,...z)}},this.proc.stdout.on("data",(z)=>{let H=z.toString();if(H==="ALIVE"){this.logger.info(H);return}let X=H.split("\x03"),Y=X[0];X[0]=this.incompleteData+Y;let G=0;for(let N of X){if(N==="")continue;try{let j=R(N);this.handleEvent(...j),this.incompleteData=""}catch(j){if(j instanceof Error)console.error(["\u274C Malformed data received from child process","",N,"",j.message].join(`
-\u274C	`));try{if(G===0){this.incompleteData=N;let W=R(Y);this.handleEvent(...W),this.incompleteData=""}else this.incompleteData+=N}catch(W){if(W instanceof Error)console.error(["\u274C Malformed data received from child process","",Y,"",W.message].join(`
-\u274C	`))}}++G}}),this.proc.stderr.on("data",(z)=>{let H=z.toString().split("\x03"),X=H[0];H[0]=this.incompleteData+X;let Y=0;for(let G of H){if(G==="")continue;try{let N=R(G);this.handleLog(N),this.incompleteData=""}catch(N){if(N instanceof Error)console.error(["\u274C Malformed log received from child process","",G,"",N.message].join(`
-\u274C	`));try{if(Y===0){this.incompleteData=G;let j=R(X);this.handleLog(j),this.incompleteData=""}else this.incompleteData+=G}catch(j){if(j instanceof Error)console.error(["\u274C Malformed log received from child process...","",X,"",j.message].join(`
-\u274C	`))}}++Y}}),Q.pid)this.id=Q.pid.toString()}},OZ=class extends n0{in;out;id="no_id_retrieved";disposalFunctions=[];constructor(Q){super((...Z)=>{return this.out.next(Z),this});this.id=Q,this.in=new E,this.out=new E,this.in.subscribe("socket",(Z)=>{this.handleEvent(...Z)})}dispose(){for(let Q of this.disposalFunctions)Q()}},KQ=class extends n0{incompleteData="";unprocessedEvents=[];relays;relayServices;proc;id="#####";log(...Q){this.proc.stderr.write(h(Q.map((Z)=>Z instanceof v?`{ ${Z.toJSON().join(" | ")} }`:Z))+"\x03")}logger={info:(...Q)=>{this.log("i",...Q)},warn:(...Q)=>{this.log("w",...Q)},error:(...Q)=>{this.log("e",...Q)}};constructor(Q){super((Z,...q)=>{let z=JSON.stringify([Z,...q]);return this.proc.stdout.write(z+"\x03"),this});if(this.proc=Q,this.proc.stdin.resume(),this.relays=new Map,this.relayServices=[],this.proc.stdin.on("data",(Z)=>{let q=Z.toString().split("\x03"),z=q[0];q[0]=this.incompleteData+z;let H=0;for(let X of q){if(X==="")continue;try{let Y=R(X);this.logger.info("\uD83C\uDFB0","received",Y),this.handleEvent(...Y),this.incompleteData=""}catch(Y){if(Y instanceof Error)this.logger.error(["received malformed data from parent process:","",X,"",Y.message].join(`
-\u274C	`));try{if(H===0){this.incompleteData=X;let G=R(z);this.logger.info("\uD83C\uDFB0","received",G),this.handleEvent(...G),this.incompleteData=""}else this.incompleteData+=X}catch(G){if(G instanceof Error)this.logger.error(["received malformed data from parent process:","",z,"",G.message].join(`
-\u274C	`))}}++H}}),this.on("exit",()=>{this.logger.info("\uD83D\uDD25",this.id,'received "exit"'),this.proc.exit(0)}),this.proc.pid)this.id=this.proc.pid?.toString();this.on("user-joins",(Z)=>{this.logger.info("\uD83D\uDC64","user",Z,"joined");let q=`user::${Z}`,z=new OZ(q);this.relays.set(Z,z),this.logger.info("\uD83D\uDD17","attaching services:",`[${[...this.relayServices.keys()].join(", ")}]`);for(let H of this.relayServices){let X=H(z,q);if(X)z.disposalFunctions.push(X)}this.on(q,(...H)=>{z.in.next(H)}),z.out.subscribe("socket",(H)=>{this.emit(...H)})}),this.on("user-leaves",(Z)=>{let q=this.relays.get(Z);if(this.off(`relay:${Z}`),q)q.dispose(),this.relays.delete(Z)}),this.proc.stdout.write("ALIVE")}receiveRelay(Q){this.logger.info("\uD83D\uDD17","running relay method"),this.relayServices.push(Q)}};var fQ=new Map;var R3=Y0({key:"joinRoom",do:(Q,Z,q,z)=>{let H={enteredAtEpoch:z};return r(q0,(X)=>{X.set({room:Z,user:q})},Q.env().store),H}}),F3=Y0({key:"leaveRoom",do:({env:Q},Z,q)=>{r(q0,(z)=>{z.delete({room:Z,user:q})},Q().store)}}),U3=Y0({key:"destroyRoom",do:({set:Q,env:Z},q)=>{r(q0,(H)=>{H.delete({room:q})},Z().store),Q(IQ,(H)=>(H.delete(q),H));let z=fQ.get(q);if(z)z.emit("exit"),fQ.delete(q)}}),x3=c({key:"sockets",default:null}),w3=m({key:"socketsIndex",class:v}),A3=m({key:"usersIndex",class:v}),I3=H0({key:"usersOfSockets",between:["user","socket"],cardinality:"1:1",isAType:(Q)=>Q.startsWith("user::"),isBType:(Q)=>Q.startsWith("socket::")}),f3=X0({key:"userMutualSituationalAwarenessIndexes",get:(Q)=>()=>{return[Q]}});var z0=new KQ(process);Object.assign(console,z0.logger,{log:z0.logger.info});z0.on("timeToStop",function(){z0.logger.info("\uD83D\uDEEC game worker exiting"),process.exit(0)});z0.logger.info("\uD83D\uDEEB game worker ready");
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
+    return;
+  }
+  molecule.subject.next();
+  const joinKeys = target.keyRefsInJoins.getRelatedKeys(stringKey);
+  if (joinKeys)
+    for (const joinKey of joinKeys) {
+      const join$1 = target.joins.get(joinKey);
+      if (join$1)
+        join$1.relations.delete(claim);
+    }
+  else {
+    const compound = decomposeCompound(claim);
+    if (compound) {
+      const [, a, b] = compound;
+      const joinKey = target.keyRefsInJoins.getRelatedKey(simpleCompound(a, b));
+      if (joinKey) {
+        const join$1 = target.joins.get(joinKey);
+        if (join$1)
+          join$1.relations.delete(a, b);
+      }
+    }
+  }
+  target.keyRefsInJoins.delete(stringKey);
+  const provenance = [];
+  const values = [];
+  const relatedMolecules = target.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: stringKey });
+  if (relatedMolecules)
+    for (const [relatedStringKey, { source }] of relatedMolecules)
+      if (source === stringKey)
+        deallocateFromStore(target, parseJson(relatedStringKey));
+      else
+        provenance.push(source);
+  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
+  if (familyKeys)
+    for (const familyKey of familyKeys) {
+      const family = target.families.get(familyKey);
+      const value = getFromStore(target, family, claim);
+      values.push([family.key, value]);
+      disposeFromStore(target, family, claim);
+    }
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    key: molecule.key,
+    values,
+    provenance,
+    timestamp: Date.now()
+  };
+  target.molecules.delete(stringKey);
+  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction)
+    target.transactionMeta.update.subEvents.push(disposalEvent);
+  target.moleculeGraph.delete(molecule.stringKey);
+  target.keyRefsInJoins.delete(molecule.stringKey);
+  target.moleculeData.delete(molecule.stringKey);
+  if (!isTransaction)
+    target.on.moleculeDisposal.next(disposalEvent);
+  target.molecules.delete(molecule.stringKey);
+  const trace = getTrace(/* @__PURE__ */ new Error);
+  target.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`, `key`, stringKey, `claim failed:`, `Could not allocate to ${stringKey} in store "${store.config.name}".`, disposal ? `
+   ${stringKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
+    return claim;
+  }
+  const newProvenanceKey = stringifyJson(newProvenance);
+  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
+  if (!newProvenanceMolecule) {
+    const disposal = store.disposalTraces.buffer.find((item) => item?.key === newProvenanceKey);
+    store.logger.error(`\u274C`, `key`, claim, `claim failed:`, `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`, disposal ? `
+   ${newProvenanceKey} was most recently disposed
+${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`);
+    return claim;
+  }
+  const priorProvenance = store.moleculeGraph.getRelationEntries({ downstreamMoleculeKey: molecule.stringKey }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
+  if (exclusive)
+    target.moleculeGraph.delete(stringKey);
+  target.moleculeGraph.set({
+    upstreamMoleculeKey: newProvenanceMolecule.stringKey,
+    downstreamMoleculeKey: molecule.stringKey
+  }, { source: newProvenanceMolecule.stringKey });
+  const transferEvent = {
+    type: `molecule_transfer`,
+    key: molecule.key,
+    exclusive: Boolean(exclusive),
+    from: priorProvenance,
+    to: [newProvenanceMolecule.key],
+    timestamp: Date.now()
+  };
+  if (isChildStore(target) && target.transactionMeta.phase === `building`)
+    target.transactionMeta.update.subEvents.push(transferEvent);
+  return claim;
+}
+function ingestCreationEvent(store, event, applying) {
+  switch (applying) {
+    case `newValue`:
+      createInStore(store, event);
+      break;
+    case `oldValue`:
+      disposeFromStore(store, event.token);
+      break;
+  }
+}
+function ingestDisposalEvent(store, event, applying) {
+  switch (applying) {
+    case `newValue`:
+      disposeFromStore(store, event.token);
+      break;
+    case `oldValue`:
+      createInStore(store, event);
+      if (event.subType === `atom`)
+        store.valueMap.set(event.token.key, event.value);
+      break;
+  }
+}
+function createInStore(store, event) {
+  const { token } = event;
+  if (event.subType === `writable` && event.value)
+    setIntoStore(store, token, event.value);
+  else
+    getFromStore(store, token);
+}
+function ingestMoleculeCreationEvent(store, event, applying) {
+  switch (applying) {
+    case `newValue`:
+      allocateIntoStore(store, event.provenance, event.key);
+      break;
+    case `oldValue`:
+      deallocateFromStore(store, event.key);
+      break;
+  }
+}
+function ingestMoleculeDisposalEvent(store, event, applying) {
+  switch (applying) {
+    case `newValue`:
+      deallocateFromStore(store, event.key);
+      break;
+    case `oldValue`:
+      allocateIntoStore(store, event.provenance.map(parseJson), event.key);
+      for (const [familyKey, value] of event.values) {
+        const family = store.families.get(familyKey);
+        if (family) {
+          getFromStore(store, family, event.key);
+          const memberKey = `${familyKey}(${stringifyJson(event.key)})`;
+          store.valueMap.set(memberKey, value);
+        }
+      }
+      break;
+  }
+}
+function ingestMoleculeTransferEvent(store, event, applying) {
+  switch (applying) {
+    case `newValue`:
+      for (const newOwner of event.to)
+        claimWithinStore(store, newOwner, event.key, event.exclusive ? `exclusive` : undefined);
+      break;
+    case `oldValue`:
+      {
+        let exclusivity = `exclusive`;
+        for (const previousOwner of event.from) {
+          claimWithinStore(store, previousOwner, event.key, exclusivity);
+          exclusivity = undefined;
+        }
+      }
+      break;
+  }
+}
+function ingestTransactionOutcomeEvent(store, event, applying) {
+  const subEvents = applying === `newValue` ? event.subEvents : [...event.subEvents].reverse();
+  for (const subEvent of subEvents)
+    switch (subEvent.type) {
+      case `atom_update`:
+        ingestAtomUpdateEvent(store, subEvent, applying);
+        break;
+      case `state_creation`:
+        ingestCreationEvent(store, subEvent, applying);
+        break;
+      case `state_disposal`:
+        ingestDisposalEvent(store, subEvent, applying);
+        break;
+      case `molecule_creation`:
+        ingestMoleculeCreationEvent(store, subEvent, applying);
+        break;
+      case `molecule_disposal`:
+        ingestMoleculeDisposalEvent(store, subEvent, applying);
+        break;
+      case `molecule_transfer`:
+        ingestMoleculeTransferEvent(store, subEvent, applying);
+        break;
+      case `transaction_outcome`:
+        ingestTransactionOutcomeEvent(store, subEvent, applying);
+        break;
+    }
+}
+function isRootStore(store) {
+  return `epoch` in store.transactionMeta;
+}
+function isChildStore(store) {
+  return `phase` in store.transactionMeta;
+}
+function getContinuityKey(store, transactionKey) {
+  return store.transactionMeta.actionContinuities.getRelatedKey(transactionKey);
+}
+function getEpochNumberOfContinuity(store, continuityKey) {
+  return store.transactionMeta.epoch.get(continuityKey);
+}
+function getEpochNumberOfAction(store, transactionKey) {
+  const continuityKey = getContinuityKey(store, transactionKey);
+  if (continuityKey === undefined)
+    return;
+  return getEpochNumberOfContinuity(store, continuityKey);
+}
+function setEpochNumberOfAction(store, transactionKey, newEpoch) {
+  const continuityKey = getContinuityKey(store, transactionKey);
+  if (continuityKey !== undefined)
+    store.transactionMeta.epoch.set(continuityKey, newEpoch);
+}
+function applyTransaction(store, output) {
+  const child = newest(store);
+  const { parent } = child;
+  child.transactionMeta.phase = `applying`;
+  child.transactionMeta.update.output = output;
+  parent.child = null;
+  parent.on.transactionApplying.next(child.transactionMeta);
+  const { subEvents: updates } = child.transactionMeta.update;
+  store.logger.info(`\uD83D\uDEC4`, `transaction`, child.transactionMeta.update.token.key, `applying ${updates.length} subEvents:`, updates);
+  ingestTransactionOutcomeEvent(parent, child.transactionMeta.update, `newValue`);
+  if (isRootStore(parent)) {
+    setEpochNumberOfAction(parent, child.transactionMeta.update.token.key, child.transactionMeta.update.epoch);
+    withdraw(store, {
+      key: child.transactionMeta.update.token.key,
+      type: `transaction`
+    })?.subject.next(child.transactionMeta.update);
+    store.logger.info(`\uD83D\uDEEC`, `transaction`, child.transactionMeta.update.token.key, `applied`);
+  } else if (isChildStore(parent))
+    parent.transactionMeta.update.subEvents.push(child.transactionMeta.update);
+  parent.on.transactionApplying.next(null);
+}
+function getEnvironmentData(store) {
+  return { store };
+}
+var buildTransaction = (store, token, params, id) => {
+  const parent = newest(store);
+  const childBase = {
+    parent,
+    child: null,
+    on: parent.on,
+    loggers: parent.loggers,
+    logger: parent.logger,
+    config: parent.config,
+    atoms: new MapOverlay(parent.atoms),
+    atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
+    families: new MapOverlay(parent.families),
+    joins: new MapOverlay(parent.joins),
+    operation: { open: false },
+    readonlySelectors: new MapOverlay(parent.readonlySelectors),
+    timelines: new MapOverlay(parent.timelines),
+    timelineTopics: parent.timelineTopics.overlay(),
+    trackers: /* @__PURE__ */ new Map,
+    transactions: new MapOverlay(parent.transactions),
+    selectorAtoms: parent.selectorAtoms.overlay(),
+    selectorGraph: parent.selectorGraph.overlay(),
+    writableSelectors: new MapOverlay(parent.writableSelectors),
+    valueMap: new MapOverlay(parent.valueMap),
+    defaults: parent.defaults,
+    disposalTraces: store.disposalTraces.copy(),
+    molecules: new MapOverlay(parent.molecules),
+    moleculeGraph: parent.moleculeGraph.overlay(),
+    moleculeData: parent.moleculeData.overlay(),
+    keyRefsInJoins: parent.keyRefsInJoins.overlay(),
+    miscResources: new MapOverlay(parent.miscResources)
+  };
+  const epoch = getEpochNumberOfAction(store, token.key);
+  const transactionMeta = {
+    phase: `building`,
+    update: {
+      type: `transaction_outcome`,
+      token,
+      id,
+      epoch: epoch === undefined ? NaN : epoch + 1,
+      timestamp: Date.now(),
+      subEvents: [],
+      params,
+      output: undefined
+    },
+    toolkit: {
+      get: (...ps) => getFromStore(child, ...ps),
+      set: (...ps) => {
+        setIntoStore(child, ...ps);
+      },
+      reset: (...ps) => {
+        resetInStore(child, ...ps);
+      },
+      run: (t, identifier = arbitrary()) => actUponStore(child, t, identifier),
+      find: (...ps) => findInStore(store, ...ps),
+      json: (t) => getJsonToken(child, t),
+      dispose: (...ps) => {
+        disposeFromStore(child, ...ps);
+      },
+      env: () => getEnvironmentData(child)
+    }
+  };
+  const child = Object.assign(childBase, { transactionMeta });
+  parent.child = child;
+  store.logger.info(`\uD83D\uDEEB`, `transaction`, token.key, `building with params:`, params);
+  return child;
+};
+function createTransaction(store, options) {
+  const { key } = options;
+  const transactionAlreadyExists = store.transactions.has(key);
+  const newTransaction = {
+    key,
+    type: `transaction`,
+    run: (params, id) => {
+      const target = buildTransaction(store, deposit(newTransaction), params, id);
+      try {
+        const { toolkit } = target.transactionMeta;
+        const output = options.do(toolkit, ...params);
+        applyTransaction(target, output);
+        return output;
+      } catch (thrown) {
+        abortTransaction(target);
+        store.logger.warn(`\uD83D\uDCA5`, `transaction`, key, `caught:`, thrown);
+        throw thrown;
+      }
+    },
+    install: (s) => createTransaction(s, options),
+    subject: new Subject
+  };
+  newest(store).transactions.set(key, newTransaction);
+  const token = deposit(newTransaction);
+  if (!transactionAlreadyExists)
+    store.on.transactionCreation.next(token);
+  return token;
+}
+var Store = class {
+  parent = null;
+  child = null;
+  valueMap = /* @__PURE__ */ new Map;
+  defaults = /* @__PURE__ */ new Map;
+  atoms = /* @__PURE__ */ new Map;
+  writableSelectors = /* @__PURE__ */ new Map;
+  readonlySelectors = /* @__PURE__ */ new Map;
+  atomsThatAreDefault = /* @__PURE__ */ new Set;
+  selectorAtoms = new Junction({
+    between: [`selectorKey`, `atomKey`],
+    cardinality: `n:n`
+  });
+  selectorGraph = new Junction({
+    between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
+    cardinality: `n:n`
+  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+  trackers = /* @__PURE__ */ new Map;
+  families = /* @__PURE__ */ new Map;
+  joins = /* @__PURE__ */ new Map;
+  transactions = /* @__PURE__ */ new Map;
+  transactionMeta = {
+    epoch: /* @__PURE__ */ new Map,
+    actionContinuities: new Junction({
+      between: [`continuity`, `action`],
+      cardinality: `1:n`
+    })
+  };
+  timelines = /* @__PURE__ */ new Map;
+  timelineTopics = new Junction({
+    between: [`timelineKey`, `topicKey`],
+    cardinality: `1:n`
+  });
+  disposalTraces = new CircularBuffer(100);
+  molecules = /* @__PURE__ */ new Map;
+  moleculeGraph = new Junction({
+    between: [`upstreamMoleculeKey`, `downstreamMoleculeKey`],
+    cardinality: `n:n`
+  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+  moleculeData = new Junction({
+    between: [`moleculeKey`, `stateFamilyKey`],
+    cardinality: `n:n`
+  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+  keyRefsInJoins = new Junction({
+    between: [`moleculeKey`, `joinKey`],
+    cardinality: `n:n`
+  }, { makeContentKey: (...keys) => keys.sort().join(`:`) });
+  miscResources = /* @__PURE__ */ new Map;
+  on = {
+    atomCreation: new Subject,
+    atomDisposal: new Subject,
+    selectorCreation: new Subject,
+    selectorDisposal: new Subject,
+    timelineCreation: new Subject,
+    transactionCreation: new Subject,
+    transactionApplying: new StatefulSubject(null),
+    operationClose: new Subject,
+    moleculeCreation: new Subject,
+    moleculeDisposal: new Subject
+  };
+  operation = { open: false };
+  config = {
+    name: `IMPLICIT_STORE`,
+    lifespan: `ephemeral`,
+    isProduction: globalThis.process?.env?.[`NODE_ENV`] === `production`
+  };
+  loggers = [new AtomIOLogger(`warn`, (_, __, key) => !isReservedIntrospectionKey(key))];
+  logger = {
+    error: (...messages) => {
+      for (const logger of this.loggers)
+        logger.error(...messages);
+    },
+    info: (...messages) => {
+      for (const logger of this.loggers)
+        logger.info(...messages);
+    },
+    warn: (...messages) => {
+      for (const logger of this.loggers)
+        logger.warn(...messages);
+    }
+  };
+  constructor(config, store = null) {
+    this.config = {
+      ...store?.config,
+      ...config
+    };
+    if (store !== null) {
+      this.operation = { ...store?.operation };
+      if (isRootStore(store))
+        this.transactionMeta = {
+          epoch: new Map(store?.transactionMeta.epoch),
+          actionContinuities: new Junction(store?.transactionMeta.actionContinuities.toJSON())
+        };
+      for (const [, family] of store.families) {
+        if (family.internalRoles?.includes(`mutable`) || family.internalRoles?.includes(`join`))
+          continue;
+        family.install(this);
+      }
+      const mutableHelpers = /* @__PURE__ */ new Set;
+      for (const [, atom] of store.atoms) {
+        if (mutableHelpers.has(atom.key))
+          continue;
+        atom.install(this);
+        if (atom.type === `mutable_atom`) {
+          const originalJsonToken = getJsonToken(store, atom);
+          const originalUpdateToken = getUpdateToken(atom);
+          mutableHelpers.add(originalJsonToken.key);
+          mutableHelpers.add(originalUpdateToken.key);
+        }
+      }
+      for (const [, selector] of store.readonlySelectors)
+        selector.install(this);
+      for (const [, selector] of store.writableSelectors) {
+        if (mutableHelpers.has(selector.key))
+          continue;
+        selector.install(this);
+      }
+      for (const [, tx] of store.transactions)
+        tx.install(this);
+      for (const [, timeline] of store.timelines)
+        timeline.install(this);
+    }
+  }
+};
+var IMPLICIT = { get STORE() {
+  globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
+    name: `IMPLICIT_STORE`,
+    lifespan: `ephemeral`,
+    isProduction: globalThis.process?.env?.[`NODE_ENV`] === `production`
+  });
+  return globalThis.ATOM_IO_IMPLICIT_STORE;
+} };
+var NotFoundError = class extends Error {
+  constructor(token, store) {
+    super(`${PRETTY_TOKEN_TYPES[token.type]} ${stringifyJson(token.key)} not found in store "${store.config.name}".`);
+  }
+};
+function withdraw(store, token) {
+  let withdrawn;
+  let target = store;
+  while (target !== null) {
+    switch (token.type) {
+      case `atom`:
+      case `mutable_atom`:
+        withdrawn = target.atoms.get(token.key);
+        break;
+      case `writable_pure_selector`:
+      case `writable_held_selector`:
+        withdrawn = target.writableSelectors.get(token.key);
+        break;
+      case `readonly_pure_selector`:
+      case `readonly_held_selector`:
+        withdrawn = target.readonlySelectors.get(token.key);
+        break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+      case `writable_pure_selector_family`:
+      case `readonly_pure_selector_family`:
+      case `writable_held_selector_family`:
+      case `readonly_held_selector_family`:
+        withdrawn = target.families.get(token.key);
+        break;
+      case `timeline`:
+        withdrawn = target.timelines.get(token.key);
+        break;
+      case `transaction`:
+        withdrawn = target.transactions.get(token.key);
+        break;
+    }
+    if (withdrawn)
+      return withdrawn;
+    target = target.child;
+  }
+  throw new NotFoundError(token, store);
+}
+function getFallback(store, token, family, subKey) {
+  const disposal = store.disposalTraces.buffer.find((item) => item?.key === stringifyJson(subKey));
+  store.logger.error(`\u274C`, token.type, token.key, `gets a fallback value because key`, subKey, `is not allocated`, disposal ? `This key was previously disposed:
+${disposal.trace}` : `(no previous disposal trace found)`);
+  switch (family.type) {
+    case `mutable_atom_family`: {
+      if (store.defaults.has(family.key))
+        return store.defaults.get(family.key);
+      const defaultValue = new family.class;
+      store.defaults.set(family.key, defaultValue);
+      return defaultValue.READONLY_VIEW;
+    }
+    case `atom_family`: {
+      if (store.defaults.has(family.key))
+        return store.defaults.get(family.key);
+      const def = family.default;
+      const defaultValue = def(subKey);
+      store.defaults.set(family.key, defaultValue);
+      return defaultValue;
+    }
+    case `readonly_pure_selector_family`:
+    case `writable_pure_selector_family`:
+    case `readonly_held_selector_family`:
+    case `writable_held_selector_family`: {
+      if (store.defaults.has(family.key))
+        return store.defaults.get(family.key);
+      const defaultValue = family.default(subKey);
+      store.defaults.set(family.key, defaultValue);
+      return defaultValue;
+    }
+  }
+}
+function safeCompute(target, state) {
+  const { type, key, catch: canCatch } = state;
+  switch (type) {
+    case `readonly_pure_selector`:
+    case `writable_pure_selector`: {
+      let val;
+      target.logger.info(`\uD83E\uDDEE`, type, key, `computing value`);
+      try {
+        val = state.getFrom(target);
+        if (val instanceof Promise)
+          return val.catch((thrown) => {
+            target.logger.error(`\uD83D\uDCA5`, type, key, `rejected:`, thrown);
+            if (canCatch) {
+              for (const Class of canCatch)
+                if (thrown instanceof Class)
+                  return thrown;
+            }
+            throw thrown;
+          });
+      } catch (e) {
+        target.logger.error(`\uD83D\uDCA5`, type, key, `rejected:`, e);
+        if (canCatch) {
+          for (const Class of canCatch)
+            if (e instanceof Class)
+              return writeToCache(target, state, e);
+        }
+        throw e;
+      }
+      return writeToCache(target, state, val);
+    }
+    case `atom`: {
+      let def;
+      if (isFn(state.default))
+        try {
+          def = state.default();
+          if (def instanceof Promise)
+            def = def.catch((thrown) => {
+              target.logger.error(`\uD83D\uDCA5`, type, key, `rejected:`, thrown);
+              if (canCatch) {
+                for (const Class of canCatch)
+                  if (thrown instanceof Class)
+                    return thrown;
+              }
+              throw thrown;
+            });
+        } catch (e) {
+          target.logger.error(`\uD83D\uDCA5`, type, key, `rejected:`, e);
+          if (canCatch) {
+            for (const Class of canCatch)
+              if (e instanceof Class) {
+                def = writeToCache(target, state, e);
+                target.logger.info(`\u2728`, state.type, key, `computed default`, def);
+                return def;
+              }
+          }
+          throw e;
+        }
+      else {
+        def = state.default;
+        target.logger.info(`\u2728`, state.type, key, `using static default`, def);
+      }
+      return writeToCache(target, state, def);
+    }
+  }
+}
+function readOrComputeValue(target, state, mut) {
+  if (target.valueMap.has(state.key))
+    return readFromCache(target, state, mut);
+  target.logger.info(`\u2754`, state.type, state.key, `value not found in cache`);
+  const { key } = state;
+  switch (state.type) {
+    case `readonly_held_selector`:
+    case `writable_held_selector`:
+      target.logger.info(`\uD83E\uDDEE`, state.type, key, `computing value`);
+      return state.getFrom(target);
+    case `writable_pure_selector`:
+    case `readonly_pure_selector`:
+    case `atom`:
+      return safeCompute(target, state);
+    case `mutable_atom`: {
+      const instance = new state.class;
+      target.logger.info(`\u2728`, state.type, key, `created new instance`, instance);
+      return writeToCache(target, state, instance);
+    }
+  }
+}
+function getFamilyOfToken(store, token) {
+  return withdraw(store, {
+    key: token.family.key,
+    type: `${token.type}_family`
+  });
+}
+var FAMILY_MEMBER_TOKEN_TYPES = {
+  atom_family: `atom`,
+  molecule_family: `molecule`,
+  mutable_atom_family: `mutable_atom`,
+  readonly_held_selector_family: `readonly_held_selector`,
+  readonly_pure_selector_family: `readonly_pure_selector`,
+  writable_held_selector_family: `writable_held_selector`,
+  writable_pure_selector_family: `writable_pure_selector`
+};
+var MUST_CREATE = Symbol(`MUST_CREATE`);
+var DO_NOT_CREATE = Symbol(`DO_NOT_CREATE`);
+function mintInStore(mustCreate, store, family, key) {
+  const stringKey = stringifyJson(key);
+  const molecule = store.molecules.get(stringKey);
+  if (!molecule && store.config.lifespan === `immortal`) {
+    const { type: familyType, key: familyKey } = family;
+    store.logger.warn(`\uD83D\uDCA3`, `key`, stringKey, `was used to mint a counterfeit token for`, familyType, `"${familyKey}"`);
+    return {
+      counterfeit: true,
+      key: `${familyKey}(${stringKey})`,
+      type: FAMILY_MEMBER_TOKEN_TYPES[familyType],
+      family: {
+        key: familyKey,
+        subKey: stringKey
+      }
+    };
+  }
+  let token;
+  if (mustCreate === MUST_CREATE) {
+    store.logger.info(`\uD83D\uDC6A`, family.type, family.key, `adds member`, typeof key === `string` ? `\`${key}\`` : key);
+    token = family.create(key);
+    if (molecule)
+      store.moleculeData.set(stringKey, family.key);
+  } else {
+    const { type: familyType, key: familyKey } = family;
+    return {
+      key: `${familyKey}(${stringKey})`,
+      type: FAMILY_MEMBER_TOKEN_TYPES[familyType],
+      family: {
+        key: familyKey,
+        subKey: stringKey
+      }
+    };
+  }
+  return token;
+}
+function reduceReference(store, ...params) {
+  let existingToken;
+  let brandNewToken;
+  let family;
+  let subKey;
+  let token;
+  if (params.length === 1) {
+    token = params[0];
+    if (`family` in token) {
+      const familyToken = getFamilyOfToken(store, token);
+      family = withdraw(store, familyToken);
+      subKey = parseJson(token.family.subKey);
+      existingToken = seekInStore(store, familyToken, subKey);
+      if (`counterfeit` in token)
+        return {
+          token,
+          family,
+          subKey,
+          isNew: false
+        };
+      if (!existingToken) {
+        brandNewToken = mintInStore(MUST_CREATE, store, familyToken, subKey);
+        token = brandNewToken;
+      } else
+        token = existingToken;
+    }
+  } else {
+    family = withdraw(store, params[0]);
+    subKey = params[1];
+    existingToken = seekInStore(store, family, subKey);
+    if (!existingToken) {
+      brandNewToken = mintInStore(MUST_CREATE, store, family, subKey);
+      token = brandNewToken;
+    } else
+      token = existingToken;
+  }
+  const isCounterfeit = `counterfeit` in token;
+  if (Boolean(brandNewToken) && isCounterfeit === false && family) {
+    let subType;
+    switch (token.type) {
+      case `readonly_pure_selector`:
+      case `readonly_held_selector`:
+        subType = `readable`;
+        break;
+      case `atom`:
+      case `mutable_atom`:
+      case `writable_pure_selector`:
+      case `writable_held_selector`:
+        subType = `writable`;
+        break;
+    }
+    const stateCreationEvent = {
+      type: `state_creation`,
+      subType,
+      token,
+      timestamp: Date.now()
+    };
+    family.subject.next(stateCreationEvent);
+    const target = newest(store);
+    if (token.family) {
+      if (isRootStore(target))
+        switch (token.type) {
+          case `atom`:
+          case `mutable_atom`:
+            store.on.atomCreation.next(token);
+            break;
+          case `writable_pure_selector`:
+          case `readonly_pure_selector`:
+          case `writable_held_selector`:
+          case `readonly_held_selector`:
+            store.on.selectorCreation.next(token);
+            break;
+        }
+      else if (isChildStore(target) && target.on.transactionApplying.state === null)
+        target.transactionMeta.update.subEvents.push(stateCreationEvent);
+    }
+  }
+  return {
+    token,
+    family,
+    subKey,
+    isNew: Boolean(brandNewToken)
+  };
+}
+function getFromStore(store, ...params) {
+  const { token, family, subKey } = reduceReference(store, ...params);
+  if (`counterfeit` in token && family && subKey)
+    return getFallback(store, token, family, subKey);
+  return readOrComputeValue(store, withdraw(store, token));
+}
+function seekInStore(store, token, key) {
+  const subKey = stringifyJson(key);
+  const fullKey = `${token.key}(${subKey})`;
+  const target = newest(store);
+  let state;
+  switch (token.type) {
+    case `atom_family`:
+    case `mutable_atom_family`:
+      state = target.atoms.get(fullKey);
+      break;
+    case `writable_held_selector_family`:
+    case `writable_pure_selector_family`:
+      state = target.writableSelectors.get(fullKey);
+      break;
+    case `readonly_held_selector_family`:
+    case `readonly_pure_selector_family`:
+      state = target.readonlySelectors.get(fullKey);
+      break;
+  }
+  if (state)
+    return deposit(state);
+  return state;
+}
+function findInStore(store, familyToken, key) {
+  const family = withdraw(store, familyToken);
+  const existingStateToken = seekInStore(store, familyToken, key);
+  if (existingStateToken)
+    return existingStateToken;
+  return mintInStore(DO_NOT_CREATE, store, family, key);
+}
+function createReadonlyPureSelectorFamily(store, options, internalRoles) {
+  const familyKey = options.key;
+  const type = `readonly_pure_selector_family`;
+  const familyToken = {
+    key: familyKey,
+    type
+  };
+  const existing = store.families.get(familyKey);
+  if (existing && store.config.isProduction === true)
+    store.logger.error(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+  const subject = new Subject;
+  const create = (key) => {
+    const subKey = stringifyJson(key);
+    const family = {
+      key: familyKey,
+      subKey
+    };
+    const fullKey = `${familyKey}(${subKey})`;
+    const target = newest(store);
+    const individualOptions = {
+      key: fullKey,
+      get: options.get(key)
+    };
+    if (options.catch)
+      individualOptions.catch = options.catch;
+    return createReadonlyPureSelector(target, individualOptions, family);
+  };
+  const readonlySelectorFamily = {
+    ...familyToken,
+    create,
+    internalRoles,
+    subject,
+    install: (s) => createReadonlyPureSelectorFamily(s, options),
+    default: (key) => {
+      return options.get(key)({
+        get: (...args) => getFromStore(store, ...args),
+        find: (...args) => findInStore(store, ...args),
+        json: (token) => getJsonToken(store, token)
+      });
+    }
+  };
+  store.families.set(familyKey, readonlySelectorFamily);
+  return familyToken;
+}
+function createRegularAtomFamily(store, options, internalRoles) {
+  const familyToken = {
+    key: options.key,
+    type: `atom_family`
+  };
+  const existing = store.families.get(options.key);
+  if (existing && store.config.isProduction === true)
+    store.logger.error(`\u2757`, `atom_family`, options.key, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+  const subject = new Subject;
+  const create = (key) => {
+    const subKey = stringifyJson(key);
+    const family = {
+      key: options.key,
+      subKey
+    };
+    const fullKey = `${options.key}(${subKey})`;
+    const target = newest(store);
+    const def = options.default;
+    const individualOptions = {
+      key: fullKey,
+      default: isFn(def) ? () => def(key) : def
+    };
+    if (options.effects)
+      individualOptions.effects = options.effects(key);
+    if (options.catch)
+      individualOptions.catch = options.catch;
+    return createRegularAtom(target, individualOptions, family);
+  };
+  const atomFamily$1 = {
+    ...familyToken,
+    create,
+    default: options.default,
+    subject,
+    install: (s) => createRegularAtomFamily(s, options),
+    internalRoles
+  };
+  store.families.set(options.key, atomFamily$1);
+  if (isFn(options.default) === false)
+    store.defaults.set(options.key, options.default);
+  return familyToken;
+}
+function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
+  const familyKey = options.key;
+  const type = `readonly_held_selector_family`;
+  const familyToken = {
+    key: familyKey,
+    type
+  };
+  const existing = store.families.get(familyKey);
+  if (existing && store.config.isProduction === true)
+    store.logger.error(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+  const subject = new Subject;
+  const create = (key) => {
+    const subKey = stringifyJson(key);
+    const family = {
+      key: familyKey,
+      subKey
+    };
+    const fullKey = `${familyKey}(${subKey})`;
+    return createReadonlyHeldSelector(newest(store), {
+      key: fullKey,
+      const: options.const(key),
+      get: options.get(key)
+    }, family);
+  };
+  const readonlySelectorFamily = {
+    ...familyToken,
+    create,
+    internalRoles,
+    subject,
+    install: (s) => createReadonlyHeldSelectorFamily(s, options),
+    default: options.const
+  };
+  store.families.set(familyKey, readonlySelectorFamily);
+  return familyToken;
+}
+function createWritableHeldSelectorFamily(store, options, internalRoles) {
+  const familyKey = options.key;
+  const type = `writable_held_selector_family`;
+  const familyToken = {
+    key: familyKey,
+    type
+  };
+  const existing = store.families.get(familyKey);
+  if (existing && store.config.isProduction === true)
+    store.logger.error(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+  const subject = new Subject;
+  const create = (key) => {
+    const subKey = stringifyJson(key);
+    const family = {
+      key: familyKey,
+      subKey
+    };
+    const fullKey = `${familyKey}(${subKey})`;
+    return createWritableHeldSelector(newest(store), {
+      key: fullKey,
+      const: options.const(key),
+      get: options.get(key),
+      set: options.set(key)
+    }, family);
+  };
+  const selectorFamily$1 = {
+    ...familyToken,
+    create,
+    internalRoles,
+    subject,
+    install: (s) => createWritableHeldSelectorFamily(s, options),
+    default: options.const
+  };
+  store.families.set(familyKey, selectorFamily$1);
+  return familyToken;
+}
+function createWritablePureSelectorFamily(store, options, internalRoles) {
+  const familyKey = options.key;
+  const type = `writable_pure_selector_family`;
+  const familyToken = {
+    key: familyKey,
+    type
+  };
+  const existing = store.families.get(familyKey);
+  if (existing && store.config.isProduction === true)
+    store.logger.error(`\u2757`, type, familyKey, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+  const subject = new Subject;
+  const create = (key) => {
+    const subKey = stringifyJson(key);
+    const family = {
+      key: familyKey,
+      subKey
+    };
+    const fullKey = `${familyKey}(${subKey})`;
+    const target = newest(store);
+    const individualOptions = {
+      key: fullKey,
+      get: options.get(key),
+      set: options.set(key)
+    };
+    if (options.catch)
+      individualOptions.catch = options.catch;
+    return createWritablePureSelector(target, individualOptions, family);
+  };
+  const selectorFamily$1 = {
+    ...familyToken,
+    create,
+    internalRoles,
+    subject,
+    install: (s) => createWritablePureSelectorFamily(s, options),
+    default: (key) => {
+      return options.get(key)({
+        get: (...args) => getFromStore(store, ...args),
+        find: (...args) => findInStore(store, ...args),
+        json: (token) => getJsonToken(store, token)
+      });
+    }
+  };
+  store.families.set(familyKey, selectorFamily$1);
+  return familyToken;
+}
+function createSelectorFamily(store, options) {
+  const isWritable = `set` in options;
+  const isHeld = `const` in options;
+  if (isHeld && isWritable)
+    return createWritableHeldSelectorFamily(store, options, undefined);
+  if (isHeld)
+    return createReadonlyHeldSelectorFamily(store, options, undefined);
+  if (isWritable)
+    return createWritablePureSelectorFamily(store, options);
+  return createReadonlyPureSelectorFamily(store, options);
+}
+function disposeFromStore(store, ...params) {
+  let token;
+  if (params.length === 1)
+    token = params[0];
+  else {
+    const family = params[0];
+    const key = params[1];
+    token = findInStore(store, family, key);
+  }
+  try {
+    withdraw(store, token);
+  } catch (_) {
+    store.logger.error(`\u274C`, token.type, token.key, `could not be disposed because it was not found in the store "${store.config.name}".`);
+    return;
+  }
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      disposeAtom(store, token);
+      break;
+    case `writable_pure_selector`:
+    case `readonly_pure_selector`:
+    case `writable_held_selector`:
+    case `readonly_held_selector`:
+      disposeSelector(store, token);
+      break;
+  }
+}
+function openOperation(store, token) {
+  if (store.operation.open) {
+    const rejectionTime = performance.now();
+    store.logger.info(`\uD83D\uDEAB`, token.type, token.key, `deferring setState at T-${rejectionTime} until setState for "${store.operation.token.key}" is done`);
+    return rejectionTime;
+  }
+  store.operation = {
+    open: true,
+    done: /* @__PURE__ */ new Set,
+    prev: /* @__PURE__ */ new Map,
+    timestamp: Date.now(),
+    token,
+    subEvents: []
+  };
+  store.logger.info(`\u2B55`, token.type, token.key, `operation start in store "${store.config.name}"${isChildStore(store) ? ` ${store.transactionMeta.phase} "${store.transactionMeta.update.token.key}"` : ``}`);
+  return store;
+}
+function closeOperation(store) {
+  if (store.operation.open)
+    store.logger.info(`\uD83D\uDD34`, store.operation.token.type, store.operation.token.key, `operation done in store "${store.config.name}"`);
+  store.operation = { open: false };
+  store.on.operationClose.next(store.operation);
+}
+var isDone = (store, key) => {
+  if (!store.operation.open) {
+    store.logger.error(`\uD83D\uDC1E`, `unknown`, key, `isDone called outside of an operation. This is probably a bug in AtomIO.`);
+    return true;
+  }
+  return store.operation.done.has(key);
+};
+var markDone = (store, key) => {
+  if (!store.operation.open) {
+    store.logger.error(`\uD83D\uDC1E`, `unknown`, key, `markDone called outside of an operation. This is probably a bug in AtomIO.`);
+    return;
+  }
+  store.operation.done.add(key);
+};
+function dispatchOrDeferStateUpdate(target, state, { oldValue, newValue }, stateIsNewlyCreated, family) {
+  const token = deposit(state);
+  if (stateIsNewlyCreated && family) {
+    state.subject.next({ newValue });
+    const stateCreationEvent = {
+      checkpoint: true,
+      type: `state_creation`,
+      subType: `writable`,
+      token,
+      timestamp: Date.now(),
+      value: newValue
+    };
+    target.operation.subEvents.push(stateCreationEvent);
+    family.subject.next(stateCreationEvent);
+    const innerTarget = newest(target);
+    if (token.family) {
+      if (isRootStore(innerTarget))
+        switch (token.type) {
+          case `atom`:
+          case `mutable_atom`:
+            target.on.atomCreation.next(token);
+            break;
+          case `writable_pure_selector`:
+          case `writable_held_selector`:
+            target.on.selectorCreation.next(token);
+            break;
+        }
+      else if (isChildStore(innerTarget) && innerTarget.on.transactionApplying.state === null)
+        innerTarget.transactionMeta.update.subEvents.push(stateCreationEvent);
+    }
+    return;
+  }
+  const { key, subject, type } = state;
+  const update = {
+    oldValue: isTransceiver(oldValue) ? oldValue.READONLY_VIEW : oldValue,
+    newValue: isTransceiver(newValue) ? newValue.READONLY_VIEW : newValue
+  };
+  if (isRootStore(target)) {
+    switch (type) {
+      case `mutable_atom`:
+        target.logger.info(`\uD83D\uDCE2`, type, key, `is now (`, newValue, `) subscribers:`, subject.subscribers.keys());
+        break;
+      case `atom`:
+      case `writable_pure_selector`:
+      case `writable_held_selector`:
+        target.logger.info(`\uD83D\uDCE2`, type, key, `went (`, oldValue, `->`, newValue, `) subscribers:`, subject.subscribers.keys());
+    }
+    subject.next(update);
+  }
+  if (isChildStore(target) && (type === `mutable_atom` || type === `atom`)) {
+    if (target.on.transactionApplying.state === null) {
+      if (isTransceiver(newValue))
+        return;
+      const { timestamp } = target.operation;
+      const atomUpdate = {
+        type: `atom_update`,
+        token,
+        timestamp,
+        update
+      };
+      target.transactionMeta.update.subEvents.push(atomUpdate);
+      target.logger.info(`\uD83D\uDCC1`, `atom`, key, `stowed (`, oldValue, `->`, newValue, `)`);
+      return;
+    }
+    if (hasRole(state, `tracker:signal`)) {
+      const keyOfMutable = key.slice(1);
+      const mutable = target.atoms.get(keyOfMutable);
+      if (readOrComputeValue(target, mutable, `mut`).do(update.newValue) === null === true)
+        evictDownstreamFromAtom(target, mutable);
+    }
+  }
+}
+var setAtom = (target, atom, next) => {
+  const oldValue = readOrComputeValue(target, atom, `mut`);
+  let newValue = become(next, oldValue);
+  target.logger.info(`\u2B50`, `atom`, atom.key, `setting value`, newValue);
+  newValue = writeToCache(target, atom, newValue);
+  markDone(target, atom.key);
+  evictDownstreamFromAtom(target, atom);
+  return {
+    oldValue,
+    newValue
+  };
+};
+function resetAtom(target, atom) {
+  switch (atom.type) {
+    case `mutable_atom`:
+      return setAtom(target, atom, new atom.class);
+    case `atom`: {
+      let def;
+      if (isFn(atom.default))
+        def = safeCompute(target, atom);
+      else
+        def = atom.default;
+      return setAtom(target, atom, def);
+    }
+  }
+}
+function resetAtomOrSelector(target, state) {
+  let protoUpdate;
+  switch (state.type) {
+    case `atom`:
+    case `mutable_atom`:
+      protoUpdate = resetAtom(target, state);
+      break;
+    case `writable_held_selector`:
+      {
+        const atoms = traceRootSelectorAtoms(target, state.key);
+        for (const atom of atoms.values())
+          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom), false);
+        const value = state.getFrom(target);
+        protoUpdate = {
+          oldValue: value,
+          newValue: value
+        };
+      }
+      break;
+    case `writable_pure_selector`:
+      {
+        const oldValue = safeCompute(target, state);
+        const atoms = traceRootSelectorAtoms(target, state.key);
+        for (const atom of atoms.values())
+          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom), false);
+        protoUpdate = {
+          oldValue,
+          newValue: safeCompute(target, state)
+        };
+      }
+      break;
+  }
+  return protoUpdate;
+}
+function setIntoStore(store, ...params) {
+  operateOnStore(OWN_OP, store, ...params);
+}
+var RESET_STATE = Symbol(`RESET`);
+function resetInStore(store, ...params) {
+  setIntoStore(store, ...[...params, RESET_STATE]);
+}
+function setSelector(target, selector, next) {
+  let oldValue;
+  let newValue;
+  let constant;
+  const { type, key } = selector;
+  switch (selector.type) {
+    case `writable_pure_selector`:
+      oldValue = readOrComputeValue(target, selector, `mut`);
+      newValue = become(next, oldValue);
+      newValue = writeToCache(target, selector, newValue);
+      break;
+    case `writable_held_selector`:
+      constant = selector.const;
+      become(next, constant);
+      oldValue = constant;
+      newValue = constant;
+  }
+  target.logger.info(`\u2B50`, type, key, `setting to`, newValue);
+  markDone(target, key);
+  selector.setSelf(newValue);
+  return {
+    oldValue,
+    newValue
+  };
+}
+var setAtomOrSelector = (target, state, value) => {
+  let protoUpdate;
+  switch (state.type) {
+    case `atom`:
+    case `mutable_atom`:
+      protoUpdate = setAtom(target, state, value);
+      break;
+    case `writable_pure_selector`:
+    case `writable_held_selector`:
+      protoUpdate = setSelector(target, state, value);
+      break;
+  }
+  return protoUpdate;
+};
+var OWN_OP = Symbol(`OWN_OP`);
+var JOIN_OP = Symbol(`JOIN_OP`);
+function operateOnStore(opMode, store, ...params) {
+  let existingToken;
+  let brandNewToken;
+  let token;
+  let family;
+  let key;
+  let value;
+  if (params.length === 2) {
+    token = params[0];
+    value = params[1];
+    if (`family` in token) {
+      family = getFamilyOfToken(store, token);
+      key = parseJson(token.family.subKey);
+      existingToken = seekInStore(store, family, key);
+      if (!existingToken)
+        token = brandNewToken = mintInStore(MUST_CREATE, store, family, key);
+      else
+        token = existingToken;
+    }
+  } else {
+    family = withdraw(store, params[0]);
+    key = params[1];
+    value = params[2];
+    existingToken = seekInStore(store, family, key);
+    if (!existingToken)
+      token = brandNewToken = mintInStore(MUST_CREATE, store, family, key);
+    else
+      token = existingToken;
+  }
+  const action = value === RESET_STATE ? `reset` : `set`;
+  let target;
+  if (opMode === OWN_OP) {
+    const result = openOperation(store, token);
+    if (typeof result === `number`) {
+      const rejectionTime = result;
+      const unsubscribe = store.on.operationClose.subscribe(`waiting to ${action} "${token.key}" at T-${rejectionTime}`, function waitUntilOperationCloseToSetState() {
+        unsubscribe();
+        store.logger.info(`\uD83D\uDFE2`, token.type, token.key, `resuming deferred`, action, `from T-${rejectionTime}`);
+        operateOnStore(opMode, store, token, value);
+      });
+      return;
+    }
+    target = result;
+  } else
+    target = store;
+  if (`counterfeit` in token && `family` in token) {
+    const subKey = token.family.subKey;
+    const disposal = store.disposalTraces.buffer.find((item) => item?.key === subKey);
+    store.logger.error(`\u274C`, token.type, token.key, `could not be`, action, `because key`, subKey, `is not allocated.`, disposal ? `this key was previously disposed:${disposal.trace}` : `(no previous disposal trace found)`);
+    return;
+  }
+  const state = withdraw(target, token);
+  let protoUpdate;
+  if (value === RESET_STATE)
+    protoUpdate = resetAtomOrSelector(target, state);
+  else
+    protoUpdate = setAtomOrSelector(target, state, value);
+  dispatchOrDeferStateUpdate(target, state, protoUpdate, Boolean(brandNewToken), family);
+  if (opMode === OWN_OP)
+    closeOperation(target);
+}
+var isAtomKey = (store, key) => newest(store).atoms.has(key);
+var isSelectorKey = (store, key) => newest(store).writableSelectors.has(key);
+var isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
+var isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
+function getSelectorDependencyKeys(store, key) {
+  return newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
+}
+function traceRootSelectorAtoms(store, selectorKey, covered = /* @__PURE__ */ new Set) {
+  const dependencies = getSelectorDependencyKeys(store, selectorKey);
+  const roots = /* @__PURE__ */ new Map;
+  while (dependencies.length > 0) {
+    const dependencyKey = dependencies.pop();
+    if (covered.has(dependencyKey))
+      continue;
+    covered.add(dependencyKey);
+    if (isAtomKey(store, dependencyKey)) {
+      const atom = store.atoms.get(dependencyKey);
+      roots.set(atom.key, atom);
+    } else
+      dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
+  }
+  return roots;
+}
+function updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered) {
+  const target = newest(store);
+  const { type: dependencyType, key: dependencyKey } = dependency;
+  if (dependencyType === `atom` || dependencyType === `mutable_atom`) {
+    target.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependencyKey
+    });
+    store.logger.info(`\uD83D\uDD0D`, selectorType, selectorKey, `discovers root atom "${dependencyKey}"`);
+  } else {
+    const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered);
+    store.logger.info(`\uD83D\uDD0D`, selectorType, selectorKey, `discovers root atoms: [ ${[...rootKeys.values()].map((root) => `"${root.key}"`).join(`, `)} ]`);
+    for (const { key: atomKey } of rootKeys.values())
+      target.selectorAtoms = target.selectorAtoms.set({
+        selectorKey,
+        atomKey
+      });
+  }
+  covered.add(dependencyKey);
+}
+function registerSelector(store, selectorType, selectorKey, covered) {
+  return {
+    get: (...params) => {
+      const target = newest(store);
+      const { token, family, subKey } = reduceReference(store, ...params);
+      let dependencyValue;
+      if (`counterfeit` in token && family && subKey)
+        dependencyValue = getFallback(store, token, family, subKey);
+      else
+        dependencyValue = readOrComputeValue(store, withdraw(store, token));
+      store.logger.info(`\uD83D\uDD0C`, selectorType, selectorKey, `registers dependency ( "${token.key}" =`, dependencyValue, `)`);
+      target.selectorGraph.set({
+        upstreamSelectorKey: token.key,
+        downstreamSelectorKey: selectorKey
+      }, { source: token.key });
+      updateSelectorAtoms(store, selectorType, selectorKey, token, covered);
+      return dependencyValue;
+    },
+    set: (...params) => {
+      operateOnStore(JOIN_OP, newest(store), ...params);
+    },
+    find: (...args) => findInStore(store, ...args),
+    json: (token) => getJsonToken(store, token)
+  };
+}
+function createReadonlyHeldSelector(store, options, family) {
+  const target = newest(store);
+  const subject = new Subject;
+  const covered = /* @__PURE__ */ new Set;
+  const { key, const: constant } = options;
+  const type = `readonly_held_selector`;
+  store.logger.info(`\uD83D\uDD28`, type, key, `is being created`);
+  const { get, find, json } = registerSelector(target, type, key, covered);
+  const getFrom = (innerTarget) => {
+    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+    for (const [downstreamSelectorKey, { source }] of upstreamStates)
+      if (source !== key)
+        innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+    innerTarget.selectorAtoms.delete(key);
+    options.get({
+      get,
+      find,
+      json
+    }, constant);
+    writeToCache(innerTarget, readonlySelector, constant);
+    store.logger.info(`\u2728`, type, key, `=`, constant);
+    covered.clear();
+    return constant;
+  };
+  const readonlySelector = {
+    ...options,
+    type,
+    subject,
+    getFrom,
+    install: (s) => createReadonlyHeldSelector(s, options, family)
+  };
+  if (family)
+    readonlySelector.family = family;
+  target.readonlySelectors.set(key, readonlySelector);
+  const token = {
+    key,
+    type
+  };
+  if (family)
+    token.family = family;
+  return token;
+}
+function createReadonlyPureSelector(store, options, family) {
+  const target = newest(store);
+  const subject = new Subject;
+  const covered = /* @__PURE__ */ new Set;
+  const key = options.key;
+  const type = `readonly_pure_selector`;
+  store.logger.info(`\uD83D\uDD28`, type, key, `is being created`);
+  const { get, find, json } = registerSelector(target, type, key, covered);
+  const getFrom = () => {
+    const innerTarget = newest(store);
+    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+    for (const [downstreamSelectorKey, { source }] of upstreamStates)
+      if (source !== key)
+        innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+    innerTarget.selectorAtoms.delete(key);
+    const cached = writeToCache(innerTarget, readonlySelector, options.get({
+      get,
+      find,
+      json
+    }));
+    store.logger.info(`\u2728`, type, key, `=`, cached);
+    covered.clear();
+    return cached;
+  };
+  const readonlySelector = {
+    ...options,
+    type,
+    subject,
+    getFrom,
+    install: (s) => createReadonlyPureSelector(s, options, family)
+  };
+  if (family)
+    readonlySelector.family = family;
+  target.readonlySelectors.set(key, readonlySelector);
+  const token = {
+    key,
+    type
+  };
+  if (family)
+    token.family = family;
+  return token;
+}
+function createWritableHeldSelector(store, options, family) {
+  const target = newest(store);
+  const subject = new Subject;
+  const covered = /* @__PURE__ */ new Set;
+  const { key, const: constant } = options;
+  const type = `writable_held_selector`;
+  store.logger.info(`\uD83D\uDD28`, type, key, `is being created`);
+  const setterToolkit = registerSelector(target, type, key, covered);
+  const { find, get, json } = setterToolkit;
+  const getterToolkit = {
+    find,
+    get,
+    json
+  };
+  const getFrom = (innerTarget) => {
+    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+    for (const [downstreamSelectorKey, { source }] of upstreamStates)
+      if (source !== key)
+        innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+    innerTarget.selectorAtoms.delete(key);
+    options.get(getterToolkit, constant);
+    writeToCache(innerTarget, mySelector, constant);
+    store.logger.info(`\u2728`, type, key, `=`, constant);
+    covered.clear();
+    return constant;
+  };
+  const setSelf = () => {
+    options.set(setterToolkit, constant);
+  };
+  const mySelector = {
+    ...options,
+    type,
+    subject,
+    getFrom,
+    setSelf,
+    install: (s) => createWritableHeldSelector(s, options, family)
+  };
+  if (family)
+    mySelector.family = family;
+  target.writableSelectors.set(key, mySelector);
+  const token = {
+    key,
+    type
+  };
+  if (family)
+    token.family = family;
+  return token;
+}
+function createWritablePureSelector(store, options, family) {
+  const target = newest(store);
+  const subject = new Subject;
+  const covered = /* @__PURE__ */ new Set;
+  const key = options.key;
+  const type = `writable_pure_selector`;
+  store.logger.info(`\uD83D\uDD28`, type, key, `is being created`);
+  const setterToolkit = registerSelector(target, type, key, covered);
+  const { find, get, json } = setterToolkit;
+  const getterToolkit = {
+    find,
+    get,
+    json
+  };
+  const getFrom = (innerTarget) => {
+    const upstreamStates = innerTarget.selectorGraph.getRelationEntries({ downstreamSelectorKey: key });
+    for (const [downstreamSelectorKey, { source }] of upstreamStates)
+      if (source !== key)
+        innerTarget.selectorGraph.delete(downstreamSelectorKey, key);
+    innerTarget.selectorAtoms.delete(key);
+    const cached = writeToCache(innerTarget, mySelector, options.get(getterToolkit));
+    store.logger.info(`\u2728`, type, key, `=`, cached);
+    covered.clear();
+    return cached;
+  };
+  const setSelf = (newValue) => {
+    options.set(setterToolkit, newValue);
+  };
+  const mySelector = {
+    ...options,
+    type,
+    subject,
+    getFrom,
+    setSelf,
+    install: (s) => createWritablePureSelector(s, options, family)
+  };
+  if (family)
+    mySelector.family = family;
+  target.writableSelectors.set(key, mySelector);
+  const token = {
+    key,
+    type
+  };
+  if (family)
+    token.family = family;
+  return token;
+}
+function createStandaloneSelector(store, options) {
+  const isWritable = `set` in options;
+  const isHeld = `const` in options;
+  if (isHeld && isWritable) {
+    const state$1 = createWritableHeldSelector(store, options, undefined);
+    store.on.selectorCreation.next(state$1);
+    return state$1;
+  }
+  if (isHeld) {
+    const state$1 = createReadonlyHeldSelector(store, options, undefined);
+    store.on.selectorCreation.next(state$1);
+    return state$1;
+  }
+  if (isWritable) {
+    const state$1 = createWritablePureSelector(store, options, undefined);
+    store.on.selectorCreation.next(state$1);
+    return state$1;
+  }
+  const state = createReadonlyPureSelector(store, options, undefined);
+  store.on.selectorCreation.next(state);
+  return state;
+}
+function disposeSelector(store, selectorToken) {
+  const target = newest(store);
+  const { key, type, family: familyMeta } = selectorToken;
+  if (!familyMeta)
+    store.logger.error(`\u274C`, type, key, `Standalone selectors cannot be disposed.`);
+  else {
+    if (target.molecules.get(familyMeta.subKey))
+      target.moleculeData.delete(familyMeta.subKey, familyMeta.key);
+    let familyToken;
+    switch (selectorToken.type) {
+      case `writable_held_selector`:
+        target.writableSelectors.delete(key);
+        familyToken = {
+          key: familyMeta.key,
+          type: `writable_held_selector_family`
+        };
+        withdraw(store, familyToken).subject.next({
+          type: `state_disposal`,
+          subType: `selector`,
+          token: selectorToken,
+          timestamp: Date.now()
+        });
+        break;
+      case `writable_pure_selector`:
+        target.writableSelectors.delete(key);
+        familyToken = {
+          key: familyMeta.key,
+          type: `writable_pure_selector_family`
+        };
+        withdraw(store, familyToken).subject.next({
+          type: `state_disposal`,
+          subType: `selector`,
+          token: selectorToken,
+          timestamp: Date.now()
+        });
+        break;
+      case `readonly_held_selector`:
+        target.readonlySelectors.delete(key);
+        familyToken = {
+          key: familyMeta.key,
+          type: `readonly_held_selector_family`
+        };
+        withdraw(store, familyToken).subject.next({
+          type: `state_disposal`,
+          subType: `selector`,
+          token: selectorToken,
+          timestamp: Date.now()
+        });
+        break;
+      case `readonly_pure_selector`:
+        target.readonlySelectors.delete(key);
+        familyToken = {
+          key: familyMeta.key,
+          type: `readonly_pure_selector_family`
+        };
+        withdraw(store, familyToken).subject.next({
+          type: `state_disposal`,
+          subType: `selector`,
+          token: selectorToken,
+          timestamp: Date.now()
+        });
+        break;
+    }
+    target.valueMap.delete(key);
+    target.selectorAtoms.delete(key);
+    target.selectorGraph.delete(key);
+    target.moleculeData.delete(familyMeta.key, familyMeta.subKey);
+    store.logger.info(`\uD83D\uDD25`, selectorToken.type, key, `deleted`);
+    if (isChildStore(target) && target.transactionMeta.phase === `building`)
+      target.transactionMeta.update.subEvents.push({
+        type: `state_disposal`,
+        subType: `selector`,
+        token: selectorToken,
+        timestamp: Date.now()
+      });
+    else
+      store.on.selectorDisposal.next(selectorToken);
+  }
+}
+var recallState = (store, state) => {
+  const target = newest(store);
+  if (target.operation.open)
+    return target.operation.prev.get(state.key);
+  return target.valueMap.get(state.key);
+};
+var subscribeToRootDependency = (target, selector, atom) => {
+  return atom.subject.subscribe(`${selector.type}:${selector.key}`, (atomChange) => {
+    target.logger.info(`\uD83D\uDCE2`, selector.type, selector.key, `root`, atom.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
+    const oldValue = recallState(target, selector);
+    const newValue = readOrComputeValue(target, selector);
+    target.logger.info(`\u2728`, selector.type, selector.key, `went`, oldValue, `->`, newValue);
+    selector.subject.next({
+      newValue,
+      oldValue
+    });
+  });
+};
+function subscribeToState(store, token, key, handleUpdate) {
+  function safelyHandleUpdate(update) {
+    if (store.operation.open) {
+      if (state?.type === `atom` && hasRole(state, `tracker:signal`) && `*` + store.operation.token.key === token.key && `inboundTracker` in handleUpdate)
+        return;
+      const unsubscribe$1 = store.on.operationClose.subscribe(`state subscription ${key}`, () => {
+        unsubscribe$1();
+        handleUpdate(update);
+      });
+    } else
+      handleUpdate(update);
+  }
+  reduceReference(store, token);
+  const state = withdraw(store, token);
+  store.logger.info(`\uD83D\uDC40`, state.type, state.key, `Adding subscription "${key}"`);
+  const isSelector = state.type === `writable_pure_selector` || state.type === `readonly_pure_selector`;
+  const rootSubs = /* @__PURE__ */ new Map;
+  let updateHandler = safelyHandleUpdate;
+  if (isSelector) {
+    readOrComputeValue(store, state);
+    for (const [atomKey, atom] of traceRootSelectorAtoms(store, state.key))
+      rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom));
+    updateHandler = function updateRootsBeforeHandlingUpdate(update) {
+      const dependencies = traceRootSelectorAtoms(store, state.key);
+      for (const [previousRootKey, unsub] of rootSubs)
+        if (dependencies.get(previousRootKey))
+          dependencies.delete(previousRootKey);
+        else {
+          unsub();
+          rootSubs.delete(previousRootKey);
+        }
+      for (const [atomKey, atom] of dependencies)
+        rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom));
+      safelyHandleUpdate(update);
+    };
+  }
+  const mainUnsubFunction = state.subject.subscribe(key, updateHandler);
+  const unsubscribe = () => {
+    store.logger.info(`\uD83D\uDE48`, state.type, state.key, `Removing subscription "${key}"`);
+    mainUnsubFunction();
+    for (const unsubFromDependency of rootSubs.values())
+      unsubFromDependency();
+  };
+  return unsubscribe;
+}
+var subscribeToTimeline = (store, token, key, handleUpdate) => {
+  const tl = withdraw(store, token);
+  store.logger.info(`\uD83D\uDC40`, `timeline`, token.key, `Adding subscription "${key}"`);
+  const unsubscribe = tl.subject.subscribe(key, handleUpdate);
+  return () => {
+    store.logger.info(`\uD83D\uDE48`, `timeline`, token.key, `Removing subscription "${key}" from timeline`);
+    unsubscribe();
+  };
+};
+var Tracker = class {
+  initializeSignalAtom(mutableState, store) {
+    const latestSignalStateKey = `*${mutableState.key}`;
+    store.atoms.delete(latestSignalStateKey);
+    store.valueMap.delete(latestSignalStateKey);
+    const familyMetaData = mutableState.family ? {
+      key: `*${mutableState.family.key}`,
+      subKey: mutableState.family.subKey
+    } : undefined;
+    const latestSignalState = createRegularAtom(store, {
+      key: latestSignalStateKey,
+      default: null
+    }, familyMetaData, [`tracker:signal`]);
+    if (store.parent?.valueMap.has(latestSignalStateKey)) {
+      const parentValue = store.parent.valueMap.get(latestSignalStateKey);
+      store.valueMap.set(latestSignalStateKey, parentValue);
+    }
+    return latestSignalState;
+  }
+  unsubscribeFromInnerValue;
+  unsubscribeFromState;
+  captureSignalsFromCore(mutableState, latestSignalState, target) {
+    const stateKey = mutableState.key;
+    const subscriptionKey = `tracker-from-core:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.token.key : `main`}:${stateKey}`;
+    const trackerCapturesOutboundSignal = (update) => {
+      operateOnStore(JOIN_OP, target, latestSignalState, update);
+    };
+    this.unsubscribeFromInnerValue = getFromStore(target, mutableState).subscribe(subscriptionKey, trackerCapturesOutboundSignal);
+    this.unsubscribeFromState = subscribeToState(target, mutableState, subscriptionKey, function trackerLooksForNewReference(update) {
+      if (update.newValue !== update.oldValue) {
+        this.unsubscribeFromInnerValue();
+        this.unsubscribeFromInnerValue = update.newValue.subscribe(subscriptionKey, trackerCapturesOutboundSignal);
+      }
+    }.bind(this));
+  }
+  supplySignalsToCore(mutableState, latestSignalState, target) {
+    const stateKey = mutableState.key;
+    const subscriptionKey = `tracker-to-core:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.token.key : `main`}:${stateKey}`;
+    subscribeToState(target, latestSignalState, subscriptionKey, Object.assign(function trackerCapturesInboundSignal({ newValue, oldValue }) {
+      const timelineId = target.timelineTopics.getRelatedKey(latestSignalState.key);
+      if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
+        const unsubscribe = subscribeToTimeline(target, {
+          key: timelineId,
+          type: `timeline`
+        }, subscriptionKey, function trackerWaitsForTimeTravelToFinish(update) {
+          unsubscribe();
+          setIntoStore(target, mutableState, (transceiver) => {
+            if (update === `redo` && newValue)
+              transceiver.do(newValue);
+            else if (update === `undo` && oldValue)
+              transceiver.undo(oldValue);
+            return transceiver;
+          });
+        });
+        return;
+      }
+      setIntoStore(target, mutableState, (transceiver) => (transceiver.do(newValue), transceiver));
+    }, { inboundTracker: true }));
+  }
+  mutableAtomToken;
+  latestSignalToken;
+  [Symbol.dispose];
+  constructor(mutableAtomToken, store) {
+    const target = newest(store);
+    const latestSignalToken = this.initializeSignalAtom(mutableAtomToken, target);
+    this.mutableAtomToken = mutableAtomToken;
+    this.latestSignalToken = latestSignalToken;
+    this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target);
+    this.supplySignalsToCore(mutableAtomToken, latestSignalToken, target);
+    target.trackers.set(mutableAtomToken.key, this);
+    this[Symbol.dispose] = () => {
+      this.unsubscribeFromInnerValue();
+      this.unsubscribeFromState();
+      target.trackers.delete(mutableAtomToken.key);
+    };
+  }
+};
+function createMutableAtom(store, options, family) {
+  store.logger.info(`\uD83D\uDD28`, `atom`, options.key, `creating in store "${store.config.name}"`);
+  const target = newest(store);
+  const { key } = options;
+  const existing = target.atoms.get(key);
+  const type = `mutable_atom`;
+  if (existing?.type === type && store.config.isProduction === true) {
+    store.logger.error(`\u274C`, type, key, `Tried to create atom, but it already exists in the store.`);
+    return deposit(existing);
+  }
+  const subject = new Subject;
+  const newAtom = {
+    ...options,
+    type,
+    install: (s) => {
+      s.logger.info(`\uD83D\uDEE0\uFE0F`, `atom`, key, `installing in store "${s.config.name}"`);
+      return createMutableAtom(s, options, family);
+    },
+    subject
+  };
+  if (family)
+    newAtom.family = family;
+  target.atoms.set(newAtom.key, newAtom);
+  const token = deposit(newAtom);
+  new Tracker(token, store);
+  if (!family)
+    createStandaloneSelector(store, {
+      key: `${key}:JSON`,
+      get: ({ get }) => get(token).toJSON(),
+      set: ({ set }, newValue) => {
+        set(token, options.class.fromJSON(newValue));
+      }
+    });
+  if (options.effects) {
+    let effectIndex = 0;
+    const cleanupFunctions = [];
+    for (const effect of options.effects) {
+      const cleanup = effect({
+        resetSelf: () => {
+          resetInStore(store, token);
+        },
+        setSelf: (next) => {
+          setIntoStore(store, token, next);
+        },
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle),
+        token,
+        store: eldest(store)
+      });
+      if (cleanup)
+        cleanupFunctions.push(cleanup);
+      ++effectIndex;
+    }
+    newAtom.cleanup = () => {
+      for (const cleanup of cleanupFunctions)
+        cleanup();
+    };
+  }
+  store.on.atomCreation.next(token);
+  return token;
+}
+var FamilyTracker = class {
+  trackers = /* @__PURE__ */ new Map;
+  latestSignalAtoms;
+  mutableAtoms;
+  constructor(mutableAtoms, store) {
+    this.latestSignalAtoms = withdraw(store, createRegularAtomFamily(store, {
+      key: `*${mutableAtoms.key}`,
+      default: null
+    }, [`mutable`, `updates`]));
+    this.mutableAtoms = mutableAtoms;
+    const trackerFamilyWatchesForCreationAndDisposalEvents = (event) => {
+      const { type, token } = event;
+      if (token.family) {
+        const key = parseJson(token.family.subKey);
+        switch (type) {
+          case `state_creation`:
+            this.trackers.set(key, new Tracker(token, store));
+            break;
+          case `state_disposal`: {
+            const tracker = this.trackers.get(key);
+            if (tracker) {
+              tracker[Symbol.dispose]();
+              this.trackers.delete(key);
+            }
+          }
+        }
+      }
+    };
+    this.mutableAtoms.subject.subscribe(`store=${store.config.name}::tracker-atom-family`, trackerFamilyWatchesForCreationAndDisposalEvents);
+  }
+};
+function createMutableAtomFamily(store, options, internalRoles) {
+  const familyToken = {
+    key: options.key,
+    type: `mutable_atom_family`
+  };
+  const existing = store.families.get(options.key);
+  if (existing && store.config.isProduction === true)
+    store.logger.error(`\u2757`, `mutable_atom_family`, options.key, `Overwriting an existing ${PRETTY_TOKEN_TYPES[existing.type]} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+  const subject = new Subject;
+  const create = (key) => {
+    const subKey = stringifyJson(key);
+    const family = {
+      key: options.key,
+      subKey
+    };
+    const fullKey = `${options.key}(${subKey})`;
+    const target = newest(store);
+    const individualOptions = {
+      key: fullKey,
+      class: options.class
+    };
+    if (options.effects)
+      individualOptions.effects = options.effects(key);
+    return createMutableAtom(target, individualOptions, family);
+  };
+  const atomFamily$1 = {
+    ...familyToken,
+    create,
+    class: options.class,
+    subject,
+    install: (s) => createMutableAtomFamily(s, options),
+    internalRoles
+  };
+  store.families.set(options.key, atomFamily$1);
+  createWritablePureSelectorFamily(store, {
+    key: `${options.key}:JSON`,
+    get: (key) => ({ get }) => get(familyToken, key).toJSON(),
+    set: (key) => ({ set }, newValue) => {
+      set(familyToken, key, options.class.fromJSON(newValue));
+    }
+  }, [`mutable`, `json`]);
+  new FamilyTracker(atomFamily$1, store);
+  return familyToken;
+}
+var getJsonFamily = (mutableAtomFamily, store) => {
+  const target = newest(store);
+  const key = `${mutableAtomFamily.key}:JSON`;
+  return target.families.get(key);
+};
+var getJsonToken = (store, mutableAtomToken) => {
+  if (mutableAtomToken.family)
+    return findInStore(store, withdraw(newest(store), {
+      key: `${mutableAtomToken.family.key}:JSON`,
+      type: `writable_pure_selector_family`
+    }), parseJson(mutableAtomToken.family.subKey));
+  return {
+    type: `writable_pure_selector`,
+    key: `${mutableAtomToken.key}:JSON`
+  };
+};
+var getUpdateToken = (mutableAtomToken) => {
+  const updateToken = {
+    type: `atom`,
+    key: `*${mutableAtomToken.key}`
+  };
+  if (mutableAtomToken.family)
+    updateToken.family = {
+      key: `*${mutableAtomToken.family.key}`,
+      subKey: mutableAtomToken.family.subKey
+    };
+  return updateToken;
+};
+function isTransceiver(value) {
+  return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value && `READONLY_VIEW` in value && `toJSON` in value;
+}
+function writeToCache(target, state, value) {
+  const { key, subject, type } = state;
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future && !currentValue.done) {
+    const future = currentValue;
+    if (value instanceof Promise) {
+      future.use(value);
+      return future;
+    }
+    target.valueMap.set(key, value);
+    return value;
+  }
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    target.valueMap.set(key, future);
+    future.then(function handleResolvedFuture(resolved) {
+      if (target.valueMap.get(key) === future) {
+        openOperation(target, state);
+        writeToCache(target, state, resolved);
+        switch (type) {
+          case `atom`:
+            evictDownstreamFromAtom(target, state);
+            break;
+          case `readonly_pure_selector`:
+          case `writable_pure_selector`:
+            evictDownstreamFromSelector(target, key);
+            break;
+        }
+        closeOperation(target);
+        subject.next({
+          newValue: resolved,
+          oldValue: future
+        });
+      }
+    }).catch((thrown) => {
+      target.logger.error(`\uD83D\uDCA5`, state.type, key, `rejected:`, thrown);
+    });
+    return future;
+  }
+  target.logger.info(`\uD83D\uDCDD`, state.type, state.key, `writing to cache`, value);
+  target.valueMap.set(key, value);
+  return value;
+}
+function readFromCache(target, state, mut) {
+  target.logger.info(`\uD83D\uDCD6`, state.type, state.key, `reading cached value`);
+  let value = target.valueMap.get(state.key);
+  if (mut === `mut` && state.type === `mutable_atom` && isChildStore(target)) {
+    const mutableAtom$1 = state;
+    const { parent } = target;
+    if (target.valueMap.hasOwn(mutableAtom$1.key))
+      return value;
+    const parentValue = parent.valueMap.get(mutableAtom$1.key);
+    target.logger.info(`\uD83D\uDCC3`, `atom`, mutableAtom$1.key, `copying`);
+    const jsonValue = parentValue.toJSON();
+    const copiedValue = mutableAtom$1.class.fromJSON(jsonValue);
+    target.valueMap.set(mutableAtom$1.key, copiedValue);
+    new Tracker(mutableAtom$1, parent);
+    value = copiedValue;
+  }
+  return value;
+}
+function evictCachedValue(target, key) {
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
+    if (selector)
+      selector.getFrom(target);
+    return;
+  }
+  if (target.operation.open)
+    target.operation.prev.set(key, currentValue);
+  target.valueMap.delete(key);
+  target.logger.info(`\uD83D\uDDD1`, `state`, key, `evicted`);
+}
+function evictDownstreamFromAtom(store, atom) {
+  const target = newest(store);
+  const { key, type } = atom;
+  const downstreamKeys = target.selectorAtoms.getRelatedKeys(key);
+  target.logger.info(`\uD83E\uDDF9`, type, key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
+  if (downstreamKeys) {
+    if (target.operation.open)
+      target.logger.info(`\uD83E\uDDF9`, type, key, `[ ${[...target.operation.done].join(`, `)} ] already done`);
+    for (const downstreamKey of downstreamKeys) {
+      if (isDone(target, downstreamKey))
+        continue;
+      evictCachedValue(target, downstreamKey);
+      markDone(target, downstreamKey);
+    }
+  }
+}
+function evictDownstreamFromSelector(store, selectorKey) {
+  const target = newest(store);
+  const relationEntries = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: selectorKey }).filter(([_, { source }]) => source === selectorKey);
+  for (const [downstreamSelectorKey] of relationEntries) {
+    if (isDone(target, downstreamSelectorKey))
+      continue;
+    evictCachedValue(target, downstreamSelectorKey);
+    markDone(target, downstreamSelectorKey);
+    evictDownstreamFromSelector(store, downstreamSelectorKey);
+  }
+}
+function createRegularAtom(store, options, family, internalRoles) {
+  const type = `atom`;
+  const { key } = options;
+  store.logger.info(`\uD83D\uDD28`, type, key, `is being created`);
+  const target = newest(store);
+  const existing = target.atoms.get(key);
+  if (existing?.type === type && store.config.isProduction === true) {
+    store.logger.error(`\u274C`, `atom`, key, `Tried to create atom, but it already exists in the store.`);
+    return deposit(existing);
+  }
+  const subject = new Subject;
+  const newAtom = {
+    ...options,
+    type,
+    install: (s) => {
+      s.logger.info(`\uD83D\uDEE0\uFE0F`, type, key, `installing in store "${s.config.name}"`);
+      return createRegularAtom(s, options, family);
+    },
+    subject
+  };
+  if (family)
+    newAtom.family = family;
+  if (internalRoles)
+    newAtom.internalRoles = internalRoles;
+  target.atoms.set(key, newAtom);
+  const token = deposit(newAtom);
+  if (options.effects) {
+    let effectIndex = 0;
+    const cleanupFunctions = [];
+    for (const effect of options.effects) {
+      const cleanup = effect({
+        resetSelf: () => {
+          resetInStore(store, token);
+        },
+        setSelf: (next) => {
+          setIntoStore(store, token, next);
+        },
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle),
+        token,
+        store: eldest(store)
+      });
+      if (cleanup)
+        cleanupFunctions.push(cleanup);
+      ++effectIndex;
+    }
+    newAtom.cleanup = () => {
+      for (const cleanup of cleanupFunctions)
+        cleanup();
+    };
+  }
+  store.on.atomCreation.next(token);
+  return token;
+}
+function hasRole(atom, role) {
+  if (`internalRoles` in atom === false)
+    return false;
+  return atom.internalRoles.includes(role);
+}
+function disposeAtom(store, atomToken) {
+  const target = newest(store);
+  const { key, family } = atomToken;
+  const atom = withdraw(target, atomToken);
+  if (!family)
+    store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
+  else {
+    atom.cleanup?.();
+    const lastValue = store.valueMap.get(atom.key);
+    const subject = withdraw(store, getFamilyOfToken(store, atomToken)).subject;
+    const disposalEvent = {
+      type: `state_disposal`,
+      subType: `atom`,
+      token: atomToken,
+      value: lastValue,
+      timestamp: Date.now()
+    };
+    subject.next(disposalEvent);
+    const isChild = isChildStore(target);
+    target.atoms.delete(key);
+    target.valueMap.delete(key);
+    target.selectorAtoms.delete(key);
+    target.atomsThatAreDefault.delete(key);
+    target.moleculeData.delete(family.key, family.subKey);
+    store.timelineTopics.delete(key);
+    if (atomToken.type === `mutable_atom`) {
+      disposeAtom(store, getUpdateToken(atomToken));
+      store.trackers.delete(key);
+    }
+    store.logger.info(`\uD83D\uDD25`, `atom`, key, `deleted`);
+    if (isChild && target.transactionMeta.phase === `building`) {
+      const mostRecentUpdate = target.transactionMeta.update.subEvents.at(-1);
+      const updateAlreadyCaptured = mostRecentUpdate?.type === `molecule_disposal` && mostRecentUpdate.values.some(([k]) => k === atom.family?.key);
+      const isTracker = hasRole(atom, `tracker:signal`);
+      if (!updateAlreadyCaptured && !isTracker)
+        target.transactionMeta.update.subEvents.push(disposalEvent);
+    } else
+      store.on.atomDisposal.next(atomToken);
+  }
+}
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+var Join = class {
+  toolkit;
+  options;
+  relations;
+  states;
+  relatedKeysAtoms;
+  transact(toolkit, run) {
+    const originalToolkit = this.toolkit;
+    this.toolkit = toolkit;
+    run(this);
+    this.toolkit = originalToolkit;
+  }
+  store;
+  [Symbol.dispose]() {}
+  constructor(options, store = IMPLICIT.STORE) {
+    this.store = store;
+    this.options = options;
+    this.store.miscResources.set(`join:${options.key}`, this);
+    this.toolkit = {
+      get: (...ps) => getFromStore(store, ...ps),
+      set: (...ps) => {
+        setIntoStore(store, ...ps);
+      },
+      find: (...ps) => findInStore(store, ...ps),
+      json: (token) => getJsonToken(store, token)
+    };
+    const aSide = options.between[0];
+    const bSide = options.between[1];
+    const relatedKeysAtoms = createMutableAtomFamily(store, {
+      key: `${options.key}/relatedKeys`,
+      class: UList
+    }, [`join`, `relations`]);
+    this.relatedKeysAtoms = relatedKeysAtoms;
+    const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
+      const { find, get, set } = toolkit;
+      const relationsOfAState = find(relatedKeysAtoms, a);
+      const currentRelationsOfA = get(relationsOfAState);
+      for (const currentRelationB of currentRelationsOfA) {
+        if (newRelationsOfA.includes(currentRelationB))
+          continue;
+        set(relatedKeysAtoms, currentRelationB, (relationsOfB) => {
+          relationsOfB.delete(a);
+          return relationsOfB;
+        });
+      }
+      set(relationsOfAState, (relationsOfA) => {
+        relationsOfA.clear();
+        for (const newRelationB of newRelationsOfA) {
+          const relationsOfBAtom = find(relatedKeysAtoms, newRelationB);
+          const relationsOfB = get(relationsOfBAtom);
+          const newRelationBIsAlreadyRelated = relationsOfB.has(a);
+          if (this.relations.cardinality === `1:n`) {
+            const previousOwnersToDispose = [];
+            for (const previousOwner of relationsOfB) {
+              if (previousOwner === a)
+                continue;
+              let previousOwnerSize;
+              operateOnStore(JOIN_OP, this.store, relatedKeysAtoms, previousOwner, (relations$1) => {
+                relations$1.delete(newRelationB);
+                previousOwnerSize = relations$1.size;
+                return relations$1;
+              });
+              if (previousOwnerSize === 0)
+                previousOwnersToDispose.push(previousOwner);
+            }
+            if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0)
+              set(relationsOfBAtom, (relations$1) => {
+                relations$1.clear();
+                return relations$1;
+              });
+            for (const previousOwner of previousOwnersToDispose)
+              store.keyRefsInJoins.delete(simpleCompound(newRelationB, previousOwner));
+          }
+          if (!newRelationBIsAlreadyRelated)
+            set(relationsOfBAtom, (relations$1) => {
+              relations$1.add(a);
+              return relations$1;
+            });
+          relationsOfA.add(newRelationB);
+        }
+        return relationsOfA;
+      });
+    };
+    const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
+      const { set } = toolkit;
+      set(relatedKeysAtoms, a, (relationsOfA) => {
+        for (const newRelationB of newRelationsOfA)
+          relationsOfA.add(newRelationB);
+        return relationsOfA;
+      });
+      for (const newRelationB of newRelationsOfA)
+        set(relatedKeysAtoms, newRelationB, (newRelationsB) => {
+          newRelationsB.add(a);
+          return newRelationsB;
+        });
+      return true;
+    };
+    const relations = new Junction(options, {
+      externalStore: {
+        getRelatedKeys: (key) => this.toolkit.get(relatedKeysAtoms, key),
+        addRelation: (a, b) => {
+          this.store.keyRefsInJoins.set(`"${a}"`, options.key);
+          this.store.keyRefsInJoins.set(`"${b}"`, options.key);
+          this.store.keyRefsInJoins.set(simpleCompound(a, b), options.key);
+          this.toolkit.set(relatedKeysAtoms, a, (aKeys) => aKeys.add(b));
+          this.toolkit.set(relatedKeysAtoms, b, (bKeys) => bKeys.add(a));
+        },
+        deleteRelation: (a, b) => {
+          this.toolkit.set(relatedKeysAtoms, a, (aKeys) => {
+            aKeys.delete(b);
+            return aKeys;
+          });
+          this.toolkit.set(relatedKeysAtoms, b, (bKeys) => {
+            bKeys.delete(a);
+            return bKeys;
+          });
+          const compositeKey = simpleCompound(a, b);
+          this.store.keyRefsInJoins.delete(compositeKey);
+        },
+        replaceRelationsSafely: (a, bs) => {
+          replaceRelationsSafely(this.toolkit, a, bs);
+        },
+        replaceRelationsUnsafely: (a, bs) => {
+          replaceRelationsUnsafely(this.toolkit, a, bs);
+        },
+        has: (a, b) => {
+          const aKeys = this.toolkit.get(relatedKeysAtoms, a);
+          return b ? aKeys.has(b) : aKeys.size > 0;
+        }
+      },
+      isAType: options.isAType,
+      isBType: options.isBType
+    });
+    const createSingleKeySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
+      key: `${options.key}/singleRelatedKey`,
+      get: (key) => ({ get }) => {
+        const relatedKeys = get(relatedKeysAtoms, key);
+        for (const relatedKey of relatedKeys)
+          return relatedKey;
+        return null;
+      }
+    }, [`join`, `keys`]);
+    const getMultipleKeySelectorFamily = () => {
+      return createReadonlyPureSelectorFamily(store, {
+        key: `${options.key}/multipleRelatedKeys`,
+        get: (key) => ({ get }) => {
+          return get(getJsonFamily(relatedKeysAtoms, store), key);
+        }
+      }, [`join`, `keys`]);
+    };
+    switch (options.cardinality) {
+      case `1:1`: {
+        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
+        this.relations = relations;
+        this.states = {
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: singleRelatedKeySelectors
+        };
+        break;
+      }
+      case `1:n`: {
+        const singleRelatedKeySelectors = createSingleKeySelectorFamily();
+        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+        const baseStates = {
+          [stateKeyA]: singleRelatedKeySelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
+        };
+        this.relations = relations;
+        this.states = baseStates;
+        break;
+      }
+      case `n:n`: {
+        const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
+        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
+        this.relations = relations;
+        this.states = {
+          [stateKeyA]: multipleRelatedKeysSelectors,
+          [stateKeyB]: multipleRelatedKeysSelectors
+        };
+      }
+    }
+  }
+};
+function createJoin(store, options) {
+  store.joins.set(options.key, new Join(options));
+  return {
+    key: options.key,
+    type: `join`,
+    a: options.between[0],
+    b: options.between[1],
+    cardinality: options.cardinality
+  };
+}
+function getJoin(token, store) {
+  let myJoin = store.joins.get(token.key);
+  if (myJoin === undefined) {
+    const rootJoin = IMPLICIT.STORE.joins.get(token.key);
+    if (rootJoin === undefined)
+      throw new Error(`Join "${token.key}" not found in store "${store.config.name}"`);
+    const root = eldest(store);
+    myJoin = new Join(rootJoin.options, root);
+    store.joins.set(token.key, myJoin);
+  }
+  return myJoin;
+}
+function editRelationsInStore(token, change, store) {
+  const myJoin = getJoin(token, store);
+  const target = newest(store);
+  if (isChildStore(target)) {
+    const { toolkit } = target.transactionMeta;
+    myJoin.transact(toolkit, ({ relations }) => {
+      change(relations);
+    });
+  } else
+    change(myJoin.relations);
+}
+function findRelationsInStore(token, key, store) {
+  const myJoin = getJoin(token, store);
+  let relations;
+  switch (token.cardinality) {
+    case `1:1`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = myJoin.states[keyAB];
+          return findInStore(store, familyAB, key);
+        },
+        get [keyBA]() {
+          const familyBA = myJoin.states[keyBA];
+          return findInStore(store, familyBA, key);
+        }
+      };
+      break;
+    }
+    case `1:n`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = myJoin.states[keyAB];
+          return findInStore(store, familyAB, key);
+        },
+        get [keysBA]() {
+          const familyBA = myJoin.states[keysBA];
+          return findInStore(store, familyBA, key);
+        }
+      };
+      break;
+    }
+    case `n:n`: {
+      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keysAB]() {
+          const familyAB = myJoin.states[keysAB];
+          return findInStore(store, familyAB, key);
+        },
+        get [keysBA]() {
+          const familyBA = myJoin.states[keysBA];
+          return findInStore(store, familyBA, key);
+        }
+      };
+    }
+  }
+  return relations;
+}
+function getInternalRelationsFromStore(token, store) {
+  return getJoin(token, store).relatedKeysAtoms;
+}
+
+// ../../packages/atom.io/dist/realtime/index.js
+var mutexAtoms = atomFamily({
+  key: `mutex`,
+  default: false
+});
+var InvariantMap = class extends Map {
+  set(key, value) {
+    if (this.has(key)) {
+      console.warn(`Tried to set a key that already exists in an InvariantMap`, {
+        key,
+        value
+      });
+      return this;
+    }
+    return super.set(key, value);
+  }
+};
+var SyncGroup = class SyncGroup2 {
+  type = `continuity`;
+  globals = [];
+  actions = [];
+  perspectives = [];
+  key;
+  constructor(key) {
+    this.key = key;
+  }
+  static existing = new InvariantMap;
+  static create(key, builder) {
+    const { type, globals, actions, perspectives } = builder(new SyncGroup2(key));
+    const token = {
+      type,
+      key,
+      globals,
+      actions,
+      perspectives
+    };
+    SyncGroup2.existing.set(key, token);
+    return token;
+  }
+  add(...args) {
+    switch (args[0].type) {
+      case `atom`:
+      case `mutable_atom`:
+        this.globals.push(...args);
+        break;
+      case `transaction`:
+        this.actions.push(...args);
+        break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+        {
+          const [family, index] = args;
+          this.perspectives.push({
+            type: `realtime_perspective`,
+            resourceAtoms: family,
+            viewAtoms: index
+          });
+        }
+        break;
+    }
+    return this;
+  }
+};
+var usersInThisRoomIndex = mutableAtom({
+  key: `usersInRoomIndex`,
+  class: UList
+});
+var roomIndex = mutableAtom({
+  key: `roomIndex`,
+  class: UList
+});
+var usersInRooms = join({
+  key: `usersInRooms`,
+  between: [`room`, `user`],
+  cardinality: `1:n`,
+  isAType: (input) => typeof input === `string`,
+  isBType: (input) => typeof input === `string`
+});
+var usersInMyRoomView = selectorFamily({
+  key: `usersInMyRoomView`,
+  get: (myUsername) => ({ find }) => {
+    return [find(getInternalRelations(usersInRooms), myUsername)];
+  }
+});
+
+// ../../packages/atom.io/dist/realtime-server/index.js
+var redactorAtoms = atomFamily({
+  key: `redactor`,
+  default: { occlude: (updates) => updates }
+});
+var unacknowledgedUpdatesAtoms = atomFamily({
+  key: `unacknowledgedUpdates`,
+  default: () => []
+});
+var CustomSocket = class {
+  listeners;
+  globalListeners;
+  handleEvent(...args) {
+    const [event, ...rest] = args;
+    for (const listener of this.globalListeners)
+      listener(event, ...rest);
+    const listeners = this.listeners.get(event);
+    if (listeners)
+      for (const listener of listeners)
+        listener(...rest);
+  }
+  id = `no_id_retrieved`;
+  emit;
+  constructor(emit) {
+    this.emit = emit;
+    this.listeners = /* @__PURE__ */ new Map;
+    this.globalListeners = /* @__PURE__ */ new Set;
+  }
+  on(event, listener) {
+    const listeners = this.listeners.get(event);
+    if (listeners)
+      listeners.add(listener);
+    else
+      this.listeners.set(event, 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;
+  }
+};
+var ChildSocket = class extends CustomSocket {
+  incompleteData = ``;
+  unprocessedEvents = [];
+  incompleteLog = ``;
+  unprocessedLogs = [];
+  id = `#####`;
+  proc;
+  key;
+  logger;
+  handleLog(log) {
+    if (Array.isArray(log)) {
+      const [level, ...rest] = log;
+      switch (level) {
+        case `i`:
+          this.logger.info(...rest);
+          break;
+        case `w`:
+          this.logger.warn(...rest);
+          break;
+        case `e`:
+          this.logger.error(...rest);
+          break;
+      }
+    }
+  }
+  constructor(proc, key, logger) {
+    super((event, ...args) => {
+      const stringifiedEvent = JSON.stringify([event, ...args]) + `\x03`;
+      const errorHandler = (err) => {
+        if (err.code === `EPIPE`)
+          console.error(`EPIPE error during write`, this.proc.stdin);
+        this.proc.stdin.removeListener(`error`, errorHandler);
+      };
+      this.proc.stdin.once(`error`, errorHandler);
+      this.proc.stdin.write(stringifiedEvent);
+      return this;
+    });
+    this.proc = proc;
+    this.key = key;
+    this.logger = logger ?? {
+      info: (...args) => {
+        console.info(this.id, this.key, ...args);
+      },
+      warn: (...args) => {
+        console.warn(this.id, this.key, ...args);
+      },
+      error: (...args) => {
+        console.error(this.id, this.key, ...args);
+      }
+    };
+    this.proc.stdout.on(`data`, (buffer) => {
+      const chunk = buffer.toString();
+      if (chunk === `ALIVE`) {
+        this.logger.info(chunk);
+        return;
+      }
+      const pieces = chunk.split(`\x03`);
+      const initialMaybeWellFormed = pieces[0];
+      pieces[0] = this.incompleteData + initialMaybeWellFormed;
+      let idx = 0;
+      for (const piece of pieces) {
+        if (piece === ``)
+          continue;
+        try {
+          const jsonPiece = parseJson(piece);
+          this.handleEvent(...jsonPiece);
+          this.incompleteData = ``;
+        } catch (thrown0) {
+          if (thrown0 instanceof Error)
+            console.error([
+              `\u274C Malformed data received from child process`,
+              ``,
+              piece,
+              ``,
+              thrown0.message
+            ].join(`
+\u274C	`));
+          try {
+            if (idx === 0) {
+              this.incompleteData = piece;
+              const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
+              this.handleEvent(...maybeActualJsonPiece);
+              this.incompleteData = ``;
+            } else
+              this.incompleteData += piece;
+          } catch (thrown1) {
+            if (thrown1 instanceof Error)
+              console.error([
+                `\u274C Malformed data received from child process`,
+                ``,
+                initialMaybeWellFormed,
+                ``,
+                thrown1.message
+              ].join(`
+\u274C	`));
+          }
+        }
+        ++idx;
+      }
+    });
+    this.proc.stderr.on(`data`, (buffer) => {
+      const pieces = buffer.toString().split(`\x03`);
+      const initialMaybeWellFormed = pieces[0];
+      pieces[0] = this.incompleteData + initialMaybeWellFormed;
+      let idx = 0;
+      for (const piece of pieces) {
+        if (piece === ``)
+          continue;
+        try {
+          const jsonPiece = parseJson(piece);
+          this.handleLog(jsonPiece);
+          this.incompleteData = ``;
+        } catch (thrown0) {
+          if (thrown0 instanceof Error)
+            console.error([
+              `\u274C Malformed log received from child process`,
+              ``,
+              piece,
+              ``,
+              thrown0.message
+            ].join(`
+\u274C	`));
+          try {
+            if (idx === 0) {
+              this.incompleteData = piece;
+              const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
+              this.handleLog(maybeActualJsonPiece);
+              this.incompleteData = ``;
+            } else
+              this.incompleteData += piece;
+          } catch (thrown1) {
+            if (thrown1 instanceof Error)
+              console.error([
+                `\u274C Malformed log received from child process...`,
+                ``,
+                initialMaybeWellFormed,
+                ``,
+                thrown1.message
+              ].join(`
+\u274C	`));
+          }
+        }
+        ++idx;
+      }
+    });
+    if (proc.pid)
+      this.id = proc.pid.toString();
+  }
+};
+var SubjectSocket = class extends CustomSocket {
+  in;
+  out;
+  id = `no_id_retrieved`;
+  disposalFunctions = [];
+  constructor(id) {
+    super((...args) => {
+      this.out.next(args);
+      return this;
+    });
+    this.id = id;
+    this.in = new Subject;
+    this.out = new Subject;
+    this.in.subscribe(`socket`, (event) => {
+      this.handleEvent(...event);
+    });
+  }
+  dispose() {
+    for (const dispose of this.disposalFunctions)
+      dispose();
+  }
+};
+var ParentSocket = class extends CustomSocket {
+  incompleteData = ``;
+  unprocessedEvents = [];
+  relays;
+  relayServices;
+  proc;
+  id = `#####`;
+  log(...args) {
+    this.proc.stderr.write(stringifyJson(args.map((arg) => arg instanceof UList ? `{ ${arg.toJSON().join(` | `)} }` : arg)) + `\x03`);
+  }
+  logger = {
+    info: (...args) => {
+      this.log(`i`, ...args);
+    },
+    warn: (...args) => {
+      this.log(`w`, ...args);
+    },
+    error: (...args) => {
+      this.log(`e`, ...args);
+    }
+  };
+  constructor(proc) {
+    super((event, ...args) => {
+      const stringifiedEvent = JSON.stringify([event, ...args]);
+      this.proc.stdout.write(stringifiedEvent + `\x03`);
+      return this;
+    });
+    this.proc = proc;
+    this.proc.stdin.resume();
+    this.relays = /* @__PURE__ */ new Map;
+    this.relayServices = [];
+    this.proc.stdin.on(`data`, (buffer) => {
+      const pieces = buffer.toString().split(`\x03`);
+      const initialMaybeWellFormed = pieces[0];
+      pieces[0] = this.incompleteData + initialMaybeWellFormed;
+      let idx = 0;
+      for (const piece of pieces) {
+        if (piece === ``)
+          continue;
+        try {
+          const jsonPiece = parseJson(piece);
+          this.logger.info(`\uD83C\uDFB0`, `received`, jsonPiece);
+          this.handleEvent(...jsonPiece);
+          this.incompleteData = ``;
+        } catch (thrown0) {
+          if (thrown0 instanceof Error)
+            this.logger.error([
+              `received malformed data from parent process:`,
+              ``,
+              piece,
+              ``,
+              thrown0.message
+            ].join(`
+\u274C	`));
+          try {
+            if (idx === 0) {
+              this.incompleteData = piece;
+              const maybeActualJsonPiece = parseJson(initialMaybeWellFormed);
+              this.logger.info(`\uD83C\uDFB0`, `received`, maybeActualJsonPiece);
+              this.handleEvent(...maybeActualJsonPiece);
+              this.incompleteData = ``;
+            } else
+              this.incompleteData += piece;
+          } catch (thrown1) {
+            if (thrown1 instanceof Error)
+              this.logger.error([
+                `received malformed data from parent process:`,
+                ``,
+                initialMaybeWellFormed,
+                ``,
+                thrown1.message
+              ].join(`
+\u274C	`));
+          }
+        }
+        ++idx;
+      }
+    });
+    this.on(`exit`, () => {
+      this.logger.info(`\uD83D\uDD25`, this.id, `received "exit"`);
+      this.proc.exit(0);
+    });
+    if (this.proc.pid)
+      this.id = this.proc.pid?.toString();
+    this.on(`user-joins`, (username) => {
+      this.logger.info(`\uD83D\uDC64`, `user`, username, `joined`);
+      const userKey = `user::${username}`;
+      const relay = new SubjectSocket(userKey);
+      this.relays.set(username, relay);
+      this.logger.info(`\uD83D\uDD17`, `attaching services:`, `[${[...this.relayServices.keys()].join(`, `)}]`);
+      for (const attachRelay of this.relayServices) {
+        const cleanupRelay = attachRelay(relay, userKey);
+        if (cleanupRelay)
+          relay.disposalFunctions.push(cleanupRelay);
+      }
+      this.on(userKey, (...data) => {
+        relay.in.next(data);
+      });
+      relay.out.subscribe(`socket`, (data) => {
+        this.emit(...data);
+      });
+    });
+    this.on(`user-leaves`, (username) => {
+      const relay = this.relays.get(username);
+      this.off(`relay:${username}`);
+      if (relay) {
+        relay.dispose();
+        this.relays.delete(username);
+      }
+    });
+    this.proc.stdout.write(`ALIVE`);
+  }
+  receiveRelay(attachServices) {
+    this.logger.info(`\uD83D\uDD17`, `running relay method`);
+    this.relayServices.push(attachServices);
+  }
+};
+var ROOMS = /* @__PURE__ */ new Map;
+var joinRoomTX = transaction({
+  key: `joinRoom`,
+  do: (tools, roomId, userId, enteredAtEpoch) => {
+    const meta = { enteredAtEpoch };
+    editRelationsInStore(usersInRooms, (relations) => {
+      relations.set({
+        room: roomId,
+        user: userId
+      });
+    }, tools.env().store);
+    return meta;
+  }
+});
+var leaveRoomTX = transaction({
+  key: `leaveRoom`,
+  do: ({ env }, roomId, userId) => {
+    editRelationsInStore(usersInRooms, (relations) => {
+      relations.delete({
+        room: roomId,
+        user: userId
+      });
+    }, env().store);
+  }
+});
+var destroyRoomTX = transaction({
+  key: `destroyRoom`,
+  do: ({ set, env }, roomId) => {
+    editRelationsInStore(usersInRooms, (relations) => {
+      relations.delete({ room: roomId });
+    }, env().store);
+    set(roomIndex, (s) => (s.delete(roomId), s));
+    const room = ROOMS.get(roomId);
+    if (room) {
+      room.emit(`exit`);
+      ROOMS.delete(roomId);
+    }
+  }
+});
+var socketAtoms = atomFamily({
+  key: `sockets`,
+  default: null
+});
+var socketIndex = mutableAtom({
+  key: `socketsIndex`,
+  class: UList
+});
+var userIndex = mutableAtom({
+  key: `usersIndex`,
+  class: UList
+});
+var usersOfSockets = join({
+  key: `usersOfSockets`,
+  between: [`user`, `socket`],
+  cardinality: `1:1`,
+  isAType: (s) => s.startsWith(`user::`),
+  isBType: (s) => s.startsWith(`socket::`)
+});
+var userMutualSituationalAwarenessIndexes = selectorFamily({
+  key: `userMutualSituationalAwarenessIndexes`,
+  get: (userId) => () => {
+    return [userId];
+  }
+});
+
+// src/backend.worker.game.bun.ts
+var parent = new ParentSocket(process);
+Object.assign(console, parent.logger, { log: parent.logger.info });
+parent.on(`timeToStop`, function gracefulExit() {
+  parent.logger.info(`\uD83D\uDEEC game worker exiting`);
+  process.exit(0);
+});
+parent.logger.info(`\uD83D\uDEEB game worker ready`);