@vibemancer/core 1.0.9 → 1.0.11

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

@@ -19,7 +19,8 @@
  * damage history — only what's visible on the battlefield.
  */
 interface EnemyState {
-    /** Enemy position in world coordinates (0-800). */
+    /** Enemy position in world coordinates. The arena is 0-860; the survivable playfield is
+     *  [30, 830], and outside that band is lava. */
     position: Position;
     /** Enemy velocity in units/tick. */
     velocity: Velocity;
@@ -95,9 +96,20 @@ interface ActionBuilder extends FinalAction {
      * to `missile()` is overwritten before the shot leaves. That makes the enemy impossible
      * to LEAD: you always fire where they are, never where they will be.
      *
-     * `lockAim()` holds your angle for the whole cast, which is what makes `getLeadPosition`
-     * and `interceptAngle` worth using. It is opt-in precisely because auto-aim is the right
-     * default for most bots: lock your aim and a target that moves during the cast is missed.
+     * `lockAim()` holds your angle for the whole cast — but it is USUALLY THE WRONG TOOL for
+     * leading, and this comment used to claim the opposite. Measured over 1,140 matches
+     * against the built-ins: auto-aim wins 80.5%, lockAim with a computed lead wins 29.3%,
+     * and it degrades monotonically the more shots you lock.
+     *
+     * The reason is cast time. A cast runs 88-240 ticks — up to 2.4 SECONDS — and lockAim
+     * freezes the angle at cast START, so it is stale long before the missile leaves. No bot
+     * holds a heading that long.
+     *
+     * TO LEAD A TARGET, call `aim(degrees)` on every tick of the cast and recompute the lead
+     * each time: same harness, 85.4%. That is what makes `getLeadPosition` worth calling.
+     *
+     * lockAim is for aiming at a PLACE rather than a bot — a lava edge, an escape lane, an
+     * area you want denied — where a fixed angle is the point.
      *
      * Chainable — `missile(cfg, ai, angle).lockAim().move(0, 1)` aims, fires and kites.
      */
@@ -288,16 +300,20 @@ interface GameState {
  * Actions returned by wizard each tick.
  *
  * Movement uses world-space coordinates:
- * - x: +100 = right, -100 = left
- * - y: +100 = down, -100 = up
- * - Diagonal movement is normalized (magnitude capped at 100)
+ * - x: positive = right, negative = left
+ * - y: positive = down, negative = up
+ * - Only the DIRECTION matters: the vector is normalised, and magnitude is capped at 1.
+ *   move(1, 0), move(5, 0) and move(100, 0) are identical; move(0.5, 0) is half speed.
  * - No rotation tracking - just output (x, y) direction
+ *
+ * The old wording here described a [-100, 100] scale, which has not been true for a long
+ * time and is 100x off.
  */
 interface WizardActions {
     /**
-     * Movement direction in world-space.
-     * Values are clamped to [-100, 100] range.
-     * Magnitude is normalized to max 100 for diagonal movement.
+     * Movement direction in world-space. Only the direction matters — the vector is
+     * normalised and its magnitude is capped at 1, so move(100, 0) and move(1, 0) are the
+     * same full-speed step. A magnitude below 1 moves proportionally slower.
      */
     move: {
         x: number;
@@ -561,6 +577,14 @@ declare function validateMissileConfig(config: MissileConfig): MissileConfig;
  * If lastMissileConfig is a MissileConfig, applies warmup multiplier:
  * - Similar to previous: up to 20% faster
  * - Very different: up to 20% slower (switching penalty)
+ *
+ * @returns cast time in SECONDS — multiply by TICKS_PER_SECOND for ticks.
+ *
+ * Bot authors almost always want `getMissileCastTime` from utils/combat.ts instead, which
+ * has the identical signature and returns TICKS, the unit the guide and every other number in
+ * the API use. Both are exported and both appear in vibemancer_api as `(config, last?) =>
+ * number`, so the unit was impossible to tell apart: 2.747 read as three ticks rather than
+ * 275.
  */
 declare function calculateMissileCastTime(config: MissileConfig, lastMissileConfig?: MissileConfig | undefined | null): number;
 declare const WARMUP_MAX_BONUS: number;
@@ -630,7 +654,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 = 293192982913104;
+declare const ENGINE_VERSION = 2983169471988242;
 /**
  * Historical versions that denote the SAME engine as `ENGINE_VERSION`.
  *
@@ -738,6 +762,16 @@ interface BudgetLimits {
 interface BotBudgetState {
     spentMs: number;
     exhausted: boolean;
+    /**
+     * Whether the engine has already reported this bot being cut off.
+     *
+     * An exhausted bot is refused on every remaining tick — thousands of them — and one record
+     * is a report while thousands is a denial of service against the reader. Lives on the
+     * state rather than in the caller because the state object is what survives the early
+     * return: once exhausted, `recordSpend` is never reached again, so this same object
+     * persists for the rest of the match.
+     */
+    reported?: boolean;
 }
 /**
  * Default, sized from measurement (2026-08-30) — and resized once, after the first
@@ -851,6 +885,7 @@ declare function tick(currentTick: number, wizard1AI: WizardFunction, wizard2AI:
     projectiles: ProjectileState[];
     events: SimEvent[];
     errors: BotError[];
+    budgetExhausted: BudgetExhaustion[];
     budgets?: [BotBudgetState, BotBudgetState];
 };
 /**
@@ -867,10 +902,41 @@ type FightWinner = 'wizard-1' | 'wizard-2' | 'draw';
  * Result of a simulation.
  */
 /** A runtime error captured from a bot or missile AI function. */
+/**
+ * A bot that ran out of its compute budget and stopped being called.
+ *
+ * Deliberately NOT a BotError. Errors feed `consecutiveCrashes` on the ladder and
+ * auto-deactivate a wizard at three; being slow on a loaded server must never cost someone
+ * their bot. But it was recorded NOWHERE, so a bot that burned its allowance stood still for
+ * the rest of the fight and reported a clean scoreline — measured, a certain 10-0 became 1
+ * win and 9 draws with nothing saying why.
+ */
+interface BudgetExhaustion {
+    entityId: string;
+    /** The tick the bot was first refused. */
+    tick: number;
+    /** How much it had spent when it was cut off, in milliseconds. */
+    spentMs: number;
+    /** 1-based match index within a fight; set by `fight()`, absent from a lone simulate(). */
+    match?: number;
+}
 interface BotError {
     tick: number;
     entityId: string;
     message: string;
+    /**
+     * True when the wizard was ALREADY DEAD on the tick this was thrown.
+     *
+     * The engine keeps calling a bot after its health reaches zero and discards the action, so
+     * these errors change nothing. Unmarked they are actively misleading in two ways: a player
+     * sees a fault spanning hundreds of ticks with no hint the wizard was dead for all of
+     * them, and the ladder counts them toward consecutiveCrashes — so a bot can be
+     * auto-deactivated for errors the guide itself calls harmless.
+     *
+     * The engine is the only place that knows, so it is recorded here rather than guessed
+     * downstream from a reconstructed death tick.
+     */
+    afterDeath?: boolean;
     /**
      * 1-based index within the fight's TEN matches, present only on `FightResult.allErrors`.
      *
@@ -889,6 +955,15 @@ interface SimulateResult {
     history: GameState[];
     /** Runtime errors thrown by bot or missile AI functions (empty if no errors). */
     errors: BotError[];
+    /**
+     * Bots that ran out of compute and stopped being called (empty if nobody did).
+     *
+     * Separate from `errors` on purpose: errors feed consecutiveCrashes and deactivate a
+     * wizard at three, and being slow must never do that. But it has to be reported SOMEWHERE
+     * — a bot cut off in match 1 stands still for the rest of the fight, and without this the
+     * player sees a clean scoreline and rewrites a strategy that was never the problem.
+     */
+    budgetExhausted: BudgetExhaustion[];
 }
 /**
  * Result of a fight (best-of-5 at different spawn distances).
@@ -917,6 +992,14 @@ interface FightResult {
      * raw would blame each side's faults on the other.
      */
     allErrors: BotError[];
+    /**
+     * Bots cut off by the compute budget, across all ten matches.
+     *
+     * The budget is FIGHT-scoped, so this is where it belongs: exhausting it in match 1
+     * freezes the bot for the other nine. Ids are in the caller's frame, mirrored out of the
+     * swapped matches like allErrors.
+     */
+    budgetExhausted: BudgetExhaustion[];
 }
 /** Spawn distances for the 5 matches in a fight (creates butterfly effect variation) */
 declare const FIGHT_SPAWN_DISTANCES: number[];
@@ -1086,6 +1169,48 @@ declare function moveProjectile(projectile: ProjectileState, deltaTicks: number)
  * Clamp a position to the full arena bounds (0-860).
  * No playfield clamping — wizards CAN walk/blink into lava.
  */
+/**
+ * Clamp a position into the band where a wizard SURVIVES.
+ *
+ * `clampToArena` clamps to the full 0-860 arena, lava border included, which is what its own
+ * JSDoc says and is almost never what a bot wants. The MCP guide nonetheless named it as the
+ * remedy for lava, and an agent following that advice verbatim blinked into the lava at tick
+ * 11 and lost 0-10 to a bot that does nothing. There was no exported helper that did the
+ * survivable thing, so the guide reached for the closest-sounding name.
+ *
+ * The band is inset by the wizard's RADIUS, not merely to the playfield edge, because death
+ * is decided by whether the wizard's EDGE touches lava: the safe range for a centre is
+ * [ARENA_MIN + radius, ARENA_MAX - radius].
+ *
+ * A non-finite input returns the arena centre rather than propagating NaN — a helper whose
+ * entire job is safety must not be the thing that poisons the simulation.
+ */
+declare function clampToSafeZone(position: Position, radius: number): Position;
+/**
+ * A move vector that walks TOWARD a target without overshooting it.
+ *
+ * `move()` takes a DIRECTION, and `moveWizard` normalises only when the vector's magnitude
+ * exceeds 1 — so a shorter vector is a fraction of full speed, not a distance. That makes the
+ * obvious composition of the two things the guide recommends quietly fatal:
+ *
+ *     const goal = clampToSafeZone({x: pos.x + dx, y: pos.y + dy}, WIZARD_RADIUS);
+ *     return move(goal.x - pos.x, goal.y - pos.y);   // overshoots the clamp
+ *
+ * Asking to move 0.09 units moves you 0.14, which at the boundary is 0.03 units into the
+ * lava, at full health. An agent died to exactly this at T1040 on 60/60 HP. It is the same
+ * shape as the clampToArena defect: the helper was right and the composition was deadly.
+ *
+ * This scales the step so that ARRIVING is the worst case. It prevents OVERSHOOT, not bad
+ * aim — clamp the target first, then walk to it:
+ *
+ *     const goal = clampToSafeZone({x: pos.x + dx, y: pos.y + dy}, WIZARD_RADIUS);
+ *     return move(...moveTowardSafely(pos, goal));   // safe
+ *
+ * Aim it at an unclamped point 90 units away and it will take a full-speed step straight into
+ * the lava, correctly. I made that exact mistake writing the test for this function, which is
+ * the same composition confusion the helper exists to fix — hence spelling it out here.
+ */
+declare function moveTowardSafely(from: Position, target: Position): Position;
 declare function clampToArena(position: Position, radius: number): Position;
 /**
  * Check if a position is in the lava zone (outside the playfield).
@@ -1413,6 +1538,14 @@ declare function magnitude(vector: Position): number;
  *
  * If lastMissileConfig is provided, includes warmup multiplier.
  * Pass undefined for first cast (full warmup) or null for base time only.
+ *
+ * @returns cast time in TICKS.
+ *
+ * Note the unit, because there are two of these: `calculateMissileCastTime` in rules.ts has
+ * the identical signature and returns SECONDS. vibemancer_api lists both as
+ * `(config, last?) => number`, and the whole guide speaks in ticks — so a player budgeting
+ * ticks from the seconds one reads 2.747 as "about three ticks" when it is 275.
+ * This one is the one a bot wants.
  */
 declare function getMissileCastTime(config: MissileConfig, lastMissileConfig?: MissileConfig | null): number;
 /**
@@ -1535,7 +1668,7 @@ declare function useVelocity(): Velocity;
 /**
  * Get your current status:
  * - 'idle':        free to act
- * - 'casting':     casting a spell (missile or blink). Can move at 50% speed.
+ * - 'casting':     casting a spell (missile, blink OR shield). Can move at 33% speed.
  * - 'channeling':  channeling shield. Cannot move. Cancel anytime with cancel().
  * - 'gcd_locked':  global cooldown after spell. Can move at full speed, but cannot cast.
  */
@@ -1572,7 +1705,9 @@ declare function useLastMissileConfig(): MissileConfig | undefined;
  * Get blink cooldown remaining in ticks. Returns 0 if ready to blink.
  *
  * Cooldown scales with distance used:
- * - 100 units → ~100 ticks (1s)
+ * - 10 units → 100 ticks (1s); 100 units → 667 ticks; 300 → 2000 (20s)
+ * - The cooldown scales with DISTANCE, so a micro-blink is cheap and a full-range one is
+ *   not. This said 100 units → ~100 ticks, which understated it by 6.7x.
  * - 300 units (max range) → 2000 ticks (20s)
  *
  * Note: 100 ticks = 1 second.
@@ -1713,7 +1848,7 @@ declare function shield(): ActionBuilder;
  * Cast a missile spell.
  *
  * Cast time scales with damage, speed, duration, and turn rate — bigger missiles
- * take longer to cast. While casting you move at 50% speed. After firing, 100-tick
+ * take longer to cast. While casting you move at 33% speed. After firing, 100-tick
  * (1s) GCD before next spell.
  *
  * Repeated similar missiles cast 20% faster (warmup bonus). Switching styles
@@ -1766,13 +1901,16 @@ declare function aim(degrees: number): ActionBuilder;
  *
  * Max range: 300 units from current position (clamped by engine if further).
  * Cast time: 10 ticks (0.1s). Cooldown scales with distance:
- *   - 100 units → 100 ticks (1s)
+ *   - 10 units → 100 ticks (1s); 100 units → 667 ticks; 150 → 1000 (10s); 300 → 2000 (20s).
+ *     The cooldown scales with DISTANCE — a micro-blink costs a second, a full-range one
+ *     costs twenty. This line used to claim 100 units → 100 ticks, understating it 6.7x.
  *   - 300 units → 2000 ticks (20s)
  *
  * Cannot chain .move() — blink IS the movement.
  *
- * @param x - Target X position (0-800, absolute world coordinate)
- * @param y - Target Y position (0-800, absolute world coordinate)
+ * @param x - Target X position (absolute world coordinate; arena is 0-860, and the
+ *            survivable playfield is [30, 830] — outside that band is lava)
+ * @param y - Target Y position (absolute world coordinate; see x)
  *
  * @example
  *   return blink(400, 400);                              // blink to center
@@ -3204,4 +3342,4 @@ declare function diagnoseTrace(events: TraceEvent[], summary: TraceSummary): str
 /** Format diagnostic tips as a human-readable string. */
 declare function formatDiagnosis(tips: string[]): string;
 
-export { Infernalist as $, ALL_BOTS as A, BLINK_CAST_TIME as B, CASTING_MOVEMENT_MULT as C, Critter as D, DEFAULT_BUDGET as E, type FightResult as F, DEFAULT_FIGHT_BACKSTOP_MS as G, DEFAULT_SEED as H, Doombringer as I, ENGINE_VERSION as J, EQUIVALENT_ENGINE_VERSIONS as K, type EnemyState as L, FIGHT_SPAWN_DISTANCES as M, type FightBudget as N, type FightStats as O, type FightWinner as P, type FinalAction as Q, Flamecaller as R, type SimulateResult as S, GCD_DURATION as T, type GameConfig as U, type GameState as V, Golem as W, Hero as X, Hogger as Y, type HomingParams as Z, type HookState as _, ARENA_MAX as a, Spellbinder as a$, type InternalWizardState as a0, KNOCKBACK_DAMAGE_THRESHOLD as a1, KNOCKBACK_DECAY as a2, KNOCKBACK_DELAY as a3, KNOCKBACK_SPEED_PER_DAMAGE as a4, LAVA_BORDER_WIDTH as a5, Lich as a6, MATCH_DURATION as a7, MAX_HEALTH as a8, MISSILE_BASE_CAST as a9, type MissileHitEvent as aA, type MissileLaunchEvent as aB, type MissileOobEvent as aC, type MissileTemplate as aD, Nightblade as aE, type ParamDeclaration as aF, type Position as aG, type ProjectileState as aH, Pyromancer as aI, RULES as aJ, RULESET_RANGES as aK, type RefObject as aL, Rookie as aM, SHIELD_CAST_TIME as aN, SHIELD_DECAY_PER_SECOND as aO, SHIELD_DECAY_RATE as aP, SHIELD_MAX_BLOCK as aQ, SHIELD_MAX_STRENGTH as aR, SHIELD_MIN_BLOCK as aS, SHIELD_MIN_STRENGTH as aT, SPAWN_DISTANCE as aU, type SeekerParams as aV, Sentinel as aW, Shadowblade as aX, type ShieldBlockEvent as aY, type ShieldStartEvent as aZ, type SimEvent as a_, MISSILE_BASE_RADIUS as aa, MISSILE_DAMAGE_POWER as ab, MISSILE_DAMAGE_RADIUS_SCALE as ac, MISSILE_DAMAGE_SCALE as ad, MISSILE_HOMING_COEFF as ae, MISSILE_MIN_CAST_TIME as af, MISSILE_MIN_DAMAGE as ag, MISSILE_MIN_DURATION as ah, MISSILE_MIN_SPEED as ai, MISSILE_RADIUS_PER_DAMAGE as aj, MISSILE_SPEED_DURATION_BASELINE as ak, MISSILE_SPEED_DURATION_COEFF as al, MISSILE_TURN_DURATION_COEFF as am, MOVEMENT_SPEED as an, MOVE_SPEED as ao, ManualMatch as ap, type ManualMatchInitOptions as aq, type ManualMatchOptions as ar, type ManualMatchStepRequest as as, type MatchWinner as at, type MissileAction as au, type MissileActions as av, type MissileConfig as aw, type MissileContext as ax, type MissileExpiredEvent as ay, type MissileFunction$1 as az, ARENA_MIN as b, clearHooks as b$, Spellseeker as b0, Spellshot as b1, Spellspinner as b2, Spelltracer as b3, Spellweaver as b4, type SpiralParams as b5, type StepResult as b6, Stormcaller as b7, Stormchaser as b8, Stormforger as b9, type WizardFunction as bA, type WizardGroup as bB, type WizardLavaDeathEvent as bC, type WizardState as bD, type WorkerFactory as bE, type WorkerLike as bF, aim as bG, analyzeThreats as bH, angleDiff as bI, angleInRange as bJ, angleTo as bK, applyDamage as bL, applyRulesetOverrides as bM, blink as bN, browserSandboxFight as bO, browserSandboxSimulate as bP, calculateBlinkCooldown as bQ, calculateMissileCastTime as bR, calculateMissileRadius as bS, calculateMissileSimilarity as bT, calculateShieldBlock as bU, calculateWarmupMultiplier as bV, canReplayMatch as bW, cancel as bX, cancelCast as bY, clampPositionToArena as bZ, clampToArena as b_, type StraightParams as ba, TICKS_PER_SECOND as bb, TICK_DURATION_MS as bc, TargetDummy as bd, type TestBotBuilder as be, type TestFightResult as bf, type TestSimulateResult as bg, type TraceBotSummary as bh, type TraceEvent as bi, type TraceEventType as bj, type TraceSummary as bk, Turtle as bl, type Velocity as bm, Voidblade as bn, WARMUP_DURATION_TOLERANCE as bo, WARMUP_MAX_BONUS as bp, WARMUP_MAX_PENALTY as bq, WARMUP_SPEED_TOLERANCE as br, WARMUP_TURN_TOLERANCE as bs, WIZARD_HEALTH as bt, WIZARD_RADIUS as bu, Warmage as bv, type WizardActions as bw, type WizardContext as bx, type WizardDeathEvent as by, type WizardEntry as bz, ARENA_SIZE as c, scoreFight as c$, clearParamValues as c0, completeCast as c1, createBudgetState as c2, createEntitySeed as c3, createFightBudget as c4, createInitialState as c5, createRandom as c6, createWorkerScript as c7, currentRuleset as c8, diagnoseTrace as c9, getWizardContext as cA, hashCombine as cB, homingMissile as cC, idle as cD, inRange as cE, interceptAngle as cF, isBannedBotName as cG, isInLava as cH, magnitude as cI, matchesAnyBanRule as cJ, mayAct as cK, missile as cL, move as cM, moveInDirection as cN, moveProjectile as cO, moveWizard as cP, narrowRange as cQ, nextRandom as cR, normalize as cS, normalizeAngle as cT, predictPosition as cU, recordSpend as cV, resetAllHooks as cW, resetRuleset as cX, resolveWizardCollision as cY, runWithHooks as cZ, runWizardWithContext as c_, directionAway as ca, directionTo as cb, distanceTo as cc, effectiveTurnRateCost as cd, extractAction as ce, extractMissileAction as cf, extractStats as cg, extractTraceEvents as ch, fight as ci, findInRange as cj, findNearest as ck, fitMissileForEscapingTarget as cl, fitMissileToBudget as cm, flyStraight as cn, formatDiagnosis as co, formatStats as cp, formatTraceEvents as cq, formatTraceSummary as cr, generateCandidates as cs, generateCombos as ct, getAdaptiveMissileConfig as cu, getEffectiveRange as cv, getLeadPosition as cw, getMissileCastTime as cx, getMissileContext as cy, getPlayerState as cz, ARENA_WATER_BUFFER as d, scoreFightAsWizard2 as d0, seekerMissile as d1, setParamValues as d2, shield as d3, simulate as d4, simulateMinDuration as d5, sortByDistance as d6, spiralMissile as d7, startCast as d8, startDiscovery as d9, usePosition as dA, useProjectiles as dB, useRandom as dC, useRef as dD, useShieldStrength as dE, useState as dF, useStatus as dG, useThreats as dH, useTick as dI, useTicksUntilReady as dJ, useVelocity as dK, validateHookCall as dL, validateMissileConfig as dM, withMissileContext as dN, withWizardContext as dO, wrapWithParams as dP, stopDiscovery as da, straightMissile as db, summarizeTrace as dc, sweptCircleCollision as dd, testBot as de, tick as df, turnToAngle as dg, turnToward as dh, updateShield as di, useArenaSize as dj, useBlinkCooldown as dk, useCastProgress as dl, useCastingSpell as dm, useClosestThreat as dn, useDamageDealt as dp, useDamageTaken as dq, useEffect as dr, useEnemy as ds, useHealth as dt, useLastHitTick as du, useLastMissileConfig as dv, useMemo as dw, useMyProjectiles as dx, useMyThreatsToEnemy as dy, useParam as dz, type ActionBuilder as e, type AnalyzedThreat as f, Archlich as g, Archmage as h, BLINK_COOLDOWN as i, BLINK_MAX_COOLDOWN as j, BLINK_MAX_RANGE as k, BLINK_MIN_COOLDOWN as l, BLINK_RANGE as m, BOT_GROUPS as n, Battlemage as o, type BlinkEvent as p, Bonemancer as q, type BotBudgetState as r, type BotError as s, BrowserManualMatchSandbox as t, BrowserMatchSandbox as u, type BrowserSandboxOptions as v, type BudgetLimits as w, COLLISION_RADIUS as x, type CastCancelEvent as y, type CastStartEvent as z };
+export { type HookState as $, ALL_BOTS as A, BLINK_CAST_TIME as B, CASTING_MOVEMENT_MULT as C, type CastStartEvent as D, Critter as E, type FightResult as F, DEFAULT_BUDGET as G, DEFAULT_FIGHT_BACKSTOP_MS as H, DEFAULT_SEED as I, Doombringer as J, ENGINE_VERSION as K, EQUIVALENT_ENGINE_VERSIONS as L, type EnemyState as M, FIGHT_SPAWN_DISTANCES as N, type FightBudget as O, type FightStats as P, type FightWinner as Q, type FinalAction as R, type SimulateResult as S, Flamecaller as T, GCD_DURATION as U, type GameConfig as V, type GameState as W, Golem as X, Hero as Y, Hogger as Z, type HomingParams as _, ARENA_MAX as a, type SimEvent as a$, Infernalist as a0, type InternalWizardState as a1, KNOCKBACK_DAMAGE_THRESHOLD as a2, KNOCKBACK_DECAY as a3, KNOCKBACK_DELAY as a4, KNOCKBACK_SPEED_PER_DAMAGE as a5, LAVA_BORDER_WIDTH as a6, Lich as a7, MATCH_DURATION as a8, MAX_HEALTH as a9, type MissileFunction$1 as aA, type MissileHitEvent as aB, type MissileLaunchEvent as aC, type MissileOobEvent as aD, type MissileTemplate as aE, Nightblade as aF, type ParamDeclaration as aG, type Position as aH, type ProjectileState as aI, Pyromancer as aJ, RULES as aK, RULESET_RANGES as aL, type RefObject as aM, Rookie as aN, SHIELD_CAST_TIME as aO, SHIELD_DECAY_PER_SECOND as aP, SHIELD_DECAY_RATE as aQ, SHIELD_MAX_BLOCK as aR, SHIELD_MAX_STRENGTH as aS, SHIELD_MIN_BLOCK as aT, SHIELD_MIN_STRENGTH as aU, SPAWN_DISTANCE as aV, type SeekerParams as aW, Sentinel as aX, Shadowblade as aY, type ShieldBlockEvent as aZ, type ShieldStartEvent as a_, MISSILE_BASE_CAST as aa, MISSILE_BASE_RADIUS as ab, MISSILE_DAMAGE_POWER as ac, MISSILE_DAMAGE_RADIUS_SCALE as ad, MISSILE_DAMAGE_SCALE as ae, MISSILE_HOMING_COEFF as af, MISSILE_MIN_CAST_TIME as ag, MISSILE_MIN_DAMAGE as ah, MISSILE_MIN_DURATION as ai, MISSILE_MIN_SPEED as aj, MISSILE_RADIUS_PER_DAMAGE as ak, MISSILE_SPEED_DURATION_BASELINE as al, MISSILE_SPEED_DURATION_COEFF as am, MISSILE_TURN_DURATION_COEFF as an, MOVEMENT_SPEED as ao, MOVE_SPEED as ap, ManualMatch as aq, type ManualMatchInitOptions as ar, type ManualMatchOptions as as, type ManualMatchStepRequest as at, type MatchWinner as au, type MissileAction as av, type MissileActions as aw, type MissileConfig as ax, type MissileContext as ay, type MissileExpiredEvent as az, ARENA_MIN as b, clampToArena as b$, Spellbinder as b0, Spellseeker as b1, Spellshot as b2, Spellspinner as b3, Spelltracer as b4, Spellweaver as b5, type SpiralParams as b6, type StepResult as b7, Stormcaller as b8, Stormchaser as b9, type WizardEntry as bA, type WizardFunction as bB, type WizardGroup as bC, type WizardLavaDeathEvent as bD, type WizardState as bE, type WorkerFactory as bF, type WorkerLike as bG, aim as bH, analyzeThreats as bI, angleDiff as bJ, angleInRange as bK, angleTo as bL, applyDamage as bM, applyRulesetOverrides as bN, blink as bO, browserSandboxFight as bP, browserSandboxSimulate as bQ, calculateBlinkCooldown as bR, calculateMissileCastTime as bS, calculateMissileRadius as bT, calculateMissileSimilarity as bU, calculateShieldBlock as bV, calculateWarmupMultiplier as bW, canReplayMatch as bX, cancel as bY, cancelCast as bZ, clampPositionToArena as b_, Stormforger as ba, type StraightParams as bb, TICKS_PER_SECOND as bc, TICK_DURATION_MS as bd, TargetDummy as be, type TestBotBuilder as bf, type TestFightResult as bg, type TestSimulateResult as bh, type TraceBotSummary as bi, type TraceEvent as bj, type TraceEventType as bk, type TraceSummary as bl, Turtle as bm, type Velocity as bn, Voidblade as bo, WARMUP_DURATION_TOLERANCE as bp, WARMUP_MAX_BONUS as bq, WARMUP_MAX_PENALTY as br, WARMUP_SPEED_TOLERANCE as bs, WARMUP_TURN_TOLERANCE as bt, WIZARD_HEALTH as bu, WIZARD_RADIUS as bv, Warmage as bw, type WizardActions as bx, type WizardContext as by, type WizardDeathEvent as bz, ARENA_SIZE as c, resolveWizardCollision as c$, clampToSafeZone as c0, clearHooks as c1, clearParamValues as c2, completeCast as c3, createBudgetState as c4, createEntitySeed as c5, createFightBudget as c6, createInitialState as c7, createRandom as c8, createWorkerScript as c9, getMissileContext as cA, getPlayerState as cB, getWizardContext as cC, hashCombine as cD, homingMissile as cE, idle as cF, inRange as cG, interceptAngle as cH, isBannedBotName as cI, isInLava as cJ, magnitude as cK, matchesAnyBanRule as cL, mayAct as cM, missile as cN, move as cO, moveInDirection as cP, moveProjectile as cQ, moveTowardSafely as cR, moveWizard as cS, narrowRange as cT, nextRandom as cU, normalize as cV, normalizeAngle as cW, predictPosition as cX, recordSpend as cY, resetAllHooks as cZ, resetRuleset as c_, currentRuleset as ca, diagnoseTrace as cb, directionAway as cc, directionTo as cd, distanceTo as ce, effectiveTurnRateCost as cf, extractAction as cg, extractMissileAction as ch, extractStats as ci, extractTraceEvents as cj, fight as ck, findInRange as cl, findNearest as cm, fitMissileForEscapingTarget as cn, fitMissileToBudget as co, flyStraight as cp, formatDiagnosis as cq, formatStats as cr, formatTraceEvents as cs, formatTraceSummary as ct, generateCandidates as cu, generateCombos as cv, getAdaptiveMissileConfig as cw, getEffectiveRange as cx, getLeadPosition as cy, getMissileCastTime as cz, ARENA_WATER_BUFFER as d, runWithHooks as d0, runWizardWithContext as d1, scoreFight as d2, scoreFightAsWizard2 as d3, seekerMissile as d4, setParamValues as d5, shield as d6, simulate as d7, simulateMinDuration as d8, sortByDistance as d9, useMyProjectiles as dA, useMyThreatsToEnemy as dB, useParam as dC, usePosition as dD, useProjectiles as dE, useRandom as dF, useRef as dG, useShieldStrength as dH, useState as dI, useStatus as dJ, useThreats as dK, useTick as dL, useTicksUntilReady as dM, useVelocity as dN, validateHookCall as dO, validateMissileConfig as dP, withMissileContext as dQ, withWizardContext as dR, wrapWithParams as dS, spiralMissile as da, startCast as db, startDiscovery as dc, stopDiscovery as dd, straightMissile as de, summarizeTrace as df, sweptCircleCollision as dg, testBot as dh, tick as di, turnToAngle as dj, turnToward as dk, updateShield as dl, useArenaSize as dm, useBlinkCooldown as dn, useCastProgress as dp, useCastingSpell as dq, useClosestThreat as dr, useDamageDealt as ds, useDamageTaken as dt, useEffect as du, useEnemy as dv, useHealth as dw, useLastHitTick as dx, useLastMissileConfig as dy, useMemo as dz, type ActionBuilder as e, type AnalyzedThreat as f, Archlich as g, Archmage as h, BLINK_COOLDOWN as i, BLINK_MAX_COOLDOWN as j, BLINK_MAX_RANGE as k, BLINK_MIN_COOLDOWN as l, BLINK_RANGE as m, BOT_GROUPS as n, Battlemage as o, type BlinkEvent as p, Bonemancer as q, type BotBudgetState as r, type BotError as s, BrowserManualMatchSandbox as t, BrowserMatchSandbox as u, type BrowserSandboxOptions as v, type BudgetExhaustion as w, type BudgetLimits as x, COLLISION_RADIUS as y, type CastCancelEvent as z };

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

package/dist/index-browser.js

@@ -114,6 +114,7 @@ import {
   cancelCast,
   clampPositionToArena,
   clampToArena,
+  clampToSafeZone,
   clearHooks,
   clearParamValues,
   completeCast,
@@ -163,6 +164,7 @@ import {
   move,
   moveInDirection,
   moveProjectile,
+  moveTowardSafely,
   moveWizard,
   narrowRange,
   nextRandom,
@@ -226,7 +228,7 @@ import {
   withMissileContext,
   withWizardContext,
   wrapWithParams
-} from "./chunk-OLGKLCCB.js";
+} from "./chunk-EO7JO2RZ.js";
 export {
   ALL_BOTS,
   ARENA_MAX,
@@ -343,6 +345,7 @@ export {
   cancelCast,
   clampPositionToArena,
   clampToArena,
+  clampToSafeZone,
   clearHooks,
   clearParamValues,
   completeCast,
@@ -392,6 +395,7 @@ export {
   move,
   moveInDirection,
   moveProjectile,
+  moveTowardSafely,
   moveWizard,
   narrowRange,
   nextRandom,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FightResult, S as SimulateResult } from './index-browser-BTHlrB_s.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 BudgetLimits, C as CASTING_MOVEMENT_MULT, x as COLLISION_RADIUS, y as CastCancelEvent, z as CastStartEvent, D as Critter, E as DEFAULT_BUDGET, G as DEFAULT_FIGHT_BACKSTOP_MS, H as DEFAULT_SEED, I as Doombringer, J as ENGINE_VERSION, K as EQUIVALENT_ENGINE_VERSIONS, L as EnemyState, M as FIGHT_SPAWN_DISTANCES, N as FightBudget, O as FightStats, P as FightWinner, Q as FinalAction, R as Flamecaller, T as GCD_DURATION, U as GameConfig, V as GameState, W as Golem, X as Hero, Y as Hogger, Z as HomingParams, _ as HookState, $ as Infernalist, a0 as InternalWizardState, a1 as KNOCKBACK_DAMAGE_THRESHOLD, a2 as KNOCKBACK_DECAY, a3 as KNOCKBACK_DELAY, a4 as KNOCKBACK_SPEED_PER_DAMAGE, a5 as LAVA_BORDER_WIDTH, a6 as Lich, a7 as MATCH_DURATION, a8 as MAX_HEALTH, a9 as MISSILE_BASE_CAST, aa as MISSILE_BASE_RADIUS, ab as MISSILE_DAMAGE_POWER, ac as MISSILE_DAMAGE_RADIUS_SCALE, ad as MISSILE_DAMAGE_SCALE, ae as MISSILE_HOMING_COEFF, af as MISSILE_MIN_CAST_TIME, ag as MISSILE_MIN_DAMAGE, ah as MISSILE_MIN_DURATION, ai as MISSILE_MIN_SPEED, aj as MISSILE_RADIUS_PER_DAMAGE, ak as MISSILE_SPEED_DURATION_BASELINE, al as MISSILE_SPEED_DURATION_COEFF, am as MISSILE_TURN_DURATION_COEFF, an as MOVEMENT_SPEED, ao as MOVE_SPEED, ap as ManualMatch, aq as ManualMatchInitOptions, ar as ManualMatchOptions, as as ManualMatchStepRequest, at as MatchWinner, au as MissileAction, av as MissileActions, aw as MissileConfig, ax as MissileContext, ay as MissileExpiredEvent, az as MissileFunction, aA as MissileHitEvent, aB as MissileLaunchEvent, aC as MissileOobEvent, aD as MissileTemplate, aE as Nightblade, aF as ParamDeclaration, aG as Position, aH as ProjectileState, aI as Pyromancer, aJ as RULES, aK as RULESET_RANGES, aL as RefObject, aM as Rookie, aN as SHIELD_CAST_TIME, aO as SHIELD_DECAY_PER_SECOND, aP as SHIELD_DECAY_RATE, aQ as SHIELD_MAX_BLOCK, aR as SHIELD_MAX_STRENGTH, aS as SHIELD_MIN_BLOCK, aT as SHIELD_MIN_STRENGTH, aU as SPAWN_DISTANCE, aV as SeekerParams, aW as Sentinel, aX as Shadowblade, aY as ShieldBlockEvent, aZ as ShieldStartEvent, a_ as SimEvent, a$ as Spellbinder, b0 as Spellseeker, b1 as Spellshot, b2 as Spellspinner, b3 as Spelltracer, b4 as Spellweaver, b5 as SpiralParams, b6 as StepResult, b7 as Stormcaller, b8 as Stormchaser, b9 as Stormforger, ba as StraightParams, bb as TICKS_PER_SECOND, bc as TICK_DURATION_MS, bd as TargetDummy, be as TestBotBuilder, bf as TestFightResult, bg as TestSimulateResult, bh as TraceBotSummary, bi as TraceEvent, bj as TraceEventType, bk as TraceSummary, bl as Turtle, bm as Velocity, bn as Voidblade, bo as WARMUP_DURATION_TOLERANCE, bp as WARMUP_MAX_BONUS, bq as WARMUP_MAX_PENALTY, br as WARMUP_SPEED_TOLERANCE, bs as WARMUP_TURN_TOLERANCE, bt as WIZARD_HEALTH, bu as WIZARD_RADIUS, bv as Warmage, bw as WizardActions, bx as WizardContext, by as WizardDeathEvent, bz as WizardEntry, bA as WizardFunction, bB as WizardGroup, bC as WizardLavaDeathEvent, bD as WizardState, bE as WorkerFactory, bF as WorkerLike, bG as aim, bH as analyzeThreats, bI as angleDiff, bJ as angleInRange, bK as angleTo, bL as applyDamage, bM as applyRulesetOverrides, bN as blink, bO as browserSandboxFight, bP as browserSandboxSimulate, bQ as calculateBlinkCooldown, bR as calculateMissileCastTime, bS as calculateMissileRadius, bT as calculateMissileSimilarity, bU as calculateShieldBlock, bV as calculateWarmupMultiplier, bW as canReplayMatch, bX as cancel, bY as cancelCast, bZ as clampPositionToArena, b_ as clampToArena, b$ as clearHooks, c0 as clearParamValues, c1 as completeCast, c2 as createBudgetState, c3 as createEntitySeed, c4 as createFightBudget, c5 as createInitialState, c6 as createRandom, c7 as createWorkerScript, c8 as currentRuleset, c9 as diagnoseTrace, ca as directionAway, cb as directionTo, cc as distanceTo, cd as effectiveTurnRateCost, ce as extractAction, cf as extractMissileAction, cg as extractStats, ch as extractTraceEvents, ci as fight, cj as findInRange, ck as findNearest, cl as fitMissileForEscapingTarget, cm as fitMissileToBudget, cn as flyStraight, co as formatDiagnosis, cp as formatStats, cq as formatTraceEvents, cr as formatTraceSummary, cs as generateCandidates, ct as generateCombos, cu as getAdaptiveMissileConfig, cv as getEffectiveRange, cw as getLeadPosition, cx as getMissileCastTime, cy as getMissileContext, cz as getPlayerState, cA as getWizardContext, cB as hashCombine, cC as homingMissile, cD as idle, cE as inRange, cF as interceptAngle, cG as isBannedBotName, cH as isInLava, cI as magnitude, cJ as matchesAnyBanRule, cK as mayAct, cL as missile, cM as move, cN as moveInDirection, cO as moveProjectile, cP as moveWizard, cQ as narrowRange, cR as nextRandom, cS as normalize, cT as normalizeAngle, cU as predictPosition, cV as recordSpend, cW as resetAllHooks, cX as resetRuleset, cY as resolveWizardCollision, cZ as runWithHooks, c_ as runWizardWithContext, c$ as scoreFight, d0 as scoreFightAsWizard2, d1 as seekerMissile, d2 as setParamValues, d3 as shield, d4 as simulate, d5 as simulateMinDuration, d6 as sortByDistance, d7 as spiralMissile, d8 as startCast, d9 as startDiscovery, da as stopDiscovery, db as straightMissile, dc as summarizeTrace, dd as sweptCircleCollision, de as testBot, df as tick, dg as turnToAngle, dh as turnToward, di as updateShield, dj as useArenaSize, dk as useBlinkCooldown, dl as useCastProgress, dm as useCastingSpell, dn as useClosestThreat, dp as useDamageDealt, dq as useDamageTaken, dr as useEffect, ds as useEnemy, dt as useHealth, du as useLastHitTick, dv as useLastMissileConfig, dw as useMemo, dx as useMyProjectiles, dy as useMyThreatsToEnemy, dz as useParam, dA as usePosition, dB as useProjectiles, dC as useRandom, dD as useRef, dE as useShieldStrength, dF as useState, dG as useStatus, dH as useThreats, dI as useTick, dJ as useTicksUntilReady, dK as useVelocity, dL as validateHookCall, dM as validateMissileConfig, dN as withMissileContext, dO as withWizardContext, dP as wrapWithParams } from './index-browser-BTHlrB_s.js';
+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';
 
 /**
  * A compiled bot ready for sandboxed execution.
@@ -43,7 +43,7 @@ declare function compileMatchBundle(bot1: BotBundle, bot2: BotBundle, options?:
  *
  * Safety:
  * - Memory limit (default 512 MB) catches memory bombs
- * - Timeout (default 30s) catches infinite loops
+ * - Timeout (default DEFAULT_FIGHT_BACKSTOP_MS) catches infinite loops
  * - Prototype freeze prevents cross-bot sabotage
  * - platform: 'neutral' strips Node.js APIs (no fs/net/process)
  */
@@ -54,7 +54,13 @@ declare function compileMatchBundle(bot1: BotBundle, bot2: BotBundle, options?:
 interface SandboxOptions {
     /** Memory limit in MB for the isolate (default: 512). */
     memoryLimitMB?: number;
-    /** Timeout in ms for fight/simulate calls (default: 60000). */
+    /**
+     * Timeout in ms for fight/simulate calls. Defaults to DEFAULT_FIGHT_BACKSTOP_MS.
+     *
+     * Named rather than written out, because this file previously gave THREE different
+     * numbers for one default — "30s" in the header, "60000" here, and the actual value used
+     * below — and a reader had no way to tell which was true.
+     */
     timeoutMs?: number;
     /** Options passed to esbuild compilation (aliases, externals). */
     compileOptions?: CompileOptions;

package/dist/index.js

@@ -116,6 +116,7 @@ import {
   cancelCast,
   clampPositionToArena,
   clampToArena,
+  clampToSafeZone,
   clearHooks,
   clearParamValues,
   completeCast,
@@ -168,6 +169,7 @@ import {
   move,
   moveInDirection,
   moveProjectile,
+  moveTowardSafely,
   moveWizard,
   narrowRange,
   nextRandom,
@@ -232,7 +234,7 @@ import {
   withMissileContext,
   withWizardContext,
   wrapWithParams
-} from "./chunk-OLGKLCCB.js";
+} from "./chunk-EO7JO2RZ.js";
 
 // src/engine/sandbox.ts
 import ivm from "isolated-vm";
@@ -256,8 +258,54 @@ Object.freeze(Date.prototype);
 Object.freeze(Error.prototype);
 Object.freeze(Map.prototype);
 Object.freeze(Set.prototype);
+// Math.random is made DETERMINISTIC before Math is frozen.
+//
+// It was live and unseeded, and calling it is a completely natural thing for a bot to write.
+// Rated matches persist only (seed, engineVersion) and spectate RE-SIMULATES, so any bot
+// touching Math.random made the spectator watch a different fight from the one that moved the
+// ratings \u2014 with nothing to fall back on and no warning anywhere. The replay feature only
+// means something if the replay is the same fight.
+//
+// Seeded from a fixed constant rather than the match seed, because this banner runs before
+// any bot code and therefore before the seed exists. That is sufficient: re-simulating the
+// same bundle reproduces the same sequence, which is exactly what replay needs. Bots wanting
+// randomness that VARIES per match still have useRandom(), which is seeded per entity and
+// per tick.
+//
+// Installed with defineProperty and then frozen, so a bot cannot swap it back out \u2014 the same
+// lesson as Date.now, which was writable and let a bot charge its opponent 50 seconds.
+(function() {
+	var state = 0x2F6E2B1 >>> 0;
+	Object.defineProperty(Math, 'random', {
+		value: function() {
+			// xorshift32: small, fast, and good enough for gameplay jitter.
+			state ^= state << 13; state >>>= 0;
+			state ^= state >>> 17;
+			state ^= state << 5; state >>>= 0;
+			return state / 4294967296;
+		},
+		writable: false,
+		configurable: false,
+	});
+})();
 Object.freeze(Math);
 Object.freeze(JSON);
+// The CONSTRUCTORS, not just their prototypes.
+//
+// Freezing Date.prototype left Date.now writable, and an agent used that to charge its
+// OPPONENT 50,000ms of compute: the engine reads Date.now() around each bot call, so a bot
+// that returns 0 for its own pair and a huge number for its victim's drains a budget that is
+// not its own. The victim froze for the rest of the fight and the report stated as fact that
+// it had burned the time.
+//
+// Freezing Number.prototype left Number.isFinite writable, which defeats every input guard in
+// the engine in one line \u2014 move, blink, aim and validateMissileConfig all rely on it.
+Object.freeze(Date);
+Object.freeze(Number);
+Object.freeze(Boolean);
+Object.freeze(String);
+Object.freeze(Array);
+Object.freeze(Object);
 (function() {
 	var g = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : {};
 	var blocked = [
@@ -816,6 +864,7 @@ export {
   cancelCast,
   clampPositionToArena,
   clampToArena,
+  clampToSafeZone,
   clearHooks,
   clearParamValues,
   compileMatchBundle,
@@ -869,6 +918,7 @@ export {
   move,
   moveInDirection,
   moveProjectile,
+  moveTowardSafely,
   moveWizard,
   narrowRange,
   nextRandom,