You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tooling.apache.org by ar...@apache.org on 2026/03/05 11:17:32 UTC

(tooling-trusted-releases) 03/03: Latest changes - note: broken

This is an automated email from the ASF dual-hosted git repository.

arm pushed a commit to branch taint_tracking_types
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git

commit 34b19fed7495006153e3e697a4f9b17716a09b18
Author: Alastair McFarlane <ar...@apache.org>
AuthorDate: Wed Mar 4 16:25:13 2026 +0000

    Latest changes - note: broken
---
 atr/admin/__init__.py                          |  31 +++--
 atr/api/__init__.py                            |  44 ++++---
 atr/attestable.py                              |  47 ++++---
 atr/blueprints/api.py                          |  50 ++++++--
 atr/blueprints/common.py                       |  72 ++++++-----
 atr/blueprints/post.py                         |   3 +
 atr/cache.py                                   |   2 +-
 atr/construct.py                               |  77 ++++++------
 atr/datasources/apache.py                      |   8 +-
 atr/db/__init__.py                             |   5 +-
 atr/db/interaction.py                          |  50 +++++---
 atr/get/announce.py                            |  20 +--
 atr/get/checklist.py                           |   2 +-
 atr/get/checks.py                              |  14 +--
 atr/get/distribution.py                        |  66 +++++-----
 atr/get/download.py                            |  20 +--
 atr/get/draft.py                               |   2 +-
 atr/get/file.py                                |  22 ++--
 atr/get/finish.py                              |  44 +++----
 atr/get/ignores.py                             |   2 +-
 atr/get/manual.py                              |   6 +-
 atr/get/projects.py                            |  46 +++----
 atr/get/report.py                              |   8 +-
 atr/get/result.py                              |   2 +-
 atr/get/revisions.py                           |   6 +-
 atr/get/sbom.py                                |  22 ++--
 atr/get/start.py                               |   2 +-
 atr/get/test.py                                |  18 +--
 atr/get/upload.py                              |   4 +-
 atr/get/vote.py                                |  12 +-
 atr/get/voting.py                              |  10 +-
 atr/merge.py                                   |  17 +--
 atr/models/__init__.py                         |   3 +-
 atr/models/api.py                              |  62 ++++-----
 atr/models/results.py                          |  14 +--
 atr/models/safe.py                             |  84 +++++++++++++
 atr/models/sql.py                              |  95 ++++++++++++--
 atr/paths.py                                   |  27 ++--
 atr/post/announce.py                           |  12 +-
 atr/post/distribution.py                       |  38 +++---
 atr/post/draft.py                              |  36 +++---
 atr/post/finish.py                             |  26 ++--
 atr/post/ignores.py                            |  18 +--
 atr/post/keys.py                               |   4 +-
 atr/post/manual.py                             |  14 +--
 atr/post/projects.py                           |  24 ++--
 atr/post/resolve.py                            |  15 ++-
 atr/post/revisions.py                          |  22 ++--
 atr/post/sbom.py                               |  12 +-
 atr/post/start.py                              |   4 +-
 atr/post/upload.py                             |  20 +--
 atr/post/vote.py                               |   2 +-
 atr/post/voting.py                             |  20 +--
 atr/shared/distribution.py                     |  19 +--
 atr/shared/projects.py                         |  19 +--
 atr/shared/web.py                              | 133 +++++++++++---------
 atr/ssh.py                                     | 168 +++++++++++++------------
 atr/storage/__init__.py                        |  23 ++--
 atr/storage/readers/checks.py                  |  13 +-
 atr/storage/readers/releases.py                |   2 +-
 atr/storage/writers/announce.py                |  17 +--
 atr/storage/writers/checks.py                  |   7 +-
 atr/storage/writers/distributions.py           |  30 ++---
 atr/storage/writers/keys.py                    |  11 +-
 atr/storage/writers/policy.py                  |  12 +-
 atr/storage/writers/project.py                 |  21 ++--
 atr/storage/writers/release.py                 | 102 +++++++++------
 atr/storage/writers/revision.py                |  36 +++---
 atr/storage/writers/sbom.py                    |  25 ++--
 atr/storage/writers/ssh.py                     |   7 +-
 atr/storage/writers/vote.py                    |  55 ++++----
 atr/storage/writers/workflowstatus.py          |   7 +-
 atr/tasks/__init__.py                          |  43 ++++---
 atr/tasks/checks/__init__.py                   |  38 +++---
 atr/tasks/checks/compare.py                    |   3 +-
 atr/tasks/distribution.py                      |   4 +-
 atr/tasks/gha.py                               |   5 +-
 atr/tasks/keys.py                              |   5 +-
 atr/tasks/quarantine.py                        |  11 +-
 atr/tasks/sbom.py                              |  17 +--
 atr/tasks/svn.py                               |   5 +-
 atr/tasks/vote.py                              |  17 ++-
 atr/templates/check-selected-path-table.html   |  20 +--
 atr/templates/check-selected-release-info.html |  36 +++---
 atr/templates/check-selected.html              |   6 +-
 atr/templates/committee-directory.html         |   4 +-
 atr/templates/committee-view.html              |   2 +-
 atr/templates/download-all.html                |  10 +-
 atr/templates/draft-tools.html                 |   2 +-
 atr/templates/includes/topnav.html             |   4 +-
 atr/templates/index-committer.html             |   8 +-
 atr/templates/project-select.html              |   6 +-
 atr/templates/projects.html                    |   4 +-
 atr/templates/release-select.html              |   6 +-
 atr/templates/releases-finished.html           |   4 +-
 atr/templates/releases.html                    |   2 +-
 atr/templates/report-selected-path.html        |   8 +-
 atr/templates/resolve-tabulated.html           |   2 +-
 atr/validate.py                                |   4 +-
 atr/web.py                                     |  12 +-
 atr/worker.py                                  |  13 +-
 101 files changed, 1327 insertions(+), 967 deletions(-)

diff --git a/atr/admin/__init__.py b/atr/admin/__init__.py
index 6a759d93..a14f31bd 100644
--- a/atr/admin/__init__.py
+++ b/atr/admin/__init__.py
@@ -47,6 +47,7 @@ import atr.htm as htm
 import atr.ldap as ldap
 import atr.log as log
 import atr.mapping as mapping
+import atr.models.safe as safe
 import atr.models.session
 import atr.models.sql as sql
 import atr.paths as paths
@@ -328,11 +329,11 @@ async def delete_release_get(session: web.Committer) -> str | web.WerkzeugRespon
                         class_="form-check-input",
                         type="checkbox",
                         name="releases_to_delete",
-                        value=release.name,
+                        value=str(release.name),
                         id=f"release_{release.name}",
                     ),
                     htpy.label(".form-check-label", for_=f"release_{release.name}")[
-                        htpy.strong[release.name],
+                        htpy.strong[str(release.name)],
                         f" ({release.project.display_name}, {release.phase.value.upper()})",
                     ],
                 ]
@@ -581,14 +582,18 @@ async def logs(session: web.Committer) -> web.QuartResponse:
 async def ongoing_tasks_get(
     session: web.Committer, project_name: str, version_name: str, revision: str
 ) -> web.QuartResponse:
-    return await _ongoing_tasks(session, project_name, version_name, revision)
+    project = safe.ProjectName(project_name)
+    version = safe.VersionName(version_name)
+    return await _ongoing_tasks(session, project, version, revision)
 
 
 @admin.post("/ongoing-tasks/<project_name>/<version_name>/<revision>")
 async def ongoing_tasks_post(
     session: web.Committer, project_name: str, version_name: str, revision: str
 ) -> web.QuartResponse:
-    return await _ongoing_tasks(session, project_name, version_name, revision)
+    project = safe.ProjectName(project_name)
+    version = safe.VersionName(version_name)
+    return await _ongoing_tasks(session, project, version, revision)
 
 
 @admin.get("/performance")
@@ -760,7 +765,9 @@ async def task_times(
     values = []
     async with db.session() as data:
         tasks = await data.task(
-            project_name=project_name, version_name=version_name, revision_number=revision_number
+            project_name=project_name,
+            version_name=version_name,
+            revision_number=revision_number,
         ).all()
         for task in tasks:
             if (task.started is None) or (task.completed is None):
@@ -840,8 +847,8 @@ async def tasks_recent(session: web.Committer, minutes: int) -> str:
                     htpy.td[task.status.value],
                     htpy.td[task.added.strftime("%H:%M:%S") if task.added else ""],
                     htpy.td[took_text],
-                    htpy.td[task.project_name or ""],
-                    htpy.td[task.version_name or ""],
+                    htpy.td[str(task.project_name) or ""],
+                    htpy.td[str(task.version_name) or ""],
                     htpy.td[task.revision_number or ""],
                     htpy.td[error_text],
                 ]
@@ -873,8 +880,8 @@ async def tasks_recent(session: web.Committer, minutes: int) -> str:
                     htpy.td[task.task_type.value],
                     htpy.td[task.added.strftime("%Y-%m-%d %H:%M:%S") if task.added else ""],
                     htpy.td[task.scheduled.strftime("%Y-%m-%d %H:%M:%S") if task.scheduled else ""],
-                    htpy.td[task.project_name or ""],
-                    htpy.td[task.version_name or ""],
+                    htpy.td[str(task.project_name) or ""],
+                    htpy.td[str(task.version_name) or ""],
                     htpy.td[task.revision_number or ""],
                 ]
             )
@@ -1015,7 +1022,7 @@ async def _delete_releases(session: web.Committer, releases_to_delete: list[str]
                     raise RuntimeError(f"Release {release_name} has no committee")
             async with storage.write(session) as write:
                 waca = write.as_committee_admin(release.committee.name)
-                error = await waca.release.delete(release.project.name, release.version)
+                error = await waca.release.delete(release.safe_project_name.name, release.safe_version_name)
                 # Ensure that deletion errors are reported to the user
                 if error is not None:
                     raise RuntimeError(error)
@@ -1085,13 +1092,13 @@ async def _get_filesystem_dirs_unfinished(filesystem_dirs: list[str]) -> None:
 
 
 async def _ongoing_tasks(
-    session: web.Committer, project_name: str, version_name: str, revision: str
+    session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, revision: str
 ) -> web.QuartResponse:
     try:
         ongoing = await interaction.tasks_ongoing(project_name, version_name, revision)
         return web.TextResponse(str(ongoing))
     except Exception:
-        log.exception(f"Error fetching ongoing task count for {project_name} {version_name} rev {revision}:")
+        log.exception(f"Error fetching ongoing task count for {project_name!s} {version_name!s} rev {revision}:")
         return web.TextResponse("")
 
 
diff --git a/atr/api/__init__.py b/atr/api/__init__.py
index b11259f5..86a4360d 100644
--- a/atr/api/__init__.py
+++ b/atr/api/__init__.py
@@ -154,7 +154,7 @@ async def checks_ongoing(
     cannot be promoted to the vote phase if checks are still ongoing.
     """
     ongoing_tasks_count, _latest_revision = await interaction.tasks_ongoing_revision(
-        str(project_name), str(version_name), revision
+        project_name, version_name, revision
     )
     # TODO: Is there a way to return just an int?
     # The ResponseReturnValue type in quart does not allow int
@@ -295,7 +295,7 @@ async def distribute_ssh_register(
         fingerprint, expires = await wacm.ssh.add_workflow_key(
             payload["actor"],
             payload["actor_id"],
-            release.project_name,
+            release.safe_project_name,
             data.ssh_key,
             payload,
         )
@@ -303,7 +303,7 @@ async def distribute_ssh_register(
     return models.api.DistributeSshRegisterResults(
         endpoint="/distribute/ssh/register",
         fingerprint=fingerprint,
-        project=release.project_name,
+        project=release.safe_project_name,
         expires=expires,
     ).model_dump(), 200
 
@@ -323,13 +323,12 @@ async def distribution_record(
     """
     asf_uid = _jwt_asf_uid()
     async with db.session() as db_data:
-        release_name = models.sql.release_name(data.project, data.version)
         release = await db_data.release(
-            project_name=data.project,
-            version=data.version,
-        ).demand(exceptions.NotFound(f"Release {release_name} not found"))
+            project_name=str(data.project),
+            version=str(data.version),
+        ).demand(exceptions.NotFound(f"Release {data.project!s} {data.version!s} not found"))
     if release.committee is None:
-        raise exceptions.NotFound(f"Release {release_name} has no committee")
+        raise exceptions.NotFound(f"Release {release.name} has no committee")
     dd = models.distribution.Data(
         platform=data.platform,
         owner_namespace=data.distribution_owner_namespace,
@@ -340,7 +339,7 @@ async def distribution_record(
     async with storage.write(asf_uid) as write:
         wacm = write.as_committee_member(release.committee.name)
         _dist, _added, metadata = await wacm.distributions.record_from_data(
-            release.name,
+            release.safe_name,
             data.staging,
             dd,
         )
@@ -383,7 +382,7 @@ async def distribution_record_from_workflow(
     )
     async with storage.write_as_committee_member(release.committee.name, asf_uid) as wacm:
         _dist, _added, metadata = await wacm.distributions.record_from_data(
-            release.name, data.staging, dd, allow_retries=True
+            release.safe_name, data.staging, dd, allow_retries=True
         )
         if metadata is None:
             log.warning("Distribution could not be found, ATR will retry this automatically")
@@ -724,7 +723,7 @@ async def project_policy(
         )
     return models.api.ProjectPolicyResults(
         endpoint="/project/policy",
-        project_name=project.name,
+        project_name=project.safe_name,
         policy_announce_release_subject=project.policy_announce_release_subject,
         policy_announce_release_template=project.policy_announce_release_template,
         policy_binary_artifact_paths=project.policy_binary_artifact_paths,
@@ -811,13 +810,12 @@ async def publisher_distribution_record(
             interaction.TrustedProjectPhase.COMPOSE,
         )
     async with db.session() as db_data:
-        release_name = models.sql.release_name(project.name, data.version)
         release = await db_data.release(
             project_name=project.name,
-            version=data.version,
-        ).demand(exceptions.NotFound(f"Release {release_name} not found"))
+            version=str(data.version),
+        ).demand(exceptions.NotFound(f"Release {project.name} {data.version!s} not found"))
     if release.committee is None:
-        raise exceptions.NotFound(f"Release {release_name} has no committee")
+        raise exceptions.NotFound(f"Release {release.name} has no committee")
     dd = models.distribution.Data(
         platform=data.platform,
         owner_namespace=data.distribution_owner_namespace,
@@ -828,7 +826,7 @@ async def publisher_distribution_record(
     async with storage.write(asf_uid) as write:
         wacm = write.as_committee_member(release.committee.name)
         await wacm.distributions.record_from_data(
-            release.name,
+            release.safe_name,
             data.staging,
             dd,
         )
@@ -859,7 +857,7 @@ async def publisher_release_announce(
         committee = util.unwrap(project.committee)
         async with storage.write_as_committee_member(committee.name, asf_uid) as wacm:
             await wacm.announce.release(
-                project_name=project.name,
+                project_name=project.safe_name,
                 version_name=data.version,
                 preview_revision_number=data.revision,
                 recipient=data.email_to,
@@ -895,7 +893,7 @@ async def publisher_ssh_register(
         fingerprint, expires = await wacm.ssh.add_workflow_key(
             payload["actor"],
             payload["actor_id"],
-            project.name,
+            project.safe_name,
             data.ssh_key,
             payload,
         )
@@ -903,7 +901,7 @@ async def publisher_ssh_register(
     return models.api.PublisherSshRegisterResults(
         endpoint="/publisher/ssh/register",
         fingerprint=fingerprint,
-        project=project.name,
+        project=project.safe_name,
         expires=expires,
     ).model_dump(), 200
 
@@ -924,11 +922,11 @@ async def publisher_vote_resolve(
         data.jwt,
         interaction.TrustedProjectPhase.VOTE,
     )
-    async with storage.write_as_project_committee_member(project.name, asf_uid) as wacm:
+    async with storage.write_as_project_committee_member(project.safe_name, asf_uid) as wacm:
         # TODO: Get fullname and use instead of asf_uid
         # TODO: Add resolution templating to atr.construct
         _release, _voting_round, _success_message, _error_message = await wacm.vote.resolve(
-            project.name,
+            project.safe_name,
             data.version,
             data.resolution,
             asf_uid,
@@ -1399,7 +1397,7 @@ async def update_distribution_task_status(
     async with db.session() as db_data:
         status = await db_data.workflow_status(
             workflow_id=data.workflow,
-            project_name=data.project_name,
+            project_name=str(data.project_name),
             run_id=int(data.run_id),
         ).demand(exceptions.NotFound(f"Workflow {data.workflow} not found"))
         status.status = data.status
@@ -1580,7 +1578,7 @@ async def vote_tabulate(
     # asf_uid = _jwt_asf_uid()
     async with db.session() as db_data:
         release_name = sql.release_name(data.project, data.version)
-        release = await db_data.release(name=release_name, _project_release_policy=True).demand(
+        release = await db_data.release(name=str(release_name), _project_release_policy=True).demand(
             exceptions.NotFound(f"Release {release_name} not found"),
         )
 
diff --git a/atr/attestable.py b/atr/attestable.py
index 8114f249..f5e8592e 100644
--- a/atr/attestable.py
+++ b/atr/attestable.py
@@ -27,6 +27,7 @@ import pydantic
 import atr.hashes as hashes
 import atr.log as log
 import atr.models.attestable as models
+import atr.models.safe as safe
 import atr.paths as paths
 import atr.util as util
 
@@ -34,32 +35,40 @@ if TYPE_CHECKING:
     import pathlib
 
 
-def attestable_checks_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
-    return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.checks.json"
+def attestable_checks_path(
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+    return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.checks.json"
 
 
-def attestable_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
-    return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.json"
+def attestable_path(
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+    return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.json"
 
 
-def attestable_paths_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
-    return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.paths.json"
+def attestable_paths_path(
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+    return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.paths.json"
 
 
-def github_tp_payload_path(project_name: str, version_name: str, revision_number: str) -> pathlib.Path:
-    return paths.get_attestable_dir() / project_name / version_name / f"{revision_number}.github-tp.json"
+def github_tp_payload_path(
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
+) -> pathlib.Path:
+    return paths.get_attestable_dir() / str(project_name) / str(version_name) / f"{revision_number}.github-tp.json"
 
 
 async def github_tp_payload_write(
-    project_name: str, version_name: str, revision_number: str, github_payload: dict[str, Any]
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str, github_payload: dict[str, Any]
 ) -> None:
     payload_path = github_tp_payload_path(project_name, version_name, revision_number)
     await util.atomic_write_file(payload_path, json.dumps(github_payload, indent=2))
 
 
 async def load(
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     revision_number: str,
 ) -> models.AttestableV1 | None:
     file_path = attestable_path(project_name, version_name, revision_number)
@@ -75,8 +84,8 @@ async def load(
 
 
 async def load_checks(
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     revision_number: str,
 ) -> dict[str, dict[str, str]]:
     file_path = attestable_checks_path(project_name, version_name, revision_number)
@@ -97,8 +106,8 @@ async def load_checks(
 
 
 async def load_paths(
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     revision_number: str,
 ) -> dict[str, str] | None:
     file_path = attestable_paths_path(project_name, version_name, revision_number)
@@ -163,8 +172,8 @@ async def paths_to_hashes_and_sizes(directory: pathlib.Path) -> tuple[dict[str,
 
 
 async def write_checks_data(
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     revision_number: str,
     rel_path: str,
     checks: dict[str, str],
@@ -187,8 +196,8 @@ async def write_checks_data(
 
 
 async def write_files_data(
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     revision_number: str,
     release_policy: dict[str, Any] | None,
     uploader_uid: str,
diff --git a/atr/blueprints/api.py b/atr/blueprints/api.py
index 1219b791..5df652e7 100644
--- a/atr/blueprints/api.py
+++ b/atr/blueprints/api.py
@@ -69,6 +69,8 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
     original = inspect.unwrap(func)
     path, validated_params, literal_params, body_param, query_param, optional_params = common.build_api_path(original)
     method = "POST" if body_param is not None else "GET"
+    body_safe_params = common.safe_params_for_type(body_param[1]) if body_param is not None else []
+    query_safe_params = common.safe_params_for_type(query_param[1]) if query_param is not None else []
 
     async def wrapper(*_args: Any, **kwargs: Any) -> Any:
         await common.run_validators(kwargs, validated_params)
@@ -78,13 +80,19 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
             body_name, body_cls = body_param
             json_data = await quart.request.get_json()
             try:
-                kwargs[body_name] = body_cls.model_validate(json_data)
+                body_instance = body_cls.model_validate(json_data)
             except pydantic.ValidationError as e:
                 raise quart_schema.RequestSchemaValidationError(e) from e
+            if body_safe_params:
+                await common.validate_safe_fields(body_instance, body_safe_params, kwargs)
+            kwargs[body_name] = body_instance
 
         if query_param is not None:
             query_name, query_cls = query_param
-            kwargs[query_name] = _parse_query_args(query_cls, quart.request.args)
+            query_instance = _parse_query_args(query_cls, quart.request.args)
+            if query_safe_params:
+                await common.validate_safe_fields(query_instance, query_safe_params, kwargs)
+            kwargs[query_name] = query_instance
 
         start_time_ns = time.perf_counter_ns()
         response = await func(**kwargs)
@@ -107,15 +115,34 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
     # Examine `func` for quart attributes and re-attach to the wrapped function
     # This makes sure the OpenAPI documentation is preserved
     # Note: we don't update querystring or request as they're processed above using our detected types
-    for attr in _QUART_ATTRIBUTES:
-        if hasattr(func, attr):
-            setattr(wrapper, attr, getattr(func, attr))
+    _copy_quart_attributes(func, wrapper)
 
     # If there are optional params, we need two routes, one with the optional params omitted
     # and one with them all present.
     # AM 26/03/03: This actually only handles the case where there's some required and a single optional, but
     # that's the only case that existed in the original code. Theoretically we could count the optional params and
     # generate the correct number of routes, but that's lot of effort for little gain right now
+    _add_url_rules(wrapper, path, endpoint, method, optional_params)
+
+    common.register_route(original, "api", _routes)
+    return wrapper
+
+
+@_BLUEPRINT.before_request
+@rate_limiter.rate_limit(500, datetime.timedelta(hours=1))
+async def _api_rate_limit() -> None:
+    """Set API-wide rate limit"""
+    pass
+
+
+def _add_url_rules(
+    wrapper: Callable[..., Any],
+    path: str,
+    endpoint: str,
+    method: str,
+    optional_params: list[str],
+) -> None:
+    """Register URL rules for the wrapper, handling optional path params with a default short route."""
     if optional_params:
         required_segments = [
             seg for seg in path.strip("/").split("/") if not any(seg == f"<{name}>" for name in optional_params)
@@ -127,15 +154,12 @@ def typed(func: Callable[..., Any]) -> Callable[..., Any]:
     else:
         _BLUEPRINT.add_url_rule(path, endpoint=endpoint, view_func=wrapper, methods=[method])
 
-    common.register_route(original, "api", _routes)
-    return wrapper
-
 
-@_BLUEPRINT.before_request
-@rate_limiter.rate_limit(500, datetime.timedelta(hours=1))
-async def _api_rate_limit() -> None:
-    """Set API-wide rate limit"""
-    pass
+def _copy_quart_attributes(src: Callable[..., Any], dst: Callable[..., Any]) -> None:
+    """Copy quart schema attributes from src to dst to preserve OpenAPI documentation."""
+    for attr in _QUART_ATTRIBUTES:
+        if hasattr(src, attr):
+            setattr(dst, attr, getattr(src, attr))
 
 
 def _exempt_blueprint(app: base.QuartApp) -> None:
diff --git a/atr/blueprints/common.py b/atr/blueprints/common.py
index 00109b6d..0a3089bb 100644
--- a/atr/blueprints/common.py
+++ b/atr/blueprints/common.py
@@ -26,12 +26,9 @@ import asfquart.base as base
 import asfquart.session
 import pydantic
 
-import atr.cache as cache
-import atr.db as db
 import atr.form as form
 import atr.ldap as ldap
 import atr.models.safe as safe
-import atr.models.sql as sql
 import atr.models.unsafe as unsafe
 import atr.web as web
 
@@ -190,42 +187,55 @@ def register_route(func: Callable[..., Any], prefix: str, routes: list[str]) ->
     routes.append(f"{prefix}.{module_name}.{func.__name__}")
 
 
+def safe_params_for_type(cls: type) -> list[tuple[str, type]]:
+    """Return (field_name, safe_type) pairs for fields typed as a validated safe type."""
+    try:
+        hints = get_type_hints(cls)
+    except Exception:
+        return []
+    return [(name, hint) for name, hint in hints.items() if hint in VALIDATED_TYPES]
+
+
 async def run_validators(kwargs: dict[str, Any], validated_params: list[tuple[str, type]]) -> None:
     """Validate URL parameters in order, using the cache/DB validators."""
     project_name_param = "project_name"
     for param_name, param_type in validated_params:
         raw = kwargs[param_name]
         if param_type is safe.ProjectName:
-            kwargs[param_name] = await validate_project(raw)
-            project_name_param = param_name
+            safe_name = await safe.ProjectName.create(raw)
+            if safe_name:
+                kwargs[param_name] = await safe.ProjectName.create(raw)
+                project_name_param = param_name
+            else:
+                raise base.ASFQuartException(f"Project name {param_name!r} is invalid. ")
         elif param_type is safe.VersionName:
             project_name = kwargs.get(project_name_param, "")
-            kwargs[param_name] = await validate_version(project_name, raw)
-
-
-async def validate_project(raw: str) -> safe.ProjectName:
-    if cache.project_version_has_project(raw):
-        return safe.ProjectName(raw)
-    async with db.session() as data:
-        project = await data.project(name=raw, status=sql.ProjectStatus.ACTIVE, _committee=False).get()
-    if project is None:
-        raise base.ASFQuartException(f"Project {raw!r} not found", errorcode=404)
-    return safe.ProjectName(project.name)
-
-
-async def validate_version(project_name: safe.ProjectName, raw: str) -> safe.VersionName:
-    if cache.project_version_has_version(project_name, raw):
-        return safe.VersionName(raw)
-    async with db.session() as data:
-        release = await data.release(
-            project_name=str(project_name),
-            version=raw,
-            _project=False,
-            _committee=False,
-        ).get()
-    if release is None:
-        raise base.ASFQuartException(f"Version {raw!r} not found for project {project_name!s}", errorcode=404)
-    return safe.VersionName(release.version)
+            safe_name = await safe.VersionName.create(project_name, raw)
+            if safe_name:
+                kwargs[param_name] = await safe.VersionName.create(project_name, raw)
+            else:
+                raise base.ASFQuartException(f"Version name {param_name!r} is invalid. ")
+
+
+async def validate_safe_fields(
+    instance: Any,
+    safe_params: list[tuple[str, type]],
+    context: dict[str, Any],
+) -> None:
+    """Validate safe-typed fields on a body, query, or form instance via cache/DB lookup.
+
+    Context should contain any URL params already validated, so that validate_version
+    can find a project_name that lives in the URL rather than the instance.
+    """
+    temp = dict(context)
+    for name, _ in safe_params:
+        value = getattr(instance, name, None)
+        if value is not None:
+            temp[name] = str(value)
+    await run_validators(temp, [(n, t) for n, t in safe_params if n in temp])
+    for name, _ in safe_params:
+        if name in temp:
+            setattr(instance, name, temp[name])
 
 
 def _is_body_type(hint: Any) -> bool:
diff --git a/atr/blueprints/post.py b/atr/blueprints/post.py
index 8224d281..7bd6c842 100644
--- a/atr/blueprints/post.py
+++ b/atr/blueprints/post.py
@@ -66,6 +66,7 @@ def typed(func: Callable[..., Any]) -> web.RouteFunction[Any]:
     path, validated_params, literal_params, form_param, public = common.build_path(func)
     project_name_var = next((name for name, t in validated_params if t is safe.ProjectName), None)
     check_access = not public and (project_name_var is not None)
+    form_safe_params = common.safe_params_for_type(form_param[1]) if form_param is not None else []
 
     async def wrapper(*_args: Any, **kwargs: Any) -> Any:
         enhanced_session = await common.authenticate_public() if public else await common.authenticate()
@@ -95,6 +96,8 @@ def typed(func: Callable[..., Any]) -> web.RouteFunction[Any]:
                 await quart.flash(summary, category="error")
                 await quart.flash(json.dumps(flash_data), category="form-error-data")
                 return quart.redirect(quart.request.path)
+            if form_safe_params:
+                await common.validate_safe_fields(kwargs[form_param_name], form_safe_params, kwargs)
 
         start_time_ns = time.perf_counter_ns()
         response = await func(enhanced_session, **kwargs)
diff --git a/atr/cache.py b/atr/cache.py
index e578f0aa..0e4ecf62 100644
--- a/atr/cache.py
+++ b/atr/cache.py
@@ -181,7 +181,7 @@ async def _project_version_fetch_from_db() -> dict[str, set[str]]:
         all_projects = await data.project(status=sql.ProjectStatus.ACTIVE, _committee=False).all()
         for project in all_projects:
             all_releases = await data.release(project_name=project.name, _project=False, _committee=False).all()
-            projects[project.name] = {release.version for release in all_releases}
+            projects[str(project.name)] = {str(release.version) for release in all_releases}
     return projects
 
 
diff --git a/atr/construct.py b/atr/construct.py
index f36ba1a6..f4ca7326 100644
--- a/atr/construct.py
+++ b/atr/construct.py
@@ -25,6 +25,7 @@ import quart
 
 import atr.config as config
 import atr.db as db
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as paths
 import atr.util as util
@@ -53,8 +54,8 @@ TEMPLATE_VARIABLES: list[tuple[str, str, set[Context]]] = [
 class AnnounceReleaseOptions:
     asfuid: str
     fullname: str
-    project_name: str
-    version_name: str
+    project_name: safe.ProjectName
+    version_name: safe.VersionName
     revision_number: str
 
 
@@ -62,17 +63,17 @@ class AnnounceReleaseOptions:
 class StartVoteOptions:
     asfuid: str
     fullname: str
-    project_name: str
-    version_name: str
+    project_name: safe.ProjectName
+    version_name: safe.VersionName
     revision_number: str
     vote_duration: int
 
 
-async def announce_release_default(project_name: str) -> str:
+async def announce_release_default(project_name: safe.ProjectName) -> str:
     async with db.session() as data:
-        project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
-            RuntimeError(f"Project {project_name} not found")
-        )
+        project = await data.project(
+            name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+        ).demand(RuntimeError(f"Project {project_name} not found"))
 
     return project.policy_announce_release_template
 
@@ -91,8 +92,8 @@ async def announce_release_subject_and_body(
 
     async with db.session() as data:
         release = await data.release(
-            project_name=options.project_name,
-            version=options.version_name,
+            project_name=str(options.project_name),
+            version=str(options.version_name),
             _project=True,
             _committee=True,
             phase=sql.ReleasePhase.RELEASE_PREVIEW,
@@ -105,18 +106,18 @@ async def announce_release_subject_and_body(
         revision_number = revision.number if revision else ""
         revision_tag = revision.tag if (revision and revision.tag) else ""
 
-    project_display_name = release.project.short_display_name if release.project else options.project_name
+    project_display_name = release.project.short_display_name if release.project else str(options.project_name)
 
     routes_file_selected = get.file.selected
     download_path = util.as_url(
-        routes_file_selected, project_name=options.project_name, version_name=options.version_name
+        routes_file_selected, project_name=str(options.project_name), version_name=str(options.version_name)
     )
     # TODO: This download_url should probably be for the proxy download directory, not the ATR view
     download_url = f"https://{host}{download_path}"
 
     # Perform substitutions in the subject
     subject = subject.replace("{{PROJECT}}", project_display_name)
-    subject = subject.replace("{{VERSION}}", options.version_name)
+    subject = subject.replace("{{VERSION}}", str(options.version_name))
 
     # Perform substitutions in the body
     body = body.replace("{{COMMITTEE}}", committee.display_name)
@@ -124,18 +125,18 @@ async def announce_release_subject_and_body(
     body = body.replace("{{PROJECT}}", project_display_name)
     body = body.replace("{{REVISION}}", revision_number)
     body = body.replace("{{TAG}}", revision_tag)
-    body = body.replace("{{VERSION}}", options.version_name)
+    body = body.replace("{{VERSION}}", str(options.version_name))
     body = body.replace("{{YOUR_ASF_ID}}", options.asfuid)
     body = body.replace("{{YOUR_FULL_NAME}}", options.fullname)
 
     return subject, body
 
 
-async def announce_release_subject_default(project_name: str) -> str:
+async def announce_release_subject_default(project_name: safe.ProjectName) -> str:
     async with db.session() as data:
-        project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
-            RuntimeError(f"Project {project_name} not found")
-        )
+        project = await data.project(
+            name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+        ).demand(RuntimeError(f"Project {project_name} not found"))
 
     return project.policy_announce_release_subject
 
@@ -151,7 +152,7 @@ def announce_template_variables() -> list[tuple[str, str]]:
 def checklist_body(
     markdown: str,
     project: sql.Project,
-    version_name: str,
+    version_name: safe.VersionName,
     committee: sql.Committee,
     revision: sql.Revision | None,
 ) -> str:
@@ -172,7 +173,7 @@ def checklist_body(
     markdown = markdown.replace("{{REVIEW_URL}}", review_url)
     markdown = markdown.replace("{{REVISION}}", revision_number)
     markdown = markdown.replace("{{TAG}}", revision_tag)
-    markdown = markdown.replace("{{VERSION}}", version_name)
+    markdown = markdown.replace("{{VERSION}}", str(version_name))
     return markdown
 
 
@@ -180,11 +181,11 @@ def checklist_template_variables() -> list[tuple[str, str]]:
     return [(name, desc) for (name, desc, contexts) in TEMPLATE_VARIABLES if "checklist" in contexts]
 
 
-async def start_vote_default(project_name: str) -> str:
+async def start_vote_default(project_name: safe.ProjectName) -> str:
     async with db.session() as data:
-        project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
-            RuntimeError(f"Project {project_name} not found")
-        )
+        project = await data.project(
+            name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+        ).demand(RuntimeError(f"Project {project_name} not found"))
 
     return project.policy_start_vote_template
 
@@ -196,8 +197,8 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
     async with db.session() as data:
         # Do not limit by phase, as it may be at RELEASE_CANDIDATE already
         release = await data.release(
-            project_name=options.project_name,
-            version=options.version_name,
+            project_name=str(options.project_name),
+            version=str(options.version_name),
             _project=True,
             _committee=True,
         ).demand(RuntimeError(f"Release {options.project_name} {options.version_name} not found"))
@@ -215,12 +216,14 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
         host = config.get().APP_HOST
 
     checklist_path = util.as_url(
-        checklist.selected, project_name=options.project_name, version_name=options.version_name
+        checklist.selected, project_name=str(options.project_name), version_name=str(options.version_name)
     )
     checklist_url = f"https://{host}{checklist_path}"
-    review_path = util.as_url(vote.selected, project_name=options.project_name, version_name=options.version_name)
+    review_path = util.as_url(
+        vote.selected, project_name=str(options.project_name), version_name=str(options.version_name)
+    )
     review_url = f"https://{host}{review_path}"
-    project_display_name = release.project.short_display_name if release.project else options.project_name
+    project_display_name = release.project.short_display_name if release.project else str(options.project_name)
     vote_end = datetime.datetime.now(datetime.UTC) + datetime.timedelta(hours=options.vote_duration)
     vote_end_str = f"{vote_end.day} {vote_end.strftime('%b %H:%M')} UTC"
 
@@ -253,10 +256,10 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
 
     # Perform substitutions in the subject
     subject = subject.replace("{{COMMITTEE}}", committee.display_name)
-    subject = subject.replace("{{PROJECT}}", project_display_name)
+    subject = subject.replace("{{PROJECT}}", str(project_display_name))
     subject = subject.replace("{{REVISION}}", revision_number)
     subject = subject.replace("{{TAG}}", revision_tag)
-    subject = subject.replace("{{VERSION}}", options.version_name)
+    subject = subject.replace("{{VERSION}}", str(options.version_name))
     subject = subject.replace("{{VOTE_ENDS_UTC}}", vote_end_str)
 
     # Perform substitutions in the body
@@ -265,23 +268,23 @@ async def start_vote_subject_and_body(subject: str, body: str, options: StartVot
     body = body.replace("{{COMMITTEE}}", committee.display_name)
     body = body.replace("{{DURATION}}", str(options.vote_duration))
     body = body.replace("{{KEYS_FILE}}", keys_file or "(Sorry, the KEYS file is missing!)")
-    body = body.replace("{{PROJECT}}", project_display_name)
+    body = body.replace("{{PROJECT}}", str(project_display_name))
     body = body.replace("{{RELEASE_CHECKLIST}}", checklist_content)
     body = body.replace("{{REVIEW_URL}}", review_url)
     body = body.replace("{{REVISION}}", revision_number)
     body = body.replace("{{TAG}}", revision_tag)
-    body = body.replace("{{VERSION}}", options.version_name)
+    body = body.replace("{{VERSION}}", str(options.version_name))
     body = body.replace("{{YOUR_ASF_ID}}", options.asfuid)
     body = body.replace("{{YOUR_FULL_NAME}}", options.fullname)
 
     return subject, body
 
 
-async def start_vote_subject_default(project_name: str) -> str:
+async def start_vote_subject_default(project_name: safe.ProjectName) -> str:
     async with db.session() as data:
-        project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
-            RuntimeError(f"Project {project_name} not found")
-        )
+        project = await data.project(
+            name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True
+        ).demand(RuntimeError(f"Project {project_name} not found"))
 
     return project.policy_start_vote_subject
 
diff --git a/atr/datasources/apache.py b/atr/datasources/apache.py
index e9547dcb..22b4a7b3 100644
--- a/atr/datasources/apache.py
+++ b/atr/datasources/apache.py
@@ -32,6 +32,7 @@ import atr.db as db
 import atr.ldap as ldap
 import atr.log as log
 import atr.models.helpers as helpers
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.models.sql as sql
 import atr.util as util
@@ -194,7 +195,7 @@ class ProjectStatus(schema.Strict):
     programming_language: str | None = schema.alias_opt("programming-language")
     doap: str | None = None
     homepage: str
-    name: str
+    name: safe.ProjectName
     pmc: str | None
     shortdesc: str | None = None
     repository: list[str | dict] = schema.factory(list)
@@ -353,7 +354,7 @@ def _project_status(pmc: sql.Committee, project_name: str, project_status: Proje
     if pmc.name == "attic":
         # This must come first, because attic is also a standing committee
         return sql.ProjectStatus.RETIRED
-    elif ("_dormant_" in project_name) or project_status.name.endswith("(Dormant)"):
+    elif ("_dormant_" in project_name) or str(project_status.name).endswith("(Dormant)"):
         return sql.ProjectStatus.DORMANT
     elif util.committee_is_standing(pmc.name):
         return sql.ProjectStatus.STANDING
@@ -449,6 +450,7 @@ async def _update_projects(data: db.Session, projects: ProjectsData) -> tuple[in
         #        the PMC seems to be identified by the key ws, but the associated projects use webservices
         if project_name.startswith("webservices-"):
             project_name = project_name.replace("webservices-", "ws-")
+            safe_name = safe.ProjectName(project_name)
             project_status.pmc = "ws"
 
         # TODO: Annotator is in both projects and ldap_projects
@@ -482,7 +484,7 @@ async def _update_projects(data: db.Session, projects: ProjectsData) -> tuple[in
             project_model.status = status
             updated_count += 1
 
-        project_model.full_name = project_status.name
+        project_model.full_name = str(project_status.name)
         project_model.category = project_status.category
         project_model.description = project_status.description
         project_model.programming_languages = project_status.programming_language
diff --git a/atr/db/__init__.py b/atr/db/__init__.py
index 6b3e1504..a5514511 100644
--- a/atr/db/__init__.py
+++ b/atr/db/__init__.py
@@ -34,6 +34,7 @@ import sqlmodel.sql.expression as expression
 
 import atr.config as config
 import atr.log as log
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.models.sql as sql
 import atr.util as util
@@ -864,9 +865,9 @@ def ensure_session(caller_data: Session | None) -> Session | contextlib.nullcont
     return contextlib.nullcontext(caller_data)
 
 
-async def get_project_release_policy(data: Session, project_name: str) -> sql.ReleasePolicy | None:
+async def get_project_release_policy(data: Session, project_name: safe.ProjectName) -> sql.ReleasePolicy | None:
     """Fetch the ReleasePolicy for a project."""
-    project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
+    project = await data.project(name=str(project_name), status=sql.ProjectStatus.ACTIVE, _release_policy=True).demand(
         RuntimeError(f"Project {project_name} not found")
     )
     return project.release_policy
diff --git a/atr/db/interaction.py b/atr/db/interaction.py
index 6e7e17a5..5d8bdd8f 100644
--- a/atr/db/interaction.py
+++ b/atr/db/interaction.py
@@ -32,6 +32,7 @@ import atr.jwtoken as jwtoken
 import atr.ldap as ldap
 import atr.log as log
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.user as user
 import atr.util as util
@@ -88,7 +89,7 @@ async def all_releases(project: sql.Project) -> list[sql.Release]:
 
         def sort_key(release: sql.Release) -> tuple[tuple[int, int | str], ...]:
             parts = []
-            v = release.version.replace("+", ".").replace("-", ".")
+            v = str(release.version).replace("+", ".").replace("-", ".")
             for part in v.split("."):
                 try:
                     # Numeric parts: (0, number) to sort before strings
@@ -170,7 +171,7 @@ async def checks_for(
     """Get the check results for a release, optionally for a specific revision and/or file path."""
     if revision is None:
         revision = release.unwrap_revision_number
-    file_path_checks = await attestable.load_checks(release.project_name, release.version, revision)
+    file_path_checks = await attestable.load_checks(release.safe_project_name, release.safe_version_name, revision)
     if file_path_checks:
         if rel_path is not None:
             hashes = [
@@ -195,7 +196,9 @@ async def checks_for(
 async def count_checks_for_revision_by_status(
     status: sql.CheckResultStatus, release: sql.Release, revision_number: str, caller_data: db.Session | None = None
 ):
-    file_path_checks = await attestable.load_checks(release.project_name, release.version, revision_number)
+    file_path_checks = await attestable.load_checks(
+        release.safe_project_name, release.safe_version_name, revision_number
+    )
     check_hashes = [h for inner in file_path_checks.values() for h in inner.values()]
     if len(check_hashes) == 0:
         return 0
@@ -239,18 +242,20 @@ async def has_failing_checks(release: sql.Release, revision_number: str, caller_
     return count > 0
 
 
-async def latest_info(project_name: str, version_name: str) -> tuple[str, str, datetime.datetime] | None:
+async def latest_info(
+    project_name: safe.ProjectName, version_name: safe.VersionName
+) -> tuple[str, str, datetime.datetime] | None:
     """Get the name, editor, and timestamp of the latest revision."""
     release_name = sql.release_name(project_name, version_name)
     async with db.session() as data:
         # TODO: No need to get release here
         # Just use maximum seq from revisions
-        release = await data.release(name=release_name, _project=True).demand(
+        release = await data.release(name=str(release_name), _project=True).demand(
             RuntimeError(f"Release {release_name} does not exist")
         )
         if release.latest_revision_number is None:
             return None
-        revision = await data.revision(release_name=release_name, number=release.latest_revision_number).get()
+        revision = await data.revision(release_name=str(release_name), number=release.latest_revision_number).get()
         if not revision:
             return None
     return revision.number, revision.asfuid, revision.created
@@ -291,8 +296,8 @@ async def release_latest_vote_task(release: sql.Release, caller_data: db.Session
 
 async def release_ready_for_vote(  # noqa: C901
     session: web.Committer,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     revision: str,
     data: db.Session,
     manual_vote: bool = False,
@@ -391,7 +396,9 @@ def task_recipient_get(latest_vote_task: sql.Task) -> str | None:
     return result.email_to
 
 
-async def tasks_ongoing(project_name: str, version_name: str, revision_number: str | None = None) -> int:
+async def tasks_ongoing(
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str | None = None
+) -> int:
     tasks = sqlmodel.select(sqlalchemy.func.count()).select_from(sql.Task)
     async with db.session() as data:
         query = tasks.where(
@@ -406,8 +413,8 @@ async def tasks_ongoing(project_name: str, version_name: str, revision_number: s
 
 
 async def tasks_ongoing_revision(
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     revision_number: str | None = None,
 ) -> tuple[int, str | None]:
     via = sql.validate_instrumented_attribute
@@ -453,17 +460,22 @@ async def trusted_jwt(publisher: str, jwt: str, phase: TrustedProjectPhase) -> t
 
 
 async def trusted_jwt_for_dist(
-    publisher: str, jwt: str, asf_uid: str, phase: TrustedProjectPhase, project_name: str, version_name: str
+    publisher: str,
+    jwt: str,
+    asf_uid: str,
+    phase: TrustedProjectPhase,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
 ) -> tuple[dict[str, Any], str, sql.Project, sql.Release]:
     payload, asf_uid_from_jwt = await validate_trusted_jwt(publisher, jwt)
     if asf_uid_from_jwt is not None:
         raise InteractionError("Must use Trusted Publishing when specifying ASF UID")
     # payload, asf_uid, project = await trusted_jwt(publisher, jwt, phase)
     async with db.session() as db_data:
-        project = await db_data.project(name=project_name, _committee=True).demand(
+        project = await db_data.project(name=str(project_name), _committee=True).demand(
             InteractionError(f"Project {project_name} does not exist")
         )
-        release = await db_data.release(project_name=project_name, version=version_name).get()
+        release = await db_data.release(project_name=str(project_name), version=str(version_name)).get()
         if not release:
             raise InteractionError(f"Release {version_name} does not exist in project {project_name}")
         if (phase == TrustedProjectPhase.COMPOSE) and (release.phase != sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT):
@@ -476,8 +488,8 @@ async def trusted_jwt_for_dist(
     return payload, asf_uid, project, release
 
 
-async def unfinished_releases(asfuid: str) -> list[tuple[str, str, list[sql.Release]]]:
-    releases: list[tuple[str, str, list[sql.Release]]] = []
+async def unfinished_releases(asfuid: str) -> list[tuple[str, safe.ProjectName, list[sql.Release]]]:
+    releases: list[tuple[str, safe.ProjectName, list[sql.Release]]] = []
     async with db.session() as data:
         user_projects = await user.projects(asfuid)
         user_projects.sort(key=lambda p: p.display_name)
@@ -501,7 +513,7 @@ async def unfinished_releases(asfuid: str) -> list[tuple[str, str, list[sql.Rele
             active_releases = list(result.scalars().all())
             if active_releases:
                 active_releases.sort(key=lambda r: r.created, reverse=True)
-                releases.append((project.short_display_name, project.name, active_releases))
+                releases.append((project.short_display_name, project.safe_name, active_releases))
 
     return releases
 
@@ -531,9 +543,9 @@ async def user_committees_participant(asf_uid: str, caller_data: db.Session | No
         return await data.committee(has_participant=asf_uid).all()
 
 
-async def user_projects(asf_uid: str, caller_data: db.Session | None = None) -> list[tuple[str, str]]:
+async def user_projects(asf_uid: str, caller_data: db.Session | None = None) -> list[tuple[safe.ProjectName, str]]:
     projects = await user.projects(asf_uid)
-    return [(p.name, p.display_name) for p in projects]
+    return [(p.safe_name, p.display_name) for p in projects]
 
 
 async def validate_trusted_jwt(publisher: str, jwt: str) -> tuple[dict[str, Any], str | None]:
diff --git a/atr/get/announce.py b/atr/get/announce.py
index 29c0cfed..663cfa9e 100644
--- a/atr/get/announce.py
+++ b/atr/get/announce.py
@@ -59,16 +59,16 @@ async def selected(
         )
 
     # Get the templates from the release policy
-    default_subject_template = await construct.announce_release_subject_default(str(project_name))
-    default_body_template = await construct.announce_release_default(str(project_name))
+    default_subject_template = await construct.announce_release_subject_default(project_name)
+    default_body_template = await construct.announce_release_default(project_name)
     subject_template_hash = construct.template_hash(default_subject_template)
 
     # Expand the templates
     options = construct.AnnounceReleaseOptions(
         asfuid=session.uid,
         fullname=session.fullname,
-        project_name=str(project_name),
-        version_name=str(version_name),
+        project_name=project_name,
+        version_name=version_name,
         revision_number=latest_revision_number,
     )
     default_subject, default_body = await construct.announce_release_subject_and_body(
@@ -114,8 +114,8 @@ async def _get_page_data(
     session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName
 ) -> sql.Release:
     release = await session.release(
-        str(project_name),
-        str(version_name),
+        project_name,
+        version_name,
         with_committee=True,
         phase=sql.ReleasePhase.RELEASE_PREVIEW,
         with_distributions=True,
@@ -220,13 +220,13 @@ async def _render_page(
     """
     page.style[markupsafe.Markup(page_styles)]
 
-    render.html_nav_phase(page, release.project.name, release.version, staging=False)
+    render.html_nav_phase(page, str(release.project.name), str(release.version), staging=False)
 
     page.h1[
         "Announce ",
         htm.strong[release.project.short_display_name],
         " ",
-        htm.em[release.version],
+        htm.em[str(release.version)],
     ]
     page.append(_render_release_card(release))
     page.h2["Announce this release"]
@@ -248,8 +248,8 @@ async def _render_page(
     if not announce_msg:
         page.p[f"This form will send an announcement to the ASF {util.USER_TESTS_ADDRESS} mailing list."]
 
-        custom_subject_widget = _render_subject_field(default_subject, release.project.name)
-        custom_body_widget = _render_body_field(default_body, release.project.name)
+        custom_subject_widget = _render_subject_field(default_subject, str(release.project.name))
+        custom_body_widget = _render_body_field(default_body, str(release.project.name))
         custom_mailing_list_widget = _render_mailing_list_with_warning(mailing_list_choices, util.USER_TESTS_ADDRESS)
 
         # Custom widget for download_path_suffix with custom documentation
diff --git a/atr/get/checklist.py b/atr/get/checklist.py
index 2d4fd788..d5ba2e3c 100644
--- a/atr/get/checklist.py
+++ b/atr/get/checklist.py
@@ -67,7 +67,7 @@ async def selected(
     substituted_markdown = construct.checklist_body(
         checklist_markdown,
         project=project,
-        version_name=str(version_name),
+        version_name=version_name,
         committee=committee,
         revision=latest_revision,
     )
diff --git a/atr/get/checks.py b/atr/get/checks.py
index df41705c..80bdde58 100644
--- a/atr/get/checks.py
+++ b/atr/get/checks.py
@@ -92,7 +92,7 @@ async def get_file_totals(release: sql.Release, session: web.Committer | None) -
 
     async with storage.read(session) as read:
         ragp = read.as_general_public()
-        match_ignore = await ragp.checks.ignores_matcher(release.project_name)
+        match_ignore = await ragp.checks.ignores_matcher(release.safe_project_name)
 
     _, totals = await _compute_stats(release, all_paths, match_ignore)
     return totals
@@ -123,7 +123,7 @@ async def selected(
 
     async with storage.read(session) as read:
         ragp = read.as_general_public()
-        match_ignore = await ragp.checks.ignores_matcher(release.project_name)
+        match_ignore = await ragp.checks.ignores_matcher(release.safe_project_name)
 
     per_file_stats, totals = await _compute_stats(release, all_paths, match_ignore)
 
@@ -169,9 +169,9 @@ async def selected_revision(
         ragp = read.as_general_public()
         info = await ragp.releases.path_info(release, all_paths)
 
-    ongoing_count = await interaction.tasks_ongoing(str(project_name), str(version_name), revision_number)
+    ongoing_count = await interaction.tasks_ongoing(project_name, version_name, revision_number)
 
-    checks_summary_elem = shared.web.render_checks_summary(info, str(project_name), str(version_name))
+    checks_summary_elem = shared.web.render_checks_summary(info, project_name, version_name)
     checks_summary_html = str(checks_summary_elem) if checks_summary_elem else ""
 
     delete_file_forms: dict[str, str] = {}
@@ -506,7 +506,7 @@ def _render_file_row(
 def _render_header(page: htm.Block, release: sql.Release) -> None:
     render.html_nav(
         page,
-        back_url=util.as_url(vote.selected, project_name=release.project.name, version_name=release.version),
+        back_url=util.as_url(vote.selected, project_name=str(release.project.name), version_name=str(release.version)),
         back_anchor=f"Vote on {release.project.short_display_name} {release.version}",
         phase="VOTE",
     )
@@ -515,7 +515,7 @@ def _render_header(page: htm.Block, release: sql.Release) -> None:
         "File checks for ",
         htm.strong[release.project.short_display_name],
         " ",
-        htm.em[release.version],
+        htm.em[str(release.version)],
     ]
 
 
@@ -526,7 +526,7 @@ def _render_ignores_section(page: htm.Block, release: sql.Release) -> None:
         "Project committee members can configure rules to ignore specific check results. "
         "Ignored checks are excluded from the counts shown above.",
     ]
-    ignores_url = util.as_url(ignores.ignores, project_name=release.project.name)
+    ignores_url = util.as_url(ignores.ignores, project_name=str(release.project.name))
     page.div[htpy.a(".btn.btn-outline-primary", href=ignores_url)["Manage check ignores"],]
 
 
diff --git a/atr/get/distribution.py b/atr/get/distribution.py
index e5955e11..efcedfe8 100644
--- a/atr/get/distribution.py
+++ b/atr/get/distribution.py
@@ -46,7 +46,7 @@ async def automate(
     URL: /distribution/automate/<project_name>/<version>
     """
     await session.check_access(project_name)
-    return await _automate_form_page(str(project_name), str(version_name), staging=False)
+    return await _automate_form_page(project_name, version_name, staging=False)
 
 
 @get.typed
@@ -59,11 +59,11 @@ async def list_get(
     """
     URL: /distribution/list/<project_name>/<version_name>
     """
-    distributions, tasks = await _get_page_data(str(project_name), str(version_name))
+    distributions, tasks = await _get_page_data(project_name, version_name)
 
     block = htm.Block()
 
-    release = await shared.distribution.release_validated(str(project_name), str(version_name), staging=None)
+    release = await shared.distribution.release_validated(project_name, version_name, staging=None)
     staging = release.phase == sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     render.html_nav_phase(block, str(project_name), str(version_name), staging)
 
@@ -80,7 +80,7 @@ async def list_get(
     block.h1["Distribution list for ", htm.em[f"{project_name!s}-{version_name!s}"]]
 
     if len(tasks) > 0:
-        _render_distribution_tasks(tasks, block, str(project_name), str(version_name))
+        _render_distribution_tasks(tasks, block, project_name, version_name)
 
     if not distributions:
         block.p["No distributions found."]
@@ -107,7 +107,7 @@ async def list_get(
             id=f"distribution-{dist.identifier}"
         )[dist.title, *title_extra]
         tbody = htm.tbody[
-            shared.distribution.html_tr("Release name", dist.release_name),
+            shared.distribution.html_tr("Release name", str(dist.release_name)),
             shared.distribution.html_tr("Platform", dist.platform.value.name),
             shared.distribution.html_tr("Owner or Namespace", dist.owner_namespace or "-"),
             shared.distribution.html_tr("Package", dist.package),
@@ -154,7 +154,7 @@ async def record(
     URL: /distribution/record/<project_name>/<version_name>
     """
     await session.check_access(project_name)
-    return await _record_form_page(str(project_name), str(version_name), staging=False)
+    return await _record_form_page(project_name, version_name, staging=False)
 
 
 @get.typed
@@ -168,7 +168,7 @@ async def stage_automate(
     URL: /distribution/stage/automate/<project_name>/<version_name>
     """
     await session.check_access(project_name)
-    return await _automate_form_page(str(project_name), str(version_name), staging=True)
+    return await _automate_form_page(project_name, version_name, staging=True)
 
 
 @get.typed
@@ -182,15 +182,15 @@ async def stage_record(
     URL: /distribution/stage/record/<project_name>/<version_name>
     """
     await session.check_access(project_name)
-    return await _record_form_page(str(project_name), str(version_name), staging=True)
+    return await _record_form_page(project_name, version_name, staging=True)
 
 
-async def _automate_form_page(project: str, version: str, staging: bool) -> str:
+async def _automate_form_page(project: safe.ProjectName, version: safe.VersionName, staging: bool) -> str:
     """Helper to render the distribution automation form page."""
     await shared.distribution.release_validated(project, version, staging=staging)
 
     block = htm.Block()
-    render.html_nav_phase(block, project, version, staging=staging)
+    render.html_nav_phase(block, str(project), str(version), staging=staging)
 
     title = "Create a staging distribution" if staging else "Create a distribution"
     block.h1[title]
@@ -202,15 +202,17 @@ async def _automate_form_page(project: str, version: str, staging: bool) -> str:
     ]
     block.p[
         "You can also ",
-        htm.a(href=util.as_url(list_get, project_name=project, version_name=version))["view the distribution list"],
+        htm.a(href=util.as_url(list_get, project_name=str(project), version_name=str(version)))[
+            "view the distribution list"
+        ],
         ".",
     ]
 
     # Determine the action based on staging
     action = (
-        util.as_url(post.distribution.stage_automate_selected, project_name=project, version_name=version)
+        util.as_url(post.distribution.stage_automate_selected, project_name=str(project), version_name=str(version))
         if staging
-        else util.as_url(post.distribution.automate_selected, project_name=project, version_name=version)
+        else util.as_url(post.distribution.automate_selected, project_name=str(project), version_name=str(version))
     )
 
     # TODO: Reuse the same form for now - maybe we can combine this and the function below adding an automate=True arg
@@ -219,31 +221,33 @@ async def _automate_form_page(project: str, version: str, staging: bool) -> str:
         model_cls=shared.distribution.DistributeForm,
         submit_label="Distribute",
         action=action,
-        defaults={"package": project, "version": version},
+        defaults={"package": str(project), "version": str(version)},
     )
     block.append(form_html)
 
     return await template.blank(title, content=block.collect())
 
 
-async def _get_page_data(project_name: str, version_name: str) -> tuple[Sequence[sql.Distribution], Sequence[sql.Task]]:
+async def _get_page_data(
+    project_name: safe.ProjectName, version_name: safe.VersionName
+) -> tuple[Sequence[sql.Distribution], Sequence[sql.Task]]:
     """Get all the data needed to render the finish page."""
     async with db.session() as data:
         via = sql.validate_instrumented_attribute
         distributions = await data.distribution(
-            release_name=sql.release_name(project_name, version_name),
+            release_name=sql.release_name(str(project_name), str(version_name)),
         ).all()
         release = await data.release(
-            project_name=project_name,
-            version=version_name,
+            project_name=str(project_name),
+            version=str(version_name),
             _committee=True,
         ).demand(base.ASFQuartException("Release does not exist", errorcode=404))
         tasks = [
             t
             for t in (
                 await data.task(
-                    project_name=project_name,
-                    version_name=version_name,
+                    project_name=str(project_name),
+                    version_name=str(version_name),
                     revision_number=release.latest_revision_number,
                     task_type=sql.TaskType.DISTRIBUTION_WORKFLOW,
                     _workflow=True,
@@ -258,12 +262,12 @@ async def _get_page_data(project_name: str, version_name: str) -> tuple[Sequence
     return distributions, tasks
 
 
-async def _record_form_page(project: str, version: str, staging: bool) -> str:
+async def _record_form_page(project: safe.ProjectName, version: safe.VersionName, staging: bool) -> str:
     """Helper to render the distribution recording form page."""
     await shared.distribution.release_validated(project, version, staging=staging)
 
     block = htm.Block()
-    render.html_nav_phase(block, project, version, staging=staging)
+    render.html_nav_phase(block, str(project), str(version), staging=staging)
 
     title = "Record a manual staging distribution" if staging else "Record a manual distribution"
     block.h1[title]
@@ -275,15 +279,17 @@ async def _record_form_page(project: str, version: str, staging: bool) -> str:
     ]
     block.p[
         "You can also ",
-        htm.a(href=util.as_url(list_get, project_name=project, version_name=version))["view the distribution list"],
+        htm.a(href=util.as_url(list_get, project_name=str(project), version_name=str(version)))[
+            "view the distribution list"
+        ],
         ".",
     ]
 
     # Determine the action based on staging
     action = (
-        util.as_url(post.distribution.stage_record_selected, project_name=project, version_name=version)
+        util.as_url(post.distribution.stage_record_selected, project_name=str(project), version_name=str(version))
         if staging
-        else util.as_url(post.distribution.record_selected, project_name=project, version_name=version)
+        else util.as_url(post.distribution.record_selected, project_name=str(project), version_name=str(version))
     )
 
     # Render the distribution form
@@ -291,14 +297,16 @@ async def _record_form_page(project: str, version: str, staging: bool) -> str:
         model_cls=shared.distribution.DistributeForm,
         submit_label="Record distribution",
         action=action,
-        defaults={"package": project, "version": version},
+        defaults={"package": str(project), "version": str(version)},
     )
     block.append(form_html)
 
     return await template.blank(title, content=block.collect())
 
 
-def _render_distribution_tasks(tasks: Sequence[sql.Task], block: htm.Block, project_name: str, version_name: str):
+def _render_distribution_tasks(
+    tasks: Sequence[sql.Task], block: htm.Block, project_name: safe.ProjectName, version_name: safe.VersionName
+):
     failed_tasks = [
         t for t in tasks if (t.status == sql.TaskStatus.FAILED) or (t.workflow and (t.workflow.status == "failed"))
     ]
@@ -329,8 +337,8 @@ def _render_distribution_tasks(tasks: Sequence[sql.Task], block: htm.Block, proj
                     ".btn.btn-success.mt-2",
                     href=util.as_url(
                         list_get,
-                        project_name=project_name,
-                        version_name=version_name,
+                        project_name=str(project_name),
+                        version_name=str(version_name),
                     ),
                 )["Refresh"],
             ]
diff --git a/atr/get/download.py b/atr/get/download.py
index 830f9633..1645e978 100644
--- a/atr/get/download.py
+++ b/atr/get/download.py
@@ -54,9 +54,7 @@ async def all_selected(
     import atr.get.root as root
 
     async with db.session() as data:
-        release = await session.release(
-            project_name=str(project_name), version_name=str(version_name), phase=None, data=data
-        )
+        release = await session.release(project_name=project_name, version_name=version_name, phase=None, data=data)
         if not release:
             return await session.redirect(root.index, error="Release not found")
         user_ssh_keys = await data.ssh_key(asf_uid=session.uid).all()
@@ -89,7 +87,7 @@ async def path(
     URL: /download/path/<project_name>/<version_name>/<path:file_path>
     Download a file or list a directory from a release in any phase.
     """
-    return await _download_or_list(str(project_name), str(version_name), str(file_path))
+    return await _download_or_list(project_name, version_name, str(file_path))
 
 
 @get.typed
@@ -103,7 +101,7 @@ async def path_empty(
     URL: /download/path/<project_name>/<version_name>/
     List files at the root of a release directory for download.
     """
-    return await _download_or_list(str(project_name), str(version_name), ".")
+    return await _download_or_list(project_name, version_name, ".")
 
 
 @get.typed
@@ -165,7 +163,7 @@ async def zip_selected(
     URL: /download/zip/<project_name>/<version_name>
     """
     try:
-        release = await session.release(project_name=str(project_name), version_name=str(version_name), phase=None)
+        release = await session.release(project_name=project_name, version_name=version_name, phase=None)
     except ValueError as e:
         return web.TextResponse(f"Error: {e}", status=404)
     except Exception as e:
@@ -187,13 +185,15 @@ async def zip_selected(
             yield chunk
 
     headers = {
-        "Content-Disposition": web.HeaderValue("attachment", filename=release.name + ".zip"),
+        "Content-Disposition": web.HeaderValue("attachment", filename=str(release.name) + ".zip"),
         "Content-Type": web.HeaderValue("application/zip"),
     }
     return web.ZipResponse(stream_zip(files_to_zip), headers=headers)
 
 
-async def _download_or_list(project_name: str, version_name: str, file_path: str) -> web.Response:
+async def _download_or_list(
+    project_name: safe.ProjectName, version_name: safe.VersionName, file_path: str
+) -> web.Response:
     """Download a file or list a directory from a release in any phase."""
     import atr.get.root as root
 
@@ -207,13 +207,13 @@ async def _download_or_list(project_name: str, version_name: str, file_path: str
 
     # We allow downloading files from any phase
     async with db.session() as data:
-        release = await data.release(project_name=project_name, version=version_name).demand(
+        release = await data.release(project_name=str(project_name), version=str(version_name)).demand(
             base.ASFQuartException("Release does not exist", errorcode=404)
         )
     full_path = paths.release_directory(release) / validated_path
 
     if await aiofiles.os.path.isdir(full_path):
-        return await _list(validated_path, full_path, project_name, version_name, str(validated_path))
+        return await _list(validated_path, full_path, str(project_name), str(version_name), str(validated_path))
 
     # Check that the path is a regular file
     if not await aiofiles.os.path.isfile(full_path):
diff --git a/atr/get/draft.py b/atr/get/draft.py
index c5a2155e..64a5a94a 100644
--- a/atr/get/draft.py
+++ b/atr/get/draft.py
@@ -52,7 +52,7 @@ async def tools(
     if validated_path is None:
         raise base.ASFQuartException("Invalid file path", errorcode=400)
 
-    release = await session.release(str(project_name), str(version_name))
+    release = await session.release(project_name, version_name)
     full_path = str(paths.release_directory(release) / validated_path)
 
     # Check that the file exists
diff --git a/atr/get/file.py b/atr/get/file.py
index c0f3f9c4..2ccb28e2 100644
--- a/atr/get/file.py
+++ b/atr/get/file.py
@@ -46,7 +46,7 @@ async def selected(
     URL: /file/<project_name>/<version_name>
     View all the files in a release (any phase).
     """
-    release = await session.release(str(project_name), str(version_name), phase=None)
+    release = await session.release(project_name, version_name, phase=None)
 
     revision_number = release.latest_revision_number
     file_stats = []
@@ -72,7 +72,7 @@ async def selected(
         back_url, back_label, phase_label = nav_info
         render.html_nav(block, back_url, back_label, phase_label)
 
-    block.h1["Files in ", htm.strong[release.project.short_display_name], " ", htm.em[release.version]]
+    block.h1["Files in ", htm.strong[release.project.short_display_name], " ", htm.em[str(release.version)]]
 
     block.div(".card.mb-4")[
         htm.div(".card-header.d-flex.justify-content-between.align-items-center")[
@@ -82,7 +82,7 @@ async def selected(
             htm.div(".row")[
                 htm.div(".col-md-6")[
                     htm.p[htm.strong["Project:"], " ", release.project.display_name],
-                    htm.p[htm.strong["Label:"], " ", release.name],
+                    htm.p[htm.strong["Label:"], " ", str(release.name)],
                 ],
                 htm.div(".col-md-6")[htm.p[htm.strong["Created:"], " ", release.created.strftime("%Y-%m-%d %H:%M:%S")]],
             ]
@@ -98,8 +98,8 @@ async def selected(
             if stat.is_file:
                 file_url = util.as_url(
                     selected_path,
-                    project_name=release.project.name,
-                    version_name=release.version,
+                    project_name=str(release.project.name),
+                    version_name=str(release.version),
                     file_path=stat.path,
                 )
                 file_link = htm.a(href=file_url)[stat.path]
@@ -153,7 +153,7 @@ async def selected_path(
     if validated_path is None:
         raise web.FlashError("Invalid file path")
 
-    release = await session.release(str(project_name), str(version_name), phase=None)
+    release = await session.release(project_name, version_name, phase=None)
     _max_view_size = 512 * 1024
     full_path = paths.release_directory(release) / validated_path
     content_listing = await util.archive_listing(full_path)
@@ -161,13 +161,13 @@ async def selected_path(
 
     block = htm.Block()
 
-    back_url = util.as_url(selected, project_name=release.project.name, version_name=release.version)
+    back_url = util.as_url(selected, project_name=str(release.project.name), version_name=str(release.version))
     phase_name = _phase_display_name(release.phase)
     block.a(href=back_url, class_="atr-back-link")[f"← Back to {phase_name} files"]
 
     block.div(".p-3.mt-4.mb-4.bg-light.border.rounded")[
         htm.h2(".mt-0")[f"Viewing file: {validated_path}"],
-        htm.p(".mb-0")[htm.strong["Release:"], " ", release.name],
+        htm.p(".mb-0")[htm.strong["Release:"], " ", str(release.name)],
     ]
 
     if content_listing:
@@ -199,19 +199,19 @@ def _get_navigation_info(release: sql.Release) -> tuple[str, str, Phase] | None:
     """Get back URL, back label, and phase label based on release phase."""
     if release.phase == sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT:
         return (
-            util.as_url(compose.selected, project_name=release.project.name, version_name=release.version),
+            util.as_url(compose.selected, project_name=str(release.project.name), version_name=str(release.version)),
             f"Compose {release.short_display_name}",
             "COMPOSE",
         )
     elif release.phase == sql.ReleasePhase.RELEASE_CANDIDATE:
         return (
-            util.as_url(vote.selected, project_name=release.project.name, version_name=release.version),
+            util.as_url(vote.selected, project_name=str(release.project.name), version_name=str(release.version)),
             f"Vote on {release.short_display_name}",
             "VOTE",
         )
     elif release.phase == sql.ReleasePhase.RELEASE_PREVIEW:
         return (
-            util.as_url(finish.selected, project_name=release.project.name, version_name=release.version),
+            util.as_url(finish.selected, project_name=str(release.project.name), version_name=str(release.version)),
             f"Finish {release.short_display_name}",
             "FINISH",
         )
diff --git a/atr/get/finish.py b/atr/get/finish.py
index f8b558a6..9789711c 100644
--- a/atr/get/finish.py
+++ b/atr/get/finish.py
@@ -72,7 +72,7 @@ async def selected(
     await session.check_access(project_name)
     try:
         (release, source_files_rel, target_dirs, deletable_dirs, rc_analysis, tasks) = await _get_page_data(
-            str(project_name), str(version_name)
+            project_name, version_name
         )
     except ValueError:
         async with db.session() as data:
@@ -155,7 +155,7 @@ async def _deletable_choices(
 
 
 async def _get_page_data(
-    project_name: str, version_name: str
+    project_name: safe.ProjectName, version_name: safe.VersionName
 ) -> tuple[
     sql.Release, list[pathlib.Path], set[pathlib.Path], list[tuple[str, str]], RCTagAnalysisResult, Sequence[sql.Task]
 ]:
@@ -163,8 +163,8 @@ async def _get_page_data(
     async with db.session() as data:
         via = sql.validate_instrumented_attribute
         release = await data.release(
-            project_name=project_name,
-            version=version_name,
+            project_name=str(project_name),
+            version=str(version_name),
             _committee=True,
             _release_policy=True,
             _project_release_policy=True,
@@ -174,8 +174,8 @@ async def _get_page_data(
             t
             for t in (
                 await data.task(
-                    project_name=project_name,
-                    version_name=version_name,
+                    project_name=str(project_name),
+                    version_name=str(version_name),
                     revision_number=release.latest_revision_number,
                     task_type=sql.TaskType.DISTRIBUTION_WORKFLOW,
                     _workflow=True,
@@ -233,16 +233,16 @@ def _render_distribution_buttons(release: sql.Release) -> htm.Element:
                 ".btn.btn-primary.me-2",
                 href=util.as_url(
                     distribution.automate,
-                    project_name=release.project.name,
-                    version_name=release.version,
+                    project_name=str(release.project.name),
+                    version_name=str(release.version),
                 ),
             )["Distribute"],
             htm.a(
                 ".btn.btn-secondary.me-2",
                 href=util.as_url(
                     distribution.record,
-                    project_name=release.project.name,
-                    version_name=release.version,
+                    project_name=str(release.project.name),
+                    version_name=str(release.version),
                 ),
             )["Record a manual distribution"],
         ],
@@ -284,8 +284,8 @@ def _render_distribution_tasks(release: sql.Release, tasks: Sequence[sql.Task])
                     ".btn.btn-success.mt-2",
                     href=util.as_url(
                         selected,
-                        project_name=release.project.name,
-                        version_name=release.version,
+                        project_name=str(release.project.name),
+                        version_name=str(release.version),
                     ),
                 )["Refresh"],
             ]
@@ -386,7 +386,7 @@ async def _render_page(
         "Finish ",
         htm.strong[release.project.short_display_name],
         " ",
-        htm.em[release.version],
+        htm.em[str(release.version)],
     ]
 
     # Release info card
@@ -511,7 +511,7 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
     announce_classes = ".btn-success"
     if announce_disable_message:
         announce_classes += ".disabled"
-    card = htm.div(".card.mb-4.shadow-sm", id=release.name)[
+    card = htm.div(".card.mb-4.shadow-sm", id=str(release.name))[
         htm.div(".card-header.bg-light")[htm.h3(".card-title.mb-0")["About this release preview"]],
         htm.div(".card-body")[
             htm.div(".d-flex.flex-wrap.gap-3.pb-3.mb-3.border-bottom.text-secondary.fs-6")[
@@ -524,8 +524,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
                     title="Download all files",
                     href=util.as_url(
                         download.all_selected,
-                        project_name=release.project.name,
-                        version_name=release.version,
+                        project_name=str(release.project.name),
+                        version_name=str(release.version),
                     ),
                 )[
                     htm.icon("download"),
@@ -536,8 +536,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
                     title=f"Show files for {release.name}",
                     href=util.as_url(
                         file.selected,
-                        project_name=release.project.name,
-                        version_name=release.version,
+                        project_name=str(release.project.name),
+                        version_name=str(release.version),
                     ),
                 )[
                     htm.icon("archive"),
@@ -548,8 +548,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
                     title=f"Show revisions for {release.name}",
                     href=util.as_url(
                         revisions.selected,
-                        project_name=release.project.name,
-                        version_name=release.version,
+                        project_name=str(release.project.name),
+                        version_name=str(release.version),
                     ),
                 )[
                     htm.icon("clock-history"),
@@ -560,8 +560,8 @@ def _render_release_card(release: sql.Release, announce_disable_message: str) ->
                     title=f"Announce and distribute {release.name}",
                     href=util.as_url(
                         announce.selected,
-                        project_name=release.project.name,
-                        version_name=release.version,
+                        project_name=str(release.project.name),
+                        version_name=str(release.version),
                     )
                     if (not announce_disable_message)
                     else None,
diff --git a/atr/get/ignores.py b/atr/get/ignores.py
index bb24979e..fd07bd53 100644
--- a/atr/get/ignores.py
+++ b/atr/get/ignores.py
@@ -42,7 +42,7 @@ async def ignores(
     await session.check_access(project_name)
     async with storage.read() as read:
         ragp = read.as_general_public()
-        ignores = await ragp.checks.ignores(str(project_name))
+        ignores = await ragp.checks.ignores(project_name)
 
     content = htm.div[
         htm.h1["Ignored checks"],
diff --git a/atr/get/manual.py b/atr/get/manual.py
index 0f774ae1..7d90f0e9 100644
--- a/atr/get/manual.py
+++ b/atr/get/manual.py
@@ -47,8 +47,8 @@ async def resolve_selected(
     """
     await session.check_access(project_name)
     release = await session.release(
-        str(project_name),
-        str(version_name),
+        project_name,
+        version_name,
         phase=sql.ReleasePhase.RELEASE_CANDIDATE,
         with_release_policy=True,
         with_project_release_policy=True,
@@ -79,7 +79,7 @@ async def start_selected_revision(
     await session.check_access(project_name)
     async with db.session() as data:
         match await interaction.release_ready_for_vote(
-            session, str(project_name), str(version_name), revision, data, manual_vote=True
+            session, project_name, version_name, revision, data, manual_vote=True
         ):
             case str() as error:
                 return await session.redirect(
diff --git a/atr/get/projects.py b/atr/get/projects.py
index 5e30b96b..ec992b13 100644
--- a/atr/get/projects.py
+++ b/atr/get/projects.py
@@ -104,14 +104,14 @@ async def projects(_session: web.Public, _projects: Literal["projects"]) -> str:
 
     delete_forms: dict[str, htm.Element] = {}
     for project in projects:
-        delete_forms[project.name] = form.render(
+        delete_forms[str(project.name)] = form.render(
             model_cls=shared.projects.DeleteSelectedProject,
             action=util.as_url(post.projects.delete),
             form_classes=".d-inline-block.m-0",
             submit_classes="btn-sm btn-outline-danger",
             submit_label="Delete project",
             empty=True,
-            defaults={"project_name": project.name},
+            defaults={"project_name": str(project.name)},
             confirm="Are you sure you want to delete this project? This cannot be undone.",
         )
 
@@ -188,7 +188,7 @@ async def view(
     page.append(title_row)
 
     page.p(".mb-4")[
-        htm.a(".btn.btn-sm.btn-outline-primary", href=util.as_url(start.selected, project_name=project.name))[
+        htm.a(".btn.btn-sm.btn-outline-primary", href=util.as_url(start.selected, project_name=str(project.name)))[
             "Start a new release"
         ]
     ]
@@ -297,9 +297,9 @@ def _render_categories_section(project: sql.Project) -> htm.Element:
     for cat in current_categories:
         remove_button = (
             # Manual form as badges are not handled by the form system
-            htm.form(".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=project.name))[
+            htm.form(".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=str(project.name)))[
                 form.csrf_input(),
-                htpy.input(type="hidden", name="project_name", value=project.name),
+                htpy.input(type="hidden", name="project_name", value=str(project.name)),
                 htpy.input(type="hidden", name="variant", value="remove_category"),
                 htpy.input(type="hidden", name="category_to_remove", value=cat),
                 htpy.button(
@@ -315,9 +315,9 @@ def _render_categories_section(project: sql.Project) -> htm.Element:
         ]
         category_badges.append(badge)
 
-    add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=project.name))[
+    add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=str(project.name)))[
         form.csrf_input(),
-        htpy.input(type="hidden", name="project_name", value=project.name),
+        htpy.input(type="hidden", name="project_name", value=str(project.name)),
         htpy.input(type="hidden", name="variant", value="add_category"),
         htm.div(".d-flex.align-items-center")[
             htpy.input(
@@ -349,10 +349,10 @@ def _render_compose_form(project: sql.Project) -> htm.Element:
         form.render_block(
             card_body,
             model_cls=shared.projects.ComposePolicyForm,
-            action=util.as_url(post.projects.view, name=project.name),
+            action=util.as_url(post.projects.view, name=str(project.name)),
             submit_label="Save",
             defaults={
-                "project_name": project.name,
+                "project_name": str(project.name),
                 "source_artifact_paths": "\n".join(project.policy_source_artifact_paths),
                 "license_check_mode": project.policy_license_check_mode,
                 "source_excludes_lightweight": "\n".join(project.policy_source_excludes_lightweight),
@@ -378,11 +378,11 @@ def _render_delete_section(project: sql.Project) -> htm.Element:
 
     delete_form = form.render(
         shared.projects.DeleteProjectForm,
-        action=util.as_url(post.projects.view, name=project.name),
+        action=util.as_url(post.projects.view, name=str(project.name)),
         form_classes="",
         submit_classes="btn-sm btn-outline-danger",
         submit_label="Delete project",
-        defaults={"project_name": project.name},
+        defaults={"project_name": str(project.name)},
         confirm="Are you sure you want to delete this project? This cannot be undone.",
         empty=True,
     )
@@ -423,7 +423,7 @@ def _render_finish_form(project: sql.Project) -> htm.Element:
         form.render_block(
             card_body,
             model_cls=shared.projects.FinishPolicyForm,
-            action=util.as_url(post.projects.view, name=project.name),
+            action=util.as_url(post.projects.view, name=str(project.name)),
             submit_label="Save",
             defaults={
                 "project_name": project.name,
@@ -453,10 +453,10 @@ def _render_languages_section(project: sql.Project) -> htm.Element:
     for lang in current_languages:
         # Manual form as badges are not handled by the form system
         remove_button = htm.form(
-            ".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=project.name)
+            ".d-inline.m-0", method="post", action=util.as_url(post.projects.view, name=str(project.name))
         )[
             form.csrf_input(),
-            htpy.input(type="hidden", name="project_name", value=project.name),
+            htpy.input(type="hidden", name="project_name", value=str(project.name)),
             htpy.input(type="hidden", name="variant", value="remove_language"),
             htpy.input(type="hidden", name="language_to_remove", value=lang),
             htpy.button(".btn-close.btn-close-white.ms-1.page-remove-tag", type="submit", aria_label=f"Remove {lang}"),
@@ -467,9 +467,9 @@ def _render_languages_section(project: sql.Project) -> htm.Element:
         ]
         language_badges.append(badge)
 
-    add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=project.name))[
+    add_form = htm.form(".mb-3", method="post", action=util.as_url(post.projects.view, name=str(project.name)))[
         form.csrf_input(),
-        htpy.input(type="hidden", name="project_name", value=project.name),
+        htpy.input(type="hidden", name="project_name", value=str(project.name)),
         htpy.input(type="hidden", name="variant", value="add_language"),
         htm.div(".d-flex.align-items-center")[
             htpy.input(
@@ -531,7 +531,7 @@ def _render_policy_readonly(project: sql.Project) -> htm.Element:
 def _render_project_label_card(project: sql.Project) -> htm.Element:
     card = htm.Block(htm.div, classes=".card.mb-4")
     card.div(".card-header.bg-light")[htm.h3(".mb-2")["Project label"]]
-    card.div(".card-body")[htm.code(".fs-6")[project.name]]
+    card.div(".card-body")[htm.code(".fs-6")[str(project.name)]]
     return card.collect()
 
 
@@ -552,7 +552,7 @@ async def _render_releases_sections(
             draft_buttons.append(
                 htm.a(
                     ".btn.btn-sm.btn-outline-secondary.py-2.px-3",
-                    href=util.as_url(file.selected, project_name=project.name, version_name=drf.version),
+                    href=util.as_url(file.selected, project_name=str(project.name), version_name=str(drf.version)),
                     title=f"View draft {project.name} {drf.version}",
                 )[
                     f"{project.name} {drf.version} ",
@@ -569,7 +569,7 @@ async def _render_releases_sections(
             candidate_buttons.append(
                 htm.a(
                     ".btn.btn-sm.btn-outline-info.py-2.px-3",
-                    href=util.as_url(file.selected, project_name=project.name, version_name=cnd.version),
+                    href=util.as_url(file.selected, project_name=str(project.name), version_name=str(cnd.version)),
                     title=f"View candidate {project.name} {cnd.version}",
                 )[
                     f"{project.name} {cnd.version} ",
@@ -586,7 +586,7 @@ async def _render_releases_sections(
             preview_buttons.append(
                 htm.a(
                     ".btn.btn-sm.btn-outline-warning.py-2.px-3",
-                    href=util.as_url(file.selected, project_name=project.name, version_name=prv.version),
+                    href=util.as_url(file.selected, project_name=str(project.name), version_name=str(prv.version)),
                     title=f"View preview {project.name} {prv.version}",
                 )[
                     f"{project.name} {prv.version} ",
@@ -603,7 +603,7 @@ async def _render_releases_sections(
             release_buttons.append(
                 htm.a(
                     ".btn.btn-sm.btn-outline-success.py-2.px-3",
-                    href=util.as_url(file.selected, project_name=project.name, version_name=rel.version),
+                    href=util.as_url(file.selected, project_name=str(project.name), version_name=str(rel.version)),
                     title=f"View release {project.name} {rel.version}",
                 )[
                     f"{project.name} {rel.version} ",
@@ -622,7 +622,7 @@ def _render_vote_form(project: sql.Project) -> htm.Element:
     ]
 
     defaults_dict = {
-        "project_name": project.name,
+        "project_name": str(project.name),
         "github_vote_workflow_path": "\n".join(project.policy_github_vote_workflow_path),
         "mailto_addresses": project.policy_mailto_addresses[0]
         if project.policy_mailto_addresses
@@ -665,7 +665,7 @@ def _render_vote_form(project: sql.Project) -> htm.Element:
         form.render_block(
             card_body,
             model_cls=shared.projects.VotePolicyForm,
-            action=util.as_url(post.projects.view, name=project.name),
+            action=util.as_url(post.projects.view, name=str(project.name)),
             submit_label="Save",
             defaults=defaults_dict,
             form_classes=".atr-canary.py-4.px-5",
diff --git a/atr/get/report.py b/atr/get/report.py
index 33b99686..15d81be6 100644
--- a/atr/get/report.py
+++ b/atr/get/report.py
@@ -52,16 +52,16 @@ async def selected_path(
     # If the draft is not found, we try to get the release candidate
     try:
         release = await session.release(
-            str(project_name),
-            str(version_name),
+            project_name,
+            version_name,
             with_committee=True,
             with_release_policy=True,
             with_project_release_policy=True,
         )
     except base.ASFQuartException:
         release = await session.release(
-            str(project_name),
-            str(version_name),
+            project_name,
+            version_name,
             phase=sql.ReleasePhase.RELEASE_CANDIDATE,
             with_committee=True,
             with_release_policy=True,
diff --git a/atr/get/result.py b/atr/get/result.py
index 2b936d36..eaf52f8a 100644
--- a/atr/get/result.py
+++ b/atr/get/result.py
@@ -49,7 +49,7 @@ async def data(
         ).get()
 
         if release is None:
-            release = await session.release(str(project_name), str(version_name), with_committee=True)
+            release = await session.release(project_name, version_name, with_committee=True)
 
         if release.committee is None:
             raise base.ASFQuartException("Release has no committee", errorcode=500)
diff --git a/atr/get/revisions.py b/atr/get/revisions.py
index 8bbb575a..7f324448 100644
--- a/atr/get/revisions.py
+++ b/atr/get/revisions.py
@@ -62,10 +62,10 @@ async def selected(
     """
     await session.check_access(project_name)
     try:
-        release = await session.release(str(project_name), str(version_name))
+        release = await session.release(project_name, version_name)
         phase_key = "draft"
     except base.ASFQuartException:
-        release = await session.release(str(project_name), str(version_name), phase=sql.ReleasePhase.RELEASE_PREVIEW)
+        release = await session.release(project_name, version_name, phase=sql.ReleasePhase.RELEASE_PREVIEW)
         phase_key = "preview"
     release_dir = paths.release_directory_base(release)
 
@@ -178,7 +178,7 @@ async def _render_page(
         "Revisions of ",
         htm.strong[release.project.short_display_name],
         " ",
-        htm.em[release.version],
+        htm.em[str(release.version)],
     ]
 
     if revision_history:
diff --git a/atr/get/sbom.py b/atr/get/sbom.py
index cd9612a7..a8ef42cc 100644
--- a/atr/get/sbom.py
+++ b/atr/get/sbom.py
@@ -58,10 +58,10 @@ async def report(
     """
     # If the draft is not found, we try to get the release candidate
     try:
-        release = await session.release(str(project_name), str(version_name), with_committee=True)
+        release = await session.release(project_name, version_name, with_committee=True)
     except base.ASFQuartException:
         release = await session.release(
-            str(project_name), str(version_name), phase=sql.ReleasePhase.RELEASE_CANDIDATE, with_committee=True
+            project_name, version_name, phase=sql.ReleasePhase.RELEASE_CANDIDATE, with_committee=True
         )
 
     block = htm.Block()
@@ -95,9 +95,7 @@ async def report(
         raise base.ASFQuartException("Invalid file path", errorcode=400)
     validated_path_str = str(validated_path)
 
-    task, augment_tasks, osv_tasks = await _fetch_tasks(
-        validated_path_str, str(project_name), release, str(version_name)
-    )
+    task, augment_tasks, osv_tasks = await _fetch_tasks(validated_path_str, project_name, release, version_name)
 
     task_status = await _report_task_results(block, task)
     if task_status:
@@ -247,15 +245,15 @@ def _extract_vulnerability_severity(vuln: results.VulnerabilityDetails) -> str:
 
 
 async def _fetch_tasks(
-    file_path: str, project: str, release: sql.Release, version: str
+    file_path: str, project: safe.ProjectName, release: sql.Release, version: safe.VersionName
 ) -> tuple[sql.Task | None, Sequence[sql.Task], Sequence[sql.Task]]:
     # TODO: Abstract this code and the sbomtool.MissingAdapter validators
     async with db.session() as data:
         via = sql.validate_instrumented_attribute
         tasks = (
             await data.task(
-                project_name=project,
-                version_name=version,
+                project_name=str(project),
+                version_name=str(version),
                 revision_number=release.latest_revision_number,
                 task_type=sql.TaskType.SBOM_TOOL_SCORE,
                 primary_rel_path=file_path,
@@ -265,8 +263,8 @@ async def _fetch_tasks(
         )
         augment_tasks = (
             await data.task(
-                project_name=project,
-                version_name=version,
+                project_name=str(project),
+                version_name=str(version),
                 task_type=sql.TaskType.SBOM_AUGMENT,
                 primary_rel_path=file_path,
             )
@@ -276,8 +274,8 @@ async def _fetch_tasks(
         # Run or running scans for the current revision
         osv_tasks = (
             await data.task(
-                project_name=project,
-                version_name=version,
+                project_name=str(project),
+                version_name=str(version),
                 task_type=sql.TaskType.SBOM_OSV_SCAN,
                 primary_rel_path=file_path,
                 revision_number=release.latest_revision_number,
diff --git a/atr/get/start.py b/atr/get/start.py
index 7e33a0fb..950204d4 100644
--- a/atr/get/start.py
+++ b/atr/get/start.py
@@ -63,7 +63,7 @@ def _existing_releases(ul: htm.Block, releases: list[sql.Release], max_revisions
             htm.div(".text-nowrap")[
                 htm.span(class_="atr-phase-symbol fs-6")[phase_symbol],
                 " ",
-                release.version,
+                str(release.version),
             ]
         ]
 
diff --git a/atr/get/test.py b/atr/get/test.py
index bdd4370b..f480e6b2 100644
--- a/atr/get/test.py
+++ b/atr/get/test.py
@@ -98,30 +98,30 @@ async def test_merge(
         raise base.ASFQuartException("Test routes not enabled", errorcode=404)
 
     async with storage.write(session) as write_n:
-        wacp_n = await write_n.as_project_committee_participant(str(project_name))
+        wacp_n = await write_n.as_project_committee_participant(project_name)
 
         async def modify_new(path_new: pathlib.Path, _old_rev_new: sql.Revision | None) -> None:
             async with aiofiles.open(path_new / "from_new.txt", "w") as f:
                 await f.write("new content")
 
             async with storage.write(session) as write_p:
-                wacp_p = await write_p.as_project_committee_participant(str(project_name))
+                wacp_p = await write_p.as_project_committee_participant(project_name)
 
                 async def modify_prior(path_prior: pathlib.Path, _old_rev_prior: sql.Revision | None) -> None:
                     async with aiofiles.open(path_prior / "from_prior.txt", "w") as f:
                         await f.write("prior content")
 
                 await wacp_p.revision.create_revision_with_quarantine(
-                    str(project_name),
-                    str(version_name),
+                    project_name,
+                    version_name,
                     session.uid,
                     description="Test merge: prior revision",
                     modify=modify_prior,
                 )
 
         await wacp_n.revision.create_revision_with_quarantine(
-            str(project_name),
-            str(version_name),
+            project_name,
+            version_name,
             session.uid,
             description="Test merge: new revision",
             modify=modify_new,
@@ -129,8 +129,8 @@ async def test_merge(
 
     files: list[str] = []
     async with db.session() as data:
-        release_name = sql.release_name(str(project_name), str(version_name))
-        release = await data.release(name=release_name, _project=True).demand(
+        release_name = sql.release_name(project_name, version_name)
+        release = await data.release(name=str(release_name), _project=True).demand(
             RuntimeError("Release not found after merge test")
         )
         release_dir = paths.release_directory(release)
@@ -232,7 +232,7 @@ async def test_vote(
     if (user_category != vote.UserCategory.UNAUTHENTICATED) and (session is None):
         raise base.ASFQuartException("You must be logged in to preview authenticated views", errorcode=401)
 
-    _, release, latest_vote_task = await vote.category_and_release(session, str(project_name), str(version_name))
+    _, release, latest_vote_task = await vote.category_and_release(session, project_name, version_name)
 
     if release.phase != sql.ReleasePhase.RELEASE_CANDIDATE:
         raise base.ASFQuartException("Release is not a candidate", errorcode=404)
diff --git a/atr/get/upload.py b/atr/get/upload.py
index e8aaacb1..eec7aad8 100644
--- a/atr/get/upload.py
+++ b/atr/get/upload.py
@@ -49,7 +49,7 @@ async def selected(
     """
     await session.check_access(project_name)
     async with db.session() as data:
-        release = await session.release(str(project_name), str(version_name), data=data)
+        release = await session.release(project_name, version_name, data=data)
         user_ssh_keys = await data.ssh_key(asf_uid=session.uid).all()
 
     block = htm.Block()
@@ -65,7 +65,7 @@ async def selected(
         "Upload to ",
         htm.strong[release.project.short_display_name],
         " ",
-        htm.em[release.version],
+        htm.em[str(release.version)],
     ]
 
     block.p[
diff --git a/atr/get/vote.py b/atr/get/vote.py
index 22890514..636ba1c1 100644
--- a/atr/get/vote.py
+++ b/atr/get/vote.py
@@ -59,12 +59,12 @@ class UserCategory(enum.StrEnum):
 
 
 async def category_and_release(
-    session: web.Committer | None, project_name: str, version_name: str
+    session: web.Committer | None, project_name: safe.ProjectName, version_name: safe.VersionName
 ) -> tuple[UserCategory, sql.Release, sql.Task | None]:
     async with db.session() as data:
         release = await data.release(
-            project_name=project_name,
-            version=version_name,
+            project_name=str(project_name),
+            version=str(version_name),
             _committee=True,
             _project_release_policy=True,
         ).demand(base.ASFQuartException("Release does not exist", errorcode=404))
@@ -136,7 +136,7 @@ async def render_vote_closed_page(release: sql.Release) -> str:
         "Vote closed for ",
         htm.strong[release.project.short_display_name],
         " ",
-        htm.em[release.version],
+        htm.em[str(release.version)],
     ]
 
     phase_messages = {
@@ -183,7 +183,7 @@ async def selected(
     URL: /vote/<project_name>/<version_name>
     Show voting options for a release candidate.
     """
-    user_category, release, latest_vote_task = await category_and_release(session, str(project_name), str(version_name))
+    user_category, release, latest_vote_task = await category_and_release(session, project_name, version_name)
 
     if release.phase != sql.ReleasePhase.RELEASE_CANDIDATE:
         if session is None:
@@ -324,7 +324,7 @@ def _render_header(page: htm.Block, release: sql.Release, show_resolve_section:
         "Vote on ",
         htm.strong[release.project.short_display_name],
         " ",
-        htm.em[release.version],
+        htm.em[str(release.version)],
     ]
 
     if release.committee is None:
diff --git a/atr/get/voting.py b/atr/get/voting.py
index 8c72cac8..a92c496d 100644
--- a/atr/get/voting.py
+++ b/atr/get/voting.py
@@ -55,7 +55,7 @@ async def selected_revision(
     await session.check_access(project_name)
     async with db.session() as data:
         match await interaction.release_ready_for_vote(
-            session, str(project_name), str(version_name), revision, data, manual_vote=False
+            session, project_name, version_name, revision, data, manual_vote=False
         ):
             case str() as error:
                 return await session.redirect(
@@ -74,15 +74,15 @@ async def selected_revision(
         if release.release_policy and (release.release_policy.min_hours is not None):
             min_hours = release.release_policy.min_hours
 
-        default_subject_template = await construct.start_vote_subject_default(str(project_name))
-        default_body_template = await construct.start_vote_default(str(project_name))
+        default_subject_template = await construct.start_vote_subject_default(project_name)
+        default_body_template = await construct.start_vote_default(project_name)
         subject_template_hash = construct.template_hash(default_subject_template)
 
         options = construct.StartVoteOptions(
             asfuid=session.uid,
             fullname=session.fullname,
-            project_name=str(project_name),
-            version_name=release.version,
+            project_name=project_name,
+            version_name=release.safe_version_name,
             revision_number=revision,
             vote_duration=min_hours,
         )
diff --git a/atr/merge.py b/atr/merge.py
index 68793eb1..81ddc81a 100644
--- a/atr/merge.py
+++ b/atr/merge.py
@@ -25,6 +25,7 @@ import aiofiles.os
 
 import atr.attestable as attestable
 import atr.hashes as hashes
+import atr.models.safe as safe
 import atr.util as util
 
 if TYPE_CHECKING:
@@ -35,8 +36,8 @@ async def merge(
     base_inodes: dict[str, int],
     base_hashes: dict[str, str],
     prior_dir: pathlib.Path,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     prior_revision_number: str,
     temp_dir: pathlib.Path,
     n_inodes: dict[str, int],
@@ -119,8 +120,8 @@ async def _add_from_prior(
     n_hashes: dict[str, str],
     n_sizes: dict[str, int],
     prior_hashes: dict[str, str] | None,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     prior_revision_number: str,
 ) -> dict[str, str] | None:
     target = temp_dir / path
@@ -176,8 +177,8 @@ async def _merge_all_present(
     n_hashes: dict[str, str],
     n_sizes: dict[str, int],
     prior_hashes: dict[str, str] | None,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     prior_revision_number: str,
 ) -> dict[str, str] | None:
     # Cases 6, 8: prior and new share an inode so they already agree
@@ -237,8 +238,8 @@ async def _replace_with_prior(
     n_hashes: dict[str, str],
     n_sizes: dict[str, int],
     prior_hashes: dict[str, str] | None,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     prior_revision_number: str,
 ) -> dict[str, str] | None:
     await aiofiles.os.remove(temp_dir / path)
diff --git a/atr/models/__init__.py b/atr/models/__init__.py
index 0eea22ce..20d8698e 100644
--- a/atr/models/__init__.py
+++ b/atr/models/__init__.py
@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from . import api, basic, distribution, github, helpers, results, schema, session, sql, tabulate, validation
+from . import api, basic, distribution, github, helpers, results, safe, schema, session, sql, tabulate, validation
 
 # If we use .__name__, pyright gives a warning
 __all__ = [
@@ -25,6 +25,7 @@ __all__ = [
     "github",
     "helpers",
     "results",
+    "safe",
     "schema",
     "session",
     "sql",
diff --git a/atr/models/api.py b/atr/models/api.py
index 9464a636..9d553b68 100644
--- a/atr/models/api.py
+++ b/atr/models/api.py
@@ -21,7 +21,7 @@ from typing import Annotated, Any, Literal, TypeVar
 
 import pydantic
 
-from . import schema, sql, tabulate, validation
+from . import safe, schema, sql, tabulate, validation
 
 T = TypeVar("T")
 
@@ -73,14 +73,14 @@ class DistributeSshRegisterArgs(schema.Strict):
     ssh_key: str = schema.example("ssh-ed25519 AAAAC3NzaC1lZDI1NTEgH5C9okWi0dh25AAAAIOMqqnkVzrm0SdG6UOoqKLsabl9GKJl")
     phase: str = schema.Field(strict=False, default="compose", json_schema_extra={"examples": ["compose", "finish"]})
     asf_uid: str = schema.example("user")
-    project_name: str = schema.example("tooling")
-    version: str = schema.example("0.0.1")
+    project_name: safe.ProjectName = schema.example("tooling")
+    version: safe.VersionName = schema.example("0.0.1")
 
 
 class DistributeSshRegisterResults(schema.Strict):
     endpoint: Literal["/distribute/ssh/register"] = schema.alias("endpoint")
     fingerprint: str = schema.example("SHA256:0123456789abcdef0123456789abcdef01234567")
-    project: str = schema.example("example")
+    project: safe.ProjectName = schema.example("example")
     expires: int = schema.example(1713547200)
 
 
@@ -89,7 +89,7 @@ class DistributeStatusUpdateArgs(schema.Strict):
     jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
     workflow: str = schema.description("Workflow name")
     run_id: str = schema.description("Workflow run ID")
-    project_name: str = schema.description("Project name in ATR")
+    project_name: safe.ProjectName = schema.description("Project name in ATR")
     status: str = schema.description("Workflow status")
     message: str = schema.description("Workflow message")
 
@@ -100,8 +100,8 @@ class DistributeStatusUpdateResults(schema.Strict):
 
 
 class DistributionRecordArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
     platform: sql.DistributionPlatform = schema.example(sql.DistributionPlatform.ARTIFACT_HUB)
     distribution_owner_namespace: str | None = schema.default_example(None, "example")
     distribution_package: str = schema.example("example")
@@ -128,8 +128,8 @@ class DistributionRecordFromWorkflowArgs(schema.Strict):
     asf_uid: str = schema.example("user")
     publisher: str = schema.example("user")
     jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
     platform: sql.DistributionPlatform = schema.example(sql.DistributionPlatform.ARTIFACT_HUB)
     distribution_owner_namespace: str | None = schema.default_example(None, "example")
     distribution_package: str = schema.example("example")
@@ -164,7 +164,7 @@ class DistributionRecordResults(schema.Strict):
 
 
 class IgnoreAddArgs(schema.Strict):
-    project_name: str = schema.example("example")
+    project_name: safe.ProjectName = schema.example("example")
     release_glob: str | None = schema.default_example(None, "example-0.0.*")
     revision_number: str | None = schema.default_example(None, "00001")
     checker_glob: str | None = schema.default_example(None, "atr.tasks.checks.license.files")
@@ -194,7 +194,7 @@ class IgnoreAddResults(schema.Strict):
 
 
 class IgnoreDeleteArgs(schema.Strict):
-    project_name: str = schema.example("example")
+    project_name: safe.ProjectName = schema.example("example")
     id: int = schema.example(1)
 
 
@@ -289,7 +289,7 @@ class ProjectGetResults(schema.Strict):
 
 class ProjectPolicyResults(schema.Strict):
     endpoint: Literal["/project/policy"] = schema.alias("endpoint")
-    project_name: str
+    project_name: safe.ProjectName
     policy_announce_release_subject: str
     policy_announce_release_template: str
     policy_binary_artifact_paths: list[str]
@@ -325,7 +325,7 @@ class ProjectsListResults(schema.Strict):
 class PublisherDistributionRecordArgs(schema.Strict):
     publisher: str = schema.example("user")
     jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
-    version: str = schema.example("0.0.1")
+    version: safe.VersionName = schema.example("0.0.1")
     platform: sql.DistributionPlatform = schema.example(sql.DistributionPlatform.ARTIFACT_HUB)
     distribution_owner_namespace: str | None = schema.default_example(None, "example")
     distribution_package: str = schema.example("example")
@@ -356,7 +356,7 @@ class PublisherDistributionRecordResults(schema.Strict):
 class PublisherReleaseAnnounceArgs(schema.Strict):
     publisher: str = schema.example("user")
     jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
-    version: str = schema.example("0.0.1")
+    version: safe.VersionName = schema.example("0.0.1")
     revision: str = schema.example("00005")
     email_to: str = schema.example("dev@example.apache.org")
     body: str = schema.example("The Apache Example team is pleased to announce the release of Example 1.0.0...")
@@ -377,14 +377,14 @@ class PublisherSshRegisterArgs(schema.Strict):
 class PublisherSshRegisterResults(schema.Strict):
     endpoint: Literal["/publisher/ssh/register"] = schema.alias("endpoint")
     fingerprint: str = schema.example("SHA256:0123456789abcdef0123456789abcdef01234567")
-    project: str = schema.example("example")
+    project: safe.ProjectName = schema.example("example")
     expires: int = schema.example(1713547200)
 
 
 class PublisherVoteResolveArgs(schema.Strict):
     publisher: str = schema.example("user")
     jwt: str = schema.example("eyJhbGciOiJIUzI1[...]mMjLiuyu5CSpyHI=")
-    version: str = schema.example("0.0.1")
+    version: safe.VersionName = schema.example("0.0.1")
     resolution: Literal["passed", "failed"] = schema.example("passed")
 
 
@@ -394,8 +394,8 @@ class PublisherVoteResolveResults(schema.Strict):
 
 
 class ReleaseAnnounceArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("1.0.0")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("1.0.0")
     revision: str = schema.example("00005")
     email_to: str = schema.example("dev@example.apache.org")
     body: str = schema.example("The Apache Example team is pleased to announce the release of Example 1.0.0...")
@@ -408,8 +408,8 @@ class ReleaseAnnounceResults(schema.Strict):
 
 
 class ReleaseDraftDeleteArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
 
 
 class ReleaseDraftDeleteResults(schema.Strict):
@@ -418,7 +418,7 @@ class ReleaseDraftDeleteResults(schema.Strict):
 
 
 class ReleaseCreateArgs(schema.Strict):
-    project: str = schema.example("example")
+    project: safe.ProjectName = schema.example("example")
     version: str = schema.example("0.0.1")
 
 
@@ -428,8 +428,8 @@ class ReleaseCreateResults(schema.Strict):
 
 
 class ReleaseDeleteArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
 
 
 class ReleaseDeleteResults(schema.Strict):
@@ -466,8 +466,8 @@ class ReleaseRevisionsResults(schema.Strict):
 
 
 class ReleaseUploadArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
     relpath: str = schema.example("example/0.0.1/example-0.0.1-bin.tar.gz")
     content: str = schema.example("This is the content of the file.")
 
@@ -568,8 +568,8 @@ class UsersListResults(schema.Strict):
 
 
 class VoteResolveArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
     resolution: Literal["passed", "failed"] = schema.example("passed")
 
 
@@ -579,8 +579,8 @@ class VoteResolveResults(schema.Strict):
 
 
 class VoteStartArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
     revision: str = schema.example("00005")
     email_to: str = schema.example("dev@example.apache.org")
     vote_duration: int = schema.example(10)
@@ -594,8 +594,8 @@ class VoteStartResults(schema.Strict):
 
 
 class VoteTabulateArgs(schema.Strict):
-    project: str = schema.example("example")
-    version: str = schema.example("0.0.1")
+    project: safe.ProjectName = schema.example("example")
+    version: safe.VersionName = schema.example("0.0.1")
 
 
 class VoteTabulateResults(schema.Strict):
diff --git a/atr/models/results.py b/atr/models/results.py
index eeb73b93..a2576b5e 100644
--- a/atr/models/results.py
+++ b/atr/models/results.py
@@ -19,7 +19,7 @@ from typing import Annotated, Any, Literal
 
 import pydantic
 
-from . import schema
+from . import safe, schema
 
 
 class DistributionStatusCheck(schema.Strict):
@@ -105,8 +105,8 @@ class OSVComponent(schema.Strict):
 
 class SBOMOSVScan(schema.Strict):
     kind: Literal["sbom_osv_scan"] = schema.Field(alias="kind")
-    project_name: str = schema.description("Project name")
-    version_name: str = schema.description("Version name")
+    project_name: safe.ProjectName = schema.description("Project name")
+    version_name: safe.VersionName = schema.description("Version name")
     revision_number: str = schema.description("Revision number")
     bom_version: int | None = schema.Field(
         default=None, strict=False, description="BOM Version produced with scan results"
@@ -165,8 +165,8 @@ class SBOMAugment(schema.Strict):
 
 class SBOMQsScore(schema.Strict):
     kind: Literal["sbom_qs_score"] = schema.Field(alias="kind")
-    project_name: str = schema.description("Project name")
-    version_name: str = schema.description("Version name")
+    project_name: safe.ProjectName = schema.description("Project name")
+    version_name: safe.VersionName = schema.description("Version name")
     revision_number: str = schema.description("Revision number")
     file_path: str = schema.description("Relative path to the scored SBOM file")
     report: SbomQsReport
@@ -174,8 +174,8 @@ class SBOMQsScore(schema.Strict):
 
 class SBOMToolScore(schema.Strict):
     kind: Literal["sbom_tool_score"] = schema.Field(alias="kind")
-    project_name: str = schema.description("Project name")
-    version_name: str = schema.description("Version name")
+    project_name: safe.ProjectName = schema.description("Project name")
+    version_name: safe.VersionName = schema.description("Version name")
     revision_number: str = schema.description("Revision number")
     bom_version: int | None = schema.Field(default=None, strict=False, description="BOM Version scanned")
     prev_bom_version: int | None = schema.Field(
diff --git a/atr/models/safe.py b/atr/models/safe.py
index c6f9893b..d07ba289 100644
--- a/atr/models/safe.py
+++ b/atr/models/safe.py
@@ -15,6 +15,15 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from __future__ import annotations
+
+from typing import Any
+
+import atr.cache as cache
+import atr.db as db
+
+# TODO: I think we should probably add some standard syntactic validations to all of the safe types too, like completely disallowing U+0000 and other control characters, requiring NFC, disallowing markup characters, and so on. Then we can rely on those when we handle safe types anywhere.
+
 
 class ProjectName:
     """A project name that has been validated against the cache or database."""
@@ -24,6 +33,15 @@ class ProjectName:
     def __init__(self, value: str) -> None:
         self._value = value
 
+    @classmethod
+    async def create(cls, value: str) -> ProjectName | None:
+        if not cache.project_version_has_project(value):
+            async with db.session() as data:
+                project = await data.project(name=value).get()
+            if project is None:
+                return None
+        return cls(value)
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, ProjectName):
             return self._value == other._value
@@ -38,6 +56,47 @@ class ProjectName:
     def __str__(self) -> str:
         return self._value
 
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> Any:
+        import pydantic_core.core_schema as core_schema
+
+        return core_schema.no_info_plain_validator_function(
+            lambda v: cls(v) if isinstance(v, str) else v,
+            serialization=core_schema.to_string_ser_schema(),
+        )
+
+
+class ReleaseName:
+    """A release name composed from a validated ProjectName and VersionName."""
+
+    __slots__ = ("_value",)
+
+    def __init__(self, value: str) -> None:
+        self._value = value
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, ReleaseName):
+            return self._value == other._value
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self._value)
+
+    def __repr__(self) -> str:
+        return f"ReleaseName({self._value!r})"
+
+    def __str__(self) -> str:
+        return self._value
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> Any:
+        import pydantic_core.core_schema as core_schema
+
+        return core_schema.no_info_plain_validator_function(
+            lambda v: cls(v) if isinstance(v, str) else v,
+            serialization=core_schema.to_string_ser_schema(),
+        )
+
 
 class VersionName:
     """A version name that has been validated against the cache or database."""
@@ -47,6 +106,22 @@ class VersionName:
     def __init__(self, value: str) -> None:
         self._value = value
 
+    @classmethod
+    async def create(
+        cls,
+        value: str,
+        project: ProjectName,
+    ) -> VersionName | None:
+        if not cache.project_version_has_version(project, value):
+            async with db.session() as data:
+                release = await data.release(
+                    project_name=str(project),
+                    version=value,
+                ).get()
+            if release is None:
+                return None
+        return cls(value)
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, VersionName):
             return self._value == other._value
@@ -60,3 +135,12 @@ class VersionName:
 
     def __str__(self) -> str:
         return self._value
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> Any:
+        import pydantic_core.core_schema as core_schema
+
+        return core_schema.no_info_plain_validator_function(
+            lambda v: cls(v) if isinstance(v, str) else v,
+            serialization=core_schema.to_string_ser_schema(),
+        )
diff --git a/atr/models/sql.py b/atr/models/sql.py
index cbb875b8..36e49baa 100644
--- a/atr/models/sql.py
+++ b/atr/models/sql.py
@@ -24,7 +24,7 @@
 import dataclasses
 import datetime
 import enum
-from typing import Any, Final, Literal, Optional, TypeVar
+from typing import Any, Final, Literal, Optional, TypeVar, overload
 
 import pydantic
 import sqlalchemy
@@ -34,7 +34,7 @@ import sqlalchemy.orm as orm
 import sqlalchemy.sql.expression as expression
 import sqlmodel
 
-from . import results, schema
+from . import results, safe, schema
 
 T = TypeVar("T")
 
@@ -264,6 +264,49 @@ class VoteEntry(schema.Strict):
 # Type decorators
 # TODO: Possibly move these to a separate module
 # That way, we can more easily track Alembic's dependence on them
+class SafeProjectName(sqlalchemy.types.TypeDecorator):
+    impl = sqlalchemy.types.String
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        return str(value)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        return safe.ProjectName(value)
+
+
+class SafeReleaseName(sqlalchemy.types.TypeDecorator):
+    impl = sqlalchemy.types.String
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        return str(value)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        return safe.ReleaseName(value)
+
+
+class SafeVersionName(sqlalchemy.types.TypeDecorator):
+    impl = sqlalchemy.types.String
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        return str(value)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        return safe.VersionName(value)
 
 
 class UTCDateTime(sqlalchemy.types.TypeDecorator):
@@ -549,7 +592,7 @@ def see_also(arg: Any) -> None:
 class Project(sqlmodel.SQLModel, table=True):
     # TODO: Consider using key or label for primary string keys
     # Then we can use simply "name" for full_name, and make it str rather than str | None
-    name: str = sqlmodel.Field(unique=True, primary_key=True, **example("example"))
+    name: str = sqlmodel.Field(primary_key=True, unique=True, **example("example"))
     # TODO: Ideally full_name would be unique for str only, but that's complex
     # We always include "Apache" in the full_name
     full_name: str | None = sqlmodel.Field(default=None, **example("Apache Example"))
@@ -598,11 +641,16 @@ class Project(sqlmodel.SQLModel, table=True):
     @property
     def display_name(self) -> str:
         """Get the display name for the Project."""
-        base = self.full_name or self.name
+        base = self.full_name or str(self.name)
         if self.committee and self.committee.is_podling:
             return f"{base} (Incubating)"
         return base
 
+    @property
+    def safe_name(self) -> safe.ProjectName:
+        """Get the typesafe validated name for the Project"""
+        return safe.ProjectName(self.name)
+
     @property
     def short_display_name(self) -> str:
         """Get the short display name for the Project."""
@@ -917,6 +965,21 @@ class Release(sqlmodel.SQLModel, table=True):
         #     return None
         return project.committee
 
+    @property
+    def safe_name(self) -> safe.ReleaseName:
+        """Get the typesafe validated name for the Release"""
+        return safe.ReleaseName(self.name)
+
+    @property
+    def safe_project_name(self) -> safe.ProjectName:
+        """Get the typesafe validated name for the release project"""
+        return safe.ProjectName(self.project_name)
+
+    @property
+    def safe_version_name(self) -> safe.VersionName:
+        """Get the typesafe validated name for the release version"""
+        return safe.VersionName(self.project_name)
+
     @property
     def short_display_name(self) -> str:
         """Get the short display name for the release."""
@@ -1023,7 +1086,7 @@ class CheckResultIgnore(sqlmodel.SQLModel, table=True):
 
 # Distribution: Release
 class Distribution(sqlmodel.SQLModel, table=True):
-    release_name: str = sqlmodel.Field(primary_key=True, index=True, foreign_key="release.name", ondelete="CASCADE")
+    release_name: str = sqlmodel.Field(foreign_key="release.name", ondelete="CASCADE", primary_key=True, index=True)
     release: Release = sqlmodel.Relationship(back_populates="distributions")
     platform: DistributionPlatform = sqlmodel.Field(primary_key=True, index=True)
     owner_namespace: str = sqlmodel.Field(primary_key=True, index=True, default="")
@@ -1050,6 +1113,11 @@ class Distribution(sqlmodel.SQLModel, table=True):
         version = normal(self.version)
         return f"{name}-{package}-{version}"
 
+    @property
+    def safe_release_name(self) -> safe.ReleaseName:
+        """Get the typesafe validated name for the distribution release"""
+        return safe.ReleaseName(self.release_name)
+
     @property
     def title(self) -> str:
         return f"{self.platform.value.name} {self.package} {self.version}"
@@ -1314,7 +1382,7 @@ class WorkflowStatus(sqlmodel.SQLModel, table=True):
     message: str | None = sqlmodel.Field(default=None)
 
 
-def revision_name(release_name: str, number: str) -> str:
+def revision_name(release_name: safe.ReleaseName | str, number: str) -> str:
     return f"{release_name} {number}"
 
 
@@ -1385,9 +1453,20 @@ def latest_revision_number_query(release_name: str | None = None) -> expression.
     )
 
 
-def release_name(project_name: str, version_name: str) -> str:
+@overload
+def release_name(project_name: safe.ProjectName, version_name: safe.VersionName) -> safe.ReleaseName: ...
+
+
+@overload
+def release_name(project_name: str, version_name: str) -> str: ...
+
+
+def release_name(project_name: safe.ProjectName | str, version_name: safe.VersionName | str) -> safe.ReleaseName | str:
     """Return the release name for a given project and version."""
-    return f"{project_name}-{version_name}"
+    name = f"{project_name}-{version_name}"
+    if isinstance(project_name, safe.ProjectName) and isinstance(version_name, safe.VersionName):
+        return safe.ReleaseName(name)
+    return name
 
 
 def validate_instrumented_attribute(obj: Any) -> orm.InstrumentedAttribute:
diff --git a/atr/paths.py b/atr/paths.py
index 2c089e26..ff6b2b06 100644
--- a/atr/paths.py
+++ b/atr/paths.py
@@ -17,12 +17,15 @@
 
 import pathlib
 
-from atr import config as config
-from atr.models import sql as sql
+import atr.config as config
+import atr.models.safe as safe
+import atr.models.sql as sql
 
 
-def base_path_for_revision(project_name: str, version_name: str, revision: str) -> pathlib.Path:
-    return pathlib.Path(get_unfinished_dir(), project_name, version_name, revision)
+def base_path_for_revision(
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision: str
+) -> pathlib.Path:
+    return pathlib.Path(get_unfinished_dir(), str(project_name), str(version_name), revision)
 
 
 def get_attestable_dir() -> pathlib.Path:
@@ -64,7 +67,7 @@ def quarantine_directory(quarantined: sql.Quarantined) -> pathlib.Path:
     if not quarantined.token.isalnum():
         raise ValueError("Invalid quarantine token")
     release = quarantined.release
-    return get_quarantined_dir() / release.project_name / release.version / quarantined.token
+    return get_quarantined_dir() / str(release.project_name) / str(release.version) / quarantined.token
 
 
 def release_directory(release: sql.Release) -> pathlib.Path:
@@ -92,7 +95,7 @@ def release_directory_base(release: sql.Release) -> pathlib.Path:
         case sql.ReleasePhase.RELEASE:
             base_dir = get_finished_dir()
         # Do not add "case _" here
-    return base_dir / project_name / version_name
+    return base_dir / str(project_name) / str(version_name)
 
 
 def release_directory_revision(release: sql.Release) -> pathlib.Path | None:
@@ -107,9 +110,9 @@ def release_directory_revision(release: sql.Release) -> pathlib.Path | None:
         ):
             if (path_revision := release.latest_revision_number) is None:
                 return None
-            path = get_unfinished_dir() / path_project / path_version / path_revision
+            path = get_unfinished_dir() / str(path_project) / str(path_version) / path_revision
         case sql.ReleasePhase.RELEASE:
-            path = get_finished_dir() / path_project / path_version
+            path = get_finished_dir() / str(path_project) / str(path_version)
         # Do not add "case _" here
     return path
 
@@ -124,12 +127,14 @@ def release_directory_version(release: sql.Release) -> pathlib.Path:
             | sql.ReleasePhase.RELEASE_CANDIDATE
             | sql.ReleasePhase.RELEASE_PREVIEW
         ):
-            path = get_unfinished_dir() / path_project / path_version
+            path = get_unfinished_dir() / str(path_project) / str(path_version)
         case sql.ReleasePhase.RELEASE:
-            path = get_finished_dir() / path_project / path_version
+            path = get_finished_dir() / str(path_project) / str(path_version)
         # Do not add "case _" here
     return path
 
 
-def revision_path_for_file(project_name: str, version_name: str, revision: str, file_name: str) -> pathlib.Path:
+def revision_path_for_file(
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision: str, file_name: str
+) -> pathlib.Path:
     return base_path_for_revision(project_name, version_name, revision) / file_name
diff --git a/atr/post/announce.py b/atr/post/announce.py
index 417c0dd6..f988b40a 100644
--- a/atr/post/announce.py
+++ b/atr/post/announce.py
@@ -53,8 +53,8 @@ async def selected(
 
     # Get the release to find the revision number
     release = await session.release(
-        str(project_name),
-        str(version_name),
+        project_name,
+        version_name,
         with_committee=True,
         phase=sql.ReleasePhase.RELEASE_PREVIEW,
         with_distributions=True,
@@ -92,7 +92,7 @@ async def selected(
             )
 
     # Validate that the subject template hasn't changed
-    subject_template = await construct.announce_release_subject_default(str(project_name))
+    subject_template = await construct.announce_release_subject_default(project_name)
     current_hash = construct.template_hash(subject_template)
     if current_hash != announce_form.subject_template_hash:
         return await session.form_error(
@@ -101,10 +101,10 @@ async def selected(
         )
 
     try:
-        async with storage.write_as_project_committee_member(str(project_name), session) as wacm:
+        async with storage.write_as_project_committee_member(project_name, session) as wacm:
             await wacm.announce.release(
-                project_name=str(project_name),
-                version_name=str(version_name),
+                project_name=project_name,
+                version_name=version_name,
                 preview_revision_number=preview_revision_number,
                 recipient=announce_form.mailing_list,
                 body=announce_form.body,
diff --git a/atr/post/distribution.py b/atr/post/distribution.py
index 3e4f0b5a..01f847ca 100644
--- a/atr/post/distribution.py
+++ b/atr/post/distribution.py
@@ -41,8 +41,8 @@ _AUTOMATED_PLATFORMS_STAGE: Final[tuple[shared.distribution.DistributionPlatform
 async def automate_form_process_page(
     session: web.Committer,
     form_data: shared.distribution.DistributeForm,
-    project: str,
-    version: str,
+    project: safe.ProjectName,
+    version: safe.VersionName,
     /,
     staging: bool = False,
 ) -> web.WerkzeugResponse:
@@ -51,8 +51,8 @@ async def automate_form_process_page(
         platform_str = form_data.platform.value
         return await session.redirect(
             get.distribution.stage_automate if staging else get.distribution.automate,
-            project_name=project,
-            version_name=version,
+            project_name=str(project),
+            version_name=str(version),
             error=f"Platform {platform_str} is not supported for automated distribution",
         )
     sql_platform = form_data.platform.to_sql()  # type: ignore[attr-defined]
@@ -77,7 +77,7 @@ async def automate_form_process_page(
     async with storage.write_as_committee_member(committee_name=committee.name) as w:
         try:
             await w.distributions.automate(
-                release.name,
+                release.safe_name,
                 dd.platform,
                 committee.name,
                 dd.owner_namespace,
@@ -120,9 +120,7 @@ async def automate_selected(
     URL: /distribution/automate/<project_name>/<version_name>
     """
     await session.check_access(project_name)
-    return await automate_form_process_page(
-        session, distribute_form, str(project_name), str(version_name), staging=False
-    )
+    return await automate_form_process_page(session, distribute_form, project_name, version_name, staging=False)
 
 
 @post.typed
@@ -141,7 +139,7 @@ async def delete(
 
     # Validate the submitted data, and obtain the committee for its name
     async with db.session() as data:
-        release = await data.release(name=delete_form.release_name).demand(
+        release = await data.release(name=str(delete_form.release_name)).demand(
             RuntimeError(f"Release {delete_form.release_name} not found")
         )
         committee = release.committee
@@ -168,8 +166,8 @@ async def delete(
 async def record_form_process_page(
     session: web.Committer,
     form_data: shared.distribution.DistributeForm,
-    project: str,
-    version: str,
+    project: safe.ProjectName,
+    version: safe.VersionName,
     /,
     staging: bool = False,
 ) -> web.WerkzeugResponse:
@@ -190,7 +188,7 @@ async def record_form_process_page(
     async with storage.write_as_committee_member(committee_name=committee.name) as w:
         try:
             _dist, added, _metadata = await w.distributions.record_from_data(
-                release_name=release.name,
+                release_name=release.safe_name,
                 staging=staging,
                 dd=dd,
                 allow_retries=False,
@@ -199,8 +197,8 @@ async def record_form_process_page(
             # Instead of calling record_form_page_new, redirect with error message
             return await session.redirect(
                 get.distribution.stage_record if staging else get.distribution.record,
-                project_name=project,
-                version_name=version,
+                project_name=str(project),
+                version_name=str(version),
                 error=str(e),
             )
 
@@ -208,8 +206,8 @@ async def record_form_process_page(
     message = "Distribution recorded successfully." if added else "Distribution was already recorded."
     return await session.redirect(
         get.distribution.list_get,
-        project_name=project,
-        version_name=version,
+        project_name=str(project),
+        version_name=str(version),
         success=message,
     )
 
@@ -225,7 +223,7 @@ async def record_selected(
     """
     URL: /distribution/record/<project_name>/<version_name>
     """
-    return await record_form_process_page(session, distribute_form, str(project_name), str(version_name), staging=False)
+    return await record_form_process_page(session, distribute_form, project_name, version_name, staging=False)
 
 
 @post.typed
@@ -239,9 +237,7 @@ async def stage_automate_selected(
     """
     URL: /distribution/stage/automate/<project_name>/<version_name>
     """
-    return await automate_form_process_page(
-        session, distribute_form, str(project_name), str(version_name), staging=True
-    )
+    return await automate_form_process_page(session, distribute_form, project_name, version_name, staging=True)
 
 
 @post.typed
@@ -255,4 +251,4 @@ async def stage_record_selected(
     """
     URL: /distribution/stage/record/<project_name>/<version_name>
     """
-    return await record_form_process_page(session, distribute_form, str(project_name), str(version_name), staging=True)
+    return await record_form_process_page(session, distribute_form, project_name, version_name, staging=True)
diff --git a/atr/post/draft.py b/atr/post/draft.py
index 533b5242..a47ccddf 100644
--- a/atr/post/draft.py
+++ b/atr/post/draft.py
@@ -57,10 +57,10 @@ async def cache_reset(
 
     description = "Empty revision to restart all checks without cache for the whole release candidate draft"
     async with storage.write(session) as write:
-        wacp = await write.as_project_committee_participant(str(project_name))
+        wacp = await write.as_project_committee_participant(project_name)
         result = await wacp.revision.create_revision_with_quarantine(
-            str(project_name),
-            str(version_name),
+            project_name,
+            version_name,
             session.uid,
             description=description,
             reset_to_global_cache=True,
@@ -91,10 +91,10 @@ async def delete(
     """
     # Delete the metadata from the database
     async with storage.write(session) as write:
-        wacp = await write.as_project_committee_participant(str(project_name))
+        wacp = await write.as_project_committee_participant(project_name)
         error = await wacp.release.delete(
-            str(project_name),
-            str(version_name),
+            project_name,
+            version_name,
             phase=sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT,
             include_downloads=False,
         )
@@ -129,10 +129,8 @@ async def delete_file(
 
     try:
         async with storage.write(session) as write:
-            wacp = await write.as_project_committee_participant(str(project_name))
-            metadata_files_deleted = await wacp.release.delete_file(
-                str(project_name), str(version_name), rel_path_to_delete
-            )
+            wacp = await write.as_project_committee_participant(project_name)
+            metadata_files_deleted = await wacp.release.delete_file(project_name, version_name, rel_path_to_delete)
     except Exception as e:
         log.exception("Error deleting file:")
         await quart.flash(f"Error deleting file: {e!s}", "error")
@@ -170,8 +168,8 @@ async def hashgen(
 
     try:
         async with storage.write(session) as write:
-            wacp = await write.as_project_committee_participant(str(project_name))
-            await wacp.release.generate_hash_file(str(project_name), str(version_name), rel_path)
+            wacp = await write.as_project_committee_participant(project_name)
+            await wacp.release.generate_hash_file(project_name, version_name, rel_path)
 
     except Exception as e:
         log.exception("Error generating hash file:")
@@ -205,10 +203,10 @@ async def recheck(
 
     description = "Empty revision to restart all checks without cache for the whole release candidate draft"
     async with storage.write(session) as write:
-        wacp = await write.as_project_committee_participant(str(project_name))
+        wacp = await write.as_project_committee_participant(project_name)
         result = await wacp.revision.create_revision_with_quarantine(
-            str(project_name),
-            str(version_name),
+            project_name,
+            version_name,
             session.uid,
             description=description,
             set_local_cache=True,
@@ -259,7 +257,7 @@ async def sbomgen(
     try:
         description = "SBOM generation through web interface"
         async with storage.write(session) as write:
-            wacp = await write.as_project_committee_participant(str(project_name))
+            wacp = await write.as_project_committee_participant(project_name)
 
             async def modify(path: pathlib.Path, old_rev: sql.Revision | None) -> None:
                 path_in_new_revision = path / rel_path
@@ -281,8 +279,8 @@ async def sbomgen(
 
                 # Create and queue the task, using paths within the new revision
                 sbom_task = await wacp.sbom.generate_cyclonedx(
-                    str(project_name),
-                    str(version_name),
+                    project_name,
+                    version_name,
                     old_rev.number,
                     path_in_new_revision,
                     sbom_path_in_new_revision,
@@ -292,7 +290,7 @@ async def sbomgen(
                     raise web.FlashError("Internal error: SBOM generation timed out")
 
             result = await wacp.revision.create_revision_with_quarantine(
-                str(project_name), str(version_name), session.uid, description=description, modify=modify
+                project_name, version_name, session.uid, description=description, modify=modify
             )
 
     except Exception as e:
diff --git a/atr/post/finish.py b/atr/post/finish.py
index fa438c87..74c26a13 100644
--- a/atr/post/finish.py
+++ b/atr/post/finish.py
@@ -40,22 +40,22 @@ async def selected(
     URL: /finish/<project_name>/<version_name>
     """
     wants_json = quart.request.accept_mimetypes.best_match(["application/json", "text/html"]) == "application/json"
-    respond = _respond_helper(session, str(project_name), str(version_name), wants_json)
+    respond = _respond_helper(session, project_name, version_name, wants_json)
 
     match finish_form:
         case shared.finish.DeleteEmptyDirectoryForm() as delete_form:
-            return await _delete_empty_directory(delete_form, session, str(project_name), str(version_name), respond)
+            return await _delete_empty_directory(delete_form, session, project_name, version_name, respond)
         case shared.finish.MoveFileForm() as move_form:
-            return await _move_file_to_revision(move_form, session, str(project_name), str(version_name), respond)
+            return await _move_file_to_revision(move_form, session, project_name, version_name, respond)
         case shared.finish.RemoveRCTagsForm():
-            return await _remove_rc_tags(session, str(project_name), str(version_name), respond)
+            return await _remove_rc_tags(session, project_name, version_name, respond)
 
 
 async def _delete_empty_directory(
     delete_form: shared.finish.DeleteEmptyDirectoryForm,
     session: web.Committer,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     respond: shared.finish.Respond,
 ) -> tuple[web.QuartResponse, int] | web.WerkzeugResponse:
     dir_to_delete_rel = delete_form.directory_to_delete
@@ -77,8 +77,8 @@ async def _delete_empty_directory(
 async def _move_file_to_revision(
     move_form: shared.finish.MoveFileForm,
     session: web.Committer,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     respond: shared.finish.Respond,
 ) -> tuple[web.QuartResponse, int] | web.WerkzeugResponse:
     source_files_rel = move_form.source_files
@@ -122,8 +122,8 @@ async def _move_file_to_revision(
 
 async def _remove_rc_tags(
     session: web.Committer,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     respond: shared.finish.Respond,
 ) -> tuple[web.QuartResponse, int] | web.WerkzeugResponse:
     try:
@@ -154,7 +154,7 @@ async def _remove_rc_tags(
 
 
 def _respond_helper(
-    session: web.Committer, project_name: str, version_name: str, wants_json: bool
+    session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, wants_json: bool
 ) -> shared.finish.Respond:
     """Create a response helper function for the finish route."""
     import atr.get as get
@@ -167,6 +167,8 @@ def _respond_helper(
         if wants_json:
             return quart.jsonify(ok=ok, message=msg), http_status
         await quart.flash(msg, "success" if ok else "error")
-        return await session.redirect(get.finish.selected, project_name=project_name, version_name=version_name)
+        return await session.redirect(
+            get.finish.selected, project_name=str(project_name), version_name=str(version_name)
+        )
 
     return respond
diff --git a/atr/post/ignores.py b/atr/post/ignores.py
index 30c2a2f8..92f37734 100644
--- a/atr/post/ignores.py
+++ b/atr/post/ignores.py
@@ -40,17 +40,17 @@ async def ignores(
     await session.check_access(project_name)
     match ignore_form:
         case shared.ignores.AddIgnoreForm() as add_form:
-            return await _add_ignore(session, add_form, str(project_name))
+            return await _add_ignore(session, add_form, project_name)
 
         case shared.ignores.DeleteIgnoreForm() as delete_form:
-            return await _delete_ignore(session, delete_form, str(project_name))
+            return await _delete_ignore(session, delete_form, project_name)
 
         case shared.ignores.UpdateIgnoreForm() as update_form:
-            return await _update_ignore(session, update_form, str(project_name))
+            return await _update_ignore(session, update_form, project_name)
 
 
 async def _add_ignore(
-    session: web.Committer, add_form: shared.ignores.AddIgnoreForm, project_name: str
+    session: web.Committer, add_form: shared.ignores.AddIgnoreForm, project_name: safe.ProjectName
 ) -> web.WerkzeugResponse:
     """Add a new ignore."""
     status = shared.ignores.ignore_status_to_sql(add_form.status)  # pyright: ignore[reportArgumentType]
@@ -70,13 +70,13 @@ async def _add_ignore(
 
     return await session.redirect(
         get.ignores.ignores,
-        project_name=project_name,
+        project_name=str(project_name),
         success="Ignore added",
     )
 
 
 async def _delete_ignore(
-    session: web.Committer, delete_form: shared.ignores.DeleteIgnoreForm, project_name: str
+    session: web.Committer, delete_form: shared.ignores.DeleteIgnoreForm, project_name: safe.ProjectName
 ) -> web.WerkzeugResponse:
     """Delete an ignore."""
     async with storage.write() as write:
@@ -85,13 +85,13 @@ async def _delete_ignore(
 
     return await session.redirect(
         get.ignores.ignores,
-        project_name=project_name,
+        project_name=str(project_name),
         success="Ignore deleted",
     )
 
 
 async def _update_ignore(
-    session: web.Committer, update_form: shared.ignores.UpdateIgnoreForm, project_name: str
+    session: web.Committer, update_form: shared.ignores.UpdateIgnoreForm, project_name: safe.ProjectName
 ) -> web.WerkzeugResponse:
     """Update an ignore."""
     status = shared.ignores.ignore_status_to_sql(update_form.status)  # pyright: ignore[reportArgumentType]
@@ -111,6 +111,6 @@ async def _update_ignore(
 
     return await session.redirect(
         get.ignores.ignores,
-        project_name=project_name,
+        project_name=str(project_name),
         success="Ignore updated",
     )
diff --git a/atr/post/keys.py b/atr/post/keys.py
index 6a3939c4..58396458 100644
--- a/atr/post/keys.py
+++ b/atr/post/keys.py
@@ -151,8 +151,8 @@ async def import_selected_revision(
     """
     await session.check_access(project_name)
     async with storage.write() as write:
-        wacm = await write.as_project_committee_member(str(project_name))
-        outcomes: outcome.List[types.Key] = await wacm.keys.import_keys_file(str(project_name), str(version_name))
+        wacm = await write.as_project_committee_member(project_name)
+        outcomes: outcome.List[types.Key] = await wacm.keys.import_keys_file(project_name, version_name)
 
     message = f"Uploaded {util.plural(outcomes.result_count, 'key')}"
     if outcomes.error_count > 0:
diff --git a/atr/post/manual.py b/atr/post/manual.py
index 9d001a04..4fd8a06e 100644
--- a/atr/post/manual.py
+++ b/atr/post/manual.py
@@ -43,8 +43,8 @@ async def resolve_selected(
     Post the manual vote resolution page.
     """
     release = await session.release(
-        str(project_name),
-        str(version_name),
+        project_name,
+        version_name,
         phase=sql.ReleasePhase.RELEASE_CANDIDATE,
         with_release_policy=True,
         with_project_release_policy=True,
@@ -70,8 +70,8 @@ async def resolve_selected(
             vote_result = "failed"
             destination = get.compose.selected
 
-    async with storage.write_as_project_committee_member(str(project_name)) as wacm:
-        success_message = await wacm.vote.resolve_manually(str(project_name), str(version_name), vote_result)
+    async with storage.write_as_project_committee_member(project_name) as wacm:
+        success_message = await wacm.vote.resolve_manually(project_name, version_name, vote_result)
 
     return await session.redirect(
         destination,
@@ -96,7 +96,7 @@ async def start_selected_revision(
 
     async with db.session() as data:
         match await interaction.release_ready_for_vote(
-            session, str(project_name), str(version_name), revision, data, manual_vote=True
+            session, project_name, version_name, revision, data, manual_vote=True
         ):
             case str() as error:
                 return await session.redirect(
@@ -109,8 +109,8 @@ async def start_selected_revision(
                 pass
 
         async with storage.write(session) as write:
-            wacp = await write.as_project_committee_participant(release.project_name)
-            error = await wacp.release.promote_to_candidate(release.name, revision, vote_manual=True)
+            wacp = await write.as_project_committee_participant(release.safe_project_name)
+            error = await wacp.release.promote_to_candidate(release.safe_name, revision, vote_manual=True)
 
         if error:
             return await session.redirect(
diff --git a/atr/post/projects.py b/atr/post/projects.py
index 9a2295d7..68f9d878 100644
--- a/atr/post/projects.py
+++ b/atr/post/projects.py
@@ -25,6 +25,7 @@ import quart
 import atr.blueprints.post as post
 import atr.db as db
 import atr.get as get
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.shared as shared
 import atr.storage as storage
@@ -44,8 +45,9 @@ async def add_project(
     display_name = project_form.display_name
     label = project_form.label
 
+    # TODO: Is this right? Name is unvalidated
     async with storage.write(session) as write:
-        wacm = await write.as_project_committee_member(committee_name)
+        wacm = await write.as_project_committee_member(safe.ProjectName(committee_name))
         try:
             await wacm.project.create(committee_name, display_name, label)
         except storage.AccessError as e:
@@ -167,17 +169,17 @@ async def _process_add_category(
     async with storage.write(session) as write:
         wacm = await write.as_project_committee_member(project_name)
         async with db.session() as data:
-            project = await data.project(name=project_name).demand(
+            project = await data.project(name=str(project_name)).demand(
                 base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
             )
         modified = await _metadata_category_add(wacm, project, category_to_add)
 
     if modified:
         return await session.redirect(
-            get.projects.view, project_name=project_name, success=f"Category '{category_to_add}' added."
+            get.projects.view, project_name=str(project_name), success=f"Category '{category_to_add}' added."
         )
     return await session.redirect(
-        get.projects.view, project_name=project_name, error=f"Category '{category_to_add}' already exists."
+        get.projects.view, project_name=str(project_name), error=f"Category '{category_to_add}' already exists."
     )
 
 
@@ -190,17 +192,17 @@ async def _process_add_language(
     async with storage.write(session) as write:
         wacm = await write.as_project_committee_member(project_name)
         async with db.session() as data:
-            project = await data.project(name=project_name).demand(
+            project = await data.project(name=str(project_name)).demand(
                 base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
             )
         modified = await _metadata_language_add(wacm, project, language_to_add)
 
     if modified:
         return await session.redirect(
-            get.projects.view, project_name=project_name, success=f"Language '{language_to_add}' added."
+            get.projects.view, project_name=str(project_name), success=f"Language '{language_to_add}' added."
         )
     return await session.redirect(
-        get.projects.view, project_name=project_name, error=f"Language '{language_to_add}' already exists."
+        get.projects.view, project_name=str(project_name), error=f"Language '{language_to_add}' already exists."
     )
 
 
@@ -266,17 +268,17 @@ async def _process_remove_category(
     async with storage.write(session) as write:
         wacm = await write.as_project_committee_member(project_name)
         async with db.session() as data:
-            project = await data.project(name=project_name).demand(
+            project = await data.project(name=str(project_name)).demand(
                 base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
             )
         modified = await _metadata_category_remove(wacm, project, category_to_remove)
 
     if modified:
         return await session.redirect(
-            get.projects.view, project_name=project_name, success=f"Category '{category_to_remove}' removed."
+            get.projects.view, project_name=str(project_name), success=f"Category '{category_to_remove}' removed."
         )
     return await session.redirect(
-        get.projects.view, project_name=project_name, error=f"Category '{category_to_remove}' does not exist."
+        get.projects.view, project_name=str(project_name), error=f"Category '{category_to_remove}' does not exist."
     )
 
 
@@ -289,7 +291,7 @@ async def _process_remove_language(
     async with storage.write(session) as write:
         wacm = await write.as_project_committee_member(project_name)
         async with db.session() as data:
-            project = await data.project(name=project_name).demand(
+            project = await data.project(name=str(project_name)).demand(
                 base.ASFQuartException(f"Project {project_name} not found", errorcode=404)
             )
         modified = await _metadata_language_remove(wacm, project, language_to_remove)
diff --git a/atr/post/resolve.py b/atr/post/resolve.py
index a631f6f5..5ee74f9c 100644
--- a/atr/post/resolve.py
+++ b/atr/post/resolve.py
@@ -46,14 +46,17 @@ async def selected(
     """
     match resolve_form:
         case shared.resolve.SubmitForm() as submit_form:
-            return await _submit(session, submit_form, str(project_name), str(version_name))
+            return await _submit(session, submit_form, project_name, version_name)
 
         case shared.resolve.TabulateForm():
-            return await _tabulate(session, str(project_name), str(version_name))
+            return await _tabulate(session, project_name, version_name)
 
 
 async def _submit(
-    session: web.Committer, submit_form: shared.resolve.SubmitForm, project_name: str, version_name: str
+    session: web.Committer,
+    submit_form: shared.resolve.SubmitForm,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
 ) -> web.WerkzeugResponse:
     email_body = submit_form.email_body
     vote_result = submit_form.vote_result
@@ -78,11 +81,11 @@ async def _submit(
             destination = get.compose.selected
 
     return await session.redirect(
-        destination, project_name=project_name, version_name=version_name, success=success_message
+        destination, project_name=str(project_name), version_name=str(version_name), success=success_message
     )
 
 
-async def _tabulate(session: web.Committer, project_name: str, version_name: str) -> str:
+async def _tabulate(session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName) -> str:
     asf_uid = session.uid
     full_name = session.fullname
 
@@ -142,7 +145,7 @@ async def _tabulate(session: web.Committer, project_name: str, version_name: str
 
     resolve_form = atr.form.render(
         model_cls=shared.resolve.SubmitForm,
-        action=util.as_url(selected, project_name=release.project.name, version_name=release.version),
+        action=util.as_url(selected, project_name=str(release.project.name), version_name=str(release.version)),
         submit_label="Resolve vote",
         textarea_rows=24,
         defaults=defaults,
diff --git a/atr/post/revisions.py b/atr/post/revisions.py
index 72f6497d..a89a22ac 100644
--- a/atr/post/revisions.py
+++ b/atr/post/revisions.py
@@ -41,13 +41,16 @@ async def selected_post(
     """
     match revision_form:
         case shared.revisions.SetRevisionForm():
-            return await _set_revision(session, revision_form, str(project_name), str(version_name))
+            return await _set_revision(session, revision_form, project_name, version_name)
         case shared.revisions.SetTagForm():
-            return await _set_tag(session, revision_form, str(project_name), str(version_name))
+            return await _set_tag(session, revision_form, project_name, version_name)
 
 
 async def _set_revision(
-    session: web.Committer, set_revision_form: shared.revisions.SetRevisionForm, project_name: str, version_name: str
+    session: web.Committer,
+    set_revision_form: shared.revisions.SetRevisionForm,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
 ) -> web.WerkzeugResponse:
     """Set a specific revision as the latest for a candidate draft or release preview."""
     selected_revision_number = set_revision_form.revision_number
@@ -80,13 +83,16 @@ async def _set_revision(
         return await session.redirect(
             get.revisions.selected,
             success=success,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
         )
 
 
 async def _set_tag(
-    session: web.Committer, set_tag_form: shared.revisions.SetTagForm, project_name: str, version_name: str
+    session: web.Committer,
+    set_tag_form: shared.revisions.SetTagForm,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
 ) -> web.WerkzeugResponse:
     """Set a tag on a specific revision."""
     revision_number = set_tag_form.revision_number
@@ -106,6 +112,6 @@ async def _set_tag(
     return await session.redirect(
         get.revisions.selected,
         success=message,
-        project_name=project_name,
-        version_name=version_name,
+        project_name=str(project_name),
+        version_name=str(version_name),
     )
diff --git a/atr/post/sbom.py b/atr/post/sbom.py
index 4f614b0e..d3aeb28b 100644
--- a/atr/post/sbom.py
+++ b/atr/post/sbom.py
@@ -57,14 +57,14 @@ async def report(
 
     match sbom_form:
         case shared.sbom.AugmentSBOMForm():
-            return await _augment(session, str(project_name), str(version_name), validated_path)
+            return await _augment(session, project_name, version_name, validated_path)
 
         case shared.sbom.ScanSBOMForm():
-            return await _scan(session, str(project_name), str(version_name), validated_path)
+            return await _scan(session, project_name, version_name, validated_path)
 
 
 async def _augment(
-    session: web.Committer, project_name: str, version_name: str, rel_path: pathlib.Path
+    session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, rel_path: pathlib.Path
 ) -> web.WerkzeugResponse:
     """Augment a CycloneDX SBOM file."""
     # Check that the file is a .cdx.json archive before creating a revision
@@ -73,7 +73,7 @@ async def _augment(
 
     try:
         async with db.session() as data:
-            release = await data.release(project_name=project_name, version=version_name).demand(
+            release = await data.release(project_name=str(project_name), version=str(version_name)).demand(
                 RuntimeError("Release does not exist for new revision creation")
             )
             revision_number = release.latest_revision_number
@@ -108,7 +108,7 @@ async def _augment(
 
 
 async def _scan(
-    session: web.Committer, project_name: str, version_name: str, rel_path: pathlib.Path
+    session: web.Committer, project_name: safe.ProjectName, version_name: safe.VersionName, rel_path: pathlib.Path
 ) -> web.WerkzeugResponse:
     """Scan a CycloneDX SBOM file for vulnerabilities using OSV."""
     if not (rel_path.name.endswith(".cdx.json")):
@@ -116,7 +116,7 @@ async def _scan(
 
     try:
         async with db.session() as data:
-            release = await data.release(project_name=project_name, version=version_name).demand(
+            release = await data.release(project_name=str(project_name), version=str(version_name)).demand(
                 RuntimeError("Release does not exist for OSV scan")
             )
             revision_number = release.latest_revision_number
diff --git a/atr/post/start.py b/atr/post/start.py
index fea9a2f2..1ff31372 100644
--- a/atr/post/start.py
+++ b/atr/post/start.py
@@ -40,9 +40,9 @@ async def selected(
 
     try:
         async with storage.write(session) as write:
-            wacp = await write.as_project_committee_participant(str(project_name))
+            wacp = await write.as_project_committee_participant(project_name)
             new_release, _project = await wacp.release.start(
-                str(project_name),
+                project_name,
                 start_release_form.version_name,
             )
 
diff --git a/atr/post/upload.py b/atr/post/upload.py
index 9c4c2cb9..54b1a056 100644
--- a/atr/post/upload.py
+++ b/atr/post/upload.py
@@ -74,7 +74,7 @@ async def finalise(
 
     try:
         async with storage.write(session) as write:
-            wacp = await write.as_project_committee_participant(str(project_name))
+            wacp = await write.as_project_committee_participant(project_name)
             number_of_files = len(staged_files)
             description = f"Upload of {util.plural(number_of_files, 'file')} through web interface"
 
@@ -85,7 +85,7 @@ async def finalise(
                     await aioshutil.move(str(src), str(dst))
 
             result = await wacp.revision.create_revision_with_quarantine(
-                str(project_name), str(version_name), session.uid, description=description, modify=modify
+                project_name, version_name, session.uid, description=description, modify=modify
             )
 
         await aioshutil.rmtree(staging_dir)
@@ -131,10 +131,10 @@ async def selected(
 
     match upload_form:
         case shared.upload.AddFilesForm() as add_form:
-            return await _add_files(session, add_form, str(project_name), str(version_name))
+            return await _add_files(session, add_form, project_name, version_name)
 
         case shared.upload.SvnImportForm() as svn_form:
-            return await _svn_import(session, svn_form, str(project_name), str(version_name))
+            return await _svn_import(session, svn_form, project_name, version_name)
 
 
 @post.typed
@@ -187,7 +187,10 @@ async def stage(
 
 
 async def _add_files(
-    session: web.Committer, add_form: shared.upload.AddFilesForm, project_name: str, version_name: str
+    session: web.Committer,
+    add_form: shared.upload.AddFilesForm,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
 ) -> web.WerkzeugResponse:
     try:
         file_name = add_form.file_name
@@ -248,7 +251,10 @@ def _json_success(data: dict[str, str], status: int = 200) -> web.WerkzeugRespon
 
 
 async def _svn_import(
-    session: web.Committer, svn_form: shared.upload.SvnImportForm, project_name: str, version_name: str
+    session: web.Committer,
+    svn_form: shared.upload.SvnImportForm,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
 ) -> web.WerkzeugResponse:
     # audit_guidance any file uploads are from known and managed repositories so file size is not an issue
     try:
@@ -259,7 +265,7 @@ async def _svn_import(
         async with db.session() as data:
             release = await session.release(project_name, version_name, data=data)
             is_podling = (release.project.committee is not None) and release.project.committee.is_podling
-            committee_name = release.project.committee_name or project_name
+            committee_name = release.project.committee_name or str(project_name)
 
         svn_url = _construct_svn_url(
             committee_name,
diff --git a/atr/post/vote.py b/atr/post/vote.py
index 894fbc69..b6d99c87 100644
--- a/atr/post/vote.py
+++ b/atr/post/vote.py
@@ -40,7 +40,7 @@ async def selected_post(
     URL: /vote/<project_name>/<version_name>
     """
 
-    release = await session.release(str(project_name), str(version_name), phase=sql.ReleasePhase.RELEASE_CANDIDATE)
+    release = await session.release(project_name, version_name, phase=sql.ReleasePhase.RELEASE_CANDIDATE)
 
     if release.committee is None:
         raise ValueError("Release has no committee")
diff --git a/atr/post/voting.py b/atr/post/voting.py
index 26a701b4..bed6534e 100644
--- a/atr/post/voting.py
+++ b/atr/post/voting.py
@@ -50,14 +50,14 @@ async def body_preview(
     URL: /voting/body/preview/<project_name>/<version_name>/<revision_number>
     """
 
-    default_subject_template = await construct.start_vote_subject_default(str(project_name))
-    default_body_template = await construct.start_vote_default(str(project_name))
+    default_subject_template = await construct.start_vote_subject_default(project_name)
+    default_body_template = await construct.start_vote_default(project_name)
 
     options = construct.StartVoteOptions(
         asfuid=session.uid,
         fullname=session.fullname,
-        project_name=str(project_name),
-        version_name=str(version_name),
+        project_name=project_name,
+        version_name=version_name,
         revision_number=revision_number,
         vote_duration=preview_form.vote_duration,
     )
@@ -81,7 +81,7 @@ async def selected_revision(
 
     async with db.session() as data:
         match await interaction.release_ready_for_vote(
-            session, str(project_name), str(version_name), revision, data, manual_vote=False
+            session, project_name, version_name, revision, data, manual_vote=False
         ):
             case str() as error:
                 return await session.redirect(
@@ -101,7 +101,7 @@ async def selected_revision(
                 f"Invalid mailing list selection: {start_voting_form.mailing_list}",
             )
 
-        subject_template = await construct.start_vote_subject_default(str(project_name))
+        subject_template = await construct.start_vote_subject_default(project_name)
         current_hash = construct.template_hash(subject_template)
         if current_hash != start_voting_form.subject_template_hash:
             return await session.form_error(
@@ -113,8 +113,8 @@ async def selected_revision(
         options = construct.StartVoteOptions(
             asfuid=session.uid,
             fullname=session.fullname,
-            project_name=str(project_name),
-            version_name=str(version_name),
+            project_name=project_name,
+            version_name=version_name,
             revision_number=revision,
             vote_duration=start_voting_form.vote_duration,
         )
@@ -123,8 +123,8 @@ async def selected_revision(
         async with storage.write_as_committee_participant(committee.name) as wacp:
             _task = await wacp.vote.start(
                 start_voting_form.mailing_list,
-                str(project_name),
-                str(version_name),
+                project_name,
+                version_name,
                 revision,
                 start_voting_form.vote_duration,
                 subject,
diff --git a/atr/shared/distribution.py b/atr/shared/distribution.py
index 6408f94f..84b150ee 100644
--- a/atr/shared/distribution.py
+++ b/atr/shared/distribution.py
@@ -29,6 +29,7 @@ import atr.form as form
 import atr.htm as htm
 import atr.models.basic as basic
 import atr.models.distribution as distribution
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.util as util
 from atr.storage import outcome
@@ -114,7 +115,7 @@ class DistributionPlatform(enum.Enum):
 
 
 class DeleteForm(form.Form):
-    release_name: str = form.label("Release name", widget=form.Widget.HIDDEN)
+    release_name: safe.ReleaseName = form.label("Release name", widget=form.Widget.HIDDEN)
     platform: form.Enum[DistributionPlatform] = form.label("Platform", widget=form.Widget.HIDDEN)
     owner_namespace: str = form.label("Owner namespace", widget=form.Widget.HIDDEN)
     package: str = form.label("Package", widget=form.Widget.HIDDEN)
@@ -362,7 +363,11 @@ async def json_from_maven_xml(api_url: str, version: str) -> outcome.Outcome[bas
 
 
 async def release_validated(
-    project: str, version: str, committee: bool = False, staging: bool | None = None, release_policy: bool = False
+    project: safe.ProjectName,
+    version: safe.VersionName,
+    committee: bool = False,
+    staging: bool | None = None,
+    release_policy: bool = False,
 ) -> sql.Release:
     match staging:
         case True:
@@ -373,20 +378,20 @@ async def release_validated(
             phase = {sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT, sql.ReleasePhase.RELEASE_PREVIEW}
     async with db.session() as data:
         release = await data.release(
-            project_name=project,
-            version=version,
+            project_name=str(project),
+            version=str(version),
             _committee=committee,
             _release_policy=release_policy,
-        ).demand(RuntimeError(f"Release {project} {version} not found"))
+        ).demand(RuntimeError(f"Release {project!s} {version!s} not found"))
         if release.phase not in phase:
-            raise RuntimeError(f"Release {project} {version} is not in {phase}")
+            raise RuntimeError(f"Release {project!s} {version!s} is not in {phase}")
         # if release.project.status != sql.ProjectStatus.ACTIVE:
         #     raise RuntimeError(f"Project {project} is not active")
     return release
 
 
 async def release_validated_and_committee(
-    project: str, version: str, *, staging: bool | None = None, release_policy: bool = False
+    project: safe.ProjectName, version: safe.VersionName, *, staging: bool | None = None, release_policy: bool = False
 ) -> tuple[sql.Release, sql.Committee]:
     release = await release_validated(project, version, committee=True, staging=staging, release_policy=release_policy)
     committee = release.committee
diff --git a/atr/shared/projects.py b/atr/shared/projects.py
index 88162e64..f09f0d81 100644
--- a/atr/shared/projects.py
+++ b/atr/shared/projects.py
@@ -23,6 +23,7 @@ from typing import Annotated, Literal
 import pydantic
 
 import atr.form as form
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.util as util
 
@@ -105,7 +106,7 @@ class AddProjectForm(form.Form):
 
 class ComposePolicyForm(form.Form):
     variant: COMPOSE = form.value(COMPOSE)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
     source_artifact_paths: str = form.label(
         "Source artifact paths",
         "Paths to source artifacts to be included in the release.",
@@ -181,7 +182,7 @@ class ComposePolicyForm(form.Form):
 
 class VotePolicyForm(form.Form):
     variant: VOTE = form.value(VOTE)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
     github_vote_workflow_path: str = form.label(
         "GitHub vote workflow paths",
         "The full paths to the GitHub workflows to use for the release, including the .github/workflows/ prefix.",
@@ -243,7 +244,7 @@ class VotePolicyForm(form.Form):
 
 class FinishPolicyForm(form.Form):
     variant: FINISH = form.value(FINISH)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
     github_finish_workflow_path: str = form.label(
         "GitHub finish workflow paths",
         "The full paths to the GitHub workflows to use for the release, including the .github/workflows/ prefix.",
@@ -277,35 +278,35 @@ class FinishPolicyForm(form.Form):
 
 class AddCategoryForm(form.Form):
     variant: ADD_CATEGORY = form.value(ADD_CATEGORY)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
     category_to_add: str = form.label("New category name")
 
 
 class RemoveCategoryForm(form.Form):
     variant: REMOVE_CATEGORY = form.value(REMOVE_CATEGORY)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
     category_to_remove: str = form.label("Category to remove", widget=form.Widget.HIDDEN)
 
 
 class AddLanguageForm(form.Form):
     variant: ADD_LANGUAGE = form.value(ADD_LANGUAGE)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
     language_to_add: str = form.label("New language name")
 
 
 class RemoveLanguageForm(form.Form):
     variant: REMOVE_LANGUAGE = form.value(REMOVE_LANGUAGE)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
     language_to_remove: str = form.label("Language to remove", widget=form.Widget.HIDDEN)
 
 
 class DeleteProjectForm(form.Form):
     variant: DELETE_PROJECT = form.value(DELETE_PROJECT)
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
 
 
 class DeleteSelectedProject(form.Form):
-    project_name: str = form.label("Project name", widget=form.Widget.HIDDEN)
+    project_name: safe.ProjectName = form.label("Project name", widget=form.Widget.HIDDEN)
 
 
 type ProjectViewForm = Annotated[
diff --git a/atr/shared/web.py b/atr/shared/web.py
index 2ac53e23..fc38b0a8 100644
--- a/atr/shared/web.py
+++ b/atr/shared/web.py
@@ -24,6 +24,7 @@ import atr.form as form
 import atr.get as get
 import atr.htm as htm
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as paths
 import atr.post as post
@@ -38,6 +39,59 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
 
+def render_checks_summary(
+    info: types.PathInfo | None, project_name: safe.ProjectName, version_name: safe.VersionName
+) -> htm.Element | None:
+    if (info is None) or (not info.checker_stats):
+        return None
+
+    card = htm.Block(htm.div, classes=".card.mb-4")
+    card.div(".card-header")[htpy.h5(".mb-0")["Checks summary"]]
+
+    body = htm.Block(htm.div, classes=".card-body")
+    for i, stat in enumerate(info.checker_stats):
+        stripe_class = ".atr-stripe-odd" if ((i % 2) == 0) else ".atr-stripe-even"
+        details = htm.Block(htm.details, classes=f".mb-0.p-2{stripe_class}")
+
+        summary_content: list[htm.Element | str] = []
+        if stat.warning_count > 0:
+            summary_content.append(htpy.span(".badge.bg-warning.text-dark.me-2")[str(stat.warning_count)])
+        if stat.failure_count > 0:
+            summary_content.append(htpy.span(".badge.bg-danger.me-2")[str(stat.failure_count)])
+        if stat.blocker_count > 0:
+            summary_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[str(stat.blocker_count)])
+        summary_content.append(htpy.strong[_checker_display_name(stat.checker)])
+
+        details.summary[*summary_content]
+
+        files_div = htm.Block(htm.div, classes=".mt-2.atr-checks-files")
+        all_files = set(stat.failure_files.keys()) | set(stat.warning_files.keys()) | set(stat.blocker_files.keys())
+        for file_path in sorted(all_files):
+            report_url = f"/report/{project_name!s}/{version_name!s}/{file_path}"
+            error_count = stat.failure_files.get(file_path, 0)
+            blocker_count = stat.blocker_files.get(file_path, 0)
+            warning_count = stat.warning_files.get(file_path, 0)
+
+            file_content: list[htm.Element | str] = []
+            if error_count > 0:
+                file_content.append(htpy.span(".badge.bg-danger.me-2")[util.plural(error_count, "error")])
+            if blocker_count > 0:
+                file_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[util.plural(blocker_count, "blocker")])
+            if warning_count > 0:
+                file_content.append(
+                    htpy.span(".badge.bg-warning.text-dark.me-2")[util.plural(warning_count, "warning")]
+                )
+            file_content.append(htpy.a(href=report_url)[htpy.strong[htpy.code[file_path]]])
+
+            files_div.div[*file_content]
+
+        details.append(files_div.collect())
+        body.append(details.collect())
+
+    card.append(body.collect())
+    return card.collect()
+
+
 async def check(
     session: web.Committer | None,
     release: sql.Release,
@@ -80,11 +134,11 @@ async def check(
 
     # Get the number of ongoing tasks for the current revision
     ongoing_tasks_count = 0
-    match await interaction.latest_info(release.project.name, release.version):
+    match await interaction.latest_info(release.safe_project_name, release.safe_version_name):
         case (revision_number, revision_editor, revision_timestamp):
             ongoing_tasks_count = await interaction.tasks_ongoing(
-                release.project.name,
-                release.version,
+                release.safe_project_name,
+                release.safe_version_name,
                 revision_number,
             )
         case None:
@@ -94,7 +148,9 @@ async def check(
 
     delete_form = form.render(
         model_cls=form.Empty,
-        action=util.as_url(get.compose.selected, project_name=release.project.name, version_name=release.version),
+        action=util.as_url(
+            get.compose.selected, project_name=release.safe_project_name, version_name=release.safe_version_name
+        ),
         submit_label="Delete this draft",
         submit_classes="btn btn-danger",
         empty=True,
@@ -105,7 +161,9 @@ async def check(
     for path in all_paths:
         delete_file_forms[str(path)] = form.render(
             model_cls=draft.DeleteFileForm,
-            action=util.as_url(post.draft.delete_file, project_name=release.project.name, version_name=release.version),
+            action=util.as_url(
+                post.draft.delete_file, project_name=release.safe_project_name, version_name=release.safe_version_name
+            ),
             form_classes=".d-inline-block.m-0",
             submit_classes="btn-sm btn-outline-danger",
             submit_label="Delete",
@@ -121,14 +179,18 @@ async def check(
 
     recheck_form = form.render(
         model_cls=form.Empty,
-        action=util.as_url(post.draft.recheck, project_name=release.project.name, version_name=release.version),
+        action=util.as_url(
+            post.draft.recheck, project_name=release.safe_project_name, version_name=release.safe_version_name
+        ),
         submit_label="Disable global cache",
         submit_classes="btn btn-primary",
         # confirm="Restart all checks without using cached results? This creates a new revision.",
     )
     cache_reset_form = form.render(
         model_cls=form.Empty,
-        action=util.as_url(post.draft.cache_reset, project_name=release.project.name, version_name=release.version),
+        action=util.as_url(
+            post.draft.cache_reset, project_name=release.safe_project_name, version_name=release.safe_version_name
+        ),
         submit_label="Enable global cache",
         submit_classes="btn btn-primary",
         # confirm="Restart all checks without using cached results? This creates a new revision.",
@@ -146,12 +208,12 @@ async def check(
 
     is_local_caching = release.check_cache_key is not None
 
-    checks_summary_html = render_checks_summary(info, release.project.name, release.version)
+    checks_summary_html = render_checks_summary(info, release.safe_project_name, release.safe_version_name)
 
     return await template.render(
         "check-selected.html",
-        project_name=release.project.name,
-        version_name=release.version,
+        project_name=str(release.project.name),
+        version_name=str(release.version),
         release=release,
         paths=all_paths,
         info=info,
@@ -188,57 +250,6 @@ async def check(
     )
 
 
-def render_checks_summary(info: types.PathInfo | None, project_name: str, version_name: str) -> htm.Element | None:
-    if (info is None) or (not info.checker_stats):
-        return None
-
-    card = htm.Block(htm.div, classes=".card.mb-4")
-    card.div(".card-header")[htpy.h5(".mb-0")["Checks summary"]]
-
-    body = htm.Block(htm.div, classes=".card-body")
-    for i, stat in enumerate(info.checker_stats):
-        stripe_class = ".atr-stripe-odd" if ((i % 2) == 0) else ".atr-stripe-even"
-        details = htm.Block(htm.details, classes=f".mb-0.p-2{stripe_class}")
-
-        summary_content: list[htm.Element | str] = []
-        if stat.warning_count > 0:
-            summary_content.append(htpy.span(".badge.bg-warning.text-dark.me-2")[str(stat.warning_count)])
-        if stat.failure_count > 0:
-            summary_content.append(htpy.span(".badge.bg-danger.me-2")[str(stat.failure_count)])
-        if stat.blocker_count > 0:
-            summary_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[str(stat.blocker_count)])
-        summary_content.append(htpy.strong[_checker_display_name(stat.checker)])
-
-        details.summary[*summary_content]
-
-        files_div = htm.Block(htm.div, classes=".mt-2.atr-checks-files")
-        all_files = set(stat.failure_files.keys()) | set(stat.warning_files.keys()) | set(stat.blocker_files.keys())
-        for file_path in sorted(all_files):
-            report_url = f"/report/{project_name!s}/{version_name!s}/{file_path}"
-            error_count = stat.failure_files.get(file_path, 0)
-            blocker_count = stat.blocker_files.get(file_path, 0)
-            warning_count = stat.warning_files.get(file_path, 0)
-
-            file_content: list[htm.Element | str] = []
-            if error_count > 0:
-                file_content.append(htpy.span(".badge.bg-danger.me-2")[util.plural(error_count, "error")])
-            if blocker_count > 0:
-                file_content.append(htpy.span(".badge.atr-bg-blocker.me-2")[util.plural(blocker_count, "blocker")])
-            if warning_count > 0:
-                file_content.append(
-                    htpy.span(".badge.bg-warning.text-dark.me-2")[util.plural(warning_count, "warning")]
-                )
-            file_content.append(htpy.a(href=report_url)[htpy.strong[htpy.code[file_path]]])
-
-            files_div.div[*file_content]
-
-        details.append(files_div.collect())
-        body.append(details.collect())
-
-    card.append(body.collect())
-    return card.collect()
-
-
 def _checker_display_name(checker: str) -> str:
     return checker.removeprefix("atr.tasks.checks.").replace("_", " ").replace(".", " ").title()
 
diff --git a/atr/ssh.py b/atr/ssh.py
index 25714bce..017dcc63 100644
--- a/atr/ssh.py
+++ b/atr/ssh.py
@@ -40,6 +40,7 @@ import atr.attestable as attestable
 import atr.config as config
 import atr.db as db
 import atr.log as log
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as paths
 import atr.storage as storage
@@ -61,6 +62,12 @@ _APPROVED_KEX: Final = util.intersect_algs(_SSH_AUDIT_POLICY, "kex", _ASYNCSSH_S
 _APPROVED_MACS: Final = util.intersect_algs(_SSH_AUDIT_POLICY, "macs", _ASYNCSSH_SUPPORTED_MAC)
 
 
+_PATH_ALPHANUM: Final = frozenset(string.ascii_letters + string.digits + "-")
+# From a survey of version numbers we find that only . and - are used
+# We also allow + which is in common use
+_PATH_VERSION_CHARS: Final = _PATH_ALPHANUM | frozenset(".-+")
+
+
 class RsyncArgsError(Exception):
     """Exception raised when the rsync arguments are invalid."""
 
@@ -271,9 +278,9 @@ async def _step_02_handle_safely(process: asyncssh.SSHServerProcess, server: SSH
         process, argv, is_read_request, server
     )
     # The release object is only present for read requests
-    release_name = sql.release_name(project_name, version_name)
 
     if release_obj is not None:
+        release_name = sql.release_name(project_name, version_name)
         log.info(f"Processing READ request for {release_name}")
         ####################################################
         ### Calls _step_07a_process_validated_rsync_read ###
@@ -333,26 +340,24 @@ def _step_03_command_simple_validate(argv: list[str]) -> bool:
 
 async def _step_04_command_validate(
     process: asyncssh.SSHServerProcess, argv: list[str], is_read_request: bool, server: SSHServer
-) -> tuple[str, str, list[str] | None, sql.Release | None]:
+) -> tuple[safe.ProjectName, safe.VersionName | None, list[str] | None, sql.Release | None]:
     """Validate the path and user permissions for read or write."""
     ############################################
     ### Calls _step_05a/b_command_path_validate ###
     ############################################
     if is_read_request:
-        path_project, path_version, tag = _step_05a_command_path_validate_read(argv[-1])
+        project_name, version_name, tag = await _step_05a_command_path_validate_read(argv[-1])
     else:
-        path_project, path_version, tag = _step_05b_command_path_validate_write(argv[-1])
+        project_name, version_name, tag = await _step_05b_command_path_validate_write(argv[-1])
 
     ssh_uid = server._get_asf_uid(process)
-
     async with db.session() as data:
-        project = await data.project(name=path_project, status=sql.ProjectStatus.ACTIVE, _committee=True).get()
+        project = await data.project(name=str(project_name), status=sql.ProjectStatus.ACTIVE, _committee=True).get()
         if project is None:
-            # Projects are public, so existence information is public
-            raise RsyncArgsError(f"Project '{path_project}' does not exist")
+            raise RsyncArgsError(f"Project '{project_name}' does not exist")
 
         release = await data.release(
-            project_name=project.name, version=path_version, _project_release_policy=True
+            project_name=str(project_name), version=str(version_name), _project_release_policy=True
         ).get()
 
     if is_read_request:
@@ -360,115 +365,102 @@ async def _step_04_command_validate(
         ### Calls _step_06a_validate_read_permissions ###
         #################################################
         validated_release, file_patterns = await _step_06a_validate_read_permissions(
-            ssh_uid, project, release, path_project, path_version, tag
+            ssh_uid, project, release, project_name, version_name, tag
         )
-        return path_project, path_version, file_patterns, validated_release
+        return project_name, version_name, file_patterns, validated_release
 
     ##################################################
     ### Calls _step_06b_validate_write_permissions ###
     ##################################################
     await _step_06b_validate_write_permissions(ssh_uid, project, release)
-    # Return None for the tag and release objects for write requests
-    return path_project, path_version, None, None
+    return project_name, version_name, None, None
 
 
-def _step_05a_command_path_validate_read(path: str) -> tuple[str, str, str | None]:
-    """Validate the path argument for rsync commands."""
+async def _step_05a_command_path_validate_read(path: str) -> tuple[safe.ProjectName, safe.VersionName, str | None]:
+    """Validate the path argument for rsync read commands, returning safe types."""
     # READ: rsync --server --sender -vlogDtpre.iLsfxCIvu . /proj/v1/
     # Validating path: /proj/v1/
-    # WRITE: rsync --server -vlogDtpre.iLsfxCIvu . /proj/v1/
-    # Validating path: /proj/v1/
-
-    if not path.startswith("/"):
-        raise RsyncArgsError("The path argument should be an absolute path")
-
-    if not path.endswith("/"):
-        # Technically we could ignore this, because we rewrite the path anyway for writes
-        # But we should enforce good rsync usage practices
-        raise RsyncArgsError("The path argument should be a directory path, ending with a /")
-
-    if "//" in path:
-        raise RsyncArgsError("The path argument should not contain //")
-
+    _validate_path_common(path)
     if (path.count("/") < 3) or (path.count("/") > 4):
         raise RsyncArgsError("The path argument should be a /PROJECT/VERSION/(tag)/ directory path")
 
     path_project, path_version, *rest = path.strip("/").split("/", 2)
     tag = rest[0] if rest else None
-    alphanum = set(string.ascii_letters + string.digits + "-")
-    if not all(c in alphanum for c in path_project):
-        raise RsyncArgsError("The project name should contain only alphanumeric characters or hyphens")
-
-    if tag and (not all(c in alphanum for c in tag)):
-        raise RsyncArgsError("The tag should contain only alphanumeric characters or hyphens")
-
-    # From a survey of version numbers we find that only . and - are used
-    # We also allow + which is in common use
-    version_punctuation = set(".-+")
-    if path_version[0] not in alphanum:
-        # Must certainly not allow the directory to be called "." or ".."
-        # And we also want to avoid patterns like ".htaccess"
-        raise RsyncArgsError("The version should start with an alphanumeric character")
-    if path_version[-1] not in alphanum:
-        raise RsyncArgsError("The version should end with an alphanumeric character")
-    if not all(c in (alphanum | version_punctuation) for c in path_version):
-        raise RsyncArgsError("The version should contain only alphanumeric characters, dots, dashes, or pluses")
+    _validate_project_segment(path_project)
+    _validate_version_segment(path_version)
+    if tag:
+        _validate_tag_segment(tag)
 
-    return path_project, path_version, tag
+    project_name, version_name = await _validate_project_and_version(path_project, path_version)
+    if version_name is None:
+        raise RsyncArgsError(f"Release '{path_project}-{path_version}' does not exist")
+    return project_name, version_name, tag
 
 
-def _step_05b_command_path_validate_write(path: str) -> tuple[str, str, str | None]:
-    """Validate the path argument for rsync commands."""
-    # READ: rsync --server --sender -vlogDtpre.iLsfxCIvu . /proj/v1/
-    # Validating path: /proj/v1/
+async def _step_05b_command_path_validate_write(path: str) -> tuple[safe.ProjectName, safe.VersionName, None]:
+    """Validate the path argument for rsync write commands, returning safe types."""
     # WRITE: rsync --server -vlogDtpre.iLsfxCIvu . /proj/v1/
     # Validating path: /proj/v1/
+    _validate_path_common(path)
+    if path.count("/") != 3:
+        raise RsyncArgsError("The path argument should be a /PROJECT/VERSION/ directory path")
+
+    path_project, path_version = path.strip("/").split("/", 1)
+    _validate_project_segment(path_project)
+    _validate_version_segment(path_version)
 
+    project_name, version_name = await _validate_project_and_version(path_project, path_version)
+    if version_name is None:
+        # No existing release: format-validated version accepted for new release creation
+        # TODO: AM Example where need to validate but not validate
+        version_name = safe.VersionName(path_version)
+    return project_name, version_name, None
+
+
+def _validate_path_common(path: str) -> None:
+    """Validate the common structural requirements for an rsync path argument."""
     if not path.startswith("/"):
         raise RsyncArgsError("The path argument should be an absolute path")
-
     if not path.endswith("/"):
         # Technically we could ignore this, because we rewrite the path anyway for writes
         # But we should enforce good rsync usage practices
         raise RsyncArgsError("The path argument should be a directory path, ending with a /")
-
     if "//" in path:
         raise RsyncArgsError("The path argument should not contain //")
 
-    if path.count("/") != 3:
-        raise RsyncArgsError("The path argument should be a /PROJECT/VERSION/ directory path")
 
-    path_project, path_version = path.strip("/").split("/", 1)
-    alphanum = set(string.ascii_letters + string.digits + "-")
-    if not all(c in alphanum for c in path_project):
+def _validate_project_segment(segment: str) -> None:
+    if not all(c in _PATH_ALPHANUM for c in segment):
         raise RsyncArgsError("The project name should contain only alphanumeric characters or hyphens")
 
-    # From a survey of version numbers we find that only . and - are used
-    # We also allow + which is in common use
-    version_punctuation = set(".-+")
-    if path_version[0] not in alphanum:
-        # Must certainly not allow the directory to be called "." or ".."
-        # And we also want to avoid patterns like ".htaccess"
+
+def _validate_tag_segment(segment: str) -> None:
+    if not all(c in _PATH_ALPHANUM for c in segment):
+        raise RsyncArgsError("The tag should contain only alphanumeric characters or hyphens")
+
+
+def _validate_version_segment(segment: str) -> None:
+    # Must certainly not allow the directory to be called "." or ".."
+    # And we also want to avoid patterns like ".htaccess"
+    if segment[0] not in _PATH_ALPHANUM:
         raise RsyncArgsError("The version should start with an alphanumeric character")
-    if path_version[-1] not in alphanum:
+    if segment[-1] not in _PATH_ALPHANUM:
         raise RsyncArgsError("The version should end with an alphanumeric character")
-    if not all(c in (alphanum | version_punctuation) for c in path_version):
+    if not all(c in _PATH_VERSION_CHARS for c in segment):
         raise RsyncArgsError("The version should contain only alphanumeric characters, dots, dashes, or pluses")
 
-    return path_project, path_version, None
-
 
 async def _step_06a_validate_read_permissions(
     ssh_uid: str,
     project: sql.Project,
     release: sql.Release | None,
-    path_project: str,
-    path_version: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     tag: str | None,
 ) -> tuple[sql.Release | None, list[str] | None]:
     """Validate permissions for a read request."""
     if release is None:
-        raise RsyncArgsError(f"Release '{path_project}-{path_version}' does not exist")
+        raise RsyncArgsError(f"Release '{project_name}-{version_name}' does not exist")
 
     allowed_read_phases = {
         sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT,
@@ -571,14 +563,14 @@ async def _step_07a_process_validated_rsync_read(
 async def _step_07b_process_validated_rsync_write(
     process: asyncssh.SSHServerProcess,
     argv: list[str],
-    project_name: str,
+    project_name: safe.ProjectName,
     version_name: str,
     server: SSHServer,
 ) -> None:
     """Handle a validated rsync write request."""
     asf_uid = server._get_asf_uid(process)
     exit_status = 0
-    release_name = sql.release_name(project_name, version_name)
+    release_name = sql.release_name(str(project_name), version_name)
 
     # Ensure the release object exists or is created
     # This must happen before creating the revision directory
@@ -640,15 +632,15 @@ async def _step_07b_process_validated_rsync_write(
             process.exit(exit_status)
 
 
-async def _step_07c_ensure_release_object_for_write(project_name: str, version_name: str) -> None:
+async def _step_07c_ensure_release_object_for_write(project_name: safe.ProjectName, version_name: str) -> None:
     """Ensure the release object exists or create it for a write operation."""
-    release_name = sql.release_name(project_name, version_name)
+    release_name = sql.release_name(str(project_name), version_name)
     async with db.session() as data:
-        release = await data.release(name=sql.release_name(project_name, version_name), _committee=True).get()
+        release = await data.release(name=release_name, _committee=True).get()
         if release is None:
-            project = await data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _committee=True).demand(
-                RuntimeError("Project not found after validation")
-            )
+            project = await data.project(
+                name=str(project_name), status=sql.ProjectStatus.ACTIVE, _committee=True
+            ).demand(RuntimeError("Project not found after validation"))
             if version_name_error := util.version_name_error(version_name):
                 # This should ideally be caught by path validation, but double check
                 raise RuntimeError(f'Invalid version name "{version_name}": {version_name_error}')
@@ -667,6 +659,22 @@ async def _step_07c_ensure_release_object_for_write(project_name: str, version_n
         await data.commit()
 
 
+async def _validate_project_and_version(
+    path_project: str, path_version: str
+) -> tuple[safe.ProjectName, safe.VersionName | None]:
+    """Validate a project and optional version against the cache or database, returning safe types.
+
+    Returns (project_name, version_name) where version_name is None if no matching
+    release exists. The project must exist or RsyncArgsError is raised.
+    """
+    project_name = await safe.ProjectName.create(path_project)
+    if not project_name:
+        raise RsyncArgsError(f"Project '{path_project}' does not exist")
+
+    version_name = await safe.VersionName.create(path_version, project_name)
+    return project_name, version_name
+
+
 async def _step_08_execute_rsync(process: asyncssh.SSHServerProcess, argv: list[str]) -> int:
     """Execute the modified rsync command."""
     log.info(f"Executing modified rsync command: {' '.join(argv)}")
diff --git a/atr/storage/__init__.py b/atr/storage/__init__.py
index 4b8caa0f..f78f2601 100644
--- a/atr/storage/__init__.py
+++ b/atr/storage/__init__.py
@@ -29,6 +29,7 @@ if TYPE_CHECKING:
 import atr.db as db
 import atr.log as log
 import atr.models.basic as basic
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.principal as principal
 import atr.storage.outcome as outcome
@@ -332,12 +333,12 @@ class Write:
     # async def as_key_owner(self) -> types.Outcome[WriteAsKeyOwner]:
     #     ...
 
-    async def as_project_committee_admin(self, project_name: str) -> WriteAsCommitteeAdmin:
+    async def as_project_committee_admin(self, project_name: safe.ProjectName) -> WriteAsCommitteeAdmin:
         write_as_outcome = await self.as_project_committee_admin_outcome(project_name)
         return write_as_outcome.result_or_raise()
 
-    async def as_project_committee_admin_outcome(self, project_name: str) -> outcome.Outcome[WriteAsCommitteeAdmin]:
-        project = await self.__data.project(project_name, _committee=True).demand(
+    async def as_project_committee_admin_outcome(self, project_name: safe.ProjectName) -> outcome.Outcome[WriteAsCommitteeAdmin]:
+        project = await self.__data.project(str(project_name), _committee=True).demand(
             AccessError(f"Project not found: {project_name}")
         )
         if project.committee is None:
@@ -356,8 +357,10 @@ class Write:
         write_as_outcome = await self.as_project_committee_member_outcome(project_name)
         return write_as_outcome.result_or_raise()
 
-    async def as_project_committee_member_outcome(self, project_name: str) -> outcome.Outcome[WriteAsCommitteeMember]:
-        project = await self.__data.project(project_name, _committee=True).demand(
+    async def as_project_committee_member_outcome(
+        self, project_name: safe.ProjectName
+    ) -> outcome.Outcome[WriteAsCommitteeMember]:
+        project = await self.__data.project(str(project_name), _committee=True).demand(
             AccessError(f"Project not found: {project_name}")
         )
         if project.committee is None:
@@ -372,15 +375,15 @@ class Write:
             return outcome.Error(e)
         return outcome.Result(wacm)
 
-    async def as_project_committee_participant(self, project_name: str) -> WriteAsCommitteeParticipant:
+    async def as_project_committee_participant(self, project_name: safe.ProjectName) -> WriteAsCommitteeParticipant:
         write_as_outcome = await self.as_project_committee_participant_outcome(project_name)
         return write_as_outcome.result_or_raise()
 
     async def as_project_committee_participant_outcome(
-        self, project_name: str
+        self, project_name: safe.ProjectName
     ) -> outcome.Outcome[WriteAsCommitteeParticipant]:
-        project = await self.__data.project(project_name, _committee=True).demand(
-            AccessError(f"Project not found: {project_name}")
+        project = await self.__data.project(str(project_name), _committee=True).demand(
+            AccessError(f"Project not found: {project_name!s}")
         )
         if project.committee is None:
             return outcome.Error(AccessError("No committee found for project - Invalid state"))
@@ -509,7 +512,7 @@ async def write_as_committee_participant(
 
 @contextlib.asynccontextmanager
 async def write_as_project_committee_member(
-    project_name: str,
+    project_name: safe.ProjectName,
     asf_uid: principal.UID = principal.ArgumentNone,
 ) -> AsyncGenerator[WriteAsCommitteeMember]:
     async with write(asf_uid) as w:
diff --git a/atr/storage/readers/checks.py b/atr/storage/readers/checks.py
index c5446ad6..466e2fc7 100644
--- a/atr/storage/readers/checks.py
+++ b/atr/storage/readers/checks.py
@@ -22,6 +22,7 @@ from typing import TYPE_CHECKING
 
 import atr.db as db
 import atr.db.interaction as interaction
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.storage as storage
 import atr.storage.types as types
@@ -54,7 +55,7 @@ class GeneralPublic:
         # Filter out any results that are ignored
         unignored_checks = []
         ignored_checks = []
-        match_ignore = await self.ignores_matcher(release.project_name)
+        match_ignore = await self.ignores_matcher(release.safe_project_name)
         for cr in all_check_results:
             if not match_ignore(cr):
                 unignored_checks.append(cr)
@@ -78,18 +79,18 @@ class GeneralPublic:
             member_results_list[member_rel_path].sort(key=lambda r: r.checker)
         return types.CheckResults(primary_results_list, member_results_list, ignored_checks)
 
-    async def ignores(self, project_name: str) -> list[sql.CheckResultIgnore]:
+    async def ignores(self, project_name: safe.ProjectName) -> list[sql.CheckResultIgnore]:
         results = await self.__data.check_result_ignore(
-            project_name=project_name,
+            project_name=str(project_name),
         ).all()
         return list(results)
 
     async def ignores_matcher(
         self,
-        project_name: str,
+        project_name: safe.ProjectName,
     ) -> Callable[[sql.CheckResult], bool]:
         ignores = await self.__data.check_result_ignore(
-            project_name=project_name,
+            project_name=str(project_name),
         ).all()
 
         def match(cr: sql.CheckResult) -> bool:
@@ -110,7 +111,7 @@ class GeneralPublic:
             # Blockers are never ignored
             return False
         if cri.release_glob is not None:
-            if not self.__check_ignore_match_pattern(cri.release_glob, cr.release_name):
+            if not self.__check_ignore_match_pattern(cri.release_glob, str(cr.release_name)):
                 return False
         if cri.revision_number is not None:
             if cri.revision_number != cr.revision_number:
diff --git a/atr/storage/readers/releases.py b/atr/storage/readers/releases.py
index 77d330fb..cfbfca0e 100644
--- a/atr/storage/readers/releases.py
+++ b/atr/storage/readers/releases.py
@@ -123,7 +123,7 @@ class GeneralPublic:
     async def __successes_errors_warnings(
         self, release: sql.Release, latest_revision_number: str, info: types.PathInfo
     ) -> None:
-        match_ignore = await self.__read_as.checks.ignores_matcher(release.project_name)
+        match_ignore = await self.__read_as.checks.ignores_matcher(release.safe_project_name)
         attestable_checks = await interaction.checks_for(
             release, revision=latest_revision_number, caller_data=self.__data
         )
diff --git a/atr/storage/writers/announce.py b/atr/storage/writers/announce.py
index aa9b0a88..a56a2997 100644
--- a/atr/storage/writers/announce.py
+++ b/atr/storage/writers/announce.py
@@ -29,6 +29,7 @@ import sqlmodel
 
 import atr.construct as construct
 import atr.db as db
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as paths
 import atr.storage as storage
@@ -103,8 +104,8 @@ class CommitteeMember(CommitteeParticipant):
 
     async def release(  # noqa: C901
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         preview_revision_number: str,
         recipient: str,
         body: str,
@@ -120,8 +121,8 @@ class CommitteeMember(CommitteeParticipant):
         finished_dir: str = ""
 
         release = await self.__data.release(
-            project_name=project_name,
-            version=version_name,
+            project_name=str(project_name),
+            version=str(version_name),
             phase=sql.ReleasePhase.RELEASE_PREVIEW,
             latest_revision_number=preview_revision_number,
             _project_release_policy=True,
@@ -196,8 +197,8 @@ class CommitteeMember(CommitteeParticipant):
             await aioshutil.move(unfinished_dir, finished_dir)
             self.__write_as.append_to_audit_log(
                 asf_uid=self.__asf_uid,
-                project_name=project_name,
-                version_name=version_name,
+                project_name=str(project_name),
+                version_name=str(version_name),
                 revision_number=preview_revision_number,
                 source_directory=unfinished_dir,
                 target_directory=finished_dir,
@@ -235,8 +236,8 @@ class CommitteeMember(CommitteeParticipant):
                     in_reply_to=None,
                 ).model_dump(),
                 asf_uid=asf_uid,
-                project_name=project_name,
-                version_name=version_name,
+                project_name=str(project_name),
+                version_name=str(version_name),
             )
             self.__data.add(task)
 
diff --git a/atr/storage/writers/checks.py b/atr/storage/writers/checks.py
index 5b2dc0a6..8140dc28 100644
--- a/atr/storage/writers/checks.py
+++ b/atr/storage/writers/checks.py
@@ -23,6 +23,7 @@ import datetime
 import sqlmodel
 
 import atr.db as db
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.models.validation as validation
 import atr.storage as storage
@@ -92,7 +93,7 @@ class CommitteeMember(CommitteeParticipant):
 
     async def ignore_add(
         self,
-        project_name: str,
+        project_name: safe.ProjectName,
         release_glob: str | None = None,
         revision_number: str | None = None,
         checker_glob: str | None = None,
@@ -101,7 +102,7 @@ class CommitteeMember(CommitteeParticipant):
         status: sql.CheckResultStatusIgnore | None = None,
         message_glob: str | None = None,
     ) -> None:
-        await self.__validate_project_in_committee(project_name)
+        await self.__validate_project_in_committee(str(project_name))
         _validate_ignore_patterns(
             release_glob,
             checker_glob,
@@ -112,7 +113,7 @@ class CommitteeMember(CommitteeParticipant):
         cri = sql.CheckResultIgnore(
             asf_uid=self.__asf_uid,
             created=datetime.datetime.now(datetime.UTC),
-            project_name=project_name,
+            project_name=str(project_name),
             release_glob=release_glob,
             revision_number=revision_number,
             checker_glob=checker_glob,
diff --git a/atr/storage/writers/distributions.py b/atr/storage/writers/distributions.py
index 34a40c9b..98adfdea 100644
--- a/atr/storage/writers/distributions.py
+++ b/atr/storage/writers/distributions.py
@@ -94,12 +94,12 @@ class CommitteeMember(CommitteeParticipant):
 
     async def automate(
         self,
-        release_name: str,
+        release_name: models.safe.ReleaseName,
         platform: models.sql.DistributionPlatform,
         committee_name: str,
         owner_namespace: str | None,
-        project_name: str,
-        version_name: str,
+        project_name: models.safe.ProjectName,
+        version_name: models.safe.VersionName,
         phase: str,
         revision_number: str | None,
         package: str,
@@ -109,7 +109,7 @@ class CommitteeMember(CommitteeParticipant):
         dist_task = models.sql.Task(
             task_type=models.sql.TaskType.DISTRIBUTION_WORKFLOW,
             task_args=gha.DistributionWorkflow(
-                name=release_name,
+                name=str(release_name),
                 namespace=owner_namespace or "",
                 package=package,
                 version=version,
@@ -125,8 +125,8 @@ class CommitteeMember(CommitteeParticipant):
             asf_uid=util.unwrap(self.__asf_uid),
             added=datetime.datetime.now(datetime.UTC),
             status=models.sql.TaskStatus.QUEUED,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
             revision_number=revision_number,
         )
         self.__data.add(dist_task)
@@ -136,7 +136,7 @@ class CommitteeMember(CommitteeParticipant):
 
     async def record(
         self,
-        release_name: str,
+        release_name: models.safe.ReleaseName,
         platform: models.sql.DistributionPlatform,
         owner_namespace: str | None,
         package: str,
@@ -147,10 +147,12 @@ class CommitteeMember(CommitteeParticipant):
         api_url: str | None = None,
         web_url: str | None = None,
     ) -> tuple[models.sql.Distribution, bool]:
-        existing = await self.__data.distribution(release_name, platform, owner_namespace or "", package, version).get()
+        existing = await self.__data.distribution(
+            str(release_name), platform, owner_namespace or "", package, version
+        ).get()
         dist = models.sql.Distribution(
             platform=platform,
-            release_name=release_name,
+            release_name=str(release_name),
             owner_namespace=owner_namespace or "",
             package=package,
             version=version,
@@ -194,7 +196,7 @@ class CommitteeMember(CommitteeParticipant):
 
     async def record_from_data(
         self,
-        release_name: str,
+        release_name: models.safe.ReleaseName,
         staging: bool,
         dd: models.distribution.Data,
         allow_retries: bool = False,
@@ -250,7 +252,7 @@ class CommitteeMember(CommitteeParticipant):
 
     async def __upgrade_staging_to_final(
         self,
-        release_name: str,
+        release_name: models.safe.ReleaseName,
         platform: models.sql.DistributionPlatform,
         owner_namespace: str | None,
         package: str,
@@ -262,7 +264,7 @@ class CommitteeMember(CommitteeParticipant):
     ) -> models.sql.Distribution | None:
         tag = f"{release_name} {platform} {owner_namespace or ''} {package} {version}"
         existing = await self.__data.distribution(
-            release_name=release_name,
+            release_name=str(release_name),
             platform=platform,
             owner_namespace=(owner_namespace or ""),
             package=package,
@@ -281,14 +283,14 @@ class CommitteeMember(CommitteeParticipant):
 
     async def delete_distribution(
         self,
-        release_name: str,
+        release_name: models.safe.ReleaseName,
         platform: models.sql.DistributionPlatform,
         owner_namespace: str,
         package: str,
         version: str,
     ) -> None:
         distribution = await self.__data.distribution(
-            release_name=release_name,
+            release_name=str(release_name),
             platform=platform,
             owner_namespace=owner_namespace,
             package=package,
diff --git a/atr/storage/writers/keys.py b/atr/storage/writers/keys.py
index b0cb6ee4..cfc07d5e 100644
--- a/atr/storage/writers/keys.py
+++ b/atr/storage/writers/keys.py
@@ -40,6 +40,7 @@ import sqlmodel
 import atr.config as config
 import atr.db as db
 import atr.log as log
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as paths
 import atr.storage as storage
@@ -465,10 +466,12 @@ class CommitteeParticipant(FoundationCommitter):
             await self.autogenerate_keys_file()
         return outcomes
 
-    async def import_keys_file(self, project_name: str, version_name: str) -> outcome.List[types.Key]:
+    async def import_keys_file(
+        self, project_name: safe.ProjectName, version_name: safe.VersionName
+    ) -> outcome.List[types.Key]:
         release = await self.__data.release(
-            project_name=project_name,
-            version=version_name,
+            project_name=str(project_name),
+            version=str(version_name),
             _committee=True,
         ).demand(storage.AccessError(f"Release not found: {project_name} {version_name}"))
         keys_path = paths.release_directory(release) / "KEYS"
@@ -478,7 +481,7 @@ class CommitteeParticipant(FoundationCommitter):
             raise storage.AccessError("No committee found for release - Invalid state")
         if release.committee.name != self.__committee_name:
             raise storage.AccessError(
-                f"Release {project_name} {version_name} is not associated with committee {self.__committee_name}"
+                f"Release {project_name!s} {version_name!s} is not associated with committee {self.__committee_name}"
             )
 
         outcomes = await self.ensure_associated(keys_file_text)
diff --git a/atr/storage/writers/policy.py b/atr/storage/writers/policy.py
index a6ff2760..79f0f6f8 100644
--- a/atr/storage/writers/policy.py
+++ b/atr/storage/writers/policy.py
@@ -129,7 +129,7 @@ class CommitteeMember(CommitteeParticipant):
         release_policy.file_tag_mappings = atr_tags_dict
         release_policy.strict_checking = form.strict_checking
 
-        await self.__commit_and_log(project_name)
+        await self.__commit_and_log(str(project_name))
 
     async def edit_finish(self, form: shared.projects.FinishPolicyForm) -> None:
         project_name = form.project_name
@@ -140,7 +140,7 @@ class CommitteeMember(CommitteeParticipant):
         self.__set_announce_release_template(form.announce_release_template or "", project, release_policy)
         release_policy.preserve_download_files = form.preserve_download_files
 
-        await self.__commit_and_log(project_name)
+        await self.__commit_and_log(str(project_name))
 
     async def edit_vote(self, form: shared.projects.VotePolicyForm) -> None:
         project_name = form.project_name
@@ -160,7 +160,7 @@ class CommitteeMember(CommitteeParticipant):
         elif project.committee and project.committee.is_podling:
             raise storage.AccessError("Manual voting is not allowed for podlings.")
 
-        await self.__commit_and_log(project_name)
+        await self.__commit_and_log(str(str(project_name)))
 
     async def __commit_and_log(self, project_name: str) -> None:
         await self.__data.commit()
@@ -169,9 +169,11 @@ class CommitteeMember(CommitteeParticipant):
             project_name=project_name,
         )
 
-    async def __get_or_create_policy(self, project_name: str) -> tuple[models.sql.Project, models.sql.ReleasePolicy]:
+    async def __get_or_create_policy(
+        self, project_name: models.safe.ProjectName
+    ) -> tuple[models.sql.Project, models.sql.ReleasePolicy]:
         project = await self.__data.project(
-            name=project_name, status=models.sql.ProjectStatus.ACTIVE, _release_policy=True, _committee=True
+            name=str(project_name), status=models.sql.ProjectStatus.ACTIVE, _release_policy=True, _committee=True
         ).demand(storage.AccessError(f"Project {project_name} not found"))
 
         release_policy = project.release_policy
diff --git a/atr/storage/writers/project.py b/atr/storage/writers/project.py
index 69a3b8ce..0580a2bc 100644
--- a/atr/storage/writers/project.py
+++ b/atr/storage/writers/project.py
@@ -21,6 +21,7 @@ from __future__ import annotations
 import datetime
 
 import atr.db as db
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.registry as registry
 import atr.storage as storage
@@ -106,7 +107,7 @@ class CommitteeMember(CommitteeParticipant):
             await self.__data.commit()
             self.__write_as.append_to_audit_log(
                 asf_uid=self.__asf_uid,
-                project_name=project.name,
+                project_name=str(project.name),
                 category=new_category,
             )
             return True
@@ -125,7 +126,7 @@ class CommitteeMember(CommitteeParticipant):
             await self.__data.commit()
             self.__write_as.append_to_audit_log(
                 asf_uid=self.__asf_uid,
-                project_name=project.name,
+                project_name=str(project.name),
                 category=action_value,
             )
             return True
@@ -133,6 +134,8 @@ class CommitteeMember(CommitteeParticipant):
 
     async def create(self, committee_name: str, display_name: str, label: str) -> None:
         super_project = None
+        # Wrap the name in safe.ProjectName so we can create it in the database
+        # TODO: Do we need to do any additional validation on the string value?
         # Get the base project to derive from
         # We're allowing derivation from a retired project here
         # TODO: Should we disallow this instead?
@@ -140,8 +143,8 @@ class CommitteeMember(CommitteeParticipant):
             committee_name=committee_name, _committee=True, _release_policy=True
         ).all()
         for committee_project in committee_projects:
-            if label.startswith(committee_project.name + "-"):
-                if (super_project is None) or (len(super_project.name) < len(committee_project.name)):
+            if label.startswith(str(committee_project.name) + "-"):
+                if (super_project is None) or (len(str(super_project.name)) < len(str(committee_project.name))):
                     super_project = committee_project
 
         # Check whether the project already exists
@@ -173,9 +176,9 @@ class CommitteeMember(CommitteeParticipant):
             project_name=label,
         )
 
-    async def delete(self, project_name: str) -> None:
+    async def delete(self, project_name: safe.ProjectName) -> None:
         project = await self.__data.project(
-            name=project_name, status=sql.ProjectStatus.ACTIVE, _releases=True, _distribution_channels=True
+            name=str(project_name), status=sql.ProjectStatus.ACTIVE, _releases=True, _distribution_channels=True
         ).get()
 
         if not project:
@@ -197,7 +200,7 @@ class CommitteeMember(CommitteeParticipant):
         await self.__data.commit()
         self.__write_as.append_to_audit_log(
             asf_uid=self.__asf_uid,
-            project_name=project_name,
+            project_name=str(project_name),
         )
         return None
 
@@ -216,7 +219,7 @@ class CommitteeMember(CommitteeParticipant):
             await self.__data.commit()
             self.__write_as.append_to_audit_log(
                 asf_uid=self.__asf_uid,
-                project_name=project.name,
+                project_name=str(project.name),
                 language=new_language,
             )
             return True
@@ -233,7 +236,7 @@ class CommitteeMember(CommitteeParticipant):
             await self.__data.commit()
             self.__write_as.append_to_audit_log(
                 asf_uid=self.__asf_uid,
-                project_name=project.name,
+                project_name=str(project.name),
                 language=action_value,
             )
             return True
diff --git a/atr/storage/writers/release.py b/atr/storage/writers/release.py
index 10188b5f..37ba75fc 100644
--- a/atr/storage/writers/release.py
+++ b/atr/storage/writers/release.py
@@ -35,6 +35,7 @@ import atr.db as db
 import atr.form as form
 import atr.log as log
 import atr.models.api as api
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as paths
 import atr.storage as storage
@@ -95,24 +96,24 @@ class CommitteeParticipant(FoundationCommitter):
 
     async def delete(
         self,
-        project_name: str,
-        version: str,
+        project_name: safe.ProjectName,
+        version: safe.VersionName,
         phase: db.Opt[sql.ReleasePhase] = db.NOT_SET,
         include_downloads: bool = True,
     ) -> str | None:
         """Handle the deletion of database records and filesystem data for a release."""
         release = await self.__data.release(
-            project_name=project_name, version=version, phase=phase, _committee=True
-        ).demand(storage.AccessError(f"Release '{project_name} {version}' not found."))
+            project_name=str(project_name), version=str(version), phase=phase, _committee=True
+        ).demand(storage.AccessError(f"Release '{project_name!s} {version!s}' not found."))
         release_dirs = [
             paths.release_directory_base(release),
-            paths.get_attestable_dir() / project_name / version,
-            paths.get_cache_archives_dir() / project_name / version,
-            paths.get_quarantined_dir() / project_name / version,
+            paths.get_attestable_dir() / str(project_name) / str(version),
+            paths.get_cache_archives_dir() / str(project_name) / str(version),
+            paths.get_quarantined_dir() / str(project_name) / str(version),
         ]
 
         # Delete from the database using bulk SQL DELETE for efficiency
-        log.info(f"Deleting database records for release: {project_name} {version}")
+        log.info(f"Deleting database records for release: {project_name!s} {version!s}")
 
         # Bulk delete tasks
         # These is no cascade, so we must delete explicitly
@@ -123,11 +124,11 @@ class CommitteeParticipant(FoundationCommitter):
         )
         task_result = await self.__data.execute(task_delete_stmt)
         task_count = task_result.rowcount if isinstance(task_result, engine.CursorResult) else 0
-        log.debug(f"Deleted {util.plural(task_count, 'task')} for {project_name} {version}")
+        log.debug(f"Deleted {util.plural(task_count, 'task')} for {project_name!s} {version!s}")
 
         release_name = release.name
         await self.__data.delete(release)
-        log.info(f"Deleted release record: {project_name} {version}")
+        log.info(f"Deleted release record: {project_name!s} {version!s}")
 
         # In test mode, delete the counter for test committee releases
         # This allows revision numbers to be reused in testing
@@ -150,14 +151,14 @@ class CommitteeParticipant(FoundationCommitter):
 
         self.__write_as.append_to_audit_log(
             asf_uid=self.__asf_uid,
-            project_name=project_name,
-            version=version,
+            project_name=str(project_name),
+            version=str(version),
             error=error,
         )
         return error
 
     async def delete_empty_directory(
-        self, project_name: str, version_name: str, dir_to_delete_rel: pathlib.Path
+        self, project_name: safe.ProjectName, version_name: safe.VersionName, dir_to_delete_rel: pathlib.Path
     ) -> str | None:
         description = f"Delete empty directory {dir_to_delete_rel} via web interface"
 
@@ -179,7 +180,9 @@ class CommitteeParticipant(FoundationCommitter):
             return str(e)
         return None
 
-    async def delete_file(self, project_name: str, version: str, rel_path_to_delete: pathlib.Path) -> int:
+    async def delete_file(
+        self, project_name: safe.ProjectName, version: safe.VersionName, rel_path_to_delete: pathlib.Path
+    ) -> int:
         metadata_files_deleted = 0
         description = "File deletion through web interface"
 
@@ -217,7 +220,9 @@ class CommitteeParticipant(FoundationCommitter):
         )
         return metadata_files_deleted
 
-    async def generate_hash_file(self, project_name: str, version_name: str, rel_path: pathlib.Path) -> None:
+    async def generate_hash_file(
+        self, project_name: safe.ProjectName, version_name: safe.VersionName, rel_path: pathlib.Path
+    ) -> None:
         description = "Hash generation through web interface"
 
         async def modify(path: pathlib.Path, _old_rev: sql.Revision | None) -> None:
@@ -256,7 +261,12 @@ class CommitteeParticipant(FoundationCommitter):
         )
 
     async def import_from_svn(
-        self, project_name: str, version_name: str, svn_url: str, revision: str, target_subdirectory: str | None
+        self,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
+        svn_url: str,
+        revision: str,
+        target_subdirectory: str | None,
     ) -> sql.Task:
         task_args = {
             "svn_url": svn_url,
@@ -272,8 +282,8 @@ class CommitteeParticipant(FoundationCommitter):
             asf_uid=util.unwrap(self.__asf_uid),
             added=datetime.datetime.now(datetime.UTC),
             status=sql.TaskStatus.QUEUED,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
         )
         self.__data.add(svn_import_task)
         await self.__data.commit()
@@ -281,7 +291,11 @@ class CommitteeParticipant(FoundationCommitter):
         return svn_import_task
 
     async def move_file(
-        self, project_name: str, version_name: str, source_files_rel: list[pathlib.Path], target_dir_rel: pathlib.Path
+        self,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
+        source_files_rel: list[pathlib.Path],
+        target_dir_rel: pathlib.Path,
     ) -> tuple[str | None, list[str], list[str]]:
         description = "File move through web interface"
         moved_files_names: list[str] = []
@@ -306,16 +320,16 @@ class CommitteeParticipant(FoundationCommitter):
 
     async def promote_to_candidate(
         self,
-        release_name: str,
+        release_name: safe.ReleaseName,
         selected_revision_number: str,
         vote_manual: bool = False,
     ) -> str | None:
         """Promote a release candidate draft to a new phase."""
-        release_for_pre_checks = await self.__data.release(name=release_name, _project=True).demand(
+        release_for_pre_checks = await self.__data.release(name=str(release_name), _project=True).demand(
             storage.AccessError("Release candidate draft not found")
         )
-        project_name = release_for_pre_checks.project.name
-        version_name = release_for_pre_checks.version
+        project_name = release_for_pre_checks.safe_project_name
+        version_name = release_for_pre_checks.safe_version_name
 
         # Check for ongoing tasks
         ongoing_tasks = await self.__tasks_ongoing(project_name, version_name, selected_revision_number)
@@ -362,13 +376,15 @@ class CommitteeParticipant(FoundationCommitter):
         await self.__data.commit()
         self.__write_as.append_to_audit_log(
             asf_uid=self.__asf_uid,
-            release_name=release_name,
+            release_name=str(release_name),
             selected_revision_number=selected_revision_number,
             vote_manual=vote_manual,
         )
         return None
 
-    async def remove_rc_tags(self, project_name: str, version_name: str) -> tuple[str | None, int, list[str]]:
+    async def remove_rc_tags(
+        self, project_name: safe.ProjectName, version_name: safe.VersionName
+    ) -> tuple[str | None, int, list[str]]:
         description = "Remove RC tags from paths via web interface"
         error_messages: list[str] = []
         renamed_count = 0
@@ -385,10 +401,13 @@ class CommitteeParticipant(FoundationCommitter):
             return str(e), renamed_count, error_messages
         return None, renamed_count, error_messages
 
-    async def start(self, project_name: str, version: str) -> tuple[sql.Release, sql.Project]:  # noqa: C901
+    async def start(self, project_name: safe.ProjectName, version: str) -> tuple[sql.Release, sql.Project]:  # noqa: C901
         """Creates the initial release draft record and revision directory."""
         # Get the project from the project name
-        project = await self.__data.project(name=project_name, status=sql.ProjectStatus.ACTIVE, _committee=True).get()
+        project = await self.__data.project(
+            name=str(project_name), status=sql.ProjectStatus.ACTIVE, _committee=True
+        ).get()
+        version_name = safe.VersionName(version)
         if not project:
             raise storage.AccessError(f"Project {project_name} not found")
 
@@ -415,7 +434,7 @@ class CommitteeParticipant(FoundationCommitter):
 
         # TODO: Consider using Release.revision instead of ./latest
         # Check whether the release already exists
-        if release := await self.__data.release(project_name=project.name, version=version).get():
+        if release := await self.__data.release(project_name=project.name, version=str(version_name)).get():
             match release.phase:
                 case sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT:
                     phase_desc = "A draft release (being composed)"
@@ -425,19 +444,18 @@ class CommitteeParticipant(FoundationCommitter):
                     phase_desc = "A release preview (being finished)"
                 case sql.ReleasePhase.RELEASE:
                     phase_desc = "A finished release"
-            raise storage.AccessError(f"{phase_desc} for {project_name} {version} already exists.")
+            raise storage.AccessError(f"{phase_desc} for {project_name!s} {version} already exists.")
 
         # Validate the version name
         # TODO: We should check that it's bigger than the current version
         # We have the packaging library as a dependency, but it is Python specific
         if version_name_error := util.version_name_error(version):
-            raise storage.AccessError(f'Invalid version name "{version}": {version_name_error}')
-
+            raise storage.AccessError(f'Invalid version name "{version!s}": {version_name_error}')
         release = sql.Release(
             phase=sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT,
             project_name=project.name,
             project=project,
-            version=version,
+            version=str(version_name),
             created=datetime.datetime.now(datetime.UTC),
         )
         self.__data.add(release)
@@ -450,8 +468,8 @@ class CommitteeParticipant(FoundationCommitter):
         )
         self.__write_as.append_to_audit_log(
             asf_uid=self.__asf_uid,
-            project_name=project_name,
-            version=version,
+            project_name=project.name,
+            version=str(version),
             created=release.created.isoformat(),
         )
         return release, project
@@ -479,14 +497,14 @@ class CommitteeParticipant(FoundationCommitter):
         async with db.session() as data:
             release_name = sql.release_name(args.project, args.version)
             return await data.revision(
-                release_name=release_name,
+                release_name=str(release_name),
                 number=result.number,
             ).demand(storage.AccessError("Revision not found"))
 
     async def upload_files(
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         file_name: pathlib.Path | None,
         files: Sequence[datastructures.FileStorage],
     ) -> tuple[str | None, int, bool]:
@@ -558,7 +576,7 @@ class CommitteeParticipant(FoundationCommitter):
                         continue
 
     async def __delete_release_data_filesystem(
-        self, release_dirs: Sequence[pathlib.Path], project_name: str, version: str
+        self, release_dirs: Sequence[pathlib.Path], project_name: safe.ProjectName, version: safe.VersionName
     ) -> str | None:
         delete_errors: list[str] = []
         for release_dir in release_dirs:
@@ -566,7 +584,7 @@ class CommitteeParticipant(FoundationCommitter):
                 try:
                     log.info(f"Deleting filesystem directory: {release_dir}")
                     await util.delete_immutable_directory(
-                        release_dir, reason=f"user {self.__asf_uid} is deleting release {project_name} {version}"
+                        release_dir, reason=f"user {self.__asf_uid} is deleting release {project_name!s} {version!s}"
                     )
                     log.info(f"Successfully deleted directory: {release_dir}")
                 except Exception as e:
@@ -576,7 +594,7 @@ class CommitteeParticipant(FoundationCommitter):
                 log.warning(f"Filesystem directory not found, skipping deletion: {release_dir}")
         if delete_errors:
             return (
-                f"Database records for '{project_name} {version}' deleted,"
+                f"Database records for '{project_name!s} {version!s}' deleted,"
                 f" but failed to delete filesystem directories: {', '.join(delete_errors)}"
             )
         return None
@@ -747,7 +765,9 @@ class CommitteeParticipant(FoundationCommitter):
                 if f == source_file_rel:
                     moved_files_names.append(f.name)
 
-    async def __tasks_ongoing(self, project_name: str, version_name: str, revision_number: str | None = None) -> int:
+    async def __tasks_ongoing(
+        self, project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str | None = None
+    ) -> int:
         tasks = sqlmodel.select(sqlalchemy.func.count()).select_from(sql.Task)
         query = tasks.where(
             sql.Task.project_name == project_name,
diff --git a/atr/storage/writers/revision.py b/atr/storage/writers/revision.py
index e3bcde32..1255ebde 100644
--- a/atr/storage/writers/revision.py
+++ b/atr/storage/writers/revision.py
@@ -35,6 +35,7 @@ import atr.db as db
 import atr.db.interaction as interaction
 import atr.detection as detection
 import atr.merge as merge
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as paths
 import atr.storage as storage
@@ -82,12 +83,12 @@ async def finalise_revision(
     path_to_hash: dict[str, str],
     path_to_size: dict[str, int],
     previous_attestable: atr.models.attestable.AttestableV1 | None,
-    project_name: str,
+    project_name: safe.ProjectName,
     release: sql.Release,
-    release_name: str,
+    release_name: safe.ReleaseName,
     temp_dir: str,
     temp_dir_path: pathlib.Path,
-    version_name: str,
+    version_name: safe.VersionName,
     was_quarantined: bool = False,
 ) -> sql.Revision:
     try:
@@ -120,7 +121,7 @@ async def finalise_revision(
         previous_attestable=previous_attestable,
         project_name=project_name,
         release=merged_release,
-        release_name=release_name,
+        release_name=str(release_name),
         temp_dir=temp_dir,
         version_name=version_name,
         was_quarantined=was_quarantined,
@@ -135,11 +136,11 @@ async def _commit_new_revision(
     path_to_hash: dict[str, str],
     path_to_size: dict[str, int],
     previous_attestable: atr.models.attestable.AttestableV1 | None,
-    project_name: str,
+    project_name: safe.ProjectName,
     release: sql.Release,
     release_name: str,
     temp_dir: str,
-    version_name: str,
+    version_name: safe.VersionName,
     was_quarantined: bool = False,
 ) -> sql.Revision:
     try:
@@ -238,11 +239,11 @@ async def _lock_and_merge(
     path_to_hash: dict[str, str],
     path_to_size: dict[str, int],
     previous_attestable: atr.models.attestable.AttestableV1 | None,
-    project_name: str,
+    project_name: safe.ProjectName,
     release: sql.Release,
-    _release_name: str,
+    _release_name: safe.ReleaseName,
     temp_dir_path: pathlib.Path,
-    version_name: str,
+    version_name: safe.VersionName,
 ) -> tuple[atr.models.attestable.AttestableV1 | None, str | None, sql.Release]:
     # Acquire the write lock
     # We need this write lock for moving the directory afterwards atomically
@@ -325,8 +326,8 @@ class CommitteeParticipant(FoundationCommitter):
 
     async def create_revision_with_quarantine(  # noqa: C901
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         asf_uid: str,
         description: str | None = None,
         set_local_cache: bool = False,
@@ -335,7 +336,7 @@ class CommitteeParticipant(FoundationCommitter):
         clone_from: str | None = None,
     ) -> sql.Revision | sql.Quarantined:
         """Create a new revision, quarantining archives that require validation."""
-        release_name = sql.release_name(project_name, version_name)
+        release_name = sql.release_name(str(project_name), str(version_name))
         async with db.session() as data:
             release = await data.release(name=release_name, _release_policy=True, _project_release_policy=True).demand(
                 RuntimeError("Release does not exist for new revision creation")
@@ -417,6 +418,7 @@ class CommitteeParticipant(FoundationCommitter):
 
         async with SafeSession(temp_dir) as data:
             try:
+                # TODO: Do we really need _release_name when we have release in this method?
                 previous_attestable, prior_revision_name, merged_release = await _lock_and_merge(
                     data,
                     base_hashes=base_hashes,
@@ -429,7 +431,7 @@ class CommitteeParticipant(FoundationCommitter):
                     previous_attestable=previous_attestable,
                     project_name=project_name,
                     release=release,
-                    _release_name=release_name,
+                    _release_name=release.safe_name,
                     temp_dir_path=temp_dir_path,
                     version_name=version_name,
                 )
@@ -477,10 +479,10 @@ class CommitteeParticipant(FoundationCommitter):
         description: str | None,
         path_to_size: dict[str, int],
         prior_revision_name: str | None,
-        project_name: str,
+        project_name: safe.ProjectName,
         release_name: str,
         temp_dir: str,
-        version_name: str,
+        version_name: safe.VersionName,
     ) -> sql.Quarantined:
         file_metadata = [
             sql.QuarantineFileEntryV1(
@@ -529,8 +531,8 @@ class CommitteeParticipant(FoundationCommitter):
                     ],
                 },
                 asf_uid=asf_uid,
-                project_name=project_name,
-                version_name=version_name,
+                project_name=str(project_name),
+                version_name=str(version_name),
                 revision_number=None,
                 primary_rel_path=None,
             )
diff --git a/atr/storage/writers/sbom.py b/atr/storage/writers/sbom.py
index b68a6cc9..aa88c42f 100644
--- a/atr/storage/writers/sbom.py
+++ b/atr/storage/writers/sbom.py
@@ -23,6 +23,7 @@ import datetime
 from typing import TYPE_CHECKING
 
 import atr.db as db
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.storage as storage
 import atr.tasks.sbom as sbom
@@ -77,8 +78,8 @@ class CommitteeParticipant(FoundationCommitter):
 
     async def augment_cyclonedx(
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         revision_number: str,
         rel_path: pathlib.Path,
     ) -> sql.Task:
@@ -94,8 +95,8 @@ class CommitteeParticipant(FoundationCommitter):
             asf_uid=util.unwrap(self.__asf_uid),
             added=datetime.datetime.now(datetime.UTC),
             status=sql.TaskStatus.QUEUED,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
             revision_number=revision_number,
             primary_rel_path=str(rel_path),
         )
@@ -106,8 +107,8 @@ class CommitteeParticipant(FoundationCommitter):
 
     async def generate_cyclonedx(
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         revision_number: str,
         path_in_new_revision: pathlib.Path,
         sbom_path_in_new_revision: pathlib.Path,
@@ -125,8 +126,8 @@ class CommitteeParticipant(FoundationCommitter):
             asf_uid=util.unwrap(self.__asf_uid),
             added=datetime.datetime.now(datetime.UTC),
             status=sql.TaskStatus.QUEUED,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
             revision_number=revision_number,
         )
         self.__data.add(sbom_task)
@@ -136,8 +137,8 @@ class CommitteeParticipant(FoundationCommitter):
 
     async def osv_scan_cyclonedx(
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         revision_number: str,
         rel_path: pathlib.Path,
     ) -> sql.Task:
@@ -153,8 +154,8 @@ class CommitteeParticipant(FoundationCommitter):
             asf_uid=util.unwrap(self.__asf_uid),
             added=datetime.datetime.now(datetime.UTC),
             status=sql.TaskStatus.QUEUED,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
             revision_number=revision_number,
             primary_rel_path=str(rel_path),
         )
diff --git a/atr/storage/writers/ssh.py b/atr/storage/writers/ssh.py
index 555a173c..f122597e 100644
--- a/atr/storage/writers/ssh.py
+++ b/atr/storage/writers/ssh.py
@@ -22,6 +22,7 @@ import time
 from typing import Any
 
 import atr.db as db
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.storage as storage
 import atr.util as util
@@ -85,7 +86,7 @@ class CommitteeParticipant(FoundationCommitter):
         self.__committee_name = committee_name
 
     async def add_workflow_key(
-        self, github_uid: str, github_nid: int, project_name: str, key: str, github_payload: dict[str, Any]
+        self, github_uid: str, github_nid: int, project_name: safe.ProjectName, key: str, github_payload: dict[str, Any]
     ) -> tuple[str, int]:
         now = int(time.time())
         # Twenty minutes to upload all files
@@ -95,7 +96,7 @@ class CommitteeParticipant(FoundationCommitter):
         wsk = sql.WorkflowSSHKey(
             fingerprint=fingerprint,
             key=key,
-            project_name=project_name,
+            project_name=str(project_name),
             asf_uid=self.__asf_uid,
             github_uid=github_uid,
             github_nid=github_nid,
@@ -107,7 +108,7 @@ class CommitteeParticipant(FoundationCommitter):
         self.__write_as.append_to_audit_log(
             asf_uid=self.__asf_uid,
             fingerprint=fingerprint,
-            project_name=project_name,
+            project_name=str(project_name),
             github_uid=github_uid,
             github_nid=github_nid,
             expires=expires,
diff --git a/atr/storage/writers/vote.py b/atr/storage/writers/vote.py
index d8925418..fd02efbb 100644
--- a/atr/storage/writers/vote.py
+++ b/atr/storage/writers/vote.py
@@ -26,6 +26,7 @@ import atr.db as db
 import atr.db.interaction as interaction
 import atr.log as log
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.storage as storage
 import atr.tasks.message as message
@@ -136,8 +137,8 @@ class CommitteeParticipant(FoundationCommitter):
     async def start(
         self,
         email_to: str,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         selected_revision_number: str,
         vote_duration_choice: int,
         subject: str,
@@ -150,8 +151,8 @@ class CommitteeParticipant(FoundationCommitter):
     ) -> sql.Task:
         if release is None:
             release = await self.__data.release(
-                project_name=project_name,
-                version=version_name,
+                project_name=str(project_name),
+                version=str(version_name),
                 _project=True,
                 _committee=True,
             ).demand(storage.AccessError("Release not found"))
@@ -170,7 +171,7 @@ class CommitteeParticipant(FoundationCommitter):
         if promote is True:
             # This verifies the state and sets the phase to RELEASE_CANDIDATE
             error = await self.__write_as.release.promote_to_candidate(
-                release.name, selected_revision_number, vote_manual=False
+                release.safe_name, selected_revision_number, vote_manual=False
             )
             if error:
                 raise storage.AccessError(error)
@@ -187,7 +188,7 @@ class CommitteeParticipant(FoundationCommitter):
             status=sql.TaskStatus.QUEUED,
             task_type=sql.TaskType.VOTE_INITIATE,
             task_args=tasks_vote.Initiate(
-                release_name=release.name,
+                release_name=release.safe_name,
                 email_to=email_to,
                 vote_duration=vote_duration_choice,
                 initiator_id=asf_uid,
@@ -196,8 +197,8 @@ class CommitteeParticipant(FoundationCommitter):
                 body=body_data,
             ).model_dump(),
             asf_uid=asf_uid,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
         )
         self.__data.add(task)
         await self.__data.commit()
@@ -228,14 +229,14 @@ class CommitteeMember(CommitteeParticipant):
 
     async def resolve(
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         vote_result: Literal["passed", "failed"],
         asf_fullname: str,
         resolution_body: str,
     ) -> tuple[sql.Release, int | None, str, str | None]:
         release = await self.__data.release(
-            name=sql.release_name(project_name, version_name),
+            name=sql.release_name(str(project_name), str(version_name)),
             phase=sql.ReleasePhase.RELEASE_CANDIDATE,
             _project=True,
             _committee=True,
@@ -268,12 +269,12 @@ class CommitteeMember(CommitteeParticipant):
 
     async def resolve_manually(
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         vote_result: Literal["passed", "failed"],
     ) -> str:
         release = await self.__data.release(
-            name=sql.release_name(project_name, version_name),
+            name=sql.release_name(str(project_name), str(version_name)),
             phase=sql.ReleasePhase.RELEASE_CANDIDATE,
             _project=True,
             _committee=True,
@@ -297,7 +298,7 @@ class CommitteeMember(CommitteeParticipant):
 
             description = "Create a preview revision from the last candidate draft"
             await self.__write_as.revision.create_revision_with_quarantine(
-                project_name, release.version, self.__asf_uid, description=description
+                project_name, release.safe_version_name, self.__asf_uid, description=description
             )
         else:
             release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
@@ -309,15 +310,15 @@ class CommitteeMember(CommitteeParticipant):
 
         self.__write_as.append_to_audit_log(
             asf_uid=self.__asf_uid,
-            project_name=project_name,
-            version_name=version_name,
+            project_name=str(project_name),
+            version_name=str(version_name),
             vote_result=vote_result,
         )
         return success_message
 
     async def resolve_release(
         self,
-        project_name: str,
+        project_name: safe.ProjectName,
         release: sql.Release,
         voting_round: int | None,
         vote_result: Literal["passed", "failed"],
@@ -350,13 +351,13 @@ class CommitteeMember(CommitteeParticipant):
             if revision_number is None:
                 raise ValueError("Release has no revision number - Invalid state")
             vote_duration = latest_vote_task.task_args["vote_duration"]
-            subject_template = await construct.start_vote_subject_default(release.project.name)
-            body_template = await construct.start_vote_default(release.project.name)
+            subject_template = await construct.start_vote_subject_default(release.safe_project_name)
+            body_template = await construct.start_vote_default(release.safe_project_name)
             options = construct.StartVoteOptions(
                 asfuid=self.__asf_uid,
                 fullname=asf_fullname,
-                project_name=release.project.name,
-                version_name=release.version,
+                project_name=release.safe_project_name,
+                version_name=release.safe_version_name,
                 revision_number=revision_number,
                 vote_duration=vote_duration,
             )
@@ -366,8 +367,8 @@ class CommitteeMember(CommitteeParticipant):
             await self.start(
                 email_to=incubator_vote_address,
                 permitted_recipients=[incubator_vote_address],
-                project_name=release.project.name,
-                version_name=release.version,
+                project_name=release.safe_project_name,
+                version_name=release.safe_version_name,
                 selected_revision_number=revision_number,
                 asf_uid=self.__asf_uid,
                 asf_fullname=asf_fullname,
@@ -387,7 +388,7 @@ class CommitteeMember(CommitteeParticipant):
 
             description = "Create a preview revision from the last candidate draft"
             await self.__write_as.revision.create_revision_with_quarantine(
-                project_name, release.version, self.__asf_uid, description=description
+                project_name, release.safe_version_name, self.__asf_uid, description=description
             )
             if (voting_round == 2) and (release.podling_thread_id is not None):
                 round_one_email_address, round_one_message_id = await util.email_mid_from_thread_id(
@@ -414,8 +415,8 @@ class CommitteeMember(CommitteeParticipant):
         # TODO: Could move this up before send_resolution
         self.__write_as.append_to_audit_log(
             asf_uid=self.__asf_uid,
-            project_name=project_name,
-            version_name=release.version,
+            project_name=str(project_name),
+            version_name=str(release.version),
             vote_result=vote_result,
             voting_round=voting_round,
         )
diff --git a/atr/storage/writers/workflowstatus.py b/atr/storage/writers/workflowstatus.py
index f944c796..1730afe0 100644
--- a/atr/storage/writers/workflowstatus.py
+++ b/atr/storage/writers/workflowstatus.py
@@ -19,6 +19,7 @@
 from __future__ import annotations
 
 import atr.db as db
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.storage as storage
 
@@ -103,7 +104,7 @@ class CommitteeMember(CommitteeParticipant):
         self,
         workflow_id: str,
         run_id: int,
-        project_name: str,
+        project_name: safe.ProjectName,
         task_id: int | None = None,
         status: str | None = None,
         message: str | None = None,
@@ -116,7 +117,7 @@ class CommitteeMember(CommitteeParticipant):
         ws = sql.WorkflowStatus(
             workflow_id=workflow_id,
             run_id=run_id,
-            project_name=project_name,
+            project_name=str(project_name),
             task_id=task_id,
             status=status or "",
             message=message,
@@ -126,7 +127,7 @@ class CommitteeMember(CommitteeParticipant):
         self.__write_as.append_to_audit_log(
             workflow_id=workflow_id,
             run_id=run_id,
-            project_name=project_name,
+            project_name=str(project_name),
             task_id=task_id,
             status=status,
             message=message,
diff --git a/atr/tasks/__init__.py b/atr/tasks/__init__.py
index b79b8017..a4ffe630 100644
--- a/atr/tasks/__init__.py
+++ b/atr/tasks/__init__.py
@@ -29,6 +29,7 @@ import atr.attestable as attestable
 import atr.db as db
 import atr.hashes as hashes
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as file_paths
 import atr.tasks.checks as checks
@@ -131,32 +132,36 @@ async def distribution_status_check(
 
 
 async def draft_checks(
-    asf_uid: str, project_name: str, release_version: str, revision_number: str, caller_data: db.Session | None = None
+    asf_uid: str,
+    project_name: safe.ProjectName,
+    release_version: safe.VersionName,
+    revision_number: str,
+    caller_data: db.Session | None = None,
 ) -> int:
     """Core logic to analyse a draft revision and queue checks."""
     # Construct path to the specific revision
     # We don't have the release object here, so we can't use util.release_directory
-    revision_path = file_paths.get_unfinished_dir() / project_name / release_version / revision_number
+    revision_path = file_paths.get_unfinished_dir() / str(project_name) / str(release_version) / revision_number
     relative_paths = [path async for path in util.paths_recursive(revision_path)]
 
     async with db.ensure_session(caller_data) as data:
         release = await data.release(
-            name=sql.release_name(project_name, release_version),
+            name=sql.release_name(str(project_name), str(release_version)),
             _committee=True,
             _release_policy=True,
             _project_release_policy=True,
         ).demand(RuntimeError("Release not found"))
         other_releases = (
-            await data.release(project_name=project_name, phase=sql.ReleasePhase.RELEASE)
+            await data.release(project_name=str(project_name), phase=sql.ReleasePhase.RELEASE)
             .order_by(sql.Release.released)
             .all()
         )
         release_versions = sorted(
-            [v for v in other_releases], key=lambda v: util.version_sort_key(v.version), reverse=True
+            [v for v in other_releases], key=lambda v: util.version_sort_key(str(v.version)), reverse=True
         )
-        release_version_sortable = util.version_sort_key(release_version)
+        release_version_sortable = util.version_sort_key(str(release_version))
         previous_version = next(
-            (v for v in release_versions if util.version_sort_key(v.version) < release_version_sortable), None
+            (v for v in release_versions if util.version_sort_key(str(v.version)) < release_version_sortable), None
         )
         for path in relative_paths:
             await _draft_file_checks(
@@ -200,7 +205,11 @@ async def draft_checks(
 
 
 async def keys_import_file(
-    asf_uid: str, project_name: str, version_name: str, revision_number: str, caller_data: db.Session | None = None
+    asf_uid: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
+    revision_number: str,
+    caller_data: db.Session | None = None,
 ) -> None:
     """Import a KEYS file from a draft release candidate revision."""
     async with db.ensure_session(caller_data) as data:
@@ -216,6 +225,8 @@ async def keys_import_file(
                 asf_uid=asf_uid,
                 revision_number=revision_number,
                 primary_rel_path=None,
+                project_name=str(project_name),
+                version_name=str(version_name),
             )
         )
         await data.commit()
@@ -239,6 +250,8 @@ async def metadata_update(
             asf_uid=asf_uid,
             revision_number=None,
             primary_rel_path=None,
+            project_name=None,
+            version_name=None,
         )
         if schedule:
             task.scheduled = schedule
@@ -263,8 +276,8 @@ async def queued(
             raise ValueError("Cache key must contain a 'checker' key")
         hash_val = hashes.compute_dict_hash(check_cache_key)
         await attestable.write_checks_data(
-            release.project.name,
-            release.version,
+            release.safe_project_name,
+            release.safe_version_name,
             revision_number,
             primary_rel_path or "",
             {check_cache_key["checker"]: hash_val},
@@ -464,6 +477,8 @@ async def workflow_update(
             asf_uid=asf_uid,
             revision_number=None,
             primary_rel_path=None,
+            project_name=None,
+            version_name=None,
         )
         if schedule:
             task.scheduled = schedule
@@ -574,9 +589,9 @@ async def _draft_file_checks(
     data: db.Session,
     path: pathlib.Path,
     previous_version: sql.Release | None,
-    project_name: str,
+    project_name: safe.ProjectName,
     release: sql.Release,
-    release_version: str,
+    release_version: safe.VersionName,
     revision_number: str,
 ):
     path_str = str(path)
@@ -600,8 +615,8 @@ async def _draft_file_checks(
             revision_number,
             path_str,
             extra_args={
-                "project_name": project_name,
-                "version_name": release_version,
+                "project_name": str(project_name),
+                "version_name": str(release_version),
                 "revision_number": revision_number,
                 "previous_release_version": previous_version.version if previous_version else None,
                 "file_path": path_str,
diff --git a/atr/tasks/checks/__init__.py b/atr/tasks/checks/__init__.py
index 1dd9b0dc..99681200 100644
--- a/atr/tasks/checks/__init__.py
+++ b/atr/tasks/checks/__init__.py
@@ -39,6 +39,7 @@ import atr.db as db
 import atr.hashes as hashes
 import atr.log as log
 import atr.models.github as github_models
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.paths as file_paths
 import atr.util as util
@@ -50,8 +51,8 @@ import atr.util as util
 class FunctionArguments:
     recorder: Callable[[], Awaitable[Recorder]]
     asf_uid: str
-    project_name: str
-    version_name: str
+    project_name: safe.ProjectName
+    version_name: safe.VersionName
     revision_number: str
     primary_rel_path: str | None
     extra_args: dict[str, Any]
@@ -59,9 +60,9 @@ class FunctionArguments:
 
 class Recorder:
     checker: str
-    release_name: str
-    project_name: str
-    version_name: str
+    release_name: safe.ReleaseName
+    project_name: safe.ProjectName
+    version_name: safe.VersionName
     primary_rel_path: str | None
     member_rel_path: str | None
     revision_number: str
@@ -73,8 +74,8 @@ class Recorder:
         self,
         checker: str | Callable[..., Any],
         inputs_hash: str | None,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         revision_number: str,
         primary_rel_path: str | None = None,
         member_rel_path: str | None = None,
@@ -99,8 +100,8 @@ class Recorder:
         cls,
         checker: str | Callable[..., Any],
         inputs_hash: str,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         revision_number: str,
         primary_rel_path: str | None = None,
         member_rel_path: str | None = None,
@@ -144,7 +145,7 @@ class Recorder:
                 self.member_problems[status] = self.member_problems.get(status, 0) + 1
 
         result = sql.CheckResult(
-            release_name=self.release_name,
+            release_name=str(self.release_name),
             revision_number=self.revision_number,
             checker=self.checker,
             primary_rel_path=primary_rel_path or self.primary_rel_path,
@@ -184,8 +185,9 @@ class Recorder:
     async def project(self) -> sql.Project:
         # TODO: Cache project
         async with db.session() as data:
-            return await data.project(name=self.project_name, _release_policy=True).demand(
-                RuntimeError(f"Project {self.project_name} not found")
+            name_str = str(self.project_name)
+            return await data.project(name=name_str, _release_policy=True).demand(
+                RuntimeError(f"Project {name_str} not found")
             )
 
     async def primary_path_is_binary(self) -> bool:
@@ -325,7 +327,7 @@ async def resolve_cache_key(
         args = {}
     cache_key = {"checker": function_key(checker), "version": checker_version}
     file_hash = None
-    attestable_data = await attestable.load(release.project_name, release.version, revision)
+    attestable_data = await attestable.load(release.safe_project_name, release.safe_version_name, revision)
     if attestable_data:
         policy = sql.ReleasePolicy.model_validate(attestable_data.policy)
         if not ignore_path:
@@ -335,7 +337,9 @@ async def resolve_cache_key(
         policy = release.release_policy or release.project.release_policy
         if not ignore_path:
             if path is None:
-                path = file_paths.revision_path_for_file(release.project_name, release.version, revision, file or "")
+                path = file_paths.revision_path_for_file(
+                    release.safe_project_name, release.safe_version_name, revision, file or ""
+                )
             file_hash = await hashes.compute_file_hash(path)
     if file_hash:
         cache_key["file_hash"] = file_hash
@@ -380,7 +384,7 @@ async def _resolve_all_files(release: sql.Release, rel_path: str | None = None)
         return []
     if not (
         base_path := file_paths.base_path_for_revision(
-            release.project_name, release.version, release.latest_revision_number
+            release.safe_project_name, release.safe_version_name, release.latest_revision_number
         )
     ):
         return []
@@ -403,7 +407,7 @@ async def _resolve_github_tp_sha(release: sql.Release, rel_path: str | None = No
     if not release.latest_revision_number:
         return ""
     payload_path = attestable.github_tp_payload_path(
-        release.project_name, release.version, release.latest_revision_number
+        release.safe_project_name, release.safe_version_name, release.latest_revision_number
     )
     if not await aiofiles.os.path.isfile(payload_path):
         return ""
@@ -431,7 +435,7 @@ async def _resolve_unsuffixed_file_hash(release: sql.Release, rel_path: str | No
     if (not rel_path) or (not release.latest_revision_number):
         return ""
     abs_path = file_paths.revision_path_for_file(
-        release.project_name, release.version, release.latest_revision_number, rel_path
+        release.safe_project_name, release.safe_version_name, release.latest_revision_number, rel_path
     )
     plain_path = abs_path.with_suffix("")
     if await aiofiles.os.path.isfile(plain_path):
diff --git a/atr/tasks/checks/compare.py b/atr/tasks/checks/compare.py
index 013f7839..f2d29881 100644
--- a/atr/tasks/checks/compare.py
+++ b/atr/tasks/checks/compare.py
@@ -42,6 +42,7 @@ import atr.config as config
 import atr.log as log
 import atr.models.github as github_models
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.paths as paths
 import atr.tasks.checks as checks
 import atr.util as util
@@ -373,7 +374,7 @@ async def _find_archive_root(archive_path: pathlib.Path, extract_dir: pathlib.Pa
 
 
 async def _load_tp_payload(
-    project_name: str, version_name: str, revision_number: str
+    project_name: safe.ProjectName, version_name: safe.VersionName, revision_number: str
 ) -> github_models.TrustedPublisherPayload | None:
     payload_path = attestable.github_tp_payload_path(project_name, version_name, revision_number)
     if not await aiofiles.os.path.isfile(payload_path):
diff --git a/atr/tasks/distribution.py b/atr/tasks/distribution.py
index c1e72515..0c962e9c 100644
--- a/atr/tasks/distribution.py
+++ b/atr/tasks/distribution.py
@@ -63,13 +63,13 @@ async def status_check(args: DistributionStatusCheckArgs, *, task_id: int | None
             async with storage.write_as_committee_member(dist.release.project.committee_name, dist.created_by) as w:
                 if dist.retries >= _RETRY_LIMIT:
                     await w.distributions.delete_distribution(
-                        dist.release_name, dist.platform, dist.owner_namespace, dist.package, dist.version
+                        dist.safe_release_name, dist.platform, dist.owner_namespace, dist.package, dist.version
                     )
                     log.error(f"Distribution {name} failed {_RETRY_LIMIT} times, skipping")
                     continue
                 log.warning(f"Retrying distribution {name}")
                 await w.distributions.record_from_data(
-                    dist.release_name,
+                    dist.safe_release_name,
                     dist.staging,
                     dd,
                     allow_retries=True,
diff --git a/atr/tasks/gha.py b/atr/tasks/gha.py
index 6be367b3..f0c5fc9b 100644
--- a/atr/tasks/gha.py
+++ b/atr/tasks/gha.py
@@ -28,6 +28,7 @@ import atr.config as config
 import atr.db as db
 import atr.log as log
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.models.sql as sql
 import atr.storage as storage
@@ -50,8 +51,8 @@ class DistributionWorkflow(schema.Strict):
     package: str = schema.description("Package to distribute")
     version: str = schema.description("Version to distribute")
     staging: bool = schema.description("Whether this is a staging distribution")
-    project_name: str = schema.description("Project name in ATR")
-    version_name: str = schema.description("Version name in ATR")
+    project_name: safe.ProjectName = schema.description("Project name in ATR")
+    version_name: safe.VersionName = schema.description("Version name in ATR")
     phase: str = schema.description("Release phase in ATR")
     asf_uid: str = schema.description("ASF UID of the user triggering the workflow")
     committee_name: str = schema.description("Committee name in ATR")
diff --git a/atr/tasks/keys.py b/atr/tasks/keys.py
index 8854fb66..4cd48d83 100644
--- a/atr/tasks/keys.py
+++ b/atr/tasks/keys.py
@@ -16,6 +16,7 @@
 # under the License.
 
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.storage as storage
 import atr.tasks.checks as checks
@@ -25,8 +26,8 @@ class ImportFile(schema.Strict):
     """Import a KEYS file from a draft release candidate revision."""
 
     asf_uid: str
-    project_name: str
-    version_name: str
+    project_name: safe.ProjectName
+    version_name: safe.VersionName
 
 
 @checks.with_model(ImportFile)
diff --git a/atr/tasks/quarantine.py b/atr/tasks/quarantine.py
index 37905842..cb027289 100644
--- a/atr/tasks/quarantine.py
+++ b/atr/tasks/quarantine.py
@@ -32,6 +32,7 @@ import atr.detection as detection
 import atr.hashes as hashes
 import atr.log as log
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.models.sql as sql
 import atr.paths as paths
@@ -65,8 +66,8 @@ async def validate(args: QuarantineValidate) -> results.Results | None:
         return None
 
     release = quarantined.release
-    project_name = release.project_name
-    version_name = release.version
+    project_name = release.safe_project_name
+    version_name = release.safe_version_name
     quarantine_dir = paths.quarantine_directory(quarantined)
 
     if not await aiofiles.os.path.isdir(quarantine_dir):
@@ -157,8 +158,8 @@ async def _mark_failed(
 
 async def _promote(
     quarantined: sql.Quarantined,
-    project_name: str,
-    version_name: str,
+    project_name: safe.ProjectName,
+    version_name: safe.VersionName,
     release_name: str,
     quarantine_dir: str,
 ) -> None:
@@ -204,7 +205,7 @@ async def _promote(
             previous_attestable=previous_attestable,
             project_name=project_name,
             release=release,
-            release_name=release_name,
+            release_name=release.safe_name,
             temp_dir=quarantine_dir,
             temp_dir_path=quarantine_dir_path,
             version_name=version_name,
diff --git a/atr/tasks/sbom.py b/atr/tasks/sbom.py
index 7c5ac7e2..185fbce4 100644
--- a/atr/tasks/sbom.py
+++ b/atr/tasks/sbom.py
@@ -28,6 +28,7 @@ import atr.archives as archives
 import atr.config as config
 import atr.log as log
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.models.sql as sql
 import atr.paths as paths
@@ -69,20 +70,20 @@ class SBOMScoringError(Exception):
 
 
 class FileArgs(schema.Strict):
-    project_name: str = schema.description("Project name")
-    version_name: str = schema.description("Version name")
+    project_name: safe.ProjectName = schema.description("Project name")
+    version_name: safe.VersionName = schema.description("Version name")
     revision_number: str = schema.description("Revision number")
     file_path: str = schema.description("Relative path to the SBOM file")
     asf_uid: str | None = None
 
 
 class ScoreArgs(FileArgs):
-    previous_release_version: str | None = schema.description("Previous release version")
+    previous_release_version: safe.VersionName | None = schema.description("Previous release version")
 
 
 @checks.with_model(FileArgs)
 async def augment(args: FileArgs) -> results.Results | None:
-    base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+    base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
     if not await aiofiles.os.path.isdir(base_dir):
         raise SBOMScoringError("Revision directory does not exist", {"base_dir": str(base_dir)})
     full_path = base_dir / args.file_path
@@ -142,7 +143,7 @@ async def generate_cyclonedx(args: GenerateCycloneDX) -> results.Results | None:
 
 @checks.with_model(FileArgs)
 async def osv_scan(args: FileArgs) -> results.Results | None:
-    base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+    base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
     if not await aiofiles.os.path.isdir(base_dir):
         raise SBOMScanningError("Revision directory does not exist", {"base_dir": str(base_dir)})
     full_path = base_dir / args.file_path
@@ -199,7 +200,7 @@ async def osv_scan(args: FileArgs) -> results.Results | None:
 
 @checks.with_model(FileArgs)
 async def score_qs(args: FileArgs) -> results.Results | None:
-    base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+    base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
     if not await aiofiles.os.path.isdir(base_dir):
         raise SBOMScoringError("Revision directory does not exist", {"base_dir": str(base_dir)})
     full_path = base_dir / args.file_path
@@ -235,10 +236,10 @@ async def score_qs(args: FileArgs) -> results.Results | None:
 
 @checks.with_model(ScoreArgs)
 async def score_tool(args: ScoreArgs) -> results.Results | None:
-    base_dir = paths.get_unfinished_dir() / args.project_name / args.version_name / args.revision_number
+    base_dir = paths.get_unfinished_dir() / str(args.project_name) / str(args.version_name) / args.revision_number
     previous_base_dir = None
     if args.previous_release_version is not None:
-        previous_base_dir = paths.get_finished_dir() / args.project_name / args.previous_release_version
+        previous_base_dir = paths.get_finished_dir() / str(args.project_name) / str(args.previous_release_version)
     if not await aiofiles.os.path.isdir(base_dir):
         raise SBOMScoringError("Revision directory does not exist", {"base_dir": str(base_dir)})
     full_path = base_dir / args.file_path
diff --git a/atr/tasks/svn.py b/atr/tasks/svn.py
index 5b6c1829..0c469488 100644
--- a/atr/tasks/svn.py
+++ b/atr/tasks/svn.py
@@ -24,6 +24,7 @@ import aioshutil
 
 import atr.log as log
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.models.sql as sql
 import atr.storage as storage
@@ -36,8 +37,8 @@ class SvnImport(schema.Strict):
     svn_url: str
     revision: str
     target_subdirectory: str | None
-    project_name: str
-    version_name: str
+    project_name: safe.ProjectName
+    version_name: safe.VersionName
     asf_uid: str
 
 
diff --git a/atr/tasks/vote.py b/atr/tasks/vote.py
index 688d4c05..a4f0087e 100644
--- a/atr/tasks/vote.py
+++ b/atr/tasks/vote.py
@@ -22,6 +22,7 @@ import atr.db.interaction as interaction
 import atr.log as log
 import atr.mail as mail
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.schema as schema
 import atr.storage as storage
 import atr.tasks.checks as checks
@@ -31,7 +32,7 @@ import atr.util as util
 class Initiate(schema.Strict):
     """Arguments for the task to start a vote."""
 
-    release_name: str = schema.description("The name of the release to vote on")
+    release_name: safe.ReleaseName = schema.description("The name of the release to vote on")
     email_to: str = schema.description("The mailing list address to send the vote email to")
     vote_duration: int = schema.description("Duration of the vote in hours")
     initiator_id: str = schema.description("ASF ID of the vote initiator")
@@ -68,16 +69,20 @@ async def _initiate_core_logic(args: Initiate) -> results.Results | None:
         raise VoteInitiationError("Invalid destination email address")
 
     async with db.session() as data:
-        release = await data.release(name=args.release_name, _project=True, _committee=True).demand(
-            VoteInitiationError(f"Release {args.release_name} not found")
+        release = await data.release(name=str(args.release_name), _project=True, _committee=True).demand(
+            VoteInitiationError(f"Release {args.release_name!s} not found")
         )
         latest_revision_number = release.latest_revision_number
         if latest_revision_number is None:
-            raise VoteInitiationError(f"No revisions found for release {args.release_name}")
+            raise VoteInitiationError(f"No revisions found for release {args.release_name!s}")
 
-        ongoing_tasks = await interaction.tasks_ongoing(release.project.name, release.version, latest_revision_number)
+        ongoing_tasks = await interaction.tasks_ongoing(
+            release.safe_project_name, release.safe_version_name, latest_revision_number
+        )
         if ongoing_tasks > 0:
-            raise VoteInitiationError(f"Cannot start vote for {args.release_name} as {ongoing_tasks} are not complete")
+            raise VoteInitiationError(
+                f"Cannot start vote for {args.release_name!s} as {ongoing_tasks} are not complete"
+            )
 
     # Calculate vote end date
     vote_duration_hours = args.vote_duration
diff --git a/atr/templates/check-selected-path-table.html b/atr/templates/check-selected-path-table.html
index 3f5b46cb..a7496118 100644
--- a/atr/templates/check-selected-path-table.html
+++ b/atr/templates/check-selected-path-table.html
@@ -48,7 +48,7 @@
             {% endif %}
           </td>
           <td class="py-2">
-            <a href="{{ as_url(get.file.selected_path, project_name=project_name, version_name=version_name, file_path=path) }}"
+            <a href="{{ as_url(get.file.selected_path, project_name=project_name|string, version_name=version_name|string, file_path=path) }}"
                title="View file {{ path }}"
                class="text-decoration-none text-reset">
               {% if has_errors or has_warnings %}
@@ -62,7 +62,7 @@
             <div class="d-flex justify-content-end align-items-center gap-2">
               {% if path|string == "KEYS" %}
                 <form method="post"
-                      action="{{ as_url(post.keys.import_selected_revision, project_name=project_name, version_name=version_name) }}"
+                      action="{{ as_url(post.keys.import_selected_revision, project_name=project_name|string, version_name=version_name|string) }}"
                       class="d-inline mb-0">
                   {{ csrf_input|safe }}
 
@@ -70,20 +70,20 @@
                 </form>
               {% endif %}
               {% if path.suffixes[-2:] == [".cdx", ".json"] %}
-                <a href="{{ as_url(get.sbom.report, project_name=project_name, version_name=version_name, file_path=path) }}"
+                <a href="{{ as_url(get.sbom.report, project_name=project_name|string, version_name=version_name|string, file_path=path) }}"
                    class="btn btn-sm btn-outline-secondary">SBOM report</a>
               {% endif %}
               {% if has_blockers %}
-                <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+                <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
                    class="btn btn-sm atr-btn-outline-blocker"><i class="bi bi-exclamation-triangle me-1"></i> Show {{ info.errors[path]|length }} {{ "error" if info.errors[path]|length == 1 else "errors" }}</a>
               {% elif has_errors %}
-                <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+                <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
                    class="btn btn-sm btn-outline-danger"><i class="bi bi-exclamation-triangle me-1"></i> Show {{ info.errors[path]|length }} {{ "error" if info.errors[path]|length == 1 else "errors" }}</a>
               {% elif has_warnings %}
-                <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+                <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
                    class="btn btn-sm btn-outline-warning">Show {{ info.warnings[path]|length }} {{ "warning" if info.warnings[path]|length == 1 else "warnings" }}</a>
               {% elif info and (path in info.successes) %}
-                <a href="{{ as_url(get.report.selected_path, project_name=project_name, version_name=version_name, rel_path=path) }}"
+                <a href="{{ as_url(get.report.selected_path, project_name=project_name|string, version_name=version_name|string, rel_path=path) }}"
                    class="btn btn-sm btn-outline-success"
                    title="Show report for {{ path }}">Show report</a>
               {% else %}
@@ -99,7 +99,7 @@
                         aria-controls="actions-{{ row_id }}"
                         title="Show more actions for {{ path }}">More</button>
               {% elif phase == "release_candidate" %}
-                <a href="{{ as_url(get.download.path, project_name=release.project.name, version_name=release.version, file_path=path) }}"
+                <a href="{{ as_url(get.download.path, project_name=release.project.name|string, version_name=release.version|string, file_path=path) }}"
                    title="Download file {{ path }}"
                    class="btn btn-sm btn-outline-secondary">Download</a>
               {% endif %}
@@ -114,10 +114,10 @@
                 <div class="d-flex justify-content-end align-items-center gap-2"
                      role="group"
                      aria-label="More file actions for {{ path }}">
-                  <a href="{{ as_url(get.download.path, project_name=release.project.name, version_name=release.version, file_path=path) }}"
+                  <a href="{{ as_url(get.download.path, project_name=release.project.name|string, version_name=release.version|string, file_path=path) }}"
                      title="Download file {{ path }}"
                      class="btn btn-sm btn-outline-secondary">Download</a>
-                  <a href="{{ as_url(get.draft.tools, project_name=project_name, version_name=version_name, file_path=path) }}"
+                  <a href="{{ as_url(get.draft.tools, project_name=release.project.name|string, version_name=release.version|string, file_path=path) }}"
                      title="Tools for file {{ path }}"
                      class="btn btn-sm btn-outline-secondary">Tools</a>
                   {{ delete_file_forms[path|string] }}
diff --git a/atr/templates/check-selected-release-info.html b/atr/templates/check-selected-release-info.html
index 3c602ff6..60b22ce4 100644
--- a/atr/templates/check-selected-release-info.html
+++ b/atr/templates/check-selected-release-info.html
@@ -7,7 +7,7 @@
       <div class="col-md-6">
         <p>
           <strong>Project:</strong>
-          <a href="{{ as_url(get.projects.view, project_name=release.project.name) }}">{{ release.project.display_name }}</a>
+          <a href="{{ as_url(get.projects.view, project_name=(release.project.name|string)) }}">{{ release.project.display_name }}</a>
         </p>
         <p>
           <strong>Label:</strong> {{ release.name }}
@@ -25,7 +25,7 @@
         {% if (phase == "release_candidate_draft") and revision_time %}
           <p>
             <strong>Revision:</strong>
-            <a href="{{ as_url(get.revisions.selected, project_name=project_name, version_name=version_name) }}#{{ revision_number }}">
+            <a href="{{ as_url(get.revisions.selected, project_name=project_name|string, version_name=version_name|string) }}#{{ revision_number }}">
               {{ format_datetime(revision_time) }}
             </a>
             {% if revision_editor %}by {{ revision_editor }}{% endif %}
@@ -41,11 +41,11 @@
     </div>
     <div class="d-flex flex-wrap gap-2">
       {% if phase == "release_candidate_draft" %}
-        <a href="{{ as_url(get.upload.selected, project_name=release.project.name, version_name=release.version) }}"
+        <a href="{{ as_url(get.upload.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
            title="Upload files to this draft"
            class="btn btn-primary"><i class="bi bi-upload me-1"></i> Upload files</a>
 
-        <a href="{{ as_url(get.download.all_selected, project_name=release.project.name, version_name=release.version) }}"
+        <a href="{{ as_url(get.download.all_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
            title="Download {%- if has_files -%}files{%- else -%}links{%- endif -%}"
            class="btn btn-primary"><i class="bi bi-download me-1"></i> Download
           {% if has_files %}
@@ -54,7 +54,7 @@
             links
           {% endif %}
         </a>
-        <a href="{{ as_url(get.revisions.selected, project_name=release.project.name, version_name=release.version) }}"
+        <a href="{{ as_url(get.revisions.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
            title="View revision history"
            class="btn btn-secondary"><i class="bi bi-clock-history me-1"></i> Revisions</a>
         {% if revision_number %}
@@ -62,13 +62,13 @@
           {% set blocked_title = "Fix blockers before starting a vote" if blocker_errors else "Fix errors before starting a vote" %}
           {% if has_files and release.project.policy_manual_vote and (ongoing_tasks_count == 0) and (not vote_blocked) %}
             <a id="start-vote-button"
-               href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+               href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
                title="Start a manual vote on this draft"
                class="btn btn-success"><i class="bi bi-check-circle me-1"></i> Start manual vote</a>
           {% elif has_files and release.project.policy_manual_vote and (not vote_blocked) %}
             <a id="start-vote-button"
-               href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
-               data-vote-href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+               href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
+               data-vote-href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
                title="Background tasks must complete first"
                class="btn btn-success disabled"
                role="button"
@@ -76,7 +76,7 @@
                tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start manual vote</a>
           {% elif has_files and release.project.policy_manual_vote and vote_blocked %}
             <a id="start-vote-button"
-               href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+               href="{{ as_url(get.manual.start_selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
                title="{{ blocked_title }}"
                class="btn btn-success disabled"
                role="button"
@@ -84,13 +84,13 @@
                tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start manual vote</a>
           {% elif has_files and (not vote_blocked) and (ongoing_tasks_count == 0) %}
             <a id="start-vote-button"
-               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
                title="Start a vote on this draft"
                class="btn btn-success"><i class="bi bi-check-circle me-1"></i> Start voting</a>
           {% elif has_files and (not vote_blocked) %}
             <a id="start-vote-button"
-               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
-               data-vote-href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
+               data-vote-href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
                title="Background tasks must complete first"
                class="btn btn-success disabled"
                role="button"
@@ -98,7 +98,7 @@
                tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start voting</a>
           {% elif has_files and vote_blocked %}
             <a id="start-vote-button"
-               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
                title="{{ blocked_title }}"
                class="btn btn-success disabled"
                role="button"
@@ -106,7 +106,7 @@
                tabindex="-1"><i class="bi bi-check-circle me-1"></i> Start voting</a>
           {% else %}
             <a id="start-vote-button"
-               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name, version_name=release.version, revision=revision_number) }}"
+               href="{{ as_url(get.voting.selected_revision, project_name=release.project.name|string, version_name=release.version|string, revision=revision_number) }}"
                title="Upload files to enable voting"
                class="btn btn-success disabled"
                role="button"
@@ -116,15 +116,15 @@
         {% endif %}
         <a href="#more-actions" class="btn btn-outline-secondary"><i class="bi bi-gear me-1"></i> More actions</a>
       {% elif phase == "release_candidate" %}
-        <a href="{{ as_url(get.download.all_selected, project_name=release.project.name, version_name=release.version) }}"
+        <a href="{{ as_url(get.download.all_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
            class="btn btn-primary"><i class="bi bi-download me-1"></i> Download files</a>
-        <a href="{{ as_url(get.file.selected, project_name=release.project.name, version_name=release.version) }}"
+        <a href="{{ as_url(get.file.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
            class="btn btn-secondary"><i class="bi bi-eye me-1"></i> View files</a>
         {% if can_resolve and release.vote_manual %}
-          <a href="{{ as_url(get.manual.resolve_selected, project_name=release.project.name, version_name=release.version) }}"
+          <a href="{{ as_url(get.manual.resolve_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
              class="btn btn-success"><i class="bi bi-clipboard-check me-1"></i> Resolve vote</a>
         {% elif can_resolve and resolve_form %}
-          <form action="{{ as_url(post.resolve.selected, project_name=release.project.name, version_name=release.version) }}"
+          <form action="{{ as_url(post.resolve.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
                 method="post"
                 class="mb-0">
             {{ csrf_input|safe }}
diff --git a/atr/templates/check-selected.html b/atr/templates/check-selected.html
index 24f91147..de8ba6c0 100644
--- a/atr/templates/check-selected.html
+++ b/atr/templates/check-selected.html
@@ -156,9 +156,9 @@
     </div>
     <p>
       <a class="btn btn-primary"
-         href="{{ as_url(get.distribution.stage_automate, project_name=release.project.name, version_name=release.version) }}">Distribute</a>
+         href="{{ as_url(get.distribution.stage_automate, project_name=release.project.name|string, version_name=(release.version|string)) }}">Distribute</a>
       <a class="btn btn-secondary"
-         href="{{ as_url(get.distribution.stage_record, project_name=release.project.name, version_name=release.version) }}">Record a manual distribution</a>
+         href="{{ as_url(get.distribution.stage_record, project_name=release.project.name|string, version_name=(release.version|string)) }}">Record a manual distribution</a>
     </p>
     <h2 id="more-actions">More actions</h2>
     <h3 id="ignored-checks" class="mt-4">Ignored checks</h3>
@@ -212,7 +212,7 @@
       <p>No ignored checks found.</p>
     {% endif %}
     <p>
-      You can also <a href="{{ as_url(get.ignores.ignores, project_name=release.project_name) }}">manage which check results are ignored</a>.
+      You can also <a href="{{ as_url(get.ignores.ignores, project_name=release.project_name|string) }}">manage which check results are ignored</a>.
     </p>
 
     {% if is_viewing_as_admin_fn(current_user.uid) %}
diff --git a/atr/templates/committee-directory.html b/atr/templates/committee-directory.html
index 3eedfe0c..0edaf7db 100644
--- a/atr/templates/committee-directory.html
+++ b/atr/templates/committee-directory.html
@@ -116,11 +116,11 @@
                         {% if committee.projects %}
                             {% for project in committee.projects|sort(attribute="name") %}
                                 <div class="card mb-3 shadow-sm page-project-subcard {% if loop.index > max_initial_projects %}page-project-extra d-none{% endif %} {% if project.status.value.lower() != "active" %}page-project-inactive{% endif %}"
-                                     data-project-url="{{ as_url(get.projects.view, project_name=project.name) }}">
+                                     data-project-url="{{ as_url(get.projects.view, project_name=(project.name|string)) }}">
                                     <div class="card-body p-3 d-flex flex-column h-100">
                                         <div class="d-flex justify-content-between align-items-start">
                                             <p class="mb-1 me-2 fs-6">
-                                                <a href="{{ as_url(get.projects.view, project_name=project.name) }}"
+                                                <a href="{{ as_url(get.projects.view, project_name=(project.name|string)) }}"
                                                    class="text-decoration-none stretched-link">{{ project.display_name }}</a>
                                             </p>
                                             <div>
diff --git a/atr/templates/committee-view.html b/atr/templates/committee-view.html
index 6ce1f66d..4c99e552 100644
--- a/atr/templates/committee-view.html
+++ b/atr/templates/committee-view.html
@@ -29,7 +29,7 @@
       <ul>
         {% for project in projects %}
           <li>
-            <a href="{{ as_url(get.projects.view, project_name=project.name) }}">{{ project.display_name }}</a>
+            <a href="{{ as_url(get.projects.view, project_name=(project.name|string)) }}">{{ project.display_name }}</a>
           </li>
         {% endfor %}
       </ul>
diff --git a/atr/templates/download-all.html b/atr/templates/download-all.html
index 5a5e4b22..4c8e7057 100644
--- a/atr/templates/download-all.html
+++ b/atr/templates/download-all.html
@@ -63,7 +63,7 @@
     The archive is generated on the fly, which may take a while for very large releases.
   </p>
   <p>
-    <a href="{{ as_url(get.download.zip_selected, project_name=release.project.name, version_name=release.version) }}"
+    <a href="{{ as_url(get.download.zip_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
        class="btn btn-primary btn-lg">
       <i class="bi bi-file-earmark-zip me-2"></i>Download {{ release.name }}.zip
     </a>
@@ -88,17 +88,17 @@
 
   <h3 id="download-browser" class="mt-4">Using your browser</h3>
   <p>
-    You can download the files one by one using your browser from the <a href="{{ as_url(get.download.path_empty, project_name=release.project.name, version_name=release.version) }}">download folder</a>. Clicking a link to any file will download it, as it is served as <code>application/octet-stream</code>.
+    You can download the files one by one using your browser from the <a href="{{ as_url(get.download.path_empty, project_name=release.project.name|string, version_name=(release.version|string)) }}">download folder</a>. Clicking a link to any file will download it, as it is served as <code>application/octet-stream</code>.
   </p>
 
   <h3 id="download-curl" class="mt-4">Using curl</h3>
   <p>You can download all of the files in this release using curl with the following command:</p>
   <!-- TODO: Add a button to copy the command to the clipboard -->
   <pre class="bg-light border rounded p-3 mb-3">
-curl{% if server_domain == "localhost.apache.org" %} --insecure{% endif %} -fsS https://{{ server_host }}{{ as_url(get.download.sh_selected, project_name=release.project.name, version_name=release.version) }} | sh
+curl{% if server_domain == "localhost.apache.org" %} --insecure{% endif %} -fsS https://{{ server_host }}{{ as_url(get.download.sh_selected, project_name=release.project.name|string, version_name=(release.version|string)) }} | sh
 </pre>
   <p>
-    This downloads the files into the <em>current directory</em>. Ensure that you create a new empty directory, and change to it, before running the command. The script requires curl and a POSIX compliant version of sh. It works by downloading a POSIX complaint shell script straight into your shell. You can of course <a href="{{ as_url(get.download.sh_selected, project_name=release.project.name, version_name=release.version) }}">download the script</a> and audit it before running it.
+    This downloads the files into the <em>current directory</em>. Ensure that you create a new empty directory, and change to it, before running the command. The script requires curl and a POSIX compliant version of sh. It works by downloading a POSIX complaint shell script straight into your shell. You can of course <a href="{{ as_url(get.download.sh_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}">download the script</a> and audit it before [...]
   </p>
 
   <h3 id="download-rsync" class="mt-4">Using rsync</h3>
@@ -112,7 +112,7 @@ rsync -av -e 'ssh -p 2222' {{ asf_id }}@{{ server_domain }}:/{{ release.project.
   <h3 id="download-wget" class="mt-4">Using wget</h3>
   <p>You can download all of the files in this release using wget with the following command:</p>
   <pre class="bg-light border rounded p-3 mb-3">
-wget -r -np -nH --cut-dirs=4 --default-page=.index.html{% if server_domain == "localhost.apache.org" %} --no-check-certificate{% endif %} https://{{ server_host }}{{ as_url(get.download.path_empty, project_name=release.project.name, version_name=release.version) }}
+wget -r -np -nH --cut-dirs=4 --default-page=.index.html{% if server_domain == "localhost.apache.org" %} --no-check-certificate{% endif %} https://{{ server_host }}{{ as_url(get.download.path_empty, project_name=release.project.name|string, version_name=(release.version|string)) }}
 </pre>
   <p>
     This downloads the files into the <em>current directory</em>. Ensure that you create a new empty directory, and change to it, before running the command.
diff --git a/atr/templates/draft-tools.html b/atr/templates/draft-tools.html
index 718f8f07..3a77ca29 100644
--- a/atr/templates/draft-tools.html
+++ b/atr/templates/draft-tools.html
@@ -5,7 +5,7 @@
 {%- block description -%}Manage a file in the candidate draft using tools.{%- endblock description -%}
 
 {% block content %}
-  <a href="{{ as_url(get.compose.selected, project_name=project_name, version_name=version_name) }}"
+  <a href="{{ as_url(get.compose.selected, project_name=project_name|string, version_name=version_name|string) }}"
      class="atr-back-link">← Back to Compose release</a>
 
   <div class="p-3 mb-4 bg-light border rounded">
diff --git a/atr/templates/includes/topnav.html b/atr/templates/includes/topnav.html
index 081c55a1..d46b1a10 100644
--- a/atr/templates/includes/topnav.html
+++ b/atr/templates/includes/topnav.html
@@ -42,7 +42,7 @@
                   </li>
                   <li>
                     <a class="dropdown-item fw-bold"
-                       href="{{ as_url(get.projects.view, project_name=project_name) }}">{{ project_short_display_name }}</a>
+                       href="{{ as_url(get.projects.view, project_name=project_name|string) }}">{{ project_short_display_name }}</a>
                   </li>
                   {% for release in releases %}
                     <li>
@@ -64,7 +64,7 @@
                 {% for project_name, project_full_name in user_projects[:max_projects] %}
                   <li>
                     <a class="dropdown-item"
-                       href="{{ as_url(get.start.selected, project_name=project_name) }}"><i class="bi bi-plus-circle"></i>
+                       href="{{ as_url(get.start.selected, project_name=project_name|string) }}"><i class="bi bi-plus-circle"></i>
                       {{ project_full_name.removeprefix("Apache ").removesuffix(" (Incubating)") }}</a>
                   </li>
                 {% endfor %}
diff --git a/atr/templates/index-committer.html b/atr/templates/index-committer.html
index ce5f428c..ea946773 100644
--- a/atr/templates/index-committer.html
+++ b/atr/templates/index-committer.html
@@ -67,7 +67,7 @@
       <div class="mb-5" id="project-{{ project_id }}">
         <h2 class="border-bottom border-secondary pb-2 mb-3">
           {{ display_name_cleaned }}
-          {% if project.committee.is_podling or project.name.startswith("incubator-") %}
+          {% if project.committee.is_podling or (project.name|string).startswith("incubator-") %}
             <span class="text-muted fw-normal fs-5">(Incubating)</span>
             <img src="{{ static_url('svg/apache_incubator.svg') }}"
                  alt=""
@@ -87,7 +87,7 @@
         </h2>
 
         <p class="mb-3">
-          <a href="{{ as_url(get.projects.view, project_name=project.name) }}"
+          <a href="{{ as_url(get.projects.view, project_name=(project.name|string) )}}"
              class="text-decoration-none me-2">About this project</a>
           {% if project.committee.name in current_user.committees %}
             <span class="text-muted me-2">/</span>
@@ -96,7 +96,7 @@
           {% endif %}
           {% if completed_releases %}
             <span class="text-muted me-2">/</span>
-            <a href="{{ as_url(get.release.finished, project_name=project.name) }}"
+            <a href="{{ as_url(get.release.finished, project_name=(project.name|string)) }}"
                class="text-decoration-none">Finished releases</a>
           {% endif %}
         </p>
@@ -145,7 +145,7 @@
             </a>
           {% endfor %}
 
-          <a href="{{ as_url(get.start.selected, project_name=project.name) }}"
+          <a href="{{ as_url(get.start.selected, project_name=(project.name|string)) }}"
              title="Start a new {{ project.display_name }} release"
              class="text-decoration-none">
             <div class="card h-100 shadow-sm atr-cursor-pointer page-card">
diff --git a/atr/templates/project-select.html b/atr/templates/project-select.html
index 0b0f7b06..0f3409ba 100644
--- a/atr/templates/project-select.html
+++ b/atr/templates/project-select.html
@@ -11,16 +11,16 @@
     <div class="row row-cols-1 row-cols-md-2 row-cols-lg-3 g-4">
       {% for project in user_projects %}
         <div class="col">
-          <a href="{{ as_url(get.release.select, project_name=project.name) }}"
+          <a href="{{ as_url(get.release.select, project_name=(project.name|string)) }}"
              class="text-decoration-none">
             {# TODO: We're only setting data-project-url for style #}
             <div class="card h-100 shadow-sm atr-cursor-pointer"
-                 data-project-url="{{ as_url(get.release.select, project_name=project.name) }}">
+                 data-project-url="{{ as_url(get.release.select, project_name=(project.name|string)) }}">
               <div class="card-body">
                 <h3 class="card-title fs-5 mb-2">{{ project.display_name }}</h3>
                 <h4 class="card-subtitle mb-2 text-muted fs-6">{{ project.name }}</h4>
                 <p>
-                  {% if project.committee.is_podling or project.name.startswith("incubator-") %}
+                  {% if project.committee.is_podling or (project.name|string).startswith("incubator-") %}
                     <img src="https://incubator.apache.org/images/SVG/apache_incubator.svg"
                          alt="" />
                   {% else %}
diff --git a/atr/templates/projects.html b/atr/templates/projects.html
index 4d30e8cf..862be6cc 100644
--- a/atr/templates/projects.html
+++ b/atr/templates/projects.html
@@ -37,12 +37,12 @@
     {% endif %}
     <div class="col">
       <div class="card h-100 shadow-sm position-relative page-project-card {{ '' if project.status.value.lower() == 'active' else 'bg-body-secondary' }}"
-           data-project-url="{{ as_url(get.projects.view, project_name=project.name) }}"
+           data-project-url="{{ as_url(get.projects.view, project_name=(project.name|string)) }}"
            data-is-participant="{{ 'true' if is_part else 'false' }}">
         <div class="card-body">
           <div class="row g-1">
             <div class="col-sm">
-              <h3 class="card-title fs-4 mb-3"><a href="{{ as_url(get.projects.view, project_name=project.name) }}" class="text-decoration-none text-body stretched-link">{{ project.display_name }}</a></h3>
+              <h3 class="card-title fs-4 mb-3"><a href="{{ as_url(get.projects.view, project_name=(project.name|string)) }}" class="text-decoration-none text-body stretched-link">{{ project.display_name }}</a></h3>
             </div>
             {% if project.status.value.lower() != 'active' %}
               <div class="col-sm-2">
diff --git a/atr/templates/release-select.html b/atr/templates/release-select.html
index 9a179fde..d072e992 100644
--- a/atr/templates/release-select.html
+++ b/atr/templates/release-select.html
@@ -30,13 +30,13 @@
         {% set target_url = None %}
         {# TODO: Use mappings.py #}
         {% if phase == "release_candidate_draft" %}
-          {% set target_url = as_url(get.compose.selected, project_name=project.name, version_name=release.version) %}
+          {% set target_url = as_url(get.compose.selected, project_name=project.name|string, version_name=(release.version|string)) %}
           {% set badge_class = "bg-primary" %}
         {% elif phase == "release_candidate" %}
-          {% set target_url = as_url(get.vote.selected, project_name=project.name, version_name=release.version) %}
+          {% set target_url = as_url(get.vote.selected, project_name=project.name|string, version_name=(release.version|string)) %}
           {% set badge_class = "bg-warning text-dark" %}
         {% elif phase == "release_preview" %}
-          {% set target_url = as_url(get.announce.selected, project_name=project.name, version_name=release.version) %}
+          {% set target_url = as_url(get.announce.selected, project_name=project.name|string, version_name=(release.version|string)) %}
           {% set badge_class = "bg-success" %}
         {% endif %}
 
diff --git a/atr/templates/releases-finished.html b/atr/templates/releases-finished.html
index c57ba4da..b8f05723 100644
--- a/atr/templates/releases-finished.html
+++ b/atr/templates/releases-finished.html
@@ -21,11 +21,11 @@
               <strong class="card-title fs-5">{{ release.version }}</strong>
               <p class="card-text text-muted">Released on {{ format_datetime(release.created) }}</p>
               <div class="mt-auto">
-                <a href="{{ as_url(get.download.all_selected, project_name=release.project.name, version_name=release.version) }}"
+                <a href="{{ as_url(get.download.all_selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
                    class="btn btn-outline-primary w-100 mb-2">
                   <i class="bi bi-download me-1"></i> Download files
                 </a>
-                <a href="{{ as_url(get.file.selected, project_name=release.project.name, version_name=release.version) }}"
+                <a href="{{ as_url(get.file.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
                    class="btn btn-outline-secondary w-100">
                   <i class="bi bi-folder2-open me-1"></i> View files
                 </a>
diff --git a/atr/templates/releases.html b/atr/templates/releases.html
index 4e5111f8..ed044657 100644
--- a/atr/templates/releases.html
+++ b/atr/templates/releases.html
@@ -29,7 +29,7 @@
         <div class="card-body">
           <h3 class="card-title mb-3">{{ project_display_name }}</h3>
           <p class="card-text">
-            <a href="{{ as_url(get.release.finished, project_name=project.name) }}"
+            <a href="{{ as_url(get.release.finished, project_name=(project.name|string)) }}"
                class="btn btn-outline-primary">
               <i class="bi bi-folder2-open me-1"></i> Finished releases (<code>{{ count }}</code>)
             </a>
diff --git a/atr/templates/report-selected-path.html b/atr/templates/report-selected-path.html
index 94ad614f..2186cb59 100644
--- a/atr/templates/report-selected-path.html
+++ b/atr/templates/report-selected-path.html
@@ -21,10 +21,10 @@
   {% set phase = release.phase.value %}
   <p class="d-flex justify-content-between align-items-center">
     {% if phase == "release_candidate_draft" %}
-      <a href="{{ as_url(get.compose.selected, project_name=release.project.name, version_name=release.version) }}"
+      <a href="{{ as_url(get.compose.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
          class="atr-back-link">← Back to Compose {{ release.project.short_display_name }} {{ release.version }}</a>
     {% else %}
-      <a href="{{ as_url(get.vote.selected, project_name=release.project.name, version_name=release.version) }}"
+      <a href="{{ as_url(get.vote.selected, project_name=str(release.project.name), version_name=str(release.version)) }}"
          class="atr-back-link">← Back to Vote on {{ release.project.short_display_name }} {{ release.version }}</a>
     {% endif %}
     <span class="atr-phase-nav">
@@ -111,7 +111,7 @@
             <tr class="atr-result-primary atr-result-status-{{ primary_result.status.value }} {% if primary_result.status.value == 'success' and not all_primary_are_success %}atr-hide{% endif %}">
               <th scope="row" class="align-middle fw-bold">
                 <a class="atr-link-plain"
-                   href="{{ as_url(get.result.data, project_name=project_name, version_name=version_name, check_id=primary_result.id) }}">
+                   href="{{ as_url(get.result.data, project_name=str(project_name), version_name=str(version_name), check_id=primary_result.id) }}">
                   {{ function_name_from_key(primary_result.checker) }}
                 </a>
               </th>
@@ -298,7 +298,7 @@
                 <td class="align-middle">{{ member_rel_path }}</td>
                 <th scope="row" class="align-middle fw-bold">
                   <a class="atr-link-plain"
-                     href="{{ as_url(get.result.data, project_name=project_name, version_name=version_name, check_id=member_result.id) }}">
+                     href="{{ as_url(get.result.data, project_name=str(project_name), version_name=str(version_name), check_id=member_result.id) }}">
                     {{ function_name_from_key(member_result.checker) }}
                   </a>
                 </th>
diff --git a/atr/templates/resolve-tabulated.html b/atr/templates/resolve-tabulated.html
index 843d72c6..8eae1919 100644
--- a/atr/templates/resolve-tabulated.html
+++ b/atr/templates/resolve-tabulated.html
@@ -6,7 +6,7 @@
 
 {% block content %}
   <p>
-    <a href="{{ as_url(get.vote.selected, project_name=release.project.name, version_name=release.version) }}"
+    <a href="{{ as_url(get.vote.selected, project_name=release.project.name|string, version_name=(release.version|string)) }}"
        class="atr-back-link">← Back to Vote for {{ release.short_display_name }}</a>
   </p>
 
diff --git a/atr/validate.py b/atr/validate.py
index 7688f823..cb2ed305 100644
--- a/atr/validate.py
+++ b/atr/validate.py
@@ -80,7 +80,7 @@ if True:
                 yield from divergences_with_annotations(
                     components,
                     original.__name__,
-                    p.name,
+                    str(p.name),
                     original(p),
                 )
 
@@ -298,7 +298,7 @@ def release_components(
             yield from divergences_with_annotations(
                 components,
                 original.__name__,
-                r.name,
+                str(r.name),
                 original(r),
             )
 
diff --git a/atr/web.py b/atr/web.py
index ce2a4656..66671007 100644
--- a/atr/web.py
+++ b/atr/web.py
@@ -89,7 +89,7 @@ class Committer:
         return user.is_admin(self.uid)
 
     async def check_access(self, project_name: str | safe.ProjectName) -> None:
-        if not any((p.name == str(project_name)) for p in (await self.user_projects)):
+        if not any((str(p.name) == str(project_name)) for p in (await self.user_projects)):
             if self.is_admin:
                 # Admins can view all projects
                 # But we must warn them when the project is not one of their own
@@ -162,8 +162,8 @@ class Committer:
 
     async def release(
         self,
-        project_name: str,
-        version_name: str,
+        project_name: safe.ProjectName,
+        version_name: safe.VersionName,
         phase: sql.ReleasePhase | db.NotSet | None = db.NOT_SET,
         latest_revision_number: str | db.NotSet | None = db.NOT_SET,
         data: db.Session | None = None,
@@ -182,11 +182,11 @@ class Committer:
             phase_value = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
         else:
             phase_value = phase
-        release_name = sql.release_name(str(project_name), str(version_name))
+        release_name = sql.release_name(project_name, version_name)
         if data is None:
             async with db.session() as data:
                 release = await data.release(
-                    name=release_name,
+                    name=str(release_name),
                     phase=phase_value,
                     latest_revision_number=latest_revision_number,
                     _committee=with_committee,
@@ -198,7 +198,7 @@ class Committer:
                 ).demand(base.ASFQuartException("Release does not exist", errorcode=404))
         else:
             release = await data.release(
-                name=release_name,
+                name=str(release_name),
                 phase=phase_value,
                 latest_revision_number=latest_revision_number,
                 _committee=with_committee,
diff --git a/atr/worker.py b/atr/worker.py
index ac19a940..358a2bcc 100644
--- a/atr/worker.py
+++ b/atr/worker.py
@@ -38,6 +38,7 @@ import atr.db as db
 import atr.ldap as ldap
 import atr.log as log
 import atr.models.results as results
+import atr.models.safe as safe
 import atr.models.sql as sql
 import atr.tasks as tasks
 import atr.tasks.checks as checks
@@ -118,12 +119,16 @@ async def _execute_check_task(
             f"Task {task_id} ({task_type}) has non-dict raw args {task_args} which should represent keyword_args"
         )
 
+    project_name = safe.ProjectName(task_obj.project_name)
+    version_name = safe.VersionName(task_obj.version_name)
+
+    # TODO: The recorder needs values but what do we do if the task doesn't have a project name?
     async def recorder_factory() -> checks.Recorder:
         return await checks.Recorder.create(
             checker=handler,
             inputs_hash=task_obj.inputs_hash or "",
-            project_name=task_obj.project_name or "",
-            version_name=task_obj.version_name or "",
+            project_name=project_name or safe.ProjectName(""),
+            version_name=version_name or safe.VersionName(""),
             revision_number=task_obj.revision_number or "",
             primary_rel_path=task_obj.primary_rel_path,
         )
@@ -131,8 +136,8 @@ async def _execute_check_task(
     function_arguments = checks.FunctionArguments(
         recorder=recorder_factory,
         asf_uid=task_obj.asf_uid,
-        project_name=task_obj.project_name or "",
-        version_name=task_obj.version_name or "",
+        project_name=project_name or safe.ProjectName(""),
+        version_name=version_name or safe.VersionName(""),
         revision_number=task_obj.revision_number,
         primary_rel_path=task_obj.primary_rel_path,
         extra_args=task_args,


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org