add symlink to web docs

update pipeline results viewer
Run pipeling, update sqllite file
2026-07-16 17:47:22 +00:00 · 2026-06-27 23:34:30 -04:00 · 2026-06-27 23:32:08 -04:00 · 2026-06-27 22:40:22 -04:00 · 2026-06-27 15:16:34 -04:00 · 2026-06-23 22:02:17 -04:00
48 changed files with 486 additions and 948 deletions
--- a/docs/pipeline/ETHICS-AND-KNOWN-ISSUES.md
+++ b/docs/pipeline/ETHICS-AND-KNOWN-ISSUES.md
@@ -111,11 +111,11 @@ persona/bio generation later.
 The full multinational dataset is kept as-is (106 countries for forenames,
 75 for surnames) rather than trimmed to `locations.json`'s current country
 list, so it doesn't need re-sourcing if more countries are added later.
-`SampleName()` (a free helper in `generate_users.cc`) returns no result for
-a country present in neither file; of the countries in `locations.json`,
-that's currently `KE`, `SE`, `SG`, `TH`, `VN`, and `ZA` — `GenerateUsers`
-skips cities in those countries the same way brewery generation skips
-cities whose enrichment lookup fails.
+`NamesByCountry::SampleName()` returns no result for a country present in
+neither file; of the countries in `locations.json`, that's currently `KE`,
+`SE`, `SG`, `TH`, `VN`, and `ZA` — `GenerateUsers` skips cities in those
+countries the same way brewery generation skips cities whose enrichment
+lookup fails.

 ---

--- a/docs/pipeline/README.md
+++ b/docs/pipeline/README.md
@@ -1,9 +1,8 @@
 # Biergarten Pipeline

 A C++20 command-line pipeline that samples city records from local JSON,
-enriches each with Wikipedia context, and generates bilingual brewery names
-and descriptions plus locale-grounded user profiles via a local GGUF model or
-a deterministic mock.
+enriches each with Wikipedia context, and generates bilingual brewery names and
+descriptions via a local GGUF model or a deterministic mock.

 > **This pipeline produces AI-generated data.** It is not a source of truth for
 > brewing techniques, cultural representation, or local-language accuracy. See
@@ -46,7 +45,6 @@ step.
 | Beer reviews and ratings         | Stable brewery fixtures with enough context to anchor review pages |
 | Social follow relationships      | Repeatable brewery entities for feeds, follows, and saved lists    |
 | Geospatial brewery experiences   | Latitude, longitude, and country-level metadata                    |
-| User accounts and profiles       | Locale-grounded names, bios, and an auth-ready email/date-of-birth pair for seeding real accounts |

 ---

@@ -220,46 +218,35 @@ environment variables listed above to match your run.

 ### Pipeline Stages

-| Stage           | Implementation                                                                                                                          |
-| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
-| Load            | `ICuratedDataService` (`CuratedJsonDataService`) reads `locations.json`, `personas.json`, `forenames-by-country.json`, and `surnames-by-country.json` (paths supplied via a `CuratedDataFilePaths` DTO at construction) into typed records, caching each after its first load. `--mocked` runs use `MockCuratedDataService`'s fixed in-memory dataset instead. |
-| Sample          | `BiergartenPipelineOrchestrator::QueryCitiesWithCountries()` samples `--location-count` locations per run (default `10`).               |
-| Enrich          | `WikipediaEnrichmentService` fetches brewing and beer-related context. Keeps going when a lookup fails. `--mocked` runs use `MockEnrichmentService` instead and skip Wikipedia entirely. |
-| Generate Users  | `GenerateUsers()` samples a persona and a forename/surname pair per enriched city (skipping countries with no name data), then `MockGenerator` or `LlamaGenerator` produces a username, bio, and activity weight around the sampled name. |
-| Generate Breweries | `MockGenerator` or `LlamaGenerator` produces brewery names and descriptions in English and the local language.                       |
-| Store           | `SqliteExportService` writes each successful user and brewery into a fresh dated `.sqlite` database with normalized `locations`, `users`, and `breweries` tables. |
-| Log             | `spdlog` writes results and warnings to the console.                                                                                    |
+| Stage    | Implementation                                                                                                                          |
+| -------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| Load     | `JsonLoader::LoadLocations()` reads `locations.json` into typed `Location` records.                                                     |
+| Sample   | `BiergartenPipelineOrchestrator::QueryCitiesWithCountries()` samples `--location-count` locations per run (default `10`).               |
+| Enrich   | `WikipediaEnrichmentService` fetches brewing and beer-related context. Keeps going when a lookup fails. `--mocked` runs use `MockEnrichmentService` instead and skip Wikipedia entirely. |
+| Generate | `MockGenerator` or `LlamaGenerator` produces brewery names and descriptions in English and the local language.                          |
+| Store    | `SqliteExportService` writes each successful brewery into a fresh dated `.sqlite` database with normalized location and brewery tables. |
+| Log      | `spdlog` writes results and warnings to the console.                                                                                    |

-If name sampling, enrichment, or generation fails for a city, that city is
-skipped and the pipeline continues. `GenerateUsers()` runs before
-`GenerateBreweries()` in `BiergartenPipelineOrchestrator::Run()`.
+If enrichment or generation fails for a city, that city is skipped and the
+pipeline continues.

 ### Key Components

 - `src/main.cc` — argument parsing and Boost.DI composition root.
- `CuratedJsonDataService` — implements `ICuratedDataService`; takes a
-  `CuratedDataFilePaths` DTO (locations/personas/forenames/surnames paths) in
-  its constructor, then parses and validates curated location, persona, and
-  forename/surname JSON, memoizing each result after its first load on a
-  given instance. `MockCuratedDataService` is the in-memory substitute (4
-  fixed locations, 3 personas, and name data for `US`/`DE`/`FR`/`BE`) used in
-  `--mocked` runs.
+- `JsonLoader` — validates curated location input.
 - `WikipediaEnrichmentService` — queries Wikipedia extracts, caches results,
  returns empty context on failure. `MockEnrichmentService` is the no-op
  substitute used in `--mocked` runs.
- `LlamaGenerator` — formats prompts for Gemma 4, validates JSON output for
-  both `GenerateBrewery` and `GenerateUser`, retries malformed responses up
-  to three times with corrective feedback in the retry prompt. The token
-  budget is fixed across attempts; it is not raised automatically on
-  truncation.
- `MockGenerator` — stable hash-based output so the same city/persona/name
-  input always produces the same brewery or user.
- `SqliteExportService` — creates a dated SQLite file per run and persists
-  each successful user and brewery into normalized tables.
+- `LlamaGenerator` — formats prompts for Gemma 4, validates JSON output, retries
+  malformed responses up to three times with corrective feedback in the
+  retry prompt. The token budget is fixed across attempts; it is not raised
+  automatically on truncation.
+- `MockGenerator` — stable hash-based output so the same city input always
+  produces the same brewery.
+- `SqliteExportService` — creates a dated SQLite file per run and persists each
+  successful brewery into normalized tables.
 - Brewery payloads include English and local-language name and description
-  fields. User payloads carry a sampled first/last name and gender, an
-  LLM-generated username/bio/activity weight, and a programmatically
-  generated (not LLM-authored) unique email and date of birth.
+  fields.

 ### Runtime Behaviour

@@ -279,18 +266,6 @@ valid output on the first pass; the retry path is kept for resilience.
 `MockGenerator` uses stable hashes for repeatable output in demos and Storybook
 runs.

-`CuratedJsonDataService` memoizes each of `LoadLocations()`, `LoadPersonas()`,
-`LoadForenamesByCountry()`, and `LoadSurnamesByCountry()` independently the
-first time each is called, since `BiergartenPipelineOrchestrator` owns a
-single `ICuratedDataService` instance for the whole run — later calls return
-the cached result instead of re-parsing. 
-
-`GenerateUsers()` samples a forename/surname pair per city via `SampleName()`,
-keyed by the city's ISO 3166-1 code. Countries present in `locations.json`
-but absent from either name fixture (currently `KE`, `SE`, `SG`, `TH`, `VN`,
-`ZA`) are skipped, the same way a failed enrichment or generation call skips
-a city — see ETHICS-AND-KNOWN-ISSUES.md's Names-by-Country Dataset section.
-
 ### Process Flow - Activity Diagram

 ![An activity diagram](./diagrams/current/output/activity.svg)
@@ -303,10 +278,9 @@ a city — see ETHICS-AND-KNOWN-ISSUES.md's Names-by-Country Dataset section.

 ## Generated Output

-Each successful run stores a `BreweryRecord` pair with the source location
-and a `BreweryResult` payload, and a `UserRecord` pair with the source
-location and a `UserResult` payload. The same generated records are also
-written to a fresh SQLite export file named with the current UTC timestamp.
+Each successful run stores a `GeneratedBrewery` pair with the source location
+and a `BreweryResult` payload. The same generated records are also written to a
+fresh SQLite export file named with the current UTC timestamp.

 | Field               | Meaning                                    |
 | ------------------- | ------------------------------------------ |
@@ -315,17 +289,6 @@ written to a fresh SQLite export file named with the current UTC timestamp.
 | `name_local`        | Brewery name in the local language.        |
 | `description_local` | Brewery description in the local language. |

-| Field             | Meaning                                                          |
-| ----------------- | ----------------------------------------------------------------- |
-| `first_name`      | Sampled forename, copied from the curated name data (not LLM-invented). |
-| `last_name`       | Sampled surname, copied from the curated name data (not LLM-invented).  |
-| `gender`          | Gender associated with the sampled forename in the source dataset. |
-| `username`        | LLM-generated handle.                                            |
-| `bio`             | LLM-generated short biography.                                   |
-| `activity_weight` | Relative check-in/activity weight, reserved for a future J-curve activity profile. |
-| `email`           | Unique `@thebiergarten.app` address, generated programmatically from the sampled name. |
-| `date_of_birth`   | Randomized date of birth (age 19-48), generated programmatically. |
-
 The log dump also includes city, country, state or province, ISO subdivision
 code, latitude, and longitude for each entry.

@@ -404,17 +367,11 @@ Silicon; CUDA or HIP/ROCm is detected on Linux when the toolkit is present.
 ## Fixture Strategy

 - `--mocked` for stable fixtures, repeatable screenshots, and Storybook runs.
-  `MockCuratedDataService` swaps in for `CuratedJsonDataService`, so no
-  fixture files need to be present on disk.
 - `--model` when geographically grounded content matters for demos.
 - Keep `locations.json` structured enough to support discovery and future
  filtering.
- `personas.json`, `forenames-by-country.json`, and
-  `surnames-by-country.json` are curated/vendored fixture data, not
-  LLM-generated — see ETHICS-AND-KNOWN-ISSUES.md's Names-by-Country Dataset
-  section for provenance.
- Treat SQLite output as seed material for the app's brewery and user
-  domains, not production data.
+- Treat SQLite output as seed material for the app's brewery domain, not
+  production data.

 ---

@@ -425,9 +382,6 @@ Silicon; CUDA or HIP/ROCm is detected on Linux when the toolkit is present.
 | `tooling/pipeline/includes/`           | Public headers and shared models.                  |
 | `tooling/pipeline/src/`                | Implementation files.                              |
 | `tooling/pipeline/locations.json`      | Curated city input copied into the build tree.     |
-| `tooling/pipeline/personas.json`       | Curated user persona archetypes copied into the build tree. |
-| `tooling/pipeline/forenames-by-country.json` | Vendored (CC0) forename data by ISO 3166-1 country code. |
-| `tooling/pipeline/surnames-by-country.json`  | Vendored (CC0) surname data by ISO 3166-1 country code. |
 | `tooling/pipeline/prompts/`            | System prompts used by the model-backed path.      |
 | `tooling/pipeline/runpod/`             | Dockerfile, launcher, and RunPod pod template.      |
 | `docs/pipeline/diagrams/`              | Architecture and pipeline diagrams.                |
@@ -442,9 +396,6 @@ Paths below are relative to `tooling/pipeline/`.
 - `src/main.cc` — argument parsing and DI composition root.
 - `src/biergarten_pipeline_orchestrator/` — orchestration, sampling, logging,
  and export.
- `src/services/curated_data/` — `CuratedJsonDataService`, the file-backed
-  `ICuratedDataService`, and `MockCuratedDataService`, the in-memory
-  `ICuratedDataService` used in `--mocked` runs.
 - `src/services/enrichment/wikipedia/` — enrichment service and cache.
 - `src/services/sqlite/` — SQLite export implementation.
 - `src/data_generation/llama/` — local inference, prompt loading, output
@@ -456,12 +407,11 @@ Paths below are relative to `tooling/pipeline/`.

 ## Next Steps

-The pipeline currently produces city-aware brewery and user records and
-dated SQLite exports. The next passes add additional fixture types so the
-app can exercise the full brewery and social domains without live data. For
-the detailed engineering breakdown of what's needed to reach the
-architecture in [`diagrams/planned/`](./diagrams/planned/), see
-[ROADMAP.md](./ROADMAP.md).
+The pipeline currently produces city-aware brewery records and dated SQLite
+exports. The next passes add additional fixture types so the app can exercise
+the full brewery domain without live data. For the detailed engineering
+breakdown of what's needed to reach the architecture in
+[`diagrams/planned/`](./diagrams/planned/), see [ROADMAP.md](./ROADMAP.md).

 ### Testing — Very High Priority

@@ -483,6 +433,12 @@ Generate catalog entries with style, ABV, IBU, color, aroma notes, and food
 pairing hints. Link beers back to breweries and cities. Keep style coverage wide
 enough to exercise search, sort, and category filters.

+### User Generation
+
+Generate user profiles with stable names, bios, locale hints, and preference
+signals. Include stable IDs for downstream fixture joins. Keep output
+deterministic for screenshots while allowing larger randomized batches.
+
 ### Check-In System

 Produce timestamped check-in events between users and breweries. Use a J-curve
--- a/docs/pipeline/ROADMAP.md
+++ b/docs/pipeline/ROADMAP.md
@@ -39,80 +39,47 @@ architecture needs.
      not LLM-invented.
 - [x] Add `Name` (`first_name`, `last_name`, `gender`) — the sampled result
      handed to `DataGenerator::GenerateUser`. Add `ForenameEntry` (`name`,
-      `gender`). Landed as a flatter shape than originally planned here: no
-      `NamesByCountry` wrapper class. `curated_data_service.h` instead
-      declares `ForenameList = std::vector<ForenameEntry>` and
-      `SurnameList = std::vector<std::string>`, and
-      `ICuratedDataService` exposes two maps keyed by ISO 3166-1 code —
-      `ForenamesByCountryMap = unordered_map<string, ForenameList>` and
-      `SurnamesByCountryMap = unordered_map<string, SurnameList>` —
-      directly (see §2). Sampling is
-      a free function, `SampleName(forenames_by_country,
-      surnames_by_country, iso3166_1, rng)`, in
-      `generate_users.cc`'s anonymous namespace, not a method on a class.
+      `gender`) and a `NamesByCountry` class (not a bare typedef) that owns
+      two maps — `std::unordered_map<std::string, std::vector<ForenameEntry>>`
+      and `std::unordered_map<std::string, std::vector<std::string>>`, both
+      keyed by ISO 3166-1 code — and exposes `SampleName(iso3166_1, rng)`.
      Pairing a forename with a surname happens at sample time so gender
      (present per-forename in the source data) is never discarded the way a
-      pre-flattened `{first_name, last_name}` list would lose it; see §2.
+      pre-flattened `{first_name, last_name}` list would lose it; see
+      `LoadNamesByCountry()` below.
 - [ ] Extend `GeneratedBrewery` with `brewery_id`, `context_completeness`,
      `metadata` (currently just `{location, brewery}`).
 - [ ] Add `GeneratedBeer`, `GeneratedCheckin`, `GeneratedRating`,
      `GeneratedFollow` aggregate structs.
- [x] Add `UserRecord` (`location`, `user : UserResult`, `email`,
-      `date_of_birth`) as the current stand-in for the planned
-      `GeneratedUser` — `email` and `date_of_birth` are programmatically
-      generated by the orchestrator, never LLM-authored, so a downstream
-      auth-account seeding consumer can register real accounts from the
-      pipeline's SQLite export. No `password`, `user_id`, or `metadata`
-      field yet, matching `BreweryRecord`'s equally pre-`metadata` shape.
-      Already wired into `IExportService`/`SqliteExportService`: a `users`
-      table exists and `GenerateUsers()` exports each successful record via
-      `ProcessRecord(const UserRecord&)` (see §5) in addition to logging and
-      holding `generated_users_` in memory. Still missing vs. the planned
-      `GeneratedUser`: `user_id`, `password`, and `metadata`.
+- [x] Add `GeneratedUser` aggregate struct. Carries `email`, `date_of_birth`,
+      and `password` — programmatically generated by the orchestrator, never
+      LLM-authored — so a downstream auth-account seeding consumer (outside
+      this repo tree's docs) can register real accounts from the pipeline's
+      SQLite export. Skips `user_id`/`metadata` for now, matching
+      `GeneratedBrewery`'s current (pre-`brewery_id`/`metadata`) shape. Not
+      yet wired into `IExportService`/`SqliteExportService` — `GenerateUsers`
+      currently only logs and holds `generated_users_` in memory; no `users`
+      table exists in the SQLite export yet (see §5).
 - [x] Add `UserPersona` (`name`, `description`, `style_affinities`).

 ## 2. Data Preloading

-`tooling/pipeline/includes/services/curated_data/`, fixture files.
+`tooling/pipeline/includes/json_handling/`, fixture files.

- [x] Extract an interface; have `CuratedJsonDataService` implement it.
-      Landed as `ICuratedDataService`
-      (`services/curated_data/curated_data_service.h`), not `DataPreloader`
-      — `LoadLocations()`, `LoadPersonas()`, `LoadForenamesByCountry()`, and
-      `LoadSurnamesByCountry()` are all virtual methods returning `const&`
-      and take no arguments. `CuratedJsonDataService`
-      (`services/curated_data/curated_json_data_service.h`, originally
-      landed as `JsonLoader` under `json_handling/` before being renamed and
-      moved) takes a `CuratedDataFilePaths` DTO (`locations_path`,
-      `personas_path`, `forenames_path`, `surnames_path`) in its
-      constructor rather than a path per `Load*()` call, and memoizes each
-      result in a private `cache` struct (`locations`, `personas`,
-      `forenames_by_country`, `surnames_by_country`), so a second call on
-      the same instance returns the cached result instead of re-parsing —
-      safe because `CuratedJsonDataService` outlives every call site (owned
-      by `BiergartenPipelineOrchestrator` via
-      `unique_ptr<ICuratedDataService>` for the whole run). `main.cc`'s DI
-      injector also gained a `MockCuratedDataService` (fixed in-memory
-      data: 4 locations across `US`/`DE`/`FR`/`BE`, 3 personas, and
-      matching forename/surname sets for those four countries), bound in
-      place of `CuratedJsonDataService` under `--mocked`, mirroring the
-      existing `MockEnrichmentService`/`MockGenerator` pattern.
+- [ ] Extract a `DataPreloader` interface; have `JsonLoader` implement it.
+      `JsonLoader` now also exposes static `LoadPersonas()` and
+      `LoadNamesByCountry()` (see below), but as additional static methods,
+      not yet behind a formal interface.
 - [ ] Add `LoadBeerStyles()`. `beer-styles.json` already exists in the repo
      and is already copied into the Docker image
      (`runpod/Dockerfile`), but no loader reads it yet, and the native
      CMake build doesn't copy it into `build/` at all — `CMakeLists.txt`'s
      "Runtime Assets" step only copies `locations.json` and `prompts/`.
 - [x] Add `LoadPersonas()` and author `personas.json` (doesn't exist yet).
- [x] Add name-by-country loading, parsing
-      `tooling/pipeline/forenames-by-country.json` and
-      `surnames-by-country.json`. Landed as two separate methods —
-      `LoadForenamesByCountry()` and `LoadSurnamesByCountry()` — each
-      returning a flat `ForenamesByCountryMap` / `SurnamesByCountryMap`
-      (aliases for `unordered_map<string, ForenameList>` /
-      `unordered_map<string, SurnameList>`) keyed by ISO 3166-1 code, rather
-      than one combined `LoadNamesByCountry() : NamesByCountry` call. Both
-      files are vendored verbatim (unmodified,
-      full multinational coverage) from
+- [x] Add `LoadNamesByCountry(forenames_filepath, surnames_filepath)`,
+      parsing `tooling/pipeline/forenames-by-country.json` and
+      `surnames-by-country.json` into a `NamesByCountry`. Both files are
+      vendored verbatim (unmodified, full multinational coverage) from
      `sigpwned/popular-names-by-country-dataset` (CC0) — see
      ETHICS-AND-KNOWN-ISSUES.md's Names-by-Country Dataset section for
      provenance. Deliberately not pre-paired or filtered down to just the
@@ -169,19 +136,12 @@ Entirely new — no `includes/policy/` (or equivalent) directory exists today.

 `tooling/pipeline/includes/services/database/`, `src/services/sqlite/`.

- [x] `IExportService::ProcessRecord(const UserRecord&)` and
-      `SqliteExportService`'s `users` table (see
-      `kCreateUsersTableSql` / `kInsertUserSql` in
-      `includes/services/database/sqlite_statement_helpers.h`) are
-      implemented — `GenerateUsers()` exports every successful user
-      alongside its resolved `location_id`.
- [ ] Extend `IExportService` with `ProcessBeer`, `ProcessCheckin`,
-      `ProcessRating`, `ProcessFollow` (today `ProcessRecord(const
-      BreweryRecord&)` and `ProcessRecord(const UserRecord&)` exist).
- [ ] Add `beers`, `checkins`, `ratings`, `follows` tables to
-      `SqliteExportService::InitializeSchema()` (`locations`, `breweries`,
-      and `users` already exist) — see `kCreateLocationsTableSql` /
-      `kCreateBreweriesTableSql` / `kCreateUsersTableSql` in
+- [ ] Extend `IExportService` with `ProcessBeer`, `ProcessUser`,
+      `ProcessCheckin`, `ProcessRating`, `ProcessFollow` (today only
+      `ProcessRecord(const GeneratedBrewery&)` exists).
+- [ ] Add `beers`, `users`, `checkins`, `ratings`, `follows` tables to
+      `SqliteExportService::InitializeSchema()` — see
+      `kCreateLocationsTableSql` / `kCreateBreweriesTableSql` in
      `includes/services/database/sqlite_statement_helpers.h` for the
      existing pattern to follow.
 - [ ] Add a `brewery_cache_` alongside the existing `location_cache_`, and
@@ -227,8 +187,7 @@ Entirely new — no `includes/policy/` (or equivalent) directory exists today.

 ## 8. Fixtures / Build

- [x] Author `personas.json`, `forenames-by-country.json`, and
-      `surnames-by-country.json` (see §2).
+- [ ] Author `personas.json` and `names-by-country.json` (see §2).
 - [ ] Fix the `beer-styles.json` build-tree gap: add it to the "Runtime
      Assets" `configure_file` step in `CMakeLists.txt` so native builds and
      the Docker image agree on what's available at runtime.
--- a/docs/pipeline/diagrams/current/activity.puml
+++ b/docs/pipeline/diagrams/current/activity.puml
@@ -93,77 +93,6 @@ while (For each sampled Location?) is (Remaining cities)
  endif
 endwhile (Done)

-|#EAF0E8|BiergartenPipelineOrchestrator|
-:GenerateUsers(enriched_cities);
-
-|#E2EBDC|JsonLoader|
-:LoadPersonas("personas.json");
-:LoadForenamesByCountry("forenames-by-country.json");
-:LoadSurnamesByCountry("surnames-by-country.json");
-note right
-  Each call is cached after its first parse.
-  MockCuratedDataService (--mocked) returns a
-  fixed in-memory dataset instead and skips
-  these three JSON files entirely.
-end note
-
-|#EAF0E8|BiergartenPipelineOrchestrator|
-while (For each EnrichedCity?) is (Remaining cities)
-  :SampleName(forenames_by_country,\n  surnames_by_country, location.iso3166_1);
-  if (Names available for country?) then (no)
-    :Log warning, skip city;
-  else (yes)
-    :Sample UserPersona (uniform random);
-
-    |#E5EDE1|DataGenerator|
-    if (Generator Mode) then (MockGenerator)
-      :DeterministicHash & Format;
-    else (LlamaGenerator)
-      :prompt_directory_->Load("USER_GENERATION");
-      note right
-        Resolves to USER_GENERATION.md inside --prompt-dir.
-      end note
-      repeat
-        :Infer(system_prompt, user_prompt, max_tokens, kUserJsonGrammar);
-        :ValidateUserJson(raw, user);
-        if (Is JSON Valid?) then (yes)
-          break
-        else (no)
-          :Attempt++;
-          :Append validation error to retry prompt;
-        endif
-      repeat while (Attempt < 3?) is (yes)
-    endif
-
-    |#EAF0E8|BiergartenPipelineOrchestrator|
-    if (Generation successful?) then (yes)
-      :BuildEmail(name, used_email_local_parts);
-      :GenerateDateOfBirth(rng);
-      note right
-        email and date_of_birth are generated
-        programmatically, never LLM-authored.
-      end note
-
-      |#E0EAE0|SqliteExportService|
-      :ProcessRecord(UserRecord);
-      if (Location in cache?) then (yes)
-        :Reuse location_id;
-      else (no)
-        :Insert Location & Cache ID;
-      endif
-      :Insert User (FK: location_id);
-
-      if (Exception caught during insert?) then (yes)
-        |#EAF0E8|BiergartenPipelineOrchestrator|
-        :Log warning "SQLite export failed";
-      else (no)
-      endif
-    else (no)
-      :Log warning "Generation failed, skipping...";
-    endif
-  endif
-endwhile (Done)
-
 |#EAF0E8|BiergartenPipelineOrchestrator|
 :GenerateBreweries(enriched_cities);

--- a/docs/pipeline/diagrams/current/class.puml
+++ b/docs/pipeline/diagrams/current/class.puml
@@ -30,14 +30,11 @@ class BiergartenPipelineOrchestrator {
  - context_service_ : std::unique_ptr<IEnrichmentService>
  - generator_ : std::unique_ptr<DataGenerator>
  - exporter_ : std::unique_ptr<IExportService>
-  - curated_data_service_ : std::unique_ptr<ICuratedDataService>
  - application_options_ : ApplicationOptions
-  - generated_breweries_ : std::vector<BreweryRecord>
-  - generated_users_ : std::vector<UserRecord>
+  - generated_breweries_ : std::vector<GeneratedBrewery>
  + Run() : bool
  - QueryCitiesWithCountries() : std::vector<Location>
  - GenerateBreweries(cities : std::span<const EnrichedCity>) : void
-  - GenerateUsers(cities : std::span<const EnrichedCity>) : void
  - LogResults() : void
 }

@@ -116,14 +113,13 @@ class HttpWebClient {

 interface DataGenerator <<interface>> {
  + GenerateBrewery(location : const Location&, region_context : const std::string&) : BreweryResult
-  + GenerateUser(city : const EnrichedCity&, persona : const UserPersona&, name : const Name&) : UserResult
+  + GenerateUser(locale : const std::string&) : UserResult
 }

 class MockGenerator {
-  + GenerateBrewery(location : const Location&, region_context : const std::string&) : BreweryResult
-  + GenerateUser(city : const EnrichedCity&, persona : const UserPersona&, name : const Name&) : UserResult
+  + GenerateBrewery(...) : BreweryResult
+  + GenerateUser(...) : UserResult
  - DeterministicHash(location : const Location&) : size_t
-  - DeterministicHash(location : const Location&, persona : const UserPersona&, name : const Name&) : size_t
 }

 class LlamaGenerator {
@@ -157,49 +153,13 @@ class PromptDirectory {
  + Load(key : std::string_view) : std::string
 }

-interface ICuratedDataService <<interface>> {
-  + LoadLocations(filepath : const std::filesystem::path&) : const std::vector<Location>&
-  + LoadPersonas(filepath : const std::filesystem::path&) : const std::vector<UserPersona>&
-  + LoadForenamesByCountry(filepath : const std::filesystem::path&) : const std::unordered_map<std::string, forename_list>&
-  + LoadSurnamesByCountry(filepath : const std::filesystem::path&) : const std::unordered_map<std::string, surname_list>&
-}
-
 class JsonLoader {
-  - cache_ : cache
-  + LoadLocations(filepath : const std::filesystem::path&) : const std::vector<Location>&
-  + LoadPersonas(filepath : const std::filesystem::path&) : const std::vector<UserPersona>&
-  + LoadForenamesByCountry(filepath : const std::filesystem::path&) : const std::unordered_map<std::string, forename_list>&
-  + LoadSurnamesByCountry(filepath : const std::filesystem::path&) : const std::unordered_map<std::string, surname_list>&
+  + {static} LoadLocations(filepath : const std::filesystem::path&) : std::vector<Location>
 }

-note right of JsonLoader
-  Each Load* method memoizes its result in
-  cache_ on first call; later calls on the
-  same instance return the cached value
-  without re-parsing.
-end note
-
-class MockCuratedDataService {
-  - locations_ : std::vector<Location>
-  - personas_ : std::vector<UserPersona>
-  - forenames_by_country_ : std::unordered_map<std::string, forename_list>
-  - surnames_by_country_ : std::unordered_map<std::string, surname_list>
-  + LoadLocations(filepath : const std::filesystem::path&) : const std::vector<Location>&
-  + LoadPersonas(filepath : const std::filesystem::path&) : const std::vector<UserPersona>&
-  + LoadForenamesByCountry(filepath : const std::filesystem::path&) : const std::unordered_map<std::string, forename_list>&
-  + LoadSurnamesByCountry(filepath : const std::filesystem::path&) : const std::unordered_map<std::string, surname_list>&
-}
-
-note right of MockCuratedDataService
-  Fixed 4-location / 3-persona dataset
-  (US, DE, FR, BE) used in --mocked runs;
-  filepath arguments are ignored.
-end note
-
 interface IExportService <<interface>> {
  + Initialize() : void
-  + ProcessRecord(brewery : const BreweryRecord&) : uint64_t
-  + ProcessRecord(user : const UserRecord&) : uint64_t
+  + ProcessRecord(brewery : const GeneratedBrewery&) : void
  + Finalize() : void
 }

@@ -207,18 +167,15 @@ class SqliteExportService {
  - date_time_provider_ : std::unique_ptr<IDateTimeProvider>
  - run_timestamp_utc_ : std::string
  - database_path_ : std::filesystem::path
-  - db_handle_ : SqliteDatabaseHandle
-  - insert_location_stmt_ : SqliteStatementHandle
-  - insert_brewery_stmt_ : SqliteStatementHandle
-  - insert_user_stmt_ : SqliteStatementHandle
+  - db_handle_ : sqlite3*
+  - insert_location_stmt_ : sqlite3_stmt*
+  - insert_brewery_stmt_ : sqlite3_stmt*
  - transaction_open_ : bool
  - location_cache_ : std::unordered_map<std::string, sqlite3_int64>
  + Initialize() : void
-  + ProcessRecord(brewery : const BreweryRecord&) : uint64_t
-  + ProcessRecord(user : const UserRecord&) : uint64_t
+  + ProcessRecord(brewery : const GeneratedBrewery&) : void
  + Finalize() : void
  - InitializeSchema() : void
-  - ResolveLocationId(location : const Location&) : sqlite3_int64
 }

 interface IDateTimeProvider <<interface>> {
@@ -234,7 +191,6 @@ BiergartenPipelineOrchestrator *-- ILogger : owns
 BiergartenPipelineOrchestrator *-- IEnrichmentService : owns
 BiergartenPipelineOrchestrator *-- DataGenerator : owns
 BiergartenPipelineOrchestrator *-- IExportService : owns
-BiergartenPipelineOrchestrator *-- ICuratedDataService : owns

 LogEntry *-- LogLevel
 LogEntry *-- PipelinePhase
@@ -259,8 +215,7 @@ LlamaGenerator *-- IPromptDirectory : uses
 IPromptFormatter <|.. Gemma4JinjaPromptFormatter : implements
 IPromptDirectory <|.. PromptDirectory : implements

-ICuratedDataService <|.. JsonLoader : implements
-ICuratedDataService <|.. MockCuratedDataService : implements
+BiergartenPipelineOrchestrator ..> JsonLoader : uses

 IExportService <|.. SqliteExportService : implements
 SqliteExportService *-- IDateTimeProvider : owns
--- a/docs/pipeline/diagrams/current/output/activity.svg
+++ b/docs/pipeline/diagrams/current/output/activity.svg
--- a/docs/pipeline/diagrams/current/output/class.svg
+++ b/docs/pipeline/diagrams/current/output/class.svg
--- a/docs/pipeline/diagrams/planned/activity.puml
+++ b/docs/pipeline/diagrams/planned/activity.puml
@@ -43,18 +43,10 @@ fork again
  :EnrichmentService::PreWarmLocationCache(sampled_locations);
 end fork
 fork
-  :JsonLoader::LoadForenamesByCountry(\n  "forenames-by-country.json");
-fork again
-  :JsonLoader::LoadSurnamesByCountry(\n  "surnames-by-country.json");
+  :JsonLoader::LoadNamesByCountry(\n  "forenames-by-country.json",\n  "surnames-by-country.json");
 fork again
  :JsonLoader::LoadPersonas("personas.json");
 end fork
-note right
-  Each call is memoized after its first parse
-  (implemented today). MockCuratedDataService
-  returns a fixed in-memory dataset instead
-  under --mocked, skipping these JSON files.
-end note

 ' ═══════════════════════════════════════════
 ' PHASE 0 — USER GENERATION
@@ -90,15 +82,11 @@ fork again
      ibu_preference, checkin_weight.
    end note

-    :SampleName(forenames_by_country,\n  surnames_by_country, location.iso3166_1, rng);
+    :NamesByCountry::SampleName(\n  location.iso3166_1);
    note right
      Deterministic lookup -- no LLM involved.
-      Free function (implemented today in
-      generate_users.cc), not a class method.
-      Name selected from pre-keyed maps
+      Name selected from pre-keyed table
      and passed into the generation prompt.
-      Skips the city if either map has no
-      entry for iso3166_1.
    end note

    :GenerateUser(enriched_city, persona, sampled_name)\nvia DataGenerator;
--- a/docs/pipeline/diagrams/planned/class.puml
+++ b/docs/pipeline/diagrams/planned/class.puml
@@ -86,30 +86,27 @@ package "Domain: Models" {
    + gender : std::string
  }

-  note right of ForenameEntry
-    forename_list = std::unordered_set<ForenameEntry>
-    surname_list = std::unordered_set<std::string>
-    (aliases declared in curated_data_service.h).
-    ICuratedDataService::LoadForenamesByCountry() /
-    LoadSurnamesByCountry() each return a flat
-    std::unordered_map<std::string, forename_list>
-    or <std::string, surname_list> keyed by ISO
-    3166-1 country code -- no NamesByCountry
-    wrapper class. SampleName(forenames_by_country,
-    surnames_by_country, iso3166_1, rng) is a free
-    function, not a method, so it can be called by
-    any per-city worker without owning the maps.
-    Sourced from popular-names-by-country-dataset
-    (CC0) -- see ETHICS-AND-KNOWN-ISSUES.md. Gender
-    is preserved per forename so it can be threaded
-    through to persona/bio generation later; surnames
-    carry no gender in the source data. Pairing
-    happens at sample time, not at fixture-authoring
-    time, so no information from the source dataset
-    is discarded up front.
+  class NamesByCountry {
+    - forenames_by_country_ : std::unordered_map<std::string, std::vector<ForenameEntry>>
+    - surnames_by_country_ : std::unordered_map<std::string, std::vector<std::string>>
+    + SampleName(iso3166_1 : const std::string&,\n  rng : std::mt19937&) : std::optional<Name>
+  }
+
+  note right of NamesByCountry
+    Backed by two source-shaped maps,
+    keyed by ISO 3166-1 country code,
+    sourced from popular-names-by-country-dataset
+    (CC0) -- see ETHICS-AND-KNOWN-ISSUES.md.
+    Gender is preserved per forename so it can
+    be threaded through to persona/bio generation
+    later; surnames carry no gender in the source
+    data. Pairing happens at sample time, not at
+    fixture-authoring time, so no information from
+    the source dataset is discarded up front.
  end note

-  ForenameEntry ..> Name : SampleName() produces
+  NamesByCountry *-- "0..*" ForenameEntry
+  NamesByCountry ..> Name : produces

  class CheckinResult {
    + checked_in_at : std::string
@@ -368,43 +365,20 @@ package "Infrastructure: Pipeline Channel" {

 package "Infrastructure: Data Preloading" {

-  interface ICuratedDataService <<interface>> {
-    + LoadLocations(filepath : const std::filesystem::path&) : const std::vector<Location>&
-    + LoadBeerStyles(filepath : const std::filesystem::path&) : const std::vector<BeerStyle>&
-    + LoadPersonas(filepath : const std::filesystem::path&) : const std::vector<UserPersona>&
-    + LoadForenamesByCountry(forenames_filepath : const std::filesystem::path&) : const std::unordered_map<std::string, forename_list>&
-    + LoadSurnamesByCountry(surnames_filepath : const std::filesystem::path&) : const std::unordered_map<std::string, surname_list>&
+  interface DataPreloader <<interface>> {
+    + LoadLocations(filepath : const std::filesystem::path&) : std::vector<Location>
+    + LoadBeerStyles(filepath : const std::filesystem::path&) : std::vector<BeerStyle>
+    + LoadPersonas(filepath : const std::filesystem::path&) : std::vector<UserPersona>
+    + LoadNamesByCountry(forenames_filepath : const std::filesystem::path&,\n  surnames_filepath : const std::filesystem::path&) : NamesByCountry
  }

  class JsonLoader {
-    + LoadLocations(filepath : const std::filesystem::path&) : const std::vector<Location>&
-    + LoadBeerStyles(filepath : const std::filesystem::path&) : const std::vector<BeerStyle>&
-    + LoadPersonas(filepath : const std::filesystem::path&) : const std::vector<UserPersona>&
-    + LoadForenamesByCountry(forenames_filepath : const std::filesystem::path&) : const std::unordered_map<std::string, forename_list>&
-    + LoadSurnamesByCountry(surnames_filepath : const std::filesystem::path&) : const std::unordered_map<std::string, surname_list>&
+    + LoadLocations(filepath : const std::filesystem::path&) : std::vector<Location>
+    + LoadBeerStyles(filepath : const std::filesystem::path&) : std::vector<BeerStyle>
+    + LoadPersonas(filepath : const std::filesystem::path&) : std::vector<UserPersona>
+    + LoadNamesByCountry(forenames_filepath : const std::filesystem::path&,\n  surnames_filepath : const std::filesystem::path&) : NamesByCountry
  }

-  note right of JsonLoader
-    Each Load* call is memoized after its first
-    parse -- implemented today, ahead of the rest
-    of this package (LoadBeerStyles is still planned).
-  end note
-
-  class MockCuratedDataService {
-    + LoadLocations(filepath : const std::filesystem::path&) : const std::vector<Location>&
-    + LoadBeerStyles(filepath : const std::filesystem::path&) : const std::vector<BeerStyle>&
-    + LoadPersonas(filepath : const std::filesystem::path&) : const std::vector<UserPersona>&
-    + LoadForenamesByCountry(forenames_filepath : const std::filesystem::path&) : const std::unordered_map<std::string, forename_list>&
-    + LoadSurnamesByCountry(surnames_filepath : const std::filesystem::path&) : const std::unordered_map<std::string, surname_list>&
-  }
-
-  note right of MockCuratedDataService
-    Fixed in-memory dataset used in --mocked mode,
-    implemented today for Locations/Personas/
-    Forenames/Surnames; would need a LoadBeerStyles
-    fixture too once that method is implemented.
-  end note
-
 }

 package "Infrastructure: Enrichment" {
@@ -546,7 +520,7 @@ package "Infrastructure: Data Export" {
 }

 class BiergartenPipelineOrchestrator {
-  - curated_data_service_ : std::unique_ptr<ICuratedDataService>
+  - preloader_ : std::unique_ptr<DataPreloader>
  - enrichment_service_ : std::unique_ptr<EnrichmentService>
  - generator_ : std::unique_ptr<DataGenerator>
  - logger_ : std::unique_ptr<Logger>
@@ -574,7 +548,7 @@ class BiergartenPipelineOrchestrator {
 }

 ' --- Orchestration Aggregations (Services & Strategies) ---
-BiergartenPipelineOrchestrator *--  ICuratedDataService
+BiergartenPipelineOrchestrator *--  DataPreloader
 BiergartenPipelineOrchestrator *--  EnrichmentService
 BiergartenPipelineOrchestrator *--  DataGenerator
 BiergartenPipelineOrchestrator *--  ExportService
@@ -593,8 +567,7 @@ BiergartenPipelineOrchestrator *-- "0..*" GeneratedCheckin : checkin_pool_
 BiergartenPipelineOrchestrator *-- "0..*" GeneratedFollow  : follow_pool_

 ' --- Interfaces & Implementations ---
-ICuratedDataService            <|.. JsonLoader
-ICuratedDataService            <|.. MockCuratedDataService
+DataPreloader                  <|.. JsonLoader
 Logger                         <|.. PipelineLogger
 ContextStrategy                <|.. BreweryContextStrategy
 ContextStrategy                <|.. BeerContextStrategy
--- a/docs/pipeline/diagrams/planned/output/biergarten_activity.svg
+++ b/docs/pipeline/diagrams/planned/output/biergarten_activity.svg
--- a/docs/pipeline/diagrams/planned/output/class.svg
+++ b/docs/pipeline/diagrams/planned/output/class.svg
--- a/tooling/pipeline/CMakeLists.txt
+++ b/tooling/pipeline/CMakeLists.txt
@@ -139,7 +139,6 @@ FetchContent_MakeAvailable(cpp-httplib)
 # 5. Executable & Sources
 add_executable(${PROJECT_NAME}
        includes/services/enrichment/mock_enrichment.h
-        includes/services/curated_data/mock_curated_data_service.h
        includes/json_handling/pretty_print.h)

 # --- Entry point ---
@@ -149,12 +148,12 @@ target_sources(${PROJECT_NAME} PRIVATE

 # --- json_handling ---
 target_sources(${PROJECT_NAME} PRIVATE
-        src/services/curated_data/curated_json_data_service.cc
+        src/json_handling/json_loader.cc
 )

-# --- services: curated_data ---
+# --- data_model ---
 target_sources(${PROJECT_NAME} PRIVATE
-        src/services/curated_data/mock_curated_data_service.cc
+        src/data_model/names_by_country.cc
 )

 # --- application_options ---
--- a/tooling/pipeline/includes/biergarten_pipeline.h
+++ b/tooling/pipeline/includes/biergarten_pipeline.h
@@ -1,74 +0,0 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_H_
-
-/**
- * @file biergarten_pipeline.h
- * @brief Master umbrella header — includes every public header in the
- * Biergarten pipeline.
- */
-
-// --- orchestrator ---
-#include "biergarten_pipeline_orchestrator.h"
-
-// --- concurrency ---
-#include "concurrency/bounded_channel.h"
-
-// --- data_generation ---
-#include "data_generation/data_generator.h"
-#include "data_generation/json_grammars.h"
-#ifndef BIERGARTEN_MOCK_ONLY
-#include "data_generation/llama_generator.h"
-#include "data_generation/llama_generator_helpers.h"
-#endif
-#include "data_generation/mock_generator.h"
-#include "data_generation/prompt_formatting/gemma4_jinja_prompt_formatter.h"
-#include "data_generation/prompt_formatting/prompt_formatter.h"
-
-// --- data_model ---
-#include "data_model/generated_models.h"
-#include "data_model/models.h"
-
-// --- json_handling ---
-#include "json_handling/pretty_print.h"
-#include "services/curated_data/curated_json_data_service.h"
-
-// --- llama backend ---
-#ifndef BIERGARTEN_MOCK_ONLY
-#include "llama_backend_state.h"
-#endif
-
-// --- services: curated_data ---
-#include "services/curated_data/curated_data_service.h"
-#include "services/curated_data/mock_curated_data_service.h"
-
-// --- services: database ---
-#include "services/database/export_service.h"
-#include "services/database/sqlite_connection_helpers.h"
-#include "services/database/sqlite_export_service.h"
-#include "services/database/sqlite_export_service_helpers.h"
-#include "services/database/sqlite_handle_types.h"
-#include "services/database/sqlite_statement_helpers.h"
-
-// --- services: datetime ---
-#include "services/datetime/date_time_provider.h"
-#include "services/datetime/timer.h"
-
-// --- services: enrichment ---
-#include "services/enrichment/enrichment_service.h"
-#include "services/enrichment/mock_enrichment.h"
-#include "services/enrichment/wikipedia_service.h"
-
-// --- services: logging ---
-#include "services/logging/log_dispatcher.h"
-#include "services/logging/log_entry.h"
-#include "services/logging/log_producer.h"
-#include "services/logging/logger.h"
-
-// --- services: prompting ---
-#include "services/prompting/prompt_directory.h"
-
-// --- web_client ---
-#include "web_client/http_web_client.h"
-#include "web_client/web_client.h"
-
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_H_
--- a/tooling/pipeline/includes/biergarten_pipeline_orchestrator.h
+++ b/tooling/pipeline/includes/biergarten_pipeline_orchestrator.h
@@ -1,9 +1,12 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_

 /**
 * @file biergarten_pipeline_orchestrator.h
 * @brief Orchestration for end-to-end brewery and user data generation.
+ *
+ * Coordinates location loading, enrichment, and generation phases to produce
+ * a complete dataset, wiring dependencies selected at the composition root.
 */

 #include <memory>
@@ -100,6 +103,10 @@ class BiergartenPipelineOrchestrator {
   * @brief Generate users grounded in sampled names and personas for
   * enriched cities.
   *
+   * Loads personas.json / forenames-by-country.json /
+   * surnames-by-country.json itself, mirroring how QueryCitiesWithCountries()
+   * owns its own locations.json load.
+   *
   * @param cities Span of enriched city data.
   */
  void GenerateUsers(std::span<const EnrichedCity> cities);
@@ -113,4 +120,4 @@ class BiergartenPipelineOrchestrator {
  std::vector<UserRecord> generated_users_;
 };

-#endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_
--- a/tooling/pipeline/includes/concurrency/bounded_channel.tcc
+++ b/tooling/pipeline/includes/concurrency/bounded_channel.tcc
@@ -1,4 +1,4 @@
-#include "concurrency/bounded_channel.h"
+#include "bounded_channel.h"

 template <typename T>
 void BoundedChannel<T>::Send(T item) {
--- a/tooling/pipeline/includes/data_generation/llama_generator.h
+++ b/tooling/pipeline/includes/data_generation/llama_generator.h
@@ -1,23 +1,24 @@
 #ifndef BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_LLAMA_GENERATOR_H_
 #define BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_LLAMA_GENERATOR_H_

+#include <filesystem>
+
 /**
 * @file data_generation/llama_generator.h
 * @brief llama.cpp-backed implementation of DataGenerator.
 */

 #include <cstdint>
-#include <filesystem>
 #include <memory>
 #include <random>
 #include <string>
 #include <string_view>

+#include "../services/prompting/prompt_directory.h"
 #include "data_generation/data_generator.h"
 #include "data_generation/prompt_formatting/prompt_formatter.h"
 #include "data_model/models.h"
 #include "services/logging/logger.h"
-#include "services/prompting/prompt_directory.h"

 struct llama_model;
 struct llama_context;
--- a/tooling/pipeline/includes/data_model/models.h
+++ b/tooling/pipeline/includes/data_model/models.h
@@ -10,7 +10,6 @@
 #include <boost/program_options.hpp>
 #include <cstdint>
 #include <filesystem>
-#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -67,7 +66,7 @@ struct Location {
 /**
 * @brief A sampled first/last name pair, with the source forename's gender.
 *
- * Produced by the SampleName() helper in generate_users.cc.
+ * Produced by NamesByCountry::SampleName();
 */
 struct Name {
  std::string first_name{};
@@ -94,23 +93,8 @@ struct ForenameEntry {
   * dataset (e.g. "M", "F").
   */
  std::string gender{};
-
-  bool operator==(const ForenameEntry& other) const {
-    return name == other.name && gender == other.gender;
-  }
 };

-namespace std {
-template <>
-struct hash<ForenameEntry> {
-  size_t operator()(const ForenameEntry& entry) const noexcept {
-    const size_t name_hash = std::hash<std::string>{}(entry.name);
-    const size_t gender_hash = std::hash<std::string>{}(entry.gender);
-    return name_hash ^ (gender_hash << 1);
-  }
-};
-}  // namespace std
-
 /**
 * @brief A persona archetype used to ground LLM-generated user bios.
 */
--- a/tooling/pipeline/includes/data_model/names_by_country.h
+++ b/tooling/pipeline/includes/data_model/names_by_country.h
@@ -0,0 +1,51 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_NAMES_BY_COUNTRY_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_NAMES_BY_COUNTRY_H_
+
+/**
+ * @file data_model/names_by_country.h
+ * @brief Sampling over the names-by-country fixture data.
+ */
+
+#include <optional>
+#include <random>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "data_model/models.h"
+
+/**
+ * @brief Samples locale-appropriate names from curated forename/surname
+ * fixture data, keyed by ISO 3166-1 country code.
+ *
+ * Forenames and surnames are kept in separate maps (mirroring the source
+ * dataset's own shape) so per-forename gender is preserved; pairing happens
+ * at sample time rather than being precomputed, so no information from the
+ * source dataset is discarded up front.
+ */
+class NamesByCountry {
+ public:
+  NamesByCountry(std::unordered_map<std::string, std::vector<ForenameEntry>>
+                     forenames_by_country,
+                 std::unordered_map<std::string, std::vector<std::string>>
+                     surnames_by_country);
+
+  /**
+   * @brief Samples a first/last name pair for the given country.
+   *
+   * @param iso3166_1 ISO 3166-1 country code to sample for.
+   * @param rng Random source used for sampling.
+   * @return A sampled Name, or std::nullopt if the country has no forename
+   * or no surname entries.
+   */
+  [[nodiscard]] std::optional<Name> SampleName(const std::string& iso3166_1,
+                                               std::mt19937& rng) const;
+
+ private:
+  std::unordered_map<std::string, std::vector<ForenameEntry>>
+      forenames_by_country_;
+  std::unordered_map<std::string, std::vector<std::string>>
+      surnames_by_country_;
+};
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_NAMES_BY_COUNTRY_H_
--- a/tooling/pipeline/includes/json_handling/json_loader.h
+++ b/tooling/pipeline/includes/json_handling/json_loader.h
@@ -0,0 +1,47 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_
+
+/**
+ * @file json_handling/json_loader.h
+ * @brief JSON-backed implementation of ICuratedDataService.
+ */
+
+#include <filesystem>
+#include <vector>
+
+#include "data_model/models.h"
+#include "data_model/names_by_country.h"
+#include "services/curated_data/curated_data_service.h"
+
+/**
+ * @brief Loads curated location, persona, and name data from JSON files.
+ */
+class JsonLoader final : public ICuratedDataService {
+ public:
+  JsonLoader() = default;
+
+  /**
+   * @brief Parses a JSON array file and returns all location records.
+   */
+  std::vector<Location> LoadLocations(
+      const std::filesystem::path& filepath) override;
+
+  /**
+   * @brief Parses a JSON array file and returns all persona records.
+   */
+  std::vector<UserPersona> LoadPersonas(
+      const std::filesystem::path& filepath) override;
+
+  /**
+   * @brief Parses the names-by-country fixture pair into a sampling-capable
+   * NamesByCountry.
+   *
+   * @param forenames_filepath Path to forenames-by-country.json.
+   * @param surnames_filepath Path to surnames-by-country.json.
+   */
+  NamesByCountry LoadNamesByCountry(
+      const std::filesystem::path& forenames_filepath,
+      const std::filesystem::path& surnames_filepath) override;
+};
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_
--- a/tooling/pipeline/includes/json_handling/pretty_print.h
+++ b/tooling/pipeline/includes/json_handling/pretty_print.h
@@ -106,4 +106,4 @@ inline void PrettyPrint(std::ostream& outstream,
  }
 }

-#endif  // BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_PRETTY_PRINT_H_
+#endif
--- a/tooling/pipeline/includes/services/curated_data/curated_data_service.h
+++ b/tooling/pipeline/includes/services/curated_data/curated_data_service.h
@@ -7,18 +7,10 @@
 */

 #include <filesystem>
-#include <unordered_map>
-#include <unordered_set>
 #include <vector>

 #include "data_model/models.h"
-
-using ForenameList = std::vector<ForenameEntry>;
-using SurnameList = std::vector<std::string>;
-using LocationsList = std::vector<Location>;
-using PersonasList = std::vector<UserPersona>;
-using ForenamesByCountryMap = std::unordered_map<std::string, ForenameList>;
-using SurnamesByCountryMap = std::unordered_map<std::string, SurnameList>;
+#include "data_model/names_by_country.h"

 /**
 * @brief Interface for services that load curated data used to seed
@@ -37,14 +29,25 @@ class ICuratedDataService {
  /**
   * @brief Loads all curated location records.
   */
-  virtual const LocationsList& LoadLocations() = 0;
+  virtual std::vector<Location> LoadLocations(
+      const std::filesystem::path& filepath) = 0;

  /**
   * @brief Loads all curated persona records.
   */
-  virtual const PersonasList& LoadPersonas() = 0;
-  virtual const ForenamesByCountryMap& LoadForenamesByCountry() = 0;
-  virtual const SurnamesByCountryMap& LoadSurnamesByCountry() = 0;
+  virtual std::vector<UserPersona> LoadPersonas(
+      const std::filesystem::path& filepath) = 0;
+
+  /**
+   * @brief Loads the names-by-country fixture pair into a sampling-capable
+   * NamesByCountry.
+   *
+   * @param forenames_filepath Path to forenames-by-country.json.
+   * @param surnames_filepath Path to surnames-by-country.json.
+   */
+  virtual NamesByCountry LoadNamesByCountry(
+      const std::filesystem::path& forenames_filepath,
+      const std::filesystem::path& surnames_filepath) = 0;
 };

 #endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_CURATED_DATA_CURATED_DATA_SERVICE_H_
--- a/tooling/pipeline/includes/services/curated_data/curated_json_data_service.h
+++ b/tooling/pipeline/includes/services/curated_data/curated_json_data_service.h
@@ -1,63 +0,0 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_
-
-/**
- * @file json_handling/json_loader.h
- * @brief JSON-backed implementation of ICuratedDataService.
- */
-
-#include <filesystem>
-
-#include "data_model/models.h"
-#include "services/curated_data/curated_data_service.h"
-
-/**
- * @brief File locations for the curated JSON fixtures consumed by
- * CuratedJsonDataService.
- */
-struct CuratedDataFilePaths {
-  std::filesystem::path locations_path;
-  std::filesystem::path personas_path;
-  std::filesystem::path forenames_path;
-  std::filesystem::path surnames_path;
-};
-
-/**
- * @brief Loads curated location, persona, and name data from JSON files.
- */
-class CuratedJsonDataService final : public ICuratedDataService {
-  struct cache {
-    LocationsList locations;
-    PersonasList personas;
-    ForenamesByCountryMap forenames_by_country;
-    SurnamesByCountryMap surnames_by_country;
-
-    cache() = default;
-    ~cache() = default;
-  };
-
-  CuratedDataFilePaths filepaths_;
-  cache cache_;
-
- public:
-  explicit CuratedJsonDataService(CuratedDataFilePaths filepaths);
-
-  /**
-   * @brief Parses a JSON array file and returns all location records.
-   */
-  const LocationsList& LoadLocations() override;
-
-  /**
-   * @brief Parses a JSON array file and returns all persona records.
-   */
-  const PersonasList& LoadPersonas() override;
-
-  const ForenamesByCountryMap& LoadForenamesByCountry() override;
-
-  /**
-   * @brief Parses a JSON file and returns all the forenames per country.
-   */
-  const SurnamesByCountryMap& LoadSurnamesByCountry() override;
-};
-
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_
--- a/tooling/pipeline/includes/services/curated_data/mock_curated_data_service.h
+++ b/tooling/pipeline/includes/services/curated_data/mock_curated_data_service.h
@@ -1,38 +0,0 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_CURATED_DATA_MOCK_CURATED_DATA_SERVICE_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_CURATED_DATA_MOCK_CURATED_DATA_SERVICE_H_
-
-/**
- * @file services/curated_data/mock_curated_data_service.h
- * @brief In-memory ICuratedDataService backed by a small fixed dataset, used
- * when file-backed curated data is disabled (mock mode).
- */
-
-#include <filesystem>
-
-#include "data_model/models.h"
-#include "services/curated_data/curated_data_service.h"
-
-/**
- * @brief Curated data service returning a small fixed in-memory dataset in
- * place of the JSON fixture files used by JsonLoader.
- */
-class MockCuratedDataService final : public ICuratedDataService {
- public:
-  MockCuratedDataService();
-
-  const LocationsList& LoadLocations() override;
-
-  const PersonasList& LoadPersonas() override;
-
-  const ForenamesByCountryMap& LoadForenamesByCountry() override;
-
-  const SurnamesByCountryMap& LoadSurnamesByCountry() override;
-
- private:
-  LocationsList locations_;
-  PersonasList personas_;
-  ForenamesByCountryMap forenames_by_country_;
-  SurnamesByCountryMap surnames_by_country_;
-};
-
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_CURATED_DATA_MOCK_CURATED_DATA_SERVICE_H_
--- a/tooling/pipeline/includes/services/database/sqlite_connection_helpers.h
+++ b/tooling/pipeline/includes/services/database/sqlite_connection_helpers.h
@@ -12,7 +12,7 @@
 #include <string>
 #include <string_view>

-#include "services/database/sqlite_handle_types.h"
+#include "sqlite_handle_types.h"

 namespace sqlite_export_service_internal {

--- a/tooling/pipeline/includes/services/database/sqlite_export_service.h
+++ b/tooling/pipeline/includes/services/database/sqlite_export_service.h
@@ -11,10 +11,10 @@
 #include <string>
 #include <unordered_map>

+#include "../datetime/date_time_provider.h"
 #include "data_model/models.h"
-#include "services/database/export_service.h"
-#include "services/database/sqlite_export_service_helpers.h"
-#include "services/datetime/date_time_provider.h"
+#include "export_service.h"
+#include "sqlite_export_service_helpers.h"

 /**
 * @brief Persists generated brewery records into a fresh SQLite database.
--- a/tooling/pipeline/includes/services/database/sqlite_export_service_helpers.h
+++ b/tooling/pipeline/includes/services/database/sqlite_export_service_helpers.h
@@ -3,8 +3,8 @@

 /* Umbrella header for backward compatibility. */

-#include "services/database/sqlite_connection_helpers.h"
-#include "services/database/sqlite_handle_types.h"
-#include "services/database/sqlite_statement_helpers.h"
+#include "sqlite_connection_helpers.h"
+#include "sqlite_handle_types.h"
+#include "sqlite_statement_helpers.h"

 #endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_EXPORT_SERVICE_HELPERS_H_
--- a/tooling/pipeline/includes/services/database/sqlite_handle_types.h
+++ b/tooling/pipeline/includes/services/database/sqlite_handle_types.h
@@ -24,10 +24,8 @@ using SqliteDatabaseHandle = std::unique_ptr<sqlite3, SqliteDatabaseDeleter>;
 using SqliteStatementHandle =
    std::unique_ptr<sqlite3_stmt, SqliteStatementDeleter>;

-// Represents a parameter that is bound to a prepared SQLite statement.
-// N.B. indices are 1 based.
 template <typename T>
-struct BoundParam {
+struct BindParam {
  int index;
  T value;
  std::string_view action;
--- a/tooling/pipeline/includes/services/database/sqlite_statement_helpers.h
+++ b/tooling/pipeline/includes/services/database/sqlite_statement_helpers.h
@@ -13,7 +13,7 @@
 #include <string_view>
 #include <vector>

-#include "services/database/sqlite_handle_types.h"
+#include "sqlite_handle_types.h"

 namespace sqlite_export_service_internal {

@@ -109,36 +109,30 @@ INSERT INTO users (

 // sqlite3_bind_*() parameter indices are 1-based, matching the "?"
 // placeholder order in the SQL above.
-enum LocationBindIndex {
-  kLocationCityBindIndex = 1,
-  kLocationStateProvinceBindIndex,
-  kLocationIso31662BindIndex,
-  kLocationCountryBindIndex,
-  kLocationIso31661BindIndex,
-  kLocationLanguagesBindIndex,
-  kLocationLatitudeBindIndex,
-  kLocationLongitudeBindIndex,
-};
+inline constexpr int kLocationCityBindIndex = 1;
+inline constexpr int kLocationStateProvinceBindIndex = 2;
+inline constexpr int kLocationIso31662BindIndex = 3;
+inline constexpr int kLocationCountryBindIndex = 4;
+inline constexpr int kLocationIso31661BindIndex = 5;
+inline constexpr int kLocationLanguagesBindIndex = 6;
+inline constexpr int kLocationLatitudeBindIndex = 7;
+inline constexpr int kLocationLongitudeBindIndex = 8;

-enum BreweryBindIndex {
-  kBreweryLocationIdBindIndex = 1,
-  kBreweryEnglishNameBindIndex,
-  kBreweryEnglishDescriptionBindIndex,
-  kBreweryLocalNameBindIndex,
-  kBreweryLocalDescriptionBindIndex,
-};
+inline constexpr int kBreweryLocationIdBindIndex = 1;
+inline constexpr int kBreweryEnglishNameBindIndex = 2;
+inline constexpr int kBreweryEnglishDescriptionBindIndex = 3;
+inline constexpr int kBreweryLocalNameBindIndex = 4;
+inline constexpr int kBreweryLocalDescriptionBindIndex = 5;

-enum UserBindIndex {
-  kUserLocationIdBindIndex = 1,
-  kUserFirstNameBindIndex,
-  kUserLastNameBindIndex,
-  kUserGenderBindIndex,
-  kUserUsernameBindIndex,
-  kUserBioBindIndex,
-  kUserActivityWeightBindIndex,
-  kUserEmailBindIndex,
-  kUserDateOfBirthBindIndex,
-};
+inline constexpr int kUserLocationIdBindIndex = 1;
+inline constexpr int kUserFirstNameBindIndex = 2;
+inline constexpr int kUserLastNameBindIndex = 3;
+inline constexpr int kUserGenderBindIndex = 4;
+inline constexpr int kUserUsernameBindIndex = 5;
+inline constexpr int kUserBioBindIndex = 6;
+inline constexpr int kUserActivityWeightBindIndex = 7;
+inline constexpr int kUserEmailBindIndex = 8;
+inline constexpr int kUserDateOfBirthBindIndex = 9;

 SqliteStatementHandle PrepareStatement(const SqliteDatabaseHandle& db_handle,
                                       std::string_view sql,
@@ -147,13 +141,13 @@ SqliteStatementHandle PrepareStatement(const SqliteDatabaseHandle& db_handle,
 void ResetStatement(SqliteStatementHandle& statement);

 void Bind(const SqliteStatementHandle& statement,
-          const BoundParam<std::string_view>& param);
+          const BindParam<std::string_view>& param);

 void Bind(const SqliteStatementHandle& statement,
-          const BoundParam<double>& param);
+          const BindParam<double>& param);

 void Bind(const SqliteStatementHandle& statement,
-          const BoundParam<sqlite3_int64>& param);
+          const BindParam<sqlite3_int64>& param);

 void StepStatement(const SqliteDatabaseHandle& db_handle,
                   const SqliteStatementHandle& statement,
--- a/tooling/pipeline/includes/services/enrichment/mock_enrichment.h
+++ b/tooling/pipeline/includes/services/enrichment/mock_enrichment.h
@@ -8,7 +8,7 @@

 #include <string>

-#include "services/enrichment/enrichment_service.h"
+#include "enrichment_service.h"

 /**
 * @brief Enrichment service that returns no context for any location.
--- a/tooling/pipeline/includes/services/enrichment/wikipedia_service.h
+++ b/tooling/pipeline/includes/services/enrichment/wikipedia_service.h
@@ -11,7 +11,7 @@
 #include <string_view>
 #include <unordered_map>

-#include "services/enrichment/enrichment_service.h"
+#include "enrichment_service.h"
 #include "services/logging/logger.h"
 #include "web_client/web_client.h"

--- a/tooling/pipeline/includes/services/logging/log_producer.h
+++ b/tooling/pipeline/includes/services/logging/log_producer.h
@@ -6,8 +6,8 @@
 * a bounded channel for later processing by the dispatcher.
 */

-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_

 #include <string_view>

@@ -50,4 +50,4 @@ class LogProducer final : public ILogger {
  BoundedChannel<LogEntry>& channel_;
 };

-#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
--- a/tooling/pipeline/includes/web_client/http_web_client.h
+++ b/tooling/pipeline/includes/web_client/http_web_client.h
@@ -52,4 +52,4 @@ class HttpWebClient final : public WebClient {
  std::shared_ptr<ILogger> logger_;
 };

-#endif  // BIERGARTEN_PIPELINE_INCLUDES_WEB_CLIENT_HTTP_WEB_CLIENT_H_
+#endif
--- a/tooling/pipeline/src/biergarten_pipeline_orchestrator/biergarten_pipeline_orchestrator.cc
+++ b/tooling/pipeline/src/biergarten_pipeline_orchestrator/biergarten_pipeline_orchestrator.cc
@@ -14,9 +14,10 @@ BiergartenPipelineOrchestrator::BiergartenPipelineOrchestrator(
    std::unique_ptr<IExportService> exporter,
    std::unique_ptr<ICuratedDataService> curated_data_service,
    const ApplicationOptions& application_options)
-    : logger_(std::move(logger)),
-      context_service_(std::move(context_service)),
-      generator_(std::move(generator)),
-      exporter_(std::move(exporter)),
-      curated_data_service_(std::move(curated_data_service)),
-      application_options_(application_options) {}
+  : logger_(std::move(logger)),
+    context_service_(std::move(context_service)),
+    generator_(std::move(generator)),
+    exporter_(std::move(exporter)),
+    curated_data_service_(std::move(curated_data_service)),
+    application_options_(application_options) {
+}
--- a/tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_users.cc
+++ b/tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_users.cc
@@ -6,7 +6,6 @@
 #include <cctype>
 #include <chrono>
 #include <format>
-#include <iterator>
 #include <optional>
 #include <random>
 #include <stdexcept>
@@ -15,7 +14,7 @@
 #include <unordered_set>

 #include "biergarten_pipeline_orchestrator.h"
-#include "services/curated_data/curated_json_data_service.h"
+#include "json_handling/json_loader.h"
 #include "services/logging/logger.h"

 namespace {
@@ -25,7 +24,7 @@ std::string Sanitize(std::string_view value) {
  for (const char character : value) {
    if (std::isalnum(static_cast<unsigned char>(character)) != 0) {
      out.push_back(static_cast<char>(
-          std::tolower(static_cast<unsigned char>(character))));
+        std::tolower(static_cast<unsigned char>(character))));
    }
  }
  return out;
@@ -70,37 +69,7 @@ std::string GenerateDateOfBirth(std::mt19937& rng) {
                     static_cast<unsigned>(birth_ymd.month()),
                     static_cast<unsigned>(birth_ymd.day()));
 }
-
-std::optional<Name> SampleName(
-    const ForenamesByCountryMap& forenames_by_country,
-    const SurnamesByCountryMap& surnames_by_country,
-    const std::string& iso3166_1, std::mt19937& rng) {
-  const auto forenames_it = forenames_by_country.find(iso3166_1);
-  const auto surnames_it = surnames_by_country.find(iso3166_1);
-
-  if (forenames_it == forenames_by_country.end() ||
-      surnames_it == surnames_by_country.end() ||
-      forenames_it->second.empty() || surnames_it->second.empty()) {
-    return std::nullopt;
-  }
-
-  const ForenameList& forenames = forenames_it->second;
-  const SurnameList& surnames = surnames_it->second;
-
-  std::uniform_int_distribution<size_t> forename_dist(0, forenames.size() - 1);
-  std::uniform_int_distribution<size_t> surname_dist(0, surnames.size() - 1);
-
-  auto forename_it = forenames.begin();
-  std::advance(forename_it, forename_dist(rng));
-
-  auto surname_it = surnames.begin();
-  std::advance(surname_it, surname_dist(rng));
-
-  return Name{.first_name = forename_it->name,
-              .last_name = *surname_it,
-              .gender = forename_it->gender};
-}
-}  // namespace
+} // namespace

 void BiergartenPipelineOrchestrator::GenerateUsers(
    std::span<const EnrichedCity> cities) {
@@ -108,17 +77,17 @@ void BiergartenPipelineOrchestrator::GenerateUsers(
                .phase = PipelinePhase::UserGeneration,
                .message = "=== SAMPLE USER GENERATION ==="});

-  const PersonasList& personas = curated_data_service_->LoadPersonas();
+  const std::vector<UserPersona> personas =
+      curated_data_service_->LoadPersonas("personas.json");

  if (personas.empty()) {
    throw std::runtime_error(
        "No personas available in personas.json for user generation");
  }

-  const ForenamesByCountryMap& forenames_by_country =
-      curated_data_service_->LoadForenamesByCountry();
-  const SurnamesByCountryMap& surnames_by_country =
-      curated_data_service_->LoadSurnamesByCountry();
+  const NamesByCountry names_by_country =
+      curated_data_service_->LoadNamesByCountry(
+          "forenames-by-country.json", "surnames-by-country.json");

  std::mt19937 rng(std::random_device{}());
  std::uniform_int_distribution<size_t> persona_dist(0, personas.size() - 1);
@@ -126,13 +95,14 @@ void BiergartenPipelineOrchestrator::GenerateUsers(
  generated_users_.clear();
  size_t skipped_count = 0;
  size_t export_failed_count = 0;
-  std::unordered_set<std::string> used_email_local_parts;

  const auto generate_record =
-      [this, &rng, &skipped_count, &used_email_local_parts](
-          const EnrichedCity& city, const UserPersona& persona,
-          const Name& sampled_name) -> std::optional<UserRecord> {
+      [this, &rng, &skipped_count](
+      const EnrichedCity& city, const UserPersona& persona,
+      const Name& sampled_name) -> std::optional<UserRecord> {
    try {
+      std::unordered_set<std::string> used_email_local_parts;
+
      const UserResult user =
          generator_->GenerateUser(city, persona, sampled_name);

@@ -155,26 +125,25 @@ void BiergartenPipelineOrchestrator::GenerateUsers(
  };

  const auto export_record = [this,
-                              &export_failed_count](const UserRecord& record) {
+        &export_failed_count](const UserRecord& record) {
    try {
      exporter_->ProcessRecord(record);
    } catch (const std::exception& export_exception) {
      ++export_failed_count;

      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message = std::format("[Pipeline] Generated user for '{}' ({}) but "
-                                  "SQLite export failed: {}",
-                                  record.location.city, record.location.country,
-                                  export_exception.what())});
+      {.level = LogLevel::Warn,
+       .phase = PipelinePhase::UserGeneration,
+       .message = std::format("[Pipeline] Generated user for '{}' ({}) but "
+                              "SQLite export failed: {}",
+                              record.location.city, record.location.country,
+                              export_exception.what())});
    }
  };

  for (const auto& city : cities) {
    const std::optional<Name> sampled_name =
-        SampleName(forenames_by_country, surnames_by_country,
-                   city.location.iso3166_1, rng);
+        names_by_country.SampleName(city.location.iso3166_1, rng);

    if (!sampled_name.has_value()) {
      ++skipped_count;
@@ -202,11 +171,11 @@ void BiergartenPipelineOrchestrator::GenerateUsers(

  if (skipped_count > 0) {
    logger_->Log(
-        {.level = LogLevel::Warn,
-         .phase = PipelinePhase::UserGeneration,
-         .message = std::format(
-             "[Pipeline] Skipped {} city/cities during user generation",
-             skipped_count)});
+    {.level = LogLevel::Warn,
+     .phase = PipelinePhase::UserGeneration,
+     .message = std::format(
+         "[Pipeline] Skipped {} city/cities during user generation",
+         skipped_count)});
  }

  if (export_failed_count > 0) {
--- a/tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc
+++ b/tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc
@@ -7,8 +7,8 @@
 #include <chrono>
 #include <format>

+#include "../../includes/json_handling/pretty_print.h"
 #include "biergarten_pipeline_orchestrator.h"
-#include "json_handling/pretty_print.h"
 #include "services/logging/logger.h"

 void BiergartenPipelineOrchestrator::LogResults() const {
--- a/tooling/pipeline/src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc
+++ b/tooling/pipeline/src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc
@@ -6,12 +6,13 @@

 #include <algorithm>
 #include <chrono>
+#include <filesystem>
 #include <format>
 #include <iterator>
 #include <random>

 #include "biergarten_pipeline_orchestrator.h"
-#include "services/curated_data/curated_json_data_service.h"
+#include "json_handling/json_loader.h"
 #include "services/logging/logger.h"

 std::vector<Location>
@@ -20,8 +21,9 @@ BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
                .phase = PipelinePhase::Startup,
                .message = "=== GEOGRAPHIC DATA OVERVIEW ==="});

-  const std::vector<Location>& all_locations =
-      curated_data_service_->LoadLocations();
+  const std::filesystem::path locations_path = "locations.json";
+
+  auto all_locations = curated_data_service_->LoadLocations(locations_path);

  const size_t sample_count = std::min(
      static_cast<size_t>(application_options_.pipeline.location_count),
--- a/tooling/pipeline/src/data_generation/llama/generate_user.cc
+++ b/tooling/pipeline/src/data_generation/llama/generate_user.cc
@@ -30,13 +30,10 @@ UserResult LlamaGenerator::GenerateUser(const EnrichedCity& city,
  const std::string system_prompt = prompt_directory_->Load("USER_GENERATION");

  std::string user_prompt = std::format(
-      "## NAME:\n\n{} {}\n\n"
-      "## GENDER:\n\n{}\n\n"
-      "## CITY:\n\n{}\n\n"
-      "## COUNTRY:\n\n{}\n\n"
-      "## PERSONA:\n\n{}\n\n"
-      "## PERSONA DESCRIPTION:\n\n{}\n\n"
-      "## STYLE AFFINITIES:\n\n{}",
+      "## NAME:\n{} {}\n\n## GENDER:\n{}\n\n## CITY:\n{}\n\n## "
+      "COUNTRY:\n{}\n\n"
+      "## PERSONA:\n{}\n\n## PERSONA DESCRIPTION:\n{}\n\n## STYLE "
+      "AFFINITIES:\n{}",
      name.first_name, name.last_name, name.gender, city.location.city,
      city.location.country, persona.name, persona.description,
      style_affinities);
--- a/tooling/pipeline/src/data_generation/llama/helpers.cc
+++ b/tooling/pipeline/src/data_generation/llama/helpers.cc
@@ -15,10 +15,8 @@
 #include <string_view>
 #include <vector>

-#include <llama.h>
-
 #include "data_generation/llama_generator_helpers.h"
-
+#include "llama.h"
 namespace {
 /**
 * String trimming: removes leading and trailing whitespace
--- a/tooling/pipeline/src/data_generation/llama/infer.cc
+++ b/tooling/pipeline/src/data_generation/llama/infer.cc
@@ -14,10 +14,9 @@
 #include <string_view>
 #include <vector>

-#include <llama.h>
-
 #include "data_generation/llama_generator.h"
 #include "data_generation/llama_generator_helpers.h"
+#include "llama.h"

 static constexpr size_t kPromptTokenSlack = 8;
 // Minimum tokens to keep when using top-p sampling. Ensures at least one
--- a/tooling/pipeline/src/data_generation/llama/llama_generator.cc
+++ b/tooling/pipeline/src/data_generation/llama/llama_generator.cc
@@ -11,9 +11,8 @@
 #include <stdexcept>
 #include <string>

-#include <llama.h>
-
 #include "data_model/models.h"
+#include "llama.h"

 static constexpr uint32_t kMaxContextSize = 32768U;

--- a/tooling/pipeline/src/data_generation/llama/load.cc
+++ b/tooling/pipeline/src/data_generation/llama/load.cc
@@ -10,10 +10,9 @@
 #include <string>
 #include <utility>

-#include <ggml-backend.h>
-#include <llama.h>
-
 #include "data_generation/llama_generator.h"
+#include "ggml-backend.h"
+#include "llama.h"

 // Maximum batch size for decode operations. Capping the batch prevents
 // excessive memory allocation while maintaining inference performance.
--- a/tooling/pipeline/src/data_model/names_by_country.cc
+++ b/tooling/pipeline/src/data_model/names_by_country.cc
@@ -0,0 +1,40 @@
+/**
+ * @file data_model/names_by_country.cc
+ * @brief NamesByCountry::SampleName() implementation.
+ */
+
+#include "data_model/names_by_country.h"
+
+#include <utility>
+
+NamesByCountry::NamesByCountry(
+    std::unordered_map<std::string, std::vector<ForenameEntry>>
+        forenames_by_country,
+    std::unordered_map<std::string, std::vector<std::string>>
+        surnames_by_country)
+    : forenames_by_country_(std::move(forenames_by_country)),
+      surnames_by_country_(std::move(surnames_by_country)) {}
+
+std::optional<Name> NamesByCountry::SampleName(const std::string& iso3166_1,
+                                               std::mt19937& rng) const {
+  const auto forenames_it = forenames_by_country_.find(iso3166_1);
+  const auto surnames_it = surnames_by_country_.find(iso3166_1);
+
+  if (forenames_it == forenames_by_country_.end() ||
+      surnames_it == surnames_by_country_.end() ||
+      forenames_it->second.empty() || surnames_it->second.empty()) {
+    return std::nullopt;
+  }
+
+  const std::vector<ForenameEntry>& forenames = forenames_it->second;
+  const std::vector<std::string>& surnames = surnames_it->second;
+
+  std::uniform_int_distribution<size_t> forename_dist(0, forenames.size() - 1);
+  std::uniform_int_distribution<size_t> surname_dist(0, surnames.size() - 1);
+
+  const ForenameEntry& forename = forenames[forename_dist(rng)];
+
+  return Name{.first_name = forename.name,
+              .last_name = surnames[surname_dist(rng)],
+              .gender = forename.gender};
+}
--- a/tooling/pipeline/src/services/curated_data/curated_json_data_service.cc
+++ b/tooling/pipeline/src/services/curated_data/curated_json_data_service.cc
@@ -4,7 +4,7 @@
 * records with strict field validation and descriptive error reporting.
 */

-#include "services/curated_data/curated_json_data_service.h"
+#include "json_handling/json_loader.h"

 #include <boost/json.hpp>
 #include <format>
@@ -14,8 +14,8 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
+#include <unordered_map>
 #include <utility>
-#include <vector>

 #include "services/logging/logger.h"

@@ -106,23 +106,16 @@ std::string ReadFirstOfStringArray(const boost::json::object& object,

 }  // namespace

-CuratedJsonDataService::CuratedJsonDataService(CuratedDataFilePaths filepaths)
-    : filepaths_(std::move(filepaths)) {}
-
-const LocationsList& CuratedJsonDataService::LoadLocations() {
-  if (!cache_.locations.empty()) {
-    return cache_.locations;
-  }
-
-  const boost::json::value root =
-      ParseJsonFile(filepaths_.locations_path, "locations");
+std::vector<Location> JsonLoader::LoadLocations(
+    const std::filesystem::path& filepath) {
+  const boost::json::value root = ParseJsonFile(filepath, "locations");

  if (!root.is_array()) {
    throw std::runtime_error(
        "Invalid locations JSON: root element must be an array");
  }

-  LocationsList locations;
+  std::vector<Location> locations;
  const auto& items = root.as_array();
  locations.reserve(items.size());

@@ -144,24 +137,20 @@ const LocationsList& CuratedJsonDataService::LoadLocations() {
        .longitude = ReadRequiredNumber(object, "longitude"),
    });
  }
-  cache_.locations = std::move(locations);
-  return cache_.locations;
+
+  return locations;
 }

-const PersonasList& CuratedJsonDataService::LoadPersonas() {
-  if (!cache_.personas.empty()) {
-    return cache_.personas;
-  }
-
-  const boost::json::value root =
-      ParseJsonFile(filepaths_.personas_path, "personas");
+std::vector<UserPersona> JsonLoader::LoadPersonas(
+    const std::filesystem::path& filepath) {
+  const boost::json::value root = ParseJsonFile(filepath, "personas");

  if (!root.is_array()) {
    throw std::runtime_error(
        "Invalid personas JSON: root element must be an array");
  }

-  PersonasList personas;
+  std::vector<UserPersona> personas;
  const auto& items = root.as_array();
  personas.reserve(items.size());

@@ -179,30 +168,30 @@ const PersonasList& CuratedJsonDataService::LoadPersonas() {
    });
  }

-  cache_.personas = std::move(personas);
-  return cache_.personas;
+  return personas;
 }

-const ForenamesByCountryMap& CuratedJsonDataService::LoadForenamesByCountry() {
-  if (!cache_.forenames_by_country.empty()) {
-    return cache_.forenames_by_country;
-  }
+NamesByCountry JsonLoader::LoadNamesByCountry(
+    const std::filesystem::path& forenames_filepath,
+    const std::filesystem::path& surnames_filepath) {
+  const boost::json::value forenames_root =
+      ParseJsonFile(forenames_filepath, "forenames-by-country");
+  const boost::json::value surnames_root =
+      ParseJsonFile(surnames_filepath, "surnames-by-country");

-  const boost::json::value root =
-      ParseJsonFile(filepaths_.forenames_path, "forenames-by-country");
-
-  if (!root.is_object()) {
+  if (!forenames_root.is_object() || !surnames_root.is_object()) {
    throw std::runtime_error(
-        "Invalid forenames-by-country JSON: root element must be an object "
+        "Invalid names-by-country JSON: root element must be an object "
        "keyed by ISO 3166-1 country code");
  }

-  ForenamesByCountryMap forenames_by_country;
-  for (const auto& [country_code, regions] : root.as_object()) {
+  std::unordered_map<std::string, std::vector<ForenameEntry>>
+      forenames_by_country;
+  for (const auto& [country_code, regions] : forenames_root.as_object()) {
    if (!regions.is_array()) {
      continue;
    }
-    ForenameList entries;
+    std::vector<ForenameEntry> entries;
    for (const auto& region : regions.as_array()) {
      if (!region.is_object()) {
        continue;
@@ -216,7 +205,7 @@ const ForenamesByCountryMap& CuratedJsonDataService::LoadForenamesByCountry() {
          continue;
        }
        const auto& name_object = name_value.as_object();
-        entries.emplace_back(ForenameEntry{
+        entries.push_back(ForenameEntry{
            .name =
                ReadFirstOfStringArray(name_object, "romanized", "localized"),
            .gender = ReadRequiredString(name_object, "gender"),
@@ -226,39 +215,22 @@ const ForenamesByCountryMap& CuratedJsonDataService::LoadForenamesByCountry() {
    forenames_by_country.emplace(country_code, std::move(entries));
  }

-  cache_.forenames_by_country = std::move(forenames_by_country);
-  return cache_.forenames_by_country;
-}
-
-const SurnamesByCountryMap& CuratedJsonDataService::LoadSurnamesByCountry() {
-  if (!cache_.surnames_by_country.empty()) {
-    return cache_.surnames_by_country;
-  }
-
-  const boost::json::value root =
-      ParseJsonFile(filepaths_.surnames_path, "surnames-by-country");
-
-  if (!root.is_object()) {
-    throw std::runtime_error(
-        "Invalid surnames-by-country JSON: root element must be an object "
-        "keyed by ISO 3166-1 country code");
-  }
-
-  SurnamesByCountryMap surnames_by_country;
-  for (const auto& [country_code, name_entries] : root.as_object()) {
-    if (!name_entries.is_array()) continue;
-
-    SurnameList surnames;
+  std::unordered_map<std::string, std::vector<std::string>> surnames_by_country;
+  for (const auto& [country_code, name_entries] : surnames_root.as_object()) {
+    if (!name_entries.is_array()) {
+      continue;
+    }
+    std::vector<std::string> surnames;
    for (const auto& name_value : name_entries.as_array()) {
      if (!name_value.is_object()) {
        continue;
      }
-      surnames.emplace_back(ReadFirstOfStringArray(name_value.as_object(),
-                                                   "romanized", "localized"));
+      surnames.push_back(ReadFirstOfStringArray(name_value.as_object(),
+                                                "romanized", "localized"));
    }
    surnames_by_country.emplace(country_code, std::move(surnames));
  }

-  cache_.surnames_by_country = std::move(surnames_by_country);
-  return cache_.surnames_by_country;
+  return NamesByCountry(std::move(forenames_by_country),
+                        std::move(surnames_by_country));
 }
--- a/tooling/pipeline/src/main.cc
+++ b/tooling/pipeline/src/main.cc
@@ -18,7 +18,27 @@
 #include <string>
 #include <thread>

-#include "biergarten_pipeline.h"
+#include "biergarten_pipeline_orchestrator.h"
+#include "concurrency/bounded_channel.h"
+#include "data_generation/llama_generator.h"
+#include "data_generation/mock_generator.h"
+#include "data_generation/prompt_formatting/gemma4_jinja_prompt_formatter.h"
+#include "data_model/models.h"
+#include "json_handling/json_loader.h"
+#include "llama_backend_state.h"
+#include "services/curated_data/curated_data_service.h"
+#include "services/database/export_service.h"
+#include "services/database/sqlite_export_service.h"
+#include "services/datetime/timer.h"
+#include "services/enrichment/enrichment_service.h"
+#include "services/enrichment/mock_enrichment.h"
+#include "services/enrichment/wikipedia_service.h"
+#include "services/logging/log_dispatcher.h"
+#include "services/logging/log_entry.h"
+#include "services/logging/log_producer.h"
+#include "services/logging/logger.h"
+#include "services/prompting/prompt_directory.h"
+#include "web_client/http_web_client.h"

 namespace di = boost::di;

@@ -29,7 +49,7 @@ int main(const int argc, char** argv) {
  spdlog::set_pattern("│ %Y-%m-%d %H:%M:%S.%e │ %^%-7l%$ │ %v");
  BoundedChannel<LogEntry> log_channel(kLogMaxCount);

-  auto log_dispatcher =  //
+  auto log_dispatcher = //
      std::make_unique<LogDispatcher>(log_channel);
  std::shared_ptr<ILogger> log_producer =
      std::make_shared<LogProducer>(log_channel);
@@ -86,43 +106,22 @@ int main(const int argc, char** argv) {
        di::bind<ApplicationOptions>().to(options),
        di::bind<std::string>().to(model_path),
        di::bind<IExportService>().to<SqliteExportService>(),
-        di::bind<ICuratedDataService>().to(
-            [options, &log_producer]() -> std::unique_ptr<ICuratedDataService> {
-              if (options.generator.use_mocked) {
-                log_producer->Log({.level = LogLevel::Info,
-                                   .phase = PipelinePhase::Startup,
-                                   .message = "Curated data: mock"});
-
-                return std::make_unique<MockCuratedDataService>();
-              }
-
-              log_producer->Log({.level = LogLevel::Info,
-                                 .phase = PipelinePhase::Startup,
-                                 .message = "Curated data: JsonLoader"});
-
-              return std::make_unique<CuratedJsonDataService>(
-                  CuratedDataFilePaths{
-                      .locations_path = "locations.json",
-                      .personas_path = "personas.json",
-                      .forenames_path = "forenames-by-country.json",
-                      .surnames_path = "surnames-by-country.json",
-                  });
-            }),
+        di::bind<ICuratedDataService>().to<JsonLoader>(),
        di::bind<IPromptFormatter>().to([options, log_producer] {
          if (options.generator.use_mocked) {
            {
              log_producer->Log(
-                  {.level = LogLevel::Info,
-                   .phase = PipelinePhase::Startup,
-                   .message = "Prompt formatter: none (mock mode)"});
+              {.level = LogLevel::Info,
+               .phase = PipelinePhase::Startup,
+               .message = "Prompt formatter: none (mock mode)"});
            }
            return std::unique_ptr<IPromptFormatter>(nullptr);
          }
          {
            log_producer->Log(
-                {.level = LogLevel::Info,
-                 .phase = PipelinePhase::Startup,
-                 .message = "Prompt formatter: Gemma4JinjaPromptFormatter"});
+            {.level = LogLevel::Info,
+             .phase = PipelinePhase::Startup,
+             .message = "Prompt formatter: Gemma4JinjaPromptFormatter"});
          }
          return std::unique_ptr<IPromptFormatter>(
              std::make_unique<Gemma4JinjaPromptFormatter>());
@@ -146,7 +145,7 @@ int main(const int argc, char** argv) {
        }),
        di::bind<IEnrichmentService>().to(
            [options, &log_producer](
-                const auto& inj) -> std::unique_ptr<IEnrichmentService> {
+            const auto& inj) -> std::unique_ptr<IEnrichmentService> {
              if (options.generator.use_mocked) {
                log_producer->Log({.level = LogLevel::Info,
                                   .phase = PipelinePhase::Startup,
@@ -165,7 +164,8 @@ int main(const int argc, char** argv) {
            }),
        di::bind<DataGenerator>().to(
            [&options, &model_path, &sampling, &prompt_directory,
-             &log_producer](const auto& inj) -> std::unique_ptr<DataGenerator> {
+              &log_producer
+            ](const auto& inj) -> std::unique_ptr<DataGenerator> {
              if (options.generator.use_mocked) {
                log_producer->Log({.level = LogLevel::Info,
                                   .phase = PipelinePhase::Startup,
@@ -174,28 +174,19 @@ int main(const int argc, char** argv) {
                return std::make_unique<MockGenerator>();
              }

-#ifdef BIERGARTEN_MOCK_ONLY
-              // Unreachable: ParseArguments requires --mocked when
-              // BIERGARTEN_MOCK_ONLY is compiled in, so LlamaGenerator is
-              // never constructed and is not linked into this binary.
-              throw std::runtime_error(
-                  "LlamaGenerator is unavailable in a BIERGARTEN_MOCK_ONLY "
-                  "build");
-#else
              log_producer->Log(
-                  {.level = LogLevel::Info,
-                   .phase = PipelinePhase::Startup,
-                   .message = std::format(
-                       "Generator: LlamaGenerator | model={} | "
-                       "temp={:.2f} top_p={:.2f} top_k={} n_ctx={} seed={}",
-                       model_path, sampling.temperature, sampling.top_p,
-                       sampling.top_k, sampling.n_ctx, sampling.seed)});
+              {.level = LogLevel::Info,
+               .phase = PipelinePhase::Startup,
+               .message = std::format(
+                   "Generator: LlamaGenerator | model={} | "
+                   "temp={:.2f} top_p={:.2f} top_k={} n_ctx={} seed={}",
+                   model_path, sampling.temperature, sampling.top_p,
+                   sampling.top_k, sampling.n_ctx, sampling.seed)});

              return std::make_unique<LlamaGenerator>(
                  options, model_path, log_producer,
                  inj.template create<std::unique_ptr<IPromptFormatter>>(),
                  std::move(prompt_directory));
-#endif
            }));

    const auto orchestrator =
--- a/tooling/pipeline/src/services/curated_data/mock_curated_data_service.cc
+++ b/tooling/pipeline/src/services/curated_data/mock_curated_data_service.cc
@@ -1,98 +0,0 @@
-/**
- * @file services/curated_data/mock_curated_data_service.cc
- * @brief Fixed in-memory location, persona, and name dataset for mock mode.
- */
-
-#include "services/curated_data/mock_curated_data_service.h"
-
-MockCuratedDataService::MockCuratedDataService()
-    : locations_{
-          Location{.city = "Portland",
-                   .state_province = "Oregon",
-                   .iso3166_2 = "US-OR",
-                   .country = "United States",
-                   .iso3166_1 = "US",
-                   .local_languages = {"en"},
-                   .latitude = 45.5152,
-                   .longitude = -122.6784},
-          Location{.city = "Munich",
-                   .state_province = "Bavaria",
-                   .iso3166_2 = "DE-BY",
-                   .country = "Germany",
-                   .iso3166_1 = "DE",
-                   .local_languages = {"de"},
-                   .latitude = 48.1351,
-                   .longitude = 11.5820},
-          Location{.city = "Lyon",
-                   .state_province = "Auvergne-Rhone-Alpes",
-                   .iso3166_2 = "FR-ARA",
-                   .country = "France",
-                   .iso3166_1 = "FR",
-                   .local_languages = {"fr"},
-                   .latitude = 45.7640,
-                   .longitude = 4.8357},
-          Location{.city = "Brussels",
-                   .state_province = "Brussels-Capital",
-                   .iso3166_2 = "BE-BRU",
-                   .country = "Belgium",
-                   .iso3166_1 = "BE",
-                   .local_languages = {"nl", "fr"},
-                   .latitude = 50.8503,
-                   .longitude = 4.3517},
-      },
-      personas_{
-          UserPersona{.name = "Hophead Explorer",
-                      .description = "Chases hop-forward IPAs and seeks out "
-                                     "taprooms with rotating drafts.",
-                      .style_affinities = {"IPA", "Pale Ale"}},
-          UserPersona{.name = "Lager Traditionalist",
-                      .description = "Prefers clean, balanced lagers and "
-                                     "classic pub styles.",
-                      .style_affinities = {"Lager", "Pilsner"}},
-          UserPersona{.name = "Sour Curious",
-                      .description = "Seeks out wild ales, sours, and "
-                                     "barrel-aged experiments.",
-                      .style_affinities = {"Sour", "Wild Ale"}},
-      },
-      forenames_by_country_{
-          {"US",
-           ForenameList{
-               ForenameEntry{.name = "James", .gender = "M"},
-               ForenameEntry{.name = "Mary", .gender = "F"},
-           }},
-          {"DE",
-           ForenameList{
-               ForenameEntry{.name = "Lukas", .gender = "M"},
-               ForenameEntry{.name = "Anna", .gender = "F"},
-           }},
-          {"FR",
-           ForenameList{
-               ForenameEntry{.name = "Lucas", .gender = "M"},
-               ForenameEntry{.name = "Camille", .gender = "F"},
-           }},
-          {"BE",
-           ForenameList{
-               ForenameEntry{.name = "Noah", .gender = "M"},
-               ForenameEntry{.name = "Emma", .gender = "F"},
-           }},
-      },
-      surnames_by_country_{
-          {"US", SurnameList{"Smith", "Johnson"}},
-          {"DE", SurnameList{"Muller", "Schmidt"}},
-          {"FR", SurnameList{"Martin", "Bernard"}},
-          {"BE", SurnameList{"Peeters", "Janssens"}},
-      } {}
-
-const LocationsList& MockCuratedDataService::LoadLocations() {
-  return locations_;
-}
-
-const PersonasList& MockCuratedDataService::LoadPersonas() { return personas_; }
-
-const ForenamesByCountryMap& MockCuratedDataService::LoadForenamesByCountry() {
-  return forenames_by_country_;
-}
-
-const SurnamesByCountryMap& MockCuratedDataService::LoadSurnamesByCountry() {
-  return surnames_by_country_;
-}
--- a/tooling/pipeline/src/services/sqlite/helpers/sqlite_statement_helpers.cc
+++ b/tooling/pipeline/src/services/sqlite/helpers/sqlite_statement_helpers.cc
@@ -33,7 +33,7 @@ void ResetStatement(SqliteStatementHandle& statement) {
 }

 void Bind(const SqliteStatementHandle& statement,
-          const BoundParam<std::string_view>& param) {
+          const BindParam<std::string_view>& param) {
  const auto byte_count = param.value.size();
  if (byte_count > static_cast<std::size_t>(std::numeric_limits<int>::max())) {
    ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
@@ -60,7 +60,7 @@ void Bind(const SqliteStatementHandle& statement,
 }

 void Bind(const SqliteStatementHandle& statement,
-          const BoundParam<double>& param) {
+          const BindParam<double>& param) {
  if (sqlite3_bind_double(statement.get(), param.index, param.value) !=
      SQLITE_OK) {
    ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
@@ -68,7 +68,7 @@ void Bind(const SqliteStatementHandle& statement,
 }

 void Bind(const SqliteStatementHandle& statement,
-          const BoundParam<sqlite3_int64>& param) {
+          const BindParam<sqlite3_int64>& param) {
  if (sqlite3_bind_int64(statement.get(), param.index, param.value) !=
      SQLITE_OK) {
    ThrowSqliteError(sqlite3_db_handle(statement.get()), param.action);
--- a/tooling/pipeline/src/services/sqlite/process_record.cc
+++ b/tooling/pipeline/src/services/sqlite/process_record.cc
@@ -42,50 +42,50 @@ sqlite3_int64 SqliteExportService::ResolveLocationId(const Location& location) {

  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kLocationCityBindIndex,
          .value = location.city,
          .action = "Failed to bind SQLite location city"});
  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index =
              sqlite_export_service_internal::kLocationStateProvinceBindIndex,
          .value = location.state_province,
          .action = "Failed to bind SQLite location state/province"});
  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kLocationIso31662BindIndex,
          .value = location.iso3166_2,
          .action = "Failed to bind SQLite location ISO 3166-2 code"});
  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kLocationCountryBindIndex,
          .value = location.country,
          .action = "Failed to bind SQLite location country"});
  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kLocationIso31661BindIndex,
          .value = location.iso3166_1,
          .action = "Failed to bind SQLite location ISO 3166-1 code"});
  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kLocationLanguagesBindIndex,
          .value = local_languages_json,
          .action = "Failed to bind SQLite location languages"});
  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam{
+      sqlite_export_service_internal::BindParam{
          .index = sqlite_export_service_internal::kLocationLatitudeBindIndex,
          .value = location.latitude,
          .action = "Failed to bind SQLite location latitude"});
  sqlite_export_service_internal::Bind(
      insert_location_stmt_,
-      sqlite_export_service_internal::BoundParam{
+      sqlite_export_service_internal::BindParam{
          .index = sqlite_export_service_internal::kLocationLongitudeBindIndex,
          .value = location.longitude,
          .action = "Failed to bind SQLite location longitude"});
@@ -111,21 +111,21 @@ uint64_t SqliteExportService::ProcessRecord(const BreweryRecord& brewery) {

  sqlite_export_service_internal::Bind(
      insert_brewery_stmt_,
-      sqlite_export_service_internal::BoundParam<sqlite3_int64>{
+      sqlite_export_service_internal::BindParam<sqlite3_int64>{
          .index = sqlite_export_service_internal::kBreweryLocationIdBindIndex,
          .value = location_id,
          .action = "Failed to bind SQLite brewery location id"});

  sqlite_export_service_internal::Bind(
      insert_brewery_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kBreweryEnglishNameBindIndex,
          .value = brewery.brewery.name_en,
          .action = "Failed to bind SQLite brewery English name"});

  sqlite_export_service_internal::Bind(
      insert_brewery_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::
              kBreweryEnglishDescriptionBindIndex,
          .value = brewery.brewery.description_en,
@@ -133,14 +133,14 @@ uint64_t SqliteExportService::ProcessRecord(const BreweryRecord& brewery) {

  sqlite_export_service_internal::Bind(
      insert_brewery_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kBreweryLocalNameBindIndex,
          .value = brewery.brewery.name_local,
          .action = "Failed to bind SQLite brewery local name"});

  sqlite_export_service_internal::Bind(
      insert_brewery_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index =
              sqlite_export_service_internal::kBreweryLocalDescriptionBindIndex,
          .value = brewery.brewery.description_local,
--- a/tooling/pipeline/src/services/sqlite/process_user_record.cc
+++ b/tooling/pipeline/src/services/sqlite/process_user_record.cc
@@ -17,55 +17,55 @@ uint64_t SqliteExportService::ProcessRecord(const UserRecord& user) {

  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<sqlite3_int64>{
+      sqlite_export_service_internal::BindParam<sqlite3_int64>{
          .index = sqlite_export_service_internal::kUserLocationIdBindIndex,
          .value = location_id,
          .action = "Failed to bind SQLite user location id"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kUserFirstNameBindIndex,
          .value = user.user.first_name,
          .action = "Failed to bind SQLite user first name"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kUserLastNameBindIndex,
          .value = user.user.last_name,
          .action = "Failed to bind SQLite user last name"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kUserGenderBindIndex,
          .value = user.user.gender,
          .action = "Failed to bind SQLite user gender"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kUserUsernameBindIndex,
          .value = user.user.username,
          .action = "Failed to bind SQLite user username"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kUserBioBindIndex,
          .value = user.user.bio,
          .action = "Failed to bind SQLite user bio"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<double>{
+      sqlite_export_service_internal::BindParam<double>{
          .index = sqlite_export_service_internal::kUserActivityWeightBindIndex,
          .value = static_cast<double>(user.user.activity_weight),
          .action = "Failed to bind SQLite user activity weight"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kUserEmailBindIndex,
          .value = user.email,
          .action = "Failed to bind SQLite user email"});
  sqlite_export_service_internal::Bind(
      insert_user_stmt_,
-      sqlite_export_service_internal::BoundParam<std::string_view>{
+      sqlite_export_service_internal::BindParam<std::string_view>{
          .index = sqlite_export_service_internal::kUserDateOfBirthBindIndex,
          .value = user.date_of_birth,
          .action = "Failed to bind SQLite user date of birth"});
Author	SHA1	Message	Date
Aaron Po	98f97b8e2c	add symlink to web docs	2026-06-27 23:34:30 -04:00
Aaron Po	2adc1eae38	update pipeline results viewer	2026-06-27 23:32:08 -04:00
Aaron Po	9d2ce67a78	Run pipeling, update sqllite file	2026-06-27 22:40:22 -04:00
Aaron Po	d1ad1eb397	rename json loader	2026-06-27 15:16:34 -04:00
Aaron Po	9137f4bddb	Do full Gemma-4 run of pipeline, transfer sqllite file to public dir of preview	2026-06-23 22:02:17 -04:00
Aaron Po	6883b05824	remove password field	2026-06-23 01:39:57 -04:00
Aaron Po	b631c0f5db	add results viewer	2026-06-23 01:27:37 -04:00
Aaron Po	9a9ffd59e6	Formatted src/biergarten_pipeline_orchestrator	2026-06-23 01:04:52 -04:00
Aaron Po	35a5c0785c	documentation updates, remove superfluous comments	2026-06-23 01:04:46 -04:00
Aaron Po	e590cf2543	edit .clang-format	2026-06-23 00:50:27 -04:00
Aaron Po	3b32766a83	edits	2026-06-23 00:48:20 -04:00
Aaron Po	8d6b83673b	Update doxygen comments	2026-06-23 00:45:32 -04:00
Aaron Po	22b3f2b3f9	cleanup gbnf grammars	2026-06-23 00:38:53 -04:00
Aaron Po	ac701d661a	Remove logger from JSON export	2026-06-23 00:19:28 -04:00
Aaron Po	3f978f4de4	Cleanup user and brewery generation exception logic	2026-06-21 23:09:29 -04:00
Aaron Po	ad97b0ea6c	format	2026-06-21 22:14:42 -04:00
Aaron Po	4de0ea6638	Persist generated users to SQLite and code cleanup	2026-06-21 22:14:42 -04:00
Aaron Po	51b40a39c9	Add user generation feature	2026-06-21 22:14:42 -04:00