@reicek/neataptic-ts 0.1.22 → 0.1.24

package/test/examples/asciiMaze/evolutionEngine/neatConfiguration.ts

@@ -98,6 +98,13 @@ export const createNeat = (
   fitnessCallback: (net: Network) => number,
   cfg?: NeatConfig,
 ): Neat => {
+  const NeatNetworkConstructor = Neat as unknown as new (
+    input: number,
+    output: number,
+    fitness: (network: Network) => unknown,
+    options: NeatConfig,
+  ) => Neat;
+
   // Default constants (extracted from EvolutionEngine static fields)
   const DEFAULT_POPSIZE = 150;
   const DEFAULT_ELITISM_FRACTION = 0.05;
@@ -162,23 +169,28 @@ export const createNeat = (
   };
 
   // Step 4: Instantiate the Neat driver with the assembled options.
-  const neatInstance = new Neat(inputCount, outputCount, fitnessCallback, {
-    popsize: popSize,
-    mutation: mutationOps,
-    mutationRate: DEFAULT_MUTATION_RATE,
-    mutationAmount: DEFAULT_MUTATION_AMOUNT,
-    elitism,
-    provenance,
-    allowRecurrent,
-    minHidden: DEFAULT_MIN_HIDDEN,
-    adaptiveMutation,
-    multiObjective,
-    telemetry,
-    lineageTracking,
-    novelty,
-    targetSpecies,
-    adaptiveTargetSpecies,
-  });
+  const neatInstance = new NeatNetworkConstructor(
+    inputCount,
+    outputCount,
+    fitnessCallback,
+    {
+      popsize: popSize,
+      mutation: mutationOps,
+      mutationRate: DEFAULT_MUTATION_RATE,
+      mutationAmount: DEFAULT_MUTATION_AMOUNT,
+      elitism,
+      provenance,
+      allowRecurrent,
+      minHidden: DEFAULT_MIN_HIDDEN,
+      adaptiveMutation,
+      multiObjective,
+      telemetry,
+      lineageTracking,
+      novelty,
+      targetSpecies,
+      adaptiveTargetSpecies,
+    },
+  );
 
   return neatInstance;
 };

package/test/examples/asciiMaze/evolutionEngine/networkInspection.ts

@@ -25,8 +25,18 @@
 
 import type { INetwork } from '../interfaces';
 import type { EngineState } from './engineState';
+import type { NetworkConnection, NetworkNode } from './evolutionEngine.types';
 import { ensureConnFlagsCapacity } from './scratchPools';
 
+interface ClassifiedNodeBuckets {
+  nodeList: NetworkNode[];
+  inputNodes: NetworkNode[];
+  hiddenNodes: NetworkNode[];
+  outputNodes: NetworkNode[];
+}
+
+type NodeBucketPool = [NetworkNode[], NetworkNode[], NetworkNode[]];
+
 /**
  * Utility to explicitly mark swallowed errors for lint compliance.
  *
@@ -61,9 +71,7 @@ export const swallowError = (error: unknown): void => {
  * @param network - Network-like object with an optional `nodes` array.
  * @returns Safe array reference (network.nodes or empty array).
  */
-// Type assertion: Network nodes are dynamically typed structures with variable properties
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const normalizeNodesArray = (network: INetwork): any[] => {
+const normalizeNodesArray = (network: INetwork): NetworkNode[] => {
   return Array.isArray(network?.nodes) ? network.nodes : [];
 };
 
@@ -95,29 +103,16 @@ const normalizeNodesArray = (network: INetwork): any[] => {
  */
 const classifyNodesFromArray = (
   engineState: EngineState,
-  // Type assertion: Network nodes are dynamically typed structures with variable properties
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  nodesArray: any[],
-): {
-  // Type assertion: Network nodes are dynamically typed structures with variable properties
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  nodeList: any[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  inputNodes: any[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  hiddenNodes: any[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  outputNodes: any[];
-} => {
+  nodesArray: NetworkNode[],
+): ClassifiedNodeBuckets => {
   // Step 1: Normalise the incoming node list to a safe, non-null array reference.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const nodeList: any[] = Array.isArray(nodesArray) ? nodesArray : [];
+  const nodeList: NetworkNode[] = Array.isArray(nodesArray) ? nodesArray : [];
 
   // Step 2: Lazily create / reuse the pooled buckets structure on the state.
   const scratchBundle = engineState.scratch;
-  let pooledBuckets = scratchBundle.nodeBuckets;
+  let pooledBuckets = scratchBundle.nodeBuckets as NodeBucketPool | undefined;
   if (!Array.isArray(pooledBuckets?.[0])) {
-    pooledBuckets = scratchBundle.nodeBuckets = [[], [], []];
+    pooledBuckets = scratchBundle.nodeBuckets = [[], [], []] as NodeBucketPool;
   }
 
   // Descriptive bucket aliases for readability.
@@ -177,17 +172,7 @@ const classifyNodesFromArray = (
 const classifyNodes = (
   engineState: EngineState,
   network: INetwork,
-): {
-  // Type assertion: Network nodes are dynamically typed structures with variable properties
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  nodeList: any[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  inputNodes: any[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  hiddenNodes: any[];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  outputNodes: any[];
-} => {
+): ClassifiedNodeBuckets => {
   // Orchestrator: normalize inputs then delegate to the fast, allocation-light classifier.
   const normalizedNodeList = normalizeNodesArray(network);
   return classifyNodesFromArray(engineState, normalizedNodeList);
@@ -221,9 +206,7 @@ const gatherActivationNames = (
   network: INetwork,
 ): string[] => {
   // Step 1: Safe normalisation of the node list reference.
-  // Type assertion: Network nodes are dynamically typed structures with variable properties
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const nodesArray: any[] = Array.isArray(network?.nodes) ? network.nodes : [];
+  const nodesArray = normalizeNodesArray(network);
   const nodesCount = nodesArray.length;
 
   // Step 2: Lazily ensure the shared pool exists.
@@ -294,9 +277,7 @@ const gatherActivationNames = (
  */
 const detectRecurrentOrGated = (
   engineState: EngineState,
-  // Type assertion: Network connections are dynamically typed structures with variable properties
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  connectionsList: any[],
+  connectionsList: NetworkConnection[],
 ): boolean => {
   // Step 1: Validate input quickly
   if (!Array.isArray(connectionsList) || connectionsList.length === 0)

package/test/examples/asciiMaze/evolutionEngine/optionsAndSetup.ts

@@ -25,8 +25,71 @@ import { Network } from '../../../../src/neataptic';
 import { MazeUtils } from '../mazeUtils';
 import { FitnessEvaluator } from '../fitness';
 import type { IFitnessEvaluationContext } from '../fitness.types';
-import type { IRunMazeEvolutionOptions } from './evolutionEngine.types';
+import type {
+  IEvolutionAlgorithmConfig,
+  IMazeConfig,
+  IReportingConfig,
+  IRunMazeEvolutionOptions,
+  ScratchBundle,
+} from './evolutionEngine.types';
 import { createNeat, seedInitialPopulation } from './neatConfiguration';
+import type { NeatConfig } from './neatConfiguration';
+
+interface NormalizedRunOptions {
+  mazeConfig?: IMazeConfig;
+  agentSimConfig: IFitnessEvaluationContext['agentSimConfig'];
+  evolutionAlgorithmConfig: IEvolutionAlgorithmConfig;
+  reportingConfig: IReportingConfig | Record<string, never>;
+  fitnessEvaluator?: IRunMazeEvolutionOptions['fitnessEvaluator'];
+  popSize: number;
+  allowRecurrent: boolean;
+  maxStagnantGenerations: number;
+  minProgressToPass: number;
+  maxGenerations: number;
+  randomSeed?: number;
+  initialPopulation?: IEvolutionAlgorithmConfig['initialPopulation'];
+  initialBestNetwork?: IEvolutionAlgorithmConfig['initialBestNetwork'];
+  lamarckianIterations: number;
+  lamarckianSampleSize?: number;
+  plateauGenerations: number;
+  plateauImprovementThreshold: number;
+  simplifyDuration: number;
+  simplifyPruneFraction: number;
+  simplifyStrategy: NonNullable<IEvolutionAlgorithmConfig['simplifyStrategy']>;
+  persistEvery: number;
+  persistDir: string;
+  persistTopK: number;
+  dynamicPopEnabled: boolean;
+  dynamicPopMax: number;
+  dynamicPopExpandInterval: number;
+  dynamicPopExpandFactor: number;
+  dynamicPopPlateauSlack: number;
+  stopOnlyOnSolve: boolean;
+  autoPauseOnSolve: boolean;
+  deterministic: boolean;
+  memoryCompactionInterval: number;
+  telemetryReduceStats: boolean;
+  telemetryMinimal: boolean;
+  disableBaldwinianRefinement: boolean;
+  neatOptions: NeatConfig;
+  maze?: string[];
+}
+
+interface PreparedRunEnvironment {
+  encodedMaze: IFitnessEvaluationContext['encodedMaze'];
+  startPosition: IFitnessEvaluationContext['startPosition'];
+  exitPosition: IFitnessEvaluationContext['exitPosition'];
+  distanceMap: NonNullable<IFitnessEvaluationContext['distanceMap']>;
+  inputSize: number;
+  outputSize: number;
+  fitnessContext: IFitnessEvaluationContext;
+}
+
+interface CreateAndSeedNeatResult {
+  neat: ReturnType<typeof createNeat> | null;
+  scratchPopClone: Network[];
+  scratchSample: unknown[];
+}
 
 /**
  * Normalize and validate run options with sensible defaults.
@@ -89,9 +152,7 @@ export const normalizeRunOptions = (
   setReducedTelemetry: (enabled: boolean) => void,
   setMinimalTelemetry: (enabled: boolean) => void,
   setDisableBaldwin: (disabled: boolean) => void,
-  // Type assertion: Return type contains mixed configuration from user options
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): any => {
+): NormalizedRunOptions => {
   // Step 1: normalise option groups using nullish coalescing for robustness.
   const mazeConfig = options?.mazeConfig;
   const agentSimConfig = options?.agentSimConfig ?? {};
@@ -147,7 +208,7 @@ export const normalizeRunOptions = (
       : Math.max(popSize, 120);
 
   // Step 5: compose the final normalised options object (shape expected by callers).
-  return {
+  const normalizedOptions: NormalizedRunOptions = {
     mazeConfig,
     agentSimConfig,
     evolutionAlgorithmConfig,
@@ -209,9 +270,9 @@ export const normalizeRunOptions = (
       },
     },
     maze: mazeConfig?.maze,
-    // Type assertion: Mixed configuration object with diverse property types
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  } as any;
+  };
+
+  return normalizedOptions;
 };
 
 /**
@@ -257,17 +318,16 @@ export const normalizeRunOptions = (
  * const neat = createAndSeedNeat(normalizedOpts, env.inputSize, env.outputSize, env.fitnessContext);
  */
 export const prepareEnvironmentForRun = (
-  // Type assertion: Accepts normalized options with mixed types from normalizeRunOptions
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  opts: any,
-  // Type assertion: Scratch bundle contains dynamic pooled structures
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  scratchBundle: any,
-  // Type assertion: Returns diverse environment properties for evolution setup
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): any => {
+  opts: NormalizedRunOptions,
+  scratchBundle: ScratchBundle,
+): PreparedRunEnvironment => {
   // Step 1: Resolve the maze input in a null-safe way.
   const mazeSource = opts?.maze ?? opts?.mazeConfig?.maze;
+  if (!Array.isArray(mazeSource)) {
+    throw new Error(
+      'ASCII Maze requires a maze layout before environment setup.',
+    );
+  }
 
   // Step 2: Encode the maze (delegated to MazeUtils). Keep the variable name explicit.
   const encodedMaze = MazeUtils.encodeMaze(mazeSource);
@@ -295,7 +355,7 @@ export const prepareEnvironmentForRun = (
   // Best-effort: warm a couple of small engine-level pools to reduce first-use allocations.
   try {
     if (!Array.isArray(scratchBundle.samplePool)) {
-      scratchBundle.samplePool = new Array(32);
+      scratchBundle.samplePool = new Array<unknown>(32);
     }
     if (!(scratchBundle.profilingScratch instanceof Float64Array)) {
       scratchBundle.profilingScratch = new Float64Array(4);
@@ -360,26 +420,18 @@ export const prepareEnvironmentForRun = (
  * );
  */
 export const createAndSeedNeat = (
-  // Type assertion: Accepts normalized options with mixed types from normalizeRunOptions
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  opts: any,
+  opts: NormalizedRunOptions,
   inputSize: number,
   outputSize: number,
   fitnessContext: IFitnessEvaluationContext,
-  // Type assertion: Pooled clone buffer for network population
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  scratchPopClone: any[],
-  // Type assertion: Pooled sample buffer for selection operations
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  scratchSample: any[],
-  // Type assertion: Returns NEAT driver and updated scratch buffers
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): any => {
+  scratchPopClone: Network[],
+  scratchSample: unknown[],
+): CreateAndSeedNeatResult => {
   try {
     // Step 1: Build a descriptive, bound fitness callback.
-    const fitnessCallback = (network: Network) =>
+    const fitnessCallback = (network: Network): number =>
       (opts.fitnessEvaluator ?? FitnessEvaluator.defaultFitnessEvaluator)(
-        network,
+        network as unknown as import('../interfaces').INetwork,
         fitnessContext,
       );
 
@@ -394,8 +446,8 @@ export const createAndSeedNeat = (
     // Step 3: Seed the newly created driver using provided initial population / best network.
     scratchPopClone = seedInitialPopulation(
       neatDriver,
-      opts.initialPopulation ?? undefined,
-      opts.initialBestNetwork ?? undefined,
+      opts.initialPopulation as Network[] | undefined,
+      opts.initialBestNetwork as Network | undefined,
       Number.isFinite(opts.popSize) ? Math.max(0, Math.floor(opts.popSize)) : 0,
       scratchPopClone,
     );
@@ -422,10 +474,18 @@ export const createAndSeedNeat = (
       // Best-effort: swallow sample buffer warm-up errors.
     }
 
-    return { neat: neatDriver, scratchPopClone, scratchSample };
+    return {
+      neat: neatDriver,
+      scratchPopClone: scratchPopClone as Network[],
+      scratchSample,
+    };
   } catch {
     // Top-level safety net: return null driver on catastrophic failure.
     // Caller should check for null and handle gracefully.
-    return { neat: null, scratchPopClone, scratchSample };
+    return {
+      neat: null,
+      scratchPopClone: scratchPopClone as Network[],
+      scratchSample,
+    };
   }
 };