@reicek/neataptic-ts 0.1.25 → 0.1.26

package/src/architecture/network/evolve/README.md

@@ -8,26 +8,22 @@ Shared dataset compatibility error message.
 
 Shared dataset compatibility error message.
 
-### STOPPING_CONDITION_REQUIRED_ERROR_MESSAGE
-
-Shared evolve stopping-condition validation error.
-
-### DEFAULT_TARGET_ERROR
+### DEFAULT_EVALUATION_AMOUNT
 
-Default target error used when omitted.
+Default repeated evaluation amount.
 
 ### DEFAULT_GROWTH
 
 Default complexity growth penalty.
 
-### DEFAULT_EVALUATION_AMOUNT
-
-Default repeated evaluation amount.
-
 ### DEFAULT_LOG_INTERVAL
 
 Default logging frequency value.
 
+### DEFAULT_TARGET_ERROR
+
+Default target error used when omitted.
+
 ### DEFAULT_THREAD_COUNT
 
 Default single-thread worker count.
@@ -36,33 +32,37 @@ Default single-thread worker count.
 
 Sentinel target error indicating that error-based stopping is disabled.
 
-### ZERO_ITERATIONS
+### EvolutionSummary
 
-Explicit zero-iteration value.
+Shared evolution summary payload.
 
-### SMALL_POPULATION_THRESHOLD
+### GenomeStructureCounts
 
-Population threshold considered "small" for mutation heuristics.
+Structural counts used by complexity heuristics.
 
-### SMALL_POPULATION_MUTATION_RATE
+### MAX_CONSECUTIVE_INVALID_ERRORS
 
-Mutation rate fallback used for very small populations.
+Maximum consecutive invalid errors tolerated before loop abort.
 
 ### SMALL_POPULATION_MUTATION_AMOUNT
 
 Mutation amount fallback used for very small populations.
 
-### MAX_CONSECUTIVE_INVALID_ERRORS
+### SMALL_POPULATION_MUTATION_RATE
 
-Maximum consecutive invalid errors tolerated before loop abort.
+Mutation rate fallback used for very small populations.
 
-### EvolutionSummary
+### SMALL_POPULATION_THRESHOLD
 
-Shared evolution summary payload.
+Population threshold considered "small" for mutation heuristics.
 
-### GenomeStructureCounts
+### STOPPING_CONDITION_REQUIRED_ERROR_MESSAGE
 
-Structural counts used by complexity heuristics.
+Shared evolve stopping-condition validation error.
+
+### ZERO_ITERATIONS
+
+Explicit zero-iteration value.
 
 ## architecture/network/evolve/network.evolve.utils.ts
 
@@ -109,76 +109,93 @@ console.log(summary.error, summary.iterations, summary.time);
 
 ## architecture/network/evolve/network.evolve.loop.utils.ts
 
-### runEvolutionLoop
+### applyEvolutionStep
 
 ```ts
-runEvolutionLoop(
-  neatInstance: NeatRuntime,
-  resolvedSettings: EvolutionSettings,
-  targetError: number,
-  iterations: number | undefined,
-): Promise<{ error: number; bestGenome: default | undefined; }>
+applyEvolutionStep(
+  state: EvolutionLoopState,
+  evolvedGenome: default,
+  growth: number,
+): void
 ```
 
-Run core evolution loop until stop condition is met.
+Applies one evolve() result to loop state.
 
 Parameters:
-- `neatInstance` - - Active NEAT instance.
-- `resolvedSettings` - - Scalar evolution settings.
-- `targetError` - - Effective target error (-1 means disabled).
-- `iterations` - - Optional max iteration count.
+- `state` - - Mutable loop state.
+- `evolvedGenome` - - Genome returned by NEAT evolve step.
+- `growth` - - Complexity growth scalar.
 
-Returns: Loop result snapshot.
+Returns: Nothing.
 
-### shouldContinueEvolution
+### createInitialLoopState
 
 ```ts
-shouldContinueEvolution(
-  currentError: number,
-  targetError: number,
-  iterationsSpecified: boolean,
-  currentGeneration: number,
-  maxIterations: number | undefined,
-): boolean
+createInitialLoopState(): EvolutionLoopState
 ```
 
-Determine whether evolution loop should continue.
+Creates initial loop state snapshot.
+
+Returns: Initial loop state.
+
+### deriveErrorFromFitness
+
+```ts
+deriveErrorFromFitness(
+  fitness: number,
+  genome: default,
+  growth: number,
+): number
+```
+
+Derive error from fitness by inverting score composition.
 
 Parameters:
-- `currentError` - - Current derived error value.
-- `targetError` - - Effective target error (-1 means disabled).
-- `iterationsSpecified` - - Whether iterations limit is active.
-- `currentGeneration` - - Current NEAT generation index.
-- `maxIterations` - - Maximum iteration limit.
+- `fitness` - - Fitness value from fittest genome.
+- `genome` - - Fittest genome.
+- `growth` - - Complexity growth scalar.
 
-Returns: True when loop should continue.
+Returns: Derived error value.
 
-### createInitialLoopState
+### runEvolutionLoop
 
 ```ts
-createInitialLoopState(): EvolutionLoopState
+runEvolutionLoop(
+  neatInstance: NeatRuntime,
+  resolvedSettings: EvolutionSettings,
+  targetError: number,
+  iterations: number | undefined,
+): Promise<{ error: number; bestGenome: default | undefined; }>
 ```
 
-Creates initial loop state snapshot.
+Run core evolution loop until stop condition is met.
 
-Returns: Initial loop state.
+Parameters:
+- `neatInstance` - - Active NEAT instance.
+- `resolvedSettings` - - Scalar evolution settings.
+- `targetError` - - Effective target error (-1 means disabled).
+- `iterations` - - Optional max iteration count.
 
-### applyEvolutionStep
+Returns: Loop result snapshot.
+
+### runScheduleCallbackSafely
 
 ```ts
-applyEvolutionStep(
-  state: EvolutionLoopState,
-  evolvedGenome: default,
-  growth: number,
+runScheduleCallbackSafely(
+  scheduleConfig: { iterations: number; function: (stats: { fitness: number; error: number; iteration: number; }) => void; } | undefined,
+  generation: number,
+  bestFitness: number,
+  error: number,
 ): void
 ```
 
-Applies one evolve() result to loop state.
+Run schedule callback if schedule trigger is reached.
 
 Parameters:
-- `state` - - Mutable loop state.
-- `evolvedGenome` - - Genome returned by NEAT evolve step.
-- `growth` - - Complexity growth scalar.
+- `scheduleConfig` - - Optional schedule configuration.
+- `generation` - - Current generation.
+- `bestFitness` - - Current best fitness.
+- `error` - - Current error.
 
 Returns: Nothing.
 
@@ -197,24 +214,28 @@ Parameters:
 
 Returns: True when invalid-error threshold is reached.
 
-### deriveErrorFromFitness
+### shouldContinueEvolution
 
 ```ts
-deriveErrorFromFitness(
-  fitness: number,
-  genome: default,
-  growth: number,
-): number
+shouldContinueEvolution(
+  currentError: number,
+  targetError: number,
+  iterationsSpecified: boolean,
+  currentGeneration: number,
+  maxIterations: number | undefined,
+): boolean
 ```
 
-Derive error from fitness by inverting score composition.
+Determine whether evolution loop should continue.
 
 Parameters:
-- `fitness` - - Fitness value from fittest genome.
-- `genome` - - Fittest genome.
-- `growth` - - Complexity growth scalar.
+- `currentError` - - Current derived error value.
+- `targetError` - - Effective target error (-1 means disabled).
+- `iterationsSpecified` - - Whether iterations limit is active.
+- `currentGeneration` - - Current NEAT generation index.
+- `maxIterations` - - Maximum iteration limit.
 
-Returns: Derived error value.
+Returns: True when loop should continue.
 
 ### updateBestGenomeIfImproved
 
@@ -254,29 +275,25 @@ Parameters:
 
 Returns: Updated guard state.
 
-### runScheduleCallbackSafely
+## architecture/network/evolve/network.evolve.setup.utils.ts
+
+### applySmallPopulationHeuristics
 
 ```ts
-runScheduleCallbackSafely(
-  scheduleConfig: { iterations: number; function: (stats: { fitness: number; error: number; iteration: number; }) => void; } | undefined,
-  generation: number,
-  bestFitness: number,
-  error: number,
+applySmallPopulationHeuristics(
+  neatInstance: NeatRuntime,
+  evolveOptions: EvolveOptions,
 ): void
 ```
 
-Run schedule callback if schedule trigger is reached.
+Increase mutation aggressiveness for tiny populations.
 
 Parameters:
-- `scheduleConfig` - - Optional schedule configuration.
-- `generation` - - Current generation.
-- `bestFitness` - - Current best fitness.
-- `error` - - Current error.
+- `neatInstance` - - Active NEAT instance.
+- `evolveOptions` - - Evolve options object.
 
 Returns: Nothing.
 
-## architecture/network/evolve/network.evolve.setup.utils.ts
-
 ### assertEvolutionDatasetCompatibility
 
 ```ts
@@ -294,67 +311,71 @@ Parameters:
 
 Returns: Nothing.
 
-### getNormalizedOptions
+### configureNeatOptions
 
 ```ts
-getNormalizedOptions(
+configureNeatOptions(
+  network: default,
   evolveOptions: EvolveOptions,
-): EvolveOptions
+): void
 ```
 
-Ensure options object exists.
+Normalize options used by NEAT constructor.
 
 Parameters:
-- `evolveOptions` - - Incoming evolve options.
+- `network` - - Network instance being evolved.
+- `evolveOptions` - - Evolve options object.
 
-Returns: Safe options object.
+Returns: Nothing.
 
-### resolveEvolutionSettings
+### createEvolutionConfig
 
 ```ts
-resolveEvolutionSettings(
-  evolveOptions: EvolveOptions,
-): EvolutionSettings
+createEvolutionConfig(
+  settingsToSummarize: EvolutionSettings,
+): EvolutionConfig | undefined
 ```
 
-Resolve normalized scalar settings with defaults.
+Build optional structured evolution config summary.
 
 Parameters:
-- `evolveOptions` - - Evolve options object.
+- `settingsToSummarize` - - Scalar evolution settings.
 
-Returns: Normalized scalar settings.
+Returns: Optional summary config.
 
-### resolveStopConditions
+### createNeatInstance
 
 ```ts
-resolveStopConditions(
+createNeatInstance(
+  network: default,
+  fitnessFunction: EvolutionFitnessFunction,
   evolveOptions: EvolveOptions,
-  initialTargetError: number,
-): EvolutionStopConditions
+): Promise<NeatRuntime>
 ```
 
-Resolve stopping-condition semantics while preserving legacy behavior.
+Lazy-load and create NEAT instance.
 
 Parameters:
+- `network` - - Network instance being evolved.
+- `fitnessFunction` - - Prepared fitness evaluator.
 - `evolveOptions` - - Evolve options object.
-- `initialTargetError` - - Target error resolved from options.
 
-Returns: Final stop conditions.
+Returns: Constructed NEAT instance.
 
-### createEvolutionConfig
+### getNormalizedOptions
 
 ```ts
-createEvolutionConfig(
-  settingsToSummarize: EvolutionSettings,
-): EvolutionConfig | undefined
+getNormalizedOptions(
+  evolveOptions: EvolveOptions,
+): EvolveOptions
 ```
 
-Build optional structured evolution config summary.
+Ensure options object exists.
 
 Parameters:
-- `settingsToSummarize` - - Scalar evolution settings.
+- `evolveOptions` - - Incoming evolve options.
 
-Returns: Optional summary config.
+Returns: Safe options object.
 
 ### prepareFitnessFunction
 
@@ -375,41 +396,37 @@ Parameters:
 
 Returns: Fitness function and resolved thread count.
 
-### configureNeatOptions
+### resolveEvolutionSettings
 
 ```ts
-configureNeatOptions(
-  network: default,
+resolveEvolutionSettings(
   evolveOptions: EvolveOptions,
-): void
+): EvolutionSettings
 ```
 
-Normalize options used by NEAT constructor.
+Resolve normalized scalar settings with defaults.
 
 Parameters:
-- `network` - - Network instance being evolved.
 - `evolveOptions` - - Evolve options object.
 
-Returns: Nothing.
+Returns: Normalized scalar settings.
 
-### createNeatInstance
+### resolveStopConditions
 
 ```ts
-createNeatInstance(
-  network: default,
-  fitnessFunction: EvolutionFitnessFunction,
+resolveStopConditions(
   evolveOptions: EvolveOptions,
-): Promise<NeatRuntime>
+  initialTargetError: number,
+): EvolutionStopConditions
 ```
 
-Lazy-load and create NEAT instance.
+Resolve stopping-condition semantics while preserving legacy behavior.
 
 Parameters:
-- `network` - - Network instance being evolved.
-- `fitnessFunction` - - Prepared fitness evaluator.
 - `evolveOptions` - - Evolve options object.
+- `initialTargetError` - - Target error resolved from options.
 
-Returns: Constructed NEAT instance.
+Returns: Final stop conditions.
 
 ### warnIfNoBestGenomeMayOccur
 
@@ -428,41 +445,49 @@ Parameters:
 
 Returns: Nothing.
 
-### applySmallPopulationHeuristics
+## architecture/network/evolve/network.evolve.fitness.utils.ts
+
+### buildMultiThreadFitness
 
 ```ts
-applySmallPopulationHeuristics(
-  neatInstance: NeatRuntime,
-  evolveOptions: EvolveOptions,
-): void
+buildMultiThreadFitness(
+  set: TrainingSample[],
+  cost: CostFunctionOrRef,
+  amount: number,
+  growth: number,
+  threads: number,
+  options: Record<string, unknown>,
+): Promise<FitnessSetup>
 ```
 
-Increase mutation aggressiveness for tiny populations.
+Build worker-based population fitness setup.
 
 Parameters:
-- `neatInstance` - - Active NEAT instance.
-- `evolveOptions` - - Evolve options object.
-
-Returns: Nothing.
+- `set` - - Dataset.
+- `cost` - - Cost function or reference.
+- `amount` - - Repetition count.
+- `growth` - - Complexity penalty scalar.
+- `threads` - - Desired worker count.
+- `options` - - Evolution options object.
 
-## architecture/network/evolve/network.evolve.fitness.utils.ts
+Returns: Population fitness setup.
 
-### computeComplexityPenalty
+### buildPopulationWorkerFitnessFunction
 
 ```ts
-computeComplexityPenalty(
-  genome: default,
+buildPopulationWorkerFitnessFunction(
+  workers: TestWorkerInstance[],
   growth: number,
-): number
+): PopulationFitnessFunction
 ```
 
-Compute structural complexity penalty scaled by growth.
+Build population-level fitness function powered by worker queue.
 
 Parameters:
-- `genome` - - Candidate network whose complexity to measure.
-- `growth` - - Positive scalar controlling parsimony pressure.
+- `workers` - - Spawned worker instances.
+- `growth` - - Complexity penalty scalar.
 
-Returns: Complexity penalty.
+Returns: Population-level fitness function.
 
 ### buildSingleThreadFitness
 
@@ -485,131 +510,94 @@ Parameters:
 
 Returns: Single-genome fitness function.
 
-### buildMultiThreadFitness
-
-```ts
-buildMultiThreadFitness(
-  set: TrainingSample[],
-  cost: CostFunctionOrRef,
-  amount: number,
-  growth: number,
-  threads: number,
-  options: Record<string, unknown>,
-): Promise<FitnessSetup>
-```
-
-Build worker-based population fitness setup.
-
-Parameters:
-- `set` - - Dataset.
-- `cost` - - Cost function or reference.
-- `amount` - - Repetition count.
-- `growth` - - Complexity penalty scalar.
-- `threads` - - Desired worker count.
-- `options` - - Evolution options object.
-
-Returns: Population fitness setup.
-
-### evaluateGenomeWithWorker
+### cacheComplexityBase
 
 ```ts
-evaluateGenomeWithWorker(
-  worker: TestWorkerInstance,
+cacheComplexityBase(
   genome: default,
-  growth: number,
-): Promise<void>
+  structureCounts: GenomeStructureCounts,
+  complexityBase: number,
+): void
 ```
 
-Evaluate one genome with a worker and assign penalized score.
+Store complexity base cache entry for future reuse.
 
 Parameters:
-- `worker` - - Worker instance.
-- `genome` - - Genome under evaluation.
-- `growth` - - Complexity penalty scalar.
+- `genome` - - Candidate network used as cache key.
+- `structureCounts` - - Current structural counts.
+- `complexityBase` - - Computed base complexity value.
 
-Returns: Promise resolving when score assignment completes.
+Returns: Nothing.
 
-### installWorkerTerminationHook
+### claimNextGenome
 
 ```ts
-installWorkerTerminationHook(
-  options: Record<string, unknown>,
-  workers: TestWorkerInstance[],
-): void
+claimNextGenome(
+  context: PopulationWorkerEvaluationContext,
+): default | undefined
 ```
 
-Register worker termination hook onto options object.
+Claims the next genome index from shared queue state.
 
 Parameters:
-- `options` - - Evolve options object.
-- `workers` - - Spawned worker instances.
+- `context` - - Population evaluation context.
 
-Returns: Nothing.
+Returns: Next genome, or undefined when queue is exhausted.
 
-### evaluateGenomeAmountTimes
+### computeComplexityBase
 
 ```ts
-evaluateGenomeAmountTimes(
+computeComplexityBase(
   genome: default,
-  set: TrainingSample[],
-  cost: EvolveCostFunction,
-  amount: number,
+  structureCounts: GenomeStructureCounts,
 ): number
 ```
 
-Evaluate one genome repeatedly and accumulate negative error.
+Compute non-scaled complexity base from structural counts.
 
 Parameters:
-- `genome` - - Genome under evaluation.
-- `set` - - Dataset used for evaluation.
-- `cost` - - Cost function reference.
-- `amount` - - Number of repeated evaluations.
+- `genome` - - Candidate network whose complexity to compute.
+- `structureCounts` - - Current structural counts.
 
-Returns: Accumulated negative error or -Infinity on failure.
+Returns: Base complexity value before growth scaling.
 
-### evaluateGenomeErrorSafely
+### computeComplexityPenalty
 
 ```ts
-evaluateGenomeErrorSafely(
+computeComplexityPenalty(
   genome: default,
-  set: TrainingSample[],
-  cost: EvolveCostFunction,
-): number | null
+  growth: number,
+): number
 ```
 
-Evaluate one genome and return error, with warning-protected failure handling.
+Compute structural complexity penalty scaled by growth.
 
 Parameters:
-- `genome` - - Genome under evaluation.
-- `set` - - Dataset used for evaluation.
-- `cost` - - Cost function reference.
+- `genome` - - Candidate network whose complexity to measure.
+- `growth` - - Positive scalar controlling parsimony pressure.
 
-Returns: Error value, or null when evaluation fails.
+Returns: Complexity penalty.
 
-### warnGenomeEvaluationFailure
+### createPopulationWorkerEvaluationContext
 
 ```ts
-warnGenomeEvaluationFailure(
-  error: unknown,
-): void
+createPopulationWorkerEvaluationContext(
+  sourceWorkers: TestWorkerInstance[],
+  sourcePopulation: default[],
+  sourceGrowth: number,
+  sourceResolve: () => void,
+): PopulationWorkerEvaluationContext
 ```
 
-Emit warning when genome evaluation fails.
+Creates the shared evaluation context for one population run.
 
 Parameters:
-- `error` - - Unknown evaluation error.
-
-Returns: Nothing.
-
-### resolveTestWorkerConstructor
-
-```ts
-resolveTestWorkerConstructor(): Promise<TestWorkerConstructor | null>
-```
-
-Resolve worker constructor for current runtime environment.
+- `sourceWorkers` - - Worker pool.
+- `sourcePopulation` - - Population to evaluate.
+- `sourceGrowth` - - Complexity penalty scalar.
+- `sourceResolve` - - Promise resolver.
 
-Returns: Worker constructor or null when unavailable.
+Returns: Population evaluation context.
 
 ### createSingleThreadFallbackFitness
 
@@ -632,171 +620,175 @@ Parameters:
 
 Returns: Single-thread fitness setup.
 
-### spawnTestWorkers
+### createWorkerTraversalContext
 
 ```ts
-spawnTestWorkers(
-  workerConstructor: TestWorkerConstructor,
-  serializedSet: number[],
-  cost: CostFunctionOrRef,
-  threads: number,
-): TestWorkerInstance[]
+createWorkerTraversalContext(
+  context: PopulationWorkerEvaluationContext,
+  worker: TestWorkerInstance,
+): WorkerTraversalContext
 ```
 
-Spawn worker instances up to requested thread count.
+Creates traversal context for one worker.
 
 Parameters:
-- `workerConstructor` - - Worker constructor resolved for runtime.
-- `serializedSet` - - Serialized dataset shared with workers.
-- `cost` - - Cost function or cost reference.
-- `threads` - - Requested worker count.
+- `context` - - Population evaluation context.
+- `worker` - - Worker instance.
 
-Returns: Spawned worker instances.
+Returns: Worker traversal context.
 
-### resolveCostName
+### evaluateGenomeAmountTimes
 
 ```ts
-resolveCostName(
-  cost: CostFunctionOrRef,
-): string
+evaluateGenomeAmountTimes(
+  genome: default,
+  set: TrainingSample[],
+  cost: EvolveCostFunction,
+  amount: number,
+): number
 ```
 
-Resolve serializable cost name for worker payload.
+Evaluate one genome repeatedly and accumulate negative error.
 
 Parameters:
-- `cost` - - Cost function or cost reference.
+- `genome` - - Genome under evaluation.
+- `set` - - Dataset used for evaluation.
+- `cost` - - Cost function reference.
+- `amount` - - Number of repeated evaluations.
 
-Returns: Cost name string.
+Returns: Accumulated negative error or -Infinity on failure.
 
-### buildPopulationWorkerFitnessFunction
+### evaluateGenomeErrorSafely
 
 ```ts
-buildPopulationWorkerFitnessFunction(
-  workers: TestWorkerInstance[],
-  growth: number,
-): PopulationFitnessFunction
+evaluateGenomeErrorSafely(
+  genome: default,
+  set: TrainingSample[],
+  cost: EvolveCostFunction,
+): number | null
 ```
 
-Build population-level fitness function powered by worker queue.
+Evaluate one genome and return error, with warning-protected failure handling.
 
 Parameters:
-- `workers` - - Spawned worker instances.
-- `growth` - - Complexity penalty scalar.
+- `genome` - - Genome under evaluation.
+- `set` - - Dataset used for evaluation.
+- `cost` - - Cost function reference.
 
-Returns: Population-level fitness function.
+Returns: Error value, or null when evaluation fails.
 
-### createPopulationWorkerEvaluationContext
+### evaluateGenomeWithWorker
 
 ```ts
-createPopulationWorkerEvaluationContext(
-  sourceWorkers: TestWorkerInstance[],
-  sourcePopulation: default[],
-  sourceGrowth: number,
-  sourceResolve: () => void,
-): PopulationWorkerEvaluationContext
+evaluateGenomeWithWorker(
+  worker: TestWorkerInstance,
+  genome: default,
+  growth: number,
+): Promise<void>
 ```
 
-Creates the shared evaluation context for one population run.
+Evaluate one genome with a worker and assign penalized score.
 
 Parameters:
-- `sourceWorkers` - - Worker pool.
-- `sourcePopulation` - - Population to evaluate.
-- `sourceGrowth` - - Complexity penalty scalar.
-- `sourceResolve` - - Promise resolver.
+- `worker` - - Worker instance.
+- `genome` - - Genome under evaluation.
+- `growth` - - Complexity penalty scalar.
 
-Returns: Population evaluation context.
+Returns: Promise resolving when score assignment completes.
 
-### hasNoWorkers
+### finalizeWorker
 
 ```ts
-hasNoWorkers(
+finalizeWorker(
   context: PopulationWorkerEvaluationContext,
-): boolean
+): void
 ```
 
-Checks whether there are workers available to process genomes.
+Marks one worker as completed and resolves when all workers finish.
 
 Parameters:
 - `context` - - Population evaluation context.
 
-Returns: True when worker pool is empty.
+Returns: Nothing.
 
-### startWorkerTraversal
+### getCachedComplexityBase
 
 ```ts
-startWorkerTraversal(
-  context: PopulationWorkerEvaluationContext,
-): void
+getCachedComplexityBase(
+  genome: default,
+  structureCounts: GenomeStructureCounts,
+): number | null
 ```
 
-Starts traversal loops for all workers.
+Retrieve cached complexity base if cached structure counts still match.
 
 Parameters:
-- `context` - - Population evaluation context.
+- `genome` - - Candidate network whose cached complexity is queried.
+- `structureCounts` - - Current structural counts.
 
-Returns: Nothing.
+Returns: Cached complexity base or null when cache miss occurs.
 
-### createWorkerTraversalContext
+### getGenomeStructureCounts
 
 ```ts
-createWorkerTraversalContext(
-  context: PopulationWorkerEvaluationContext,
-  worker: TestWorkerInstance,
-): WorkerTraversalContext
+getGenomeStructureCounts(
+  genome: default,
+): GenomeStructureCounts
 ```
 
-Creates traversal context for one worker.
+Get structural counts used by complexity heuristic.
 
 Parameters:
-- `context` - - Population evaluation context.
-- `worker` - - Worker instance.
+- `genome` - - Candidate network whose structure is being measured.
 
-Returns: Worker traversal context.
+Returns: Structural counts used for complexity computation.
 
-### runWorkerTraversalStep
+### hasNoWorkers
 
 ```ts
-runWorkerTraversalStep(
-  traversalContext: WorkerTraversalContext,
-): void
+hasNoWorkers(
+  context: PopulationWorkerEvaluationContext,
+): boolean
 ```
 
-Runs one asynchronous traversal step for a worker.
+Checks whether there are workers available to process genomes.
 
 Parameters:
-- `traversalContext` - - Worker traversal context.
+- `context` - - Population evaluation context.
 
-Returns: Nothing.
+Returns: True when worker pool is empty.
 
-### claimNextGenome
+### installWorkerTerminationHook
 
 ```ts
-claimNextGenome(
-  context: PopulationWorkerEvaluationContext,
-): default | undefined
+installWorkerTerminationHook(
+  options: Record<string, unknown>,
+  workers: TestWorkerInstance[],
+): void
 ```
 
-Claims the next genome index from shared queue state.
+Register worker termination hook onto options object.
 
 Parameters:
-- `context` - - Population evaluation context.
+- `options` - - Evolve options object.
+- `workers` - - Spawned worker instances.
 
-Returns: Next genome, or undefined when queue is exhausted.
+Returns: Nothing.
 
-### finalizeWorker
+### resolveCostName
 
 ```ts
-finalizeWorker(
-  context: PopulationWorkerEvaluationContext,
-): void
+resolveCostName(
+  cost: CostFunctionOrRef,
+): string
 ```
 
-Marks one worker as completed and resolves when all workers finish.
+Resolve serializable cost name for worker payload.
 
 Parameters:
-- `context` - - Population evaluation context.
+- `cost` - - Cost function or cost reference.
 
-Returns: Nothing.
+Returns: Cost name string.
 
 ### resolveEvaluation
 
@@ -813,71 +805,79 @@ Parameters:
 
 Returns: Nothing.
 
-### getGenomeStructureCounts
+### resolveTestWorkerConstructor
 
 ```ts
-getGenomeStructureCounts(
-  genome: default,
-): GenomeStructureCounts
+resolveTestWorkerConstructor(): Promise<TestWorkerConstructor | null>
 ```
 
-Get structural counts used by complexity heuristic.
+Resolve worker constructor for current runtime environment.
+
+Returns: Worker constructor or null when unavailable.
+
+### runWorkerTraversalStep
+
+```ts
+runWorkerTraversalStep(
+  traversalContext: WorkerTraversalContext,
+): void
+```
+
+Runs one asynchronous traversal step for a worker.
 
 Parameters:
-- `genome` - - Candidate network whose structure is being measured.
+- `traversalContext` - - Worker traversal context.
 
-Returns: Structural counts used for complexity computation.
+Returns: Nothing.
 
-### getCachedComplexityBase
+### spawnTestWorkers
 
 ```ts
-getCachedComplexityBase(
-  genome: default,
-  structureCounts: GenomeStructureCounts,
-): number | null
+spawnTestWorkers(
+  workerConstructor: TestWorkerConstructor,
+  serializedSet: number[],
+  cost: CostFunctionOrRef,
+  threads: number,
+): TestWorkerInstance[]
 ```
 
-Retrieve cached complexity base if cached structure counts still match.
+Spawn worker instances up to requested thread count.
 
 Parameters:
-- `genome` - - Candidate network whose cached complexity is queried.
-- `structureCounts` - - Current structural counts.
+- `workerConstructor` - - Worker constructor resolved for runtime.
+- `serializedSet` - - Serialized dataset shared with workers.
+- `cost` - - Cost function or cost reference.
+- `threads` - - Requested worker count.
 
-Returns: Cached complexity base or null when cache miss occurs.
+Returns: Spawned worker instances.
 
-### computeComplexityBase
+### startWorkerTraversal
 
 ```ts
-computeComplexityBase(
-  genome: default,
-  structureCounts: GenomeStructureCounts,
-): number
+startWorkerTraversal(
+  context: PopulationWorkerEvaluationContext,
+): void
 ```
 
-Compute non-scaled complexity base from structural counts.
+Starts traversal loops for all workers.
 
 Parameters:
-- `genome` - - Candidate network whose complexity to compute.
-- `structureCounts` - - Current structural counts.
+- `context` - - Population evaluation context.
 
-Returns: Base complexity value before growth scaling.
+Returns: Nothing.
 
-### cacheComplexityBase
+### warnGenomeEvaluationFailure
 
 ```ts
-cacheComplexityBase(
-  genome: default,
-  structureCounts: GenomeStructureCounts,
-  complexityBase: number,
+warnGenomeEvaluationFailure(
+  error: unknown,
 ): void
 ```
 
-Store complexity base cache entry for future reuse.
+Emit warning when genome evaluation fails.
 
 Parameters:
-- `genome` - - Candidate network used as cache key.
-- `structureCounts` - - Current structural counts.
-- `complexityBase` - - Computed base complexity value.
+- `error` - - Unknown evaluation error.
 
 Returns: Nothing.
 
@@ -904,21 +904,6 @@ Parameters:
 
 Returns: Nothing.
 
-### terminateWorkersSafely
-
-```ts
-terminateWorkersSafely(
-  evolveOptions: EvolveOptions,
-): void
-```
-
-Terminate worker resources registered in options.
-
-Parameters:
-- `evolveOptions` - - Evolve options object.
-
-Returns: Nothing.
-
 ### buildEvolutionSummary
 
 ```ts
@@ -937,3 +922,18 @@ Parameters:
 - `loopStartTime` - - Loop start timestamp.
 
 Returns: Evolution summary object.
+
+### terminateWorkersSafely
+
+```ts
+terminateWorkersSafely(
+  evolveOptions: EvolveOptions,
+): void
+```
+
+Terminate worker resources registered in options.
+
+Parameters:
+- `evolveOptions` - - Evolve options object.
+
+Returns: Nothing.