Every seam, by category

The always-on kernel: connect, login, sessions, rooms/groups, and the messaging SDK.

• IAccountCharacterSource game SPI

  Where an account's character ids come from.

• IAccountDataParticipant game SPI

  GDPR seam: one participant per data domain.

• IAccountDirectory provider

  Resolves online players by ACCOUNT id — the account-keyed sibling of IOnlineDirectory (which resolves by display name).

• IAccountStore provider

  Account persistence.

• IAnomalySink game SPI

  Where anomaly flags go.

• IAuditSink provider

  A durable destination for audit entries (so the trail survives a restart).

• IBanStore provider

  Persists account bans.

• IClusterBus provider

  Cross-node message bus — publish/subscribe of opaque bytes on named channels.

• IClusterInbox provider

  A hand-off queue from background bus threads to the server poll thread.

• IClusterSessionControl provider

  Cross-node SESSION CONTROL — the act-on sibling of the account directory's remote proxies.

• IConnection provider

  A single transport-level connection (one peer).

• IDistributedLock provider

  Cross-node mutual exclusion for the rare operations that must not run twice concurrently anywhere in the cluster (cross-node matchmaking sweeps, market settlement, scheduled jobs).

• IEmailSender provider

  Outbound email delivery — the game/ops plug in SMTP/SES/SendGrid; the framework never speaks a mail protocol itself.

• IExternalIdentityValidator provider

  Platform ticket validation — the game plugs Steam/Google/Apple (usually an HTTPS call to the platform; it runs on the auth work queue, never the poll thread).

• IFleetLifecycle game SPI

  The provider-neutral lifecycle contract between this node and the fleet orchestrator that HOSTS it (PlayFab Multiplayer Servers, Amazon GameLift Servers, an Agones sidecar).

• IHealthCheck game SPI

  A readiness check for one subsystem (e.g. the persistence backend or the transport).

• IIdentityLinkStore provider

  The external-identity ↔ account link table: a proven platform identity (provider + externalId) maps to the account it was attached to.

• IMessageHandlerRegistrar game SPI

  Implemented by any package/piece that contributes message handlers.

• IMetricsTextSource game SPI

  A pluggable extra section for the /metrics endpoint.

• IOutboundShaper provider

  Decides whether an outbound frame to a connection may go out under that connection's bandwidth budget.

• IPasswordHasher provider

  Hashes and verifies passwords using a salted, slow KDF.

• IRestResource game SPI

  One read-only JSON resource on the companion-app gateway: GET /api/{name}?args → Get.

• IResumeTokenStore provider

  Tracks issued reconnect tokens so a later ResumeSession can be validated.

• IServerClock provider

  A monotonic millisecond clock.

• IServerInfoProvider game SPI

  Builds the ServerInfo advertised to clients on connect.

• IServerMetrics provider

  A pluggable telemetry sink.

• IServerPollable game SPI

  Incremental per-poll work hook: Poll calls Pump every cycle — a high-frequency, event-driven cadence (typically thousands of times per second under load, and at least the host's…

• IServerTickable game SPI

  Implemented by pieces that need periodic server work decoupled from the inbound-message poll — e.g. the Movement piece batches its observer broadcast into a fixed-rate tick (ser…

• IServerTransport provider

  A server transport.

• ISessionLifecycleListener game SPI

  Implemented by pieces that need per-connection lifecycle hooks — e.g.

• ISessionTokenFactory provider

  Creates opaque, unguessable session tokens used for reconnect.

• ITransportSignal provider

  Optional low-latency extension of IServerTransport.

• IAuthProvider unity SPI

  SPI: a source of platform login tickets.

• IClientTransport unity SPI

  The client's wire seam — the mirror of the server's IServerTransport.

• IConnectionStats unity SPI

  Cumulative wire counters for the client connection — the raw feed for diagnostics overlays (rates are computed by the consumer over its own window).

• IServerClockSampler unity SPI

  Write side of the clock — the heartbeat feeds one sample per pong.

• IServerConnection unity SPI

  Client half of the transport: a single UDP link to the Crossplay server.

Genre-agnostic authored-content store: define content types + records (entities, items, levels, classes, quests, anything) over a metaschema — every domain type is DATA, not code. Saved in the DB, served to clients on demand (manifest -> lazy fetch -> live push), asset-load-path binding. A must for Core — auto-installed, cannot be unselected.

• IContentAssetStore provider

  Persistence seam for authored content ASSETS — keyed + versioned binary blobs (images/icons/audio).

• IContentStore provider

  Persistence seam for authored content.

• IContentAssetBinder unity SPI

  The game-implemented seam that turns a content record's opaque asset-path field into a real Unity asset.

Create / select / roster of characters with an opaque appearance blob (ICharacterFactory SPI).

• ICharacterNamePolicy provider

  The game's name rule beyond the universal length gate (donor-gap E3): reserved names, charsets, profanity filters, impersonation guards — all the game's vocabulary.

• ICharacterPolicy game SPI

  5.3: the game's precondition gate on character CREATE and SELECT — beyond the built-in checks (length, name policy, roster limit, name uniqueness, ownership).

• ICharacterStore provider

  Character persistence SPI — the seam a game implements to store its roster durably.

• ICharacterFactory unity SPI

  SPI the game implements to turn an opaque appearance blob into a visible avatar.

Enter-world, spawn/despawn, spatial interest, zones/instancing, server entities, bounds.

• IBoundsArea game SPI

  A playable area on the XZ plane — the abstract "shape of the map" both tiers evaluate with the SAME code (this assembly ships to the server and, as the embedded contracts DLL, t…

• IInstanceSpawnPolicy game SPI

  Optional per-arrival spawn placement into an instanced zone — the seam the composition-layer Zone instance realizer consults so a SPATIAL game gets scatter (or any per-player la…

• IInterestVisibilityPolicy game SPI

  The game's "may this observer KNOW this subject exists" rule — fog of war, spotting systems, bush/stealth mechanics, GM invisibility.

• IPositionStore provider

  Persists a character's last zone + world position, so a player resumes where they logged out (see RestoreSavedPosition).

• ISpatialIndex provider

  2D spatial index over the XZ plane for interest queries — the swappable strategy behind the interest system (one index per zone).

• ISpatialIndexFactory provider

  Creates one spatial index per zone/instance (each zone is its own interest space).

• IWorldBounds game SPI

  SPI the game implements to give zones a playable-area shape ("drop a map, it has bounds"): return an IBoundsArea (box, circle, grid mask, or the game's own shape) per zone, or n…

• IZoneDirectory provider

  Who owns which zone — the seam that turns zone-per-node scale-out from static config into a live cluster directory.

• IClientWorldBounds unity SPI

  SPI the game implements to give the CLIENT the same per-zone playable areas it registered on the server (IWorldBounds) — the shared BoundsResolver then makes local prediction sl…

• ITerrainHeightProvider unity SPI

  SPI the game implements to ground remote replicas: the server is authoritative over X/Z but does not simulate Y, so the client samples the terrain height for spawns and moving e…

• IWorldEntities unity SPI

  Read model over the entities the client currently knows about (self + observed remotes).

Server-authoritative movement: input, 20Hz broadcast, prediction/reconciliation, interpolation.

• IBroadcastCullingPolicy game SPI

  Network-LOD seam: decides, per subject→observer pair, how often that observer receives the subject's EntityMove.

• IControlResolver game SPI

  Possession seam: decides which entity a session's movement input drives.

• IMovementGate game SPI

  Mobility seam: may this entity move right now?

• IMovementSpeedProvider game SPI

  Per-entity move-speed seam: how fast may THIS entity move right now?

• IAnimatorParameterMapper unity SPI

  SPI the game implements to map Crossplay's universal locomotion state onto its own animator.

• IGameplayInput unity SPI

  SPI the game implements to feed movement intent from any input source (new Input System, AI, replay, …).

• IMovementDiagnostics unity SPI

  Live movement-quality numbers for diagnostics overlays — how far behind the render timeline sits, and how wrong the last prediction was.

Per-pair broadcast-rate rings so distant entities cost less bandwidth. Off by default.

• ICullingClient unity SPI

  The client culling layer: assigns every world entity view a distance tier from the local player and (by default) applies the built-in actions — full detail near, animator pose-w…

"Player used entity X": a validated verb pipeline; the game's policy SPI decides meaning.

• IInteractionPolicy game SPI

  The game's interaction rules — THE plug-in point of this piece.

Optimized networked transform sync for non-player physics bodies (crates/vehicles/debris/doors): quantized position + smallest-three quaternion + velocity, sleep-gated, interest-culled, batched. The game runs its own physics; this only syncs the result.

• IPhysicsBackend provider

  OPTIONAL engine seam: a server-authoritative physics engine that RigidBodies drives.

• IRigidBodyIntegrator unity SPI

  The game's local-physics seam for bodies THIS client owns and predicts (Pattern B, PhysicsNetMode.ClientPredicted).

• IRigidBodyView unity SPI

  The presentation seam for ONE rigid body — the game binds an entity id to its own Rigidbody/Transform (or a 2D body, or a text row: the piece cannot tell).

• IRigidBodyViewFactory unity SPI

  The game's factory that resolves an entity id to its IRigidBodyView — the rigid-body analogue of ICharacterFactory.

Shared spatial cell grid: per-zone chunked opaque cells (terrain edits, tiles, build pieces), streamed to each player's chunk window and delta-batched on change. Seed + persistence SPIs; server-set only.

• IWorldGridSeed game SPI

  The procedural-generation seam: fills a chunk's cells the FIRST time it is touched (no stored copy existed).

• IWorldGridStore provider

  Persistence seam for chunk payloads — one record per (zone, chunkX, chunkZ).

Spatial enter/exit/dwell volumes over the world. Server-only.

• ITriggerListener game SPI

  SPI the game implements to give volumes meaning — the plug-in point of this piece.

NPC behavior drivers: wander/patrol/chase built-ins + an IAgentBehavior game SPI. Server-only.

• IAgentAttackHandler game SPI

  The attack seam this piece OWNS: a behavior decides WHEN to attack (range, cooldown); this seam decides WHAT an attack does — spawn a projectile, apply a stat change, start a di…

• IAgentBehavior game SPI

  One NPC brain — the SPI to implement for custom AI.

Instanced-zone lifecycle: create/seed via IDungeonContent, complete/reset, abandon sweep. Server-only.

• IDungeonContent game SPI

  The game's dungeon content — THE SPI to implement for the Dungeons piece.

A rideable STATE on an entity: mount id + opaque look blob + speed multiplier (applied through Movement's speed seam via a Hosting bridge). Horses, hoverboards, sprint stances, transformation forms — same state machine, the game's render. Ownership/eligibility = IMountPolicy; broadcast on change + replayed on interest reveal; empty catalog = inert.

• IMountPolicy provider

  The game's mount rule: may THIS player ride THIS mount now?

Bind/recall points, a warp destination table, and death→respawn location resolution through an ORDERED strategy chain (bind → nearest zone point → your own IRespawnStrategy). WHEN travel is allowed is the game's policy SPIs (the default DENIES client respawns until one is composed — the Stats-depletion bridge supplies the classic 'dead may go home'); moves ride the ITravelMover seam (Movement's prediction-aware Teleport when composed).

• IBindPointStore provider

  Storage seam for per-player bind points.

• IBindPolicy provider

  The game's bind rule: may THIS player bind HERE, now?

• IRespawnPolicy provider

  The game's respawn gate: WHEN may this player respawn?

• IRespawnStrategy game SPI

  One link of the respawn WHERE chain.

• ITravelMover provider

  HOW an entity actually moves — the seam that keeps Travel off the Movement piece (a sibling, never a reference).

• IWarpPolicy provider

  The game's warp rule: may THIS player take THIS destination now?

Opaque verbs with server-tracked cooldowns and an IAbilityRules SPI.

• IAbilityBookPolicy provider

  The game's learning rule (donor-gap E4): may THIS player learn (or rank up) THIS ability now, and at what cost?

• IAbilityBookStore provider

  Storage seam for the per-player book.

• IAbilityGate game SPI

  Actor seam: may this entity use abilities right now?

• IAbilityRules game SPI

  SPI the game implements to give abilities their meaning — hit detection, damage, combos, ammo.

Kinematic projectile entities with deterministic client rendering + click-frame prediction: one launch event per volley, no interpolation buffer.

• IProjectileRules game SPI

  SPI the game implements to give projectiles their meaning.

• IProjectilesClient unity SPI

  The projectile client: renders deterministic catalog kinds from the shared trajectory evaluator at server-now (no interpolation buffer — their entities stop streaming movement)…

Timed opaque markers (buffs/debuffs) applied to entities.

• IStatusEffectRules game SPI

  SPI the game implements to give effects their meaning — a burning DoT modifies a stat on tick, a stun gates ability rules, a shield changes damage math.

WHO MAY HARM WHOM, answered in one place: consent stances (opt-in verb), combat flags on aggression, escalation tiers on innocent kills, safe zones — one IHarmResolver seam every combat consumer asks (Crossplay:Hostility:DriveTargeting bridges Targeting). PvE pairs pass through untouched; defaults = the classic no-PvP baseline.

• IHarmResolver provider

  THE seam combat consumers ask: may attacker A harm target B right now?

Server-only auto-attack driver: enrolled attackers acquire a target (ITargetSelector) and attack on a cadence (IAttackAction) over World — survivors/auto-shooter auto-fire, turrets, sentries, pet auto-attack. Genre-neutral defaults (nearest-in-cone selection, two-faction PvE hostility, inert attack); zero wire.

• IAttackAction game SPI

  Effect seam: what does an attack DO?

• IAttackCadenceProvider game SPI

  Per-attacker fire-cadence seam: how many seconds between THIS attacker's shots right now?

• ITargetHostility game SPI

  Faction seam: is a candidate a valid target for an attacker?

• ITargetSelector game SPI

  Acquisition seam: which entity (if any) should this attacker attack right now?

Pooled nameplates + eased HP bars + effect chips + cooldown pips over the combat clients. Client-only UI.

• ICombatHudNameSource unity SPI

  The game's display-name vocabulary: Crossplay has no client-side name registry (names are game data — often encoded in the opaque appearance blob), so plates ask the game.

• ICombatHudStyleSource unity SPI

  The game's effect presentation vocabulary: an effect id means nothing to the framework, so the default chip is a deterministic id-derived color + the numeric id.

• ICombatLogClient unity SPI

  Read access to the live combat log, for games that render their own feed instead of (or beside) the built-in view.

• ICombatLogVocabulary unity SPI

  The game's combat-log wording.

• IHudCameraProvider unity SPI

  The camera plates project through.

The generic opaque-item-container engine every item piece sits on: containerId-keyed slots/stacks, policy SPI, persistence, and atomic cross-container moves. Server-only; inventory/bank/vault/equipment are thin roles over it.

• IContainerConfigProvider provider

  Optional seam: supplies the ContainerConfig to create a container with the FIRST time the engine loads it, when no explicit config was passed to EnsureContainer.

• IContainerPolicy game SPI

  SPI the game implements to give containers their item rules — the framework only moves opaque bytes.

• IContainerStore provider

  Persistence seam for containers, keyed by ContainerId.

The character's bag — a container role over the Container engine (opaque item blobs, policy SPI, persistence).

• IInventoryPolicy game SPI

  SPI the game implements to give items its rules — the framework only moves opaque bytes.

• IInventoryStore provider

  Persistence seam for inventories, keyed by character id.

A personal item-storage container — a role over the Container engine (opaque item blobs; atomic bag<->bank deposit/withdraw via TryExchange; policy SPI; persistence). Depends on Container, not Inventory.

• IBankPolicy game SPI

  SPI the game implements to give the bank its item rules — the framework only moves opaque bytes.

Worn/active gear in typed slots — a container role over the Container engine (opaque items + opaque slot ids, IEquipmentPolicy SPI). World-optional visible loadout broadcast; item effects via Equipped/Unequipped events (never references Stats).

• IEquipmentPolicy game SPI

  SPI the game implements to give equip slots their TYPED rules — the framework only moves opaque bytes into slots.

• IEquipmentClient unity SPI

  The Equipment piece, client side.

• IEquipmentView unity SPI

  The presentation seam for ONE wearer's VISIBLE loadout — the game binds an entity id + its equipped slots to its own models / attachment points (or a text row, or a 2D paper-dol…

• IEquipmentViewFactory unity SPI

  The game's factory that resolves a wearer's entity id to its IEquipmentView — the equipment analogue of IRigidBodyViewFactory / ICharacterFactory.

Validated recipe execution (opaque in/out, all-or-nothing) over Inventory; catalog is a game SPI.

• ICraftingCatalog game SPI

  SPI the game implements to supply its recipe book — the piece is inert (every craft returns UnknownRecipe) until a non-default catalog is registered.

• ICraftingRules game SPI

  Optional SPI the game implements to gate crafts beyond "holds the ingredients" — skill/level checks, a required crafting station in range, per-recipe cooldowns, quest prerequisi…

Atomic, policy-gated, ledgered currencies; read-only on the wire.

• IEconomyLedger provider

  SPI recording every committed mutation — the audit trail for the whole economy.

• IEconomyPolicy game SPI

  SPI the GAME implements to gate every currency mutation — where taxes, caps, level requirements, and region rules live.

• IEconomyStore provider

  Persistence seam for balances.

Escrowed listings + lock-guarded buyout over Inventory + Economy, with durable Scheduler expiry.

• IMarketExpirySchedule provider

  The durable-expiry seam a Market needs: schedule (and re-schedule) a listing's auto-return to the seller — without the piece compiling against the concrete Scheduler.

• IMarketStore provider

  Listing persistence SPI (in-memory default; document-backed across restarts/nodes).

• IMarketWallet provider

  The currency seam a Market needs: debit the buyer, credit the seller.

System-owned stores selling/buying OPAQUE items for game currencies: catalog stock, per-buyer daily caps, finite stock, buyback ring. Currency/access/appraisal/pricing are seams (Economy bridges the wallet); WHAT a shop is — NPC, vending machine, terminal — is the game's. Server-only wire verbs; empty catalog = inert.

• IShopAccess provider

  The game's access rule: may THIS player use THIS shop right now?

• IShopAppraiser provider

  The game's sell-side rule: what does THIS shop pay for THIS item?

• IShopCounterStore provider

  Storage seam for per-buyer daily purchase counters.

• IShopPricing provider

  The game's buy-side price rule — personalizes an entry's unit price per buyer (reputation discounts, dynamic economies, sales).

• IShopWallet provider

  The currency seam Shop spends and pays through — the piece references NO concrete currency system.

Offline delivery with escrowed item attachments.

• IMailPolicy game SPI

  SPI the GAME implements to gate every player-to-player send — where block lists, cross-faction rules, and postage costs (via Economy) live.

• IMailRecipientResolver provider

  The identity seam Mail resolves recipients through, so the piece never hard-references the Crossplay.Characters spatial piece (it only needs a name↔id directory, not character d…

• IMailStore provider

  Mail persistence SPI (in-memory default; document-backed override across restarts).

Shared guild inventory of opaque item blobs with per-rank deposit/withdraw/view permissions and an audit trail.

• IGuildVaultPolicy game SPI

  SPI the game implements to give the vault its item rules — the framework only moves opaque bytes.

• IGuildVaultStore provider

  Persistence seam for guild vaults, keyed by guild id.

Data-driven purchase catalog: wallet stat, per-buyer live price (stored as a stat, so it replicates) with growth, and capped stat effects. Server-only wire verb; empty catalog = inert.

• IPurchasePolicy game SPI

  Whether a purchase may happen RIGHT NOW — the SPI that keeps commerce timing the game's.

Coin-priced, persistent, server-authoritative meta-upgrades: price from the buyer's stored tier (ceil(InitialPrice*Growth^tier)), atomic currency debit, tier persisted per-character. Currency + persistence via seams bridged to Economy + PlayerData.

• IUpgradeTierStore game SPI

  The persistence seam: read / write an owner's upgrade TIER by key.

• IUpgradeWallet game SPI

  The currency seam: debit amount of currency for an upgrade purchase, atomically.

Channels and whispers over Core, with profanity masking and rate caps.

• IChatClock provider

  Wall-clock seam (unix UTC ms) so mute-expiry math is testable — implement it to feed a fake clock in tests.

• IChatMuteStore provider

  Mute-persistence SPI — the seam that decides where mutes are stored.

Persistent guilds: officer ranks, MOTD, invites/kicks, leader handoff.

• IGuildStore provider

  Guild persistence SPI — the seam that owns where and how guild data lives.

Ephemeral parties: leader, ready checks, kicks.

• IPartyReadySink game SPI

  The post-ready-check seam the Party piece OWNS — the analog of Matchmaking's IMatchFormedSink and Lobbies' ILobbyStartSink: fired once when a party's ready check completes with…

• IPartyStore provider

  Persistence SPI for live parties and pending invites.

Server-authoritative in-match sides per game-defined scope: opaque team ids, members, a rankable score + opaque blob, team-scoped broadcast, optional policy-gated self-service joins.

• ITeamPolicy game SPI

  Game-implemented join rules for self-service (TeamJoinRequest) joins — balance caps, faction locks, "no switching after the round starts".

Friend lists, requests, and online presence.

• IFriendStore provider

  Friendship persistence SPI.

Queue-based matchmaking with team/role quotas and MMR.

• IMatchFormedSink game SPI

  The post-formation seam this piece OWNS (the IMatchResultSink idiom): called after a match forms, BEFORE any MatchFound is sent, with every member — cross-node aware.

• IMatchmakerPolicy game SPI

  SPI the game implements to gate match QUALITY: given a full set of candidates, is this a good enough match to form now?

• IRatingModel game SPI

  SPI the game implements to rate players — the MMR the matchmaker balances by.

Create/join/list lobbies with slots and metadata.

• ILobbyStartSink game SPI

  The start seam this piece OWNS (the IMatchFormedSink idiom): called inside TryStartMatch after the lobby's state flips to InProgress, BEFORE the MatchStarting broadcast, with th…

Allocate game instances (zone/room/lockstep) on match/lobby formation across nodes, hand each player a single-use join token, run the lifecycle, and return them to the hub.

• IExternalAllocator game SPI

  The game/infra adapter to an EXTERNAL fleet manager (Agones, a Kubernetes operator, a studio's own allocator API).

• IInstanceRealizer game SPI

  The kind bridge: how an InstanceKind becomes a real container on THIS node.

• IInstanceStore provider

  Instance-record store.

• IJoinTokenStore provider

  Single-use join-token store.

• IPlacementStrategy provider

  Placement SPI.

• ITransferAuthenticator unity SPI

  Narrow re-authentication seam the transfer flow rides after each dial: "restore my session on the server I'm now connected to — did it work?".

Persistent ranked boards: keep-best, around-me, rolling seasons.

• ILeaderboardClock provider

  SPI supplying "now" (unix UTC ms) to the rolling-season math — implement it to control where season boundaries fall (and to make season rollover deterministic in tests).

• ILeaderboardStore provider

  Persistence-swappable storage for leaderboard entries: an upsertable set of ScoreRecord per (board, season).

Interval claims with grace-window streaks; reward is an IDailyRewardGrantor game SPI.

• IDailyClock provider

  Wall-clock seam (unix-epoch UTC milliseconds) so the interval/streak math is testable and restart-safe.

• IDailyRewardGrantor game SPI

  THE game hook: what a daily reward IS.

• IDailyRewardStore provider

  Claim-state persistence SPI, keyed by the owner (character) id.

Server-reported counters against game-defined thresholds; catalog/reward are game SPIs.

• IAchievementCatalog game SPI

  SPI the GAME implements to declare its achievements — the source of every id, counter key, and threshold.

• IAchievementRewardGrantor game SPI

  Optional SPI the GAME implements to decide what an unlock GRANTS.

• IAchievementStore provider

  Persistence seam for achievement state.

Multi-track server-granted xp/levels; curve is config exponential or an IProgressionCurve SPI.

• IProgressionCurve game SPI

  SPI the GAME implements to define the shape of the leveling curve — how much xp completes each level on a track.

• IProgressionRewardGrantor game SPI

  Optional SPI the GAME implements to decide what a level-up GRANTS.

• IProgressionStore provider

  Persistence seam for progression state.

Accept/track/turn-in over game-defined objectives; catalog/policy/reward are game SPIs.

• IQuestCatalog game SPI

  SPI the GAME implements to define its quests — the source of every quest id, its repeatable flag, and its objectives.

• IQuestPolicy game SPI

  SPI the GAME implements to gate quest ACCEPTANCE — prerequisites, level gates, faction checks, "one per chain" rules.

• IQuestRewardGrantor game SPI

  Optional SPI the GAME implements to decide what a turn-in GRANTS.

• IQuestStore provider

  Persistence seam for quest state.

Server-resolved conversation graphs: opaque node/choice payloads, per-choice conditions evaluated SERVER-side and stripped from the wire, choice actions via game SPIs. NPC talk, visual novels, tutorials, quest givers — one engine; Core-only, stateless, empty graph table = inert.

• IDialogAction game SPI

  The game's action vocabulary: what picking a choice DOES — accept a quest, open a shop, grant an item, set a flag.

• IDialogCondition game SPI

  The game's condition vocabulary: "is condition C true for THIS player right now?" — quest state, stats, items, reputation, anything.

• IDialogPolicy provider

  The game's open rule: may THIS player open THIS graph now?

• IDialogSource provider

  Where graphs come from.

Per-player key/value store of opaque blobs.

• IPlayerDataPolicy game SPI

  SPI the game implements to gate CLIENT-initiated writes (the wire PlayerDataSet).

• IPlayerDataStore provider

  Persistence seam for player data, keyed by the owner (character) id.

Match lifecycle (countdown/duration/return-zone) with results bridged to Leaderboards.

• IMatchResultSink game SPI

  Where final results go besides the participants — the composition layer bridges this to Leaderboards when both pieces are present (Matches itself never references another piece).

• IMatchRules game SPI

  SPI the game implements to give matches their meaning — scoring, win conditions, teams — the plug-in point of this piece.

Server-authoritative phase/round state machine per game-defined scope: opaque phase ids, per-phase deadlines, IRoundFlow SPI transitions, and an authoritative elimination set. No client verbs (unforgeable).

• IRoundFlow game SPI

  THE plug-in point of the Rounds piece: the game's phase graph.

Server-opened proposals over opaque choice ids: one ballot per eligible voter, live anonymous tallies, deadline/everyone-voted close, outcome decided by an IVoteRules SPI (plurality default). The game acts on Closed; the piece never executes outcomes.

• IVoteRules game SPI

  The game's tally rules: called once when a vote closes (deadline, everyone voted, or an explicit close) with the full context — all ballots, choices, and eligible voters — and a…

Server-assigned opaque role ids with per-viewer visibility filtering (a hidden assignment never touches the wire), per-holder private payloads, role-scoped sends, and an end-of-game reveal. IRoleVisibilityPolicy SPI; no client verbs (unforgeable).

• IRoleVisibilityPolicy game SPI

  The game's "who may know whose role" rule — the non-spatial visibility axis this piece exists for.

Live tuning values pushed to clients.

• IRemoteConfigStore provider

  Persistence seam for the config set.

Persistent fire-at-time callbacks that survive restarts. Server-only.

• IScheduleHandler game SPI

  The SPI a game implements per KIND: when an entry of your kind comes due, you get its opaque payload.

• IScheduleStore provider

  Persistence seam: pending entries must survive restarts.

• IWallClock provider

  Wall-clock seam (restart-safe time, unlike the uptime-based server clock).

Genre-agnostic gameplay-event pipeline: server-authoritative Track + a rate-capped client wire, batched off-thread to the game's IAnalyticsSink SPI (Segment/Amplitude/BigQuery/…). Ships inert (null sink counts + drops).

• IAnalyticsSink game SPI

  THE routing SPI (server-side): the game implements this to ship batched events to ITS warehouse — Segment, Amplitude, BigQuery, Kafka, a JSONL file, anything.

Report-a-player: rate-capped, recorded, surfaced via an admin decorator.

• IReportClock provider

  Wall-clock seam (unix UTC ms) so rate-cap math is testable.

• IReportStore provider

  Persistence seam for filed reports.

Server = input authority (order/relay/ack/checksum); client RollbackEngine + IDeterministicSim SPI.

• IDeterministicSim game SPI

  The SPI a game implements to run under rollback netcode — the same three-callback shape GGPO pioneered.

Single-elimination brackets: winners reported by server code (never client-trusted); join policy + champion reward are game SPIs.

• ITournamentFormat game SPI

  SPI: the tournament's SCHEDULING RULES — what a valid field size is, how the field is paired into matches, and how a recorded result advances the schedule until a champion is de…

• ITournamentPolicy game SPI

  SPI the GAME implements to gate who may register in a bracket — rating floors, entry fees, faction or level checks, ban lists: all game logic.

• ITournamentRewardGrantor game SPI

  SPI the GAME implements to decide what a champion receives — the returned byte[] is an OPAQUE, game-defined reward blob that rides the TournamentChampion push to participants; t…

• ITournamentStore provider

  Persistence seam for tournament state.

Resolves keys (notification codes etc.) to localized, interpolated strings with locale fallback; strings are game data via ILocalizationCatalog. Client-only, Core-only.

• ILocalizationCatalog unity SPI

  The game's locale tables.

Record broadcasts server-side (archive) + play a .cdrp recording back through the live client dispatch with play/pause/speed/seek.

• IReplayArchive provider

  Durable storage for recordings: upload a blob under a game key, list what exists, fetch it back, delete it.

• IReplayPlayer unity SPI

  Replay playback control: load a .cdrp recording and play it back through the live client dispatch.

Generic rent/return instance pooling on the client. Client-only.

• IObjectPool<T> unity SPI

  A generic rent/return pool for plain C# objects.

• IPoolable unity SPI

  Optional lifecycle hook for components on pooled GameObjects.

Net/sim overlay: RTT, rates, interp delay, prediction error, cull tiers. Client-only.

• IDebugGizmoSource unity SPI

  Game seam for the debug gizmos (C16): supply extra shapes to draw in the Scene view.

FPS/MMO/click-to-move/ARPG/cards control schemes over the intent SPI. Client-only.

• IInputCameraProvider unity SPI

  The camera used to turn pointer positions into world rays.

• IInputPawnLocator unity SPI

  Where the local player's pawn IS — needed by point-targeted schemes (click-to-move, ARPG) to steer toward a world point.

Ref-counted Addressables asset service with load scopes. Client-only.

• IAssetScope unity SPI

  A disposable loading bucket (a zone's content, a screen's content).

Every piece that persists anything rides these. Implement one and every piece's storage follows.

• IBatchDocumentStore provider

  Optional capability: apply several writes as ONE atomic unit — all land or none do.

• IDocumentStore provider

  A generic, provider-agnostic document store — the whole persistence infra.

• IDocumentStoreExport provider

  The backup capability: enumerate EVERYTHING a store holds (documents + indexes + sequences) and set sequence positions on restore.