maya library

A Rust crate (libs/maya/agora-constitution/src/lib.rs, ~1,071 lines, tag layer:agora; Cargo.toml carries no description, so per its module doc the "Maya Agora machine-readable constitution framework"). It is the constitutional-constraint layer of Maya's Agora governance subsystem. A GameConstitution binds inalienable_rights (Right: DataPortability, CreatorAttribution, SafeEnvironment, …), amendment-only protected_params, an AmendmentProcess (supermajority basis points, extended voting, grace period), time-limited EmergencyPowers, and an EconomicConstitution (treasury/revenue/tax basis points). validate checks the schema; enforce_action rejects any GovernanceAction that overrides a right or mutates a protected parameter without a qualifying amendment; authorize_emergency_power role- and time-scopes exploit responses; apply_amendment bumps the version and appends a diff_constitutions history entry. Four constitution_templates (DirectDemocracy → Anarchy) ship ready-made charters.

Honesty: dependency-free pure-std (BTreeMap/BTreeSet), unsafe_code = "forbid", five unit tests. It is not on-chain and not the vote tallier — vote share arrives pre-computed as yes_basis_points; no liquid-democracy delegation, sybil resistance, or persistence lives here. The "YAML/TOML" reader is a hand-rolled flat key:/key = line scanner, not a real grammar. A sanctioned sibling TS port (index.ts, type:ts-lib) re-declares the same types for orchestration.

A Rust crate (libs/maya/agora-core/src/lib.rs, ~580 lines, tag layer:agora, unsafe_code = "forbid"). Cargo.toml has no description, so its module doc: "Maya Agora governance core" defining "the tier hierarchy, governance configuration merging, Themis bridge metadata, event sourcing, permission checks, and analytics for game-community governance." A five-level GovernanceTier chain (Global → Game → Realm → Server → GuildParty) drives GovernanceContextResolver::resolve, composing per-tier GovernanceConfigs through merge_restrictive — a child tier may tighten but never widen authority (voting-model intersection, max quorum, min voting period, ANDed delegation). VotingModel enumerates Quadratic/RankedChoice/TokenWeighted/Approval/Optimistic; GovernanceEventStore event-sources the proposal lifecycle (GovernanceEventKind), while GovernancePermissionSystem and GovernanceAnalytics gate by reputation plus role and compute participation/success rates. Honesty: this is a small, zero-dependency foundation layer for Maya Forge governance, not a live chain. ThemisBridgeBinding only names @themis/voting/dao/deliberation packages — metadata, not an invoked integration; the store is in-memory Vec/BTreeSet; constitutions and delegate registrations are opaque ID sets (no delegation-graph or sybil logic); per-model tallying lives downstream. A parallel TypeScript mirror (src/index.ts) ports the same shapes for orchestration callers.

A Rust crate (libs/maya/agora-councils/src/lib.rs, ~594 lines, tag layer:agora; Cargo carries no description, so per its module doc the "Maya Agora council and delegate election system") modelling the council tier of Maya Forge's Agora governance for UGC realms. It is dependency-free std-only with unsafe_code = "forbid": a CouncilRegistry of BTreeMaps holds CouncilDefinitions, time-bounded CouncilMembers, and topic-scoped DomainDelegates (DomainScope: CombatBalance, Narrative, Economy, Content, Security), while run_ranked_choice_election is a genuine multi-seat instant-runoff elimination with deterministic lowest-name tie-breaking. OptimisticProposal::challenge/finalize implement challenge-window optimistic approval; trigger_recall fires on a sub-threshold approval plus a ≥0.1 petition ratio; dashboard aggregates public votes, participation, and average approval for realm transparency. State is schema-pinned at maya.agora.councils.1. Honesty: this is in-memory only — no persistence, DB, or actual on-chain layer; approval_score is a stored field (default 1.0), not a computed reputation, and generate_meeting_summary is a format! vote-count template with two hard-coded action items, not real summarisation. It scopes to councils/delegates — constitutions, liquid-democracy delegation graphs, and sybil resistance would live in sibling Agora crates. A parallel TypeScript mirror (src/index.ts) re-declares the same types (type:rust-lib + type:ts-lib).

A Rust crate (libs/maya/agora-delegation/src/lib.rs, ~624 lines, tag layer:agora, unsafe_code = "forbid"; Cargo.toml carries no description, so its //! doc names it "Maya Agora liquid democracy delegation"). It implements the delegation slice of Maya's Agora governance subsystem: a DelegationManager over in-memory BTreeMap/BTreeSet stores routes topic-scoped voting power (TopicScope: Combat, Economy, Content, Governance, Treasury, Any) from delegators to delegates. register_delegation rejects self-delegation and runs cycle_path_with_edge, which simulates the new edge, walks the graph, and returns the offending CycleDetected path; effective_power sums power by resolving each voter's final delegate under a max_depth cap (transitive liquid democracy with an Any-topic fallback). begin_vote_snapshot freezes delegations so revoke_delegation is instant going forward while effective_power_for_vote preserves an open ballot. dashboard reports public votes, chains, participation rate, and satisfaction; trigger_recalls files RecallElections below threshold. Six tests assert exact power, cycle paths, and recalls.

Honesty: despite the "on-chain-style" framing, this is a pure, dependency-free, deterministic in-memory model — no ledger, persistence, networking, signatures, or sybil resistance, and no constitutions/councils/proposal-lifecycle here. A parallel TypeScript port (src/index.ts, ~340 lines, immutable DelegationRegistry) mirrors the same logic for orchestration callers.

A Rust crate (libs/maya/agora-proposals/src/lib.rs, ~932 lines, tag layer:agora, unsafe_code = "forbid"; Cargo.toml carries no description, so per its //! doc a "Maya Agora proposal lifecycle manager" that "models proposal creation, quality gates, review, voting, grace, enactment, rollback, structured proposal payloads, and search"). It is the governance backbone for Maya Forge UGC. A ProposalLifecycleManager drives a nine-state ProposalState machine (Draft → Review → Voting → GracePeriod → Enacted/Rejected/Challenged → RolledBack) over eight ProposalTypes (balance, content adoption, rule change, mod endorsement, constitution amendment, emergency, treasury, election). submit_for_review enforces a deposit-or-reputation anti-spam gate; QualityGateReport::passes blocks voting on failing mod tests, >10% perf regression, or security issues; close_voting folds quorum and yes>no into a ClosingCeremonyReport; open_emergency_voting fast-tracks security-board-approved actions; rollback_if_degraded reverts on RuntimeMetrics thresholds. Honesty: all state lives in an in-memory BTreeMap — no persistence or actual chain; "sybil resistance" is a plain deposit/reputation numeric gate, and liquid-democracy delegation and councils are not implemented here. A parallel TS façade (src/index.ts, ~184 lines) mirrors the model for orchestration-side use.

A Rust crate (libs/maya/agora-sybil/src/lib.rs, ~611 lines, tag layer:agora, unsafe_code = "forbid"). Cargo.toml carries no description, so per its module doc: "Maya Agora sybil resistance and vote integrity" — "deterministic models for proof-of-play weighting, reputation staking, privacy-preserving identity proofs, MACI-style encrypted vote commitments, quadratic funding, brigading detection, and vote anomaly detection." It is the integrity layer beneath Agora, the Forge's on-chain-style governance subsystem: proof_of_play_score weights active, diverse play over AFK time; ReputationStakeLedger slashes stakes on rolled-back proposals; MaciRound hides votes until close then reveals by vote_commitment; allocate_quadratic_funding matches broad community support over whales; and detect_brigading/detect_vote_anomalies flag new-account influx, vote bursts, and uniform-choice clusters. Honesty: it is dependency-free and fully in-memory (BTreeMap ledgers and rounds), with no persistence, and the "encryption"/ZK is modelled, not real — encrypt_vote/vote_commitment format a non-cryptographic FNV-1a stable_hash, and identity_weight_multiplier merely trusts the kyc_verified/zk_proof_valid booleans. A parallel TypeScript port (src/index.ts, ~313 lines, tag type:ts-lib) mirrors every function. All seven algorithms ship with passing tests.

A Rust crate (libs/maya/agora-voting/src/lib.rs, ~733 lines incl. tests, tag layer:agora, unsafe_code = "forbid"; Cargo.toml carries no description, so per its //! doc: "Maya Agora voting model adapters … dependency-light adapters for common Themis-style voting models used by game-community governance"). It implements eleven real tally algorithms behind one VoteOutcome type and a VotingModel enum: quadratic (enforcing the N² credit cost), conviction (tokens × committed days), instant-runoff ranked choice, Condorcet pairwise-majority, token-weighted with optional sqrt damping, approval, holographic-consensus (stake + small quorum), optimistic (timeout unless challenged), futarchy (goal gate then highest belief market), supermajority (yes-ratio + quorum), and a LiquidDemocracyAdapter::resolve_delegate that walks delegation chains with cycle and depth-limit detection. VotingModelSelector maps ProposalType×GovernanceTier to a recommended model — the governance math for realm/guild/global councils in the Maya Forge UGC stack. Honesty: these are pure deterministic functions over caller-supplied ballots — no persistence, no chain/ledger, no constitution/council storage, no sybil resistance, no proposal-lifecycle state (despite the "on-chain-style" framing). [dependencies] is empty; AGORA_VOTING_SCHEMA_VERSION = "maya.agora.voting.1". A thin parallel src/index.ts (~89 lines) mirrors a subset (quadratic, supermajority, recommend); the project is dual-tagged type:rust-lib/type:ts-lib.

A TS library (libs/maya/bazaar-core/src/index.ts, ~464 lines, tag layer:bazaar; package.json has no description and the file carries no module-doc, so this is read from its symbols) implementing the listings/discovery slice of the Maya Forge UGC bazaar. It is a pure, stateless function module — no classes, no persistence, no HTTP, no in-memory store: callers pass arrays of ModListing/ModReview plus a subscriptions record, and every exported function returns fresh data. validateModPackage enforces semver, asset hash/byte-size integrity and screenshot warnings; publishModPackage mints a ModListing; discoverMods runs token relevance scoring (modRelevance) with category/tag faceting and pagination; resolveCollection does DFS dependency ordering that throws on cycles; summarizeReviews weights ratings by reviewer credibility and playtime while filtering spam; createDownloadSession selects a regional CDN endpoint with resumable byte offsets. Its ModManifest echoes forge-core's manifest but is a separate, looser TS shape (category is a free string, no deny_unknown_fields). Honestly scoped: despite "bazaar" implying economy, there is no revenue-split, licensing, or creator-treasury code here — only listings, discovery, reviews, downloads, reporting, and per-platform packaging.

A TS library (libs/maya/bazaar-licensing/src/index.ts, ~524 lines; package.json has no description field and the source carries no module doc-comment, so this summary is read from its exported symbols) — the machine-readable licensing law for Maya's Bazaar UGC marketplace. LicenseType defines six tiers (OpenForge, ShareAlikeForge, CommercialForge, PersonalForge, ExclusiveForge, Custom), each minted by createStandardLicense/buildCustomLicense into a MachineReadableLicense of typed permissions, restrictions, obligations, and RevenueRequirements. The real work is compatibility: checkPairwiseCompatibility, checkLicenseCompatibility, and scanLicenseViolations walk a mod's dependency graph and emit coded LicenseIssues (no-derivatives, non-commercial, share-alike-required, revenue-share-required…); enforceLicenseInheritance propagates parent terms onto derivatives, auto-coercing a child to ShareAlikeForge when required. It sits upstream of @maya/forge-resolver and the marketplace economy, governing how creators may fork, sell, and depend on each other's mods. Honesty: pure, stateless functions — no persistence, no registry beyond the per-call Map built from inputs, and no treasury or payment runtime. RevenueRequirement (bps/fixedCents/recipientId) is policy data only; no money moves here, and legalLanguage is template-generated, not vetted legal text. Real deterministic policy logic with a spec, not a stub — actual revenue-split/creator-treasury execution lives in deferred downstream subsystems.

A TS library (libs/maya/bazaar-revenue/src/index.ts, ~836 lines, tag layer:bazaar; no package.json description or module-doc, so the role is read from the symbols) implementing the Bazaar UGC marketplace economy for Maya Forge. It models seven pricing modes (PricingModelKind: Free, PayWhatYouWant, FixedPrice, Subscription, Patronage, AdSupported, TipJar) and a basis-point RevenueSplit that validateRevenueSplit forces to total 10000 (DEFAULT_REVENUE_SPLIT = 1000/7000/1500/500 across platform/creator/dependency/treasury). The core is calculateRevenueChain: collectDependencyClaims walks the mod dependency graph with depth-decayed weights, circular-chain detection, and missing-dependency warnings, then allocateByWeight apportions cents by largest-remainder so the splits sum exactly. Around it sit attribution graphs, ledger and dashboard rollups (earnings by mod, dependency chain, and period), tip intents, crowdfunding pledges with refund policy, and processPayouts (gated on an enabled payment method plus verified tax docs). Honest scope: these are pure in-memory functions over readonly data — no DB, no real payment rails (payouts emit 'queued' records), and signature checks delegate to a caller-injected AttributionVerifier. This is genuine apportionment logic, not a stub; it realises the pricing/revenue data @maya/forge-core carries but defers to "downstream marketplace subsystems."

A TS library (libs/maya/bazaar-treasury/src/index.ts, ~666 lines, tag layer:bazaar; package.json carries no description and the file has no module-doc, so this summary is drawn from its exported symbols) modelling a community-governed treasury for the Maya Forge UGC bazaar. It is a pure-functional, dependency-free kernel: every operation takes a CommunityTreasury and returns a new immutable one. fundTreasury records ledger credits from four TreasuryFundingSources (mod_sales, donations, community_asset_revenue, grants), applying a real basis-points revenue split (Math.round(grossCents * allocationBps / 10000)). Spending flows through weighted governance — createSpendingProposal → castTreasuryVote → finalizeSpendingProposal tallies quorum against an approval threshold — then an N-of-M MultiSigRequest above a cent threshold, and executeSpendingProposal debits only against availableCents. It also runs mod/bug-bounty lifecycles and tournament prize pools (allocatePrizePool does real largest-remainder apportionment by rank). buildTreasuryDashboard folds the ledger into balance/encumbered/income-by-source/expense-by-category. Honesty: in-memory only — no persistence, no payment rails, and multi-sig signature is an unverified string, not a real cryptographic check; this is the economic accounting/governance logic a service must persist and wire to real money and identity.

A dependency-free, std-only Rust crate (libs/maya/crucible-adversarial/src/lib.rs, ~2,021 lines, tags layer:crucible/type:rust-lib, unsafe_code = "forbid"; Cargo.toml carries no description, schema const CRUCIBLE_ADVERSARIAL_SCHEMA_VERSION = "maya.crucible.adversarial.1"). Within the crucible adversarial-playtest harness it is the exploit hunter: it statically searches typed models of a modded game for game-breaking combinations, ranking them on a five-tier ExploitTier (T1Cosmetic → T5EconomyDestroying) across nine ExploitKinds. This is real algorithmic code, not a readiness facade. scan_infinite_resource_exploits runs a depth-bounded positive-cycle DFS (dfs_positive_cycle) over crafting/currency graphs, plus price-arbitrage and uncapped-modifier checks; scan_one_shot_combos enumerates ability sequences in a time window and stacks fixed-point multipliers (multiply_milli, i128, fields in _milli) against ProgressionStage health; scan_invincibility sums additive/compound mitigation, regen, shield and lifesteal versus incoming DPS. generate_exploit_proof minimizes the mod set and emits a deterministic FNV-1a replay id, suggest_mitigations maps each kind to MitigationStrategy patches, and synthetic_known_exploit_suite seeds a regression corpus of real exploits (skyrim-restoration-loop, diablo-dupe, poe-mirror). Honesty: it reasons over declarative mod-effect structs, never a live engine — the economy, combo and movement scanners genuinely derive findings, while the AI, grief and physics-numeric paths are threshold gates over self-reported fields (ai_win_rate_milli, produces_nan). A 302-line Python companion (python/crucible_adversarial/proofs.py) mirrors the proof/report path.

A Rust crate (crucible-agents v0.1.0, libs/maya/crucible-agents/src/lib.rs, ~2,093 lines, tags layer:crucible + type:rust-lib/type:python, unsafe_code = "forbid", with crucible-core and sha2 dependencies; no Cargo/package description, so CRUCIBLE_AGENTS_SCHEMA_VERSION = "maya.crucible.agents.2" names it). It is the AI-opponent cast for the Maya Crucible playtest/adversarial-evaluation harness — the bot populations that actually play modded matches so sibling crates can measure balance, exploits, and coordination. The simulation core is real, deterministic logic: a CrucibleAgent trait (agent_id/act) with ScriptedAgent (eight ScriptedBehaviors dispatched in scripted_action, e.g. AlwaysStrongestAttack = max_by_key(threat_milli), RushObjective = nearest objective) and HeuristicAgent (branching on a 13-field PlaystyleProfile); a six-tier skill_calibration (Bronze→Champion) feeding estimate_matchup_win_rate; a 12-entry archetype_library; build_observation's genuine fog-of-war / line-of-sight / hidden-stat redaction; validate_action's legality+cooldown gate; and a seeded xorshift DeterministicRng (a test asserts identical actions across 10,000 frames). test_coordination computes premade and solo rates from measured MatchRecords, while run_exploit_hunter detects the first threshold crossing in measured episode telemetry.

train_rl_agent now has one real, deliberately bounded execution mode: one-step tabular Q-learning over conservative/balanced/aggressive strategy actions. Each update consumes an actual crucible-core match; the checkpoint stores learned Q parameters, the measured reward curve, actual frames, held-out wins/matches, and separate SHA-256 training/evaluation digests. Evaluation alternates red/blue sides. run_match_based_meta_discovery likewise executes side-balanced matches, selects parents by measured wins, mutates the next generation, and hashes all result identities before Wilson ranking. The owning tests run 6,000 training frames, 50 held-out matches, and 48 evolutionary matches deterministically.

Honesty: this is a small CPU baseline, not PPO, distributed GPU training, or self-play; those modes fail loud. The Python training.py remains an orchestration/ingest seam and explicitly points to the Rust baseline rather than fabricating a Python trainer.

A dual crate (layer:crucible, tags type:rust-lib + type:ts-lib) whose real engine is the Rust side: libs/maya/crucible-balance/src/lib.rs (~1,463 lines incl. 11 inline tests, unsafe_code = "forbid", dependency-free, schema maya.crucible.balance.1; neither Cargo.toml nor package.json carries a description). It is the balance-analysis facet of the crucible playtest harness: it ingests match telemetry and emits flagged reports certifying a mod combination. The statistics are genuine, deterministic, and fixed-point (_milli u32): win_rate_matrix with wilson_interval_milli (Wilson score, z=1.96), analyze_pick_win quadrants (PickWinQuadrant::{NoobTrap,HiddenOp,BalancedPopular,Niche,Watch}, 2σ outliers), analyze_power_curve (Convexity via second differences, inflection points), analyze_ttk (p10/median/p90), economy_health (Gini, supply-vs-demand inflation, velocity), strategy_diversity (Shannon entropy normalized by log2), matchup_graph (intransitive-cycle / degenerate-RPS detection), plus comeback_potential, blowout_rate, cross_mod_interactions, progression_pace, and sensitivity_analysis — aggregated by balance_scorecard into eight ScoreCategory LetterGrades.

The TypeScript surface (src/index.ts, 184 lines) is a thinner presentation/recommendation mirror, not a second engine: buildBalanceScorecard maps already-computed BalanceMetricSummary[] to A-F grades, heatmapRows lays out matchup cells, classifyPickWinScatter re-derives the quadrant taxonomy on rates, and recommendationsFor/recommendationForFlag turn flags into remediation text ("add currency sinks or reduce generator yield"). It shares the grade/quadrant vocabulary but on a 0-100 scale, not Rust's 0-1000 milli, and recomputes none of the Wilson/Gini/entropy math.

A Rust crate (libs/maya/crucible-core/src/lib.rs, ~2,147 lines, tags scope:maya/layer:crucible/type:rust-lib; Cargo.toml carries no description, zero dependencies, unsafe_code = "forbid", schema maya.crucible.core.2). Unlike Maya's plan/readiness TS facades, this is a real, std-only deterministic playtest engine — the headless simulation core of the Crucible balance/adversarial harness. HeadlessSimulation::run drives a fixed-dt tick loop that, per headless_system_order(fidelity), applies apply_economy/apply_ai/apply_combat/apply_rules (per-attacker damage dps + dps*bonus/1000 + jitter, kill/death tracking, a SimulationEvent log) over a seeded xorshift64 DeterministicRng, sampling EconomySnapshot/PowerCurveSample; excluded_headless_engine_systems drops rendering/audio/input. bootstrap_simulation content-addresses the ModLoadout via FNV-1a derive_mod_loadout_hash and rejects mismatches. capture_snapshot/replay_from_snapshot round-trip a compressed envelope, run_parallel_simulations fans scenarios across real thread::spawn workers (parallel result hashes equal sequential), and run_campaign/pause_campaign/resume_campaign expand parameter sweeps with checkpointing. Declared learned:{conservative,balanced,aggressive} strategies now apply explicit damage/survival trade-offs at bootstrap so measured policy training changes a gameplay strategy without silently changing skill. Eleven tests assert 1000x determinism, mid-match replay equality, and the strategy trade-offs. Honesty: gameplay systems remain simplified integer models, the snapshot codec is explicitly Rle, and content/state hashes are FNV-1a rather than cryptographic identities. Full-engine parity no longer self-compares: verify_headless_parity_against_reference now requires an externally supplied reference bound to a supported full runtime, engine build, executable SHA-256, run and artifact identities, UTC completion, and a length-framed digest of the complete scenario plus loop configuration. The comparison requires an exact state-hash match as well as a margin delta no greater than 1%. Unit fixtures exercise validation and comparison semantics but are not full-engine evidence; no Unreal or assembled Maya runtime receipt was captured in this slice.

A TypeScript library (libs/maya/crucible-governance/src/index.ts, 367 lines, tags scope:maya/layer:crucible/type:ts-lib; package.json carries no description) that is the governance and balance-policy layer riding on top of Crucible's adversarial-playtest engines. Unlike the maya Rust forge/loom crates, it is pure, dependency-free, deterministic TypeScript: nine exported functions over seventeen readonly interfaces (BalanceFingerprint, MetricImpact, SimulationBudget, ArchiveEvent, Bounty, DraftBalanceProposal). Its genuine algorithmic core is diffFingerprints, which Map-joins before/after BalanceMetrics, derives absolute/relative change, flags regression by each metric's higherIsRisk direction, and sorts by impact magnitude; evaluateWhatIfQuery adds per-user/per-day rate limiting plus a parameterHash cache; appendArchiveEvent/searchArchive keep an append-only, dedup-guarded precedent log; validateBountySubmission gates exploit payouts on severity rank and simulation reproduction; draftBalancePatchProposal routes T4+ severities to an emergency-fast-track process with councilReviewRequired.

Honesty about scope: it evaluates data handed to it rather than running simulations. simulateProposalImpact is an SLA/budget calculator (estimatedMinutes = ceil(scenarios / 50)) wrapped around a fingerprint diff, and buildBalanceHealthDashboard/buildAdvisorOutput mostly sort, select, and template over supplied metrics (the narrativeSummary is a boilerplate one-liner that interpolates the dominant build name). The heavy balance simulation lives in sibling crucible-* packages; this is the tested (index.spec.ts, 7 value-asserting cases) decision/precedent toolkit layered on top.

A dual crate (tags type:rust-lib + type:ts-lib, layer:crucible) pairing a Rust detection engine with a TypeScript dashboard surface; neither Cargo.toml nor package.json carries a description, and both pin schema maya.crucible.live.1. The Rust crate (libs/maya/crucible-live/src/lib.rs, ~688 lines, unsafe_code = "forbid", zero deps) holds the real statistics: ingest_telemetry does exactly-once BTreeSet dedup plus k-anonymity drops (loadouts under 10 events), track_win_rates computes 99%-z Wilson intervals (wilson_interval) with mode-aware min-sample gating, detect_anomalies flags ≥3-sigma shifts plus win-rate spikes / population drops with known-event suppression, detect_simulation_drift measures relative drift versus simulator predictions, and track_meta_evolution derives Shannon entropy, kl_divergence, top-K stability and oscillation into a MetaPattern. Six #[cfg(test)] cases assert these against known values.

The TypeScript surface (libs/maya/crucible-live/src/index.ts, 389 lines) is not a thin mirror but the complementary presentation/governance layer: buildLiveDashboard fans six finding streams through per-source builders (winRateAlerts…metaAlerts) into dedupeAlerts (severity-weighted, seen-key suppressed), routes each LiveAlert to AlertChannels with slaMinutes, and scores a 0–100 healthScore plus a pickWinUrgency scatter; packageHotfixProposal mints an emergency-fast-track proposal with humanApprovalRequired: true. The two sides overlap only in shared constants (classifyPickWin, quadrant/sentiment cutoffs). Within crucible's playtest-evaluation family this is the live-ops arm — watching post-ship meta telemetry and measuring live drift against the pre-ship balance simulation.

A dual crate (tags type:rust-lib + type:ts-lib, layer:crucible) whose statistical core lives on the Rust side. libs/maya/crucible-regression/src/lib.rs (~915 lines, schema maya.crucible.regression.1; package.json carries no description) is a genuine balance-regression engine for the crucible playtest/evaluation harness. compute_balance_fingerprint snapshots a loadout's MetricFingerprints across the 12-variant RegressionMetric taxonomy (MatchupWinRate, TtkMedian, EconomyGini, StrategyEntropy, …); diff_fingerprints computes a pooled-standard-error z_score and classifies each metric Green/Yellow/Red against RegressionThresholds (0.01/0.05/0.10 abs, 1.96/3.29 z), with direction set by higher_is_risk. evaluate_regression_gate returns a graduated Informational/Warning/Blocking GateDecision (blocking attaches a governance_note); run_ab_simulation is a paired-seed, Bonferroni-corrected A/B test with 95% CIs and effect sizes; analyze_historical_trend least-squares-fits power-creep and mean-reversion failure; schedule_monitoring tiers popular combos Daily/Weekly/Monthly; alerts_for_gate routes severity to AlertChannels, backed by FingerprintStore and AlertDeduper. Nine tests assert domain correctness, including zero false positives on cosmetic-neutral updates.

The TypeScript surface (libs/maya/crucible-regression/src/index.ts, 215 lines) is a thinner typed mirror of the reporting layer — buildRegressionReport, evaluateGate, buildMonitoringPlan, summarizeTrend (adding a sparkline renderer), alertsForReport/dedupeAlerts — operating on already-diffed MetricDiff rows. It re-implements the color gate, tiering, and least-squares slope, but not the fingerprint statistics or Bonferroni A/B simulation, which live only in Rust.

A dual Rust+TypeScript crate (tags scope:maya, layer:crucible, type:rust-lib, type:ts-lib; neither Cargo.toml nor package.json carries a description, so the constant CRUCIBLE_SCENARIOS_SCHEMA_VERSION = "maya.crucible.scenarios.1" names it). It is the scenario-design surface of the crucible adversarial/playtest harness, building the combinatorial test-matrix that @maya/crucible-core then validates, snapshots, and replays. The real engine is the Rust side — libs/maya/crucible-scenarios/src/lib.rs, 915 lines, dependency-free, unsafe_code = "forbid". generate_pairwise_campaign is a genuine greedy pairwise covering-array generator: it enumerates all_factor_pairs, expands capped cartesian_rows (≤50_000), greedily selects rows by max_by_key over uncovered-pair intersection, then patches residual pairs — compressing a full_combinatorial_size: u128 space into a compact ScenarioCampaign. Around it sit threshold balance analyzers emitting ScenarioFindings over a nine-variant ScenarioFlagKind (analyze_asymmetry, generate_map_findings, analyze_new_player_experience, analyze_endgame_stagnation), a curated seven-pattern edge_case_library, a six-factor rank_scenarios, and spearman_rho rank-correlation — all covered by value-asserting tests (full_combinatorial_size == 192, coverage 1.0, grade 'A'). src/index.ts (156 lines) is a thinner typed companion, not a full mirror: it re-exports coverageGrade, buildCoverageSummary, validateScenario, coveredPairs and a reduced four-factor rankScenarios, but omits the generator and analyzers. The analyzers flag supplied metrics against fixed thresholds rather than simulating matches.

A single-file model library (libs/maya/community-companion/src/index.ts, ~170 lines) for the companion web/mobile surface of Maya Social Fabric: typed records for finder feeds, synchronized calendars, public profiles, deep links, notification preferences, Discord/external bridges, RSVP flows, and webhooks, with small pure constructors and validators (buildCompanionFinderFeed, syncEventCalendar, createDeepLink, updateNotificationPreferences). It is a schema-plus-helpers library, not a running API service.

The inter-community diplomacy model (libs/maya/community-federation/src/index.ts, ~215 lines): Alliance records with member guilds, channels, events, and GovernancePermissionTemplates, guest access via issueGuestAccessPass/canUseGuestPass expiry-and-rights checks, coalition kinds, partner discovery, and DiplomaticState stances. Thirteen small pure functions over typed records; persistence and transport are left to consumers.

Community-leadership workflows as a typed model library (libs/maya/community-governance/src/index.ts, ~270 lines): leadership role templates and GovernancePermissions, event-ownership delegation, decision logging (logGovernanceDecision), ambassador tracks, staffing shifts with evaluateStaffingCoverage, and a buildBurnoutDashboard over leadership workloads, plus culture-template and operations-runbook kinds. Pure helpers over records — no storage layer.

Community-health analytics models (libs/maya/community-health/src/index.ts, ~240 lines): metric definitions and warehouse event schemas, social cohort metrics (computeCohortMetric for first-friend/first-repeat-squad/first-guild), guild and LFG funnels (buildGuildFunnel, buildLfgFunnel), safety-trust summaries, a scorePlayerRisk risk model, experiment definitions, and intervention playbooks. It computes real ratios and scores over counts the caller supplies; it does not own a data warehouse.

Prosocial recognition models (libs/maya/community-recognition/src/index.ts, ~185 lines): badge rules with evaluateBadgeEligibility quality signals, milestone ceremonies, appreciations, graduation moments, memory artifacts, and recognizeInvisibleLabor for logistics/moderation/welcoming/conflict-resolution work, with incentive guardrails expressed in the types. Seven pure constructors/evaluators over typed records.

Private-first reputation for Maya Social Fabric (libs/maya/community-reputation/src/index.ts, ~325 lines): computePrivateReliabilityScore over a PrivateReliabilityModel, endorsements with summarizeEndorsements, deriveTrustMarkers, avoid/block preferences with shouldSuppressForPreference, computeCompatibilityScore, recovery workflows, and fairness-audit shapes. Scores are computed for selective surfacing in a TrustSurfaceContext (discovery, matching, private ops), deliberately not for public display.

The AI co-creator for V7 realm builders (libs/maya/forge-assist/src). Its forge-assist.ts ForgeAssistService takes a creator brief, calls an injected @oshun/ai LLMProviderInterface to write a forge artifact (entity script, behavior, or UI panel against the sandbox API), then runs every artifact through the CapabilityPolicy trust boundary (capability-policy.ts) — artifacts that declare or use non-realm.* capabilities are rejected with named violations and never reach the sandbox. It also supports an optional injected §9.6 ForgeQualityGate with critique→rewrite refine passes, and stamps SHA-256 provenance on each proposal. This is the one node that bridges Maya to the shared LLM gateway; the quality judge is injected ([~] for full V7 sandbox wiring).

The Forge companion's expressive-avatar layer (libs/maya/forge-companion/avatar-controller/src, 15 modules): a FACS Action-Unit blend-shape driver (ACTION_UNITS, rig mapping, intensityCurve), VAD-emotion→FACS mapping with micro-expressions, transition easing and layer compositing, blink/gaze/pupil eye controllers, 60+ expression presets, gesture/IK/idle/cloth-hair/personality layers, and a realtime phoneme→viseme lip-sync pipeline (VisemeMapper, CoArticulationBlender, RealtimeLipSyncDriver, EmotionalLipSyncModifier) with emphasis animation and sync-drift monitoring.

A testing-only project (libs/maya/forge-companion/e2e-tests/src): the Phase 78.15 end-to-end suites (voice-e2e, avatar-e2e, workshop-e2e, mod-engine-e2e, integration-e2e spec files) wire the real sibling forge-companion libraries together, and the barrel exports only shared scenario helpers — a 55-entry MOD_SCENARIOS corpus of voice-modding utterances labelled with their expected mod domain. No production runtime ships from here.

The Forge companion's real-time generation pipeline (libs/maya/forge-companion/generation-pipeline/src): orchestration.ts is real local logic (GenerationOrchestrator priority queue, progress streaming, MidGenerationFeedbackLoop, GenerationQualityGate, cost estimation, semantic cache), while generators.ts is honestly fail-loud — TextTo3DGenerator and its siblings are GeneratorSeams that throw GeneratorNotConfiguredError until a model backend is attached rather than fabricating output. The mesh.ts/media.ts/content.ts post-processing is runnable locally: AutoRetopology, PBRMaterialAutoAssignment, animation retargeting, UV-stretch analysis, and waveform preview.

The transparent "Glass Workshop" workspace (libs/maya/forge-companion/glass-workshop/src, 10 modules): spatial panel layout/focus/transitions, a headless panel scene-graph renderer with VR and flat adapters, theme and opacity engines, an LCS-based live diff viewer (LiveDiffPanel, DiffStreamRenderer, category colour coding, approval and history), a system dependency graph with ripple highlighting, and a reasoning-stream model (ReasoningStreamPanel, ReasoningToSpeechBridge) that narrates the companion's thinking. Headless UI logic — the actual surface rendering is the client's.

Player modelling and adaptation for the Forge companion (libs/maya/forge-companion/learning-system/src, three modules): skill.ts per-domain skill profiling and expertise detection, preference.ts learning (AestheticPreferenceModel, WorkflowPatternRecognizer, FeedbackSignalExtractor, PersonalShortcutLearner), and teaching.ts with TeachingMode, GuidedModTutorials, ChallengeMode, and a ModInspirationEngine.

The universal mod-engine abstraction (libs/maya/forge-companion/mod-abstraction/src): layers.ts types the four-layer stack — natural-language ModIntent → SemanticAction (SemanticVerb) → SystemCommand → EnginePrimitive — with novice/intermediate/expert Granularity routing, layer translation, and transactional commit/rollback, and src/domains/ carries typed handlers for all 12 moddable domains (asset, code, rules, world, physics, ui, audio, economy, social, narrative, ai-behavior, accessibility).

Safety and mod integrity for the Forge companion (libs/maya/forge-companion/mod-sandbox/src): runtime.ts is a real WebAssembly host — WASMSandboxRuntime instantiates mod WASM with an import object exposing only capability-gated functions (SandboxCapabilitySystem, CapabilityViolation) plus cooperative gas metering — and the rest covers SandboxResourceMonitor, ModIsolation and escape detection, the performance-budget system (PerformanceBudgetAllocator/-Enforcer, AdaptiveBudgetScaling), content-policy/IP-protection seams, a voice content filter, provenance watermarking, and multiplayer mod safety.

The integration layer that ties the companion together (libs/maya/forge-companion/orchestrator/src): orchestrator.ts runs the CompanionOrchestrator event loop over an EventBus with PipelineLatencyMonitor, GracefulDegradationController, and SessionStateManager; tools.ts defines the LLM tool-calling surface (ToolDefinition); and adapters.ts is the engine adapter layer — a native MayaEngineAdapter plus GodotEngineAdapter/UnrealEngineAdapter/ UnityEngineAdapter external adapters that fail loud with EngineNotConnectedError when no engine is attached.

Intent-aware mod conflict resolution replacing load-order last-wins (libs/maya/forge-companion/semantic-merge/src) — deliberately small: one ~310-line merge.ts with ModIntentExtractor, ConflictDetector, typed ModChange/ModIntent/Conflict shapes, directional-intent analysis (increase/decrease/set/toggle), and ResolutionMode strategies.

Social and distribution integration for the Forge companion (libs/maya/forge-companion/social-integration/src, four modules): publishing.ts Bazaar publishing (ModPublisher, VoiceModDescription), forking.ts Variants-style forking (ModForkingInterface, ForkDiffVisualization, UpstreamMergeNotifier, AttributionChainTracker), governance.ts the Agora governance bridge, and collaboration.ts collaborative modding (CollaborativeModSession, ModSessionVoiceChannel, CollaborativeConflictResolver, ModSessionReplay).

The streaming ASR front-end of the companion voice pipeline (libs/maya/forge-companion/voice-asr/src, 15 modules) — the deterministic, locally-runnable core: spectral-gating GameAudioNoiseFilter, VoiceActivityDetector and UtteranceBoundaryDetector, streaming transcript accumulation with confidence scoring, intent parsing (ModIntentClassifier, CompoundCommandParser, ConditionalCommandParser, ClarificationGenerator), language detection/switching, latency scheduling, spatial-voice geometry, and WER/latency metrics. Cloud ASR backends are honest fail-loud provider seams in providers.ts, not simulated recognizers.

Expressive TTS and multi-turn dialogue (libs/maya/forge-companion/voice-tts/src): a streaming TTS provider seam that fails loud (TtsNotConfiguredError, CloudTtsProvider, TTSProviderFailover) with SentenceChunker/StreamingTTSEngine first-audio scheduling, emotion-tag → SSML prosody, personality voice profiles, rule-based grapheme-to-phoneme (wordToPhonemes) with viseme timing, autocorrelation ProsodyAnalyzer, HRTF spatial routing, a phrase cache, and dialogue management (barge-in, confirmation, proactive suggestions, memory bridge).

A TypeScript readiness-evaluator library (libs/maya/genesis-flora/src/index.ts, ~376 lines) for procedural vegetation. It exports rich config types (tree-generation, biome distribution with Poisson sampling and clustering, ecology with competition/succession/seasonal-growth, render/export with SpeedTree/Nanite handoff) and a single evaluateMayaGenesisFloraLandscape function that scores coverage ratios and emits blocking/warning issues. It evaluates readiness of a flora pipeline rather than running L-system growth itself (that lives in genesis-neural-flora and the Rust maya-genesis-flora crate).

A substantial TS library (libs/maya/genesis-nca/src/index.ts, ~5.6K lines) implementing neural cellular automata for exotic-biome and living-terrain texture generation. It actually trains and runs the automata: trainMayaNcaExoticBiomeRule learns per-channel growth/decay/diffusion/anisotropy rules from exemplars, growMayaNcaExoticBiomeTexture evolves the grid, and there are morphogenesis, vegetation-pattern, biome-boundary, Whittaker-biome classification, painted-texture training, and a WebGPU compute-integration planner. Real generative algorithms with diagnostics (loss curves, distinctiveness scores), not a facade.

A TS library (libs/maya/genesis-neural-flora/src/index.ts, ~2.2K lines) for transformer-guided procedural vegetation. createMayaNeuralLSystemGrowthModel runs an attention-weighted L-system whose production rules respond to a real environment vector (soil quality, light direction, wind exposure, neighbor density); additional functions cover LiDAR species-model training, single-image plant reconstruction, growth animation, a classical-vs-neural benchmark, and growth-style transfer. Concrete grammar-expansion logic over typed MayaNeuralLSystemToken streams.

A TS library (libs/maya/genesis-physarum/src/index.ts, ~1.5K lines) implementing Physarum (slime-mould) network growth for organic infrastructure. createMayaPhysarumRoadNetwork does terrain-aware pathfinding between settlements (findTerrainAwarePath) then selects a Physarum-weighted minimum spanning tree, accumulating trail intensity per cell; sibling functions generate trade-route, tunnel, river-enhancement, and utility networks plus a morphology controller and a comparison benchmark. Real graph/pathfinding math over slope and water-penalty terrain grids.

A TS library (libs/maya/genesis-scene-agent/src/index.ts, ~1.5K lines) for agentic, natural-language world creation. It defines a procedural scene-program IR (place_terrain / place_building / scatter_flora calls with absolute/relative/between position expressions) and executeMayaProceduralSceneProgram resolves references and corrects spatial overlaps deterministically. It also provides a tool catalog + selector, incremental world editing, multi-agent parallel generation, and an audit-trail/decision-explanation layer for the generation agent — real planner/interpreter logic.

A TS library (libs/maya/genesis-sketch/src/index.ts, ~2.1K lines) for sketch-to-terrain authoring. It maps stroke styles to terrain operations (createMayaRidgeLineSketchTerrain, valley/canyon, river-path, cliff-face, coastline, crater/caldera), supports multi-stroke composition, an undo/redo stack (applyMayaSketchTerrainUndoRedo), and a feature-eraser. Concrete heightfield-from-strokes algorithms with a style-preset library, not a scaffold.

A TS readiness-evaluator library (libs/maya/genesis-terrain/src/index.ts, ~346 lines) for procedural terrain. It models heightfield, climate/biome (Whittaker biomes, microclimate, seasonal variation), erosion/hydrology (hydraulic/thermal, river networks, sediment transport), streaming/LOD, and material/export config, and evaluateMayaGenesisTerrainEnvironment scores coverage and emits typed issues (determinism-missing, coverage-low, generation/memory budget exceeded). Like genesis-flora/-urban it evaluates pipeline readiness; the heavy terrain runtime is the Rust maya-genesis-terrain crate.

A substantial TS library (libs/maya/genesis-tiling/src/index.ts, ~3.7K lines) implementing aperiodic/Wang tiling for anti-repetition content. It generates Wang terrain-chunk plans, aperiodic monotile surface patterns, stochastic terrain texture synthesis, Wang dungeon-room layouts, aperiodic city-block placement, and stochastic vegetation scatter, plus an anti-repetition quality report and a technique-comparison. Real tiling/constraint algorithms with measured repetition quality.

A TS readiness-evaluator library (libs/maya/genesis-urban/src/index.ts, ~346 lines, mirroring genesis-terrain's shape) for procedural urban generation. It exports the urban config types and a single evaluateMayaGenesisUrbanEnvironment that scores coverage and emits blocking / warning issues. The full urban-generation runtime lives in the Rust maya-genesis-urban crate (the largest genesis crate); this TS library evaluates the pipeline's readiness.

Phase 83 NPC agency orchestration (libs/maya/npc-agency-orchestrator/src/index.ts, ~640 lines): generateEmergentGoals derives goals from an NpcAgencyContext using emergent goal templates, circumstance triggers, emergency and player-interaction goals; validateGoalCoherence filters incoherent goals; logNarrative records the resulting story beats and populationGoalDistribution reports goal spread across the NPC population.

Hybrid cloud-LLM fallback orchestration for complex NPC reasoning (libs/maya/npc-cloud-fallback/src/index.ts, ~215 lines) — the policy layer, not the transport: CloudQueryManager is a narrative-importance priority queue with concurrency and rate limits, plus CloudResultCache, createMultiNpcReasoningRequest, latency-tolerant result integration, distillCloudResult back into local decision rules, a deterministic offlineFallbackDecision, and applyCloudSafetyLayer. Actual calls to the typed CloudProviderKind backends (claude/gemini/gpt/vllm) are the caller's.

The smallest Phase 83 NPC library (libs/maya/npc-cooperation-negotiation/src/index.ts, ~120 lines): detectSharedGoal across NegotiatingNpcs, createCooperationOffer, acceptanceScore, negotiateCooperation, and assignRoles, producing group schedules and narrative hooks for cooperating NPCs. Deliberately compact pure logic.

Teacher–student NPC cognition distillation (libs/maya/npc-distillation/src/index.ts, ~370 lines): SlmDecisionLogger and a DecisionRingBuffer capture SLM decisions, compressContextToPersonalityInput reduces full context to a PersonalityVector12, then filterHighQualityRecords, stratifiedSampleByArchetype, and createVersionedDataset build training sets for trainOfflineDistillation, with A/B rollout (assignAbWeights, compareAbCoherence), deployment packaging, and a distillation dashboard. The "training" here is the deterministic dataset/weight-evaluation pipeline in TS — GPU training infrastructure is out of scope.

NPC occupation simulation at libs/maya/npc-occupations/src: templates.ts holds the committed OCCUPATIONS catalog (40+ templates) with category queries, work.ts computes work behaviour and production (produceOutput, qualityFromSkill, gainSkill, schedule checks), career.ts drives worker lifecycle (hire/fire/changeCareer, apprentice graduation, retirement), and worldgen.ts assigns occupations to settlement populations (assignOccupations over SettlementNeeds). The barrel notes the economy-system integration is left to the economy domain this library feeds.

The Maya Nexus social platform library (libs/maya/social/src, 16 modules): the ~840-line index.ts implements MayaSocialService — an in-memory friends/presence/follow/activity engine (addFriendship, followPlayer, recordActivity, suggestFriends, social analytics) with a typed MayaSocialError — alongside party, guild, chat and chat-formatting, smart-ping, communication-wheel modules and a voice tier (spatial voice, VAD, push-to-talk, volume, moderation, effects, noise suppression, server infrastructure, VR integration).

Intent-aware discovery for Maya Social Fabric (libs/maya/social-discovery/src/index.ts, ~455 lines): buildHomeDiscoveryFeed, recommendPeopleYouShouldMeet, recommendGuilds, discoverEvents, buildReturnerResurfacing, and a deliberate buildLowPressureLane for players who want low-stakes contact, plus applyDiversityGuardrails and notification-policy evaluation to keep recommendations from becoming spammy or homogeneous.

Festival/market/performance simulation at libs/maya/social-events/src: schema.ts models SocialEvents with a scheduled→preparation→active→cleanup EventPhase lifecycle, calendar.ts derives seasons and scheduled/dynamic events (seasonOf, dynamicEvent), and activities.ts simulates street performers (performerCrowd, coinsTossed), vendors (shopperBuys), and tavern drunkenness (drunkModifier), including festival mini-games and NPC schedule overrides. Ambient audio and speech bubbles are the engine's rendering concern.

Consent-first AI social facilitation (libs/maya/social-facilitation/src/index.ts, ~275 lines): opt-in AiOptInSettings gating every feature (isFeatureEnabled), companion profiles, suggestGroups, disclosed AI introductions (generateWingmanIntroduction), rehearsal sessions, party concierge summaries, participation nudges, novice-question routing, mentor/returner assistants, memory controls, and evaluation shapes. The disclosure/opt-in gating is built into the types, not bolted on.

The intent-aware player social graph model (libs/maya/social-graph/src/index.ts, ~390 lines): a createDefaultPrivacyMatrix privacy layer with canViewField checks, computeReliabilityScore, aggregatePresence over presence signals, relationship-kind counting, comfort tags, and buildFeatureProjection — the projection other Social Fabric libraries (discovery, LFG, facilitation) consume instead of raw graph data.

NPC voice dialogue sessions (libs/maya/voice-dialogue/src/index.ts, ~230 lines): shouldInitiateConversation, startDialogueSession and turn-taking (manageTurnTaking, recordTurn), buildNpcSystemPrompt for the LLM path plus a deterministic rule-based generateNpcResponse bounded by the NPC's typed knowledge (it answers "I don't know that." rather than inventing facts), consequence derivation, conversation memory, eavesdropping, groups, and transcript logging. The LLM transport itself is not in this library.

Phase 83 voice-driven emergent narrative consequences (libs/maya/voice-narrative/src/index.ts, ~180 lines): detectConsequences from player speech, promise tracking (trackPromise/resolvePromises), propagateLie through rumor spread, reputationFromWord, emotion effects, and detectNarrativeArc over accumulated consequences. What players say to NPCs becomes durable world state.

Voice negotiation mechanics for NPC conversations (libs/maya/voice-negotiation/src/index.ts, ~185 lines): detectNegotiation classifies an utterance into a NegotiationKind (persuasion/intimidation/deception/trade/faction), scoreArgument against context, personality-derived resistance, resolveNegotiation and multi-round nextRound state, witness effects, and rememberPromise negotiation memory.

Natural-language squad command processing (libs/maya/voice-tactics/src/index.ts, ~240 lines): createCommandPromptTemplate over SquadState, decomposeCommand into an ExecutionPlan with temporal dependencies and signal groups, validatePlan issue detection, executeSignal releasing held actions, standing orders, and createPlanPreview HUD markers so the player can confirm before execution.

Gameplay NPC voice-output policy (libs/maya/voice-tts/src/index.ts, ~175 lines — distinct from @maya/forge-companion-voice-tts): createVoiceProfile personality-matched profiles, modulateEmotion producing SynthesisParams, applyTacticalBrevity text compression under combat context, priority queues (enqueueVoice), precacheCommonCallouts, estimateVisemes lip-sync hooks, spatial/radio filters, and benchmarkQuality. It emits synthesis parameters and queue decisions — the audio synthesizer itself lives elsewhere.

A small TS "facade" library (libs/maya/world/src/index.ts, ~415 lines; description "TypeScript facade for Maya world weather, time-of-day, and atmospheric simulation readiness"). It exports world-environment config types and evaluateMayaWorldVirtualEnvironment, scoring weather/time-of-day/atmosphere coverage and emitting issues. It is the readiness companion to the Rust maya-world (chunk streaming) and maya-atmosphere crates in the engine core.

Legends Mode over generated history at libs/maya/world-history/src: legends.ts builds a queryable Legends encyclopedia from the maya-world-history Rust generator's WorldHistory output — figure/artifact/war/civilization lookups over typed HistoryEntry kinds, era grouping, and timeline filtering. The barrel notes the timeline visualization rendering is the app's; this is the query layer feeding it.

In-world social infrastructure (libs/maya/world-social-runtime/src/index.ts, ~205 lines): social hub templates, interactive boards, public co-op rituals (createPublicCoopRitual), guild fairgrounds, social memory surfaces, recurring community-event expansion, NPC anchor points, and quiet social zones (createQuietSocialZone), each constructor validating its typed record. Definitions and validation for the world layer — spawning them into a running world is the engine's job.

A small reference-data library at libs/maya/animal-database/src backing the maya-ecology domestic husbandry simulation: catalog.ts defines the AnimalEntry shape (an AnimalCategory of farm/working/pet/wildlife, Diet, products, care needs) over a committed ANIMALS catalog, with lookup helpers getAnimal, animalsByCategory, and producers. It is a data catalog plus query helpers — the husbandry simulation itself lives in the maya-ecology Rust crate, not here.

A single-module TypeScript library (libs/maya/anticheat/src/index.ts, ~740 lines) implementing anti-cheat enforcement as one stateful MayaAnticheatModerationSystem: bans (MayaAnticheatBan with account/hardware/ip-range scopes), applyEscalatingPenalty ladders, player reports, appeals (submitAppeal/reviewAppeal), and a community tribunal (openTribunalCase, castTribunalVote), governed by a DEFAULT_MAYA_ANTICHEAT_POLICY and failing loud via MayaAnticheatModerationError. It is the moderation workflow engine — cheat detection signals and persistence are the caller's.

A large TypeScript library (libs/maya/client/src, ~75 implementation files) for the Maya runtime client across platforms. Its files group into browser asset delivery (chunked/progressive-mesh/texture-mipmap streaming, CDN integration, service-worker offline support, bandwidth-adaptive quality), a WebGPU render path (~16 webgpu-* files), a WASM bridge (~15 wasm-* files), and native/device targets (android-mobile-build, apple-vision-pro-build, steamvr, Windows). browser-bandwidth-adaptive-quality.ts is representative: real network-class / quality-tier types and adaptive logic, not a stub.

The Maya persistence layer (libs/maya/database/src). Its index.ts barrel re-exports a full set of schema validators with DDL generators (generateUserAccountTableDDL, avatar, inventory, world/zone, building, NPC AI state, quest/progression, economy with parseCents/formatCents, analytics, moderation, asset metadata, permissions, audit) plus a data-access tier: MayaRepository, query builders, MayaTransactionManager, a Redis cache layer, read-replica routing, sharding, archival, backup/PITR, GDPR tooling, anonymizer, retention, and a query optimizer. Real schema/validator/DDL logic throughout — e.g. asset-metadata-schema.ts defines concrete AssetType/AssetStatus enums and record shapes.

A documentation-pipeline library (libs/maya/documentation/src) split into two groups: api-documentation/ (TypeDoc generation, versioned docs, changelog generation, API diff/deprecation tracking, interactive API explorer, PDF/offline export, search, localization, CI/CD) and tutorials-guides/ (authored tutorials such as ai-npc-tutorial, asset-pipeline-guide, building-basics-tutorial). typedoc-generation.ts works against real fs/path and concrete TypedocConfig / DocSymbol models, not placeholders.

Species data management at libs/maya/ecology/src — the TypeScript counterpart to the maya-ecology Rust crate: species.ts defines the typed species schema (Taxon, Archetype, diet, SocialStructure, habitat, perception) including a Kleiber's-law sublinear metabolic-energy model, and registry.ts provides the queryable SpeciesRegistry with taxonomy/habitat/diet queries, predator/prey trophic-web traversal, and validateSpecies referential checks.

A broad virtual-economy library (libs/maya/economy/src, 26 modules): a double-entry ledger (MayaLedgerTransaction), currencies and conversion, idempotent transaction processing, IAP receipt validation with refund/clawback, escrowed direct trading, marketplace listings/auctions (MayaMarketplaceAuctionService), fees, fraud detection (MayaMarketplaceFraudDetectionService), trade restrictions, gifting, price history, economy-health monitoring, and a creator-revenue tier (dashboard, payouts, pricing, promotions, tax compliance, IP disputes). The barrel's MAYA_ECONOMY_PACKAGE descriptor enumerates 32 capabilities that map onto the modules.

Balance-analysis tooling over maya-economy simulation output at libs/maya/economy-tools/src: convergence.ts computes price-series statistics (seriesStats, detectConvergence, volatilityReduction) and report.ts grades settlement economic indicators (gradeHealth into thriving/stable/struggling/crisis, formatReport, rankByHealth). The barrel says plainly that the live debugging dashboard's charts are the app's rendering concern; this library is the analysis that feeds them.

Procedural environmental storytelling at libs/maya/env-storytelling/src — scene dressing that tells stories without dialogue: rules.ts maps WorldEvents (battle/fire/abandonment/celebration/crime) to decoration sets with battleAftermath and abandonmentDecay, surfaces.ts covers lived-in spaces, graffiti, creature trails and economic/seasonal dressing, and placement.ts does collision-avoiding, density-scaled placement (placeAvoidingCollision, densityForDetail, thinToCount).

A TypeScript library (libs/maya/future-input/src, ~31 files, ~21K lines) for next-generation input modalities. The two clusters are brain-computer interface (bci-*: device abstraction, calibration, focus/attention detection, emotional and meditation-state detection, game input mapping, privacy controls, accessibility, multiplayer, research data export, Neuralink preparation) and advanced haptics (force-feedback gloves, full-body exoskeleton, electrical-muscle stimulation, audio transducers, design/recording tools). bci-focus-attention-detection.ts operates on real EEG-style feature vectors (beta/alpha and theta/beta ratios, engagement index, gamma share) to classify attention states — real signal logic.

The largest TypeScript library in the area (libs/maya/games/src, ~109 files, ~123K lines) — the gameplay-systems toolkit. It is organised into ~18 subsystems: abilities, classes, combat, companions, crafting, equipment, gathering, hathor, inventory, items, loot, mmo, party, progression, quests, skills, stats, survival. The combat module alone holds melee/ranged/projectile, blocking-parrying, combo chains, status effects, cover, dodge-roll, AI combat behavior, and a damage-calculation-system.ts with real armor/resistance mitigation, penetration, and outcome-multiplier formulae that compose CharacterStatBlock and ResolvedWeaponInstance — concrete game logic, not CRUD.

Web-Mercator tile mathematics and streaming at libs/maya/geospatial/src: tiles.ts implements the slippy-map tile pyramid (lonLatToTile, tileBounds, zoom 0–21), cache.ts an LRU TileCache with a disk budget, and streaming.ts predictive prefetching plus hybrid real+authored region overrides. The barrel is honest about scope: live tile/DEM/vector ingestion and neural building reconstruction need external APIs, large datasets, and a GPU — this library is the addressing/caching/streaming logic they plug into.

Guild day-to-day operations as a single-module model library (libs/maya/guild-operations/src/index.ts, ~325 lines): project boards (createProjectBoard, updateTaskProgress), contribution summaries by GuildWorkKind, a newcomer welcome queue with pairMentor, calendar events with RSVP/ownership-delegation/expandRecurringEvent, plus knowledge, treasury, goal, hall-scheduling, and officer-coverage records. Pure functions over typed records.

Healthy guild recruitment (libs/maya/guild-recruitment/src/index.ts, ~410 lines): recruitment profiles and searchGuilds, quickApply and reviewApplication flows, provisional trial membership with updateTrialChecklist, referrals, recruiter office hours (scheduleOfficeHour/bookOfficeHour), public pages, kiosks, and recommendations. Model-plus-workflow helpers; no persistence of its own.

Cross-platform identity for Maya Nexus (libs/maya/identity/src, 19 modules): MayaOshunAccountService with real PBKDF2 password hashing (createNodePbkdf2PasswordHasher) and password/email validation, MayaOAuthIntegrationService, MayaTwoFactorService with a genuine generateTotpCode TOTP implementation, and MayaPlatformComplianceLayer compliance gates, alongside account-merge, age gating, cross-platform ban sync, entitlements, friends/party, sessions, SSO, security, and telemetry modules.

A real TypeScript domain library (libs/maya/instancing/src/index.ts, ~2,009 lines; description "Session instancing and player placement core for Maya Nexus", tags layer:domain/domain:instancing) — the third sibling of the Nexus multiplayer-session family, after @maya/matchmaking (rating + queue + allocation) and @maya/lobbies (pre-game). It ships two services. InstanceManagementService owns the instance lifecycle active → idle → draining → shutting-down → closed across four InstanceTypes (persistent, temporary, social, competitive) and the placement of players into the right shard: spawnInstance (capacity + region/InstanceLocation), placePlayer (a PlacementReason-tagged best-instance selector honouring InstanceCapacity min/target/max), population snapshots (population → InstancePopulationSnapshot), overflow/underflow rebalancing (splitOverflowInstance shards a full instance, mergeUnderpopulatedInstances consolidates near-empty ones), cross-instance transfers (beginTransfer/completeTransfer mint and resolve an InstanceTransferTicket with a typed InstanceTransferReason/-Status), graceful drain (beginGracefulShutdown), and a sweepLifecycle tick that ages idle instances and reaps closed ones. ActivityInstancingService layers matchmade PvE/PvP activities on top — ActivityKind (mission/dungeon/raid/ tournament) at an ActivityDifficulty (story→mythic/competitive) — driving an activity through reserveActivityInstance → spawnActivityInstance → activateActivity → mutateActivityState/checkpoint saves → completeActivity/failActivity, with ActivityDifficultyScaling, ActivityCheckpointDefinition/-Save progress, party messaging, friend status, return transfers, and formMatchmadeActivity (an ActivityMatchmakingEntry former) plus ActivityAnalytics. Like its siblings both are dependency-free and deterministic — callers pass nowMs and ids, no clock or network of their own — validated by 12 value-asserting spec cases; it is the tested placement-sharding-and-activity rules engine a real session-orchestration layer drives, not a server fleet itself.

Parametric jewelry and gem generation at libs/maya/jewelry/src: gems.ts does refractive-index optics (criticalAngle, totalInternalReflection, idealPavilionAngle) over real material constants (DIAMOND n=2.42, SAPPHIRE, EMERALD, QUARTZ) with a standard cut library, and metalwork.ts builds prong/bezel/channel Settings, ring bands (makeBand, bandCircumference), chains, and matched ensembles. The barrel states plainly that mesh LOD generation and character try-on physics belong to the render/physics layers — this is the parametric math.

Community-first looking-for-group (libs/maya/lfg-community/src/index.ts, ~480 lines): listings (createListing, createListingFromQuest), applications (requestJoin, reviewApplicant), routeBackfillCandidates, ready-up flows (createReadyCheck, confirmReady), buildExpectationSummary, scheduling, regroup, and squad templates. A pure in-memory rules layer for the social LFG path, sibling to @maya/social-discovery.

Live-event orchestration for synchronized Maya world events (libs/maya/live-events/src, 16 modules): a MayaGlobalEventStateCoordinator state machine, event sequences/cameras/replays, countdown notifications, asset preloading, instance scaling, participation tracking, limited-time modes, world-state mutation (MayaLiveEventWorldMutationService), and a seasonal tier (season pass progression via MayaSeasonPassProgressionService, seasonal content, leaderboards, world changes, archives, analytics). Each service fails loud through its own typed error class; the barrel exports a package descriptor enumerating capabilities.

A real TypeScript domain library (libs/maya/lobbies/src, ~3,050 implementation lines across three services; description "Lobby and pre-game session core for Maya Nexus", tags layer:domain/domain:lobbies) — the deterministic, in-memory logic core for everything that happens between matchmaking and the match itself. LobbyService (index.ts, ~1,094 lines) drives the lobby lifecycle state machine Forming → ReadyCheck → Launching → InGame → PostGame → Disbanded (transitionLifecycle validates each edge) and owns the full pre-game surface: createLobby/joinLobby with separate player and spectator caps, time-boxed invites (createInvite/expireInvites honour inviteTtlMs and mint deep-links off deepLinkBaseUrl), a bounded chat ring with per-viewer mute (postChatMessage/visibleChatFor/setMute, capped at maxChatMessages), ready-check (setReady/readiness → LobbyLaunchReadiness), disconnect/reconnect with a reconnectGraceMs window (disconnectParticipant/reconnectParticipant/expireDisconnected), and team assignment that is either manual (assignTeam) or autoBalanceTeams. SessionDiscoveryService (discovery.ts, ~620 lines) is the server browser: upsertSession/removeSession emit sequenced SessionRealtimeUpdates drained by realtimeUpdatesSince, listSessions/paginateSessions filter and sort by ping/player-count/age/friend-presence, plus favorites with notifications, join history with quickRejoin, friendActivity, quickJoin, and profile-weighted recommendSessions. CustomGameService (custom-game.ts, ~1,336 lines) covers private/custom matches — registerMap/registerMutator, selectMap/mapRecommendations, saved rule presets and published templates, scheduling with scheduled/starting-soon notifications, spectator controls and views, a replay policy with private/friends/public share modes, and analytics snapshots with popular configurations. All three are dependency-free and deterministic (no clock or network of their own — callers pass now ISO strings and IDs), validated by 25 value-asserting spec cases (index 10, custom-game 8, discovery 7); they are the tested rules engine a real transport/persistence layer wraps, not a networking stack themselves.

A real TypeScript competitive-multiplayer library (libs/maya/matchmaking/src, ~3,074 lines across three modules; description "Production matchmaking rating and skill systems for Maya Nexus", tags layer:domain/domain:matchmaking). The rating core (index.ts, ~1,479 lines) implements three competitive rating systems as genuine algorithms, not facades: Glicko-2 (updateGlicko2Rating runs Glickman's full update — preRatingPhi = √(φ²+σ²), iterative volatility convergence to convergenceTolerance, and newPhi = 1/√(1/preRatingPhi² + 1/variance)), Elo (updateEloRating, eloExpectedScore, calculateEloKFactor), and a multi-dimensional TrueSkill2 (aggregateTrueSkill2Mean/-Deviation over the overall, aim, positioning, and teamwork SkillDimensions). On top sit the full competitive surface: 10-match placement (recordPlacementMatch, placementRatingMultiplier), DEFAULT_RANK_TIERS divisions with rankFromRating/evaluateRankMovement, applyRatingDecay and applySeasonalSoftReset, detectPlacementSmurfing, team-skill aggregation, and RatingConfidenceIntervals. runRatingSystemBenchmark checks the implementations against LICHESS_PUBLIC_BENCHMARK_SAMPLE — honestly an 8-row, hand-authored fixture shaped like Lichess data (it carries a dataset label and a sourceUrl, but is committed in-source, not loaded from the live public database) — backed by spec tests. The library also ships the rest of the path into a match: a matchmaking queue (queue.ts, ~994 lines — MatchmakingTickets with priority classes, team assignment, MatchQualityScore, backfill, dodge penalties, and wait-time/satisfaction analytics) and server allocation (allocation.ts, ~601 lines — GameServerInstance health, ServerAllocationPolicy, player connection routing, demand forecasting, reservations, and loading-abandon penalties). It is the rating-and-routing brain behind the Maya Nexus multiplayer layer, paired with its sibling @maya/lobbies.

Social onboarding and mentorship (libs/maya/mentorship/src/index.ts, ~375 lines): detectPlayerLifecycle over lifecycle signals, onboarding journeys with milestone recovery after churn (createOnboardingJourney, recoverMilestonesAfterChurn), routeHelpQuestion, a mentor registry (registerMentor, updateMentorCertification, matchMentors), returner rescue, protected cohorts, and mentor quality tracking. Pure typed helpers for the Social Fabric layer.

A TS trust-and-safety library (libs/maya/moderation/src, ~31 files; package description "Content moderation and trust safety planning for Maya"). It covers hate-speech detection (hate-speech-detection.ts with coded-hate / dehumanization / protected-class categories and an allow/reject/review decision with evidence sourcing), harassment-pattern and ban-evasion detection, CSAM detection/reporting, copyright-infringement detection, image/audio/model content classification, age verification, GDPR/COPPA tooling, appeals workflow, graduated-response and human-moderator tools, and a moderation dashboard/queue. Real classification and policy logic.

A TS planning library (libs/maya/neural-capture/src/index.ts, ~5K lines; description "Advanced neural capture systems for 4D Gaussian splatting, volumetric video, and AI motion capture"). Its create…Plan functions compute deterministic 4DGS pipelines from real inputs — createMaya4DgsTrainingFromMultiViewVideoPlan derives synchronized frame counts, densified Gaussian counts, memory budgets, and a convergence score from calibration/motion-blur quality; siblings plan temporal deformation fields, high-FPS rendering, compression, relighting, editing, and quality metrics. Real estimation math (a planner, not the GPU runtime).

Deployment orchestration for Maya simulation fleets (libs/maya/orchestration/src, 23 modules): MayaFleetManagementService, Agones and Edgegap integrations, autoscaling, blue-green/canary/hotfix/ zero-downtime deployment services (e.g. MayaCanaryDeploymentService with typed policies), multi-region fleets with geographic routing, latency probes, region failover and cross-region transfer, a global session directory, client-version gating, health monitoring, and capacity/deployment dashboards. Each module pairs a service class with a fail-loud error type; it is the control-plane logic, not the cloud provisioning itself.

Procedural ornamental pattern generators emitting 2D curve/point data at libs/maya/ornament/src: curves.ts produces guilloche, Greek-key meander, and filigree scrolls, and interlace.ts produces islamicStar and rosette patterns, torusKnots, celticPlait over/under matrices, and braid-group braids. The barrel is explicit that extruding these into 3D relief and mapping onto meshes belongs to the geometry/render layer — this library is the pattern mathematics.

A small TS "facade" library (libs/maya/physics/src/index.ts, ~340 lines; description "TypeScript facade for Maya physics simulation readiness across cloth, fluid, destruction, and particles"). It exports physics-readiness config types and evaluateMayaPhysicsSimulation, which scores simulation coverage and emits typed issues. The actual physics-backend abstraction (Havok/PhysX/Jolt) is the Rust maya-physics crate inside maya-engine-core; this library evaluates readiness rather than stepping a solver.

Government and faction simulation at libs/maya/politics/src, inspired by CK3 and Dwarf Fortress: government.ts maps GovernmentTypes and policies to governanceEffects, factions.ts runs faction power, loyalty, and civil-unrest escalation (unrestLevel from content through riots to rebellion), and diplomacy.ts covers stances, treaty acceptance, refugees, elections (runForOffice), and bribery. It integrates with the Hathor faction system at the Faction boundary and emits gossip-shaped news via toGossip.

A very large TS "facade" library (libs/maya/renderer/src/index.ts, ~22K lines; description "TypeScript facade for Maya renderer GI, virtualized geometry, and neural rendering readiness", with two author-facing tuning guides under renderer/docs). It plans neural rendering pipelines: designMayaNeuralRadianceCacheArchitecture estimates MLP parameter counts, memory budgets, and training/inference cost from scene complexity; further functions cover NRC warmup/memory/serialization, multi-resolution NRC, Lumen-class GI integration, a temporal ML denoiser (training, ONNX runtime, TAA/ TSR integration, hot-swap), and neural-material/texture compression. Concrete performance-model math.

A very large TS planning library (libs/maya/renderer-advanced/src/index.ts, ~20K lines; description "Next-generation Maya rendering techniques including MegaLights and advanced GPU rendering"). It computes deterministic plans for MegaLights (light-source importance sampling, fixed-ray-count-per-pixel, area-light soft shadows, directional mega-lights, stochastic direct lighting, adaptive noise reduction) and GPU-driven rendering (Nanite voxel geometry, foliage voxelization, instance culling, persistent buffer management, million-instance rendering). Real GPU-budget heuristics, complementary to the core renderer.

A small TS "facade" library (libs/maya/scene/src/index.ts, ~258 lines; description "TypeScript facade for Maya virtual set scene graph, asset loading, and state persistence readiness"). It exports scene-readiness types and evaluateMayaSceneVirtualSet, scoring scene-graph / asset-loading / persistence coverage and emitting issues. It is the readiness companion to the Rust maya-scene crate in the engine core.

The Maya authoritative-server library (libs/maya/server/src, ~31 services). Files are real backend services: matchmaking-service.ts implements ELO skill matching with a concrete formula (K_FACTOR = 32, ELO_BASE = 400, expectedScore/rating updates and match-quality estimation); alongside it are achievement, analytics, anti-cheat, asset-storage, authentication, economy (service + transactions), inventory, leaderboard, notification, payment, player-connection, session, social-graph, world-simulation-loop, zone-handoff, clustering, hot-reload, metrics, service-mesh, and the game-server application. Real service logic.

A large TS planning library (libs/maya/spatial-ar/src/index.ts, ~18K lines; description "Persistent spatial AR content anchoring for Maya AR cloud workflows"). It plans world-scale spatial maps, visual-positioning systems, large-geospatial-model and Niantic spatial localization, cross-device AR content persistence (visionOS / Android-XR / iOS-AR / WebXR), AR cloud storage and real-time sync, content discovery/permissions, colocated multiplayer AR, hand/ eye/gesture controls, passthrough optimization, and real-world occlusion. Typed readiness/plan structures with tracking-state and persistence-backend models.

Spectator and broadcast primitives for Maya Nexus (libs/maya/spectator/src, 14 modules): camera systems (directed camera, free camera, player lock, X-ray observer, picture-in-picture, minimap overview), a MayaKillCamService and MayaPlayOfGameService, and a full replay tier (storage, rendering, highlight detection, annotation, sharing, timeline UI), each service paired with a typed fail-loud error class. Control-plane logic for spectating — actual frame capture/encoding is the engine's.

A very large TS interoperability library (libs/maya/standards/src/index.ts, ~25K lines; description "Metaverse interoperability standards and OpenUSD compliance planning for Maya"). It plans OpenUSD import/export and composition, USD geospatial/international-character/IoT-streaming extensions, glTF + OMI-glTF extension compliance, USD↔glTF bidirectional conversion, material-translation and animation-interoperability, physics/audio schema compliance, behavior-scripting portability, asset-provenance metadata, MSF certification, and avatar formats (VRM, Ready Player Me, MSF avatar standard, cross-platform portability, feature-mapping, clothing-portability, animation-retargeting). Concrete format/compliance modelling with real extension catalogs.

A TS test-infrastructure library (libs/maya/testing/src, ~46 files) for the Maya domain, split into integration-testing/, unit-testing/, and visual-testing/. It provides an integration-test framework plus suites (authentication-flow, client-server, cross-platform, database, e2e-scenario, economy-transaction, multiplayer, world-streaming, VR-device, chaos-engineering), a MayaLoadTester with weighted-scenario selection and p50/p95/p99 reporting, and unit-test helpers (AI, audio, API-contract, data-structure, coverage reporting). Real harness/runner logic.

A TS developer-tooling library (libs/maya/tooling/src, ~46 files) in three groups: asset-tools/ (asset converter CLI, comparison, dependency analyzer, migration, size reporter, validation, audio processing, batch processing, collision/navmesh/LOD/lightmap generation, mesh optimization, texture compression), profiling/ (AI/audio debuggers, breakpoint system, console logging, crash-dump analysis), and world-editor/. mesh-optimization-tools.ts models Quadric/Decimate simplification with concrete mesh stats/analysis (degenerate faces, non-manifold, UV overlap) and optimization results — real pipeline logic.

Tournament and esports infrastructure as one very large module (libs/maya/tournaments/src/index.ts, ~12,100 lines, 163 exported classes/functions/interfaces): typed tournament formats, seeding methods, and registration guards (isMayaTournamentFormat and friends) feeding per-subsystem services that each fail loud through their own error class — creation, bracket formats, seeding, registration and entry fees, scheduling, dedicated-server reservation, match results, anti-cheat escalation, the observer system, and streaming integration.

Community trust & safety for Maya Social Fabric (libs/maya/trust-safety/src/index.ts, ~245 lines): evaluateOnboardingGate, channel selection, moderateText against a LocalizedModerationPolicy, processVoiceSafety, report intake into ModeratorCases with updateModeratorCase action history, plus retention, report-sync, localization, and safety-dashboard shapes. The moderation here is the deterministic policy/case layer, not an ML classifier.

The sandboxed UGC multiplayer runtime foundation (libs/maya/ugc-runtime/src/index.ts, ~5,450 lines, 42 exported functions): script-API policy construction (createMayaUgcScriptApiPolicy), a scene-graph state machine with validated mutation application (applyMayaUgcSceneGraphMutation/-Mutations), game-mode templates (list/get/instantiateMayaUgcGameModeTemplate), creator documentation and tutorial-progress tracking, and server-authority plus hot-reload policies. It is the typed policy/state layer of the runtime — script execution itself happens in the engine sandbox.

Phase 83 urban evolution scheduling (libs/maya/urban-evolution-manager/src/index.ts, ~165 lines): scheduleConstruction driven by constructionDemand, scheduleDecay, scheduleDisasterRecovery, seasonal visual changes, a timeline view over UrbanChanges, and playerImpact attribution. Compact pure scheduling logic for city change over time.

A large TS library (libs/maya/vr-studio/src/index.ts, ~28K lines; description "Immersive VR production studio runtime planning and capability contracts for Maya"). It plans the native VR studio runtime: OpenXR runtime + session lifecycle, reference spaces, swapchains, view/projection, controller/hand/eye input, foveated rendering, mixed reality, spatial anchors, haptics, composition layers, capability + performance overlays, comfort settings, and a full spatial-panel / workspace-layout UI system (placement, lifecycle, adaptive rendering, interaction, text rendering, panel communication). Typed VR-readiness plans with MayaVrIssue diagnostics.

A TS library (libs/maya/vr-studio-web/src/index.ts, ~424 lines; description "WebXR preview bridge contracts for the Maya immersive VR production studio"). It plans the browser/WebXR side of the studio: createMayaVrWebXrSessionPlan, scene-sync, interaction-parity (WebXR vs native), a WebGPU render-path plan, a spectator-review plan, and the preview-bridge that connects the web preview to the native vr-studio. Capability-contract / plan structures.

The Rust engine workspace at libs/maya/engine-core (sourceRoot is crates, tags type:rust / layer:engine) — a 30-crate Cargo workspace and by far the largest entity in the area. Cargo.toml enumerates the members: foundation crates (maya-kernel plugin registry, maya-ecs archetype ECS, maya-jobs work-stealing scheduler, maya-fibers, maya-alloc arena allocators, maya-math SIMD, maya-spatial octree/BVH/k-d tree, maya-reflect, maya-serialize, maya-events, maya-resource, maya-hot-reload) and large domain crates (maya-renderer render graph, maya-physics Havok/PhysX/Jolt backend abstraction, maya-audio spatial acoustics, maya-atmosphere, maya-embodiment avatars, maya-souls NPC/dialogue AI, maya-nexus client-server networking, maya-world chunked streaming, and the maya-genesis-flora/-terrain/-urban procedural crates). Each crate's description in its Cargo.toml is authoritative; maya-physics is explicitly "backend abstraction and integration planning". The project also ships a small TS src/index.ts that is a readiness evaluator (createMayaEngineCoreVirtualEnvironmentFrame validating PBR materials and estimating frame latency), distinct from the Rust runtime.

A Rust crate (libs/maya/forge-ai-assist/src/lib.rs, ~629 lines, tag layer:forge) with a TS mirror (dual type:rust-lib / type:ts-lib); module doc "Deterministic planning primitives for AI-augmented Forge modding tools." It is the planning layer behind the Forge authoring tools' AI assistance: from an AiGenerationContext it produces deterministic plans across an AiContentCategory taxonomy — a ModScaffold (a set of GeneratedFiles), plus TexturePlan, ModelPlan, SoundEffectPlan, QuestPlan, and NpcPlan — and a ConflictResolutionPlan from ConflictInput, with a ReviewStatus gate so AI-suggested content is human-reviewed before it lands. Honesty: as the module doc says, these are deterministic planning primitives (4 unit tests) — the crate computes what to generate and how to structure it, but the actual generative model is a deferred seam (it emits plans and scaffolds, not model-generated textures/meshes/audio/prose), the same boundary forge-ai and the @themis/universal-* libs document. It is the AI-assist companion to the forge-* UGC authoring stack.

A TS library (libs/maya/forge-api/src/index.ts, ~1,084 lines, single module; no package description — per its barrel, the Forge public API gateway). It is the REST + GraphQL surface over the Forge mod catalog. ForgeApiGateway (built by createForgeApiGateway) handles RestRequest→RestResponse calls and GraphQlRequest→GraphQlResponse queries over ForgeModRecords (ForgeModCreateInput / ForgeModUpdateInput CRUD, ForgeModReview moderation state), with authorize enforcing per-ApiSubject RegisteredCredentials, ApiVersionSpec version negotiation, RateLimitConfig + rateLimitHeaders throttling, typed ApiErrorBody errors, and PaginatedResult cursoring. Honesty: this is a deterministic, in-memory request-handling layer — it processes request/response objects and stores mod records in memory; it binds no real HTTP/GraphQL server, database, or transport (those wrap this gateway downstream). It is the public-API leg of the Forge UGC stack — the surface external clients reach the mod catalog through.

A dual Rust+TypeScript crate (tags type:rust-lib, type:ts-lib, layer:forge) for backward-compatibility management of published Maya Forge mods across game versions — the Rust module doc reads "Backward compatibility management for Maya Forge mods," and package.json (0.1.0) carries no description. Unusually for the maya area, this is not a TS plan over a Rust engine: libs/maya/forge-compat/src/lib.rs (270 lines incl. tests) and libs/maya/forge-compat/src/index.ts (157 lines) are parallel mirror implementations of the same API, both real and both tested. Around shared types — PublishedMod, GameVersion (availableApis/deprecatedApis/removedApis), CompatibilityStatus (pass/degraded/fail) — six pure functions do the work: buildCompatibilityMatrix set-diffs each mod's apiCalls against a version to grade every row; deprecationWarnings surfaces replacement/migrationGuide/sunsetVersion; buildCompatibilityShims maps removedApis; pinGameVersion mints a simultaneousLoaderSlot; detectBreakingChanges flags impacted mods/authors; migrateModSource rewrites a mod's wasmSource. Honesty: deterministic and dependency-free, but migrateModSource is naive substring replacement (not semantic WASM rewriting), buildCompatibilityShims stamps a constant "next-major" lifetime, and there is no registry or persistence — these are pure functions over caller-supplied data. Three Rust #[test]s and five Vitest cases assert specific computed values.

A dual Rust+TypeScript library (tags scope:maya, layer:forge, type:rust-lib, type:ts-lib) whose two surfaces — libs/maya/forge-cross-platform/src/lib.rs (393 lines incl. tests, unsafe_code = "forbid", zero dependencies) and libs/maya/forge-cross-platform/src/index.ts (271 lines) — are line-for-line parallel ports of the same logic, not one FFI facade over the other. Neither Cargo.toml nor package.json carries a description, so the Rust module doc names it: "Cross-platform mod packaging and execution planning for Maya Forge." Within the Ixchel Forge UGC stack (beside @maya/forge-core's ModManifest/registry) it answers "will this mod run, and how does it package, across the nine PlatformKind targets" — pc/playstation/xbox/switch/ios/android/vr/web/cloud.

This is real, deterministic policy logic, not a scaffold: profilePlatform maps each target to a CapabilityProfile (GPU features, cpuArch of x86_64/aarch64/wasm32, OS capabilities); packageForPlatform derives a PackageVariant with texture-compression selection (astc/basisu/bc7), per-platform texture/LOD clamps and a 44.1 kHz audio cap; enforceMobileBudget (512 MB / 1024 px / 25k-poly ceilings), curateConsoleMod, validateVrRequirements (11 ms budget), planWebWasmExecution and planCloudHosting emit typed compatible/requiresOptimization/blocked verdicts that validateCrossPlatform folds into a CompatibilityMatrix. Both surfaces carry matching tests (3 Rust #[cfg(test)] cases; a 91-line index.spec.ts over the same mod.weather asset). Honesty: budgets, GPU lists and cloud regions (iad/sfo/fra) are hardcoded heuristics and outputs are plans/reports — actual cooking, signing and certification stay downstream in the engine and platform toolchains.

A dual Rust + TS library (tag layer:forge, type:rust-lib / type:ts-lib): the TS client SDK (libs/maya/forge-sdk/src/index.ts, ~555 lines) plus a Rust mirror (src/lib.rs, ~333 lines, "Native SDK planning primitives for Maya Forge clients"). It is the client SDK for the Forge API gateway (@maya/forge-api). ForgeSdkClient (built via createWebForgeSdk / client) wraps ForgeMod CRUD (ForgeCreateModInput / ForgeUpdateModInput), ForgeListOptions→ForgePage pagination, ForgeGraphQlQuery queries, and ForgeRealtimeSubscription streaming (ForgeSdkStreamRequest / ForgeSdkStreamFrame) over a pluggable ForgeSdkTransport with a ForgeSdkRetryPolicy and a MemoryWebForgeCache; createUnityWrapperDescriptor / createUnrealWrapperDescriptor describe the engine-side bindings. Honesty: this is a deterministic SDK shell — only InMemoryForgeTransport ships, so out of the box it talks to an in-memory Forge; the real HTTP/GraphQL transport is an injected ForgeSdkTransport seam, and the Unity/Unreal wrappers are descriptors, not compiled bindings. It is how web and engine clients reach the Forge mod catalog — the SDK companion to @maya/forge-api.

A Rust crate (libs/maya/forge-ai/src/lib.rs, ~1,231 lines, tag layer:ixchel; Cargo.toml carries no description, so its module doc: "Maya Forge AI behavior mod layers") that lets Ixchel mods reshape NPC behavior deterministically. It models seven composition surfaces: additive BehaviorTreeExtensions grafted onto a BehaviorTree; explicit priority-ranked BehaviorReplacements resolved through a BehaviorOverrideRegistry (highest priority wins, ties broken by mod id, losers recorded as IgnoredReplacements and re-pointed in parents/root); BigFiveProfile personality deltas summed then clamped to 0.0..=1.0 by PersonalityComposer; DialogueStyleMod prompt-template injection; SocialRuleComposer faction/reputation/hierarchy precedence; CombatAiMod tactical branches; and DailyRoutineComposer schedule merging. Every composition emits provenance — source_mod_id per node plus an AiModDebugReport so realm operators see which mod supplied each branch.

Honesty: this is pure, dependency-free (unsafe_code = "forbid") in-memory data composition with 6 unit tests, schema maya.forge.ai.1. It deliberately stops at the engine boundary — it shapes behavior-tree and dialogue-prompt data, but binds no actual behavior-tree executor or dialogue model.