tempest.games 0.2.73 → 0.2.75

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

@@ -114,28 +114,9 @@ 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) {
@@ -300,9 +281,6 @@ var UList = class UList2 extends Set {
 };
 
 // ../../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;
@@ -894,426 +872,12 @@ var Junction = class Junction2 {
 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 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
-${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;
@@ -1991,34 +1555,6 @@ function createSelectorFamily(store, options) {
     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();
@@ -2588,85 +2124,6 @@ function createStandaloneSelector(store, options) {
   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)
@@ -3141,46 +2598,6 @@ function hasRole(atom, role) {
     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);
 }
@@ -3523,11 +2940,10 @@ var SyncGroup = class SyncGroup2 {
     return this;
   }
 };
-var usersInThisRoomIndex = mutableAtom({
-  key: `usersInRoomIndex`,
-  class: UList
-});
-var roomIndex = mutableAtom({
+var isSocketKey = (key) => key.startsWith(`socket::`);
+var isUserKey = (key) => key.startsWith(`user::`);
+var isRoomKey = (key) => key.startsWith(`room::`);
+var roomKeysAtom = mutableAtom({
   key: `roomIndex`,
   class: UList
 });
@@ -3535,8 +2951,8 @@ var usersInRooms = join({
   key: `usersInRooms`,
   between: [`room`, `user`],
   cardinality: `1:n`,
-  isAType: (input) => typeof input === `string`,
-  isBType: (input) => typeof input === `string`
+  isAType: isRoomKey,
+  isBType: isUserKey
 });
 var usersInMyRoomView = selectorFamily({
   key: `usersInMyRoomView`,
@@ -3887,54 +3303,15 @@ var ParentSocket = class extends CustomSocket {
     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({
+var socketKeysAtom = mutableAtom({
   key: `socketsIndex`,
   class: UList
 });
-var userIndex = mutableAtom({
+var userKeysAtom = mutableAtom({
   key: `usersIndex`,
   class: UList
 });
@@ -3942,15 +3319,14 @@ var usersOfSockets = join({
   key: `usersOfSockets`,
   between: [`user`, `socket`],
   cardinality: `1:1`,
-  isAType: (s) => s.startsWith(`user::`),
-  isBType: (s) => s.startsWith(`socket::`)
+  isAType: isUserKey,
+  isBType: isSocketKey
 });
-var userMutualSituationalAwarenessIndexes = selectorFamily({
-  key: `userMutualSituationalAwarenessIndexes`,
-  get: (userId) => () => {
-    return [userId];
-  }
+var selfListSelectors = selectorFamily({
+  key: `selfList`,
+  get: (userId) => () => [userId]
 });
+var ROOMS = globalThis.ATOM_IO_REALTIME_SERVER_ROOMS ?? (globalThis.ATOM_IO_REALTIME_SERVER_ROOMS = /* @__PURE__ */ new Map);
 
 // src/backend.worker.game.bun.ts
 var parent = new ParentSocket(process);