@vibemancer/core 1.0.11 → 1.0.13

package/dist/{index-browser-CM0uuzWp.d.ts → index-browser-Dc-Vl1HI.d.ts}

@@ -241,6 +241,10 @@ interface WizardState {
     lastMissileConfig?: MissileConfig;
     warmupMultiplier?: number;
     invincible?: boolean;
+    advised?: {
+        nonFinite?: boolean;
+        unfinishableCast?: boolean;
+    };
 }
 /**
  * Projectile (missile) state.
@@ -654,7 +658,7 @@ declare function currentRuleset(): Record<string, number>;
  * Used to gate spectator replays: a recorded match can only be re-simulated when
  * the runtime engine version matches the version that produced the match.
  */
-declare const ENGINE_VERSION = 2983169471988242;
+declare const ENGINE_VERSION = 4256327861353618;
 /**
  * Historical versions that denote the SAME engine as `ENGINE_VERSION`.
  *
@@ -873,9 +877,6 @@ interface InternalWizardState extends WizardState {
  * Initialize a new match state.
  */
 declare function createInitialState(_seed: number, spawnDist?: number): GameState;
-/**
- * Process one game tick.
- */
 declare function tick(currentTick: number, wizard1AI: WizardFunction, wizard2AI: WizardFunction, config: GameConfig, wizards: InternalWizardState[], projectiles: ProjectileState[], missileAIs: Map<string, MissileFunction$1>, matchSeed: number, budgets?: {
     states: [BotBudgetState, BotBudgetState];
     limits: BudgetLimits;
@@ -1810,9 +1811,14 @@ declare function useMyThreatsToEnemy(): AnalyzedThreat[];
  * @param projectiles - All projectiles in the game
  * @param myProjectiles - Only the bot's own projectiles (used for filtering)
  * @param ticksUntilReady - Ticks until wizard can start a new action
+ * @param options - `canCancelCurrentCast` when the wizard is mid-CAST and could cancel()
+ *                  out of it for one tick's cost. Defaults to false, which is the safe
+ *                  reading for a caller that does not know its own state.
  * @returns Array of analyzed threats sorted by ticksToImpact (soonest first)
  */
-declare function analyzeThreats(myPos: Position, projectiles: ProjectileState[], myProjectiles: ProjectileState[], ticksUntilReady: number): AnalyzedThreat[];
+declare function analyzeThreats(myPos: Position, projectiles: ProjectileState[], myProjectiles: ProjectileState[], ticksUntilReady: number, options?: {
+    canCancelCurrentCast?: boolean;
+}): AnalyzedThreat[];
 
 /**
  * VIBEMANCER - ACTION BUILDERS

package/dist/index-browser.d.ts

@@ -1 +1 @@
-export { A as ALL_BOTS, a as ARENA_MAX, b as ARENA_MIN, c as ARENA_SIZE, d as ARENA_WATER_BUFFER, e as ActionBuilder, f as AnalyzedThreat, g as Archlich, h as Archmage, B as BLINK_CAST_TIME, i as BLINK_COOLDOWN, j as BLINK_MAX_COOLDOWN, k as BLINK_MAX_RANGE, l as BLINK_MIN_COOLDOWN, m as BLINK_RANGE, n as BOT_GROUPS, o as Battlemage, p as BlinkEvent, q as Bonemancer, s as BotError, t as BrowserManualMatchSandbox, u as BrowserMatchSandbox, v as BrowserSandboxOptions, w as BudgetExhaustion, C as CASTING_MOVEMENT_MULT, y as COLLISION_RADIUS, z as CastCancelEvent, D as CastStartEvent, E as Critter, I as DEFAULT_SEED, J as Doombringer, K as ENGINE_VERSION, L as EQUIVALENT_ENGINE_VERSIONS, M as EnemyState, N as FIGHT_SPAWN_DISTANCES, F as FightResult, P as FightStats, Q as FightWinner, R as FinalAction, T as Flamecaller, U as GCD_DURATION, V as GameConfig, W as GameState, X as Golem, Y as Hero, Z as Hogger, _ as HomingParams, $ as HookState, a0 as Infernalist, a1 as InternalWizardState, a2 as KNOCKBACK_DAMAGE_THRESHOLD, a3 as KNOCKBACK_DECAY, a4 as KNOCKBACK_DELAY, a5 as KNOCKBACK_SPEED_PER_DAMAGE, a6 as LAVA_BORDER_WIDTH, a7 as Lich, a8 as MATCH_DURATION, a9 as MAX_HEALTH, aa as MISSILE_BASE_CAST, ab as MISSILE_BASE_RADIUS, ac as MISSILE_DAMAGE_POWER, ad as MISSILE_DAMAGE_RADIUS_SCALE, ae as MISSILE_DAMAGE_SCALE, af as MISSILE_HOMING_COEFF, ag as MISSILE_MIN_CAST_TIME, ah as MISSILE_MIN_DAMAGE, ai as MISSILE_MIN_DURATION, aj as MISSILE_MIN_SPEED, ak as MISSILE_RADIUS_PER_DAMAGE, al as MISSILE_SPEED_DURATION_BASELINE, am as MISSILE_SPEED_DURATION_COEFF, an as MISSILE_TURN_DURATION_COEFF, ao as MOVEMENT_SPEED, ap as MOVE_SPEED, aq as ManualMatch, ar as ManualMatchInitOptions, as as ManualMatchOptions, at as ManualMatchStepRequest, au as MatchWinner, av as MissileAction, aw as MissileActions, ax as MissileConfig, ay as MissileContext, az as MissileExpiredEvent, aA as MissileFunction, aB as MissileHitEvent, aC as MissileLaunchEvent, aD as MissileOobEvent, aE as MissileTemplate, aF as Nightblade, aG as ParamDeclaration, aH as Position, aI as ProjectileState, aJ as Pyromancer, aK as RULES, aL as RULESET_RANGES, aM as RefObject, aN as Rookie, aO as SHIELD_CAST_TIME, aP as SHIELD_DECAY_PER_SECOND, aQ as SHIELD_DECAY_RATE, aR as SHIELD_MAX_BLOCK, aS as SHIELD_MAX_STRENGTH, aT as SHIELD_MIN_BLOCK, aU as SHIELD_MIN_STRENGTH, aV as SPAWN_DISTANCE, aW as SeekerParams, aX as Sentinel, aY as Shadowblade, aZ as ShieldBlockEvent, a_ as ShieldStartEvent, a$ as SimEvent, S as SimulateResult, b0 as Spellbinder, b1 as Spellseeker, b2 as Spellshot, b3 as Spellspinner, b4 as Spelltracer, b5 as Spellweaver, b6 as SpiralParams, b7 as StepResult, b8 as Stormcaller, b9 as Stormchaser, ba as Stormforger, bb as StraightParams, bc as TICKS_PER_SECOND, bd as TICK_DURATION_MS, be as TargetDummy, bf as TestBotBuilder, bg as TestFightResult, bh as TestSimulateResult, bi as TraceBotSummary, bj as TraceEvent, bk as TraceEventType, bl as TraceSummary, bm as Turtle, bn as Velocity, bo as Voidblade, bp as WARMUP_DURATION_TOLERANCE, bq as WARMUP_MAX_BONUS, br as WARMUP_MAX_PENALTY, bs as WARMUP_SPEED_TOLERANCE, bt as WARMUP_TURN_TOLERANCE, bu as WIZARD_HEALTH, bv as WIZARD_RADIUS, bw as Warmage, bx as WizardActions, by as WizardContext, bz as WizardDeathEvent, bA as WizardEntry, bB as WizardFunction, bC as WizardGroup, bD as WizardLavaDeathEvent, bE as WizardState, bF as WorkerFactory, bG as WorkerLike, bH as aim, bI as analyzeThreats, bJ as angleDiff, bK as angleInRange, bL as angleTo, bM as applyDamage, bN as applyRulesetOverrides, bO as blink, bP as browserSandboxFight, bQ as browserSandboxSimulate, bR as calculateBlinkCooldown, bS as calculateMissileCastTime, bT as calculateMissileRadius, bU as calculateMissileSimilarity, bV as calculateShieldBlock, bW as calculateWarmupMultiplier, bX as canReplayMatch, bY as cancel, bZ as cancelCast, b_ as clampPositionToArena, b$ as clampToArena, c0 as clampToSafeZone, c1 as clearHooks, c2 as clearParamValues, c3 as completeCast, c5 as createEntitySeed, c7 as createInitialState, c8 as createRandom, c9 as createWorkerScript, ca as currentRuleset, cb as diagnoseTrace, cc as directionAway, cd as directionTo, ce as distanceTo, cf as effectiveTurnRateCost, cg as extractAction, ch as extractMissileAction, ci as extractStats, cj as extractTraceEvents, ck as fight, cl as findInRange, cm as findNearest, cn as fitMissileForEscapingTarget, co as fitMissileToBudget, cp as flyStraight, cq as formatDiagnosis, cr as formatStats, cs as formatTraceEvents, ct as formatTraceSummary, cu as generateCandidates, cv as generateCombos, cw as getAdaptiveMissileConfig, cx as getEffectiveRange, cy as getLeadPosition, cz as getMissileCastTime, cA as getMissileContext, cB as getPlayerState, cC as getWizardContext, cD as hashCombine, cE as homingMissile, cF as idle, cG as inRange, cH as interceptAngle, cI as isBannedBotName, cJ as isInLava, cK as magnitude, cL as matchesAnyBanRule, cN as missile, cO as move, cP as moveInDirection, cQ as moveProjectile, cR as moveTowardSafely, cS as moveWizard, cT as narrowRange, cU as nextRandom, cV as normalize, cW as normalizeAngle, cX as predictPosition, cZ as resetAllHooks, c_ as resetRuleset, c$ as resolveWizardCollision, d0 as runWithHooks, d1 as runWizardWithContext, d2 as scoreFight, d3 as scoreFightAsWizard2, d4 as seekerMissile, d5 as setParamValues, d6 as shield, d7 as simulate, d8 as simulateMinDuration, d9 as sortByDistance, da as spiralMissile, db as startCast, dc as startDiscovery, dd as stopDiscovery, de as straightMissile, df as summarizeTrace, dg as sweptCircleCollision, dh as testBot, di as tick, dj as turnToAngle, dk as turnToward, dl as updateShield, dm as useArenaSize, dn as useBlinkCooldown, dp as useCastProgress, dq as useCastingSpell, dr as useClosestThreat, ds as useDamageDealt, dt as useDamageTaken, du as useEffect, dv as useEnemy, dw as useHealth, dx as useLastHitTick, dy as useLastMissileConfig, dz as useMemo, dA as useMyProjectiles, dB as useMyThreatsToEnemy, dC as useParam, dD as usePosition, dE as useProjectiles, dF as useRandom, dG as useRef, dH as useShieldStrength, dI as useState, dJ as useStatus, dK as useThreats, dL as useTick, dM as useTicksUntilReady, dN as useVelocity, dO as validateHookCall, dP as validateMissileConfig, dQ as withMissileContext, dR as withWizardContext, dS as wrapWithParams } from './index-browser-CM0uuzWp.js';
+export { A as ALL_BOTS, a as ARENA_MAX, b as ARENA_MIN, c as ARENA_SIZE, d as ARENA_WATER_BUFFER, e as ActionBuilder, f as AnalyzedThreat, g as Archlich, h as Archmage, B as BLINK_CAST_TIME, i as BLINK_COOLDOWN, j as BLINK_MAX_COOLDOWN, k as BLINK_MAX_RANGE, l as BLINK_MIN_COOLDOWN, m as BLINK_RANGE, n as BOT_GROUPS, o as Battlemage, p as BlinkEvent, q as Bonemancer, s as BotError, t as BrowserManualMatchSandbox, u as BrowserMatchSandbox, v as BrowserSandboxOptions, w as BudgetExhaustion, C as CASTING_MOVEMENT_MULT, y as COLLISION_RADIUS, z as CastCancelEvent, D as CastStartEvent, E as Critter, I as DEFAULT_SEED, J as Doombringer, K as ENGINE_VERSION, L as EQUIVALENT_ENGINE_VERSIONS, M as EnemyState, N as FIGHT_SPAWN_DISTANCES, F as FightResult, P as FightStats, Q as FightWinner, R as FinalAction, T as Flamecaller, U as GCD_DURATION, V as GameConfig, W as GameState, X as Golem, Y as Hero, Z as Hogger, _ as HomingParams, $ as HookState, a0 as Infernalist, a1 as InternalWizardState, a2 as KNOCKBACK_DAMAGE_THRESHOLD, a3 as KNOCKBACK_DECAY, a4 as KNOCKBACK_DELAY, a5 as KNOCKBACK_SPEED_PER_DAMAGE, a6 as LAVA_BORDER_WIDTH, a7 as Lich, a8 as MATCH_DURATION, a9 as MAX_HEALTH, aa as MISSILE_BASE_CAST, ab as MISSILE_BASE_RADIUS, ac as MISSILE_DAMAGE_POWER, ad as MISSILE_DAMAGE_RADIUS_SCALE, ae as MISSILE_DAMAGE_SCALE, af as MISSILE_HOMING_COEFF, ag as MISSILE_MIN_CAST_TIME, ah as MISSILE_MIN_DAMAGE, ai as MISSILE_MIN_DURATION, aj as MISSILE_MIN_SPEED, ak as MISSILE_RADIUS_PER_DAMAGE, al as MISSILE_SPEED_DURATION_BASELINE, am as MISSILE_SPEED_DURATION_COEFF, an as MISSILE_TURN_DURATION_COEFF, ao as MOVEMENT_SPEED, ap as MOVE_SPEED, aq as ManualMatch, ar as ManualMatchInitOptions, as as ManualMatchOptions, at as ManualMatchStepRequest, au as MatchWinner, av as MissileAction, aw as MissileActions, ax as MissileConfig, ay as MissileContext, az as MissileExpiredEvent, aA as MissileFunction, aB as MissileHitEvent, aC as MissileLaunchEvent, aD as MissileOobEvent, aE as MissileTemplate, aF as Nightblade, aG as ParamDeclaration, aH as Position, aI as ProjectileState, aJ as Pyromancer, aK as RULES, aL as RULESET_RANGES, aM as RefObject, aN as Rookie, aO as SHIELD_CAST_TIME, aP as SHIELD_DECAY_PER_SECOND, aQ as SHIELD_DECAY_RATE, aR as SHIELD_MAX_BLOCK, aS as SHIELD_MAX_STRENGTH, aT as SHIELD_MIN_BLOCK, aU as SHIELD_MIN_STRENGTH, aV as SPAWN_DISTANCE, aW as SeekerParams, aX as Sentinel, aY as Shadowblade, aZ as ShieldBlockEvent, a_ as ShieldStartEvent, a$ as SimEvent, S as SimulateResult, b0 as Spellbinder, b1 as Spellseeker, b2 as Spellshot, b3 as Spellspinner, b4 as Spelltracer, b5 as Spellweaver, b6 as SpiralParams, b7 as StepResult, b8 as Stormcaller, b9 as Stormchaser, ba as Stormforger, bb as StraightParams, bc as TICKS_PER_SECOND, bd as TICK_DURATION_MS, be as TargetDummy, bf as TestBotBuilder, bg as TestFightResult, bh as TestSimulateResult, bi as TraceBotSummary, bj as TraceEvent, bk as TraceEventType, bl as TraceSummary, bm as Turtle, bn as Velocity, bo as Voidblade, bp as WARMUP_DURATION_TOLERANCE, bq as WARMUP_MAX_BONUS, br as WARMUP_MAX_PENALTY, bs as WARMUP_SPEED_TOLERANCE, bt as WARMUP_TURN_TOLERANCE, bu as WIZARD_HEALTH, bv as WIZARD_RADIUS, bw as Warmage, bx as WizardActions, by as WizardContext, bz as WizardDeathEvent, bA as WizardEntry, bB as WizardFunction, bC as WizardGroup, bD as WizardLavaDeathEvent, bE as WizardState, bF as WorkerFactory, bG as WorkerLike, bH as aim, bI as analyzeThreats, bJ as angleDiff, bK as angleInRange, bL as angleTo, bM as applyDamage, bN as applyRulesetOverrides, bO as blink, bP as browserSandboxFight, bQ as browserSandboxSimulate, bR as calculateBlinkCooldown, bS as calculateMissileCastTime, bT as calculateMissileRadius, bU as calculateMissileSimilarity, bV as calculateShieldBlock, bW as calculateWarmupMultiplier, bX as canReplayMatch, bY as cancel, bZ as cancelCast, b_ as clampPositionToArena, b$ as clampToArena, c0 as clampToSafeZone, c1 as clearHooks, c2 as clearParamValues, c3 as completeCast, c5 as createEntitySeed, c7 as createInitialState, c8 as createRandom, c9 as createWorkerScript, ca as currentRuleset, cb as diagnoseTrace, cc as directionAway, cd as directionTo, ce as distanceTo, cf as effectiveTurnRateCost, cg as extractAction, ch as extractMissileAction, ci as extractStats, cj as extractTraceEvents, ck as fight, cl as findInRange, cm as findNearest, cn as fitMissileForEscapingTarget, co as fitMissileToBudget, cp as flyStraight, cq as formatDiagnosis, cr as formatStats, cs as formatTraceEvents, ct as formatTraceSummary, cu as generateCandidates, cv as generateCombos, cw as getAdaptiveMissileConfig, cx as getEffectiveRange, cy as getLeadPosition, cz as getMissileCastTime, cA as getMissileContext, cB as getPlayerState, cC as getWizardContext, cD as hashCombine, cE as homingMissile, cF as idle, cG as inRange, cH as interceptAngle, cI as isBannedBotName, cJ as isInLava, cK as magnitude, cL as matchesAnyBanRule, cN as missile, cO as move, cP as moveInDirection, cQ as moveProjectile, cR as moveTowardSafely, cS as moveWizard, cT as narrowRange, cU as nextRandom, cV as normalize, cW as normalizeAngle, cX as predictPosition, cZ as resetAllHooks, c_ as resetRuleset, c$ as resolveWizardCollision, d0 as runWithHooks, d1 as runWizardWithContext, d2 as scoreFight, d3 as scoreFightAsWizard2, d4 as seekerMissile, d5 as setParamValues, d6 as shield, d7 as simulate, d8 as simulateMinDuration, d9 as sortByDistance, da as spiralMissile, db as startCast, dc as startDiscovery, dd as stopDiscovery, de as straightMissile, df as summarizeTrace, dg as sweptCircleCollision, dh as testBot, di as tick, dj as turnToAngle, dk as turnToward, dl as updateShield, dm as useArenaSize, dn as useBlinkCooldown, dp as useCastProgress, dq as useCastingSpell, dr as useClosestThreat, ds as useDamageDealt, dt as useDamageTaken, du as useEffect, dv as useEnemy, dw as useHealth, dx as useLastHitTick, dy as useLastMissileConfig, dz as useMemo, dA as useMyProjectiles, dB as useMyThreatsToEnemy, dC as useParam, dD as usePosition, dE as useProjectiles, dF as useRandom, dG as useRef, dH as useShieldStrength, dI as useState, dJ as useStatus, dK as useThreats, dL as useTick, dM as useTicksUntilReady, dN as useVelocity, dO as validateHookCall, dP as validateMissileConfig, dQ as withMissileContext, dR as withWizardContext, dS as wrapWithParams } from './index-browser-Dc-Vl1HI.js';

package/dist/index-browser.js

@@ -228,7 +228,7 @@ import {
   withMissileContext,
   withWizardContext,
   wrapWithParams
-} from "./chunk-EO7JO2RZ.js";
+} from "./chunk-KGRG7TZS.js";
 export {
   ALL_BOTS,
   ARENA_MAX,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FightResult, S as SimulateResult } from './index-browser-CM0uuzWp.js';
-export { A as ALL_BOTS, a as ARENA_MAX, b as ARENA_MIN, c as ARENA_SIZE, d as ARENA_WATER_BUFFER, e as ActionBuilder, f as AnalyzedThreat, g as Archlich, h as Archmage, B as BLINK_CAST_TIME, i as BLINK_COOLDOWN, j as BLINK_MAX_COOLDOWN, k as BLINK_MAX_RANGE, l as BLINK_MIN_COOLDOWN, m as BLINK_RANGE, n as BOT_GROUPS, o as Battlemage, p as BlinkEvent, q as Bonemancer, r as BotBudgetState, s as BotError, t as BrowserManualMatchSandbox, u as BrowserMatchSandbox, v as BrowserSandboxOptions, w as BudgetExhaustion, x as BudgetLimits, C as CASTING_MOVEMENT_MULT, y as COLLISION_RADIUS, z as CastCancelEvent, D as CastStartEvent, E as Critter, G as DEFAULT_BUDGET, H as DEFAULT_FIGHT_BACKSTOP_MS, I as DEFAULT_SEED, J as Doombringer, K as ENGINE_VERSION, L as EQUIVALENT_ENGINE_VERSIONS, M as EnemyState, N as FIGHT_SPAWN_DISTANCES, O as FightBudget, P as FightStats, Q as FightWinner, R as FinalAction, T as Flamecaller, U as GCD_DURATION, V as GameConfig, W as GameState, X as Golem, Y as Hero, Z as Hogger, _ as HomingParams, $ as HookState, a0 as Infernalist, a1 as InternalWizardState, a2 as KNOCKBACK_DAMAGE_THRESHOLD, a3 as KNOCKBACK_DECAY, a4 as KNOCKBACK_DELAY, a5 as KNOCKBACK_SPEED_PER_DAMAGE, a6 as LAVA_BORDER_WIDTH, a7 as Lich, a8 as MATCH_DURATION, a9 as MAX_HEALTH, aa as MISSILE_BASE_CAST, ab as MISSILE_BASE_RADIUS, ac as MISSILE_DAMAGE_POWER, ad as MISSILE_DAMAGE_RADIUS_SCALE, ae as MISSILE_DAMAGE_SCALE, af as MISSILE_HOMING_COEFF, ag as MISSILE_MIN_CAST_TIME, ah as MISSILE_MIN_DAMAGE, ai as MISSILE_MIN_DURATION, aj as MISSILE_MIN_SPEED, ak as MISSILE_RADIUS_PER_DAMAGE, al as MISSILE_SPEED_DURATION_BASELINE, am as MISSILE_SPEED_DURATION_COEFF, an as MISSILE_TURN_DURATION_COEFF, ao as MOVEMENT_SPEED, ap as MOVE_SPEED, aq as ManualMatch, ar as ManualMatchInitOptions, as as ManualMatchOptions, at as ManualMatchStepRequest, au as MatchWinner, av as MissileAction, aw as MissileActions, ax as MissileConfig, ay as MissileContext, az as MissileExpiredEvent, aA as MissileFunction, aB as MissileHitEvent, aC as MissileLaunchEvent, aD as MissileOobEvent, aE as MissileTemplate, aF as Nightblade, aG as ParamDeclaration, aH as Position, aI as ProjectileState, aJ as Pyromancer, aK as RULES, aL as RULESET_RANGES, aM as RefObject, aN as Rookie, aO as SHIELD_CAST_TIME, aP as SHIELD_DECAY_PER_SECOND, aQ as SHIELD_DECAY_RATE, aR as SHIELD_MAX_BLOCK, aS as SHIELD_MAX_STRENGTH, aT as SHIELD_MIN_BLOCK, aU as SHIELD_MIN_STRENGTH, aV as SPAWN_DISTANCE, aW as SeekerParams, aX as Sentinel, aY as Shadowblade, aZ as ShieldBlockEvent, a_ as ShieldStartEvent, a$ as SimEvent, b0 as Spellbinder, b1 as Spellseeker, b2 as Spellshot, b3 as Spellspinner, b4 as Spelltracer, b5 as Spellweaver, b6 as SpiralParams, b7 as StepResult, b8 as Stormcaller, b9 as Stormchaser, ba as Stormforger, bb as StraightParams, bc as TICKS_PER_SECOND, bd as TICK_DURATION_MS, be as TargetDummy, bf as TestBotBuilder, bg as TestFightResult, bh as TestSimulateResult, bi as TraceBotSummary, bj as TraceEvent, bk as TraceEventType, bl as TraceSummary, bm as Turtle, bn as Velocity, bo as Voidblade, bp as WARMUP_DURATION_TOLERANCE, bq as WARMUP_MAX_BONUS, br as WARMUP_MAX_PENALTY, bs as WARMUP_SPEED_TOLERANCE, bt as WARMUP_TURN_TOLERANCE, bu as WIZARD_HEALTH, bv as WIZARD_RADIUS, bw as Warmage, bx as WizardActions, by as WizardContext, bz as WizardDeathEvent, bA as WizardEntry, bB as WizardFunction, bC as WizardGroup, bD as WizardLavaDeathEvent, bE as WizardState, bF as WorkerFactory, bG as WorkerLike, bH as aim, bI as analyzeThreats, bJ as angleDiff, bK as angleInRange, bL as angleTo, bM as applyDamage, bN as applyRulesetOverrides, bO as blink, bP as browserSandboxFight, bQ as browserSandboxSimulate, bR as calculateBlinkCooldown, bS as calculateMissileCastTime, bT as calculateMissileRadius, bU as calculateMissileSimilarity, bV as calculateShieldBlock, bW as calculateWarmupMultiplier, bX as canReplayMatch, bY as cancel, bZ as cancelCast, b_ as clampPositionToArena, b$ as clampToArena, c0 as clampToSafeZone, c1 as clearHooks, c2 as clearParamValues, c3 as completeCast, c4 as createBudgetState, c5 as createEntitySeed, c6 as createFightBudget, c7 as createInitialState, c8 as createRandom, c9 as createWorkerScript, ca as currentRuleset, cb as diagnoseTrace, cc as directionAway, cd as directionTo, ce as distanceTo, cf as effectiveTurnRateCost, cg as extractAction, ch as extractMissileAction, ci as extractStats, cj as extractTraceEvents, ck as fight, cl as findInRange, cm as findNearest, cn as fitMissileForEscapingTarget, co as fitMissileToBudget, cp as flyStraight, cq as formatDiagnosis, cr as formatStats, cs as formatTraceEvents, ct as formatTraceSummary, cu as generateCandidates, cv as generateCombos, cw as getAdaptiveMissileConfig, cx as getEffectiveRange, cy as getLeadPosition, cz as getMissileCastTime, cA as getMissileContext, cB as getPlayerState, cC as getWizardContext, cD as hashCombine, cE as homingMissile, cF as idle, cG as inRange, cH as interceptAngle, cI as isBannedBotName, cJ as isInLava, cK as magnitude, cL as matchesAnyBanRule, cM as mayAct, cN as missile, cO as move, cP as moveInDirection, cQ as moveProjectile, cR as moveTowardSafely, cS as moveWizard, cT as narrowRange, cU as nextRandom, cV as normalize, cW as normalizeAngle, cX as predictPosition, cY as recordSpend, cZ as resetAllHooks, c_ as resetRuleset, c$ as resolveWizardCollision, d0 as runWithHooks, d1 as runWizardWithContext, d2 as scoreFight, d3 as scoreFightAsWizard2, d4 as seekerMissile, d5 as setParamValues, d6 as shield, d7 as simulate, d8 as simulateMinDuration, d9 as sortByDistance, da as spiralMissile, db as startCast, dc as startDiscovery, dd as stopDiscovery, de as straightMissile, df as summarizeTrace, dg as sweptCircleCollision, dh as testBot, di as tick, dj as turnToAngle, dk as turnToward, dl as updateShield, dm as useArenaSize, dn as useBlinkCooldown, dp as useCastProgress, dq as useCastingSpell, dr as useClosestThreat, ds as useDamageDealt, dt as useDamageTaken, du as useEffect, dv as useEnemy, dw as useHealth, dx as useLastHitTick, dy as useLastMissileConfig, dz as useMemo, dA as useMyProjectiles, dB as useMyThreatsToEnemy, dC as useParam, dD as usePosition, dE as useProjectiles, dF as useRandom, dG as useRef, dH as useShieldStrength, dI as useState, dJ as useStatus, dK as useThreats, dL as useTick, dM as useTicksUntilReady, dN as useVelocity, dO as validateHookCall, dP as validateMissileConfig, dQ as withMissileContext, dR as withWizardContext, dS as wrapWithParams } from './index-browser-CM0uuzWp.js';
+import { F as FightResult, S as SimulateResult } from './index-browser-Dc-Vl1HI.js';
+export { A as ALL_BOTS, a as ARENA_MAX, b as ARENA_MIN, c as ARENA_SIZE, d as ARENA_WATER_BUFFER, e as ActionBuilder, f as AnalyzedThreat, g as Archlich, h as Archmage, B as BLINK_CAST_TIME, i as BLINK_COOLDOWN, j as BLINK_MAX_COOLDOWN, k as BLINK_MAX_RANGE, l as BLINK_MIN_COOLDOWN, m as BLINK_RANGE, n as BOT_GROUPS, o as Battlemage, p as BlinkEvent, q as Bonemancer, r as BotBudgetState, s as BotError, t as BrowserManualMatchSandbox, u as BrowserMatchSandbox, v as BrowserSandboxOptions, w as BudgetExhaustion, x as BudgetLimits, C as CASTING_MOVEMENT_MULT, y as COLLISION_RADIUS, z as CastCancelEvent, D as CastStartEvent, E as Critter, G as DEFAULT_BUDGET, H as DEFAULT_FIGHT_BACKSTOP_MS, I as DEFAULT_SEED, J as Doombringer, K as ENGINE_VERSION, L as EQUIVALENT_ENGINE_VERSIONS, M as EnemyState, N as FIGHT_SPAWN_DISTANCES, O as FightBudget, P as FightStats, Q as FightWinner, R as FinalAction, T as Flamecaller, U as GCD_DURATION, V as GameConfig, W as GameState, X as Golem, Y as Hero, Z as Hogger, _ as HomingParams, $ as HookState, a0 as Infernalist, a1 as InternalWizardState, a2 as KNOCKBACK_DAMAGE_THRESHOLD, a3 as KNOCKBACK_DECAY, a4 as KNOCKBACK_DELAY, a5 as KNOCKBACK_SPEED_PER_DAMAGE, a6 as LAVA_BORDER_WIDTH, a7 as Lich, a8 as MATCH_DURATION, a9 as MAX_HEALTH, aa as MISSILE_BASE_CAST, ab as MISSILE_BASE_RADIUS, ac as MISSILE_DAMAGE_POWER, ad as MISSILE_DAMAGE_RADIUS_SCALE, ae as MISSILE_DAMAGE_SCALE, af as MISSILE_HOMING_COEFF, ag as MISSILE_MIN_CAST_TIME, ah as MISSILE_MIN_DAMAGE, ai as MISSILE_MIN_DURATION, aj as MISSILE_MIN_SPEED, ak as MISSILE_RADIUS_PER_DAMAGE, al as MISSILE_SPEED_DURATION_BASELINE, am as MISSILE_SPEED_DURATION_COEFF, an as MISSILE_TURN_DURATION_COEFF, ao as MOVEMENT_SPEED, ap as MOVE_SPEED, aq as ManualMatch, ar as ManualMatchInitOptions, as as ManualMatchOptions, at as ManualMatchStepRequest, au as MatchWinner, av as MissileAction, aw as MissileActions, ax as MissileConfig, ay as MissileContext, az as MissileExpiredEvent, aA as MissileFunction, aB as MissileHitEvent, aC as MissileLaunchEvent, aD as MissileOobEvent, aE as MissileTemplate, aF as Nightblade, aG as ParamDeclaration, aH as Position, aI as ProjectileState, aJ as Pyromancer, aK as RULES, aL as RULESET_RANGES, aM as RefObject, aN as Rookie, aO as SHIELD_CAST_TIME, aP as SHIELD_DECAY_PER_SECOND, aQ as SHIELD_DECAY_RATE, aR as SHIELD_MAX_BLOCK, aS as SHIELD_MAX_STRENGTH, aT as SHIELD_MIN_BLOCK, aU as SHIELD_MIN_STRENGTH, aV as SPAWN_DISTANCE, aW as SeekerParams, aX as Sentinel, aY as Shadowblade, aZ as ShieldBlockEvent, a_ as ShieldStartEvent, a$ as SimEvent, b0 as Spellbinder, b1 as Spellseeker, b2 as Spellshot, b3 as Spellspinner, b4 as Spelltracer, b5 as Spellweaver, b6 as SpiralParams, b7 as StepResult, b8 as Stormcaller, b9 as Stormchaser, ba as Stormforger, bb as StraightParams, bc as TICKS_PER_SECOND, bd as TICK_DURATION_MS, be as TargetDummy, bf as TestBotBuilder, bg as TestFightResult, bh as TestSimulateResult, bi as TraceBotSummary, bj as TraceEvent, bk as TraceEventType, bl as TraceSummary, bm as Turtle, bn as Velocity, bo as Voidblade, bp as WARMUP_DURATION_TOLERANCE, bq as WARMUP_MAX_BONUS, br as WARMUP_MAX_PENALTY, bs as WARMUP_SPEED_TOLERANCE, bt as WARMUP_TURN_TOLERANCE, bu as WIZARD_HEALTH, bv as WIZARD_RADIUS, bw as Warmage, bx as WizardActions, by as WizardContext, bz as WizardDeathEvent, bA as WizardEntry, bB as WizardFunction, bC as WizardGroup, bD as WizardLavaDeathEvent, bE as WizardState, bF as WorkerFactory, bG as WorkerLike, bH as aim, bI as analyzeThreats, bJ as angleDiff, bK as angleInRange, bL as angleTo, bM as applyDamage, bN as applyRulesetOverrides, bO as blink, bP as browserSandboxFight, bQ as browserSandboxSimulate, bR as calculateBlinkCooldown, bS as calculateMissileCastTime, bT as calculateMissileRadius, bU as calculateMissileSimilarity, bV as calculateShieldBlock, bW as calculateWarmupMultiplier, bX as canReplayMatch, bY as cancel, bZ as cancelCast, b_ as clampPositionToArena, b$ as clampToArena, c0 as clampToSafeZone, c1 as clearHooks, c2 as clearParamValues, c3 as completeCast, c4 as createBudgetState, c5 as createEntitySeed, c6 as createFightBudget, c7 as createInitialState, c8 as createRandom, c9 as createWorkerScript, ca as currentRuleset, cb as diagnoseTrace, cc as directionAway, cd as directionTo, ce as distanceTo, cf as effectiveTurnRateCost, cg as extractAction, ch as extractMissileAction, ci as extractStats, cj as extractTraceEvents, ck as fight, cl as findInRange, cm as findNearest, cn as fitMissileForEscapingTarget, co as fitMissileToBudget, cp as flyStraight, cq as formatDiagnosis, cr as formatStats, cs as formatTraceEvents, ct as formatTraceSummary, cu as generateCandidates, cv as generateCombos, cw as getAdaptiveMissileConfig, cx as getEffectiveRange, cy as getLeadPosition, cz as getMissileCastTime, cA as getMissileContext, cB as getPlayerState, cC as getWizardContext, cD as hashCombine, cE as homingMissile, cF as idle, cG as inRange, cH as interceptAngle, cI as isBannedBotName, cJ as isInLava, cK as magnitude, cL as matchesAnyBanRule, cM as mayAct, cN as missile, cO as move, cP as moveInDirection, cQ as moveProjectile, cR as moveTowardSafely, cS as moveWizard, cT as narrowRange, cU as nextRandom, cV as normalize, cW as normalizeAngle, cX as predictPosition, cY as recordSpend, cZ as resetAllHooks, c_ as resetRuleset, c$ as resolveWizardCollision, d0 as runWithHooks, d1 as runWizardWithContext, d2 as scoreFight, d3 as scoreFightAsWizard2, d4 as seekerMissile, d5 as setParamValues, d6 as shield, d7 as simulate, d8 as simulateMinDuration, d9 as sortByDistance, da as spiralMissile, db as startCast, dc as startDiscovery, dd as stopDiscovery, de as straightMissile, df as summarizeTrace, dg as sweptCircleCollision, dh as testBot, di as tick, dj as turnToAngle, dk as turnToward, dl as updateShield, dm as useArenaSize, dn as useBlinkCooldown, dp as useCastProgress, dq as useCastingSpell, dr as useClosestThreat, ds as useDamageDealt, dt as useDamageTaken, du as useEffect, dv as useEnemy, dw as useHealth, dx as useLastHitTick, dy as useLastMissileConfig, dz as useMemo, dA as useMyProjectiles, dB as useMyThreatsToEnemy, dC as useParam, dD as usePosition, dE as useProjectiles, dF as useRandom, dG as useRef, dH as useShieldStrength, dI as useState, dJ as useStatus, dK as useThreats, dL as useTick, dM as useTicksUntilReady, dN as useVelocity, dO as validateHookCall, dP as validateMissileConfig, dQ as withMissileContext, dR as withWizardContext, dS as wrapWithParams } from './index-browser-Dc-Vl1HI.js';
 
 /**
  * A compiled bot ready for sandboxed execution.

package/dist/index.js

@@ -234,7 +234,7 @@ import {
   withMissileContext,
   withWizardContext,
   wrapWithParams
-} from "./chunk-EO7JO2RZ.js";
+} from "./chunk-KGRG7TZS.js";
 
 // src/engine/sandbox.ts
 import ivm from "isolated-vm";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vibemancer/core",
-	"version": "1.0.11",
+	"version": "1.0.13",
 	"description": "Vibemancer game engine - competitive programming wizard battle arena",
 	"type": "module",
 	"author": "Low Entry",

package/src/engine/bot-error-capture.ts

@@ -38,10 +38,24 @@ export const MAX_ERRORS_PER_MATCH = 500;
  */
 export function describeThrown(thrown: unknown): string
 {
-	return truncate(rawDescription(thrown));
+	const {text, alreadyBounded} = rawDescription(thrown);
+	// `alreadyBounded` exists because truncating twice destroyed the marker. The oversized-
+	// Error branch returns a string that is ALREADY capped and ends in
+	// "[stack omitted: message too large]"; running truncate() over that re-sliced to the
+	// first MAX_MESSAGE_LENGTH characters — all of them original message text — and cut the
+	// marker off every single time. The player was told "truncated, N more characters" and
+	// never that a stack had been dropped, which was the one thing the branch existed to say.
+	return alreadyBounded ? text : truncate(text);
 }
 
-function rawDescription(thrown: unknown): string
+/** A description plus whether it is already within the size cap and must not be re-cut. */
+interface RawDescription
+{
+	text: string;
+	alreadyBounded: boolean;
+}
+
+function rawDescription(thrown: unknown): RawDescription
 {
 	if (thrown instanceof Error)
 	{
@@ -62,26 +76,26 @@ function rawDescription(thrown: unknown): string
 		{
 			// Deliberately NOT reading .stack here. The location is worth having, but not at
 			// the cost of letting a bot decide how much the engine allocates.
-			return truncate(message) + ' [stack omitted: message too large]';
+			return {text: truncate(message) + ' [stack omitted: message too large]', alreadyBounded: true};
 		}
 
 		// The stack's first line is "Error: message", so it carries both the message and the
 		// location — which is the whole point, since nothing else gives a player a line number.
 		const stack = typeof thrown.stack === 'string' ? stripBundleCoordinates(thrown.stack.trim()) : '';
-		if (stack) return stack;
-		return message || `${thrown.name || 'Error'} (thrown with no message)`;
+		if (stack) return {text: stack, alreadyBounded: false};
+		return {text: message || `${thrown.name || 'Error'} (thrown with no message)`, alreadyBounded: false};
 	}
 
-	if (typeof thrown === 'string') return thrown || '(empty string thrown)';
-	if (thrown === null) return 'null was thrown';
-	if (thrown === undefined) return 'undefined was thrown';
+	if (typeof thrown === 'string') return {text: thrown || '(empty string thrown)', alreadyBounded: false};
+	if (thrown === null) return {text: 'null was thrown', alreadyBounded: false};
+	if (thrown === undefined) return {text: 'undefined was thrown', alreadyBounded: false};
 
 	// A thrown object is a deliberate choice by the author — a custom error type, usually —
 	// so its fields are exactly what they wanted to see. String() would discard all of them.
 	try
 	{
 		const json = JSON.stringify(thrown);
-		if (typeof json === 'string' && json !== '{}') return json;
+		if (typeof json === 'string' && json !== '{}') return {text: json, alreadyBounded: false};
 	}
 	catch
 	{
@@ -96,12 +110,12 @@ function rawDescription(thrown: unknown): string
 		// returning it is a silent failure to describe. It happens when JSON.stringify refuses
 		// — a circular reference, or a getter that throws — and a player who sees it learns
 		// nothing at all. Say what we DO know instead: the constructor name and the keys.
-		if (text === '[object Object]') return describeOpaqueObject(thrown);
-		return text;
+		if (text === '[object Object]') return {text: describeOpaqueObject(thrown), alreadyBounded: false};
+		return {text, alreadyBounded: false};
 	}
 	catch
 	{
-		return '(a value was thrown that could not be described)';
+		return {text: '(a value was thrown that could not be described)', alreadyBounded: false};
 	}
 }
 
@@ -152,7 +166,13 @@ function describeOpaqueObject(thrown: object): string
  */
 function stripBundleCoordinates(stack: string): string
 {
-	return stack.replace(/\s*\((?:[^()\s]*match-bundle\.js|<isolated-vm>)[^()]*\)/g, '');
+	return stack
+		// `at helper (match-bundle.js:9108:16)` — the common case, name kept, coordinates gone.
+		.replace(/\s*\((?:[^()\s]*match-bundle\.js|<isolated-vm>)[^()]*\)/g, '')
+		// `at match-bundle.js:911:62` — V8 emits this for an ANONYMOUS frame, with no
+		// parentheses at all, so the version above never matched it and the bogus line number
+		// survived in precisely the case with no function name to make up for it.
+		.replace(/(\s*at )(?:[^()\s]*match-bundle\.js|<isolated-vm>)[^\s)]*/g, '$1<your bot>');
 }
 
 function truncate(message: string): string

package/src/engine/simulation.ts

@@ -160,6 +160,33 @@ function buildWizardContext(state: GameState, config: GameConfig, random: () =>
 /**
  * Process one game tick.
  */
+
+/**
+ * Name the first non-finite number a bot handed the engine this tick, or null.
+ *
+ * Checks the three doors that were each found separately: the move vector, the blink target,
+ * and the aim angle. Returns WHICH field so the message can point at the player's own call
+ * rather than saying "something went wrong".
+ */
+function nonFiniteField(
+	move: {x?: number; y?: number},
+	action: {startCast?: {spell?: string; target?: {x?: number; y?: number}}; aimDirection?: number},
+	wizard: {blinkTarget?: {x?: number; y?: number}},
+): {what: string; value: string} | null
+{
+	const bad = (v: unknown): boolean => typeof v === 'number' && !Number.isFinite(v);
+	if (bad(move?.x)) return {what: 'move(x, y): x', value: String(move.x)};
+	if (bad(move?.y)) return {what: 'move(x, y): y', value: String(move.y)};
+
+	const target = action.startCast?.spell === 'blink' ? action.startCast.target : undefined;
+	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;
+}
 export function tick(
 	currentTick: number,
 	wizard1AI: WizardFunction,
@@ -430,6 +457,35 @@ export function tick(
 		// Handle movement (default to no movement if bot didn't provide move)
 		const oldPos = wizard.position;
 		const move = action.move ?? {x: 0, y: 0};
+
+		// The non-finite guards work, and were completely silent. A bot that divides by zero
+		// somewhere just stops moving; the guard saves the match but tells the author nothing,
+		// which is the same "looks passive, is broken" failure as an unreported throw — and
+		// reached by accident rather than by anything hostile.
+		//
+		// Reporting deliberately does NOT change behaviour: the clamp still stands and the
+		// match plays out identically. Throwing instead would alter results for bots already
+		// on the ladder and could feed crash-deactivation, which is far too large a
+		// consequence to attach to a diagnostic.
+		// The flag lives on the WIZARD, not in a Set here: tick() runs afresh every frame, so a
+		// Set declared inside it deduped nothing and the first version of this reported the
+		// same paragraph 500 times, straight into the error cap.
+		if (!wizard.advised?.nonFinite)
+		{
+			const bad = nonFiniteField(move, 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 — 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, move, 1);
 
 		// Process delayed knockback (apply impulse after delay expires)
@@ -500,6 +556,32 @@ export function tick(
 				startCast(wizard, castingSpell, castingSpell === 'missile' ? action.startCast.config : undefined);
 				if (castingSpell === 'missile')
 				{
+					// A cast longer than the whole match can never complete, so the wizard
+					// stands still until time runs out and NOTHING is reported. Every field is
+					// clamped by validateMissileConfig — nothing here is NaN — but turnRate is
+					// clamped only to `>= 0`, and turnRate 9999 prices the cast at 130,017
+					// ticks against a 30,000-tick match. Measured against TargetDummy, a bot
+					// that does nothing at all, the result was ten draws: the bot could not
+					// even lose in a way that hinted at the cause.
+					//
+					// The cast is still allowed — refusing it would silently change what bots
+					// do, and the defect was never the cast, it was the silence.
+					if ((wizard.castDuration ?? 0) > MATCH_DURATION && !wizard.advised?.unfinishableCast)
+					{
+						wizard.advised = {...wizard.advised, unfinishableCast: true};
+						const config = 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 (${config?.turnRate ?? '?'}) — 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 !== undefined)

package/src/engine/spells.ts

@@ -4,6 +4,7 @@ import {
 	TICKS_PER_SECOND,
 	calculateMissileCastTime,
 	calculateWarmupMultiplier,
+	validateMissileConfig,
 } from '../rules.js';
 
 /**
@@ -19,8 +20,19 @@ export function startCast(wizard: WizardState, spell: 'missile' | 'shield' | 'bl
 	// Stryker disable next-line ConditionalExpression: `true && config` equivalent for valid calls (spell is always correct type)
 	if (spell === 'missile' && config)
 	{
+		// VALIDATE FIRST. This used to pass the raw config, and the raw formula returns NaN for
+		// a config a beginner can easily type — `{damage: -999, speed: 0, duration: -5}` —
+		// because of the powers and divisions inside it. `Math.max(1, Math.round(NaN))` is NaN,
+		// not 1, so castDuration became NaN and `castProgress >= castDuration` was never true:
+		// the cast could NEVER complete and the wizard stood still for the whole match, silently.
+		// Measured against TargetDummy, a bot that does nothing: ten draws, zero errors.
+		//
+		// getMissileCastTime — the function bots call to PREDICT this exact number — has always
+		// validated first, so the engine and its own prediction disagreed for precisely the
+		// configs where a player most needed them to agree.
+		const validated = validateMissileConfig(config);
 		// calculateMissileCastTime includes warmup when lastMissileConfig is passed
-		const castTimeSec = calculateMissileCastTime(config, wizard.lastMissileConfig);
+		const castTimeSec = calculateMissileCastTime(validated, wizard.lastMissileConfig);
 		wizard.castDuration = Math.max(1, Math.round(castTimeSec * TICKS_PER_SECOND));
 		// Store warmup multiplier for visualization
 		wizard.warmupMultiplier = calculateWarmupMultiplier(wizard.lastMissileConfig, config);

package/src/engine-version.ts

@@ -9,7 +9,7 @@
  * Used to gate spectator replays: a recorded match can only be re-simulated when
  * the runtime engine version matches the version that produced the match.
  */
-export const ENGINE_VERSION = 2983169471988242;
+export const ENGINE_VERSION = 4256327861353618;
 
 /**
  * Historical versions that denote the SAME engine as `ENGINE_VERSION`.

package/src/hooks/action-builders.ts

@@ -279,12 +279,47 @@ export function flyStraight(): MissileAction
 	};
 }
 
+/**
+ * Name what a bot handed back, for an error message it can act on.
+ *
+ * Named specifically rather than by bare typeof: "a object" is both ungrammatical and
+ * unhelpful, and the realistic version of this mistake is `async function MyBot()`, where the
+ * value is a Promise and the fix is to remove the `async`.
+ */
+function describeReturned(value: unknown): string
+{
+	if (value === null) return 'null';
+	if (value === undefined) return 'undefined';
+	if (Array.isArray(value)) return 'an array';
+	if (typeof value === 'object')
+	{
+		if ('then' in value && typeof (value as {then?: unknown}).then === 'function')
+		{
+			return 'a Promise — your function is `async`, and it must not be: remove the async keyword';
+		}
+		return 'a plain object';
+	}
+	return `a ${typeof value}`;
+}
+
 /**
  * Extract MissileActions from a MissileAction.
  * Used by the engine to get the actual missile action.
  */
 export function extractMissileAction(action: MissileAction): MissileActions
 {
+	// The wizard-level path got a readable message for a bad return; this one did not, and a
+	// missile AI is the SECOND function a player writes. Returning `{}` from it produced
+	// "TypeError: action._toMissileAction is not a function" over an engine-internal stack —
+	// naming a private field that appears nowhere in the API, 84 times in one match.
+	if (action === null || action === undefined || 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();
 }
 
@@ -312,21 +347,6 @@ export function extractAction(finalAction: FinalAction): WizardActions
 		// Named specifically rather than by bare typeof: "a object" is both ungrammatical and
 		// unhelpful, and the realistic version of this mistake is `async function MyBot()`,
 		// where the value is a Promise and the fix is to remove the `async`.
-		const describeReturned = (value: unknown): string =>
-		{
-			if (value === null) return 'null';
-			if (value === undefined) return 'undefined';
-			if (Array.isArray(value)) return 'an array';
-			if (typeof value === 'object')
-			{
-				if ('then' in value && typeof value.then === 'function')
-				{
-					return 'a Promise — your bot function is `async`, and it must not be: remove the async keyword';
-				}
-				return 'a plain object';
-			}
-			return `a ${typeof value}`;
-		};
 		const got = describeReturned(finalAction);
 		throw new Error(
 			`Your bot returned ${got}. Return one of: idle(), move(x, y), missile(config, ai, angle), `

package/src/hooks/state-hooks.ts

@@ -366,8 +366,12 @@ export function useThreats(): AnalyzedThreat[]
 			ctx.projectiles,
 			ctx.myProjectiles,
 			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]);
 }
 
 /**

package/src/hooks/threat-analysis.ts

@@ -19,6 +19,14 @@ import {distanceTo} from '../utils/distance.js';
 import {angleTo, normalizeAngle, angleDiff} from '../utils/angles.js';
 import type {AnalyzedThreat} from './types.js';
 
+/**
+ * Ticks lost to cancel() before a new cast can begin.
+ *
+ * The guide states it: cancel() "returns you to idle immediately and costs NO cooldown, but
+ * it takes effect after this tick's cast check — so you can shield on the NEXT tick".
+ */
+const CANCEL_COST_TICKS = 1;
+
 // Maximum distance at which a missile is still tracked as a potential threat
 // (even if simulation says it will miss — homing missiles can change course)
 const THREAT_RELEVANCE_DISTANCE = 500;
@@ -30,6 +38,9 @@ const THREAT_RELEVANCE_DISTANCE = 500;
  * @param projectiles - All projectiles in the game
  * @param myProjectiles - Only the bot's own projectiles (used for filtering)
  * @param ticksUntilReady - Ticks until wizard can start a new action
+ * @param options - `canCancelCurrentCast` when the wizard is mid-CAST and could cancel()
+ *                  out of it for one tick's cost. Defaults to false, which is the safe
+ *                  reading for a caller that does not know its own state.
  * @returns Array of analyzed threats sorted by ticksToImpact (soonest first)
  */
 export function analyzeThreats(
@@ -37,6 +48,7 @@ export function analyzeThreats(
 	projectiles: ProjectileState[],
 	myProjectiles: ProjectileState[],
 	ticksUntilReady: number,
+	options?: {canCancelCurrentCast?: boolean},
 ): AnalyzedThreat[]
 {
 	// Filter to enemy projectiles by excluding our own
@@ -48,7 +60,7 @@ export function analyzeThreats(
 
 	for (const projectile of enemyProjectiles)
 	{
-		const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady);
+		const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady, options?.canCancelCurrentCast ?? false);
 		// Only include if it will hit or missile is within reasonable distance
 		const missileDistance = Math.sqrt(
 			(projectile.position.x - myPos.x) ** 2 +
@@ -74,6 +86,7 @@ function analyzeOneThreat(
 	targetPos: Position,
 	projectile: ProjectileState,
 	ticksUntilReady: number,
+	canCancelCurrentCast: boolean,
 ): AnalyzedThreat
 {
 	// Ask the ENGINE for the collision radius rather than re-deriving it.
@@ -123,13 +136,22 @@ function analyzeOneThreat(
 		);
 	}
 
-	// Calculate shield timing
-	// Can block if: ticksUntilReady + shield cast time < ticksToImpact
-	// Stryker disable next-line EqualityOperator,ArithmeticOperator: ±1 tick boundary is intentional buffer, not precisely testable
-	const canBlockInTime = ticksToImpact > ticksUntilReady + RULES.SHIELD_CAST_TIME + 1;
-
-	// When to start casting shield (leave 1 tick buffer)
-	const ticksToStartShield = Math.max(0, ticksToImpact - RULES.SHIELD_CAST_TIME - 1);
+	// Shield timing. These two fields MUST be satisfiable together: a bot acts on
+	// `canBlockInTime && ticksToStartShield === 0`, so if they can never both hold the bot
+	// never shields. They used to disagree — canBlockInTime charged the wizard the whole
+	// remainder of its cast while ticksToStartShield ignored the cast entirely — and mid-cast
+	// that made them mutually exclusive. Measured cost: zero shields raised in a full match.
+	//
+	// The pessimism was wrong as well as inconsistent. cancel() leaves a CAST for one tick's
+	// cost, so a casting wizard's real delay is 1, not the couple of hundred ticks remaining.
+	// A GCD is different: nothing can be started during it and it cannot be cancelled, so
+	// there the full ticksUntilReady genuinely does apply.
+	const delayBeforeShield = canCancelCurrentCast ? CANCEL_COST_TICKS : ticksUntilReady;
+
+	// One tick of slack, so the window is not a single exact frame.
+	const ticksNeededToBlock = delayBeforeShield + RULES.SHIELD_CAST_TIME + 1;
+	const canBlockInTime = ticksToImpact >= ticksNeededToBlock;
+	const ticksToStartShield = Math.max(0, ticksToImpact - ticksNeededToBlock);
 
 	return {
 		id: projectile.id,

package/src/types.ts

@@ -44,6 +44,7 @@ export interface WizardState
 	lastMissileConfig?: MissileConfig; // last fired missile (for warmup system)
 	warmupMultiplier?: number; // warmup multiplier applied to most recent missile cast (0.80 = full bonus, 1.20 = full penalty)
 	invincible?: boolean; // manual play mode: damage is ignored when true
+	advised?: {nonFinite?: boolean; unfinishableCast?: boolean}; // engine advisories already given, so each is reported once per match
 }
 
 /**