diff --git a/pephub/_version.py b/pephub/_version.py
index 1748769b..5a313cc7 100644
--- a/pephub/_version.py
+++ b/pephub/_version.py
@@ -1 +1 @@
-__version__ = "0.15.8"
+__version__ = "0.16.0"
diff --git a/pephub/const.py b/pephub/const.py
index 739fdbba..fc03c944 100644
--- a/pephub/const.py
+++ b/pephub/const.py
@@ -6,18 +6,20 @@
 import pandas as pd
 from fastapi import __version__ as fastapi_version
 from pepdbagent import __version__ as pepdbagent_version
-from peppy import __version__ as peppy_version
-from peppy.const import PEP_LATEST_VERSION
 
 from ._version import __version__ as pephub_version
 
+# peprs has no __version__ attribute and no PEP_LATEST_VERSION constant.
+PEP_LATEST_VERSION = "2.1.0"
+peprs_version = "unknown"
+
 PKG_NAME = "pephub"
 DATA_REPO = "https://github.com/pepkit/data.pephub.git"
 
 
 ALL_VERSIONS = {
     "pephub_version": pephub_version,
-    "peppy_version": peppy_version,
+    "peprs_version": peprs_version,
     "python_version": python_version(),
     "fastapi_version": fastapi_version,
     "pepdbagent_version": pepdbagent_version,
diff --git a/pephub/helpers.py b/pephub/helpers.py
index a1f13613..9247b4aa 100644
--- a/pephub/helpers.py
+++ b/pephub/helpers.py
@@ -9,16 +9,18 @@
 import json
 from fastapi import Response, UploadFile
 from fastapi.exceptions import HTTPException
-from peppy.const import (
-    CFG_SAMPLE_TABLE_KEY,
-    CFG_SUBSAMPLE_TABLE_KEY,
+from peprs.const import (
     CONFIG_KEY,
-    NAME_KEY,
     SAMPLE_RAW_DICT_KEY,
-    SUBSAMPLE_RAW_LIST_KEY,
+    SUBSAMPLE_RAW_DICT_KEY,
 )
 from .const import JWT_EXPIRATION, JWT_SECRET
 
+# peprs.const does not export these — they are PEP config schema strings.
+CFG_SAMPLE_TABLE_KEY = "sample_table"
+CFG_SUBSAMPLE_TABLE_KEY = "subsample_table"
+NAME_KEY = "name"
+
 
 def jwt_encode_user_data(user_data: dict, exp: datetime = None) -> str:
     """
@@ -53,15 +55,15 @@ def zip_pep(project: Dict[str, Any]) -> Response:
             project[SAMPLE_RAW_DICT_KEY]
         ).to_csv(index=False)
 
-    if project[SUBSAMPLE_RAW_LIST_KEY] is not None:
-        if not isinstance(project[SUBSAMPLE_RAW_LIST_KEY], list):
+    if project[SUBSAMPLE_RAW_DICT_KEY] is not None:
+        if not isinstance(project[SUBSAMPLE_RAW_DICT_KEY], list):
             config[CFG_SUBSAMPLE_TABLE_KEY] = ["subsample_table1.csv"]
             content_to_zip["subsample_table1.csv"] = pd.DataFrame(
-                project[SUBSAMPLE_RAW_LIST_KEY]
+                project[SUBSAMPLE_RAW_DICT_KEY]
             ).to_csv(index=False)
         else:
             config[CFG_SUBSAMPLE_TABLE_KEY] = []
-            for number, file in enumerate(project[SUBSAMPLE_RAW_LIST_KEY]):
+            for number, file in enumerate(project[SUBSAMPLE_RAW_DICT_KEY]):
                 file_name = f"subsample_table{number + 1}.csv"
                 config[CFG_SUBSAMPLE_TABLE_KEY].append(file_name)
                 content_to_zip[file_name] = pd.DataFrame(file).to_csv(index=False)
diff --git a/pephub/main.py b/pephub/main.py
index 7b9bd491..6dc91cc1 100644
--- a/pephub/main.py
+++ b/pephub/main.py
@@ -28,12 +28,12 @@
     fmt="[%(levelname)s] [%(asctime)s] [PEPDBAGENT] %(message)s",
 )
 
-_LOGGER_PEPPY = logging.getLogger("peppy")
+_LOGGER_PEPRS = logging.getLogger("peprs")
 coloredlogs.install(
-    logger=_LOGGER_PEPPY,
+    logger=_LOGGER_PEPRS,
     level=logging.ERROR,
     datefmt="%b %d %Y %H:%M:%S",
-    fmt="[%(levelname)s] [%(asctime)s] [PEPPY] %(message)s",
+    fmt="[%(levelname)s] [%(asctime)s] [PEPRS] %(message)s",
 )
 
 _LOGGER_PEPHUB = logging.getLogger("uvicorn.access")
diff --git a/pephub/routers/api/v1/helpers.py b/pephub/routers/api/v1/helpers.py
index 1610a249..70eae68a 100644
--- a/pephub/routers/api/v1/helpers.py
+++ b/pephub/routers/api/v1/helpers.py
@@ -1,16 +1,14 @@
 import logging
 
-import eido
-from eido.validation import validate_config
-from eido.exceptions import EidoValidationError
-import peppy
+import peprs
 import yaml
 from fastapi.exceptions import HTTPException
-from peppy import Project
-from peppy.const import (
+from peprs import Project
+from peprs.eido import EidoValidationError, validate_config, validate_project
+from peprs.const import (
     CONFIG_KEY,
     SAMPLE_RAW_DICT_KEY,
-    SUBSAMPLE_RAW_LIST_KEY,
+    SUBSAMPLE_RAW_DICT_KEY,
 )
 from ....dependencies import (
     get_db,
@@ -22,7 +20,7 @@
 DEFAULT_SCHEMA_VERSION = "2.1.0"
 
 
-async def verify_updated_project(updated_project) -> peppy.Project:
+async def verify_updated_project(updated_project) -> peprs.Project:
     new_raw_project = {}
 
     agent = get_db()
@@ -37,43 +35,23 @@ async def verify_updated_project(updated_project) -> peppy.Project:
             status_code=400,
             detail="Please provide a sample table and project config yaml to update project",
         )
-    try:
-        validate_config(
-            yaml.safe_load(updated_project.project_config_yaml), default_schema
-        )
-    except EidoValidationError as e:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Config structure error: {', '.join(list(e.errors_by_type.keys()))}. Please check schema definition and try again.",
-        )
-    # sample table update
-    new_raw_project[SAMPLE_RAW_DICT_KEY] = updated_project.sample_table
 
     try:
         yaml_dict = yaml.safe_load(updated_project.project_config_yaml)
-        new_raw_project[CONFIG_KEY] = yaml_dict
     except yaml.scanner.ScannerError as e:
         raise HTTPException(
             status_code=400,
             detail=f"Could not parse provided yaml. Error: {e}",
         )
 
-    # sample_table_index_col = yaml_dict.get(
-    #     SAMPLE_TABLE_INDEX_KEY, SAMPLE_NAME_ATTR  # default to sample_name
-    # )
-
-    # await check_sample_names(
-    #     new_raw_project[SAMPLE_RAW_DICT_KEY], sample_table_index_col
-    # )
+    new_raw_project[CONFIG_KEY] = yaml_dict
+    new_raw_project[SAMPLE_RAW_DICT_KEY] = updated_project.sample_table
 
     # subsample table update
     if updated_project.subsample_tables is not None:
         subsamples = list(updated_project.subsample_tables[0][0].values())
-        new_raw_project[SUBSAMPLE_RAW_LIST_KEY] = (
-            updated_project.subsample_tables
-            if len(subsamples) > 0 and subsamples[0]
-            else None
-        )
+        if len(subsamples) > 0 and subsamples[0]:
+            new_raw_project[SUBSAMPLE_RAW_DICT_KEY] = updated_project.subsample_tables
 
     try:
         new_project = Project.from_dict(new_raw_project)
@@ -83,9 +61,19 @@ async def verify_updated_project(updated_project) -> peppy.Project:
             detail=f"Could not create PEP from provided data. Error: {e}",
         )
 
+    # peprs.eido.validate_config takes a Project (not a raw dict like eido did),
+    # so we validate after constructing the Project.
+    try:
+        validate_config(new_project, default_schema)
+    except EidoValidationError as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Config structure error: {', '.join(list(e.errors_by_type.keys()))}. Please check schema definition and try again.",
+        )
+
     try:
         # validate project (it will also validate samples)
-        eido.validate_project(new_project, default_schema)
+        validate_project(new_project, default_schema)
     except Exception as _:
         raise HTTPException(
             status_code=400,
diff --git a/pephub/routers/api/v1/namespace.py b/pephub/routers/api/v1/namespace.py
index ac357566..022b60ca 100644
--- a/pephub/routers/api/v1/namespace.py
+++ b/pephub/routers/api/v1/namespace.py
@@ -3,7 +3,7 @@
 from typing import List, Literal, Optional, Union
 import os
 
-import peppy
+import peprs
 from dotenv import load_dotenv
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile, Request
 from fastapi.responses import JSONResponse
@@ -22,10 +22,13 @@
     NamespaceStats,
     TarNamespaceModelReturn,
 )
-from peppy import Project
-from peppy.const import DESC_KEY, NAME_KEY
+from peprs import Project
 from typing_extensions import Annotated
 
+# peprs.const does not export these — they are PEP config schema strings.
+NAME_KEY = "name"
+DESC_KEY = "description"
+
 from ....const import (
     DEFAULT_TAG,
     ARCHIVE_URL_PATH,
@@ -213,7 +216,7 @@ async def create_pep(
                 },
                 status_code=202,
             )
-    # create a blank peppy.Project object with fake files
+    # create a blank peprs.Project object with fake files
     else:
         raise HTTPException(
             detail="Project files were not provided",
@@ -258,21 +261,23 @@ async def upload_raw_pep(
         # This configurations needed due to Issue #124 Should be removed in the future
         project_dict = ProjectRawModel(**project_from_json.pep_dict.dict())
         ff = project_dict.model_dump(by_alias=True)
-        p_project = peppy.Project().from_dict(ff)
+        p_project = peprs.Project.from_dict(ff)
 
-        p_project.namespace = name
+        # peprs.Project has no `namespace` attribute, so we set the registry name
+        # in the config and pass `name` separately to agent.project.create.
+        p_project.name = name
         p_project.description = description
 
     except Exception as e:
         raise HTTPException(
-            detail=f"Incorrect raw project was provided. Couldn't initiate peppy object: {e}",
+            detail=f"Incorrect raw project was provided. Couldn't initiate peprs object: {e}",
             status_code=417,
         )
     try:
         agent.project.create(
             p_project,
             namespace=namespace,
-            name=p_project.namespace,
+            name=name,
             tag=tag,
             description=description,
             is_private=is_private,
@@ -282,15 +287,15 @@ async def upload_raw_pep(
         )
     except ProjectUniqueNameError:
         raise HTTPException(
-            detail=f"Project '{namespace}/{p_project.namespace}:{tag}' already exists in namespace",
+            detail=f"Project '{namespace}/{name}:{tag}' already exists in namespace",
             status_code=400,
         )
     return JSONResponse(
         content={
             "namespace": namespace,
-            "name": p_project.namespace,
+            "name": name,
             "tag": tag,
-            "registry_path": f"{namespace}/{p_project.namespace}:{tag}",
+            "registry_path": f"{namespace}/{name}:{tag}",
         },
         status_code=202,
     )
diff --git a/pephub/routers/api/v1/project.py b/pephub/routers/api/v1/project.py
index ea181b92..7ac5d8f6 100644
--- a/pephub/routers/api/v1/project.py
+++ b/pephub/routers/api/v1/project.py
@@ -1,10 +1,9 @@
 import logging
 from typing import Annotated, Any, Literal, Dict, List, Optional, Union
 
-import eido
 import numpy as np
 import pandas as pd
-import peppy
+import peprs
 import yaml
 from dotenv import load_dotenv
 from fastapi import APIRouter, Body, Depends, Query
@@ -29,7 +28,7 @@
     ProjectViews,
     HistoryAnnotationModel,
 )
-from peppy.const import SAMPLE_RAW_DICT_KEY
+from peprs.const import SAMPLE_RAW_DICT_KEY
 
 # from ....const import SAMPLE_CONVERSION_FUNCTIONS
 from ....dependencies import (
@@ -262,25 +261,23 @@ async def get_pep_samples(
             )
 
         if isinstance(proj, dict):
-            if len(proj["_sample_dict"]) > MAX_PROCESSED_PROJECT_SIZE:
+            if len(proj[SAMPLE_RAW_DICT_KEY]) > MAX_PROCESSED_PROJECT_SIZE:
                 raise HTTPException(
                     status_code=400,
                     detail=f"Project is too large. View raw samples, or create a view. Limit is {MAX_PROCESSED_PROJECT_SIZE} samples.",
                 )
-            proj = peppy.Project.from_dict(proj)
+            proj = peprs.Project.from_dict(proj)
 
         if format == "json":
             return {
                 "samples": [sample.to_dict() for sample in proj.samples],
             }
         elif format == "csv":
-            return PlainTextResponse(eido.convert_project(proj, "csv")["samples"])
+            return PlainTextResponse(proj.to_csv_string())
         elif format == "yaml":
-            return PlainTextResponse(
-                eido.convert_project(proj, "yaml-samples")["samples"]
-            )
+            return PlainTextResponse(proj.to_yaml_string())
         elif format == "basic":
-            return eido.convert_project(proj, "basic")
+            return proj.to_dict()
 
     if raw:
         df = pd.DataFrame(proj[SAMPLE_RAW_DICT_KEY])
@@ -289,12 +286,12 @@ async def get_pep_samples(
             items=df.replace({np.nan: None}).to_dict(orient="records"),
         )
     if isinstance(proj, dict):
-        if len(proj["_sample_dict"]) > MAX_PROCESSED_PROJECT_SIZE:
+        if len(proj[SAMPLE_RAW_DICT_KEY]) > MAX_PROCESSED_PROJECT_SIZE:
             raise HTTPException(
                 status_code=400,
                 detail=f"Project is too large. View raw samples, or create a view. Limit is {MAX_PROCESSED_PROJECT_SIZE} samples.",
             )
-        proj = peppy.Project.from_dict(proj)
+        proj = peprs.Project.from_dict(proj)
     return [sample.to_dict() for sample in proj.samples]
 
 
@@ -500,7 +497,7 @@ async def delete_sample(
 
 @project.get("/subsamples", response_model=SamplesResponseModel)
 async def get_subsamples_endpoint(
-    subsamples: peppy.Project = Depends(get_subsamples),
+    subsamples: list = Depends(get_subsamples),
     download: bool = False,
 ):
     """
@@ -543,11 +540,8 @@ async def convert_pep(
     format: Optional[str] = "plain",
 ):
     """
-    Convert a PEP to a specific format, f. For a list of available formats/filters,
-    see /eido/filters.
-
-    See, http://eido.databio.org/en/latest/filters/#convert-a-pep-into-an-alternative-format-with-a-filter
-    for more information.
+    Convert a PEP to a specific format. Supported filters are: basic, csv, yaml,
+    yaml-samples, json.
 
     Don't have a namespace, or project?
 
@@ -559,18 +553,26 @@ async def convert_pep(
     """
     # default to basic
     if filter is None:
-        filter = "basic"  # default to basic
+        filter = "basic"
 
-    # validate filter exists
-    filter_list = eido.get_available_pep_filters()
-    if filter not in filter_list:
+    # eido filter infrastructure is not in peprs; emulate the previously supported
+    # filters using peprs Project conversion methods.
+    available_filters = ["basic", "csv", "yaml", "yaml-samples", "json"]
+    if filter not in available_filters:
         raise HTTPException(
-            400, f"Unknown filter '{filter}'. Available filters: {filter_list}"
+            400, f"Unknown filter '{filter}'. Available filters: {available_filters}"
         )
 
-    # generate result
-    peppy_project = peppy.Project.from_dict(proj)
-    conv_result = eido.run_filter(peppy_project, filter, verbose=False)
+    peprs_project = peprs.Project.from_dict(proj)
+
+    if filter == "basic":
+        conv_result = {"project_config.yaml": peprs_project.to_yaml_string()}
+    elif filter == "csv":
+        conv_result = {"sample_table.csv": peprs_project.to_csv_string()}
+    elif filter in ("yaml", "yaml-samples"):
+        conv_result = {"sample_table.yaml": peprs_project.to_yaml_string()}
+    else:  # json
+        conv_result = {"project.json": peprs_project.to_json_string()}
 
     if format == "plain":
         return_str = "\n".join([conv_result[k] for k in conv_result])
@@ -996,7 +998,7 @@ def get_project_history_by_id(
             with_id=True,
         )
         # convert the config to a yaml string
-        project_at_history["_config"] = yaml.dump(project_at_history["_config"])
+        project_at_history["config"] = yaml.dump(project_at_history["config"])
         return project_at_history
 
     except ProjectNotFoundError:
diff --git a/pephub/routers/eido/eido.py b/pephub/routers/eido/eido.py
index 248b29a1..c9108b8b 100644
--- a/pephub/routers/eido/eido.py
+++ b/pephub/routers/eido/eido.py
@@ -2,8 +2,7 @@
 import tempfile
 from typing import List, Optional, Tuple
 
-import eido
-import peppy
+import peprs
 import requests
 import yaml
 from fastapi import APIRouter, Depends, Form, UploadFile
@@ -13,6 +12,7 @@
 from pepdbagent.exceptions import SchemaDoesNotExistError
 from pepdbagent.utils import schema_path_converter
 from pepdbagent.const import LATEST_SCHEMA_VERSION
+from peprs.eido import EidoValidationError, validate_project
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 
@@ -31,6 +31,20 @@ async def status():
     return JSONResponse(schemas_to_test)
 
 
+def _read_schema(path_or_url: str) -> dict:
+    """
+    Fetch and parse an eido YAML schema from a local file path or URL.
+    peprs.eido does not yet expose a read_schema helper, so we inline a
+    minimal implementation here.
+    """
+    if path_or_url.startswith(("http://", "https://")):
+        resp = requests.get(path_or_url)
+        resp.raise_for_status()
+        return yaml.safe_load(resp.text)
+    with open(path_or_url) as f:
+        return yaml.safe_load(f)
+
+
 @router.get("/schemas/{namespace}/{project}")
 async def get_schema(request: Request, namespace: str, project: str):
     """
@@ -41,15 +55,16 @@ async def get_schema(request: Request, namespace: str, project: str):
     # like pipelines/ProseqPEP.yaml
 
     try:
-        schema = eido.read_schema(
-            f"https://schema.databio.org/{namespace}/{project}.yaml"
-        )[0]
-    except IndexError:
+        schema = _read_schema(f"https://schema.databio.org/{namespace}/{project}.yaml")
+    except Exception:
         raise HTTPException(status_code=404, detail="Schema not found")
 
     return schema
 
 
+# Note: The pephub web UI now runs validation client-side via the
+# @pepkit/peprs WASM bindings. This server-side endpoint is kept for
+# programmatic/API consumers. See validation_wasm_plan.md.
 @router.post("/validate")
 async def validate(
     # accept both pep_registry and pep_files, both should be optional
@@ -90,12 +105,12 @@ async def validate(
 
         pep_annot = agent.annotation.get(namespace=namespace, name=name, tag=tag)
 
-        if pep_annot.results[0].number_of_samples > MAX_PROCESSED_PROJECT_SIZE:
-            return {
-                "valid": False,
-                "error_type": "Project size",
-                "errors": ["Project is too large. Can't validate."],
-            }
+        # if pep_annot.results[0].number_of_samples > MAX_PROCESSED_PROJECT_SIZE:
+        #     return {
+        #         "valid": False,
+        #         "error_type": "Project size",
+        #         "errors": ["Project is too large. Can't validate."],
+        #     }
 
         p = agent.project.get(namespace, name, tag, raw=False)
     else:
@@ -115,7 +130,7 @@ async def validate(
                     with open(f"{dirpath}/{upload_file.filename}", "wb") as local_tmpf:
                         shutil.copyfileobj(upload_file.file, local_tmpf)
 
-            p = peppy.Project(f"{dirpath}/{init_file.filename}")
+            p = peprs.Project(f"{dirpath}/{init_file.filename}")
 
     if schema is None and schema_registry is None and schema_file is None:
         raise HTTPException(
@@ -156,28 +171,28 @@ async def validate(
         contents = schema_file.file.read()
         schema_dict = yaml.safe_load(contents)
     else:
-        # save schema string to temp file, then read in with eido
-        with tempfile.NamedTemporaryFile(mode="w") as schema_file:
-            schema_file.write(schema)
-            schema_file.flush()
-            try:
-                schema_dict = eido.read_schema(schema_file.name)[0]
-            except eido.exceptions.EidoSchemaInvalidError as e:
-                raise HTTPException(
-                    status_code=200,
-                    detail={"error": f"Schema is invalid: {str(e)}"},
-                )
+        # parse the schema string directly; peprs.eido has no read_schema /
+        # EidoSchemaInvalidError, so any parse failure is reported as a schema error.
+        try:
+            schema_dict = yaml.safe_load(schema)
+            if not isinstance(schema_dict, dict):
+                raise ValueError("Schema must parse to a YAML mapping")
+        except Exception as e:
+            raise HTTPException(
+                status_code=200,
+                detail={"error": f"Schema is invalid: {str(e)}"},
+            )
 
     # validate project
     try:
-        eido.validate_project(
+        validate_project(
             p,
             schema_dict,
         )
 
     # while we catch this, its still a 200 response since we want to
     # return the validation errors
-    except eido.exceptions.EidoValidationError as e:
+    except EidoValidationError as e:
         error_type, property_names = await eido_error_string_converter(e)
 
         return {"valid": False, "error_type": error_type, "errors": property_names}
@@ -193,33 +208,57 @@ async def validate(
 
 
 async def eido_error_string_converter(
-    e: eido.exceptions.EidoValidationError,
+    e: EidoValidationError,
 ) -> Tuple[str, List[str]]:
     """
     Convert eido error into nice modified string
 
-    :param e: eido Validation error
+    peprs.eido.EidoValidationError.errors_by_type has the shape:
+        {
+            "<error_type>": [
+                {"path": ..., "message": ..., "sample_names": [...optional]},
+                ...
+            ],
+            ...
+        }
+    An item without "sample_names" is a project-level error; otherwise it
+    is a sample-level error affecting the listed samples.
+
+    :param e: peprs.eido Validation error
     :return: error_type, property_names
     """
-    property_names = []
-    error_type_list = []
-    for item_list in e.errors_by_type.values():
-        property_type = item_list[0]["type"]
-        property_name_list = []
+    property_names: List[str] = []
+    error_type_set = set()
+    messages = []
+
+    for error_type_key, item_list in e.errors_by_type.items():
+        sample_names_all: List[str] = []
+        has_project_level = False
         for item in item_list:
-            if item["sample_name"] == "project":
-                error_type_list.append("Project")
-                break
+            sample_names = item.get("sample_names") or []
+            if sample_names:
+                sample_names_all.extend(sample_names)
+                messages.append(item.get("message"))
+            else:
+                has_project_level = True
+
+        if sample_names_all:
+            error_type_set.add("Samples")
+            if len(sample_names_all) > 20:
+                property_names.append(
+                    f"{error_type_key}: more than 20 samples have encountered errors."
+                )
             else:
-                error_type_list.append("Samples")
-                if len(item_list) > 20:
-                    property_names = ["More than 20 samples have encountered errors."]
-                else:
-                    property_name_list.append(item["sample_name"])
-
-        if len(property_name_list) > 0:
-            property_names.append(f"{property_type} ({', '.join(property_name_list)})")
-        else:
-            property_names.append(f"{property_type} in the project")
-    error_type = " and ".join(set(error_type_list))
+                property_names.append(
+                    f"{error_type_key} ({', '.join(sample_names_all)})"
+                )
+        if not sample_names_all:
+            property_names = messages
+
+        if has_project_level:
+            error_type_set.add("Project")
+            property_names.append(f"{error_type_key} in the project")
+
+    error_type = " and ".join(sorted(error_type_set))
+
     return error_type, property_names
diff --git a/pephub/routers/models.py b/pephub/routers/models.py
index 8e52579b..f649a545 100644
--- a/pephub/routers/models.py
+++ b/pephub/routers/models.py
@@ -74,25 +74,25 @@ class JWTDeviceTokenResponse(BaseModel):
 
 
 class ProjectRawModel(BaseModel):
-    config: dict = Field(alias="_config")
-    subsample_list: Optional[list] = Field(alias="_subsample_list", default=None)
-    sample_list: list[dict] = Field(alias="_sample_dict")
+    config: dict
+    subsamples: Optional[list] = None
+    samples: list[dict]
 
     model_config = ConfigDict(populate_by_name=True)
 
 
 class ProjectHistoryResponse(BaseModel):
-    config: str = Field(alias="_config")
-    subsample_list: Optional[list] = Field(alias="_subsample_list", default=None)
-    sample_list: list[dict] = Field(alias="_sample_dict")
+    config: str
+    subsamples: Optional[list] = None
+    samples: list[dict]
 
     model_config = ConfigDict(populate_by_name=True)
 
 
 class ProjectRawRequest(BaseModel):
     config: dict
-    subsample_list: Optional[List[List[dict]]] = None
-    sample_list: List[dict]
+    subsamples: Optional[List[List[dict]]] = None
+    samples: List[dict]
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
@@ -120,7 +120,7 @@ class DeveloperKey(BaseModel):
 
 class VersionResponseModel(BaseModel):
     pephub_version: str
-    peppy_version: str
+    peprs_version: str
     python_version: str
     fastapi_version: str
     pepdbagent_version: str
diff --git a/pephub/routers/views/eido.py b/pephub/routers/views/eido.py
index d57fff81..7c3bc55c 100644
--- a/pephub/routers/views/eido.py
+++ b/pephub/routers/views/eido.py
@@ -1,15 +1,16 @@
 from platform import python_version
 
-import eido
 import jinja2
+import requests
+import yaml
 from dotenv import load_dotenv
 from fastapi import APIRouter, Request
+from fastapi.exceptions import HTTPException
 from fastapi.responses import HTMLResponse
-from peppy import __version__ as peppy_version
 from starlette.templating import Jinja2Templates
 
 from ..._version import __version__ as pephub_version
-from ...const import EIDO_TEMPLATES_PATH
+from ...const import EIDO_TEMPLATES_PATH, peprs_version
 
 load_dotenv()
 
@@ -18,7 +19,7 @@
 
 ALL_VERSIONS = {
     "pephub_version": pephub_version,
-    "peppy_version": peppy_version,
+    "peprs_version": peprs_version,
     "python_version": python_version(),
     "api_version": 1,
 }
@@ -35,7 +36,13 @@ async def get_schema(request: Request, namespace: str, project: str):
     # endpoint to schema.databio.org/...
     # like pipelines/ProseqPEP.yaml
 
-    schema = eido.read_schema(f"http://schema.databio.org/{namespace}/{project}")
+    # peprs.eido has no read_schema helper, so fetch and parse the YAML directly.
+    try:
+        resp = requests.get(f"http://schema.databio.org/{namespace}/{project}")
+        resp.raise_for_status()
+        schema = yaml.safe_load(resp.text)
+    except Exception:
+        raise HTTPException(status_code=404, detail="Schema not found")
 
     return templates.TemplateResponse(
         "schema.html",
diff --git a/requirements/requirements-all.txt b/requirements/requirements-all.txt
index b1b12340..302998fa 100644
--- a/requirements/requirements-all.txt
+++ b/requirements/requirements-all.txt
@@ -1,9 +1,8 @@
 fastapi>=0.108.0
 psycopg>=3.1.15
-pepdbagent>=0.12.4
-# pepdbagent @ git+https://github.com/pepkit/pepdbagent.git@dev#egg=pepdbagent
-peppy>=0.40.7
-eido>=0.2.4
+#pepdbagent>=0.12.4
+ pepdbagent @ git+https://github.com/pepkit/pepdbagent.git@peprs#egg=pepdbagent
+peprs>=0.2.0
 jinja2>=3.1.2
 python-multipart>=0.0.5
 uvicorn
diff --git a/tests/conftest.py b/tests/conftest.py
index 2ab8d763..8cf53b2e 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -4,7 +4,7 @@
 import pytest
 import requests
 from pepdbagent import PEPDatabaseAgent
-from peppy import Project
+from peprs import Project
 
 
 @pytest.fixture
diff --git a/tests/test_validation.py b/tests/test_validation.py
index b2b79f43..3b0c8667 100644
--- a/tests/test_validation.py
+++ b/tests/test_validation.py
@@ -1,4 +1,4 @@
-import eido
+from peprs import eido
 import pytest
 
 from pephub.dependencies import *
@@ -13,7 +13,7 @@ def test_file_file_validate_valid(project_object_file, schema_file_path):
 
 # test project file on schema file validation failure
 def test_file_file_validate_invalid(project_object_file, schema_file_path_invalid):
-    with pytest.raises(eido.exceptions.EidoValidationError):
+    with pytest.raises(eido.EidoValidationError):
         eido.validate_project(
             project=project_object_file, schema=schema_file_path_invalid
         )
@@ -26,7 +26,7 @@ def test_file_string_validate_valid(project_object_file, schema_paste):
 
 # test project file on schema string validation failure
 def test_file_string_validate_invalid(project_object_file, schema_paste_invalid):
-    with pytest.raises(eido.exceptions.EidoValidationError):
+    with pytest.raises(eido.EidoValidationError):
         eido.validate_project(project=project_object_file, schema=schema_paste_invalid)
 
 
@@ -37,7 +37,7 @@ def test_file_url_validate_valid(project_object_file, schema_from_url_valid):
 
 # test project file on schema url validation failure
 def test_file_url_validate_invalid(project_object_file, schema_from_url_invalid):
-    with pytest.raises(eido.exceptions.EidoValidationError):
+    with pytest.raises(eido.EidoValidationError):
         eido.validate_project(
             project=project_object_file, schema=schema_from_url_invalid
         )
@@ -50,7 +50,7 @@ def test_registry_paste_valid(db, schema_paste):
 
 def test_registry_paste_invalid(db, schema_paste_invalid):
     p = db.project.get("ayobi", "new-project-test12345", "default")
-    with pytest.raises(eido.exceptions.EidoValidationError):
+    with pytest.raises(eido.EidoValidationError):
         eido.validate_project(project=p, schema=schema_paste_invalid)
 
 
@@ -61,7 +61,7 @@ def test_registry_file_valid(db, schema_file_path):
 
 def test_registry_file_invalid(db, schema_file_path_invalid):
     p = db.project.get("ayobi", "new-project-test12345", "default")
-    with pytest.raises(eido.exceptions.EidoValidationError):
+    with pytest.raises(eido.EidoValidationError):
         eido.validate_project(project=p, schema=schema_file_path_invalid)
 
 
@@ -72,5 +72,5 @@ def test_registry_url_valid(db, schema_from_url_valid):
 
 def test_registry_url_invalid(db, schema_from_url_invalid):
     p = db.project.get("ayobi", "new-project-test12345", "default")
-    with pytest.raises(eido.exceptions.EidoValidationError):
+    with pytest.raises(eido.EidoValidationError):
         eido.validate_project(project=p, schema=schema_from_url_invalid)
diff --git a/web/package.json b/web/package.json
index c0a240fe..d4427736 100644
--- a/web/package.json
+++ b/web/package.json
@@ -1,7 +1,7 @@
 {
   "name": "web",
   "private": true,
-  "version": "0.15.4",
+  "version": "0.16.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -15,6 +15,7 @@
     "@hookform/error-message": "^2.0.1",
     "@mdx-js/react": "^3.0.0",
     "@monaco-editor/react": "^4.4.6",
+    "@databio/peprs": "^0.2.0",
     "@popperjs/core": "^2.11.6",
     "@tanstack/react-query": "^5.0.0",
     "@tanstack/react-query-devtools": "^5.0.0",
diff --git a/web/src/api/namespace.ts b/web/src/api/namespace.ts
index 933c2dff..663d0476 100644
--- a/web/src/api/namespace.ts
+++ b/web/src/api/namespace.ts
@@ -219,7 +219,7 @@ export const submitProjectJSON = (
       {
         pep_dict: {
           config: config_json,
-          sample_list: sample_table,
+          samples: sample_table,
         },
         description: description || '',
         name: name,
@@ -269,7 +269,7 @@ export const submitPop = (
       {
         pep_dict: {
           config: config_json,
-          sample_list: peps,
+          samples: peps,
           pep_schema: pep_schema,
         },
         description: description || '',
diff --git a/web/src/api/project.ts b/web/src/api/project.ts
index 540c1dde..6793f24b 100644
--- a/web/src/api/project.ts
+++ b/web/src/api/project.ts
@@ -25,7 +25,7 @@ type ProjectUpdateMetadata = ProjectUpdateItems & {
   sample_table?: Sample[] | null;
   project_config_yaml?: string | null;
   description?: string | null;
-  subsample_list?: string[] | null;
+  subsample_tables?: any[][] | null;
 };
 export type SampleTableResponse = {
   count: number;
diff --git a/web/src/api/server.ts b/web/src/api/server.ts
index ef3ab976..19e756cf 100644
--- a/web/src/api/server.ts
+++ b/web/src/api/server.ts
@@ -2,7 +2,7 @@ import axios from 'axios';
 
 export interface ApiBase {
   pephub_version: string;
-  peppy_version: string;
+  peprs_version: string;
   python_version: string;
   fastapi_version: string;
   pepdbagent_version: string;
diff --git a/web/src/components/forms/components/schemas-databio-dropdown.tsx b/web/src/components/forms/components/schemas-databio-dropdown.tsx
index 6a03a93a..f2cc4b39 100644
--- a/web/src/components/forms/components/schemas-databio-dropdown.tsx
+++ b/web/src/components/forms/components/schemas-databio-dropdown.tsx
@@ -12,7 +12,7 @@ interface Props {
   defaultValue?: string;
 }
 
-const SchemaDropdown: FC<Props> = ({ value, onChange, showDownload = true, defaultValue = 'databio/pep'}) => {
+const SchemaDropdown: FC<Props> = ({ value, onChange, showDownload = true, defaultValue }) => {
   const { data: schemas, isFetching: isLoading } = useAllSchemas({});
 
   const options = (schemas?.results || []).map((schema) => ({
@@ -20,14 +20,16 @@ const SchemaDropdown: FC<Props> = ({ value, onChange, showDownload = true, defau
     value: `${schema.namespace}/${schema.schema_name}`,
   }));
 
-  const defaultSchema = defaultValue;
-  const valueForSelect = options.find((option) => option.value === value);
+  const valueForSelect = options.find((option) => option.value === value) ?? null;
+  const defaultValueForSelect = defaultValue
+    ? { label: defaultValue, value: defaultValue }
+    : undefined;
 
   return (
     <div className="d-flex flex-row align-items-center gap-1 w-100">
       <Select
         options={options}
-        defaultValue={{ label: defaultSchema, value: defaultSchema }}
+        defaultValue={defaultValueForSelect}
         value={valueForSelect}
         onChange={(newValue: SingleValue<{ label: string; value: string }>) => {
           onChange(newValue?.value || '');
diff --git a/web/src/components/forms/validator-form.tsx b/web/src/components/forms/validator-form.tsx
index bbfb2508..88d6355e 100644
--- a/web/src/components/forms/validator-form.tsx
+++ b/web/src/components/forms/validator-form.tsx
@@ -1,13 +1,18 @@
 import Editor from '@monaco-editor/react';
-import { FC, useRef, useState } from 'react';
+import { useQueries } from '@tanstack/react-query';
+import { FC, useMemo, useRef, useState } from 'react';
 import { Tab, Tabs } from 'react-bootstrap';
 import { Controller, useForm } from 'react-hook-form';
 import Select from 'react-select';
 
+import { getNamespaceProjects } from '../../api/namespace';
 import { useSession } from '../../contexts/session-context';
-import { useNamespaceProjects } from '../../hooks/queries/useNamespaceProjects';
-import { ValidationParams } from '../../hooks/queries/useValidation';
-import { useValidation } from '../../hooks/queries/useValidation';
+import { PepValidationOutcome, validatePep } from '../../utils/validate-pep';
+import {
+  prepareSchema,
+  preparePepFromFiles,
+  preparePepFromRegistry,
+} from '../../utils/validator-form-helpers';
 import { popFileFromFileList } from '../../utils/dragndrop';
 import { FileDropZone } from './components/file-dropzone';
 import { SchemaDropdown } from './components/schemas-databio-dropdown';
@@ -32,10 +37,36 @@ interface ValidatorFormProps {
 }
 
 export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath, defaultSchemaRegistryPath }) => {
-  const { user, login } = useSession();
-  const { data: projects } = useNamespaceProjects(user?.login, {});
+  const { user, jwt, login } = useSession();
+
+  const namespaces = useMemo(
+    () => (user ? [user.login, ...(user.orgs ?? [])] : []),
+    [user],
+  );
+
+  const projectQueries = useQueries({
+    queries: namespaces.map((ns) => ({
+      queryKey: [ns, {}],
+      queryFn: () => getNamespaceProjects(ns, jwt, {}),
+      enabled: !!ns,
+    })),
+  });
+
+  const pepOptions = useMemo(() => {
+    const seen = new Set<string>();
+    const opts: { label: string; value: string }[] = [];
+    projectQueries.forEach((q) => {
+      q.data?.results?.forEach((project) => {
+        const path = `${project.namespace}/${project.name}:${project.tag}`;
+        if (!seen.has(path)) {
+          seen.add(path);
+          opts.push({ value: path, label: path });
+        }
+      });
+    });
+    return opts;
+  }, [projectQueries]);
 
-  // instantiate form
   const {
     reset: resetForm,
     setValue: setFormValue,
@@ -45,16 +76,10 @@ export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath,
   } = useForm<ValidatorFormInputs>({
     defaultValues: {
       pepRegistryPath: defaultPepRegistryPath
-        ? {
-            label: defaultPepRegistryPath || '',
-            value: defaultPepRegistryPath || '',
-          }
+        ? { label: defaultPepRegistryPath, value: defaultPepRegistryPath }
         : null,
       schemaRegistryPath: defaultSchemaRegistryPath
-        ? {
-            label: defaultSchemaRegistryPath || '',
-            value: defaultSchemaRegistryPath || '',
-          }
+        ? { label: defaultSchemaRegistryPath, value: defaultSchemaRegistryPath }
         : null,
     },
   });
@@ -64,42 +89,16 @@ export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath,
   const [useExistingPEP, setUseExistingPEP] = useState(true);
   const [useExistingSchema, setUseExistingSchema] = useState(true);
 
-  // watch the form data so we can use it
   const pepFiles = watch('pepFiles');
   const pepRegistryPath = watch('pepRegistryPath');
   const schemaFile = watch('schemaFile');
   const schemaRegistryPath = watch('schemaRegistryPath');
   const schemaPasteValue = watch('schemaPaste');
 
-  // validation params for the useValidation hook
-  let params = {
-    enabled: false,
-  } as ValidationParams;
-
-  // populate params based on form data for the PEP
-  if (useExistingPEP) {
-    params.pepRegistry = pepRegistryPath?.value;
-    params.pepFiles = undefined;
-  } else {
-    params.pepRegistry = undefined;
-    params.pepFiles = pepFiles;
-  }
-
-  // populate params based on form data for the schema
-  if (useExistingSchema) {
-    params.schema_registry = schemaRegistryPath?.value;
-    params.schema = undefined;
-  } else if (schemaPasteValue) {
-    params.schema_registry = undefined;
-    params.schema = schemaPasteValue;
-  } else {
-    params.schema_registry = undefined;
-    // just take the first file they give
-    params.schema_file = schemaFile && schemaFile.length > 0 ? schemaFile[0] : undefined;
-  }
-
-  // validator hook
-  const { data: result, error, isFetching: isValidating, refetch } = useValidation(params);
+  const [isValidating, setIsValidating] = useState(false);
+  const [result, setResult] = useState<PepValidationOutcome | undefined>();
+  const [runError, setRunError] = useState<string | undefined>();
+  const [validationTimeMs, setValidationTimeMs] = useState<number | undefined>();
 
   const resetValidator = () => {
     resetForm({
@@ -109,29 +108,44 @@ export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath,
       schemaRegistryPath: null,
       schemaPaste: undefined,
     });
+    setResult(undefined);
+    setRunError(undefined);
   };
 
-  const runValidation = () => {
-    refetch();
+  const runValidation = async () => {
+    setIsValidating(true);
+    setResult(undefined);
+    setRunError(undefined);
+    setValidationTimeMs(undefined);
+    try {
+      const pep = useExistingPEP
+        ? await preparePepFromRegistry(pepRegistryPath?.value || '')
+        : await preparePepFromFiles(pepFiles as FileList);
+
+      const schema = await prepareSchema({
+        registryPath: useExistingSchema ? schemaRegistryPath?.value : undefined,
+        file: !useExistingSchema && schemaFile && schemaFile.length > 0 ? schemaFile[0] : undefined,
+        pasted: !useExistingSchema && !schemaFile && schemaPasteValue ? schemaPasteValue : undefined,
+      });
+
+      const t0 = performance.now();
+      const outcome = await validatePep({
+        configYaml: pep.configYaml,
+        samples: pep.samples,
+        subsamples: pep.subsamples,
+        schema,
+      });
+      setValidationTimeMs(performance.now() - t0);
+      setResult(outcome);
+    } catch (e) {
+      setRunError(e instanceof Error ? e.message : String(e));
+    } finally {
+      setIsValidating(false);
+    }
   };
 
   return (
     <>
-      {/* Only in development mode  */}
-      {/* render the params */}
-      {/* @ts-ignore */}
-      {process.env.NODE_ENV === 'development' && (
-        <div className="my-3">
-          <pre>
-            <code>{JSON.stringify(params, null, 2)}</code>
-          </pre>
-          <pre>
-            <code>Use existing PEP: {JSON.stringify(useExistingPEP)}</code>
-            <br />
-            <code>Use existing schema: {JSON.stringify(useExistingSchema)}</code>
-          </pre>
-        </div>
-      )}
       <form className="form-control border-dark shadow-sm">
         <div className="p-2">
           <label className="form-label fw-bold h5">1. Select your PEP</label>
@@ -158,17 +172,12 @@ export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath,
                       placeholder="Select a PEP"
                       className="mt-2"
                       // @ts-ignore
-                      options={
-                        projects?.results.map((project) => ({
-                          value: `${project.namespace}/${project.name}:${project.tag}`,
-                          label: `${project.namespace}/${project.name}:${project.tag}`,
-                        })) || []
-                      }
+                      options={pepOptions}
                       noOptionsMessage={() => {
                         if (user) {
                           return (
                             <span>
-                              No PEPs found in your namespace. <a href={`/${user.login}`}>Create a new PEP</a>.
+                              No PEPs found in your namespaces. <a href={`/${user.login}`}>Create a new PEP</a>.
                             </span>
                           );
                         } else {
@@ -243,10 +252,7 @@ export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath,
                     <SchemaDropdown
                       value={field.value?.value || undefined}
                       onChange={(schema) => {
-                        setFormValue('schemaRegistryPath', {
-                          value: schema,
-                          label: schema,
-                        });
+                        setFormValue('schemaRegistryPath', { value: schema, label: schema });
                       }}
                     />
                   )}
@@ -298,8 +304,13 @@ export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath,
             </Tab>
           </Tabs>
           <div className="mt-3">
-            <button onClick={() => runValidation()} disabled={!isValid} type="button" className="me-1 btn btn-success">
-              Validate
+            <button
+              onClick={() => runValidation()}
+              disabled={!isValid || isValidating}
+              type="button"
+              className="me-1 btn btn-success"
+            >
+              {isValidating ? 'Validating...' : 'Validate'}
             </button>
             <button
               disabled={!isDirty}
@@ -318,37 +329,44 @@ export const ValidatorForm: FC<ValidatorFormProps> = ({ defaultPepRegistryPath,
             <img className="bounce" src="/pep-dark.svg" alt="loading" width="50" height="50" />
             <p className="text-muted">Validating...</p>
           </div>
-        ) : error ? (
+        ) : runError ? (
           <div className="alert alert-danger" role="alert">
-            <pre>
-              <code>{JSON.stringify(error, null, 2)}</code>
-            </pre>
+            <pre className="mb-0"><code>{runError}</code></pre>
           </div>
         ) : result ? (
-          <>
-            {result.valid ? (
-              <div className="alert alert-success" role="alert">
-                <p className="mb-0">PEP is valid!</p>
-              </div>
-            ) : (
-              <>
-                <div className="alert alert-danger" role="alert">
-                  <p className="mb-0">
-                    {result.error_type === 'Schema' ? 'Schema is invalid, found issue with:' : 'PEP is invalid!'}
-                  </p>
-                  <p className="mb-0">{result.error_type !== 'Schema' && <>Errors found in {result.error_type} </>}</p>
-                  <code className="error-code">
-                    {result.errors.map((e) => (
-                      <pre className="mb-2 text-danger" key={e}>
-                        <i className="bi bi bi-exclamation-triangle me-2"></i>
-                        {`${e}`}
-                      </pre>
-                    ))}
-                  </code>
-                </div>
-              </>
-            )}
-          </>
+          result.state === 'valid' ? (
+            <div className="alert alert-success" role="alert">
+              <p className="mb-0">
+                PEP is valid!
+                {validationTimeMs !== undefined && (
+                  <span className="ms-2 text-muted small">({(validationTimeMs / 1000).toFixed(2)}s)</span>
+                )}
+              </p>
+            </div>
+          ) : result.state === 'error' ? (
+            <div className="alert alert-danger" role="alert">
+              <p className="mb-0">Validation could not run:</p>
+              <pre className="mb-0"><code>{result.message}</code></pre>
+            </div>
+          ) : (
+            <div className="alert alert-danger" role="alert">
+              <p className="mb-0">
+                PEP is invalid!
+                {validationTimeMs !== undefined && (
+                  <span className="ms-2 text-muted small">({(validationTimeMs / 1000).toFixed(2)}s)</span>
+                )}
+              </p>
+              <p className="mb-0">Errors found in {result.errorType}</p>
+              <code className="error-code">
+                {result.errors.map((e, i) => (
+                  <pre className="mb-2 text-danger" key={i}>
+                    <i className="bi bi bi-exclamation-triangle me-2"></i>
+                    {e}
+                  </pre>
+                ))}
+              </code>
+            </div>
+          )
         ) : null}
       </div>
     </>
diff --git a/web/src/components/layout/page-layout.tsx b/web/src/components/layout/page-layout.tsx
index 9351a0e0..f2a80baa 100644
--- a/web/src/components/layout/page-layout.tsx
+++ b/web/src/components/layout/page-layout.tsx
@@ -24,7 +24,7 @@ const Footer: FC = () => {
         <div className="d-flex flex-column">
           <div>
             <span className="badge rounded-pill bg-secondary me-1">pephub {data?.pephub_version || ''}</span>
-            <span className="badge rounded-pill bg-secondary me-1">peppy {data?.peppy_version || ''}</span>
+            <span className="badge rounded-pill bg-secondary me-1">peprs {data?.peprs_version || ''}</span>
             <span className="badge rounded-pill bg-secondary me-1">Python {data?.python_version || ''}</span>
             <span className="badge rounded-pill bg-secondary me-1">pepdbagent {data?.pepdbagent_version || ''}</span>
           </div>
diff --git a/web/src/components/modals/validation-result.tsx b/web/src/components/modals/validation-result.tsx
index 975aeb2a..8be86bf8 100644
--- a/web/src/components/modals/validation-result.tsx
+++ b/web/src/components/modals/validation-result.tsx
@@ -4,13 +4,13 @@ import { Controller, useForm } from 'react-hook-form';
 
 import { useProjectPage } from '../../contexts/project-page-context';
 import { useEditProjectMetaMutation } from '../../hooks/mutations/useEditProjectMetaMutation';
-import { useValidation } from '../../hooks/queries/useValidation';
+import { PepValidationOutcome } from '../../utils/validate-pep';
 import { SchemaDropdown } from '../forms/components/schemas-databio-dropdown';
 
 type Props = {
   show: boolean;
   onHide: () => void;
-  validationResult: ReturnType<typeof useValidation>['data'];
+  validationResult: PepValidationOutcome | undefined;
   currentSchema: string | undefined;
 };
 
@@ -58,7 +58,7 @@ export const ValidationResultModal = (props: Props) => {
         <h1 className="modal-title fs-5">
           {currentSchema ? (
             <>
-              {validationResult?.valid ? (
+              {validationResult?.state === 'valid' ? (
                 <span className="text-success d-flex align-items-center gap-1">
                   <i className="bi bi-check-circle"></i>
                   Validation Passed
@@ -78,16 +78,25 @@ export const ValidationResultModal = (props: Props) => {
       <Modal.Body>
         {currentSchema && (
           <>
-            {validationResult?.valid ? (
+            {validationResult?.state === 'valid' ? (
               <p>Your PEP is valid against the schema.</p>
-            ) : (
+            ) : validationResult?.state === 'invalid' ? (
               <Fragment>
                 <p>Your PEP is invalid against the schema.</p>
-                <p>Validation result:</p>
+                <p>Errors found in {validationResult.errorType}:</p>
+                <pre>
+                  <code>{validationResult.errors.join('\n')}</code>
+                </pre>
+              </Fragment>
+            ) : validationResult?.state === 'error' ? (
+              <Fragment>
+                <p>Validation could not run:</p>
                 <pre>
-                  <code>{JSON.stringify(validationResult, null, 2)}</code>
+                  <code>{validationResult.message}</code>
                 </pre>
               </Fragment>
+            ) : (
+              <p>Validating...</p>
             )}
           </>
         )}
diff --git a/web/src/components/project/project-info-footer.tsx b/web/src/components/project/project-info-footer.tsx
index 1f564601..4a8144e9 100644
--- a/web/src/components/project/project-info-footer.tsx
+++ b/web/src/components/project/project-info-footer.tsx
@@ -49,7 +49,7 @@ export const ProjectInfoFooter = () => {
             <span className="mx-1">{projectInfo?.pop ? 'Project' : 'Sample'} Count:</span>
             <span id="project-update-date">
               {currentHistoryId !== null
-                ? projectHistoryQuery.data?._sample_dict.length
+                ? projectHistoryQuery.data?.samples.length
                 : projectInfo?.number_of_samples}
             </span>
           </div>
diff --git a/web/src/components/project/project-interface.tsx b/web/src/components/project/project-interface.tsx
index 35378dc1..915a7639 100644
--- a/web/src/components/project/project-interface.tsx
+++ b/web/src/components/project/project-interface.tsx
@@ -25,6 +25,8 @@ import { ProjectValidationAndEditButtons } from './project-validation-and-edit-b
 import { StandardizeMetadataModal } from '../modals/standardize-metadata';
 import { useStandardizeModalStore } from '../../hooks/stores/useStandardizeModalStore'
 import { useSchemaVersions } from '../../hooks/queries/useSchemaVersions';
+import { useSchemaJson } from '../../hooks/queries/useSchemaJson';
+import { useClientSidePepValidation } from '../../hooks/useClientSidePepValidation';
 
 type Props = {
   projectConfig: ReturnType<typeof useProjectConfig>['data'];
@@ -90,6 +92,37 @@ export const ProjectInterface = (props: Props) => {
   const newSubsamples = projectUpdates.watch('subsamples');
   const newConfig = projectUpdates.watch('config');
 
+  // Client-side live validation via peprs WASM.
+  const { data: schemaJson } = useSchemaJson(projectInfo?.pep_schema);
+
+  const liveValidationInput = (() => {
+    try {
+      const samples = arraysToSampleList(newSamples || [], 'Sample') as unknown as Record<string, unknown>[];
+      const subsamplesParsed = newSubsamples && newSubsamples.length > 1
+        ? [arraysToSampleList(newSubsamples, 'Subsample') as unknown as Record<string, unknown>[]]
+        : undefined;
+      return { samples, subsamples: subsamplesParsed, parseError: undefined as string | undefined };
+    } catch (e) {
+      return {
+        samples: undefined,
+        subsamples: undefined,
+        parseError: e instanceof Error ? e.message : String(e),
+      };
+    }
+  })();
+
+  const { isValidating, result: validationResult } = useClientSidePepValidation({
+    configYaml: newConfig,
+    samples: liveValidationInput.samples,
+    subsamples: liveValidationInput.subsamples,
+    schema: schemaJson,
+    enabled: !!schemaJson && !liveValidationInput.parseError,
+  });
+
+  const effectiveValidationResult = liveValidationInput.parseError
+    ? { state: 'error' as const, message: liveValidationInput.parseError }
+    : validationResult;
+
   const userCanEdit = projectInfo && canEdit(user, projectInfo);
 
   const { isPending: isSubmitting, submit } = useTotalProjectChangeMutation(namespace, projectName, tag);
@@ -175,11 +208,9 @@ export const ProjectInterface = (props: Props) => {
           ctrlKey = e.ctrlKey;
           break;
       }
-      // SAVE (ctrl + s)
+      // SAVE (ctrl + s) — only when the form is actually dirty.
       if (ctrlKey && e.key === 's') {
-        if (true && !isSubmitting) {
-          // TODO: why does this not work in production?
-          // if (projectUpdates.formState.isDirty && !isSubmitting) {
+        if (projectUpdates.formState.isDirty && !isSubmitting) {
           e.preventDefault();
           handleSubmit();
         }
@@ -229,13 +260,13 @@ export const ProjectInterface = (props: Props) => {
     <Fragment>
         <div className="pt-0 px-2 bg-body-secondary bg-opacity-25" style={{ flex: '0 0 3.5em' }}>
           <ProjectValidationAndEditButtons
-            isDirty={true}
-            // TODO: why does this not work in production?
-            // isDirty={projectUpdates.formState.isDirty}
+            isDirty={projectUpdates.formState.isDirty}
             isUpdatingProject={isSubmitting}
             reset={projectUpdates.reset}
             handleSubmit={handleSubmit}
             filteredSamples={filteredSamples || []}
+            validationResult={effectiveValidationResult}
+            isValidating={isValidating}
           />
         </div>
         <div ref={projectDataRef} className='d-flex flex-column' style={{flex: 'auto'}}>
@@ -253,7 +284,7 @@ export const ProjectInterface = (props: Props) => {
                     view !== undefined
                       ? sampleListToArrays(viewSamples)
                       : currentHistoryId
-                      ? sampleListToArrays(historyData?._sample_dict || [])
+                      ? sampleListToArrays(historyData?.samples || [])
                       : newSamples
                   }
                   // height={window.innerHeight - 15 - (projectDataRef.current?.offsetTop || 300)}
@@ -272,7 +303,7 @@ export const ProjectInterface = (props: Props) => {
                   onChange={(subsamples) => {
                     onChange(subsamples);
                   }}
-                  data={currentHistoryId ? sampleListToArrays(historyData?._subsample_list[0] || []) : newSubsamples}
+                  data={currentHistoryId ? sampleListToArrays(historyData?.subsamples?.[0] || []) : newSubsamples}
                   // height={window.innerHeight - 15 - (projectDataRef.current?.offsetTop || 300)}
                   readOnly={!userCanEdit}
                 />
@@ -285,7 +316,7 @@ export const ProjectInterface = (props: Props) => {
               name="config"
               render={({ field: { onChange } }) => (
                 <ProjectConfigEditor
-                  value={currentHistoryId ? historyData?._config || '' : newConfig}
+                  value={currentHistoryId ? historyData?.config || '' : newConfig}
                   setValue={(val) => {
                     onChange(val);
                   }}
diff --git a/web/src/components/project/project-page-description.tsx b/web/src/components/project/project-page-description.tsx
index f1e6505f..c3559b94 100644
--- a/web/src/components/project/project-page-description.tsx
+++ b/web/src/components/project/project-page-description.tsx
@@ -35,7 +35,7 @@ export const ProjectDescription = () => {
         <div ref={projectDescriptionRef} className="col-md-12" style={{ maxHeight: MAX_DESC_HEIGHT, overflow: 'hidden' }}>
           <Markdown>
             {currentHistoryId !== null
-              ? YAML.parse(projectHistoryQuery.data?._config || '')?.description || 'No description'
+              ? YAML.parse(projectHistoryQuery.data?.config || '')?.description || 'No description'
               : projectInfo?.description || 'No description'}
           </Markdown>
         </div>
diff --git a/web/src/components/project/project-validation-and-edit-buttons.tsx b/web/src/components/project/project-validation-and-edit-buttons.tsx
index 1a8f2e72..c1007efa 100644
--- a/web/src/components/project/project-validation-and-edit-buttons.tsx
+++ b/web/src/components/project/project-validation-and-edit-buttons.tsx
@@ -1,12 +1,10 @@
 import { Fragment } from 'react';
-import { OverlayTrigger, Tooltip } from 'react-bootstrap';
 
 import { useProjectPage } from '../../contexts/project-page-context';
 import { useSession } from '../../contexts/session-context';
 import { useProjectAnnotation } from '../../hooks/queries/useProjectAnnotation';
-import { useValidation } from '../../hooks/queries/useValidation';
+import { PepValidationOutcome } from '../../utils/validate-pep';
 import { canEdit } from '../../utils/permissions';
-import { StatusIcon } from '../badges/status-icons';
 import { ProjectDataNav } from '../layout/project-data-nav';
 import { ValidationResult } from './validation/validation-result';
 
@@ -16,26 +14,26 @@ type ProjectValidationAndEditButtonsProps = {
   reset: () => void;
   handleSubmit: () => void;
   filteredSamples: string[];
+  validationResult: PepValidationOutcome | undefined;
+  isValidating: boolean;
 };
 
-const MAX_SAMPLES_FOR_VALIDATION = 5000;
-
 export const ProjectValidationAndEditButtons = (props: ProjectValidationAndEditButtonsProps) => {
-  const { isDirty, isUpdatingProject, reset, handleSubmit, filteredSamples } = props;
+  const {
+    isDirty,
+    isUpdatingProject,
+    reset,
+    handleSubmit,
+    filteredSamples,
+    validationResult,
+    isValidating,
+  } = props;
   const { user } = useSession();
 
   const { namespace, projectName, tag } = useProjectPage();
 
   const { data: projectInfo } = useProjectAnnotation(namespace, projectName, tag);
-  const shouldValidate: boolean = (projectInfo?.number_of_samples || 0) > MAX_SAMPLES_FOR_VALIDATION;
-
-  const projectValidationQuery = useValidation({
-    pepRegistry: `${namespace}/${projectName}:${tag}`,
-    schema_registry: projectInfo?.pep_schema || 'pep/2.0.0',
-    enabled: !!projectInfo?.pep_schema,
-  });
 
-  const validationResult = projectValidationQuery.data;
   const projectSchema = projectInfo?.pep_schema;
 
   const userHasOwnership = user && projectInfo && canEdit(user, projectInfo);
@@ -50,14 +48,14 @@ export const ProjectValidationAndEditButtons = (props: ProjectValidationAndEditB
             <div>
               <ValidationResult
                 schemaRegistry={projectSchema}
-                isValidating={projectValidationQuery.isLoading}
+                isValidating={isValidating}
                 validationResult={validationResult}
-                shouldValidate={shouldValidate}
               />
             </div>
             <div className="ps-1">
               <Fragment>
                 <button
+                  type="button"
                   disabled={isUpdatingProject || !isDirty}
                   onClick={() => handleSubmit()}
                   className="fst-italic btn btn-sm btn-success me-1 border-dark"
@@ -65,6 +63,7 @@ export const ProjectValidationAndEditButtons = (props: ProjectValidationAndEditB
                   {isUpdatingProject ? 'Saving...' : 'Save'}
                 </button>
                 <button
+                  type="button"
                   disabled={isUpdatingProject || !isDirty}
                   className="fst-italic btn btn-sm btn-outline-dark bg-white"
                   onClick={() => reset()}
diff --git a/web/src/components/project/validation/validation-result.tsx b/web/src/components/project/validation/validation-result.tsx
index 354f344a..bcd8894e 100644
--- a/web/src/components/project/validation/validation-result.tsx
+++ b/web/src/components/project/validation/validation-result.tsx
@@ -1,28 +1,27 @@
 import { useState } from 'react';
 import { OverlayTrigger, Tooltip } from 'react-bootstrap';
 
-import { useValidation } from '../../../hooks/queries/useValidation';
+import { PepValidationOutcome } from '../../../utils/validate-pep';
 import { StatusIcon } from '../../badges/status-icons';
 import { ValidationResultModal } from '../../modals/validation-result';
 
 type Props = {
   schemaRegistry: string | undefined;
   isValidating: boolean;
-  validationResult: ReturnType<typeof useValidation>['data'];
-  shouldValidate: boolean;
+  validationResult: PepValidationOutcome | undefined;
 };
 
 export const ValidationResult = (props: Props) => {
-  const { validationResult, isValidating, schemaRegistry, shouldValidate } = props;
+  const { validationResult, isValidating, schemaRegistry } = props;
 
   const [validationModalIsOpen, setValidationModalIsOpen] = useState(false);
 
+  const isValid = validationResult?.state === 'valid';
+
   let wrapperClassName = 'py-1 px-2 rounded-1 bg-opacity-10 validation-button';
-  if (shouldValidate) {
-    wrapperClassName += ' border border-warning text-warning bg-warning';
-  } else if (isValidating) {
+  if (isValidating || !validationResult) {
     wrapperClassName += ' border border-warning text-warning bg-warning';
-  } else if (validationResult?.valid) {
+  } else if (isValid) {
     wrapperClassName += ' border border-success text-success bg-success';
   } else {
     wrapperClassName += ' border border-danger text-danger bg-danger';
@@ -48,9 +47,9 @@ export const ValidationResult = (props: Props) => {
             className={wrapperClassName}
           >
             <div className="d-flex flex-row align-items-center gap-2 text-sm py-0">
-              {isValidating || shouldValidate ? (
+              {isValidating || !validationResult ? (
                 <span className="bg-warning text-warning rounded-pill validation-badge"></span>
-              ) : validationResult?.valid ? (
+              ) : isValid ? (
                 <span className="bg-success text-success rounded-pill validation-badge"></span>
               ) : (
                 <span className="bg-danger text-danger rounded-pill validation-badge"></span>
diff --git a/web/src/hooks/queries/useSchemaJson.ts b/web/src/hooks/queries/useSchemaJson.ts
new file mode 100644
index 00000000..0664e7c7
--- /dev/null
+++ b/web/src/hooks/queries/useSchemaJson.ts
@@ -0,0 +1,40 @@
+import { useQuery } from '@tanstack/react-query';
+import axios from 'axios';
+
+const API_HOST = import.meta.env.VITE_API_HOST || '';
+const API_BASE = `${API_HOST}/api/v1`;
+
+// pep_schema is stored as "namespace/name" or "namespace/name:version".
+// Default version when missing is "latest".
+export const parseSchemaRegistryPath = (
+  path: string | null | undefined,
+): { namespace: string; name: string; version: string } | null => {
+  if (!path) return null;
+  const [nsAndName, versionPart] = path.split(':');
+  if (!nsAndName) return null;
+  const [namespace, name] = nsAndName.split('/');
+  if (!namespace || !name) return null;
+  return { namespace, name, version: versionPart || 'latest' };
+};
+
+export const fetchSchemaJson = async (
+  namespace: string,
+  name: string,
+  version: string,
+): Promise<object> => {
+  const url = `${API_BASE}/schemas/${namespace}/${name}/versions/${version}/file?format=json`;
+  const { data } = await axios.get<object>(url);
+  return data;
+};
+
+export const useSchemaJson = (
+  schemaRegistryPath: string | null | undefined,
+) => {
+  const parsed = parseSchemaRegistryPath(schemaRegistryPath);
+  return useQuery({
+    queryKey: ['schema-json', parsed?.namespace, parsed?.name, parsed?.version],
+    queryFn: () => fetchSchemaJson(parsed!.namespace, parsed!.name, parsed!.version),
+    enabled: !!parsed,
+    refetchOnWindowFocus: false,
+  });
+};
diff --git a/web/src/hooks/queries/useValidation.ts b/web/src/hooks/queries/useValidation.ts
deleted file mode 100644
index a3fd5113..00000000
--- a/web/src/hooks/queries/useValidation.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import axios from 'axios';
-
-import { ValidationResult } from '../../../types';
-
-const API_HOST = import.meta.env.VITE_API_HOST || '';
-const API_BASE = `${API_HOST}/api/v1`;
-
-export interface ValidationParams {
-  pepRegistry?: string | null;
-  pepFiles?: FileList | null;
-  schema?: string | null;
-  schema_file?: File | null;
-  schema_registry?: string | null;
-  enabled?: boolean;
-}
-
-const runValidation = async (params: ValidationParams) => {
-  const { pepRegistry, pepFiles, schema, schema_registry } = params;
-
-  // create form data
-  const formData = new FormData();
-
-  // PEP things
-  formData.append('pep_registry', pepRegistry || '');
-  if (pepFiles) {
-    for (let i = 0; i < pepFiles.length; i++) {
-      formData.append('pep_files', pepFiles[i]);
-    }
-  }
-
-  // Schema things
-  formData.append('schema', schema || '');
-  if (params.schema_file) {
-    formData.append('schema_file', params.schema_file);
-  }
-  if (schema_registry) {
-    formData.append('schema_registry', schema_registry || '');
-  }
-  const { data: result } = await axios.post<ValidationResult>(`${API_BASE}/eido/validate`, formData, {
-    headers: {
-      'Content-Type': 'multipart/form-data',
-    },
-  });
-  return result;
-};
-
-export const useValidation = (params: ValidationParams) => {
-  const { pepRegistry, pepFiles, schema, schema_registry, enabled } = params;
-  return useQuery({
-    queryKey: ['validation', pepRegistry, pepFiles, schema, schema_registry],
-    queryFn: () => runValidation(params),
-    enabled: enabled,
-    refetchOnWindowFocus: false,
-    retry: false,
-  });
-};
diff --git a/web/src/hooks/useClientSidePepValidation.ts b/web/src/hooks/useClientSidePepValidation.ts
new file mode 100644
index 00000000..faa7f169
--- /dev/null
+++ b/web/src/hooks/useClientSidePepValidation.ts
@@ -0,0 +1,107 @@
+import { useEffect, useRef, useState } from 'react';
+import { useDebounce } from 'usehooks-ts';
+
+import {
+  PepValidationOutcome,
+  ValidatePepInput,
+  validatePep,
+} from '../utils/validate-pep';
+import { loadPeprsWasm } from '../utils/peprs-wasm';
+
+type HookInput = {
+  configYaml: string | undefined;
+  samples: Record<string, unknown>[] | undefined;
+  subsamples?: Record<string, unknown>[][];
+  schema: object | string | undefined;
+  enabled?: boolean;
+  debounceMs?: number;
+};
+
+type HookResult = {
+  isValidating: boolean;
+  isReady: boolean;
+  result: PepValidationOutcome | undefined;
+};
+
+// Debounced, cancellable client-side PEP validation.
+export const useClientSidePepValidation = (input: HookInput): HookResult => {
+  const { enabled = true, debounceMs = 400 } = input;
+
+  const [isReady, setIsReady] = useState(false);
+  const [isValidating, setIsValidating] = useState(false);
+  const [result, setResult] = useState<PepValidationOutcome | undefined>();
+
+  // Trigger lazy WASM load on first enabled render.
+  useEffect(() => {
+    if (!enabled) return;
+    let cancelled = false;
+    loadPeprsWasm()
+      .then(() => {
+        if (!cancelled) setIsReady(true);
+      })
+      .catch(() => {
+        if (!cancelled) setIsReady(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled]);
+
+  // Debounce the inputs. We serialize to a string so a referential
+  // change in the arrays doesn't retrigger validation on every keystroke.
+  const payload = enabled
+    ? JSON.stringify({
+        c: input.configYaml,
+        s: input.samples,
+        u: input.subsamples,
+        sc: input.schema,
+      })
+    : '';
+  const debouncedPayload = useDebounce(payload, debounceMs);
+
+  const requestIdRef = useRef(0);
+
+  useEffect(() => {
+    if (!enabled) {
+      setResult(undefined);
+      return;
+    }
+    if (
+      !input.schema ||
+      input.configYaml === undefined ||
+      input.samples === undefined
+    ) {
+      return;
+    }
+
+    const id = ++requestIdRef.current;
+    setIsValidating(true);
+
+    const run: ValidatePepInput = {
+      configYaml: input.configYaml,
+      samples: input.samples,
+      subsamples: input.subsamples,
+      schema: input.schema,
+    };
+
+    validatePep(run)
+      .then((outcome) => {
+        if (id !== requestIdRef.current) return;
+        setResult(outcome);
+      })
+      .catch((e) => {
+        if (id !== requestIdRef.current) return;
+        setResult({
+          state: 'error',
+          message: e instanceof Error ? e.message : String(e),
+        });
+      })
+      .finally(() => {
+        if (id !== requestIdRef.current) return;
+        setIsValidating(false);
+      });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [debouncedPayload, enabled]);
+
+  return { isValidating, isReady, result };
+};
diff --git a/web/src/utils/peprs-wasm.ts b/web/src/utils/peprs-wasm.ts
new file mode 100644
index 00000000..b19e62ae
--- /dev/null
+++ b/web/src/utils/peprs-wasm.ts
@@ -0,0 +1,27 @@
+// Singleton lazy loader for the @databio/peprs WASM bindings.
+//
+// The wasm blob is ~18MB, so we only load it on first use and then
+// memoize the init promise for the rest of the session.
+
+type PeprsModule = typeof import('@databio/peprs');
+
+let modPromise: Promise<PeprsModule> | null = null;
+
+export const loadPeprsWasm = (): Promise<PeprsModule> => {
+  if (!modPromise) {
+    modPromise = (async () => {
+      const mod = await import('@databio/peprs');
+      // The default export (__wbg_init) resolves the .wasm URL relative
+      // to the package's own JS file via its built-in import.meta.url.
+      // Calling with no arguments lets Vite handle the URL correctly in
+      // both dev and production builds.
+      await mod.default();
+      return mod;
+    })().catch((err) => {
+      // reset so a later retry can try again
+      modPromise = null;
+      throw err;
+    });
+  }
+  return modPromise;
+};
diff --git a/web/src/utils/validate-pep.ts b/web/src/utils/validate-pep.ts
new file mode 100644
index 00000000..85446e17
--- /dev/null
+++ b/web/src/utils/validate-pep.ts
@@ -0,0 +1,195 @@
+import yaml from 'js-yaml';
+
+import { loadPeprsWasm } from './peprs-wasm';
+
+export type PepValidationErrorItem = {
+  path?: string;
+  message: string;
+  sample_name?: string;
+};
+
+export type PepValidationErrorType =
+  | 'Project'
+  | 'Samples'
+  | 'Project and Samples'
+  | 'Schema';
+
+export type PepValidationOutcome =
+  | { state: 'valid' }
+  | {
+      state: 'invalid';
+      errorType: PepValidationErrorType;
+      errors: string[];
+      rawErrors: PepValidationErrorItem[];
+    }
+  | { state: 'error'; message: string };
+
+export type ValidatePepInput = {
+  // raw yaml string for the project config
+  configYaml: string;
+  // rows of already-parsed samples (list of dicts)
+  samples: Record<string, unknown>[];
+  // optional list of subsample tables (list of lists of dicts)
+  subsamples?: Record<string, unknown>[][];
+  // schema as either a parsed object or a yaml/json string
+  schema: object | string;
+};
+
+const normalizeSchema = (schema: object | string): string => {
+  if (typeof schema === 'string') {
+    // Try JSON first, fall back to YAML.
+    try {
+      const parsed = JSON.parse(schema);
+      return JSON.stringify(parsed);
+    } catch {
+      const parsed = yaml.load(schema);
+      return JSON.stringify(parsed);
+    }
+  }
+  return JSON.stringify(schema);
+};
+
+const parseConfig = (configYaml: string): Record<string, unknown> => {
+  if (!configYaml || configYaml.trim() === '') {
+    return {};
+  }
+  const parsed = yaml.load(configYaml);
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+    return parsed as Record<string, unknown>;
+  }
+  throw new Error('Project config must parse to a YAML mapping.');
+};
+
+export const validatePep = async (
+  input: ValidatePepInput,
+): Promise<PepValidationOutcome> => {
+  const { configYaml, samples, subsamples, schema } = input;
+
+  let projectJson: string;
+  let schemaJson: string;
+
+  try {
+    const config = parseConfig(configYaml);
+    const projectObj: Record<string, unknown> = {
+      config,
+      samples,
+    };
+    if (subsamples && subsamples.length > 0) {
+      projectObj.subsamples = subsamples;
+    }
+    projectJson = JSON.stringify(projectObj);
+  } catch (e) {
+    return {
+      state: 'error',
+      message: e instanceof Error ? e.message : String(e),
+    };
+  }
+
+  try {
+    schemaJson = normalizeSchema(schema);
+  } catch (e) {
+    return {
+      state: 'error',
+      message: `Schema is invalid: ${
+        e instanceof Error ? e.message : String(e)
+      }`,
+    };
+  }
+
+  let mod: Awaited<ReturnType<typeof loadPeprsWasm>>;
+  try {
+    mod = await loadPeprsWasm();
+  } catch (e) {
+    return {
+      state: 'error',
+      message: `Failed to load WASM validator: ${
+        e instanceof Error ? e.message : String(e)
+      }`,
+    };
+  }
+
+  let proj: InstanceType<typeof mod.WasmProject> | null = null;
+  try {
+    proj = new mod.WasmProject(projectJson);
+  } catch (e) {
+    return {
+      state: 'error',
+      message: `Could not build PEP project: ${
+        e instanceof Error ? e.message : String(e)
+      }`,
+    };
+  }
+
+  let result: { valid: boolean; errors?: PepValidationErrorItem[] } | null =
+    null;
+  try {
+    result = mod.validate(proj, schemaJson) as {
+      valid: boolean;
+      errors?: PepValidationErrorItem[];
+    };
+  } catch (e) {
+    return {
+      state: 'error',
+      message: `Validation failed to run: ${
+        e instanceof Error ? e.message : String(e)
+      }`,
+    };
+  } finally {
+    proj?.free();
+  }
+
+  if (!result) {
+    return { state: 'error', message: 'Validator returned no result.' };
+  }
+
+  if (result.valid) {
+    return { state: 'valid' };
+  }
+
+  const rawErrors = result.errors ?? [];
+  let hasProject = false;
+  let hasSamples = false;
+  const messages: string[] = [];
+
+  // Group sample errors by message so we don't repeat the same line
+  // hundreds of times for large projects.
+  const sampleErrorGroups = new Map<string, string[]>();
+  for (const err of rawErrors) {
+    if (err.sample_name) {
+      hasSamples = true;
+      const existing = sampleErrorGroups.get(err.message);
+      if (existing) {
+        existing.push(err.sample_name);
+      } else {
+        sampleErrorGroups.set(err.message, [err.sample_name]);
+      }
+    } else {
+      hasProject = true;
+      messages.push(err.message);
+    }
+  }
+
+  const MAX_SAMPLE_NAMES = 20;
+  for (const [msg, names] of sampleErrorGroups) {
+    if (names.length === 1) {
+      messages.push(`${msg} (sample: ${names[0]})`);
+    } else if (names.length <= MAX_SAMPLE_NAMES) {
+      messages.push(`${msg} (samples: ${names.join(', ')})`);
+    } else {
+      const shown = names.slice(0, MAX_SAMPLE_NAMES).join(', ');
+      messages.push(`${msg} (samples: ${shown}, and ${names.length - MAX_SAMPLE_NAMES} more)`);
+    }
+  }
+
+  let errorType: PepValidationErrorType;
+  if (hasProject && hasSamples) errorType = 'Project and Samples';
+  else if (hasSamples) errorType = 'Samples';
+  else errorType = 'Project';
+
+  return {
+    state: 'invalid',
+    errorType,
+    errors: messages,
+    rawErrors,
+  };
+};
diff --git a/web/src/utils/validator-form-helpers.ts b/web/src/utils/validator-form-helpers.ts
new file mode 100644
index 00000000..633b851a
--- /dev/null
+++ b/web/src/utils/validator-form-helpers.ts
@@ -0,0 +1,186 @@
+// Helpers for the Validator page: turn user input (uploaded files or a
+// registry path) into the shape that validate-pep needs.
+import yaml from 'js-yaml';
+
+import { getProjectConfig, getSampleTable, getSubsampleTable } from '../api/project';
+import { fetchSchemaJson, parseSchemaRegistryPath } from '../hooks/queries/useSchemaJson';
+
+export type PreparedPep = {
+  configYaml: string;
+  samples: Record<string, unknown>[];
+  subsamples?: Record<string, unknown>[][];
+};
+
+// Minimal CSV parser — handles comma delimiter, double-quoted strings with
+// embedded commas, escaped quotes (""), CRLF/LF line endings. Good enough
+// for PEP sample tables; does not handle exotic quoting.
+export const parseCsv = (text: string): Record<string, string>[] => {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let field = '';
+  let inQuotes = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += c;
+      }
+      continue;
+    }
+    if (c === '"') {
+      inQuotes = true;
+    } else if (c === ',') {
+      row.push(field);
+      field = '';
+    } else if (c === '\n' || c === '\r') {
+      if (c === '\r' && text[i + 1] === '\n') i++;
+      row.push(field);
+      field = '';
+      if (row.length > 1 || row[0] !== '') rows.push(row);
+      row = [];
+    } else {
+      field += c;
+    }
+  }
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    if (row.length > 1 || row[0] !== '') rows.push(row);
+  }
+  if (rows.length === 0) return [];
+  const header = rows[0];
+  return rows.slice(1).map((r) => {
+    const obj: Record<string, string> = {};
+    header.forEach((h, idx) => {
+      obj[h] = r[idx] ?? '';
+    });
+    return obj;
+  });
+};
+
+const readFileText = (file: File): Promise<string> =>
+  new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = () => reject(new Error(`Failed to read ${file.name}`));
+    reader.readAsText(file);
+  });
+
+// Build a PreparedPep from a list of uploaded files. Accepts either:
+//   - a single .json / .yaml file that already encodes a full
+//     `{config, samples[, subsamples]}` project, or
+//   - a .yaml config paired with a .csv sample table.
+export const preparePepFromFiles = async (files: FileList): Promise<PreparedPep> => {
+  if (!files || files.length === 0) {
+    throw new Error('No PEP files uploaded.');
+  }
+
+  const entries = await Promise.all(
+    Array.from(files).map(async (f) => ({ file: f, text: await readFileText(f) })),
+  );
+
+  // Single file case: full JSON/YAML project.
+  if (entries.length === 1) {
+    const { file, text } = entries[0];
+    const name = file.name.toLowerCase();
+    let parsed: unknown;
+    if (name.endsWith('.json')) {
+      parsed = JSON.parse(text);
+    } else if (name.endsWith('.yaml') || name.endsWith('.yml')) {
+      parsed = yaml.load(text);
+    } else {
+      throw new Error(
+        'Single-file uploads must be .json or .yaml encoding a full PEP project.',
+      );
+    }
+    if (!parsed || typeof parsed !== 'object') {
+      throw new Error('Uploaded file did not parse to a PEP project object.');
+    }
+    const obj = parsed as Record<string, unknown>;
+    // Accept either a pre-shaped {config, samples} or a raw config document
+    // — we can't validate a config without samples, so require the former.
+    if (!('config' in obj) || !('samples' in obj)) {
+      throw new Error(
+        'Uploaded project must include both "config" and "samples". Upload a config + CSV instead.',
+      );
+    }
+    const config = obj.config as Record<string, unknown>;
+    return {
+      configYaml: yaml.dump(config),
+      samples: obj.samples as Record<string, unknown>[],
+      subsamples: obj.subsamples as Record<string, unknown>[][] | undefined,
+    };
+  }
+
+  // Multi-file case: find config yaml + sample csv.
+  const configEntry = entries.find((e) =>
+    /\.ya?ml$/i.test(e.file.name),
+  );
+  const sampleEntry = entries.find((e) => /\.csv$/i.test(e.file.name));
+  if (!configEntry || !sampleEntry) {
+    throw new Error(
+      'Multi-file uploads must include a .yaml config and a .csv sample table.',
+    );
+  }
+  return {
+    configYaml: configEntry.text,
+    samples: parseCsv(sampleEntry.text),
+  };
+};
+
+// Pull a PEP out of the server by registry path. Note: this still reads
+// from the server (necessary — the raw PEP lives there), but the
+// validation itself runs in the browser.
+export const preparePepFromRegistry = async (
+  registryPath: string,
+): Promise<PreparedPep> => {
+  // registry path: "namespace/name" or "namespace/name:tag"
+  const [nsAndName, tagPart] = registryPath.split(':');
+  const [namespace, name] = nsAndName.split('/');
+  const tag = tagPart || 'default';
+  if (!namespace || !name) {
+    throw new Error(`Invalid registry path: ${registryPath}`);
+  }
+
+  const [configResp, samplesResp, subsamplesResp] = await Promise.all([
+    getProjectConfig(namespace, name, tag).catch(() => null),
+    getSampleTable(namespace, name, tag).catch(() => null),
+    getSubsampleTable(namespace, name, tag).catch(() => null),
+  ]);
+
+  const configYaml =
+    (configResp as unknown as { config?: string } | null)?.config ?? '';
+  const samples = ((samplesResp as unknown as { items?: Record<string, unknown>[] } | null)?.items ?? []);
+  const subsamplesItems =
+    (subsamplesResp as unknown as { items?: Record<string, unknown>[] } | null)?.items;
+  const subsamples =
+    subsamplesItems && subsamplesItems.length > 0 ? [subsamplesItems] : undefined;
+
+  return { configYaml, samples, subsamples };
+};
+
+export const prepareSchema = async (opts: {
+  registryPath?: string | null;
+  file?: File | null;
+  pasted?: string | null;
+}): Promise<object | string> => {
+  if (opts.registryPath) {
+    const parsed = parseSchemaRegistryPath(opts.registryPath);
+    if (!parsed) throw new Error(`Invalid schema registry path: ${opts.registryPath}`);
+    return fetchSchemaJson(parsed.namespace, parsed.name, parsed.version);
+  }
+  if (opts.file) {
+    const text = await readFileText(opts.file);
+    return text;
+  }
+  if (opts.pasted) {
+    return opts.pasted;
+  }
+  throw new Error('No schema provided.');
+};
diff --git a/web/types.ts b/web/types.ts
index f31c230b..b80debc0 100644
--- a/web/types.ts
+++ b/web/types.ts
@@ -127,9 +127,9 @@ export type ProjectAllHistory = {
 };
 
 export type ProjectHistory = {
-  _config: string;
-  _subsample_list: any[];
-  _sample_dict: Sample[];
+  config: string;
+  subsamples: any[];
+  samples: Sample[];
 };
 
 export interface PaginationResult {
diff --git a/web/vite.config.ts b/web/vite.config.ts
index c10064ec..9ad164a2 100644
--- a/web/vite.config.ts
+++ b/web/vite.config.ts
@@ -16,4 +16,5 @@ export default defineConfig({
   build: {
     target: browserslistToEsbuild(),
   },
+  assetsInclude: ['**/*.wasm'],
 });