fix: Fixes release workflow for multi-platform builds.

.devcontainer/devcontainer.json

@@ -0,0 +1,40 @@
+{
+	"name": "swift-manual-d-dev",
+	"image": "git.housh.dev/michael/swift-dev-container:latest",
+	"features": {
+    "ghcr.io/devcontainers/features/git:1": {
+      "version": "os-provided",
+      "ppa": "false"
+    },
+		"ghcr.io/jsburckhardt/devcontainer-features/just:1": {},
+		"ghcr.io/rocker-org/devcontainer-features/pandoc:1": {},
+		//"ghcr.io/devcontainers/features/docker-in-docker:2": {},
+		"ghcr.io/wxw-matt/devcontainer-features/apt:latest": {
+			"packages": "weasyprint gnupg2 tmux"
+    },
+	  "ghcr.io/swift-server-community/swift-devcontainer-features/jemalloc:1": { },
+
+	},
+	"runArgs": [
+    "--cap-add=SYS_PTRACE",
+    "--security-opt",
+    "seccomp=unconfined"
+  ],
+	"remoteEnv": {
+		// Set TERM, prevents problems when "xterm-ghostty" get's passed from host,
+		// which causes weird typing and display problems.
+		"TERM": "xterm-256color",
+		// Less backtrace error warnings from swift.
+		"SWIFT_BACKTRACE": "enable=no"
+	},
+  "remoteUser": "swift",
+	"forwardPorts": [8080],
+	"mounts": [
+		{
+			"type": "bind", 
+			"source": "${localEnv:HOME}/.local/share/nvim",
+			"target": "/home/swift/.local/share/nvim"
+		}
+	]
+}
+	

.gitea/workflows/ci.yaml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  ubuntu:
+    name: Linux Tests
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup QEMU
+      uses: docker/setup-qemu-action@v3
+    - name: Setup buildx
+      uses: docker/setup-buildx-action@v3 
+    - name: Build test image
+      uses: docker/build-push-action@v6
+      with:
+        context: .
+        file: docker/Dockerfile.test
+        push: false
+        load: true
+        tags: michael/ductcalc:test
+    - name: Run Tests
+      run: |
+        docker run --rm michael/ductcalc:test swift test

.gitea/workflows/release.yaml

@@ -1,6 +1,5 @@
 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']
@@ -8,17 +7,13 @@ on:
       - '*.*.*'
   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 }}
+  IMAGE_NAME: ductcalc
 
-# 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
@@ -27,17 +22,28 @@ jobs:
     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: Set up Docker
+        uses: docker/setup-docker-action@v4
+        with:
+          daemon-config: |
+            {
+              "debug": true,
+              "features": {
+                "containerd-snapshotter": true
+              }
+            }   
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
       - name: Extract metadata (tags, labels) for Docker
         id: meta
         uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
@@ -46,19 +52,18 @@ jobs:
           tags: |
             type=ref,event=branch
             type=semver,pattern={{version}}
+            type=semver,pattern={{major.minor}}
+            type=semver,pattern={{major}}
             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.
+            type=raw,value=latest
+
       - name: Build and push Docker image
         id: push
         uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
         with:
           context: .
           file: docker/Dockerfile
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

.github/workflows/ci.yaml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  ubuntu:
+    name: Linux Tests
+    runs-on: ubuntu:latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup QEMU
+      uses: docker/setup-qemu-action@v3
+    - name: Setup buildx
+      uses: docker/setup-buildx-action@v3 
+    - name: Build test image
+      uses: docker/build-push-action@v6
+      with:
+        context: .
+        file: docker/Dockerfile.test
+        push: false
+        load: true
+        tags: ${{ github.repository_owner }}/ductcalc:test
+    - name: Run Tests
+      run: |
+        docker run --rm ${{ github.repository_owner }}/ductcalc:test swift test

.github/workflows/release.yaml

@@ -0,0 +1,70 @@
+name: Create and publish a Docker image
+
+on:
+  push:
+    # branches: ['main']
+    tags:
+      - '*.*.*'
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ductcalc
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.CONTAINER_TOKEN }}
+
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v4
+        with:
+          daemon-config: |
+            {
+              "debug": true,
+              "features": {
+                "containerd-snapshotter": true
+              }
+            }   
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major.minor}}
+            type=semver,pattern={{major}}
+            type=sha
+            type=raw,value=latest
+
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+

.gitignore

@@ -13,3 +13,5 @@ tailwindcss
 *.pdf
 .env
 .env*
+default.profraw
+/rooms.csv

LICENSE

@@ -1,18 +1,384 @@
-MIT License
+Copyright (c) 2026 Michael Housh II
 
-Copyright (c) 2025 michael
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+Public License
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
-associated documentation files (the "Software"), to deal in the Software without restriction, including 
-without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
-copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the 
-following conditions:
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial-ShareAlike 4.0 International Public License
+("Public License"). To the extent this Public License may be
+interpreted as a contract, You are granted the Licensed Rights in
+consideration of Your acceptance of these terms and conditions, and the
+Licensor grants You such rights in consideration of benefits the
+Licensor receives from making the Licensed Material available under
+these terms and conditions.
 
-The above copyright notice and this permission notice shall be included in all copies or substantial 
-portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
-LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO 
-EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
-USE OR OTHER DEALINGS IN THE SOFTWARE.
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-NC-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution, NonCommercial, and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+
+  l. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  m. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  n. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-NC-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+     including for purposes of Section 3(b); and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+

Package.resolved

@@ -1,5 +1,5 @@
 {
-  "originHash" : "c3efcfd33bc1490f59ae406e4e5292027b2d01cafee9fc625652213505df50fb",
+  "originHash" : "5bbd172c602e6484b32782f8cb68faca2d5120adc511acdff74e62fec2178c15",
   "pins" : [
     {
       "identity" : "async-http-client",
@@ -73,6 +73,15 @@
         "version" : "1.53.0"
       }
     },
+    {
+      "identity" : "fluent-postgres-driver",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/vapor/fluent-postgres-driver.git",
+      "state" : {
+        "revision" : "59bff45a41d1ece1950bb8a6e0006d88c1fb6e69",
+        "version" : "2.12.0"
+      }
+    },
     {
       "identity" : "fluent-sqlite-driver",
       "kind" : "remoteSourceControl",
@@ -100,6 +109,24 @@
         "version" : "0.14.0"
       }
     },
+    {
+      "identity" : "postgres-kit",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/vapor/postgres-kit.git",
+      "state" : {
+        "revision" : "7c079553e9cda74811e627775bf22e40a9405ad9",
+        "version" : "2.15.1"
+      }
+    },
+    {
+      "identity" : "postgres-nio",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/vapor/postgres-nio.git",
+      "state" : {
+        "revision" : "d578b86fb2c8321b114d97cd70831d1a3e9531a6",
+        "version" : "1.30.1"
+      }
+    },
     {
       "identity" : "routing-kit",
       "kind" : "remoteSourceControl",
@@ -145,6 +172,15 @@
         "version" : "1.2.1"
       }
     },
+    {
+      "identity" : "swift-argument-parser",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-argument-parser.git",
+      "state" : {
+        "revision" : "c5d11a805e765f52ba34ec7284bd4fcd6ba68615",
+        "version" : "1.7.0"
+      }
+    },
     {
       "identity" : "swift-asn1",
       "kind" : "remoteSourceControl",
@@ -397,6 +433,15 @@
         "version" : "1.6.3"
       }
     },
+    {
+      "identity" : "swift-tagged",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/pointfreeco/swift-tagged",
+      "state" : {
+        "revision" : "3907a9438f5b57d317001dc99f3f11b46882272b",
+        "version" : "0.10.0"
+      }
+    },
     {
       "identity" : "swift-url-routing",
       "kind" : "remoteSourceControl",
@@ -406,6 +451,15 @@
         "version" : "0.6.2"
       }
     },
+    {
+      "identity" : "swift-validations",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/m-housh/swift-validations.git",
+      "state" : {
+        "revision" : "ae939c146f380ca12d0a04ca1f6b0c4c270fdd5a",
+        "version" : "0.3.5"
+      }
+    },
     {
       "identity" : "vapor",
       "kind" : "remoteSourceControl",

Package.swift

@@ -6,10 +6,11 @@ let package = Package(
   name: "swift-manual-d",
   products: [
     .executable(name: "App", targets: ["App"]),
-    .library(name: "ApiController", targets: ["ApiController"]),
+    .executable(name: "ductcalc", targets: ["CLI"]),
     .library(name: "AuthClient", targets: ["AuthClient"]),
+    .library(name: "CSVParser", targets: ["CSVParser"]),
     .library(name: "DatabaseClient", targets: ["DatabaseClient"]),
-    .library(name: "EnvClient", targets: ["EnvClient"]),
+    .library(name: "EnvVars", targets: ["EnvVars"]),
     .library(name: "FileClient", targets: ["FileClient"]),
     .library(name: "HTMLSnapshotTesting", targets: ["HTMLSnapshotTesting"]),
     .library(name: "PdfClient", targets: ["PdfClient"]),
@@ -20,30 +21,34 @@ let package = Package(
     .library(name: "ViewController", targets: ["ViewController"]),
   ],
   dependencies: [
+    .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.7.0"),
     .package(url: "https://github.com/vapor/vapor.git", from: "4.110.1"),
     .package(url: "https://github.com/vapor/fluent.git", from: "4.9.0"),
     .package(url: "https://github.com/vapor/fluent-sqlite-driver.git", from: "4.6.0"),
+    .package(url: "https://github.com/vapor/fluent-postgres-driver.git", from: "2.0.0"),
     .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-snapshot-testing", from: "1.12.0"),
+    .package(url: "https://github.com/pointfreeco/swift-tagged", from: "0.6.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"),
+    .package(url: "https://github.com/m-housh/swift-validations.git", from: "0.3.5"),
   ],
   targets: [
     .executableTarget(
       name: "App",
       dependencies: [
-        .target(name: "ApiController"),
         .target(name: "AuthClient"),
         .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: "FluentPostgresDriver", package: "fluent-postgres-driver"),
         .product(name: "Vapor", package: "vapor"),
         .product(name: "NIOCore", package: "swift-nio"),
         .product(name: "NIOPosix", package: "swift-nio"),
@@ -51,14 +56,11 @@ let package = Package(
         .product(name: "VaporRouting", package: "vapor-routing"),
       ]
     ),
-    .target(
-      name: "ApiController",
+    .executableTarget(
+      name: "CLI",
       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: "ManualDClient"),
+        .product(name: "ArgumentParser", package: "swift-argument-parser"),
       ]
     ),
     .target(
@@ -70,6 +72,20 @@ let package = Package(
         .product(name: "DependenciesMacros", package: "swift-dependencies"),
       ]
     ),
+    .target(
+      name: "CSVParser",
+      dependencies: [
+        .target(name: "ManualDCore"),
+        .product(name: "Dependencies", package: "swift-dependencies"),
+        .product(name: "DependenciesMacros", package: "swift-dependencies"),
+      ]
+    ),
+    .testTarget(
+      name: "CSVParsingTests",
+      dependencies: [
+        .target(name: "CSVParser")
+      ]
+    ),
     .target(
       name: "DatabaseClient",
       dependencies: [
@@ -78,11 +94,23 @@ let package = Package(
         .product(name: "DependenciesMacros", package: "swift-dependencies"),
         .product(name: "Fluent", package: "fluent"),
         .product(name: "Vapor", package: "vapor"),
+        .product(name: "Validations", package: "swift-validations"),
+      ]
+    ),
+    .testTarget(
+      name: "DatabaseClientTests",
+      dependencies: [
+        .target(name: "App"),
+        .target(name: "DatabaseClient"),
+        .product(name: "DependenciesTestSupport", package: "swift-dependencies"),
+        .product(name: "FluentSQLiteDriver", package: "fluent-sqlite-driver"),
+      ],
+      resources: [
+        .copy("Resources")
       ]
     ),
-
     .target(
-      name: "EnvClient",
+      name: "EnvVars",
       dependencies: [
         .product(name: "Dependencies", package: "swift-dependencies"),
         .product(name: "DependenciesMacros", package: "swift-dependencies"),
@@ -106,7 +134,7 @@ let package = Package(
     .target(
       name: "PdfClient",
       dependencies: [
-        .target(name: "EnvClient"),
+        .target(name: "EnvVars"),
         .target(name: "FileClient"),
         .target(name: "ManualDCore"),
         .product(name: "Dependencies", package: "swift-dependencies"),
@@ -120,11 +148,10 @@ let package = Package(
         .target(name: "HTMLSnapshotTesting"),
         .target(name: "PdfClient"),
         .product(name: "SnapshotTesting", package: "swift-snapshot-testing"),
+      ],
+      resources: [
+        .copy("__Snapshots__")
       ]
-      // ,
-      // resources: [
-      //   .copy("__Snapshots__")
-      // ]
     ),
     .target(
       name: "ProjectClient",
@@ -138,24 +165,20 @@ let package = Package(
     .target(
       name: "ManualDCore",
       dependencies: [
+        .product(name: "CasePaths", package: "swift-case-paths"),
         .product(name: "Dependencies", package: "swift-dependencies"),
         .product(name: "Fluent", package: "fluent"),
+        .product(name: "Tagged", package: "swift-tagged"),
         .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: [
-        "ManualDCore",
+        .target(name: "ManualDCore"),
         .product(name: "Dependencies", package: "swift-dependencies"),
         .product(name: "DependenciesMacros", package: "swift-dependencies"),
+        .product(name: "Tagged", package: "swift-tagged"),
       ]
     ),
     .target(
@@ -177,6 +200,7 @@ let package = Package(
       name: "ViewController",
       dependencies: [
         .target(name: "AuthClient"),
+        .target(name: "CSVParser"),
         .target(name: "DatabaseClient"),
         .target(name: "PdfClient"),
         .target(name: "ProjectClient"),

Public/css/output.css

@@ -7,19 +7,18 @@
     'Noto Color Emoji';
     --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New',
     monospace;
-    --color-red-500: oklch(63.7% 0.237 25.331);
-    --color-red-600: oklch(57.7% 0.245 27.325);
     --color-green-400: oklch(79.2% 0.209 151.711);
-    --color-indigo-600: oklch(51.1% 0.262 276.966);
-    --color-slate-300: oklch(86.9% 0.022 252.894);
-    --color-slate-900: oklch(20.8% 0.042 265.755);
     --color-gray-200: oklch(92.8% 0.006 264.531);
     --color-gray-400: oklch(70.7% 0.022 261.325);
     --color-black: #000;
     --color-white: #fff;
     --spacing: 0.25rem;
+    --text-xs: 0.75rem;
+    --text-xs--line-height: calc(1 / 0.75);
     --text-sm: 0.875rem;
     --text-sm--line-height: calc(1.25 / 0.875);
+    --text-base: 1rem;
+    --text-base--line-height: calc(1.5 / 1);
     --text-lg: 1.125rem;
     --text-lg--line-height: calc(1.75 / 1.125);
     --text-xl: 1.25rem;
@@ -28,10 +27,17 @@
     --text-2xl--line-height: calc(2 / 1.5);
     --text-3xl: 1.875rem;
     --text-3xl--line-height: calc(2.25 / 1.875);
+    --text-4xl: 2.25rem;
+    --text-4xl--line-height: calc(2.5 / 2.25);
+    --text-5xl: 3rem;
+    --text-5xl--line-height: 1;
+    --text-8xl: 6rem;
+    --text-8xl--line-height: 1;
     --font-weight-bold: 700;
     --radius-sm: 0.25rem;
     --radius-md: 0.375rem;
     --radius-lg: 0.5rem;
+    --radius-3xl: 1.5rem;
     --ease-out: cubic-bezier(0, 0, 0.2, 1);
     --ease-in-out: cubic-bezier(0.4, 0, 0.2, 1);
     --default-transition-duration: 150ms;
@@ -1690,6 +1696,9 @@
       opacity: 40%;
     }
   }
+  .pointer-events-none {
+    pointer-events: none;
+  }
   .react-day-picker {
     @layer daisyui.l1.l2.l3 {
       user-select: none;
@@ -4224,6 +4233,9 @@
   .top-2 {
     top: calc(var(--spacing) * 2);
   }
+  .top-10 {
+    top: calc(var(--spacing) * 10);
+  }
   .right-2 {
     right: calc(var(--spacing) * 2);
   }
@@ -4287,6 +4299,9 @@
   .bottom-0 {
     bottom: calc(var(--spacing) * 0);
   }
+  .-left-15 {
+    left: calc(var(--spacing) * -15);
+  }
   .left-0 {
     left: calc(var(--spacing) * 0);
   }
@@ -4679,6 +4694,9 @@
   .z-1 {
     z-index: 1;
   }
+  .z-50 {
+    z-index: 50;
+  }
   .tab-content {
     @layer daisyui.l1.l2.l3 {
       order: var(--tabcontent-order);
@@ -5231,6 +5249,9 @@
   .m-1 {
     margin: calc(var(--spacing) * 1);
   }
+  .m-4 {
+    margin: calc(var(--spacing) * 4);
+  }
   .m-6 {
     margin: calc(var(--spacing) * 6);
   }
@@ -5279,6 +5300,15 @@
       }
     }
   }
+  .-mx-2 {
+    margin-inline: calc(var(--spacing) * -2);
+  }
+  .mx-6 {
+    margin-inline: calc(var(--spacing) * 6);
+  }
+  .mx-10 {
+    margin-inline: calc(var(--spacing) * 10);
+  }
   .mx-auto {
     margin-inline: auto;
   }
@@ -5580,14 +5610,17 @@
       border-width: var(--border, 1px) 0 var(--border, 1px) var(--border, 1px);
     }
   }
+  .ms-10 {
+    margin-inline-start: calc(var(--spacing) * 10);
+  }
   .me-2 {
     margin-inline-end: calc(var(--spacing) * 2);
   }
   .me-4 {
     margin-inline-end: calc(var(--spacing) * 4);
   }
-  .me-6 {
-    margin-inline-end: calc(var(--spacing) * 6);
+  .me-10 {
+    margin-inline-end: calc(var(--spacing) * 10);
   }
   .me-\[140px\] {
     margin-inline-end: 140px;
@@ -5634,12 +5667,21 @@
   .-mt-2 {
     margin-top: calc(var(--spacing) * -2);
   }
+  .mt-2 {
+    margin-top: calc(var(--spacing) * 2);
+  }
   .mt-4 {
     margin-top: calc(var(--spacing) * 4);
   }
   .mt-6 {
     margin-top: calc(var(--spacing) * 6);
   }
+  .mt-10 {
+    margin-top: calc(var(--spacing) * 10);
+  }
+  .mt-30 {
+    margin-top: calc(var(--spacing) * 30);
+  }
   .breadcrumbs {
     @layer daisyui.l1.l2.l3 {
       max-width: 100%;
@@ -5696,6 +5738,9 @@
       }
     }
   }
+  .mr-2 {
+    margin-right: calc(var(--spacing) * 2);
+  }
   .fieldset-legend {
     @layer daisyui.l1.l2.l3 {
       margin-bottom: calc(0.25rem * -1);
@@ -5716,6 +5761,9 @@
       font-weight: 600;
     }
   }
+  .mb-2 {
+    margin-bottom: calc(var(--spacing) * 2);
+  }
   .mb-4 {
     margin-bottom: calc(var(--spacing) * 4);
   }
@@ -6218,6 +6266,9 @@
   .hidden {
     display: none;
   }
+  .inline {
+    display: inline;
+  }
   .inline-block {
     display: inline-block;
   }
@@ -6437,6 +6488,33 @@
       }
     }
   }
+  .\!h-auto {
+    height: auto !important;
+  }
+  .h-3 {
+    height: calc(var(--spacing) * 3);
+  }
+  .h-4 {
+    height: calc(var(--spacing) * 4);
+  }
+  .h-5 {
+    height: calc(var(--spacing) * 5);
+  }
+  .h-6 {
+    height: calc(var(--spacing) * 6);
+  }
+  .h-8 {
+    height: calc(var(--spacing) * 8);
+  }
+  .h-10 {
+    height: calc(var(--spacing) * 10);
+  }
+  .h-12 {
+    height: calc(var(--spacing) * 12);
+  }
+  .h-14 {
+    height: calc(var(--spacing) * 14);
+  }
   .h-\[1em\] {
     height: 1em;
   }
@@ -6446,6 +6524,21 @@
   .h-full {
     height: 100%;
   }
+  .min-h-6 {
+    min-height: calc(var(--spacing) * 6);
+  }
+  .min-h-8 {
+    min-height: calc(var(--spacing) * 8);
+  }
+  .min-h-10 {
+    min-height: calc(var(--spacing) * 10);
+  }
+  .min-h-12 {
+    min-height: calc(var(--spacing) * 12);
+  }
+  .min-h-14 {
+    min-height: calc(var(--spacing) * 14);
+  }
   .min-h-screen {
     min-height: 100vh;
   }
@@ -6577,6 +6670,24 @@
       width: calc(var(--size-selector, 0.25rem) * 4);
     }
   }
+  .w-3 {
+    width: calc(var(--spacing) * 3);
+  }
+  .w-4 {
+    width: calc(var(--spacing) * 4);
+  }
+  .w-5 {
+    width: calc(var(--spacing) * 5);
+  }
+  .w-6 {
+    width: calc(var(--spacing) * 6);
+  }
+  .w-52 {
+    width: calc(var(--spacing) * 52);
+  }
+  .w-\[250px\] {
+    width: 250px;
+  }
   .w-\[330px\] {
     width: 330px;
   }
@@ -6586,6 +6697,12 @@
   .w-full {
     width: 100%;
   }
+  .w-px {
+    width: 1px;
+  }
+  .min-w-0 {
+    min-width: calc(var(--spacing) * 0);
+  }
   .min-w-\[200px\] {
     min-width: 200px;
   }
@@ -6604,6 +6721,12 @@
   .flex-shrink {
     flex-shrink: 1;
   }
+  .flex-shrink-0 {
+    flex-shrink: 0;
+  }
+  .shrink-0 {
+    flex-shrink: 0;
+  }
   .flex-grow {
     flex-grow: 1;
   }
@@ -6626,6 +6749,12 @@
       }
     }
   }
+  .-rotate-45 {
+    rotate: calc(45deg * -1);
+  }
+  .rotate-180 {
+    rotate: 180deg;
+  }
   .swap-flip {
     @layer daisyui.l1.l2 {
       transform-style: preserve-3d;
@@ -6681,6 +6810,12 @@
       }
     }
   }
+  .cursor-not-allowed {
+    cursor: not-allowed;
+  }
+  .cursor-pointer {
+    cursor: pointer;
+  }
   .resize {
     resize: both;
   }
@@ -6719,6 +6854,9 @@
       }
     }
   }
+  .list-disc {
+    list-style-type: disc;
+  }
   .alert-horizontal {
     @layer daisyui.l1.l2 {
       justify-content: start;
@@ -6785,6 +6923,12 @@
       }
     }
   }
+  .grid-flow-col {
+    grid-auto-flow: column;
+  }
+  .grid-flow-row {
+    grid-auto-flow: row;
+  }
   .grid-cols-1 {
     grid-template-columns: repeat(1, minmax(0, 1fr));
   }
@@ -6797,6 +6941,9 @@
   .flex-col {
     flex-direction: column;
   }
+  .flex-row {
+    flex-direction: row;
+  }
   .flex-wrap {
     flex-wrap: wrap;
   }
@@ -6821,22 +6968,21 @@
   .justify-start {
     justify-content: flex-start;
   }
+  .gap-0 {
+    gap: calc(var(--spacing) * 0);
+  }
   .gap-1 {
     gap: calc(var(--spacing) * 1);
   }
   .gap-2 {
     gap: calc(var(--spacing) * 2);
   }
+  .gap-3 {
+    gap: calc(var(--spacing) * 3);
+  }
   .gap-4 {
     gap: calc(var(--spacing) * 4);
   }
-  .space-y-1 {
-    :where(& > :not(:last-child)) {
-      --tw-space-y-reverse: 0;
-      margin-block-start: calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));
-      margin-block-end: calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)));
-    }
-  }
   .space-y-2 {
     :where(& > :not(:last-child)) {
       --tw-space-y-reverse: 0;
@@ -6844,6 +6990,13 @@
       margin-block-end: calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)));
     }
   }
+  .space-y-3 {
+    :where(& > :not(:last-child)) {
+      --tw-space-y-reverse: 0;
+      margin-block-start: calc(calc(var(--spacing) * 3) * var(--tw-space-y-reverse));
+      margin-block-end: calc(calc(var(--spacing) * 3) * calc(1 - var(--tw-space-y-reverse)));
+    }
+  }
   .space-y-4 {
     :where(& > :not(:last-child)) {
       --tw-space-y-reverse: 0;
@@ -6858,6 +7011,9 @@
       margin-block-end: calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)));
     }
   }
+  .gap-x-2 {
+    column-gap: calc(var(--spacing) * 2);
+  }
   .space-x-2 {
     :where(& > :not(:last-child)) {
       --tw-space-x-reverse: 0;
@@ -6885,6 +7041,9 @@
   .overflow-auto {
     overflow: auto;
   }
+  .overflow-hidden {
+    overflow: hidden;
+  }
   .timeline-box {
     @layer daisyui.l1.l2.l3 {
       border: var(--border) solid;
@@ -6967,6 +7126,12 @@
       }
     }
   }
+  .rounded {
+    border-radius: 0.25rem;
+  }
+  .rounded-3xl {
+    border-radius: var(--radius-3xl);
+  }
   .rounded-box {
     border-radius: var(--radius-box);
   }
@@ -6979,6 +7144,9 @@
   .rounded-field {
     border-radius: var(--radius-field);
   }
+  .rounded-full {
+    border-radius: calc(infinity * 1px);
+  }
   .rounded-lg {
     border-radius: var(--radius-lg);
   }
@@ -7170,10 +7338,18 @@
     border-style: var(--tw-border-style);
     border-width: 2px;
   }
+  .border-3 {
+    border-style: var(--tw-border-style);
+    border-width: 3px;
+  }
   .border-b-1 {
     border-bottom-style: var(--tw-border-style);
     border-bottom-width: 1px;
   }
+  .border-b-6 {
+    border-bottom-style: var(--tw-border-style);
+    border-bottom-width: 6px;
+  }
   .badge-dash {
     @layer daisyui.l1.l2 {
       color: var(--badge-color);
@@ -7283,6 +7459,12 @@
       border-color: currentColor;
     }
   }
+  .border-accent {
+    border-color: var(--color-accent);
+  }
+  .border-base-300 {
+    border-color: var(--color-base-300);
+  }
   .border-error {
     border-color: var(--color-error);
   }
@@ -7292,6 +7474,9 @@
   .border-primary {
     border-color: var(--color-primary);
   }
+  .border-success {
+    border-color: var(--color-success);
+  }
   .menu-active {
     :where(:not(ul, details, .menu-title, .btn))& {
       @layer daisyui.l1.l2 {
@@ -7443,21 +7628,21 @@
       }
     }
   }
+  .bg-base-200 {
+    background-color: var(--color-base-200);
+  }
   .bg-base-300 {
     background-color: var(--color-base-300);
   }
+  .bg-current {
+    background-color: currentcolor;
+  }
   .bg-error {
     background-color: var(--color-error);
   }
-  .bg-red-500 {
-    background-color: var(--color-red-500);
-  }
   .bg-secondary {
     background-color: var(--color-secondary);
   }
-  .bg-white {
-    background-color: var(--color-white);
-  }
   .divider-accent {
     @layer daisyui.l1.l2 {
       &:before, &:after {
@@ -7670,6 +7855,9 @@
   .mask-repeat {
     mask-repeat: repeat;
   }
+  .stroke-current {
+    stroke: currentcolor;
+  }
   .checkbox-lg {
     @layer daisyui.l1.l2 {
       padding: 0.3125rem;
@@ -7740,15 +7928,33 @@
       }
     }
   }
+  .\!p-1\.5 {
+    padding: calc(var(--spacing) * 1.5) !important;
+  }
+  .p-1 {
+    padding: calc(var(--spacing) * 1);
+  }
+  .p-1\.5 {
+    padding: calc(var(--spacing) * 1.5);
+  }
   .p-2 {
     padding: calc(var(--spacing) * 2);
   }
+  .p-2\.5 {
+    padding: calc(var(--spacing) * 2.5);
+  }
+  .p-3 {
+    padding: calc(var(--spacing) * 3);
+  }
   .p-4 {
     padding: calc(var(--spacing) * 4);
   }
   .p-6 {
     padding: calc(var(--spacing) * 6);
   }
+  .p-10 {
+    padding: calc(var(--spacing) * 10);
+  }
   .menu-title {
     @layer daisyui.l1.l2.l3 {
       padding-inline: calc(0.25rem * 3);
@@ -7866,18 +8072,36 @@
       }
     }
   }
+  .\!px-0 {
+    padding-inline: calc(var(--spacing) * 0) !important;
+  }
+  .\!px-3 {
+    padding-inline: calc(var(--spacing) * 3) !important;
+  }
+  .px-2 {
+    padding-inline: calc(var(--spacing) * 2);
+  }
   .px-3 {
     padding-inline: calc(var(--spacing) * 3);
   }
   .px-4 {
     padding-inline: calc(var(--spacing) * 4);
   }
-  .py-1\.5 {
-    padding-block: calc(var(--spacing) * 1.5);
+  .px-6 {
+    padding-inline: calc(var(--spacing) * 6);
+  }
+  .px-10 {
+    padding-inline: calc(var(--spacing) * 10);
+  }
+  .py-1 {
+    padding-block: calc(var(--spacing) * 1);
   }
   .py-2 {
     padding-block: calc(var(--spacing) * 2);
   }
+  .py-6 {
+    padding-block: calc(var(--spacing) * 6);
+  }
   .ps-2 {
     padding-inline-start: calc(var(--spacing) * 2);
   }
@@ -7901,6 +8125,12 @@
   .pb-6 {
     padding-bottom: calc(var(--spacing) * 6);
   }
+  .text-center {
+    text-align: center;
+  }
+  .text-left {
+    text-align: left;
+  }
   .file-input-lg {
     @layer daisyui.l1.l2 {
       --size: calc(var(--size-field, 0.25rem) * 12);
@@ -7949,6 +8179,22 @@
     font-size: var(--text-3xl);
     line-height: var(--tw-leading, var(--text-3xl--line-height));
   }
+  .text-4xl {
+    font-size: var(--text-4xl);
+    line-height: var(--tw-leading, var(--text-4xl--line-height));
+  }
+  .text-5xl {
+    font-size: var(--text-5xl);
+    line-height: var(--tw-leading, var(--text-5xl--line-height));
+  }
+  .text-8xl {
+    font-size: var(--text-8xl);
+    line-height: var(--tw-leading, var(--text-8xl--line-height));
+  }
+  .text-base {
+    font-size: var(--text-base);
+    line-height: var(--tw-leading, var(--text-base--line-height));
+  }
   .text-lg {
     font-size: var(--text-lg);
     line-height: var(--tw-leading, var(--text-lg--line-height));
@@ -7961,6 +8207,10 @@
     font-size: var(--text-xl);
     line-height: var(--tw-leading, var(--text-xl--line-height));
   }
+  .text-xs {
+    font-size: var(--text-xs);
+    line-height: var(--tw-leading, var(--text-xs--line-height));
+  }
   .tabs-lg {
     @layer daisyui.l1.l2 {
       --tab-height: calc(var(--size-field, 0.25rem) * 12);
@@ -8515,6 +8765,9 @@
       color: var(--color-warning);
     }
   }
+  .text-accent {
+    color: var(--color-accent);
+  }
   .text-base-content {
     color: var(--color-base-content);
   }
@@ -8530,15 +8783,12 @@
   .text-info {
     color: var(--color-info);
   }
-  .text-slate-900 {
-    color: var(--color-slate-900);
+  .text-primary {
+    color: var(--color-primary);
   }
   .text-success {
     color: var(--color-success);
   }
-  .text-white {
-    color: var(--color-white);
-  }
   .lowercase {
     text-transform: lowercase;
   }
@@ -8600,9 +8850,18 @@
       }
     }
   }
+  .opacity-0 {
+    opacity: 0%;
+  }
+  .opacity-30 {
+    opacity: 30%;
+  }
   .opacity-50 {
     opacity: 50%;
   }
+  .opacity-60 {
+    opacity: 60%;
+  }
   .shadow-2xl {
     --tw-shadow: 0 25px 50px -12px var(--tw-shadow-color, rgb(0 0 0 / 0.25));
     box-shadow: var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow);
@@ -8619,13 +8878,6 @@
     outline-style: var(--tw-outline-style);
     outline-width: 1px;
   }
-  .outline-1 {
-    outline-style: var(--tw-outline-style);
-    outline-width: 1px;
-  }
-  .-outline-offset-1 {
-    outline-offset: calc(1px * -1);
-  }
   .btn-ghost {
     @layer daisyui.l1 {
       &:not(.btn-active, :hover, :active:focus, :focus-visible, input:checked:not(.filter .btn)) {
@@ -8650,9 +8902,6 @@
       }
     }
   }
-  .outline-slate-300 {
-    outline-color: var(--color-slate-300);
-  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -8665,6 +8914,16 @@
     transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
     transition-duration: var(--tw-duration, var(--default-transition-duration));
   }
+  .transition-opacity {
+    transition-property: opacity;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
+  .transition-transform {
+    transition-property: transform, translate, scale, rotate;
+    transition-timing-function: var(--tw-ease, var(--default-transition-timing-function));
+    transition-duration: var(--tw-duration, var(--default-transition-duration));
+  }
   .ease-in-out {
     --tw-ease: var(--ease-in-out);
     transition-timing-function: var(--ease-in-out);
@@ -9406,16 +9665,6 @@
       }
     }
   }
-  .invalid\:border-red-500 {
-    &:invalid {
-      border-color: var(--color-red-500);
-    }
-  }
-  .out-of-range\:border-red-500 {
-    &:out-of-range {
-      border-color: var(--color-red-500);
-    }
-  }
   .hover\:bg-neutral {
     &:hover {
       @media (hover: hover) {
@@ -9423,13 +9672,6 @@
       }
     }
   }
-  .hover\:bg-red-600 {
-    &:hover {
-      @media (hover: hover) {
-        background-color: var(--color-red-600);
-      }
-    }
-  }
   .hover\:text-white {
     &:hover {
       @media (hover: hover) {
@@ -9437,20 +9679,42 @@
       }
     }
   }
-  .focus\:outline {
-    &:focus {
-      outline-style: var(--tw-outline-style);
-      outline-width: 1px;
+  .hover\:opacity-75 {
+    &:hover {
+      @media (hover: hover) {
+        opacity: 75%;
+      }
     }
   }
-  .focus\:-outline-offset-2 {
-    &:focus {
-      outline-offset: calc(2px * -1);
+  .hover\:opacity-100 {
+    &:hover {
+      @media (hover: hover) {
+        opacity: 100%;
+      }
     }
   }
-  .focus\:outline-indigo-600 {
+  .focus\:\!bg-transparent {
     &:focus {
-      outline-color: var(--color-indigo-600);
+      background-color: transparent !important;
+    }
+  }
+  .focus\:outline-none {
+    &:focus {
+      --tw-outline-style: none;
+      outline-style: none;
+    }
+  }
+  .active\:scale-100 {
+    &:active {
+      --tw-scale-x: 100%;
+      --tw-scale-y: 100%;
+      --tw-scale-z: 100%;
+      scale: var(--tw-scale-x) var(--tw-scale-y);
+    }
+  }
+  .active\:\!bg-transparent {
+    &:active {
+      background-color: transparent !important;
     }
   }
   .data-active\:bg-neutral {
@@ -9473,14 +9737,39 @@
       }
     }
   }
+  .md\:mt-15 {
+    @media (width >= 48rem) {
+      margin-top: calc(var(--spacing) * 15);
+    }
+  }
   .md\:grid-cols-2 {
     @media (width >= 48rem) {
       grid-template-columns: repeat(2, minmax(0, 1fr));
     }
   }
-  .md\:grid-cols-3 {
+  .md\:justify-between {
     @media (width >= 48rem) {
-      grid-template-columns: repeat(3, minmax(0, 1fr));
+      justify-content: space-between;
+    }
+  }
+  .md\:place-self-center {
+    @media (width >= 48rem) {
+      place-self: center;
+    }
+  }
+  .md\:place-self-end {
+    @media (width >= 48rem) {
+      place-self: end;
+    }
+  }
+  .md\:place-self-start {
+    @media (width >= 48rem) {
+      place-self: start;
+    }
+  }
+  .md\:justify-self-end {
+    @media (width >= 48rem) {
+      justify-self: flex-end;
     }
   }
   .lg\:drawer-open {
@@ -9536,9 +9825,14 @@
       }
     }
   }
-  .lg\:grid-cols-4 {
+  .lg\:mx-20 {
     @media (width >= 64rem) {
-      grid-template-columns: repeat(4, minmax(0, 1fr));
+      margin-inline: calc(var(--spacing) * 20);
+    }
+  }
+  .lg\:mt-6 {
+    @media (width >= 64rem) {
+      margin-top: calc(var(--spacing) * 6);
     }
   }
   .is-drawer-close\:mx-auto {
@@ -9580,16 +9874,6 @@
       overflow: visible;
     }
   }
-  .is-drawer-close\:text-error {
-    &:where(.drawer-toggle:not(:checked) ~ .drawer-side, .drawer-toggle:not(:checked) ~ .drawer-side *) {
-      color: var(--color-error);
-    }
-  }
-  .is-drawer-close\:text-green-400 {
-    &:where(.drawer-toggle:not(:checked) ~ .drawer-side, .drawer-toggle:not(:checked) ~ .drawer-side *) {
-      color: var(--color-green-400);
-    }
-  }
   .is-drawer-open\:flex {
     &:where(.drawer-toggle:checked ~ .drawer-side, .drawer-toggle:checked ~ .drawer-side *) {
       display: flex;
@@ -11172,6 +11456,21 @@
   syntax: "*";
   inherits: false;
 }
+@property --tw-scale-x {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-y {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
+@property --tw-scale-z {
+  syntax: "*";
+  inherits: false;
+  initial-value: 1;
+}
 @layer properties {
   @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
     *, ::before, ::after, ::backdrop {
@@ -11227,6 +11526,9 @@
       --tw-backdrop-saturate: initial;
       --tw-backdrop-sepia: initial;
       --tw-ease: initial;
+      --tw-scale-x: 1;
+      --tw-scale-y: 1;
+      --tw-scale-z: 1;
     }
   }
 }

README.md

@@ -1,2 +1,2 @@
-# swift-manual-d
+# swift-duct-calc
 

Sources/ApiController/Interface.swift

@@ -1,38 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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 .index:
-        return try await database.projects.detail(id)
-      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/Extensions/ApiController+respond.swift

@@ -1,37 +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))
-    )
-  }
-}
+// 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/Middleware/DependenciesMiddleware.swift

@@ -1,7 +1,8 @@
-import ApiController
+// import ApiController
 import AuthClient
 import DatabaseClient
 import Dependencies
+import EnvVars
 import ManualDCore
 import PdfClient
 import Vapor
@@ -12,27 +13,31 @@ import ViewController
 struct DependenciesMiddleware: AsyncMiddleware {
 
   private let values: DependencyValues.Continuation
-  private let apiController: ApiController
+  // private let apiController: ApiController
   private let database: DatabaseClient
+  private let environment: EnvVars
   private let viewController: ViewController
 
   init(
     database: DatabaseClient,
-    apiController: ApiController = .liveValue,
+    environment: EnvVars,
+    // apiController: ApiController = .liveValue,
     viewController: ViewController = .liveValue
   ) {
     self.values = withEscapedDependencies { $0 }
-    self.apiController = apiController
+    // self.apiController = apiController
     self.database = database
+    self.environment = environment
     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.authClient = .live(on: request)
+        // $0.apiController = apiController
+        $0.auth = .live(on: request)
         $0.database = database
+        $0.environment = environment
         // $0.dateFormatter = .liveValue
         $0.viewController = viewController
         $0.pdfClient = .liveValue

Sources/App/Middleware/ViewRoute+middleware.swift

@@ -14,7 +14,7 @@ private let viewRouteMiddleware: [any Middleware] = [
 extension SiteRoute.View {
   var middleware: [any Middleware]? {
     switch self {
-    case .login, .signup, .test:
+    case .home, .login, .signup, .test, .ductulator, .privacyPolicy:
       return nil
     case .project, .user:
       return viewRouteMiddleware

Sources/App/configure.swift

@@ -1,7 +1,9 @@
 import DatabaseClient
 import Dependencies
 import Elementary
+import EnvVars
 import Fluent
+import FluentPostgresDriver
 import FluentSQLiteDriver
 import ManualDCore
 import NIOSSL
@@ -14,12 +16,15 @@ import ViewController
 // configures your application
 public func configure(
   _ app: Application,
+  in environment: EnvVars,
   makeDatabaseClient: @escaping (any Database) -> DatabaseClient = { .live(database: $0) }
 ) async throws {
   // Setup the database client.
-  let databaseClient = try await setupDatabase(on: app, factory: makeDatabaseClient)
+  let databaseClient = try await setupDatabase(
+    on: app, environment: environment, factory: makeDatabaseClient
+  )
   // Add the global middlewares.
-  addMiddleware(to: app, database: databaseClient)
+  addMiddleware(to: app, database: databaseClient, environment: environment)
   #if DEBUG
     // Live reload of the application for development when launched with the `./swift-dev` command
     // app.lifecycle.use(BrowserSyncHandler())
@@ -33,7 +38,11 @@ public func configure(
   addCommands(to: app)
 }
 
-private func addMiddleware(to app: Application, database databaseClient: DatabaseClient) {
+private func addMiddleware(
+  to app: Application,
+  database databaseClient: DatabaseClient,
+  environment: EnvVars
+) {
   // cors middleware should come before default error middleware using `at: .beginning`
   let corsConfiguration = CORSMiddleware.Configuration(
     allowedOrigin: .all,
@@ -48,16 +57,20 @@ private func addMiddleware(to app: Application, database databaseClient: Databas
 
   app.middleware.use(FileMiddleware(publicDirectory: app.directory.publicDirectory))
   app.middleware.use(app.sessions.middleware)
-  app.middleware.use(DependenciesMiddleware(database: databaseClient))
+  app.middleware.use(DependenciesMiddleware(database: databaseClient, environment: environment))
 }
 
 private func setupDatabase(
   on app: Application,
+  environment: EnvVars,
   factory makeDatabaseClient: @escaping (any Database) -> DatabaseClient
 ) async throws -> DatabaseClient {
   switch app.environment {
-  case .production, .development:
-    let dbFileName = Environment.get("SQLITE_FILENAME") ?? "db.sqlite"
+  case .production:
+    let configuration = try environment.postgresConfiguration()
+    app.databases.use(.postgres(configuration: configuration), as: .psql)
+  case .development:
+    let dbFileName = environment.sqlitePath ?? "db.sqlite"
     app.databases.use(DatabaseConfigurationFactory.sqlite(.file(dbFileName)), as: .sqlite)
   default:
     app.databases.use(DatabaseConfigurationFactory.sqlite(.memory), as: .sqlite)
@@ -65,9 +78,7 @@ private func setupDatabase(
 
   let databaseClient = makeDatabaseClient(app.db)
 
-  if app.environment != .testing {
-    try await app.migrations.add(databaseClient.migrations())
-  }
+  try await app.migrations.add(databaseClient.migrations())
 
   return databaseClient
 }
@@ -102,8 +113,6 @@ extension SiteRoute {
 
   fileprivate func middleware() -> [any Middleware]? {
     switch self {
-    case .api:
-      return nil
     case .health:
       return nil
     case .view(let route):
@@ -119,13 +128,10 @@ private func siteHandler(
   request: Request,
   route: SiteRoute
 ) async throws -> any AsyncResponseEncodable {
-  @Dependency(\.apiController) var apiController
   @Dependency(\.viewController) var viewController
   @Dependency(\.projectClient) var projectClient
 
   switch route {
-  case .api(let route):
-    return try await apiController.respond(route, request: request)
   case .health:
     return HTTPStatus.ok
   // Generating a pdf return's a `Response` instead of `HTML` like other views, so we
@@ -136,3 +142,30 @@ private func siteHandler(
     return try await viewController.respond(route: route, request: request)
   }
 }
+
+extension EnvVars {
+  func postgresConfiguration() throws -> SQLPostgresConfiguration {
+    guard let hostname = postgresHostname,
+      let username = postgresUsername,
+      let password = postgresPassword,
+      let database = postgresDatabase
+    else {
+      throw EnvError("Missing environment variables for postgres connection.")
+    }
+    return .init(
+      hostname: hostname,
+      username: username,
+      password: password,
+      database: database,
+      tls: .disable
+    )
+  }
+}
+
+struct EnvError: Error {
+  let reason: String
+
+  init(_ reason: String) {
+    self.reason = reason
+  }
+}

Sources/App/entrypoint.swift

@@ -1,5 +1,6 @@
 import DatabaseClient
 import Dependencies
+import EnvVars
 import Logging
 import NIOCore
 import NIOPosix
@@ -17,11 +18,15 @@ enum Entrypoint {
     // 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)])
+    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)
+      try await configure(app, in: EnvVars.live())
     } catch {
       app.logger.report(error: error)
       try? await app.asyncShutdown()

Sources/AuthClient/Interface.swift

@@ -5,17 +5,23 @@ import ManualDCore
 import Vapor
 
 extension DependencyValues {
-  public var authClient: AuthClient {
+  /// Authentication dependency, for handling authentication tasks.
+  public var auth: AuthClient {
     get { self[AuthClient.self] }
     set { self[AuthClient.self] = newValue }
   }
 }
 
+/// Represents authentication tasks that are used in the application.
 @DependencyClient
 public struct AuthClient: Sendable {
+  /// Create a new user and log them in.
   public var createAndLogin: @Sendable (User.Create) async throws -> User
+  /// Get the current user.
   public var currentUser: @Sendable () throws -> User
+  /// Login a user.
   public var login: @Sendable (User.Login) async throws -> User
+  /// Logout a user.
   public var logout: @Sendable () throws -> Void
 }
 
@@ -32,6 +38,7 @@ extension AuthClient: TestDependencyKey {
           .init(email: createForm.email, password: createForm.password)
         )
         request.auth.login(user)
+        request.session.authenticate(user)
         request.logger.debug("LOGGED IN: \(user.id)")
         return user
       },

Sources/CLI/Cli.swift

@@ -0,0 +1,14 @@
+import ArgumentParser
+
+@main
+struct DuctCalcCli: AsyncParsableCommand {
+  static let configuration: CommandConfiguration = .init(
+    commandName: "ductcalc",
+    abstract: "Perform duct calculations.",
+    subcommands: [
+      ConvertCommand.self,
+      SizeCommand.self,
+    ],
+    defaultSubcommand: SizeCommand.self
+  )
+}

Sources/CLI/Commands/Convert.swift

@@ -0,0 +1,35 @@
+import ArgumentParser
+import Dependencies
+import ManualDClient
+
+struct ConvertCommand: AsyncParsableCommand {
+
+  static let configuration = CommandConfiguration(
+    commandName: "convert",
+    abstract: "Convert to an equivalent recangular size."
+  )
+
+  @Option(
+    name: .shortAndLong,
+    help: "The height"
+  )
+  var height: Int
+
+  @Argument(
+    // name: .shortAndLong,
+    help: "The round size."
+  )
+  var roundSize: Int
+
+  func run() async throws {
+    @Dependency(\.manualD) var manualD
+
+    let size = try await manualD.rectangularSize(
+      round: .init(roundSize),
+      height: .init(height)
+    )
+
+    print("\(size.width) x \(height)")
+  }
+
+}

Sources/CLI/Commands/Size.swift

@@ -0,0 +1,35 @@
+import ArgumentParser
+import Dependencies
+import ManualDClient
+
+struct SizeCommand: AsyncParsableCommand {
+  static let configuration = CommandConfiguration(
+    commandName: "size",
+    abstract: "Calculate the required size of a duct."
+  )
+
+  @Option(
+    name: .shortAndLong,
+    help: "The design friction rate."
+  )
+  var frictionRate: Double = 0.06
+
+  @Argument(
+    help: "The required CFM for the duct."
+  )
+  var cfm: Int
+
+  func run() async throws {
+    @Dependency(\.manualD) var manualD
+
+    let size = try await manualD.ductSize(cfm: cfm, frictionRate: frictionRate)
+    print(
+      """
+      Calculated: \(size.calculatedSize.string(digits: 2))
+      Final Size: \(size.finalSize)
+      Flex Size: \(size.flexSize)
+      """
+    )
+
+  }
+}

Sources/CSVParser/Interface.swift

@@ -0,0 +1,42 @@
+import Dependencies
+import DependenciesMacros
+import ManualDCore
+import Parsing
+
+extension DependencyValues {
+  public var csvParser: CSVParser {
+    get { self[CSVParser.self] }
+    set { self[CSVParser.self] = newValue }
+  }
+}
+
+@DependencyClient
+public struct CSVParser: Sendable {
+  public var parseRooms: @Sendable (Room.CSV) async throws -> [Room.CSV.Row]
+}
+
+extension CSVParser: DependencyKey {
+  public static let testValue = Self()
+
+  public static let liveValue = Self(
+    parseRooms: { csv in
+      guard let string = String(data: csv.file, encoding: .utf8) else {
+        throw CSVParsingError("Unreadable file data")
+      }
+      let rows = try RoomCSVParser().parse(string[...].utf8)
+      return rows.reduce(into: [Room.CSV.Row]()) {
+        if case .room(let room) = $1 {
+          $0.append(room)
+        }
+      }
+    }
+  )
+}
+
+public struct CSVParsingError: Error {
+  let reason: String
+
+  public init(_ reason: String) {
+    self.reason = reason
+  }
+}

Sources/CSVParser/Internal/Room+parsing.swift

@@ -0,0 +1,64 @@
+import ManualDCore
+import Parsing
+
+struct RoomCSVParser: Parser {
+  var body: some Parser<Substring.UTF8View, [RoomRowType]> {
+    Many {
+      RoomRowParser()
+    } separator: {
+      "\n".utf8
+    }
+  }
+}
+
+struct RoomRowParser: Parser {
+
+  var body: some Parser<Substring.UTF8View, RoomRowType> {
+    OneOf {
+      RoomCreateParser().map { RoomRowType.room($0) }
+      Prefix { $0 != UInt8(ascii: "\n") }
+        .map(.string)
+        .map { RoomRowType.header($0) }
+    }
+  }
+}
+
+enum RoomRowType {
+  case header(String)
+  case room(Room.CSV.Row)
+}
+
+struct RoomCreateParser: ParserPrinter {
+
+  // FIX: The delegated to field won't work here, as we potentially have not created
+  //    the room yet, so we will need an intermediate representation for the csv data
+  //    that uses a room's name or disregard and require user to delegate airflow in
+  //    the ui.
+  var body: some ParserPrinter<Substring.UTF8View, Room.CSV.Row> {
+    ParsePrint {
+      Prefix { $0 != UInt8(ascii: ",") }.map(.string)
+      ",".utf8
+      Optionally {
+        Int.parser()
+          .map(.memberwise(Room.Level.init(rawValue:)))
+      }
+      ",".utf8
+      Double.parser()
+      ",".utf8
+      Optionally {
+        Double.parser()
+      }
+      ",".utf8
+      Optionally {
+        Double.parser()
+      }
+      ",".utf8
+      Int.parser()
+      ",".utf8
+      Optionally {
+        Prefix { $0 != UInt8(ascii: "\n") }.map(.string)
+      }
+    }
+    .map(.memberwise(Room.CSV.Row.init))
+  }
+}

Sources/DatabaseClient/Interface.swift

@@ -4,23 +4,134 @@ import FluentKit
 import ManualDCore
 
 extension DependencyValues {
+  /// The database dependency.
   public var database: DatabaseClient {
     get { self[DatabaseClient.self] }
     set { self[DatabaseClient.self] = newValue }
   }
 }
 
+/// Represents the database interactions used by the application.
 @DependencyClient
 public struct DatabaseClient: Sendable {
+  /// Database migrations.
   public var migrations: Migrations
+  /// Interactions with the projects table.
   public var projects: Projects
+  /// Interactions with the rooms table.
   public var rooms: Rooms
+  /// Interactions with the equipment table.
   public var equipment: Equipment
-  public var componentLoss: ComponentLoss
-  public var effectiveLength: EffectiveLengthClient
+  /// Interactions with the component losses table.
+  public var componentLosses: ComponentLosses
+  /// Interactions with the equivalent lengths table.
+  public var equivalentLengths: EquivalentLengths
+  /// Interactions with the users table.
   public var users: Users
-  public var userProfile: UserProfile
+  /// Interactions with the user profiles table.
+  public var userProfiles: UserProfiles
+  /// Interactions with the trunk sizes table.
   public var trunkSizes: TrunkSizes
+
+  @DependencyClient
+  public struct ComponentLosses: 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
+  }
+
+  @DependencyClient
+  public struct EquivalentLengths: Sendable {
+    public var create: @Sendable (EquivalentLength.Create) async throws -> EquivalentLength
+    public var delete: @Sendable (EquivalentLength.ID) async throws -> Void
+    public var fetch: @Sendable (Project.ID) async throws -> [EquivalentLength]
+    public var fetchMax: @Sendable (Project.ID) async throws -> EquivalentLength.MaxContainer
+    public var get: @Sendable (EquivalentLength.ID) async throws -> EquivalentLength?
+    public var update:
+      @Sendable (EquivalentLength.ID, EquivalentLength.Update) async throws -> EquivalentLength
+  }
+
+  @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
+  }
+
+  @DependencyClient
+  public struct Migrations: Sendable {
+    public var all: @Sendable () async throws -> [any AsyncMigration]
+
+    public func callAsFunction() async throws -> [any AsyncMigration] {
+      try await self.all()
+    }
+  }
+
+  @DependencyClient
+  public struct Projects: Sendable {
+    public var create: @Sendable (User.ID, Project.Create) async throws -> Project
+    public var delete: @Sendable (Project.ID) async throws -> Void
+    public var detail: @Sendable (Project.ID) async throws -> Project.Detail?
+    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
+  }
+
+  @DependencyClient
+  public struct Rooms: Sendable {
+    public var create: @Sendable (Project.ID, Room.Create) async throws -> Room
+    public var createMany: @Sendable (Project.ID, [Room.Create]) async throws -> [Room]
+    public var createFromCSV: @Sendable (Project.ID, [Room.CSV.Row]) async throws -> [Room]
+    public var delete: @Sendable (Room.ID) async throws -> Void
+    public var deleteRectangularSize:
+      @Sendable (Room.ID, Room.RectangularSize.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, Room.RectangularSize) async throws -> Room
+
+  }
+
+  @DependencyClient
+  public struct TrunkSizes: Sendable {
+    public var create: @Sendable (TrunkSize.Create) async throws -> TrunkSize
+    public var delete: @Sendable (TrunkSize.ID) async throws -> Void
+    public var fetch: @Sendable (Project.ID) async throws -> [TrunkSize]
+    public var get: @Sendable (TrunkSize.ID) async throws -> TrunkSize?
+    public var update:
+      @Sendable (TrunkSize.ID, TrunkSize.Update) async throws ->
+        TrunkSize
+  }
+
+  @DependencyClient
+  public struct UserProfiles: 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
+  }
+
+  @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: TestDependencyKey {
@@ -29,10 +140,10 @@ extension DatabaseClient: TestDependencyKey {
     projects: .testValue,
     rooms: .testValue,
     equipment: .testValue,
-    componentLoss: .testValue,
-    effectiveLength: .testValue,
+    componentLosses: .testValue,
+    equivalentLengths: .testValue,
     users: .testValue,
-    userProfile: .testValue,
+    userProfiles: .testValue,
     trunkSizes: .testValue
   )
 
@@ -42,44 +153,11 @@ extension DatabaseClient: TestDependencyKey {
       projects: .live(database: database),
       rooms: .live(database: database),
       equipment: .live(database: database),
-      componentLoss: .live(database: database),
-      effectiveLength: .live(database: database),
+      componentLosses: .live(database: database),
+      equivalentLengths: .live(database: database),
       users: .live(database: database),
-      userProfile: .live(database: database),
+      userProfiles: .live(database: database),
       trunkSizes: .live(database: database)
     )
   }
 }
-
-extension DatabaseClient {
-  @DependencyClient
-  public struct Migrations: Sendable {
-    public var run: @Sendable () async throws -> [any AsyncMigration]
-
-    public func callAsFunction() async throws -> [any AsyncMigration] {
-      try await self.run()
-    }
-  }
-}
-
-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(),
-        TrunkSize.Migrate(),
-      ]
-    }
-  )
-}

Sources/DatabaseClient/Internal/Array+validator.swift

@@ -0,0 +1,48 @@
+import Validations
+
+extension Validator {
+
+  static func validate<Child: Validatable>(
+    _ toChild: KeyPath<Value, [Child]>
+  )
+    -> Self
+  {
+    self.mapValue({ $0[keyPath: toChild] }, with: ArrayValidator())
+  }
+
+  static func validate<Child: Validatable>(
+    _ toChild: KeyPath<Value, [Child]?>
+  )
+    -> Self
+  {
+    self.mapValue({ $0[keyPath: toChild] }, with: ArrayValidator().optional())
+  }
+}
+
+extension Array where Element: Validatable {
+  static func validator() -> some Validation<Self> {
+    ArrayValidator<Element>()
+  }
+}
+
+struct ArrayValidator<Element>: Validation where Element: Validatable {
+  func validate(_ value: [Element]) throws {
+    for item in value {
+      try item.validate()
+    }
+  }
+}
+
+struct ForEachValidator<T, E>: Validation where T: Validation, T.Value == E {
+  let validator: T
+
+  init(@ValidationBuilder<E> builder: () -> T) {
+    self.validator = builder()
+  }
+
+  func validate(_ value: [E]) throws {
+    for item in value {
+      try validator.validate(item)
+    }
+  }
+}

Sources/DatabaseClient/Internal/ComponentLosses.swift

@@ -3,31 +3,19 @@ import DependenciesMacros
 import Fluent
 import Foundation
 import ManualDCore
+import SQLKit
+import Validations
 
-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 {
+extension DatabaseClient.ComponentLosses: TestDependencyKey {
   public static let testValue = Self()
 }
 
-extension DatabaseClient.ComponentLoss {
+extension DatabaseClient.ComponentLosses {
   public static func live(database: any Database) -> Self {
     .init(
       create: { request in
-        let model = try request.toModel()
-        try await model.save(on: database)
+        let model = request.toModel()
+        try await model.validateAndSave(on: database)
         return try model.toDTO()
       },
       delete: { id in
@@ -48,13 +36,13 @@ extension DatabaseClient.ComponentLoss {
         try await ComponentLossModel.find(id, on: database).map { try $0.toDTO() }
       },
       update: { id, updates in
-        try updates.validate()
+        // 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)
+          try await model.validateAndSave(on: database)
         }
         return try model.toDTO()
       }
@@ -64,40 +52,9 @@ extension DatabaseClient.ComponentLoss {
 
 extension ComponentPressureLoss.Create {
 
-  func toModel() throws(ValidationError) -> ComponentLossModel {
-    try validate()
+  func toModel() -> ComponentLossModel {
     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 {
@@ -184,3 +141,19 @@ final class ComponentLossModel: Model, @unchecked Sendable {
     }
   }
 }
+
+extension ComponentLossModel: Validatable {
+
+  var body: some Validation<ComponentLossModel> {
+    Validator.accumulating {
+      Validator.validate(\.name, with: .notEmpty())
+        .errorLabel("Name", inline: true)
+
+      Validator.validate(\.value) {
+        Double.greaterThan(0.0)
+        Double.lessThanOrEquals(1.0)
+      }
+      .errorLabel("Value", inline: true)
+    }
+  }
+}

Sources/DatabaseClient/Internal/Equipment.swift

@@ -3,29 +3,16 @@ 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
-  }
-}
+import Validations
 
 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)
+        let model = request.toModel()
+        try await model.validateAndSave(on: database)
         return try model.toDTO()
       },
       delete: { id in
@@ -51,10 +38,9 @@ extension DatabaseClient.Equipment {
         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)
+          try await model.validateAndSave(on: database)
         }
         return try model.toDTO()
       }
@@ -64,8 +50,7 @@ extension DatabaseClient.Equipment {
 
 extension EquipmentInfo.Create {
 
-  func toModel() throws(ValidationError) -> EquipmentModel {
-    try validate()
+  func toModel() -> EquipmentModel {
     return .init(
       staticPressure: staticPressure,
       heatingCFM: heatingCFM,
@@ -74,44 +59,6 @@ extension EquipmentInfo.Create {
     )
   }
 
-  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 {
@@ -211,3 +158,22 @@ final class EquipmentModel: Model, @unchecked Sendable {
     }
   }
 }
+
+extension EquipmentModel: Validatable {
+
+  var body: some Validation<EquipmentModel> {
+    Validator.accumulating {
+      Validator.validate(\.staticPressure) {
+        Double.greaterThan(0.0)
+        Double.lessThan(1.0)
+      }
+      .errorLabel("Static Pressure", inline: true)
+
+      Validator.validate(\.heatingCFM, with: .greaterThan(0))
+        .errorLabel("Heating CFM", inline: true)
+
+      Validator.validate(\.coolingCFM, with: .greaterThan(0))
+        .errorLabel("Cooling CFM", inline: true)
+    }
+  }
+}

Sources/DatabaseClient/Internal/EquivalentLengths.swift

@@ -3,28 +3,16 @@ import DependenciesMacros
 import Fluent
 import Foundation
 import ManualDCore
+import Validations
 
-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 {
+extension DatabaseClient.EquivalentLengths: 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)
+        try await model.validateAndSave(on: database)
         return try model.toDTO()
       },
       delete: { id in
@@ -66,7 +54,7 @@ extension DatabaseClient.EffectiveLengthClient: TestDependencyKey {
         }
         try model.applyUpdates(updates)
         if model.hasChanges {
-          try await model.save(on: database)
+          try await model.validateAndSave(on: database)
         }
         return try model.toDTO()
       }
@@ -74,10 +62,12 @@ extension DatabaseClient.EffectiveLengthClient: TestDependencyKey {
   }
 }
 
-extension EffectiveLength.Create {
+extension EquivalentLength.Create {
 
   func toModel() throws -> EffectiveLengthModel {
-    try validate()
+    if groups.count > 0 {
+      try [EquivalentLength.FittingGroup].validator().validate(groups)
+    }
     return try .init(
       name: name,
       type: type.rawValue,
@@ -86,15 +76,9 @@ extension EffectiveLength.Create {
       projectID: projectID
     )
   }
-
-  func validate() throws(ValidationError) {
-    guard !name.isEmpty else {
-      throw ValidationError("Effective length name can not be empty.")
-    }
-  }
 }
 
-extension EffectiveLength {
+extension EquivalentLength {
 
   struct Migrate: AsyncMigration {
     let name = "CreateEffectiveLength"
@@ -173,20 +157,20 @@ final class EffectiveLengthModel: Model, @unchecked Sendable {
     $project.id = projectID
   }
 
-  func toDTO() throws -> EffectiveLength {
+  func toDTO() throws -> EquivalentLength {
     try .init(
       id: requireID(),
       projectID: $project.id,
       name: name,
       type: .init(rawValue: type)!,
       straightLengths: straightLengths,
-      groups: JSONDecoder().decode([EffectiveLength.Group].self, from: groups),
+      groups: JSONDecoder().decode([EquivalentLength.FittingGroup].self, from: groups),
       createdAt: createdAt!,
       updatedAt: updatedAt!
     )
   }
 
-  func applyUpdates(_ updates: EffectiveLength.Update) throws {
+  func applyUpdates(_ updates: EquivalentLength.Update) throws {
     if let name = updates.name, name != self.name {
       self.name = name
     }
@@ -197,7 +181,51 @@ final class EffectiveLengthModel: Model, @unchecked Sendable {
       self.straightLengths = straightLengths
     }
     if let groups = updates.groups {
+      if groups.count > 0 {
+        try [EquivalentLength.FittingGroup].validator().validate(groups)
+      }
       self.groups = try JSONEncoder().encode(groups)
     }
   }
 }
+
+extension EffectiveLengthModel: Validatable {
+
+  var body: some Validation<EffectiveLengthModel> {
+    Validator.accumulating {
+      Validator.validate(\.name, with: .notEmpty())
+        .errorLabel("Name", inline: true)
+
+      Validator.validate(
+        \.straightLengths,
+        with: [Int].empty().or(
+          ForEachValidator {
+            Int.greaterThan(0)
+          })
+      )
+      .errorLabel("Straight Lengths", inline: true)
+    }
+  }
+}
+
+extension EquivalentLength.FittingGroup: Validatable {
+
+  public var body: some Validation<Self> {
+    Validator.accumulating {
+      Validator.validate(\.group) {
+        Int.greaterThanOrEquals(1)
+        Int.lessThanOrEquals(12)
+      }
+      .errorLabel("Group", inline: true)
+
+      Validator.validate(\.letter, with: .regex(matching: "[a-zA-Z]"))
+        .errorLabel("Letter", inline: true)
+
+      Validator.validate(\.value, with: .greaterThan(0))
+        .errorLabel("Value", inline: true)
+
+      Validator.validate(\.quantity, with: .greaterThanOrEquals(1))
+        .errorLabel("Quantity", inline: true)
+    }
+  }
+}

Sources/DatabaseClient/Internal/Migrations.swift

@@ -0,0 +1,22 @@
+import Dependencies
+import ManualDCore
+
+extension DatabaseClient.Migrations: DependencyKey {
+  public static let testValue = Self()
+
+  public static let liveValue = Self(
+    all: {
+      [
+        Project.Migrate(),
+        User.Migrate(),
+        User.Token.Migrate(),
+        User.Profile.Migrate(),
+        ComponentPressureLoss.Migrate(),
+        EquipmentInfo.Migrate(),
+        Room.Migrate(),
+        EquivalentLength.Migrate(),
+        TrunkSize.Migrate(),
+      ]
+    }
+  )
+}

Sources/DatabaseClient/Internal/Model+validateAndSave.swift

@@ -0,0 +1,10 @@
+import Fluent
+import Validations
+
+extension Model where Self: Validations.Validatable {
+
+  func validateAndSave(on database: any Database) async throws {
+    try self.validate()
+    try await self.save(on: database)
+  }
+}

Sources/DatabaseClient/Internal/Projects.swift

@@ -3,20 +3,7 @@ import DependenciesMacros
 import Fluent
 import Foundation
 import ManualDCore
-
-extension DatabaseClient {
-  @DependencyClient
-  public struct Projects: Sendable {
-    public var create: @Sendable (User.ID, Project.Create) async throws -> Project
-    public var delete: @Sendable (Project.ID) async throws -> Void
-    public var detail: @Sendable (Project.ID) async throws -> Project.Detail?
-    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
-  }
-}
+import Validations
 
 extension DatabaseClient.Projects: TestDependencyKey {
   public static let testValue = Self()
@@ -24,8 +11,8 @@ extension DatabaseClient.Projects: TestDependencyKey {
   public static func live(database: any Database) -> Self {
     .init(
       create: { userID, request in
-        let model = try request.toModel(userID: userID)
-        try await model.save(on: database)
+        let model = request.toModel(userID: userID)
+        try await model.validateAndSave(on: database)
         return try model.toDTO()
       },
       delete: { id in
@@ -35,28 +22,7 @@ extension DatabaseClient.Projects: TestDependencyKey {
         try await model.delete(on: database)
       },
       detail: { id in
-        guard
-          let model = try await ProjectModel.query(on: database)
-            .with(\.$componentLosses)
-            .with(\.$equipment)
-            .with(\.$equivalentLengths)
-            .with(\.$rooms)
-            .with(
-              \.$trunks,
-              { trunk in
-                trunk.with(
-                  \.$rooms,
-                  {
-                    $0.with(\.$room)
-                  }
-                )
-              }
-            )
-            .filter(\.$id == id)
-            .first()
-        else {
-          throw NotFoundError()
-        }
+        let model = try await ProjectModel.fetchDetail(for: id, on: database)
 
         // TODO: Different error ??
         guard let equipmentInfo = model.equipment else { return nil }
@@ -76,44 +42,25 @@ extension DatabaseClient.Projects: TestDependencyKey {
         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()
-
+        let model = try await ProjectModel.fetchDetail(for: id, on: database)
         var equivalentLengthsCompleted = false
 
-        if equivalentLengths.filter({ $0.type == "supply" }).first != nil,
-          equivalentLengths.filter({ $0.type == "return" }).first != nil
+        if model.equivalentLengths.filter({ $0.type == "supply" }).first != nil,
+          model.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,
+          equipmentInfo: model.equipment != nil,
+          rooms: model.rooms.count > 0,
           equivalentLength: equivalentLengthsCompleted,
-          frictionRate: componentLosses > 0
+          frictionRate: model.componentLosses.count > 0
         )
       },
       getSensibleHeatRatio: { id in
         guard
-          let shr = try await ProjectModel.query(on: database)
+          let model = try await ProjectModel.query(on: database)
             .field(\.$id)
             .field(\.$sensibleHeatRatio)
             .filter(\.$id == id)
@@ -121,7 +68,7 @@ extension DatabaseClient.Projects: TestDependencyKey {
         else {
           throw NotFoundError()
         }
-        return shr.sensibleHeatRatio
+        return model.sensibleHeatRatio
       },
       fetch: { userID, request in
         try await ProjectModel.query(on: database)
@@ -135,10 +82,9 @@ extension DatabaseClient.Projects: TestDependencyKey {
         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)
+          try await model.validateAndSave(on: database)
         }
         return try model.toDTO()
       }
@@ -148,8 +94,7 @@ extension DatabaseClient.Projects: TestDependencyKey {
 
 extension Project.Create {
 
-  func toModel(userID: User.ID) throws -> ProjectModel {
-    try validate()
+  func toModel(userID: User.ID) -> ProjectModel {
     return .init(
       name: name,
       streetAddress: streetAddress,
@@ -160,70 +105,6 @@ extension Project.Create {
     )
   }
 
-  func validate() throws(ValidationError) {
-    guard !name.isEmpty else {
-      throw ValidationError("Project name should not be empty.")
-    }
-    guard !streetAddress.isEmpty else {
-      throw ValidationError("Project street address should not be empty.")
-    }
-    guard !city.isEmpty else {
-      throw ValidationError("Project city should not be empty.")
-    }
-    guard !state.isEmpty else {
-      throw ValidationError("Project state should not be empty.")
-    }
-    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.")
-      }
-    }
-  }
 }
 
 extension Project {
@@ -241,7 +122,7 @@ extension Project {
         .field("sensibleHeatRatio", .double)
         .field("createdAt", .datetime)
         .field("updatedAt", .datetime)
-        .field("userID", .uuid, .required, .references(UserModel.schema, "id"))
+        .field("userID", .uuid, .required, .references(UserModel.schema, "id", onDelete: .cascade))
         .unique(on: "userID", "name")
         .create()
     }
@@ -364,4 +245,67 @@ final class ProjectModel: Model, @unchecked Sendable {
       self.sensibleHeatRatio = sensibleHeatRatio
     }
   }
+
+  /// Returns a ``ProjectModel`` with all the relations eagerly loaded.
+  static func fetchDetail(
+    for projectID: Project.ID,
+    on database: any Database
+  ) async throws -> ProjectModel {
+    guard
+      let model =
+        try await ProjectModel.query(on: database)
+        .with(\.$componentLosses)
+        .with(\.$equipment)
+        .with(\.$equivalentLengths)
+        .with(\.$rooms)
+        .with(
+          \.$trunks,
+          { trunk in
+            trunk.with(
+              \.$rooms,
+              {
+                $0.with(\.$room)
+              }
+            )
+          }
+        )
+        .filter(\.$id == projectID)
+        .first()
+    else {
+      throw NotFoundError()
+    }
+    return model
+  }
+}
+
+extension ProjectModel: Validatable {
+
+  var body: some Validation<ProjectModel> {
+    Validator.accumulating {
+      Validator.validate(\.name, with: .notEmpty())
+        .errorLabel("Name", inline: true)
+
+      Validator.validate(\.streetAddress, with: .notEmpty())
+        .errorLabel("Address", inline: true)
+
+      Validator.validate(\.city, with: .notEmpty())
+        .errorLabel("City", inline: true)
+
+      Validator.validate(\.state, with: .notEmpty())
+        .errorLabel("State", inline: true)
+
+      Validator.validate(\.zipCode, with: .notEmpty())
+        .errorLabel("Zip", inline: true)
+
+      Validator.validate(\.sensibleHeatRatio) {
+        Validator {
+          Double.greaterThan(0)
+          Double.lessThanOrEquals(1.0)
+        }
+        .optional()
+      }
+      .errorLabel("Sensible Heat Ratio", inline: true)
+
+    }
+  }
 }

Sources/DatabaseClient/Internal/Rooms.swift

@@ -0,0 +1,396 @@
+import Dependencies
+import DependenciesMacros
+import Fluent
+import Foundation
+import ManualDCore
+import Validations
+
+extension DatabaseClient.Rooms: TestDependencyKey {
+  public static let testValue = Self()
+
+  public static func live(database: any Database) -> Self {
+    .init(
+      create: { projectID, request in
+        let model = try request.toModel(projectID: projectID)
+        try await model.validateAndSave(on: database)
+        return try model.toDTO()
+      },
+      createMany: { projectID, rooms in
+        try await RoomModel.createMany(projectID: projectID, rooms: rooms, on: database)
+      },
+      createFromCSV: { projectID, rows in
+
+        database.logger.debug("\nCreate From CSV rows: \(rows)\n")
+
+        // Filter out rows that delegate their airflow / load to another room,
+        // these need to be created last.
+        let rowsThatDelegate = rows.filter({
+          $0.delegatedToName != nil && $0.delegatedToName != ""
+        })
+
+        // Filter out the rest of the rooms that don't delegate their airflow / loads.
+        let initialRooms = rows.filter({
+          $0.delegatedToName == nil || $0.delegatedToName == ""
+        })
+        .map(\.createModel)
+
+        database.logger.debug("\nInitial rows: \(initialRooms)\n")
+
+        let initialCreated = try await RoomModel.createMany(
+          projectID: projectID,
+          rooms: initialRooms,
+          on: database
+        )
+        database.logger.debug("\nInitially created rows: \(initialCreated)\n")
+
+        let roomsThatDelegateModels = try rowsThatDelegate.reduce(into: [Room.Create]()) {
+          array, row in
+          database.logger.debug("\n\(row.name), delegating to: \(row.delegatedToName!)\n")
+          guard let created = initialCreated.first(where: { $0.name == row.delegatedToName }) else {
+            database.logger.debug(
+              "\nUnable to find created room with name: \(row.delegatedToName!)\n"
+            )
+            throw NotFoundError()
+          }
+          array.append(
+            Room.Create.init(
+              name: row.name,
+              level: row.level,
+              heatingLoad: row.heatingLoad,
+              coolingTotal: row.coolingTotal,
+              coolingSensible: row.coolingSensible,
+              registerCount: 0,
+              delegatedTo: created.id
+            )
+          )
+        }
+
+        return try await RoomModel.createMany(
+          projectID: projectID,
+          rooms: roomsThatDelegateModels,
+          on: database
+        ) + initialCreated
+
+      },
+      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.rectangularSizes?.count == 0 {
+          model.rectangularSizes = nil
+        }
+        if model.hasChanges {
+          try await model.validateAndSave(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()
+        }
+        model.applyUpdates(updates)
+        if model.hasChanges {
+          try await model.validateAndSave(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.CSV.Row {
+  fileprivate var createModel: Room.Create {
+    assert(delegatedToName == nil || delegatedToName == "")
+    return .init(
+      name: name,
+      level: level,
+      heatingLoad: heatingLoad,
+      coolingTotal: coolingTotal,
+      coolingSensible: coolingSensible,
+      registerCount: registerCount,
+      delegatedTo: nil
+    )
+  }
+}
+
+extension RoomModel {
+  fileprivate static func createMany(
+    projectID: Project.ID,
+    rooms: [Room.Create],
+    on database: any Database
+  ) async throws -> [Room] {
+    try await rooms.asyncMap { request in
+      let model = try request.toModel(projectID: projectID)
+      try await model.validateAndSave(on: database)
+      return try model.toDTO()
+    }
+  }
+}
+
+extension Room.Create {
+
+  func toModel(projectID: Project.ID) throws -> RoomModel {
+    var registerCount = registerCount
+    // Set register count appropriately when delegatedTo is set / changes.
+    if delegatedTo != nil {
+      registerCount = 0
+    } else if registerCount == 0 {
+      registerCount = 1
+    }
+
+    return .init(
+      name: name,
+      level: level?.rawValue,
+      heatingLoad: heatingLoad,
+      coolingLoad: coolingLoad,
+      registerCount: registerCount,
+      delegetedToID: delegatedTo,
+      projectID: projectID
+    )
+  }
+}
+
+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("level", .int8)
+        .field("heatingLoad", .double, .required)
+        .field("coolingLoad", .dictionary, .required)
+        .field("registerCount", .int8, .required)
+        .field("delegatedToID", .uuid, .references(RoomModel.schema, "id"))
+        .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, Validatable {
+
+  static let schema = "room"
+
+  @ID(key: .id)
+  var id: UUID?
+
+  @Field(key: "name")
+  var name: String
+
+  @Field(key: "level")
+  var level: Int?
+
+  @Field(key: "heatingLoad")
+  var heatingLoad: Double
+
+  @Field(key: "coolingLoad")
+  var coolingLoad: Room.CoolingLoad
+
+  @Field(key: "registerCount")
+  var registerCount: Int
+
+  @OptionalParent(key: "delegatedToID")
+  var room: RoomModel?
+
+  @Field(key: "rectangularSizes")
+  var rectangularSizes: [Room.RectangularSize]?
+
+  @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,
+    level: Int? = nil,
+    heatingLoad: Double,
+    coolingLoad: Room.CoolingLoad,
+    registerCount: Int,
+    delegetedToID: UUID? = nil,
+    rectangularSizes: [Room.RectangularSize]? = nil,
+    createdAt: Date? = nil,
+    updatedAt: Date? = nil,
+    projectID: Project.ID
+  ) {
+    self.id = id
+    self.name = name
+    self.level = level
+    self.heatingLoad = heatingLoad
+    self.coolingLoad = coolingLoad
+    self.registerCount = registerCount
+    $room.id = delegetedToID
+    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,
+      level: level.map(Room.Level.init(rawValue:)),
+      heatingLoad: heatingLoad,
+      coolingLoad: coolingLoad,
+      registerCount: registerCount,
+      delegatedTo: $room.id,
+      rectangularSizes: rectangularSizes,
+      createdAt: createdAt!,
+      updatedAt: updatedAt!
+    )
+  }
+
+  func applyUpdates(_ updates: Room.Update) {
+
+    if let name = updates.name, name != self.name {
+      self.name = name
+    }
+    if let level = updates.level?.rawValue, level != self.level {
+      self.level = level
+    }
+    if let heatingLoad = updates.heatingLoad, heatingLoad != self.heatingLoad {
+      self.heatingLoad = heatingLoad
+    }
+    if let coolingLoad = updates.coolingLoad, coolingLoad != self.coolingLoad {
+      self.coolingLoad = coolingLoad
+    }
+    if let registerCount = updates.registerCount, registerCount != self.registerCount {
+      self.registerCount = registerCount
+    }
+    if let rectangularSizes = updates.rectangularSizes, rectangularSizes != self.rectangularSizes {
+      self.rectangularSizes = rectangularSizes
+    }
+
+  }
+
+  var body: some Validation<RoomModel> {
+    Validator.accumulating {
+      Validator.validate(\.name, with: .notEmpty())
+        .errorLabel("Name", inline: true)
+
+      Validator.validate(\.heatingLoad, with: .greaterThanOrEquals(0))
+        .errorLabel("Heating Load", inline: true)
+
+      Validator.validate(\.coolingLoad)
+        .errorLabel("Cooling Load", inline: true)
+
+      Validator.validate(\.registerCount, with: .greaterThanOrEquals($room.id == nil ? 1 : 0))
+        .errorLabel("Register Count", inline: true)
+
+      Validator.validate(\.rectangularSizes)
+
+    }
+  }
+
+  func validateAndSave(on database: Database) async throws {
+    try self.validate()
+    if let delegateTo = $room.id {
+      guard
+        let parent =
+          try await RoomModel
+          .query(on: database)
+          .with(\.$room)
+          .filter(\.$id == delegateTo)
+          .first()
+      else {
+        throw ValidationError("Can not find room: \(delegateTo), to delegate airflow to.")
+      }
+      guard parent.$room.id == nil else {
+        throw ValidationError(
+          """
+          Attempting to delegate to: \(parent.name), that delegates to: \(parent.$room.name)
+
+          Unable to delegate airflow to a room that already delegates it's airflow.
+          """
+
+        )
+      }
+    }
+    try await save(on: database)
+  }
+}
+
+extension Room.CoolingLoad: Validatable {
+
+  public var body: some Validation<Self> {
+    Validator.accumulating {
+      // Ensure that at least one of the values is not nil.
+      Validator.oneOf {
+        Validator.validate(\.total, with: .notNil())
+          .errorLabel("Total or Sensible", inline: true)
+        Validator.validate(\.sensible, with: .notNil())
+          .errorLabel("Total or Sensible", inline: true)
+      }
+
+      Validator.validate(\.total, with: Double.greaterThan(0).optional())
+      Validator.validate(\.sensible, with: Double.greaterThan(0).optional())
+    }
+  }
+
+}
+
+extension Room.RectangularSize: Validatable {
+
+  public var body: some Validation<Self> {
+    Validator.accumulating {
+      Validator.validate(\.register, with: Int.greaterThanOrEquals(1).optional())
+        .errorLabel("Register", inline: true)
+
+      Validator.validate(\.height, with: Int.greaterThanOrEquals(1))
+        .errorLabel("Height", inline: true)
+    }
+  }
+}

Sources/DatabaseClient/Internal/Sequence+asyncMap.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+extension Sequence {
+
+  // Taken from: https://forums.swift.org/t/are-there-any-kind-of-asyncmap-method-for-a-normal-sequence/77354/7
+  func asyncMap<Result: Sendable>(
+    _ transform: @escaping @Sendable (Element) async throws -> Result
+  ) async rethrows -> [Result] where Element: Sendable {
+    try await withThrowingTaskGroup(of: (Int, Result).self) { group in
+
+      var i = 0
+      var iterator = self.makeIterator()
+      var results = [Result?]()
+      results.reserveCapacity(underestimatedCount)
+
+      func submitTask() throws {
+        try Task.checkCancellation()
+        if let element = iterator.next() {
+          results.append(nil)
+          group.addTask { [i] in try await (i, transform(element)) }
+          i += 1
+        }
+
+      }
+
+      // Add initial tasks
+      for _ in 0..<ProcessInfo.processInfo.processorCount {
+        try submitTask()
+      }
+
+      // Submit more tasks as results complete
+      while let (index, result) = try await group.next() {
+        results[index] = result
+        try submitTask()
+      }
+
+      return results.compactMap { $0 }
+
+    }
+  }
+}

Sources/DatabaseClient/Internal/TrunkSizes.swift

@@ -3,19 +3,7 @@ import DependenciesMacros
 import Fluent
 import Foundation
 import ManualDCore
-
-extension DatabaseClient {
-  @DependencyClient
-  public struct TrunkSizes: Sendable {
-    public var create: @Sendable (TrunkSize.Create) async throws -> TrunkSize
-    public var delete: @Sendable (TrunkSize.ID) async throws -> Void
-    public var fetch: @Sendable (Project.ID) async throws -> [TrunkSize]
-    public var get: @Sendable (TrunkSize.ID) async throws -> TrunkSize?
-    public var update:
-      @Sendable (TrunkSize.ID, TrunkSize.Update) async throws ->
-        TrunkSize
-  }
-}
+import Validations
 
 extension DatabaseClient.TrunkSizes: TestDependencyKey {
   public static let testValue = Self()
@@ -23,12 +11,12 @@ extension DatabaseClient.TrunkSizes: TestDependencyKey {
   public static func live(database: any Database) -> Self {
     .init(
       create: { request in
-        try request.validate()
+        // try request.validate()
 
         let trunk = request.toModel()
         var roomProxies = [TrunkSize.RoomProxy]()
 
-        try await trunk.save(on: database)
+        try await trunk.validateAndSave(on: database)
 
         for (roomID, registers) in request.rooms {
           guard let room = try await RoomModel.find(roomID, on: database) else {
@@ -40,7 +28,7 @@ extension DatabaseClient.TrunkSizes: TestDependencyKey {
             registers: registers,
             type: request.type
           )
-          try await model.save(on: database)
+          try await model.validateAndSave(on: database)
           roomProxies.append(
             .init(room: try room.toDTO(), registers: registers)
           )
@@ -50,7 +38,9 @@ extension DatabaseClient.TrunkSizes: TestDependencyKey {
           id: trunk.requireID(),
           projectID: trunk.$project.id,
           type: .init(rawValue: trunk.type)!,
-          rooms: roomProxies
+          rooms: roomProxies,
+          height: trunk.height,
+          name: trunk.name
         )
       },
       delete: { id in
@@ -91,7 +81,7 @@ extension DatabaseClient.TrunkSizes: TestDependencyKey {
         else {
           throw NotFoundError()
         }
-        try updates.validate()
+        // try updates.validate()
         try await model.applyUpdates(updates, on: database)
         return try model.toDTO()
       }
@@ -101,17 +91,6 @@ extension DatabaseClient.TrunkSizes: TestDependencyKey {
 
 extension 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,
@@ -122,21 +101,6 @@ extension TrunkSize.Create {
   }
 }
 
-extension 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 TrunkSize {
 
   struct Migrate: AsyncMigration {
@@ -211,15 +175,22 @@ final class TrunkRoomModel: Model, @unchecked Sendable {
   }
 
   func toDTO() throws -> TrunkSize.RoomProxy {
-    // guard let room = try await RoomModel.find($room.id, on: database) else {
-    //   throw NotFoundError()
-    // }
     return .init(
       room: try room.toDTO(),
       registers: registers
     )
   }
+}
 
+extension TrunkRoomModel: Validatable {
+  var body: some Validation<TrunkRoomModel> {
+    Validator.validate(\.registers) {
+      [Int].notEmpty()
+      ForEachValidator {
+        Int.greaterThanOrEquals(1)
+      }
+    }
+  }
 }
 
 final class TrunkModel: Model, @unchecked Sendable {
@@ -261,19 +232,6 @@ final class TrunkModel: Model, @unchecked Sendable {
   }
 
   func toDTO() throws -> TrunkSize {
-    // let rooms = try await withThrowingTaskGroup(of: TrunkSize.RoomProxy.self) { group in
-    //   for room in self.rooms {
-    //     group.addTask {
-    //       try await room.toDTO(on: database)
-    //     }
-    //   }
-    //
-    //   return try await group.reduce(into: [TrunkSize.RoomProxy]()) {
-    //     $0.append($1)
-    //   }
-    //
-    // }
-
     let rooms = try rooms.reduce(into: [TrunkSize.RoomProxy]()) {
       $0.append(try $1.toDTO())
     }
@@ -303,7 +261,7 @@ final class TrunkModel: Model, @unchecked Sendable {
       self.name = name
     }
     if hasChanges {
-      try await self.save(on: database)
+      try await self.validateAndSave(on: database)
     }
 
     guard let updateRooms = updates.rooms else {
@@ -324,7 +282,7 @@ final class TrunkModel: Model, @unchecked Sendable {
           currRoom.registers = registers
         }
         if currRoom.hasChanges {
-          try await currRoom.save(on: database)
+          try await currRoom.validateAndSave(on: database)
         }
       } else {
         database.logger.debug("CREATING NEW TrunkRoomModel")
@@ -351,19 +309,27 @@ final class TrunkModel: Model, @unchecked Sendable {
   }
 }
 
+extension TrunkModel: Validatable {
+
+  var body: some Validation<TrunkModel> {
+    Validator.accumulating {
+
+      Validator.validate(\.height, with: Int.greaterThan(0).optional())
+        .errorLabel("Height", inline: true)
+
+      Validator.validate(\.name, with: String.notEmpty().optional())
+        .errorLabel("Name", inline: true)
+
+    }
+  }
+}
+
 extension Array where Element == TrunkModel {
 
   func toDTO() throws -> [TrunkSize] {
-    // try await withThrowingTaskGroup(of: TrunkSize.self) { group in
-    //   for model in self {
-    //     group.addTask {
-    //       try await model.toDTO(on: database)
-    //     }
-    //   }
 
     return try reduce(into: [TrunkSize]()) {
       $0.append(try $1.toDTO())
     }
   }
-  // }
 }

Sources/DatabaseClient/Internal/User+validation.swift

@@ -0,0 +1,20 @@
+import ManualDCore
+import Validations
+
+// Declaring this in seperate file because some Vapor imports
+// have same name's and this was easiest solution.
+extension User.Create: Validatable {
+  public var body: some Validation<Self> {
+    Validator.accumulating {
+      Validator.validate(\.email, with: .email())
+        .errorLabel("Email", inline: true)
+
+      Validator.validate(\.password.count, with: .greaterThanOrEquals(8))
+        .errorLabel("Password Count", inline: true)
+
+      Validator.validate(\.confirmPassword, with: .equals(password))
+        .mapError(ValidationError("Confirm password does not match."))
+        .errorLabel("Confirm Password", inline: true)
+    }
+  }
+}

Sources/DatabaseClient/Internal/UserProfiles.swift

@@ -1,30 +1,19 @@
 import Dependencies
 import DependenciesMacros
 import Fluent
+import Foundation
 import ManualDCore
-import Vapor
+import Validations
 
-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 {
+extension DatabaseClient.UserProfiles: 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)
+        try await model.validateAndSave(on: database)
         return try model.toDTO()
       },
       delete: { id in
@@ -48,10 +37,9 @@ extension DatabaseClient.UserProfile: TestDependencyKey {
         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)
+          try await model.validateAndSave(on: database)
         }
         return try model.toDTO()
       }
@@ -61,30 +49,6 @@ extension DatabaseClient.UserProfile: TestDependencyKey {
 
 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,
@@ -100,47 +64,6 @@ extension User.Profile.Create {
   }
 }
 
-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 {
@@ -281,3 +204,31 @@ final class UserProfileModel: Model, @unchecked Sendable {
   }
 
 }
+
+extension UserProfileModel: Validatable {
+
+  var body: some Validation<UserProfileModel> {
+    Validator.accumulating {
+      Validator.validate(\.firstName, with: .notEmpty())
+        .errorLabel("First Name", inline: true)
+
+      Validator.validate(\.lastName, with: .notEmpty())
+        .errorLabel("Last Name", inline: true)
+
+      Validator.validate(\.companyName, with: .notEmpty())
+        .errorLabel("Company", inline: true)
+
+      Validator.validate(\.streetAddress, with: .notEmpty())
+        .errorLabel("Address", inline: true)
+
+      Validator.validate(\.city, with: .notEmpty())
+        .errorLabel("City", inline: true)
+
+      Validator.validate(\.state, with: .notEmpty())
+        .errorLabel("State", inline: true)
+
+      Validator.validate(\.zipCode, with: .notEmpty())
+        .errorLabel("Zip", inline: true)
+    }
+  }
+}

Sources/DatabaseClient/Internal/Users.swift

@@ -1,28 +1,17 @@
 import Dependencies
 import DependenciesMacros
 import Fluent
+import Foundation
 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
+        try request.validate()
         let model = try request.toModel()
         try await model.save(on: database)
         return try model.toDTO()
@@ -46,6 +35,11 @@ extension DatabaseClient.Users: TestDependencyKey {
           throw NotFoundError()
         }
 
+        // Verify the password matches the user's hashed password.
+        guard try user.verifyPassword(request.password) else {
+          throw Abort(.unauthorized)
+        }
+
         let token: User.Token
 
         // Check if there's a user token
@@ -126,21 +120,8 @@ extension User {
 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 {

Sources/DatabaseClient/RectangularDuct.swift

@@ -1,175 +0,0 @@
-// 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

@@ -1,281 +0,0 @@
-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, Room.RectangularSize.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, Room.RectangularSize) 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: [Room.RectangularSize]?
-
-  @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: [Room.RectangularSize]? = 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/EnvClient/Interface.swift

@@ -1,74 +0,0 @@
-import Dependencies
-import DependenciesMacros
-import Foundation
-
-extension DependencyValues {
-
-  /// Holds values defined in the process environment that are needed.
-  ///
-  /// These are generally loaded from a `.env` file, but also have default values,
-  /// if not found.
-  public var env: @Sendable () throws -> EnvVars {
-    get { self[EnvClient.self].env }
-    set { self[EnvClient.self].env = newValue }
-  }
-}
-
-@DependencyClient
-struct EnvClient: Sendable {
-  public var env: @Sendable () throws -> EnvVars
-}
-
-/// Holds values defined in the process environment that are needed.
-///
-/// These are generally loaded from a `.env` file, but also have default values,
-/// if not found.
-public struct EnvVars: Codable, Equatable, Sendable {
-
-  /// The path to the pandoc executable on the system, used to generate pdf's.
-  public let pandocPath: String
-
-  /// The pdf engine to use with pandoc when creating pdf's.
-  public let pdfEngine: String
-
-  public init(
-    pandocPath: String = "/usr/bin/pandoc",
-    pdfEngine: String = "weasyprint"
-  ) {
-    self.pandocPath = pandocPath
-    self.pdfEngine = pdfEngine
-  }
-
-  enum CodingKeys: String, CodingKey {
-    case pandocPath = "PANDOC_PATH"
-    case pdfEngine = "PDF_ENGINE"
-  }
-
-}
-
-extension EnvClient: DependencyKey {
-  static let testValue = Self()
-
-  static let liveValue = Self(env: {
-    // Convert default values into a dictionary.
-    let defaults =
-      (try? encoder.encode(EnvVars()))
-      .flatMap { try? decoder.decode([String: String].self, from: $0) }
-      ?? [:]
-
-    // Merge the default values with values found in process environment.
-    let assigned = defaults.merging(ProcessInfo.processInfo.environment, uniquingKeysWith: { $1 })
-
-    return (try? JSONSerialization.data(withJSONObject: assigned))
-      .flatMap { try? decoder.decode(EnvVars.self, from: $0) }
-      ?? .init()
-  })
-}
-
-private let encoder: JSONEncoder = {
-  JSONEncoder()
-}()
-
-private let decoder: JSONDecoder = {
-  JSONDecoder()
-}()

Sources/EnvVars/Interface.swift

@@ -0,0 +1,100 @@
+import Dependencies
+import DependenciesMacros
+import Foundation
+
+extension DependencyValues {
+
+  /// Holds values defined in the process environment that are needed.
+  ///
+  /// These are generally loaded from a `.env` file, but also have default values,
+  /// if not found.
+  public var environment: EnvVars {
+    get { self[EnvVars.self] }
+    set { self[EnvVars.self] = newValue }
+  }
+}
+
+/// Holds values defined in the process environment that are needed.
+///
+/// These are generally loaded from a `.env` file, but also have default values,
+/// if not found.
+public struct EnvVars: Codable, Equatable, Sendable {
+
+  /// The path to the pandoc executable on the system, used to generate pdf's.
+  public let pandocPath: String
+
+  /// The pdf engine to use with pandoc when creating pdf's.
+  public let pdfEngine: String
+
+  /// The postgres hostname, used for production database connection.
+  public let postgresHostname: String?
+
+  /// The postgres username, used for production database connection.
+  public let postgresUsername: String?
+
+  /// The postgres password, used for production database connection.
+  public let postgresPassword: String?
+
+  /// The postgres database, used for production database connection.
+  public let postgresDatabase: String?
+
+  /// The path to the sqlite database, used for development database connection.
+  public let sqlitePath: String?
+
+  public init(
+    pandocPath: String = "/usr/bin/pandoc",
+    pdfEngine: String = "weasyprint",
+    postgresHostname: String? = "localhost",
+    postgresUsername: String? = "vapor",
+    postgresPassword: String? = "super-secret",
+    postgresDatabase: String? = "vapor",
+    sqlitePath: String? = "db.sqlite"
+  ) {
+    self.pandocPath = pandocPath
+    self.pdfEngine = pdfEngine
+    self.postgresHostname = postgresHostname
+    self.postgresUsername = postgresUsername
+    self.postgresPassword = postgresPassword
+    self.postgresDatabase = postgresDatabase
+    self.sqlitePath = sqlitePath
+  }
+
+  enum CodingKeys: String, CodingKey {
+    case pandocPath = "PANDOC_PATH"
+    case pdfEngine = "PDF_ENGINE"
+    case postgresHostname = "POSTGRES_HOSTNAME"
+    case postgresUsername = "POSTGRES_USER"
+    case postgresPassword = "POSTGRES_PASSWORD"
+    case postgresDatabase = "POSTGRES_DB"
+    case sqlitePath = "SQLITE_PATH"
+  }
+
+  public static func live(_ env: [String: String] = ProcessInfo.processInfo.environment) -> Self {
+
+    // Convert default values into a dictionary.
+    let defaults =
+      (try? encoder.encode(EnvVars()))
+      .flatMap { try? decoder.decode([String: String].self, from: $0) }
+      ?? [:]
+
+    // Merge the default values with values found in process environment.
+    let assigned = defaults.merging(env, uniquingKeysWith: { $1 })
+
+    return (try? JSONSerialization.data(withJSONObject: assigned))
+      .flatMap { try? decoder.decode(EnvVars.self, from: $0) }
+      ?? .init()
+  }
+
+}
+
+extension EnvVars: TestDependencyKey {
+  public static let testValue = Self()
+}
+
+private let encoder: JSONEncoder = {
+  JSONEncoder()
+}()
+
+private let decoder: JSONDecoder = {
+  JSONDecoder()
+}()

Sources/FileClient/Interface.swift

@@ -4,6 +4,7 @@ import Foundation
 import Vapor
 
 extension DependencyValues {
+  /// Dependency used for file operations.
   public var fileClient: FileClient {
     get { self[FileClient.self] }
     set { self[FileClient.self] = newValue }
@@ -14,9 +15,27 @@ extension DependencyValues {
 public struct FileClient: Sendable {
   public typealias OnCompleteHandler = @Sendable () async throws -> Void
 
-  public var writeFile: @Sendable (String, String) async throws -> Void
-  public var removeFile: @Sendable (String) async throws -> Void
-  public var streamFile: @Sendable (String, @escaping OnCompleteHandler) async throws -> Response
+  /// Write contents to a file.
+  ///
+  /// > Warning: This will overwrite a file if it exists.
+  public var writeFile: @Sendable (_ contents: String, _ path: String) async throws -> Void
+  /// Remove a file.
+  public var removeFile: @Sendable (_ path: String) async throws -> Void
+  /// Stream a file.
+  public var streamFile:
+    @Sendable (_ path: String, @escaping OnCompleteHandler) async throws -> Response
+
+  /// Stream a file at the given path.
+  ///
+  /// - Paramters:
+  ///   - path: The path to the file to stream.
+  ///   - onComplete: Completion handler to run when done streaming the file.
+  public func streamFile(
+    at path: String,
+    onComplete: @escaping OnCompleteHandler = {}
+  ) async throws -> Response {
+    try await streamFile(path, onComplete)
+  }
 }
 
 extension FileClient: TestDependencyKey {

Sources/HTMLSnapshotTesting/Snapshotting.swift

@@ -11,12 +11,12 @@ extension Snapshotting where Value == (any HTML), Format == String {
   }
 }
 
-extension Snapshotting where Value == String, Format == String {
-  public static var html: Snapshotting {
-    var snapshotting = SimplySnapshotting.lines
-      .pullback { $0 }
-
-    snapshotting.pathExtension = "html"
-    return snapshotting
-  }
-}
+// extension Snapshotting where Value == String, Format == String {
+//   public static var html: Snapshotting {
+//     var snapshotting = SimplySnapshotting.lines
+//       .pullback { $0 }
+//
+//     snapshotting.pathExtension = "html"
+//     return snapshotting
+//   }
+// }

Sources/ManualDClient/Helpers.swift

@@ -1,55 +1,6 @@
 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 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 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 } }
-}
-
 extension Array where Element == EffectiveLengthGroup {
   var totalEffectiveLength: Int {
     reduce(0) { $0 + $1.effectiveLength }
@@ -101,16 +52,16 @@ func roundSize(_ size: Double) throws -> Int {
   }
 }
 
-func velocity(cfm: Int, roundSize: Int) -> Int {
-  let cfm = Double(cfm)
+func velocity(cfm: ManualDClient.CFM, roundSize: Int) -> Int {
+  let cfm = Double(cfm.rawValue)
   let roundSize = Double(roundSize)
   let velocity = cfm / (pow(roundSize / 24, 2) * 3.14)
   return Int(round(velocity))
 }
 
-func flexSize(_ request: ManualDClient.DuctSizeRequest) throws -> Int {
-  let cfm = pow(Double(request.designCFM), 0.4)
-  let fr = pow(request.frictionRate / 1.76, 0.2)
+func flexSize(_ cfm: ManualDClient.CFM, _ frictionRate: Double) throws -> Int {
+  let cfm = pow(Double(cfm.rawValue), 0.4)
+  let fr = pow(frictionRate / 1.76, 0.2)
   let size = 0.55 * (cfm / fr)
   return try roundSize(size)
 }

Sources/ManualDClient/Interface.swift

@@ -2,8 +2,10 @@ import Dependencies
 import DependenciesMacros
 import Logging
 import ManualDCore
+import Tagged
 
 extension DependencyValues {
+  /// Dependency that performs manual-d duct sizing calculations.
   public var manualD: ManualDClient {
     get { self[ManualDClient.self] }
     set { self[ManualDClient.self] = newValue }
@@ -15,12 +17,61 @@ extension DependencyValues {
 ///
 @DependencyClient
 public struct ManualDClient: Sendable {
-  public var ductSize: @Sendable (DuctSizeRequest) async throws -> DuctSizeResponse
-  public var frictionRate: @Sendable (FrictionRateRequest) async throws -> FrictionRate
-  public var totalEquivalentLength: @Sendable (TotalEquivalentLengthRequest) async throws -> Int
-  public var rectangularSize:
-    @Sendable (RectangularSizeRequest) async throws -> RectangularSizeResponse
 
+  /// Calculates the duct size for the given cfm and friction rate.
+  public var ductSize: @Sendable (CFM, DesignFrictionRate) async throws -> DuctSize
+  /// Calculates the design friction rate for the given request.
+  public var frictionRate: @Sendable (FrictionRateRequest) async throws -> FrictionRate
+  /// Calculates the equivalent rectangular size for the given round duct and rectangular height.
+  public var rectangularSize: @Sendable (RoundSize, Height) async throws -> RectangularSize
+
+  /// Calculates the duct size for the given cfm and friction rate.
+  ///
+  /// - Paramaters:
+  ///   - designCFM: The design cfm for the duct.
+  ///   - designFrictionRate: The design friction rate for the system.
+  public func ductSize(
+    cfm designCFM: Int,
+    frictionRate designFrictionRate: Double
+  ) async throws -> DuctSize {
+    try await ductSize(.init(rawValue: designCFM), .init(rawValue: designFrictionRate))
+  }
+
+  /// Calculates the duct size for the given cfm and friction rate.
+  ///
+  /// - Paramaters:
+  ///   - designCFM: The design cfm for the duct.
+  ///   - designFrictionRate: The design friction rate for the system.
+  public func ductSize(
+    cfm designCFM: Double,
+    frictionRate designFrictionRate: Double
+  ) async throws -> DuctSize {
+    try await ductSize(.init(rawValue: Int(designCFM)), .init(rawValue: designFrictionRate))
+  }
+
+  /// Calculates the equivalent rectangular size for the given round duct and rectangular height.
+  ///
+  /// - Paramaters:
+  ///   - roundSize: The round duct size.
+  ///   - height: The rectangular height of the duct.
+  public func rectangularSize(
+    round roundSize: RoundSize,
+    height: Height
+  ) async throws -> RectangularSize {
+    try await rectangularSize(roundSize, height)
+  }
+
+  /// Calculates the equivalent rectangular size for the given round duct and rectangular height.
+  ///
+  /// - Paramaters:
+  ///   - roundSize: The round duct size.
+  ///   - height: The rectangular height of the duct.
+  public func rectangularSize(
+    round roundSize: Int,
+    height: Int
+  ) async throws -> RectangularSize {
+    try await rectangularSize(.init(rawValue: roundSize), .init(rawValue: height))
+  }
 }
 
 extension ManualDClient: TestDependencyKey {
@@ -28,21 +79,20 @@ extension ManualDClient: TestDependencyKey {
 }
 
 extension ManualDClient {
-
-  public struct DuctSizeRequest: Codable, Equatable, Sendable {
-    public let designCFM: Int
-    public let frictionRate: Double
-
-    public init(
-      designCFM: Int,
-      frictionRate: Double
-    ) {
-      self.designCFM = designCFM
-      self.frictionRate = frictionRate
-    }
+  /// A name space for tags used by the ManualDClient.
+  public enum Tag {
+    public enum CFM {}
+    public enum DesignFrictionRate {}
+    public enum Height {}
+    public enum Round {}
   }
 
-  public struct DuctSizeResponse: Codable, Equatable, Sendable {
+  public typealias CFM = Tagged<Tag.CFM, Int>
+  public typealias DesignFrictionRate = Tagged<Tag.DesignFrictionRate, Double>
+  public typealias Height = Tagged<Tag.Height, Int>
+  public typealias RoundSize = Tagged<Tag.Round, Int>
+
+  public struct DuctSize: Codable, Equatable, Sendable {
 
     public let calculatedSize: Double
     public let finalSize: Int
@@ -66,58 +116,20 @@ extension ManualDClient {
 
     public let externalStaticPressure: Double
     public let componentPressureLosses: [ComponentPressureLoss]
-    public let totalEffectiveLength: Int
+    public let totalEquivalentLength: Int
 
     public init(
       externalStaticPressure: Double,
       componentPressureLosses: [ComponentPressureLoss],
-      totalEffectiveLength: Int
+      totalEquivalentLength: Int
     ) {
       self.externalStaticPressure = externalStaticPressure
       self.componentPressureLosses = componentPressureLosses
-      self.totalEffectiveLength = totalEffectiveLength
+      self.totalEquivalentLength = totalEquivalentLength
     }
   }
 
-  public struct FrictionRateResponse: Codable, Equatable, Sendable {
-
-    public let availableStaticPressure: Double
-    public let frictionRate: Double
-
-    public init(availableStaticPressure: Double, frictionRate: Double) {
-      self.availableStaticPressure = availableStaticPressure
-      self.frictionRate = frictionRate
-    }
-  }
-
-  public struct TotalEquivalentLengthRequest: Codable, Equatable, Sendable {
-
-    public let trunkLengths: [Int]
-    public let runoutLengths: [Int]
-    public let effectiveLengthGroups: [EffectiveLengthGroup]
-
-    public init(
-      trunkLengths: [Int],
-      runoutLengths: [Int],
-      effectiveLengthGroups: [EffectiveLengthGroup]
-    ) {
-      self.trunkLengths = trunkLengths
-      self.runoutLengths = runoutLengths
-      self.effectiveLengthGroups = effectiveLengthGroups
-    }
-  }
-
-  public struct RectangularSizeRequest: Codable, Equatable, Sendable {
-    public let roundSize: Int
-    public let height: Int
-
-    public init(round roundSize: Int, height: Int) {
-      self.roundSize = roundSize
-      self.height = height
-    }
-  }
-
-  public struct RectangularSizeResponse: Codable, Equatable, Sendable {
+  public struct RectangularSize: Codable, Equatable, Sendable {
     public let height: Int
     public let width: Int
 

Sources/ManualDClient/Live.swift

@@ -4,41 +4,47 @@ import ManualDCore
 
 extension ManualDClient: DependencyKey {
   public static let liveValue: Self = .init(
-    ductSize: { request in
-      guard request.designCFM > 0 else {
+    ductSize: { cfm, frictionRate in
+      guard cfm > 0 else {
         throw ManualDError(message: "Design CFM should be greater than 0.")
       }
-      let fr = pow(request.frictionRate, 0.5)
-      let ductulatorSize = pow(Double(request.designCFM) / (3.12 * fr), 0.38)
+      let fr = pow(frictionRate.rawValue, 0.5)
+      let ductulatorSize = pow(Double(cfm.rawValue) / (3.12 * fr), 0.38)
       let finalSize = try roundSize(ductulatorSize)
-      let flexSize = try flexSize(request)
+      let flexSize = try flexSize(cfm, frictionRate.rawValue)
       return .init(
         calculatedSize: ductulatorSize,
         finalSize: finalSize,
         flexSize: flexSize,
-        velocity: velocity(cfm: request.designCFM, roundSize: finalSize)
+        velocity: velocity(cfm: cfm, roundSize: finalSize)
       )
     },
     frictionRate: { request in
       // Ensure the total effective length is greater than 0.
-      guard request.totalEffectiveLength > 0 else {
+      guard request.totalEquivalentLength > 0 else {
         throw ManualDError(message: "Total Effective Length should be greater than 0.")
       }
 
       let totalComponentLosses = request.componentPressureLosses.total
       let availableStaticPressure = request.externalStaticPressure - totalComponentLosses
-      let frictionRate = availableStaticPressure * 100.0 / Double(request.totalEffectiveLength)
-      return .init(availableStaticPressure: availableStaticPressure, value: frictionRate)
+      let frictionRate = availableStaticPressure * 100.0 / Double(request.totalEquivalentLength)
+      return .init(
+        availableStaticPressure: availableStaticPressure,
+        value: frictionRate
+      )
     },
-    totalEquivalentLength: { request in
-      let trunkLengths = request.trunkLengths.reduce(0) { $0 + $1 }
-      let runoutLengths = request.runoutLengths.reduce(0) { $0 + $1 }
-      let groupLengths = request.effectiveLengthGroups.totalEffectiveLength
-      return trunkLengths + runoutLengths + groupLengths
-    },
-    rectangularSize: { request in
-      let width = (Double.pi * (pow(Double(request.roundSize) / 2.0, 2.0))) / Double(request.height)
-      return .init(height: request.height, width: Int(width.rounded(.toNearestOrEven)))
+    // totalEquivalentLength: { request in
+    //   let trunkLengths = request.trunkLengths.reduce(0) { $0 + $1 }
+    //   let runoutLengths = request.runoutLengths.reduce(0) { $0 + $1 }
+    //   let groupLengths = request.effectiveLengthGroups.totalEffectiveLength
+    //   return trunkLengths + runoutLengths + groupLengths
+    // },
+    rectangularSize: { round, height in
+      let width = (Double.pi * (pow(Double(round.rawValue) / 2.0, 2.0))) / Double(height.rawValue)
+      return .init(
+        height: height.rawValue,
+        width: Int(width.rounded(.toNearestOrEven))
+      )
     }
   )
 }

Sources/ManualDCore/ComponentPressureLoss.swift

@@ -1,6 +1,10 @@
 import Dependencies
 import Foundation
 
+/// Represents component pressure losses used in the friction rate worksheet.
+///
+/// These are items such as filter, evaporator-coils, balance-dampers, etc. that
+/// need to be overcome by the system fan.
 public struct ComponentPressureLoss: Codable, Equatable, Identifiable, Sendable {
 
   public let id: UUID
@@ -44,7 +48,7 @@ extension ComponentPressureLoss {
       self.value = value
     }
 
-    // Return's commonly used default component pressure losses.
+    /// Commonly used default component pressure losses.
     public static func `default`(projectID: Project.ID) -> [Self] {
       [
         .init(projectID: projectID, name: "supply-outlet", value: 0.03),
@@ -75,20 +79,7 @@ extension Array where Element == ComponentPressureLoss {
   }
 }
 
-public typealias ComponentPressureLosses = [String: Double]
-
 #if DEBUG
-  extension ComponentPressureLosses {
-    public static var mock: Self {
-      [
-        "evaporator-coil": 0.2,
-        "filter": 0.1,
-        "supply-outlet": 0.03,
-        "return-grille": 0.03,
-        "balancing-damper": 0.03,
-      ]
-    }
-  }
 
   extension Array where Element == ComponentPressureLoss {
     public static func mock(projectID: Project.ID) -> Self {

Sources/ManualDCore/CoolingLoad.swift

@@ -1,13 +1,14 @@
-import Foundation
+// import Foundation
 
-public struct CoolingLoad: Codable, Equatable, Sendable {
-  public let total: Double
-  public let sensible: Double
-  public var latent: Double { total - sensible }
-  public var shr: Double { sensible / total }
-
-  public init(total: Double, sensible: Double) {
-    self.total = total
-    self.sensible = sensible
-  }
-}
+//
+// public struct CoolingLoad: Codable, Equatable, Sendable {
+//   public let total: Double
+//   public let sensible: Double
+//   public var latent: Double { total - sensible }
+//   public var shr: Double { sensible / total }
+//
+//   public init(total: Double, sensible: Double) {
+//     self.total = total
+//     self.sensible = sensible
+//   }
+// }

Sources/ManualDCore/DuctSizes.swift

@@ -152,11 +152,12 @@ extension DuctSizes {
     public static func mock(
       equipmentInfo: EquipmentInfo,
       rooms: [Room],
-      trunks: [TrunkSize]
+      trunks: [TrunkSize],
+      shr: Double
     ) -> Self {
 
       let totalHeatingLoad = rooms.totalHeatingLoad
-      let totalCoolingLoad = rooms.totalCoolingLoad
+      let totalCoolingLoad = try! rooms.totalCoolingLoad(shr: shr)
 
       let roomContainers = rooms.reduce(into: [RoomContainer]()) { array, room in
         array += RoomContainer.mock(
@@ -164,7 +165,8 @@ extension DuctSizes {
           totalHeatingLoad: totalHeatingLoad,
           totalCoolingLoad: totalCoolingLoad,
           totalHeatingCFM: Double(equipmentInfo.heatingCFM),
-          totalCoolingCFM: Double(equipmentInfo.coolingCFM)
+          totalCoolingCFM: Double(equipmentInfo.coolingCFM),
+          shr: shr
         )
       }
 
@@ -187,14 +189,15 @@ extension DuctSizes {
       totalHeatingLoad: Double,
       totalCoolingLoad: Double,
       totalHeatingCFM: Double,
-      totalCoolingCFM: Double
+      totalCoolingCFM: Double,
+      shr: Double
     ) -> [Self] {
       var retval = [DuctSizes.RoomContainer]()
       let heatingLoad = room.heatingLoad / Double(room.registerCount)
       let heatingFraction = heatingLoad / totalHeatingLoad
       let heatingCFM = totalHeatingCFM * heatingFraction
       // Not really accurate, but works for mocks.
-      let coolingLoad = room.coolingTotal / Double(room.registerCount)
+      let coolingLoad = (try! room.coolingLoad.ensured(shr: shr).total) / Double(room.registerCount)
       let coolingFraction = coolingLoad / totalCoolingLoad
       let coolingCFM = totalCoolingCFM * coolingFraction
 

Sources/ManualDCore/EffectiveLength.swift

@@ -1,215 +0,0 @@
-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 func mock(projectID: Project.ID) -> [Self] {
-      @Dependency(\.uuid) var uuid
-      @Dependency(\.date.now) var now
-
-      return [
-        .init(
-          id: uuid(),
-          projectID: projectID,
-          name: "Supply - 1",
-          type: .supply,
-          straightLengths: [10, 25],
-          groups: [
-            .init(group: 1, letter: "a", value: 20),
-            .init(group: 2, letter: "b", value: 30, quantity: 1),
-            .init(group: 3, letter: "a", value: 10, quantity: 1),
-            .init(group: 12, letter: "a", value: 10, quantity: 1),
-          ],
-          createdAt: now,
-          updatedAt: now
-        ),
-        .init(
-          id: uuid(),
-          projectID: projectID,
-          name: "Return - 1",
-          type: .return,
-          straightLengths: [10, 20, 5],
-          groups: [
-            .init(group: 5, letter: "a", value: 10),
-            .init(group: 6, letter: "a", value: 15, quantity: 1),
-            .init(group: 7, letter: "a", value: 20, quantity: 1),
-          ],
-          createdAt: now,
-          updatedAt: now
-        ),
-      ]
-    }
-
-    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/EffectiveLengthGroup.swift

@@ -1,5 +1,7 @@
 import Foundation
 
+// TODO: These are not used, should they be removed??
+
 // TODO: Add other description / label for items that have same group & letter, but
 //       different effective length.
 public struct EffectiveLengthGroup: Codable, Equatable, Sendable {

Sources/ManualDCore/EquipmentInfo.swift

@@ -1,6 +1,10 @@
 import Dependencies
 import Foundation
 
+/// Represents the equipment information for a project.
+///
+/// This is used in the friction rate worksheet and sizing ducts. It holds on to items
+/// such as the target static pressure, cooling CFM, and heating CFM for the project.
 public struct EquipmentInfo: Codable, Equatable, Identifiable, Sendable {
   public let id: UUID
   public let projectID: Project.ID

Sources/ManualDCore/EquivalentLength.swift

@@ -0,0 +1,239 @@
+import Dependencies
+import Foundation
+
+/// Represents the equivalent length of a single duct path.
+///
+/// These consist of both straight lengths of duct / trunks, as well as the
+/// equivalent length of duct fittings.  They are used to determine the worst
+/// case total equivalent length of duct that the system fan has to move air
+/// through.
+///
+/// There can be many equivalent lengths saved for a project, however the only
+/// ones that matter in most calculations are the longest supply path and the
+/// the longest return path.
+///
+/// It is required that project has at least one equivalent length saved for
+/// the supply and one saved for return, otherwise duct sizes can not be calculated.
+public struct EquivalentLength: Codable, Equatable, Identifiable, Sendable {
+
+  /// The id of the equivalent length.
+  public let id: UUID
+  /// The project that this equivalent length is associated with.
+  public let projectID: Project.ID
+  /// A unique name / label for this equivalent length.
+  public let name: String
+  /// The type (supply or return) of the equivalent length.
+  public let type: EffectiveLengthType
+  /// The straight lengths of duct for this equivalent length.
+  public let straightLengths: [Int]
+  /// The fitting groups associated with this equivalent length.
+  public let groups: [FittingGroup]
+  /// When this equivalent length was created in the database.
+  public let createdAt: Date
+  /// When this equivalent length was updated in the database.
+  public let updatedAt: Date
+
+  public init(
+    id: UUID,
+    projectID: Project.ID,
+    name: String,
+    type: EquivalentLength.EffectiveLengthType,
+    straightLengths: [Int],
+    groups: [EquivalentLength.FittingGroup],
+    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 EquivalentLength {
+
+  /// Represents the data needed to create a new ``EquivalentLength`` in the database.
+  public struct Create: Codable, Equatable, Sendable {
+
+    /// The project that this equivalent length is associated with.
+    public let projectID: Project.ID
+    /// A unique name / label for this equivalent length.
+    public let name: String
+    /// The type (supply or return) of the equivalent length.
+    public let type: EffectiveLengthType
+    /// The straight lengths of duct for this equivalent length.
+    public let straightLengths: [Int]
+    /// The fitting groups associated with this equivalent length.
+    public let groups: [FittingGroup]
+
+    public init(
+      projectID: Project.ID,
+      name: String,
+      type: EquivalentLength.EffectiveLengthType,
+      straightLengths: [Int],
+      groups: [EquivalentLength.FittingGroup]
+    ) {
+      self.projectID = projectID
+      self.name = name
+      self.type = type
+      self.straightLengths = straightLengths
+      self.groups = groups
+    }
+  }
+
+  /// Represents the data needed to update an ``EquivalentLength`` in the database.
+  ///
+  /// Only the supplied fields are updated.
+  public struct Update: Codable, Equatable, Sendable {
+
+    /// A unique name / label for this equivalent length.
+    public let name: String?
+    /// The type (supply or return) of the equivalent length.
+    public let type: EffectiveLengthType?
+    /// The straight lengths of duct for this equivalent length.
+    public let straightLengths: [Int]?
+    /// The fitting groups associated with this equivalent length.
+    public let groups: [FittingGroup]?
+
+    public init(
+      name: String? = nil,
+      type: EquivalentLength.EffectiveLengthType? = nil,
+      straightLengths: [Int]? = nil,
+      groups: [EquivalentLength.FittingGroup]? = nil
+    ) {
+      self.name = name
+      self.type = type
+      self.straightLengths = straightLengths
+      self.groups = groups
+    }
+  }
+
+  /// Represents the type of equivalent length, either supply or return.
+  public enum EffectiveLengthType: String, CaseIterable, Codable, Sendable {
+    case `return`
+    case supply
+  }
+
+  /// Represents a Manual-D fitting group.
+  ///
+  /// These are defined by Manual-D and convert different types of fittings into
+  /// an equivalent length of straight duct.
+  public struct FittingGroup: Codable, Equatable, Sendable {
+    /// The fitting group number.
+    public let group: Int
+    /// The fitting group letter.
+    public let letter: String
+    /// The equivalent length of the fitting.
+    public let value: Double
+    /// The quantity of the fittings in the path.
+    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
+    }
+  }
+
+  // TODO: Should these not be optional and we just throw an error or return nil from
+  //       a database query.
+
+  /// Represents the max ``EquivalentLength``'s for a project.
+  ///
+  /// Calculating the duct sizes for a project requires there to be a max supply
+  /// and a max return equivalent length, so this container represents those values
+  /// when they exist in the database.
+  public struct MaxContainer: Codable, Equatable, Sendable {
+
+    /// The longest supply equivalent length.
+    public let supply: EquivalentLength?
+    /// The longest return equivalent length.
+    public let `return`: EquivalentLength?
+
+    public init(supply: EquivalentLength? = nil, return: EquivalentLength? = nil) {
+      self.supply = supply
+      self.return = `return`
+    }
+
+    public var totalEquivalentLength: Double? {
+      guard let supply else { return nil }
+      guard let `return` else { return nil }
+      return supply.totalEquivalentLength + `return`.totalEquivalentLength
+    }
+  }
+}
+
+extension EquivalentLength {
+
+  /// The calculated total equivalent length.
+  ///
+  /// This is the sum of all the straigth lengths and fitting groups (with quantities).
+  public var totalEquivalentLength: Double {
+    straightLengths.reduce(into: 0.0) { $0 += Double($1) }
+      + groups.totalEquivalentLength
+  }
+}
+
+extension Array where Element == EquivalentLength.FittingGroup {
+
+  /// The calculated total equivalent length for the fitting groups.
+  public var totalEquivalentLength: Double {
+    reduce(into: 0.0) {
+      $0 += ($1.value * Double($1.quantity))
+    }
+  }
+}
+
+#if DEBUG
+
+  extension EquivalentLength {
+
+    public static func mock(projectID: Project.ID) -> [Self] {
+      @Dependency(\.uuid) var uuid
+      @Dependency(\.date.now) var now
+
+      return [
+        .init(
+          id: uuid(),
+          projectID: projectID,
+          name: "Supply - 1",
+          type: .supply,
+          straightLengths: [10, 25],
+          groups: [
+            .init(group: 1, letter: "a", value: 20),
+            .init(group: 2, letter: "b", value: 30, quantity: 1),
+            .init(group: 3, letter: "a", value: 10, quantity: 1),
+            .init(group: 12, letter: "a", value: 10, quantity: 1),
+          ],
+          createdAt: now,
+          updatedAt: now
+        ),
+        .init(
+          id: uuid(),
+          projectID: projectID,
+          name: "Return - 1",
+          type: .return,
+          straightLengths: [10, 20, 5],
+          groups: [
+            .init(group: 5, letter: "a", value: 10),
+            .init(group: 6, letter: "a", value: 15, quantity: 1),
+            .init(group: 7, letter: "a", value: 20, quantity: 1),
+          ],
+          createdAt: now,
+          updatedAt: now
+        ),
+      ]
+    }
+  }
+
+#endif

Sources/ManualDCore/Extensions/Numbers+string.swift

@@ -1,4 +1,17 @@
 import Foundation
+import Tagged
+
+extension Tagged where RawValue == Double {
+  public func string(digits: Int = 2) -> String {
+    rawValue.string(digits: digits)
+  }
+}
+
+extension Tagged where RawValue == Int {
+  public func string() -> String {
+    rawValue.string()
+  }
+}
 
 extension Double {
 

Sources/ManualDCore/FrictionRate.swift

@@ -1,8 +1,14 @@
 /// Holds onto values returned when calculating the design
 /// friction rate for a project.
+///
+/// **NOTE:** This is not stored in the database, it is calculated on the fly.
 public struct FrictionRate: Codable, Equatable, Sendable {
+  /// The available static pressure is the equipment's design static pressure
+  /// minus the ``ComponentPressureLoss``es for the project.
   public let availableStaticPressure: Double
+  /// The calculated design friction rate value.
   public let value: Double
+  /// Whether the design friction rate is within a valid range.
   public var hasErrors: Bool { error != nil }
 
   public init(
@@ -13,6 +19,7 @@ public struct FrictionRate: Codable, Equatable, Sendable {
     self.value = value
   }
 
+  /// The error if the design friction rate is out of a valid range.
   public var error: FrictionRateError? {
     if value >= 0.18 {
       return .init(
@@ -37,8 +44,13 @@ public struct FrictionRate: Codable, Equatable, Sendable {
   }
 }
 
+/// Represents an error when the ``FrictionRate`` is out of a valid range.
+///
+/// This holds onto the reason for the error as well as possible resolutions.
 public struct FrictionRateError: Error, Equatable, Sendable {
+  /// The reason for the error.
   public let reason: String
+  /// The possible resolutions to the error.
   public let resolutions: [String]
 
   public init(

Sources/ManualDCore/Project.swift

@@ -1,16 +1,29 @@
 import Dependencies
 import Foundation
 
+/// Represents a single duct design project / system.
+///
+/// Holds items such as project name and address.
 public struct Project: Codable, Equatable, Identifiable, Sendable {
-
+  /// The unique ID of the project.
   public let id: UUID
+  /// The name of the project.
   public let name: String
+  /// The street address of the project.
   public let streetAddress: String
+  /// The city of the project.
   public let city: String
+  /// The state of the project.
   public let state: String
+  /// The zip code of the project.
   public let zipCode: String
+  /// The global sensible heat ratio for the project.
+  ///
+  /// **NOTE:** This is used for calculating the sensible cooling load for rooms.
   public let sensibleHeatRatio: Double?
+  /// When the project was created in the database.
   public let createdAt: Date
+  /// When the project was updated in the database.
   public let updatedAt: Date
 
   public init(
@@ -37,14 +50,20 @@ public struct Project: Codable, Equatable, Identifiable, Sendable {
 }
 
 extension Project {
-
+  /// Represents the data needed to create a new project.
   public struct Create: Codable, Equatable, Sendable {
 
+    /// The name of the project.
     public let name: String
+    /// The street address of the project.
     public let streetAddress: String
+    /// The city of the project.
     public let city: String
+    /// The state of the project.
     public let state: String
+    /// The zip code of the project.
     public let zipCode: String
+    /// The global sensible heat ratio for the project.
     public let sensibleHeatRatio: Double?
 
     public init(
@@ -64,11 +83,19 @@ extension Project {
     }
   }
 
+  /// Represents steps that are completed in order to calculate the duct sizes
+  /// for a project.
+  ///
+  /// This is primarily used on the web pages to display errors or color of the
+  /// different steps of a project.
   public struct CompletedSteps: Codable, Equatable, Sendable {
-
+    /// Whether there is ``EquipmentInfo`` for a project.
     public let equipmentInfo: Bool
+    /// Whether there are ``Room``'s for a project.
     public let rooms: Bool
+    /// Whether there are ``EquivalentLength``'s for a project.
     public let equivalentLength: Bool
+    /// Whether there is a ``FrictionRate`` for a project.
     public let frictionRate: Bool
 
     public init(
@@ -84,20 +111,30 @@ extension Project {
     }
   }
 
+  /// Represents project details loaded from the database.
+  ///
+  /// This is generally used to perform duct sizing calculations for the
+  /// project, once all the steps have been completed.
   public struct Detail: Codable, Equatable, Sendable {
 
+    /// The project.
     public let project: Project
+    /// The component pressure losses for the project.
     public let componentLosses: [ComponentPressureLoss]
+    /// The equipment info for the project.
     public let equipmentInfo: EquipmentInfo
-    public let equivalentLengths: [EffectiveLength]
+    /// The equivalent lengths for the project.
+    public let equivalentLengths: [EquivalentLength]
+    /// The rooms in the project.
     public let rooms: [Room]
+    /// The trunk sizes in the project.
     public let trunks: [TrunkSize]
 
     public init(
       project: Project,
       componentLosses: [ComponentPressureLoss],
       equipmentInfo: EquipmentInfo,
-      equivalentLengths: [EffectiveLength],
+      equivalentLengths: [EquivalentLength],
       rooms: [Room],
       trunks: [TrunkSize]
     ) {
@@ -110,13 +147,22 @@ extension Project {
     }
   }
 
+  /// Represents fields that can be updated for a project that has already been created.
+  ///
+  /// Only fields that are supplied get updated in the database.
   public struct Update: Codable, Equatable, Sendable {
 
+    /// The name of the project.
     public let name: String?
+    /// The street address of the project.
     public let streetAddress: String?
+    /// The city of the project.
     public let city: String?
+    /// The state of the project.
     public let state: String?
+    /// The zip code of the project.
     public let zipCode: String?
+    /// The global sensible heat ratio for the project.
     public let sensibleHeatRatio: Double?
 
     public init(

Sources/ManualDCore/Room.swift

@@ -1,26 +1,59 @@
 import Dependencies
 import Foundation
+import Tagged
 
+/// Represents a room in a project.
+///
+/// This contains data such as the heating and cooling load for the
+/// room, the number of registers in the room, and any rectangular
+/// duct size calculations stored for the room.
 public struct Room: Codable, Equatable, Identifiable, Sendable {
+
+  /// The unique id of the room.
   public let id: UUID
+
+  /// The project this room is associated with.
   public let projectID: Project.ID
+
+  /// A unique name for the room in the project.
   public let name: String
+
+  /// The level of the home the room is on.
+  public let level: Level?
+
+  /// The heating load required for the room (from Manual-J).
   public let heatingLoad: Double
-  public let coolingTotal: Double
-  public let coolingSensible: Double?
+
+  /// The cooling load required for the room (from Manual-J).
+  public let coolingLoad: CoolingLoad
+
+  /// The number of registers for the room.
   public let registerCount: Int
+
+  /// An optional room that the airflow is delegated to.
+  public let delegatedTo: Room.ID?
+
+  /// The rectangular duct size calculations for a room.
+  ///
+  /// **NOTE:** These are optionally set after the round sizes have been calculate
+  ///           for a room.
   public let rectangularSizes: [RectangularSize]?
+
+  /// When the room was created in the database.
   public let createdAt: Date
+
+  /// When the room was updated in the database.
   public let updatedAt: Date
 
   public init(
     id: UUID,
     projectID: Project.ID,
     name: String,
+    level: Level? = nil,
     heatingLoad: Double,
-    coolingTotal: Double,
-    coolingSensible: Double? = nil,
+    coolingLoad: CoolingLoad,
     registerCount: Int = 1,
+    delegatedTo: Room.ID? = nil,
     rectangularSizes: [RectangularSize]? = nil,
     createdAt: Date,
     updatedAt: Date
@@ -28,47 +61,173 @@ public struct Room: Codable, Equatable, Identifiable, Sendable {
     self.id = id
     self.projectID = projectID
     self.name = name
+    self.level = level
     self.heatingLoad = heatingLoad
-    self.coolingTotal = coolingTotal
-    self.coolingSensible = coolingSensible
+    self.coolingLoad = coolingLoad
     self.registerCount = registerCount
+    self.delegatedTo = delegatedTo
     self.rectangularSizes = rectangularSizes
     self.createdAt = createdAt
     self.updatedAt = updatedAt
   }
+
+  /// Represents the cooling load of a room.
+  ///
+  /// Generally only one of the values is provided by a Manual-J room x room
+  /// calculation.
+  ///
+  public struct CoolingLoad: Codable, Equatable, Sendable {
+
+    public let total: Double?
+    public let sensible: Double?
+
+    public init(total: Double? = nil, sensible: Double? = nil) {
+      self.total = total
+      self.sensible = sensible
+    }
+
+    /// Calculates the cooling load based on the shr.
+    ///
+    /// Generally Manual-J room x room loads provide either the total load or the
+    /// sensible load, so this allows us to calculate whichever is not provided.
+    public func ensured(shr: Double) throws -> (total: Double, sensible: Double) {
+      switch (total, sensible) {
+      case (.none, .none):
+        throw CoolingLoadError("Both the total and sensible loads are nil.")
+      case (.some(let total), .some(let sensible)):
+        return (total, sensible)
+      case (.some(let total), .none):
+        return (total, total * shr)
+      case (.none, .some(let sensible)):
+        return (sensible / shr, sensible)
+      }
+
+    }
+  }
+
+  public enum LevelTag {}
+
+  public typealias Level = Tagged<LevelTag, Int>
+
 }
 
 extension Room {
-
+  /// Represents the data required to create a new room for a project.
   public struct Create: Codable, Equatable, Sendable {
-    public let projectID: Project.ID
+    /// A unique name for the room in the project.
     public let name: String
+
+    /// An optional level of the home the room is on.
+    public let level: Room.Level?
+
+    /// The heating load required for the room (from Manual-J).
     public let heatingLoad: Double
-    public let coolingTotal: Double
+
+    /// The total cooling load required for the room (from Manual-J).
+    public let coolingTotal: Double?
+
+    /// An optional sensible cooling load for the room.
     public let coolingSensible: Double?
+
+    /// The number of registers for the room.
     public let registerCount: Int
 
+    /// An optional room that this room delegates it's airflow to.
+    public let delegatedTo: Room.ID?
+
+    public var coolingLoad: Room.CoolingLoad {
+      .init(total: coolingTotal, sensible: coolingSensible)
+    }
+
     public init(
-      projectID: Project.ID,
       name: String,
+      level: Room.Level? = nil,
       heatingLoad: Double,
-      coolingTotal: Double,
+      coolingTotal: Double? = nil,
       coolingSensible: Double? = nil,
-      registerCount: Int = 1
+      registerCount: Int = 1,
+      delegatedTo: Room.ID? = nil
     ) {
-      self.projectID = projectID
       self.name = name
+      self.level = level
       self.heatingLoad = heatingLoad
       self.coolingTotal = coolingTotal
       self.coolingSensible = coolingSensible
       self.registerCount = registerCount
+      self.delegatedTo = delegatedTo
     }
   }
 
-  public struct RectangularSize: Codable, Equatable, Identifiable, Sendable {
+  public struct CSV: Equatable, Sendable {
+    public let file: Data
 
+    public init(file: Data) {
+      self.file = file
+    }
+
+    /// Represents a row in a CSV file.
+    ///
+    /// This is similar to ``Room.Create``, but since the rooms are not yet
+    /// created, delegating to another room is done via the room's name
+    /// instead of id.
+    ///
+    public struct Row: Codable, Equatable, Sendable {
+
+      /// A unique name for the room in the project.
+      public let name: String
+
+      /// An optional level of the home the room is on.
+      public let level: Room.Level?
+
+      /// The heating load required for the room (from Manual-J).
+      public let heatingLoad: Double
+
+      /// The total cooling load required for the room (from Manual-J).
+      public let coolingTotal: Double?
+
+      /// An optional sensible cooling load for the room.
+      public let coolingSensible: Double?
+
+      /// The number of registers for the room.
+      public let registerCount: Int
+
+      /// An optional room that this room delegates it's airflow to.
+      public let delegatedToName: String?
+
+      public init(
+        name: String,
+        level: Room.Level? = nil,
+        heatingLoad: Double,
+        coolingTotal: Double? = nil,
+        coolingSensible: Double? = nil,
+        registerCount: Int,
+        delegatedToName: String? = nil
+      ) {
+        self.name = name
+        self.level = level
+        self.heatingLoad = heatingLoad
+        self.coolingTotal = coolingTotal
+        self.coolingSensible = coolingSensible
+        self.registerCount = registerCount
+        // Treat empty strings as nil, as they are often empty
+        // when left blank in a CSV file.
+        self.delegatedToName = delegatedToName == "" ? nil : delegatedToName
+      }
+    }
+
+  }
+
+  /// Represents a rectangular size calculation that is stored in the
+  /// database for a given room.
+  ///
+  /// These are done after the round duct sizes have been calculated and
+  /// can be used to calculate the equivalent rectangular size for a given run.
+  public struct RectangularSize: Codable, Equatable, Identifiable, Sendable {
+    /// The unique id of the rectangular size.
     public let id: UUID
+    /// The register the rectangular size is associated with.
     public let register: Int?
+    /// The height of the rectangular size, the width gets calculated.
     public let height: Int
 
     public init(
@@ -82,22 +241,44 @@ extension Room {
     }
   }
 
+  /// Represents field that can be updated on a room after it's been created in the database.
+  ///
+  /// Onlly fields that are supplied get updated.
   public struct Update: Codable, Equatable, Sendable {
+    /// A unique name for the room in the project.
     public let name: String?
+
+    /// An optional level of the home the room is on.
+    public let level: Room.Level?
+
+    /// The heating load required for the room (from Manual-J).
     public let heatingLoad: Double?
+    /// The total cooling load required for the room (from Manual-J).
     public let coolingTotal: Double?
+    /// An optional sensible cooling load for the room.
     public let coolingSensible: Double?
+    /// The number of registers for the room.
     public let registerCount: Int?
+    /// The rectangular duct size calculations for a room.
     public let rectangularSizes: [RectangularSize]?
 
+    public var coolingLoad: CoolingLoad? {
+      guard coolingTotal != nil || coolingSensible != nil else {
+        return nil
+      }
+      return .init(total: coolingTotal, sensible: coolingSensible)
+    }
+
     public init(
       name: String? = nil,
+      level: Room.Level? = nil,
       heatingLoad: Double? = nil,
       coolingTotal: Double? = nil,
       coolingSensible: Double? = nil,
       registerCount: Int? = nil
     ) {
       self.name = name
+      self.level = level
       self.heatingLoad = heatingLoad
       self.coolingTotal = coolingTotal
       self.coolingSensible = coolingSensible
@@ -109,6 +290,7 @@ extension Room {
       rectangularSizes: [RectangularSize]
     ) {
       self.name = nil
+      self.level = nil
       self.heatingLoad = nil
       self.coolingTotal = nil
       self.coolingSensible = nil
@@ -120,57 +302,49 @@ extension Room {
 
 extension Array where Element == Room {
 
+  /// The sum of heating loads for an array of rooms.
   public var totalHeatingLoad: Double {
     reduce(into: 0) { $0 += $1.heatingLoad }
   }
 
-  public var totalCoolingLoad: Double {
-    reduce(into: 0) { $0 += $1.coolingTotal }
+  /// The sum of total cooling loads for an array of rooms.
+  public func totalCoolingLoad(shr: Double) throws -> Double {
+    try reduce(into: 0) { $0 += try $1.coolingLoad.ensured(shr: shr).total }
   }
 
-  public func totalCoolingSensible(shr: Double) -> Double {
-    reduce(into: 0) {
-      let sensible = $1.coolingSensible ?? ($1.coolingTotal * shr)
-      $0 += sensible
+  /// The sum of sensible cooling loads for an array of rooms.
+  ///
+  /// - Parameters:
+  ///   - shr: The project wide sensible heat ratio.
+  public func totalCoolingSensible(shr: Double) throws -> Double {
+    try reduce(into: 0) {
+      // let sensible = $1.coolingSensible ?? ($1.coolingTotal * shr)
+      $0 += try $1.coolingLoad.ensured(shr: shr).sensible
     }
   }
 }
 
+public struct CoolingLoadError: Error, Equatable, Sendable {
+  public let reason: String
+
+  public init(_ reason: String) {
+    self.reason = reason
+  }
+}
+
+extension Room.Level {
+  /// The label for the level, i.e. 'Basement' or 'Level-1', etc.
+  public var label: String {
+    if rawValue <= 0 {
+      return "Basement"
+    }
+    return "Level-\(rawValue)"
+  }
+}
+
 #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()
-      ),
-    ]
 
     public static func mock(projectID: Project.ID) -> [Self] {
       @Dependency(\.uuid) var uuid
@@ -182,8 +356,8 @@ extension Array where Element == Room {
           projectID: projectID,
           name: "Bed-1",
           heatingLoad: 3913,
-          coolingTotal: 2472,
-          coolingSensible: nil,
+          coolingLoad: .init(total: 2472),
+          // coolingSensible: nil,
           registerCount: 1,
           rectangularSizes: nil,
           createdAt: now,
@@ -194,8 +368,8 @@ extension Array where Element == Room {
           projectID: projectID,
           name: "Entry",
           heatingLoad: 8284,
-          coolingTotal: 2916,
-          coolingSensible: nil,
+          coolingLoad: .init(total: 2916),
+          // coolingSensible: nil,
           registerCount: 2,
           rectangularSizes: nil,
           createdAt: now,
@@ -206,8 +380,8 @@ extension Array where Element == Room {
           projectID: projectID,
           name: "Family Room",
           heatingLoad: 9785,
-          coolingTotal: 7446,
-          coolingSensible: nil,
+          coolingLoad: .init(total: 7446),
+          // coolingSensible: nil,
           registerCount: 3,
           rectangularSizes: nil,
           createdAt: now,
@@ -218,8 +392,8 @@ extension Array where Element == Room {
           projectID: projectID,
           name: "Kitchen",
           heatingLoad: 4518,
-          coolingTotal: 5096,
-          coolingSensible: nil,
+          coolingLoad: .init(total: 5096),
+          // coolingSensible: nil,
           registerCount: 2,
           rectangularSizes: nil,
           createdAt: now,
@@ -230,8 +404,8 @@ extension Array where Element == Room {
           projectID: projectID,
           name: "Living Room",
           heatingLoad: 7553,
-          coolingTotal: 6829,
-          coolingSensible: nil,
+          coolingLoad: .init(total: 6829),
+          // coolingSensible: nil,
           registerCount: 2,
           rectangularSizes: nil,
           createdAt: now,
@@ -242,8 +416,8 @@ extension Array where Element == Room {
           projectID: projectID,
           name: "Master",
           heatingLoad: 8202,
-          coolingTotal: 2076,
-          coolingSensible: nil,
+          coolingLoad: .init(total: 2076),
+          // coolingSensible: nil,
           registerCount: 2,
           rectangularSizes: nil,
           createdAt: now,

Sources/ManualDCore/Routes/ApiRoute.swift

@@ -1,270 +0,0 @@
-import CasePathsCore
-import Foundation
-@preconcurrency import URLRouting
-
-extension SiteRoute {
-  /// Represents api routes.
-  ///
-  /// The routes return json as opposed to view routes that return html.
-  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"
-      "v1"
-    }
-
-    public static let router = OneOf {
-      Route(.case(Self.project)) {
-        rootPath
-        ProjectRoute.router
-      }
-      Route(.case(Self.room)) {
-        rootPath
-        RoomRoute.router
-      }
-      Route(.case(Self.equipment)) {
-        rootPath
-        EquipmentRoute.router
-      }
-      Route(.case(Self.componentLoss)) {
-        rootPath
-        ComponentLossRoute.router
-      }
-    }
-
-  }
-
-}
-
-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
-
-    static let rootPath = "projects"
-
-    public static let router = OneOf {
-      Route(.case(Self.create)) {
-        Path { rootPath }
-        Method.post
-        Body(.json(Project.Create.self))
-      }
-      Route(.case(Self.delete(id:))) {
-        Path {
-          rootPath
-          Project.ID.parser()
-        }
-        Method.delete
-      }
-      Route(.case(Self.get(id:))) {
-        Path {
-          rootPath
-          Project.ID.parser()
-        }
-        Method.get
-      }
-      Route(.case(Self.index)) {
-        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 index
-    case completedSteps
-
-    static let rootPath = "details"
-
-    static let router = OneOf {
-      Route(.case(Self.index)) {
-        Path { rootPath }
-        Method.get
-      }
-      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

@@ -5,14 +5,10 @@ import Foundation
 
 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

Sources/ManualDCore/Routes/ViewRoute.swift

@@ -8,9 +8,12 @@ extension SiteRoute {
   ///
   /// The routes return html.
   public enum View: Equatable, Sendable {
+    case home
+    case privacyPolicy
     case login(LoginRoute)
     case signup(SignupRoute)
     case project(ProjectRoute)
+    case ductulator(DuctulatorRoute)
     case user(UserRoute)
     //FIX: Remove.
     case test
@@ -20,6 +23,13 @@ extension SiteRoute {
         Path { "test" }
         Method.get
       }
+      Route(.case(Self.home)) {
+        Method.get
+      }
+      Route(.case(Self.privacyPolicy)) {
+        Path { "privacy-policy" }
+        Method.get
+      }
       Route(.case(Self.login)) {
         SiteRoute.View.LoginRoute.router
       }
@@ -29,6 +39,9 @@ extension SiteRoute {
       Route(.case(Self.project)) {
         SiteRoute.View.ProjectRoute.router
       }
+      Route(.case(Self.ductulator)) {
+        SiteRoute.View.DuctulatorRoute.router
+      }
       Route(.case(Self.user)) {
         SiteRoute.View.UserRoute.router
       }
@@ -188,6 +201,7 @@ extension SiteRoute.View.ProjectRoute {
   }
 
   public enum RoomRoute: Equatable, Sendable {
+    case csv(Room.CSV)
     case delete(id: Room.ID)
     case index
     case submit(Room.Create)
@@ -197,6 +211,17 @@ extension SiteRoute.View.ProjectRoute {
     static let rootPath = "rooms"
 
     public static let router = OneOf {
+      Route(.case(Self.csv)) {
+        Path {
+          rootPath
+          "csv"
+        }
+        Headers {
+          Field("Content-Type") { "multipart/form-data" }
+        }
+        Method.post
+        Body().map(.memberwise(Room.CSV.init))
+      }
       Route(.case(Self.delete)) {
         Path {
           rootPath
@@ -215,14 +240,24 @@ extension SiteRoute.View.ProjectRoute {
         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("level") {
+                Int.parser()
+              }
+              .map(.memberwise(Room.Level.init(rawValue:)))
+            }
+            Field("heatingLoad") { Double.parser() }
+            Optionally {
+              Field("coolingTotal") { Double.parser() }
+            }
+            Optionally {
+              Field("coolingSensible") { Double.parser() }
             }
             Field("registerCount") { Digits() }
+            Optionally {
+              Field("delegatedTo") { Room.ID.parser() }
+            }
           }
           .map(.memberwise(Room.Create.init))
         }
@@ -238,6 +273,12 @@ extension SiteRoute.View.ProjectRoute {
             Optionally {
               Field("name", .string)
             }
+            Optionally {
+              Field("level") {
+                Int.parser()
+              }
+              .map(.memberwise(Room.Level.init(rawValue:)))
+            }
             Optionally {
               Field("heatingLoad") { Double.parser() }
             }
@@ -394,11 +435,11 @@ extension SiteRoute.View.ProjectRoute {
   }
 
   public enum EquivalentLengthRoute: Equatable, Sendable {
-    case delete(id: EffectiveLength.ID)
-    case field(FieldType, style: EffectiveLength.EffectiveLengthType? = nil)
+    case delete(id: EquivalentLength.ID)
+    case field(FieldType, style: EquivalentLength.EffectiveLengthType? = nil)
     case index
     case submit(FormStep)
-    case update(EffectiveLength.ID, StepThree)
+    case update(EquivalentLength.ID, StepThree)
 
     static let rootPath = "effective-lengths"
 
@@ -406,7 +447,7 @@ extension SiteRoute.View.ProjectRoute {
       Route(.case(Self.delete(id:))) {
         Path {
           rootPath
-          EffectiveLength.ID.parser()
+          EquivalentLength.ID.parser()
         }
         Method.delete
       }
@@ -424,7 +465,7 @@ extension SiteRoute.View.ProjectRoute {
           Field("type") { FieldType.parser() }
           Optionally {
             Field("style", default: nil) {
-              EffectiveLength.EffectiveLengthType.parser()
+              EquivalentLength.EffectiveLengthType.parser()
             }
           }
         }
@@ -437,16 +478,16 @@ extension SiteRoute.View.ProjectRoute {
       Route(.case(Self.update)) {
         Path {
           rootPath
-          EffectiveLength.ID.parser()
+          EquivalentLength.ID.parser()
         }
         Method.patch
         Body {
           FormData {
             Optionally {
-              Field("id", default: nil) { EffectiveLength.ID.parser() }
+              Field("id", default: nil) { EquivalentLength.ID.parser() }
             }
             Field("name", .string)
-            Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+            Field("type") { EquivalentLength.EffectiveLengthType.parser() }
             Many {
               Field("straightLengths") {
                 Int.parser()
@@ -490,10 +531,10 @@ extension SiteRoute.View.ProjectRoute {
           Body {
             FormData {
               Optionally {
-                Field("id", default: nil) { EffectiveLength.ID.parser() }
+                Field("id", default: nil) { EquivalentLength.ID.parser() }
               }
               Field("name", .string)
-              Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+              Field("type") { EquivalentLength.EffectiveLengthType.parser() }
             }
             .map(.memberwise(StepOne.init))
           }
@@ -505,10 +546,10 @@ extension SiteRoute.View.ProjectRoute {
           Body {
             FormData {
               Optionally {
-                Field("id", default: nil) { EffectiveLength.ID.parser() }
+                Field("id", default: nil) { EquivalentLength.ID.parser() }
               }
               Field("name", .string)
-              Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+              Field("type") { EquivalentLength.EffectiveLengthType.parser() }
               Many {
                 Field("straightLengths") {
                   Int.parser()
@@ -525,10 +566,10 @@ extension SiteRoute.View.ProjectRoute {
           Body {
             FormData {
               Optionally {
-                Field("id", default: nil) { EffectiveLength.ID.parser() }
+                Field("id", default: nil) { EquivalentLength.ID.parser() }
               }
               Field("name", .string)
-              Field("type") { EffectiveLength.EffectiveLengthType.parser() }
+              Field("type") { EquivalentLength.EffectiveLengthType.parser() }
               Many {
                 Field("straightLengths") {
                   Int.parser()
@@ -567,22 +608,22 @@ extension SiteRoute.View.ProjectRoute {
     }
 
     public struct StepOne: Codable, Equatable, Sendable {
-      public let id: EffectiveLength.ID?
+      public let id: EquivalentLength.ID?
       public let name: String
-      public let type: EffectiveLength.EffectiveLengthType
+      public let type: EquivalentLength.EffectiveLengthType
     }
 
     public struct StepTwo: Codable, Equatable, Sendable {
 
-      public let id: EffectiveLength.ID?
+      public let id: EquivalentLength.ID?
       public let name: String
-      public let type: EffectiveLength.EffectiveLengthType
+      public let type: EquivalentLength.EffectiveLengthType
       public let straightLengths: [Int]
 
       public init(
-        id: EffectiveLength.ID? = nil,
+        id: EquivalentLength.ID? = nil,
         name: String,
-        type: EffectiveLength.EffectiveLengthType,
+        type: EquivalentLength.EffectiveLengthType,
         straightLengths: [Int]
       ) {
         self.id = id
@@ -593,9 +634,9 @@ extension SiteRoute.View.ProjectRoute {
     }
 
     public struct StepThree: Codable, Equatable, Sendable {
-      public let id: EffectiveLength.ID?
+      public let id: EquivalentLength.ID?
       public let name: String
-      public let type: EffectiveLength.EffectiveLengthType
+      public let type: EquivalentLength.EffectiveLengthType
       public let straightLengths: [Int]
       public let groupGroups: [Int]
       public let groupLetters: [String]
@@ -873,11 +914,16 @@ extension SiteRoute.View {
 extension SiteRoute.View {
   public enum UserRoute: Equatable, Sendable {
     case profile(Profile)
+    case logout
 
     static let router = OneOf {
       Route(.case(Self.profile)) {
         Profile.router
       }
+      Route(.case(Self.logout)) {
+        Path { "logout" }
+        Method.get
+      }
     }
   }
 }
@@ -955,6 +1001,49 @@ extension SiteRoute.View.UserRoute {
   }
 }
 
+extension SiteRoute.View {
+  public enum DuctulatorRoute: Equatable, Sendable {
+    case index
+    case submit(Form)
+
+    public static let rootPath = "duct-size"
+
+    static let router = OneOf {
+      Route(.case(Self.index)) {
+        Path { rootPath }
+        Method.get
+      }
+      Route(.case(Self.submit)) {
+        Path { rootPath }
+        Method.post
+        Body {
+          FormData {
+            Field("cfm") { Int.parser() }
+            Field("frictionRate") { Double.parser() }
+            Optionally {
+              Field("height") { Int.parser() }
+            }
+          }
+          .map(.memberwise(Form.init))
+        }
+      }
+    }
+
+    public struct Form: Equatable, Sendable {
+
+      public let cfm: Int
+      public let frictionRate: Double
+      public let height: Int?
+
+      public init(cfm: Int, frictionRate: Double, height: Int? = nil) {
+        self.cfm = cfm
+        self.frictionRate = frictionRate
+        self.height = height
+      }
+    }
+  }
+}
+
 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

@@ -1,5 +1,6 @@
 import Foundation
 
+/// Represents supported color themes for the website.
 public enum Theme: String, CaseIterable, Codable, Equatable, Sendable {
   case aqua
   case cupcake
@@ -13,6 +14,7 @@ public enum Theme: String, CaseIterable, Codable, Equatable, Sendable {
   case retro
   case synthwave
 
+  /// Represents dark color themes.
   public static let darkThemes = [
     Self.aqua,
     Self.cyberpunk,
@@ -22,6 +24,7 @@ public enum Theme: String, CaseIterable, Codable, Equatable, Sendable {
     Self.synthwave,
   ]
 
+  /// Represents light color themes.
   public static let lightThemes = [
     Self.cupcake,
     Self.light,

Sources/ManualDCore/TrunkSize.swift

@@ -1,14 +1,23 @@
 import Dependencies
 import Foundation
 
-// Represents the database model.
+/// Represents trunk calculations for a project.
+///
+/// These are used to size trunk ducts / runs for multiple rooms or registers.
 public struct TrunkSize: Codable, Equatable, Identifiable, Sendable {
 
+  /// The unique identifier of the trunk size.
   public let id: UUID
+  /// The project the trunk size is for.
   public let projectID: Project.ID
+  /// The type of the trunk size (supply or return).
   public let type: TrunkType
+  /// The rooms / registers associated with the trunk size.
   public let rooms: [RoomProxy]
+  /// An optional rectangular height used to calculate the equivalent
+  /// rectangular size of the trunk.
   public let height: Int?
+  /// An optional name / label used for identifying the trunk.
   public let name: String?
 
   public init(
@@ -29,12 +38,19 @@ public struct TrunkSize: Codable, Equatable, Identifiable, Sendable {
 }
 
 extension TrunkSize {
+  /// Represents the data needed to create a new ``TrunkSize`` in the database.
   public struct Create: Codable, Equatable, Sendable {
 
+    /// The project the trunk size is for.
     public let projectID: Project.ID
+    /// The type of the trunk size (supply or return).
     public let type: TrunkType
+    /// The rooms / registers associated with the trunk size.
     public let rooms: [Room.ID: [Int]]
+    /// An optional rectangular height used to calculate the equivalent
+    /// rectangular size of the trunk.
     public let height: Int?
+    /// An optional name / label used for identifying the trunk.
     public let name: String?
 
     public init(
@@ -52,11 +68,19 @@ extension TrunkSize {
     }
   }
 
+  /// Represents the fields that can be updated on a ``TrunkSize`` in the database.
+  ///
+  /// Only supplied fields are updated.
   public struct Update: Codable, Equatable, Sendable {
 
+    /// The type of the trunk size (supply or return).
     public let type: TrunkType?
+    /// The rooms / registers associated with the trunk size.
     public let rooms: [Room.ID: [Int]]?
+    /// An optional rectangular height used to calculate the equivalent
+    /// rectangular size of the trunk.
     public let height: Int?
+    /// An optional name / label used for identifying the trunk.
     public let name: String?
 
     public init(
@@ -72,18 +96,29 @@ extension TrunkSize {
     }
   }
 
-  public struct RoomProxy: Codable, Equatable, Identifiable, Sendable {
+  /// A container / wrapper around a ``Room`` that is used with a ``TrunkSize``.
+  ///
+  /// This is needed because a room can have multiple registers and it is possible
+  /// that a trunk does not serve all registers in that room.
+  @dynamicMemberLookup
+  public struct RoomProxy: Codable, Equatable, Sendable {
 
-    public var id: Room.ID { room.id }
+    /// The room associated with the ``TrunkSize``.
     public let room: Room
+    /// The specific room registers associated with the ``TrunkSize``.
     public let registers: [Int]
 
     public init(room: Room, registers: [Int]) {
       self.room = room
       self.registers = registers
     }
+
+    public subscript<T>(dynamicMember keyPath: KeyPath<Room, T>) -> T {
+      room[keyPath: keyPath]
+    }
   }
 
+  /// Represents the type of a ``TrunkSize``, either supply or return.
   public enum TrunkType: String, CaseIterable, Codable, Equatable, Sendable {
     case `return`
     case supply

Sources/ManualDCore/User.swift

@@ -1,12 +1,17 @@
 import Dependencies
 import Foundation
 
-// FIX: Remove username.
+/// Represents a user of the site.
+///
 public struct User: Codable, Equatable, Identifiable, Sendable {
 
+  /// The unique id of the user.
   public let id: UUID
+  /// The user's email address.
   public let email: String
+  /// When the user was created in the database.
   public let createdAt: Date
+  /// When the user was updated in the database.
   public let updatedAt: Date
 
   public init(
@@ -23,10 +28,14 @@ public struct User: Codable, Equatable, Identifiable, Sendable {
 }
 
 extension User {
+  /// Represents the data required to create a new user.
   public struct Create: Codable, Equatable, Sendable {
 
+    /// The user's email address.
     public let email: String
+    /// The password for the user.
     public let password: String
+    /// The password confirmation, must match the password.
     public let confirmPassword: String
 
     public init(
@@ -40,9 +49,13 @@ extension User {
     }
   }
 
+  /// Represents data required to login a user.
   public struct Login: Codable, Equatable, Sendable {
+    /// The user's email address.
     public let email: String
+    /// The password for the user.
     public let password: String
+    /// An optional page / route to navigate to after logging in the user.
     public let next: String?
 
     public init(email: String, password: String, next: String? = nil) {
@@ -52,10 +65,13 @@ extension User {
     }
   }
 
+  /// Represents a user session token, for a logged in user.
   public struct Token: Codable, Equatable, Identifiable, Sendable {
-
+    /// The unique id of the token.
     public let id: UUID
+    /// The user id the token is for.
     public let userID: User.ID
+    /// The token value.
     public let value: String
 
     public init(id: UUID, userID: User.ID, value: String) {

Sources/ManualDCore/UserProfile.swift

@@ -2,19 +2,32 @@ import Dependencies
 import Foundation
 
 extension User {
+  /// Represents a user's profile. Which contains extra information about a user of the site.
   public struct Profile: Codable, Equatable, Identifiable, Sendable {
 
+    /// The unique id of the profile
     public let id: UUID
+    /// The user id the profile is for.
     public let userID: User.ID
+    /// The user's first name.
     public let firstName: String
+    /// The user's last name.
     public let lastName: String
+    /// The user's company name.
     public let companyName: String
+    /// The user's street address.
     public let streetAddress: String
+    /// The user's city.
     public let city: String
+    /// The user's state.
     public let state: String
+    /// The user's zip code.
     public let zipCode: String
+    /// An optional theme that the user prefers.
     public let theme: Theme?
+    /// When the profile was created in the database.
     public let createdAt: Date
+    /// When the profile was updated in the database.
     public let updatedAt: Date
 
     public init(
@@ -49,15 +62,25 @@ extension User {
 
 extension User.Profile {
 
+  /// Represents the data required to create a user profile.
   public struct Create: Codable, Equatable, Sendable {
+    /// The user id the profile is for.
     public let userID: User.ID
+    /// The user's first name.
     public let firstName: String
+    /// The user's last name.
     public let lastName: String
+    /// The user's company name.
     public let companyName: String
+    /// The user's street address.
     public let streetAddress: String
+    /// The user's city.
     public let city: String
+    /// The user's state.
     public let state: String
+    /// The user's zip code.
     public let zipCode: String
+    /// An optional theme that the user prefers.
     public let theme: Theme?
 
     public init(
@@ -83,14 +106,25 @@ extension User.Profile {
     }
   }
 
+  /// Represents the fields that can be updated on a user's profile.
+  ///
+  /// Only fields that are supplied get updated.
   public struct Update: Codable, Equatable, Sendable {
+    /// The user's first name.
     public let firstName: String?
+    /// The user's last name.
     public let lastName: String?
+    /// The user's company name.
     public let companyName: String?
+    /// The user's street address.
     public let streetAddress: String?
+    /// The user's city.
     public let city: String?
+    /// The user's state.
     public let state: String?
+    /// The user's zip code.
     public let zipCode: String?
+    /// An optional theme that the user prefers.
     public let theme: Theme?
 
     public init(

Sources/PdfClient/Interface.swift

@@ -1,7 +1,7 @@
 import Dependencies
 import DependenciesMacros
 import Elementary
-import EnvClient
+import EnvVars
 import FileClient
 import Foundation
 import ManualDCore
@@ -32,8 +32,7 @@ public struct PdfClient: Sendable {
   /// - Parameters:
   ///   - request: The project data used to generate the pdf.
   public func generatePdf(request: Request) async throws -> Response {
-    let html = try await self.html(request)
-    return try await self.generatePdf(request.project.id, html)
+    try await self.generatePdf(request.project.id, html(request))
   }
 
 }
@@ -47,9 +46,8 @@ extension PdfClient: DependencyKey {
     },
     generatePdf: { projectID, html in
       @Dependency(\.fileClient) var fileClient
-      @Dependency(\.env) var env
+      @Dependency(\.environment) var environment
 
-      let envVars = try env()
       let baseUrl = "/tmp/\(projectID)"
       try await fileClient.writeFile(html.render(), "\(baseUrl).html")
 
@@ -58,10 +56,10 @@ extension PdfClient: DependencyKey {
       let standardOutput = Pipe()
       process.standardInput = standardInput
       process.standardOutput = standardOutput
-      process.executableURL = URL(fileURLWithPath: envVars.pandocPath)
+      process.executableURL = URL(fileURLWithPath: environment.pandocPath)
       process.arguments = [
         "\(baseUrl).html",
-        "--pdf-engine=\(envVars.pdfEngine)",
+        "--pdf-engine=\(environment.pdfEngine)",
         "--from=html",
         "--css=Public/css/pdf.css",
         "--output=\(baseUrl).pdf",
@@ -76,17 +74,26 @@ extension PdfClient: DependencyKey {
 }
 
 extension PdfClient {
-  /// Container for the data required to generate a pdf for a given project.
+  /// Represents the data required to generate a pdf for a given project.
   public struct Request: Codable, Equatable, Sendable {
 
+    /// The project we're generating a pdf for.
     public let project: Project
+    /// The rooms in the project.
     public let rooms: [Room]
+    /// The component pressure losses for the project.
     public let componentLosses: [ComponentPressureLoss]
+    /// The calculated duct sizes for the project.
     public let ductSizes: DuctSizes
+    /// The equipment information for the project.
     public let equipmentInfo: EquipmentInfo
-    public let maxSupplyTEL: EffectiveLength
-    public let maxReturnTEL: EffectiveLength
+    /// The max supply equivalent length for the project.
+    public let maxSupplyTEL: EquivalentLength
+    /// The max return equivalent length for the project.
+    public let maxReturnTEL: EquivalentLength
+    /// The calculated design friction rate for the project.
     public let frictionRate: FrictionRate
+    /// The project wide sensible heat ratio.
     public let projectSHR: Double
 
     var totalEquivalentLength: Double {
@@ -99,8 +106,8 @@ extension PdfClient {
       componentLosses: [ComponentPressureLoss],
       ductSizes: DuctSizes,
       equipmentInfo: EquipmentInfo,
-      maxSupplyTEL: EffectiveLength,
-      maxReturnTEL: EffectiveLength,
+      maxSupplyTEL: EquivalentLength,
+      maxReturnTEL: EquivalentLength,
       frictionRate: FrictionRate,
       projectSHR: Double
     ) {
@@ -116,9 +123,12 @@ extension PdfClient {
     }
   }
 
+  /// Represents the response after generating a pdf.
   public struct Response: Equatable, Sendable {
 
+    /// The path to the html file used to generate the pdf from.
     public let htmlPath: String
+    /// The path to the pdf file.
     public let pdfPath: String
 
     public init(htmlPath: String, pdfPath: String) {
@@ -134,13 +144,18 @@ extension PdfClient {
       let rooms = Room.mock(projectID: project.id)
       let trunks = TrunkSize.mock(projectID: project.id, rooms: rooms)
       let equipmentInfo = EquipmentInfo.mock(projectID: project.id)
-      let equivalentLengths = EffectiveLength.mock(projectID: project.id)
+      let equivalentLengths = EquivalentLength.mock(projectID: project.id)
 
       return .init(
         project: project,
         rooms: rooms,
         componentLosses: ComponentPressureLoss.mock(projectID: project.id),
-        ductSizes: .mock(equipmentInfo: equipmentInfo, rooms: rooms, trunks: trunks),
+        ductSizes: .mock(
+          equipmentInfo: equipmentInfo,
+          rooms: rooms,
+          trunks: trunks,
+          shr: project.sensibleHeatRatio ?? 0.83
+        ),
         equipmentInfo: equipmentInfo,
         maxSupplyTEL: equivalentLengths.first { $0.type == .supply }!,
         maxReturnTEL: equivalentLengths.first { $0.type == .return }!,

Sources/PdfClient/Views/EquivalentLengthTable.swift

@@ -2,7 +2,7 @@ import Elementary
 import ManualDCore
 
 struct EffectiveLengthsTable: HTML, Sendable {
-  let effectiveLengths: [EffectiveLength]
+  let effectiveLengths: [EquivalentLength]
 
   var body: some HTML<HTMLTag.table> {
     table {
@@ -41,7 +41,7 @@ struct EffectiveLengthsTable: HTML, Sendable {
 }
 
 struct EffectiveLengthGroupTable: HTML, Sendable {
-  let groups: [EffectiveLength.Group]
+  let groups: [EquivalentLength.FittingGroup]
 
   var body: some HTML<HTMLTag.table> {
     table {

Sources/PdfClient/Views/RoomTable.swift

@@ -21,10 +21,9 @@ struct RoomsTable: HTML, Sendable {
           tr {
             td { room.name }
             td { room.heatingLoad.string(digits: 0) }
-            td { room.coolingTotal.string(digits: 0) }
+            td { try! room.coolingLoad.ensured(shr: projectSHR).total.string(digits: 0) }
             td {
-              (room.coolingSensible
-                ?? (room.coolingTotal * projectSHR)).string(digits: 0)
+              try! room.coolingLoad.ensured(shr: projectSHR).sensible.string(digits: 0)
             }
             td { room.registerCount.string() }
           }
@@ -37,10 +36,10 @@ struct RoomsTable: HTML, Sendable {
             rooms.totalHeatingLoad.string(digits: 0)
           }
           td(.class("coolingTotal label")) {
-            rooms.totalCoolingLoad.string(digits: 0)
+            try! rooms.totalCoolingLoad(shr: projectSHR).string(digits: 0)
           }
           td(.class("coolingSensible label")) {
-            rooms.totalCoolingSensible(shr: projectSHR).string(digits: 0)
+            try! rooms.totalCoolingSensible(shr: projectSHR).string(digits: 0)
           }
           td {}
         }

Sources/ProjectClient/DuctCalcClientError.swift

@@ -1,9 +0,0 @@
-import Foundation
-
-public struct ProjectClientError: Error {
-  public let reason: String
-
-  public init(_ reason: String) {
-    self.reason = reason
-  }
-}

Sources/ProjectClient/Interface.swift

@@ -15,12 +15,15 @@ extension DependencyValues {
 /// Useful helper utilities for project's.
 ///
 /// This is primarily used for implementing logic required to get the needed data
-/// for the view controller client to render views.
+/// for the view controller to render views.
 @DependencyClient
 public struct ProjectClient: Sendable {
-  public var calculateDuctSizes: @Sendable (Project.ID) async throws -> DuctSizes
+
+  /// Calculates the room duct sizes for the given project.
   public var calculateRoomDuctSizes:
     @Sendable (Project.ID) async throws -> [DuctSizes.RoomContainer]
+
+  /// Calculates the trunk duct sizes for the given project.
   public var calculateTrunkDuctSizes:
     @Sendable (Project.ID) async throws -> [DuctSizes.TrunkContainer]
 
@@ -29,6 +32,13 @@ public struct ProjectClient: Sendable {
 
   public var frictionRate: @Sendable (Project.ID) async throws -> FrictionRateResponse
   public var generatePdf: @Sendable (Project.ID) async throws -> Response
+
+  public func calculateDuctSizes(_ projectID: Project.ID) async throws -> DuctSizes {
+    .init(
+      rooms: try await calculateRoomDuctSizes(projectID),
+      trunks: try await calculateTrunkDuctSizes(projectID)
+    )
+  }
 }
 
 extension ProjectClient: TestDependencyKey {
@@ -60,12 +70,12 @@ extension ProjectClient {
   public struct FrictionRateResponse: Codable, Equatable, Sendable {
 
     public let componentLosses: [ComponentPressureLoss]
-    public let equivalentLengths: EffectiveLength.MaxContainer
+    public let equivalentLengths: EquivalentLength.MaxContainer
     public let frictionRate: FrictionRate?
 
     public init(
       componentLosses: [ComponentPressureLoss],
-      equivalentLengths: EffectiveLength.MaxContainer,
+      equivalentLengths: EquivalentLength.MaxContainer,
       frictionRate: FrictionRate? = nil
     ) {
       self.componentLosses = componentLosses

Sources/ProjectClient/Internal/ComponentLoss+createDefaults.swift

@@ -1,7 +1,7 @@
 import DatabaseClient
 import ManualDCore
 
-extension DatabaseClient.ComponentLoss {
+extension DatabaseClient.ComponentLosses {
 
   func createDefaults(projectID: Project.ID) async throws {
     let defaults = ComponentPressureLoss.Create.default(projectID: projectID)

Sources/ProjectClient/Internal/DatabaseClient+calculateDuctSizes.swift

@@ -9,32 +9,18 @@ extension DatabaseClient {
     details: Project.Detail
   ) async throws -> (DuctSizes, DuctSizeSharedRequest) {
     let (rooms, shared) = try await calculateRoomDuctSizes(details: details)
-    let (trunks, _) = try await calculateTrunkDuctSizes(details: details)
-    return (.init(rooms: rooms, trunks: trunks), shared)
-  }
-
-  func calculateDuctSizes(
-    projectID: Project.ID
-  ) async throws -> (DuctSizes, DuctSizeSharedRequest, [Room]) {
-    @Dependency(\.manualD) var manualD
-
-    let shared = try await sharedDuctRequest(projectID)
-    let rooms = try await rooms.fetch(projectID)
-
     return try await (
-      manualD.calculateDuctSizes(
+      .init(
         rooms: rooms,
-        trunks: trunkSizes.fetch(projectID),
-        sharedRequest: shared
+        trunks: calculateTrunkDuctSizes(details: details, shared: shared)
       ),
-      shared,
-      rooms
+      shared
     )
   }
 
   func calculateRoomDuctSizes(
     details: Project.Detail
-  ) async throws -> ([DuctSizes.RoomContainer], DuctSizeSharedRequest) {
+  ) async throws -> (rooms: [DuctSizes.RoomContainer], shared: DuctSizeSharedRequest) {
     @Dependency(\.manualD) var manualD
 
     let shared = try sharedDuctRequest(details: details)
@@ -42,54 +28,29 @@ extension DatabaseClient {
     return (rooms, shared)
   }
 
-  func calculateRoomDuctSizes(
-    projectID: Project.ID
-  ) async throws -> ([DuctSizes.RoomContainer], DuctSizeSharedRequest) {
-    @Dependency(\.manualD) var manualD
-
-    let shared = try await sharedDuctRequest(projectID)
-
-    return try await (
-      manualD.calculateRoomSizes(
-        rooms: rooms.fetch(projectID),
-        sharedRequest: shared
-      ),
-      shared
-    )
-  }
-
   func calculateTrunkDuctSizes(
-    details: Project.Detail
-  ) async throws -> ([DuctSizes.TrunkContainer], DuctSizeSharedRequest) {
+    details: Project.Detail,
+    shared: DuctSizeSharedRequest? = nil
+  ) async throws -> [DuctSizes.TrunkContainer] {
     @Dependency(\.manualD) var manualD
 
-    let shared = try sharedDuctRequest(details: details)
-    let trunks = try await manualD.calculateTrunkSizes(
+    let sharedRequest: DuctSizeSharedRequest
+    if let shared {
+      sharedRequest = shared
+    } else {
+      sharedRequest = try sharedDuctRequest(details: details)
+    }
+
+    return try await manualD.calculateTrunkSizes(
       rooms: details.rooms,
       trunks: details.trunks,
-      sharedRequest: shared
-    )
-    return (trunks, shared)
-  }
-
-  func calculateTrunkDuctSizes(
-    projectID: Project.ID
-  ) async throws -> ([DuctSizes.TrunkContainer], DuctSizeSharedRequest) {
-    @Dependency(\.manualD) var manualD
-
-    let shared = try await sharedDuctRequest(projectID)
-
-    return try await (
-      manualD.calculateTrunkSizes(
-        rooms: rooms.fetch(projectID),
-        trunks: trunkSizes.fetch(projectID),
-        sharedRequest: shared
-      ),
-      shared
+      sharedRequest: sharedRequest
     )
   }
 
   func sharedDuctRequest(details: Project.Detail) throws -> DuctSizeSharedRequest {
+    let projectSHR = try details.project.ensuredSHR()
+
     guard
       let dfrResponse = designFrictionRate(
         componentLosses: details.componentLosses,
@@ -100,10 +61,6 @@ extension DatabaseClient {
       throw ProjectClientError("Project not complete.")
     }
 
-    guard let projectSHR = details.project.sensibleHeatRatio else {
-      throw ProjectClientError("Project sensible heat ratio not set.")
-    }
-
     let ensuredTEL = try dfrResponse.ensureMaxContainer()
 
     return .init(
@@ -115,40 +72,14 @@ extension DatabaseClient {
     )
   }
 
-  func sharedDuctRequest(_ projectID: Project.ID) async throws -> DuctSizeSharedRequest {
-
-    guard let dfrResponse = try await designFrictionRate(projectID: projectID) else {
-      throw ProjectClientError("Project not complete.")
-    }
-
-    let ensuredTEL = try dfrResponse.ensureMaxContainer()
-
-    return try await .init(
-      equipmentInfo: dfrResponse.equipmentInfo,
-      maxSupplyLength: ensuredTEL.supply,
-      maxReturnLenght: ensuredTEL.return,
-      designFrictionRate: dfrResponse.designFrictionRate,
-      projectSHR: ensuredSHR(projectID)
-    )
-
-  }
-
-  // Fetches the project sensible heat ratio or throws an error if it's nil.
-  func ensuredSHR(_ projectID: Project.ID) async throws -> Double {
-    guard let projectSHR = try await projects.getSensibleHeatRatio(projectID) else {
-      throw ProjectClientError("Project sensible heat ratio not set.")
-    }
-    return projectSHR
-  }
-
   // Internal container.
   struct DesignFrictionRateResponse: Equatable, Sendable {
 
-    typealias EnsuredTEL = (supply: EffectiveLength, return: EffectiveLength)
+    typealias EnsuredTEL = (supply: EquivalentLength, return: EquivalentLength)
 
     let designFrictionRate: Double
     let equipmentInfo: EquipmentInfo
-    let telMaxContainer: EffectiveLength.MaxContainer
+    let telMaxContainer: EquivalentLength.MaxContainer
 
     func ensureMaxContainer() throws -> EnsuredTEL {
 
@@ -167,9 +98,9 @@ extension DatabaseClient {
   func designFrictionRate(
     componentLosses: [ComponentPressureLoss],
     equipmentInfo: EquipmentInfo,
-    equivalentLengths: EffectiveLength.MaxContainer
+    equivalentLengths: EquivalentLength.MaxContainer
   ) -> DesignFrictionRateResponse? {
-    guard let tel = equivalentLengths.total,
+    guard let tel = equivalentLengths.totalEquivalentLength,
       componentLosses.count > 0
     else { return nil }
 
@@ -183,18 +114,13 @@ extension DatabaseClient {
 
   }
 
-  func designFrictionRate(
-    projectID: Project.ID
-  ) async throws -> DesignFrictionRateResponse? {
+}
 
-    guard let equipmentInfo = try await equipment.fetch(projectID) else {
-      return nil
+extension Project {
+  func ensuredSHR() throws -> Double {
+    guard let shr = sensibleHeatRatio else {
+      throw ProjectClientError("Sensible heat ratio not set on project id: \(id)")
     }
-
-    return try await designFrictionRate(
-      componentLosses: componentLoss.fetch(projectID),
-      equipmentInfo: equipmentInfo,
-      equivalentLengths: effectiveLength.fetchMax(projectID)
-    )
+    return shr
   }
 }

Sources/ProjectClient/Internal/DatabaseClient+makePdfRequest.swift

@@ -0,0 +1,53 @@
+import DatabaseClient
+import Dependencies
+import ManualDClient
+import ManualDCore
+import PdfClient
+
+extension DatabaseClient {
+
+  /// Generate a pdf request for the given project.
+  func makePdfRequest(_ projectID: Project.ID) async throws -> PdfClient.Request {
+    @Dependency(\.manualD) var manualD
+
+    guard let projectDetails = try await projects.detail(projectID) else {
+      throw ProjectClientError.notFound(.project(projectID))
+    }
+
+    let (ductSizes, shared) = try await calculateDuctSizes(details: projectDetails)
+
+    let frictionRateResponse = try await manualD.frictionRate(details: projectDetails)
+    guard let frictionRate = frictionRateResponse.frictionRate else {
+      throw ProjectClientError.notFound(.frictionRate(projectID))
+    }
+
+    return .init(
+      details: projectDetails,
+      ductSizes: ductSizes,
+      shared: shared,
+      frictionRate: frictionRate
+    )
+  }
+
+}
+
+extension PdfClient.Request {
+  fileprivate init(
+    details: Project.Detail,
+    ductSizes: DuctSizes,
+    shared: DuctSizeSharedRequest,
+    frictionRate: FrictionRate
+  ) {
+    self.init(
+      project: details.project,
+      rooms: details.rooms,
+      componentLosses: details.componentLosses,
+      ductSizes: ductSizes,
+      equipmentInfo: details.equipmentInfo,
+      maxSupplyTEL: shared.maxSupplyLength,
+      maxReturnTEL: shared.maxReturnLenght,
+      frictionRate: frictionRate,
+      projectSHR: shared.projectSHR
+    )
+  }
+}

Sources/ProjectClient/Internal/ManualDClient+calculateDuctSizes.swift

@@ -4,8 +4,8 @@ import ManualDCore
 
 struct DuctSizeSharedRequest {
   let equipmentInfo: EquipmentInfo
-  let maxSupplyLength: EffectiveLength
-  let maxReturnLenght: EffectiveLength
+  let maxSupplyLength: EquivalentLength
+  let maxReturnLenght: EquivalentLength
   let designFrictionRate: Double
   let projectSHR: Double
 }
@@ -33,6 +33,7 @@ extension ManualDClient {
     )
   }
 
+  // FIX: Need to add the loads for rooms that get delegated to other rooms here.
   func calculateRoomSizes(
     rooms: [Room],
     sharedRequest: DuctSizeSharedRequest,
@@ -41,18 +42,24 @@ extension ManualDClient {
 
     var retval: [DuctSizes.RoomContainer] = []
     let totalHeatingLoad = rooms.totalHeatingLoad
-    let totalCoolingSensible = rooms.totalCoolingSensible(shr: sharedRequest.projectSHR)
+    let totalCoolingSensible = try rooms.totalCoolingSensible(shr: sharedRequest.projectSHR)
+    let nonDelegatedRooms = rooms.filter { $0.delegatedTo == nil }
+
+    for room in nonDelegatedRooms {
+      // Get all the rooms that delegate their loads to this room.
+      let delegatedRooms = rooms.filter { $0.delegatedTo == room.id }
+
+      let heatingLoad = room.heatingLoadPerRegister(delegatedRooms: delegatedRooms)
+      let coolingLoad = try room.coolingSensiblePerRegister(projectSHR: sharedRequest.projectSHR)
 
-    for room in rooms {
-      let heatingLoad = room.heatingLoadPerRegister
-      let coolingLoad = room.coolingSensiblePerRegister(projectSHR: sharedRequest.projectSHR)
       let heatingPercent = heatingLoad / totalHeatingLoad
       let coolingPercent = coolingLoad / totalCoolingSensible
       let heatingCFM = heatingPercent * Double(sharedRequest.equipmentInfo.heatingCFM)
       let coolingCFM = coolingPercent * Double(sharedRequest.equipmentInfo.coolingCFM)
       let designCFM = DuctSizes.DesignCFM(heating: heatingCFM, cooling: coolingCFM)
       let sizes = try await self.ductSize(
-        .init(designCFM: Int(designCFM.value), frictionRate: sharedRequest.designFrictionRate)
+        cfm: designCFM.value,
+        frictionRate: sharedRequest.designFrictionRate
       )
 
       for n in 1...room.registerCount {
@@ -63,7 +70,8 @@ extension ManualDClient {
 
         if let rectangularSize {
           let response = try await self.rectangularSize(
-            .init(round: sizes.finalSize, height: rectangularSize.height)
+            round: sizes.finalSize,
+            height: rectangularSize.height
           )
           rectangularWidth = response.width
         }
@@ -100,23 +108,25 @@ extension ManualDClient {
 
     var retval = [DuctSizes.TrunkContainer]()
     let totalHeatingLoad = rooms.totalHeatingLoad
-    let totalCoolingSensible = rooms.totalCoolingSensible(shr: sharedRequest.projectSHR)
+    let totalCoolingSensible = try rooms.totalCoolingSensible(shr: sharedRequest.projectSHR)
 
     for trunk in trunks {
       let heatingLoad = trunk.totalHeatingLoad
-      let coolingLoad = trunk.totalCoolingSensible(projectSHR: sharedRequest.projectSHR)
+      let coolingLoad = try trunk.totalCoolingSensible(projectSHR: sharedRequest.projectSHR)
       let heatingPercent = heatingLoad / totalHeatingLoad
       let coolingPercent = coolingLoad / totalCoolingSensible
       let heatingCFM = heatingPercent * Double(sharedRequest.equipmentInfo.heatingCFM)
       let coolingCFM = coolingPercent * Double(sharedRequest.equipmentInfo.coolingCFM)
       let designCFM = DuctSizes.DesignCFM(heating: heatingCFM, cooling: coolingCFM)
       let sizes = try await self.ductSize(
-        .init(designCFM: Int(designCFM.value), frictionRate: sharedRequest.designFrictionRate)
+        cfm: designCFM.value,
+        frictionRate: sharedRequest.designFrictionRate
       )
       var width: Int? = nil
       if let height = trunk.height {
         let rectangularSize = try await self.rectangularSize(
-          .init(round: sizes.finalSize, height: height)
+          round: sizes.finalSize,
+          height: height
         )
         width = rectangularSize.width
       }
@@ -142,7 +152,7 @@ extension ManualDClient {
 extension DuctSizes.SizeContainer {
   init(
     designCFM: DuctSizes.DesignCFM,
-    sizes: ManualDClient.DuctSizeResponse,
+    sizes: ManualDClient.DuctSize,
     height: Int?,
     width: Int?
   ) {
@@ -160,7 +170,7 @@ extension DuctSizes.SizeContainer {
 
   init(
     designCFM: DuctSizes.DesignCFM,
-    sizes: ManualDClient.DuctSizeResponse,
+    sizes: ManualDClient.DuctSize,
     rectangularSize: Room.RectangularSize?,
     width: Int?
   ) {
@@ -177,47 +187,34 @@ extension DuctSizes.SizeContainer {
   }
 }
 
-extension Room {
+// extension 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) throws -> Double {
+//     try room.coolingSensiblePerRegister(projectSHR: projectSHR) * Double(actualRegisterCount)
+//   }
+// }
 
-  var heatingLoadPerRegister: Double {
-
-    heatingLoad / Double(registerCount)
-  }
-
-  func coolingSensiblePerRegister(projectSHR: Double) -> Double {
-    let sensible = coolingSensible ?? (coolingTotal * projectSHR)
-    return sensible / Double(registerCount)
-  }
-}
-
-extension 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 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 TrunkSize {
+//
+//   var totalHeatingLoad: Double {
+//     rooms.reduce(into: 0) { $0 += $1.totalHeatingLoad }
+//   }
+//
+//   func totalCoolingSensible(projectSHR: Double) throws -> Double {
+//     try rooms.reduce(into: 0) { $0 += try $1.totalCoolingSensible(projectSHR: projectSHR) }
+//   }
+// }

Sources/ProjectClient/Internal/ManualDClient+frictionRate.swift

@@ -8,7 +8,7 @@ extension ManualDClient {
   func frictionRate(details: Project.Detail) async throws -> ProjectClient.FrictionRateResponse {
 
     let maxContainer = details.maxContainer
-    guard let totalEquivalentLength = maxContainer.total else {
+    guard let totalEquivalentLength = maxContainer.totalEquivalentLength else {
       return .init(componentLosses: details.componentLosses, equivalentLengths: maxContainer)
     }
 
@@ -19,7 +19,7 @@ extension ManualDClient {
         .init(
           externalStaticPressure: details.equipmentInfo.staticPressure,
           componentPressureLosses: details.componentLosses,
-          totalEffectiveLength: Int(totalEquivalentLength)
+          totalEquivalentLength: Int(totalEquivalentLength)
         )
       )
     )
@@ -28,15 +28,15 @@ extension ManualDClient {
   func frictionRate(projectID: Project.ID) async throws -> ProjectClient.FrictionRateResponse {
     @Dependency(\.database) var database
 
-    let componentLosses = try await database.componentLoss.fetch(projectID)
-    let lengths = try await database.effectiveLength.fetchMax(projectID)
+    let componentLosses = try await database.componentLosses.fetch(projectID)
+    let lengths = try await database.equivalentLengths.fetchMax(projectID)
 
     let equipmentInfo = try await database.equipment.fetch(projectID)
     guard let staticPressure = equipmentInfo?.staticPressure else {
       return .init(componentLosses: componentLosses, equivalentLengths: lengths)
     }
 
-    guard let totalEquivalentLength = lengths.total else {
+    guard let totalEquivalentLength = lengths.totalEquivalentLength else {
       return .init(componentLosses: componentLosses, equivalentLengths: lengths)
     }
 
@@ -46,8 +46,8 @@ extension ManualDClient {
       frictionRate: frictionRate(
         .init(
           externalStaticPressure: staticPressure,
-          componentPressureLosses: database.componentLoss.fetch(projectID),
-          totalEffectiveLength: Int(totalEquivalentLength)
+          componentPressureLosses: componentLosses,
+          totalEquivalentLength: Int(totalEquivalentLength)
         )
       )
     )

Sources/ProjectClient/Internal/ProjectDetail+maxContainer.swift

@@ -1,7 +1,7 @@
 import ManualDCore
 
 extension Project.Detail {
-  var maxContainer: EffectiveLength.MaxContainer {
+  var maxContainer: EquivalentLength.MaxContainer {
     .init(
       supply: equivalentLengths.filter({ $0.type == .supply })
         .sorted(by: { $0.totalEquivalentLength > $1.totalEquivalentLength })

Sources/ProjectClient/Internal/Room+loadPerRegister.swift

@@ -0,0 +1,20 @@
+import Foundation
+import ManualDCore
+
+extension Room {
+
+  public func heatingLoadPerRegister(delegatedRooms: [Room]? = nil) -> Double {
+    (heatingLoad + (delegatedRooms?.totalHeatingLoad ?? 0)) / Double(registerCount)
+  }
+
+  public func coolingSensiblePerRegister(
+    projectSHR: Double,
+    delegatedRooms: [Room]? = nil
+  ) throws -> Double {
+    let sensible =
+      try coolingLoad.ensured(shr: projectSHR).sensible
+      + (delegatedRooms?.totalCoolingSensible(shr: projectSHR) ?? 0)
+
+    return sensible / Double(registerCount)
+  }
+}

Sources/ProjectClient/Internal/TrunkSize+loads.swift

@@ -0,0 +1,34 @@
+import Foundation
+import ManualDCore
+
+extension 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
+  }
+
+  public var totalHeatingLoad: Double {
+    room.heatingLoadPerRegister() * Double(actualRegisterCount)
+  }
+
+  public func totalCoolingSensible(projectSHR: Double) throws -> Double {
+    try room.coolingSensiblePerRegister(projectSHR: projectSHR) * Double(actualRegisterCount)
+  }
+}
+
+extension TrunkSize {
+
+  public var totalHeatingLoad: Double {
+    rooms.reduce(into: 0) { $0 += $1.totalHeatingLoad }
+  }
+
+  public func totalCoolingSensible(projectSHR: Double) throws -> Double {
+    try rooms.reduce(into: 0) { $0 += try $1.totalCoolingSensible(projectSHR: projectSHR) }
+  }
+}

Sources/ProjectClient/Live.swift

@@ -15,18 +15,21 @@ extension ProjectClient: DependencyKey {
     @Dependency(\.fileClient) var fileClient
 
     return .init(
-      calculateDuctSizes: { projectID in
-        try await database.calculateDuctSizes(projectID: projectID).0
-      },
       calculateRoomDuctSizes: { projectID in
-        try await database.calculateRoomDuctSizes(projectID: projectID).0
+        guard let details = try await database.projects.detail(projectID) else {
+          throw ProjectClientError.notFound(.project(projectID))
+        }
+        return try await database.calculateRoomDuctSizes(details: details).rooms
       },
       calculateTrunkDuctSizes: { projectID in
-        try await database.calculateTrunkDuctSizes(projectID: projectID).0
+        guard let details = try await database.projects.detail(projectID) else {
+          throw ProjectClientError.notFound(.project(projectID))
+        }
+        return try await database.calculateTrunkDuctSizes(details: details)
       },
       createProject: { userID, request in
         let project = try await database.projects.create(userID, request)
-        try await database.componentLoss.createDefaults(projectID: project.id)
+        try await database.componentLosses.createDefaults(projectID: project.id)
         return try await .init(
           projectID: project.id,
           rooms: database.rooms.fetch(project.id),
@@ -42,13 +45,10 @@ extension ProjectClient: DependencyKey {
           request: database.makePdfRequest(projectID)
         )
 
-        let response = try await fileClient.streamFile(
-          pdfResponse.pdfPath,
-          {
-            try await fileClient.removeFile(pdfResponse.htmlPath)
-            try await fileClient.removeFile(pdfResponse.pdfPath)
-          }
-        )
+        let response = try await fileClient.streamFile(at: pdfResponse.pdfPath) {
+          try await fileClient.removeFile(pdfResponse.htmlPath)
+          try await fileClient.removeFile(pdfResponse.pdfPath)
+        }
 
         response.headers.replaceOrAdd(name: .contentType, value: "application/octet-stream")
         response.headers.replaceOrAdd(
@@ -61,50 +61,3 @@ extension ProjectClient: DependencyKey {
   }
 
 }
-
-extension DatabaseClient {
-
-  fileprivate func makePdfRequest(_ projectID: Project.ID) async throws -> PdfClient.Request {
-    @Dependency(\.manualD) var manualD
-
-    guard let projectDetails = try await projects.detail(projectID) else {
-      throw ProjectClientError("Project not found. id: \(projectID)")
-    }
-
-    let (ductSizes, shared) = try await calculateDuctSizes(details: projectDetails)
-
-    let frictionRateResponse = try await manualD.frictionRate(details: projectDetails)
-    guard let frictionRate = frictionRateResponse.frictionRate else {
-      throw ProjectClientError("Friction rate not found. id: \(projectID)")
-    }
-
-    return .init(
-      details: projectDetails,
-      ductSizes: ductSizes,
-      shared: shared,
-      frictionRate: frictionRate
-    )
-  }
-
-}
-
-extension PdfClient.Request {
-  init(
-    details: Project.Detail,
-    ductSizes: DuctSizes,
-    shared: DuctSizeSharedRequest,
-    frictionRate: FrictionRate
-  ) {
-    self.init(
-      project: details.project,
-      rooms: details.rooms,
-      componentLosses: details.componentLosses,
-      ductSizes: ductSizes,
-      equipmentInfo: details.equipmentInfo,
-      maxSupplyTEL: shared.maxSupplyLength,
-      maxReturnTEL: shared.maxReturnLenght,
-      frictionRate: frictionRate,
-      projectSHR: shared.projectSHR
-    )
-  }
-}

Sources/ProjectClient/ProjectClientError.swift

@@ -0,0 +1,35 @@
+import Foundation
+import ManualDCore
+
+public struct ProjectClientError: Error {
+  public let reason: String
+
+  public init(_ reason: String) {
+    self.reason = reason
+  }
+
+  static func notFound(_ notFound: NotFound) -> Self {
+    .init(notFound.reason)
+  }
+
+  enum NotFound {
+    case project(Project.ID)
+    case frictionRate(Project.ID)
+
+    var reason: String {
+      switch self {
+      case .project(let id):
+        return "Project not found. id: \(id)"
+      case .frictionRate(let id):
+        return """
+          Friction unable to be calculated. id: \(id)
+
+          This usually means that not all the required steps have been completed.
+
+          Calculating the friction rate requires the component pressure losses to be set and
+          have a max equivalent length for both the supply and return.
+          """
+      }
+    }
+  }
+}

Sources/Styleguide/Badge.swift

@@ -1,4 +1,5 @@
 import Elementary
+import Tagged
 
 public struct Badge<Inner: HTML>: HTML, Sendable where Inner: Sendable {
 
@@ -25,4 +26,5 @@ extension Badge where Inner == Number {
   public init(number: Double, digits: Int = 2) {
     self.inner = Number(number, digits: digits)
   }
+
 }

Sources/Styleguide/Buttons.swift

@@ -1,4 +1,6 @@
 import Elementary
+import ElementaryHTMX
+import ManualDCore
 
 public struct SubmitButton: HTML, Sendable {
   let title: String
@@ -26,32 +28,6 @@ public struct SubmitButton: HTML, Sendable {
   }
 }
 
-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
@@ -100,3 +76,17 @@ public struct TrashButton: HTML, Sendable {
     }
   }
 }
+
+public struct DuctulatorButton: HTML, Sendable {
+  public init() {}
+
+  public var body: some HTML<HTMLTag.a> {
+    a(
+      .class("btn"),
+      .href(route: .ductulator(.index)),
+      .target(.blank)
+    ) {
+      "Ductulator"
+    }
+  }
+}

Sources/Styleguide/ElementaryExtensions.swift

@@ -9,13 +9,6 @@ extension HTMLAttribute where Tag: HTMLTrait.Attributes.href {
   }
 }
 
-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 {
@@ -42,9 +35,6 @@ extension HTMLAttribute where Tag == HTMLTag.button {
 }
 
 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)

Sources/Styleguide/Icon.swift

@@ -1,45 +0,0 @@
-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/Input.swift

@@ -21,60 +21,6 @@ public struct LabeledInput: HTML, Sendable {
   }
 }
 
-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 {

Sources/Styleguide/MultiSelect.swift

@@ -0,0 +1,46 @@
+import Elementary
+
+extension HTMLTag {
+  public enum daisyMultiSelect: HTMLTrait.Paired { public static let name = "daisy-multiselect" }
+}
+public typealias daisyMultiSelect<Content: HTML> = HTMLElement<HTMLTag.daisyMultiSelect, Content>
+
+extension HTMLTrait.Attributes {
+  public protocol chipStyle {}
+  public protocol showSelectAll {}
+  public protocol showClear {}
+  public protocol virtualScroll {}
+}
+
+extension HTMLAttribute where Tag: HTMLTrait.Attributes.chipStyle {
+  public static var chipStyle: Self {
+    HTMLAttribute(name: "chip-style", value: nil)
+  }
+}
+
+extension HTMLAttribute where Tag: HTMLTrait.Attributes.showSelectAll {
+  public static var showSelectAll: Self {
+    HTMLAttribute(name: "show-select-all", value: nil)
+  }
+}
+
+extension HTMLAttribute where Tag: HTMLTrait.Attributes.showClear {
+  public static var showClear: Self {
+    HTMLAttribute(name: "show-clear", value: nil)
+  }
+}
+
+extension HTMLAttribute where Tag: HTMLTrait.Attributes.virtualScroll {
+  public static var virtualScroll: Self {
+    HTMLAttribute(name: "virtual-scroll", value: nil)
+  }
+}
+
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.required {}
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.disabled {}
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.placeholder {}
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.name {}
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.chipStyle {}
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.showSelectAll {}
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.showClear {}
+extension HTMLTag.daisyMultiSelect: HTMLTrait.Attributes.virtualScroll {}

Sources/Styleguide/Number.swift

@@ -6,15 +6,6 @@ public struct Number: HTML, Sendable {
   let fractionDigits: Int
   let value: Double
 
-  // private var formatter: NumberFormatter {
-  //   let formatter = NumberFormatter()
-  //   formatter.maximumFractionDigits = fractionDigits
-  //   formatter.numberStyle = .decimal
-  //   formatter.groupingSize = 3
-  //   formatter.groupingSeparator = ","
-  //   return formatter
-  // }
-
   public init(
     _ value: Double,
     digits fractionDigits: Int = 2

Sources/Styleguide/ResultView.swift

@@ -1,5 +1,6 @@
 import Elementary
 import Foundation
+import Validations
 
 public struct ResultView<ValueView, ErrorView>: HTML where ValueView: HTML, ErrorView: HTML {
 
@@ -69,7 +70,11 @@ public struct ErrorView: HTML, Sendable {
     div {
       h1(.class("text-xl font-bold text-error")) { "Oops: Error" }
       p {
-        "\(error.localizedDescription)"
+        if let validationError = (error as? ValidationError) {
+          "\(validationError.debugDescription)"
+        } else {
+          "\(error.localizedDescription)"
+        }
       }
     }
   }

Sources/Styleguide/SVG.swift

@@ -17,6 +17,7 @@ extension SVG {
   public enum Key: Sendable {
     case badgeCheck
     case ban
+    case calculator
     case chevronDown
     case chevronRight
     case chevronsLeft
@@ -26,6 +27,7 @@ extension SVG {
     case doorClosed
     case email
     case fan
+    case filePlusCorner
     case key
     case mapPin
     case rulerDimensionLine
@@ -47,6 +49,10 @@ extension SVG {
         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 .calculator:
+        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-calculator-icon lucide-calculator"><rect width="16" height="20" x="4" y="2" rx="2"/><line x1="8" x2="16" y1="6" y2="6"/><line x1="16" x2="16" y1="14" y2="18"/><path d="M16 10h.01"/><path d="M12 10h.01"/><path d="M8 10h.01"/><path d="M12 14h.01"/><path d="M8 14h.01"/><path d="M12 18h.01"/><path d="M8 18h.01"/></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>
@@ -94,6 +100,10 @@ extension SVG {
         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 .filePlusCorner:
+        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-file-plus-corner-icon lucide-file-plus-corner"><path d="M11.35 22H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v5.35"/><path d="M14 2v5a1 1 0 0 0 1 1h5"/><path d="M14 19h6"/><path d="M17 16v6"/></svg>
+          """
       case .key:
         return """
             <svg class="h-[1em] opacity-50" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">

Sources/Styleguide/Select.swift

@@ -0,0 +1,82 @@
+import Elementary
+import Foundation
+
+/// NOTE: This does not have the 'select' class added to it, because it's generally
+///       added to the label of the field.
+public struct Select<Label, Element>: HTML where Label: HTML {
+
+  let label: @Sendable (Element) -> Label
+  let value: @Sendable (Element) -> String
+  let selected: @Sendable (Element) -> Bool
+  let items: [Element]
+  let placeholder: String?
+
+  public init(
+    _ items: [Element],
+    placeholder: String? = nil,
+    value: @escaping @Sendable (Element) -> String,
+    selected: @escaping @Sendable (Element) -> Bool = { _ in false },
+    @HTMLBuilder label: @escaping @Sendable (Element) -> Label
+  ) {
+    self.label = label
+    self.items = items
+    self.placeholder = placeholder
+    self.selected = selected
+    self.value = value
+  }
+
+  public var body: some HTML<HTMLTag.select> {
+    select {
+      if let placeholder {
+        option(.selected, .disabled) { placeholder }
+      }
+      for item in items {
+        option(.value(value(item))) { label(item) }
+          .attributes(.selected, when: selected(item))
+      }
+    }
+  }
+}
+
+extension Select: Sendable where Element: Sendable, Label: Sendable {}
+
+extension Select where Element: Identifiable, Element.ID == UUID, Element: Sendable {
+
+  public init(
+    _ items: [Element],
+    placeholder: String? = nil,
+    selected: @escaping @Sendable (Element) -> Bool = { _ in false },
+    @HTMLBuilder label: @escaping @Sendable (Element) -> Label
+  ) {
+    self.init(
+      items,
+      placeholder: placeholder,
+      value: { $0.id.uuidString },
+      selected: selected,
+      label: label
+    )
+
+  }
+
+}
+
+extension Select
+where Element: Identifiable, Element.ID == UUID, Element: Sendable, Label == HTMLText {
+
+  public init(
+    _ items: [Element],
+    label keyPath: KeyPath<Element, String>,
+    placeholder: String? = nil,
+    selected: @escaping @Sendable (Element) -> Bool = { _ in false }
+  ) {
+    self.init(
+      items,
+      placeholder: placeholder,
+      value: { $0.id.uuidString },
+      selected: selected,
+      label: { HTMLText($0[keyPath: keyPath]) }
+    )
+
+  }
+
+}

Sources/ViewController/Extensions/EquivalentLengthForm+extensions.swift

@@ -12,8 +12,8 @@ extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepThree {
     }
   }
 
-  var groups: [EffectiveLength.Group] {
-    var groups = [EffectiveLength.Group]()
+  var groups: [EquivalentLength.FittingGroup] {
+    var groups = [EquivalentLength.FittingGroup]()
     for (n, group) in groupGroups.enumerated() {
       groups.append(
         .init(
@@ -29,7 +29,7 @@ extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepThree {
   }
 }
 
-extension EffectiveLength.Create {
+extension EquivalentLength.Create {
 
   init(
     form: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepThree,
@@ -45,7 +45,7 @@ extension EffectiveLength.Create {
   }
 }
 
-extension EffectiveLength.Update {
+extension EquivalentLength.Update {
   init(
     form: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepThree,
     projectID: Project.ID

Sources/ViewController/Interface.swift

@@ -53,15 +53,22 @@ extension ViewController: DependencyKey {
 
 extension ViewController.Request {
 
+  var isLoggedIn: Bool {
+    if (try? currentUser()) != nil {
+      return true
+    }
+    return false
+  }
+
   func currentUser() throws -> User {
-    @Dependency(\.authClient.currentUser) var currentUser
+    @Dependency(\.auth.currentUser) var currentUser
     return try currentUser()
   }
 
   func authenticate(
     _ login: User.Login
   ) async throws -> User {
-    @Dependency(\.authClient) var auth
+    @Dependency(\.auth) var auth
     return try await auth.login(login)
   }
 
@@ -69,7 +76,7 @@ extension ViewController.Request {
   func createAndAuthenticate(
     _ signup: User.Create
   ) async throws -> User {
-    @Dependency(\.authClient) var auth
+    @Dependency(\.auth) var auth
     return try await auth.createAndLogin(signup)
   }
 }

Sources/ViewController/Live.swift

@@ -1,7 +1,9 @@
+import CSVParser
 import DatabaseClient
 import Dependencies
 import Elementary
 import Foundation
+import ManualDClient
 import ManualDCore
 import PdfClient
 import ProjectClient
@@ -16,6 +18,14 @@ extension ViewController.Request {
     @Dependency(\.pdfClient) var pdfClient
 
     switch route {
+    case .home:
+      return await view {
+        HomeView()
+      }
+    case .privacyPolicy:
+      return await view {
+        PrivacyPolicyView()
+      }
     case .test:
       // let projectID = UUID(uuidString: "E796C96C-F527-4753-A00A-EBCF25630663")!
       // return await view {
@@ -33,7 +43,9 @@ extension ViewController.Request {
       //   }
       // }
       // return try! await pdfClient.html(.mock())
-      return EmptyHTML()
+      return await view {
+        TestPage()
+      }
     case .login(let route):
       switch route {
       case .index(let next):
@@ -70,7 +82,7 @@ extension ViewController.Request {
       case .submitProfile(let profile):
         return await view {
           await ResultView {
-            _ = try await database.userProfile.create(profile)
+            _ = try await database.userProfiles.create(profile)
             let userID = profile.userID
             // let user = try currentUser()
             return (
@@ -88,6 +100,9 @@ extension ViewController.Request {
     case .project(let route):
       return await route.renderView(on: self)
 
+    case .ductulator(let route):
+      return await route.renderView(on: self)
+
     case .user(let route):
       return await route.renderView(on: self)
     }
@@ -99,7 +114,7 @@ extension ViewController.Request {
     let inner = await inner()
     let theme = await self.theme
 
-    return MainPage(displayFooter: displayFooter, theme: theme) {
+    return MainPage(displayFooter: displayFooter, theme: theme ?? .default) {
       inner
     }
   }
@@ -108,7 +123,7 @@ extension ViewController.Request {
     get async {
       @Dependency(\.database) var database
       guard let user = try? currentUser() else { return nil }
-      return try? await database.userProfile.fetch(user.id)?.theme
+      return try? await database.userProfiles.fetch(user.id)?.theme
     }
   }
 
@@ -284,10 +299,18 @@ extension SiteRoute.View.ProjectRoute.RoomRoute {
     on request: ViewController.Request,
     projectID: Project.ID
   ) async -> AnySendableHTML {
+    @Dependency(\.csvParser) var csvParser
     @Dependency(\.database) var database
 
     switch self {
 
+    case .csv(let csv):
+      return await roomsView(on: request, projectID: projectID) {
+        let rooms = try await csvParser.parseRooms(csv)
+        _ = try await database.rooms.createFromCSV(projectID, rooms)
+      }
+    // return EmptyHTML()
+
     case .delete(let id):
       return await ResultView {
         try await database.rooms.delete(id)
@@ -298,7 +321,7 @@ extension SiteRoute.View.ProjectRoute.RoomRoute {
 
     case .submit(let form):
       return await roomsView(on: request, projectID: projectID) {
-        _ = try await database.rooms.create(form)
+        _ = try await database.rooms.create(projectID, form)
       }
 
     case .update(let id, let form):
@@ -366,8 +389,8 @@ extension SiteRoute.View.ProjectRoute.FrictionRateRoute {
     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)
+        let componentLosses = try await database.componentLosses.fetch(projectID)
+        let lengths = try await database.equivalentLengths.fetchMax(projectID)
 
         return (
           try await database.projects.getCompletedSteps(projectID),
@@ -407,16 +430,16 @@ extension SiteRoute.View.ProjectRoute.ComponentLossRoute {
       return EmptyHTML()
     case .delete(let id):
       return await view(on: request, projectID: projectID) {
-        _ = try await database.componentLoss.delete(id)
+        _ = try await database.componentLosses.delete(id)
       }
     case .submit(let form):
       return await view(on: request, projectID: projectID) {
-        _ = try await database.componentLoss.create(form)
+        _ = try await database.componentLosses.create(form)
       }
 
     case .update(let id, let form):
       return await view(on: request, projectID: projectID) {
-        _ = try await database.componentLoss.update(id, form)
+        _ = try await database.componentLosses.update(id, form)
       }
     }
   }
@@ -464,7 +487,7 @@ extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute {
 
     case .delete(let id):
       return await ResultView {
-        try await database.effectiveLength.delete(id)
+        try await database.equivalentLengths.delete(id)
       }
 
     case .index:
@@ -481,16 +504,16 @@ extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute {
 
     case .update(let id, let form):
       return await view(on: request, projectID: projectID) {
-        _ = try await database.effectiveLength.update(id, .init(form: form, projectID: projectID))
+        _ = try await database.equivalentLengths.update(id, .init(form: form, projectID: projectID))
       }
 
     case .submit(let step):
       switch step {
       case .one(let stepOne):
         return await ResultView {
-          var effectiveLength: EffectiveLength? = nil
+          var effectiveLength: EquivalentLength? = nil
           if let id = stepOne.id {
-            effectiveLength = try await database.effectiveLength.get(id)
+            effectiveLength = try await database.equivalentLengths.get(id)
           }
           return effectiveLength
         } onSuccess: { effectiveLength in
@@ -503,9 +526,9 @@ extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute {
       case .two(let stepTwo):
         return await ResultView {
           request.logger.debug("ViewController: Got step two...")
-          var effectiveLength: EffectiveLength? = nil
+          var effectiveLength: EquivalentLength? = nil
           if let id = stepTwo.id {
-            effectiveLength = try await database.effectiveLength.get(id)
+            effectiveLength = try await database.equivalentLengths.get(id)
           }
           return effectiveLength
         } onSuccess: { effectiveLength in
@@ -515,7 +538,7 @@ extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute {
         }
       case .three(let stepThree):
         return await view(on: request, projectID: projectID) {
-          _ = try await database.effectiveLength.create(
+          _ = try await database.equivalentLengths.create(
             .init(form: stepThree, projectID: projectID)
           )
         }
@@ -536,7 +559,7 @@ extension SiteRoute.View.ProjectRoute.EquivalentLengthRoute {
         try await catching()
         return (
           try await database.projects.getCompletedSteps(projectID),
-          try await database.effectiveLength.fetch(projectID)
+          try await database.equivalentLengths.fetch(projectID)
         )
       } onSuccess: { (steps, equivalentLengths) in
         ProjectView(projectID: projectID, activeTab: .equivalentLength, completedSteps: steps) {
@@ -592,6 +615,7 @@ extension SiteRoute.View.ProjectRoute.DuctSizingRoute {
           try await database.trunkSizes.delete(id)
         }
       case .submit(let form):
+        request.logger.debug("Trunk Form: \(form)")
         return await view(on: request, projectID: projectID) {
           _ = try await database.trunkSizes.create(
             form.toCreate(logger: request.logger)
@@ -633,7 +657,17 @@ extension SiteRoute.View.ProjectRoute.DuctSizingRoute {
 extension SiteRoute.View.UserRoute {
 
   func renderView(on request: ViewController.Request) async -> AnySendableHTML {
+    @Dependency(\.auth) var auth
+
     switch self {
+    case .logout:
+      return await request.view {
+        await ResultView {
+          try auth.logout()
+        } onSuccess: {
+          LoginForm(next: nil)
+        }
+      }
     case .profile(let route):
       return await route.renderView(on: request)
     }
@@ -652,11 +686,11 @@ extension SiteRoute.View.UserRoute.Profile {
       return await view(on: request)
     case .submit(let form):
       return await view(on: request) {
-        _ = try await database.userProfile.create(form)
+        _ = try await database.userProfiles.create(form)
       }
     case .update(let id, let updates):
       return await view(on: request) {
-        _ = try await database.userProfile.update(id, updates)
+        _ = try await database.userProfiles.update(id, updates)
       }
     }
   }
@@ -673,7 +707,7 @@ extension SiteRoute.View.UserRoute.Profile {
         let user = try request.currentUser()
         return (
           user,
-          try await database.userProfile.fetch(user.id)
+          try await database.userProfiles.fetch(user.id)
         )
       } onSuccess: { (user, profile) in
         UserView(user: user, profile: profile)
@@ -681,3 +715,33 @@ extension SiteRoute.View.UserRoute.Profile {
     }
   }
 }
+
+extension SiteRoute.View.DuctulatorRoute {
+
+  func renderView(
+    on request: ViewController.Request
+  ) async -> AnySendableHTML {
+    @Dependency(\.manualD) var manualD
+
+    switch self {
+    case .index:
+      return await request.view {
+        DuctulatorView(
+          isLoggedIn: request.isLoggedIn
+        )
+      }
+    case .submit(let form):
+      return await ResultView {
+        let ductSize = try await manualD.ductSize(cfm: form.cfm, frictionRate: form.frictionRate)
+        var rectangularSize: ManualDClient.RectangularSize? = nil
+        if let height = form.height {
+          rectangularSize = try await manualD.rectangularSize(
+            round: ductSize.finalSize, height: height)
+        }
+        return (ductSize, rectangularSize)
+      } onSuccess: { (ductSize, rectangularSize) in
+        DuctulatorView.Result(ductSize: ductSize, rectangularSize: rectangularSize)
+      }
+    }
+  }
+}

Sources/ViewController/Views/DuctSizing/TrunkSizeForm.swift

@@ -39,6 +39,7 @@ struct TrunkSizeForm: HTML, Sendable {
   }
 
   var body: some HTML {
+    script(.src("/js/daisy-multiselect.js")) {}
     ModalForm(id: Self.id(container), dismiss: dismiss) {
       h1(.class("text-lg font-bold mb-4")) { "Trunk / Runout Size" }
       form(
@@ -77,40 +78,33 @@ struct TrunkSizeForm: HTML, Sendable {
           .type(.text),
           .name("name"),
           .value(trunk?.name),
-          .placeholder("Trunk-1 (Optional)")
+          .placeholder("Trunk-1"),
+          .required
         )
 
         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
-              """
-            )
+          daisyMultiSelect(
+            .class("z-50 bg-base-200"),
+            .placeholder("Select rooms"),
+            .name("rooms"),
+            .chipStyle,
+            .showSelectAll,
+            .showClear,
+            .required,
+            .virtualScroll
           ) {
             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)
-                    )
-                  }
-                }
+              option(.value("\(room.roomID)_\(room.roomRegister)")) {
+                room.roomName
               }
+              .attributes(
+                .selected,
+                when: trunk == nil ? false : trunk!.rooms.hasRoom(room)
+              )
             }
           }
+
         }
 
         SubmitButton()

Sources/ViewController/Views/Ductulator/DuctulatorView.swift

@@ -0,0 +1,141 @@
+import Dependencies
+import Elementary
+import ElementaryHTMX
+import Foundation
+import ManualDClient
+import ManualDCore
+import Styleguide
+
+struct DuctulatorView: HTML, Sendable {
+
+  let isLoggedIn: Bool
+
+  init(isLoggedIn: Bool = false) {
+    self.isLoggedIn = isLoggedIn
+  }
+
+  var body: some HTML {
+    div {
+      Navbar(
+        showSidebarToggle: false,
+        isLoggedIn: isLoggedIn
+      )
+      div(.class("flex justify-center items-center px-10")) {
+        div(
+          .class(
+            """
+            bg-base-300 rounded-3xl shadow-3xl
+            p-6 w-full
+            """
+          )
+        ) {
+          div(.class("flex space-x-6 items-center text-4xl")) {
+            SVG(.calculator)
+            h1(.class("text-4xl font-bold me-10")) {
+              "Ductulator"
+            }
+          }
+
+          p(.class("text-primary font-bold italic")) {
+            "Calculate duct size for the given parameters"
+          }
+
+          form(
+            .class("space-y-4 mt-6"),
+            .hx.post(route: .ductulator(.index)),
+            .hx.target("#\(Result.id)"),
+            .hx.swap(.outerHTML)
+          ) {
+            LabeledInput(
+              "CFM",
+              .name("cfm"),
+              .type(.number),
+              .placeholder("1000"),
+              .required,
+              .autofocus
+            )
+
+            LabeledInput(
+              "Friction Rate",
+              .name("frictionRate"),
+              .value("0.06"),
+              .required,
+              .type(.number),
+              .min("0.01"),
+              .step("0.01")
+            )
+
+            LabeledInput(
+              "Height",
+              .name("height"),
+              .type(.number),
+              .placeholder("Height (Optional)"),
+            )
+
+            SubmitButton()
+              .attributes(.class("btn-block mt-6"))
+          }
+
+          // Populate when submitted
+          div(.id(Result.id)) {}
+        }
+      }
+    }
+  }
+
+  struct Result: HTML, Sendable {
+    static let id = "resultView"
+
+    let ductSize: ManualDClient.DuctSize
+    let rectangularSize: ManualDClient.RectangularSize?
+
+    var body: some HTML<HTMLTag.div> {
+      div(
+        .id(Self.id),
+        .class(
+          """
+          border-2 border-accent rounded-lg shadow-lg
+          w-full p-6 my-6
+          """
+        )
+      ) {
+        div(.class("flex justify-between p-4")) {
+          h2(.class("text-3xl font-bold")) { "Result" }
+          button(
+            .class("btn btn-primary"),
+            .hx.get(route: .ductulator(.index)),
+            .hx.target("body"),
+            .hx.swap(.outerHTML)
+          ) {
+            "Reset"
+          }
+          .tooltip("Reset form", position: .left)
+        }
+
+        table(.class("table table-zebra text-lg font-bold")) {
+          tbody {
+            tr {
+              td { Label("Calculated Size") }
+              td { Number(ductSize.calculatedSize, digits: 2) }
+            }
+            tr {
+              td { Label("Final Size") }
+              td { Number(ductSize.finalSize) }
+            }
+            tr {
+              td { Label("Flex Size") }
+              td { Number(ductSize.flexSize) }
+            }
+            if let rectangularSize {
+              tr {
+                td { Label("Rectangular Size") }
+                td { "\(rectangularSize.width) x \(rectangularSize.height)" }
+              }
+            }
+          }
+        }
+
+      }
+    }
+  }
+}

Sources/ViewController/Views/EffectiveLength/EffectiveLengthForm.swift

@@ -7,7 +7,7 @@ import Styleguide
 
 struct EffectiveLengthForm: HTML, Sendable {
 
-  static func id(_ equivalentLength: EffectiveLength?) -> String {
+  static func id(_ equivalentLength: EquivalentLength?) -> String {
     let base = "equivalentLengthForm"
     guard let equivalentLength else { return base }
     return "\(base)_\(equivalentLength.id.uuidString.replacing("-", with: ""))"
@@ -15,15 +15,15 @@ struct EffectiveLengthForm: HTML, Sendable {
 
   let projectID: Project.ID
   let dismiss: Bool
-  let type: EffectiveLength.EffectiveLengthType
-  let effectiveLength: EffectiveLength?
+  let type: EquivalentLength.EffectiveLengthType
+  let effectiveLength: EquivalentLength?
 
   var id: String { Self.id(effectiveLength) }
 
   init(
     projectID: Project.ID,
     dismiss: Bool,
-    type: EffectiveLength.EffectiveLengthType = .supply
+    type: EquivalentLength.EffectiveLengthType = .supply
   ) {
     self.projectID = projectID
     self.dismiss = dismiss
@@ -32,7 +32,7 @@ struct EffectiveLengthForm: HTML, Sendable {
   }
 
   init(
-    effectiveLength: EffectiveLength
+    effectiveLength: EquivalentLength
   ) {
     self.dismiss = true
     self.type = effectiveLength.type
@@ -55,7 +55,7 @@ struct EffectiveLengthForm: HTML, Sendable {
 
   struct StepOne: HTML, Sendable {
     let projectID: Project.ID
-    let effectiveLength: EffectiveLength?
+    let effectiveLength: EquivalentLength?
 
     var route: String {
       let baseRoute = SiteRoute.View.router.path(
@@ -97,7 +97,7 @@ struct EffectiveLengthForm: HTML, Sendable {
   struct StepTwo: HTML, Sendable {
     let projectID: Project.ID
     let stepOne: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepOne
-    let effectiveLength: EffectiveLength?
+    let effectiveLength: EquivalentLength?
 
     var route: String {
       let baseRoute = SiteRoute.View.router.path(
@@ -152,7 +152,7 @@ struct EffectiveLengthForm: HTML, Sendable {
 
   struct StepThree: HTML, Sendable {
     let projectID: Project.ID
-    let effectiveLength: EffectiveLength?
+    let effectiveLength: EquivalentLength?
     let stepTwo: SiteRoute.View.ProjectRoute.EquivalentLengthRoute.StepTwo
 
     var route: String {
@@ -254,10 +254,10 @@ struct StraightLengthField: HTML, Sendable {
 
 struct GroupField: HTML, Sendable {
 
-  let style: EffectiveLength.EffectiveLengthType
-  let group: EffectiveLength.Group?
+  let style: EquivalentLength.EffectiveLengthType
+  let group: EquivalentLength.FittingGroup?
 
-  init(style: EffectiveLength.EffectiveLengthType, group: EffectiveLength.Group? = nil) {
+  init(style: EquivalentLength.EffectiveLengthType, group: EquivalentLength.FittingGroup? = nil) {
     self.style = style
     self.group = group
   }
@@ -307,7 +307,7 @@ struct GroupField: HTML, Sendable {
 
 struct GroupSelect: HTML, Sendable {
 
-  let style: EffectiveLength.EffectiveLengthType
+  let style: EquivalentLength.EffectiveLengthType
 
   var body: some HTML {
     label(.class("select")) {
@@ -328,13 +328,13 @@ struct GroupSelect: HTML, Sendable {
 struct GroupTypeSelect: HTML, Sendable {
 
   let projectID: Project.ID
-  let selected: EffectiveLength.EffectiveLengthType
+  let selected: EquivalentLength.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 {
+        for value in EquivalentLength.EffectiveLengthType.allCases {
           option(
             .value("\(value.rawValue)"),
           ) { value.title }
@@ -345,7 +345,7 @@ struct GroupTypeSelect: HTML, Sendable {
   }
 }
 
-extension EffectiveLength.EffectiveLengthType {
+extension EquivalentLength.EffectiveLengthType {
 
   var title: String { rawValue.capitalized }
 

Sources/ViewController/Views/EffectiveLength/EffectiveLengthsTable.swift

@@ -5,9 +5,9 @@ import Styleguide
 
 struct EffectiveLengthsTable: HTML, Sendable {
 
-  let effectiveLengths: [EffectiveLength]
+  let effectiveLengths: [EquivalentLength]
 
-  private var sortedLengths: [EffectiveLength] {
+  private var sortedLengths: [EquivalentLength] {
     effectiveLengths.sorted {
       $0.totalEquivalentLength > $1.totalEquivalentLength
     }
@@ -55,7 +55,7 @@ struct EffectiveLengthsTable: HTML, Sendable {
 
   struct EffectiveLenghtRow: HTML, Sendable {
 
-    let effectiveLength: EffectiveLength
+    let effectiveLength: EquivalentLength
 
     private var deleteRoute: SiteRoute.View {
       .project(