diff --git a/.vscode/settings.json b/.vscode/settings.json
index aea395f..f6ff041 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -2,6 +2,8 @@
   "python-envs.defaultEnvManager": "ms-python.python:conda",
   "cSpell.words": [
     "ACCESSCODE",
+    "ALTROADNAME",
+    "ALTROADTYPE",
     "arcgispro",
     "arcpy",
     "boxelder",
@@ -25,12 +27,18 @@
     "pytest",
     "pythonpath",
     "recents",
+    "ROADALIASNAME",
     "saltlake",
+    "Sevier",
     "SRFTYP",
     "STREETNAME",
+    "SUFDIR",
+    "SUFFIXDIR",
     "testpaths",
     "TOADDR",
+    "Tooele",
     "UGRC",
+    "Uintah",
     "utrans",
     "UTRANS",
     "vecc"
@@ -42,6 +50,18 @@
     "/^dotnet build add-in\\\\UGRC\\.UtransTools\\\\UGRC\\.UtransTools\\.csproj --no-restore$/": {
       "approve": true,
       "matchCommandLine": true
+    },
+    "/^conda activate utrans-tools$/": {
+      "approve": true,
+      "matchCommandLine": true
+    },
+    "/^conda activate utrans-tools; pytest[^;]*$/": {
+      "approve": true,
+      "matchCommandLine": true
+    }
+    "/^conda activate utrans-tools; ruff/": {
+      "approve": true,
+      "matchCommandLine": true
     }
   },
   "[csharp]": {
diff --git a/README.md b/README.md
index 254b31e..4056c98 100644
--- a/README.md
+++ b/README.md
@@ -1,18 +1,18 @@
-# UTrans Tools
+# UTRANS Tools
 
-Tools for working with UTrans data
+Tools for working with UTRANS data
 
 ## CLI
 
-This is a Python CLI tool for processing county-submitted data prior to ingestion into UTrans. See its [README](cli/README.md) for installation, usage, and release instructions.
+This is a Python CLI tool for processing county-submitted data prior to ingestion into UTRANS. See its [README](cli/README.md) for installation, usage, and release instructions.
 
 ## ArcGIS Pro Add-in
 
-This is an ArcGIS Pro Add-in for working with UTrans data. See its [README](add-in/README.md) for installation, usage, and release instructions.
+This is an ArcGIS Pro Add-in for working with UTRANS data. See its [README](add-in/README.md) for installation, usage, and release instructions.
 
 ## Data Flow
 
-The following diagram shows the flow of data from the county into UTrans.
+The following diagram shows the flow of data from the county into UTRANS.
 
 ```mermaid
 flowchart TD
diff --git a/add-in/README.md b/add-in/README.md
index 53ce0b8..1b4b468 100644
--- a/add-in/README.md
+++ b/add-in/README.md
@@ -1,10 +1,10 @@
-# UTrans Tools ArcGIS Pro Add-In
+# UTRANS Tools ArcGIS Pro Add-In
 
 ## Usage
 
 ### Adding New Features
 
-Use **Add New** to copy an unlinked new record or records from `DFC_RESULT` into the UTrans roads layer.
+Use **Add New** to copy an unlinked new record or records from `DFC_RESULT` into the UTRANS roads layer.
 
 1. In the map, select one or more unlinked records in the `DFC_RESULT` layer. A record is eligible when its change type is `N` and its `BASE_FID` is `-1`.
 2. Review or update the road attributes shown in the editor. When multiple records are selected, the values are used for each new road.
@@ -12,7 +12,7 @@ Use **Add New** to copy an unlinked new record or records from `DFC_RESULT` into
 
 When multiple features are selected, the form values override the county-road values for `CARTOCODE`, `ONEWAY`, `VERT_LEVEL`, `SPEED_LMT`, and `STATUS`. Review these values before clicking **Add New** because the same editor values are applied to every new road.
 
-The add-in creates a UTrans road using each selected county-road geometry and attributes, links the `DFC_RESULT` record to the new road, and marks the DFC disposition as `COMPLETED`. The map selections are cleared after the operation finishes.
+The add-in creates a UTRANS road using each selected county-road geometry and attributes, links the `DFC_RESULT` record to the new road, and marks the DFC disposition as `COMPLETED`. The map selections are cleared after the operation finishes.
 
 ## Developer Set Up
 
diff --git a/add-in/UGRC.UtransTools/Config.daml b/add-in/UGRC.UtransTools/Config.daml
index 03eea27..3107f22 100644
--- a/add-in/UGRC.UtransTools/Config.daml
+++ b/add-in/UGRC.UtransTools/Config.daml
@@ -6,7 +6,7 @@
         xsi:schemaLocation="http://schemas.esri.com/DADF/Registry file:///C:/Program%20Files/ArcGIS/Pro/bin/ArcGIS.Desktop.Framework.xsd">
 
   <AddInInfo id="{f893be2f-ad95-46be-9d60-fd6dba457152}" version="1.14" desktopVersion="3.6.59527" product="ArcGISPro">
-    <Name>UGRC_UtransTools</Name>   
+    <Name>UGRC_UtransTools</Name>
     <Description>UGRC_UtransTools description</Description>
     <Image>Images\AddinDesktop32.png</Image>
     <Author>stdavis</Author>
@@ -18,36 +18,36 @@
   <modules>
     <insertModule id="UGRC_UtransTools_Module" className="UtransToolsModule" autoLoad="false" caption="UTRANS Tools">
       <tabs>
-        <tab id="UGRC_UtransTools_CustomTab" caption="UTrans" keytip="UTRANS_Tab">
+        <tab id="UGRC_UtransTools_CustomTab" caption="UTRANS" keytip="UTRANS_Tab">
           <group refID="UGRC_UtransTools_Group1"/>
         </tab>
       </tabs>
-              
+
       <groups>
-        <group id="UGRC_UtransTools_Group1" caption="UTrans" keytip="UTRANS_Group">
+        <group id="UGRC_UtransTools_Group1" caption="UTRANS" keytip="UTRANS_Group">
           <button refID="UGRC_UtransTools_UtransEditorDockpaneButton" />
         </group>
       </groups>
-      
+
       <controls>
         <button id="UGRC_UtransTools_UtransEditorDockpaneButton"
-                caption="UTrans Editor"
+                caption="UTRANS Editor"
                 className="UtransEditorDockpaneButton"
                 loadOnClick="true"
                 smallImage="Images\AddInDesktop16.png"
                 largeImage="Images\AddInDesktop32.png"
 				keytip="UTRANS Editor Pane"/>
-      </controls> 
+      </controls>
 
        <dockPanes>
          <dockPane id="UGRC_UtransTools_UtransEditorDockpane"
-                   caption="UTrans Editor"
+                   caption="UTRANS Editor"
                    className="UtransEditorDockpaneViewModel"
                    dock="right">
            <content className="UtransEditorDockpaneView" />
          </dockPane>
        </dockPanes>
-      
+
     </insertModule>
   </modules>
 </ArcGIS>
\ No newline at end of file
diff --git a/add-in/UGRC.UtransTools/UtransEditorDockpaneView.xaml b/add-in/UGRC.UtransTools/UtransEditorDockpaneView.xaml
index 323bea9..9869cae 100644
--- a/add-in/UGRC.UtransTools/UtransEditorDockpaneView.xaml
+++ b/add-in/UGRC.UtransTools/UtransEditorDockpaneView.xaml
@@ -274,7 +274,7 @@
       <GroupBox
         Grid.Row="3"
         Header="{Binding ReviewState.UtransRecordObjectId}"
-        HeaderStringFormat="Target UTrans Road Segment ({0})"
+        HeaderStringFormat="Target UTRANS Road Segment ({0})"
         Margin="3"
       >
         <Grid IsEnabled="{Binding HasReviewState}">
@@ -539,7 +539,7 @@
           VerticalAlignment="Bottom"
           IsEnabled="{Binding CanEditRoadValues}"
         >
-          <TextBlock VerticalAlignment="Bottom" Text="UTrans Database Version:" />
+          <TextBlock VerticalAlignment="Bottom" Text="UTRANS Database Version:" />
           <TextBlock VerticalAlignment="Bottom" Text="{Binding UtransDatabaseVersion}" />
         </StackPanel>
 
diff --git a/cli/PROFILES.md b/cli/PROFILES.md
index 8acef3d..6d5ba81 100644
--- a/cli/PROFILES.md
+++ b/cli/PROFILES.md
@@ -12,7 +12,7 @@ Each key in the JSON object is a county identifier (e.g. `"grand"`, `"davis"`).
 
 **Type:** `string` | **Required by `etl`**
 
-The county's five-digit FIPS code written to `COUNTY_L` and `COUNTY_R` during ETL.
+The county's five-digit FIPS code plus the name written to `COUNTY_L` and `COUNTY_R` during ETL. For example, `"49035 - Salt Lake"`.
 
 ### `field_mappings`
 
@@ -21,13 +21,95 @@ The county's five-digit FIPS code written to `COUNTY_L` and `COUNTY_R` during ET
 A semicolon-delimited list of `UTRANS_FIELD=COUNTY_FIELD` assignments. These map
 county source fields into the target schema after colliding source fields have been
 renamed with an underscore. When the UTRANS destination has a coded-value domain,
-the assignment is validated against that domain from `--utrans-roads`; invalid values
-are appended to `UTRANS_NOTES`.
+valid aliases are converted to coded values. Invalid values are preserved and
+appended to `UTRANS_NOTES` in all cases. An invalid value is also copied to the
+destination field when it fits within that field's length; otherwise the destination
+field is left at its default value. Values that exceed the destination field length
+are reported with the field and value.
 
 ```json
 "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; NAME=STREETNAME"
 ```
 
+### `value_mappings`
+
+**Type:** `object` | **Optional** — defaults to `{}`
+
+Per-target mappings for source values that do not match a UTRANS coded-value
+domain code or description. Each target field contains an object mapping the
+source value to the desired target value. Field names and source values are
+matched case-insensitively after surrounding whitespace is removed. The mapped
+target value is then resolved against the destination coded-value domain, so it
+can be either a coded value or a domain description.
+
+```json
+"value_mappings": {
+  "ONEWAY": {
+    "ONE DIRECTION": "Y",
+    "TWO WAY": "N"
+  },
+  "DOT_CLASS": {
+    "LOCAL ROAD": "L"
+  }
+}
+```
+
+Mappings run after `field_mappings` selects a source field and before normal
+destination-domain matching. If no configured mapping or valid domain match is
+found, the original source value is handled as an invalid value: it is appended
+to `UTRANS_NOTES` and copied only when it fits the target field length.
+
+### `rules`
+
+**Type:** `string[]` | **Optional** — defaults to `[]`
+
+An ordered list of supported post-mapping transformations. Rules run after field
+and full-address mappings, but before the feature is normalized and appended. Unknown
+or duplicate names are rejected.
+
+```json
+"rules": ["remove_postdir_if_alpha", "remove_posttype_if_numeric"]
+```
+
+Supported rules:
+
+- `remove_postdir_if_alpha`: clears `POSTDIR` when `NAME` begins with a letter.
+- `remove_posttype_if_numeric`: clears `POSTTYPE` when `NAME` begins with a digit.
+
+### `custom_handler`
+
+**Type:** `string` | **Optional**
+
+Selects a built-in, county-specific transformation for behavior that requires
+multiple fields or conditional assignments. Handler names are resolved from the
+CLI's fixed registry; profile files cannot name Python modules or functions.
+Unknown handler names are rejected before ETL updates begin.
+
+```json
+"custom_handler": "utah_road_names"
+```
+
+Currently supported handlers:
+
+- `utah_road_names`: preserves Utah County's legacy handling of numeric primary
+  and alternate road names ending in a cardinal direction.
+- `davis_alias`: parses Davis County's `RoadAliasName` into alpha or numeric
+  aliases while ignoring compound names.
+- `washington_postdir_and_aliases`: selects Washington County's primary or
+  suffix direction and removes aliases duplicated by the numeric alias.
+- `weber_alias`: parses Weber County's alpha and numeric alias conventions.
+- `summit_names`: prefixes Summit County highway names and conditionally parses
+  its alternate road name.
+- `tooele_numeric_name`: parses numeric Tooele County primary names.
+- `emery_compact_aliases`: recognizes Emery County compact numeric aliases such
+  as `100N`.
+- `grand_numeric_acs_name`: retains Grand County's ACS name only when numeric.
+- `kane_alias_cleanup`: removes Kane County's invalid `K`-prefixed aliases.
+- `sevier_postdir_fallback`: uses Sevier County's suffix direction when address
+  parsing did not produce one.
+- `uintah_exclusion_note`: records Uintah County's excluded features in notes.
+- `wayne_acs_alias`: parses Wayne County's ACS alias.
+
 ### `parse_sources`
 
 **Type:** `string` | **Optional**
@@ -40,7 +122,8 @@ names. `TARGET` is `PRIMARY`, `A1`, or `A2`.
 **Type:** `boolean` | **Optional** — defaults to `false`
 
 When `true`, legacy vertical values `1`, `2`, and `3` are translated to `0`, `1`,
-and `2` before target-domain validation.
+and `2` before domain-value matching. Invalid values are still preserved when they
+fit within the destination field length and are always appended to `UTRANS_NOTES`.
 
 ### `exclude_if_any`
 
diff --git a/cli/pyproject.toml b/cli/pyproject.toml
index 9173458..fb5aa64 100644
--- a/cli/pyproject.toml
+++ b/cli/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "ugrc-utrans-tools"
 version = "1.0.1"
-description = "Command-line tools for working with UTrans data."
+description = "Command-line tools for working with UTRANS data."
 readme = "README.md"
 requires-python = ">=3.13"
 license = { file = "LICENSE" }
diff --git a/cli/src/utrans/etl.py b/cli/src/utrans/etl.py
index 979f55c..33be914 100644
--- a/cli/src/utrans/etl.py
+++ b/cli/src/utrans/etl.py
@@ -4,6 +4,7 @@
 
 import argparse
 import json
+import time
 from datetime import UTC, datetime
 from pathlib import Path
 from uuid import uuid4
@@ -30,8 +31,8 @@ def _default_output_name(county: str) -> str:
 
 
 def _county_boundary_name(county: str) -> str:
-    names = {"boxelder": "Box Elder", "saltlake": "Salt Lake", "sanjuan": "San Juan"}
-    return names.get(county, county.title())
+    names = {"boxelder": "BOX ELDER", "saltlake": "SALT LAKE", "sanjuan": "SAN JUAN"}
+    return names.get(county, county.upper())
 
 
 def _unique_name(prefix: str) -> str:
@@ -105,7 +106,7 @@ def run_etl(
 
         log(f"Applying {county} county field mappings")
         apply_mapper(staging_source, profile, utrans_roads)
-        normalize_target_fields(staging_source)
+        normalize_target_fields(staging_source, utrans_roads)
 
         log("Appending transformed roads to the target schema")
         arcpy.management.Append(staging_source, staging_output, "NO_TEST")
@@ -173,6 +174,7 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
 
 
 def main(argv: list[str] | None = None, *, prog: str | None = None) -> int:
+    start_time = time.time()
     args = build_parser(prog).parse_args(argv)
     try:
         profiles = load_profiles(Path(args.profiles) if args.profiles else None)
@@ -190,4 +192,6 @@ def main(argv: list[str] | None = None, *, prog: str | None = None) -> int:
     except (RuntimeError, TypeError, FileNotFoundError, json.JSONDecodeError) as exc:
         log(str(exc))
         return 2
+    elapsed = time.time() - start_time
+    log(f"Time elapsed: {elapsed:.2f}s")
     return 0
diff --git a/cli/src/utrans/etl_common.py b/cli/src/utrans/etl_common.py
index c1deaa7..09b7d33 100644
--- a/cli/src/utrans/etl_common.py
+++ b/cli/src/utrans/etl_common.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -105,7 +105,7 @@ def domain_values(utrans_roads: str) -> dict[str, dict[str, str]]:
     return resolved
 
 
-def resolve_domain_value(value: object, values: dict[str, str]) -> str | None:
+def resolve_domain_value(value: object, values: Mapping[str, str]) -> str | None:
     if not has_value(value):
         return ""
     normalized = str(value).strip().upper()
@@ -131,15 +131,32 @@ def add_missing_template_fields(source_features: str, utrans_roads: str) -> None
         kwargs: dict[str, object] = {}
         if field.type == "String":
             kwargs["field_length"] = field.length
-        if field.domain:
-            kwargs["field_domain"] = field.domain
-        arcpy.management.AddField(source_features, field.name, field.type, **kwargs)
-
-
-def normalize_target_fields(feature_class: str) -> None:
+        try:
+            arcpy.management.AddField(source_features, field.name, field.type, **kwargs)
+        except arcpy.ExecuteError as exc:
+            details = str(exc) or arcpy.GetMessages(2)
+            length = f", length={field.length}" if field.type == "String" else ""
+            raise RuntimeError(
+                f"Failed to add target field '{field.name}' "
+                f"(type={field.type}{length}): {details}"
+            ) from exc
+
+
+def normalize_target_fields(
+    feature_class: str, utrans_roads: str | None = None
+) -> None:
     """Normalize target nulls, casing, and legacy name conventions in place."""
     names = field_name_map(feature_class)
     text_fields = [names[name] for name in CORE_TEXT_FIELDS if name in names]
+    field_lengths: dict[str, int | None] = {}
+    if utrans_roads is not None:
+        for field in arcpy.ListFields(utrans_roads):
+            if field.type != "String" or field.name.upper() not in names:
+                continue
+            actual_name = names[field.name.upper()]
+            if actual_name not in text_fields:
+                text_fields.append(actual_name)
+            field_lengths[actual_name.upper()] = field.length
     numeric_fields = [names[name] for name in CORE_NUMERIC_FIELDS if name in names]
     fields = text_fields + numeric_fields
     if not fields:
@@ -155,6 +172,12 @@ def normalize_target_fields(feature_class: str) -> None:
                     row[index] = 0
 
             row = _normalize_names(row, fields)
+            for index, field in enumerate(fields):
+                length = field_lengths.get(field.upper())
+                if length is not None and len(str(row[index])) > length:
+                    raise RuntimeError(
+                        f"Field length exceeded. Field: {field}. Value: {row[index]!r}"
+                    )
             cursor.updateRow(row)
 
 
diff --git a/cli/src/utrans/etl_handlers.py b/cli/src/utrans/etl_handlers.py
new file mode 100644
index 0000000..c238296
--- /dev/null
+++ b/cli/src/utrans/etl_handlers.py
@@ -0,0 +1,437 @@
+"""Registered county-specific ETL transformations.
+
+Profiles may select only handlers defined in this module; they cannot import
+arbitrary code from a custom profiles file.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+
+from utrans.etl_common import (
+    direction,
+    has_value,
+    parse_full_address,
+    resolve_domain_value,
+)
+from utrans.profiles import CountyProfile
+
+RowHandler = Callable[
+    [list[object], Mapping[str, int], Mapping[str, Mapping[str, str]]], None
+]
+
+
+@dataclass(frozen=True)
+class Handler:
+    required_fields: tuple[str, ...]
+    target_fields: tuple[str, ...]
+    apply: RowHandler
+
+
+def _value(row: list[object], indexes: Mapping[str, int], field: str) -> object:
+    index = indexes.get(field.upper())
+    return row[index] if index is not None else ""
+
+
+def _set(
+    row: list[object], indexes: Mapping[str, int], field: str, value: object
+) -> None:
+    index = indexes.get(field.upper())
+    if index is not None:
+        row[index] = value
+
+
+def _numeric_name_and_direction(value: object) -> tuple[str, str] | None:
+    if not has_value(value):
+        return None
+    parts = str(value).strip().upper().split()
+    if len(parts) < 2 or not parts[0].isdigit():
+        return None
+    postdir = direction(parts[-1])
+    return (parts[0], postdir) if postdir else None
+
+
+def _clear(row: list[object], indexes: Mapping[str, int], prefix: str) -> None:
+    for suffix in ("PREDIR", "NAME", "POSTTYPE", "POSTDIR"):
+        _set(row, indexes, f"{prefix}_{suffix}", "")
+
+
+def _assign_parsed_name(
+    row: list[object],
+    indexes: Mapping[str, int],
+    value: object,
+    prefix: str,
+    posttypes: Mapping[str, str],
+) -> None:
+    parsed = parse_full_address(value, posttypes)
+    if parsed is None:
+        return
+    if prefix != "" and parsed.name.isdigit():
+        _set(row, indexes, "AN_NAME", parsed.name)
+        _set(row, indexes, "AN_POSTDIR", parsed.postdir)
+        return
+    for suffix, part in (
+        ("PREDIR", parsed.predir),
+        ("NAME", parsed.name),
+        ("POSTTYPE", parsed.posttype),
+        ("POSTDIR", parsed.postdir),
+    ):
+        _set(row, indexes, f"{prefix}{suffix}", part)
+
+
+def _utah_road_names(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    """Preserve Utah County's legacy numeric primary and alternate road parsing."""
+    primary = _numeric_name_and_direction(_value(row, indexes, "ROADNAME"))
+    if primary is not None:
+        _set(row, indexes, "NAME", primary[0])
+        _set(row, indexes, "POSTDIR", primary[1])
+        _set(row, indexes, "POSTTYPE", "")
+
+    numeric_alias: tuple[str, str] | None = None
+    for source, target in (("ALTROADNAME2", "A2_NAME"), ("ALTROADNAME", "A1_NAME")):
+        parsed = _numeric_name_and_direction(_value(row, indexes, source))
+        if parsed is None:
+            continue
+        numeric_alias = parsed
+        _set(row, indexes, target, "")
+        _set(row, indexes, "A1_POSTTYPE", "")
+    if numeric_alias is not None:
+        _set(row, indexes, "AN_NAME", numeric_alias[0])
+        _set(row, indexes, "AN_POSTDIR", numeric_alias[1])
+
+    alias_name = _value(row, indexes, "A1_NAME")
+    if not has_value(alias_name):
+        _set(row, indexes, "A1_POSTTYPE", "")
+        return
+    alias_type = _value(row, indexes, "ALTROADTYPE")
+    first_word = (
+        str(alias_type).strip().split(maxsplit=1)[0] if has_value(alias_type) else ""
+    )
+    resolved = resolve_domain_value(first_word, domains.get("A1_POSTTYPE", {}))
+    if resolved is not None:
+        _set(row, indexes, "A1_POSTTYPE", resolved)
+
+
+def _davis_alias(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    value = _value(row, indexes, "ROADALIASNAME")
+    if not has_value(value) or "&" in str(value):
+        return
+    alias = str(value).strip()
+    parts = alias.split()
+    if alias[0].isdigit():
+        parsed = _numeric_name_and_direction(alias)
+        if parsed is not None:
+            _set(row, indexes, "AN_NAME", parsed[0])
+            _set(row, indexes, "AN_POSTDIR", parsed[1])
+        else:
+            _set(row, indexes, "A1_NAME", alias)
+        return
+    posttype = resolve_domain_value(parts[-1], domains.get("A1_POSTTYPE", {}))
+    if posttype is None and parts[-1].upper() == "WY":
+        posttype = resolve_domain_value("WAY", domains.get("A1_POSTTYPE", {}))
+    if posttype is None:
+        _set(row, indexes, "A1_NAME", alias)
+        return
+    _set(row, indexes, "A1_NAME", " ".join(parts[:-1]))
+    _set(row, indexes, "A1_POSTTYPE", posttype)
+
+
+def _washington_postdir_and_aliases(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    del domains
+    for source in ("POSTDIR_", "SUFFIXDIR"):
+        value = direction(_value(row, indexes, source))
+        if value:
+            _set(row, indexes, "POSTDIR", value)
+    an_name = _value(row, indexes, "AN_NAME")
+    if not has_value(an_name):
+        return
+    for prefix in ("A1", "A2"):
+        alias = _value(row, indexes, f"{prefix}_NAME")
+        if has_value(alias) and str(an_name) in str(alias):
+            _clear(row, indexes, prefix)
+
+
+def _weber_alias(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    alias = _value(row, indexes, "ALIAS")
+    if (
+        not has_value(alias)
+        or str(alias).strip() == str(_value(row, indexes, "S_NAME")).strip()
+    ):
+        return
+    alias_text = str(alias).strip()
+    if alias_text.isdigit():
+        parsed = _numeric_name_and_direction(_value(row, indexes, "ACS_ALIAS"))
+        _set(row, indexes, "AN_NAME", parsed[0] if parsed is not None else alias_text)
+        _set(
+            row,
+            indexes,
+            "AN_POSTDIR",
+            parsed[1]
+            if parsed is not None
+            else direction(_value(row, indexes, "SUFDIR")),
+        )
+        return
+    parts = alias_text.split()
+    posttype = resolve_domain_value(parts[-1], domains.get("A1_POSTTYPE", {}))
+    if posttype is None:
+        _set(row, indexes, "A1_NAME", alias_text)
+        return
+    _set(row, indexes, "A1_NAME", " ".join(parts[:-1]))
+    _set(row, indexes, "A1_POSTTYPE", posttype)
+
+
+def _summit_names(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    pre_type = _value(row, indexes, "PRE_TYPE")
+    if has_value(pre_type) and has_value(_value(row, indexes, "NAME")):
+        _set(row, indexes, "NAME", f"{pre_type} {_value(row, indexes, 'NAME')}")
+    other_name = _value(row, indexes, "OTHER_NAME")
+    street = _value(row, indexes, "STREET")
+    if not has_value(other_name) or not has_value(street):
+        return
+    if str(other_name).split()[0].upper() != str(street).split()[0].upper():
+        _assign_parsed_name(
+            row, indexes, other_name, "A1_", domains.get("POSTTYPE", {})
+        )
+
+
+def _tooele_numeric_name(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    name = _value(row, indexes, "NAME_")
+    if has_value(name) and str(name).strip()[0].isdigit():
+        _assign_parsed_name(row, indexes, name, "", domains.get("POSTTYPE", {}))
+
+
+def _emery_compact_aliases(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    del domains
+    for source, target in (("ACS_ALIAS", None), ("ALIAS1", "A1"), ("ALIAS2", "A2")):
+        value = _value(row, indexes, source)
+        compact = (
+            re.fullmatch(r"(\d+)([NSEW])", str(value).strip().upper())
+            if has_value(value)
+            else None
+        )
+        if compact is not None:
+            _set(row, indexes, "AN_NAME", compact.group(1))
+            _set(row, indexes, "AN_POSTDIR", compact.group(2))
+        elif target is None and has_value(value) and str(value).strip().isdigit():
+            _set(row, indexes, "AN_NAME", str(value).strip())
+
+
+def _kane_alias_cleanup(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    del domains
+    for prefix in ("A1", "A2"):
+        value = str(_value(row, indexes, f"{prefix}_NAME")).strip().upper()
+        if len(value) >= 2 and value[0] == "K" and value[1].isdigit():
+            _clear(row, indexes, prefix)
+    if not str(_value(row, indexes, "AN_NAME")).strip().isdigit():
+        _set(row, indexes, "AN_NAME", "")
+
+
+def _grand_numeric_acs_name(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    del domains
+    if not str(_value(row, indexes, "AN_NAME")).strip().isdigit():
+        _set(row, indexes, "AN_NAME", "")
+
+
+def _sevier_postdir_fallback(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    del domains
+    if not has_value(_value(row, indexes, "POSTDIR")):
+        _set(row, indexes, "POSTDIR", direction(_value(row, indexes, "SUR_DIR")))
+
+
+def _uintah_exclusion_note(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    del domains
+    if str(_value(row, indexes, "EXCLUDE")).strip().upper() == "X":
+        notes = str(_value(row, indexes, "UTRANS_NOTES") or "")
+        _set(row, indexes, "UTRANS_NOTES", f"{notes}Uintah marked as exclude;"[:200])
+
+
+def _wayne_acs_alias(
+    row: list[object],
+    indexes: Mapping[str, int],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    parsed = parse_full_address(
+        _value(row, indexes, "ACS_ALIAS"), domains.get("POSTTYPE", {})
+    )
+    if parsed is not None and parsed.name.isdigit():
+        _set(row, indexes, "AN_NAME", parsed.name)
+        _set(row, indexes, "AN_POSTDIR", parsed.postdir)
+
+
+HANDLERS: Mapping[str, Handler] = {
+    "utah_road_names": Handler(
+        required_fields=(
+            "ROADNAME",
+            "ALTROADNAME",
+            "ALTROADTYPE",
+            "ALTROADNAME2",
+        ),
+        target_fields=(
+            "NAME",
+            "POSTDIR",
+            "POSTTYPE",
+            "A1_NAME",
+            "A1_POSTTYPE",
+            "A2_NAME",
+            "AN_NAME",
+            "AN_POSTDIR",
+        ),
+        apply=_utah_road_names,
+    ),
+    "davis_alias": Handler(
+        required_fields=("ROADALIASNAME",),
+        target_fields=("A1_NAME", "A1_POSTTYPE", "AN_NAME", "AN_POSTDIR"),
+        apply=_davis_alias,
+    ),
+    "washington_postdir_and_aliases": Handler(
+        required_fields=("POSTDIR_", "SUFFIXDIR"),
+        target_fields=(
+            "POSTDIR",
+            "AN_NAME",
+            "A1_PREDIR",
+            "A1_NAME",
+            "A1_POSTTYPE",
+            "A1_POSTDIR",
+            "A2_PREDIR",
+            "A2_NAME",
+            "A2_POSTTYPE",
+            "A2_POSTDIR",
+        ),
+        apply=_washington_postdir_and_aliases,
+    ),
+    "weber_alias": Handler(
+        required_fields=("ALIAS", "ACS_ALIAS", "S_NAME", "SUFDIR"),
+        target_fields=("A1_NAME", "A1_POSTTYPE", "AN_NAME", "AN_POSTDIR"),
+        apply=_weber_alias,
+    ),
+    "summit_names": Handler(
+        required_fields=("PRE_TYPE", "OTHER_NAME", "STREET"),
+        target_fields=(
+            "NAME",
+            "A1_PREDIR",
+            "A1_NAME",
+            "A1_POSTTYPE",
+            "A1_POSTDIR",
+            "AN_NAME",
+            "AN_POSTDIR",
+        ),
+        apply=_summit_names,
+    ),
+    "tooele_numeric_name": Handler(
+        required_fields=("NAME_",),
+        target_fields=("PREDIR", "NAME", "POSTTYPE", "POSTDIR"),
+        apply=_tooele_numeric_name,
+    ),
+    "emery_compact_aliases": Handler(
+        required_fields=("ACS_ALIAS", "ALIAS1", "ALIAS2"),
+        target_fields=("AN_NAME", "AN_POSTDIR"),
+        apply=_emery_compact_aliases,
+    ),
+    "kane_alias_cleanup": Handler(
+        required_fields=(),
+        target_fields=(
+            "A1_PREDIR",
+            "A1_NAME",
+            "A1_POSTTYPE",
+            "A1_POSTDIR",
+            "A2_PREDIR",
+            "A2_NAME",
+            "A2_POSTTYPE",
+            "A2_POSTDIR",
+            "AN_NAME",
+        ),
+        apply=_kane_alias_cleanup,
+    ),
+    "grand_numeric_acs_name": Handler(
+        required_fields=(),
+        target_fields=("AN_NAME",),
+        apply=_grand_numeric_acs_name,
+    ),
+    "sevier_postdir_fallback": Handler(
+        required_fields=("SUR_DIR",),
+        target_fields=("POSTDIR",),
+        apply=_sevier_postdir_fallback,
+    ),
+    "uintah_exclusion_note": Handler(
+        required_fields=("EXCLUDE",),
+        target_fields=("UTRANS_NOTES",),
+        apply=_uintah_exclusion_note,
+    ),
+    "wayne_acs_alias": Handler(
+        required_fields=("ACS_ALIAS",),
+        target_fields=(
+            "A1_PREDIR",
+            "A1_NAME",
+            "A1_POSTTYPE",
+            "A1_POSTDIR",
+            "AN_NAME",
+            "AN_POSTDIR",
+        ),
+        apply=_wayne_acs_alias,
+    ),
+}
+
+
+def profile_handler(profile: CountyProfile) -> Handler | None:
+    """Resolve an optional handler name from the closed registry."""
+    value = profile.get("custom_handler")
+    if value is None or value == "":
+        return None
+    if not isinstance(value, str):
+        raise TypeError(
+            f"Profile '{profile.key}' setting 'custom_handler' must be a string."
+        )
+    try:
+        return HANDLERS[value]
+    except KeyError as exc:
+        names = ", ".join(sorted(HANDLERS))
+        raise ValueError(
+            f"Profile '{profile.key}' has unsupported custom_handler '{value}'. "
+            f"Supported handlers: {names}."
+        ) from exc
diff --git a/cli/src/utrans/etl_mappers.py b/cli/src/utrans/etl_mappers.py
index 4f2dbb0..ebcbccf 100644
--- a/cli/src/utrans/etl_mappers.py
+++ b/cli/src/utrans/etl_mappers.py
@@ -13,6 +13,8 @@
     parse_full_address,
     resolve_domain_value,
 )
+from utrans.etl_handlers import profile_handler
+from utrans.etl_rules import apply_rules, profile_rules
 from utrans.profiles import CountyProfile
 
 
@@ -69,6 +71,61 @@ def _parse_sources(profile: CountyProfile) -> tuple[tuple[str, str], ...]:
     return tuple(result)
 
 
+def _value_mappings(profile: CountyProfile) -> dict[str, dict[str, str]]:
+    """Return configured source-value to target-value mappings by target field."""
+    value = profile.get("value_mappings", {})
+    if not isinstance(value, Mapping):
+        raise TypeError(
+            f"Profile '{profile.key}' setting 'value_mappings' must be an object."
+        )
+    mappings: dict[str, dict[str, str]] = {}
+    for target, values in value.items():
+        if not isinstance(target, str) or not isinstance(values, Mapping):
+            raise TypeError(
+                f"Profile '{profile.key}' value_mappings must map field names to objects."
+            )
+        if not all(
+            isinstance(source, str) and isinstance(destination, str)
+            for source, destination in values.items()
+        ):
+            raise TypeError(
+                f"Profile '{profile.key}' value_mappings for '{target}' must map strings to strings."
+            )
+        mappings[target.upper()] = {
+            source.strip().upper(): destination.strip()
+            for source, destination in values.items()
+        }
+    return mappings
+
+
+def _validate_value_mappings(
+    profile: CountyProfile,
+    value_mappings: Mapping[str, Mapping[str, str]],
+    names: Mapping[str, str],
+    domains: Mapping[str, Mapping[str, str]],
+) -> None:
+    for target, values in value_mappings.items():
+        if target not in names:
+            raise ValueError(
+                f"Profile '{profile.key}' value_mappings references unknown target field "
+                f"'{target}'."
+            )
+        domain = domains.get(target)
+        if domain is None:
+            continue
+        invalid = [
+            value
+            for value in values.values()
+            if resolve_domain_value(value, domain) is None
+        ]
+        if invalid:
+            rendered = ", ".join(repr(value) for value in invalid)
+            raise ValueError(
+                f"Profile '{profile.key}' value_mappings for '{target}' contains values "
+                f"outside the target domain: {rendered}."
+            )
+
+
 def _excluded_values(profile: CountyProfile) -> dict[str, set[str]]:
     value = profile.get("exclude_if_any", "")
     if isinstance(value, str):
@@ -95,12 +152,27 @@ def _excluded_values(profile: CountyProfile) -> dict[str, set[str]]:
     }
 
 
+def _fits_field_length(
+    value: object, field_lengths: Mapping[str, int | None], field: str
+) -> bool:
+    length = field_lengths.get(field.upper())
+    return length is None or len(str(value)) <= length
+
+
 def apply_mapper(feature_class: str, profile: CountyProfile, utrans_roads: str) -> None:
-    """Apply a county's root-level profile mapping configuration."""
+    """Apply mappings while preserving invalid domain values in the audit notes.
+
+    Valid domain aliases are converted to their coded values. Invalid values are
+    recorded in UTRANS_NOTES and assigned to the target when they fit its field
+    length. Field-length validation runs after all mapping and normalization.
+    """
     mappings = _mapping(profile, "field_mappings")
     if not mappings:
         raise RuntimeError(f"Profile '{profile.key}' requires field_mappings for ETL.")
     parse_sources = _parse_sources(profile)
+    value_mappings = _value_mappings(profile)
+    rules = profile_rules(profile)
+    handler = profile_handler(profile)
     names = field_name_map(feature_class)
     mappings = {
         **{
@@ -119,6 +191,8 @@ def apply_mapper(feature_class: str, profile: CountyProfile, utrans_roads: str)
         "AN_NAME",
         "AN_POSTDIR",
     ]
+    if handler is not None:
+        target_fields.extend(handler.target_fields)
     for _, alias in parse_sources:
         prefix = "" if alias == "PRIMARY" else f"{alias}_"
         target_fields.extend(
@@ -127,6 +201,7 @@ def apply_mapper(feature_class: str, profile: CountyProfile, utrans_roads: str)
     source_fields = [
         *mappings.values(),
         *(source for source, _ in parse_sources),
+        *(handler.required_fields if handler is not None else ()),
     ]
     fields = list(
         dict.fromkeys(
@@ -136,7 +211,13 @@ def apply_mapper(feature_class: str, profile: CountyProfile, utrans_roads: str)
         )
     )
     indexes = {field.upper(): index for index, field in enumerate(fields)}
+    field_lengths = {
+        field.name.upper(): field.length
+        for field in arcpy.ListFields(feature_class)
+        if field.type == "String"
+    }
     domains = domain_values(utrans_roads)
+    _validate_value_mappings(profile, value_mappings, names, domains)
     posttypes = domains.get("POSTTYPE", {})
     vertical_translation = profile.get("translate_vertical_levels", False)
     if not isinstance(vertical_translation, bool):
@@ -160,16 +241,20 @@ def apply_mapper(feature_class: str, profile: CountyProfile, utrans_roads: str)
                     source_value = {"1": "0", "2": "1", "3": "2"}.get(
                         str(source_value).strip(), source_value
                     )
+                source_value = value_mappings.get(target.upper(), {}).get(
+                    str(source_value).strip().upper(), source_value
+                )
                 resolved = resolve_domain_value(source_value, values)
                 if resolved is not None:
                     row[target_index] = resolved
                 elif has_value(row[source_index]):
-                    row[target_index] = source_value
                     notes_index = indexes.get("UTRANS_NOTES")
                     if notes_index is not None:
                         row[notes_index] = (
                             f"{row[notes_index] or ''}{target}: {source_value}; "
                         )[:200]
+                    if _fits_field_length(source_value, field_lengths, target):
+                        row[target_index] = source_value
             for source, alias in parse_sources:
                 source_index = indexes.get(source.upper())
                 if source_index is None:
@@ -199,6 +284,9 @@ def apply_mapper(feature_class: str, profile: CountyProfile, utrans_roads: str)
                     index = indexes.get(f"{prefix}{suffix}".upper())
                     if index is not None:
                         row[index] = value
+            apply_rules(row, indexes, rules)
+            if handler is not None:
+                handler.apply(row, indexes, domains)
             for field, value in (
                 ("COUNTY_L", profile.require("fips")),
                 ("COUNTY_R", profile.require("fips")),
diff --git a/cli/src/utrans/etl_rules.py b/cli/src/utrans/etl_rules.py
new file mode 100644
index 0000000..4f19462
--- /dev/null
+++ b/cli/src/utrans/etl_rules.py
@@ -0,0 +1,53 @@
+"""Supported declarative post-mapping rules for county ETL profiles."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+from utrans.etl_common import has_value
+from utrans.profiles import CountyProfile
+
+SUPPORTED_RULES = frozenset({"remove_postdir_if_alpha", "remove_posttype_if_numeric"})
+
+
+def profile_rules(profile: CountyProfile) -> tuple[str, ...]:
+    """Validate and return the ordered post-mapping rules for a profile."""
+    value = profile.get("rules", [])
+    if (
+        not isinstance(value, Sequence)
+        or isinstance(value, str)
+        or not all(isinstance(rule, str) for rule in value)
+    ):
+        raise TypeError(
+            f"Profile '{profile.key}' setting 'rules' must be a list of strings."
+        )
+    unknown = set(value) - SUPPORTED_RULES
+    if unknown:
+        names = ", ".join(sorted(unknown))
+        raise ValueError(
+            f"Profile '{profile.key}' has unsupported ETL rule(s): {names}."
+        )
+    if len(set(value)) != len(value):
+        raise ValueError(
+            f"Profile '{profile.key}' setting 'rules' cannot contain duplicates."
+        )
+    return tuple(value)
+
+
+def apply_rules(
+    row: list[object], indexes: Mapping[str, int], rules: Sequence[str]
+) -> None:
+    """Apply supported post-mapping rules to a cursor row in profile order."""
+    name_index = indexes.get("NAME")
+    if name_index is None or not has_value(row[name_index]):
+        return
+    name = str(row[name_index]).strip()
+    for rule in rules:
+        if rule == "remove_postdir_if_alpha" and name[0].isalpha():
+            postdir_index = indexes.get("POSTDIR")
+            if postdir_index is not None:
+                row[postdir_index] = ""
+        elif rule == "remove_posttype_if_numeric" and name[0].isdigit():
+            posttype_index = indexes.get("POSTTYPE")
+            if posttype_index is not None:
+                row[posttype_index] = ""
diff --git a/cli/src/utrans/profiles.json b/cli/src/utrans/profiles.json
index 3e75fbb..2c453ba 100644
--- a/cli/src/utrans/profiles.json
+++ b/cli/src/utrans/profiles.json
@@ -1,202 +1,222 @@
 {
   "beaver": {
-    "fips": "49001",
-    "match_fields": "STREETNAME STREETNAME",
     "compare_fields": "PREDIR PREDIR; STREETNAME STREETNAME; STREETTYPE STREETTYPE; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD; ALIAS1 ALIAS1; ALIAS1TYP ALIAS1TYP; ACSNAME ACSNAME; ACSSUF ACSSUF; SUFDIR SUFDIR",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; NAME=STREETNAME; POSTDIR=SUFDIR; AN_NAME=ACSNAME; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=CO_UNIQUE; STATUS=STATUS_; POSTTYPE=STREETTYPE; DOT_SRFTYP=SURFTYPE; DOT_CLASS=CLASS; VERT_LEVEL=VERTLEVEL",
+    "fips": "49001 - Beaver",
+    "match_fields": "STREETNAME STREETNAME",
     "translate_vertical_levels": true
   },
   "boxelder": {
-    "fips": "49003",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD; PRE_DIR PRE_DIR; S_NAME S_NAME; S_TYPE S_TYPE; SUF_DIR SUF_DIR; ACS_ALIAS ACS_ALIAS; ACS_NAME ACS_NAME; ACS_SUF ACS_SUF; ALIAS1 ALIAS1; ALIAS1_TYP ALIAS1_TYP; ALIAS2 ALIAS2; ALIAS2_TYP ALIAS2_TYP",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=S_NAME; POSTDIR=SUF_DIR; AN_NAME=ACS_NAME; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=CO_UNIQUE; POSTTYPE=S_TYPE; DOT_CLASS=CLASS; VERT_LEVEL=VERTLEVEL",
+    "fips": "49003 - Box Elder",
+    "match_fields": "S_NAME S_NAME",
     "translate_vertical_levels": true
   },
   "cache": {
-    "fips": "49005",
-    "match_fields": "GEOCODEST GEOCODEST",
     "compare_fields": "PRE_DIR PRE_DIR; GEOCODEST GEOCODEST; TYPE TYPE; FAL FAL; TAL TAL; FAR FAR; TAR TAR; AliasPreDir AliasPreDir; AliasStreet AliasStreet; AliasType AliasType; AliasSufDir AliasSufDir; SUFFDIR SUFFDIR",
     "field_mappings": "FROMADDR_L=FAL; TOADDR_L=TAL; FROMADDR_R=FAR; TOADDR_R=TAR; NAME=STNAME; A1_NAME=ALIAS; A2_NAME=ALIAS2",
+    "fips": "49005 - Cache",
+    "match_fields": "GEOCODEST GEOCODEST",
     "parse_sources": "STNAME=PRIMARY; ALIAS=A1; ALIAS2=A2"
   },
+  "carbon": {
+    "compare_fields": "PREDIR PREDIR; NAME NAME; POSTTYPE POSTTYPE; POSTDIR POSTDIR; FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R",
+    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_; LOCAL_UID=LOCAL_UID_",
+    "fips": "49007 - Carbon",
+    "match_fields": "NAME NAME"
+  },
   "daggett": {
-    "fips": "49009",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "PRE_DIR PRE_DIR; S_NAME S_NAME; S_TYPE S_TYPE; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD; ACS_ALIAS ACS_ALIAS; SUF_DIR SUF_DIR",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=S_NAME; A2_NAME=ALIAS2; LOCAL_UID=CO_UNIQUE; STATUS=S_STATUS; POSTTYPE=S_TYPE; A2_POSTTYPE=ALIAS2_TYP; DOT_CLASS=CLASS; ONEWAY=ONE_WAY; DOT_SRFTYP=S_SURF2; SPEED_LMT=SPD_LMT",
+    "fips": "49009 - Daggett",
+    "match_fields": "S_NAME S_NAME",
     "parse_sources": "ALIAS1=A1; ALIAS2=A2; ACS_ALIAS=A1"
   },
+  "davis": {
+    "compare_fields": "PrefixDirection PrefixDirection; RoadName RoadName; RoadNameType RoadNameType; PostDirection PostDirection; RoadAliasName RoadAliasName; LeftFrom LeftFrom; LeftTo LeftTo; RightFrom RightFrom; RightTo RightTo; MPH MPH",
+    "custom_handler": "davis_alias",
+    "field_mappings": "FROMADDR_L=LeftFrom; TOADDR_L=LeftTo; FROMADDR_R=RightFrom; TOADDR_R=RightTo; PREDIR=PrefixDirection; NAME=RoadName; POSTTYPE=RoadNameType; POSTDIR=PostDirection; DOT_SRFTYP=RoadSurfaceType",
+    "fips": "49011 - Davis",
+    "match_fields": "RoadName RoadName",
+    "required_fields": [
+      "PrefixDirection",
+      "RoadName",
+      "RoadNameType",
+      "PostDirection",
+      "RoadAliasName",
+      "LeftFrom",
+      "LeftTo",
+      "RightFrom",
+      "RightTo",
+      "MPH"
+    ]
+  },
   "duchesne": {
-    "fips": "49013",
-    "match_fields": "STREETNAME STREETNAME",
     "compare_fields": "PREDIR PREDIR; STREETNAME STREETNAME; STREETTYPE STREETTYPE; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD; ALIAS1 ALIAS1; ALIAS1TYPE ALIAS1TYPE; ALIAS2 ALIAS2; ALIAS2TYPE ALIAS2TYPE; ACSNAME ACSNAME; ACSSUF ACSSUF; SUFDIR SUFDIR",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PREDIR_; NAME=STREETNAME; POSTDIR=SUFDIR; AN_NAME=ACSNAME; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=COUNIQUE; POSTTYPE=STREETTYPE; ONEWAY=ONEWAY_; DOT_SRFTYP=SURFTYPE; STATUS=STATUS_; DOT_CLASS=CLASS; A1_POSTTYPE=ALIAS1TYPE; A2_POSTTYPE=ALIAS2TYPE; VERT_LEVEL=VERTLEVEL",
+    "fips": "49013 - Duchesne",
+    "match_fields": "STREETNAME STREETNAME",
     "parse_sources": "ALIAS1=A1; ALIAS2=A2",
     "translate_vertical_levels": true
   },
   "emery": {
-    "fips": "49015",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "PRE_DIR PRE_DIR; S_NAME S_NAME; S_TYPE S_TYPE; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD; ALIAS1 ALIAS1; ALIAS1_TYP ALIAS1_TYP; ALIAS2 ALIAS2; ALIAS2_TYP ALIAS2_TYP; SUF_DIR SUF_DIR",
-    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=S_NAME; POSTDIR=SUF_DIR; LOCAL_UID=CO_UNIQUE; STATUS=STATUS_; POSTTYPE=S_TYPE; DOT_CLASS=CLASS; ONEWAY=ONE_WAY; DOT_SRFTYP=S_SURF2; SPEED_LMT=SPD_LMT; A1_POSTTYPE=ALIAS1_TYP; A2_POSTTYPE=ALIAS2_TYP",
-    "exclude_if_any": "S_SURF=400,410,420,430,440"
-  },
-  "carbon": {
-    "fips": "49007",
-    "match_fields": "NAME NAME",
-    "compare_fields": "PREDIR PREDIR; NAME NAME; POSTTYPE POSTTYPE; POSTDIR POSTDIR; FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R",
-    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_; LOCAL_UID=LOCAL_UID_"
+    "custom_handler": "emery_compact_aliases",
+    "exclude_if_any": "S_SURF=400,410,420,430,440",
+    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=S_NAME; POSTDIR=SUF_DIR; AN_NAME=ACS_ALIAS; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=CO_UNIQUE; STATUS=STATUS_; POSTTYPE=S_TYPE; DOT_CLASS=CLASS; ONEWAY=ONE_WAY; DOT_SRFTYP=S_SURF2; SPEED_LMT=SPD_LMT; A1_POSTTYPE=ALIAS1_TYP; A2_POSTTYPE=ALIAS2_TYP",
+    "fips": "49015 - Emery",
+    "match_fields": "S_NAME S_NAME"
   },
   "garfield": {
-    "fips": "49017",
-    "match_fields": "NAME NAME",
     "compare_fields": "FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R; NAME NAME; PREDIR PREDIR; POSTDIR POSTDIR; POSTTYPE POSTTYPE; AN_NAME AN_NAME; A1_NAME A1_NAME; A2_NAME A2_NAME",
-    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; A1_NAME=A1_NAME_; A2_NAME=A2_NAME_; LOCAL_UID=LOCAL_UID_; POSTTYPE=POSTTYPE_; A1_POSTTYPE=A1_POSTTYPE_; A2_POSTTYPE=A2_POSTTYPE_; ONEWAY=ONEWAY_; CARTOCODE=CARTOCODE_; STATUS=STATUS_; DOT_SRFTYP=DOT_SRFTYP_; DOT_CLASS=DOT_CLASS_; SPEED_LMT=SPEED_LMT_"
+    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; A1_NAME=A1_NAME_; A2_NAME=A2_NAME_; LOCAL_UID=LOCAL_UID_; POSTTYPE=POSTTYPE_; A1_POSTTYPE=A1_POSTTYPE_; A2_POSTTYPE=A2_POSTTYPE_; ONEWAY=ONEWAY_; CARTOCODE=CARTOCODE_; STATUS=STATUS_; DOT_SRFTYP=DOT_SRFTYP_; DOT_CLASS=DOT_CLASS_; SPEED_LMT=SPEED_LMT_",
+    "fips": "49017 - Garfield",
+    "match_fields": "NAME NAME"
   },
   "grand": {
-    "fips": "49019",
-    "match_fields": "STREETNAME STREETNAME",
     "compare_fields": "L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD; STREETNAME STREETNAME; PREDIR PREDIR; SUFDIR SUFDIR; STREETTYPE STREETTYPE; ACSALIAS ACSALIAS; ALIAS1 ALIAS1; ALIAS2 ALIAS2",
+    "custom_handler": "grand_numeric_acs_name",
+    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PREDIR_; NAME=STREETNAME; POSTDIR=SUFDIR; AN_NAME=ACSNAME; AN_POSTDIR=ACSSUF; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=COUNIQUE; STATUS=STATUS_; POSTTYPE=STREETTYPE; A1_POSTTYPE=ALIAS1TYPE; A2_POSTTYPE=ALIAS2TYPE; DOT_CLASS=CLASS; ONEWAY=ONEWAY_; DOT_SRFTYP=SURFTYPE; CARTOCODE=CARTOCODE_; SPEED_LMT=SPEED",
+    "fips": "49019 - Grand",
+    "match_fields": "STREETNAME STREETNAME",
     "uppercase_normalize_fields": [
       "STREETNAME",
       "STREETTYPE",
       "ACSALIAS",
       "ALIAS1",
       "ALIAS2"
-    ],
-    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PREDIR_; NAME=STREETNAME; POSTDIR=SUFDIR; AN_NAME=ACSNAME; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=COUNIQUE; STATUS=STATUS_; POSTTYPE=STREETTYPE; A1_POSTTYPE=ALIAS1TYPE; A2_POSTTYPE=ALIAS2TYPE; DOT_CLASS=CLASS; ONEWAY=ONEWAY_; DOT_SRFTYP=SURFTYPE; CARTOCODE=CARTOCODE_; SPEED_LMT=SPEED"
+    ]
   },
   "iron": {
-    "fips": "49021",
-    "match_fields": "STREETNAME STREETNAME",
     "compare_fields": "PREDIR PREDIR; STREETNAME STREETNAME; STREETTYPE STREETTYPE; SUFDIR SUFDIR; ALIAS1 ALIAS1; ALIAS1TYPE ALIAS1TYPE; ALIAS2 ALIAS2; ALIAS2TYPE ALIAS2TYPE; ACSALIAS ACSALIAS; ACSNAME ACSNAME; ACSSUF ACSSUF; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PREDIR_; NAME=STREETNAME; POSTDIR=SUFDIR; AN_NAME=ACSNAME; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=COUNIQUE; POSTTYPE=STREETTYPE; ONEWAY=ONEWAY_; DOT_SRFTYP=SURFTYPE; STATUS=STATUS_; DOT_CLASS=CLASS; VERT_LEVEL=VERTLEVEL",
+    "fips": "49021 - Iron",
+    "match_fields": "STREETNAME STREETNAME",
     "translate_vertical_levels": true
   },
   "kane": {
-    "fips": "49025",
-    "match_fields": "STREETNAME STREETNAME",
     "compare_fields": "PREDIR PREDIR; STREETNAME STREETNAME; STREETTYPE STREETTYPE; SUFDIR SUFDIR; ACSALIAS ACSALIAS; ALIAS1 ALIAS1; ALIAS1TYPE ALIAS1TYPE; ALIAS2 ALIAS2; ALIAS2TYPE ALIAS2TYPE; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD",
+    "custom_handler": "kane_alias_cleanup",
+    "exclude_if_any": "SURFTYPE=400,410,420,430,440,999",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PREDIR_; NAME=STREETNAME; POSTDIR=SUFDIR; AN_NAME=ACSNAME; A1_NAME=ALIAS1; A2_NAME=ALIAS2; LOCAL_UID=COUNIQUE; STATUS=STATUS_; POSTTYPE=STREETTYPE; A1_POSTTYPE=ALIAS1TYPE; A2_POSTTYPE=ALIAS2TYPE; DOT_CLASS=CLASS; ONEWAY=ONEWAY_; DOT_SRFTYP=SURFTYPE; CARTOCODE=CARTOCODE_; SPEED_LMT=SPEED",
-    "exclude_if_any": "SURFTYPE=400,410,420,430,440,999"
+    "fips": "49025 - Kane",
+    "match_fields": "STREETNAME STREETNAME"
   },
   "millard": {
-    "fips": "49027",
-    "match_fields": "FULLNAME FULLNAME",
     "compare_fields": "PREDIR PREDIR; FULLNAME FULLNAME; STREETTYPE STREETTYPE; SUFDIR SUFDIR; ALIAS1 ALIAS1; ALIAS1TYPE ALIAS1TYPE; ALIAS2 ALIAS2; ALIAS2TYPE ALIAS2TYPE; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD",
-    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PREDIR_; NAME=FULLNAME; POSTDIR=SUFDIR; A1_NAME=ALIAS1; A2_NAME=ALIAS2; POSTTYPE=STREETTYPE; A1_POSTTYPE=ALIAS1TYPE; A2_POSTTYPE=ALIAS2TYPE; CARTOCODE=CARTOCODE_"
+    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PREDIR_; NAME=FULLNAME; POSTDIR=SUFDIR; A1_NAME=ALIAS1; A2_NAME=ALIAS2; POSTTYPE=STREETTYPE; A1_POSTTYPE=ALIAS1TYPE; A2_POSTTYPE=ALIAS2TYPE; CARTOCODE=CARTOCODE_",
+    "fips": "49027 - Millard",
+    "match_fields": "FULLNAME FULLNAME"
   },
   "morgan": {
-    "fips": "49029",
-    "match_fields": "FULLNAME FULLNAME",
     "compare_fields": "FROMLEFT FROMLEFT; TOLEFT TOLEFT; FROMRIGHT FROMRIGHT; TORIGHT TORIGHT; FULLNAME FULLNAME",
     "field_mappings": "FROMADDR_L=FROMLEFT; TOADDR_L=TOLEFT; FROMADDR_R=FROMRIGHT; TOADDR_R=TORIGHT; FULLNAME=FULLNAME_; ONEWAY=ONEWAYDIR; DOT_CLASS=ROADCLASS; VERT_LEVEL=ROADLEVEL",
+    "fips": "49029 - Morgan",
+    "match_fields": "FULLNAME FULLNAME",
     "parse_sources": "FULLNAME_=PRIMARY"
   },
   "piute": {
-    "fips": "49031",
-    "match_fields": "NAME NAME",
     "compare_fields": "PREDIR PREDIR; NAME NAME; POSTTYPE POSTTYPE; POSTDIR POSTDIR; FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R",
-    "field_mappings": "FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_"
+    "field_mappings": "FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_",
+    "fips": "49031 - Piute",
+    "match_fields": "NAME NAME"
   },
   "rich": {
-    "fips": "49033",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "PRE_DIR PRE_DIR; S_NAME S_NAME; S_TYPE S_TYPE; SUF_DIR SUF_DIR; ACS_ALIAS ACS_ALIAS; ALIAS1 ALIAS1; ALIAS1_TYP ALIAS1_TYP; ALIAS2 ALIAS2; ALIAS2_TYP ALIAS2_TYP; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=S_NAME; LOCAL_UID=CO_UNIQUE; POSTTYPE=S_TYPE; A1_POSTTYPE=ALIAS1_TYP; A2_POSTTYPE=ALIAS2_TYP; ONEWAY=ONE_WAY; DOT_SRFTYP=S_SURF; SPEED_LMT=SPD_LMT",
+    "fips": "49033 - Rich",
+    "match_fields": "S_NAME S_NAME",
     "parse_sources": "ALIAS1=A1; ALIAS2=A2; ACS_ALIAS=A1"
   },
   "saltlake": {
-    "fips": "49035",
-    "match_fields": "NAME NAME",
     "compare_fields": "PREDIR PREDIR; NAME NAME; POSTTYPE POSTTYPE; POSTDIR POSTDIR; AN_NAME AN_NAME; AN_POSTDIR AN_POSTDIR; FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R",
-    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; POSTTYPE=POSTTYPE_; STATUS=STATUS_; ONEWAY=ONEWAY_; DOT_SRFTYP=DOT_SRFTYP_"
+    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; POSTTYPE=POSTTYPE_; STATUS=STATUS_; ONEWAY=ONEWAY_; DOT_SRFTYP=DOT_SRFTYP_",
+    "fips": "49035 - Salt Lake",
+    "match_fields": "NAME NAME"
   },
   "sanjuan": {
-    "fips": "49037",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "S_NAME S_NAME",
     "field_mappings": "NAME=S_NAME; LOCAL_UID=CO_UNIQUE; DOT_CLASS=CLASS",
+    "fips": "49037 - San Juan",
+    "match_fields": "S_NAME S_NAME",
     "parse_sources": "S_NAME=PRIMARY"
   },
+  "sanpete": {
+    "compare_fields": "",
+    "field_mappings": "??",
+    "fips": "49039 - Sanpete",
+    "match_fields": ""
+  },
   "sevier": {
-    "fips": "49041",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD; PRE_DIR PRE_DIR; S_NAME S_NAME; S_TYPE S_TYPE; SUR_DIR SUR_DIR; ALIAS ALIAS",
-    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=STREET; LOCAL_UID=CO_UNIQUE; POSTTYPE=S_TYPE",
+    "custom_handler": "sevier_postdir_fallback",
+    "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=STREET; POSTDIR=SUR_DIR; LOCAL_UID=CO_UNIQUE; POSTTYPE=S_TYPE",
+    "fips": "49041 - Sevier",
+    "match_fields": "S_NAME S_NAME",
     "parse_sources": "STREET=PRIMARY; ALIAS=A1"
   },
   "summit": {
-    "fips": "49043",
-    "match_fields": "STREET STREET",
     "compare_fields": "PREFIX_DIR PREFIX_DIR; STREET STREET; CLASSIFICA CLASSIFICA; POST_DIR POST_DIR; FROMLEFT FROMLEFT; TOLEFT TOLEFT; FROMRIGHT FROMRIGHT; TORIGHT TORIGHT",
-    "field_mappings": "FROMADDR_L=FROMLEFT; TOADDR_L=TOLEFT; FROMADDR_R=FROMRIGHT; TOADDR_R=TORIGHT; PREDIR=PREFIX_DIR; NAME=STREET; POSTDIR=POST_DIR; POSTTYPE=SUFF_TYPE; ONEWAY=ONEWAY_; STATUS=STATUS_"
+    "custom_handler": "summit_names",
+    "field_mappings": "FROMADDR_L=FROMLEFT; TOADDR_L=TOLEFT; FROMADDR_R=FROMRIGHT; TOADDR_R=TORIGHT; PREDIR=PREFIX_DIR; NAME=STREET; POSTDIR=POST_DIR; POSTTYPE=SUFF_TYPE; ONEWAY=ONEWAY_; STATUS=STATUS_",
+    "fips": "49043 - Summit",
+    "match_fields": "STREET STREET"
   },
   "tooele": {
-    "fips": "49045",
-    "match_fields": "FULLNAME FULLNAME",
     "compare_fields": "FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R; FULLNAME FULLNAME; PREDIR PREDIR; A1_NAME A1_NAME; A2_NAME A2_NAME; AN_NAME AN_NAME; STATUS STATUS",
-    "uppercase_normalize_fields": ["FULLNAME", "A1_NAME", "A2_NAME"],
+    "custom_handler": "tooele_numeric_name",
+    "exclude_if_any": "EXCLUDE=X,P; STATUS_=CONSTRUCTION,PLANNED",
     "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; A1_NAME=A1_NAME_; A2_NAME=A2_NAME_; LOCAL_UID=LOCAL_UID_",
-    "exclude_if_any": "EXCLUDE=X,P; STATUS_=CONSTRUCTION,PLANNED"
+    "fips": "49045 - Tooele",
+    "match_fields": "FULLNAME FULLNAME",
+    "uppercase_normalize_fields": ["FULLNAME", "A1_NAME", "A2_NAME"]
   },
   "uintah": {
-    "fips": "49047",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "toleft toleft; toright toright; fromleft fromleft; fromright fromright; S_NAME S_NAME; ALIAS1 ALIAS1",
-    "uppercase_normalize_fields": ["S_NAME", "ALIAS1"],
+    "custom_handler": "uintah_exclusion_note",
     "field_mappings": "FROMADDR_L=fromleft; TOADDR_L=toleft; FROMADDR_R=fromright; TOADDR_R=toright; PREDIR=PRE_DIR; NAME=S_NAME; POSTDIR=SUF_DIR; A1_NAME=ALIAS1; LOCAL_UID=CO_UNIQUE; POSTTYPE=S_TYPE; SPEED_LMT=SPD_LMT",
-    "parse_sources": "S_NAME=PRIMARY; ALIAS1=A1"
+    "fips": "49047 - Uintah",
+    "match_fields": "S_NAME S_NAME",
+    "parse_sources": "S_NAME=PRIMARY; ALIAS1=A1",
+    "uppercase_normalize_fields": ["S_NAME", "ALIAS1"]
   },
   "utah": {
-    "fips": "49049",
-    "match_fields": "ROADNAME ROADNAME",
     "compare_fields": "ROADPREDIR ROADPREDIR; ROADNAME ROADNAME; ROADTYPE ROADTYPE; ROADPOSTDIR ROADPOSTDIR; ALTROADNAME ALTROADNAME; ALTROADTYPE ALTROADTYPE; ALTROADNAME2 ALTROADNAME2; ALTROADTYPE2 ALTROADTYPE2; FROMLEFT FROMLEFT; TOLEFT TOLEFT; FROMRIGHT FROMRIGHT; TORIGHT TORIGHT",
-    "field_mappings": "FROMADDR_L=FROMLEFT; TOADDR_L=TOLEFT; FROMADDR_R=FROMRIGHT; TOADDR_R=TORIGHT; PREDIR=ROADPREDIR; NAME=ROADNAME"
+    "custom_handler": "utah_road_names",
+    "field_mappings": "FROMADDR_L=FROMLEFT; TOADDR_L=TOLEFT; FROMADDR_R=FROMRIGHT; TOADDR_R=TORIGHT; PREDIR=ROADPREDIR; NAME=ROADNAME; POSTTYPE=ROADTYPE; POSTDIR=ROADPOSTDIR; A1_NAME=ALTROADNAME; A1_POSTTYPE=ALTROADTYPE; A2_NAME=ALTROADNAME2",
+    "fips": "49049 - Utah",
+    "match_fields": "ROADNAME ROADNAME",
+    "rules": ["remove_posttype_if_numeric"]
   },
   "wasatch": {
-    "fips": "49051",
-    "match_fields": "FULLNAME FULLNAME",
     "compare_fields": "FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R; FULLNAME FULLNAME; PREDIR PREDIR; AN_NAME AN_NAME",
-    "uppercase_normalize_fields": ["FULLNAME"],
-    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; LOCAL_UID=LOCAL_UID_"
+    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; LOCAL_UID=LOCAL_UID_",
+    "fips": "49051 - Wasatch",
+    "match_fields": "FULLNAME FULLNAME",
+    "uppercase_normalize_fields": ["FULLNAME"]
   },
   "washington": {
-    "fips": "49053",
-    "match_fields": "NAME NAME",
     "compare_fields": "FROMADDR_L FROMADDR_L; TOADDR_L TOADDR_L; FROMADDR_R FROMADDR_R; TOADDR_R TOADDR_R; PREDIR PREDIR; NAME NAME; POSTTYPE POSTTYPE; POSTDIR POSTDIR; SUFFIXDIR SUFFIXDIR; AN_NAME AN_NAME; AN_POSTDIR AN_POSTDIR; A1_NAME A1_NAME; A1_POSTTYPE A1_POSTTYPE; A2_NAME A2_NAME; A2_POSTTYPE A2_POSTTYPE",
-    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; AN_NAME=AN_NAME_; A1_NAME=A1_NAME_; A2_NAME=A2_NAME_; LOCAL_UID=LOCAL_UID_"
+    "custom_handler": "washington_postdir_and_aliases",
+    "field_mappings": "FULLNAME=FULLNAME_; FROMADDR_L=FROMADDR_L_; TOADDR_L=TOADDR_L_; FROMADDR_R=FROMADDR_R_; TOADDR_R=TOADDR_R_; PREDIR=PREDIR_; NAME=NAME_; POSTTYPE=POSTTYPE_; POSTDIR=POSTDIR_; AN_NAME=AN_NAME_; AN_POSTDIR=AN_POSTDIR_; A1_NAME=A1_NAME_; A1_POSTTYPE=A1_POSTTYPE_; A1_POSTDIR=A1_POSTDIR_; A2_NAME=A2_NAME_; A2_POSTTYPE=A2_POSTTYPE_; A2_POSTDIR=A2_POSTDIR_; STATUS=STATUS_; ONEWAY=ONEWAY_; LOCAL_UID=LOCAL_UID_",
+    "fips": "49053 - Washington",
+    "match_fields": "NAME NAME"
   },
   "wayne": {
-    "fips": "49055",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "PRE_DIR PRE_DIR; S_NAME S_NAME; S_TYPE S_TYPE; SUF_DIR SUF_DIR; ACS_ALIAS ACS_ALIAS; ALIAS1 ALIAS1; ALIAS1_TYP ALIAS1_TYP; L_F_ADD L_F_ADD; L_T_ADD L_T_ADD; R_F_ADD R_F_ADD; R_T_ADD R_T_ADD",
+    "custom_handler": "wayne_acs_alias",
     "field_mappings": "FROMADDR_L=L_F_ADD; TOADDR_L=L_T_ADD; FROMADDR_R=R_F_ADD; TOADDR_R=R_T_ADD; PREDIR=PRE_DIR; NAME=S_NAME; LOCAL_UID=CO_UNIQUE; DOT_CLASS=CLASS; ONEWAY=ONE_WAY; DOT_SRFTYP=S_SURF2; VERT_LEVEL=VERTLEVEL",
+    "fips": "49055 - Wayne",
+    "match_fields": "S_NAME S_NAME",
     "parse_sources": "S_NAME=PRIMARY; ALIAS1=A1"
   },
   "weber": {
-    "fips": "49057",
-    "match_fields": "S_NAME S_NAME",
     "compare_fields": "PREDIR PREDIR; S_NAME S_NAME; STREETTYPE STREETTYPE; SUFDIR SUFDIR; ALIAS ALIAS; ACS_ALIAS ACS_ALIAS; SUFFIX_911 SUFFIX_911; LEFTFROM LEFTFROM; LEFTTO LEFTTO; RIGHTFROM RIGHTFROM; RIGHTTO RIGHTTO",
-    "field_mappings": "FROMADDR_L=LEFTFROM; TOADDR_L=LEFTTO; FROMADDR_R=RIGHTFROM; TOADDR_R=RIGHTTO; PREDIR=PREDIR; NAME=S_NAME; POSTDIR=SUFDIR; LOCAL_UID=S_UNIQUE"
-  },
-  "davis": {
-    "fips": "49011",
-    "match_fields": "RoadName RoadName",
-    "compare_fields": "PrefixDirection PrefixDirection; RoadName RoadName; RoadNameType RoadNameType; PostDirection PostDirection; RoadAliasName RoadAliasName; LeftFrom LeftFrom; LeftTo LeftTo; RightFrom RightFrom; RightTo RightTo; MPH MPH",
-    "required_fields": [
-      "PrefixDirection",
-      "RoadName",
-      "RoadNameType",
-      "PostDirection",
-      "RoadAliasName",
-      "LeftFrom",
-      "LeftTo",
-      "RightFrom",
-      "RightTo",
-      "MPH"
-    ],
-    "field_mappings": "FROMADDR_L=LeftFrom; TOADDR_L=LeftTo; FROMADDR_R=RightFrom; TOADDR_R=RightTo; PREDIR=PrefixDirection; NAME=RoadName; POSTDIR=PostDirection"
+    "custom_handler": "weber_alias",
+    "field_mappings": "FROMADDR_L=LEFTFROM; TOADDR_L=LEFTTO; FROMADDR_R=RIGHTFROM; TOADDR_R=RIGHTTO; PREDIR=PREDIR; NAME=S_NAME; POSTTYPE=STREETTYPE; POSTDIR=SUFDIR; SPEED_LMT=SPEEDLIMIT; LOCAL_UID=S_UNIQUE",
+    "fips": "49057 - Weber",
+    "match_fields": "S_NAME S_NAME",
+    "rules": ["remove_postdir_if_alpha", "remove_posttype_if_numeric"]
   }
 }
diff --git a/cli/tests/test_cli.py b/cli/tests/test_cli.py
index 60ed9ba..53d9021 100644
--- a/cli/tests/test_cli.py
+++ b/cli/tests/test_cli.py
@@ -5,7 +5,9 @@
 
 import utrans
 from utrans import cli
+from utrans.etl import _county_boundary_name
 from utrans.etl_common import direction, parse_full_address, resolve_domain_value
+from utrans.etl_handlers import HANDLERS
 from utrans.profiles import load_profiles
 
 
@@ -61,10 +63,23 @@ def test_etl_help(capsys):
     assert "--county-boundaries" in captured.out
 
 
+@pytest.mark.parametrize(
+    ("county", "expected"),
+    [
+        ("davis", "DAVIS"),
+        ("boxelder", "BOX ELDER"),
+        ("saltlake", "SALT LAKE"),
+        ("sanjuan", "SAN JUAN"),
+    ],
+)
+def test_county_boundary_name_is_uppercase(county, expected):
+    assert _county_boundary_name(county) == expected
+
+
 def test_saltlake_profile_replaces_vecc():
     profiles = load_profiles()
 
-    assert profiles["saltlake"].require("fips") == "49035"
+    assert profiles["saltlake"].require("fips") == "49035 - Salt Lake"
     assert "vecc" not in profiles
 
 
@@ -72,6 +87,16 @@ def test_every_profile_has_field_mappings():
     assert all(profile.get("field_mappings") for profile in load_profiles().values())
 
 
+def test_profile_handlers_are_registered():
+    handlers = {
+        profile.get("custom_handler")
+        for profile in load_profiles().values()
+        if profile.get("custom_handler")
+    }
+
+    assert handlers <= HANDLERS.keys()
+
+
 def test_legacy_address_helpers():
     parsed = parse_full_address("North 1200 West", {"RD"})
 
diff --git a/cli/tests/test_etl_common.py b/cli/tests/test_etl_common.py
new file mode 100644
index 0000000..5ad5428
--- /dev/null
+++ b/cli/tests/test_etl_common.py
@@ -0,0 +1,62 @@
+from types import SimpleNamespace
+from unittest.mock import MagicMock, Mock
+
+import pytest
+
+from utrans import etl_common
+from utrans.etl_mappers import _fits_field_length
+
+
+def _field(name, field_type="String", length=None):
+    return SimpleNamespace(name=name, type=field_type, length=length, domain=None)
+
+
+def _update_cursor(rows):
+    cursor = MagicMock()
+    cursor.__enter__.return_value = cursor
+    cursor.__exit__.return_value = False
+    cursor.__iter__.return_value = iter(rows)
+    return cursor
+
+
+def test_add_missing_template_fields_reports_failed_field(monkeypatch):
+    source_fields = []
+    target_fields = [_field("ROAD_NAME", length=5)]
+    add_field = Mock(side_effect=etl_common.arcpy.ExecuteError("invalid length"))
+    monkeypatch.setattr(
+        etl_common.arcpy,
+        "ListFields",
+        Mock(side_effect=[source_fields, target_fields]),
+    )
+    monkeypatch.setattr(etl_common.arcpy.management, "AddField", add_field)
+
+    with pytest.raises(
+        RuntimeError, match=r"ROAD_NAME.*String.*length=5.*invalid length"
+    ):
+        etl_common.add_missing_template_fields("source", "target")
+
+    add_field.assert_called_once_with("source", "ROAD_NAME", "String", field_length=5)
+
+
+def test_normalize_target_fields_reports_overlong_values(monkeypatch):
+    source_fields = [_field("ONEWAY", length=2)]
+    target_fields = [_field("ONEWAY", length=1)]
+    cursor = _update_cursor([["FT"]])
+    update_cursor = Mock(return_value=cursor)
+    monkeypatch.setattr(
+        etl_common.arcpy,
+        "ListFields",
+        Mock(side_effect=[source_fields, target_fields]),
+    )
+    monkeypatch.setattr(etl_common.arcpy.da, "UpdateCursor", update_cursor)
+
+    with pytest.raises(RuntimeError, match=r"ONEWAY.*'FT'"):
+        etl_common.normalize_target_fields("source", "target")
+
+
+@pytest.mark.parametrize(
+    ("value", "length", "expected"),
+    [("F", 1, True), ("FT", 1, False), ("FT", 2, True)],
+)
+def test_fits_field_length(value, length, expected):
+    assert _fits_field_length(value, {"ONEWAY": length}, "oneway") is expected
diff --git a/cli/tests/test_etl_mappers.py b/cli/tests/test_etl_mappers.py
new file mode 100644
index 0000000..8fe2a57
--- /dev/null
+++ b/cli/tests/test_etl_mappers.py
@@ -0,0 +1,225 @@
+import pytest
+
+from utrans.etl_handlers import HANDLERS, profile_handler
+from utrans.etl_mappers import _validate_value_mappings, _value_mappings
+from utrans.etl_rules import apply_rules, profile_rules
+from utrans.profiles import CountyProfile
+
+
+def test_value_mappings_normalizes_fields_and_source_values():
+    profile = CountyProfile(
+        key="example",
+        values={
+            "value_mappings": {
+                "oneway": {" One Direction ": "Y"},
+            }
+        },
+    )
+
+    assert _value_mappings(profile) == {"ONEWAY": {"ONE DIRECTION": "Y"}}
+
+
+@pytest.mark.parametrize(
+    "value, message",
+    [
+        ([], "must be an object"),
+        ({"ONEWAY": []}, "map field names to objects"),
+        ({"ONEWAY": {"ONE DIRECTION": 1}}, "must map strings to strings"),
+    ],
+)
+def test_value_mappings_reject_invalid_configuration(value, message):
+    profile = CountyProfile(key="example", values={"value_mappings": value})
+
+    with pytest.raises(TypeError, match=message):
+        _value_mappings(profile)
+
+
+def test_value_mappings_validate_targets_and_domain_values():
+    profile = CountyProfile(key="example", values={})
+
+    with pytest.raises(ValueError, match="unknown target field"):
+        _validate_value_mappings(profile, {"ONEWAY": {}}, {}, {})
+
+    with pytest.raises(ValueError, match="outside the target domain"):
+        _validate_value_mappings(
+            profile,
+            {"ONEWAY": {"ONE DIRECTION": "MAYBE"}},
+            {"ONEWAY": "ONEWAY"},
+            {"ONEWAY": {"Y": "Y", "YES": "Y"}},
+        )
+
+
+def test_rules_apply_legacy_name_cleanup():
+    row: list[object] = ["1200", "RD", "N"]
+    indexes = {"NAME": 0, "POSTTYPE": 1, "POSTDIR": 2}
+
+    apply_rules(row, indexes, ["remove_posttype_if_numeric"])
+
+    assert row == ["1200", "", "N"]
+
+
+def test_rules_reject_unknown_and_duplicate_names():
+    profile = CountyProfile(key="example", values={"rules": ["unknown"]})
+
+    with pytest.raises(ValueError, match="unsupported"):
+        profile_rules(profile)
+
+    profile = CountyProfile(
+        key="example", values={"rules": ["remove_posttype_if_numeric"] * 2}
+    )
+    with pytest.raises(ValueError, match="duplicates"):
+        profile_rules(profile)
+
+
+def test_profile_handler_uses_closed_registry():
+    profile = CountyProfile(key="utah", values={"custom_handler": "utah_road_names"})
+
+    assert profile_handler(profile) is HANDLERS["utah_road_names"]
+
+    profile = CountyProfile(key="example", values={"custom_handler": "os.system"})
+    with pytest.raises(ValueError, match="unsupported custom_handler"):
+        profile_handler(profile)
+
+
+def test_handlers_declare_cursor_target_fields():
+    assert "AN_NAME" in HANDLERS["utah_road_names"].target_fields
+
+
+def test_utah_handler_parses_numeric_primary_and_alias_names():
+    row: list[object] = [
+        "1200 NORTH",
+        "300 WEST",
+        "DR",
+        "500 SOUTH",
+        "",
+        "",
+        "",
+        "RD",
+        "",
+        "",
+        "",
+        "",
+    ]
+    indexes = {
+        "ROADNAME": 0,
+        "ALTROADNAME": 1,
+        "ALTROADTYPE": 2,
+        "ALTROADNAME2": 3,
+        "NAME": 4,
+        "POSTDIR": 5,
+        "A1_NAME": 6,
+        "A1_POSTTYPE": 7,
+        "A2_NAME": 8,
+        "AN_NAME": 9,
+        "AN_POSTDIR": 10,
+        "POSTTYPE": 11,
+    }
+
+    HANDLERS["utah_road_names"].apply(
+        row,
+        indexes,
+        {"A1_POSTTYPE": {"DR": "DR"}},
+    )
+
+    assert row[4:6] == ["1200", "N"]
+    assert row[6:9] == ["", "", ""]
+    assert row[9:11] == ["300", "W"]
+    assert row[11] == ""
+
+
+def test_davis_handler_parses_alpha_and_numeric_aliases():
+    row: list[object] = ["Main WY", "", "", "", ""]
+    indexes = {
+        "ROADALIASNAME": 0,
+        "A1_NAME": 1,
+        "A1_POSTTYPE": 2,
+        "AN_NAME": 3,
+        "AN_POSTDIR": 4,
+    }
+    handler = HANDLERS["davis_alias"]
+
+    handler.apply(row, indexes, {"A1_POSTTYPE": {"WAY": "WAY"}})
+
+    assert row[1:3] == ["Main", "WAY"]
+
+    row[0] = "1200 N"
+    handler.apply(row, indexes, {})
+
+    assert row[3:5] == ["1200", "N"]
+
+
+def test_washington_handler_prefers_suffix_direction_and_deduplicates_aliases():
+    row: list[object] = ["NORTH", "WEST", "1200", "1200 W", "", "", "", "", ""]
+    indexes = {
+        "POSTDIR_": 0,
+        "SUFFIXDIR": 1,
+        "AN_NAME": 2,
+        "A1_NAME": 3,
+        "A1_PREDIR": 4,
+        "A1_POSTTYPE": 5,
+        "A1_POSTDIR": 6,
+        "POSTDIR": 7,
+        "A2_NAME": 8,
+    }
+
+    HANDLERS["washington_postdir_and_aliases"].apply(row, indexes, {})
+
+    assert row[3:7] == ["", "", "", ""]
+    assert row[7] == "W"
+
+
+def test_weber_handler_uses_acs_alias_for_numeric_aliases():
+    row: list[object] = ["1200", "1200 W", "MAIN", "S", "", "", "", ""]
+    indexes = {
+        "ALIAS": 0,
+        "ACS_ALIAS": 1,
+        "S_NAME": 2,
+        "SUFDIR": 3,
+        "A1_NAME": 4,
+        "A1_POSTTYPE": 5,
+        "AN_NAME": 6,
+        "AN_POSTDIR": 7,
+    }
+
+    HANDLERS["weber_alias"].apply(row, indexes, {})
+
+    assert row[6:8] == ["1200", "W"]
+
+
+def test_remaining_handlers_apply_verified_legacy_conditions():
+    summit_row: list[object] = ["US", "89", "ALT 89", "", "", "", "", ""]
+    summit_indexes = {
+        "PRE_TYPE": 0,
+        "NAME": 1,
+        "OTHER_NAME": 2,
+        "STREET": 1,
+        "A1_PREDIR": 3,
+        "A1_NAME": 4,
+        "A1_POSTTYPE": 5,
+        "A1_POSTDIR": 6,
+        "AN_NAME": 7,
+    }
+    HANDLERS["summit_names"].apply(summit_row, summit_indexes, {})
+    assert summit_row[1] == "US 89"
+
+    emery_row: list[object] = ["100N", "", "", "", ""]
+    emery_indexes = {
+        "ACS_ALIAS": 0,
+        "ALIAS1": 1,
+        "ALIAS2": 2,
+        "AN_NAME": 3,
+        "AN_POSTDIR": 4,
+    }
+    HANDLERS["emery_compact_aliases"].apply(emery_row, emery_indexes, {})
+    assert emery_row[3:5] == ["100", "N"]
+
+    kane_row: list[object] = ["K7000", "RD", "", "", ""]
+    kane_indexes = {
+        "A1_NAME": 0,
+        "A1_POSTTYPE": 1,
+        "A1_PREDIR": 2,
+        "A1_POSTDIR": 3,
+        "A2_NAME": 4,
+    }
+    HANDLERS["kane_alias_cleanup"].apply(kane_row, kane_indexes, {})
+    assert kane_row[:2] == ["", ""]