feat: Adds release workflow.

.dockerignore

@@ -0,0 +1,3 @@
+.build/
+.swiftpm/
+

.gitea/workflows/release.yaml

@@ -0,0 +1,65 @@
+name: Create and publish a Docker image
+
+# Configures this workflow to run every time a change is pushed to the branch called `release`.
+on:
+  push:
+    # branches: ['main']
+    tags:
+      - '*.*.*'
+  workflow_dispatch:
+
+# Defines two custom environment variables for the workflow. These are used for the Container registry domain,
+# and a name for the Docker image that this workflow builds.
+env:
+  REGISTRY: git.housh.dev
+  IMAGE_NAME: ${{ gitea.repository }}
+
+# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      # Uses the `docker/login-action` action to log in to the Container registry registry using the account
+      # and password that will publish the packages. Once published, the packages are scoped to the account defined here.
+      - name: Log in to the Container registry
+        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ gitea.actor }}
+          password: ${{ secrets.CONTAINER_TOKEN }}
+      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels
+      # that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a
+      # subsequent step. The `images` value provides the base name for the tags and labels.
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}}
+            type=sha
+            type=raw,value=prod
+      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If
+      # the build succeeds, it pushes the image to GitHub Packages. It uses the `context` parameter to define the build's context
+      # as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)"
+      # in the README of the `docker/build-push-action` repository.
+      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
+        with:
+          context: .
+          file: docker/Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+

.gitignore

@@ -6,3 +6,6 @@ DerivedData/
 .swiftpm/configuration/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
+.swift-version
+node_modules/
+tailwindcss

Package.resolved

@@ -1,5 +1,5 @@
 {
-  "originHash" : "f8ca659e4ec9041ea590b94c8dc267718be8941a4594eb74964b6396e987ca95",
+  "originHash" : "5d6dad57209ac74e3c47d8e8eb162768b81c9e63e15df87d29019d46a13cfec2",
   "pins" : [
     {
       "identity" : "async-http-client",
@@ -37,6 +37,24 @@
         "version" : "4.15.2"
       }
     },
+    {
+      "identity" : "elementary",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/elementary-swift/elementary.git",
+      "state" : {
+        "revision" : "65803c4770b6c8b6452c6ce83ab570c1b7042528",
+        "version" : "0.6.1"
+      }
+    },
+    {
+      "identity" : "elementary-htmx",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/elementary-swift/elementary-htmx.git",
+      "state" : {
+        "revision" : "f7ba147f2a076142a90a4f8300a89584164dba6d",
+        "version" : "0.5.1"
+      }
+    },
     {
       "identity" : "fluent",
       "kind" : "remoteSourceControl",
@@ -379,6 +397,24 @@
         "version" : "4.120.0"
       }
     },
+    {
+      "identity" : "vapor-elementary",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/vapor-community/vapor-elementary.git",
+      "state" : {
+        "revision" : "e1326d2439a9d4bd271c24b9765c195f7f793e77",
+        "version" : "0.2.2"
+      }
+    },
+    {
+      "identity" : "vapor-routing",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/pointfreeco/vapor-routing.git",
+      "state" : {
+        "revision" : "ae1db2ec96fad88b00173a265313de2c447a9945",
+        "version" : "0.1.3"
+      }
+    },
     {
       "identity" : "websocket-kit",
       "kind" : "remoteSourceControl",

Package.swift

@@ -5,23 +5,54 @@ import PackageDescription
 let package = Package(
   name: "swift-manual-d",
   products: [
+    .executable(name: "App", targets: ["App"]),
+    .library(name: "ApiController", targets: ["ApiController"]),
+    .library(name: "DatabaseClient", targets: ["DatabaseClient"]),
     .library(name: "ManualDCore", targets: ["ManualDCore"]),
     .library(name: "ManualDClient", targets: ["ManualDClient"]),
+    .library(name: "Styleguide", targets: ["Styleguide"]),
+    .library(name: "ViewController", targets: ["ViewController"]),
   ],
   dependencies: [
-    // 💧 A server-side Swift web framework.
     .package(url: "https://github.com/vapor/vapor.git", from: "4.110.1"),
-    // 🗄 An ORM for SQL and NoSQL databases.
     .package(url: "https://github.com/vapor/fluent.git", from: "4.9.0"),
-    // 🪶 Fluent driver for SQLite.
     .package(url: "https://github.com/vapor/fluent-sqlite-driver.git", from: "4.6.0"),
-    // 🔵 Non-blocking, event-driven networking Swift. Used for, custom executors
     .package(url: "https://github.com/apple/swift-nio.git", from: "2.65.0"),
     .package(url: "https://github.com/pointfreeco/swift-dependencies", from: "1.0.0"),
     .package(url: "https://github.com/pointfreeco/swift-url-routing.git", from: "0.6.2"),
+    .package(url: "https://github.com/pointfreeco/vapor-routing.git", from: "0.1.3"),
     .package(url: "https://github.com/pointfreeco/swift-case-paths.git", from: "1.6.0"),
+    .package(url: "https://github.com/elementary-swift/elementary.git", from: "0.6.0"),
+    .package(url: "https://github.com/elementary-swift/elementary-htmx.git", from: "0.5.0"),
+    .package(url: "https://github.com/vapor-community/vapor-elementary.git", from: "0.1.0"),
   ],
   targets: [
+    .executableTarget(
+      name: "App",
+      dependencies: [
+        .target(name: "ApiController"),
+        .target(name: "DatabaseClient"),
+        .target(name: "ViewController"),
+        .product(name: "Dependencies", package: "swift-dependencies"),
+        .product(name: "Fluent", package: "fluent"),
+        .product(name: "FluentSQLiteDriver", package: "fluent-sqlite-driver"),
+        .product(name: "Vapor", package: "vapor"),
+        .product(name: "NIOCore", package: "swift-nio"),
+        .product(name: "NIOPosix", package: "swift-nio"),
+        .product(name: "VaporElementary", package: "vapor-elementary"),
+        .product(name: "VaporRouting", package: "vapor-routing"),
+      ]
+    ),
+    .target(
+      name: "ApiController",
+      dependencies: [
+        .target(name: "DatabaseClient"),
+        .target(name: "ManualDCore"),
+        .product(name: "Dependencies", package: "swift-dependencies"),
+        .product(name: "DependenciesMacros", package: "swift-dependencies"),
+        .product(name: "Vapor", package: "vapor"),
+      ]
+    ),
     .target(
       name: "DatabaseClient",
       dependencies: [
@@ -36,10 +67,17 @@ let package = Package(
       name: "ManualDCore",
       dependencies: [
         .product(name: "Dependencies", package: "swift-dependencies"),
+        .product(name: "Fluent", package: "fluent"),
         .product(name: "URLRouting", package: "swift-url-routing"),
         .product(name: "CasePaths", package: "swift-case-paths"),
       ]
     ),
+    .testTarget(
+      name: "ApiRouteTests",
+      dependencies: [
+        .target(name: "ManualDCore")
+      ]
+    ),
     .target(
       name: "ManualDClient",
       dependencies: [
@@ -48,6 +86,14 @@ let package = Package(
         .product(name: "DependenciesMacros", package: "swift-dependencies"),
       ]
     ),
+    .target(
+      name: "Styleguide",
+      dependencies: [
+        "ManualDCore",
+        .product(name: "Elementary", package: "elementary"),
+        .product(name: "ElementaryHTMX", package: "elementary-htmx"),
+      ]
+    ),
     .testTarget(
       name: "ManualDClientTests",
       dependencies: [
@@ -55,10 +101,18 @@ let package = Package(
         .product(name: "DependenciesTestSupport", package: "swift-dependencies"),
       ]
     ),
-    .testTarget(
-      name: "ApiRouteTests",
+    .target(
+      name: "ViewController",
       dependencies: [
-        .target(name: "ManualDCore")
+        .target(name: "DatabaseClient"),
+        .target(name: "ManualDClient"),
+        .target(name: "ManualDCore"),
+        .target(name: "Styleguide"),
+        .product(name: "Dependencies", package: "swift-dependencies"),
+        .product(name: "DependenciesMacros", package: "swift-dependencies"),
+        .product(name: "Elementary", package: "elementary"),
+        .product(name: "ElementaryHTMX", package: "elementary-htmx"),
+        .product(name: "Vapor", package: "vapor"),
       ]
     ),
   ]

Public/css/main.css

@@ -0,0 +1,5 @@
+@import "tailwindcss";
+@plugin "daisyui" {
+	themes: all;
+}
+

Public/site.webmanifest

@@ -0,0 +1 @@
+{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

Sources/ApiController/Interface.swift

@@ -0,0 +1,38 @@
+import Dependencies
+import DependenciesMacros
+import Logging
+import ManualDCore
+
+extension DependencyValues {
+  public var apiController: ApiController {
+    get { self[ApiController.self] }
+    set { self[ApiController.self] = newValue }
+  }
+}
+
+@DependencyClient
+public struct ApiController: Sendable {
+  public var json: @Sendable (Request) async throws -> (any Encodable)?
+}
+
+extension ApiController {
+  public struct Request: Sendable {
+    public let route: SiteRoute.Api
+    public let logger: Logger
+
+    public init(route: SiteRoute.Api, logger: Logger) {
+      self.route = route
+      self.logger = logger
+    }
+  }
+}
+
+extension ApiController: DependencyKey {
+  public static let testValue = Self()
+
+  public static let liveValue = Self(
+    json: { request in
+      try await request.route.respond(logger: request.logger)
+    }
+  )
+}

Sources/ApiController/Live.swift

@@ -0,0 +1,127 @@
+import DatabaseClient
+import Dependencies
+import Logging
+import ManualDCore
+
+extension SiteRoute.Api {
+  func respond(logger: Logger) async throws -> (any Encodable)? {
+    switch self {
+    case .project(let route):
+      return try await route.respond(logger: logger)
+    case .room(let route):
+      return try await route.respond(logger: logger)
+    case .equipment(let route):
+      return try await route.respond(logger: logger)
+    case .componentLoss(let route):
+      return try await route.respond(logger: logger)
+    }
+  }
+}
+
+extension SiteRoute.Api.ProjectRoute {
+
+  func respond(logger: Logger) async throws -> (any Encodable)? {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .create(let request):
+      // return try await database.projects.create(request)
+      // FIX:
+      fatalError()
+    case .delete(let id):
+      try await database.projects.delete(id)
+      return nil
+    case .detail(let id, let route):
+      switch route {
+      case .completedSteps:
+        // FIX:
+        fatalError()
+
+      }
+    case .get(let id):
+      guard let project = try await database.projects.get(id) else {
+        logger.error("Project not found for id: \(id)")
+        throw ApiError("Project not found.")
+      }
+      return project
+    case .index:
+      // FIX: Fix to return projects.
+      return [Project]()
+    }
+  }
+}
+
+extension SiteRoute.Api.RoomRoute {
+
+  func respond(logger: Logger) async throws -> (any Encodable)? {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .create(let request):
+      return try await database.rooms.create(request)
+    case .delete(let id):
+      try await database.rooms.delete(id)
+      return nil
+    case .get(let id):
+      guard let room = try await database.rooms.get(id) else {
+        logger.error("Room not found for id: \(id)")
+        throw ApiError("Room not found.")
+      }
+      return room
+    }
+  }
+}
+
+extension SiteRoute.Api.EquipmentRoute {
+
+  func respond(logger: Logger) async throws -> (any Encodable)? {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .create(let request):
+      return try await database.equipment.create(request)
+    case .delete(let id):
+      try await database.equipment.delete(id)
+      return nil
+    case .fetch(let projectID):
+      return try await database.equipment.fetch(projectID)
+    case .get(let id):
+      guard let room = try await database.equipment.get(id) else {
+        logger.error("Equipment not found for id: \(id)")
+        throw ApiError("Equipment not found.")
+      }
+      return room
+    }
+  }
+}
+
+extension SiteRoute.Api.ComponentLossRoute {
+
+  func respond(logger: Logger) async throws -> (any Encodable)? {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .create(let request):
+      return try await database.componentLoss.create(request)
+    case .delete(let id):
+      try await database.componentLoss.delete(id)
+      return nil
+    case .fetch(let projectID):
+      return try await database.componentLoss.fetch(projectID)
+    case .get(let id):
+      guard let room = try await database.componentLoss.get(id) else {
+        logger.error("Component loss not found for id: \(id)")
+        throw ApiError("Component loss not found.")
+      }
+      return room
+    }
+  }
+}
+
+public struct ApiError: Error {
+  let message: String
+
+  init(_ message: String) {
+    self.message = message
+  }
+}

Sources/App/BrowserSync.swift

@@ -0,0 +1,17 @@
+import Foundation
+import Vapor
+
+#if DEBUG
+  struct BrowserSyncHandler: LifecycleHandler {
+    func didBoot(_ application: Application) throws {
+      let process = Process()
+      process.executableURL = URL(filePath: "/bin/sh")
+      process.arguments = ["-c", "browser-sync reload"]
+      do {
+        try process.run()
+      } catch {
+        print("Could not auto-reload: \(error)")
+      }
+    }
+  }
+#endif

Sources/App/Extensions/ApiController+respond.swift

@@ -0,0 +1,37 @@
+import ApiController
+import ManualDCore
+import Vapor
+
+extension ApiController {
+
+  func respond(_ route: SiteRoute.Api, request: Vapor.Request) async throws
+    -> any AsyncResponseEncodable
+  {
+    guard let encodable = try await json(.init(route: route, logger: request.logger)) else {
+      return HTTPStatus.ok
+    }
+    return AnyJSONResponse(value: encodable)
+  }
+}
+
+struct AnyJSONResponse: AsyncResponseEncodable {
+  public var headers: HTTPHeaders = ["Content-Type": "application/json"]
+  let value: any Encodable
+
+  init(additionalHeaders: HTTPHeaders = [:], value: any Encodable) {
+    if additionalHeaders.contains(name: .contentType) {
+      self.headers = additionalHeaders
+    } else {
+      headers.add(contentsOf: additionalHeaders)
+    }
+    self.value = value
+  }
+
+  func encodeResponse(for request: Request) async throws -> Response {
+    try Response(
+      status: .ok,
+      headers: headers,
+      body: .init(data: JSONEncoder().encode(value))
+    )
+  }
+}

Sources/App/Extensions/Request+extensions.swift

@@ -0,0 +1,7 @@
+import Vapor
+
+extension Request {
+  var isHtmxRequest: Bool {
+    headers.contains(name: "hx-request")
+  }
+}

Sources/App/Extensions/ViewController+respond.swift

@@ -0,0 +1,60 @@
+import Elementary
+import ManualDCore
+import Vapor
+import VaporElementary
+import ViewController
+
+extension ViewController {
+  func respond(route: SiteRoute.View, request: Vapor.Request) async throws
+    -> any AsyncResponseEncodable
+  {
+    let html = try await view(
+      .init(
+        route: route,
+        isHtmxRequest: request.isHtmxRequest,
+        logger: request.logger,
+        authenticateUser: { request.session.authenticate($0) },
+        currentUser: {
+          try request.auth.require(User.self)
+        }
+      )
+    )
+    return AnyHTMLResponse(value: html)
+  }
+}
+
+// Re-adapted from `HTMLResponse` in the VaporElementary package to work with any html types
+// returned from the view controller.
+struct AnyHTMLResponse: AsyncResponseEncodable {
+
+  public var chunkSize: Int
+  public var headers: HTTPHeaders = ["Content-Type": "text/html; charset=utf-8"]
+  var value: _SendableAnyHTMLBox
+
+  init(chunkSize: Int = 1024, additionalHeaders: HTTPHeaders = [:], value: AnySendableHTML) {
+    self.chunkSize = chunkSize
+    if additionalHeaders.contains(name: .contentType) {
+      self.headers = additionalHeaders
+    } else {
+      headers.add(contentsOf: additionalHeaders)
+    }
+    self.value = .init(value)
+  }
+
+  func encodeResponse(for request: Request) async throws -> Response {
+    Response(
+      status: .ok,
+      headers: headers,
+      body: .init(asyncStream: { [value, chunkSize] writer in
+        guard let html = value.tryTake() else {
+          assertionFailure("Non-sendable HTML value consumed more than once")
+          request.logger.error("Non-sendable HTML value consumed more than once")
+          throw Abort(.internalServerError)
+        }
+        try await writer.writeHTML(html, chunkSize: chunkSize)
+        try await writer.write(.end)
+
+      })
+    )
+  }
+}

Sources/App/Middleware/DependenciesMiddleware.swift

@@ -0,0 +1,41 @@
+import ApiController
+import DatabaseClient
+import Dependencies
+import Vapor
+import ViewController
+
+// Taken from discussions page on `swift-dependencies`.
+
+// FIX: Use live view controller.
+struct DependenciesMiddleware: AsyncMiddleware {
+
+  private let values: DependencyValues.Continuation
+  private let apiController: ApiController
+  private let database: DatabaseClient
+  private let viewController: ViewController
+
+  init(
+    database: DatabaseClient,
+    apiController: ApiController = .liveValue,
+    viewController: ViewController = .liveValue
+  ) {
+    self.values = withEscapedDependencies { $0 }
+    self.apiController = apiController
+    self.database = database
+    self.viewController = viewController
+  }
+
+  func respond(to request: Request, chainingTo next: any AsyncResponder) async throws -> Response {
+    try await values.yield {
+      try await withDependencies {
+        $0.apiController = apiController
+        $0.database = database
+        // $0.dateFormatter = .liveValue
+        $0.viewController = viewController
+      } operation: {
+        try await next.respond(to: request)
+      }
+    }
+  }
+
+}

Sources/App/Middleware/URLRoutingMiddleware.swift

@@ -0,0 +1,100 @@
+import URLRouting
+import Vapor
+import VaporRouting
+
+// Taken from github.com/nevillco/vapor-routing
+
+extension Application {
+  /// Mounts a router to the Vapor application.
+  ///
+  /// See ``VaporRouting`` for more information on usage.
+  ///
+  /// - Parameters:
+  ///   - router: A parser-printer that works on inputs of `URLRequestData`.
+  ///   - middleware: A closure for providing any per-route migrations to be run before processing the request.
+  ///   - closure: A closure that takes a `Request` and the router's output as arguments.
+  public func mount<R: Parser>(
+    _ router: R,
+    middleware: @escaping @Sendable (R.Output) -> [any Middleware]? = { _ in nil },
+    use closure: @escaping @Sendable (Request, R.Output) async throws -> any AsyncResponseEncodable
+  ) where R.Input == URLRequestData, R: Sendable, R.Output: Sendable {
+    self.middleware.use(
+      AsyncRoutingMiddleware(router: router, middleware: middleware, respond: closure))
+  }
+}
+
+/// Serves requests using a router and response handler.
+///
+/// You will not typically need to interact with this type directly. Instead you should use the
+/// `mount` method on your Vapor application.
+///
+/// See ``VaporRouting`` for more information on usage.
+public struct AsyncRoutingMiddleware<Router: Parser>: AsyncMiddleware
+where
+  Router.Input == URLRequestData,
+  Router: Sendable,
+  Router.Output: Sendable
+{
+  let router: Router
+  let middleware: @Sendable (Router.Output) -> [any Middleware]?
+  let respond: @Sendable (Request, Router.Output) async throws -> any AsyncResponseEncodable
+
+  public func respond(
+    to request: Request,
+    chainingTo next: any AsyncResponder
+  ) async throws -> Response {
+    if request.body.data == nil {
+      try await _ = request.body.collect(max: request.application.routes.defaultMaxBodySize.value)
+        .get()
+    }
+
+    guard let requestData = URLRequestData(request: request)
+    else { return try await next.respond(to: request) }
+
+    let route: Router.Output
+    do {
+      route = try router.parse(requestData)
+    } catch let routingError {
+      do {
+        return try await next.respond(to: request)
+      } catch {
+        request.logger.info("\(routingError)")
+
+        guard request.application.environment == .development
+        else { throw error }
+
+        return Response(status: .notFound, body: .init(string: "Routing \(routingError)"))
+      }
+    }
+
+    if let middleware = middleware(route) {
+      return try await middleware.makeResponder(
+        chainingTo: AsyncBasicResponder { request in
+          try await self.respond(request, route).encodeResponse(for: request)
+        }
+      ).respond(to: request).get()
+
+      // return try await middleware.respond(
+      //   to: request,
+      //   chainingTo: AsyncBasicResponder { request in
+      //     try await self.respond(request, route).encodeResponse(for: request)
+      //   }
+      // ).get()
+    } else {
+      return try await respond(request, route).encodeResponse(for: request)
+    }
+  }
+}
+
+// Usage:
+// app.mount(
+//   router,
+//   middleware: { route in
+//     case .onboarding: return nil
+//     case .signIn: return BasicAuthMiddleware()
+//     default: return BearerAuthMiddleware()
+//   },
+//   use: { request, route in
+//     // route handline
+//   }
+// )

Sources/App/Middleware/ViewRoute+middleware.swift

@@ -0,0 +1,23 @@
+import DatabaseClient
+import Fluent
+import ManualDCore
+import Vapor
+
+private let viewRouteMiddleware: [any Middleware] = [
+  UserPasswordAuthenticator(),
+  UserSessionAuthenticator(),
+  User.redirectMiddleware { req in
+    "/login?next=\(req.url.string)"
+  },
+]
+
+extension SiteRoute.View {
+  var middleware: [any Middleware]? {
+    switch self {
+    case .project, .user:
+      return viewRouteMiddleware
+    case .login, .signup, .test:
+      return nil
+    }
+  }
+}

Sources/App/configure.swift

@@ -0,0 +1,130 @@
+import DatabaseClient
+import Dependencies
+import Elementary
+import Fluent
+import FluentSQLiteDriver
+import ManualDCore
+import NIOSSL
+import Vapor
+import VaporElementary
+@preconcurrency import VaporRouting
+import ViewController
+
+// configures your application
+public func configure(
+  _ app: Application,
+  makeDatabaseClient: @escaping (any Database) -> DatabaseClient = { .live(database: $0) }
+) async throws {
+  // Setup the database client.
+  let databaseClient = try await setupDatabase(on: app, factory: makeDatabaseClient)
+  // Add the global middlewares.
+  addMiddleware(to: app, database: databaseClient)
+  #if DEBUG
+    // Live reload of the application for development when launched with the `./swift-dev` command
+    // app.lifecycle.use(BrowserSyncHandler())
+  #endif
+  // Add our route handlers.
+  addRoutes(to: app)
+  if app.environment != .testing {
+    try await app.autoMigrate()
+  }
+  // Add our custom cli-commands to the application.
+  addCommands(to: app)
+}
+
+private func addMiddleware(to app: Application, database databaseClient: DatabaseClient) {
+  // cors middleware should come before default error middleware using `at: .beginning`
+  let corsConfiguration = CORSMiddleware.Configuration(
+    allowedOrigin: .all,
+    allowedMethods: [.GET, .POST, .PUT, .OPTIONS, .DELETE, .PATCH],
+    allowedHeaders: [
+      .accept, .authorization, .contentType, .origin,
+      .xRequestedWith, .userAgent, .accessControlAllowOrigin,
+    ]
+  )
+  let cors = CORSMiddleware(configuration: corsConfiguration)
+  app.middleware.use(cors, at: .beginning)
+
+  app.middleware.use(FileMiddleware(publicDirectory: app.directory.publicDirectory))
+  app.middleware.use(app.sessions.middleware)
+  app.middleware.use(DependenciesMiddleware(database: databaseClient))
+}
+
+private func setupDatabase(
+  on app: Application,
+  factory makeDatabaseClient: @escaping (any Database) -> DatabaseClient
+) async throws -> DatabaseClient {
+  switch app.environment {
+  case .production, .development:
+    let dbFileName = Environment.get("SQLITE_FILENAME") ?? "db.sqlite"
+    app.databases.use(DatabaseConfigurationFactory.sqlite(.file(dbFileName)), as: .sqlite)
+  default:
+    app.databases.use(DatabaseConfigurationFactory.sqlite(.memory), as: .sqlite)
+  }
+
+  let databaseClient = makeDatabaseClient(app.db)
+
+  if app.environment != .testing {
+    try await app.migrations.add(databaseClient.migrations.run())
+  }
+
+  return databaseClient
+}
+
+private func addRoutes(to app: Application) {
+  // Redirect the index path to project route.
+  app.get { req in
+    req.redirect(to: SiteRoute.View.router.path(for: .project(.index)))
+  }
+
+  app.mount(
+    SiteRoute.router,
+    middleware: {
+      if app.environment == .testing {
+        return nil
+      } else {
+        return $0.middleware()
+      }
+    },
+    use: siteHandler
+  )
+}
+
+private func addCommands(to app: Application) {
+  // #if DEBUG
+  //   app.asyncCommands.use(SeedCommand(), as: "seed")
+  // #endif
+  // app.asyncCommands.use(GenerateAdminUserCommand(), as: "generate-admin")
+}
+
+extension SiteRoute {
+
+  fileprivate func middleware() -> [any Middleware]? {
+    switch self {
+    case .api:
+      return nil
+    case .health:
+      return nil
+    case .view(let route):
+      return route.middleware
+    }
+  }
+}
+
+@Sendable
+private func siteHandler(
+  request: Request,
+  route: SiteRoute
+) async throws -> any AsyncResponseEncodable {
+  @Dependency(\.apiController) var apiController
+  @Dependency(\.viewController) var viewController
+
+  switch route {
+  case .api(let route):
+    return try await apiController.respond(route, request: request)
+  case .health:
+    return HTTPStatus.ok
+  case .view(let route):
+    return try await viewController.respond(route: route, request: request)
+  }
+}

Sources/App/entrypoint.swift

@@ -0,0 +1,34 @@
+import DatabaseClient
+import Dependencies
+import Logging
+import NIOCore
+import NIOPosix
+import Vapor
+
+@main
+enum Entrypoint {
+  static func main() async throws {
+    var env = try Environment.detect()
+    try LoggingSystem.bootstrap(from: &env)
+
+    let app = try await Application.make(env)
+
+    // This attempts to install NIO as the Swift Concurrency global executor.
+    // You can enable it if you'd like to reduce the amount of context switching between NIO and Swift Concurrency.
+    // Note: this has caused issues with some libraries that use `.wait()` and cleanly shutting down.
+    // If enabled, you should be careful about calling async functions before this point as it can cause assertion failures.
+    // let executorTakeoverSuccess = NIOSingletons.unsafeTryInstallSingletonPosixEventLoopGroupAsConcurrencyGlobalExecutor()
+    // app.logger.debug("Tried to install SwiftNIO's EventLoopGroup as Swift's global concurrency executor", metadata: ["success": .stringConvertible(executorTakeoverSuccess)])
+
+    do {
+      try await configure(app)
+    } catch {
+      app.logger.report(error: error)
+      try? await app.asyncShutdown()
+      throw error
+    }
+
+    try await app.execute()
+    try await app.asyncShutdown()
+  }
+}

Sources/DatabaseClient/ComponentPressureLoss.swift

@@ -0,0 +1,186 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Foundation
+import ManualDCore
+
+extension DatabaseClient {
+  @DependencyClient
+  public struct ComponentLoss: Sendable {
+    public var create:
+      @Sendable (ComponentPressureLoss.Create) async throws -> ComponentPressureLoss
+    public var delete: @Sendable (ComponentPressureLoss.ID) async throws -> Void
+    public var fetch: @Sendable (Project.ID) async throws -> [ComponentPressureLoss]
+    public var get: @Sendable (ComponentPressureLoss.ID) async throws -> ComponentPressureLoss?
+    public var update:
+      @Sendable (ComponentPressureLoss.ID, ComponentPressureLoss.Update) async throws ->
+        ComponentPressureLoss
+  }
+}
+
+extension DatabaseClient.ComponentLoss: TestDependencyKey {
+  public static let testValue = Self()
+}
+
+extension DatabaseClient.ComponentLoss {
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { request in
+        let model = try request.toModel()
+        try await model.save(on: database)
+        return try model.toDTO()
+      },
+      delete: { id in
+        guard let model = try await ComponentLossModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try await model.delete(on: database)
+      },
+      fetch: { projectID in
+        try await ComponentLossModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id, .equal, projectID)
+          .all()
+          .map { try $0.toDTO() }
+
+      },
+      get: { id in
+        try await ComponentLossModel.find(id, on: database).map { try $0.toDTO() }
+      },
+      update: { id, updates in
+        try updates.validate()
+        guard let model = try await ComponentLossModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        model.applyUpdates(updates)
+        if model.hasChanges {
+          try await model.save(on: database)
+        }
+        return try model.toDTO()
+      }
+    )
+  }
+}
+
+extension ComponentPressureLoss.Create {
+
+  func toModel() throws(ValidationError) -> ComponentLossModel {
+    try validate()
+    return .init(name: name, value: value, projectID: projectID)
+  }
+
+  func validate() throws(ValidationError) {
+    guard !name.isEmpty else {
+      throw ValidationError("Component loss name should not be empty.")
+    }
+    guard value > 0 else {
+      throw ValidationError("Component loss value should be greater than 0.")
+    }
+    guard value < 1.0 else {
+      throw ValidationError("Component loss value should be less than 1.0.")
+    }
+  }
+}
+
+extension ComponentPressureLoss.Update {
+  func validate() throws(ValidationError) {
+    if let name {
+      guard !name.isEmpty else {
+        throw ValidationError("Component loss name should not be empty.")
+      }
+    }
+    if let value {
+      guard value > 0 else {
+        throw ValidationError("Component loss value should be greater than 0.")
+      }
+      guard value < 1.0 else {
+        throw ValidationError("Component loss value should be less than 1.0.")
+      }
+    }
+  }
+}
+
+extension ComponentPressureLoss {
+  struct Migrate: AsyncMigration {
+    let name = "CreateComponentLoss"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(ComponentLossModel.schema)
+        .id()
+        .field("name", .string, .required)
+        .field("value", .double, .required)
+        .field("createdAt", .datetime)
+        .field("updatedAt", .datetime)
+        .field(
+          "projectID", .uuid, .required, .references(ProjectModel.schema, "id", onDelete: .cascade)
+        )
+        // .unique(on: "projectID", "name")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(ComponentLossModel.schema).delete()
+    }
+  }
+}
+
+final class ComponentLossModel: Model, @unchecked Sendable {
+
+  static let schema = "component_loss"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "name")
+  var name: String
+
+  @Field(key: "value")
+  var value: Double
+
+  @Timestamp(key: "createdAt", on: .create, format: .iso8601)
+  var createdAt: Date?
+
+  @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
+  var updatedAt: Date?
+
+  @Parent(key: "projectID")
+  var project: ProjectModel
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    name: String,
+    value: Double,
+    createdAt: Date? = nil,
+    updatedAt: Date? = nil,
+    projectID: Project.ID
+  ) {
+    self.id = id
+    self.name = name
+    self.value = value
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+    $project.id = projectID
+  }
+
+  func toDTO() throws -> ComponentPressureLoss {
+    try .init(
+      id: requireID(),
+      projectID: $project.id,
+      name: name,
+      value: value,
+      createdAt: createdAt!,
+      updatedAt: updatedAt!
+    )
+  }
+
+  func applyUpdates(_ updates: ComponentPressureLoss.Update) {
+    if let name = updates.name, name != self.name {
+      self.name = name
+    }
+    if let value = updates.value, value != self.value {
+      self.value = value
+    }
+  }
+}

Sources/DatabaseClient/EffectiveLength.swift

@@ -0,0 +1,203 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Foundation
+import ManualDCore
+
+extension DatabaseClient {
+  @DependencyClient
+  public struct EffectiveLengthClient: Sendable {
+    public var create: @Sendable (EffectiveLength.Create) async throws -> EffectiveLength
+    public var delete: @Sendable (EffectiveLength.ID) async throws -> Void
+    public var fetch: @Sendable (Project.ID) async throws -> [EffectiveLength]
+    public var fetchMax: @Sendable (Project.ID) async throws -> EffectiveLength.MaxContainer
+    public var get: @Sendable (EffectiveLength.ID) async throws -> EffectiveLength?
+    public var update:
+      @Sendable (EffectiveLength.ID, EffectiveLength.Update) async throws -> EffectiveLength
+  }
+}
+
+extension DatabaseClient.EffectiveLengthClient: TestDependencyKey {
+  public static let testValue = Self()
+
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { request in
+        let model = try request.toModel()
+        try await model.save(on: database)
+        return try model.toDTO()
+      },
+      delete: { id in
+        guard let model = try await EffectiveLengthModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try await model.delete(on: database)
+      },
+      fetch: { projectID in
+        try await EffectiveLengthModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id, .equal, projectID)
+          .all()
+          .map { try $0.toDTO() }
+      },
+      fetchMax: { projectID in
+        let effectiveLengths = try await EffectiveLengthModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id, .equal, projectID)
+          .all()
+          .map { try $0.toDTO() }
+
+        return .init(
+          supply: effectiveLengths.filter({ $0.type == .supply })
+            .sorted(by: { $0.totalEquivalentLength > $1.totalEquivalentLength })
+            .first,
+          return: effectiveLengths.filter({ $0.type == .return })
+            .sorted(by: { $0.totalEquivalentLength > $1.totalEquivalentLength })
+            .first
+        )
+
+      },
+      get: { id in
+        try await EffectiveLengthModel.find(id, on: database).map { try $0.toDTO() }
+      },
+      update: { id, updates in
+        guard let model = try await EffectiveLengthModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try model.applyUpdates(updates)
+        if model.hasChanges {
+          try await model.save(on: database)
+        }
+        return try model.toDTO()
+      }
+    )
+  }
+}
+
+extension EffectiveLength.Create {
+
+  func toModel() throws -> EffectiveLengthModel {
+    try validate()
+    return try .init(
+      name: name,
+      type: type.rawValue,
+      straightLengths: straightLengths,
+      groups: JSONEncoder().encode(groups),
+      projectID: projectID
+    )
+  }
+
+  func validate() throws(ValidationError) {
+    guard !name.isEmpty else {
+      throw ValidationError("Effective length name can not be empty.")
+    }
+  }
+}
+
+extension EffectiveLength {
+
+  struct Migrate: AsyncMigration {
+    let name = "CreateEffectiveLength"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(EffectiveLengthModel.schema)
+        .id()
+        .field("name", .string, .required)
+        .field("type", .string, .required)
+        .field("straightLengths", .array(of: .int))
+        .field("groups", .data)
+        .field("createdAt", .datetime)
+        .field("updatedAt", .datetime)
+        .field(
+          "projectID", .uuid, .required, .references(ProjectModel.schema, "id", onDelete: .cascade)
+        )
+        .unique(on: "projectID", "name", "type")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(EffectiveLengthModel.schema).delete()
+    }
+  }
+}
+
+// TODO: Add total effective length field so that we can lookup / compare which one is
+//       the longest for a given project.
+final class EffectiveLengthModel: Model, @unchecked Sendable {
+
+  static let schema = "effective_length"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "name")
+  var name: String
+
+  @Field(key: "type")
+  var type: String
+
+  @Field(key: "straightLengths")
+  var straightLengths: [Int]
+
+  @Field(key: "groups")
+  var groups: Data
+
+  @Timestamp(key: "createdAt", on: .create, format: .iso8601)
+  var createdAt: Date?
+
+  @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
+  var updatedAt: Date?
+
+  @Parent(key: "projectID")
+  var project: ProjectModel
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    name: String,
+    type: String,
+    straightLengths: [Int],
+    groups: Data,
+    createdAt: Date? = nil,
+    updatedAt: Date? = nil,
+    projectID: Project.ID
+  ) {
+    self.id = id
+    self.name = name
+    self.type = type
+    self.straightLengths = straightLengths
+    self.groups = groups
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+    $project.id = projectID
+  }
+
+  func toDTO() throws -> EffectiveLength {
+    try .init(
+      id: requireID(),
+      projectID: $project.id,
+      name: name,
+      type: .init(rawValue: type)!,
+      straightLengths: straightLengths,
+      groups: JSONDecoder().decode([EffectiveLength.Group].self, from: groups),
+      createdAt: createdAt!,
+      updatedAt: updatedAt!
+    )
+  }
+
+  func applyUpdates(_ updates: EffectiveLength.Update) throws {
+    if let name = updates.name, name != self.name {
+      self.name = name
+    }
+    if let type = updates.type, type.rawValue != self.type {
+      self.type = type.rawValue
+    }
+    if let straightLengths = updates.straightLengths, straightLengths != self.straightLengths {
+      self.straightLengths = straightLengths
+    }
+    if let groups = updates.groups {
+      self.groups = try JSONEncoder().encode(groups)
+    }
+  }
+}

Sources/DatabaseClient/Equipment.swift

@@ -0,0 +1,213 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Foundation
+import ManualDCore
+
+extension DatabaseClient {
+  @DependencyClient
+  public struct Equipment: Sendable {
+    public var create: @Sendable (EquipmentInfo.Create) async throws -> EquipmentInfo
+    public var delete: @Sendable (EquipmentInfo.ID) async throws -> Void
+    public var fetch: @Sendable (Project.ID) async throws -> EquipmentInfo?
+    public var get: @Sendable (EquipmentInfo.ID) async throws -> EquipmentInfo?
+    public var update:
+      @Sendable (EquipmentInfo.ID, EquipmentInfo.Update) async throws -> EquipmentInfo
+  }
+}
+
+extension DatabaseClient.Equipment: TestDependencyKey {
+  public static let testValue = Self()
+}
+
+extension DatabaseClient.Equipment {
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { request in
+        let model = try request.toModel()
+        try await model.save(on: database)
+        return try model.toDTO()
+      },
+      delete: { id in
+        guard let model = try await EquipmentModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try await model.delete(on: database)
+      },
+      fetch: { projectId in
+        guard
+          let model = try await EquipmentModel.query(on: database)
+            .filter("projectID", .equal, projectId)
+            .first()
+        else {
+          return nil
+        }
+        return try model.toDTO()
+      },
+      get: { id in
+        try await EquipmentModel.find(id, on: database).map { try $0.toDTO() }
+      },
+      update: { id, updates in
+        guard let model = try await EquipmentModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try updates.validate()
+        model.applyUpdates(updates)
+        if model.hasChanges {
+          try await model.save(on: database)
+        }
+        return try model.toDTO()
+      }
+    )
+  }
+}
+
+extension EquipmentInfo.Create {
+
+  func toModel() throws(ValidationError) -> EquipmentModel {
+    try validate()
+    return .init(
+      staticPressure: staticPressure,
+      heatingCFM: heatingCFM,
+      coolingCFM: coolingCFM,
+      projectID: projectID
+    )
+  }
+
+  func validate() throws(ValidationError) {
+    guard staticPressure >= 0 else {
+      throw ValidationError("Equipment info static pressure should be greater than 0.")
+    }
+    guard staticPressure <= 1.0 else {
+      throw ValidationError("Equipment info static pressure should be less than 1.0.")
+    }
+    guard heatingCFM >= 0 else {
+      throw ValidationError("Equipment info heating CFM should be greater than 0.")
+    }
+    guard coolingCFM >= 0 else {
+      throw ValidationError("Equipment info heating CFM should be greater than 0.")
+    }
+  }
+}
+
+extension EquipmentInfo.Update {
+  var hasUpdates: Bool {
+    staticPressure != nil || heatingCFM != nil || coolingCFM != nil
+  }
+
+  func validate() throws(ValidationError) {
+    if let staticPressure {
+      guard staticPressure >= 0 else {
+        throw ValidationError("Equipment info static pressure should be greater than 0.")
+      }
+    }
+    if let heatingCFM {
+      guard heatingCFM >= 0 else {
+        throw ValidationError("Equipment info heating CFM should be greater than 0.")
+      }
+    }
+    if let coolingCFM {
+      guard coolingCFM >= 0 else {
+        throw ValidationError("Equipment info heating CFM should be greater than 0.")
+      }
+    }
+  }
+}
+
+extension EquipmentInfo {
+
+  struct Migrate: AsyncMigration {
+
+    let name = "CreateEquipment"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(EquipmentModel.schema)
+        .id()
+        .field("staticPressure", .double, .required)
+        .field("heatingCFM", .int16, .required)
+        .field("coolingCFM", .int16, .required)
+        .field("createdAt", .datetime)
+        .field("updatedAt", .datetime)
+        .field(
+          "projectID", .uuid, .required, .references(ProjectModel.schema, "id", onDelete: .cascade)
+        )
+        .unique(on: "projectID")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(EquipmentModel.schema).delete()
+    }
+
+  }
+}
+
+final class EquipmentModel: Model, @unchecked Sendable {
+
+  static let schema = "equipment"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "staticPressure")
+  var staticPressure: Double
+
+  @Field(key: "heatingCFM")
+  var heatingCFM: Int
+
+  @Field(key: "coolingCFM")
+  var coolingCFM: Int
+
+  @Timestamp(key: "createdAt", on: .create, format: .iso8601)
+  var createdAt: Date?
+
+  @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
+  var updatedAt: Date?
+
+  @Parent(key: "projectID")
+  var project: ProjectModel
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    staticPressure: Double,
+    heatingCFM: Int,
+    coolingCFM: Int,
+    createdAt: Date? = nil,
+    updatedAt: Date? = nil,
+    projectID: Project.ID
+  ) {
+    self.id = id
+    self.staticPressure = staticPressure
+    self.heatingCFM = heatingCFM
+    self.coolingCFM = coolingCFM
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+    $project.id = projectID
+  }
+
+  func toDTO() throws -> EquipmentInfo {
+    try .init(
+      id: requireID(),
+      projectID: $project.id,
+      staticPressure: staticPressure,
+      heatingCFM: heatingCFM,
+      coolingCFM: coolingCFM,
+      createdAt: createdAt!,
+      updatedAt: updatedAt!
+    )
+  }
+
+  func applyUpdates(_ updates: EquipmentInfo.Update) {
+    if let staticPressure = updates.staticPressure {
+      self.staticPressure = staticPressure
+    }
+    if let heatingCFM = updates.heatingCFM {
+      self.heatingCFM = heatingCFM
+    }
+    if let coolingCFM = updates.coolingCFM {
+      self.coolingCFM = coolingCFM
+    }
+  }
+}

Sources/DatabaseClient/Errors.swift

@@ -1,5 +1,6 @@
 import Foundation
 
+// TODO: Move to ManualDCore
 public struct ValidationError: Error {
   public let message: String
 
@@ -8,4 +9,6 @@ public struct ValidationError: Error {
   }
 }
 
-public struct NotFoundError: Error {}
+public struct NotFoundError: Error {
+  public init() {}
+}

Sources/DatabaseClient/Interface.swift

@@ -14,6 +14,41 @@ extension DependencyValues {
 public struct DatabaseClient: Sendable {
   public var migrations: Migrations
   public var projects: Projects
+  public var rooms: Rooms
+  public var equipment: Equipment
+  public var componentLoss: ComponentLoss
+  public var effectiveLength: EffectiveLengthClient
+  public var users: Users
+  public var userProfile: UserProfile
+  public var trunkSizes: TrunkSizes
+}
+
+extension DatabaseClient: TestDependencyKey {
+  public static let testValue: DatabaseClient = Self(
+    migrations: .testValue,
+    projects: .testValue,
+    rooms: .testValue,
+    equipment: .testValue,
+    componentLoss: .testValue,
+    effectiveLength: .testValue,
+    users: .testValue,
+    userProfile: .testValue,
+    trunkSizes: .testValue
+  )
+
+  public static func live(database: any Database) -> Self {
+    .init(
+      migrations: .liveValue,
+      projects: .live(database: database),
+      rooms: .live(database: database),
+      equipment: .live(database: database),
+      componentLoss: .live(database: database),
+      effectiveLength: .live(database: database),
+      users: .live(database: database),
+      userProfile: .live(database: database),
+      trunkSizes: .live(database: database)
+    )
+  }
 }
 
 extension DatabaseClient {
@@ -23,13 +58,24 @@ extension DatabaseClient {
   }
 }
 
-extension DatabaseClient: TestDependencyKey {
-  public static let testValue: DatabaseClient = Self(
-    migrations: .testValue,
-    projects: .testValue
-  )
-}
-
 extension DatabaseClient.Migrations: TestDependencyKey {
   public static let testValue = Self()
 }
+
+extension DatabaseClient.Migrations: DependencyKey {
+  public static let liveValue = Self(
+    run: {
+      [
+        Project.Migrate(),
+        User.Migrate(),
+        User.Token.Migrate(),
+        User.Profile.Migrate(),
+        ComponentPressureLoss.Migrate(),
+        EquipmentInfo.Migrate(),
+        Room.Migrate(),
+        EffectiveLength.Migrate(),
+        DuctSizing.TrunkSize.Migrate(),
+      ]
+    }
+  )
+}

Sources/DatabaseClient/Projects.swift

@@ -7,32 +7,95 @@ import ManualDCore
 extension DatabaseClient {
   @DependencyClient
   public struct Projects: Sendable {
-    public var create: @Sendable (Project.Create) async throws -> Project
+    public var create: @Sendable (User.ID, Project.Create) async throws -> Project
     public var delete: @Sendable (Project.ID) async throws -> Void
     public var get: @Sendable (Project.ID) async throws -> Project?
+    public var getCompletedSteps: @Sendable (Project.ID) async throws -> Project.CompletedSteps
+    public var getSensibleHeatRatio: @Sendable (Project.ID) async throws -> Double?
+    public var fetch: @Sendable (User.ID, PageRequest) async throws -> Page<Project>
+    public var update: @Sendable (Project.ID, Project.Update) async throws -> Project
   }
 }
 
 extension DatabaseClient.Projects: TestDependencyKey {
   public static let testValue = Self()
-}
 
-extension DatabaseClient.Projects {
   public static func live(database: any Database) -> Self {
     .init(
-      create: { request in
-        let model = try request.toModel()
+      create: { userID, request in
+        let model = try request.toModel(userID: userID)
         try await model.save(on: database)
         return try model.toDTO()
       },
       delete: { id in
-        guard let model = ProjectModel.find(id, on: database) else {
+        guard let model = try await ProjectModel.find(id, on: database) else {
           throw NotFoundError()
         }
         try await model.delete(on: database)
       },
       get: { id in
-        ProjectModel.find(id, on: database).map { try $0.toDTO() }
+        try await ProjectModel.find(id, on: database).map { try $0.toDTO() }
+      },
+      getCompletedSteps: { id in
+        let roomsCount = try await RoomModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id == id)
+          .count()
+
+        let equivalentLengths = try await EffectiveLengthModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id == id)
+          .all()
+
+        var equivalentLengthsCompleted = false
+
+        if equivalentLengths.filter({ $0.type == "supply" }).first != nil,
+          equivalentLengths.filter({ $0.type == "return" }).first != nil
+        {
+          equivalentLengthsCompleted = true
+        }
+
+        let componentLosses = try await ComponentLossModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id == id)
+          .count()
+
+        let equipmentInfo = try await EquipmentModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id == id)
+          .first()
+
+        return .init(
+          equipmentInfo: equipmentInfo != nil,
+          rooms: roomsCount > 0,
+          equivalentLength: equivalentLengthsCompleted,
+          frictionRate: componentLosses > 0
+        )
+      },
+      getSensibleHeatRatio: { id in
+        guard let model = try await ProjectModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        return model.sensibleHeatRatio
+      },
+      fetch: { userID, request in
+        try await ProjectModel.query(on: database)
+          .sort(\.$createdAt, .descending)
+          .with(\.$user)
+          .filter(\.$user.$id == userID)
+          .paginate(request)
+          .map { try $0.toDTO() }
+      },
+      update: { id, updates in
+        guard let model = try await ProjectModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try updates.validate()
+        model.applyUpdates(updates)
+        if model.hasChanges {
+          try await model.save(on: database)
+        }
+        return try model.toDTO()
       }
     )
   }
@@ -40,14 +103,15 @@ extension DatabaseClient.Projects {
 
 extension Project.Create {
 
-  func toModel() throws -> ProjectModel {
+  func toModel(userID: User.ID) throws -> ProjectModel {
     try validate()
     return .init(
       name: name,
       streetAddress: streetAddress,
       city: city,
       state: state,
-      zipCode: zipCode
+      zipCode: zipCode,
+      userID: userID
     )
   }
 
@@ -67,6 +131,53 @@ extension Project.Create {
     guard !zipCode.isEmpty else {
       throw ValidationError("Project zipCode should not be empty.")
     }
+    if let sensibleHeatRatio {
+      guard sensibleHeatRatio >= 0 else {
+        throw ValidationError("Project sensible heat ratio should be greater than 0.")
+      }
+      guard sensibleHeatRatio <= 1 else {
+        throw ValidationError("Project sensible heat ratio should be less than 1.")
+      }
+    }
+  }
+}
+
+extension Project.Update {
+
+  func validate() throws(ValidationError) {
+    if let name {
+      guard !name.isEmpty else {
+        throw ValidationError("Project name should not be empty.")
+      }
+    }
+    if let streetAddress {
+      guard !streetAddress.isEmpty else {
+        throw ValidationError("Project street address should not be empty.")
+      }
+    }
+    if let city {
+      guard !city.isEmpty else {
+        throw ValidationError("Project city should not be empty.")
+      }
+    }
+    if let state {
+      guard !state.isEmpty else {
+        throw ValidationError("Project state should not be empty.")
+      }
+    }
+    if let zipCode {
+      guard !zipCode.isEmpty else {
+        throw ValidationError("Project zipCode should not be empty.")
+      }
+    }
+    if let sensibleHeatRatio {
+      guard sensibleHeatRatio >= 0 else {
+        throw ValidationError("Project sensible heat ratio should be greater than 0.")
+      }
+      guard sensibleHeatRatio <= 1 else {
+        throw ValidationError("Project sensible heat ratio should be less than 1.")
+      }
+    }
   }
 }
 
@@ -82,9 +193,11 @@ extension Project {
         .field("city", .string, .required)
         .field("state", .string, .required)
         .field("zipCode", .string, .required)
+        .field("sensibleHeatRatio", .double)
         .field("createdAt", .datetime)
         .field("updatedAt", .datetime)
-        .unique(on: "name")
+        .field("userID", .uuid, .required, .references(UserModel.schema, "id"))
+        .unique(on: "userID", "name")
         .create()
     }
 
@@ -117,12 +230,21 @@ final class ProjectModel: Model, @unchecked Sendable {
   @Field(key: "zipCode")
   var zipCode: String
 
+  @Field(key: "sensibleHeatRatio")
+  var sensibleHeatRatio: Double?
+
   @Timestamp(key: "createdAt", on: .create, format: .iso8601)
   var createdAt: Date?
 
   @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
   var updatedAt: Date?
 
+  @Children(for: \.$project)
+  var componentLosses: [ComponentLossModel]
+
+  @Parent(key: "userID")
+  var user: UserModel
+
   init() {}
 
   init(
@@ -132,6 +254,8 @@ final class ProjectModel: Model, @unchecked Sendable {
     city: String,
     state: String,
     zipCode: String,
+    sensibleHeatRatio: Double? = nil,
+    userID: User.ID,
     createdAt: Date? = nil,
     updatedAt: Date? = nil
   ) {
@@ -139,9 +263,10 @@ final class ProjectModel: Model, @unchecked Sendable {
     self.name = name
     self.streetAddress = streetAddress
     self.city = city
-    self.city = city
     self.state = state
     self.zipCode = zipCode
+    self.sensibleHeatRatio = sensibleHeatRatio
+    $user.id = userID
     self.createdAt = createdAt
     self.updatedAt = updatedAt
   }
@@ -154,8 +279,32 @@ final class ProjectModel: Model, @unchecked Sendable {
       city: city,
       state: state,
       zipCode: zipCode,
+      sensibleHeatRatio: sensibleHeatRatio,
       createdAt: createdAt!,
       updatedAt: updatedAt!
     )
   }
+
+  func applyUpdates(_ updates: Project.Update) {
+    if let name = updates.name, name != self.name {
+      self.name = name
+    }
+    if let streetAddress = updates.streetAddress, streetAddress != self.streetAddress {
+      self.streetAddress = streetAddress
+    }
+    if let city = updates.city, city != self.city {
+      self.city = city
+    }
+    if let state = updates.state, state != self.state {
+      self.state = state
+    }
+    if let zipCode = updates.zipCode, zipCode != self.zipCode {
+      self.zipCode = zipCode
+    }
+    if let sensibleHeatRatio = updates.sensibleHeatRatio,
+      sensibleHeatRatio != self.sensibleHeatRatio
+    {
+      self.sensibleHeatRatio = sensibleHeatRatio
+    }
+  }
 }

Sources/DatabaseClient/RectangularDuct.swift

@@ -0,0 +1,175 @@
+// import Dependencies
+// import DependenciesMacros
+// import Fluent
+// import Foundation
+// import ManualDCore
+//
+// extension DatabaseClient {
+//   @DependencyClient
+//   public struct RectangularDuct: Sendable {
+//     public var create:
+//       @Sendable (DuctSizing.RectangularDuct.Create) async throws -> DuctSizing.RectangularDuct
+//     public var delete: @Sendable (DuctSizing.RectangularDuct.ID) async throws -> Void
+//     public var fetch: @Sendable (Room.ID) async throws -> [DuctSizing.RectangularDuct]
+//     public var get:
+//       @Sendable (DuctSizing.RectangularDuct.ID) async throws -> DuctSizing.RectangularDuct?
+//     public var update:
+//       @Sendable (DuctSizing.RectangularDuct.ID, DuctSizing.RectangularDuct.Update) async throws ->
+//         DuctSizing.RectangularDuct
+//   }
+// }
+//
+// extension DatabaseClient.RectangularDuct: TestDependencyKey {
+//   public static let testValue = Self()
+//
+//   public static func live(database: any Database) -> Self {
+//     .init(
+//       create: { request in
+//         try request.validate()
+//         let model = request.toModel()
+//         try await model.save(on: database)
+//         return try model.toDTO()
+//       },
+//       delete: { id in
+//         guard let model = try await RectangularDuctModel.find(id, on: database) else {
+//           throw NotFoundError()
+//         }
+//         try await model.delete(on: database)
+//       },
+//       fetch: { roomID in
+//         try await RectangularDuctModel.query(on: database)
+//           .with(\.$room)
+//           .filter(\.$room.$id == roomID)
+//           .all()
+//           .map { try $0.toDTO() }
+//       },
+//       get: { id in
+//         try await RectangularDuctModel.find(id, on: database)
+//           .map { try $0.toDTO() }
+//       },
+//       update: { id, updates in
+//         guard let model = try await RectangularDuctModel.find(id, on: database) else {
+//           throw NotFoundError()
+//         }
+//         try updates.validate()
+//         model.applyUpdates(updates)
+//         if model.hasChanges {
+//           try await model.save(on: database)
+//         }
+//         return try model.toDTO()
+//       }
+//     )
+//   }
+// }
+//
+// extension DuctSizing.RectangularDuct.Create {
+//
+//   func validate() throws(ValidationError) {
+//     guard height > 0 else {
+//       throw ValidationError("Rectangular duct size height should be greater than 0.")
+//     }
+//     if let register {
+//       guard register > 0 else {
+//         throw ValidationError("Rectangular duct size register should be greater than 0.")
+//       }
+//     }
+//   }
+//
+//   func toModel() -> RectangularDuctModel {
+//     .init(roomID: roomID, height: height)
+//   }
+// }
+//
+// extension DuctSizing.RectangularDuct.Update {
+//
+//   func validate() throws(ValidationError) {
+//     if let height {
+//       guard height > 0 else {
+//         throw ValidationError("Rectangular duct size height should be greater than 0.")
+//       }
+//     }
+//     if let register {
+//       guard register > 0 else {
+//         throw ValidationError("Rectangular duct size register should be greater than 0.")
+//       }
+//     }
+//   }
+// }
+//
+// extension DuctSizing.RectangularDuct {
+//   struct Migrate: AsyncMigration {
+//     let name = "CreateRectangularDuct"
+//
+//     func prepare(on database: any Database) async throws {
+//       try await database.schema(RectangularDuctModel.schema)
+//         .id()
+//         .field("register", .int8)
+//         .field("height", .int8, .required)
+//         .field("roomID", .uuid, .required, .references(RoomModel.schema, "id", onDelete: .cascade))
+//         .field("createdAt", .datetime)
+//         .field("updatedAt", .datetime)
+//         .create()
+//     }
+//
+//     func revert(on database: any Database) async throws {
+//       try await database.schema(RectangularDuctModel.schema).delete()
+//     }
+//   }
+// }
+//
+// final class RectangularDuctModel: Model, @unchecked Sendable {
+//
+//   static let schema = "rectangularDuct"
+//
+//   @ID(key: .id)
+//   var id: UUID?
+//
+//   @Parent(key: "roomID")
+//   var room: RoomModel
+//
+//   @Field(key: "height")
+//   var height: Int
+//
+//   @Field(key: "register")
+//   var register: Int?
+//
+//   @Timestamp(key: "createdAt", on: .create, format: .iso8601)
+//   var createdAt: Date?
+//
+//   @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
+//   var updatedAt: Date?
+//
+//   init() {}
+//
+//   init(
+//     id: UUID? = nil,
+//     roomID: Room.ID,
+//     register: Int? = nil,
+//     height: Int
+//   ) {
+//     self.id = id
+//     $room.id = roomID
+//     self.register = register
+//     self.height = height
+//   }
+//
+//   func toDTO() throws -> DuctSizing.RectangularDuct {
+//     return try .init(
+//       id: requireID(),
+//       roomID: $room.id,
+//       register: register,
+//       height: height,
+//       createdAt: createdAt!,
+//       updatedAt: updatedAt!
+//     )
+//   }
+//
+//   func applyUpdates(_ updates: DuctSizing.RectangularDuct.Update) {
+//     if let height = updates.height, height != self.height {
+//       self.height = height
+//     }
+//     if let register = updates.register, register != self.register {
+//       self.register = register
+//     }
+//   }
+// }

Sources/DatabaseClient/Rooms.swift

@@ -0,0 +1,282 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Foundation
+import ManualDCore
+
+extension DatabaseClient {
+  @DependencyClient
+  public struct Rooms: Sendable {
+    public var create: @Sendable (Room.Create) async throws -> Room
+    public var delete: @Sendable (Room.ID) async throws -> Void
+    public var deleteRectangularSize:
+      @Sendable (Room.ID, DuctSizing.RectangularDuct.ID) async throws -> Room
+    public var get: @Sendable (Room.ID) async throws -> Room?
+    public var fetch: @Sendable (Project.ID) async throws -> [Room]
+    public var update: @Sendable (Room.ID, Room.Update) async throws -> Room
+    public var updateRectangularSize:
+      @Sendable (Room.ID, DuctSizing.RectangularDuct) async throws -> Room
+  }
+}
+
+extension DatabaseClient.Rooms: TestDependencyKey {
+  public static let testValue = Self()
+
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { request in
+        let model = try request.toModel()
+        try await model.save(on: database)
+        return try model.toDTO()
+      },
+      delete: { id in
+        guard let model = try await RoomModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try await model.delete(on: database)
+      },
+      deleteRectangularSize: { roomID, rectangularDuctID in
+        guard let model = try await RoomModel.find(roomID, on: database) else {
+          throw NotFoundError()
+        }
+        model.rectangularSizes?.removeAll {
+          $0.id == rectangularDuctID
+        }
+        if model.hasChanges {
+          try await model.save(on: database)
+        }
+        return try model.toDTO()
+      },
+      get: { id in
+        try await RoomModel.find(id, on: database).map { try $0.toDTO() }
+      },
+      fetch: { projectID in
+        try await RoomModel.query(on: database)
+          .with(\.$project)
+          .filter(\.$project.$id, .equal, projectID)
+          .sort(\.$name, .ascending)
+          .all()
+          .map { try $0.toDTO() }
+      },
+      update: { id, updates in
+        guard let model = try await RoomModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+
+        try updates.validate()
+        model.applyUpdates(updates)
+        if model.hasChanges {
+          try await model.save(on: database)
+        }
+        return try model.toDTO()
+      },
+      updateRectangularSize: { id, size in
+        guard let model = try await RoomModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        var rectangularSizes = model.rectangularSizes ?? []
+        rectangularSizes.removeAll {
+          $0.id == size.id
+        }
+        rectangularSizes.append(size)
+        model.rectangularSizes = rectangularSizes
+        try await model.save(on: database)
+        return try model.toDTO()
+      }
+    )
+  }
+}
+
+extension Room.Create {
+
+  func toModel() throws(ValidationError) -> RoomModel {
+    try validate()
+    return .init(
+      name: name,
+      heatingLoad: heatingLoad,
+      coolingTotal: coolingTotal,
+      coolingSensible: coolingSensible,
+      registerCount: registerCount,
+      projectID: projectID
+    )
+  }
+
+  func validate() throws(ValidationError) {
+    guard !name.isEmpty else {
+      throw ValidationError("Room name should not be empty.")
+    }
+    guard heatingLoad >= 0 else {
+      throw ValidationError("Room heating load should not be less than 0.")
+    }
+    guard coolingTotal >= 0 else {
+      throw ValidationError("Room cooling total should not be less than 0.")
+    }
+    if let coolingSensible {
+      guard coolingSensible >= 0 else {
+        throw ValidationError("Room cooling sensible should not be less than 0.")
+      }
+    }
+    guard registerCount >= 1 else {
+      throw ValidationError("Room cooling sensible should not be less than 1.")
+    }
+  }
+}
+
+extension Room.Update {
+
+  func validate() throws(ValidationError) {
+    if let name {
+      guard !name.isEmpty else {
+        throw ValidationError("Room name should not be empty.")
+      }
+    }
+    if let heatingLoad {
+      guard heatingLoad >= 0 else {
+        throw ValidationError("Room heating load should not be less than 0.")
+      }
+    }
+    if let coolingTotal {
+      guard coolingTotal >= 0 else {
+        throw ValidationError("Room cooling total should not be less than 0.")
+      }
+    }
+    if let coolingSensible {
+      guard coolingSensible >= 0 else {
+        throw ValidationError("Room cooling sensible should not be less than 0.")
+      }
+    }
+    if let registerCount {
+      guard registerCount >= 1 else {
+        throw ValidationError("Room cooling sensible should not be less than 1.")
+      }
+    }
+  }
+}
+
+extension Room {
+  struct Migrate: AsyncMigration {
+    let name = "CreateRoom"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(RoomModel.schema)
+        .id()
+        .field("name", .string, .required)
+        .field("heatingLoad", .double, .required)
+        .field("coolingTotal", .double, .required)
+        .field("coolingSensible", .double)
+        .field("registerCount", .int8, .required)
+        .field("rectangularSizes", .array)
+        .field("createdAt", .datetime)
+        .field("updatedAt", .datetime)
+        .field(
+          "projectID", .uuid, .required, .references(ProjectModel.schema, "id", onDelete: .cascade)
+        )
+        .unique(on: "projectID", "name")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(RoomModel.schema).delete()
+    }
+  }
+}
+
+final class RoomModel: Model, @unchecked Sendable {
+
+  static let schema = "room"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "name")
+  var name: String
+
+  @Field(key: "heatingLoad")
+  var heatingLoad: Double
+
+  @Field(key: "coolingTotal")
+  var coolingTotal: Double
+
+  @Field(key: "coolingSensible")
+  var coolingSensible: Double?
+
+  @Field(key: "registerCount")
+  var registerCount: Int
+
+  @Field(key: "rectangularSizes")
+  var rectangularSizes: [DuctSizing.RectangularDuct]?
+
+  @Timestamp(key: "createdAt", on: .create, format: .iso8601)
+  var createdAt: Date?
+
+  @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
+  var updatedAt: Date?
+
+  @Parent(key: "projectID")
+  var project: ProjectModel
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    name: String,
+    heatingLoad: Double,
+    coolingTotal: Double,
+    coolingSensible: Double? = nil,
+    registerCount: Int,
+    rectangularSizes: [DuctSizing.RectangularDuct]? = nil,
+    createdAt: Date? = nil,
+    updatedAt: Date? = nil,
+    projectID: Project.ID
+  ) {
+    self.id = id
+    self.name = name
+    self.heatingLoad = heatingLoad
+    self.coolingTotal = coolingTotal
+    self.coolingSensible = coolingSensible
+    self.registerCount = registerCount
+    self.rectangularSizes = rectangularSizes
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+    $project.id = projectID
+  }
+
+  func toDTO() throws -> Room {
+    try .init(
+      id: requireID(),
+      projectID: $project.id,
+      name: name,
+      heatingLoad: heatingLoad,
+      coolingTotal: coolingTotal,
+      coolingSensible: coolingSensible,
+      registerCount: registerCount,
+      rectangularSizes: rectangularSizes,
+      createdAt: createdAt!,
+      updatedAt: updatedAt!
+    )
+  }
+
+  func applyUpdates(_ updates: Room.Update) {
+
+    if let name = updates.name, name != self.name {
+      self.name = name
+    }
+    if let heatingLoad = updates.heatingLoad, heatingLoad != self.heatingLoad {
+      self.heatingLoad = heatingLoad
+    }
+    if let coolingTotal = updates.coolingTotal, coolingTotal != self.coolingTotal {
+      self.coolingTotal = coolingTotal
+    }
+    if let coolingSensible = updates.coolingSensible, coolingSensible != self.coolingSensible {
+      self.coolingSensible = coolingSensible
+    }
+    if let registerCount = updates.registerCount, registerCount != self.registerCount {
+      self.registerCount = registerCount
+    }
+    if let rectangularSizes = updates.rectangularSizes, rectangularSizes != self.rectangularSizes {
+      self.rectangularSizes = rectangularSizes
+    }
+
+  }
+
+}

Sources/DatabaseClient/TrunkSizes.swift

@@ -0,0 +1,356 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Foundation
+import ManualDCore
+
+extension DatabaseClient {
+  @DependencyClient
+  public struct TrunkSizes: Sendable {
+    public var create: @Sendable (DuctSizing.TrunkSize.Create) async throws -> DuctSizing.TrunkSize
+    public var delete: @Sendable (DuctSizing.TrunkSize.ID) async throws -> Void
+    public var fetch: @Sendable (Project.ID) async throws -> [DuctSizing.TrunkSize]
+    public var get: @Sendable (DuctSizing.TrunkSize.ID) async throws -> DuctSizing.TrunkSize?
+    public var update:
+      @Sendable (DuctSizing.TrunkSize.ID, DuctSizing.TrunkSize.Update) async throws ->
+        DuctSizing.TrunkSize
+  }
+}
+
+extension DatabaseClient.TrunkSizes: TestDependencyKey {
+  public static let testValue = Self()
+
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { request in
+        try request.validate()
+
+        let trunk = request.toModel()
+        var roomProxies = [DuctSizing.TrunkSize.RoomProxy]()
+
+        try await trunk.save(on: database)
+
+        for (roomID, registers) in request.rooms {
+          guard let room = try await RoomModel.find(roomID, on: database) else {
+            throw NotFoundError()
+          }
+          let model = try TrunkRoomModel(
+            trunkID: trunk.requireID(),
+            roomID: room.requireID(),
+            registers: registers,
+            type: request.type
+          )
+          try await model.save(on: database)
+          try await roomProxies.append(model.toDTO(on: database))
+        }
+
+        return try .init(
+          id: trunk.requireID(),
+          projectID: trunk.$project.id,
+          type: .init(rawValue: trunk.type)!,
+          rooms: roomProxies
+        )
+      },
+      delete: { id in
+        guard let model = try await TrunkModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try await model.delete(on: database)
+      },
+      fetch: { projectID in
+        try await TrunkModel.query(on: database)
+          .with(\.$project)
+          .with(\.$rooms)
+          .filter(\.$project.$id == projectID)
+          .all()
+          .toDTO(on: database)
+      },
+      get: { id in
+        guard let model = try await TrunkModel.find(id, on: database) else {
+          return nil
+        }
+        return try await model.toDTO(on: database)
+      },
+      update: { id, updates in
+        guard
+          let model =
+            try await TrunkModel
+            .query(on: database)
+            .with(\.$rooms)
+            .filter(\.$id == id)
+            .first()
+        else {
+          throw NotFoundError()
+        }
+        try updates.validate()
+        try await model.applyUpdates(updates, on: database)
+        return try await model.toDTO(on: database)
+      }
+    )
+  }
+}
+
+extension DuctSizing.TrunkSize.Create {
+
+  func validate() throws(ValidationError) {
+    guard rooms.count > 0 else {
+      throw ValidationError("Trunk size should have associated rooms / registers.")
+    }
+    if let height {
+      guard height > 0 else {
+        throw ValidationError("Trunk size height should be greater than 0.")
+      }
+    }
+  }
+
+  func toModel() -> TrunkModel {
+    .init(
+      projectID: projectID,
+      type: type,
+      height: height,
+      name: name
+    )
+  }
+}
+
+extension DuctSizing.TrunkSize.Update {
+  func validate() throws(ValidationError) {
+    if let rooms {
+      guard rooms.count > 0 else {
+        throw ValidationError("Trunk size should have associated rooms / registers.")
+      }
+    }
+    if let height {
+      guard height > 0 else {
+        throw ValidationError("Trunk size height should be greater than 0.")
+      }
+    }
+  }
+}
+
+extension DuctSizing.TrunkSize {
+
+  struct Migrate: AsyncMigration {
+    let name = "CreateTrunkSize"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(TrunkModel.schema)
+        .id()
+        .field("height", .int8)
+        .field("name", .string)
+        .field("type", .string, .required)
+        .field(
+          "projectID", .uuid, .required, .references(ProjectModel.schema, "id", onDelete: .cascade)
+        )
+        .create()
+
+      try await database.schema(TrunkRoomModel.schema)
+        .id()
+        .field("registers", .array(of: .int), .required)
+        .field("type", .string, .required)
+        .field(
+          "trunkID", .uuid, .required, .references(TrunkModel.schema, "id", onDelete: .cascade)
+        )
+        .field(
+          "roomID", .uuid, .required, .references(RoomModel.schema, "id", onDelete: .cascade)
+        )
+        .unique(on: "trunkID", "roomID", "type")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(TrunkRoomModel.schema).delete()
+      try await database.schema(TrunkModel.schema).delete()
+    }
+  }
+}
+
+// Pivot table for associating rooms and trunks.
+final class TrunkRoomModel: Model, @unchecked Sendable {
+
+  static let schema = "room+trunk"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Parent(key: "trunkID")
+  var trunk: TrunkModel
+
+  @Parent(key: "roomID")
+  var room: RoomModel
+
+  @Field(key: "registers")
+  var registers: [Int]
+
+  @Field(key: "type")
+  var type: String
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    trunkID: TrunkModel.IDValue,
+    roomID: RoomModel.IDValue,
+    registers: [Int],
+    type: DuctSizing.TrunkSize.TrunkType
+  ) {
+    self.id = id
+    $trunk.id = trunkID
+    $room.id = roomID
+    self.registers = registers
+    self.type = type.rawValue
+  }
+
+  func toDTO(on database: any Database) async throws -> DuctSizing.TrunkSize.RoomProxy {
+    guard let room = try await RoomModel.find($room.id, on: database) else {
+      throw NotFoundError()
+    }
+    return .init(
+      room: try room.toDTO(),
+      registers: registers
+    )
+  }
+
+}
+
+final class TrunkModel: Model, @unchecked Sendable {
+
+  static let schema = "trunk"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Parent(key: "projectID")
+  var project: ProjectModel
+
+  @OptionalField(key: "height")
+  var height: Int?
+
+  @Field(key: "type")
+  var type: String
+
+  @OptionalField(key: "name")
+  var name: String?
+
+  @Children(for: \.$trunk)
+  var rooms: [TrunkRoomModel]
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    projectID: Project.ID,
+    type: DuctSizing.TrunkSize.TrunkType,
+    height: Int? = nil,
+    name: String? = nil
+  ) {
+    self.id = id
+    $project.id = projectID
+    self.height = height
+    self.type = type.rawValue
+    self.name = name
+  }
+
+  func toDTO(on database: any Database) async throws -> DuctSizing.TrunkSize {
+    let rooms = try await withThrowingTaskGroup(of: DuctSizing.TrunkSize.RoomProxy.self) { group in
+      for room in self.rooms {
+        group.addTask {
+          try await room.toDTO(on: database)
+        }
+      }
+
+      return try await group.reduce(into: [DuctSizing.TrunkSize.RoomProxy]()) {
+        $0.append($1)
+      }
+
+    }
+
+    return try .init(
+      id: requireID(),
+      projectID: $project.id,
+      type: .init(rawValue: type)!,
+      rooms: rooms,
+      height: height,
+      name: name
+    )
+
+  }
+
+  func applyUpdates(
+    _ updates: DuctSizing.TrunkSize.Update,
+    on database: any Database
+  ) async throws {
+    if let type = updates.type, type.rawValue != self.type {
+      self.type = type.rawValue
+    }
+    if let height = updates.height, height != self.height {
+      self.height = height
+    }
+    if let name = updates.name, name != self.name {
+      self.name = name
+    }
+    if hasChanges {
+      try await self.save(on: database)
+    }
+
+    guard let updateRooms = updates.rooms else {
+      return
+    }
+
+    // Update rooms.
+    let rooms = try await TrunkRoomModel.query(on: database)
+      .with(\.$room)
+      .filter(\.$trunk.$id == requireID())
+      .all()
+
+    for (roomID, registers) in updateRooms {
+      if let currRoom = rooms.first(where: { $0.$room.id == roomID }) {
+        database.logger.debug("CURRENT ROOM: \(currRoom.room.name)")
+        if registers != currRoom.registers {
+          database.logger.debug("Updating registers for: \(currRoom.room.name)")
+          currRoom.registers = registers
+        }
+        if currRoom.hasChanges {
+          try await currRoom.save(on: database)
+        }
+      } else {
+        database.logger.debug("CREATING NEW TrunkRoomModel")
+        let newModel = try TrunkRoomModel(
+          trunkID: requireID(),
+          roomID: roomID,
+          registers: registers,
+          type: .init(rawValue: type)!
+        )
+        try await newModel.save(on: database)
+      }
+    }
+
+    let roomsToDelete = rooms.filter {
+      !updateRooms.keys.contains($0.$room.id)
+    }
+
+    for room in roomsToDelete {
+      try await room.delete(on: database)
+    }
+
+    database.logger.debug("DONE WITH UPDATES")
+
+  }
+}
+
+extension Array where Element == TrunkModel {
+
+  func toDTO(on database: any Database) async throws -> [DuctSizing.TrunkSize] {
+    try await withThrowingTaskGroup(of: DuctSizing.TrunkSize.self) { group in
+      for model in self {
+        group.addTask {
+          try await model.toDTO(on: database)
+        }
+      }
+
+      return try await group.reduce(into: [DuctSizing.TrunkSize]()) {
+        $0.append($1)
+      }
+    }
+  }
+}

Sources/DatabaseClient/UserProfile.swift

@@ -0,0 +1,283 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import ManualDCore
+import Vapor
+
+extension DatabaseClient {
+  @DependencyClient
+  public struct UserProfile: Sendable {
+    public var create: @Sendable (User.Profile.Create) async throws -> User.Profile
+    public var delete: @Sendable (User.Profile.ID) async throws -> Void
+    public var fetch: @Sendable (User.ID) async throws -> User.Profile?
+    public var get: @Sendable (User.Profile.ID) async throws -> User.Profile?
+    public var update: @Sendable (User.Profile.ID, User.Profile.Update) async throws -> User.Profile
+  }
+}
+
+extension DatabaseClient.UserProfile: TestDependencyKey {
+
+  public static let testValue = Self()
+
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { profile in
+        try profile.validate()
+        let model = profile.toModel()
+        try await model.save(on: database)
+        return try model.toDTO()
+      },
+      delete: { id in
+        guard let model = try await UserProfileModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try await model.delete(on: database)
+      },
+      fetch: { userID in
+        try await UserProfileModel.query(on: database)
+          .with(\.$user)
+          .filter(\.$user.$id == userID)
+          .first()
+          .map { try $0.toDTO() }
+      },
+      get: { id in
+        try await UserProfileModel.find(id, on: database)
+          .map { try $0.toDTO() }
+      },
+      update: { id, updates in
+        guard let model = try await UserProfileModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try updates.validate()
+        model.applyUpdates(updates)
+        if model.hasChanges {
+          try await model.save(on: database)
+        }
+        return try model.toDTO()
+      }
+    )
+  }
+}
+
+extension User.Profile.Create {
+
+  func validate() throws(ValidationError) {
+    guard !firstName.isEmpty else {
+      throw ValidationError("User first name should not be empty.")
+    }
+    guard !lastName.isEmpty else {
+      throw ValidationError("User last name should not be empty.")
+    }
+    guard !companyName.isEmpty else {
+      throw ValidationError("User company name should not be empty.")
+    }
+    guard !streetAddress.isEmpty else {
+      throw ValidationError("User street address should not be empty.")
+    }
+    guard !city.isEmpty else {
+      throw ValidationError("User city should not be empty.")
+    }
+    guard !state.isEmpty else {
+      throw ValidationError("User state should not be empty.")
+    }
+    guard !zipCode.isEmpty else {
+      throw ValidationError("User zip code should not be empty.")
+    }
+  }
+
+  func toModel() -> UserProfileModel {
+    .init(
+      userID: userID,
+      firstName: firstName,
+      lastName: lastName,
+      companyName: companyName,
+      streetAddress: streetAddress,
+      city: city,
+      state: state,
+      zipCode: zipCode,
+      theme: theme
+    )
+  }
+}
+
+extension User.Profile.Update {
+
+  func validate() throws(ValidationError) {
+    if let firstName {
+      guard !firstName.isEmpty else {
+        throw ValidationError("User first name should not be empty.")
+      }
+    }
+    if let lastName {
+      guard !lastName.isEmpty else {
+        throw ValidationError("User last name should not be empty.")
+      }
+    }
+    if let companyName {
+      guard !companyName.isEmpty else {
+        throw ValidationError("User company name should not be empty.")
+      }
+    }
+    if let streetAddress {
+      guard !streetAddress.isEmpty else {
+        throw ValidationError("User street address should not be empty.")
+      }
+    }
+    if let city {
+      guard !city.isEmpty else {
+        throw ValidationError("User city should not be empty.")
+      }
+    }
+    if let state {
+      guard !state.isEmpty else {
+        throw ValidationError("User state should not be empty.")
+      }
+    }
+    if let zipCode {
+      guard !zipCode.isEmpty else {
+        throw ValidationError("User zip code should not be empty.")
+      }
+    }
+  }
+}
+
+extension User.Profile {
+
+  struct Migrate: AsyncMigration {
+    let name = "Create UserProfile"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(UserProfileModel.schema)
+        .id()
+        .field("firstName", .string, .required)
+        .field("lastName", .string, .required)
+        .field("companyName", .string, .required)
+        .field("streetAddress", .string, .required)
+        .field("city", .string, .required)
+        .field("state", .string, .required)
+        .field("zipCode", .string, .required)
+        .field("theme", .string)
+        .field("userID", .uuid, .references(UserModel.schema, "id", onDelete: .cascade))
+        .field("createdAt", .datetime)
+        .field("updatedAt", .datetime)
+        .unique(on: "userID")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(UserProfileModel.schema).delete()
+    }
+  }
+}
+
+final class UserProfileModel: Model, @unchecked Sendable {
+
+  static let schema = "user_profile"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Parent(key: "userID")
+  var user: UserModel
+
+  @Field(key: "firstName")
+  var firstName: String
+
+  @Field(key: "lastName")
+  var lastName: String
+
+  @Field(key: "companyName")
+  var companyName: String
+
+  @Field(key: "streetAddress")
+  var streetAddress: String
+
+  @Field(key: "city")
+  var city: String
+
+  @Field(key: "state")
+  var state: String
+
+  @Field(key: "zipCode")
+  var zipCode: String
+
+  @Field(key: "theme")
+  var theme: String?
+
+  @Timestamp(key: "createdAt", on: .create, format: .iso8601)
+  var createdAt: Date?
+
+  @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
+  var updatedAt: Date?
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    userID: User.ID,
+    firstName: String,
+    lastName: String,
+    companyName: String,
+    streetAddress: String,
+    city: String,
+    state: String,
+    zipCode: String,
+    theme: Theme? = nil
+  ) {
+    self.id = id
+    $user.id = userID
+    self.firstName = firstName
+    self.lastName = lastName
+    self.companyName = companyName
+    self.streetAddress = streetAddress
+    self.city = city
+    self.state = state
+    self.zipCode = zipCode
+    self.theme = theme?.rawValue
+  }
+
+  func toDTO() throws -> User.Profile {
+    try .init(
+      id: requireID(),
+      userID: $user.id,
+      firstName: firstName,
+      lastName: lastName,
+      companyName: companyName,
+      streetAddress: streetAddress,
+      city: city,
+      state: state,
+      zipCode: zipCode,
+      theme: self.theme.flatMap(Theme.init),
+      createdAt: createdAt!,
+      updatedAt: updatedAt!
+    )
+  }
+
+  func applyUpdates(_ updates: User.Profile.Update) {
+    if let firstName = updates.firstName, firstName != self.firstName {
+      self.firstName = firstName
+    }
+    if let lastName = updates.lastName, lastName != self.lastName {
+      self.lastName = lastName
+    }
+    if let companyName = updates.companyName, companyName != self.companyName {
+      self.companyName = companyName
+    }
+    if let streetAddress = updates.streetAddress, streetAddress != self.streetAddress {
+      self.streetAddress = streetAddress
+    }
+    if let city = updates.city, city != self.city {
+      self.city = city
+    }
+    if let state = updates.state, state != self.state {
+      self.state = state
+    }
+    if let zipCode = updates.zipCode, zipCode != self.zipCode {
+      self.zipCode = zipCode
+    }
+    if let theme = updates.theme, theme.rawValue != self.theme {
+      self.theme = theme.rawValue
+    }
+  }
+
+}

Sources/DatabaseClient/Users.swift

@@ -0,0 +1,286 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import ManualDCore
+import Vapor
+
+extension DatabaseClient {
+  @DependencyClient
+  public struct Users: Sendable {
+    public var create: @Sendable (User.Create) async throws -> User
+    public var delete: @Sendable (User.ID) async throws -> Void
+    public var get: @Sendable (User.ID) async throws -> User?
+    public var login: @Sendable (User.Login) async throws -> User.Token
+    public var logout: @Sendable (User.Token.ID) async throws -> Void
+    // public var token: @Sendable (User.ID) async throws -> User.Token
+  }
+
+}
+
+extension DatabaseClient.Users: TestDependencyKey {
+  public static let testValue = Self()
+
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { request in
+        let model = try request.toModel()
+        try await model.save(on: database)
+        return try model.toDTO()
+      },
+      delete: { id in
+        guard let model = try await UserModel.find(id, on: database) else {
+          throw NotFoundError()
+        }
+        try await model.delete(on: database)
+      },
+      get: { id in
+        try await UserModel.find(id, on: database).map { try $0.toDTO() }
+      },
+      login: { request in
+        guard
+          let user = try await UserModel.query(on: database)
+            .with(\.$token)
+            .filter(\UserModel.$email == request.email)
+            .first()
+        else {
+          throw NotFoundError()
+        }
+
+        let token: User.Token
+
+        // Check if there's a user token
+        if let userToken = user.token {
+          token = try userToken.toDTO()
+        } else {
+          // generate a new token
+          let tokenModel = try user.generateToken()
+          try await tokenModel.save(on: database)
+          token = try tokenModel.toDTO()
+        }
+
+        return token
+
+      },
+      logout: { tokenID in
+        guard let token = try await UserTokenModel.find(tokenID, on: database) else { return }
+        try await token.delete(on: database)
+      }
+      // ,
+      // token: { id in
+      // }
+
+    )
+  }
+}
+
+extension User {
+  struct Migrate: AsyncMigration {
+    let name = "CreateUser"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(UserModel.schema)
+        .id()
+        .field("email", .string, .required)
+        .field("password_hash", .string, .required)
+        .field("createdAt", .datetime)
+        .field("updatedAt", .datetime)
+        .unique(on: "email")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(UserModel.schema).delete()
+    }
+  }
+}
+
+extension User.Token {
+  struct Migrate: AsyncMigration {
+    let name = "CreateUserToken"
+
+    func prepare(on database: any Database) async throws {
+      try await database.schema(UserTokenModel.schema)
+        .id()
+        .field("value", .string, .required)
+        .field("user_id", .uuid, .required, .references(UserModel.schema, "id"))
+        .field("createdAt", .datetime)
+        .field("updatedAt", .datetime)
+        .unique(on: "value")
+        .create()
+    }
+
+    func revert(on database: any Database) async throws {
+      try await database.schema(UserTokenModel.schema).delete()
+    }
+  }
+}
+
+extension User {
+
+  static func hashPassword(_ password: String) throws -> String {
+    try Bcrypt.hash(password, cost: 12)
+  }
+
+}
+
+extension User.Create {
+
+  func toModel() throws -> UserModel {
+    try validate()
+    return try .init(email: email, passwordHash: User.hashPassword(password))
+  }
+
+  func validate() throws {
+    guard !email.isEmpty else {
+      throw ValidationError("Email should not be empty")
+    }
+    guard password.count > 8 else {
+      throw ValidationError("Password should be more than 8 characters long.")
+    }
+    guard password == confirmPassword else {
+      throw ValidationError("Passwords do not match.")
+    }
+  }
+}
+
+final class UserModel: Model, @unchecked Sendable {
+
+  static let schema = "user"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "email")
+  var email: String
+
+  @Field(key: "password_hash")
+  var passwordHash: String
+
+  @Timestamp(key: "createdAt", on: .create, format: .iso8601)
+  var createdAt: Date?
+
+  @Timestamp(key: "updatedAt", on: .update, format: .iso8601)
+  var updatedAt: Date?
+
+  @OptionalChild(for: \.$user)
+  var token: UserTokenModel?
+
+  init() {}
+
+  init(
+    id: UUID? = nil,
+    email: String,
+    passwordHash: String
+  ) {
+    self.id = id
+    self.email = email
+    self.passwordHash = passwordHash
+  }
+
+  func toDTO() throws -> User {
+    try .init(
+      id: requireID(),
+      email: email,
+      createdAt: createdAt!,
+      updatedAt: updatedAt!
+    )
+  }
+
+  func generateToken() throws -> UserTokenModel {
+    try .init(
+      value: [UInt8].random(count: 16).base64,
+      userID: requireID()
+    )
+  }
+
+  func verifyPassword(_ password: String) throws -> Bool {
+    try Bcrypt.verify(password, created: passwordHash)
+  }
+}
+
+final class UserTokenModel: Model, Codable, @unchecked Sendable {
+
+  static let schema = "user_token"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "value")
+  var value: String
+
+  @Parent(key: "user_id")
+  var user: UserModel
+
+  init() {}
+
+  init(id: UUID? = nil, value: String, userID: UserModel.IDValue) {
+    self.id = id
+    self.value = value
+    $user.id = userID
+  }
+
+  func toDTO() throws -> User.Token {
+    try .init(id: requireID(), userID: $user.id, value: value)
+  }
+
+}
+
+// MARK: - Authentication
+
+extension User: Authenticatable {}
+extension User: SessionAuthenticatable {
+  public var sessionID: String { email }
+}
+
+public struct UserPasswordAuthenticator: AsyncBasicAuthenticator {
+  public typealias User = ManualDCore.User
+
+  public init() {}
+
+  public func authenticate(basic: BasicAuthorization, for request: Request) async throws {
+    guard
+      let user = try await UserModel.query(on: request.db)
+        .filter(\UserModel.$email == basic.username)
+        .first(),
+      try user.verifyPassword(basic.password)
+    else {
+      throw Abort(.unauthorized)
+    }
+    try request.auth.login(user.toDTO())
+  }
+}
+
+public struct UserTokenAuthenticator: AsyncBearerAuthenticator {
+  public typealias User = ManualDCore.User
+
+  public init() {}
+
+  public func authenticate(bearer: BearerAuthorization, for request: Request) async throws {
+    guard
+      let token = try await UserTokenModel.query(on: request.db)
+        .filter(\UserTokenModel.$value == bearer.token)
+        .with(\UserTokenModel.$user)
+        .first()
+    else {
+      throw Abort(.unauthorized)
+    }
+    try request.auth.login(token.user.toDTO())
+  }
+}
+
+public struct UserSessionAuthenticator: AsyncSessionAuthenticator {
+  public typealias User = ManualDCore.User
+
+  public init() {}
+
+  public func authenticate(sessionID: User.SessionID, for request: Request) async throws {
+    guard
+      let user = try await UserModel.query(on: request.db)
+        .filter(\UserModel.$email == sessionID)
+        .first()
+    else {
+      throw Abort(.unauthorized)
+    }
+    try request.auth.login(user.toDTO())
+  }
+}

Sources/ManualDClient/Helpers.swift

@@ -1,6 +1,51 @@
 import Foundation
 import ManualDCore
 
+extension Room {
+
+  var heatingLoadPerRegister: Double {
+
+    heatingLoad / Double(registerCount)
+  }
+
+  func coolingSensiblePerRegister(projectSHR: Double) -> Double {
+    let sensible = coolingSensible ?? (coolingTotal * projectSHR)
+    return sensible / Double(registerCount)
+  }
+}
+
+extension DuctSizing.TrunkSize.RoomProxy {
+
+  // We need to make sure if registers got removed after a trunk
+  // was already made / saved that we do not include registers that
+  // no longer exist.
+  private var actualRegisterCount: Int {
+    guard registers.count <= room.registerCount else {
+      return room.registerCount
+    }
+    return registers.count
+  }
+
+  var totalHeatingLoad: Double {
+    room.heatingLoadPerRegister * Double(actualRegisterCount)
+  }
+
+  func totalCoolingSensible(projectSHR: Double) -> Double {
+    room.coolingSensiblePerRegister(projectSHR: projectSHR) * Double(actualRegisterCount)
+  }
+}
+
+extension DuctSizing.TrunkSize {
+
+  var totalHeatingLoad: Double {
+    rooms.reduce(into: 0) { $0 += $1.totalHeatingLoad }
+  }
+
+  func totalCoolingSensible(projectSHR: Double) -> Double {
+    rooms.reduce(into: 0) { $0 += $1.totalCoolingSensible(projectSHR: projectSHR) }
+  }
+}
+
 extension ComponentPressureLosses {
   var totalLosses: Double { values.reduce(0) { $0 + $1 } }
 }
@@ -19,6 +64,8 @@ func roundSize(_ size: Double) throws -> Int {
     throw ManualDError(message: "Size should be less than 24.")
   }
 
+  // let size = size.rounded(.toNearestOrEven)
+
   switch size {
   case 0..<4:
     return 4

Sources/ManualDClient/Live.swift

@@ -25,7 +25,7 @@ extension ManualDClient: DependencyKey {
         throw ManualDError(message: "Total Effective Length should be greater than 0.")
       }
 
-      let totalComponentLosses = request.componentPressureLosses.totalLosses
+      let totalComponentLosses = request.componentPressureLosses.total
       let availableStaticPressure = request.externalStaticPressure - totalComponentLosses
       let frictionRate = availableStaticPressure * 100.0 / Double(request.totalEffectiveLength)
       return .init(availableStaticPressure: availableStaticPressure, frictionRate: frictionRate)
@@ -38,23 +38,7 @@ extension ManualDClient: DependencyKey {
     },
     equivalentRectangularDuct: { request in
       let width = (Double.pi * (pow(Double(request.roundSize) / 2.0, 2.0))) / Double(request.height)
-      // Round the width up or fail (really should never fail since we know the input is a number).
-      guard let widthStr = numberFormatter.string(for: width),
-        let widthInt = Int(widthStr)
-      else {
-        throw ManualDError(
-          message: "Failed to convert to to rectangular duct size, width: \(width)"
-        )
-      }
-      return .init(height: request.height, width: widthInt)
+      return .init(height: request.height, width: Int(width.rounded(.toNearestOrEven)))
     }
   )
 }
-
-private let numberFormatter: NumberFormatter = {
-  let formatter = NumberFormatter()
-  formatter.maximumFractionDigits = 0
-  formatter.minimumFractionDigits = 0
-  formatter.roundingMode = .ceiling
-  return formatter
-}()

Sources/ManualDClient/ManualDClient.swift

@@ -1,5 +1,6 @@
 import Dependencies
 import DependenciesMacros
+import Logging
 import ManualDCore
 
 @DependencyClient
@@ -9,6 +10,146 @@ public struct ManualDClient: Sendable {
   public var totalEffectiveLength: @Sendable (TotalEffectiveLengthRequest) async throws -> Int
   public var equivalentRectangularDuct:
     @Sendable (EquivalentRectangularDuctRequest) async throws -> EquivalentRectangularDuctResponse
+
+  public func calculateSizes(
+    rooms: [Room],
+    trunks: [DuctSizing.TrunkSize],
+    equipmentInfo: EquipmentInfo,
+    maxSupplyLength: EffectiveLength,
+    maxReturnLength: EffectiveLength,
+    designFrictionRate: Double,
+    projectSHR: Double,
+    logger: Logger? = nil
+  ) async throws -> (rooms: [DuctSizing.RoomContainer], trunks: [DuctSizing.TrunkContainer]) {
+    try await (
+      calculateSizes(
+        rooms: rooms, equipmentInfo: equipmentInfo,
+        maxSupplyLength: maxSupplyLength, maxReturnLength: maxReturnLength,
+        designFrictionRate: designFrictionRate, projectSHR: projectSHR
+      ),
+      calculateSizes(
+        rooms: rooms, trunks: trunks, equipmentInfo: equipmentInfo,
+        maxSupplyLength: maxSupplyLength, maxReturnLength: maxReturnLength,
+        designFrictionRate: designFrictionRate, projectSHR: projectSHR)
+    )
+  }
+
+  func calculateSizes(
+    rooms: [Room],
+    equipmentInfo: EquipmentInfo,
+    maxSupplyLength: EffectiveLength,
+    maxReturnLength: EffectiveLength,
+    designFrictionRate: Double,
+    projectSHR: Double,
+    logger: Logger? = nil
+  ) async throws -> [DuctSizing.RoomContainer] {
+
+    var retval: [DuctSizing.RoomContainer] = []
+    let totalHeatingLoad = rooms.totalHeatingLoad
+    let totalCoolingSensible = rooms.totalCoolingSensible(shr: projectSHR)
+
+    for room in rooms {
+      let heatingLoad = room.heatingLoadPerRegister
+      let coolingLoad = room.coolingSensiblePerRegister(projectSHR: projectSHR)
+      let heatingPercent = heatingLoad / totalHeatingLoad
+      let coolingPercent = coolingLoad / totalCoolingSensible
+      let heatingCFM = heatingPercent * Double(equipmentInfo.heatingCFM)
+      let coolingCFM = coolingPercent * Double(equipmentInfo.coolingCFM)
+      let designCFM = DuctSizing.DesignCFM(heating: heatingCFM, cooling: coolingCFM)
+      let sizes = try await self.ductSize(
+        .init(designCFM: Int(designCFM.value), frictionRate: designFrictionRate)
+      )
+
+      for n in 1...room.registerCount {
+
+        var rectangularWidth: Int? = nil
+        let rectangularSize = room.rectangularSizes?
+          .first(where: { $0.register == nil || $0.register == n })
+
+        if let rectangularSize {
+          let response = try await self.equivalentRectangularDuct(
+            .init(round: sizes.finalSize, height: rectangularSize.height)
+          )
+          rectangularWidth = response.width
+        }
+
+        retval.append(
+          .init(
+            roomID: room.id,
+            roomName: "\(room.name)-\(n)",
+            roomRegister: n,
+            heatingLoad: heatingLoad,
+            coolingLoad: coolingLoad,
+            heatingCFM: heatingCFM,
+            coolingCFM: coolingCFM,
+            designCFM: designCFM,
+            roundSize: sizes.ductulatorSize,
+            finalSize: sizes.finalSize,
+            velocity: sizes.velocity,
+            flexSize: sizes.flexSize,
+            rectangularSize: rectangularSize,
+            rectangularWidth: rectangularWidth
+          )
+        )
+      }
+    }
+
+    return retval
+  }
+
+  func calculateSizes(
+    rooms: [Room],
+    trunks: [DuctSizing.TrunkSize],
+    equipmentInfo: EquipmentInfo,
+    maxSupplyLength: EffectiveLength,
+    maxReturnLength: EffectiveLength,
+    designFrictionRate: Double,
+    projectSHR: Double,
+    logger: Logger? = nil
+  ) async throws -> [DuctSizing.TrunkContainer] {
+
+    var retval = [DuctSizing.TrunkContainer]()
+    let totalHeatingLoad = rooms.totalHeatingLoad
+    let totalCoolingSensible = rooms.totalCoolingSensible(shr: projectSHR)
+
+    for trunk in trunks {
+      let heatingLoad = trunk.totalHeatingLoad
+      let coolingLoad = trunk.totalCoolingSensible(projectSHR: projectSHR)
+      let heatingPercent = heatingLoad / totalHeatingLoad
+      let coolingPercent = coolingLoad / totalCoolingSensible
+      let heatingCFM = heatingPercent * Double(equipmentInfo.heatingCFM)
+      let coolingCFM = coolingPercent * Double(equipmentInfo.coolingCFM)
+      let designCFM = DuctSizing.DesignCFM(heating: heatingCFM, cooling: coolingCFM)
+      let sizes = try await self.ductSize(
+        .init(designCFM: Int(designCFM.value), frictionRate: designFrictionRate)
+      )
+      var width: Int? = nil
+      if let height = trunk.height {
+        let rectangularSize = try await self.equivalentRectangularDuct(
+          .init(round: sizes.finalSize, height: height)
+        )
+        width = rectangularSize.width
+      }
+
+      retval.append(
+        .init(
+          trunk: trunk,
+          ductSize: .init(
+            designCFM: designCFM,
+            roundSize: sizes.ductulatorSize,
+            finalSize: sizes.finalSize,
+            velocity: sizes.velocity,
+            flexSize: sizes.flexSize,
+            height: trunk.height,
+            width: width
+          )
+        )
+      )
+    }
+
+    return retval
+  }
+
 }
 
 extension ManualDClient: TestDependencyKey {
@@ -63,12 +204,12 @@ extension ManualDClient {
   public struct FrictionRateRequest: Codable, Equatable, Sendable {
 
     public let externalStaticPressure: Double
-    public let componentPressureLosses: ComponentPressureLosses
+    public let componentPressureLosses: [ComponentPressureLoss]
     public let totalEffectiveLength: Int
 
     public init(
       externalStaticPressure: Double,
-      componentPressureLosses: ComponentPressureLosses,
+      componentPressureLosses: [ComponentPressureLoss],
       totalEffectiveLength: Int
     ) {
       self.externalStaticPressure = externalStaticPressure

Sources/ManualDCore/ComponentPressureLosses.swift

@@ -1,5 +1,79 @@
 import Foundation
 
+public struct ComponentPressureLoss: Codable, Equatable, Identifiable, Sendable {
+
+  public let id: UUID
+  public let projectID: Project.ID
+  public let name: String
+  public let value: Double
+  public let createdAt: Date
+  public let updatedAt: Date
+
+  public init(
+    id: UUID,
+    projectID: Project.ID,
+    name: String,
+    value: Double,
+    createdAt: Date,
+    updatedAt: Date
+  ) {
+    self.id = id
+    self.projectID = projectID
+    self.name = name
+    self.value = value
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+  }
+}
+
+extension ComponentPressureLoss {
+  public struct Create: Codable, Equatable, Sendable {
+
+    public let projectID: Project.ID
+    public let name: String
+    public let value: Double
+
+    public init(
+      projectID: Project.ID,
+      name: String,
+      value: Double,
+    ) {
+      self.projectID = projectID
+      self.name = name
+      self.value = value
+    }
+
+    // Return's commonly used default component pressure losses.
+    public static func `default`(projectID: Project.ID) -> [Self] {
+      [
+        .init(projectID: projectID, name: "supply-outlet", value: 0.03),
+        .init(projectID: projectID, name: "return-grille", value: 0.03),
+        .init(projectID: projectID, name: "balancing-damper", value: 0.03),
+      ]
+    }
+  }
+
+  public struct Update: Codable, Equatable, Sendable {
+
+    public let name: String?
+    public let value: Double?
+
+    public init(
+      name: String? = nil,
+      value: Double? = nil
+    ) {
+      self.name = name
+      self.value = value
+    }
+  }
+}
+
+extension Array where Element == ComponentPressureLoss {
+  public var total: Double {
+    reduce(into: 0) { $0 += $1.value }
+  }
+}
+
 public typealias ComponentPressureLosses = [String: Double]
 
 #if DEBUG
@@ -14,4 +88,51 @@ public typealias ComponentPressureLosses = [String: Double]
       ]
     }
   }
+
+  extension ComponentPressureLoss {
+    public static var mock: [Self] {
+      [
+        .init(
+          id: UUID(0),
+          projectID: UUID(0),
+          name: "evaporator-coil",
+          value: 0.2,
+          createdAt: Date(),
+          updatedAt: Date()
+        ),
+        .init(
+          id: UUID(1),
+          projectID: UUID(0),
+          name: "filter",
+          value: 0.1,
+          createdAt: Date(),
+          updatedAt: Date()
+        ),
+        .init(
+          id: UUID(2),
+          projectID: UUID(0),
+          name: "supply-outlet",
+          value: 0.03,
+          createdAt: Date(),
+          updatedAt: Date()
+        ),
+        .init(
+          id: UUID(3),
+          projectID: UUID(0),
+          name: "return-grille",
+          value: 0.03,
+          createdAt: Date(),
+          updatedAt: Date()
+        ),
+        .init(
+          id: UUID(4),
+          projectID: UUID(0),
+          name: "balance-damper",
+          value: 0.03,
+          createdAt: Date(),
+          updatedAt: Date()
+        ),
+      ]
+    }
+  }
 #endif

Sources/ManualDCore/DuctSizing.swift

@@ -0,0 +1,248 @@
+import Dependencies
+import Foundation
+
+public enum DuctSizing {
+
+  public struct RectangularDuct: Codable, Equatable, Identifiable, Sendable {
+
+    public let id: UUID
+    public let register: Int?
+    public let height: Int
+
+    public init(
+      id: UUID = .init(),
+      register: Int? = nil,
+      height: Int,
+    ) {
+      self.id = id
+      self.register = register
+      self.height = height
+    }
+
+  }
+
+  public struct SizeContainer: Codable, Equatable, Sendable {
+
+    public let designCFM: DesignCFM
+    public let roundSize: Double
+    public let finalSize: Int
+    public let velocity: Int
+    public let flexSize: Int
+    public let height: Int?
+    public let width: Int?
+
+    public init(
+      designCFM: DuctSizing.DesignCFM,
+      roundSize: Double,
+      finalSize: Int,
+      velocity: Int,
+      flexSize: Int,
+      height: Int? = nil,
+      width: Int? = nil
+    ) {
+      self.designCFM = designCFM
+      self.roundSize = roundSize
+      self.finalSize = finalSize
+      self.velocity = velocity
+      self.flexSize = flexSize
+      self.height = height
+      self.width = width
+    }
+  }
+
+  // TODO: Uses SizeContainer
+
+  public struct RoomContainer: Codable, Equatable, Sendable {
+
+    public let roomID: Room.ID
+    public let roomName: String
+    public let roomRegister: Int
+    public let heatingLoad: Double
+    public let coolingLoad: Double
+    public let heatingCFM: Double
+    public let coolingCFM: Double
+    public let designCFM: DesignCFM
+    public let roundSize: Double
+    public let finalSize: Int
+    public let velocity: Int
+    public let flexSize: Int
+    public let rectangularSize: RectangularDuct?
+    public let rectangularWidth: Int?
+
+    public init(
+      roomID: Room.ID,
+      roomName: String,
+      roomRegister: Int,
+      heatingLoad: Double,
+      coolingLoad: Double,
+      heatingCFM: Double,
+      coolingCFM: Double,
+      designCFM: DesignCFM,
+      roundSize: Double,
+      finalSize: Int,
+      velocity: Int,
+      flexSize: Int,
+      rectangularSize: RectangularDuct? = nil,
+      rectangularWidth: Int? = nil
+    ) {
+      self.roomID = roomID
+      self.roomName = roomName
+      self.roomRegister = roomRegister
+      self.heatingLoad = heatingLoad
+      self.coolingLoad = coolingLoad
+      self.heatingCFM = heatingCFM
+      self.coolingCFM = coolingCFM
+      self.designCFM = designCFM
+      self.roundSize = roundSize
+      self.finalSize = finalSize
+      self.velocity = velocity
+      self.flexSize = flexSize
+      self.rectangularSize = rectangularSize
+      self.rectangularWidth = rectangularWidth
+    }
+  }
+
+  public enum DesignCFM: Codable, Equatable, Sendable {
+    case heating(Double)
+    case cooling(Double)
+
+    public init(heating: Double, cooling: Double) {
+      if heating >= cooling {
+        self = .heating(heating)
+      } else {
+        self = .cooling(cooling)
+      }
+    }
+
+    public var value: Double {
+      switch self {
+      case .heating(let value): return value
+      case .cooling(let value): return value
+      }
+    }
+  }
+}
+
+extension DuctSizing {
+
+  // Represents the database model that the duct sizes have been calculated
+  // for.
+  @dynamicMemberLookup
+  public struct TrunkContainer: Codable, Equatable, Identifiable, Sendable {
+    public var id: TrunkSize.ID { trunk.id }
+
+    public let trunk: TrunkSize
+    public let ductSize: SizeContainer
+
+    public init(
+      trunk: TrunkSize,
+      ductSize: SizeContainer
+    ) {
+      self.trunk = trunk
+      self.ductSize = ductSize
+    }
+
+    public subscript<T>(dynamicMember keyPath: KeyPath<DuctSizing.TrunkSize, T>) -> T {
+      trunk[keyPath: keyPath]
+    }
+
+    public subscript<T>(dynamicMember keyPath: KeyPath<DuctSizing.SizeContainer, T>) -> T {
+      ductSize[keyPath: keyPath]
+    }
+  }
+
+  // TODO: Add an optional label that the user can set.
+
+  // Represents the database model.
+  public struct TrunkSize: Codable, Equatable, Identifiable, Sendable {
+
+    public let id: UUID
+    public let projectID: Project.ID
+    public let type: TrunkType
+    public let rooms: [RoomProxy]
+    public let height: Int?
+    public let name: String?
+
+    public init(
+      id: UUID,
+      projectID: Project.ID,
+      type: DuctSizing.TrunkSize.TrunkType,
+      rooms: [DuctSizing.TrunkSize.RoomProxy],
+      height: Int? = nil,
+      name: String? = nil
+    ) {
+      self.id = id
+      self.projectID = projectID
+      self.type = type
+      self.rooms = rooms
+      self.height = height
+      self.name = name
+    }
+  }
+
+}
+
+extension DuctSizing.TrunkSize {
+  public struct Create: Codable, Equatable, Sendable {
+
+    public let projectID: Project.ID
+    public let type: TrunkType
+    public let rooms: [Room.ID: [Int]]
+    public let height: Int?
+    public let name: String?
+
+    public init(
+      projectID: Project.ID,
+      type: DuctSizing.TrunkSize.TrunkType,
+      rooms: [Room.ID: [Int]],
+      height: Int? = nil,
+      name: String? = nil
+    ) {
+      self.projectID = projectID
+      self.type = type
+      self.rooms = rooms
+      self.height = height
+      self.name = name
+    }
+  }
+
+  public struct Update: Codable, Equatable, Sendable {
+
+    public let type: TrunkType?
+    public let rooms: [Room.ID: [Int]]?
+    public let height: Int?
+    public let name: String?
+
+    public init(
+      type: DuctSizing.TrunkSize.TrunkType? = nil,
+      rooms: [Room.ID: [Int]]? = nil,
+      height: Int? = nil,
+      name: String? = nil
+    ) {
+      self.type = type
+      self.rooms = rooms
+      self.height = height
+      self.name = name
+    }
+  }
+
+  // TODO: Make registers non-optional
+  public struct RoomProxy: Codable, Equatable, Identifiable, Sendable {
+
+    public var id: Room.ID { room.id }
+    public let room: Room
+    public let registers: [Int]
+
+    public init(room: Room, registers: [Int]) {
+      self.room = room
+      self.registers = registers
+    }
+  }
+
+  public enum TrunkType: String, CaseIterable, Codable, Equatable, Sendable {
+    case `return`
+    case supply
+
+    public static let allCases = [Self.supply, .return]
+  }
+}

Sources/ManualDCore/EffectiveLength.swift

@@ -0,0 +1,177 @@
+import Dependencies
+import Foundation
+
+// TODO: Not sure how to model effective length groups in the database.
+//       thinking perhaps just have a 'data' field that encoded / decodes
+//       to swift types??
+public struct EffectiveLength: Codable, Equatable, Identifiable, Sendable {
+
+  public let id: UUID
+  public let projectID: Project.ID
+  public let name: String
+  public let type: EffectiveLengthType
+  public let straightLengths: [Int]
+  public let groups: [Group]
+  public let createdAt: Date
+  public let updatedAt: Date
+
+  public init(
+    id: UUID,
+    projectID: Project.ID,
+    name: String,
+    type: EffectiveLength.EffectiveLengthType,
+    straightLengths: [Int],
+    groups: [EffectiveLength.Group],
+    createdAt: Date,
+    updatedAt: Date
+  ) {
+    self.id = id
+    self.projectID = projectID
+    self.name = name
+    self.type = type
+    self.straightLengths = straightLengths
+    self.groups = groups
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+  }
+}
+
+extension EffectiveLength {
+
+  public struct Create: Codable, Equatable, Sendable {
+
+    public let projectID: Project.ID
+    public let name: String
+    public let type: EffectiveLengthType
+    public let straightLengths: [Int]
+    public let groups: [Group]
+
+    public init(
+      projectID: Project.ID,
+      name: String,
+      type: EffectiveLength.EffectiveLengthType,
+      straightLengths: [Int],
+      groups: [EffectiveLength.Group]
+    ) {
+      self.projectID = projectID
+      self.name = name
+      self.type = type
+      self.straightLengths = straightLengths
+      self.groups = groups
+    }
+  }
+
+  public struct Update: Codable, Equatable, Sendable {
+
+    public let name: String?
+    public let type: EffectiveLengthType?
+    public let straightLengths: [Int]?
+    public let groups: [Group]?
+
+    public init(
+      name: String? = nil,
+      type: EffectiveLength.EffectiveLengthType? = nil,
+      straightLengths: [Int]? = nil,
+      groups: [EffectiveLength.Group]? = nil
+    ) {
+      self.name = name
+      self.type = type
+      self.straightLengths = straightLengths
+      self.groups = groups
+    }
+  }
+
+  public enum EffectiveLengthType: String, CaseIterable, Codable, Sendable {
+    case `return`
+    case supply
+  }
+
+  public struct Group: Codable, Equatable, Sendable {
+
+    public let group: Int
+    public let letter: String
+    public let value: Double
+    public let quantity: Int
+
+    public init(
+      group: Int,
+      letter: String,
+      value: Double,
+      quantity: Int = 1
+    ) {
+      self.group = group
+      self.letter = letter
+      self.value = value
+      self.quantity = quantity
+    }
+  }
+
+  public struct MaxContainer: Codable, Equatable, Sendable {
+    public let supply: EffectiveLength?
+    public let `return`: EffectiveLength?
+
+    public var total: Double? {
+      guard let supply else { return nil }
+      guard let `return` else { return nil }
+      return supply.totalEquivalentLength + `return`.totalEquivalentLength
+    }
+
+    public init(supply: EffectiveLength? = nil, return: EffectiveLength? = nil) {
+      self.supply = supply
+      self.return = `return`
+    }
+  }
+}
+
+extension EffectiveLength {
+  public var totalEquivalentLength: Double {
+    straightLengths.reduce(into: 0.0) { $0 += Double($1) }
+      + groups.totalEquivalentLength
+  }
+}
+
+extension Array where Element == EffectiveLength.Group {
+
+  public var totalEquivalentLength: Double {
+    reduce(into: 0.0) {
+      $0 += ($1.value * Double($1.quantity))
+    }
+  }
+}
+
+#if DEBUG
+
+  extension EffectiveLength {
+    public static let mocks: [Self] = [
+      .init(
+        id: UUID(0),
+        projectID: UUID(0),
+        name: "Test Supply - 1",
+        type: .supply,
+        straightLengths: [10, 20, 25],
+        groups: [
+          .init(group: 1, letter: "a", value: 20),
+          .init(group: 2, letter: "b", value: 15, quantity: 2),
+          .init(group: 3, letter: "c", value: 10, quantity: 1),
+        ],
+        createdAt: Date(),
+        updatedAt: Date()
+      ),
+      .init(
+        id: UUID(1),
+        projectID: UUID(0),
+        name: "Test Return - 1",
+        type: .return,
+        straightLengths: [10, 20, 25],
+        groups: [
+          .init(group: 1, letter: "a", value: 20),
+          .init(group: 2, letter: "b", value: 15, quantity: 2),
+          .init(group: 3, letter: "c", value: 10, quantity: 1),
+        ],
+        createdAt: Date(),
+        updatedAt: Date()
+      ),
+    ]
+  }
+
+#endif

Sources/ManualDCore/EquipmentInfo.swift

@@ -1,17 +1,82 @@
+import Dependencies
 import Foundation
 
-public struct EquipmentInfo: Codable, Equatable, Sendable {
+public struct EquipmentInfo: Codable, Equatable, Identifiable, Sendable {
+  public let id: UUID
+  public let projectID: Project.ID
   public let staticPressure: Double
   public let heatingCFM: Int
   public let coolingCFM: Int
+  public let createdAt: Date
+  public let updatedAt: Date
 
   public init(
+    id: UUID,
+    projectID: Project.ID,
     staticPressure: Double = 0.5,
     heatingCFM: Int,
-    coolingCFM: Int
+    coolingCFM: Int,
+    createdAt: Date,
+    updatedAt: Date
   ) {
+    self.id = id
+    self.projectID = projectID
     self.staticPressure = staticPressure
     self.heatingCFM = heatingCFM
     self.coolingCFM = coolingCFM
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
   }
 }
+
+extension EquipmentInfo {
+
+  // TODO: Remove projectID and use dependency to lookup current project ??
+  public struct Create: Codable, Equatable, Sendable {
+    public let projectID: Project.ID
+    public let staticPressure: Double
+    public let heatingCFM: Int
+    public let coolingCFM: Int
+
+    public init(
+      projectID: Project.ID,
+      staticPressure: Double = 0.5,
+      heatingCFM: Int,
+      coolingCFM: Int
+    ) {
+      self.projectID = projectID
+      self.staticPressure = staticPressure
+      self.heatingCFM = heatingCFM
+      self.coolingCFM = coolingCFM
+    }
+  }
+
+  public struct Update: Codable, Equatable, Sendable {
+    public let staticPressure: Double?
+    public let heatingCFM: Int?
+    public let coolingCFM: Int?
+
+    public init(
+      staticPressure: Double? = nil,
+      heatingCFM: Int? = nil,
+      coolingCFM: Int? = nil
+    ) {
+      self.staticPressure = staticPressure
+      self.heatingCFM = heatingCFM
+      self.coolingCFM = coolingCFM
+    }
+  }
+}
+
+#if DEBUG
+  extension EquipmentInfo {
+    public static let mock = Self(
+      id: UUID(0),
+      projectID: UUID(0),
+      heatingCFM: 1000,
+      coolingCFM: 1000,
+      createdAt: Date(),
+      updatedAt: Date()
+    )
+  }
+#endif

Sources/ManualDCore/Project.swift

@@ -1,3 +1,4 @@
+import Dependencies
 import Foundation
 
 public struct Project: Codable, Equatable, Identifiable, Sendable {
@@ -8,6 +9,7 @@ public struct Project: Codable, Equatable, Identifiable, Sendable {
   public let city: String
   public let state: String
   public let zipCode: String
+  public let sensibleHeatRatio: Double?
   public let createdAt: Date
   public let updatedAt: Date
 
@@ -18,6 +20,7 @@ public struct Project: Codable, Equatable, Identifiable, Sendable {
     city: String,
     state: String,
     zipCode: String,
+    sensibleHeatRatio: Double? = nil,
     createdAt: Date,
     updatedAt: Date
   ) {
@@ -27,6 +30,7 @@ public struct Project: Codable, Equatable, Identifiable, Sendable {
     self.city = city
     self.state = state
     self.zipCode = zipCode
+    self.sensibleHeatRatio = sensibleHeatRatio
     self.createdAt = createdAt
     self.updatedAt = updatedAt
   }
@@ -41,19 +45,85 @@ extension Project {
     public let city: String
     public let state: String
     public let zipCode: String
+    public let sensibleHeatRatio: Double?
 
     public init(
       name: String,
       streetAddress: String,
       city: String,
       state: String,
-      zipCode: String
+      zipCode: String,
+      sensibleHeatRatio: Double? = nil,
     ) {
       self.name = name
       self.streetAddress = streetAddress
       self.city = city
       self.state = state
       self.zipCode = zipCode
+      self.sensibleHeatRatio = sensibleHeatRatio
+    }
+  }
+
+  public struct CompletedSteps: Codable, Equatable, Sendable {
+
+    public let equipmentInfo: Bool
+    public let rooms: Bool
+    public let equivalentLength: Bool
+    public let frictionRate: Bool
+
+    public init(
+      equipmentInfo: Bool,
+      rooms: Bool,
+      equivalentLength: Bool,
+      frictionRate: Bool
+    ) {
+      self.equipmentInfo = equipmentInfo
+      self.rooms = rooms
+      self.equivalentLength = equivalentLength
+      self.frictionRate = frictionRate
+    }
+  }
+
+  public struct Update: Codable, Equatable, Sendable {
+
+    public let name: String?
+    public let streetAddress: String?
+    public let city: String?
+    public let state: String?
+    public let zipCode: String?
+    public let sensibleHeatRatio: Double?
+
+    public init(
+      name: String? = nil,
+      streetAddress: String? = nil,
+      city: String? = nil,
+      state: String? = nil,
+      zipCode: String? = nil,
+      sensibleHeatRatio: Double? = nil
+    ) {
+      self.name = name
+      self.streetAddress = streetAddress
+      self.city = city
+      self.state = state
+      self.zipCode = zipCode
+      self.sensibleHeatRatio = sensibleHeatRatio
     }
   }
 }
+
+#if DEBUG
+
+  extension Project {
+    public static let mock = Self(
+      id: UUID(0),
+      name: "Testy McTestface",
+      streetAddress: "1234 Sesame Street",
+      city: "Monroe",
+      state: "OH",
+      zipCode: "55555",
+      createdAt: Date(),
+      updatedAt: Date()
+    )
+  }
+
+#endif

Sources/ManualDCore/Room.swift

@@ -1,20 +1,159 @@
+import Dependencies
 import Foundation
 
-public struct Room: Codable, Equatable, Sendable {
+public struct Room: Codable, Equatable, Identifiable, Sendable {
+  public let id: UUID
+  public let projectID: Project.ID
   public let name: String
   public let heatingLoad: Double
-  public let coolingLoad: CoolingLoad
+  public let coolingTotal: Double
+  public let coolingSensible: Double?
   public let registerCount: Int
+  public let rectangularSizes: [DuctSizing.RectangularDuct]?
+  public let createdAt: Date
+  public let updatedAt: Date
 
   public init(
+    id: UUID,
+    projectID: Project.ID,
     name: String,
     heatingLoad: Double,
-    coolingLoad: CoolingLoad,
-    registerCount: Int = 1
+    coolingTotal: Double,
+    coolingSensible: Double? = nil,
+    registerCount: Int = 1,
+    rectangularSizes: [DuctSizing.RectangularDuct]? = nil,
+    createdAt: Date,
+    updatedAt: Date
   ) {
+    self.id = id
+    self.projectID = projectID
     self.name = name
     self.heatingLoad = heatingLoad
-    self.coolingLoad = coolingLoad
+    self.coolingTotal = coolingTotal
+    self.coolingSensible = coolingSensible
     self.registerCount = registerCount
+    self.rectangularSizes = rectangularSizes
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
   }
 }
+
+extension Room {
+
+  public struct Create: Codable, Equatable, Sendable {
+    public let projectID: Project.ID
+    public let name: String
+    public let heatingLoad: Double
+    public let coolingTotal: Double
+    public let coolingSensible: Double?
+    public let registerCount: Int
+
+    public init(
+      projectID: Project.ID,
+      name: String,
+      heatingLoad: Double,
+      coolingTotal: Double,
+      coolingSensible: Double? = nil,
+      registerCount: Int = 1
+    ) {
+      self.projectID = projectID
+      self.name = name
+      self.heatingLoad = heatingLoad
+      self.coolingTotal = coolingTotal
+      self.coolingSensible = coolingSensible
+      self.registerCount = registerCount
+    }
+  }
+
+  public struct Update: Codable, Equatable, Sendable {
+    public let name: String?
+    public let heatingLoad: Double?
+    public let coolingTotal: Double?
+    public let coolingSensible: Double?
+    public let registerCount: Int?
+    public let rectangularSizes: [DuctSizing.RectangularDuct]?
+
+    public init(
+      name: String? = nil,
+      heatingLoad: Double? = nil,
+      coolingTotal: Double? = nil,
+      coolingSensible: Double? = nil,
+      registerCount: Int? = nil
+    ) {
+      self.name = name
+      self.heatingLoad = heatingLoad
+      self.coolingTotal = coolingTotal
+      self.coolingSensible = coolingSensible
+      self.registerCount = registerCount
+      self.rectangularSizes = nil
+    }
+
+    public init(
+      rectangularSizes: [DuctSizing.RectangularDuct]
+    ) {
+      self.name = nil
+      self.heatingLoad = nil
+      self.coolingTotal = nil
+      self.coolingSensible = nil
+      self.registerCount = nil
+      self.rectangularSizes = rectangularSizes
+    }
+  }
+}
+
+extension Array where Element == Room {
+
+  public var totalHeatingLoad: Double {
+    reduce(into: 0) { $0 += $1.heatingLoad }
+  }
+
+  public var totalCoolingLoad: Double {
+    reduce(into: 0) { $0 += $1.coolingTotal }
+  }
+
+  public func totalCoolingSensible(shr: Double) -> Double {
+    reduce(into: 0) {
+      let sensible = $1.coolingSensible ?? ($1.coolingTotal * shr)
+      $0 += sensible
+    }
+  }
+}
+
+#if DEBUG
+
+  extension Room {
+    public static let mocks = [
+      Room(
+        id: UUID(0),
+        projectID: UUID(0),
+        name: "Kitchen",
+        heatingLoad: 12345,
+        coolingTotal: 1234,
+        registerCount: 2,
+        createdAt: Date(),
+        updatedAt: Date()
+      ),
+      Room(
+        id: UUID(1),
+        projectID: UUID(1),
+        name: "Bedroom - 1",
+        heatingLoad: 12345,
+        coolingTotal: 1456,
+        registerCount: 1,
+        createdAt: Date(),
+        updatedAt: Date()
+      ),
+      Room(
+        id: UUID(2),
+        projectID: UUID(2),
+        name: "Family Room",
+        heatingLoad: 12345,
+        coolingTotal: 1673,
+        registerCount: 3,
+        createdAt: Date(),
+        updatedAt: Date()
+      ),
+    ]
+  }
+
+#endif

Sources/ManualDCore/Routes/ApiRoute.swift

@@ -9,6 +9,9 @@ extension SiteRoute {
   public enum Api: Sendable, Equatable {
 
     case project(Self.ProjectRoute)
+    case room(Self.RoomRoute)
+    case equipment(Self.EquipmentRoute)
+    case componentLoss(Self.ComponentLossRoute)
 
     public static let rootPath = Path {
       "api"
@@ -20,6 +23,18 @@ extension SiteRoute {
         rootPath
         ProjectRoute.router
       }
+      Route(.case(Self.room)) {
+        rootPath
+        RoomRoute.router
+      }
+      Route(.case(Self.equipment)) {
+        rootPath
+        EquipmentRoute.router
+      }
+      Route(.case(Self.componentLoss)) {
+        rootPath
+        ComponentLossRoute.router
+      }
     }
 
   }
@@ -30,6 +45,7 @@ extension SiteRoute.Api {
   public enum ProjectRoute: Sendable, Equatable {
     case create(Project.Create)
     case delete(id: Project.ID)
+    case detail(id: Project.ID, route: DetailRoute)
     case get(id: Project.ID)
     case index
 
@@ -59,7 +75,191 @@ extension SiteRoute.Api {
         Path { rootPath }
         Method.get
       }
+      Route(.case(Self.detail(id:route:))) {
+        Path {
+          rootPath
+          Project.ID.parser()
+        }
+        DetailRoute.router
+      }
+    }
+  }
+}
+
+extension SiteRoute.Api.ProjectRoute {
+  public enum DetailRoute: Equatable, Sendable {
+    case completedSteps
+
+    static let rootPath = "details"
+
+    static let router = OneOf {
+      Route(.case(Self.completedSteps)) {
+        Path {
+          rootPath
+          "completed"
+        }
+        Method.get
+      }
+    }
+  }
+}
+
+extension SiteRoute.Api {
+
+  public enum RoomRoute: Sendable, Equatable {
+    case create(Room.Create)
+    case delete(id: Room.ID)
+    case get(id: Room.ID)
+
+    static let rootPath = "rooms"
+
+    public static let router = OneOf {
+      Route(.case(Self.create)) {
+        Path { rootPath }
+        Method.post
+        Body(.json(Room.Create.self))
+      }
+      Route(.case(Self.delete(id:))) {
+        Path {
+          rootPath
+          Room.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.get(id:))) {
+        Path {
+          rootPath
+          Room.ID.parser()
+        }
+        Method.get
+      }
+    }
+  }
+}
+
+extension SiteRoute.Api {
+
+  public enum EquipmentRoute: Sendable, Equatable {
+    case create(EquipmentInfo.Create)
+    case delete(id: EquipmentInfo.ID)
+    case fetch(projectID: Project.ID)
+    case get(id: EquipmentInfo.ID)
+
+    static let rootPath = "equipment"
+
+    public static let router = OneOf {
+      Route(.case(Self.create)) {
+        Path { rootPath }
+        Method.post
+        Body(.json(EquipmentInfo.Create.self))
+      }
+      Route(.case(Self.delete(id:))) {
+        Path {
+          rootPath
+          EquipmentInfo.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.fetch(projectID:))) {
+        Path { rootPath }
+        Method.get
+        Query {
+          Field("projectID") { Project.ID.parser() }
+        }
+      }
+      Route(.case(Self.get(id:))) {
+        Path {
+          rootPath
+          EquipmentInfo.ID.parser()
+        }
+        Method.get
+      }
+    }
+  }
+}
+
+extension SiteRoute.Api {
+
+  public enum ComponentLossRoute: Sendable, Equatable {
+    case create(ComponentPressureLoss.Create)
+    case delete(id: ComponentPressureLoss.ID)
+    case fetch(projectID: Project.ID)
+    case get(id: ComponentPressureLoss.ID)
+
+    static let rootPath = "componentLoss"
+
+    public static let router = OneOf {
+      Route(.case(Self.create)) {
+        Path { rootPath }
+        Method.post
+        Body(.json(ComponentPressureLoss.Create.self))
+      }
+      Route(.case(Self.delete(id:))) {
+        Path {
+          rootPath
+          ComponentPressureLoss.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.fetch(projectID:))) {
+        Path { rootPath }
+        Method.get
+        Query {
+          Field("projectID") { Project.ID.parser() }
+        }
+      }
+      Route(.case(Self.get(id:))) {
+        Path {
+          rootPath
+          ComponentPressureLoss.ID.parser()
+        }
+        Method.get
+      }
+    }
+  }
+}
+
+extension SiteRoute.Api {
+  public enum EffectiveLengthRoute: Equatable, Sendable {
+    case create(EffectiveLength.Create)
+    case delete(id: EffectiveLength.ID)
+    case fetch(projectID: Project.ID)
+    case get(id: EffectiveLength.ID)
+
+    static let rootPath = "effectiveLength"
+
+    public static let router = OneOf {
+      Route(.case(Self.create)) {
+        Path {
+          rootPath
+          "create"
+        }
+        Method.post
+        Body(.json(EffectiveLength.Create.self))
+      }
+      Route(.case(Self.delete(id:))) {
+        Path {
+          rootPath
+          EffectiveLength.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.fetch(projectID:))) {
+        Path {
+          rootPath
+        }
+        Method.get
+        Query {
+          Field("projectID") { Project.ID.parser() }
+        }
+      }
+      Route(.case(Self.get(id:))) {
+        Path {
+          rootPath
+          EffectiveLength.ID.parser()
+        }
+        Method.get
+      }
     }
   }
-
 }

Sources/ManualDCore/Routes/SiteRoute.swift

@@ -1,14 +1,24 @@
 import CasePathsCore
+import FluentKit
 import Foundation
 @preconcurrency import URLRouting
 
 public enum SiteRoute: Equatable, Sendable {
 
   case api(Self.Api)
+  case health
+  case view(Self.View)
 
   public static let router = OneOf {
     Route(.case(Self.api)) {
       SiteRoute.Api.router
     }
+    Route(.case(Self.health)) {
+      Path { "health" }
+      Method.get
+    }
+    Route(.case(Self.view)) {
+      SiteRoute.View.router
+    }
   }
 }

Sources/ManualDCore/Routes/ViewRoute.swift

@@ -1,4 +1,5 @@
 import CasePathsCore
+import FluentKit
 import Foundation
 @preconcurrency import URLRouting
 
@@ -6,7 +7,925 @@ extension SiteRoute {
   /// Represents view routes.
   ///
   /// The routes return html.
-  public enum View {
+  public enum View: Equatable, Sendable {
+    case login(LoginRoute)
+    case signup(SignupRoute)
+    case project(ProjectRoute)
+    case user(UserRoute)
+    //FIX: Remove.
+    case test
 
+    public static let router = OneOf {
+      Route(.case(Self.test)) {
+        Path { "test" }
+        Method.get
+      }
+      Route(.case(Self.login)) {
+        SiteRoute.View.LoginRoute.router
+      }
+      Route(.case(Self.signup)) {
+        SiteRoute.View.SignupRoute.router
+      }
+      Route(.case(Self.project)) {
+        SiteRoute.View.ProjectRoute.router
+      }
+      Route(.case(Self.user)) {
+        SiteRoute.View.UserRoute.router
+      }
+    }
+  }
+}
+
+extension SiteRoute.View {
+  public enum ProjectRoute: Equatable, Sendable {
+    case create(Project.Create)
+    case delete(id: Project.ID)
+    case detail(Project.ID, DetailRoute)
+    case index
+    case page(PageRequest)
+    case update(Project.ID, Project.Update)
+
+    public static func page(page: Int, per limit: Int) -> Self {
+      .page(.init(page: page, per: limit))
+    }
+
+    static let rootPath = "projects"
+
+    public static let router = OneOf {
+      Route(.case(Self.create)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("name", .string)
+            Field("streetAddress", .string)
+            Field("city", .string)
+            Field("state", .string)
+            Field("zipCode", .string)
+            Optionally {
+              Field("sensibleHeatRatio", default: nil) {
+                Double.parser()
+              }
+            }
+          }
+          .map(.memberwise(Project.Create.init))
+        }
+      }
+      Route(.case(Self.delete)) {
+        Path {
+          rootPath
+          Project.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.detail)) {
+        Path {
+          rootPath
+          Project.ID.parser()
+        }
+        DetailRoute.router
+      }
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.page)) {
+        Path {
+          rootPath
+          "page"
+        }
+        Method.get
+        Query {
+          Field("page", default: 1) { Int.parser() }
+          Field("per", default: 25) { Int.parser() }
+        }
+        .map(.memberwise(PageRequest.init))
+      }
+      Route(.case(Self.update)) {
+        Path {
+          rootPath
+          Project.ID.parser()
+        }
+        Method.patch
+        Body {
+          FormData {
+            Optionally {
+              Field("name", .string)
+            }
+            Optionally {
+              Field("streetAddress", .string)
+            }
+            Optionally {
+              Field("city", .string)
+            }
+            Optionally {
+              Field("state", .string)
+            }
+            Optionally {
+              Field("zipCode", .string)
+            }
+            Optionally {
+              Field("sensibleHeatRatio", default: nil) {
+                Double.parser()
+              }
+            }
+          }
+          .map(.memberwise(Project.Update.init))
+        }
+      }
+    }
+  }
+}
+
+extension SiteRoute.View.ProjectRoute {
+
+  public enum DetailRoute: Equatable, Sendable {
+    case index
+    case componentLoss(ComponentLossRoute)
+    case ductSizing(DuctSizingRoute)
+    case equipment(EquipmentInfoRoute)
+    case equivalentLength(EquivalentLengthRoute)
+    case frictionRate(FrictionRateRoute)
+    case rooms(RoomRoute)
+
+    static let router = OneOf {
+      Route(.case(Self.index)) {
+        Method.get
+      }
+      Route(.case(Self.componentLoss)) {
+        ComponentLossRoute.router
+      }
+      Route(.case(Self.ductSizing)) {
+        DuctSizingRoute.router
+      }
+      Route(.case(Self.equipment)) {
+        EquipmentInfoRoute.router
+      }
+      Route(.case(Self.equivalentLength)) {
+        EquivalentLengthRoute.router
+      }
+      Route(.case(Self.frictionRate)) {
+        FrictionRateRoute.router
+      }
+      Route(.case(Self.rooms)) {
+        RoomRoute.router
+      }
+    }
+
+    public enum Tab: String, CaseIterable, Equatable, Sendable {
+      case project
+      case equipment
+      case rooms
+      case equivalentLength
+      case frictionRate
+      case ductSizing
+    }
+  }
+
+  public enum RoomRoute: Equatable, Sendable {
+    case delete(id: Room.ID)
+    case index
+    case submit(Room.Create)
+    case update(Room.ID, Room.Update)
+    case updateSensibleHeatRatio(SHRUpdate)
+
+    static let rootPath = "rooms"
+
+    public static let router = OneOf {
+      Route(.case(Self.delete)) {
+        Path {
+          rootPath
+          Room.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.index)) {
+        Path {
+          rootPath
+        }
+        Method.get
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("projectID") { Project.ID.parser() }
+            Field("name", .string)
+            Field("heatingLoad") { Double.parser() }
+            Field("coolingTotal") { Double.parser() }
+            Optionally {
+              Field("coolingSensible", default: nil) { Double.parser() }
+            }
+            Field("registerCount") { Digits() }
+          }
+          .map(.memberwise(Room.Create.init))
+        }
+      }
+      Route(.case(Self.update)) {
+        Path {
+          rootPath
+          Room.ID.parser()
+        }
+        Method.patch
+        Body {
+          FormData {
+            Optionally {
+              Field("name", .string)
+            }
+            Optionally {
+              Field("heatingLoad") { Double.parser() }
+            }
+            Optionally {
+              Field("coolingTotal") { Double.parser() }
+            }
+            Optionally {
+              Field("coolingSensible") { Double.parser() }
+            }
+            Optionally {
+              Field("registerCount") { Digits() }
+            }
+          }
+          .map(.memberwise(Room.Update.init))
+        }
+      }
+      Route(.case(Self.updateSensibleHeatRatio)) {
+        Path {
+          rootPath
+          "update-shr"
+        }
+        Method.patch
+        Body {
+          FormData {
+            Field("projectID") { Project.ID.parser() }
+            Optionally {
+              Field("sensibleHeatRatio") { Double.parser() }
+            }
+          }
+          .map(.memberwise(SHRUpdate.init))
+        }
+      }
+    }
+
+    public struct SHRUpdate: Codable, Equatable, Sendable {
+      public let projectID: Project.ID
+      public let sensibleHeatRatio: Double?
+    }
+  }
+
+  public enum ComponentLossRoute: Equatable, Sendable {
+    case index
+    case delete(ComponentPressureLoss.ID)
+    case submit(ComponentPressureLoss.Create)
+    case update(ComponentPressureLoss.ID, ComponentPressureLoss.Update)
+
+    static let rootPath = "component-loss"
+
+    static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.delete)) {
+        Path {
+          rootPath
+          ComponentPressureLoss.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("projectID") { Project.ID.parser() }
+            Field("name", .string)
+            Field("value") { Double.parser() }
+          }
+          .map(.memberwise(ComponentPressureLoss.Create.init))
+        }
+      }
+      Route(.case(Self.update)) {
+        Path {
+          rootPath
+          ComponentPressureLoss.ID.parser()
+        }
+        Method.patch
+        Body {
+          FormData {
+            Optionally {
+              Field("name", .string)
+            }
+            Optionally {
+              Field("value") { Double.parser() }
+            }
+          }
+          .map(.memberwise(ComponentPressureLoss.Update.init))
+        }
+      }
+    }
+  }
+
+  public enum FrictionRateRoute: Equatable, Sendable {
+    case index
+
+    static let rootPath = "friction-rate"
+
+    public static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+    }
+  }
+
+  public enum EquipmentInfoRoute: Equatable, Sendable {
+    case index
+    case submit(EquipmentInfo.Create)
+    case update(EquipmentInfo.ID, EquipmentInfo.Update)
+
+    static let rootPath = "equipment"
+
+    public static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("projectID") { Project.ID.parser() }
+            Field("staticPressure") { Double.parser() }
+            Field("heatingCFM") { Int.parser() }
+            Field("coolingCFM") { Int.parser() }
+          }
+          .map(.memberwise(EquipmentInfo.Create.init))
+        }
+      }
+      Route(.case(Self.update)) {
+        Path {
+          rootPath
+          EquipmentInfo.ID.parser()
+        }
+        Method.patch
+        Body {
+          FormData {
+            Optionally {
+              Field("staticPressure", default: nil) { Double.parser() }
+            }
+            Optionally {
+              Field("heatingCFM", default: nil) { Int.parser() }
+            }
+            Optionally {
+              Field("coolingCFM", default: nil) { Int.parser() }
+            }
+          }
+          .map(.memberwise(EquipmentInfo.Update.init))
+        }
+      }
+    }
+  }
+
+  public enum EquivalentLengthRoute: Equatable, Sendable {
+    case delete(id: EffectiveLength.ID)
+    case field(FieldType, style: EffectiveLength.EffectiveLengthType? = nil)
+    case index
+    case submit(FormStep)
+    case update(EffectiveLength.ID, StepThree)
+
+    static let rootPath = "effective-lengths"
+
+    public static let router = OneOf {
+      Route(.case(Self.delete(id:))) {
+        Path {
+          rootPath
+          EffectiveLength.ID.parser()
+        }
+        Method.delete
+      }
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.field)) {
+        Path {
+          rootPath
+          "field"
+        }
+        Method.get
+        Query {
+          Field("type") { FieldType.parser() }
+          Optionally {
+            Field("style", default: nil) {
+              EffectiveLength.EffectiveLengthType.parser()
+            }
+          }
+        }
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        FormStep.router
+      }
+      Route(.case(Self.update)) {
+        Path {
+          rootPath
+          EffectiveLength.ID.parser()
+        }
+        Method.patch
+        Body {
+          FormData {
+            Optionally {
+              Field("id", default: nil) { EffectiveLength.ID.parser() }
+            }
+            Field("name", .string)
+            Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+            Many {
+              Field("straightLengths") {
+                Int.parser()
+              }
+            }
+            Many {
+              Field("group[group]") {
+                Int.parser()
+              }
+            }
+            Many {
+              Field("group[letter]", .string)
+            }
+            Many {
+              Field("group[length]") {
+                Int.parser()
+              }
+
+            }
+            Many {
+              Field("group[quantity]") {
+                Int.parser()
+              }
+            }
+          }
+          .map(.memberwise(StepThree.init))
+        }
+      }
+    }
+
+    public enum FormStep: Equatable, Sendable {
+      case one(StepOne)
+      case two(StepTwo)
+      case three(StepThree)
+
+      static let router = OneOf {
+        Route(.case(Self.one)) {
+          Path {
+            Key.stepOne.rawValue
+          }
+          Body {
+            FormData {
+              Optionally {
+                Field("id", default: nil) { EffectiveLength.ID.parser() }
+              }
+              Field("name", .string)
+              Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+            }
+            .map(.memberwise(StepOne.init))
+          }
+        }
+        Route(.case(Self.two)) {
+          Path {
+            Key.stepTwo.rawValue
+          }
+          Body {
+            FormData {
+              Optionally {
+                Field("id", default: nil) { EffectiveLength.ID.parser() }
+              }
+              Field("name", .string)
+              Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+              Many {
+                Field("straightLengths") {
+                  Int.parser()
+                }
+              }
+            }
+            .map(.memberwise(StepTwo.init))
+          }
+        }
+        Route(.case(Self.three)) {
+          Path {
+            Key.stepThree.rawValue
+          }
+          Body {
+            FormData {
+              Optionally {
+                Field("id", default: nil) { EffectiveLength.ID.parser() }
+              }
+              Field("name", .string)
+              Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+              Many {
+                Field("straightLengths") {
+                  Int.parser()
+                }
+              }
+              Many {
+                Field("group[group]") {
+                  Int.parser()
+                }
+              }
+              Many {
+                Field("group[letter]", .string)
+              }
+              Many {
+                Field("group[length]") {
+                  Int.parser()
+                }
+
+              }
+              Many {
+                Field("group[quantity]") {
+                  Int.parser()
+                }
+              }
+            }
+            .map(.memberwise(StepThree.init))
+          }
+        }
+      }
+
+      public enum Key: String, CaseIterable, Codable, Equatable, Sendable {
+        case stepOne
+        case stepTwo
+        case stepThree
+      }
+    }
+
+    public struct StepOne: Codable, Equatable, Sendable {
+      public let id: EffectiveLength.ID?
+      public let name: String
+      public let type: EffectiveLength.EffectiveLengthType
+    }
+
+    public struct StepTwo: Codable, Equatable, Sendable {
+
+      public let id: EffectiveLength.ID?
+      public let name: String
+      public let type: EffectiveLength.EffectiveLengthType
+      public let straightLengths: [Int]
+
+      public init(
+        id: EffectiveLength.ID? = nil,
+        name: String,
+        type: EffectiveLength.EffectiveLengthType,
+        straightLengths: [Int]
+      ) {
+        self.id = id
+        self.name = name
+        self.type = type
+        self.straightLengths = straightLengths
+      }
+    }
+
+    public struct StepThree: Codable, Equatable, Sendable {
+      public let id: EffectiveLength.ID?
+      public let name: String
+      public let type: EffectiveLength.EffectiveLengthType
+      public let straightLengths: [Int]
+      public let groupGroups: [Int]
+      public let groupLetters: [String]
+      public let groupLengths: [Int]
+      public let groupQuantities: [Int]
+    }
+
+    public enum FieldType: String, CaseIterable, Equatable, Sendable {
+      case straightLength
+      case group
+    }
+
+  }
+
+  public enum DuctSizingRoute: Equatable, Sendable {
+    case index
+    case deleteRectangularSize(Room.ID, DeleteRectangularDuct)
+    case roomRectangularForm(Room.ID, RoomRectangularForm)
+    case trunk(TrunkRoute)
+
+    public static let roomPath = "room"
+    static let rootPath = "duct-sizing"
+
+    static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.deleteRectangularSize)) {
+        Path {
+          rootPath
+          roomPath
+          Room.ID.parser()
+        }
+        Method.delete
+        Query {
+          Field("rectangularSize") { DuctSizing.RectangularDuct.ID.parser() }
+          Field("register") { Int.parser() }
+        }
+        .map(.memberwise(DeleteRectangularDuct.init))
+      }
+      Route(.case(Self.roomRectangularForm)) {
+        Path {
+          rootPath
+          roomPath
+          Room.ID.parser()
+        }
+        Method.post
+        Body {
+          FormData {
+            Optionally {
+              Field("id") { DuctSizing.RectangularDuct.ID.parser() }
+            }
+            Field("register") { Int.parser() }
+            Field("height") { Int.parser() }
+          }
+          .map(.memberwise(RoomRectangularForm.init))
+        }
+      }
+      Route(.case(Self.trunk)) {
+        Path { rootPath }
+        TrunkRoute.router
+      }
+    }
+
+    public struct DeleteRectangularDuct: Equatable, Sendable {
+
+      public let rectangularSizeID: DuctSizing.RectangularDuct.ID
+      public let register: Int
+
+      public init(rectangularSizeID: DuctSizing.RectangularDuct.ID, register: Int) {
+        self.rectangularSizeID = rectangularSizeID
+        self.register = register
+      }
+    }
+
+    public enum TrunkRoute: Equatable, Sendable {
+      case delete(DuctSizing.TrunkSize.ID)
+      case submit(TrunkSizeForm)
+      case update(DuctSizing.TrunkSize.ID, TrunkSizeForm)
+
+      public static let rootPath = "trunk"
+
+      static let router = OneOf {
+        Route(.case(Self.delete)) {
+          Path {
+            rootPath
+            DuctSizing.TrunkSize.ID.parser()
+          }
+          Method.delete
+        }
+        Route(.case(Self.submit)) {
+          Path {
+            rootPath
+          }
+          Method.post
+          Body {
+            FormData {
+              Field("projectID") { Project.ID.parser() }
+              Field("type") { DuctSizing.TrunkSize.TrunkType.parser() }
+              Optionally {
+                Field("height") { Int.parser() }
+
+              }
+              Optionally {
+                Field("name", .string)
+              }
+              Many {
+                Field("rooms", .string)
+              }
+            }
+            .map(.memberwise(TrunkSizeForm.init))
+          }
+        }
+        Route(.case(Self.update)) {
+          Path {
+            rootPath
+            DuctSizing.TrunkSize.ID.parser()
+          }
+          Method.patch
+          Body {
+            FormData {
+              Field("projectID") { Project.ID.parser() }
+              Field("type") { DuctSizing.TrunkSize.TrunkType.parser() }
+              Optionally {
+                Field("height") { Int.parser() }
+              }
+              Optionally {
+                Field("name", .string)
+              }
+              Many {
+                Field("rooms", .string)
+              }
+            }
+            .map(.memberwise(TrunkSizeForm.init))
+          }
+        }
+      }
+    }
+
+    public struct RoomRectangularForm: Equatable, Sendable {
+      public let id: DuctSizing.RectangularDuct.ID?
+      public let register: Int
+      public let height: Int
+    }
+
+    public struct TrunkSizeForm: Equatable, Sendable {
+      public let projectID: Project.ID
+      public let type: DuctSizing.TrunkSize.TrunkType
+      public let height: Int?
+      public let name: String?
+      public let rooms: [String]
+    }
+  }
+}
+
+extension SiteRoute.View {
+
+  public enum LoginRoute: Equatable, Sendable {
+    case index(next: String? = nil)
+    case submit(User.Login)
+
+    static let rootPath = "login"
+
+    public static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+        Query {
+          Optionally {
+            Field("next", .string, default: nil)
+            // {
+            //   CharacterSet.map(.string)
+            // }
+          }
+        }
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("email", .string)
+            Field("password", .string)
+            Optionally {
+              Field("next", .string, default: nil)
+            }
+          }
+          .map(.memberwise(User.Login.init))
+        }
+      }
+    }
+  }
+}
+
+extension SiteRoute.View {
+
+  public enum SignupRoute: Equatable, Sendable {
+    case index
+    case submit(User.Create)
+    case submitProfile(User.Profile.Create)
+
+    static let rootPath = "signup"
+
+    public static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("email", .string)
+            Field("password", .string)
+            Field("confirmPassword", .string)
+          }
+          .map(.memberwise(User.Create.init))
+        }
+      }
+      Route(.case(Self.submitProfile)) {
+        Path {
+          rootPath
+          "profile"
+        }
+        Method.post
+        Body {
+          FormData {
+            Field("userID") { User.ID.parser() }
+            Field("firstName", .string)
+            Field("lastName", .string)
+            Field("companyName", .string)
+            Field("streetAddress", .string)
+            Field("city", .string)
+            Field("state", .string)
+            Field("zipCode", .string)
+            Optionally {
+              Field("theme") { Theme.parser() }
+            }
+          }
+          .map(.memberwise(User.Profile.Create.init))
+        }
+      }
+    }
+  }
+}
+
+extension SiteRoute.View {
+  public enum UserRoute: Equatable, Sendable {
+    case profile(Profile)
+
+    static let router = OneOf {
+      Route(.case(Self.profile)) {
+        Profile.router
+      }
+    }
+  }
+}
+
+extension SiteRoute.View.UserRoute {
+  public enum Profile: Equatable, Sendable {
+    case index
+    case submit(User.Profile.Create)
+    case update(User.Profile.ID, User.Profile.Update)
+
+    static let rootPath = "profile"
+
+    static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("userID") { User.ID.parser() }
+            Field("firstName", .string)
+            Field("lastName", .string)
+            Field("companyName", .string)
+            Field("streetAddress", .string)
+            Field("city", .string)
+            Field("state", .string)
+            Field("zipCode", .string)
+            Optionally {
+              Field("theme") { Theme.parser() }
+            }
+          }
+          .map(.memberwise(User.Profile.Create.init))
+        }
+      }
+      Route(.case(Self.update)) {
+        Path {
+          rootPath
+          User.Profile.ID.parser()
+        }
+        Method.patch
+        Body {
+          FormData {
+            Optionally {
+              Field("firstName", .string)
+            }
+            Optionally {
+              Field("lastName", .string)
+            }
+            Optionally {
+              Field("companyName", .string)
+            }
+            Optionally {
+              Field("streetAddress", .string)
+            }
+            Optionally {
+              Field("city", .string)
+            }
+            Optionally {
+              Field("state", .string)
+            }
+            Optionally {
+              Field("zipCode", .string)
+            }
+            Optionally {
+              Field("theme") { Theme.parser() }
+            }
+          }
+          .map(.memberwise(User.Profile.Update.init))
+        }
+      }
+    }
+  }
+}
+
+extension PageRequest: @retroactive Equatable {
+  public static func == (lhs: FluentKit.PageRequest, rhs: FluentKit.PageRequest) -> Bool {
+    lhs.page == rhs.page && lhs.per == rhs.per
   }
 }

Sources/ManualDCore/Theme.swift

@@ -0,0 +1,31 @@
+import Foundation
+
+public enum Theme: String, CaseIterable, Codable, Equatable, Sendable {
+  case aqua
+  case cupcake
+  case cyberpunk
+  case dark
+  case `default`
+  case dracula
+  case light
+  case night
+  case nord
+  case retro
+  case synthwave
+
+  public static let darkThemes = [
+    Self.aqua,
+    Self.cyberpunk,
+    Self.dark,
+    Self.dracula,
+    Self.night,
+    Self.synthwave,
+  ]
+
+  public static let lightThemes = [
+    Self.cupcake,
+    Self.light,
+    Self.nord,
+    Self.retro,
+  ]
+}

Sources/ManualDCore/User.swift

@@ -0,0 +1,67 @@
+import Dependencies
+import Foundation
+
+// FIX: Remove username.
+public struct User: Codable, Equatable, Identifiable, Sendable {
+
+  public let id: UUID
+  public let email: String
+  public let createdAt: Date
+  public let updatedAt: Date
+
+  public init(
+    id: UUID,
+    email: String,
+    createdAt: Date,
+    updatedAt: Date
+  ) {
+    self.id = id
+    self.email = email
+    self.createdAt = createdAt
+    self.updatedAt = updatedAt
+  }
+}
+
+extension User {
+  public struct Create: Codable, Equatable, Sendable {
+
+    public let email: String
+    public let password: String
+    public let confirmPassword: String
+
+    public init(
+      email: String,
+      password: String,
+      confirmPassword: String
+    ) {
+      self.email = email
+      self.password = password
+      self.confirmPassword = confirmPassword
+    }
+  }
+
+  public struct Login: Codable, Equatable, Sendable {
+    public let email: String
+    public let password: String
+    public let next: String?
+
+    public init(email: String, password: String, next: String? = nil) {
+      self.email = email
+      self.password = password
+      self.next = next
+    }
+  }
+
+  public struct Token: Codable, Equatable, Identifiable, Sendable {
+
+    public let id: UUID
+    public let userID: User.ID
+    public let value: String
+
+    public init(id: UUID, userID: User.ID, value: String) {
+      self.id = id
+      self.userID = userID
+      self.value = value
+    }
+  }
+}

Sources/ManualDCore/UserProfile.swift

@@ -0,0 +1,115 @@
+import Foundation
+
+extension User {
+  public struct Profile: Codable, Equatable, Identifiable, Sendable {
+
+    public let id: UUID
+    public let userID: User.ID
+    public let firstName: String
+    public let lastName: String
+    public let companyName: String
+    public let streetAddress: String
+    public let city: String
+    public let state: String
+    public let zipCode: String
+    public let theme: Theme?
+    public let createdAt: Date
+    public let updatedAt: Date
+
+    public init(
+      id: UUID,
+      userID: User.ID,
+      firstName: String,
+      lastName: String,
+      companyName: String,
+      streetAddress: String,
+      city: String,
+      state: String,
+      zipCode: String,
+      theme: Theme? = nil,
+      createdAt: Date,
+      updatedAt: Date
+    ) {
+      self.id = id
+      self.userID = userID
+      self.firstName = firstName
+      self.lastName = lastName
+      self.companyName = companyName
+      self.streetAddress = streetAddress
+      self.city = city
+      self.state = state
+      self.zipCode = zipCode
+      self.theme = theme
+      self.createdAt = createdAt
+      self.updatedAt = updatedAt
+    }
+  }
+}
+
+extension User.Profile {
+
+  public struct Create: Codable, Equatable, Sendable {
+    public let userID: User.ID
+    public let firstName: String
+    public let lastName: String
+    public let companyName: String
+    public let streetAddress: String
+    public let city: String
+    public let state: String
+    public let zipCode: String
+    public let theme: Theme?
+
+    public init(
+      userID: User.ID,
+      firstName: String,
+      lastName: String,
+      companyName: String,
+      streetAddress: String,
+      city: String,
+      state: String,
+      zipCode: String,
+      theme: Theme? = nil
+    ) {
+      self.userID = userID
+      self.firstName = firstName
+      self.lastName = lastName
+      self.companyName = companyName
+      self.streetAddress = streetAddress
+      self.city = city
+      self.state = state
+      self.zipCode = zipCode
+      self.theme = theme
+    }
+  }
+
+  public struct Update: Codable, Equatable, Sendable {
+    public let firstName: String?
+    public let lastName: String?
+    public let companyName: String?
+    public let streetAddress: String?
+    public let city: String?
+    public let state: String?
+    public let zipCode: String?
+    public let theme: Theme?
+
+    public init(
+      firstName: String? = nil,
+      lastName: String? = nil,
+      companyName: String? = nil,
+      streetAddress: String? = nil,
+      city: String? = nil,
+      state: String? = nil,
+      zipCode: String? = nil,
+      theme: Theme? = nil
+    ) {
+      self.firstName = firstName
+      self.lastName = lastName
+      self.companyName = companyName
+      self.streetAddress = streetAddress
+      self.city = city
+      self.state = state
+      self.zipCode = zipCode
+      self.theme = theme
+    }
+  }
+}

Sources/Styleguide/Alert.swift

@@ -0,0 +1,28 @@
+import Elementary
+
+public struct Alert<Content: HTML>: HTML {
+
+  let inner: Content
+
+  public init(@HTMLBuilder content: () -> Content) {
+    self.inner = content()
+  }
+
+  public var body: some HTML<HTMLTag.div> {
+    div(.class("flex space-x-2")) {
+      SVG(.triangleAlert)
+      inner
+    }
+  }
+}
+
+extension Alert: Sendable where Content: Sendable {}
+
+extension Alert where Content == p<HTMLText> {
+
+  public init(_ description: String) {
+    self.init {
+      p { description }
+    }
+  }
+}

Sources/Styleguide/Badge.swift

@@ -0,0 +1,28 @@
+import Elementary
+
+public struct Badge<Inner: HTML>: HTML, Sendable where Inner: Sendable {
+
+  let inner: Inner
+
+  public init(
+    @HTMLBuilder inner: () -> Inner
+  ) {
+    self.inner = inner()
+  }
+
+  public var body: some HTML<HTMLTag.div> {
+    div(.class("badge badge-lg badge-outline")) {
+      inner
+    }
+  }
+}
+
+extension Badge where Inner == Number {
+  public init(number: Int) {
+    self.inner = Number(number)
+  }
+
+  public init(number: Double, digits: Int = 2) {
+    self.inner = Number(number, digits: digits)
+  }
+}

Sources/Styleguide/Buttons.swift

@@ -0,0 +1,102 @@
+import Elementary
+
+public struct SubmitButton: HTML, Sendable {
+  let title: String
+  let type: HTMLAttribute<HTMLTag.button>.ButtonType
+
+  public init(
+    title: String = "Submit",
+    type: HTMLAttribute<HTMLTag.button>.ButtonType = .submit
+  ) {
+    self.title = title
+    self.type = type
+  }
+
+  public var body: some HTML<HTMLTag.button> {
+    button(
+      .class(
+        """
+        btn btn-secondary
+        """
+      ),
+      .type(type)
+    ) {
+      title
+    }
+  }
+}
+
+public struct CancelButton: HTML, Sendable {
+  let title: String
+  let type: HTMLAttribute<HTMLTag.button>.ButtonType
+
+  public init(
+    title: String = "Cancel",
+    type: HTMLAttribute<HTMLTag.button>.ButtonType = .button
+  ) {
+    self.title = title
+    self.type = type
+  }
+
+  public var body: some HTML<HTMLTag.button> {
+    button(
+      .class(
+        """
+        text-white font-bold text-xl bg-red-500 hover:bg-red-600 px-4 py-2 rounded-lg shadow-lg
+        """
+      ),
+      .type(type)
+    ) {
+      title
+    }
+  }
+}
+
+public struct EditButton: HTML, Sendable {
+  let title: String?
+  let type: HTMLAttribute<HTMLTag.button>.ButtonType
+
+  public init(
+    title: String? = nil,
+    type: HTMLAttribute<HTMLTag.button>.ButtonType = .button
+  ) {
+    self.title = title
+    self.type = type
+  }
+
+  public var body: some HTML<HTMLTag.button> {
+    button(.class("btn"), .type(type)) {
+      div(.class("flex")) {
+        if let title {
+          span(.class("pe-2")) { title }
+        }
+        SVG(.squarePen)
+      }
+    }
+  }
+}
+
+public struct PlusButton: HTML, Sendable {
+
+  public init() {}
+
+  public var body: some HTML<HTMLTag.button> {
+    button(
+      .type(.button),
+      .class("btn")
+    ) { SVG(.circlePlus) }
+  }
+}
+
+public struct TrashButton: HTML, Sendable {
+  public init() {}
+
+  public var body: some HTML<HTMLTag.button> {
+    button(
+      .type(.button),
+      .class("btn btn-error")
+    ) {
+      SVG(.trash)
+    }
+  }
+}

Sources/Styleguide/Date.swift

@@ -0,0 +1,20 @@
+import Elementary
+import Foundation
+
+public struct DateView: HTML, Sendable {
+  let date: Date
+
+  var formatter: DateFormatter {
+    let formatter = DateFormatter()
+    formatter.dateStyle = .short
+    return formatter
+  }
+
+  public init(_ date: Date) {
+    self.date = date
+  }
+
+  public var body: some HTML<HTMLTag.span> {
+    span { formatter.string(from: date) }
+  }
+}

Sources/Styleguide/ElementaryExtensions.swift

@@ -0,0 +1,56 @@
+import Elementary
+import Foundation
+import ManualDCore
+
+extension HTMLAttribute where Tag: HTMLTrait.Attributes.href {
+
+  public static func href(route: SiteRoute.View) -> Self {
+    href(SiteRoute.View.router.path(for: route))
+  }
+}
+
+extension HTMLAttribute where Tag == HTMLTag.form {
+
+  public static func action(route: SiteRoute.View) -> Self {
+    action(SiteRoute.View.router.path(for: route))
+  }
+}
+
+extension HTMLAttribute where Tag == HTMLTag.input {
+
+  public static func value(_ string: String?) -> Self {
+    value(string ?? "")
+  }
+
+  public static func value(_ int: Int?) -> Self {
+    value(int == nil ? "" : "\(int!)")
+  }
+
+  public static func value(_ double: Double?) -> Self {
+    value(double == nil ? "" : "\(double!)")
+  }
+
+  public static func value(_ uuid: UUID?) -> Self {
+    value(uuid?.uuidString ?? "")
+  }
+}
+
+extension HTMLAttribute where Tag == HTMLTag.button {
+  public static func showModal(id: String) -> Self {
+    .on(.click, "\(id).showModal()")
+  }
+}
+
+extension HTML where Tag: HTMLTrait.Attributes.Global {
+  public func badge() -> _AttributedElement<Self> {
+    attributes(.class("badge badge-lg badge-outline"))
+  }
+
+  public func hidden(when shouldHide: Bool) -> _AttributedElement<Self> {
+    attributes(.class("hidden"), when: shouldHide)
+  }
+
+  public func bold(when shouldBeBold: Bool = true) -> _AttributedElement<Self> {
+    attributes(.class("font-bold"), when: shouldBeBold)
+  }
+}

Sources/Styleguide/HTMXExtensions.swift

@@ -0,0 +1,37 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+
+extension HTMLAttribute.hx {
+  @Sendable
+  public static func get(route: SiteRoute.View) -> HTMLAttribute {
+    get(SiteRoute.View.router.path(for: route))
+  }
+
+  @Sendable
+  public static func patch(route: SiteRoute.View) -> HTMLAttribute {
+    patch(SiteRoute.View.router.path(for: route))
+  }
+
+  @Sendable
+  public static func post(route: SiteRoute.View) -> HTMLAttribute {
+    post(SiteRoute.View.router.path(for: route))
+  }
+
+  @Sendable
+  public static func put(route: SiteRoute.View) -> HTMLAttribute {
+    put(SiteRoute.View.router.path(for: route))
+  }
+
+  @Sendable
+  public static func delete(route: SiteRoute.View) -> HTMLAttribute {
+    delete(SiteRoute.View.router.path(for: route))
+  }
+}
+
+extension HTMLAttribute.hx {
+  @Sendable
+  public static func indicator() -> HTMLAttribute {
+    indicator(".hx-indicator")
+  }
+}

Sources/Styleguide/Icon.swift

@@ -0,0 +1,45 @@
+import Elementary
+
+// TODO: Remove, using svg's.
+public struct Icon: HTML, Sendable {
+
+  let icon: String
+
+  public init(icon: String) {
+    self.icon = icon
+  }
+
+  public var body: some HTML {
+    i(.data("lucide", value: icon)) {}
+  }
+}
+
+extension Icon {
+
+  public init(_ icon: Key) {
+    self.init(icon: icon.icon)
+  }
+
+  public enum Key: String {
+
+    case circlePlus
+    case close
+    case doorClosed
+    case mapPin
+    case rulerDimensionLine
+    case squareFunction
+    case wind
+
+    var icon: String {
+      switch self {
+      case .circlePlus: return "circle-plus"
+      case .close: return "x"
+      case .doorClosed: return "door-closed"
+      case .mapPin: return "map-pin"
+      case .rulerDimensionLine: return "ruler-dimension-line"
+      case .squareFunction: return "square-function"
+      case .wind: return rawValue
+      }
+    }
+  }
+}

Sources/Styleguide/Indicator.swift

@@ -0,0 +1,26 @@
+import Elementary
+
+public struct Indicator: HTML, Sendable {
+
+  let size: Size
+
+  public init(size: Size = .lg) {
+    self.size = size
+  }
+
+  public var body: some HTML<HTMLTag.span> {
+    span(.class("loading loading-spinner \(size.class) htmx-indicator")) {}
+  }
+
+  public enum Size: String, Equatable, Sendable {
+    case xs
+    case sm
+    case md
+    case lg
+    case xl
+
+    var `class`: String {
+      "loading-\(rawValue)"
+    }
+  }
+}

Sources/Styleguide/Input.swift

@@ -0,0 +1,117 @@
+import Elementary
+
+public struct LabeledInput: HTML, Sendable {
+
+  let labelText: String
+  let inputAttributes: [HTMLAttribute<HTMLTag.input>]
+
+  public init(
+    _ label: String,
+    _ attributes: HTMLAttribute<HTMLTag.input>...
+  ) {
+    self.labelText = label
+    self.inputAttributes = attributes
+  }
+
+  public var body: some HTML<HTMLTag.label> {
+    label(.class("input w-full")) {
+      span(.class("label")) { labelText }
+      input(attributes: inputAttributes)
+    }
+  }
+}
+
+public struct Input: HTML, Sendable {
+
+  let id: String?
+  let name: String?
+  let placeholder: String
+
+  private var _name: String {
+    guard let name else {
+      return id ?? ""
+    }
+    return name
+  }
+
+  init(
+    id: String? = nil,
+    name: String? = nil,
+    placeholder: String
+  ) {
+    self.id = id
+    self.name = name
+    self.placeholder = placeholder
+  }
+
+  public init(
+    id: String,
+    name: String? = nil,
+    placeholder: String
+  ) {
+    self.id = id
+    self.name = name
+    self.placeholder = placeholder
+  }
+
+  public init(
+    name: String,
+    placeholder: String
+  ) {
+    self.init(id: nil, name: name, placeholder: placeholder)
+  }
+
+  public var body: some HTML<HTMLTag.input> {
+    input(
+      .id(id ?? ""), .name(_name), .placeholder(placeholder),
+      .class(
+        """
+        input w-full rounded-md bg-white px-3 py-1.5 text-slate-900 outline-1
+        -outline-offset-1 outline-slate-300 focus:outline focus:-outline-offset-2
+        focus:outline-indigo-600 invalid:border-red-500 out-of-range:border-red-500
+        """
+      )
+    )
+  }
+}
+
+extension HTMLAttribute where Tag == HTMLTag.input {
+
+  public static func max(_ value: String) -> Self {
+    .init(name: "max", value: value)
+  }
+
+  public static func min(_ value: String) -> Self {
+    .init(name: "min", value: value)
+  }
+
+  public static func step(_ value: String) -> Self {
+    .init(name: "step", value: value)
+  }
+
+  public static func minlength(_ value: String) -> Self {
+    .init(name: "minlength", value: value)
+  }
+
+  public static func pattern(value: String) -> Self {
+    .init(name: "pattern", value: value)
+  }
+
+  public static func pattern(_ type: PatternType) -> Self {
+    pattern(value: type.value)
+  }
+}
+
+public enum PatternType: Sendable {
+  case password
+  case username
+
+  var value: String {
+    switch self {
+    case .password:
+      return "(?=.*\\d)(?=.*[a-z])(?=.*[A-Z]).{8,}"
+    case .username:
+      return "[A-Za-z][A-Za-z0-9\\-]*"
+    }
+  }
+}

Sources/Styleguide/Label.swift

@@ -0,0 +1,20 @@
+import Elementary
+
+public struct Label: HTML, Sendable {
+
+  let title: String
+
+  public init(_ title: String) {
+    self.title = title
+  }
+
+  public init(_ title: @escaping () -> String) {
+    self.title = title()
+  }
+
+  public var body: some HTML<HTMLTag.span> {
+    span(.class("text-lg label font-bold")) {
+      title
+    }
+  }
+}

Sources/Styleguide/LabeledContent.swift

@@ -0,0 +1,72 @@
+import Elementary
+
+public struct LabeledContent<Label: HTML, Content: HTML>: HTML {
+  let label: @Sendable () -> Label
+  let content: @Sendable () -> Content
+  let position: LabelPosition
+
+  public init(
+    position: LabelPosition = .default,
+    @HTMLBuilder label: @escaping @Sendable () -> Label,
+    @HTMLBuilder content: @escaping @Sendable () -> Content
+  ) {
+    self.position = position
+    self.label = label
+    self.content = content
+  }
+
+  public var body: some HTML<HTMLTag.div> {
+    div {
+      switch position {
+      case .leading:
+        label()
+        content()
+      case .trailing:
+        content()
+        label()
+      case .top:
+        label()
+        content()
+      case .bottom:
+        content()
+        label()
+      }
+    }
+    .attributes(.class("flex space-x-4"), when: position.isHorizontal)
+    .attributes(.class("space-y-4"), when: position.isVertical)
+  }
+}
+
+// TODO: Merge / use TooltipPosition
+public enum LabelPosition: String, CaseIterable, Equatable, Sendable {
+  case leading
+  case trailing
+  case top
+  case bottom
+
+  var isHorizontal: Bool {
+    self == .leading || self == .trailing
+  }
+
+  var isVertical: Bool {
+    self == .top || self == .bottom
+  }
+
+  public static let `default` = Self.leading
+}
+
+extension LabeledContent: Sendable where Label: Sendable, Content: Sendable {}
+
+extension LabeledContent where Label == Styleguide.Label {
+
+  public init(
+    _ label: String, position: LabelPosition = .default,
+    @HTMLBuilder content: @escaping @Sendable () -> Content
+  ) {
+    self.init(
+      position: position,
+      label: { Label(label) },
+      content: content
+    )
+  }
+}

Sources/Styleguide/ModalForm.swift

@@ -0,0 +1,38 @@
+import Elementary
+
+public struct ModalForm<T: HTML>: HTML, Sendable where T: Sendable {
+
+  let closeButton: Bool
+  let dismiss: Bool
+  let id: String
+  let inner: T
+
+  public init(
+    id: String,
+    closeButton: Bool = true,
+    dismiss: Bool,
+    @HTMLBuilder inner: () -> T
+  ) {
+    self.closeButton = closeButton
+    self.dismiss = dismiss
+    self.id = id
+    self.inner = inner()
+  }
+
+  public var body: some HTML<HTMLTag.dialog> {
+    dialog(.id(id), .class("modal")) {
+      div(.class("modal-box")) {
+        if closeButton {
+          button(
+            .class("btn btn-sm btn-circle btn-ghost absolute right-2 top-2"),
+            .on(.click, "\(id).close()")
+          ) {
+            SVG(.close)
+          }
+        }
+        inner
+      }
+    }
+    .attributes(.class("modal-open"), when: dismiss == false)
+  }
+}

Sources/Styleguide/Number.swift

@@ -0,0 +1,32 @@
+import Elementary
+import Foundation
+
+public struct Number: HTML, Sendable {
+  let fractionDigits: Int
+  let value: Double
+
+  private var formatter: NumberFormatter {
+    let formatter = NumberFormatter()
+    formatter.maximumFractionDigits = fractionDigits
+    formatter.numberStyle = .decimal
+    return formatter
+  }
+
+  public init(
+    _ value: Double,
+    digits fractionDigits: Int = 2
+  ) {
+    self.value = value
+    self.fractionDigits = fractionDigits
+  }
+
+  public init(
+    _ value: Int
+  ) {
+    self.init(Double(value), digits: 0)
+  }
+
+  public var body: some HTML<HTMLTag.span> {
+    span { formatter.string(for: value) ?? "N/A" }
+  }
+}

Sources/Styleguide/PageTitle.swift

@@ -0,0 +1,40 @@
+import Elementary
+
+public struct PageTitleRow<Content: HTML>: HTML, Sendable where Content: Sendable {
+
+  let inner: Content
+
+  public init(@HTMLBuilder content: () -> Content) {
+    self.inner = content()
+  }
+
+  public var body: some HTML<HTMLTag.div> {
+    div(
+      .class(
+        """
+        flex justify-between bg-secondary border-2 border-primary rounded-sm shadow-sm 
+        p-6 w-full
+        """
+      )
+    ) {
+      inner
+    }
+  }
+}
+
+public struct PageTitle: HTML, Sendable {
+
+  let title: String
+
+  public init(_ title: String) {
+    self.title = title
+  }
+
+  public init(_ title: () -> String) {
+    self.title = title()
+  }
+
+  public var body: some HTML<HTMLTag.h1> {
+    h1(.class("text-3xl font-bold")) { title }
+  }
+}

Sources/Styleguide/ResultView.swift

@@ -0,0 +1,89 @@
+import Elementary
+import Foundation
+
+public struct ResultView<
+  V: Sendable,
+  E: Error,
+  ValueView: HTML,
+  ErrorView: HTML
+>: HTML {
+
+  let onSuccess: @Sendable (V) -> ValueView
+  let onError: @Sendable (E) -> ErrorView
+  let result: Result<V, E>
+
+  public init(
+    result: Result<V, E>,
+    @HTMLBuilder onSuccess: @escaping @Sendable (V) -> ValueView,
+    @HTMLBuilder onError: @escaping @Sendable (E) -> ErrorView
+  ) {
+    self.result = result
+    self.onError = onError
+    self.onSuccess = onSuccess
+  }
+
+  public var body: some HTML {
+    switch result {
+    case .success(let value):
+      onSuccess(value)
+    case .failure(let error):
+      onError(error)
+    }
+  }
+}
+
+extension ResultView {
+
+  public init(
+    result: Result<V, E>,
+    @HTMLBuilder onSuccess: @escaping @Sendable (V) -> ValueView
+  ) where ErrorView == Styleguide.ErrorView<E> {
+    self.init(result: result, onSuccess: onSuccess) { error in
+      Styleguide.ErrorView(error: error)
+    }
+  }
+
+  public init(
+    catching: @escaping @Sendable () async throws(E) -> V,
+    @HTMLBuilder onSuccess: @escaping @Sendable (V) -> ValueView
+  ) async where ErrorView == Styleguide.ErrorView<E> {
+    await self.init(
+      result: .init(catching: catching),
+      onSuccess: onSuccess
+    ) { error in
+      Styleguide.ErrorView(error: error)
+    }
+  }
+
+  public init(
+    catching: @escaping @Sendable () async throws(E) -> V,
+  ) async where ErrorView == Styleguide.ErrorView<E>, V == Void, ValueView == EmptyHTML {
+    await self.init(
+      result: .init(catching: catching),
+      onSuccess: { EmptyHTML() }
+    ) { error in
+      Styleguide.ErrorView(error: error)
+    }
+  }
+}
+
+extension ResultView: Sendable where Error: Sendable, ValueView: Sendable, ErrorView: Sendable {}
+
+public struct ErrorView<E: Error>: HTML, Sendable where Error: Sendable {
+
+  let error: E
+
+  public init(error: E) {
+    self.error = error
+  }
+
+  public var body: some HTML<HTMLTag.div> {
+    div {
+      h1(.class("text-2xl font-bold text-error")) { "Oops: Error" }
+      p {
+        "\(error)"
+      }
+    }
+  }
+
+}

Sources/Styleguide/Row.swift

@@ -0,0 +1,18 @@
+import Elementary
+
+public struct Row<T: HTML>: HTML, Sendable where T: Sendable {
+
+  let inner: T
+
+  public init(
+    @HTMLBuilder _ body: () -> T
+  ) {
+    self.inner = body()
+  }
+
+  public var body: some HTML<HTMLTag.div> {
+    div(.class("flex justify-between")) {
+      inner
+    }
+  }
+}

Sources/Styleguide/SVG.swift

@@ -0,0 +1,165 @@
+import Elementary
+
+public struct SVG: HTML, Sendable {
+
+  let key: Key
+
+  public init(_ key: Key) {
+    self.key = key
+  }
+
+  public var body: some HTML {
+    HTMLRaw(key.svg)
+  }
+}
+
+extension SVG {
+  public enum Key: Sendable {
+    case badgeCheck
+    case ban
+    case chevronDown
+    case chevronRight
+    case chevronsLeft
+    case circlePlus
+    case circleUser
+    case close
+    case doorClosed
+    case email
+    case fan
+    case key
+    case mapPin
+    case rulerDimensionLine
+    case sidebarToggle
+    case squareFunction
+    case squarePen
+    case trash
+    case triangleAlert
+    case user
+    case wind
+
+    var svg: String {
+      switch self {
+      case .badgeCheck:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-badge-check-icon lucide-badge-check"><path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"/><path d="m9 12 2 2 4-4"/></svg>
+          """
+      case .ban:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-ban-icon lucide-ban"><path d="M4.929 4.929 19.07 19.071"/><circle cx="12" cy="12" r="10"/></svg>
+          """
+      case .chevronDown:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-chevron-down-icon lucide-chevron-down"><path d="m6 9 6 6 6-6"/></svg>
+          """
+      case .chevronRight:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-chevron-right-icon lucide-chevron-right"><path d="m9 18 6-6-6-6"/></svg>
+          """
+      case .chevronsLeft:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-chevrons-left-icon lucide-chevrons-left"><path d="m11 17-5-5 5-5"/><path d="m18 17-5-5 5-5"/></svg>
+          """
+      case .circlePlus:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle-plus-icon lucide-circle-plus"><circle cx="12" cy="12" r="10"/><path d="M8 12h8"/><path d="M12 8v8"/></svg>
+          """
+      case .circleUser:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle-user-icon lucide-circle-user"><circle cx="12" cy="12" r="10"/><circle cx="12" cy="10" r="3"/><path d="M7 20.662V19a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v1.662"/></svg>
+          """
+      case .close:
+        return """
+            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-x-icon lucide-x"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>
+          """
+      case .doorClosed:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-door-closed-icon lucide-door-closed"><path d="M10 12h.01"/><path d="M18 20V6a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v14"/><path d="M2 20h20"/></svg>
+          """
+      case .email:
+        return """
+            <svg class="h-[1em] opacity-50" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+            <g
+              stroke-linejoin="round"
+              stroke-linecap="round"
+              stroke-width="2.5"
+              fill="none"
+              stroke="currentColor"
+            >
+              <rect width="20" height="16" x="2" y="4" rx="2"></rect>
+              <path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"></path>
+            </g>
+          </svg>
+          """
+      case .fan:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-fan-icon lucide-fan"><path d="M10.827 16.379a6.082 6.082 0 0 1-8.618-7.002l5.412 1.45a6.082 6.082 0 0 1 7.002-8.618l-1.45 5.412a6.082 6.082 0 0 1 8.618 7.002l-5.412-1.45a6.082 6.082 0 0 1-7.002 8.618l1.45-5.412Z"/><path d="M12 12v.01"/></svg>
+          """
+      case .key:
+        return """
+            <svg class="h-[1em] opacity-50" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+              <g
+                stroke-linejoin="round"
+                stroke-linecap="round"
+                stroke-width="2.5"
+                fill="none"
+                stroke="currentColor"
+              >
+                <path
+                  d="M2.586 17.414A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814a6.5 6.5 0 1 0-4-4z"
+                ></path>
+                <circle cx="16.5" cy="7.5" r=".5" fill="currentColor"></circle>
+              </g>
+            </svg>
+          """
+      case .mapPin:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-map-pin-icon lucide-map-pin"><path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"/><circle cx="12" cy="10" r="3"/></svg>
+          """
+      case .rulerDimensionLine:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-ruler-dimension-line-icon lucide-ruler-dimension-line"><path d="M10 15v-3"/><path d="M14 15v-3"/><path d="M18 15v-3"/><path d="M2 8V4"/><path d="M22 6H2"/><path d="M22 8V4"/><path d="M6 15v-3"/><rect x="2" y="12" width="20" height="8" rx="2"/></svg>
+          """
+      case .sidebarToggle:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" stroke-linejoin="round" stroke-linecap="round" stroke-width="2" fill="none" stroke="currentColor" class="my-1.5 inline-block"><path d="M4 4m0 2a2 2 0 0 1 2 -2h12a2 2 0 0 1 2 2v12a2 2 0 0 1 -2 2h-12a2 2 0 0 1 -2 -2z"></path><path d="M9 4v16"></path><path d="M14 10l2 2l-2 2"></path></svg>
+          """
+      case .squareFunction:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square-function-icon lucide-square-function"><rect width="18" height="18" x="3" y="3" rx="2" ry="2"/><path d="M9 17c2 0 2.8-1 2.8-2.8V10c0-2 1-3.3 3.2-3"/><path d="M9 11.2h5.7"/></svg>
+          """
+      case .squarePen:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square-pen-icon lucide-square-pen"><path d="M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/><path d="M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z"/></svg>
+
+          """
+      case .trash:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-trash2-icon lucide-trash-2"><path d="M10 11v6"/><path d="M14 11v6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"/><path d="M3 6h18"/><path d="M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>
+          """
+      case .triangleAlert:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-triangle-alert-icon lucide-triangle-alert"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></svg>
+          """
+      case .user:
+        return """
+            <svg class="h-[1em] opacity-50" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+            <g
+              stroke-linejoin="round"
+              stroke-linecap="round"
+              stroke-width="2.5"
+              fill="none"
+              stroke="currentColor"
+            >
+              <path d="M19 21v-2a4 4 0 0 0-4-4H9a4 4 0 0 0-4 4v2"></path>
+              <circle cx="12" cy="7" r="4"></circle>
+            </g>
+          </svg>
+          """
+      case .wind:
+        return """
+          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-wind-icon lucide-wind"><path d="M12.8 19.6A2 2 0 1 0 14 16H2"/><path d="M17.5 8a2.5 2.5 0 1 1 2 4H2"/><path d="M9.8 4.4A2 2 0 1 1 11 8H2"/></svg>
+          """
+      }
+    }
+  }
+}

Sources/Styleguide/Tooltip.swift

@@ -0,0 +1,51 @@
+import Elementary
+
+extension HTML {
+
+  public func tooltip(
+    _ tip: String,
+    position: TooltipPosition = .default
+  ) -> Tooltip<Self> {
+    Tooltip(tip, position: position) {
+      self
+    }
+  }
+}
+
+public struct Tooltip<Inner: HTML>: HTML {
+
+  let tooltip: String
+  let position: TooltipPosition
+  let inner: Inner
+
+  public init(
+    _ tooltip: String,
+    position: TooltipPosition = .default,
+    @HTMLBuilder inner: () -> Inner
+  ) {
+    self.tooltip = tooltip
+    self.position = position
+    self.inner = inner()
+  }
+
+  public var body: some HTML<HTMLTag.div> {
+    div(
+      .class("tooltip tooltip-\(position.rawValue)"),
+      .data("tip", value: tooltip)
+    ) {
+      inner
+    }
+  }
+}
+
+extension Tooltip: Sendable where Inner: Sendable {}
+
+public enum TooltipPosition: String, CaseIterable, Sendable {
+
+  public static let `default` = Self.left
+
+  case bottom
+  case left
+  case right
+  case top
+}

Sources/ViewController/Extensions/DatabaseExtensions.swift

@@ -0,0 +1,78 @@
+import DatabaseClient
+import Dependencies
+import Fluent
+import ManualDClient
+import ManualDCore
+import Vapor
+
+// FIX: Remove these, not used currently.
+extension DatabaseClient.Projects {
+
+  func fetchPage(
+    userID: User.ID,
+    page: Int = 1,
+    limit: Int = 25
+  ) async throws -> Page<Project> {
+    try await fetch(userID, .init(page: page, per: limit))
+  }
+
+  func fetchPage(
+    userID: User.ID,
+    page: PageRequest
+  ) async throws -> Page<Project> {
+    try await fetch(userID, page)
+  }
+}
+
+extension DatabaseClient {
+
+  func calculateDuctSizes(
+    projectID: Project.ID
+  ) async throws -> (rooms: [DuctSizing.RoomContainer], trunks: [DuctSizing.TrunkContainer]) {
+    @Dependency(\.manualD) var manualD
+
+    return try await manualD.calculate(
+      rooms: rooms.fetch(projectID),
+      trunks: trunkSizes.fetch(projectID),
+      designFrictionRateResult: designFrictionRate(projectID: projectID),
+      projectSHR: projects.getSensibleHeatRatio(projectID)
+    )
+  }
+
+  func designFrictionRate(
+    projectID: Project.ID
+  ) async throws -> (EquipmentInfo, EffectiveLength.MaxContainer, Double)? {
+    guard let equipmentInfo = try await equipment.fetch(projectID) else {
+      return nil
+    }
+
+    let equivalentLengths = try await effectiveLength.fetchMax(projectID)
+    guard let tel = equivalentLengths.total else { return nil }
+
+    let componentLosses = try await componentLoss.fetch(projectID)
+    guard componentLosses.count > 0 else { return nil }
+
+    let availableStaticPressure =
+      equipmentInfo.staticPressure - componentLosses.total
+
+    let designFrictionRate = (availableStaticPressure * 100) / tel
+
+    return (equipmentInfo, equivalentLengths, designFrictionRate)
+  }
+}
+
+extension DatabaseClient.ComponentLoss {
+
+  func createDefaults(projectID: Project.ID) async throws {
+    let defaults = ComponentPressureLoss.Create.default(projectID: projectID)
+    for loss in defaults {
+      _ = try await create(loss)
+    }
+  }
+}
+
+extension PageRequest {
+  static func next<T>(_ currentPage: Page<T>) -> Self {
+    .init(page: currentPage.metadata.page + 1, per: currentPage.metadata.per)
+  }
+}

Sources/ViewController/Extensions/EquivalentLengthForm+extensions.swift

@@ -0,0 +1,60 @@
+import DatabaseClient
+import ManualDCore
+
+extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepThree {
+
+  func validate() throws(ValidationError) {
+    guard groupGroups.count == groupLengths.count,
+      groupGroups.count == groupLetters.count,
+      groupGroups.count == groupQuantities.count
+    else {
+      throw ValidationError("Equivalent length form group counts are not equal.")
+    }
+  }
+
+  var groups: [EffectiveLength.Group] {
+    var groups = [EffectiveLength.Group]()
+    for (n, group) in groupGroups.enumerated() {
+      groups.append(
+        .init(
+          group: group,
+          letter: groupLetters[n],
+          value: Double(groupLengths[n]),
+          quantity: groupQuantities[n]
+        )
+      )
+    }
+    return groups
+
+  }
+}
+
+extension EffectiveLength.Create {
+
+  init(
+    form: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepThree,
+    projectID: Project.ID
+  ) {
+    self.init(
+      projectID: projectID,
+      name: form.name,
+      type: form.type,
+      straightLengths: form.straightLengths,
+      groups: form.groups
+    )
+  }
+}
+
+extension EffectiveLength.Update {
+  init(
+    form: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepThree,
+    projectID: Project.ID
+  ) throws {
+    self.init(
+      name: form.name,
+      type: form.type,
+      straightLengths: form.straightLengths,
+      groups: form.groups
+    )
+  }
+}

Sources/ViewController/Extensions/ManualDClient+extensions.swift

@@ -0,0 +1,38 @@
+import Logging
+import ManualDClient
+import ManualDCore
+
+extension ManualDClient {
+
+  func calculate(
+    rooms: [Room],
+    trunks: [DuctSizing.TrunkSize],
+    designFrictionRateResult: (EquipmentInfo, EffectiveLength.MaxContainer, Double)?,
+    projectSHR: Double?,
+    logger: Logger? = nil
+  ) async throws -> (rooms: [DuctSizing.RoomContainer], trunks: [DuctSizing.TrunkContainer]) {
+    guard let designFrictionRateResult else { return ([], []) }
+    let equipmentInfo = designFrictionRateResult.0
+    let effectiveLengths = designFrictionRateResult.1
+    let designFrictionRate = designFrictionRateResult.2
+
+    guard let maxSupply = effectiveLengths.supply else { return ([], []) }
+    guard let maxReturn = effectiveLengths.return else { return ([], []) }
+
+    let ductRooms = try await self.calculateSizes(
+      rooms: rooms,
+      trunks: trunks,
+      equipmentInfo: equipmentInfo,
+      maxSupplyLength: maxSupply,
+      maxReturnLength: maxReturn,
+      designFrictionRate: designFrictionRate,
+      projectSHR: projectSHR ?? 1.0,
+      logger: logger
+    )
+
+    // logger?.debug("Rooms: \(ductRooms)")
+
+    return ductRooms
+
+  }
+}

Sources/ViewController/Extensions/String+extensions.swift

@@ -0,0 +1,25 @@
+import Foundation
+
+extension String {
+
+  func appendingPath(_ string: String) -> Self {
+    guard string.starts(with: "/") else {
+      return self.appending("/\(string)")
+    }
+    return self.appending(string)
+  }
+
+  func appendingPath(_ id: UUID?) -> Self {
+    guard let id else { return self }
+    return appendingPath(id.uuidString)
+  }
+
+  func appendingPath(_ id: UUID) -> Self {
+    return appendingPath(id.uuidString)
+  }
+
+  var idString: Self {
+    replacing("-", with: "")
+      .replacing(" ", with: "")
+  }
+}

Sources/ViewController/Extensions/TrunkSizeForm+extensions.swift

@@ -0,0 +1,54 @@
+import Foundation
+import Logging
+import ManualDCore
+
+extension SiteRoute.View.ProjectRoute.DuctSizingRoute.TrunkSizeForm {
+
+  func toCreate(logger: Logger? = nil) throws -> DuctSizing.TrunkSize.Create {
+    try .init(
+      projectID: projectID,
+      type: type,
+      rooms: makeRooms(logger: logger),
+      height: height,
+      name: name
+    )
+  }
+
+  func toUpdate(logger: Logger? = nil) throws -> DuctSizing.TrunkSize.Update {
+    try .init(
+      type: type,
+      rooms: makeRooms(logger: logger),
+      height: height,
+      name: name
+    )
+  }
+
+  func makeRooms(logger: Logger?) throws -> [Room.ID: [Int]] {
+    var retval = [Room.ID: [Int]]()
+    for room in rooms {
+      let split = room.split(separator: "_")
+      guard let idString = split.first,
+        let id = UUID(uuidString: String(idString))
+      else {
+        logger?.error("Could not parse id from: \(room)")
+        throw RoomError()
+      }
+      guard let registerString = split.last,
+        let register = Int(registerString)
+      else {
+        logger?.error("Could not register number from: \(room)")
+        throw RoomError()
+      }
+      if var currRegisters = retval[id] {
+        currRegisters.append(register)
+        retval[id] = currRegisters
+      } else {
+        retval[id] = [register]
+      }
+
+    }
+    return retval
+  }
+}
+
+struct RoomError: Error {}

Sources/ViewController/Extensions/UUID+idString.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+extension UUID {
+  var idString: String {
+    uuidString.idString
+  }
+}

Sources/ViewController/Interface.swift

@@ -0,0 +1,89 @@
+import Dependencies
+import DependenciesMacros
+import Elementary
+import Logging
+import ManualDCore
+
+extension DependencyValues {
+  public var viewController: ViewController {
+    get { self[ViewController.self] }
+    set { self[ViewController.self] = newValue }
+  }
+}
+
+public typealias AnySendableHTML = (any HTML & Sendable)
+
+@DependencyClient
+public struct ViewController: Sendable {
+
+  public typealias AuthenticateHandler = @Sendable (User) -> Void
+  public typealias CurrentUserHandler = @Sendable () throws -> User
+
+  public var view: @Sendable (Request) async throws -> AnySendableHTML
+}
+
+extension ViewController {
+
+  public struct Request: Sendable {
+
+    public let route: SiteRoute.View
+    public let isHtmxRequest: Bool
+    public let logger: Logger
+    public let authenticateUser: AuthenticateHandler
+    public let currentUser: CurrentUserHandler
+
+    public init(
+      route: SiteRoute.View,
+      isHtmxRequest: Bool,
+      logger: Logger,
+      authenticateUser: @escaping AuthenticateHandler,
+      currentUser: @escaping CurrentUserHandler
+    ) {
+      self.route = route
+      self.isHtmxRequest = isHtmxRequest
+      self.logger = logger
+      self.authenticateUser = authenticateUser
+      self.currentUser = currentUser
+    }
+
+  }
+}
+
+extension ViewController: DependencyKey {
+  public static let testValue = Self()
+
+  // FIX: Fix.
+  public static let liveValue = Self(
+    view: { request in
+      await request.render()
+    }
+  )
+}
+
+extension ViewController.Request {
+
+  func authenticate(
+    _ login: User.Login
+  ) async throws -> User {
+    @Dependency(\.database.users) var users
+    let token = try await users.login(login)
+    let user = try await users.get(token.userID)!
+    authenticateUser(user)
+    logger.debug("Logged in user: \(user.id)")
+    return user
+  }
+
+  @discardableResult
+  func createAndAuthenticate(
+    _ signup: User.Create
+  ) async throws -> User {
+    @Dependency(\.database.users) var users
+    let user = try await users.create(signup)
+    let _ = try await users.login(
+      .init(email: signup.email, password: signup.password)
+    )
+    authenticateUser(user)
+    logger.debug("Created and logged in user: \(user.id)")
+    return user
+  }
+}

Sources/ViewController/Live.swift

@@ -0,0 +1,679 @@
+import DatabaseClient
+import Dependencies
+import Elementary
+import Foundation
+import ManualDCore
+import Styleguide
+
+extension ViewController.Request {
+
+  func render() async -> AnySendableHTML {
+
+    @Dependency(\.database) var database
+
+    switch route {
+    case .test:
+      let projectID = UUID(uuidString: "A9C20153-E2E5-4C65-B33F-4D8A29C63A7A")!
+      return await view {
+        await ResultView {
+          return (
+            try await database.projects.getCompletedSteps(projectID),
+            try await database.calculateDuctSizes(projectID: projectID)
+          )
+        } onSuccess: { (_, result) in
+          TestPage(trunks: result.trunks, rooms: result.rooms)
+        }
+      }
+    case .login(let route):
+      switch route {
+      case .index(let next):
+        return await view {
+          LoginForm(next: next)
+        }
+      case .submit(let login):
+        // let _ = try await authenticate(login)
+        return await view {
+          await ResultView {
+            try await authenticate(login)
+          } onSuccess: { _ in
+            LoggedIn(next: login.next)
+          }
+        }
+      }
+    case .signup(let route):
+      switch route {
+      case .index:
+        return await view {
+          LoginForm(style: .signup)
+        }
+      case .submit(let request):
+        // Create a new user and log them in.
+        return await view {
+          await ResultView {
+            try await createAndAuthenticate(request)
+          } onSuccess: { user in
+            MainPage {
+              UserProfileForm(userID: user.id, profile: nil, dismiss: false, signup: true)
+            }
+          }
+        }
+      case .submitProfile(let profile):
+        return await view {
+          await ResultView {
+            _ = try await database.userProfile.create(profile)
+            let userID = profile.userID
+            // let user = try currentUser()
+            return (
+              userID,
+              try await database.projects.fetch(userID, .init(page: 1, per: 25))
+            )
+          } onSuccess: { (userID, projects) in
+            ProjectsTable(userID: userID, projects: projects)
+          }
+        }
+      }
+    case .project(let route):
+      return await route.renderView(on: self)
+
+    case .user(let route):
+      return await route.renderView(on: self)
+    }
+  }
+
+  func view<C: HTML>(
+    @HTMLBuilder inner: () async -> C
+  ) async -> AnySendableHTML where C: Sendable {
+    let inner = await inner()
+    let theme = await self.theme
+
+    return MainPage(displayFooter: displayFooter, theme: theme) {
+      inner
+    }
+  }
+
+  var theme: Theme? {
+    get async {
+      @Dependency(\.database) var database
+      guard let user = try? currentUser() else { return nil }
+      return try? await database.userProfile.fetch(user.id)?.theme
+    }
+  }
+
+  var displayFooter: Bool {
+    switch route {
+    case .login, .signup:
+      return false
+    default:
+      return true
+    }
+  }
+}
+
+extension SiteRoute.View.ProjectRoute {
+
+  func renderView(on request: ViewController.Request) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .index:
+      return await request.view {
+        await ResultView {
+          let user = try request.currentUser()
+          return try await (
+            user.id,
+            database.projects.fetchPage(userID: user.id)
+          )
+
+        } onSuccess: { (userID, projects) in
+          ProjectsTable(userID: userID, projects: projects)
+        }
+      }
+    case .page(let page):
+      return await ResultView {
+        let user = try request.currentUser()
+        return try await (
+          user.id,
+          database.projects.fetch(user.id, page)
+        )
+      } onSuccess: { (userID, projects) in
+        ProjectsTable(userID: userID, projects: projects)
+      }
+
+    case .create(let form):
+      return await request.view {
+        await ResultView {
+          let user = try request.currentUser()
+          let project = try await database.projects.create(user.id, form)
+          try await database.componentLoss.createDefaults(projectID: project.id)
+          let rooms = try await database.rooms.fetch(project.id)
+          let shr = try await database.projects.getSensibleHeatRatio(project.id)
+          let completedSteps = try await database.projects.getCompletedSteps(project.id)
+          return (project.id, rooms, shr, completedSteps)
+        } onSuccess: { (projectID, rooms, shr, completedSteps) in
+          ProjectView(
+            projectID: projectID,
+            activeTab: .rooms,
+            completedSteps: completedSteps
+          ) {
+            RoomsView(rooms: rooms, sensibleHeatRatio: shr)
+          }
+        }
+      }
+
+    case .delete(let id):
+      return await ResultView {
+        try await database.projects.delete(id)
+      }
+
+    case .update(let id, let form):
+      return await projectView(on: request, projectID: id) {
+        _ = try await database.projects.update(id, form)
+      }
+
+    case .detail(let projectID, let route):
+      switch route {
+      case .index:
+        return await projectView(on: request, projectID: projectID)
+      case .componentLoss(let route):
+        return await route.renderView(on: request, projectID: projectID)
+      case .ductSizing(let route):
+        return await route.renderView(on: request, projectID: projectID)
+      case .equipment(let route):
+        return await route.renderView(on: request, projectID: projectID)
+      case .equivalentLength(let route):
+        return await route.renderView(on: request, projectID: projectID)
+      case .frictionRate(let route):
+        return await route.renderView(on: request, projectID: projectID)
+      case .rooms(let route):
+        return await route.renderView(on: request, projectID: projectID)
+      }
+    }
+
+  }
+
+  func projectView(
+    on request: ViewController.Request,
+    projectID: Project.ID,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    return await request.view {
+      await ResultView {
+        try await catching()
+        guard let project = try await database.projects.get(projectID) else {
+          throw NotFoundError()
+        }
+        return (
+          try await database.projects.getCompletedSteps(project.id),
+          project
+        )
+      } onSuccess: { (steps, project) in
+        ProjectView(projectID: projectID, activeTab: .project, completedSteps: steps) {
+          ProjectDetail(project: project)
+        }
+      }
+    }
+  }
+
+}
+
+extension SiteRoute.View.ProjectRoute.EquipmentInfoRoute {
+  func renderView(
+    on request: ViewController.Request,
+    projectID: Project.ID
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .index:
+      return await equipmentView(on: request, projectID: projectID)
+
+    case .submit(let form):
+      return await equipmentView(on: request, projectID: projectID) {
+        _ = try await database.equipment.create(form)
+      }
+
+    case .update(let id, let updates):
+      return await equipmentView(on: request, projectID: projectID) {
+        _ = try await database.equipment.update(id, updates)
+      }
+    }
+  }
+
+  func equipmentView(
+    on request: ViewController.Request,
+    projectID: Project.ID,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    return await request.view {
+      await ResultView {
+        try await catching()
+        return (
+          try await database.projects.getCompletedSteps(projectID),
+          try await database.equipment.fetch(projectID)
+        )
+      } onSuccess: { (steps, equipment) in
+        ProjectView(projectID: projectID, activeTab: .equipment, completedSteps: steps) {
+          EquipmentInfoView(equipmentInfo: equipment, projectID: projectID)
+        }
+      }
+    }
+  }
+}
+
+extension SiteRoute.View.ProjectRoute.RoomRoute {
+  func renderView(
+    on request: ViewController.Request,
+    projectID: Project.ID
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    switch self {
+
+    case .delete(let id):
+      return await ResultView {
+        try await database.rooms.delete(id)
+      }
+
+    case .index:
+      return await roomsView(on: request, projectID: projectID)
+
+    case .submit(let form):
+      return await roomsView(on: request, projectID: projectID) {
+        _ = try await database.rooms.create(form)
+      }
+
+    case .update(let id, let form):
+      return await roomsView(on: request, projectID: projectID) {
+        _ = try await database.rooms.update(id, form)
+      }
+
+    case .updateSensibleHeatRatio(let form):
+      return await roomsView(on: request, projectID: projectID) {
+        _ = try await database.projects.update(
+          form.projectID,
+          .init(sensibleHeatRatio: form.sensibleHeatRatio)
+        )
+      }
+    }
+  }
+
+  func roomsView(
+    on request: ViewController.Request,
+    projectID: Project.ID,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    return await request.view {
+      await ResultView {
+        try await catching()
+        return (
+          try await database.projects.getCompletedSteps(projectID),
+          try await database.rooms.fetch(projectID),
+          try await database.projects.getSensibleHeatRatio(projectID)
+        )
+      } onSuccess: { (steps, rooms, shr) in
+        ProjectView(projectID: projectID, activeTab: .rooms, completedSteps: steps) {
+          RoomsView(rooms: rooms, sensibleHeatRatio: shr)
+        }
+      }
+    }
+  }
+}
+
+extension SiteRoute.View.ProjectRoute.FrictionRateRoute {
+  func renderView(
+    on request: ViewController.Request,
+    projectID: Project.ID
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+    @Dependency(\.manualD) var manualD
+
+    switch self {
+    case .index:
+      return await view(on: request, projectID: projectID)
+    }
+  }
+
+  func view(
+    on request: ViewController.Request,
+    projectID: Project.ID,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+
+    @Dependency(\.database) var database
+    @Dependency(\.manualD) var manualD
+
+    return await request.view {
+      await ResultView {
+        let equipment = try await database.equipment.fetch(projectID)
+        let componentLosses = try await database.componentLoss.fetch(projectID)
+        let lengths = try await database.effectiveLength.fetchMax(projectID)
+
+        return (
+          try await database.projects.getCompletedSteps(projectID),
+          componentLosses,
+          lengths,
+          try await manualD.frictionRate(
+            equipmentInfo: equipment,
+            componentLosses: componentLosses,
+            effectiveLength: lengths
+          )
+        )
+      } onSuccess: { (steps, losses, lengths, frictionRate) in
+        ProjectView(projectID: projectID, activeTab: .frictionRate, completedSteps: steps) {
+          FrictionRateView(
+            componentLosses: losses,
+            equivalentLengths: lengths,
+            frictionRateResponse: frictionRate
+          )
+        }
+
+      }
+    }
+  }
+
+}
+
+extension SiteRoute.View.ProjectRoute.ComponentLossRoute {
+
+  func renderView(
+    on request: ViewController.Request,
+    projectID: Project.ID
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .index:
+      return EmptyHTML()
+    case .delete(let id):
+      return await view(on: request, projectID: projectID) {
+        _ = try await database.componentLoss.delete(id)
+      }
+    case .submit(let form):
+      return await view(on: request, projectID: projectID) {
+        _ = try await database.componentLoss.create(form)
+      }
+
+    case .update(let id, let form):
+      return await view(on: request, projectID: projectID) {
+        _ = try await database.componentLoss.update(id, form)
+      }
+    }
+  }
+
+  func view(
+    on request: ViewController.Request,
+    projectID: Project.ID,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+
+    @Dependency(\.database) var database
+    @Dependency(\.manualD) var manualD
+
+    return await request.view {
+      await ResultView {
+        try await catching()
+
+        let equipment = try await database.equipment.fetch(projectID)
+        let componentLosses = try await database.componentLoss.fetch(projectID)
+        let lengths = try await database.effectiveLength.fetchMax(projectID)
+
+        return (
+          try await database.projects.getCompletedSteps(projectID),
+          componentLosses,
+          lengths,
+          try await manualD.frictionRate(
+            equipmentInfo: equipment,
+            componentLosses: componentLosses,
+            effectiveLength: lengths
+          )
+        )
+      } onSuccess: { (steps, losses, lengths, frictionRate) in
+        ProjectView(projectID: projectID, activeTab: .frictionRate, completedSteps: steps) {
+          FrictionRateView(
+            componentLosses: losses,
+            equivalentLengths: lengths,
+            frictionRateResponse: frictionRate
+          )
+        }
+
+      }
+    }
+  }
+
+}
+
+extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute {
+
+  func renderView(
+    on request: ViewController.Request,
+    projectID: Project.ID
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    switch self {
+
+    case .delete(let id):
+      return await ResultView {
+        try await database.effectiveLength.delete(id)
+      }
+
+    case .index:
+      return await self.view(on: request, projectID: projectID)
+
+    case .field(let type, let style):
+      switch type {
+      case .straightLength:
+        return StraightLengthField()
+      case .group:
+        // FIX:
+        return GroupField(style: style ?? .supply)
+      }
+
+    case .update(let id, let form):
+      return await view(on: request, projectID: projectID) {
+        _ = try await database.effectiveLength.update(id, .init(form: form, projectID: projectID))
+      }
+
+    case .submit(let step):
+      switch step {
+      case .one(let stepOne):
+        return await ResultView {
+          var effectiveLength: EffectiveLength? = nil
+          if let id = stepOne.id {
+            effectiveLength = try await database.effectiveLength.get(id)
+          }
+          return effectiveLength
+        } onSuccess: { effectiveLength in
+          EffectiveLengthForm.StepTwo(
+            projectID: projectID,
+            stepOne: stepOne,
+            effectiveLength: effectiveLength
+          )
+        }
+      case .two(let stepTwo):
+        return await ResultView {
+          request.logger.debug("ViewController: Got step two...")
+          var effectiveLength: EffectiveLength? = nil
+          if let id = stepTwo.id {
+            effectiveLength = try await database.effectiveLength.get(id)
+          }
+          return effectiveLength
+        } onSuccess: { effectiveLength in
+          return EffectiveLengthForm.StepThree(
+            projectID: projectID, effectiveLength: effectiveLength, stepTwo: stepTwo
+          )
+        }
+      case .three(let stepThree):
+        return await view(on: request, projectID: projectID) {
+          _ = try await database.effectiveLength.create(
+            .init(form: stepThree, projectID: projectID)
+          )
+        }
+
+      }
+    }
+
+  }
+
+  func view(
+    on request: ViewController.Request,
+    projectID: Project.ID,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+    return await request.view {
+      await ResultView {
+        try await catching()
+        return (
+          try await database.projects.getCompletedSteps(projectID),
+          try await database.effectiveLength.fetch(projectID)
+        )
+      } onSuccess: { (steps, equivalentLengths) in
+        ProjectView(projectID: projectID, activeTab: .equivalentLength, completedSteps: steps) {
+          EffectiveLengthsView(effectiveLengths: equivalentLengths)
+            .environment(ProjectViewValue.$projectID, projectID)
+        }
+      }
+    }
+  }
+}
+
+extension SiteRoute.View.ProjectRoute.DuctSizingRoute {
+
+  func renderView(
+    on request: ViewController.Request,
+    projectID: Project.ID
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+    @Dependency(\.manualD) var manualD
+
+    switch self {
+    case .index:
+      return await view(on: request, projectID: projectID)
+
+    case .deleteRectangularSize(let roomID, let request):
+      return await ResultView {
+        let room = try await database.rooms.deleteRectangularSize(roomID, request.rectangularSizeID)
+        return try await database.calculateDuctSizes(projectID: projectID)
+          .rooms
+          .filter({ $0.roomID == room.id && $0.roomRegister == request.register })
+          .first!
+      } onSuccess: { room in
+        DuctSizingView.RoomRow(room: room)
+      }
+
+    case .roomRectangularForm(let roomID, let form):
+      return await ResultView {
+        let room = try await database.rooms.updateRectangularSize(
+          roomID,
+          .init(id: form.id ?? .init(), register: form.register, height: form.height)
+        )
+        return try await database.calculateDuctSizes(projectID: projectID)
+          .rooms
+          .filter({ $0.roomID == room.id && $0.roomRegister == form.register })
+          .first!
+      } onSuccess: { room in
+        DuctSizingView.RoomRow(room: room)
+      }
+
+    case .trunk(let route):
+      switch route {
+      case .delete(let id):
+        return await ResultView {
+          try await database.trunkSizes.delete(id)
+        }
+      case .submit(let form):
+        return await view(on: request, projectID: projectID) {
+          _ = try await database.trunkSizes.create(
+            form.toCreate(logger: request.logger)
+          )
+        }
+
+      case .update(let id, let form):
+        return await view(on: request, projectID: projectID) {
+          _ = try await database.trunkSizes.update(id, form.toUpdate())
+        }
+      }
+    }
+  }
+
+  func view(
+    on request: ViewController.Request,
+    projectID: Project.ID,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    return await request.view {
+      await ResultView {
+        try await catching()
+        return (
+          try await database.projects.getCompletedSteps(projectID),
+          try await database.calculateDuctSizes(projectID: projectID)
+        )
+      } onSuccess: { (steps, ducts) in
+        ProjectView(projectID: projectID, activeTab: .ductSizing, completedSteps: steps) {
+          DuctSizingView(rooms: ducts.rooms, trunks: ducts.trunks)
+        }
+      }
+    }
+  }
+}
+
+extension SiteRoute.View.UserRoute {
+
+  func renderView(on request: ViewController.Request) async -> AnySendableHTML {
+    switch self {
+    case .profile(let route):
+      return await route.renderView(on: request)
+    }
+  }
+}
+
+extension SiteRoute.View.UserRoute.Profile {
+
+  func renderView(
+    on request: ViewController.Request
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    switch self {
+    case .index:
+      return await view(on: request)
+    case .submit(let form):
+      return await view(on: request) {
+        _ = try await database.userProfile.create(form)
+      }
+    case .update(let id, let updates):
+      return await view(on: request) {
+        _ = try await database.userProfile.update(id, updates)
+      }
+    }
+  }
+
+  func view(
+    on request: ViewController.Request,
+    catching: @escaping @Sendable () async throws -> Void = {}
+  ) async -> AnySendableHTML {
+    @Dependency(\.database) var database
+
+    return await request.view {
+      await ResultView {
+        try await catching()
+        let user = try request.currentUser()
+        return (
+          user,
+          try await database.userProfile.fetch(user.id)
+        )
+      } onSuccess: { (user, profile) in
+        UserView(user: user, profile: profile)
+      }
+    }
+  }
+}

Sources/ViewController/Views/ComponentLoss/ComponentLossForm.swift

@@ -0,0 +1,72 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+// FIX: The value field is sometimes wonky as far as what values it accepts.
+
+struct ComponentLossForm: HTML, Sendable {
+
+  static func id(_ componentLoss: ComponentPressureLoss? = nil) -> String {
+    let base = "componentLossForm"
+    guard let componentLoss else { return base }
+    return "\(base)_\(componentLoss.id.idString)"
+  }
+
+  let dismiss: Bool
+  let projectID: Project.ID
+  let componentLoss: ComponentPressureLoss?
+
+  var route: String {
+    SiteRoute.View.router.path(
+      for: .project(.detail(projectID, .componentLoss(.index)))
+    )
+    .appendingPath(componentLoss?.id)
+  }
+
+  var body: some HTML {
+    ModalForm(id: Self.id(componentLoss), dismiss: dismiss) {
+      h1(.class("text-2xl font-bold")) { "Component Loss" }
+      form(
+        .class("space-y-4 p-4"),
+        componentLoss == nil
+          ? .hx.post(route)
+          : .hx.patch(route),
+        .hx.target("body"),
+        .hx.swap(.outerHTML)
+      ) {
+
+        if let componentLoss {
+          input(.class("hidden"), .name("id"), .value("\(componentLoss.id)"))
+        }
+
+        input(.class("hidden"), .name("projectID"), .value("\(projectID)"))
+
+        LabeledInput(
+          "Name",
+          .name("name"),
+          .type(.text),
+          .value(componentLoss?.name),
+          .placeholder("Name"),
+          .required,
+          .autofocus
+        )
+
+        LabeledInput(
+          "Value",
+          .name("value"),
+          .type(.number),
+          .value(componentLoss?.value),
+          .placeholder("0.2"),
+          .min("0.03"),
+          .max("1.0"),
+          .step("0.01"),
+          .required
+        )
+
+        SubmitButton()
+          .attributes(.class("btn-block"))
+      }
+    }
+  }
+}

Sources/ViewController/Views/ComponentLoss/ComponentLossesView.swift

@@ -0,0 +1,90 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+struct ComponentPressureLossesView: HTML, Sendable {
+
+  let componentPressureLosses: [ComponentPressureLoss]
+  let projectID: Project.ID
+
+  private var total: Double {
+    componentPressureLosses.total
+  }
+
+  private var sortedLosses: [ComponentPressureLoss] {
+    componentPressureLosses.sorted {
+      $0.value > $1.value
+    }
+  }
+
+  var body: some HTML {
+    div(.class("space-y-4")) {
+      Row {
+        h1(.class("text-2xl font-bold")) { "Component Pressure Losses" }
+        PlusButton()
+          .attributes(
+            .class("btn-primary text-2xl me-2"),
+            .showModal(id: ComponentLossForm.id())
+          )
+          .tooltip("Add component loss")
+      }
+      .attributes(.class("px-4"))
+
+      table(.class("table table-zebra")) {
+        thead {
+          tr(.class("text-xl font-bold")) {
+            th { "Name" }
+            th { "Value" }
+            th(.class("min-w-[200px]")) {}
+          }
+        }
+        tbody {
+          for row in sortedLosses {
+            TableRow(row: row)
+          }
+        }
+      }
+    }
+    ComponentLossForm(dismiss: true, projectID: projectID, componentLoss: nil)
+  }
+
+  struct TableRow: HTML, Sendable {
+    let row: ComponentPressureLoss
+
+    var body: some HTML<HTMLTag.tr> {
+      tr(.class("text-lg")) {
+        td { row.name }
+        td { Number(row.value) }
+        td {
+          div(.class("flex join items-end justify-end mx-auto")) {
+            Tooltip("Delete", position: .bottom) {
+              TrashButton()
+                .attributes(
+                  .class("join-item btn-ghost"),
+                  .hx.delete(
+                    route: .project(
+                      .detail(row.projectID, .componentLoss(.delete(row.id)))
+                    )
+                  ),
+                  .hx.target("body"),
+                  .hx.swap(.outerHTML),
+                  .hx.confirm("Are your sure?")
+
+                )
+            }
+            Tooltip("Edit", position: .bottom) {
+              EditButton()
+                .attributes(
+                  .class("join-item btn-ghost"),
+                  .showModal(id: ComponentLossForm.id(row))
+                )
+            }
+          }
+
+          ComponentLossForm(dismiss: true, projectID: row.projectID, componentLoss: row)
+        }
+      }
+    }
+  }
+}

Sources/ViewController/Views/DuctSizing/DuctSizingView.swift

@@ -0,0 +1,55 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+struct DuctSizingView: HTML, Sendable {
+
+  @Environment(ProjectViewValue.$projectID) var projectID
+
+  let rooms: [DuctSizing.RoomContainer]
+  let trunks: [DuctSizing.TrunkContainer]
+
+  var body: some HTML {
+    div(.class("space-y-4")) {
+      PageTitleRow {
+        div {
+          PageTitle("Duct Sizes")
+
+          Alert(
+            """
+            Must complete all the previous sections to display duct sizing calculations.
+            """
+          )
+          .hidden(when: rooms.count > 0)
+          .attributes(.class("text-error font-bold italic mt-4"))
+        }
+      }
+
+      if rooms.count != 0 {
+        RoomsTable(rooms: rooms)
+
+        PageTitleRow {
+          PageTitle {
+            "Trunk / Runout Sizes"
+          }
+
+          PlusButton()
+            .attributes(
+              .class("btn-primary"),
+              .showModal(id: TrunkSizeForm.id())
+            )
+            .tooltip("Add trunk / runout")
+        }
+
+        if trunks.count > 0 {
+          TrunkTable(trunks: trunks, rooms: rooms)
+        }
+
+      }
+
+      TrunkSizeForm(rooms: rooms, dismiss: true)
+    }
+  }
+
+}

Sources/ViewController/Views/DuctSizing/RectangularSizeForm.swift

@@ -0,0 +1,76 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+struct RectangularSizeForm: HTML, Sendable {
+
+  static func id(_ room: DuctSizing.RoomContainer) -> String {
+    let base = "rectangularSize"
+    return "\(base)_\(room.roomName.idString)"
+  }
+
+  @Environment(ProjectViewValue.$projectID) var projectID
+
+  let id: String
+  let room: DuctSizing.RoomContainer
+  let dismiss: Bool
+
+  init(
+    id: String? = nil,
+    room: DuctSizing.RoomContainer,
+    dismiss: Bool = true
+  ) {
+    self.id = Self.id(room)
+    self.room = room
+    self.dismiss = dismiss
+  }
+
+  var route: String {
+    SiteRoute.View.router.path(
+      for: .project(.detail(projectID, .ductSizing(.index)))
+    )
+    .appendingPath("room")
+    .appendingPath(room.roomID)
+
+  }
+
+  var rowID: String {
+    DuctSizingView.RoomRow.id(room)
+  }
+
+  var height: Int? {
+    room.rectangularSize?.height
+  }
+
+  var body: some HTML<HTMLTag.dialog> {
+    ModalForm(id: id, dismiss: dismiss) {
+      h1(.class("text-lg pb-6")) { "Rectangular Size" }
+
+      form(
+        .class("space-y-4"),
+        .hx.post(route),
+        .hx.target("#\(rowID)"),
+        .hx.swap(.outerHTML)
+      ) {
+        input(.class("hidden"), .name("register"), .value(room.roomRegister))
+        input(.class("hidden"), .name("id"), .value(room.rectangularSize?.id))
+
+        LabeledInput(
+          "Height",
+          .name("height"),
+          .type(.number),
+          .value(height),
+          .placeholder("8"),
+          .min("0"),
+          .required,
+          .autofocus
+        )
+
+        SubmitButton()
+          .attributes(.class("btn-block"))
+      }
+
+    }
+  }
+}

Sources/ViewController/Views/DuctSizing/RoomsTable.swift

@@ -0,0 +1,167 @@
+import Elementary
+import ElementaryHTMX
+import Foundation
+import ManualDCore
+import Styleguide
+
+extension DuctSizingView {
+  // TODO: Remove register ID.
+  struct RoomsTable: HTML, Sendable {
+    @Environment(ProjectViewValue.$projectID) var projectID
+
+    let rooms: [DuctSizing.RoomContainer]
+
+    var body: some HTML<HTMLTag.table> {
+
+      table(.class("table table-zebra text-lg")) {
+        thead {
+          tr(.class("text-lg")) {
+            th { "Name" }
+            th { "BTU" }
+            th { "CFM" }
+            th { "Velocity" }
+            th(.class("w-[330px]")) { "Size" }
+          }
+        }
+        tbody {
+          for room in rooms {
+            RoomRow(room: room)
+          }
+        }
+      }
+    }
+  }
+
+  struct RoomRow: HTML, Sendable {
+
+    static func id(_ room: DuctSizing.RoomContainer) -> String {
+      "roomRow_\(room.roomName.idString)"
+    }
+
+    @Environment(ProjectViewValue.$projectID) var projectID
+
+    let room: DuctSizing.RoomContainer
+    let formID = UUID().idString
+
+    var deleteRoute: String {
+      guard let id = room.rectangularSize?.id else { return "" }
+
+      return SiteRoute.View.router.path(
+        for: .project(
+          .detail(
+            projectID,
+            .ductSizing(
+              .deleteRectangularSize(
+                room.roomID,
+                .init(rectangularSizeID: id, register: room.roomRegister)
+              ))
+          )
+        )
+      )
+    }
+
+    var rowID: String { Self.id(room) }
+
+    var body: some HTML<HTMLTag.tr> {
+      tr(.class("text-lg"), .id(rowID)) {
+        td { room.roomName }
+        td {
+          div(.class("flex flex-wrap grid grid-cols-2 gap-2")) {
+            span(.class("label")) { "Heating" }
+            Number(room.heatingLoad, digits: 0)
+
+            span(.class("label")) { "Cooling" }
+            Number(room.coolingLoad, digits: 0)
+          }
+        }
+
+        td {
+          div(.class("flex flex-wrap grid grid-cols-2 gap-2")) {
+
+            span(.class("label")) { "Design" }
+            div(.class("flex justify-center")) {
+              Badge(number: room.designCFM.value, digits: 0)
+            }
+
+            span(.class("label")) { "Heating" }
+            div(.class("flex justify-center")) {
+              Number(room.heatingCFM, digits: 0)
+            }
+
+            span(.class("label")) { "Cooling" }
+            div(.class("flex justify-center")) {
+              Number(room.coolingCFM, digits: 0)
+            }
+
+          }
+        }
+
+        td { Number(room.velocity) }
+
+        td {
+          div(.class("grid grid-cols-3 gap-2 w-[330px]")) {
+
+            div(.class("label")) { "Calculated" }
+            div(.class("flex justify-center")) {
+              Badge(number: room.roundSize, digits: 2)
+            }
+            div {}
+
+            div(.class("label")) { "Final" }
+            div(.class("flex justify-center")) {
+              Badge(number: room.finalSize)
+                .attributes(.class("badge-secondary"))
+            }
+            div {}
+
+            div(.class("label")) { "Flex" }
+            div(.class("flex justify-center")) {
+              Badge(number: room.flexSize)
+                .attributes(.class("badge-primary"))
+            }
+            div {}
+
+            div(.class("label")) { "Rectangular" }
+            div(.class("flex justify-center")) {
+              if let width = room.rectangularWidth,
+                let height = room.rectangularSize?.height
+              {
+                Badge {
+                  span { "\(width) x \(height)" }
+                }
+                .attributes(.class("badge-info"))
+              }
+            }
+            div(.class("flex justify-end")) {
+              div(.class("join")) {
+                if room.rectangularSize != nil {
+                  Tooltip("Delete Size", position: .bottom) {
+                    TrashButton()
+                      .attributes(.class("join-item btn-ghost"))
+                      .attributes(
+                        .hx.delete(deleteRoute),
+                        .hx.target("#\(rowID)"),
+                        .hx.swap(.outerHTML),
+                        when: room.rectangularSize != nil
+                      )
+                  }
+                }
+
+                Tooltip("Edit Size", position: .bottom) {
+                  EditButton()
+                    .attributes(
+                      .class("join-item btn-ghost"),
+                      .showModal(id: RectangularSizeForm.id(room))
+                    )
+                }
+
+              }
+            }
+            RectangularSizeForm(room: room)
+          }
+        }
+      }
+    }
+  }
+
+}

Sources/ViewController/Views/DuctSizing/TrunkSizeForm.swift

@@ -0,0 +1,131 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+struct TrunkSizeForm: HTML, Sendable {
+
+  static func id(_ trunk: DuctSizing.TrunkContainer? = nil) -> String {
+    let base = "trunkSizeForm"
+    guard let trunk else { return base }
+    return "\(base)_\(trunk.id.idString)"
+  }
+
+  @Environment(ProjectViewValue.$projectID) var projectID
+
+  let container: DuctSizing.TrunkContainer?
+  let rooms: [DuctSizing.RoomContainer]
+  let dismiss: Bool
+
+  var trunk: DuctSizing.TrunkSize? {
+    container?.trunk
+  }
+
+  init(
+    trunk: DuctSizing.TrunkContainer? = nil,
+    rooms: [DuctSizing.RoomContainer],
+    dismiss: Bool = true
+  ) {
+    self.container = trunk
+    self.rooms = rooms
+    self.dismiss = dismiss
+  }
+
+  var route: String {
+    SiteRoute.View.router
+      .path(for: .project(.detail(projectID, .ductSizing(.index))))
+      .appendingPath(SiteRoute.View.ProjectRoute.DuctSizingRoute.TrunkRoute.rootPath)
+      .appendingPath(trunk?.id)
+  }
+
+  var body: some HTML {
+    ModalForm(id: Self.id(container), dismiss: dismiss) {
+      h1(.class("text-lg font-bold mb-4")) { "Trunk / Runout Size" }
+      form(
+        .class("space-y-4"),
+        trunk == nil
+          ? .hx.post(route)
+          : .hx.patch(route),
+        .hx.target("body"),
+        .hx.swap(.outerHTML)
+      ) {
+
+        input(.class("hidden"), .name("projectID"), .value(projectID))
+
+        div(.class("grid grid-cols-1 md:grid-cols-2 gap-4")) {
+          label(.class("select w-full")) {
+            span(.class("label")) { "Type" }
+            select(.name("type")) {
+              for type in DuctSizing.TrunkSize.TrunkType.allCases {
+                option(.value(type.rawValue)) { type.rawValue.capitalized }
+                  .attributes(.selected, when: trunk?.type == type)
+              }
+            }
+          }
+
+          LabeledInput(
+            "Height",
+            .type(.text),
+            .name("height"),
+            .value(trunk?.height),
+            .placeholder("8 (Optional)"),
+          )
+        }
+
+        LabeledInput(
+          "Name",
+          .type(.text),
+          .name("name"),
+          .value(trunk?.name),
+          .placeholder("Trunk-1 (Optional)")
+        )
+
+        div {
+          h2(.class("label font-bold col-span-3 mb-6")) { "Associated Supply Runs" }
+          div(
+            .class(
+              """
+              grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 justify-center items-center gap-4
+              """
+            )
+          ) {
+            for room in rooms {
+              div(.class("block grow")) {
+                div(.class("grid grid-cols-1 space-y-1")) {
+                  div(.class("flex justify-center")) {
+                    p(.class("label")) { room.roomName }
+                  }
+                  div(.class("flex justify-center")) {
+                    input(
+                      .class("checkbox"),
+                      .type(.checkbox),
+                      .name("rooms"),
+                      .value("\(room.roomID)_\(room.roomRegister)")
+                    )
+                    .attributes(
+                      .checked,
+                      when: trunk == nil ? false : trunk!.rooms.hasRoom(room)
+                    )
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        SubmitButton()
+          .attributes(.class("btn-block mt-6"))
+      }
+    }
+  }
+
+}
+
+extension Array where Element == DuctSizing.TrunkSize.RoomProxy {
+  func hasRoom(_ room: DuctSizing.RoomContainer) -> Bool {
+    first {
+      $0.id == room.roomID
+        && $0.registers.contains(room.roomRegister)
+    } != nil
+  }
+}

Sources/ViewController/Views/DuctSizing/TrunksTable.swift

@@ -0,0 +1,152 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+extension DuctSizingView {
+
+  struct TrunkTable: HTML, Sendable {
+
+    let trunks: [DuctSizing.TrunkContainer]
+    let rooms: [DuctSizing.RoomContainer]
+
+    private var sortedTrunks: [DuctSizing.TrunkContainer] {
+      trunks
+        .sorted(by: { $0.designCFM.value > $1.designCFM.value })
+        .sorted(by: { $0.type.rawValue > $1.type.rawValue })
+    }
+
+    var body: some HTML {
+      table(.class("table table-zebra text-lg")) {
+        thead {
+          tr(.class("text-lg")) {
+            th { "Name / Type" }
+            th { "Associated Supplies" }
+            th { "Dsn CFM" }
+            th { "Velocity" }
+            th(.class("w-[330px]")) { "Size" }
+          }
+        }
+        tbody {
+          for trunk in sortedTrunks {
+            TrunkRow(trunk: trunk, rooms: rooms)
+          }
+        }
+      }
+    }
+
+  }
+
+  struct TrunkRow: HTML, Sendable {
+
+    @Environment(ProjectViewValue.$projectID) var projectID
+
+    let trunk: DuctSizing.TrunkContainer
+    let rooms: [DuctSizing.RoomContainer]
+
+    var body: some HTML<HTMLTag.tr> {
+      tr {
+        td {
+          div(.class("grid grid-cols-1 space-y-2")) {
+            if let name = trunk.name {
+              p(.class("w-fit")) { name }
+            }
+
+            Badge {
+              trunk.trunk.type.rawValue
+            }
+            .attributes(.class("badge-info"), when: trunk.type == .supply)
+            .attributes(.class("badge-error"), when: trunk.type == .return)
+          }
+        }
+        td {
+          div(.class("flex flex-wrap space-x-2 space-y-2")) {
+            for id in registerIDS {
+              Badge { id }
+            }
+          }
+        }
+        td {
+          Number(trunk.designCFM.value, digits: 0)
+        }
+        td {
+          Number(trunk.velocity)
+        }
+        td {
+          div(.class("grid grid-cols-3 gap-2 w-[330px]")) {
+            div(.class("label")) { "Calculated" }
+            div(.class("flex justify-center")) {
+              Badge(number: trunk.roundSize, digits: 1)
+            }
+            div {}
+
+            div(.class("label")) { "Final" }
+            div(.class("flex justify-center")) {
+              Badge(number: trunk.finalSize)
+                .attributes(.class("badge-secondary"))
+            }
+            div {}
+
+            div(.class("label")) { "Flex" }
+            div(.class("flex justify-center")) {
+              Badge(number: trunk.flexSize)
+                .attributes(.class("badge-primary"))
+            }
+            div {}
+
+            div(.class("label")) { "Rectangular" }
+            div(.class("flex justify-center")) {
+              if let width = trunk.width,
+                let height = trunk.ductSize.height
+              {
+                Badge {
+                  span { "\(width) x \(height)" }
+                }
+                .attributes(.class("badge-info"))
+              }
+            }
+            div(.class("flex justify-end items-end")) {
+              div(.class("join")) {
+                if trunk.width != nil {
+                  TrashButton()
+                    .attributes(.class("join-item btn-ghost"))
+                    .attributes(
+                      .hx.delete(route: deleteRoute),
+                      .hx.target("closest tr"),
+                      .hx.swap(.outerHTML)
+                    )
+                }
+
+                EditButton()
+                  .attributes(
+                    .class("join-item btn-ghost"),
+                    .showModal(id: TrunkSizeForm.id(trunk))
+                  )
+              }
+            }
+          }
+          TrunkSizeForm(trunk: trunk, rooms: rooms, dismiss: true)
+        }
+      }
+    }
+
+    private var deleteRoute: SiteRoute.View {
+      .project(.detail(projectID, .ductSizing(.trunk(.delete(trunk.id)))))
+    }
+
+    private var registerIDS: [String] {
+      trunk.rooms.reduce(into: []) { array, room in
+        array = room.registers.reduce(into: array) { array, register in
+          if let room =
+            rooms
+            .first(where: { $0.roomID == room.id && $0.roomRegister == register })
+          {
+            array.append(room.roomName)
+          }
+        }
+      }
+      .sorted()
+    }
+
+  }
+}

Sources/ViewController/Views/EffectiveLength/EffectiveLengthForm.swift

@@ -0,0 +1,360 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+// TODO: Add back buttons / capability??
+
+struct EffectiveLengthForm: HTML, Sendable {
+
+  static func id(_ equivalentLength: EffectiveLength?) -> String {
+    let base = "equivalentLengthForm"
+    guard let equivalentLength else { return base }
+    return "\(base)_\(equivalentLength.id.uuidString.replacing("-", with: ""))"
+  }
+
+  let projectID: Project.ID
+  let dismiss: Bool
+  let type: EffectiveLength.EffectiveLengthType
+  let effectiveLength: EffectiveLength?
+
+  var id: String { Self.id(effectiveLength) }
+
+  init(
+    projectID: Project.ID,
+    dismiss: Bool,
+    type: EffectiveLength.EffectiveLengthType = .supply
+  ) {
+    self.projectID = projectID
+    self.dismiss = dismiss
+    self.type = type
+    self.effectiveLength = nil
+  }
+
+  init(
+    effectiveLength: EffectiveLength
+  ) {
+    self.dismiss = true
+    self.type = effectiveLength.type
+    self.projectID = effectiveLength.projectID
+    self.effectiveLength = effectiveLength
+
+  }
+
+  var body: some HTML {
+    ModalForm(
+      id: id,
+      dismiss: dismiss
+    ) {
+      h1(.class("text-2xl font-bold")) { "Effective Length" }
+      div(.id("formStep_\(id)"), .class("mt-4")) {
+        StepOne(projectID: projectID, effectiveLength: effectiveLength)
+      }
+    }
+  }
+
+  struct StepOne: HTML, Sendable {
+    let projectID: Project.ID
+    let effectiveLength: EffectiveLength?
+
+    var route: String {
+      let baseRoute = SiteRoute.View.router.path(
+        for: .project(.detail(projectID, .equivalentLength(.index)))
+      )
+      return "\(baseRoute)/stepOne"
+    }
+
+    var body: some HTML {
+      form(
+        .class("space-y-4"),
+        .hx.post(route),
+        .hx.target("#formStep_\(EffectiveLengthForm.id(effectiveLength))"),
+        .hx.swap(.innerHTML)
+      ) {
+        if let id = effectiveLength?.id {
+          input(.class("hidden"), .name("id"), .value("\(id)"))
+        }
+
+        LabeledInput(
+          "Name",
+          .name("name"),
+          .type(.text),
+          .value(effectiveLength?.name),
+          .required,
+          .autofocus
+        )
+
+        GroupTypeSelect(projectID: projectID, selected: effectiveLength?.type ?? .supply)
+
+        Row {
+          div {}
+          SubmitButton(title: "Next")
+        }
+      }
+    }
+  }
+
+  struct StepTwo: HTML, Sendable {
+    let projectID: Project.ID
+    let stepOne: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepOne
+    let effectiveLength: EffectiveLength?
+
+    var route: String {
+      let baseRoute = SiteRoute.View.router.path(
+        for: .project(.detail(projectID, .equivalentLength(.index)))
+      )
+      return "\(baseRoute)/stepTwo"
+    }
+
+    var body: some HTML {
+      form(
+        .class("space-y-4"),
+        .hx.post(route),
+        .hx.target("#formStep_\(EffectiveLengthForm.id(effectiveLength))"),
+        .hx.swap(.innerHTML)
+      ) {
+        if let id = effectiveLength?.id {
+          input(.class("hidden"), .name("id"), .value("\(id)"))
+        }
+        input(.class("hidden"), .name("name"), .value(stepOne.name))
+        input(.class("hidden"), .name("type"), .value(stepOne.type.rawValue))
+
+        Row {
+          Label { "Straigth Lengths" }
+          button(
+            .type(.button),
+            .hx.get(
+              route: .project(.detail(projectID, .equivalentLength(.field(.straightLength))))
+            ),
+            .hx.target("#straightLengths"),
+            .hx.swap(.beforeEnd)
+          ) {
+            SVG(.circlePlus)
+          }
+        }
+        div(.id("straightLengths"), .class("space-y-4")) {
+          if let effectiveLength {
+            for length in effectiveLength.straightLengths {
+              StraightLengthField(value: length)
+            }
+          } else {
+            StraightLengthField()
+          }
+        }
+
+        Row {
+          div {}
+          SubmitButton(title: "Next")
+        }
+      }
+    }
+  }
+
+  struct StepThree: HTML, Sendable {
+    let projectID: Project.ID
+    let effectiveLength: EffectiveLength?
+    let stepTwo: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepTwo
+
+    var route: String {
+      let baseRoute = SiteRoute.View.router.path(
+        for: .project(.detail(projectID, .equivalentLength(.index)))
+      )
+
+      if let effectiveLength {
+        return baseRoute.appendingPath(effectiveLength.id)
+      } else {
+        return baseRoute.appendingPath("stepThree")
+      }
+    }
+
+    var body: some HTML {
+      form(
+        .class("space-y-4"),
+        effectiveLength == nil
+          ? .hx.post(route)
+          : .hx.patch(route),
+        .hx.target("body"),
+        .hx.swap(.outerHTML)
+      ) {
+        if let id = effectiveLength?.id {
+          input(.class("hidden"), .name("id"), .value("\(id)"))
+        }
+        input(.class("hidden"), .name("name"), .value(stepTwo.name))
+        input(.class("hidden"), .name("type"), .value(stepTwo.type.rawValue))
+        for length in stepTwo.straightLengths {
+          input(.class("hidden"), .name("straightLengths"), .value("\(length)"))
+        }
+
+        Row {
+          Label { "Groups" }
+          button(
+            .type(.button),
+            .hx.get(
+              route: .project(
+                .detail(projectID, .equivalentLength(.field(.group, style: stepTwo.type))))
+            ),
+            .hx.target("#groups"),
+            .hx.swap(.beforeEnd)
+          ) {
+            SVG(.circlePlus)
+          }
+        }
+
+        a(
+          .href("/files/ManD.Groups.pdf"),
+          .target(.blank),
+          .class("btn btn-link")
+        ) {
+          "Click here for Manual-D groups reference."
+        }
+
+        div(.id("groups"), .class("space-y-4")) {
+          if let effectiveLength {
+            for group in effectiveLength.groups {
+              GroupField(style: effectiveLength.type, group: group)
+            }
+          } else {
+            GroupField(style: stepTwo.type)
+          }
+        }
+        Row {
+          div {}
+          SubmitButton()
+        }
+      }
+    }
+  }
+}
+
+struct StraightLengthField: HTML, Sendable {
+  let value: Int?
+
+  init(value: Int? = nil) {
+    self.value = value
+  }
+
+  var body: some HTML<HTMLTag.div> {
+    Row {
+      LabeledInput(
+        "Length",
+        .name("straightLengths"),
+        .type(.number),
+        .value(value),
+        .placeholder("10"),
+        .min("0"),
+        .autofocus,
+        .required
+      )
+      TrashButton()
+        .attributes(.data("remove", value: "true"))
+    }
+    .attributes(.hx.ext("remove"), .class("space-x-4"))
+  }
+}
+
+struct GroupField: HTML, Sendable {
+
+  let style: EffectiveLength.EffectiveLengthType
+  let group: EffectiveLength.Group?
+
+  init(style: EffectiveLength.EffectiveLengthType, group: EffectiveLength.Group? = nil) {
+    self.style = style
+    self.group = group
+  }
+
+  var body: some HTML {
+    div(.class("grid grid-cols-3 gap-2 p-2 border rounded-lg shadow-sm")) {
+      GroupSelect(style: style)
+
+      LabeledInput(
+        "Letter",
+        .name("group[letter]"),
+        .type(.text),
+        .value(group?.letter),
+        .placeholder("a"),
+        .required
+      )
+
+      LabeledInput(
+        "Length",
+        .name("group[length]"),
+        .type(.number),
+        .value(group?.value),
+        .placeholder("10"),
+        .min("0"),
+        .required
+      )
+
+      LabeledInput(
+        "Quantity",
+        .name("group[quantity]"),
+        .type(.number),
+        .value(group?.quantity ?? 1),
+        .min("1"),
+        .required
+      )
+      .attributes(.class("col-span-2"))
+
+      TrashButton()
+        .attributes(
+          .data("remove", value: "true"),
+          .class("me-2 btn-block")
+        )
+    }
+    .attributes(.class("space-x-2"), .hx.ext("remove"))
+  }
+}
+
+struct GroupSelect: HTML, Sendable {
+
+  let style: EffectiveLength.EffectiveLengthType
+
+  var body: some HTML {
+    label(.class("select")) {
+      span(.class("label")) { "Group" }
+      select(
+        .name("group[group]"),
+        .autofocus
+      ) {
+        for value in style.selectOptions {
+          option(.value("\(value)")) { "\(value)" }
+        }
+      }
+    }
+  }
+
+}
+
+struct GroupTypeSelect: HTML, Sendable {
+
+  let projectID: Project.ID
+  let selected: EffectiveLength.EffectiveLengthType
+
+  var body: some HTML<HTMLTag.label> {
+    label(.class("select w-full")) {
+      span(.class("label")) { "Type" }
+      select(.name("type"), .id("type")) {
+        for value in EffectiveLength.EffectiveLengthType.allCases {
+          option(
+            .value("\(value.rawValue)"),
+          ) { value.title }
+          .attributes(.selected, when: value == selected)
+        }
+      }
+    }
+  }
+}
+
+extension EffectiveLength.EffectiveLengthType {
+
+  var title: String { rawValue.capitalized }
+
+  var selectOptions: [Int] {
+    switch self {
+    case .return:
+      return [5, 6, 7, 8, 10, 11, 12]
+    case .supply:
+      return [1, 2, 3, 4, 8, 9, 11, 12]
+    }
+  }
+}

Sources/ViewController/Views/EffectiveLength/EffectiveLengthsTable.swift

@@ -0,0 +1,139 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+struct EffectiveLengthsTable: HTML, Sendable {
+
+  let effectiveLengths: [EffectiveLength]
+
+  private var sortedLengths: [EffectiveLength] {
+    effectiveLengths.sorted {
+      $0.totalEquivalentLength > $1.totalEquivalentLength
+    }
+    .sorted {
+      $0.type.rawValue > $1.type.rawValue
+    }
+  }
+
+  var body: some HTML<HTMLTag.table> {
+    table(.class("table table-zebra text-lg")) {
+      thead {
+        tr(.class("text-lg")) {
+          th { "Type" }
+          th { "Name" }
+          th { "Straight Lengths" }
+          th {
+            div(.class("grid grid-cols-3 gap-2 min-w-[220px]")) {
+              div(.class("flex justify-center col-span-3")) {
+                "Groups"
+              }
+              div { "Group" }
+              div(.class("flex justify-center")) {
+                "T.E.L."
+              }
+              div(.class("flex justify-end")) {
+                "Quantity"
+              }
+            }
+          }
+          th {
+            div(.class("flex justify-end me-[140px]")) {
+              "T.E.L."
+            }
+          }
+        }
+      }
+      tbody {
+        for row in sortedLengths {
+          EffectiveLenghtRow(effectiveLength: row)
+        }
+      }
+
+    }
+  }
+
+  struct EffectiveLenghtRow: HTML, Sendable {
+
+    let effectiveLength: EffectiveLength
+
+    private var deleteRoute: SiteRoute.View {
+      .project(
+        .detail(
+          effectiveLength.projectID,
+          .equivalentLength(.delete(id: effectiveLength.id))
+        )
+      )
+    }
+
+    var body: some HTML<HTMLTag.tr> {
+      tr(.id(effectiveLength.id.idString)) {
+        td {
+          // Type
+          Badge {
+            span { effectiveLength.type.rawValue }
+          }
+          .attributes(.class("badge-info"), when: effectiveLength.type == .supply)
+          .attributes(.class("badge-error"), when: effectiveLength.type == .return)
+
+        }
+        td { effectiveLength.name }
+        td {
+          // Lengths
+          div(.class("grid grid-cols-1 gap-2")) {
+            for length in effectiveLength.straightLengths {
+              Number(length)
+            }
+          }
+        }
+        td {
+          div(.class("grid grid-cols-3 gap-2 min-w-[220px]")) {
+            for group in effectiveLength.groups {
+              span { "\(group.group)-\(group.letter)" }
+              div(.class("flex justify-center")) {
+                Number(group.value)
+              }
+              div(.class("flex justify-end")) {
+                Number(group.quantity)
+              }
+            }
+          }
+
+        }
+        td {
+          // Total
+          // Row {
+          div(.class("flex justify-end mx-auto space-x-4")) {
+            Badge(number: effectiveLength.totalEquivalentLength, digits: 0)
+              .attributes(.class("badge-primary badge-lg pt-2"))
+
+            // Buttons
+            div(.class("flex justify-end -mt-2")) {
+              div(.class("join")) {
+                TrashButton()
+                  .attributes(
+                    .class("join-item btn-ghost"),
+                    .hx.delete(route: deleteRoute),
+                    .hx.confirm("Are you sure?"),
+                    .hx.target("#\(effectiveLength.id.idString)"),
+                    .hx.swap(.outerHTML)
+                  )
+                  .tooltip("Delete", position: .bottom)
+
+                EditButton()
+                  .attributes(
+                    .class("join-item btn-ghost"),
+                    .showModal(id: EffectiveLengthForm.id(effectiveLength))
+                  )
+                  .tooltip("Edit", position: .bottom)
+              }
+            }
+          }
+
+          EffectiveLengthForm(effectiveLength: effectiveLength)
+        }
+      }
+    }
+  }
+
+}

Sources/ViewController/Views/EffectiveLength/EffectiveLengthsView.swift

@@ -0,0 +1,41 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+struct EffectiveLengthsView: HTML, Sendable {
+
+  @Environment(ProjectViewValue.$projectID) var projectID
+
+  let effectiveLengths: [EffectiveLength]
+
+  var supplies: [EffectiveLength] {
+    effectiveLengths.filter({ $0.type == .supply })
+      .sorted { $0.totalEquivalentLength > $1.totalEquivalentLength }
+  }
+
+  var returns: [EffectiveLength] {
+    effectiveLengths.filter({ $0.type == .return })
+      .sorted { $0.totalEquivalentLength > $1.totalEquivalentLength }
+  }
+
+  var body: some HTML {
+    div(.class("space-y-4")) {
+      PageTitleRow {
+        PageTitle { "Equivalent Lengths" }
+        PlusButton()
+          .attributes(
+            .class("btn-primary"),
+            .showModal(id: EffectiveLengthForm.id(nil))
+          )
+          .tooltip("Add equivalent length")
+      }
+      .attributes(.class("pb-6"))
+
+      EffectiveLengthForm(projectID: projectID, dismiss: true)
+
+      EffectiveLengthsTable(effectiveLengths: effectiveLengths)
+
+    }
+  }
+}

Sources/ViewController/Views/EquipmentInfo/EquipmentInfoForm.swift

@@ -0,0 +1,83 @@
+import Elementary
+import ManualDCore
+import Styleguide
+
+// TODO: Have form hold onto equipment info model to edit.
+struct EquipmentInfoForm: HTML, Sendable {
+
+  static let id = "equipmentForm"
+
+  @Environment(ProjectViewValue.$projectID) var projectID
+
+  let dismiss: Bool
+  let equipmentInfo: EquipmentInfo?
+
+  var staticPressure: String {
+    guard let staticPressure = equipmentInfo?.staticPressure else {
+      return "0.5"
+    }
+    return "\(staticPressure)"
+  }
+
+  var route: String {
+    SiteRoute.View.router.path(
+      for: .project(.detail(projectID, .equipment(.index)))
+    )
+    .appendingPath(equipmentInfo?.id)
+  }
+
+  var body: some HTML {
+    ModalForm(id: Self.id, dismiss: dismiss) {
+      h1(.class("text-3xl font-bold pb-6 ps-2")) { "Equipment Info" }
+      form(
+        .class("grid grid-cols-1 gap-4"),
+        equipmentInfo != nil
+          ? .hx.patch(route)
+          : .hx.post(route),
+        .hx.target("body"),
+        .hx.swap(.outerHTML)
+      ) {
+        input(.class("hidden"), .name("projectID"), .value("\(projectID)"))
+
+        if let equipmentInfo {
+          input(.class("hidden"), .name("id"), .value("\(equipmentInfo.id)"))
+        }
+
+        LabeledInput(
+          "Static Pressure",
+          .name("staticPressure"),
+          .type(.number),
+          .value(staticPressure),
+          .min("0"),
+          .max("1.0"),
+          .step("0.1"),
+          .required
+        )
+
+        LabeledInput(
+          "Heating CFM",
+          .name("heatingCFM"),
+          .type(.number),
+          .value(equipmentInfo?.heatingCFM),
+          .placeholder("1000"),
+          .min("0"),
+          .required,
+          .autofocus
+        )
+
+        LabeledInput(
+          "Cooling CFM",
+          .name("coolingCFM"),
+          .type(.number),
+          .value(equipmentInfo?.coolingCFM),
+          .placeholder("1000"),
+          .min("0"),
+          .required
+        )
+
+        SubmitButton(title: "Save")
+          .attributes(.class("btn-block my-6"))
+      }
+    }
+  }
+}

Sources/ViewController/Views/EquipmentInfo/EquipmentInfoView.swift

@@ -0,0 +1,63 @@
+import Elementary
+import ManualDCore
+import Styleguide
+
+struct EquipmentInfoView: HTML, Sendable {
+  let equipmentInfo: EquipmentInfo?
+  var projectID: Project.ID
+
+  var body: some HTML {
+    div(
+      .class("space-y-4"),
+      .id("equipmentInfo")
+    ) {
+
+      PageTitleRow {
+        PageTitle { "Equipment Details" }
+
+        EditButton()
+          .attributes(
+            .class("btn-primary"),
+            .showModal(id: EquipmentInfoForm.id)
+          )
+          .tooltip("Edit equipment details")
+      }
+
+      if let equipmentInfo {
+
+        table(.class("table table-zebra")) {
+          tbody(.class("text-lg")) {
+            tr {
+              td { Label { "Static Pressure" } }
+              td {
+                div(.class("flex justify-end")) {
+                  Number(equipmentInfo.staticPressure)
+                }
+              }
+            }
+            tr {
+              td { Label { "Heating CFM" } }
+              td {
+                div(.class("flex justify-end")) {
+                  Number(equipmentInfo.heatingCFM)
+                }
+              }
+            }
+            tr {
+              td { Label { "Cooling CFM" } }
+              td {
+                div(.class("flex justify-end")) {
+                  Number(equipmentInfo.coolingCFM)
+                }
+              }
+            }
+          }
+        }
+      }
+      EquipmentInfoForm(
+        dismiss: equipmentInfo != nil,
+        equipmentInfo: equipmentInfo
+      )
+    }
+  }
+}

Sources/ViewController/Views/FrictionRate/FrictionRateView.swift

@@ -0,0 +1,151 @@
+import Elementary
+import ManualDClient
+import ManualDCore
+import Styleguide
+
+struct FrictionRateView: HTML, Sendable {
+
+  @Environment(ProjectViewValue.$projectID) var projectID
+
+  let componentLosses: [ComponentPressureLoss]
+  let equivalentLengths: EffectiveLength.MaxContainer
+  let frictionRateResponse: ManualDClient.FrictionRateResponse?
+
+  private var availableStaticPressure: Double? {
+    frictionRateResponse?.availableStaticPressure
+  }
+
+  private var frictionRateDesignValue: Double? {
+    frictionRateResponse?.frictionRate
+  }
+
+  private var shouldShowBadges: Bool {
+    frictionRateDesignValue != nil || availableStaticPressure != nil
+  }
+
+  private var badgeColor: String {
+    let base = "badge-info"
+    guard let frictionRateDesignValue else { return base }
+    if frictionRateDesignValue >= 0.18 || frictionRateDesignValue <= 0.02 {
+      return "badge-error"
+    }
+    return base
+  }
+
+  private var showHighErrors: Bool {
+    guard let frictionRateDesignValue else { return false }
+    return frictionRateDesignValue >= 0.18
+  }
+
+  private var showLowErrors: Bool {
+    guard let frictionRateDesignValue else { return false }
+    return frictionRateDesignValue <= 0.02
+  }
+
+  private var showNoComponentLossesError: Bool {
+    componentLosses.count == 0
+  }
+
+  private var showIncompleteSectionsError: Bool {
+    availableStaticPressure == nil || frictionRateDesignValue == nil
+  }
+
+  private var hasAlerts: Bool {
+    showLowErrors
+      || showHighErrors
+      || showNoComponentLossesError
+      || showIncompleteSectionsError
+
+  }
+
+  var body: some HTML {
+    div(.class("space-y-6")) {
+      PageTitleRow {
+        div(.class("grid grid-cols-2 px-4 w-full")) {
+
+          PageTitle { "Friction Rate" }
+
+          div(.class("space-y-2 justify-end font-bold text-lg")) {
+            if shouldShowBadges {
+
+              if let frictionRateDesignValue {
+                LabeledContent {
+                  span { "Friction Rate Design Value" }
+                } content: {
+                  Badge(number: frictionRateDesignValue, digits: 2)
+                    .attributes(.class("\(badgeColor) badge-lg"))
+                    .bold()
+                }
+                .attributes(.class("justify-end mx-auto"))
+              }
+
+              if let availableStaticPressure {
+                LabeledContent {
+                  span { "Available Static Pressure" }
+                } content: {
+                  Badge(number: availableStaticPressure, digits: 2)
+                }
+                .attributes(.class("justify-end mx-auto"))
+              }
+
+              LabeledContent {
+                span { "Component Pressure Losses" }
+              } content: {
+                Badge(number: componentLosses.total, digits: 2)
+              }
+              .attributes(.class("justify-end mx-auto"))
+            }
+          }
+
+          div(.class("text-error font-bold italic col-span-2")) {
+            Alert {
+              p {
+                "Must complete previous sections."
+              }
+            }
+            .hidden(when: !showIncompleteSectionsError)
+
+            Alert {
+              p {
+                "No component pressures losses"
+              }
+            }
+            .hidden(when: !showNoComponentLossesError)
+
+            Alert {
+              p(.class("block")) {
+                "Calculated friction rate is below 0.02. The fan may not deliver the required CFM."
+                br()
+                " * Increase the blower speed"
+                br()
+                " * Increase the blower size"
+                br()
+                " * Decrease the Total Effective Length (TEL)"
+              }
+            }
+            .hidden(when: !showLowErrors)
+
+            Alert {
+              p(.class("block")) {
+                "Calculated friction rate is above 0.18. The fan may deliver too many CFM."
+                br()
+                " * Decrease the blower speed"
+                br()
+                " * Decreae the blower size"
+                br()
+                " * Increase the Total Effective Length (TEL)"
+              }
+            }
+            .hidden(when: !showHighErrors)
+
+          }
+          .attributes(.class("mt-4"), when: hasAlerts)
+        }
+      }
+
+      ComponentPressureLossesView(
+        componentPressureLosses: componentLosses, projectID: projectID
+      )
+    }
+  }
+}

Sources/ViewController/Views/MainPage.swift

@@ -0,0 +1,133 @@
+import Elementary
+import ElementaryHTMX
+import Foundation
+import ManualDCore
+import Styleguide
+
+public struct MainPage<Inner: HTML>: SendableHTMLDocument where Inner: Sendable {
+
+  public var title: String { "Duct Calc" }
+  public var lang: String { "en" }
+
+  let inner: Inner
+  let theme: Theme?
+  let displayFooter: Bool
+
+  init(
+    displayFooter: Bool = true,
+    theme: Theme? = nil,
+    _ inner: () -> Inner
+  ) {
+    self.displayFooter = displayFooter
+    self.theme = theme
+    self.inner = inner()
+  }
+
+  private var summary: String {
+    """
+    Duct sizing based on ACCA, Manual-D.
+    """
+  }
+
+  private var keywords: String {
+    """
+    duct, hvac, duct-design, duct design, manual-d, manual d, design
+    """
+  }
+
+  public var head: some HTML {
+    meta(.charset(.utf8))
+    meta(.name(.viewport), .content("width=device-width, initial-scale=1.0"))
+    meta(.content("ductcalc.com"), .name("og:site_name"))
+    meta(.content("Duct Calc"), .name("og:title"))
+    meta(.content(summary), .name("description"))
+    meta(.content(summary), .name("og:description"))
+    meta(.content("/images/mand_logo.png"), .name("og:image"))
+    meta(.content("/images/mand_logo.png"), .name("twitter:image"))
+    meta(.content("Duct Calc"), .name("twitter:image:alt"))
+    meta(.content("summary_large_image"), .name("twitter:card"))
+    meta(.content("1536"), .name("og:image:width"))
+    meta(.content("1024"), .name("og:image:height"))
+    meta(.content(keywords), .name(.keywords))
+    script(.src("https://unpkg.com/htmx.org@2.0.8")) {}
+    script(.src("/js/main.js")) {}
+    link(.rel(.stylesheet), .href("/css/output.css"))
+    link(
+      .rel(.icon),
+      .href("/images/favicon.ico"),
+      .init(name: "type", value: "image/x-icon")
+    )
+    link(
+      .rel(.icon),
+      .href("/images/favicon-32x32.png"),
+      .init(name: "type", value: "image/png")
+    )
+    link(
+      .rel(.icon),
+      .href("/images/favicon-16x16.png"),
+      .init(name: "type", value: "image/png")
+    )
+    link(
+      .rel(.init(rawValue: "apple-touch-icon")),
+      .init(name: "sizes", value: "180x180"),
+      .href("/images/apple-touch-icon.png")
+    )
+    link(.rel(.init(rawValue: "manifest")), .href("/site.webmanifest"))
+    script(
+      .src("https://unpkg.com/htmx-remove@latest"),
+      .crossorigin(.anonymous),
+      .integrity("sha384-NwB2Xh66PNEYfVki0ao13UAFmdNtMIdBKZ8sNGRT6hKfCPaINuZ4ScxS6vVAycPT")
+    ) {}
+  }
+
+  public var body: some HTML {
+    div(.class("flex flex-col min-h-screen min-w-full justify-between")) {
+      main(.class("flex flex-col min-h-screen min-w-full grow mb-auto")) {
+        inner
+      }
+
+      div(.class("bottom-0 left-0 bg-error")) {
+        if displayFooter {
+          footer(
+            .class(
+              """
+              footer sm:footer-horizontal footer-center
+              bg-base-300 text-base-content p-4
+              """
+            )
+          ) {
+            aside {
+              p {
+                "Copyright © \(Date().description.prefix(4)) - All rights reserved by Michael Housh"
+              }
+            }
+          }
+        }
+      }
+    }
+    .attributes(.data("theme", value: theme?.rawValue ?? "default"), when: theme != nil)
+  }
+}
+
+struct LoggedIn: HTML, Sendable {
+  let next: String
+
+  init(next: String? = nil) {
+    self.next = next ?? SiteRoute.View.router.path(for: .project(.index))
+  }
+
+  var body: some HTML {
+    div(
+      .hx.get(next),
+      .hx.pushURL(true),
+      .hx.target("body"),
+      .hx.trigger(.event(.revealed)),
+      .hx.indicator()
+    ) {
+      Indicator()
+    }
+  }
+
+}
+
+public protocol SendableHTMLDocument: HTMLDocument, Sendable {}

Sources/ViewController/Views/Navbar.swift

@@ -0,0 +1,72 @@
+import Elementary
+import ManualDCore
+import Styleguide
+
+struct Navbar: HTML, Sendable {
+  let sidebarToggle: Bool
+  let userProfile: Bool
+
+  init(
+    sidebarToggle: Bool,
+    userProfile: Bool = true
+  ) {
+    self.sidebarToggle = sidebarToggle
+    self.userProfile = userProfile
+  }
+
+  var body: some HTML<HTMLTag.nav> {
+    nav(
+      .class(
+        """
+        navbar w-full bg-base-300 text-base-content shadow-sm mb-4
+        """
+      )
+    ) {
+      div(.class("flex flex-1 space-x-4 items-center")) {
+        if sidebarToggle {
+          label(
+            .for("my-drawer-1"),
+            .class("size-7"),
+            .init(name: "aria-label", value: "open sidebar")
+          ) {
+            SVG(.sidebarToggle)
+          }
+          .navButton()
+          .tooltip("Open sidebar", position: .right)
+        }
+
+        a(
+          .class("flex w-fit h-fit text-xl items-end px-4 py-2"),
+          .href(route: .project(.index))
+        ) {
+          img(
+            .src("/images/mand_logo_sm.webp"),
+          )
+          span { "Duct Calc" }
+        }
+        .navButton()
+        .tooltip("Home", position: .right)
+      }
+      if userProfile {
+        // TODO: Make dropdown
+        div(.class("flex-none")) {
+          a(
+            .href(route: .user(.profile(.index))),
+          ) {
+            SVG(.circleUser)
+          }
+          .navButton()
+          .tooltip("Profile")
+        }
+      }
+    }
+  }
+}
+
+extension HTML where Tag: HTMLTrait.Attributes.Global {
+  func navButton() -> _AttributedElement<Self> {
+    attributes(
+      .class("btn btn-square btn-ghost hover:bg-neutral hover:text-white")
+    )
+  }
+}

Sources/ViewController/Views/Project/ProjectDetail.swift

@@ -0,0 +1,71 @@
+import Elementary
+import ElementaryHTMX
+import ManualDCore
+import Styleguide
+
+struct ProjectDetail: HTML, Sendable {
+  let project: Project
+
+  var body: some HTML {
+    div {
+      PageTitleRow {
+        PageTitle { "Project" }
+
+        EditButton()
+          .attributes(
+            .class("btn-primary"),
+            .on(.click, "projectForm.showModal()")
+          )
+          .tooltip("Edit project", position: .left)
+      }
+
+      table(.class("table table-zebra text-lg")) {
+        tbody {
+          tr {
+            td(.class("label font-bold")) { "Name" }
+            td {
+              div(.class("flex justify-end")) {
+                project.name
+              }
+            }
+          }
+          tr {
+            td(.class("label font-bold")) { "Street Address" }
+            td {
+              div(.class("flex justify-end")) {
+                project.streetAddress
+              }
+            }
+          }
+          tr {
+            td(.class("label font-bold")) { "City" }
+            td {
+              div(.class("flex justify-end")) {
+                project.city
+              }
+            }
+          }
+          tr {
+            td(.class("label font-bold")) { "State" }
+            td {
+              div(.class("flex justify-end")) {
+                project.state
+              }
+            }
+          }
+          tr {
+            td(.class("label font-bold")) { "Zip" }
+            td {
+              div(.class("flex justify-end")) {
+                project.zipCode
+              }
+            }
+          }
+        }
+      }
+
+      ProjectForm(dismiss: true, project: project)
+    }
+  }
+
+}