The
apps/v7/area: the nine deployable services and tools of the V7 "Mawu" UGC-realm platform — a server-authoritative creator-world runtime, its meshing/persistence/gateway substrate, a malware-and-child-safety scanner, and the marketplace and governance services that sit on top.
What this area is#
apps/v7/ is one Nx-tracked app cluster: nine application-type projects, all
tagged scope:v7, that together implement the backend of a hosted
user-generated "realm" platform (the V7 / Mawu universe). It is a polyglot area
by design. Seven of the nine are Rust crates that live in a single Cargo
workspace (apps/v7/Cargo.toml, resolver = "2", members listed there) and
form the latency-sensitive game substrate; the other two are TypeScript services
(@v7/abundantia-market-service, @v7/eunomia-governance-service) that own the
business-logic surfaces — marketplace and governance — where rich domain schemas
matter more than per-tick performance. This split follows the repo's stack rule:
Rust for the realm/network/runtime kernels, TypeScript for orchestration and
business services.
Every service shares one health/identity convention. The Rust crates each
#[path = "../../service_contract.rs"] in the shared
apps/v7/service_contract.rs module, which defines a ServiceDescriptor (name,
owner, port, purpose, capabilities) plus a minimal std::net::TcpListener HTTP
server (run_health_server, render_health_json) and a worktree-aware
port-override scheme (V7_<NAME>_PORT / V7_PORT_OFFSET). The two TypeScript
services mirror the same shape with a V7ServiceDescriptor / V7HealthDocument
pair and a createHealthDocument / renderHealthJson exported from their
service.ts, served over node:http in main.ts. The result is a uniform
/health contract across both languages, and a stable per-service port map:
Moremi 47201, Danu 47202, Nephthys 47203, Mawu 47204, Sekhmet 47205, Hera 47206
(Rust), Abundantia 47301, Eunomia 47302 (TypeScript).
The services are layered. v7-moremi-realm-server is the authoritative realm
runtime and the densest crate in the area; it composes v7-danu-mesh-cluster
(authority meshing) and the libs/v7/* crates (v7-nana character/economy,
v7-realm-protocol wire protocol, v7-substrate-bridge identity firewall). The
gateway (v7-mawu-gateway) fronts it for attested clients,
v7-nephthys-replica-service persists its event-sourced state,
v7-sekhmet-scanner gates the content that flows through it, and
v7-hera-social-service carries the cross-realm social graph.
@v7/abundantia-market-service and @v7/eunomia-governance-service are the
creator-economy and self-governance layers above the runtime, and
v7-dev-hygiene is the local-dev tooling that allocates per-worktree ports and
emits Agones manifests so several of these services can run side by side.
How it fits the wider system#
These nine projects are the V7 server tier. The Rust crates depend "downward"
into libs/v7/* (realm protocol, substrate bridge, nana) rather than on each
other, except the deliberate moremi → danu edge for authority handoff; the two
TypeScript services are self-contained domain services whose service.ts
carries the full implementation and whose main.ts is only the HTTP shell.
Cross-service coupling is expressed through shared schema-version constants
(e.g. the v7.moremi.*, v7.mawu.*, v7.sekhmet.*, v7.abundantia.*,
v7.eunomia.* namespaced strings) and named integration points — Sekhmet scan
reports gate Abundantia catalog publication and Eunomia's Maya "Verified" realm
gate; Nephthys is the handoff ledger Danu writes to; Mawu is the sole client
ingress in front of Moremi. Boundaries to other Oshun versions are explicit:
Mawu bridges V6 transport, and the substrate bridge projects V6 Ori identity.
Walk the dependency edges on each node below for the exact wiring.
Entity catalog (9)#
The 9 tracked Nx projects in v7, each a code-linked entity node — package, type, source path, declared targets, and its internal dependency graph (depends-on / used-by, resolved from the package manifests, §6/§8), read from the project graph. Grouped by architectural layer; walk the dependency links to travel the system. 9 of these carry an authored deep-dive (what / why / how it fits); the rest are generated scaffolds awaiting one.
service (8)#
V7 Abundantia catalog and creator-market service
The marketplace and creator-economy service (TypeScript; logic in
apps/v7/abundantia-market-service/src/service.ts, ~4.5k lines, with main.ts
serving /health over node:http; owner "Abundantia", port 47301). It is a
dense domain implementation — content-addressed catalog publication with a
SHA-256 content hasher (computeAbundantiaContentHash) and CDN object builder,
cross-platform install sync and one-click atomic collection installs gated on
Sekhmet-cleared fetch, a publishing lifecycle with semver linting and pinned-
version retention, and a full creator-payout engine: an engagement pool,
direct-sale/subscription rails, dependency-revenue chains, Aje settlement,
compliance hold gates, a currency firewall that blocks real-money/play-currency
leakage, retention-weighted payout eligibility, and a fraud-graph eval that
flags self-dealing and one-directional RMT flows. Schema versions are namespaced
v7.abundantia.* and the abundantiaMarketServiceDescriptor carries ~50
capabilities. Fully implemented; many helper functions referenced here continue
past the read window but the public API and its delegates are concrete domain
logic, not CRUD.
V7 Eunomia realm-governance service
The realm-governance and self-authoring-content service (TypeScript;
apps/v7/eunomia-governance-service/src/service.ts, ~1.6k lines; main.ts
serves /health; owner "Eunomia", port 47302). It implements five-tier
sovereign rule spaces (platform/game/realm/server/guild) with parent-override
consent and a safety-floor evaluator that can never be overridden
(EunomiaSafetyFloorPolicy covers minor-protection, CSAM-blocking, real-money
firewall, …), a proposal lifecycle state machine (draft → deliberation → vote →
execution → appeal), six plural-voting models with real per-model weight
formulas (pluralVotingBallotWeight: token, reputation,
sqrt(quadratic_credits), conviction stake×age, delegated, capped
time-weighted), and Themis appeal routing. It also owns the "Maya"
creator-variant system: fork publication with attribution/revenue-link chains,
canonical-variant voting, and a Maya Crucible economy verifier that actually
simulates baseline-worker vs exploit-seeker agents tick-by-tick
(simulateCrucibleAgent, detectCrucibleFindings) to block excessive-mint /
runaway-growth / infinite-currency-cycle realms before the Verified gate. Fully
implemented; deterministic simulation, not stubbed.
The realm-authority meshing control plane for dense regions
(apps/v7/danu-mesh-cluster/src/lib.rs, ~3.5k lines; owner "Danu", port 47202,
no external crate dependencies — pure std). It implements two-phase authority
handoff with a Nephthys-backed ledger and mid-handoff node-death recovery, grid
area-of-interest culling with a bounded client working set (DANU_AOI_*
constants), density-triggered dynamic split/merge meshing, a time-dilation
overload valve, and Agones fleet/allocation modelling (DanuAgonesScheduling,
DanuAgonesGameServerState, buffer autoscaler). The capability list and the
named eval constants (DANU_HANDOFF_EVAL_ENTITY_COUNT,
DANU_OVERLOAD_EVAL_TICKS, …) show these are concrete simulated evaluations
rather than placeholders. Moremi depends on this crate by path. Fully
implemented.
The crew-graph, presence, and reputation substrate
(apps/v7/hera-social-service/src/lib.rs, ~1.1k lines; owner "Hera", port
47206, pure std). It models PlatformBan and RealmJoinAttempt with
active-window logic and a 5-second ban-propagation SLA
(V7_BAN_PROPAGATION_SLA_MS), device-attestation ban-evasion evaluation, crew /
guild / org role-gated permissions, an Aje-backed group treasury with a
shared-asset audit ledger, cross-realm group reputation, and Ori-passport group
presence with an Aye V2 group-roster bridge. The eval schema-version constants
(V7_BAN_EVASION_EVAL_SCHEMA_VERSION, V7_HERA_GROUPS_EVAL_SCHEMA_VERSION,
V7_HERA_CROSS_VERSION_GROUP_PRESENCE_SCHEMA_VERSION) anchor its evaluation
surfaces. Fully implemented Rust, smaller in scope than the runtime crates but
real.
Attested client ingress and the V6 transport bridge in front of the realm tier
(apps/v7/mawu-gateway/src/lib.rs, ~3.4k lines; owner "Mawu", port 47204; deps
hmac, sha2, plus the v7-realm-protocol and v7-substrate-bridge libs). It
implements GSP "bring-your-own-compute" creator registration that is restricted
to sandboxed realm logic only — MAWU_GSP_FORBIDDEN_CREATOR_HOSTED_CAPABILITIES
hard-bans platform identity/economy/safety/payout, native host process, host
networking, and direct client ingress via the MawuGspRuntimeCapability enum —
plus DDoS scrubbing/rate-limiting, a platform voice-safety tap, HMAC-signed
client attestation join-gating (tampered/unsigned/operator-patched clients
denied), and streamer-mode privacy redaction with an anti-stream-sniping join
delay. Reuses the realm wire-protocol conformance and web-view-escape evals from
the substrate libs. Fully implemented.
The server-authoritative realm runtime and the core of the area
(apps/v7/moremi-realm-server/src/lib.rs, ~14.9k lines — by far the largest
crate here; main.rs is just moremi_realm_server::run_service()). Its
DESCRIPTOR (owner "Moremi", port 47201) advertises a fixed-timestep
deterministic sim with a dual-tick loop (MOREMI_FIXED_TIMESTEP_HZ = 30,
MOREMI_COMBAT_TICK_HZ = 60), a WASM-sandboxed resource lifecycle ("Ixchel")
that runs creator gameplay logic through real wasmtime component-model
instances under hard fuel/memory/table limits
(MOREMI_IXCHEL_DETERMINISTIC_FUEL_PER_TICK,
MOREMI_IXCHEL_MEMORY_LIMIT_BYTES), golden-replay CI gating, and a content
"forge" resolver built on pubgrub + semver version resolution and sha2
content hashing. It composes danu-mesh-cluster for authority handoff and the
libs/v7 crates v7-nana (character/economy/civic records),
v7-realm-protocol (event-tamper eval), and v7-substrate-bridge (identity
firewall, trust-boundary secret isolation, Ori projection). Fully implemented
Rust, not a scaffold.
Event-sourced persistence and replication for realm state
(apps/v7/nephthys-replica-service/src/lib.rs, ~3.1k lines; owner "Nephthys",
port 47203, pure std). It models aggregates by NephthysAggregateKind (Realm
/ Character) and NephthysAggregateKey, with snapshot checkpoints at a fixed
interval (NEPHTHYS_CHECKPOINT_INTERVAL = 3), single-writer replication,
ledger-diff rehydration, an authority-lease broker, read-only replica views, and
byte-verified restart — the capabilities the descriptor lists and that the
schema-version constants (NEPHTHYS_STATE_STORE_SCHEMA_VERSION,
…SINGLE_WRITER…, …PERSISTENCE_API…) key. This is the durable state tier
Danu's handoff and Moremi's runtime write through. Fully implemented Rust.
The malware and supply-chain scanner, and the platform's child-safety gate
(apps/v7/sekhmet-scanner/src/lib.rs, ~6.0k lines; owner "Sekhmet", port 47205;
deps hmac, sha2). It produces a ScanReport with a three-state
ScanVerdict (Clean / NeedsReview / Blocked) from static-signature, heuristic,
and dynamic WASM-capability findings, runs a malware-corpus detection-rate eval,
and enforces a clean-scan distribution gate with content-addressed manifests and
signed lock-file pinning (republish step-up "Fractureiser" defense). Beyond
malware it implements a large trust-and-safety surface: CSAM perceptual-hash /
PDQ-NCMEC matching, NCII 48h-takedown SLA (NCII_TAKEDOWN_SLA_MS), facial age
estimation with immediate biometric deletion
(AGE_ASSURANCE_BIOMETRIC_DELETION_SLA_MS), minor-protection defaults, a
Sentinel longitudinal child-endangerment detector, and a three-layer moderation
pipeline with DSA appeal paths and threshold constants
(SEKHMET_ML_PRESCREEN_*, SEKHMET_KUANYIN_REMOVE_THRESHOLD…). Its clean
verdicts gate Abundantia publication and Eunomia's Verified-realm decision.
Fully implemented.
tooling (1)#
The local-development tooling crate (apps/v7/dev-hygiene/src/lib.rs, 257 lines
incl. tests; tag layer:tooling; the only non-layer:service project here). It
turns a worktree path into a deterministic, collision-free port plan:
derive_worktree_slot hashes the path into one of V7_WORKTREE_SLOT_COUNT = 64
slots, each slot reserving a V7_WORKTREE_PORT_BLOCK_SIZE = 256 port block, and
build_worktree_port_plan_for_slot allocates the Moremi-realm and Mawu-gateway
dev ports from that offset with validate_unique_ports /
validate_cross_worktree_ports guards. It renders shell export lines
(render_env_exports) and a complete resource-bounded Agones local Fleet +
FleetAutoscaler manifest (render_agones_local_fleet_manifest, with
V7_DEV_REALM_MEMORY_LIMIT_MIB/ …GATEWAY… limits), and ships four unit tests
asserting concrete derived ports and namespaces. main.rs prints the env
exports and manifest for the current directory. Small but fully real, directly
enacting the repo's unique-ports-per- worktree hygiene rule.