@reicek/neataptic-ts 0.1.25 → 0.1.26

package/src/neat/adaptive/mutation/README.md

@@ -100,6 +100,30 @@ Parameters:
 
 Returns: Mutation outcome flags.
 
+### applyOperatorDecay
+
+```ts
+applyOperatorDecay(
+  stats: Map<string, { success: number; attempts: number; }>,
+  entries: [string, { success: number; attempts: number; }][],
+  decay: number,
+): void
+```
+
+Apply exponential decay to each operator statistic entry.
+
+Operator decay is the controller-level counterpart to per-genome mutation
+tuning. Rather than rewriting genomes directly, it softens stale wins and
+attempts so later operator selection can weight recent performance more
+heavily.
+
+Parameters:
+- `stats` - - Operator statistics map.
+- `entries` - - Operator stat entries to update.
+- `decay` - - Decay factor.
+
+Returns: Nothing.
+
 ### applyTwoTierFallback
 
 ```ts
@@ -144,6 +168,24 @@ Parameters:
 
 Returns: Resolved mutation settings.
 
+### resolveOperatorDecay
+
+```ts
+resolveOperatorDecay(
+  config: { enabled?: boolean | undefined; learningRate?: number | undefined; alpha?: number | undefined; decay?: number | undefined; },
+): number
+```
+
+Resolve the decay factor for operator statistics.
+
+Centralizing the default decay factor keeps the caller focused on the update
+cycle instead of repeatedly restating configuration fallback rules.
+
+Parameters:
+- `config` - - Operator adaptation configuration.
+
+Returns: Decay factor for exponential smoothing.
+
 ### shouldAdaptThisGeneration
 
 ```ts
@@ -186,48 +228,6 @@ Parameters:
 
 Returns: True if fallback should run.
 
-### applyOperatorDecay
-
-```ts
-applyOperatorDecay(
-  stats: Map<string, { success: number; attempts: number; }>,
-  entries: [string, { success: number; attempts: number; }][],
-  decay: number,
-): void
-```
-
-Apply exponential decay to each operator statistic entry.
-
-Operator decay is the controller-level counterpart to per-genome mutation
-tuning. Rather than rewriting genomes directly, it softens stale wins and
-attempts so later operator selection can weight recent performance more
-heavily.
-
-Parameters:
-- `stats` - - Operator statistics map.
-- `entries` - - Operator stat entries to update.
-- `decay` - - Decay factor.
-
-Returns: Nothing.
-
-### resolveOperatorDecay
-
-```ts
-resolveOperatorDecay(
-  config: { enabled?: boolean | undefined; learningRate?: number | undefined; alpha?: number | undefined; decay?: number | undefined; },
-): number
-```
-
-Resolve the decay factor for operator statistics.
-
-Centralizing the default decay factor keeps the caller focused on the update
-cycle instead of repeatedly restating configuration fallback rules.
-
-Parameters:
-- `config` - - Operator adaptation configuration.
-
-Returns: Decay factor for exponential smoothing.
-
 ## neat/adaptive/mutation/adaptive.mutation.utils.ts
 
 Per-genome adaptive mutation helpers.
@@ -245,123 +245,77 @@ The helper flow is intentionally compact:
 3. resolve strategy-specific deltas,
 4. clamp the updated mutation fields and apply fallback balancing if needed.
 
-### shouldAdaptThisGeneration
-
-```ts
-shouldAdaptThisGeneration(
-  generation: number,
-  config: { enabled?: boolean | undefined; learningRate?: number | undefined; min?: number | undefined; max?: number | undefined; adaptEvery?: number | undefined; sigma?: number | undefined; minRate?: number | undefined; maxRate?: number | undefined; strategy?: string | undefined; adaptAmount?: boolean | undefined; minAmount?: number | undefined; maxAmount?: number | undefined; initialRate?: number | undefined; amountSigma?: number | undefined; },
-): boolean
-```
-
-Check whether mutation adaptation should run this generation.
-
-Cadence checks keep adaptive mutation from rewriting per-genome pressure on
-every generation unless the configuration explicitly asks for that. This lets
-runs choose between fast reaction and slower, more stable adjustment cycles.
-
-Parameters:
-- `generation` - - Current generation index.
-- `config` - - Adaptive mutation configuration.
-
-Returns: True if adaptation should run.
-
-### collectScoredGenomes
-
-```ts
-collectScoredGenomes(
-  population: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
-): { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[]
-```
-
-Collect genomes with numeric scores.
-
-The adaptive mutation loop only partitions genomes that have meaningful score
-evidence. Unevaluated genomes stay out of the ranking split so the strategy
-logic only reacts to genomes the run has actually judged.
-
-Parameters:
-- `population` - - Population of genomes.
-
-Returns: Scored genomes.
-
-### sortScoredGenomes
-
-```ts
-sortScoredGenomes(
-  scoredGenomes: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
-): { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[]
-```
-
-Sort scored genomes in ascending score order.
-
-Sorting creates the stable ordering used by the two-tier and explore-low
-strategies. Lower-scoring genomes end up at the front, which makes the later
-top-half and bottom-half split read naturally.
-
-Parameters:
-- `scoredGenomes` - - Scored genomes.
-
-Returns: Sorted genomes.
-
-### splitScoredGenomes
+### applyAnnealDelta
 
 ```ts
-splitScoredGenomes(
-  scoredGenomes: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
-): MutationPartitions
+applyAnnealDelta(
+  baseDelta: number,
+  settings: MutationSettings,
+): number
 ```
 
-Split scored genomes into top and bottom halves.
+Apply annealing adjustments to a delta.
 
-The partition step is where population performance becomes strategy-friendly
-structure. Later helpers can ask whether a genome belongs to the exploratory
-bottom half or the conservative top half without re-deriving the split.
+Annealing gradually shrinks the effective delta as the run ages, making early
+mutation-pressure updates more aggressive and later ones more conservative.
 
 Parameters:
-- `scoredGenomes` - - Sorted scored genomes.
+- `baseDelta` - - Base random delta.
+- `settings` - - Resolved settings.
 
-Returns: Partitions used by strategy rules.
+Returns: Adjusted delta.
 
-### resolveMutationSettings
+### applyExploreLowDelta
 
 ```ts
-resolveMutationSettings(
-  engine: NeatLikeWithAdaptive,
-  config: { enabled?: boolean | undefined; learningRate?: number | undefined; min?: number | undefined; max?: number | undefined; adaptEvery?: number | undefined; sigma?: number | undefined; minRate?: number | undefined; maxRate?: number | undefined; strategy?: string | undefined; adaptAmount?: boolean | undefined; minAmount?: number | undefined; maxAmount?: number | undefined; initialRate?: number | undefined; amountSigma?: number | undefined; },
-): MutationSettings
+applyExploreLowDelta(
+  baseDelta: number,
+  genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
+  bottomHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
+): number
 ```
 
-Resolve mutation settings derived from configuration and engine state.
+Apply explore-low adjustments to a delta.
 
-This is the normalization boundary for adaptive mutation. It gathers all
-defaults, runtime counters, and mutation-amount settings into one typed
-object so later helpers can stay focused on strategy logic instead of config
-fallback bookkeeping.
+Explore-low treats weaker genomes as exploration candidates. Bottom-half
+genomes receive larger positive pressure, while the rest are gently pushed
+downward so the search budget does not inflate everywhere at once.
 
 Parameters:
-- `engine` - - NEAT engine instance.
-- `config` - - Adaptive mutation configuration.
+- `baseDelta` - - Base random delta.
+- `genome` - - Current genome.
+- `bottomHalfSet` - - Lookup for bottom-half genomes.
 
-Returns: Resolved mutation settings.
+Returns: Adjusted delta.
 
-### resolveRandomSource
+### applyMutationAmount
 
 ```ts
-resolveRandomSource(
-  engine: NeatLikeWithAdaptive,
-): () => number
+applyMutationAmount(
+  genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
+  settings: MutationSettings,
+  randomSource: () => number,
+  genomeIndex: number,
+  topHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
+  bottomHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
+): void
 ```
 
-Resolve a random source that matches the legacy RNG usage.
+Apply mutation-amount adjustments to a genome.
 
-Adaptive mutation uses the same RNG access pattern as the older runtime so
-the pressure updates remain comparable with existing runs and tests.
+Rate and amount adaptation share the same high-level strategy vocabulary, but
+amount updates remain optional because some runs only want to tune how often
+mutation fires, not how large each mutation should be.
 
 Parameters:
-- `engine` - - NEAT engine instance.
+- `genome` - - Current genome.
+- `settings` - - Resolved settings.
+- `randomSource` - - Random number provider.
+- `genomeIndex` - - Genome index.
+- `topHalfSet` - - Lookup for top-half genomes.
+- `bottomHalfSet` - - Lookup for bottom-half genomes.
 
-Returns: Random number provider.
+Returns: Nothing.
 
 ### applyMutationsToPopulation
 
@@ -390,12 +344,11 @@ Parameters:
 
 Returns: Mutation outcome flags.
 
-### resolveRateDelta
+### applyTwoTierAmountDelta
 
 ```ts
-resolveRateDelta(
-  settings: MutationSettings,
-  randomSource: () => number,
+applyTwoTierAmountDelta(
+  baseDelta: number,
   genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
   genomeIndex: number,
   topHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
@@ -403,56 +356,34 @@ resolveRateDelta(
 ): number
 ```
 
-Resolve mutation-rate delta based on strategy.
+Apply two-tier adjustments to amount delta.
 
-Strategy dispatch keeps the public mutation flow readable. Each strategy gets
-the same base random delta, then reshapes it according to its own policy for
-favoring exploration, rewarding stronger genomes with lower pressure, or
-annealing toward smaller adjustments over time.
+Amount deltas mirror the high-level two-tier idea from rate adaptation: give
+weaker genomes more room to roam and keep stronger genomes from drifting too
+far in one step.
 
 Parameters:
-- `settings` - - Resolved settings.
-- `randomSource` - - Random number provider.
+- `baseDelta` - - Base random delta.
 - `genome` - - Current genome.
 - `genomeIndex` - - Genome index.
 - `topHalfSet` - - Lookup for top-half genomes.
 - `bottomHalfSet` - - Lookup for bottom-half genomes.
 
-Returns: Signed mutation rate delta.
+Returns: Adjusted delta.
 
-### createRandomDelta
+### applyTwoTierDelta
 
 ```ts
-createRandomDelta(
-  sigmaBase: number,
-  randomSource: () => number,
+applyTwoTierDelta(
+  baseDelta: number,
+  genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
+  genomeIndex: number,
+  topHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
+  bottomHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
 ): number
 ```
 
-Create a signed random delta scaled by sigma.
-
-This is the small stochastic core shared by rate and amount adaptation.
-Later strategy helpers decide how to reinterpret the sign and magnitude.
-
-Parameters:
-- `sigmaBase` - - Sigma scaling factor.
-- `randomSource` - - Random number provider.
-
-Returns: Signed delta.
-
-### applyTwoTierDelta
-
-```ts
-applyTwoTierDelta(
-  baseDelta: number,
-  genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
-  genomeIndex: number,
-  topHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
-  bottomHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
-): number
-```
-
-Apply two-tier adjustments to a delta.
+Apply two-tier adjustments to a delta.
 
 Two-tier mode deliberately pushes the two halves in opposite directions so
 one side becomes more exploratory while the other becomes more conservative.
@@ -468,77 +399,89 @@ Parameters:
 
 Returns: Adjusted delta.
 
-### applyExploreLowDelta
+### applyTwoTierFallback
 
 ```ts
-applyExploreLowDelta(
-  baseDelta: number,
-  genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
-  bottomHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
-): number
+applyTwoTierFallback(
+  population: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
+  settings: MutationSettings,
+): void
 ```
 
-Apply explore-low adjustments to a delta.
+Apply two-tier fallback balancing.
 
-Explore-low treats weaker genomes as exploration candidates. Bottom-half
-genomes receive larger positive pressure, while the rest are gently pushed
-downward so the search budget does not inflate everywhere at once.
+Fallback balancing restores the intended contrast when the stochastic pass
+fails to produce both exploratory and conservative outcomes. It is narrower
+than the main update loop because it only nudges rates, leaving the richer
+strategy-specific reasoning to the first pass.
 
 Parameters:
-- `baseDelta` - - Base random delta.
-- `genome` - - Current genome.
-- `bottomHalfSet` - - Lookup for bottom-half genomes.
+- `population` - - Population of genomes.
+- `settings` - - Resolved settings.
 
-Returns: Adjusted delta.
+Returns: Nothing.
 
-### applyAnnealDelta
+### clampValue
 
 ```ts
-applyAnnealDelta(
-  baseDelta: number,
-  settings: MutationSettings,
+clampValue(
+  value: number,
+  min: number,
+  max: number,
 ): number
 ```
 
-Apply annealing adjustments to a delta.
+Clamp a value between min and max bounds.
 
-Annealing gradually shrinks the effective delta as the run ages, making early
-mutation-pressure updates more aggressive and later ones more conservative.
+Clamping is the final safety guard that keeps adaptive mutation inside the
+configured rate and amount envelopes even when repeated random pressure would
+otherwise drift beyond them.
 
 Parameters:
-- `baseDelta` - - Base random delta.
-- `settings` - - Resolved settings.
+- `value` - - Value to clamp.
+- `min` - - Minimum bound.
+- `max` - - Maximum bound.
 
-Returns: Adjusted delta.
+Returns: Clamped value.
 
-### applyMutationAmount
+### collectScoredGenomes
 
 ```ts
-applyMutationAmount(
-  genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
-  settings: MutationSettings,
+collectScoredGenomes(
+  population: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
+): { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[]
+```
+
+Collect genomes with numeric scores.
+
+The adaptive mutation loop only partitions genomes that have meaningful score
+evidence. Unevaluated genomes stay out of the ranking split so the strategy
+logic only reacts to genomes the run has actually judged.
+
+Parameters:
+- `population` - - Population of genomes.
+
+Returns: Scored genomes.
+
+### createRandomDelta
+
+```ts
+createRandomDelta(
+  sigmaBase: number,
   randomSource: () => number,
-  genomeIndex: number,
-  topHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
-  bottomHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
-): void
+): number
 ```
 
-Apply mutation-amount adjustments to a genome.
+Create a signed random delta scaled by sigma.
 
-Rate and amount adaptation share the same high-level strategy vocabulary, but
-amount updates remain optional because some runs only want to tune how often
-mutation fires, not how large each mutation should be.
+This is the small stochastic core shared by rate and amount adaptation.
+Later strategy helpers decide how to reinterpret the sign and magnitude.
 
 Parameters:
-- `genome` - - Current genome.
-- `settings` - - Resolved settings.
+- `sigmaBase` - - Sigma scaling factor.
 - `randomSource` - - Random number provider.
-- `genomeIndex` - - Genome index.
-- `topHalfSet` - - Lookup for top-half genomes.
-- `bottomHalfSet` - - Lookup for bottom-half genomes.
 
-Returns: Nothing.
+Returns: Signed delta.
 
 ### resolveAmountDelta
 
@@ -569,11 +512,52 @@ Parameters:
 
 Returns: Signed mutation amount delta.
 
-### applyTwoTierAmountDelta
+### resolveMutationSettings
 
 ```ts
-applyTwoTierAmountDelta(
-  baseDelta: number,
+resolveMutationSettings(
+  engine: NeatLikeWithAdaptive,
+  config: { enabled?: boolean | undefined; learningRate?: number | undefined; min?: number | undefined; max?: number | undefined; adaptEvery?: number | undefined; sigma?: number | undefined; minRate?: number | undefined; maxRate?: number | undefined; strategy?: string | undefined; adaptAmount?: boolean | undefined; minAmount?: number | undefined; maxAmount?: number | undefined; initialRate?: number | undefined; amountSigma?: number | undefined; },
+): MutationSettings
+```
+
+Resolve mutation settings derived from configuration and engine state.
+
+This is the normalization boundary for adaptive mutation. It gathers all
+defaults, runtime counters, and mutation-amount settings into one typed
+object so later helpers can stay focused on strategy logic instead of config
+fallback bookkeeping.
+
+Parameters:
+- `engine` - - NEAT engine instance.
+- `config` - - Adaptive mutation configuration.
+
+Returns: Resolved mutation settings.
+
+### resolveRandomSource
+
+```ts
+resolveRandomSource(
+  engine: NeatLikeWithAdaptive,
+): () => number
+```
+
+Resolve a random source that matches the legacy RNG usage.
+
+Adaptive mutation uses the same RNG access pattern as the older runtime so
+the pressure updates remain comparable with existing runs and tests.
+
+Parameters:
+- `engine` - - NEAT engine instance.
+
+Returns: Random number provider.
+
+### resolveRateDelta
+
+```ts
+resolveRateDelta(
+  settings: MutationSettings,
+  randomSource: () => number,
   genome: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; },
   genomeIndex: number,
   topHalfSet: Set<{ [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }>,
@@ -581,43 +565,43 @@ applyTwoTierAmountDelta(
 ): number
 ```
 
-Apply two-tier adjustments to amount delta.
+Resolve mutation-rate delta based on strategy.
 
-Amount deltas mirror the high-level two-tier idea from rate adaptation: give
-weaker genomes more room to roam and keep stronger genomes from drifting too
-far in one step.
+Strategy dispatch keeps the public mutation flow readable. Each strategy gets
+the same base random delta, then reshapes it according to its own policy for
+favoring exploration, rewarding stronger genomes with lower pressure, or
+annealing toward smaller adjustments over time.
 
 Parameters:
-- `baseDelta` - - Base random delta.
+- `settings` - - Resolved settings.
+- `randomSource` - - Random number provider.
 - `genome` - - Current genome.
 - `genomeIndex` - - Genome index.
 - `topHalfSet` - - Lookup for top-half genomes.
 - `bottomHalfSet` - - Lookup for bottom-half genomes.
 
-Returns: Adjusted delta.
+Returns: Signed mutation rate delta.
 
-### clampValue
+### shouldAdaptThisGeneration
 
 ```ts
-clampValue(
-  value: number,
-  min: number,
-  max: number,
-): number
+shouldAdaptThisGeneration(
+  generation: number,
+  config: { enabled?: boolean | undefined; learningRate?: number | undefined; min?: number | undefined; max?: number | undefined; adaptEvery?: number | undefined; sigma?: number | undefined; minRate?: number | undefined; maxRate?: number | undefined; strategy?: string | undefined; adaptAmount?: boolean | undefined; minAmount?: number | undefined; maxAmount?: number | undefined; initialRate?: number | undefined; amountSigma?: number | undefined; },
+): boolean
 ```
 
-Clamp a value between min and max bounds.
+Check whether mutation adaptation should run this generation.
 
-Clamping is the final safety guard that keeps adaptive mutation inside the
-configured rate and amount envelopes even when repeated random pressure would
-otherwise drift beyond them.
+Cadence checks keep adaptive mutation from rewriting per-genome pressure on
+every generation unless the configuration explicitly asks for that. This lets
+runs choose between fast reaction and slower, more stable adjustment cycles.
 
 Parameters:
-- `value` - - Value to clamp.
-- `min` - - Minimum bound.
-- `max` - - Maximum bound.
+- `generation` - - Current generation index.
+- `config` - - Adaptive mutation configuration.
 
-Returns: Clamped value.
+Returns: True if adaptation should run.
 
 ### shouldApplyTwoTierFallback
 
@@ -640,27 +624,43 @@ Parameters:
 
 Returns: True if fallback should run.
 
-### applyTwoTierFallback
+### sortScoredGenomes
 
 ```ts
-applyTwoTierFallback(
-  population: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
-  settings: MutationSettings,
-): void
+sortScoredGenomes(
+  scoredGenomes: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
+): { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[]
 ```
 
-Apply two-tier fallback balancing.
+Sort scored genomes in ascending score order.
 
-Fallback balancing restores the intended contrast when the stochastic pass
-fails to produce both exploratory and conservative outcomes. It is narrower
-than the main update loop because it only nudges rates, leaving the richer
-strategy-specific reasoning to the first pass.
+Sorting creates the stable ordering used by the two-tier and explore-low
+strategies. Lower-scoring genomes end up at the front, which makes the later
+top-half and bottom-half split read naturally.
 
 Parameters:
-- `population` - - Population of genomes.
-- `settings` - - Resolved settings.
+- `scoredGenomes` - - Scored genomes.
 
-Returns: Nothing.
+Returns: Sorted genomes.
+
+### splitScoredGenomes
+
+```ts
+splitScoredGenomes(
+  scoredGenomes: { [key: string]: unknown; score?: number | undefined; _mutRate?: number | null | undefined; _mutAmount?: number | null | undefined; }[],
+): MutationPartitions
+```
+
+Split scored genomes into top and bottom halves.
+
+The partition step is where population performance becomes strategy-friendly
+structure. Later helpers can ask whether a genome belongs to the exploratory
+bottom half or the conservative top half without re-deriving the split.
+
+Parameters:
+- `scoredGenomes` - - Sorted scored genomes.
+
+Returns: Partitions used by strategy rules.
 
 ## neat/adaptive/mutation/adaptive.operator.utils.ts
 
@@ -671,23 +671,29 @@ have succeeded recently. They stay separate from per-genome mutation tuning so
 the generated chapter can distinguish genome-local pressure from controller-
 level evidence decay.
 
-### resolveOperatorDecay
+### applyOperatorDecay
 
 ```ts
-resolveOperatorDecay(
-  config: { enabled?: boolean | undefined; learningRate?: number | undefined; alpha?: number | undefined; decay?: number | undefined; },
-): number
+applyOperatorDecay(
+  stats: Map<string, { success: number; attempts: number; }>,
+  entries: [string, { success: number; attempts: number; }][],
+  decay: number,
+): void
 ```
 
-Resolve the decay factor for operator statistics.
+Apply exponential decay to each operator statistic entry.
 
-Centralizing the default decay factor keeps the caller focused on the update
-cycle instead of repeatedly restating configuration fallback rules.
+Operator decay is the controller-level counterpart to per-genome mutation
+tuning. Rather than rewriting genomes directly, it softens stale wins and
+attempts so later operator selection can weight recent performance more
+heavily.
 
 Parameters:
-- `config` - - Operator adaptation configuration.
+- `stats` - - Operator statistics map.
+- `entries` - - Operator stat entries to update.
+- `decay` - - Decay factor.
 
-Returns: Decay factor for exponential smoothing.
+Returns: Nothing.
 
 ### collectOperatorStatsEntries
 
@@ -708,30 +714,6 @@ Parameters:
 
 Returns: Array of operator stat entries.
 
-### applyOperatorDecay
-
-```ts
-applyOperatorDecay(
-  stats: Map<string, { success: number; attempts: number; }>,
-  entries: [string, { success: number; attempts: number; }][],
-  decay: number,
-): void
-```
-
-Apply exponential decay to each operator statistic entry.
-
-Operator decay is the controller-level counterpart to per-genome mutation
-tuning. Rather than rewriting genomes directly, it softens stale wins and
-attempts so later operator selection can weight recent performance more
-heavily.
-
-Parameters:
-- `stats` - - Operator statistics map.
-- `entries` - - Operator stat entries to update.
-- `decay` - - Decay factor.
-
-Returns: Nothing.
-
 ### decayOperatorStat
 
 ```ts
@@ -752,3 +734,21 @@ Parameters:
 - `decay` - - Decay factor.
 
 Returns: Decayed operator statistic record.
+
+### resolveOperatorDecay
+
+```ts
+resolveOperatorDecay(
+  config: { enabled?: boolean | undefined; learningRate?: number | undefined; alpha?: number | undefined; decay?: number | undefined; },
+): number
+```
+
+Resolve the decay factor for operator statistics.
+
+Centralizing the default decay factor keeps the caller focused on the update
+cycle instead of repeatedly restating configuration fallback rules.
+
+Parameters:
+- `config` - - Operator adaptation configuration.
+
+Returns: Decay factor for exponential smoothing.