Why does my for-range over a super type give super-type values when the start and end are subtype objects?

#!ek9
defines module qa.controlflow.range.declared.super

  defines class

    Step as open
      position as Integer: 0

      Step()
        -> start as Integer
        this.position: start

      //The copy constructor: a range makes its own values with it. It COPIES the position (':=:'), so the
      //range's '++' on its own values never reaches the object it was copied from.
      Step()
        -> other as Step
        position :=: other.place()

      place() as pure
        <- rtn as Integer: position

      kind() as pure
        <- rtn as String: "Step"

      operator <=> as pure
        -> other as Step
        <- rtn as Integer: position <=> other.place()

      operator #? as pure
        <- rtn as Integer: #? position

      operator ++
        position++

      operator --
        position--

      operator $ as pure
        <- rtn as String: `${kind()}(${position})`

      default operator ?

    TenStep extends Step
      TenStep()
        -> start as Integer
        super(start)

      TenStep()
        -> other as TenStep
        super(other)

      override kind() as pure
        <- rtn as String: "TenStep"

  defines function

    describe()
      -> step as Step
      <- rtn as String: `${step} is a ${step.kind()}`

  defines program

    RangeOverDeclaredSuper()
      stdout <- Stdout()
      first as Step: TenStep(1)
      last as Step: TenStep(3)

      //Declared as Step: the values are Steps.
      for step in first ... last
        stdout.println(describe(step))

      //Declared as the subtype: the values are TenSteps.
      for tenStep in TenStep(1) ... TenStep(2)
        stdout.println(describe(tenStep))

      stdout.println(`first is still ${first}`)