anchor.diff:  
       /// Transforms a constrained value.
       type 'a Transformer =
  -        single -> Constraint -> 'a -> struct ('a * Output)
  +        int64 -> Constraint -> 'a array -> ('a array * Output)
   
       [<AutoOpen>]
       module Transformer =
   
           /// Pipe two transformers.
           let pipe (transformer : 'a Transformer) (transformer2 : 'a Transformer) : 'a Transformer =
  -            fun progress constrain a ->
  -                let struct (a, output) = transformer progress constrain a
  -                let struct (a, output2) = transformer2 progress constrain a
  -                struct (a, output + output2)
  +            fun time constrain targets ->
  +                let (targets, output) = transformer time constrain targets
  +                let (targets, output2) = transformer2 time constrain targets
  +                (targets, output + output2)
   
           /// Pipe multiple transformers.
           let pipeMany transformers =
  
positive.code:     /// The forces that may operate on a target.
      type Forces = single array
  
      /// Describes the life of an instance value.
      /// OPTIMIZATION: LifeTimeOpt uses 0L to represent infinite life.
      /// OPTIMIZATION: doesn't use Liveness type to avoid its constructor calls.
  
negative.code: 
      /// Scopes transformable values.
      type [<NoEquality; NoComparison>] Scope<'a, 'b when 'a : struct> =
          { In : 'a array -> 'b array
            Out : ('b array * Output) -> 'a array -> ('a array * Output) }
  
      [<RequireQualifiedAccess>]
      module Scope =
  
          /// Make a scope.
          let inline make<'a, 'b when 'a : struct> (getField : 'a -> 'b) (setField : 'b -> 'a -> 'a) : Scope<'a, 'b> =
              { In = Array.map getField
                Out = fun (fields, output) (targets : 'a array) -> (Array.map2 setField fields targets, output) }
  
      /// The base behavior type.
      type Behavior =
  