# Product Promise & Subsystem Glossary

```mermaid
classDiagram
  class SharedSpine {
    +identity
    +worldState
    +online
    +creator
  }
  class NarrativeTruth {
    +caseLedger
    +mindPalace
    +relationships
    +consequences
  }
  class RulesetCell {
    +movementGrammar
    +combatGrammar
    +simulationPolicy
  }
  class EvidencePlane {
    +telemetry
    +qualityGates
    +releaseDecision
  }
  SharedSpine *-- NarrativeTruth
  SharedSpine o-- RulesetCell
  SharedSpine --> EvidencePlane
  RulesetCell --> NarrativeTruth : emits consequences
```

The shared spine owns identity and durable world state; a ruleset cell owns only
the mechanics that make its genre distinct. Narrative truth composes with both,
while the evidence plane decides whether their integration is safe to release.

V5 is the largest of the V-products: one Unreal Engine 5.5 open-world
narrative-action game built as a universe of distinct **ruleset cells** — urban
crime, period drama, frontier, monster hunter, and two sci-fi flavours — sharing
one roster ("Cross-Continuum Bureau"), one cross-cell Mind Palace deduction
layer, one creator suite, and one online backbone. The pitch is not a launcher
bolted over unrelated titles but **per-genre feel on a single spine**: a Hong
Kong triad brawl, a 1947 noir interrogation, a frontier outlaw chase, a Witcher
contract hunt, and a Newtonian ship duel must each feel like its own genre while
reading stimuli from the same perception model and depositing evidence into the
same deduction graph. The architecture exists to make that shippable — each
ruleset is a swappable gameplay layer over common engine modules, so cells can
be enabled, stripped per platform, or DLC-gated without forking the foundation.

That ambition is wired through the repository, and at a scale that dwarfs its
siblings. The UE project at `V5/ue/V5.uproject` pins
`"EngineAssociation": "5.5"` and declares **74 C++ modules** — verified
one-to-one against 74 directories under `V5/ue/Source/` — alongside a curated
engine-plugin set (GameplayAbilities, EnhancedInput, CommonUI +
ModelViewViewModel, the Mover/PoseSearch/Chooser motion-matching stack, Niagara,
MetaSounds, the Chaos cloth/flesh/vehicle set, MetaHumanRuntime, PCG,
MassEntity, Iris + NetworkPrediction + ReplicationGraph, GameFeatures +
ModularGameplay). The tree carries **328 `.cpp` and 341 `.h`** files of
domain-specific gameplay code, **five** build targets, **29** content plugins
under `V5/ue/Plugins/`, and a sixteen-service TypeScript backend under
`apps/v5/`. Like V2 and V4, V5 holds itself to a target-artifact discipline:
"Where a section names a module or path, it names a **target artifact** unless
the path already exists in the repo" (`V5/V5_ARCHITECTURE.md`, Purpose). This
page is the orientation door to that architecture — it states what V5 commits to
and separates what is real on disk from what is spec. The runtime topology and
module split are its sibling
[./topology-layout-module-split.md](./topology-layout-module-split.md), the
gameplay-framework layer is
[./gas-animation-input.md](./gas-animation-input.md), and the full section hub
is [../V5_ARCHITECTURE.md](../V5_ARCHITECTURE.md).

## What ships, honestly

The **module skeleton is real and exactly consistent.** Parsing `V5.uproject`
yields 74 `Modules` entries; `ls V5/ue/Source/` yields 74 module directories
(plus five `.Target.cs` files); the two sets are identical — **there are no
spec-only modules and no orphan directories.** Every module ships a
`*.Build.cs`, a `Public/`/`Private/` split, and a module class, and the depth is
concentrated where the genre needs it: the deepest module is **`V5MindPalace`
(36 files)** — the cross-cell deduction engine, with public surfaces for
`AddEvidenceNode`, `AttemptDeduction`, `BuildHypothesisChain`, `MakeAccusation`,
`CrossEraGate`, and `CloudSyncHttp` — followed by `V5Melee` and
`V5Investigation` (22 each), `V5Spaceship` and `V5Interrogation` (20 each), and
`V5StarMap`, `V5Squad`, `V5Combat` (18 each). `V5Spaceship` carries a real
`AV5_Ship_NewtonianPawn` with `ConfigureShip`, `SetNewtonianState`, and
`RCSTorqueDegPerSecond` thruster math — not a renamed CRUD shell. Even the
leanest non-bootstrap modules ship a real subsystem plus a `*Types.h`, not a
three-file stub.

The **single biggest honest correction** this page makes concerns where the cell
gameplay lives. The architecture prose frames each mode as a hot-swappable
`GameFeatures` **plugin**. On disk, the cell _code_ is instead a statically
compiled **Source module**: `V5UrbanHeistCity`, `V5HunterWitchersPath`,
`V5FrontierOutlawTrail`, `V5SciFiGalacticSquad`, `V5SciFiHardVacuum`,
`V5PeriodMadeMan`, `V5DetectiveMindPalace`, and twelve more are real `Runtime`
modules (each with `*Systems.cpp`, `*Types.h`, and a `Private/Tests/` spec)
named in the `.uproject` `Modules` array. The matching `Plugins/V5Mode_*`
directory is a **content/manifest shell**: all **29** `V5Mode_*` plugins carry
**zero `.cpp`**, hold only JSON manifests under `Content/Data/`, declare
`"EnabledByDefault": false`, and there are **zero `GameFeatureData.uasset`**
binaries in the entire `Plugins/` tree. None of the 29 are listed in the
`.uproject` `Plugins` array. So the "hot-swap GameFeatures" story is **half
realized**: the runtime code exists and compiles into the monolith; the binary
GameFeature data assets that would let it activate as a toggleable plugin are
not yet authored. The cells are modular _by source module_, not yet by _runtime
feature_.

The **build targets do real work — and the determinism posture lives in code,
not flags.** Five `*.Target.cs` files exist: `V5` (Game), `V5Editor` (Editor),
`V5DedicatedServer` (Server), `V5ListenServer` (Game), and `V5ArcadeCabinet`
(Game) — a richer target matrix than V4's three. The headless
`V5DedicatedServer` target is the standout: beyond a `V5_DEDICATED_SERVER=1`
define it carries a **real `DisablePlugins` list of 29 plugins** (Niagara,
MetaSounds, the Chaos set, MetaHumanRuntime, CommonUI, EnhancedInput, the
geometry-processing stack, PCG…), so the server build genuinely strips
client-only rendering/audio/physics — concrete per-target stripping V4's targets
only aspired to. Honestly labelled the other way: `V5_DEDICATED_SERVER` and
`V5_LISTEN_SERVER` are **defined but not referenced anywhere under `Source/`** —
they are reserved compile seams, exactly the caveat V2/V4 carry for their own
build defines. None of the five targets sets `/fp:strict` or a `DETERMINISM=*`
define; the "deterministic offline" and "rollback-emulated" netcode strategies
the promise names live inside `V5Netcode`, not stamped by the target.

The honest gaps, named rather than implied:

- **No authored binary content.** `V5/ue/Content/` holds **0 `.uasset` and 1
  `.umap`**, against **393 JSON** authoring/manifest sidecars. V5 is a
  **logic-and-manifest skeleton**: real C++ systems and structured data, but no
  hand-authored meshes, MetaHumans, mocap, VO, or cinematics in-tree. Every "AAA
  open-world" claim depends on art/audio production that is not in the
  repository.
- **A cross-product plugin reference.** The `.uproject` `Plugins` array enables
  **`V8_Ariadne_CaseClient`** — a plugin owned by the V8 (Ariadne) detective
  product, not present under `V5/ue/Plugins/`. It appears only as compiled
  artifacts under `Binaries/`/`Intermediate/`, so it builds _into_ V5 but its
  source is shared from elsewhere; treat it as a deliberate cross-cell
  case-client reuse, labelled here because the source is not local.
- **The backend is TypeScript, not Rust.** `apps/v5/` is a **NestJS-style
  TypeScript** workspace — 234 `.ts` across 16 services (`auth`, `friends`,
  `parties`, `matchmaking`, `leaderboards`, `replays`, `telemetry`,
  `anti-cheat`, `mindpalace-cloud-sync`, `workshop`, `compliance-dsar`, …), each
  with a `contract.json` + `contract.test.ts` + `Dockerfile` — plus a `web/`
  Next.js marketing site (`@v5/web`). This is a real, contract-tested backend,
  and a deliberate contrast with V4's three-crate Rust workspace.
- **Provider- and ops-gated surfaces.** Cross-play, anti-cheat, store/cert, and
  the live-service cadence depend on platform credentials and real operations;
  the 2026-05-31 audit and `V5/REMEDIATION_2026-06-12.md` mark these `[~]` and
  the latter _removed a fabricated launch-readiness manifest_ rather than
  letting the prose imply ship-state.

## The product promise

V5's promise, authored in `V5_features.md` and mirrored in the architecture's
`V5 Product Promise` section, is a small set of non-negotiable commitments. The
unifying idea is **per-genre feel, one shared spine**, and each commitment has a
code anchor or an honest status.

| #   | Commitment                                                                             | Code-grounding / status                                                                                        |
| --- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| 1   | One coherent game delivering per-genre feel across all launch cells                    | 74 `Source/` modules incl. per-mode cell modules; identity routed by `V5Modes` + `EV5Cell` (`V5Core`)          |
| 2   | Per-cell netcode envelope (dedicated-server, rollback-emulated, offline-deterministic) | `V5Netcode` (one module hosts all three paths); `V5DedicatedServer.Target.cs` is a real `TargetType.Server`    |
| 3   | One shared AI perception model across every NPC in every cell                          | `V5Perception` (10 files) — unified sight/hearing/suspicion, consumed by every cell                            |
| 4   | One shared roster across cells, cell-specific overrides hung off a character record    | `EV5Cell`-keyed character data in `V5Core`/`V5Gameplay`; per-cell mesh/morphology overrides                    |
| 5   | One cross-cell Mind Palace deduction layer                                             | `V5MindPalace` (36 files) — evidence graph, hypothesis chains, cross-era gate; cells push evidence in          |
| 6   | One creator suite (Mission/Heist/Case/Contract/Loadout/Bestiary authoring)             | `V5MissionEditor`, `V5HeistAuthor`, `V5CaseAuthor`, `V5WorkshopEditor` (Editor-type modules) + `tools/`        |
| 7   | Cells enable/disable per platform, per build target, per DLC                           | `Plugins/V5Mode_*` manifests + per-cell `Content/` roots; **gap:** no `GameFeatureData.uasset` to hot-activate |
| 8   | One online backbone (auth, parties, matchmaking, leaderboards, replays, anti-cheat)    | `apps/v5/` — 16 contract-tested NestJS services; `V5OnlineServices` engine module is the client                |
| 9   | Run across nine platforms, including a dedicated and a listen-server SKU               | Five `.Target.cs`; `Platforms/` overrides for Windows/PS5/PS5Pro/XSX/XSS/Switch2/Mac/Linux/iOS                 |

Commitment 2 is one decision expressed as a **per-cell envelope**, because no
single strategy fits a 32-player open-world session, a co-op heist, and a 60 Hz
ship duel. Unlike V2 (which stamps rollback determinism through strict-FP build
flags) and like V4, V5 keeps that logic _inside_ `V5Netcode` rather than on the
targets — read the determinism prose as module-level intent, not a build-target
guarantee.

## The six-cell vision, and three honest cell counts

The cells are the product. The prompt frames V5 as **six ruleset cells** — urban
crime, period drama, frontier, monster hunter, and **two** sci-fi flavours — and
the disk bears that out, but the count needs care because three different
numbers are all correct in their own frame:

- **Five launch cells** is the marketing/promise framing: Urban, Period,
  Frontier, Hunter, Sci-Fi (`V5_ARCHITECTURE.md`, V5 Product Promise).
- **Six** is what you get counting the two distinct sci-fi gameplay modules as
  separate experiences: `V5SciFiGalacticSquad` (Mass-Effect-style squad RPG) and
  `V5SciFiHardVacuum` (hard-sim Newtonian flight via `V5Spaceship`), plus
  `V5SciFiPvP` for ship-duel deathmatch.
- **Seven** is the canonical engine count: `EV5Cell`
  (`V5/ue/Source/V5Core/Public/V5Types.h`) enumerates
  `Urban, Period, Frontier, Hunter, SciFi, Steampunk, MindPalace` — the five
  launch cells plus the Brave New World **Steampunk Detective** DLC cell and the
  cross-cell **Mind Palace** meta-layer. Per-cell datasets and tests must size
  against `GetAllV5Cells()` (returning all seven, defined in `V5Types.cpp`), not
  a literal 5 or 6 — the 2026-05-31 audit traced four automation failures to
  exactly that mismatch.

Each cell is realized as a family of compiled Source modules: **Urban**
(`V5UrbanHeistCity`, `V5UrbanStreetTriad`, `V5UrbanOnline`, over `V5Heist`,
`V5Wanted`, `V5Parkour`, `V5Karaoke`); **Period** (`V5PeriodMadeMan`,
`V5PeriodViceSquad`, over `V5Interrogation`, `V5FaceCapture`, `V5PeriodAuth`);
**Frontier** (`V5FrontierOutlawTrail`, `V5FrontierOnline`, over `V5Honor`,
`V5Hunting`, `V5HorseAI`, `V5DeadEye`); **Hunter** (`V5HunterWitchersPath`,
`V5HunterContractBoard`, `V5HunterCardGame`, over `V5Alchemy`, `V5Signs`,
`V5MonsterHunt`); and **Sci-Fi** (`V5SciFiGalacticSquad`, `V5SciFiHardVacuum`,
`V5SciFiPvP`, over `V5Spaceship`, `V5StarMap`, `V5Squad`). The cells are held
together — not blended — by shared infrastructure: a triad goon, a noir witness,
an outlaw, a drowner, and a station guard all read the _same_ `V5Perception`
state machine; `V5MindPalace` links `V5Investigation` so evidence picked up in
any cell can pair across eras; and `V5Modes` gates which cell's ruleset and HUD
are live.

## The subsystem glossary, mapped to code

The architecture monolith's "Engine Modules" glossary lists **48** names, and
the good news is that **all 48 exist on disk, one-to-one** — no spec-only
entries, the V4-style happy case. The reconciliation worth knowing is the
_other_ direction: the disk carries **26 modules the glossary table omits**, in
three groups.

- **Four infrastructure modules** the table skips: `V5` (the thin composition
  root — three files, depending only on
  `Core`/`CoreUObject`/`Engine`/`InputCore`, named by every target via
  `ExtraModuleNames.Add("V5")`, fusing nothing itself), `V5Accessibility`,
  `V5Localization`, and `V5Compliance`.
- **Eighteen per-mode cell modules** — the `V5UrbanHeistCity` … `V5SpecOpsCoop`
  set described above. These are the modules the prose expected to be
  `GameFeatures` plugins; they are compiled `Runtime` modules instead, each with
  a colocated `Private/Tests/` spec.
- **Four creator-suite modules**: `V5MissionEditor`, `V5HeistAuthor`,
  `V5CaseAuthor`, `V5WorkshopEditor` (all `Editor`-type), realizing promise #6.

Grouped by concern, the 48 catalogue modules read as: a **foundation** (`V5Core`
— tags registry, save scaffolding, the `EV5Cell` enum); a **gameplay-framework
spine** (`V5Gameplay` with real GAS — `UV5_AttributeSet_Combat : UAttributeSet`
exposing Health/MaxHealth/Stamina; plus `V5Animation`, `V5Input`, `V5Netcode`,
`V5Modes` — detailed in [./gas-animation-input.md](./gas-animation-input.md)); a
**shared-AI layer** (`V5Perception`, `V5Crowd`, `V5Schedules`); the **per-cell
gameplay systems** (`V5Combat`, `V5Melee`, `V5Vehicles`, `V5Spaceship`,
`V5Alchemy`, `V5Signs`, `V5MonsterHunt`, `V5Heist`, `V5Investigation`,
`V5Interrogation`, `V5DeadEye`, `V5Honor`, `V5Hunting`, `V5HorseAI`,
`V5Parkour`, `V5LockpickHack`, `V5Karaoke`, `V5CardGame`, `V5RadioTV`,
`V5StarMap`, `V5Squad`); the **cross-cell layer** (`V5MindPalace`, `V5Dialogue`,
`V5PeriodAuth`, `V5FaceCapture`); the **presentation/services** modules (`V5UI`,
`V5Audio`, `V5VFX`, `V5Cinematics`, `V5Persistence`, `V5OnlineServices`,
`V5Telemetry`, `V5Hub`, `V5Open`, `V5Procgen`); and the DLC/test pair
(`V5SteampunkDetective`, `V5Tests`). Inter-module dependencies are declared
explicitly in each `*.Build.cs` and run one-way —
`V5Combat → V5Core, V5Gameplay`; `V5MindPalace → V5Core, V5Investigation`;
`V5UrbanHeistCity → V5Core, V5Wanted` — with the cross-cell-shared modules
forbidden from depending on any per-cell module (the acyclic-graph property
[./topology-layout-module-split.md](./topology-layout-module-split.md) audits in
full).

One more glossary-to-code note on **testing**: where V4 centralizes 92 specs in
a single `V4Tests` module, V5 **distributes** its automation — **73 of 74
modules ship their own `Private/Tests/` directory** (74 test `.cpp` total), so
the cell that owns a system also owns its UE automation spec, and `V5Tests`
itself is a lean six-file harness rather than the bulk of the test code.

## How the promise is kept honest

Two conventions keep V5's prose from drifting ahead of its tree. First, the
**target-artifact convention** above: a section that names a module or path
either points at a file that exists or declares a target the owning TODO must
build with tests. Second, the **cross-reference convention**: a bare `§N`/`§N.M`
resolves to a numbered task in `V5_TODOS.md`, while `deps§N` →
`V5_DEPENDENCIES.md`, `features§"anchor"` → `V5_features.md`, and
`arch§"anchor"` → the architecture hub. The most concrete honesty mechanism is
`V5/REMEDIATION_2026-06-12.md`, which **deleted a fabricated launch-readiness
manifest** that had asserted shippability the repo could not back. The precise
claim a reader can make today: V5's _systems_ — 74 modules, 669 source files,
distributed UE automation — are real and compile; the _content_ that dresses
them (meshes, MetaHumans, VO, cinematics, the binary `GameFeatureData.uasset`
that would hot-activate the mode plugins) is production-gated and not yet
in-tree; and the _operations_ claims are marked `[~]` until they can occur.

## Related

- Hub: [../V5_ARCHITECTURE.md](../V5_ARCHITECTURE.md); feature map
  `V5/V5_features.md`; backlog `V5/V5_TODOS.md`; dependencies
  `V5/V5_DEPENDENCIES.md`; remediation log `V5/REMEDIATION_2026-06-12.md`.
- [./topology-layout-module-split.md](./topology-layout-module-split.md) — the
  runtime tiers, project layout, the acyclic module graph, and the five build
  targets in full.
- [./gas-animation-input.md](./gas-animation-input.md) — the Gameplay Ability
  System spine, the motion-matching animation stack, and the Enhanced Input
  layer that every cell rides.
- [../../platform/overview.html](../../platform/overview.html) — the shared
  Oshun platform foundations the V5 services and identity surfaces build on.