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.

• IActingEntityResolver game SPI

  Answers "which entity is this session acting AS" — the one question every piece that resolves an actor has to ask, at the one layer every piece is allowed to ask it.

• 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).

• IFrameCipher provider

  Authenticated encryption for ONE framed message, independent of which transport carries it.

• 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.

• IMessageTrafficStats provider

  Per-message-id byte and frame accounting: the breakdown behind the aggregate BytesReceived, so a bandwidth claim can name the id it changed.

• 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.

• IRequiredVersionProvider game SPI

  Supplies the client version the server requires RIGHT NOW, read once per login/register attempt — so the gate can be moved without redeploying a node, and so a rejected client c…

• 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.

• IServerActivation game SPI

  Whether this process is doing the job it was started for yet, or merely STANDING BY waiting to be given one.

• 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.

• IStandbyTickable game SPI

  An IServerTickable that must keep ticking while the process is in fleet STANDBY — i.e. work that is about staying alive rather than about running a game.

• ITransportSignal provider

  Optional low-latency extension of IServerTransport.

• IAuthProvider unity SPI

  SPI: a source of platform login tickets.

• IClientMessageTraffic unity SPI

  Per-message-id wire counters for the client connection — the breakdown behind IConnectionStats, so "which message is the bandwidth" has an answer on this tier too.

• 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).

• IRawMessageDispatcher unity SPI

  An OPTIONAL extra on a dispatcher: deliver a message's raw payload — the frame's bytes after the id header — instead of a decoded instance.

• IServerClockDiagnostics unity SPI

  Read-only visibility into how the clock estimate is moving (GAP-16).

• 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, pathfinding (A*), and spatial enter/exit/dwell trigger volumes.

• 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…

• IBoundsVolume game SPI

  A 3D playable/collision volume — the volumetric sibling of the 2D IBoundsArea, evaluated with the SAME code on both tiers (this assembly ships to the server and, as the embedded…

• IBroadcastCullingPolicy game SPI

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

• IEntityBounds game SPI

  Optional SPI: a PER-ENTITY playable area, tighter than the zone's.

• IEntityRegionAnchor game SPI

  Optional companion to IEntityBounds: where INSIDE its own region an entity belongs.

• IEntityTerritory game SPI

  Optional companion to IEntityBounds: what an entity DEFENDS, as opposed to where it may move.

• 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).

• ITriggerListener game SPI

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

• 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…

• IWorldGeometry game SPI

  SPI the game implements to give a zone its 3D collision volumes — the volumetric sibling of IWorldBounds ("drop a map, it has walls, floors and kill zones").

• IWorldGeometryProvider provider

  The swappable back-end that actually answers 3D geometry queries for a zone — the seam (RULE 13) that lets the fidelity scale without changing callers.

• IWorldSurfaceMap game SPI

  SPI the game implements (or the baked default answers) to give zones a per-cell SURFACE plane — the bounds grid-mask's opaque sibling.

• IZoneAdmissionPolicy game SPI

  The game's "may THIS session enter THAT zone" rule — per-party instances, personal housing, solo trials, who may spectate which match.

• IZoneDirectory provider

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

• IZoneSpawnSlots game SPI

  The claim book over ZoneSpawnSlots: hands each entrant its OWN authored placement out of a zone's ordered slot list, and takes it back when that entrant leaves.

• IClientEntityBounds unity SPI

  SPI the game implements to give the CLIENT the same PER-ENTITY areas it registered on the server (IEntityBounds) — the client mirror of IClientWorldBounds, which mirrors the zon…

• 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…

• IClientWorldGeometry unity SPI

  SPI the game implements to give the CLIENT the same 3D collision volumes it registered on the server (IWorldGeometry) — the volumetric sibling of IClientWorldBounds.

• 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.

• IControlResolver game SPI

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

• ILocomotionResolver game SPI

  Locomotion seam: which state id is THIS entity in right now?

• 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?

• IMovementDiagnostics unity SPI

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

Client-side distance tiers over entity views: full detail near, animator pose-write culling in the mid ring, deactivation beyond. Whatever the game spawns gets culled and the layer never knows what the objects are. No server half and no wire — usable on its own, including by a client that only moves a camera.

• 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.

One entity rides another: a rider's pose is derived from its carrier at a fixed offset in the carrier's own frame. Passengers in a vehicle, a patient on a stretcher, cargo in a hold, a player on a moving platform, a turret on a tank — the framework never knows which. The wire carries ONE reliable message per ride (replayed on interest reveal), not a pose per tick: a rider costs nothing while it rides and cannot drift against the thing carrying it. Server-decided and therefore unforgeable — there is no client verb.

• IAttachmentsClient unity SPI

  The Attachments piece, client side: an entity told to ride another has its view driven from the carrier's, every frame, at the offset the server sent.

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.

• IPhysicsBodyFactory game SPI

  OPTIONAL creation sibling of IPhysicsBackend: an engine that can build a body from an engine-neutral PhysicsShape.

• IPhysicsBodyPlacement game SPI

  OPTIONAL placement sibling of IPhysicsBodyFactory: putting an EXISTING body back somewhere, stopped.

• IPhysicsBodyProfiles game SPI

  Decides WHICH physical profile a given entity is — the game's answer to "what kind of thing is this".

• IPhysicsBodySleep game SPI

  PHYS-28 — putting a settled body's constraint island to sleep, and asking whether it already is.

• IPhysicsForces game SPI

  OPTIONAL force sibling of IPhysicsBodyFactory: an engine that can be told to PUSH something.

• IPhysicsImpactSink game SPI

  Where collisions go — the PUSH counterpart to IPhysicsBackend's pull surface, and the difference between physics that is scenery and physics that is gameplay.

• IPhysicsJointBreakSink game SPI

  Where breaks go.

• IPhysicsJointRelease game SPI

  OPTIONAL release sibling of IPhysicsJoints: let go of everything holding ONE body.

• IPhysicsJointStrength game SPI

  OPTIONAL strength sibling of IPhysicsJoints: changing what an EXISTING joint can carry.

• IPhysicsJoints game SPI

  OPTIONAL joint sibling of IPhysicsBodyFactory: an engine that can hold two bodies together, and let go when pulled hard enough.

• IPhysicsLevelGeometry game SPI

  Gives a physics backend the LEVEL — the static collision a zone is actually made of.

• IPhysicsQueryBackend game SPI

  OPTIONAL query sibling of IPhysicsBackend: a physics engine that can also answer spatial queries (raycast / swept sphere) against its world.

• IPhysicsShapeLibrary game SPI

  Where a server gets the shapes a game authored — the last link in "a model in Unity becomes a collision volume on the server".

• IRigidBodyInputSink game SPI

  Where a validated input frame goes — the game's half of client-predicted rigid bodies.

• IStructureCatalog game SPI

  PHYS-21 — the live connection graph of a built structure, and what it implies.

• IStructureDetach game SPI

  PHYS-29 — taking a piece OFF a kinematically-held structure: the donor engine's FracturedChunk.DetachFromObject().

• IStructureGraph game SPI

  PHYS-29 — walking and CUTTING the structure graph, for the kinematically-held mode.

• IStructureIntegrity game SPI
• IStructureLibrary game SPI

  Where a server gets the STRUCTURES a game authored — the last link in "an artist's wall becomes a building the server holds up and can knock down".

• IStructures game SPI

  PHYS-20 — every structure currently standing, and what is left of each.

• INeighbourAwareRigidBodyIntegrator unity SPI

  An integrator that can also see the bodies near the one it is stepping (GAP-28) — so a predicted body stops being alone in the universe.

• IRigidBodyBatchView unity SPI

  LB-GAP-16 — the presentation seam for MANY rigid bodies at once: every tracked body's render pose, handed over in one call per frame instead of one call per body.

• IRigidBodyCollisionShapes unity SPI

  What a networked body is SHAPED like, for the client's own collision — PHYS-14's one game-facing seam.

• 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.

Generic client-authoritative avatar relay (Route B): the owning client simulates its avatar with its OWN controller and reports a full-3D pose (Vec3 + smallest-three quaternion + quantized velocity) plus an opaque game-state blob; the server validates (rate + gross-delta + optional IAvatarMoveValidator) and relays to observers with interpolation. Any bespoke-controller game (platformer/racer/ragdoll) gets multiplayer with near-zero netcode — it implements only IAvatarStateSource + IAvatarStateApplier and never defines a message or an id.

• IAvatarMoveValidator game SPI

  Optional game seam for DEEP validation of a client-authoritative avatar report.

• IMotorRelayAuthority game SPI

  Optional game seam that decides which client may drive which server-spawned entity.

• IMotorSimulation game SPI

  The ENTIRE per-game surface for server-authoritative motion: a pure, deterministic step the framework runs on BOTH tiers (server = authority, client = prediction).

• IAvatarStateApplier unity SPI

  OBSERVER-side game seam — the entire per-game surface for rendering a remote avatar.

• IAvatarStateSource unity SPI

  OWNER-side game seam — the entire per-game surface for reporting the local avatar.

• IMotorClient unity SPI

  Public facade / diagnostics seam for the Motor client loop.

• IMotorDiagnostics unity SPI

  What the Motor client can tell you about remote playback quality, so "is the jitter fixed?" is a number rather than an impression.

• IMotorInputSource unity SPI

  OWNER-side game seam for ServerAuth mode — the game's INPUT (not a pose).

• IMotorPlacementHandler unity SPI

  The game's hook for "you are now here" — PHYS-10's client half.

• IRelayedAvatarStateSource unity SPI

  HOST-side game seam — report poses for entities this client does not own.

Authored static level objects with server-authoritative state — pickups, crates, chests, levers, doors, checkpoints, moving platforms, goals. A designer places them as CONTENT (the piece defines its own content types, so the editors show a ready-made form) and the piece owns spawning, stable ids, the 3D reach test, the state blob and its replay on interest reveal. Five built-in rules cover the recurring shapes — claim-once, durability, counter, flag, clock-epoch — with an ILevelObjectRule SPI for anything novel; which verb acts on which kind is authored, not coded. Zero new wire: spawns ride World, state rides EntityState, verbs ride Interactions.

• ILevelObjectHarmPolicy provider

  Optional gate + feedback for the one archetype that is genuinely COMBAT: Durability.

• ILevelObjectResetPolicy game SPI

  WHO may reset a zone's authored objects over the wire (GAP-35's LevelObjectResetRequest) — the game's rule, because the framework cannot know what a "run", a "match" or a "lobby…

• ILevelObjectRule game SPI

  SPI for an object rule the five built-in archetypes cannot express — the escape hatch, not the normal path.

• ILevelObjectTable provider

  Where the authored level-object table comes from.

• ILevelObjectBinder unity SPI

  The game seam for authored level objects — where presentation begins and this piece ends.

3D collision/query fidelity: baked triangle-mesh geometry (slopes/loops/ledges) answering raycast / sphere+capsule sweep / ground-probe via World's IWorldQueries3D, alongside the analytic volumes. Ships as content (.mesh3d, CBK envelope) — zero wire. The client package carries the mesh->.mesh3d editor BAKER, the shared collision math, and a RUNTIME mirror (IClientMeshGeometry) that preloads the same bakes by Addressables label so prediction asks the identical triangles authority does — which is what lets a client predict a vehicle's height and slope per frame instead of receiving them at the ack rate.

• IWorldMeshGeometry game SPI

  SPI the game (or the file loader) implements to give a zone its baked collision TriangleMesh — the mesh analogue of IWorldGeometry/IWorldBounds.

Deterministic segment bodies: a body travels in straight legs and deflects off game-supplied surfaces by a configured rule set (hit-offset steer, capped surface-motion transfer, speed gain with a floor and a ceiling). The wire carries one leg per CONTACT, not a pose per tick, and both tiers evaluate the same line against the shared clock — so there is no interpolation delay and nothing to smooth at a bounce. For pong and its family, air hockey, breakout, arcade football.

• IKinematicSurfaces game SPI

  The game's answer to "what can this body bounce off right now?" — the piece's one required SPI.

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).

Dropped-item entities: opaque payload, atomic first-claim, timed expiry. Server-only.

• ILootClaimPolicy game SPI

  SPI the game implements to gate claims — consulted BEFORE the atomic take in both the manual claimer-aware TryClaim path and the AutoClaimRadius auto-claim pass.

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.

• IAgentFixedKindAttackFactory game SPI

  The narrower sibling of IAgentAttackHandler: what a brain template that PINS one attack kind (AttackProjectileKind) attacks WITH.

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?

Generic entity-vs-entity contact: circle / yaw-oriented-box footprints, layer bits + mask, weight-split push-out. Hard corrections ride the swept movement pipeline (never through walls); predicted avatars push via the ISoftContactResolver seam. Zero wire — positions ride the existing movement broadcast. Server-only.

• IContactDisplacementResolver game SPI

  Where a swept REWIND goes — the seam GAP-19 needs for an entity whose position is owned by a simulation rather than by the world.

• IContactImpulseResolver game SPI

  Where an IMPULSE goes — the seam for Impulse, and the counterpart to ISoftContactResolver's positional push.

• IContactPairFilter game SPI

  Optional seam: a veto on which entity PAIRS the piece checks at all — asked once per candidate pair per tick, after the layer/mask filter and before any geometry.

• ISoftContactResolver game SPI

  The Soft-correction seam this piece OWNS: how a contact push reaches an entity the server must NOT silently reposition — an input-driven predicted avatar, where a server-side po…

Server-authoritative heading+speed vehicle motion (cars/karts/boats/hover/tanks): sampled steer/drive/drift axes in through one validated path (wire AND AI), substepped shared-integrator sim over baked per-class LUT tables, swept through the world bounds every substep (no wall tunneling), full-state owner ack for client prediction. Wall + vehicle-vs-vehicle contact events (car-vs-car via the config-gated Contact bridge); per-entity multiplier SPI (nitro / upgrades). Drivable from CONFIG ALONE: AutoRegister says which entities entering which zone become vehicles of which class, and SurfaceHandling maps the world's baked per-cell surface ids to handling multipliers (surface 0 and unmapped ids stay neutral) — no server code required for either. Motion rides the Movement broadcast; requires the Movement piece composed. The client package predicts the local vehicle through the same shared integrator and reconciles on the owner ack.

• IVehicleDriver game SPI

  Server-side DRIVER seam — the other half of SetInput, which until now had exactly one caller (the client wire handler).

• IVehicleParamsProvider game SPI

  Per-entity handling overlay seam — the vehicle twin of Movement's IMovementSpeedProvider: each substep the integrator asks it for THIS vehicle's multiplier set (VehicleParams: m…

• IVehicleClassTableProvider unity SPI

  SPI the game implements to give the CLIENT the same per-class integrator tuning the server's Crossplay:Vehicles:Classes:{id} config carries — the vehicles twin of IClientWorldBo…

• IVehicleClientParamsProvider unity SPI

  SPI the game implements to mirror the server's per-entity IVehicleParamsProvider overlay (surface grip, nitro, upgrade tiers) for the LOCAL vehicle, so prediction applies the sa…

• IVehicleGameplayInput unity SPI

  SPI the game implements to feed vehicle intent from any input source (new Input System, AI, replay, a rhythm chart, …) — the vehicle twin of the movement piece's IGameplayInput.

• IVehiclesClient unity SPI

  The vehicles piece's client surface: the game tells it when the local player starts/stops driving (the server registered its entity as a vehicle through the game's own flow — an…

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.

• IProjectileTargetResolver game SPI

  Acquisition seam for seeking kinds (Homing): which entity should this projectile steer toward, and is the one it already holds still worth steering toward?

• 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?

Two halves of "what am I aiming at". (1) 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. (2) The SELECTED target (TargetSelection:Enabled): SetTargetRequest in, TargetChanged out, validated against the actor's interest set + an ITargetPolicy SPI, readable server-side through ITargetService — tab-target MMOs, RTS selection, a sports pass target, a card game's targeting step. DriveAutoAttack makes your swings land on what you clicked; RevealTargets drives target-of-target frames (off by default — who you selected is information).

• 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?

• ITargetPolicy game SPI

  Selection seam: may this actor SELECT this candidate?

• ITargetSelector game SPI

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

Consensual 1v1: challenge -> accept -> fight -> the winner is decided by a SERVER-reported defeat, a forfeit, or the time limit. There was no challenge/accept flow anywhere (matches is match containers, tournaments is brackets, and hostility models consent as a standing STANCE rather than "this person, now, then we stop"). The piece is CORE-ONLY: mutual harm, ending a duel just before the loser would die, and restoring the health they spent are the composition's job (Crossplay:DuelCombat over Hostility + Stats), so it also composes into a game with neither. IDuelPolicy = eligibility + stakes.

• IDuelPolicy game SPI

  Whether a duel may happen — the game's eligibility and stakes (GAP-14).

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.

A player's OWN shop, standing where they left it: open a stall that escrows stock out of your bag, and anyone the game's IStallPolicy says can reach it browses and buys — the seller does nothing, and may be afk or offline. Nothing else covered it (shop is system-owned, market is asynchronous listings, trade needs both parties present and consenting). Presentation-agnostic: a market stall, a vending machine you place, a shop sign over an avatar, or a text for-sale list are the same data. Currency = IStallWallet, proximity/zone rules = IStallPolicy, so it names nothing spatial and no Economy type.

• IStallPolicy game SPI

  WHERE a stall may open, and who may see one — the game's rules (GAP-13).

• IStallWallet provider

  Currency seam.

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.

• IGuildVaultItemSource provider

  Where a WIRE deposit's items come from — the seam that makes the SERVER, not the client, decide what is being deposited.

• 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.

Containers owned by a group rather than a character — a crew kit, a party stash, a team's shared crate — over the Container engine: the contents are pushed to every session the game's audience seam admits, and only those sessions may read or rearrange them. Items enter and leave through server-side game verbs (atomic exchanges with a member's bag); the wire carries request and move only, so a client is never trusted to say what it takes. Inert until an audience is composed.

• ISharedContainerAudience game SPI

  The game's answer to "who sees this container?" — the one decision that makes a container SHARED.

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.

• IChatAudienceResolver game SPI

  Resolves WHO hears a channel whose audience is not a subscriber list (GAP-15).

• 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.

• IPartyMemberLocator game SPI

  The member-location seam the Party piece OWNS — how the roster's Zone/Endpoint fields fill without Party (a Core-only feature piece) ever referencing the World piece.

• 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…

• IPartyStatePolicy game SPI

  Who may write the party's shared opaque state blob (PartySetStateRequest).

• 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).

• ILeaderboardSubmitPolicy game SPI

  Wire-submit gate (game SPI): decides whether a SESSION may submit a score to a (board, season) over the wire (LeaderboardSubmitRequest).

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.

• ITournamentEventFormat game SPI

  SPI: the EVENT-based side of the format family — scheduling rules for tournaments whose unit of play is an N-entrant scored EVENT (a race, a heat, a battle-royale round) rather…

• 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…

• ITournamentScoring game SPI

  SPI the GAME implements to decide what a finishing position in an N-entrant EVENT is worth — the scoring half of the event-based format family (ITournamentEventFormat): standing…

• 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.

The always-present shared client SPIs a game binds to, independent of any feature piece: IGameplayInput + MovementIntent (feed input intent), IAnimatorParameterMapper (map locomotion onto your animator), and IAssetService + IAssetScope (load assets by key). Feature pieces (movement, input, assets, audio) implement or consume these contracts, so a game can bind any SPI without installing the feature that used to define it. A must for Core — auto-installed, cannot be unselected. Client-only, no wire.

• IAnimatorParameterMapper unity SPI

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

• IAssetScope unity SPI

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

• IAssetService unity SPI

  The asset-loading SPI every Crossplay client system loads content through: ref-counted load/release by key, label preloads, tracked instantiation, and CreateScope for lifetime-b…

• IGameplayInput unity SPI

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

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

• IInputAxisProvider unity SPI

  Which WORLD direction a rightward drag moves the pawn along — the one thing a drag scheme cannot know for itself.

• 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.

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.

• ISteamSockets provider

  The seam between SteamServerTransport and Steam itself.

• IRendezvousClient provider

  How this server is introduced to peers that have no address to dial.