JelloSwift – Build Information – Swift Package Index

Has it really been five years since Swift Package Index launched? Read our anniversary blog post!

Build Information

Failed to build JelloSwift, reference master (ce1dac), with Swift 6.1 for Wasm on 29 May 2025 16:43:06 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4606859-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi 2>&1

Build Log

 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:93:24: error: cannot find type 'JFloat' in scope
 91 |     /// Inits a vector 2 with X and Y defined as a given float
 92 |     @inlinable
 93 |     public init(value: JFloat) {
    |                        `- error: cannot find type 'JFloat' in scope
 94 |         x = value
 95 |         y = value
/host/spi-builder-workspace/Sources/Body.swift:50:28: error: cannot find type 'JFloat' in scope
  48 |     /// 1 never decelerates. Values outside the range [0, 1] inclusive may
  49 |     /// introduce instability
  50 |     public var velDamping: JFloat = 0.999
     |                            `- error: cannot find type 'JFloat' in scope
  51 |
  52 |     /// The array of body components for this body object
/host/spi-builder-workspace/Sources/Body.swift:63:47: error: cannot find type 'JFloat' in scope
  61 |
  62 |     /// The derived rotation of the body, in radians
  63 |     public fileprivate(set) var derivedAngle: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
/host/spi-builder-workspace/Sources/Body.swift:66:47: error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
  66 |     public fileprivate(set) var derivedOmega: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
/host/spi-builder-workspace/Sources/Body.swift:69:32: error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
  69 |     fileprivate var lastAngle: JFloat = 0
     |                                `- error: cannot find type 'JFloat' in scope
  70 |
  71 |     /// Gets a list of vertices that represents the current position of each
/host/spi-builder-workspace/Sources/Body.swift:143:23: error: cannot find type 'JFloat' in scope
 141 |         world: World? = nil,
 142 |         shape: ClosedShape,
 143 |         pointMasses: [JFloat] = [1],
     |                       `- error: cannot find type 'JFloat' in scope
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
/host/spi-builder-workspace/Sources/Body.swift:145:16: error: cannot find type 'JFloat' in scope
 143 |         pointMasses: [JFloat] = [1],
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
     |                `- error: cannot find type 'JFloat' in scope
 146 |         scale: Vector2 = Vector2.unit,
 147 |         kinematic: Bool = false,
/host/spi-builder-workspace/Sources/Body.swift:305:39: error: cannot find type 'JFloat' in scope
 303 |     /// - parameter forceUpdate:
 304 |     ///     Whether to force the update of the body, even if it's a static body.
 305 |     public func updateAABB(_ elapsed: JFloat, forceUpdate: Bool) {
     |                                       `- error: cannot find type 'JFloat' in scope
 306 |         guard !isStatic || forceUpdate else {
 307 |             return
/host/spi-builder-workspace/Sources/Body.swift:361:36: error: cannot find type 'JFloat' in scope
 359 |
 360 |     /// Sets the mass for all the PointMass objects in this body.
 361 |     public func setMassAll(_ mass: JFloat) {
     |                                    `- error: cannot find type 'JFloat' in scope
 362 |         for i in 0..<pointMasses.count {
 363 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:370:63: error: cannot find type 'JFloat' in scope
 368 |
 369 |     /// Sets the mass for a single PointMass individually.
 370 |     public func setMassForPointMass(atIndex index: Int, mass: JFloat) {
     |                                                               `- error: cannot find type 'JFloat' in scope
 371 |         pointMasses[index].mass = mass
 372 |
/host/spi-builder-workspace/Sources/Body.swift:381:43: error: cannot find type 'JFloat' in scope
 379 |     /// sets up to the count of masses in the array, if larger, it sets the
 380 |     /// matching masses for all point masses, and ignores the rest of the array.
 381 |     public func setMass(fromList masses: [JFloat]) {
     |                                           `- error: cannot find type 'JFloat' in scope
 382 |         for (mass, i) in zip(masses, 0..<pointMasses.count) {
 383 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:394:57: error: cannot find type 'JFloat' in scope
 392 |     /// Setting the position and angle resets the current shape to the original
 393 |     /// base shape of the object.
 394 |     public func setPositionAngle(_ pos: Vector2, angle: JFloat, scale: Vector2) {
     |                                                         `- error: cannot find type 'JFloat' in scope
 395 |         let matrix = Vector2.matrix(scalingBy: scale, rotatingBy: angle, translatingBy: pos)
 396 |
/host/spi-builder-workspace/Sources/Body.swift:424:51: error: cannot find type 'JFloat' in scope
 422 |     /// call this. Instead you can just access the `derivedPosition`, `DerivedAngle`,
 423 |     /// `derivedVelocity`, and `derivedOmega` properties.
 424 |     public func derivePositionAndAngle(_ elapsed: JFloat) {
     |                                                   `- error: cannot find type 'JFloat' in scope
 425 |         // No need if this is a static body, or kinematically controlled.
 426 |         if isStatic || isKinematic {
/host/spi-builder-workspace/Sources/Body.swift:522:38: error: cannot find type 'JFloat' in scope
 520 |     /// Integrates the point masses for this Body.
 521 |     /// Ignored, if body is static.
 522 |     public func integrate(_ elapsed: JFloat) {
     |                                      `- error: cannot find type 'JFloat' in scope
 523 |         if isStatic {
 524 |             return
/host/spi-builder-workspace/Sources/Body.swift:536:43: error: cannot find type 'JFloat' in scope
 534 |     /// Applies the velocity damping to the point masses.
 535 |     /// Ignored, if body is static.
 536 |     public func dampenVelocity(_ elapsed: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 537 |         if isStatic {
 538 |             return
/host/spi-builder-workspace/Sources/Body.swift:550:39: error: cannot find type 'JFloat' in scope
 548 |     /// Applies a rotational clockwise torque of a given force on this body.
 549 |     /// Ignored, if body is static.
 550 |     public func applyTorque(of force: JFloat) {
     |                                       `- error: cannot find type 'JFloat' in scope
 551 |         if isStatic {
 552 |             return
/host/spi-builder-workspace/Sources/Body.swift:569:43: error: cannot find type 'JFloat' in scope
 567 |     /// The method keeps the average velocity of the point masses the same during
 568 |     /// the procedure.
 569 |     public func setAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 570 |         if isStatic {
 571 |             return
/host/spi-builder-workspace/Sources/Body.swift:583:43: error: cannot find type 'JFloat' in scope
 581 |
 582 |     /// Accumulates the angular velocity for this body
 583 |     public func addAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 584 |         if isStatic {
 585 |             return
/host/spi-builder-workspace/Sources/Body.swift:743:54: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:743:72: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:810:54: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:810:72: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:835:80: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:835:98: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                                  `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:891:45: error: cannot find type 'JFloat' in scope
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
     |                                             `- error: cannot find type 'JFloat' in scope
 892 |         if edges.count == 0 || pointMasses.count == 0 {
 893 |             return nil
/host/spi-builder-workspace/Sources/Body.swift:890:34: error: cannot find type 'JFloat' in scope
 888 |     public func closestEdge(
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
     |                                  `- error: cannot find type 'JFloat' in scope
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
 892 |         if edges.count == 0 || pointMasses.count == 0 {
/host/spi-builder-workspace/Sources/Body.swift:936:77: error: cannot find type 'JFloat' in scope
 934 |     /// Find the closest PointMass index in this body, given a global point
 935 |     /// - precondition: There is at least one point mass in this body
 936 |     public func closestPointMass(to pos: Vector2) -> (point: Int, distance: JFloat) {
     |                                                                             `- error: cannot find type 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:36:24: error: cannot find type 'JFloat' in scope
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                        `- error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
/host/spi-builder-workspace/Sources/BodyEdge.swift:39:31: error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                               `- error: cannot find type 'JFloat' in scope
40 |
41 |     public init() {
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:284:45: error: cannot find type 'JFloat' in scope
282 |
283 |     @inlinable
284 |     static public func %(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
285 |         return Vector2(x: lhs.x.truncatingRemainder(dividingBy: rhs),
286 |                        y: lhs.y.truncatingRemainder(dividingBy: rhs))
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:274:46: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func % (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
275 |         return Vector3(
276 |             x: lhs.x.truncatingRemainder(dividingBy: rhs),
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:264:45: error: cannot find type 'JFloat' in scope
262 |     // JFloat interaction
263 |     @inlinable
264 |     static public func +(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
265 |         return Vector2(x: lhs.x + rhs, y: lhs.y + rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:254:46: error: cannot find type 'JFloat' in scope
252 |     // JFloat interaction
253 |     @inlinable
254 |     static public func + (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
255 |         return Vector3(x: lhs.x + rhs, y: lhs.y + rhs, z: lhs.z + rhs)
256 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:274:45: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func *(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
275 |         return Vector2(x: lhs.x * rhs, y: lhs.y * rhs)
276 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:264:46: error: cannot find type 'JFloat' in scope
262 |
263 |     @inlinable
264 |     static public func * (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
265 |         return Vector3(x: lhs.x * rhs, y: lhs.y * rhs, z: lhs.z * rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:349:27: error: cannot find type 'JFloat' in scope
347 |     static public func matrix(
348 |         scalingBy scale: Vector2 = Vector2.unit,
349 |         rotatingBy angle: JFloat = 0,
    |                           `- error: cannot find type 'JFloat' in scope
350 |         translatingBy translate: Vector2 = Vector2.zero
351 |     ) -> Matrix3x3 {
/host/spi-builder-workspace/Sources/Geometry/ClosedShape.swift:150:25: error: cannot find type 'JFloat' in scope
148 |         _ target: inout [Vector2],
149 |         worldPos: Vector2,
150 |         angleInRadians: JFloat,
    |                         `- error: cannot find type 'JFloat' in scope
151 |         localScale: Vector2 = Vector2.unit
152 |     ) {
/host/spi-builder-workspace/Sources/PointMass.swift:16:22: error: cannot find type 'JFloat' in scope
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                      `- error: cannot find type 'JFloat' in scope
17 |
18 |     /// The global position of the point, in world coordinates
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:35:23: error: cannot find type 'JFloat' in scope
33 |     }
34 |
35 |     public init(mass: JFloat = 0, position: Vector2 = Vector2.zero) {
   |                       `- error: cannot find type 'JFloat' in scope
36 |         self.mass = mass
37 |         self.position = position
/host/spi-builder-workspace/Sources/Body.swift:445:20: error: cannot find type 'JFloat' in scope
 443 |
 444 |         // find the average angle of all of the masses.
 445 |         var angle: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
/host/spi-builder-workspace/Sources/Body.swift:448:28: error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
 448 |         var originalAngle: JFloat = 0
     |                            `- error: cannot find type 'JFloat' in scope
 449 |
 450 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:221:59: error: cannot find type 'JFloat' in scope
219 |     /// See `Vector2.dot`
220 |     @inlinable
221 |     static public func •(lhs: Vector2, rhs: Vector2) -> JFloat {
    |                                                         `- error: cannot find type 'JFloat' in scope
222 |         return lhs.dot(rhs)
223 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:208:60: error: cannot find type 'JFloat' in scope
206 |     /// See `Vector3.dot`
207 |     @inlinable
208 |     static public func • (lhs: Vector3, rhs: Vector3) -> JFloat {
    |                                                          `- error: cannot find type 'JFloat' in scope
209 |         return lhs.dot(rhs)
210 |     }
/host/spi-builder-workspace/Sources/Body.swift:467:33: error: reference to member 'pi' cannot be resolved without a contextual type
 465 |                 let thisSign = (thisAngle >= 0.0) ? 1 : -1
 466 |
 467 |                 if abs(diff) > .pi && (thisSign != originalSign) {
     |                                 `- error: reference to member 'pi' cannot be resolved without a contextual type
 468 |                     if thisSign == -1 {
 469 |                         thisAngle = .pi + (.pi + thisAngle)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:316:52: error: cannot find type 'JFloat' in scope
314 |     // JFloat interaction
315 |     @inlinable
316 |     static public func +=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
317 |         lhs = lhs + rhs
318 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:309:53: error: cannot find type 'JFloat' in scope
307 |     // JFloat interaction
308 |     @inlinable
309 |     static public func += (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
310 |         lhs = lhs + rhs
311 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:328:52: error: cannot find type 'JFloat' in scope
326 |     }
327 |     @inlinable
328 |     static public func /=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
329 |         lhs = lhs / rhs
330 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:321:53: error: cannot find type 'JFloat' in scope
319 |     }
320 |     @inlinable
321 |     static public func /= (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
322 |         lhs = lhs / rhs
323 |     }
/host/spi-builder-workspace/Sources/Body.swift:479:18: error: cannot find 'JFloat' in scope
 477 |         }
 478 |
 479 |         angle /= JFloat(c)
     |                  `- error: cannot find 'JFloat' in scope
 480 |
 481 |         derivedAngle = angle
/host/spi-builder-workspace/Sources/Body.swift:486:59: error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                           `- error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Body.swift:486:63: error: reference to member 'pi' cannot be resolved without a contextual type
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                               `- error: reference to member 'pi' cannot be resolved without a contextual type
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:279:45: error: cannot find type 'JFloat' in scope
277 |
278 |     @inlinable
279 |     static public func /(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
280 |         return Vector2(x: lhs.x / rhs, y: lhs.y / rhs)
281 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:290:31: error: cannot find type 'JFloat' in scope
288 |
289 |     @inlinable
290 |     static public func /(lhs: JFloat, rhs: Vector2) -> Vector2 {
    |                               `- error: cannot find type 'JFloat' in scope
291 |         return Vector2(x: lhs / rhs.x, y: lhs / rhs.y)
292 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:269:46: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func / (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
270 |         return Vector3(x: lhs.x / rhs, y: lhs.y / rhs, z: lhs.z / rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:283:32: error: cannot find type 'JFloat' in scope
281 |
282 |     @inlinable
283 |     static public func / (lhs: JFloat, rhs: Vector3) -> Vector3 {
    |                                `- error: cannot find type 'JFloat' in scope
284 |         return Vector3(x: lhs / rhs.x, y: lhs / rhs.y, z: lhs / rhs.z)
285 |     }
/host/spi-builder-workspace/Sources/PointMass.swift:45:47: error: cannot find type 'JFloat' in scope
43 |     /// seconds
44 |     @inlinable
45 |     public mutating func integrate(_ elapsed: JFloat) {
   |                                               `- error: cannot find type 'JFloat' in scope
46 |         if mass.isFinite {
47 |             let elapsedMass = elapsed / mass
/host/spi-builder-workspace/Sources/Body.swift:544:13: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 542 |             let pointMass = pointMasses[i]
 543 |
 544 |             applyVelocity(-(pointMass.velocity - (pointMass.velocity * velDamping)) * (elapsed * 200), toPointMassAt: i)
     |             `- error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 545 |         }
 546 |     }
/host/spi-builder-workspace/Sources/Geometry/AABB.swift:53:22: error: cannot find type 'JFloat' in scope
 51 |     /// Gets the middle X position of this AABB
 52 |     @inlinable
 53 |     public var midX: JFloat {
    |                      `- error: cannot find type 'JFloat' in scope
 54 |         return (minimum.x + maximum.x) / 2
 55 |     }
/host/spi-builder-workspace/Sources/Body.swift:638:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 636 |                     // this line crosses the test line at some point... does it
 637 |                     // do so within our test range?
 638 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 639 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 640 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Body.swift:665:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 663 |                     // this line crosses the test line at some point... does it
 664 |                     // do so within our test range?
 665 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 666 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 667 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:27: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                           `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:39: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                                       `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Body.swift:748:20: error: cannot find type 'JFloat' in scope
 746 |         var hitPt: Vector2 = .zero
 747 |         var normal: Vector2 = .zero
 748 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 749 |
 750 |         var dist: JFloat = 0
/host/spi-builder-workspace/Sources/Body.swift:750:19: error: cannot find type 'JFloat' in scope
 748 |         var edgeD: JFloat = 0
 749 |
 750 |         var dist: JFloat = 0
     |                   `- error: cannot find type 'JFloat' in scope
 751 |
 752 |         let edge = edges[edgeNum]
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:108:53: error: cannot find type 'JFloat' in scope
106 |     /// Returns the distance squared between this Vector2 and another Vector2
107 |     @inlinable
108 |     public func distanceSquared(to vec: Vector2) -> JFloat {
    |                                                     `- error: cannot find type 'JFloat' in scope
109 |         let d = self - vec
110 |
/host/spi-builder-workspace/Sources/Body.swift:840:20: error: cannot find type 'JFloat' in scope
 838 |         var pointA = -1
 839 |         var pointB = -1
 840 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 841 |         var normal: Vector2 = .zero
 842 |         var hitPt: Vector2 = .zero
/host/spi-builder-workspace/Sources/Body.swift:844:24: error: cannot find 'JFloat' in scope
 842 |         var hitPt: Vector2 = .zero
 843 |
 844 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 845 |
 846 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Body.swift:900:24: error: cannot find type 'JFloat' in scope
 898 |         var closestP2 = 0// closestP1
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
     |                        `- error: cannot find type 'JFloat' in scope
 901 |         var closestD = JFloat.infinity
 902 |
/host/spi-builder-workspace/Sources/Body.swift:901:24: error: cannot find 'JFloat' in scope
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
 901 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 902 |
 903 |         for edge in edges {
/host/spi-builder-workspace/Sources/Body.swift:939:26: error: cannot find 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
 939 |         var closestSQD = JFloat.greatestFiniteMagnitude
     |                          `- error: cannot find 'JFloat' in scope
 940 |         var closest: Int!
 941 |
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:29:23: error: cannot find type 'JFloat' in scope
27 |     /// A value from 0 - 1 specifying at which point in the edge
28 |     /// bodyBpmA - bodyBpmB is the penetration occurring.
29 |     public var edgeD: JFloat = 0
   |                       `- error: cannot find type 'JFloat' in scope
30 |     /// Global normal for the collision. Always the penetrated edge's normal.
31 |     public var normal = Vector2.zero
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:34:29: error: cannot find type 'JFloat' in scope
32 |     /// Penetration distance.
33 |     /// Is the distance required to move bodyApm in order to solve the collision
34 |     public var penetration: JFloat = 0
   |                             `- error: cannot find type 'JFloat' in scope
35 |
36 |     /// Inits this collision information with no edge information.
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Encodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Encodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
40 |
41 |     public init() {
Swift.Encodable.encode:2:6: note: protocol requires function 'encode(to:)' with type 'Encodable'
1 | protocol Encodable {
2 | func encode(to encoder: any Encoder) throws}
  |      `- note: protocol requires function 'encode(to:)' with type 'Encodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:100:46: error: cannot find type 'JFloat' in scope
 98 |     /// Returns the distance between this Vector2 and another Vector2
 99 |     @inlinable
100 |     public func distance(to vec: Vector2) -> JFloat {
    |                                              `- error: cannot find type 'JFloat' in scope
101 |         let d = self - vec
102 |
[33/36] Compiling JelloSwift Body.swift
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:269:45: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func -(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
270 |         return Vector2(x: lhs.x - rhs, y: lhs.y - rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:259:46: error: cannot find type 'JFloat' in scope
257 |
258 |     @inlinable
259 |     static public func - (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
260 |         return Vector3(x: lhs.x - rhs, y: lhs.y - rhs, z: lhs.z - rhs)
261 |     }
/host/spi-builder-workspace/Sources/Geometry/Matrix3x3.swift:5:31: error: cannot find type 'JFloat' in scope
  3 | /// Plain 3-row 3-column Matrix with real components.
  4 | public struct Matrix3x3: CustomStringConvertible {
  5 |     public typealias Scalar = JFloat
    |                               `- error: cannot find type 'JFloat' in scope
  6 |
  7 |     /// Returns a 3x3 [identity matrix].
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:28:19: error: cannot find type 'JFloat' in scope
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:31:19: error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 32 |
 33 |     /// Returns the angle in radians of this Vector2
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:93:24: error: cannot find type 'JFloat' in scope
 91 |     /// Inits a vector 2 with X and Y defined as a given float
 92 |     @inlinable
 93 |     public init(value: JFloat) {
    |                        `- error: cannot find type 'JFloat' in scope
 94 |         x = value
 95 |         y = value
/host/spi-builder-workspace/Sources/Body.swift:50:28: error: cannot find type 'JFloat' in scope
  48 |     /// 1 never decelerates. Values outside the range [0, 1] inclusive may
  49 |     /// introduce instability
  50 |     public var velDamping: JFloat = 0.999
     |                            `- error: cannot find type 'JFloat' in scope
  51 |
  52 |     /// The array of body components for this body object
/host/spi-builder-workspace/Sources/Body.swift:63:47: error: cannot find type 'JFloat' in scope
  61 |
  62 |     /// The derived rotation of the body, in radians
  63 |     public fileprivate(set) var derivedAngle: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
/host/spi-builder-workspace/Sources/Body.swift:66:47: error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
  66 |     public fileprivate(set) var derivedOmega: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
/host/spi-builder-workspace/Sources/Body.swift:69:32: error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
  69 |     fileprivate var lastAngle: JFloat = 0
     |                                `- error: cannot find type 'JFloat' in scope
  70 |
  71 |     /// Gets a list of vertices that represents the current position of each
/host/spi-builder-workspace/Sources/Body.swift:143:23: error: cannot find type 'JFloat' in scope
 141 |         world: World? = nil,
 142 |         shape: ClosedShape,
 143 |         pointMasses: [JFloat] = [1],
     |                       `- error: cannot find type 'JFloat' in scope
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
/host/spi-builder-workspace/Sources/Body.swift:145:16: error: cannot find type 'JFloat' in scope
 143 |         pointMasses: [JFloat] = [1],
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
     |                `- error: cannot find type 'JFloat' in scope
 146 |         scale: Vector2 = Vector2.unit,
 147 |         kinematic: Bool = false,
/host/spi-builder-workspace/Sources/Body.swift:305:39: error: cannot find type 'JFloat' in scope
 303 |     /// - parameter forceUpdate:
 304 |     ///     Whether to force the update of the body, even if it's a static body.
 305 |     public func updateAABB(_ elapsed: JFloat, forceUpdate: Bool) {
     |                                       `- error: cannot find type 'JFloat' in scope
 306 |         guard !isStatic || forceUpdate else {
 307 |             return
/host/spi-builder-workspace/Sources/Body.swift:361:36: error: cannot find type 'JFloat' in scope
 359 |
 360 |     /// Sets the mass for all the PointMass objects in this body.
 361 |     public func setMassAll(_ mass: JFloat) {
     |                                    `- error: cannot find type 'JFloat' in scope
 362 |         for i in 0..<pointMasses.count {
 363 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:370:63: error: cannot find type 'JFloat' in scope
 368 |
 369 |     /// Sets the mass for a single PointMass individually.
 370 |     public func setMassForPointMass(atIndex index: Int, mass: JFloat) {
     |                                                               `- error: cannot find type 'JFloat' in scope
 371 |         pointMasses[index].mass = mass
 372 |
/host/spi-builder-workspace/Sources/Body.swift:381:43: error: cannot find type 'JFloat' in scope
 379 |     /// sets up to the count of masses in the array, if larger, it sets the
 380 |     /// matching masses for all point masses, and ignores the rest of the array.
 381 |     public func setMass(fromList masses: [JFloat]) {
     |                                           `- error: cannot find type 'JFloat' in scope
 382 |         for (mass, i) in zip(masses, 0..<pointMasses.count) {
 383 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:394:57: error: cannot find type 'JFloat' in scope
 392 |     /// Setting the position and angle resets the current shape to the original
 393 |     /// base shape of the object.
 394 |     public func setPositionAngle(_ pos: Vector2, angle: JFloat, scale: Vector2) {
     |                                                         `- error: cannot find type 'JFloat' in scope
 395 |         let matrix = Vector2.matrix(scalingBy: scale, rotatingBy: angle, translatingBy: pos)
 396 |
/host/spi-builder-workspace/Sources/Body.swift:424:51: error: cannot find type 'JFloat' in scope
 422 |     /// call this. Instead you can just access the `derivedPosition`, `DerivedAngle`,
 423 |     /// `derivedVelocity`, and `derivedOmega` properties.
 424 |     public func derivePositionAndAngle(_ elapsed: JFloat) {
     |                                                   `- error: cannot find type 'JFloat' in scope
 425 |         // No need if this is a static body, or kinematically controlled.
 426 |         if isStatic || isKinematic {
/host/spi-builder-workspace/Sources/Body.swift:522:38: error: cannot find type 'JFloat' in scope
 520 |     /// Integrates the point masses for this Body.
 521 |     /// Ignored, if body is static.
 522 |     public func integrate(_ elapsed: JFloat) {
     |                                      `- error: cannot find type 'JFloat' in scope
 523 |         if isStatic {
 524 |             return
/host/spi-builder-workspace/Sources/Body.swift:536:43: error: cannot find type 'JFloat' in scope
 534 |     /// Applies the velocity damping to the point masses.
 535 |     /// Ignored, if body is static.
 536 |     public func dampenVelocity(_ elapsed: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 537 |         if isStatic {
 538 |             return
/host/spi-builder-workspace/Sources/Body.swift:550:39: error: cannot find type 'JFloat' in scope
 548 |     /// Applies a rotational clockwise torque of a given force on this body.
 549 |     /// Ignored, if body is static.
 550 |     public func applyTorque(of force: JFloat) {
     |                                       `- error: cannot find type 'JFloat' in scope
 551 |         if isStatic {
 552 |             return
/host/spi-builder-workspace/Sources/Body.swift:569:43: error: cannot find type 'JFloat' in scope
 567 |     /// The method keeps the average velocity of the point masses the same during
 568 |     /// the procedure.
 569 |     public func setAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 570 |         if isStatic {
 571 |             return
/host/spi-builder-workspace/Sources/Body.swift:583:43: error: cannot find type 'JFloat' in scope
 581 |
 582 |     /// Accumulates the angular velocity for this body
 583 |     public func addAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 584 |         if isStatic {
 585 |             return
/host/spi-builder-workspace/Sources/Body.swift:743:54: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:743:72: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:810:54: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:810:72: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:835:80: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:835:98: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                                  `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:891:45: error: cannot find type 'JFloat' in scope
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
     |                                             `- error: cannot find type 'JFloat' in scope
 892 |         if edges.count == 0 || pointMasses.count == 0 {
 893 |             return nil
/host/spi-builder-workspace/Sources/Body.swift:890:34: error: cannot find type 'JFloat' in scope
 888 |     public func closestEdge(
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
     |                                  `- error: cannot find type 'JFloat' in scope
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
 892 |         if edges.count == 0 || pointMasses.count == 0 {
/host/spi-builder-workspace/Sources/Body.swift:936:77: error: cannot find type 'JFloat' in scope
 934 |     /// Find the closest PointMass index in this body, given a global point
 935 |     /// - precondition: There is at least one point mass in this body
 936 |     public func closestPointMass(to pos: Vector2) -> (point: Int, distance: JFloat) {
     |                                                                             `- error: cannot find type 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:36:24: error: cannot find type 'JFloat' in scope
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                        `- error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
/host/spi-builder-workspace/Sources/BodyEdge.swift:39:31: error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                               `- error: cannot find type 'JFloat' in scope
40 |
41 |     public init() {
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:284:45: error: cannot find type 'JFloat' in scope
282 |
283 |     @inlinable
284 |     static public func %(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
285 |         return Vector2(x: lhs.x.truncatingRemainder(dividingBy: rhs),
286 |                        y: lhs.y.truncatingRemainder(dividingBy: rhs))
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:274:46: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func % (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
275 |         return Vector3(
276 |             x: lhs.x.truncatingRemainder(dividingBy: rhs),
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:264:45: error: cannot find type 'JFloat' in scope
262 |     // JFloat interaction
263 |     @inlinable
264 |     static public func +(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
265 |         return Vector2(x: lhs.x + rhs, y: lhs.y + rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:254:46: error: cannot find type 'JFloat' in scope
252 |     // JFloat interaction
253 |     @inlinable
254 |     static public func + (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
255 |         return Vector3(x: lhs.x + rhs, y: lhs.y + rhs, z: lhs.z + rhs)
256 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:274:45: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func *(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
275 |         return Vector2(x: lhs.x * rhs, y: lhs.y * rhs)
276 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:264:46: error: cannot find type 'JFloat' in scope
262 |
263 |     @inlinable
264 |     static public func * (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
265 |         return Vector3(x: lhs.x * rhs, y: lhs.y * rhs, z: lhs.z * rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:349:27: error: cannot find type 'JFloat' in scope
347 |     static public func matrix(
348 |         scalingBy scale: Vector2 = Vector2.unit,
349 |         rotatingBy angle: JFloat = 0,
    |                           `- error: cannot find type 'JFloat' in scope
350 |         translatingBy translate: Vector2 = Vector2.zero
351 |     ) -> Matrix3x3 {
/host/spi-builder-workspace/Sources/Geometry/ClosedShape.swift:150:25: error: cannot find type 'JFloat' in scope
148 |         _ target: inout [Vector2],
149 |         worldPos: Vector2,
150 |         angleInRadians: JFloat,
    |                         `- error: cannot find type 'JFloat' in scope
151 |         localScale: Vector2 = Vector2.unit
152 |     ) {
/host/spi-builder-workspace/Sources/PointMass.swift:16:22: error: cannot find type 'JFloat' in scope
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                      `- error: cannot find type 'JFloat' in scope
17 |
18 |     /// The global position of the point, in world coordinates
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:35:23: error: cannot find type 'JFloat' in scope
33 |     }
34 |
35 |     public init(mass: JFloat = 0, position: Vector2 = Vector2.zero) {
   |                       `- error: cannot find type 'JFloat' in scope
36 |         self.mass = mass
37 |         self.position = position
/host/spi-builder-workspace/Sources/Body.swift:445:20: error: cannot find type 'JFloat' in scope
 443 |
 444 |         // find the average angle of all of the masses.
 445 |         var angle: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
/host/spi-builder-workspace/Sources/Body.swift:448:28: error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
 448 |         var originalAngle: JFloat = 0
     |                            `- error: cannot find type 'JFloat' in scope
 449 |
 450 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:221:59: error: cannot find type 'JFloat' in scope
219 |     /// See `Vector2.dot`
220 |     @inlinable
221 |     static public func •(lhs: Vector2, rhs: Vector2) -> JFloat {
    |                                                         `- error: cannot find type 'JFloat' in scope
222 |         return lhs.dot(rhs)
223 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:208:60: error: cannot find type 'JFloat' in scope
206 |     /// See `Vector3.dot`
207 |     @inlinable
208 |     static public func • (lhs: Vector3, rhs: Vector3) -> JFloat {
    |                                                          `- error: cannot find type 'JFloat' in scope
209 |         return lhs.dot(rhs)
210 |     }
/host/spi-builder-workspace/Sources/Body.swift:467:33: error: reference to member 'pi' cannot be resolved without a contextual type
 465 |                 let thisSign = (thisAngle >= 0.0) ? 1 : -1
 466 |
 467 |                 if abs(diff) > .pi && (thisSign != originalSign) {
     |                                 `- error: reference to member 'pi' cannot be resolved without a contextual type
 468 |                     if thisSign == -1 {
 469 |                         thisAngle = .pi + (.pi + thisAngle)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:316:52: error: cannot find type 'JFloat' in scope
314 |     // JFloat interaction
315 |     @inlinable
316 |     static public func +=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
317 |         lhs = lhs + rhs
318 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:309:53: error: cannot find type 'JFloat' in scope
307 |     // JFloat interaction
308 |     @inlinable
309 |     static public func += (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
310 |         lhs = lhs + rhs
311 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:328:52: error: cannot find type 'JFloat' in scope
326 |     }
327 |     @inlinable
328 |     static public func /=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
329 |         lhs = lhs / rhs
330 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:321:53: error: cannot find type 'JFloat' in scope
319 |     }
320 |     @inlinable
321 |     static public func /= (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
322 |         lhs = lhs / rhs
323 |     }
/host/spi-builder-workspace/Sources/Body.swift:479:18: error: cannot find 'JFloat' in scope
 477 |         }
 478 |
 479 |         angle /= JFloat(c)
     |                  `- error: cannot find 'JFloat' in scope
 480 |
 481 |         derivedAngle = angle
/host/spi-builder-workspace/Sources/Body.swift:486:59: error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                           `- error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Body.swift:486:63: error: reference to member 'pi' cannot be resolved without a contextual type
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                               `- error: reference to member 'pi' cannot be resolved without a contextual type
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:279:45: error: cannot find type 'JFloat' in scope
277 |
278 |     @inlinable
279 |     static public func /(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
280 |         return Vector2(x: lhs.x / rhs, y: lhs.y / rhs)
281 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:290:31: error: cannot find type 'JFloat' in scope
288 |
289 |     @inlinable
290 |     static public func /(lhs: JFloat, rhs: Vector2) -> Vector2 {
    |                               `- error: cannot find type 'JFloat' in scope
291 |         return Vector2(x: lhs / rhs.x, y: lhs / rhs.y)
292 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:269:46: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func / (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
270 |         return Vector3(x: lhs.x / rhs, y: lhs.y / rhs, z: lhs.z / rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:283:32: error: cannot find type 'JFloat' in scope
281 |
282 |     @inlinable
283 |     static public func / (lhs: JFloat, rhs: Vector3) -> Vector3 {
    |                                `- error: cannot find type 'JFloat' in scope
284 |         return Vector3(x: lhs / rhs.x, y: lhs / rhs.y, z: lhs / rhs.z)
285 |     }
/host/spi-builder-workspace/Sources/PointMass.swift:45:47: error: cannot find type 'JFloat' in scope
43 |     /// seconds
44 |     @inlinable
45 |     public mutating func integrate(_ elapsed: JFloat) {
   |                                               `- error: cannot find type 'JFloat' in scope
46 |         if mass.isFinite {
47 |             let elapsedMass = elapsed / mass
/host/spi-builder-workspace/Sources/Body.swift:544:13: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 542 |             let pointMass = pointMasses[i]
 543 |
 544 |             applyVelocity(-(pointMass.velocity - (pointMass.velocity * velDamping)) * (elapsed * 200), toPointMassAt: i)
     |             `- error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 545 |         }
 546 |     }
/host/spi-builder-workspace/Sources/Geometry/AABB.swift:53:22: error: cannot find type 'JFloat' in scope
 51 |     /// Gets the middle X position of this AABB
 52 |     @inlinable
 53 |     public var midX: JFloat {
    |                      `- error: cannot find type 'JFloat' in scope
 54 |         return (minimum.x + maximum.x) / 2
 55 |     }
/host/spi-builder-workspace/Sources/Body.swift:638:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 636 |                     // this line crosses the test line at some point... does it
 637 |                     // do so within our test range?
 638 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 639 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 640 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Body.swift:665:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 663 |                     // this line crosses the test line at some point... does it
 664 |                     // do so within our test range?
 665 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 666 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 667 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:27: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                           `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:39: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                                       `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Body.swift:748:20: error: cannot find type 'JFloat' in scope
 746 |         var hitPt: Vector2 = .zero
 747 |         var normal: Vector2 = .zero
 748 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 749 |
 750 |         var dist: JFloat = 0
/host/spi-builder-workspace/Sources/Body.swift:750:19: error: cannot find type 'JFloat' in scope
 748 |         var edgeD: JFloat = 0
 749 |
 750 |         var dist: JFloat = 0
     |                   `- error: cannot find type 'JFloat' in scope
 751 |
 752 |         let edge = edges[edgeNum]
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:108:53: error: cannot find type 'JFloat' in scope
106 |     /// Returns the distance squared between this Vector2 and another Vector2
107 |     @inlinable
108 |     public func distanceSquared(to vec: Vector2) -> JFloat {
    |                                                     `- error: cannot find type 'JFloat' in scope
109 |         let d = self - vec
110 |
/host/spi-builder-workspace/Sources/Body.swift:840:20: error: cannot find type 'JFloat' in scope
 838 |         var pointA = -1
 839 |         var pointB = -1
 840 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 841 |         var normal: Vector2 = .zero
 842 |         var hitPt: Vector2 = .zero
/host/spi-builder-workspace/Sources/Body.swift:844:24: error: cannot find 'JFloat' in scope
 842 |         var hitPt: Vector2 = .zero
 843 |
 844 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 845 |
 846 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Body.swift:900:24: error: cannot find type 'JFloat' in scope
 898 |         var closestP2 = 0// closestP1
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
     |                        `- error: cannot find type 'JFloat' in scope
 901 |         var closestD = JFloat.infinity
 902 |
/host/spi-builder-workspace/Sources/Body.swift:901:24: error: cannot find 'JFloat' in scope
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
 901 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 902 |
 903 |         for edge in edges {
/host/spi-builder-workspace/Sources/Body.swift:939:26: error: cannot find 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
 939 |         var closestSQD = JFloat.greatestFiniteMagnitude
     |                          `- error: cannot find 'JFloat' in scope
 940 |         var closest: Int!
 941 |
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:29:23: error: cannot find type 'JFloat' in scope
27 |     /// A value from 0 - 1 specifying at which point in the edge
28 |     /// bodyBpmA - bodyBpmB is the penetration occurring.
29 |     public var edgeD: JFloat = 0
   |                       `- error: cannot find type 'JFloat' in scope
30 |     /// Global normal for the collision. Always the penetrated edge's normal.
31 |     public var normal = Vector2.zero
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:34:29: error: cannot find type 'JFloat' in scope
32 |     /// Penetration distance.
33 |     /// Is the distance required to move bodyApm in order to solve the collision
34 |     public var penetration: JFloat = 0
   |                             `- error: cannot find type 'JFloat' in scope
35 |
36 |     /// Inits this collision information with no edge information.
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Encodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Encodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
40 |
41 |     public init() {
Swift.Encodable.encode:2:6: note: protocol requires function 'encode(to:)' with type 'Encodable'
1 | protocol Encodable {
2 | func encode(to encoder: any Encoder) throws}
  |      `- note: protocol requires function 'encode(to:)' with type 'Encodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:100:46: error: cannot find type 'JFloat' in scope
 98 |     /// Returns the distance between this Vector2 and another Vector2
 99 |     @inlinable
100 |     public func distance(to vec: Vector2) -> JFloat {
    |                                              `- error: cannot find type 'JFloat' in scope
101 |         let d = self - vec
102 |
[34/36] Compiling JelloSwift BodyCollisionInformation.swift
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:269:45: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func -(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
270 |         return Vector2(x: lhs.x - rhs, y: lhs.y - rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:259:46: error: cannot find type 'JFloat' in scope
257 |
258 |     @inlinable
259 |     static public func - (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
260 |         return Vector3(x: lhs.x - rhs, y: lhs.y - rhs, z: lhs.z - rhs)
261 |     }
/host/spi-builder-workspace/Sources/Geometry/Matrix3x3.swift:5:31: error: cannot find type 'JFloat' in scope
  3 | /// Plain 3-row 3-column Matrix with real components.
  4 | public struct Matrix3x3: CustomStringConvertible {
  5 |     public typealias Scalar = JFloat
    |                               `- error: cannot find type 'JFloat' in scope
  6 |
  7 |     /// Returns a 3x3 [identity matrix].
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:28:19: error: cannot find type 'JFloat' in scope
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:31:19: error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 32 |
 33 |     /// Returns the angle in radians of this Vector2
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:93:24: error: cannot find type 'JFloat' in scope
 91 |     /// Inits a vector 2 with X and Y defined as a given float
 92 |     @inlinable
 93 |     public init(value: JFloat) {
    |                        `- error: cannot find type 'JFloat' in scope
 94 |         x = value
 95 |         y = value
/host/spi-builder-workspace/Sources/Body.swift:50:28: error: cannot find type 'JFloat' in scope
  48 |     /// 1 never decelerates. Values outside the range [0, 1] inclusive may
  49 |     /// introduce instability
  50 |     public var velDamping: JFloat = 0.999
     |                            `- error: cannot find type 'JFloat' in scope
  51 |
  52 |     /// The array of body components for this body object
/host/spi-builder-workspace/Sources/Body.swift:63:47: error: cannot find type 'JFloat' in scope
  61 |
  62 |     /// The derived rotation of the body, in radians
  63 |     public fileprivate(set) var derivedAngle: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
/host/spi-builder-workspace/Sources/Body.swift:66:47: error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
  66 |     public fileprivate(set) var derivedOmega: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
/host/spi-builder-workspace/Sources/Body.swift:69:32: error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
  69 |     fileprivate var lastAngle: JFloat = 0
     |                                `- error: cannot find type 'JFloat' in scope
  70 |
  71 |     /// Gets a list of vertices that represents the current position of each
/host/spi-builder-workspace/Sources/Body.swift:143:23: error: cannot find type 'JFloat' in scope
 141 |         world: World? = nil,
 142 |         shape: ClosedShape,
 143 |         pointMasses: [JFloat] = [1],
     |                       `- error: cannot find type 'JFloat' in scope
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
/host/spi-builder-workspace/Sources/Body.swift:145:16: error: cannot find type 'JFloat' in scope
 143 |         pointMasses: [JFloat] = [1],
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
     |                `- error: cannot find type 'JFloat' in scope
 146 |         scale: Vector2 = Vector2.unit,
 147 |         kinematic: Bool = false,
/host/spi-builder-workspace/Sources/Body.swift:305:39: error: cannot find type 'JFloat' in scope
 303 |     /// - parameter forceUpdate:
 304 |     ///     Whether to force the update of the body, even if it's a static body.
 305 |     public func updateAABB(_ elapsed: JFloat, forceUpdate: Bool) {
     |                                       `- error: cannot find type 'JFloat' in scope
 306 |         guard !isStatic || forceUpdate else {
 307 |             return
/host/spi-builder-workspace/Sources/Body.swift:361:36: error: cannot find type 'JFloat' in scope
 359 |
 360 |     /// Sets the mass for all the PointMass objects in this body.
 361 |     public func setMassAll(_ mass: JFloat) {
     |                                    `- error: cannot find type 'JFloat' in scope
 362 |         for i in 0..<pointMasses.count {
 363 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:370:63: error: cannot find type 'JFloat' in scope
 368 |
 369 |     /// Sets the mass for a single PointMass individually.
 370 |     public func setMassForPointMass(atIndex index: Int, mass: JFloat) {
     |                                                               `- error: cannot find type 'JFloat' in scope
 371 |         pointMasses[index].mass = mass
 372 |
/host/spi-builder-workspace/Sources/Body.swift:381:43: error: cannot find type 'JFloat' in scope
 379 |     /// sets up to the count of masses in the array, if larger, it sets the
 380 |     /// matching masses for all point masses, and ignores the rest of the array.
 381 |     public func setMass(fromList masses: [JFloat]) {
     |                                           `- error: cannot find type 'JFloat' in scope
 382 |         for (mass, i) in zip(masses, 0..<pointMasses.count) {
 383 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:394:57: error: cannot find type 'JFloat' in scope
 392 |     /// Setting the position and angle resets the current shape to the original
 393 |     /// base shape of the object.
 394 |     public func setPositionAngle(_ pos: Vector2, angle: JFloat, scale: Vector2) {
     |                                                         `- error: cannot find type 'JFloat' in scope
 395 |         let matrix = Vector2.matrix(scalingBy: scale, rotatingBy: angle, translatingBy: pos)
 396 |
/host/spi-builder-workspace/Sources/Body.swift:424:51: error: cannot find type 'JFloat' in scope
 422 |     /// call this. Instead you can just access the `derivedPosition`, `DerivedAngle`,
 423 |     /// `derivedVelocity`, and `derivedOmega` properties.
 424 |     public func derivePositionAndAngle(_ elapsed: JFloat) {
     |                                                   `- error: cannot find type 'JFloat' in scope
 425 |         // No need if this is a static body, or kinematically controlled.
 426 |         if isStatic || isKinematic {
/host/spi-builder-workspace/Sources/Body.swift:522:38: error: cannot find type 'JFloat' in scope
 520 |     /// Integrates the point masses for this Body.
 521 |     /// Ignored, if body is static.
 522 |     public func integrate(_ elapsed: JFloat) {
     |                                      `- error: cannot find type 'JFloat' in scope
 523 |         if isStatic {
 524 |             return
/host/spi-builder-workspace/Sources/Body.swift:536:43: error: cannot find type 'JFloat' in scope
 534 |     /// Applies the velocity damping to the point masses.
 535 |     /// Ignored, if body is static.
 536 |     public func dampenVelocity(_ elapsed: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 537 |         if isStatic {
 538 |             return
/host/spi-builder-workspace/Sources/Body.swift:550:39: error: cannot find type 'JFloat' in scope
 548 |     /// Applies a rotational clockwise torque of a given force on this body.
 549 |     /// Ignored, if body is static.
 550 |     public func applyTorque(of force: JFloat) {
     |                                       `- error: cannot find type 'JFloat' in scope
 551 |         if isStatic {
 552 |             return
/host/spi-builder-workspace/Sources/Body.swift:569:43: error: cannot find type 'JFloat' in scope
 567 |     /// The method keeps the average velocity of the point masses the same during
 568 |     /// the procedure.
 569 |     public func setAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 570 |         if isStatic {
 571 |             return
/host/spi-builder-workspace/Sources/Body.swift:583:43: error: cannot find type 'JFloat' in scope
 581 |
 582 |     /// Accumulates the angular velocity for this body
 583 |     public func addAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 584 |         if isStatic {
 585 |             return
/host/spi-builder-workspace/Sources/Body.swift:743:54: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:743:72: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:810:54: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:810:72: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:835:80: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:835:98: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                                  `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:891:45: error: cannot find type 'JFloat' in scope
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
     |                                             `- error: cannot find type 'JFloat' in scope
 892 |         if edges.count == 0 || pointMasses.count == 0 {
 893 |             return nil
/host/spi-builder-workspace/Sources/Body.swift:890:34: error: cannot find type 'JFloat' in scope
 888 |     public func closestEdge(
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
     |                                  `- error: cannot find type 'JFloat' in scope
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
 892 |         if edges.count == 0 || pointMasses.count == 0 {
/host/spi-builder-workspace/Sources/Body.swift:936:77: error: cannot find type 'JFloat' in scope
 934 |     /// Find the closest PointMass index in this body, given a global point
 935 |     /// - precondition: There is at least one point mass in this body
 936 |     public func closestPointMass(to pos: Vector2) -> (point: Int, distance: JFloat) {
     |                                                                             `- error: cannot find type 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:36:24: error: cannot find type 'JFloat' in scope
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                        `- error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
/host/spi-builder-workspace/Sources/BodyEdge.swift:39:31: error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                               `- error: cannot find type 'JFloat' in scope
40 |
41 |     public init() {
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:284:45: error: cannot find type 'JFloat' in scope
282 |
283 |     @inlinable
284 |     static public func %(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
285 |         return Vector2(x: lhs.x.truncatingRemainder(dividingBy: rhs),
286 |                        y: lhs.y.truncatingRemainder(dividingBy: rhs))
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:274:46: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func % (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
275 |         return Vector3(
276 |             x: lhs.x.truncatingRemainder(dividingBy: rhs),
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:264:45: error: cannot find type 'JFloat' in scope
262 |     // JFloat interaction
263 |     @inlinable
264 |     static public func +(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
265 |         return Vector2(x: lhs.x + rhs, y: lhs.y + rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:254:46: error: cannot find type 'JFloat' in scope
252 |     // JFloat interaction
253 |     @inlinable
254 |     static public func + (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
255 |         return Vector3(x: lhs.x + rhs, y: lhs.y + rhs, z: lhs.z + rhs)
256 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:274:45: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func *(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
275 |         return Vector2(x: lhs.x * rhs, y: lhs.y * rhs)
276 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:264:46: error: cannot find type 'JFloat' in scope
262 |
263 |     @inlinable
264 |     static public func * (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
265 |         return Vector3(x: lhs.x * rhs, y: lhs.y * rhs, z: lhs.z * rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:349:27: error: cannot find type 'JFloat' in scope
347 |     static public func matrix(
348 |         scalingBy scale: Vector2 = Vector2.unit,
349 |         rotatingBy angle: JFloat = 0,
    |                           `- error: cannot find type 'JFloat' in scope
350 |         translatingBy translate: Vector2 = Vector2.zero
351 |     ) -> Matrix3x3 {
/host/spi-builder-workspace/Sources/Geometry/ClosedShape.swift:150:25: error: cannot find type 'JFloat' in scope
148 |         _ target: inout [Vector2],
149 |         worldPos: Vector2,
150 |         angleInRadians: JFloat,
    |                         `- error: cannot find type 'JFloat' in scope
151 |         localScale: Vector2 = Vector2.unit
152 |     ) {
/host/spi-builder-workspace/Sources/PointMass.swift:16:22: error: cannot find type 'JFloat' in scope
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                      `- error: cannot find type 'JFloat' in scope
17 |
18 |     /// The global position of the point, in world coordinates
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:35:23: error: cannot find type 'JFloat' in scope
33 |     }
34 |
35 |     public init(mass: JFloat = 0, position: Vector2 = Vector2.zero) {
   |                       `- error: cannot find type 'JFloat' in scope
36 |         self.mass = mass
37 |         self.position = position
/host/spi-builder-workspace/Sources/Body.swift:445:20: error: cannot find type 'JFloat' in scope
 443 |
 444 |         // find the average angle of all of the masses.
 445 |         var angle: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
/host/spi-builder-workspace/Sources/Body.swift:448:28: error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
 448 |         var originalAngle: JFloat = 0
     |                            `- error: cannot find type 'JFloat' in scope
 449 |
 450 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:221:59: error: cannot find type 'JFloat' in scope
219 |     /// See `Vector2.dot`
220 |     @inlinable
221 |     static public func •(lhs: Vector2, rhs: Vector2) -> JFloat {
    |                                                         `- error: cannot find type 'JFloat' in scope
222 |         return lhs.dot(rhs)
223 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:208:60: error: cannot find type 'JFloat' in scope
206 |     /// See `Vector3.dot`
207 |     @inlinable
208 |     static public func • (lhs: Vector3, rhs: Vector3) -> JFloat {
    |                                                          `- error: cannot find type 'JFloat' in scope
209 |         return lhs.dot(rhs)
210 |     }
/host/spi-builder-workspace/Sources/Body.swift:467:33: error: reference to member 'pi' cannot be resolved without a contextual type
 465 |                 let thisSign = (thisAngle >= 0.0) ? 1 : -1
 466 |
 467 |                 if abs(diff) > .pi && (thisSign != originalSign) {
     |                                 `- error: reference to member 'pi' cannot be resolved without a contextual type
 468 |                     if thisSign == -1 {
 469 |                         thisAngle = .pi + (.pi + thisAngle)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:316:52: error: cannot find type 'JFloat' in scope
314 |     // JFloat interaction
315 |     @inlinable
316 |     static public func +=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
317 |         lhs = lhs + rhs
318 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:309:53: error: cannot find type 'JFloat' in scope
307 |     // JFloat interaction
308 |     @inlinable
309 |     static public func += (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
310 |         lhs = lhs + rhs
311 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:328:52: error: cannot find type 'JFloat' in scope
326 |     }
327 |     @inlinable
328 |     static public func /=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
329 |         lhs = lhs / rhs
330 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:321:53: error: cannot find type 'JFloat' in scope
319 |     }
320 |     @inlinable
321 |     static public func /= (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
322 |         lhs = lhs / rhs
323 |     }
/host/spi-builder-workspace/Sources/Body.swift:479:18: error: cannot find 'JFloat' in scope
 477 |         }
 478 |
 479 |         angle /= JFloat(c)
     |                  `- error: cannot find 'JFloat' in scope
 480 |
 481 |         derivedAngle = angle
/host/spi-builder-workspace/Sources/Body.swift:486:59: error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                           `- error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Body.swift:486:63: error: reference to member 'pi' cannot be resolved without a contextual type
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                               `- error: reference to member 'pi' cannot be resolved without a contextual type
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:279:45: error: cannot find type 'JFloat' in scope
277 |
278 |     @inlinable
279 |     static public func /(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
280 |         return Vector2(x: lhs.x / rhs, y: lhs.y / rhs)
281 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:290:31: error: cannot find type 'JFloat' in scope
288 |
289 |     @inlinable
290 |     static public func /(lhs: JFloat, rhs: Vector2) -> Vector2 {
    |                               `- error: cannot find type 'JFloat' in scope
291 |         return Vector2(x: lhs / rhs.x, y: lhs / rhs.y)
292 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:269:46: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func / (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
270 |         return Vector3(x: lhs.x / rhs, y: lhs.y / rhs, z: lhs.z / rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:283:32: error: cannot find type 'JFloat' in scope
281 |
282 |     @inlinable
283 |     static public func / (lhs: JFloat, rhs: Vector3) -> Vector3 {
    |                                `- error: cannot find type 'JFloat' in scope
284 |         return Vector3(x: lhs / rhs.x, y: lhs / rhs.y, z: lhs / rhs.z)
285 |     }
/host/spi-builder-workspace/Sources/PointMass.swift:45:47: error: cannot find type 'JFloat' in scope
43 |     /// seconds
44 |     @inlinable
45 |     public mutating func integrate(_ elapsed: JFloat) {
   |                                               `- error: cannot find type 'JFloat' in scope
46 |         if mass.isFinite {
47 |             let elapsedMass = elapsed / mass
/host/spi-builder-workspace/Sources/Body.swift:544:13: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 542 |             let pointMass = pointMasses[i]
 543 |
 544 |             applyVelocity(-(pointMass.velocity - (pointMass.velocity * velDamping)) * (elapsed * 200), toPointMassAt: i)
     |             `- error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 545 |         }
 546 |     }
/host/spi-builder-workspace/Sources/Geometry/AABB.swift:53:22: error: cannot find type 'JFloat' in scope
 51 |     /// Gets the middle X position of this AABB
 52 |     @inlinable
 53 |     public var midX: JFloat {
    |                      `- error: cannot find type 'JFloat' in scope
 54 |         return (minimum.x + maximum.x) / 2
 55 |     }
/host/spi-builder-workspace/Sources/Body.swift:638:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 636 |                     // this line crosses the test line at some point... does it
 637 |                     // do so within our test range?
 638 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 639 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 640 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Body.swift:665:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 663 |                     // this line crosses the test line at some point... does it
 664 |                     // do so within our test range?
 665 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 666 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 667 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:27: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                           `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:39: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                                       `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Body.swift:748:20: error: cannot find type 'JFloat' in scope
 746 |         var hitPt: Vector2 = .zero
 747 |         var normal: Vector2 = .zero
 748 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 749 |
 750 |         var dist: JFloat = 0
/host/spi-builder-workspace/Sources/Body.swift:750:19: error: cannot find type 'JFloat' in scope
 748 |         var edgeD: JFloat = 0
 749 |
 750 |         var dist: JFloat = 0
     |                   `- error: cannot find type 'JFloat' in scope
 751 |
 752 |         let edge = edges[edgeNum]
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:108:53: error: cannot find type 'JFloat' in scope
106 |     /// Returns the distance squared between this Vector2 and another Vector2
107 |     @inlinable
108 |     public func distanceSquared(to vec: Vector2) -> JFloat {
    |                                                     `- error: cannot find type 'JFloat' in scope
109 |         let d = self - vec
110 |
/host/spi-builder-workspace/Sources/Body.swift:840:20: error: cannot find type 'JFloat' in scope
 838 |         var pointA = -1
 839 |         var pointB = -1
 840 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 841 |         var normal: Vector2 = .zero
 842 |         var hitPt: Vector2 = .zero
/host/spi-builder-workspace/Sources/Body.swift:844:24: error: cannot find 'JFloat' in scope
 842 |         var hitPt: Vector2 = .zero
 843 |
 844 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 845 |
 846 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Body.swift:900:24: error: cannot find type 'JFloat' in scope
 898 |         var closestP2 = 0// closestP1
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
     |                        `- error: cannot find type 'JFloat' in scope
 901 |         var closestD = JFloat.infinity
 902 |
/host/spi-builder-workspace/Sources/Body.swift:901:24: error: cannot find 'JFloat' in scope
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
 901 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 902 |
 903 |         for edge in edges {
/host/spi-builder-workspace/Sources/Body.swift:939:26: error: cannot find 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
 939 |         var closestSQD = JFloat.greatestFiniteMagnitude
     |                          `- error: cannot find 'JFloat' in scope
 940 |         var closest: Int!
 941 |
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:29:23: error: cannot find type 'JFloat' in scope
27 |     /// A value from 0 - 1 specifying at which point in the edge
28 |     /// bodyBpmA - bodyBpmB is the penetration occurring.
29 |     public var edgeD: JFloat = 0
   |                       `- error: cannot find type 'JFloat' in scope
30 |     /// Global normal for the collision. Always the penetrated edge's normal.
31 |     public var normal = Vector2.zero
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:34:29: error: cannot find type 'JFloat' in scope
32 |     /// Penetration distance.
33 |     /// Is the distance required to move bodyApm in order to solve the collision
34 |     public var penetration: JFloat = 0
   |                             `- error: cannot find type 'JFloat' in scope
35 |
36 |     /// Inits this collision information with no edge information.
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Encodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Encodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
40 |
41 |     public init() {
Swift.Encodable.encode:2:6: note: protocol requires function 'encode(to:)' with type 'Encodable'
1 | protocol Encodable {
2 | func encode(to encoder: any Encoder) throws}
  |      `- note: protocol requires function 'encode(to:)' with type 'Encodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:100:46: error: cannot find type 'JFloat' in scope
 98 |     /// Returns the distance between this Vector2 and another Vector2
 99 |     @inlinable
100 |     public func distance(to vec: Vector2) -> JFloat {
    |                                              `- error: cannot find type 'JFloat' in scope
101 |         let d = self - vec
102 |
[35/36] Compiling JelloSwift BodyComponent.swift
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:269:45: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func -(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
270 |         return Vector2(x: lhs.x - rhs, y: lhs.y - rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:259:46: error: cannot find type 'JFloat' in scope
257 |
258 |     @inlinable
259 |     static public func - (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
260 |         return Vector3(x: lhs.x - rhs, y: lhs.y - rhs, z: lhs.z - rhs)
261 |     }
/host/spi-builder-workspace/Sources/Geometry/Matrix3x3.swift:5:31: error: cannot find type 'JFloat' in scope
  3 | /// Plain 3-row 3-column Matrix with real components.
  4 | public struct Matrix3x3: CustomStringConvertible {
  5 |     public typealias Scalar = JFloat
    |                               `- error: cannot find type 'JFloat' in scope
  6 |
  7 |     /// Returns a 3x3 [identity matrix].
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:28:19: error: cannot find type 'JFloat' in scope
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:31:19: error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 32 |
 33 |     /// Returns the angle in radians of this Vector2
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:93:24: error: cannot find type 'JFloat' in scope
 91 |     /// Inits a vector 2 with X and Y defined as a given float
 92 |     @inlinable
 93 |     public init(value: JFloat) {
    |                        `- error: cannot find type 'JFloat' in scope
 94 |         x = value
 95 |         y = value
/host/spi-builder-workspace/Sources/Body.swift:50:28: error: cannot find type 'JFloat' in scope
  48 |     /// 1 never decelerates. Values outside the range [0, 1] inclusive may
  49 |     /// introduce instability
  50 |     public var velDamping: JFloat = 0.999
     |                            `- error: cannot find type 'JFloat' in scope
  51 |
  52 |     /// The array of body components for this body object
/host/spi-builder-workspace/Sources/Body.swift:63:47: error: cannot find type 'JFloat' in scope
  61 |
  62 |     /// The derived rotation of the body, in radians
  63 |     public fileprivate(set) var derivedAngle: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
/host/spi-builder-workspace/Sources/Body.swift:66:47: error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
  66 |     public fileprivate(set) var derivedOmega: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
/host/spi-builder-workspace/Sources/Body.swift:69:32: error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
  69 |     fileprivate var lastAngle: JFloat = 0
     |                                `- error: cannot find type 'JFloat' in scope
  70 |
  71 |     /// Gets a list of vertices that represents the current position of each
/host/spi-builder-workspace/Sources/Body.swift:143:23: error: cannot find type 'JFloat' in scope
 141 |         world: World? = nil,
 142 |         shape: ClosedShape,
 143 |         pointMasses: [JFloat] = [1],
     |                       `- error: cannot find type 'JFloat' in scope
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
/host/spi-builder-workspace/Sources/Body.swift:145:16: error: cannot find type 'JFloat' in scope
 143 |         pointMasses: [JFloat] = [1],
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
     |                `- error: cannot find type 'JFloat' in scope
 146 |         scale: Vector2 = Vector2.unit,
 147 |         kinematic: Bool = false,
/host/spi-builder-workspace/Sources/Body.swift:305:39: error: cannot find type 'JFloat' in scope
 303 |     /// - parameter forceUpdate:
 304 |     ///     Whether to force the update of the body, even if it's a static body.
 305 |     public func updateAABB(_ elapsed: JFloat, forceUpdate: Bool) {
     |                                       `- error: cannot find type 'JFloat' in scope
 306 |         guard !isStatic || forceUpdate else {
 307 |             return
/host/spi-builder-workspace/Sources/Body.swift:361:36: error: cannot find type 'JFloat' in scope
 359 |
 360 |     /// Sets the mass for all the PointMass objects in this body.
 361 |     public func setMassAll(_ mass: JFloat) {
     |                                    `- error: cannot find type 'JFloat' in scope
 362 |         for i in 0..<pointMasses.count {
 363 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:370:63: error: cannot find type 'JFloat' in scope
 368 |
 369 |     /// Sets the mass for a single PointMass individually.
 370 |     public func setMassForPointMass(atIndex index: Int, mass: JFloat) {
     |                                                               `- error: cannot find type 'JFloat' in scope
 371 |         pointMasses[index].mass = mass
 372 |
/host/spi-builder-workspace/Sources/Body.swift:381:43: error: cannot find type 'JFloat' in scope
 379 |     /// sets up to the count of masses in the array, if larger, it sets the
 380 |     /// matching masses for all point masses, and ignores the rest of the array.
 381 |     public func setMass(fromList masses: [JFloat]) {
     |                                           `- error: cannot find type 'JFloat' in scope
 382 |         for (mass, i) in zip(masses, 0..<pointMasses.count) {
 383 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:394:57: error: cannot find type 'JFloat' in scope
 392 |     /// Setting the position and angle resets the current shape to the original
 393 |     /// base shape of the object.
 394 |     public func setPositionAngle(_ pos: Vector2, angle: JFloat, scale: Vector2) {
     |                                                         `- error: cannot find type 'JFloat' in scope
 395 |         let matrix = Vector2.matrix(scalingBy: scale, rotatingBy: angle, translatingBy: pos)
 396 |
/host/spi-builder-workspace/Sources/Body.swift:424:51: error: cannot find type 'JFloat' in scope
 422 |     /// call this. Instead you can just access the `derivedPosition`, `DerivedAngle`,
 423 |     /// `derivedVelocity`, and `derivedOmega` properties.
 424 |     public func derivePositionAndAngle(_ elapsed: JFloat) {
     |                                                   `- error: cannot find type 'JFloat' in scope
 425 |         // No need if this is a static body, or kinematically controlled.
 426 |         if isStatic || isKinematic {
/host/spi-builder-workspace/Sources/Body.swift:522:38: error: cannot find type 'JFloat' in scope
 520 |     /// Integrates the point masses for this Body.
 521 |     /// Ignored, if body is static.
 522 |     public func integrate(_ elapsed: JFloat) {
     |                                      `- error: cannot find type 'JFloat' in scope
 523 |         if isStatic {
 524 |             return
/host/spi-builder-workspace/Sources/Body.swift:536:43: error: cannot find type 'JFloat' in scope
 534 |     /// Applies the velocity damping to the point masses.
 535 |     /// Ignored, if body is static.
 536 |     public func dampenVelocity(_ elapsed: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 537 |         if isStatic {
 538 |             return
/host/spi-builder-workspace/Sources/Body.swift:550:39: error: cannot find type 'JFloat' in scope
 548 |     /// Applies a rotational clockwise torque of a given force on this body.
 549 |     /// Ignored, if body is static.
 550 |     public func applyTorque(of force: JFloat) {
     |                                       `- error: cannot find type 'JFloat' in scope
 551 |         if isStatic {
 552 |             return
/host/spi-builder-workspace/Sources/Body.swift:569:43: error: cannot find type 'JFloat' in scope
 567 |     /// The method keeps the average velocity of the point masses the same during
 568 |     /// the procedure.
 569 |     public func setAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 570 |         if isStatic {
 571 |             return
/host/spi-builder-workspace/Sources/Body.swift:583:43: error: cannot find type 'JFloat' in scope
 581 |
 582 |     /// Accumulates the angular velocity for this body
 583 |     public func addAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 584 |         if isStatic {
 585 |             return
/host/spi-builder-workspace/Sources/Body.swift:743:54: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:743:72: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:810:54: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:810:72: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:835:80: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:835:98: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                                  `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:891:45: error: cannot find type 'JFloat' in scope
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
     |                                             `- error: cannot find type 'JFloat' in scope
 892 |         if edges.count == 0 || pointMasses.count == 0 {
 893 |             return nil
/host/spi-builder-workspace/Sources/Body.swift:890:34: error: cannot find type 'JFloat' in scope
 888 |     public func closestEdge(
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
     |                                  `- error: cannot find type 'JFloat' in scope
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
 892 |         if edges.count == 0 || pointMasses.count == 0 {
/host/spi-builder-workspace/Sources/Body.swift:936:77: error: cannot find type 'JFloat' in scope
 934 |     /// Find the closest PointMass index in this body, given a global point
 935 |     /// - precondition: There is at least one point mass in this body
 936 |     public func closestPointMass(to pos: Vector2) -> (point: Int, distance: JFloat) {
     |                                                                             `- error: cannot find type 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:36:24: error: cannot find type 'JFloat' in scope
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                        `- error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
/host/spi-builder-workspace/Sources/BodyEdge.swift:39:31: error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                               `- error: cannot find type 'JFloat' in scope
40 |
41 |     public init() {
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:284:45: error: cannot find type 'JFloat' in scope
282 |
283 |     @inlinable
284 |     static public func %(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
285 |         return Vector2(x: lhs.x.truncatingRemainder(dividingBy: rhs),
286 |                        y: lhs.y.truncatingRemainder(dividingBy: rhs))
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:274:46: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func % (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
275 |         return Vector3(
276 |             x: lhs.x.truncatingRemainder(dividingBy: rhs),
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:264:45: error: cannot find type 'JFloat' in scope
262 |     // JFloat interaction
263 |     @inlinable
264 |     static public func +(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
265 |         return Vector2(x: lhs.x + rhs, y: lhs.y + rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:254:46: error: cannot find type 'JFloat' in scope
252 |     // JFloat interaction
253 |     @inlinable
254 |     static public func + (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
255 |         return Vector3(x: lhs.x + rhs, y: lhs.y + rhs, z: lhs.z + rhs)
256 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:274:45: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func *(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
275 |         return Vector2(x: lhs.x * rhs, y: lhs.y * rhs)
276 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:264:46: error: cannot find type 'JFloat' in scope
262 |
263 |     @inlinable
264 |     static public func * (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
265 |         return Vector3(x: lhs.x * rhs, y: lhs.y * rhs, z: lhs.z * rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:349:27: error: cannot find type 'JFloat' in scope
347 |     static public func matrix(
348 |         scalingBy scale: Vector2 = Vector2.unit,
349 |         rotatingBy angle: JFloat = 0,
    |                           `- error: cannot find type 'JFloat' in scope
350 |         translatingBy translate: Vector2 = Vector2.zero
351 |     ) -> Matrix3x3 {
/host/spi-builder-workspace/Sources/Geometry/ClosedShape.swift:150:25: error: cannot find type 'JFloat' in scope
148 |         _ target: inout [Vector2],
149 |         worldPos: Vector2,
150 |         angleInRadians: JFloat,
    |                         `- error: cannot find type 'JFloat' in scope
151 |         localScale: Vector2 = Vector2.unit
152 |     ) {
/host/spi-builder-workspace/Sources/PointMass.swift:16:22: error: cannot find type 'JFloat' in scope
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                      `- error: cannot find type 'JFloat' in scope
17 |
18 |     /// The global position of the point, in world coordinates
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:35:23: error: cannot find type 'JFloat' in scope
33 |     }
34 |
35 |     public init(mass: JFloat = 0, position: Vector2 = Vector2.zero) {
   |                       `- error: cannot find type 'JFloat' in scope
36 |         self.mass = mass
37 |         self.position = position
/host/spi-builder-workspace/Sources/Body.swift:445:20: error: cannot find type 'JFloat' in scope
 443 |
 444 |         // find the average angle of all of the masses.
 445 |         var angle: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
/host/spi-builder-workspace/Sources/Body.swift:448:28: error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
 448 |         var originalAngle: JFloat = 0
     |                            `- error: cannot find type 'JFloat' in scope
 449 |
 450 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:221:59: error: cannot find type 'JFloat' in scope
219 |     /// See `Vector2.dot`
220 |     @inlinable
221 |     static public func •(lhs: Vector2, rhs: Vector2) -> JFloat {
    |                                                         `- error: cannot find type 'JFloat' in scope
222 |         return lhs.dot(rhs)
223 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:208:60: error: cannot find type 'JFloat' in scope
206 |     /// See `Vector3.dot`
207 |     @inlinable
208 |     static public func • (lhs: Vector3, rhs: Vector3) -> JFloat {
    |                                                          `- error: cannot find type 'JFloat' in scope
209 |         return lhs.dot(rhs)
210 |     }
/host/spi-builder-workspace/Sources/Body.swift:467:33: error: reference to member 'pi' cannot be resolved without a contextual type
 465 |                 let thisSign = (thisAngle >= 0.0) ? 1 : -1
 466 |
 467 |                 if abs(diff) > .pi && (thisSign != originalSign) {
     |                                 `- error: reference to member 'pi' cannot be resolved without a contextual type
 468 |                     if thisSign == -1 {
 469 |                         thisAngle = .pi + (.pi + thisAngle)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:316:52: error: cannot find type 'JFloat' in scope
314 |     // JFloat interaction
315 |     @inlinable
316 |     static public func +=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
317 |         lhs = lhs + rhs
318 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:309:53: error: cannot find type 'JFloat' in scope
307 |     // JFloat interaction
308 |     @inlinable
309 |     static public func += (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
310 |         lhs = lhs + rhs
311 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:328:52: error: cannot find type 'JFloat' in scope
326 |     }
327 |     @inlinable
328 |     static public func /=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
329 |         lhs = lhs / rhs
330 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:321:53: error: cannot find type 'JFloat' in scope
319 |     }
320 |     @inlinable
321 |     static public func /= (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
322 |         lhs = lhs / rhs
323 |     }
/host/spi-builder-workspace/Sources/Body.swift:479:18: error: cannot find 'JFloat' in scope
 477 |         }
 478 |
 479 |         angle /= JFloat(c)
     |                  `- error: cannot find 'JFloat' in scope
 480 |
 481 |         derivedAngle = angle
/host/spi-builder-workspace/Sources/Body.swift:486:59: error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                           `- error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Body.swift:486:63: error: reference to member 'pi' cannot be resolved without a contextual type
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                               `- error: reference to member 'pi' cannot be resolved without a contextual type
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:279:45: error: cannot find type 'JFloat' in scope
277 |
278 |     @inlinable
279 |     static public func /(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
280 |         return Vector2(x: lhs.x / rhs, y: lhs.y / rhs)
281 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:290:31: error: cannot find type 'JFloat' in scope
288 |
289 |     @inlinable
290 |     static public func /(lhs: JFloat, rhs: Vector2) -> Vector2 {
    |                               `- error: cannot find type 'JFloat' in scope
291 |         return Vector2(x: lhs / rhs.x, y: lhs / rhs.y)
292 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:269:46: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func / (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
270 |         return Vector3(x: lhs.x / rhs, y: lhs.y / rhs, z: lhs.z / rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:283:32: error: cannot find type 'JFloat' in scope
281 |
282 |     @inlinable
283 |     static public func / (lhs: JFloat, rhs: Vector3) -> Vector3 {
    |                                `- error: cannot find type 'JFloat' in scope
284 |         return Vector3(x: lhs / rhs.x, y: lhs / rhs.y, z: lhs / rhs.z)
285 |     }
/host/spi-builder-workspace/Sources/PointMass.swift:45:47: error: cannot find type 'JFloat' in scope
43 |     /// seconds
44 |     @inlinable
45 |     public mutating func integrate(_ elapsed: JFloat) {
   |                                               `- error: cannot find type 'JFloat' in scope
46 |         if mass.isFinite {
47 |             let elapsedMass = elapsed / mass
/host/spi-builder-workspace/Sources/Body.swift:544:13: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 542 |             let pointMass = pointMasses[i]
 543 |
 544 |             applyVelocity(-(pointMass.velocity - (pointMass.velocity * velDamping)) * (elapsed * 200), toPointMassAt: i)
     |             `- error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 545 |         }
 546 |     }
/host/spi-builder-workspace/Sources/Geometry/AABB.swift:53:22: error: cannot find type 'JFloat' in scope
 51 |     /// Gets the middle X position of this AABB
 52 |     @inlinable
 53 |     public var midX: JFloat {
    |                      `- error: cannot find type 'JFloat' in scope
 54 |         return (minimum.x + maximum.x) / 2
 55 |     }
/host/spi-builder-workspace/Sources/Body.swift:638:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 636 |                     // this line crosses the test line at some point... does it
 637 |                     // do so within our test range?
 638 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 639 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 640 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Body.swift:665:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 663 |                     // this line crosses the test line at some point... does it
 664 |                     // do so within our test range?
 665 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 666 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 667 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:27: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                           `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:39: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                                       `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Body.swift:748:20: error: cannot find type 'JFloat' in scope
 746 |         var hitPt: Vector2 = .zero
 747 |         var normal: Vector2 = .zero
 748 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 749 |
 750 |         var dist: JFloat = 0
/host/spi-builder-workspace/Sources/Body.swift:750:19: error: cannot find type 'JFloat' in scope
 748 |         var edgeD: JFloat = 0
 749 |
 750 |         var dist: JFloat = 0
     |                   `- error: cannot find type 'JFloat' in scope
 751 |
 752 |         let edge = edges[edgeNum]
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:108:53: error: cannot find type 'JFloat' in scope
106 |     /// Returns the distance squared between this Vector2 and another Vector2
107 |     @inlinable
108 |     public func distanceSquared(to vec: Vector2) -> JFloat {
    |                                                     `- error: cannot find type 'JFloat' in scope
109 |         let d = self - vec
110 |
/host/spi-builder-workspace/Sources/Body.swift:840:20: error: cannot find type 'JFloat' in scope
 838 |         var pointA = -1
 839 |         var pointB = -1
 840 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 841 |         var normal: Vector2 = .zero
 842 |         var hitPt: Vector2 = .zero
/host/spi-builder-workspace/Sources/Body.swift:844:24: error: cannot find 'JFloat' in scope
 842 |         var hitPt: Vector2 = .zero
 843 |
 844 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 845 |
 846 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Body.swift:900:24: error: cannot find type 'JFloat' in scope
 898 |         var closestP2 = 0// closestP1
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
     |                        `- error: cannot find type 'JFloat' in scope
 901 |         var closestD = JFloat.infinity
 902 |
/host/spi-builder-workspace/Sources/Body.swift:901:24: error: cannot find 'JFloat' in scope
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
 901 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 902 |
 903 |         for edge in edges {
/host/spi-builder-workspace/Sources/Body.swift:939:26: error: cannot find 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
 939 |         var closestSQD = JFloat.greatestFiniteMagnitude
     |                          `- error: cannot find 'JFloat' in scope
 940 |         var closest: Int!
 941 |
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:29:23: error: cannot find type 'JFloat' in scope
27 |     /// A value from 0 - 1 specifying at which point in the edge
28 |     /// bodyBpmA - bodyBpmB is the penetration occurring.
29 |     public var edgeD: JFloat = 0
   |                       `- error: cannot find type 'JFloat' in scope
30 |     /// Global normal for the collision. Always the penetrated edge's normal.
31 |     public var normal = Vector2.zero
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:34:29: error: cannot find type 'JFloat' in scope
32 |     /// Penetration distance.
33 |     /// Is the distance required to move bodyApm in order to solve the collision
34 |     public var penetration: JFloat = 0
   |                             `- error: cannot find type 'JFloat' in scope
35 |
36 |     /// Inits this collision information with no edge information.
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Encodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Encodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
40 |
41 |     public init() {
Swift.Encodable.encode:2:6: note: protocol requires function 'encode(to:)' with type 'Encodable'
1 | protocol Encodable {
2 | func encode(to encoder: any Encoder) throws}
  |      `- note: protocol requires function 'encode(to:)' with type 'Encodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:100:46: error: cannot find type 'JFloat' in scope
 98 |     /// Returns the distance between this Vector2 and another Vector2
 99 |     @inlinable
100 |     public func distance(to vec: Vector2) -> JFloat {
    |                                              `- error: cannot find type 'JFloat' in scope
101 |         let d = self - vec
102 |
[36/36] Compiling JelloSwift BodyEdge.swift
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:269:45: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func -(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
270 |         return Vector2(x: lhs.x - rhs, y: lhs.y - rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:259:46: error: cannot find type 'JFloat' in scope
257 |
258 |     @inlinable
259 |     static public func - (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
260 |         return Vector3(x: lhs.x - rhs, y: lhs.y - rhs, z: lhs.z - rhs)
261 |     }
/host/spi-builder-workspace/Sources/Geometry/Matrix3x3.swift:5:31: error: cannot find type 'JFloat' in scope
  3 | /// Plain 3-row 3-column Matrix with real components.
  4 | public struct Matrix3x3: CustomStringConvertible {
  5 |     public typealias Scalar = JFloat
    |                               `- error: cannot find type 'JFloat' in scope
  6 |
  7 |     /// Returns a 3x3 [identity matrix].
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:28:19: error: cannot find type 'JFloat' in scope
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:31:19: error: cannot find type 'JFloat' in scope
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                   `- error: cannot find type 'JFloat' in scope
 32 |
 33 |     /// Returns the angle in radians of this Vector2
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:12:15: error: type 'Vector2' does not conform to protocol 'Decodable'
 10 |
 11 | /// Represents a 2D vector
 12 | public struct Vector2: VectorRepresentable, Equatable, CustomStringConvertible, Codable {
    |               `- error: type 'Vector2' does not conform to protocol 'Decodable'
 13 |
 14 |     /// A zeroed-value Vector2
    :
 26 |
 27 |     /// The JFloat representation of this vector's x axis
 28 |     public var x: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 29 |
 30 |     /// The JFloat representation of this vector's y axis
 31 |     public var y: JFloat
    |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
 32 |
 33 |     /// Returns the angle in radians of this Vector2
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:93:24: error: cannot find type 'JFloat' in scope
 91 |     /// Inits a vector 2 with X and Y defined as a given float
 92 |     @inlinable
 93 |     public init(value: JFloat) {
    |                        `- error: cannot find type 'JFloat' in scope
 94 |         x = value
 95 |         y = value
/host/spi-builder-workspace/Sources/Body.swift:50:28: error: cannot find type 'JFloat' in scope
  48 |     /// 1 never decelerates. Values outside the range [0, 1] inclusive may
  49 |     /// introduce instability
  50 |     public var velDamping: JFloat = 0.999
     |                            `- error: cannot find type 'JFloat' in scope
  51 |
  52 |     /// The array of body components for this body object
/host/spi-builder-workspace/Sources/Body.swift:63:47: error: cannot find type 'JFloat' in scope
  61 |
  62 |     /// The derived rotation of the body, in radians
  63 |     public fileprivate(set) var derivedAngle: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
/host/spi-builder-workspace/Sources/Body.swift:66:47: error: cannot find type 'JFloat' in scope
  64 |
  65 |     /// Omega (ω) is the relative angular speed of the body, in radians/s
  66 |     public fileprivate(set) var derivedOmega: JFloat = 0
     |                                               `- error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
/host/spi-builder-workspace/Sources/Body.swift:69:32: error: cannot find type 'JFloat' in scope
  67 |
  68 |     // Utilize to calculate the omega for the body
  69 |     fileprivate var lastAngle: JFloat = 0
     |                                `- error: cannot find type 'JFloat' in scope
  70 |
  71 |     /// Gets a list of vertices that represents the current position of each
/host/spi-builder-workspace/Sources/Body.swift:143:23: error: cannot find type 'JFloat' in scope
 141 |         world: World? = nil,
 142 |         shape: ClosedShape,
 143 |         pointMasses: [JFloat] = [1],
     |                       `- error: cannot find type 'JFloat' in scope
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
/host/spi-builder-workspace/Sources/Body.swift:145:16: error: cannot find type 'JFloat' in scope
 143 |         pointMasses: [JFloat] = [1],
 144 |         position: Vector2 = Vector2.zero,
 145 |         angle: JFloat = 0,
     |                `- error: cannot find type 'JFloat' in scope
 146 |         scale: Vector2 = Vector2.unit,
 147 |         kinematic: Bool = false,
/host/spi-builder-workspace/Sources/Body.swift:305:39: error: cannot find type 'JFloat' in scope
 303 |     /// - parameter forceUpdate:
 304 |     ///     Whether to force the update of the body, even if it's a static body.
 305 |     public func updateAABB(_ elapsed: JFloat, forceUpdate: Bool) {
     |                                       `- error: cannot find type 'JFloat' in scope
 306 |         guard !isStatic || forceUpdate else {
 307 |             return
/host/spi-builder-workspace/Sources/Body.swift:361:36: error: cannot find type 'JFloat' in scope
 359 |
 360 |     /// Sets the mass for all the PointMass objects in this body.
 361 |     public func setMassAll(_ mass: JFloat) {
     |                                    `- error: cannot find type 'JFloat' in scope
 362 |         for i in 0..<pointMasses.count {
 363 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:370:63: error: cannot find type 'JFloat' in scope
 368 |
 369 |     /// Sets the mass for a single PointMass individually.
 370 |     public func setMassForPointMass(atIndex index: Int, mass: JFloat) {
     |                                                               `- error: cannot find type 'JFloat' in scope
 371 |         pointMasses[index].mass = mass
 372 |
/host/spi-builder-workspace/Sources/Body.swift:381:43: error: cannot find type 'JFloat' in scope
 379 |     /// sets up to the count of masses in the array, if larger, it sets the
 380 |     /// matching masses for all point masses, and ignores the rest of the array.
 381 |     public func setMass(fromList masses: [JFloat]) {
     |                                           `- error: cannot find type 'JFloat' in scope
 382 |         for (mass, i) in zip(masses, 0..<pointMasses.count) {
 383 |             pointMasses[i].mass = mass
/host/spi-builder-workspace/Sources/Body.swift:394:57: error: cannot find type 'JFloat' in scope
 392 |     /// Setting the position and angle resets the current shape to the original
 393 |     /// base shape of the object.
 394 |     public func setPositionAngle(_ pos: Vector2, angle: JFloat, scale: Vector2) {
     |                                                         `- error: cannot find type 'JFloat' in scope
 395 |         let matrix = Vector2.matrix(scalingBy: scale, rotatingBy: angle, translatingBy: pos)
 396 |
/host/spi-builder-workspace/Sources/Body.swift:424:51: error: cannot find type 'JFloat' in scope
 422 |     /// call this. Instead you can just access the `derivedPosition`, `DerivedAngle`,
 423 |     /// `derivedVelocity`, and `derivedOmega` properties.
 424 |     public func derivePositionAndAngle(_ elapsed: JFloat) {
     |                                                   `- error: cannot find type 'JFloat' in scope
 425 |         // No need if this is a static body, or kinematically controlled.
 426 |         if isStatic || isKinematic {
/host/spi-builder-workspace/Sources/Body.swift:522:38: error: cannot find type 'JFloat' in scope
 520 |     /// Integrates the point masses for this Body.
 521 |     /// Ignored, if body is static.
 522 |     public func integrate(_ elapsed: JFloat) {
     |                                      `- error: cannot find type 'JFloat' in scope
 523 |         if isStatic {
 524 |             return
/host/spi-builder-workspace/Sources/Body.swift:536:43: error: cannot find type 'JFloat' in scope
 534 |     /// Applies the velocity damping to the point masses.
 535 |     /// Ignored, if body is static.
 536 |     public func dampenVelocity(_ elapsed: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 537 |         if isStatic {
 538 |             return
/host/spi-builder-workspace/Sources/Body.swift:550:39: error: cannot find type 'JFloat' in scope
 548 |     /// Applies a rotational clockwise torque of a given force on this body.
 549 |     /// Ignored, if body is static.
 550 |     public func applyTorque(of force: JFloat) {
     |                                       `- error: cannot find type 'JFloat' in scope
 551 |         if isStatic {
 552 |             return
/host/spi-builder-workspace/Sources/Body.swift:569:43: error: cannot find type 'JFloat' in scope
 567 |     /// The method keeps the average velocity of the point masses the same during
 568 |     /// the procedure.
 569 |     public func setAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 570 |         if isStatic {
 571 |             return
/host/spi-builder-workspace/Sources/Body.swift:583:43: error: cannot find type 'JFloat' in scope
 581 |
 582 |     /// Accumulates the angular velocity for this body
 583 |     public func addAngularVelocity(_ vel: JFloat) {
     |                                           `- error: cannot find type 'JFloat' in scope
 584 |         if isStatic {
 585 |             return
/host/spi-builder-workspace/Sources/Body.swift:743:54: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:743:72: error: cannot find type 'JFloat' in scope
 741 |         to pt: Vector2,
 742 |         onEdge edgeNum: Int
 743 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 744 |         assert(pointMasses.count > 0)
 745 |
/host/spi-builder-workspace/Sources/Body.swift:810:54: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                      `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:810:72: error: cannot find type 'JFloat' in scope
 808 |         to pt: Vector2,
 809 |         onEdge edgeNum: Int
 810 |     ) -> (hitPoint: Vector2, normal: Vector2, edgeD: JFloat, distance: JFloat) {
     |                                                                        `- error: cannot find type 'JFloat' in scope
 811 |         let result = closestPointSquared(to: pt, onEdge: edgeNum)
 812 |
/host/spi-builder-workspace/Sources/Body.swift:835:80: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:835:98: error: cannot find type 'JFloat' in scope
 833 |     public func closestPoint(
 834 |         to pt: Vector2
 835 |     ) -> (hitPoint: Vector2, normal: Vector2, pointA: Int, pointB: Int, edgeD: JFloat, distance: JFloat) {
     |                                                                                                  `- error: cannot find type 'JFloat' in scope
 836 |         assert(pointMasses.count > 0)
 837 |
/host/spi-builder-workspace/Sources/Body.swift:891:45: error: cannot find type 'JFloat' in scope
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
     |                                             `- error: cannot find type 'JFloat' in scope
 892 |         if edges.count == 0 || pointMasses.count == 0 {
 893 |             return nil
/host/spi-builder-workspace/Sources/Body.swift:890:34: error: cannot find type 'JFloat' in scope
 888 |     public func closestEdge(
 889 |         to pt: Vector2,
 890 |         withTolerance tolerance: JFloat = JFloat.infinity
     |                                  `- error: cannot find type 'JFloat' in scope
 891 |     ) -> (edgePosition: Vector2, edgeRatio: JFloat, edgePoint1: Int, edgePoint2: Int)? {
 892 |         if edges.count == 0 || pointMasses.count == 0 {
/host/spi-builder-workspace/Sources/Body.swift:936:77: error: cannot find type 'JFloat' in scope
 934 |     /// Find the closest PointMass index in this body, given a global point
 935 |     /// - precondition: There is at least one point mass in this body
 936 |     public func closestPointMass(to pos: Vector2) -> (point: Int, distance: JFloat) {
     |                                                                             `- error: cannot find type 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:36:24: error: cannot find type 'JFloat' in scope
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                        `- error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
/host/spi-builder-workspace/Sources/BodyEdge.swift:39:31: error: cannot find type 'JFloat' in scope
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                               `- error: cannot find type 'JFloat' in scope
40 |
41 |     public init() {
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Decodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Decodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
40 |
41 |     public init() {
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:284:45: error: cannot find type 'JFloat' in scope
282 |
283 |     @inlinable
284 |     static public func %(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
285 |         return Vector2(x: lhs.x.truncatingRemainder(dividingBy: rhs),
286 |                        y: lhs.y.truncatingRemainder(dividingBy: rhs))
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:274:46: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func % (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
275 |         return Vector3(
276 |             x: lhs.x.truncatingRemainder(dividingBy: rhs),
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:264:45: error: cannot find type 'JFloat' in scope
262 |     // JFloat interaction
263 |     @inlinable
264 |     static public func +(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
265 |         return Vector2(x: lhs.x + rhs, y: lhs.y + rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:254:46: error: cannot find type 'JFloat' in scope
252 |     // JFloat interaction
253 |     @inlinable
254 |     static public func + (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
255 |         return Vector3(x: lhs.x + rhs, y: lhs.y + rhs, z: lhs.z + rhs)
256 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:274:45: error: cannot find type 'JFloat' in scope
272 |
273 |     @inlinable
274 |     static public func *(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
275 |         return Vector2(x: lhs.x * rhs, y: lhs.y * rhs)
276 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:264:46: error: cannot find type 'JFloat' in scope
262 |
263 |     @inlinable
264 |     static public func * (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
265 |         return Vector3(x: lhs.x * rhs, y: lhs.y * rhs, z: lhs.z * rhs)
266 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:349:27: error: cannot find type 'JFloat' in scope
347 |     static public func matrix(
348 |         scalingBy scale: Vector2 = Vector2.unit,
349 |         rotatingBy angle: JFloat = 0,
    |                           `- error: cannot find type 'JFloat' in scope
350 |         translatingBy translate: Vector2 = Vector2.zero
351 |     ) -> Matrix3x3 {
/host/spi-builder-workspace/Sources/Geometry/ClosedShape.swift:150:25: error: cannot find type 'JFloat' in scope
148 |         _ target: inout [Vector2],
149 |         worldPos: Vector2,
150 |         angleInRadians: JFloat,
    |                         `- error: cannot find type 'JFloat' in scope
151 |         localScale: Vector2 = Vector2.unit
152 |     ) {
/host/spi-builder-workspace/Sources/PointMass.swift:16:22: error: cannot find type 'JFloat' in scope
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                      `- error: cannot find type 'JFloat' in scope
17 |
18 |     /// The global position of the point, in world coordinates
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:10:15: error: type 'PointMass' does not conform to protocol 'Decodable'
 8 |
 9 | /// Specifies a point mass that composes a body
10 | public struct PointMass: Codable, VectorRepresentable {
   |               `- error: type 'PointMass' does not conform to protocol 'Decodable'
11 |     /// The mass of this point mass.
12 |     /// Leave this value always `> 0` to maintain consistency on the simulation,
   :
14 |     /// Values `< 0.2` usually cause inconsistency and instability in the
15 |     /// simulation
16 |     public var mass: JFloat = 1
   |                `- note: cannot automatically synthesize 'Decodable' because 'JFloat' does not conform to 'Decodable'
17 |
18 |     /// The global position of the point, in world coordinates
Swift.Decodable.init:2:1: note: protocol requires initializer 'init(from:)' with type 'Decodable'
1 | protocol Decodable {
2 | init(from decoder: any Decoder) throws}
  | `- note: protocol requires initializer 'init(from:)' with type 'Decodable'
3 |
/host/spi-builder-workspace/Sources/PointMass.swift:35:23: error: cannot find type 'JFloat' in scope
33 |     }
34 |
35 |     public init(mass: JFloat = 0, position: Vector2 = Vector2.zero) {
   |                       `- error: cannot find type 'JFloat' in scope
36 |         self.mass = mass
37 |         self.position = position
/host/spi-builder-workspace/Sources/Body.swift:445:20: error: cannot find type 'JFloat' in scope
 443 |
 444 |         // find the average angle of all of the masses.
 445 |         var angle: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
/host/spi-builder-workspace/Sources/Body.swift:448:28: error: cannot find type 'JFloat' in scope
 446 |
 447 |         var originalSign = 1
 448 |         var originalAngle: JFloat = 0
     |                            `- error: cannot find type 'JFloat' in scope
 449 |
 450 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:221:59: error: cannot find type 'JFloat' in scope
219 |     /// See `Vector2.dot`
220 |     @inlinable
221 |     static public func •(lhs: Vector2, rhs: Vector2) -> JFloat {
    |                                                         `- error: cannot find type 'JFloat' in scope
222 |         return lhs.dot(rhs)
223 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:208:60: error: cannot find type 'JFloat' in scope
206 |     /// See `Vector3.dot`
207 |     @inlinable
208 |     static public func • (lhs: Vector3, rhs: Vector3) -> JFloat {
    |                                                          `- error: cannot find type 'JFloat' in scope
209 |         return lhs.dot(rhs)
210 |     }
/host/spi-builder-workspace/Sources/Body.swift:467:33: error: reference to member 'pi' cannot be resolved without a contextual type
 465 |                 let thisSign = (thisAngle >= 0.0) ? 1 : -1
 466 |
 467 |                 if abs(diff) > .pi && (thisSign != originalSign) {
     |                                 `- error: reference to member 'pi' cannot be resolved without a contextual type
 468 |                     if thisSign == -1 {
 469 |                         thisAngle = .pi + (.pi + thisAngle)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:316:52: error: cannot find type 'JFloat' in scope
314 |     // JFloat interaction
315 |     @inlinable
316 |     static public func +=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
317 |         lhs = lhs + rhs
318 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:309:53: error: cannot find type 'JFloat' in scope
307 |     // JFloat interaction
308 |     @inlinable
309 |     static public func += (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
310 |         lhs = lhs + rhs
311 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:328:52: error: cannot find type 'JFloat' in scope
326 |     }
327 |     @inlinable
328 |     static public func /=(lhs: inout Vector2, rhs: JFloat) {
    |                                                    `- error: cannot find type 'JFloat' in scope
329 |         lhs = lhs / rhs
330 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:321:53: error: cannot find type 'JFloat' in scope
319 |     }
320 |     @inlinable
321 |     static public func /= (lhs: inout Vector3, rhs: JFloat) {
    |                                                     `- error: cannot find type 'JFloat' in scope
322 |         lhs = lhs / rhs
323 |     }
/host/spi-builder-workspace/Sources/Body.swift:479:18: error: cannot find 'JFloat' in scope
 477 |         }
 478 |
 479 |         angle /= JFloat(c)
     |                  `- error: cannot find 'JFloat' in scope
 480 |
 481 |         derivedAngle = angle
/host/spi-builder-workspace/Sources/Body.swift:486:59: error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                           `- error: binary operator '>=' cannot be applied to operands of type 'Matrix3x3' and '_'
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Body.swift:486:63: error: reference to member 'pi' cannot be resolved without a contextual type
 484 |         var angleChange = (derivedAngle - lastAngle)
 485 |
 486 |         if (angleChange < 0 ? -angleChange : angleChange) >= .pi {
     |                                                               `- error: reference to member 'pi' cannot be resolved without a contextual type
 487 |             if angleChange < 0 {
 488 |                 angleChange = angleChange + (.pi * 2)
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:279:45: error: cannot find type 'JFloat' in scope
277 |
278 |     @inlinable
279 |     static public func /(lhs: Vector2, rhs: JFloat) -> Vector2 {
    |                                             `- error: cannot find type 'JFloat' in scope
280 |         return Vector2(x: lhs.x / rhs, y: lhs.y / rhs)
281 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:290:31: error: cannot find type 'JFloat' in scope
288 |
289 |     @inlinable
290 |     static public func /(lhs: JFloat, rhs: Vector2) -> Vector2 {
    |                               `- error: cannot find type 'JFloat' in scope
291 |         return Vector2(x: lhs / rhs.x, y: lhs / rhs.y)
292 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:269:46: error: cannot find type 'JFloat' in scope
267 |
268 |     @inlinable
269 |     static public func / (lhs: Vector3, rhs: JFloat) -> Vector3 {
    |                                              `- error: cannot find type 'JFloat' in scope
270 |         return Vector3(x: lhs.x / rhs, y: lhs.y / rhs, z: lhs.z / rhs)
271 |     }
/host/spi-builder-workspace/Sources/Geometry/Vector3.swift:283:32: error: cannot find type 'JFloat' in scope
281 |
282 |     @inlinable
283 |     static public func / (lhs: JFloat, rhs: Vector3) -> Vector3 {
    |                                `- error: cannot find type 'JFloat' in scope
284 |         return Vector3(x: lhs / rhs.x, y: lhs / rhs.y, z: lhs / rhs.z)
285 |     }
/host/spi-builder-workspace/Sources/PointMass.swift:45:47: error: cannot find type 'JFloat' in scope
43 |     /// seconds
44 |     @inlinable
45 |     public mutating func integrate(_ elapsed: JFloat) {
   |                                               `- error: cannot find type 'JFloat' in scope
46 |         if mass.isFinite {
47 |             let elapsedMass = elapsed / mass
/host/spi-builder-workspace/Sources/Body.swift:544:13: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 542 |             let pointMass = pointMasses[i]
 543 |
 544 |             applyVelocity(-(pointMass.velocity - (pointMass.velocity * velDamping)) * (elapsed * 200), toPointMassAt: i)
     |             `- error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 545 |         }
 546 |     }
/host/spi-builder-workspace/Sources/Geometry/AABB.swift:53:22: error: cannot find type 'JFloat' in scope
 51 |     /// Gets the middle X position of this AABB
 52 |     @inlinable
 53 |     public var midX: JFloat {
    |                      `- error: cannot find type 'JFloat' in scope
 54 |         return (minimum.x + maximum.x) / 2
 55 |     }
/host/spi-builder-workspace/Sources/Body.swift:638:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 636 |                     // this line crosses the test line at some point... does it
 637 |                     // do so within our test range?
 638 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 639 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 640 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Body.swift:665:56: error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 663 |                     // this line crosses the test line at some point... does it
 664 |                     // do so within our test range?
 665 |                     let slope = (edgeEnd.x - edgeSt.x) / (edgeEnd.y - edgeSt.y)
     |                                                        `- error: referencing operator function '/' on 'DurationProtocol' requires that 'Matrix3x3' conform to 'DurationProtocol'
 666 |                     let hitX = edgeSt.x + ((pt.y - edgeSt.y) * slope)
 667 |
Swift.DurationProtocol:2:17: note: where 'Self' = 'Matrix3x3'
1 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
2 | public protocol DurationProtocol : AdditiveArithmetic, Comparable, Sendable {
  |                 `- note: where 'Self' = 'Matrix3x3'
3 |     static func / (lhs: Self, rhs: Int) -> Self
4 |     static func /= (lhs: inout Self, rhs: Int)
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:27: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                           `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Geometry/GeomUtils.swift:35:39: error: cannot find type 'JFloat' in scope
33 |     lineA: (start: Vector2, end: Vector2),
34 |     lineB: (start: Vector2, end: Vector2)
35 | ) -> (hitPt: Vector2, Ua: JFloat, Ub: JFloat)? {
   |                                       `- error: cannot find type 'JFloat' in scope
36 |     let denom = ((lineB.end.y - lineB.start.y) * (lineA.end.x - lineA.start.x)) - ((lineB.end.x - lineB.start.x) * (lineA.end.y - lineA.start.y))
37 |
/host/spi-builder-workspace/Sources/Body.swift:748:20: error: cannot find type 'JFloat' in scope
 746 |         var hitPt: Vector2 = .zero
 747 |         var normal: Vector2 = .zero
 748 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 749 |
 750 |         var dist: JFloat = 0
/host/spi-builder-workspace/Sources/Body.swift:750:19: error: cannot find type 'JFloat' in scope
 748 |         var edgeD: JFloat = 0
 749 |
 750 |         var dist: JFloat = 0
     |                   `- error: cannot find type 'JFloat' in scope
 751 |
 752 |         let edge = edges[edgeNum]
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:108:53: error: cannot find type 'JFloat' in scope
106 |     /// Returns the distance squared between this Vector2 and another Vector2
107 |     @inlinable
108 |     public func distanceSquared(to vec: Vector2) -> JFloat {
    |                                                     `- error: cannot find type 'JFloat' in scope
109 |         let d = self - vec
110 |
/host/spi-builder-workspace/Sources/Body.swift:840:20: error: cannot find type 'JFloat' in scope
 838 |         var pointA = -1
 839 |         var pointB = -1
 840 |         var edgeD: JFloat = 0
     |                    `- error: cannot find type 'JFloat' in scope
 841 |         var normal: Vector2 = .zero
 842 |         var hitPt: Vector2 = .zero
/host/spi-builder-workspace/Sources/Body.swift:844:24: error: cannot find 'JFloat' in scope
 842 |         var hitPt: Vector2 = .zero
 843 |
 844 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 845 |
 846 |         let c = pointMasses.count
/host/spi-builder-workspace/Sources/Body.swift:900:24: error: cannot find type 'JFloat' in scope
 898 |         var closestP2 = 0// closestP1
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
     |                        `- error: cannot find type 'JFloat' in scope
 901 |         var closestD = JFloat.infinity
 902 |
/host/spi-builder-workspace/Sources/Body.swift:901:24: error: cannot find 'JFloat' in scope
 899 |         var edgePosition = Vector2.zero
 900 |         var edgeRatio: JFloat = 0
 901 |         var closestD = JFloat.infinity
     |                        `- error: cannot find 'JFloat' in scope
 902 |
 903 |         for edge in edges {
/host/spi-builder-workspace/Sources/Body.swift:939:26: error: cannot find 'JFloat' in scope
 937 |         assert(pointMasses.count > 0)
 938 |
 939 |         var closestSQD = JFloat.greatestFiniteMagnitude
     |                          `- error: cannot find 'JFloat' in scope
 940 |         var closest: Int!
 941 |
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:29:23: error: cannot find type 'JFloat' in scope
27 |     /// A value from 0 - 1 specifying at which point in the edge
28 |     /// bodyBpmA - bodyBpmB is the penetration occurring.
29 |     public var edgeD: JFloat = 0
   |                       `- error: cannot find type 'JFloat' in scope
30 |     /// Global normal for the collision. Always the penetrated edge's normal.
31 |     public var normal = Vector2.zero
/host/spi-builder-workspace/Sources/BodyCollisionInformation.swift:34:29: error: cannot find type 'JFloat' in scope
32 |     /// Penetration distance.
33 |     /// Is the distance required to move bodyApm in order to solve the collision
34 |     public var penetration: JFloat = 0
   |                             `- error: cannot find type 'JFloat' in scope
35 |
36 |     /// Inits this collision information with no edge information.
/host/spi-builder-workspace/Sources/BodyEdge.swift:10:15: error: type 'BodyEdge' does not conform to protocol 'Encodable'
 8 |
 9 | /// Contains information about the edge of a body
10 | public struct BodyEdge: Codable {
   |               `- error: type 'BodyEdge' does not conform to protocol 'Encodable'
11 |
12 |     /// The index of the edge on the body
   :
34 |
35 |     /// The edge's length
36 |     public var length: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
37 |
38 |     /// The edge's length, squared
39 |     public var lengthSquared: JFloat = 0
   |                `- note: cannot automatically synthesize 'Encodable' because 'JFloat' does not conform to 'Encodable'
40 |
41 |     public init() {
Swift.Encodable.encode:2:6: note: protocol requires function 'encode(to:)' with type 'Encodable'
1 | protocol Encodable {
2 | func encode(to encoder: any Encoder) throws}
  |      `- note: protocol requires function 'encode(to:)' with type 'Encodable'
3 |
/host/spi-builder-workspace/Sources/Geometry/Vector2.swift:100:46: error: cannot find type 'JFloat' in scope
 98 |     /// Returns the distance between this Vector2 and another Vector2
 99 |     @inlinable
100 |     public func distance(to vec: Vector2) -> JFloat {
    |                                              `- error: cannot find type 'JFloat' in scope
101 |         let d = self - vec
102 |
BUILD FAILURE 6.1 wasm