@vibemancer/core 1.0.10 → 1.0.12

package/dist/{chunk-OLGKLCCB.js → chunk-KGRG7TZS.js}

@@ -213,7 +213,7 @@ function currentRuleset() {
 }
 
 // src/engine-version.ts
-var ENGINE_VERSION = 293192982913104;
+var ENGINE_VERSION = 4256327861353618;
 var EQUIVALENT_ENGINE_VERSIONS = [1688330189011034];
 
 // src/replay-compat.ts
@@ -516,11 +516,60 @@ function flyStraight() {
     _toMissileAction: () => ({})
   };
 }
+function describeReturned(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "object") {
+    if ("then" in value && typeof value.then === "function") {
+      return "a Promise \u2014 your function is `async`, and it must not be: remove the async keyword";
+    }
+    return "a plain object";
+  }
+  return `a ${typeof value}`;
+}
 function extractMissileAction(action) {
+  if (action === null || action === void 0 || typeof action._toMissileAction !== "function") {
+    throw new Error(
+      `Your missile AI returned ${describeReturned(action)}. Return turnToward(x, y), turnToAngle(degrees) or flyStraight(). The missile AI runs once per tick for every missile you have in flight, and it must return one of those every time.`
+    );
+  }
   return action._toMissileAction();
 }
 function extractAction(finalAction) {
-  return finalAction._toAction();
+  if (finalAction === null || finalAction === void 0 || typeof finalAction._toAction !== "function") {
+    const got = describeReturned(finalAction);
+    throw new Error(
+      `Your bot returned ${got}. Return one of: idle(), move(x, y), missile(config, ai, angle), shield(), blink(x, y), cancel() or aim(degrees). A bot must return an action every tick \u2014 returning nothing throws, it does not skip the tick.`
+    );
+  }
+  const action = finalAction._toAction();
+  if (action === null || typeof action !== "object" || typeof action.move !== "object" || action.move === null) {
+    throw new Error(
+      "Your bot returned something that is not a valid action. Build actions with the provided functions \u2014 idle(), move(x, y), missile(config, ai, angle), shield(), blink(x, y), cancel() or aim(degrees) \u2014 rather than constructing the object yourself."
+    );
+  }
+  return normaliseActionNumbers(action);
+}
+function normaliseActionNumbers(action) {
+  const num = (value) => Number(value);
+  const normalised = {
+    ...action,
+    move: { x: num(action.move?.x), y: num(action.move?.y) }
+  };
+  if (action.aimDirection !== void 0) normalised.aimDirection = num(action.aimDirection);
+  if (action.startCast?.spell === "missile") {
+    normalised.startCast = {
+      ...action.startCast,
+      ...action.startCast.direction !== void 0 ? { direction: num(action.startCast.direction) } : {}
+    };
+  } else if (action.startCast?.spell === "blink") {
+    normalised.startCast = {
+      ...action.startCast,
+      target: { x: num(action.startCast.target?.x), y: num(action.startCast.target?.y) }
+    };
+  }
+  return normalised;
 }
 
 // src/engine/physics.ts
@@ -551,6 +600,27 @@ function moveProjectile(projectile, deltaTicks) {
     y: projectile.position.y + Math.sin(radians) * projectile.speed * deltaTicks
   };
 }
+function clampToSafeZone(position, radius) {
+  const min = ARENA_MIN + radius;
+  const max = ARENA_MAX - radius;
+  const centre = ARENA_SIZE / 2;
+  const axis = (value) => {
+    if (!Number.isFinite(value)) return centre;
+    return Math.max(min, Math.min(max, value));
+  };
+  return { x: axis(position?.x), y: axis(position?.y) };
+}
+function moveTowardSafely(from, target) {
+  const dx = target?.x - from?.x;
+  const dy = target?.y - from?.y;
+  if (!Number.isFinite(dx) || !Number.isFinite(dy)) return { x: 0, y: 0 };
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  if (distance === 0) return { x: 0, y: 0 };
+  if (distance >= RULES.MOVEMENT_SPEED) return { x: dx / distance, y: dy / distance };
+  const travel = Math.max(0, distance - 1e-6);
+  const fraction = travel / RULES.MOVEMENT_SPEED;
+  return { x: dx / distance * fraction, y: dy / distance * fraction };
+}
 function clampToArena(position, radius) {
   return {
     x: Math.max(radius, Math.min(ARENA_SIZE - radius, position.x)),
@@ -605,7 +675,8 @@ function startCast(wizard, spell, config) {
   wizard.castingSpell = spell;
   wizard.castProgress = 0;
   if (spell === "missile" && config) {
-    const castTimeSec = calculateMissileCastTime(config, wizard.lastMissileConfig);
+    const validated = validateMissileConfig(config);
+    const castTimeSec = calculateMissileCastTime(validated, wizard.lastMissileConfig);
     wizard.castDuration = Math.max(1, Math.round(castTimeSec * TICKS_PER_SECOND));
     wizard.warmupMultiplier = calculateWarmupMultiplier(wizard.lastMissileConfig, config);
   } else if (spell === "shield") {
@@ -729,6 +800,70 @@ function createEntitySeed(matchSeed, entityId, tick2) {
   return combined;
 }
 
+// src/engine/bot-error-capture.ts
+var MAX_MESSAGE_LENGTH = 1e3;
+var MAX_ERRORS_PER_MATCH = 500;
+function describeThrown(thrown) {
+  const { text, alreadyBounded } = rawDescription(thrown);
+  return alreadyBounded ? text : truncate(text);
+}
+function rawDescription(thrown) {
+  if (thrown instanceof Error) {
+    const message = typeof thrown.message === "string" ? thrown.message : "";
+    if (message.length > MAX_MESSAGE_LENGTH) {
+      return { text: truncate(message) + " [stack omitted: message too large]", alreadyBounded: true };
+    }
+    const stack = typeof thrown.stack === "string" ? stripBundleCoordinates(thrown.stack.trim()) : "";
+    if (stack) return { text: stack, alreadyBounded: false };
+    return { text: message || `${thrown.name || "Error"} (thrown with no message)`, alreadyBounded: false };
+  }
+  if (typeof thrown === "string") return { text: thrown || "(empty string thrown)", alreadyBounded: false };
+  if (thrown === null) return { text: "null was thrown", alreadyBounded: false };
+  if (thrown === void 0) return { text: "undefined was thrown", alreadyBounded: false };
+  try {
+    const json = JSON.stringify(thrown);
+    if (typeof json === "string" && json !== "{}") return { text: json, alreadyBounded: false };
+  } catch {
+  }
+  try {
+    const text = String(thrown);
+    if (text === "[object Object]") return { text: describeOpaqueObject(thrown), alreadyBounded: false };
+    return { text, alreadyBounded: false };
+  } catch {
+    return { text: "(a value was thrown that could not be described)", alreadyBounded: false };
+  }
+}
+function describeOpaqueObject(thrown) {
+  let name = "object";
+  try {
+    const ctor = thrown.constructor;
+    if (ctor && typeof ctor.name === "string" && ctor.name) name = ctor.name;
+  } catch {
+  }
+  let keys = [];
+  try {
+    keys = Object.keys(thrown).slice(0, 12);
+  } catch {
+  }
+  const shape = keys.length > 0 ? ` with keys: ${keys.join(", ")}` : " with no enumerable keys";
+  return `a non-serialisable ${name} was thrown${shape} (it could not be converted to text \u2014 usually a circular reference, or a getter that throws)`;
+}
+function stripBundleCoordinates(stack) {
+  return stack.replace(/\s*\((?:[^()\s]*match-bundle\.js|<isolated-vm>)[^()]*\)/g, "").replace(/(\s*at )(?:[^()\s]*match-bundle\.js|<isolated-vm>)[^\s)]*/g, "$1<your bot>");
+}
+function truncate(message) {
+  if (message.length <= MAX_MESSAGE_LENGTH) return message;
+  const dropped = message.length - MAX_MESSAGE_LENGTH;
+  return `${message.slice(0, MAX_MESSAGE_LENGTH)}\u2026 [truncated, ${dropped} more characters]`;
+}
+function cappedNotice(entityId, tick2) {
+  return {
+    tick: tick2,
+    entityId,
+    message: `\u2026 stopped recording errors after ${MAX_ERRORS_PER_MATCH} in this match. The bot is still being called and still failing; only the recording stopped.`
+  };
+}
+
 // src/engine/simulation.ts
 function createInitialState(_seed, spawnDist = SPAWN_DISTANCE) {
   const center = { x: ARENA_SIZE / 2, y: ARENA_SIZE / 2 };
@@ -812,9 +947,22 @@ function buildWizardContext(state, config, random) {
     lastHitTick: state.lastHitTick
   };
 }
+function nonFiniteField(move2, action, wizard) {
+  const bad = (v) => typeof v === "number" && !Number.isFinite(v);
+  if (bad(move2?.x)) return { what: "move(x, y): x", value: String(move2.x) };
+  if (bad(move2?.y)) return { what: "move(x, y): y", value: String(move2.y) };
+  const target = action.startCast?.spell === "blink" ? action.startCast.target : void 0;
+  if (bad(target?.x)) return { what: "blink(x, y): x", value: String(target.x) };
+  if (bad(target?.y)) return { what: "blink(x, y): y", value: String(target.y) };
+  if (bad(wizard.blinkTarget?.x)) return { what: "blink(x, y): x", value: String(wizard.blinkTarget.x) };
+  if (bad(wizard.blinkTarget?.y)) return { what: "blink(x, y): y", value: String(wizard.blinkTarget.y) };
+  if (bad(action.aimDirection)) return { what: "aim(degrees)", value: String(action.aimDirection) };
+  return null;
+}
 function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, missileAIs, matchSeed, budgets) {
   const nextTick = currentTick + 1;
   const errors = [];
+  const budgetExhausted = [];
   const events = [];
   const random1 = createRandom(createEntitySeed(matchSeed, wizards[0].id, nextTick));
   const random2 = createRandom(createEntitySeed(matchSeed, wizards[1].id, nextTick));
@@ -822,13 +970,25 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
   const nextBudgets = budgets ? [budgets.states[0], budgets.states[1]] : void 0;
   const runBot = (index, entityId, invoke) => {
     const state = nextBudgets?.[index];
-    if (state && !mayAct(state)) return IDLE_ACTION();
+    if (state && !mayAct(state)) {
+      if (!state.reported) {
+        state.reported = true;
+        budgetExhausted.push({ tick: nextTick, entityId, spentMs: state.spentMs });
+      }
+      return IDLE_ACTION();
+    }
     const startedAt = state ? Date.now() : 0;
     let action;
     try {
       action = invoke();
     } catch (e) {
-      errors.push({ tick: nextTick, entityId, message: e instanceof Error ? e.message : String(e) });
+      const alreadyDead = (wizards[index]?.health ?? 1) <= 0;
+      errors.push({
+        tick: nextTick,
+        entityId,
+        message: describeThrown(e),
+        ...alreadyDead ? { afterDeath: true } : {}
+      });
       action = IDLE_ACTION();
     }
     if (state && budgets) {
@@ -911,10 +1071,12 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
           delete wizard.missileConfig;
           delete wizard.missileAI;
         } else if (spell === "blink" && wizard.blinkTarget) {
-          const dx = wizard.blinkTarget.x - wizard.position.x;
-          const dy = wizard.blinkTarget.y - wizard.position.y;
+          const targetX = Number.isFinite(wizard.blinkTarget.x) ? wizard.blinkTarget.x : wizard.position.x;
+          const targetY = Number.isFinite(wizard.blinkTarget.y) ? wizard.blinkTarget.y : wizard.position.y;
+          const dx = targetX - wizard.position.x;
+          const dy = targetY - wizard.position.y;
           const distance = Math.sqrt(dx * dx + dy * dy);
-          let targetPos = wizard.blinkTarget;
+          let targetPos = { x: targetX, y: targetY };
           if (distance > RULES.BLINK_RANGE) {
             const scale = RULES.BLINK_RANGE / distance;
             targetPos = {
@@ -940,6 +1102,17 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
     }
     const oldPos = wizard.position;
     const move2 = action.move ?? { x: 0, y: 0 };
+    if (!wizard.advised?.nonFinite) {
+      const bad = nonFiniteField(move2, action, wizard);
+      if (bad) {
+        wizard.advised = { ...wizard.advised, nonFinite: true };
+        errors.push({
+          tick: nextTick,
+          entityId: wizard.id,
+          message: `${bad.what} is not a finite number (it was ${bad.value}). The engine ignored it to keep the match running \u2014 the value is treated as zero, so your wizard simply does not do what you asked. This is almost always a divide-by-zero or a subtraction of two equal positions somewhere in your maths. Reported once per match.`
+        });
+      }
+    }
     wizard.position = moveWizard(wizard, move2, 1);
     if (wizard.knockbackDelay !== void 0 && wizard.knockbackDelay > 0) {
       wizard.knockbackDelay--;
@@ -986,6 +1159,15 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
         const castingSpell = action.startCast.spell;
         startCast(wizard, castingSpell, castingSpell === "missile" ? action.startCast.config : void 0);
         if (castingSpell === "missile") {
+          if ((wizard.castDuration ?? 0) > MATCH_DURATION && !wizard.advised?.unfinishableCast) {
+            wizard.advised = { ...wizard.advised, unfinishableCast: true };
+            const config2 = action.startCast.config;
+            errors.push({
+              tick: nextTick,
+              entityId: wizard.id,
+              message: `This missile takes ${wizard.castDuration} ticks to cast, but a match is only ${MATCH_DURATION} ticks long, so the cast can never finish and this wizard will stand still for the rest of the match. The cost is dominated by turnRate (${config2?.turnRate ?? "?"}) \u2014 it is the most expensive field by far, and unlike the others it is not clamped to a sane maximum. Try a turnRate in the single digits, then use missile-calc or getMissileCastTime() to check the cast time before committing to a config.`
+            });
+          }
           wizard.missileConfig = action.startCast.config;
           wizard.missileAI = action.startCast.missileAI;
           if (action.startCast.direction !== void 0) {
@@ -1043,12 +1225,12 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
             () => extractMissileAction(withMissileContext(missileCtx, ai))
           ) ?? {};
         } catch (e) {
-          errors.push({ tick: nextTick, entityId: projectile.id, message: e instanceof Error ? e.message : String(e) });
+          errors.push({ tick: nextTick, entityId: projectile.id, message: describeThrown(e) });
         }
         targetAngle = missileActions.turnToward ? angleTo(projectile.position, missileActions.turnToward) : missileActions.turnToAngle !== void 0 ? missileActions.turnToAngle : null;
       }
     }
-    if (targetAngle !== null) {
+    if (targetAngle !== null && Number.isFinite(targetAngle)) {
       const diff = angleDiff(projectile.rotation, targetAngle);
       const turn = Math.max(-projectile.turnRate, Math.min(projectile.turnRate, diff));
       projectile.rotation = normalizeAngle(projectile.rotation + turn);
@@ -1109,6 +1291,7 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
     projectiles: remainingProjectiles,
     events,
     errors,
+    budgetExhausted,
     budgets: nextBudgets
   };
 }
@@ -1248,6 +1431,7 @@ var FIGHT_SPAWN_DISTANCES = [500, 550, 600, 650, 700];
 function fight(wizard1AI, wizard2AI, options = {}) {
   const matches = [];
   const allErrors = [];
+  const allBudgetExhausted = [];
   let matchNumber = 1;
   let wizard1Wins = 0;
   let wizard2Wins = 0;
@@ -1262,6 +1446,7 @@ function fight(wizard1AI, wizard2AI, options = {}) {
     });
     matches.push(result);
     allErrors.push(...result.errors.map((e) => ({ ...e, match: matchNumber })));
+    allBudgetExhausted.push(...result.budgetExhausted.map((b) => ({ ...b, match: matchNumber })));
     matchNumber++;
     if (result.winner === "wizard-1") {
       wizard1Wins++;
@@ -1282,6 +1467,7 @@ function fight(wizard1AI, wizard2AI, options = {}) {
       budget.states = [swappedBudget.states[1], swappedBudget.states[0]];
     }
     allErrors.push(...swapped.errors.map((e) => ({ ...e, entityId: swapSide(e.entityId), match: matchNumber })));
+    allBudgetExhausted.push(...swapped.budgetExhausted.map((b) => ({ ...b, entityId: swapSide(b.entityId), match: matchNumber })));
     matchNumber++;
     if (swapped.winner === "wizard-1") {
       wizard2Wins++;
@@ -1292,7 +1478,7 @@ function fight(wizard1AI, wizard2AI, options = {}) {
     }
   }
   const winner = wizard1Wins > wizard2Wins ? "wizard-1" : wizard2Wins > wizard1Wins ? "wizard-2" : "draw";
-  return { wizard1Wins, wizard2Wins, draws, winner, matches, allErrors };
+  return { wizard1Wins, wizard2Wins, draws, winner, matches, allErrors, budgetExhausted: allBudgetExhausted };
 }
 function simulate(wizard1AI, wizard2AI, options = {}) {
   if (typeof wizard1AI !== "function") {
@@ -1345,6 +1531,7 @@ function simulate(wizard1AI, wizard2AI, options = {}) {
   let projectiles = [];
   const missileAIs = /* @__PURE__ */ new Map();
   const allErrors = [];
+  const allBudgetExhausted = [];
   let deathTick = null;
   const sharedBudget = options.budget;
   const budgetLimits = sharedBudget?.limits ?? options.budgetLimits;
@@ -1368,7 +1555,15 @@ function simulate(wizard1AI, wizard2AI, options = {}) {
     currentTick = result.nextTick;
     wizards = result.wizards;
     projectiles = result.projectiles;
-    if (result.errors.length > 0) allErrors.push(...result.errors);
+    for (const error of result.errors) {
+      if (allErrors.length > MAX_ERRORS_PER_MATCH) break;
+      if (allErrors.length === MAX_ERRORS_PER_MATCH) {
+        allErrors.push(cappedNotice(error.entityId, error.tick));
+        break;
+      }
+      allErrors.push(error);
+    }
+    if (result.budgetExhausted.length > 0) allBudgetExhausted.push(...result.budgetExhausted);
     if (!skipHistory) {
       history.push(getPlayerState(0, wizards, projectiles, currentTick, result.events));
     }
@@ -1393,7 +1588,8 @@ function simulate(wizard1AI, wizard2AI, options = {}) {
     ticks: currentTick,
     finalState,
     history: skipHistory ? [] : history,
-    errors: allErrors
+    errors: allErrors,
+    budgetExhausted: allBudgetExhausted
   };
 }
 
@@ -1567,7 +1763,9 @@ var ManualMatch = class {
       ticks: this.currentTick,
       finalState: this.getGameState(),
       history: this.history,
-      errors: this.allErrors
+      errors: this.allErrors,
+      // Manual play is unbudgeted — the clock is never read, so nobody can be cut off.
+      budgetExhausted: []
     };
   }
   dispose() {
@@ -1936,13 +2134,14 @@ function fitMissileForEscapingTarget(currentDistance, budgetTicks, options) {
 }
 
 // src/hooks/threat-analysis.ts
+var CANCEL_COST_TICKS = 1;
 var THREAT_RELEVANCE_DISTANCE = 500;
-function analyzeThreats(myPos, projectiles, myProjectiles, ticksUntilReady) {
+function analyzeThreats(myPos, projectiles, myProjectiles, ticksUntilReady, options) {
   const myProjectileIds = new Set(myProjectiles.map((p) => p.id));
   const enemyProjectiles = projectiles.filter((p) => !myProjectileIds.has(p.id));
   const threats = [];
   for (const projectile of enemyProjectiles) {
-    const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady);
+    const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady, options?.canCancelCurrentCast ?? false);
     const missileDistance = Math.sqrt(
       (projectile.position.x - myPos.x) ** 2 + (projectile.position.y - myPos.y) ** 2
     );
@@ -1953,7 +2152,7 @@ function analyzeThreats(myPos, projectiles, myProjectiles, ticksUntilReady) {
   threats.sort((a, b) => a.ticksToImpact - b.ticksToImpact);
   return threats;
 }
-function analyzeOneThreat(targetPos, projectile, ticksUntilReady) {
+function analyzeOneThreat(targetPos, projectile, ticksUntilReady, canCancelCurrentCast) {
   const missileRadius = calculateMissileRadius(projectile.damage);
   const collisionDist = COLLISION_RADIUS + missileRadius;
   const dodgeCollisionDist = collisionDist + projectile.speed * 0.5;
@@ -1975,11 +2174,14 @@ function analyzeOneThreat(targetPos, projectile, ticksUntilReady) {
       targetPos,
       canDodgeLeft,
       canDodgeRight,
-      canOutrun
+      canOutrun,
+      ticksToImpact
     );
   }
-  const canBlockInTime = ticksToImpact > ticksUntilReady + RULES.SHIELD_CAST_TIME + 1;
-  const ticksToStartShield = Math.max(0, ticksToImpact - RULES.SHIELD_CAST_TIME - 1);
+  const delayBeforeShield = canCancelCurrentCast ? CANCEL_COST_TICKS : ticksUntilReady;
+  const ticksNeededToBlock = delayBeforeShield + RULES.SHIELD_CAST_TIME + 1;
+  const canBlockInTime = ticksToImpact >= ticksNeededToBlock;
+  const ticksToStartShield = Math.max(0, ticksToImpact - ticksNeededToBlock);
   return {
     id: projectile.id,
     projectile,
@@ -2090,15 +2292,28 @@ function getDodgeDirection(projectile, targetPos, direction) {
       return { x: 0, y: 0 };
   }
 }
-function calculateBestDodgeDirection(projectile, targetPos, canDodgeLeft, canDodgeRight, canOutrun) {
-  if (canDodgeLeft && canDodgeRight) {
-    return getDodgeDirection(projectile, targetPos, "left");
-  } else if (canDodgeLeft) {
-    return getDodgeDirection(projectile, targetPos, "left");
-  } else if (canDodgeRight) {
-    return getDodgeDirection(projectile, targetPos, "right");
-  } else if (canOutrun) {
-    return getDodgeDirection(projectile, targetPos, "away");
+function roomBeforeLava(from, dir) {
+  const min = ARENA_MIN + COLLISION_RADIUS;
+  const max = ARENA_MAX - COLLISION_RADIUS;
+  const along = (pos, d, lo, hi) => {
+    if (Math.abs(d) < 1e-9) return Number.POSITIVE_INFINITY;
+    return d > 0 ? (hi - pos) / d : (lo - pos) / d;
+  };
+  return Math.max(0, Math.min(along(from.x, dir.x, min, max), along(from.y, dir.y, min, max)));
+}
+function calculateBestDodgeDirection(projectile, targetPos, canDodgeLeft, canDodgeRight, canOutrun, ticksToImpact) {
+  const travel = RULES.MOVEMENT_SPEED * Math.max(1, Math.min(ticksToImpact, 600));
+  const survives = (dir) => roomBeforeLava(targetPos, dir) >= travel;
+  const sides = [];
+  if (canDodgeLeft) sides.push(getDodgeDirection(projectile, targetPos, "left"));
+  if (canDodgeRight) sides.push(getDodgeDirection(projectile, targetPos, "right"));
+  const safeSides = sides.filter(survives);
+  if (safeSides.length > 0) {
+    return safeSides.reduce((best, dir) => roomBeforeLava(targetPos, dir) > roomBeforeLava(targetPos, best) ? dir : best);
+  }
+  if (canOutrun) {
+    const away = getDodgeDirection(projectile, targetPos, "away");
+    if (survives(away)) return away;
   }
   return null;
 }
@@ -2241,9 +2456,13 @@ function useThreats() {
       ctx.position,
       ctx.projectiles,
       ctx.myProjectiles,
-      ticksUntilReady
+      ticksUntilReady,
+      // Mid-CAST you are one cancel() away from being able to shield, so the analysis
+      // must not charge you the whole remainder of the cast. A GCD cannot be cancelled,
+      // so it keeps the pessimistic reading.
+      { canCancelCurrentCast: ctx.state === "casting" }
     );
-  }, [ctx.projectiles, ctx.myProjectiles, ctx.position.x, ctx.position.y, ticksUntilReady]);
+  }, [ctx.projectiles, ctx.myProjectiles, ctx.position.x, ctx.position.y, ticksUntilReady, ctx.state]);
 }
 function useClosestThreat() {
   const threats = useThreats();
@@ -10585,6 +10804,8 @@ export {
   extractAction,
   moveWizard,
   moveProjectile,
+  clampToSafeZone,
+  moveTowardSafely,
   clampToArena,
   isInLava,
   resolveWizardCollision,
@@ -10723,4 +10944,4 @@ export {
   diagnoseTrace,
   formatDiagnosis
 };
-//# sourceMappingURL=chunk-OLGKLCCB.js.map
+//# sourceMappingURL=chunk-KGRG7TZS.js.map