@vibemancer/core 0.1.0

package/src/bots/homing/02_Lich.ts

@@ -0,0 +1,356 @@
+import {WizardFunction, MissileAIFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {distanceTo} from '../../utils/distance.js';
+import {ARENA_SIZE, GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	getBlinkToCenter,
+	fitMissileToBudget,
+	shouldForceShield,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const WALL_BUFFER = 60;
+
+const SHIELD_BUFFER = 3;
+
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+function isNearWall(position: {x: number; y: number}): boolean 
+{
+	return (
+		position.x < WALL_BUFFER ||
+    position.x > ARENA_SIZE - WALL_BUFFER ||
+    position.y < WALL_BUFFER ||
+    position.y > ARENA_SIZE - WALL_BUFFER
+	);
+}
+
+function smartStrafe(
+	position: {x: number; y: number},
+	enemy: {position: {x: number; y: number}},
+	dodgeDirection: {x: number; y: number} | null,
+	tick: number,
+	strafeCyclePeriod: number,
+	strafeIntensity: number,
+): {x: number; y: number} 
+{
+	const deltaX = enemy.position.x - position.x;
+	const deltaY = enemy.position.y - position.y;
+	const normalizedDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+	if (normalizedDistance === 0) return {x: 0, y: 0};
+
+	const strafeClockwise = {
+		x: -deltaY / normalizedDistance,
+		y: deltaX / normalizedDistance,
+	};
+	const strafeCounterClockwise = {
+		x: deltaY / normalizedDistance,
+		y: -deltaX / normalizedDistance,
+	};
+
+	let strafeDir: {x: number; y: number};
+
+	if (dodgeDirection) 
+	{
+		strafeDir = dodgeDirection;
+	}
+	else if (isNearWall(position)) 
+	{
+		const futureClockwise = {
+			x: position.x + strafeClockwise.x * 100,
+			y: position.y + strafeClockwise.y * 100,
+		};
+		const futureCounterClockwise = {
+			x: position.x + strafeCounterClockwise.x * 100,
+			y: position.y + strafeCounterClockwise.y * 100,
+		};
+		const scoreClockwise = Math.min(
+			futureClockwise.x,
+			ARENA_SIZE - futureClockwise.x,
+			futureClockwise.y,
+			ARENA_SIZE - futureClockwise.y,
+		);
+		const scoreCounterClockwise = Math.min(
+			futureCounterClockwise.x,
+			ARENA_SIZE - futureCounterClockwise.x,
+			futureCounterClockwise.y,
+			ARENA_SIZE - futureCounterClockwise.y,
+		);
+		strafeDir =
+			scoreClockwise > scoreCounterClockwise
+				? strafeClockwise
+				: strafeCounterClockwise;
+	}
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDir = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	const intensity = dodgeDirection ? 100 : strafeIntensity;
+	return {x: strafeDir.x * intensity, y: strafeDir.y * intensity};
+}
+
+/**
+ * Bot: Lich
+ *
+ * BEHAVIOR: Homing missile specialist with strong-tracking adaptive missiles.
+ * Uses fitMissileToBudget with minTurnRate 1.0 — higher than other bots (0.5) —
+ * producing missiles with superior tracking at the cost of some damage/speed.
+ * Strafing launches missiles from different angles, creating multi-angle pressure.
+ *
+ * Shields undodgeable/critical threats, emergency blinks. Cancels missile cast
+ * only for lethal incoming damage.
+ *
+ * KEY DIFFERENCES FROM BONEMANCER:
+ * - Bonemancer: stationary, no defense, fixed d=7/s=3/t=2/dur=300
+ * - Lich: mobile, full defense, adaptive strong-tracking homing missiles
+ *
+ * PROGRESSION LINE: Bonemancer → Lich → Archlich
+ * - Bonemancer (tier 1): Stationary, spams fixed slow homing missiles, no defense
+ * - Lich (tier 2): Mobile + defense, adaptive strong-tracking missiles (minTurnRate 1.0)
+ * - Archlich (tier 3): Future — converging web patterns, impossible to escape
+ *
+ * TIER: 2 (enhanced Bonemancer)
+ */
+export const Lich: WizardFunction = ({state}) => 
+{
+	const targetDistance = useParam('targetDistance', 768, {
+		range: 175,
+		min: 0,
+	});
+	const minTurnRate = useParam('minTurnRate', 0.4, {range: 1.5, steps: 5});
+	const shieldHealthThreshold = useParam('shieldHealthThreshold', 99, {
+		range: 23,
+		min: 1,
+		steps: 7,
+	});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 138, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 100, {
+		range: 40,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 62, {
+		range: 30,
+		min: 10,
+		max: 70,
+		steps: 7,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 7, {
+		range: 30,
+		min: 5,
+		max: 80,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 27, {
+		range: 30,
+		min: 15,
+		max: 80,
+		steps: 7,
+	});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 5.8, {
+		range: 4,
+		min: 2,
+		max: 12,
+		steps: 5,
+	});
+
+	const enemy = state.enemies[0];
+	if (!enemy) 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	const distance = distanceTo(state.position, enemy.position);
+
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const strafe = smartStrafe(
+		state.position,
+		enemy,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+	);
+
+	// Distance management (retreat if too close, approach if too far)
+	let moveX = strafe.x;
+	let moveY = strafe.y;
+
+	if (!dodgeDirection) 
+	{
+		const deltaX = enemy.position.x - state.position.x;
+		const deltaY = enemy.position.y - state.position.y;
+		const normalizedDistance = distance > 0 ? distance : 1;
+
+		if (distance > targetDistance + distanceDeadZone) 
+		{
+			moveX += (deltaX / normalizedDistance) * approachSpeed;
+			moveY += (deltaY / normalizedDistance) * approachSpeed;
+		}
+		else if (distance < targetDistance - distanceDeadZone) 
+		{
+			moveX -= (deltaX / normalizedDistance) * approachSpeed;
+			moveY -= (deltaY / normalizedDistance) * approachSpeed;
+		}
+	}
+
+	const magnitude = Math.sqrt(moveX * moveX + moveY * moveY);
+	if (magnitude > 100) 
+	{
+		moveX = (moveX / magnitude) * 100;
+		moveY = (moveY / magnitude) * 100;
+	}
+
+	const move = {x: moveX, y: moveY};
+
+	// === DEFENSE: Handle channeling ===
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Cancel missile cast only for LETHAL incoming damage ===
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    urgentThreat &&
+    urgentThreat.projectile.damage >= state.health
+	) 
+	{
+		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		if (
+			urgentThreat.ticksToImpact <=
+      remainingCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER
+		) 
+		{
+			return {move, cancel: true};
+		}
+	}
+
+	// === BLINK: Dodge missile + reposition (first priority) ===
+	// Blink dodges the incoming missile — no GCD after, so can immediately resume casting.
+	// Only shield when blink is on cooldown.
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    state.blinkCooldown === 0 &&
+    urgentThreat.ticksToImpact >= 10 &&
+    urgentThreat.ticksToImpact <= blinkWindowMax
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+		};
+	}
+
+	// === DEFENSE: Shield threats (when blink on cooldown) ===
+	// Shield undodgeable, high-damage homing, or when health is critical
+	if (state.state === 'idle' && urgentThreat) 
+	{
+		const forceShield = shouldForceShield(urgentThreat);
+		const undodgeable = !urgentThreat.bestDodgeDirection;
+		const healthLow = state.health < shieldHealthThreshold;
+		const healthCritical =
+			state.health <= urgentThreat.projectile.damage * 2 + 1;
+		const doShield =
+			forceShield || (undodgeable && healthLow) || healthCritical;
+
+		if (
+			doShield &&
+      urgentThreat.canBlockInTime &&
+      urgentThreat.ticksToStartShield <= SHIELD_BUFFER
+		) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+	}
+
+	// === OFFENSE: Adaptive strong-tracking homing missiles ===
+	// minTurnRate 1.0 gives better tracking than other bots (0.5) at the cost of damage/speed.
+	// Skip offense when a lethal missile could reach us during cast+GCD — dodge at full speed instead
+	const myProjectileIds = new Set(state.myProjectiles.map((p) => p.id));
+	const hasNearbyLethalMissile = state.projectiles.some(
+		(p) =>
+			!myProjectileIds.has(p.id) &&
+      p.damage >= state.health &&
+      distanceTo(state.position, p.position) / p.speed <
+        MAX_CAST_BUDGET + GCD_DURATION,
+	);
+	if (state.state === 'idle' && !hasNearbyLethalMissile) 
+	{
+		let nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+
+		// Account for enemy's active cast — their missile will arrive after cast completes + flight time
+		if (enemy.state === 'casting' && enemy.castingSpell === 'missile') 
+		{
+			const remainingEnemyCast =
+				(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
+			const estimatedFlightTime = distance / flightTimeDivisor;
+			nextThreatTime = Math.min(
+				nextThreatTime,
+				remainingEnemyCast + estimatedFlightTime,
+			);
+		}
+
+		const safeBudget =
+			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
+
+		// Lich specializes in strong tracking (minTurnRate 1.0 vs typical 0.5)
+		const enemyHP = Math.ceil(enemy.health);
+		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
+		const config = fitMissileToBudget(budgetTicks, distance, {
+			minTurnRate,
+			lastMissileConfig: state.lastMissileConfig,
+		});
+
+		if (config && config.damage >= minDmg) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Budget too small for useful missile — wait for threat to pass, then fire
+	}
+
+	return {move};
+};

package/src/bots/homing/03_Archlich.ts

@@ -0,0 +1,220 @@
+import {WizardFunction, MissileAIFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {distanceTo} from '../../utils/distance.js';
+import {ARENA_SIZE, GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	getBlinkToCenter,
+	fitMissileToBudget,
+	shouldForceShield,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+	getEnemyVulnerabilityTicks,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const WALL_BUFFER = 60;
+const SHIELD_BUFFER = 3;
+
+const HomingAI: MissileAIFunction = ({worldState}) =>
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+const StraightAI: MissileAIFunction = () => ({});
+
+function isNearWall(position: {x: number; y: number}): boolean
+{
+	return (
+		position.x < WALL_BUFFER ||
+    position.x > ARENA_SIZE - WALL_BUFFER ||
+    position.y < WALL_BUFFER ||
+    position.y > ARENA_SIZE - WALL_BUFFER
+	);
+}
+
+function smartStrafe(
+	position: {x: number; y: number},
+	enemy: {position: {x: number; y: number}},
+	dodgeDirection: {x: number; y: number} | null,
+	tick: number,
+	strafeCyclePeriod: number,
+	strafeIntensity: number,
+): {x: number; y: number}
+{
+	const deltaX = enemy.position.x - position.x;
+	const deltaY = enemy.position.y - position.y;
+	const normalizedDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+	if (normalizedDistance === 0) return {x: 0, y: 0};
+
+	const cw = {x: -deltaY / normalizedDistance, y: deltaX / normalizedDistance};
+	const ccw = {x: deltaY / normalizedDistance, y: -deltaX / normalizedDistance};
+
+	let dir: {x: number; y: number};
+
+	if (dodgeDirection)
+	{
+		dir = dodgeDirection;
+	}
+	else if (isNearWall(position))
+	{
+		const fCw = {x: position.x + cw.x * 100, y: position.y + cw.y * 100};
+		const fCcw = {x: position.x + ccw.x * 100, y: position.y + ccw.y * 100};
+		const sCw = Math.min(fCw.x, ARENA_SIZE - fCw.x, fCw.y, ARENA_SIZE - fCw.y);
+		const sCcw = Math.min(fCcw.x, ARENA_SIZE - fCcw.x, fCcw.y, ARENA_SIZE - fCcw.y);
+		dir = sCw > sCcw ? cw : ccw;
+	}
+	else
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		dir = cycle === 0 ? cw : ccw;
+	}
+
+	const intensity = dodgeDirection ? 100 : strafeIntensity;
+	return {x: dir.x * intensity, y: dir.y * intensity};
+}
+
+/**
+ * Bot: Archlich
+ *
+ * BEHAVIOR: Lich's proven core (mobile homing specialist) plus vulnerability
+ * exploitation. Defense, movement, and standard offense are identical to Lich.
+ * The T3 advantage: when the enemy is locked in GCD/cast, fires fast straight
+ * punish missiles that land during the vulnerability window.
+ *
+ * PROGRESSION LINE: Bonemancer → Lich → Archlich
+ * TIER: 3 (elite Homing line)
+ */
+export const Archlich: WizardFunction = ({state}) =>
+{
+	// Same params as Lich — Archlich is Lich + punish mode (disabled by default, optimizer tunes)
+	const targetDistance = useParam('targetDistance', 737, {range: 175, min: 0});
+	const minTurnRate = useParam('minTurnRate', 0.4, {range: 1.5, steps: 5});
+	const shieldHealthThreshold = useParam('shieldHealthThreshold', 99, {range: 23, min: 1, steps: 7});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 300, {range: 75, min: 80, max: 300});
+	const strafeIntensity = useParam('strafeIntensity', 96, {range: 40, min: 20, max: 100, steps: 7});
+	const approachSpeed = useParam('approachSpeed', 65, {range: 30, min: 10, max: 70, steps: 7});
+	const distanceDeadZone = useParam('distanceDeadZone', 7, {range: 30, min: 5, max: 80, steps: 7});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {range: 75, min: 50, max: 300});
+	const blinkWindowMax = useParam('blinkWindowMax', 38, {range: 30, min: 15, max: 80, steps: 7});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 5.8, {range: 4, min: 2, max: 12, steps: 5});
+	const punishMinVulnerability = useParam('punishMinVulnerability', 500, {range: 80, min: 30, steps: 7});
+
+	const enemy = state.enemies[0];
+	if (!enemy) return {move: {x: 0, y: 0}};
+
+	const distance = distanceTo(state.position, enemy.position);
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const strafe = smartStrafe(state.position, enemy, dodgeDirection, state.tick, strafeCyclePeriod, strafeIntensity);
+
+	let moveX = strafe.x;
+	let moveY = strafe.y;
+	if (!dodgeDirection)
+	{
+		const dx = enemy.position.x - state.position.x;
+		const dy = enemy.position.y - state.position.y;
+		const nd = distance > 0 ? distance : 1;
+		if (distance > targetDistance + distanceDeadZone)
+		{
+			moveX += (dx / nd) * approachSpeed;
+			moveY += (dy / nd) * approachSpeed;
+		}
+		else if (distance < targetDistance - distanceDeadZone)
+		{
+			moveX -= (dx / nd) * approachSpeed;
+			moveY -= (dy / nd) * approachSpeed;
+		}
+	}
+	const mag = Math.sqrt(moveX * moveX + moveY * moveY);
+	if (mag > 100) 
+	{
+		moveX = (moveX / mag) * 100; moveY = (moveY / mag) * 100; 
+	}
+	const move = {x: moveX, y: moveY};
+
+	// === DEFENSE: identical to Lich ===
+	if (state.state === 'channeling')
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) return {move, cancel: true};
+		return {move: {x: 0, y: 0}};
+	}
+
+	if (state.state === 'casting' && state.castingSpell === 'missile' && urgentThreat && urgentThreat.projectile.damage >= state.health)
+	{
+		const rem = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		if (urgentThreat.ticksToImpact <= rem + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER) return {move, cancel: true};
+	}
+
+	if (state.state === 'idle' && urgentThreat && state.blinkCooldown === 0 && urgentThreat.ticksToImpact >= 10 && urgentThreat.ticksToImpact <= blinkWindowMax)
+	{
+		return {move: {x: 0, y: 0}, startCast: {spell: 'blink', target: getBlinkToCenter(state.position)}};
+	}
+
+	if (state.state === 'idle' && urgentThreat)
+	{
+		const forceShield = shouldForceShield(urgentThreat);
+		const undodgeable = !urgentThreat.bestDodgeDirection;
+		const healthLow = state.health < shieldHealthThreshold;
+		const healthCritical = state.health <= urgentThreat.projectile.damage * 2 + 1;
+		if ((forceShield || (undodgeable && healthLow) || healthCritical) && urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= SHIELD_BUFFER)
+		{
+			return {move: {x: 0, y: 0}, startCast: {spell: 'shield'}};
+		}
+	}
+
+	// === OFFENSE ===
+	const myIds = new Set(state.myProjectiles.map((p) => p.id));
+	const hasLethal = state.projectiles.some((p) => !myIds.has(p.id) && p.damage >= state.health && distanceTo(state.position, p.position) / p.speed < MAX_CAST_BUDGET + GCD_DURATION);
+	if (state.state === 'idle' && !hasLethal)
+	{
+		const enemyHP = Math.ceil(enemy.health);
+
+		// T3 PUNISH: fast straight missiles during vulnerability
+		const vulnTicks = getEnemyVulnerabilityTicks(enemy);
+		if (vulnTicks >= punishMinVulnerability && distance < 300)
+		{
+			const flight = distance / flightTimeDivisor;
+			const pBudget = vulnTicks - flight;
+			const ntt = urgentThreat?.ticksToImpact ?? Infinity;
+			const sBudget = ntt - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+			const eBudget = Math.min(pBudget, sBudget, MAX_CAST_BUDGET);
+			if (eBudget > 0)
+			{
+				const cfg = fitMissileToBudget(eBudget, distance, {minTurnRate: 0, maxDamage: enemyHP, lastMissileConfig: state.lastMissileConfig});
+				if (cfg && cfg.damage >= MIN_USEFUL_DAMAGE)
+				{
+					const ct = getMissileCastTime(cfg, state.lastMissileConfig);
+					if (ct + distance / cfg.speed < vulnTicks)
+					{
+						const aim = cfg.turnRate > 0 ? enemy.position : getLeadPosition(enemy.position, enemy.velocity, cfg.speed, state.position);
+						return {move, startCast: {spell: 'missile', config: cfg, missileAI: cfg.turnRate > 0 ? HomingAI : StraightAI, direction: angleTo(state.position, aim)}};
+					}
+				}
+			}
+		}
+
+		// STANDARD MODE: identical to Lich
+		let ntt = urgentThreat?.ticksToImpact ?? Infinity;
+		if (enemy.state === 'casting' && enemy.castingSpell === 'missile')
+		{
+			const rem = (enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
+			ntt = Math.min(ntt, rem + distance / flightTimeDivisor);
+		}
+		const sBudget = ntt - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+		const budget = Math.min(sBudget, MAX_CAST_BUDGET);
+		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
+		const cfg = fitMissileToBudget(budget, distance, {minTurnRate, lastMissileConfig: state.lastMissileConfig});
+		if (cfg && cfg.damage >= minDmg)
+		{
+			return {move, startCast: {spell: 'missile', config: cfg, missileAI: HomingAI, direction: angleTo(state.position, enemy.position)}};
+		}
+	}
+
+	return {move};
+};

package/src/bots/index.ts

@@ -0,0 +1,30 @@
+export * from './standalone/TargetDummy.js';
+export * from './standalone/Rookie.js';
+export * from './standalone/Critter.js';
+export * from './standalone/Hogger.js';
+export * from './standalone/Doombringer.js';
+export * from './defensive/01_Turtle.js';
+export * from './defensive/02_Sentinel.js';
+export * from './defensive/03_Golem.js';
+export * from './melee/01_Shadowblade.js';
+export * from './melee/02_Nightblade.js';
+export * from './melee/03_Voidblade.js';
+export * from './homing/01_Bonemancer.js';
+export * from './homing/02_Lich.js';
+export * from './homing/03_Archlich.js';
+export * from './caster/01_Flamecaller.js';
+export * from './caster/02_Pyromancer.js';
+export * from './caster/03_Infernalist.js';
+export * from './sniper/01_Spellshot.js';
+export * from './sniper/02_Spelltracer.js';
+export * from './sniper/03_Spellseeker.js';
+export * from './duelist/01_Battlemage.js';
+export * from './duelist/02_Warmage.js';
+export * from './duelist/03_Archmage.js';
+export * from './berserker/01_Stormchaser.js';
+export * from './berserker/02_Stormcaller.js';
+export * from './berserker/03_Stormforger.js';
+export * from './kiter/01_Spellspinner.js';
+export * from './kiter/02_Spellweaver.js';
+export * from './kiter/03_Spellbinder.js';
+export * from './registry.js';