tempest.games 0.3.13 → 0.3.14

package/bin/backend.worker.bug-rangers.bun.js

@@ -9123,9 +9123,9 @@ ${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
   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);
+      const join2 = target.joins.get(joinKey);
+      if (join2)
+        join2.relations.delete(claim);
     }
   else {
     const compound = decomposeCompound(claim);
@@ -9133,9 +9133,9 @@ ${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`);
       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);
+        const join2 = target.joins.get(joinKey);
+        if (join2)
+          join2.relations.delete(a, b);
       }
     }
   }
@@ -9888,7 +9888,7 @@ function createRegularAtomFamily(store, options, internalRoles) {
       individualOptions.catch = options.catch;
     return createRegularAtom(target, individualOptions, family);
   };
-  const atomFamily$1 = {
+  const atomFamily2 = {
     ...familyToken,
     create,
     default: options.default,
@@ -9896,7 +9896,7 @@ function createRegularAtomFamily(store, options, internalRoles) {
     install: (s) => createRegularAtomFamily(s, options),
     internalRoles
   };
-  store.families.set(options.key, atomFamily$1);
+  store.families.set(options.key, atomFamily2);
   if (isFn(options.default) === false)
     store.defaults.set(options.key, options.default);
   return familyToken;
@@ -9961,7 +9961,7 @@ function createWritableHeldSelectorFamily(store, options, internalRoles) {
       set: options.set(key)
     }, family);
   };
-  const selectorFamily$1 = {
+  const selectorFamily2 = {
     ...familyToken,
     create,
     internalRoles,
@@ -9969,7 +9969,7 @@ function createWritableHeldSelectorFamily(store, options, internalRoles) {
     install: (s) => createWritableHeldSelectorFamily(s, options),
     default: options.const
   };
-  store.families.set(familyKey, selectorFamily$1);
+  store.families.set(familyKey, selectorFamily2);
   return familyToken;
 }
 function createWritablePureSelectorFamily(store, options, internalRoles) {
@@ -10000,7 +10000,7 @@ function createWritablePureSelectorFamily(store, options, internalRoles) {
       individualOptions.catch = options.catch;
     return createWritablePureSelector(target, individualOptions, family);
   };
-  const selectorFamily$1 = {
+  const selectorFamily2 = {
     ...familyToken,
     create,
     internalRoles,
@@ -10018,7 +10018,7 @@ function createWritablePureSelectorFamily(store, options, internalRoles) {
       });
     }
   };
-  store.families.set(familyKey, selectorFamily$1);
+  store.families.set(familyKey, selectorFamily2);
   return familyToken;
 }
 function createSelectorFamily(store, options) {
@@ -10161,17 +10161,17 @@ function dispatchOrDeferStateUpdate(target, state, proto2, stateIsNewlyCreated,
     }
   }
 }
-function resetAtom(target, atom$1) {
-  switch (atom$1.type) {
+function resetAtom(target, atom2) {
+  switch (atom2.type) {
     case `mutable_atom`:
-      return setAtom(target, atom$1, new atom$1.class);
+      return setAtom(target, atom2, new atom2.class);
     case `atom`: {
       let def;
-      if (isFn(atom$1.default))
-        def = safeCompute(target, atom$1);
+      if (isFn(atom2.default))
+        def = safeCompute(target, atom2);
       else
-        def = atom$1.default;
-      return setAtom(target, atom$1, def);
+        def = atom2.default;
+      return setAtom(target, atom2, def);
     }
   }
 }
@@ -10185,8 +10185,8 @@ function resetAtomOrSelector(target, state) {
     case `writable_held_selector`:
       {
         const atoms = traceRootSelectorAtoms(target, state.key);
-        for (const atom$1 of atoms.values())
-          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom$1), false);
+        for (const atom2 of atoms.values())
+          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom2), false);
         const value2 = state.getFrom(target);
         protoUpdate = {
           oldValue: value2,
@@ -10198,8 +10198,8 @@ function resetAtomOrSelector(target, state) {
       {
         const oldValue = safeCompute(target, state);
         const atoms = traceRootSelectorAtoms(target, state.key);
-        for (const atom$1 of atoms.values())
-          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom$1), false);
+        for (const atom2 of atoms.values())
+          dispatchOrDeferStateUpdate(target, state, resetAtom(target, atom2), false);
         protoUpdate = {
           oldValue,
           newValue: safeCompute(target, state)
@@ -10215,26 +10215,26 @@ function setIntoStore(store, ...params) {
 function resetInStore(store, ...params) {
   setIntoStore(store, ...[...params, RESET_STATE]);
 }
-function setSelector(target, selector$1, next2) {
+function setSelector(target, selector2, next2) {
   let oldValue;
   let newValue;
   let constant;
-  const { type: type2, key } = selector$1;
-  switch (selector$1.type) {
+  const { type: type2, key } = selector2;
+  switch (selector2.type) {
     case `writable_pure_selector`:
-      oldValue = readOrComputeValue(target, selector$1, `mut`);
+      oldValue = readOrComputeValue(target, selector2, `mut`);
       newValue = become(next2, oldValue);
-      newValue = writeToCache(target, selector$1, newValue);
+      newValue = writeToCache(target, selector2, newValue);
       break;
     case `writable_held_selector`:
-      constant = selector$1.const;
+      constant = selector2.const;
       become(next2, constant);
       oldValue = constant;
       newValue = constant;
   }
   target.logger.info(`\u2B50`, type2, key, `setting to`, newValue);
   markDone(target, key);
-  selector$1.setSelf(newValue);
+  selector2.setSelf(newValue);
   return {
     oldValue,
     newValue
@@ -10313,8 +10313,8 @@ function traceRootSelectorAtoms(store, selectorKey, covered = /* @__PURE__ */ ne
       continue;
     covered.add(dependencyKey);
     if (isAtomKey(store, dependencyKey)) {
-      const atom$1 = store.atoms.get(dependencyKey);
-      roots.set(atom$1.key, atom$1);
+      const atom2 = store.atoms.get(dependencyKey);
+      roots.set(atom2.key, atom2);
     } else
       dependencies.push(...getSelectorDependencyKeys(store, dependencyKey));
   }
@@ -10559,19 +10559,19 @@ 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;
+    const state2 = createWritableHeldSelector(store, options, undefined);
+    store.on.selectorCreation.next(state2);
+    return state2;
   }
   if (isHeld) {
-    const state$1 = createReadonlyHeldSelector(store, options, undefined);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
+    const state2 = createReadonlyHeldSelector(store, options, undefined);
+    store.on.selectorCreation.next(state2);
+    return state2;
   }
   if (isWritable) {
-    const state$1 = createWritablePureSelector(store, options, undefined);
-    store.on.selectorCreation.next(state$1);
-    return state$1;
+    const state2 = createWritablePureSelector(store, options, undefined);
+    store.on.selectorCreation.next(state2);
+    return state2;
   }
   const state = createReadonlyPureSelector(store, options, undefined);
   store.on.selectorCreation.next(state);
@@ -10670,8 +10670,8 @@ function subscribeToState(store, token, key, handleUpdate) {
   let updateHandler = safelyHandleUpdate;
   if (isSelector) {
     readOrComputeValue(store, state);
-    for (const [atomKey, atom$1] of traceRootSelectorAtoms(store, state.key))
-      rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
+    for (const [atomKey, atom2] of traceRootSelectorAtoms(store, state.key))
+      rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom2));
     updateHandler = function updateRootsBeforeHandlingUpdate(update) {
       const dependencies = traceRootSelectorAtoms(store, state.key);
       for (const [previousRootKey, unsub] of rootSubs)
@@ -10681,8 +10681,8 @@ function subscribeToState(store, token, key, handleUpdate) {
           unsub();
           rootSubs.delete(previousRootKey);
         }
-      for (const [atomKey, atom$1] of dependencies)
-        rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom$1));
+      for (const [atomKey, atom2] of dependencies)
+        rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom2));
       safelyHandleUpdate(update);
     };
   }
@@ -10780,7 +10780,7 @@ function createMutableAtomFamily(store, options, internalRoles) {
       individualOptions.effects = options.effects(key);
     return createMutableAtom(target, individualOptions, family);
   };
-  const atomFamily$1 = {
+  const atomFamily2 = {
     ...familyToken,
     create,
     class: options.class,
@@ -10788,7 +10788,7 @@ function createMutableAtomFamily(store, options, internalRoles) {
     install: (s) => createMutableAtomFamily(s, options),
     internalRoles
   };
-  store.families.set(options.key, atomFamily$1);
+  store.families.set(options.key, atomFamily2);
   createWritablePureSelectorFamily(store, {
     key: `${options.key}:JSON`,
     get: (key) => ({ get }) => get(familyToken, key).toJSON(),
@@ -10796,7 +10796,7 @@ function createMutableAtomFamily(store, options, internalRoles) {
       set(familyToken, key, options.class.fromJSON(newValue));
     }
   }, [`mutable`, `json`]);
-  new FamilyTracker(atomFamily$1, store);
+  new FamilyTracker(atomFamily2, store);
   return familyToken;
 }
 function isTransceiver(value2) {
@@ -10849,16 +10849,16 @@ function readFromCache(target, state, mut) {
   target.logger.info(`\uD83D\uDCD6`, state.type, state.key, `reading cached value`);
   let value2 = target.valueMap.get(state.key);
   if (mut === `mut` && state.type === `mutable_atom` && isChildStore(target)) {
-    const mutableAtom$1 = state;
+    const mutableAtom2 = state;
     const { parent } = target;
-    if (target.valueMap.hasOwn(mutableAtom$1.key))
+    if (target.valueMap.hasOwn(mutableAtom2.key))
       return value2;
-    const parentValue = parent.valueMap.get(mutableAtom$1.key);
-    target.logger.info(`\uD83D\uDCC3`, `atom`, mutableAtom$1.key, `copying`);
+    const parentValue = parent.valueMap.get(mutableAtom2.key);
+    target.logger.info(`\uD83D\uDCC3`, `atom`, mutableAtom2.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);
+    const copiedValue = mutableAtom2.class.fromJSON(jsonValue);
+    target.valueMap.set(mutableAtom2.key, copiedValue);
+    new Tracker(mutableAtom2, parent);
     value2 = copiedValue;
   }
   return value2;
@@ -10872,9 +10872,9 @@ function evictCachedValue(target, key) {
   target.valueMap.delete(key);
   target.logger.info(`\uD83D\uDDD1`, `state`, key, `evicted`);
 }
-function evictDownstreamFromAtom(store, atom$1) {
+function evictDownstreamFromAtom(store, atom2) {
   const target = newest(store);
-  const { key, type: type2 } = atom$1;
+  const { key, type: type2 } = atom2;
   const downstreamKeys = target.selectorAtoms.getRelatedKeys(key);
   target.logger.info(`\uD83E\uDDF9`, type2, key, downstreamKeys ? `evicting ${downstreamKeys.size} states downstream:` : `no downstream states`, downstreamKeys ?? `to evict`);
   if (downstreamKeys) {
@@ -10952,20 +10952,20 @@ function createRegularAtom(store, options, family, internalRoles) {
   store.on.atomCreation.next(token);
   return token;
 }
-function hasRole(atom$1, role) {
-  if (`internalRoles` in atom$1 === false)
+function hasRole(atom2, role) {
+  if (`internalRoles` in atom2 === false)
     return false;
-  return atom$1.internalRoles.includes(role);
+  return atom2.internalRoles.includes(role);
 }
 function disposeAtom(store, atomToken) {
   const target = newest(store);
   const { key, family } = atomToken;
-  const atom$1 = withdraw(target, atomToken);
+  const atom2 = withdraw(target, atomToken);
   if (!family)
     store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   else {
-    atom$1.cleanup?.();
-    const lastValue = store.valueMap.get(atom$1.key);
+    atom2.cleanup?.();
+    const lastValue = store.valueMap.get(atom2.key);
     const subject = withdraw(store, getFamilyOfToken(store, atomToken)).subject;
     const disposalEvent = {
       type: `state_disposal`,
@@ -10989,8 +10989,8 @@ function disposeAtom(store, atomToken) {
     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$1.family?.key);
-      const isTracker = hasRole(atom$1, `tracker:signal`);
+      const updateAlreadyCaptured = mostRecentUpdate?.type === `molecule_disposal` && mostRecentUpdate.values.some(([k]) => k === atom2.family?.key);
+      const isTracker = hasRole(atom2, `tracker:signal`);
       if (!updateAlreadyCaptured && !isTracker)
         target.transactionMeta.update.subEvents.push(disposalEvent);
     } else
@@ -11538,23 +11538,23 @@ var NON_CTOR_FN_REGEX, Future, Subject = class {
         family.install(this);
       }
       const mutableHelpers = /* @__PURE__ */ new Set;
-      for (const [, atom$1] of store.atoms) {
-        if (mutableHelpers.has(atom$1.key))
+      for (const [, atom2] of store.atoms) {
+        if (mutableHelpers.has(atom2.key))
           continue;
-        atom$1.install(this);
-        if (atom$1.type === `mutable_atom`) {
-          const originalJsonToken = getJsonToken(store, atom$1);
-          const originalUpdateToken = getUpdateToken(atom$1);
+        atom2.install(this);
+        if (atom2.type === `mutable_atom`) {
+          const originalJsonToken = getJsonToken(store, atom2);
+          const originalUpdateToken = getUpdateToken(atom2);
           mutableHelpers.add(originalJsonToken.key);
           mutableHelpers.add(originalUpdateToken.key);
         }
       }
-      for (const [, selector$1] of store.readonlySelectors)
-        selector$1.install(this);
-      for (const [, selector$1] of store.writableSelectors) {
-        if (mutableHelpers.has(selector$1.key))
+      for (const [, selector2] of store.readonlySelectors)
+        selector2.install(this);
+      for (const [, selector2] of store.writableSelectors) {
+        if (mutableHelpers.has(selector2.key))
           continue;
-        selector$1.install(this);
+        selector2.install(this);
       }
       for (const [, tx] of store.transactions)
         tx.install(this);
@@ -11574,26 +11574,26 @@ var NON_CTOR_FN_REGEX, Future, Subject = class {
     return;
   }
   store.operation.done.add(key);
-}, UNSET, setAtom = (target, atom$1, next2) => {
+}, UNSET, setAtom = (target, atom2, next2) => {
   let oldValue;
   let newValue;
   if (isFn(next2)) {
-    const prev = readOrComputeValue(target, atom$1, `mut`);
+    const prev = readOrComputeValue(target, atom2, `mut`);
     oldValue = prev;
     newValue = next2(prev);
   } else {
-    if (target.valueMap.has(atom$1.key))
-      oldValue = readFromCache(target, atom$1, `mut`);
-    else if (atom$1.type === `atom` && !isFn(atom$1.default))
-      oldValue = atom$1.default;
+    if (target.valueMap.has(atom2.key))
+      oldValue = readFromCache(target, atom2, `mut`);
+    else if (atom2.type === `atom` && !isFn(atom2.default))
+      oldValue = atom2.default;
     else
       oldValue = UNSET;
     newValue = next2;
   }
-  target.logger.info(`\u2B50`, `atom`, atom$1.key, `setting value`, newValue);
-  newValue = writeToCache(target, atom$1, newValue);
-  markDone(target, atom$1.key);
-  evictDownstreamFromAtom(target, atom$1);
+  target.logger.info(`\u2B50`, `atom`, atom2.key, `setting value`, newValue);
+  newValue = writeToCache(target, atom2, newValue);
+  markDone(target, atom2.key);
+  evictDownstreamFromAtom(target, atom2);
   if (oldValue === UNSET)
     return { newValue };
   return {
@@ -11618,13 +11618,13 @@ var NON_CTOR_FN_REGEX, Future, Subject = class {
   if (target.operation.open)
     return target.operation.prev.get(state.key);
   return target.valueMap.get(state.key);
-}, subscribeToRootDependency = (target, selector$1, atom$1) => {
-  return atom$1.subject.subscribe(`${selector$1.type}:${selector$1.key}`, (atomChange) => {
-    target.logger.info(`\uD83D\uDCE2`, selector$1.type, selector$1.key, `root`, atom$1.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
-    const oldValue = recallState(target, selector$1);
-    const newValue = readOrComputeValue(target, selector$1);
-    target.logger.info(`\u2728`, selector$1.type, selector$1.key, `went`, oldValue, `->`, newValue);
-    selector$1.subject.next({
+}, subscribeToRootDependency = (target, selector2, atom2) => {
+  return atom2.subject.subscribe(`${selector2.type}:${selector2.key}`, (atomChange) => {
+    target.logger.info(`\uD83D\uDCE2`, selector2.type, selector2.key, `root`, atom2.key, `went`, atomChange.oldValue, `->`, atomChange.newValue);
+    const oldValue = recallState(target, selector2);
+    const newValue = readOrComputeValue(target, selector2);
+    target.logger.info(`\u2728`, selector2.type, selector2.key, `went`, oldValue, `->`, newValue);
+    selector2.subject.next({
       newValue,
       oldValue
     });
@@ -11955,26 +11955,26 @@ var init_internal = __esm(() => {
                 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;
+                operateOnStore(JOIN_OP, this.store, relatedKeysAtoms, previousOwner, (relations2) => {
+                  relations2.delete(newRelationB);
+                  previousOwnerSize = relations2.size;
+                  return relations2;
                 });
                 if (previousOwnerSize === 0)
                   previousOwnersToDispose.push(previousOwner);
               }
               if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0)
-                set(relationsOfBAtom, (relations$1) => {
-                  relations$1.clear();
-                  return relations$1;
+                set(relationsOfBAtom, (relations2) => {
+                  relations2.clear();
+                  return relations2;
                 });
               for (const previousOwner of previousOwnersToDispose)
                 store.keyRefsInJoins.delete(simpleCompound(newRelationB, previousOwner));
             }
             if (!newRelationBIsAlreadyRelated)
-              set(relationsOfBAtom, (relations$1) => {
-                relations$1.add(a);
-                return relations$1;
+              set(relationsOfBAtom, (relations2) => {
+                relations2.add(a);
+                return relations2;
               });
             relationsOfA.add(newRelationB);
           }
@@ -14730,7 +14730,7 @@ var require_src = __commonJS((exports, module2) => {
   }
 });
 
-// ../../node_modules/.pnpm/@t3-oss+env-core@0.13.10_arktype@2.1.29_typescript@5.9.3_zod@4.3.5/node_modules/@t3-oss/env-core/dist/standard.js
+// ../../node_modules/.pnpm/@t3-oss+env-core@0.13.10_arktype@2.1.29_typescript@5.9.3_zod@4.3.6/node_modules/@t3-oss/env-core/dist/standard.js
 function ensureSynchronous(value3, message) {
   if (value3 instanceof Promise)
     throw new Error(message);
@@ -14757,7 +14757,7 @@ function parseWithDictionary(dictionary, value3) {
 }
 var init_standard = () => {};
 
-// ../../node_modules/.pnpm/@t3-oss+env-core@0.13.10_arktype@2.1.29_typescript@5.9.3_zod@4.3.5/node_modules/@t3-oss/env-core/dist/index.js
+// ../../node_modules/.pnpm/@t3-oss+env-core@0.13.10_arktype@2.1.29_typescript@5.9.3_zod@4.3.6/node_modules/@t3-oss/env-core/dist/index.js
 function createEnv(opts) {
   const runtimeEnv = opts.runtimeEnvStrict ?? opts.runtimeEnv ?? process.env;
   if (opts.emptyStringAsUndefined ?? false) {
@@ -29097,8 +29097,15 @@ parent.receiveRelay((socket, userKey) => {
           const stackHeight = getState2(gameTilesStackHeightAtoms, turnInProgress.target);
           if (stackHeight >= maximumStackHeight)
             return;
+          const { target } = turnInProgress;
+          const newStackHeight = stackHeight + 1;
           setState(playerRemainingTilesAtoms, userKey, (n) => n - 1);
-          setState(gameTilesStackHeightAtoms, turnInProgress.target, stackHeight + 1);
+          setState(gameTilesStackHeightAtoms, target, newStackHeight);
+          setState(turnInProgressAtom, {
+            type: `build`,
+            target,
+            count: newStackHeight
+          });
           socket.emit(`placeTile`, turnInProgress.target);
         }
         break;
@@ -29238,7 +29245,7 @@ parent.receiveRelay((socket, userKey) => {
       case `build`:
         {
           const { target, count } = turnInProgress;
-          setState(gameTilesStackHeightAtoms, target, 0);
+          setState(gameTilesStackHeightAtoms, target, 1);
           setState(tileCubeCountAtoms, target, 0);
           setState(tileOwnerAtoms, target, null);
           setState(playerRemainingTilesAtoms, userKey, (n) => n + count);