Function bodies 443 total

function candidateInsanity(c: SlotCandidate): number {
  let insanity = sumStatFromSources("insanity", c.enchantment, c.modifier, c.gems);
  if (c.modifier?.atlanteanBehavior != null) {
    insanity += c.modifier.atlanteanBehavior.insanity;
  }
  return insanity;
}

function insanityWithinBudget(
  c: SlotCandidate,
  currentStats: Stats,
  maxUnwardedInsanity: number,
): boolean {
  const newInsanity = currentStats.insanity + candidateInsanity(c);
  const newWarding = currentStats.warding + candidateWarding(c);
  return newInsanity <= Math.max(newWarding, maxUnwardedInsanity);
}

  tryInsert(result: SearchResult): void {
    if (
      this.results.length >= this.maxResults &&
      result.score <= this.worstScore
    ) {
      return;
    }
    const insertIdx = this.findInsertionIndex(result.score);
    this.results.splice(insertIdx, 0, result);
    if (this.results.length > this.maxResults) {
      this.results.pop();
    }
  }

  private findInsertionIndex(score: number): number {
    let lo = 0;
    let hi = this.results.length;
    while (lo < hi) {
      const mid = (lo + hi) >>> 1;
      const midResult = this.results[mid];
      if (midResult != null && midResult.score > score) {
        lo = mid + 1;
      } else {
        hi = mid;
      }
    }
    return lo;
  }

export function* generateAccessoryCombinations(
  accessories: readonly EquipmentPiece[],
  constraints: HardConstraints,
): Generator<
  readonly [EquipmentPiece, EquipmentPiece, EquipmentPiece]
> {
  const n = accessories.length;
  for (let i = 0; i < n; i++) {
    for (let j = i + 1; j < n; j++) {
      for (let k = j + 1; k < n; k++) {
        const a = accessories[i];
        const b = accessories[j];
        const c = accessories[k];
        if (a == null || b == null || c == null) continue;
        if (isValidAccTriplet([a, b, c], constraints)) {
          yield [a, b, c] as const;
        }
      }
    }
  }
}

function isValidAccTriplet(
  triplet: readonly [EquipmentPiece, EquipmentPiece, EquipmentPiece],
  constraints: HardConstraints,
): boolean {
  let helmets = 0;
  let amulets = 0;
  for (const piece of triplet) {
    if (piece.slot === "accessory-H") helmets++;
    if (piece.slot === "accessory-A") amulets++;
  }
  return (
    helmets <= constraints.maxHelmetAccessories &&
    amulets <= constraints.maxAmuletAccessories
  );
}

function buildBareLoadout(
  chest: EquipmentPiece,
  legs: EquipmentPiece,
  acc: readonly [EquipmentPiece, EquipmentPiece, EquipmentPiece],
): Loadout {
  return {
    slots: [
      bareSlot(chest),
      bareSlot(legs),
      bareSlot(acc[0]),
      bareSlot(acc[1]),
      bareSlot(acc[2]),
    ],
  };
}

function scoreLoadout(input: ScoreInput): SearchResult | null {
  const { loadout, constraints, fitness, atlanteanChoices, scoringMode, statWeights } = input;
  const validation = validateLoadout(loadout, constraints);
  if (!validation.valid) return null;

  const stats: Stats = computeLoadoutStats(loadout, atlanteanChoices);
  const score = computeFitness(stats, fitness, scoringMode, statWeights);
  if (score === -Infinity) return null;

  return { loadout, score, stats, atlanteanChoices };
}

function enhanceLoadout(
  loadout: Loadout,
  config: EnhanceConfig,
): EnhancedLoadoutResult {
  const { pool, constraints, fitness, scoringMode, statWeights } = config;
  return budgetAwareAssign({
    loadout,
    pool,
    hardConstraints: constraints,
    fitness,
    scoringMode,
    statWeights,
  });
}

function processCombo(
  bareLoadout: Loadout,
  enhanceConfig: EnhanceConfig,
  tracker: TopNTracker,
): void {
  const enhanced = enhanceLoadout(bareLoadout, enhanceConfig);
  const result = scoreLoadout({
    loadout: enhanced.loadout,
    constraints: enhanceConfig.constraints,
    fitness: enhanceConfig.fitness,
    atlanteanChoices: enhanced.atlanteanChoices,
    scoringMode: enhanceConfig.scoringMode,
    statWeights: enhanceConfig.statWeights,
  });
  if (result != null) tracker.tryInsert(result);
}

async function runSearchLoop(
  params: SearchLoopParams,
  config: SearchLoopConfig,
  onProgress: ((checked: number, total: number, best: number, results: readonly SearchResult[]) => void) | undefined,
): Promise<void> {
  const { gearPool, constraints, fitness, scoringMode, statWeights } = params;
  const { tracker, token, deadline, total } = config;
  const enhanceConfig: EnhanceConfig = {
    pool: gearPool, constraints, fitness, scoringMode, statWeights,
  };
  let checked = 0;

  for (const chest of gearPool.chestplates) {
    for (const legs of gearPool.leggings) {
      const accGen = generateAccessoryCombinations(gearPool.accessories, constraints);
      for (const acc of accGen) {
        if (token.cancelled || (deadline != null && Date.now() > deadline)) {
          // Report final progress before early exit so bar reaches end
          emitProgress(onProgress, total, total, tracker);
          return;
        }

        processCombo(buildBareLoadout(chest, legs, acc), enha

function emitProgress(
  cb: ((checked: number, total: number, best: number, results: readonly SearchResult[]) => void) | undefined,
  checked: number,
  total: number,
  tracker: TopNTracker,
): void {
  if (cb == null) return;
  const results = tracker.getResults();
  const best = results[0];
  cb(checked, total, best?.score ?? -Infinity, results);
}

  async search(
    gearPool: GearPool,
    constraints: HardConstraints,
    fitness: readonly SoftConstraint[],
    options: SearchOptions,
  ): Promise<readonly SearchResult[]> {
    this.token.cancelled = false;
    const tracker = new TopNTracker(options.maxResults);
    const total = countCombinations(gearPool);
    const deadline = options.timeout != null
      ? Date.now() + options.timeout
      : undefined;

    await runSearchLoop(
      { gearPool, constraints, fitness, scoringMode: options.scoringMode, statWeights: options.statWeights },
      { tracker, token: this.token, deadline, total },
      this.onProgress,
    );

    return tracker.getResults();
  }

function addStats(
  base: Partial<Stats>,
  addition: Partial<Stats>,
): Partial<Stats> {
  const result: Partial<Stats> = { ...base };
  for (const stat of STAT_NAMES) {
    const addValue = addition[stat];
    if (addValue !== undefined) {
      result[stat] = (result[stat] ?? 0) + addValue;
    }
  }
  return result;
}

function expandSingleItem(
  item: EquipmentPiece,
  enabledVariants: ReadonlySet<string>,
): ExpandedEquipment[] {
  const results: ExpandedEquipment[] = [];

  // Always include base-only candidate (no variant)
  results.push({
    ...item,
    appliedVariant: undefined,
    effectiveStats: item.baseStats,
  });

  // If item has variants, add candidates for each enabled variant
  if (item.variants) {
    for (const [variantName, variantStats] of Object.entries(item.variants)) {
      if (enabledVariants.has(variantName)) {
        results.push({
          ...item,
          appliedVariant: variantName,
          effectiveStats: addStats(item.baseStats, variantStats),
        });
      }
    }
  }

  return results;
}

export function expandEquipment(
  items: readonly EquipmentPiece[],
  enabledVariants: ReadonlySet<string>,
): readonly ExpandedEquipment[] {
  return items.flatMap((item) => expandSingleItem(item, enabledVariants));
}

export function getAvailableVariants(
  items: readonly EquipmentPiece[],
): ReadonlySet<string> {
  const variants = new Set<string>();
  for (const item of items) {
    if (item.variants) {
      for (const variantName of Object.keys(item.variants)) {
        variants.add(variantName);
      }
    }
  }
  return variants;
}

function scoreAtLeast(val: number, weight: number, value: number): number {
  if (val < value) {
    return -((value - val) * weight * 10);
  }
  // Cap bonus at 1× weight to prevent dominating other constraints
  return Math.min((val - value) * weight * 0.1, weight);
}

function scoreAtMost(
  val: number,
  _weight: number,
  value: number,
): number | null {
  // Value is a hard limit - exceeding disqualifies the loadout
  if (val > value) return null;
  return 0;
}

function scoreBetween(
  val: number,
  weight: number,
  min: number,
  max: number | undefined,
): number {
  const effectiveMax = max ?? Infinity;
  if (val < min) {
    return -((min - val) * weight * 10);
  }
  if (val > effectiveMax) {
    return -((val - effectiveMax) * weight * 10);
  }
  return 0;
}

export function checkHardConstraints(
  stats: Stats,
  constraints: readonly SoftConstraint[],
  scoringMode: ScoringMode = "linear",
): boolean {
  for (const c of constraints) {
    const val = stats[c.stat];
    const target = c.value ?? 0;

    // atMost is always a hard constraint (exceeding limit = disqualified)
    if (c.type === "atMost" && val > target) return false;

    // atLeast is only hard in efficiency/multiplier modes
    // In linear mode, it's a soft penalty handled by scoreAtLeast
    if (scoringMode !== "linear" && c.type === "atLeast" && val < target) {
      return false;
    }
  }
  return true;
}

function computeLinearScore(
  stats: Stats,
  constraints: readonly SoftConstraint[],
): number {
  let score = 0;

  for (const c of constraints) {
    const val = stats[c.stat];
    const value = c.value ?? 0;

    // Guard against invalid constraint types (can happen with corrupted localStorage)
    const constraintType = c.type as unknown;
    if (typeof constraintType !== "string" || !(constraintType in SCORERS)) {
      throw new Error(
        `Invalid constraint type "${c.type}" for stat "${c.stat}". ` +
        `Try clearing site data (Settings → Clear Local Data).`
      );
    }

    const scorer = SCORERS[c.type];
    const result = scorer(val, c.weight, value, c.hardCap);

    if (result === null) return -Infinity;
    score += result;
  }

  return score;
}

export function computeFitness(
  stats: Stats,
  constraints: readonly SoftConstraint[],
  scoringMode: ScoringMode = "linear",
  statWeights: Readonly<Record<StatName, number>> = DEFAULT_STAT_WEIGHTS,
): number {
  // Hard constraints check (mode-aware)
  if (!checkHardConstraints(stats, constraints, scoringMode)) {
    return -Infinity;
  }

  // Mode-specific scoring
  if (scoringMode === "efficiency") {
    return computeEfficiencyScore(stats, statWeights);
  }
  if (scoringMode === "multiplier") {
    return computeMultiplierScore(stats, statWeights);
  }

  // Linear mode: constraint-based scoring
  return computeLinearScore(stats, constraints);
}

export function buildIndexedPool(pool: GearPool): IndexedPool {
  return {
    chestplates: pool.chestplates,
    leggings: pool.leggings,
    accessories: pool.accessories,
    armorEnchantments: pool.enchantments.filter((e) => e.applicableTo.includes("armor")),
    accessoryEnchantments: pool.enchantments.filter((e) => e.applicableTo.includes("accessory")),
    modifiers: pool.modifiers,
    setModifierIndices: pool.modifiers
      .map((m, i) => (m.atlanteanBehavior != null ? i : -1))
      .filter((i) => i >= 0),
    gems: pool.gems,
  };
}

function pickRandomModIdx(
  piece: EquipmentPiece | undefined,
  pool: IndexedPool,
): number {
  if (piece?.atlanteanOnly !== false) {
    const valid = pool.setModifierIndices;
    if (valid.length === 0) return -1;
    const r = randInt(valid.length + 1) - 1;
    return r < 0 ? -1 : valid[r] ?? -1;
  }
  return randInt(pool.modifiers.length + 1) - 1;
}

function resolveSlot(
  params: ResolveSlotParams,
  atlanteanMap: Map<number, StatName>,
): EquippedSlot {
  const { piece, slotIdx, chromo, pool } = params;
  const enchPool = getEnchantPool(slotIdx, pool);
  const eIdx = chromo.enchantIndices[slotIdx] ?? -1;
  const mIdx = chromo.modIndices[slotIdx] ?? -1;
  const enchantment = eIdx >= 0 ? enchPool[eIdx] : undefined;
  const rawModifier = mIdx >= 0 ? pool.modifiers[mIdx] : undefined;
  // Atlantean-only pieces cannot have regular modifiers
  const modifier = (piece.atlanteanOnly !== false && rawModifier?.atlanteanBehavior == null)
    ? undefined
    : rawModifier;

  const gems = resolveGems(piece, modifier, chromo.gemIndices[slotIdx] ?? [], pool);
  const slot: EquippedSlot = { piece, enchantment, modifier, gems };

  resolveAtlanteanSlot(slot, slotIdx, atlanteanMap);
  return slot;
}

function resolveGems(
  piece: EquipmentPiece,
  modifier: Modifier | undefined,
  slotGemIndices: readonly number[],
  pool: IndexedPool,
): Gem[] {
  const socketCount = piece.socketCount + (modifier?.grantsSocket === true ? 1 : 0);
  const gems: Gem[] = [];
  for (let s = 0; s < Math.min(slotGemIndices.length, socketCount); s++) {
    const gIdx = slotGemIndices[s] ?? -1;
    if (gIdx >= 0) {
      const gem = pool.gems[gIdx];
      if (gem != null) gems.push(gem);
    }
  }
  return gems;
}

function resolveAtlanteanSlot(
  slot: EquippedSlot,
  slotIdx: number,
  atlanteanMap: Map<number, StatName>,
): void {
  const chosen = getAtlanteanBonusStat(slot);
  if (chosen != null) atlanteanMap.set(slotIdx, chosen);
}

function resolvePieces(
  chromo: Chromosome,
  pool: IndexedPool,
): readonly EquipmentPiece[] | null {
  const chest = pool.chestplates[chromo.chestIdx];
  const legs = pool.leggings[chromo.legsIdx];
  if (chest == null || legs == null) return null;

  const acc0 = pool.accessories[chromo.accIndices[0]];
  const acc1 = pool.accessories[chromo.accIndices[1]];
  const acc2 = pool.accessories[chromo.accIndices[2]];
  if (acc0 == null || acc1 == null || acc2 == null) return null;

  return [chest, legs, acc0, acc1, acc2];
}

export function evaluate(options: EvaluateOptions): EvaluatedIndividual | null {
  const { chromo, pool, constraints, fitness, scoringMode = "linear", statWeights } = options;
  const decoded = decodeChromosome(chromo, pool);
  if (decoded == null) return null;

  const validation = validateLoadout(decoded.loadout, constraints);
  if (!validation.valid) return null;

  const stats = computeLoadoutStats(decoded.loadout, decoded.atlanteanMap);
  const score = computeFitness(stats, fitness, scoringMode, statWeights);
  if (score === -Infinity) return null;

  return {
    chromosome: chromo,
    score,
    loadout: decoded.loadout,
    stats,
    atlanteanMap: decoded.atlanteanMap,
  };
}

function pickDistinct(count: number, max: number): number[] {
  if (max < count) return Array.from({ length: count }, (_, i) => i % max);
  const result: number[] = [];
  const used = new Set<number>();
  while (result.length < count) {
    const v = randInt(max);
    if (!used.has(v)) { used.add(v); result.push(v); }
  }
  return result;
}

export function randomChromosome(pool: IndexedPool): Chromosome {
  const chestIdx = randInt(pool.chestplates.length);
  const legsIdx = randInt(pool.leggings.length);
  const accArr = pickDistinct(3, pool.accessories.length);
  const accIndices: [number, number, number] = [accArr[0] ?? 0, accArr[1] ?? 0, accArr[2] ?? 0];

  const enchantIndices: [number, number, number, number, number] = [0, 0, 0, 0, 0];
  const modIndices: [number, number, number, number, number] = [0, 0, 0, 0, 0];
  const gemIndices: number[][] = [];

  const pieces = [
    pool.chestplates[chestIdx],
    pool.leggings[legsIdx],
    pool.accessories[accIndices[0]],
    pool.accessories[accIndices[1]],
    pool.accessories[accIndices[2]],
  ];

  for (let i = 0; i < 5; i++) {
    const sg = randomSlotGenes(pieces[i], i, pool);
    enchantIndices[i] = sg.enchIdx;
    modIndices[i] = sg.modIdx;
    gemIndices.push(sg.gems);
  }

  return { chestIdx, legsIdx, accIndices, enchantIndices, modIndices, gemIndices };
}

export function uniformCrossover(
  a: Chromosome,
  b: Chromosome,
): [Chromosome, Chromosome] {
  const c1 = structuredClone(a);
  const c2 = structuredClone(b);
  swapEquipmentGenes(c1, c2, a, b);
  swapSlotGenes(c1, c2, a, b);
  return [c1, c2];
}

function swapEquipmentGenes(
  c1: Chromosome,
  c2: Chromosome,
  a: Chromosome,
  b: Chromosome,
): void {
  if (Math.random() < 0.5) { c1.chestIdx = b.chestIdx; c2.chestIdx = a.chestIdx; }
  if (Math.random() < 0.5) { c1.legsIdx = b.legsIdx; c2.legsIdx = a.legsIdx; }
  for (let i = 0; i < 3; i++) {
    if (Math.random() < 0.5) {
      c1.accIndices[i] = b.accIndices[i] ?? 0;
      c2.accIndices[i] = a.accIndices[i] ?? 0;
    }
  }
}

function swapSlotGenes(
  c1: Chromosome,
  c2: Chromosome,
  a: Chromosome,
  b: Chromosome,
): void {
  for (let i = 0; i < 5; i++) {
    if (Math.random() < 0.5) {
      c1.enchantIndices[i] = b.enchantIndices[i] ?? -1;
      c2.enchantIndices[i] = a.enchantIndices[i] ?? -1;
    }
    if (Math.random() < 0.5) {
      c1.modIndices[i] = b.modIndices[i] ?? -1;
      c2.modIndices[i] = a.modIndices[i] ?? -1;
    }
  }
}

export function mutate(chromo: Chromosome, pool: IndexedPool): void {
  const gene = randInt(6);
  if (gene === 0) { chromo.chestIdx = randInt(pool.chestplates.length); return; }
  if (gene === 1) { chromo.legsIdx = randInt(pool.leggings.length); return; }
  if (gene === 2) { chromo.accIndices[randInt(3)] = randInt(pool.accessories.length); return; }
  mutateSlotGene(chromo, gene, pool);
}

function mutateSlotGene(chromo: Chromosome, gene: number, pool: IndexedPool): void {
  const slot = randInt(5);
  if (gene === 3) {
    chromo.enchantIndices[slot] = randInt(getEnchantPool(slot, pool).length + 1) - 1;
  } else if (gene === 4) {
    const piece = getPieceForSlot(chromo, slot, pool);
    chromo.modIndices[slot] = pickRandomModIdx(piece, pool);
  } else {
    const slotGems = chromo.gemIndices[slot];
    if (slotGems != null && slotGems.length > 0) {
      slotGems[randInt(slotGems.length)] = pool.gems.length > 0 ? randInt(pool.gems.length) : -1;
    }
  }
}

function getAppliedVariant(piece: EquipmentPiece | ExpandedEquipment): string {
  if ("appliedVariant" in piece) {
    return piece.appliedVariant ?? "";
  }
  return "";
}

function getPieceKey(ind: EvaluatedIndividual): string {
  return ind.loadout.slots.map((s) => {
    const variantKey = getAppliedVariant(s.piece);
    return `${s.piece.id}:${variantKey}`;
  }).join(",");
}

function tournamentSelect(
  pop: readonly EvaluatedIndividual[],
  tournamentSize = 3,
): EvaluatedIndividual {
  let best = pop[randInt(pop.length)];
  for (let i = 1; i < tournamentSize; i++) {
    const candidate = pop[randInt(pop.length)];
    if (candidate != null && (best == null || candidate.score > best.score)) {
      best = candidate;
    }
  }
  const fallback = pop[0];
  if (best != null) return best;
  if (fallback != null) return fallback;
  throw new Error("tournamentSelect called with empty population");
}

export function extractResults(
  population: readonly EvaluatedIndividual[],
  maxResults: number,
): readonly SearchResult[] {
  const sorted = [...population].sort((a, b) => b.score - a.score);
  const seen = new Set<string>();
  const results: SearchResult[] = [];

  for (const ind of sorted) {
    // Dedup by piece identity only (id + variant) — same pieces with different
    // enchants/mods are consolidated to the highest-scoring configuration
    const key = ind.loadout.slots.map((s) => {
      const variantKey = getAppliedVariant(s.piece);
      return `${s.piece.id}:${variantKey}`;
    }).join(",");
    if (seen.has(key)) continue;
    seen.add(key);
    results.push({
      loadout: ind.loadout,
      score: ind.score,
      stats: ind.stats,
      atlanteanChoices: ind.atlanteanMap,
    });
    if (results.length >= maxResults) break;
  }

  return results;
}

function initPopulation(
  pool: IndexedPool,
  constraints: HardConstraints,
  fitness: readonly SoftConstraint[],
  size: number,
): EvaluatedIndividual[] {
  const pop: EvaluatedIndividual[] = [];
  let attempts = 0;
  const maxAttempts = size * 20;

  while (pop.length < size && attempts < maxAttempts) {
    attempts++;
    const chromo = randomChromosome(pool);
    repair(chromo, pool, undefined);
    const individual = evaluate({ chromo, pool, constraints, fitness });
    if (individual != null) pop.push(individual);
  }

  if (pop.length === 0) {
    throw new Error(
      "No valid builds found. Constraints may be too strict for the available gear.",
    );
  }

  return pop;
}

function evolveOneGeneration(
  params: EvolveParams,
  population: readonly EvaluatedIndividual[],
): EvaluatedIndividual[] {
  const { populationSize } = params;
  const nextPop: EvaluatedIndividual[] = [];

  // Measure diversity and adapt parameters
  const diversity = measureDiversity(population);
  const isLowDiversity = diversity < DIVERSITY_THRESHOLD;
  const adaptedParams: EvolveParams = isLowDiversity
    ? { ...params, mutationRate: Math.min(params.mutationRate * LOW_DIVERSITY_MUTATION_BOOST, 0.5) }
    : params;
  const tournamentSize = isLowDiversity ? 2 : 3;

  // Elitism: keep top 2
  const sorted = [...population].sort((a, b) => b.score - a.score);
  const elite0 = sorted[0];
  const elite1 = sorted[1];
  if (elite0 != null) nextPop.push(elite0);
  if (elite1 != null) nextPop.push(elite1);

  while (nextPop.length < populationSize) {
    produceOffspring(adaptedParams, population, nextPop, tournamentSize);
  }

  return nextPop.slice(0, populationSize);
}

function produceOffspring(
  params: EvolveParams,
  population: readonly EvaluatedIndividual[],
  nextPop: EvaluatedIndividual[],
  tournamentSize: number,
): void {
  const { pool, constraints, fitness, mutationRate, crossoverRate } = params;
  const p1 = tournamentSelect(population, tournamentSize);
  const p2 = tournamentSelect(population, tournamentSize);

  const [c1, c2] = Math.random() < crossoverRate
    ? uniformCrossover(p1.chromosome, p2.chromosome)
    : [structuredClone(p1.chromosome), structuredClone(p2.chromosome)];

  if (Math.random() < mutationRate) mutate(c1, pool);
  if (Math.random() < mutationRate) mutate(c2, pool);

  repair(c1, pool, undefined);
  repair(c2, pool, undefined);

  const eval1 = evaluate({ chromo: c1, pool, constraints, fitness });
  const eval2 = evaluate({ chromo: c2, pool, constraints, fitness });
  if (eval1 != null) nextPop.push(eval1);
  if (eval2 != null) nextPop.push(eval2);
}

function incorporateMigrants(
  state: LoopState,
  migrants: Chromosome[],
  params: EvolveParams,
): void {
  const { pool, constraints, fitness, populationSize } = params;

  // Evaluate migrants
  const evaluatedMigrants: EvaluatedIndividual[] = [];
  for (const chromo of migrants) {
    repair(chromo, pool, undefined);
    const ind = evaluate({ chromo, pool, constraints, fitness });
    if (ind != null) evaluatedMigrants.push(ind);
  }

  if (evaluatedMigrants.length === 0) return;

  // Replace worst individuals with migrants
  const sorted = [...state.population].sort((a, b) => b.score - a.score);
  const keepCount = populationSize - evaluatedMigrants.length;
  state.population = [...sorted.slice(0, keepCount), ...evaluatedMigrants];
  state.stagnation = 0;
}

function handleStagnation(
  state: LoopState,
  gen: number,
  config: LoopConfig,
): boolean {
  if (state.stagnation <= INJECTION_THRESHOLD) return false;

  const { evolveParams, onStagnating, getMigrants } = config;
  const migrants = getMigrants?.();

  // Try migrants first
  if (migrants != null && migrants.length > 0) {
    incorporateMigrants(state, migrants, evolveParams);
    return false;
  }

  // Notify coordinator if available, but still use diversity injection
  if (onStagnating != null) {
    onStagnating();
    if (state.injections < MAX_INJECTIONS) {
      injectDiversity(state, evolveParams);
      return false;
    }
  } else if (shouldInjectDiversity(state)) {
    injectDiversity(state, evolveParams);
    return false;
  }

  // Check for final exit
  if (state.stagnation > STAGNATION_LIMIT) {
    state.finalGeneration = gen + 1;
    state.exitReason = "stagnation";
    return true;
  }
  return false;
}

function extractResultsWithArchive(
  state: LoopState,
  maxResults: number,
): readonly SearchResult[] {
  // Merge archive with current population for extraction
  const archiveIndividuals = [...state.archive.values()];
  const combined = [...archiveIndividuals, ...state.population];
  return extractResults(combined, maxResults);
}

async function runEvolutionLoop(
  config: LoopConfig,
  state: LoopState,
): Promise<void> {
  const { evolveParams, generations, maxResults, token, onProgress } = config;
  // Archive size limit: 2x maxResults to capture diverse solutions
  const archiveLimit = maxResults * 2;
  let diversityInjections = 0;

  for (let gen = 0; gen < generations; gen++) {
    if (token.cancelled) {
      state.finalGeneration = gen;
      state.exitReason = "cancelled";
      break;
    }

    state.population = evolveOneGeneration(evolveParams, state.population);
    updateStagnation(state);
    updateArchive(state, archiveLimit);

    // Proactive diversity injection when population becomes too homogeneous
    const diversity = measureDiversity(state.population);
    if (diversity < CRITICAL_DIVERSITY_THRESHOLD && diversityInjections < MAX_DIVERSITY_INJECTIONS) {
      injectDiversity(state, evolveParams);
      diversityInjections++;
    }

    const currentResults = extractResultsWithArchive(stat

function injectDiversity(state: LoopState, params: EvolveParams): void {
  const { pool, constraints, fitness, populationSize } = params;
  const sorted = [...state.population].sort((a, b) => b.score - a.score);
  const keepCount = Math.floor(populationSize * 0.8);
  const survivors = sorted.slice(0, keepCount);

  const freshIndividuals = initPopulation(
    pool, constraints, fitness, populationSize - keepCount,
  );

  state.population = [...survivors, ...freshIndividuals];
  state.stagnation = 0;
  state.injections++;
}

function updateStagnation(state: LoopState): void {
  const genBest = state.population[0]?.score ?? -Infinity;
  if (genBest > state.bestScore) {
    state.bestScore = genBest;
    state.stagnation = 0;
  } else {
    state.stagnation++;
  }
}