Backpack does not handle unlifted types

In the code snippet below, I attempt to use backpack with levity polymorphism:

{-# LANGUAGE MagicHash #-}
{-# LANGUAGE TypeInType #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE DataKinds #-}

unit number-unknown where
  signature NumberUnknown where
    import GHC.Types
    data Number 
    plus :: Number -> Number -> Number
    multiply :: Number -> Number -> Number
  module NumberStuff where
    import NumberUnknown
    funcA :: Number -> Number -> Number
    funcA x y = plus x (multiply x y)

unit number-int where
  module NumberUnknown where
    type Number = Int
    plus :: Int -> Int -> Int
    plus = (+)
    multiply :: Int -> Int -> Int
    multiply = (*)

unit number-unboxed-int where
  module NumberUnknown where
    import GHC.Prim
    type Number = Int#
    plus :: Int# -> Int# -> Int#
    plus = (+#)
    multiply :: Int# -> Int# -> Int#
    multiply = (*#)

unit main where
  dependency number-unknown[NumberUnknown=number-unboxed-int:NumberUnknown]
  module Main where
    import NumberStuff
    main = putStrLn "Hello world!"

Compiling this with ghc --backpack packer.bkp fails with the following error:

    - Type constructor ‘Number’ has conflicting definitions in the module
      and its hsig file
      Main module: type Number = GHC.Prim.Int# :: TYPE 'GHC.Types.IntRep
      Hsig file:  data Number
      The types have different kinds
    - while checking that number-unboxed-int:NumberUnknown implements signature NumberUnknown in number-unknown[NumberUnknown=number-unboxed-int:NumberUnknown]

        type Number = Int#

The error is pretty clear: Number can only be instantiated by types of kind Type (aka TYPE LiftedRep). Even while remaining levity monomorphic, there doesn't seem to be a way to pick a different kind. For example, redefining Number in the signature as

data Number :: TYPE IntRep

leads to the following immediate failure:

Kind signature on data type declaration has non-* return kind TYPE 'IntRep

I do not understand any of the internals of backpack, so I do not understand if there's anything fundamental that makes this impossible. Going one step further, I would like to be able to do something like this (the syntax here is not even currently valid for a backpack signature):

type MyRep :: RuntimeRep
data Number :: TYPE MyRep

This may be instantiated with something like this:

type MyRep = IntRep
type Number = Int#

And then end users would be able to monomorphize levity-polymorphic functions. This would be really neat because there is currently no way to do this in GHC.

So, I guess there are really two feature requests in here. One is the ability to use unlifted data types with backpack. The other is the ability to use backpack to monomorphize levity-polymorphic functions.

It seems unlikely to sneak this into GHC 8.2 but who knows!