CultLib/docs/cultnet-transport-parity.md

CultNet Transport Parity Map

CultNet payload parity is not enough. The runtimes can already trade schema-v0 MessagePack documents through the interop lane, and the shared cultnet.transport.rudp.v0 packet/session language now exists across C#, TypeScript, Rust, Python, and Kotlin. The remaining split is service adoption: C# still carries the production LiteNetLib path, and older TCP-framed or WebSocket-like bodies still exist for local services and harnesses.

This document is the working map for promoting transport into CultNet itself so C#, TypeScript, Rust, Python, Kotlin, and future runtimes can speak the same network language. Runtime role boundaries live in runtime-parity-scope.md.

Objective

CultNet owns cross-runtime transport semantics:

• peers discover each other without runtime-specific side channels;
• connection/session lifecycle is described the same way in every runtime;
• reliable ordered delivery is portable and testable across runtimes;
• unreliable and sequenced realtime channels can exist beside reliable state sync without changing payload contracts;
• LiteNetLib becomes one adapter, not the hidden specification.

Current Mechanism

Runtime	Current data transport	Discovery	Transport authority today
C# GameCult.Networking	LiteNetLib UDP NetManager / NetPeer; sends legacy union messages and schema-v0 messages with DeliveryMethod.ReliableOrdered; single-peer RUDP socket transport exists in the library	LiteNetLib connection requests and app-level peer/catalog surfaces	Production LiteNetLib adapter profile plus UDP socket binding for the shared RUDP reliability owner
C# interop peer	Schema-v0 MessagePack over TCP-framed or shared RUDP transport	UDP multicast probe/announce with TCP and RUDP transport profiles	Test harness transport parity
TypeScript cultnet-ts	CultNetPeer over any Node Duplex, TCP-framed transport, or single-peer RUDP socket transport; interop uses TCP	UDP multicast probe/announce in the interop peer	First UDP socket binding for the shared RUDP reliability owner
Rust cultnet-rs	Interop example serves and dials schema-v0 MessagePack over TCP-framed or shared RUDP transport; single-peer RUDP socket transport exists in the library	UDP multicast probe/announce with TCP and RUDP transport profiles	UDP socket binding for the shared RUDP reliability owner
Python cultnet-py	TCP sockets with 4-byte length-prefixed MessagePack frames for local CultMesh/CultNet server and client; single-peer RUDP socket transport exists in the library	Endpoint lists and CultMesh peer/Verse catalogs	UDP socket binding for the shared RUDP reliability owner
Kotlin cultmesh-kotlin	Channel-aware WebSocket transport connection for reliable ordered schema frames; single-peer RUDP socket transport exists in the library; interop CLI serves and dials schema-v0 MessagePack over TCP-framed or shared RUDP transport	CultMesh Verse and peer catalogs, plus endpoint lists carried in schema-v0 catalog messages	WebSocket/TCP adapters plus UDP socket binding for the shared RUDP reliability owner, with build-script and TypeScript harness proof

The live split is therefore: payload language and the native RUDP packet/session language now converge across the targeted runtimes, while production service adoption still varies by runtime and older TCP/LiteNetLib/WebSocket bodies have not all been lowered behind the shared transport port.

Invariants

• cultnet.schema.v0 payloads are transport-neutral. Message schemas must not know whether they rode TCP, LiteNetLib, WebSocket, or CultNet reliable UDP.
• Discovery is its own concern. A discovery packet may advertise transport endpoints and capabilities, but it does not own reliable delivery semantics.
• The first portable realtime channel must provide reliable ordered delivery, because schema catalogs, snapshots, shard logs, auth/session messages, and mutation forwarding already depend on ordered request/response behavior.
• Transport capability negotiation must happen before higher-level CultMesh state claims a peer is usable for realtime work.
• Auth/session primitives bind to a connection, but credential encryption and session token formats remain owned by CultNet security, not by UDP packet framing.
• Backpressure, resend pressure, MTU limits, fragmentation, ping/timeout, and reconnect posture are transport-owned signals. They must not leak upward as ad hoc message-level retry loops.

Intended Ownership

cultnet.transport.v0 owns the transport contract:

• endpoint description: protocol, host, port, path/group when relevant;
• channel descriptions: reliable ordered, reliable unordered, sequenced, and unreliable;
• packet envelope: connection id, sequence/ack state, channel id, fragment id, payload encoding, and payload bytes;
• session lifecycle: connect, accept/reject, disconnect reason, timeout, ping, reconnect state, and feature negotiation;
• flow control: send queue limits, resend window, fragmentation limit, and backpressure reporting.

Adapters own socket mechanics:

• cultnet.transport.tcp_framed.v0: existing 4-byte length-prefixed MessagePack stream, reliable ordered only;
• cultnet.transport.litenetlib.v0: C# adapter preserving current GameCult.Networking behavior while exposing CultNet channel semantics;
• cultnet.transport.websocket.v0: browser/mobile-friendly stream adapter, reliable ordered only;
• cultnet.transport.rudp.v0: native cross-runtime reliable UDP transport, replacing LiteNetLib as the portable realtime specification.

Payload handlers own documents:

• cultnet.login.v0, cultnet.register.v0, cultnet.verify.v0, and cultnet.login_success.v0 are security/session messages;
• cultnet.schema_catalog_*, snapshot, shard catalog, shard log, subscription, and simulation messages remain schema-v0 payloads;
• no payload handler decides packet resend, channel ordering, or fragmentation.

Cut Line

• Do not build a Python-only LiteNetLib clone.
• Do not let the TCP interop harness become the implied production transport.
• Do not hide transport capability in loose endpoint strings.
• Do not add message-level retry compensators for missing reliable UDP.
• Do not put UDP packet mechanics into CultMesh database/session code.
• Do not treat C# LiteNetLib behavior as optional folklore; mine it for the required semantics, then express those semantics in CultNet-owned contracts.

First Portable Contract

The first shippable slice should be a transport profile document that every runtime can advertise through schema catalogs and hello/peer descriptors:

cultnet.transport_profile.v0
  runtimeId
  transports[]
    transportId
    protocol
    endpoint
    wireContracts[]
    channels[]
      channelId
      delivery
      ordering
      maxPayloadBytes
      maxFragmentBytes

This is not the reliable UDP implementation. It is the shared language that lets the runtimes stop guessing what kind of pipe a peer is offering.

Implementation Sequence

1. Add cultnet.transport_profile.v0 as a shared contract in C#, TS, Rust, Python, and Kotlin catalogs.
2. Make every runtime advertise its current transport honestly: tcp_framed, litenetlib, or websocket.
3. Add a cross-runtime transport-profile interop check so parody surfaces fail loudly.
4. Introduce a narrow transport port in each runtime: connect, accept, send(channel, payload), receive, close, stats.
5. Put current TCP/LiteNetLib/WebSocket bodies behind that port.
6. Build cultnet.transport.rudp.v0 once against the shared port and prove it with C#/TS/Rust/Python/Kotlin ping, loss, reordering, fragmentation, reconnect, and schema-message tests.

Current progress:

• Steps 1-3 are live in C#, TypeScript, Rust, Python, and Kotlin.
• C# now has the shared tcp_framed transport profile helper plus a TcpFramedTransportConnection with schema-channel SendAsync, ReceiveAsync, and transfer stats. The C# interop peer advertises and uses that shared port instead of owning raw TCP frame I/O directly. The C# interop peer now also advertises and serves the full schema-v0 flow over interop-rudp, and its dial path can use the shared RUDP transport while keeping TCP-framed as compatibility.
• C# now has a litenetlib transport profile helper, and the production Client/Server expose profiles for the LiteNetLib lane. The profile names both the modern reliable ordered schema channel and the legacy reliable ordered legacy union-message channel, so LiteNetLib is described as an adapter instead of remaining the hidden default. NetPeer send helpers now route through LiteNetLibTransportConnection; Client and Server now keep a per-peer adapter and route their own schema/legacy sends through it as well. Inbound payload classification and transfer stats also belong to that channel-aware adapter before dispatching schema-v0 or legacy messages. The C# database, simulation-observation, Verse-discovery, and peer-exchange service wrappers now enter their built-in handlers through CultNetServerPeer, a transport-aware server peer context. Responses send through that context instead of reaching around the per-peer adapter with direct NetPeer extension sends. The C# schema-client port now also has an RUDP adapter; shard log fetch, shard snapshot fetch, and shard write forwarding select it for rudp:// primary endpoints and keep LiteNetLib for cultnet:// endpoints, so those service clients no longer need custom injection to leave the LiteNetLib lane.
• TypeScript has the first narrow transport connection port: TcpFramedTransportConnection owns length-prefixed frame delivery, exposes frame/close/error events, send(channel, payload), close, and transfer stats, and destroys its owned stream on close. CultNetPeer can still run over either the compatibility Duplex stream path or the transport connection path, while the TypeScript interop peer now accepts and dials TCP peers through TcpFramedTransportConnection so the parity harness exercises the shared port instead of raw socket framing. createTcpFramedCultNetPeer gives application callers the same transport-first path without hand-building the profile and adapter; raw Duplex peer construction is now explicitly the compatibility lane.
• Python now has the same tcp_framed transport profile helper plus a synchronous TcpFramedTransportConnection with send, receive, close, and stats. CultNetRawClient, database subscriptions, and the local CultMesh server connection loop send/read through that port instead of owning frame I/O directly. The Python TCP interop peer now also accepts and dials through that port, so the parity harness no longer keeps a raw framing side-channel for Python's schema lane.
• Rust now has the same tcp_framed transport profile helper plus a TcpFramedTransportConnection with schema-channel send, receive, and transfer stats. The Rust interop peer advertises TCP and RUDP profiles and serves/dials schema-v0 through the shared RUDP path without giving RUDP its own document semantics.
• Kotlin now has a websocket transport profile helper plus CultNetWebSocketTransportConnection, which wraps the older binary WebSocket client behind the same CultNetTransportFrame and stats shape for reliable ordered schema frames. The adapter now also has sendSchemaMessage and receiveSchemaMessage sugar so JVM callers can exchange schema-v0 MessagePack messages without hand-parsing transport frames.
• TypeScript, C#, Rust, Python, and Kotlin now share the first cultnet.transport.rudp.v0 packet codec fixture: the same reliable ordered fragmented data packet encodes to the same bytes in every runtime. This is not the RUDP runtime yet; it is the binary packet language the runtimes must converge on before resend loops, windows, and timeout behavior are allowed to claim parity.
• TypeScript, C#, Rust, Python, and Kotlin now share the first deterministic RUDP reliability state machine: connect/accept handshake, packet-level ack/ack-mask accounting, reliable resend scheduling, duplicate suppression, and reliable ordered channel delivery. It is in-memory and socket-free so the behavior can be tested before any runtime binds it to UDP I/O.
• C#, TypeScript, Rust, Python, and Kotlin now have socket-backed RUDP transport connections that bind a single UDP peer to the shared RUDP session. TypeScript emits the same frame events as the TCP-framed transport and can carry CultNetPeer schema messages over reliable ordered schema frames; C#, Rust, Python, and Kotlin expose the same transport frame/stats shape through synchronous socket polling.
• The TypeScript interop harness now proves bidirectional cross-runtime RUDP socket exchange with C#, Kotlin, Python, and Rust: TypeScript can dial those UDP peers, C#/Kotlin/Python/Rust can dial a TypeScript UDP peer, and all sides exchange reliable ordered schema frames through the shared handshake and packet language.
• The same harness now proves schema-v0 MessagePack messages over RUDP in both directions for C#, Kotlin, Python, and Rust peers against TypeScript. Those tests send cultnet.schema_catalog_request.v0 payloads through reliable ordered schema frames and validate cultnet.hello.v0 responses with advertised RUDP transport profiles where the responding runtime owns them, including the shared reconnectPolicy field.
• The same harness now proves reliable ordered schema delivery survives one dropped data packet in both directions between TypeScript and C#/Kotlin/Python/Rust. The drops happen below the transport connection through a UDP bridge, so the recovery is RUDP resend/ack behavior, not application-level retry.
• The same harness now proves reliable ordered schema delivery survives reordered data packets in both directions between TypeScript and C#/Kotlin/Python/Rust. The bridge delays one packet below the transport, sends the following packet first, and then releases the held packet; delivered frames still surface in sequence.
• C#, TypeScript, Rust, Python, and Kotlin now also guard against control-packet sequence bleed in ordered channels: a received ack/control packet may advance the global acknowledgement window, but it must not block the next ordered schema frame for that channel. Runtime-local RUDP tests prove the data-control-data sequence in each implementation.
• TypeScript, C#, Rust, Python, and Kotlin now share the first RUDP fragmentation implementation: the session can split oversized reliable ordered payloads into fragment packets, reassemble them before delivery, and the socket transport can carry fragmented schema frames when maxFragmentBytes is configured.
• The TypeScript interop harness now proves fragmented reliable ordered schema frames in both request and response direction between TypeScript and C#/Kotlin/Python/Rust one-shot UDP peers.
• TypeScript, C#, Rust, Python, and Kotlin now share a transport-level RUDP disconnect primitive: sessions create and consume disconnect packets with raw reason bytes, socket transports surface the remote reason, and the TypeScript interop harness proves reason propagation from C#/Kotlin/Python/Rust one-shot UDP peers.
• TypeScript, C#, Rust, Python, and Kotlin now share transport-level ping/pong and receive-timeout state: sessions create pings, answer pings with pongs, expose pong payloads, and mark themselves disconnected after a configured silent receive window. The TypeScript interop harness proves ping/pong payload echo against C#/Kotlin/Python/Rust UDP peers; local runtime tests prove timeout state transitions.
• TypeScript, C#, Rust, Python, and Kotlin now share bounded reliable-send backpressure for RUDP sessions. At most 32 reliable packets are admitted to the wire at once; later fragments remain in a session-owned FIFO and acknowledgements promote the next packets. Receivers emit a cumulative ACK for packets inside the 32-sequence ACK horizon and an exact ACK for an older retransmit, so unrelated unreliable traffic cannot strand reliable work. This keeps the send frontier well inside the 4,096-sequence receive history instead of blasting an entire large document and hoping the UDP buffers impersonate flow control. maxPendingReliablePackets bounds both queued and in-flight packets before a reliable frame is accepted. Socket transports expose an explicit reliable flush where the runtime supports one, so callers that require confirmed transport delivery do not substitute a fixed sleep. TCP-framed profiles do not publish the field because they do not own the RUDP pending-reliable queue.
• TypeScript, C#, Rust, Python, and Kotlin now share a portable cultnet.reconnect_policy.v0 document and deterministic exponential delay helper, and RUDP transport profiles advertise that policy under reconnectPolicy. This gives discovery the same policy language for reconnect posture.
• TypeScript, C#, Rust, Python, and Kotlin now share a portable reconnect controller shape over that policy: failed connection attempts produce the same attempt number, delay, next-attempt time, exhaustion signal, and successful-connection reset semantics. This is the orchestration primitive service loops must use; it does not yet claim every production daemon or socket path automatically redials through it.
• The C# LiteNetLib Client reconnect loop now consumes CultNetReconnectController directly instead of owning a private attempt counter and duplicate backoff constants. It still owns LiteNetLib socket mechanics and UI-facing reconnect state; the controller owns retry attempt scheduling.
• C# now has an ICultNetSchemaClient service-client port for schema-v0 request/response bodies. Verse discovery, peer exchange, shard-log fetch, shard-snapshot fetch, and shard write forwarding clients consume the port and choose the native RUDP schema client for rudp:// endpoints while preserving LiteNetLib for cultnet:// endpoints. This moves transport choice below service payload ownership without claiming every daemon uses native RUDP yet.
• C# now also has a poll-driven CultNetRudpReconnectLoop for the native RUDP socket transport. Caller-owned game/service loops report closure, ask ReconnectIfDue(nowMs) inside their own scheduler, and the shared controller owns retry delay/exhaustion state while the caller-owned factory opens the next CultNetRudpSocketTransportConnection.
• C# now has CultNetRudpSocketTransportServer, a multi-peer UDP listener that demultiplexes remote endpoints into separate RUDP sessions and delivers (peer, frame) records to higher service owners. This is the production server substrate cut: UDP/session ownership is no longer limited to the single-peer interop/client helper, but authentication and game-session authority still remain above the transport.
• C# now also has RudpCultNetSchemaServer, a multi-peer schema-v0 service host over that listener. Service code can register OnCultNet<T> handlers and reply through peer.SendCultNet(...) without owning UDP demux or RUDP session state. Database, Verse discovery, peer exchange, and simulation bridges still need to adopt the shared schema-server peer port before the old LiteNetLib Server bridge can be demoted.
• C# GameCult.Mesh now mirrors the branded RUDP facade shape used by TypeScript, Python, Kotlin, and Rust: it parses rudp://host:port endpoints, creates RUDP client/server transports from endpoint or peer-card contact hints, and can create a RUDP client from the first peer authorized by the authority lease catalog for a Verse role. The facade can also return a connected RUDP client from a direct endpoint, peer card, or authorized peer lookup, so schema-message helpers can ride the RUDP pipe without caller-side handshake ceremony. RUDP packet/session behavior remains owned by GameCult.Networking.
• TypeScript now has a CultNetRudpReconnectLoop that consumes the shared controller while keeping socket construction caller-owned. A closed RUDP transport schedules the next attempt with the portable policy, opens a fresh caller-provided transport when the controller says it may retry, and resets attempt state when the caller marks the connection established.
• Python now has the same CultNetRudpReconnectLoop shape for synchronous callers: the caller-owned receive loop reports closure, the shared controller owns retry delay/exhaustion state, and the caller-provided factory opens the next CultNetRudpSocketTransportConnection.
• Python raw CultNet clients now consume a caller-provided CultNetSchemaTransport factory for request/response and database subscription flows. The default factory opens the existing TCP-framed schema transport, but the raw client no longer owns inline socket setup as its request truth. Python now also exposes create_rudp_schema_transport(...), which handshakes a socket-backed RUDP client and gives CultNetRawClient the same reliable ordered schema request path over cultnet.transport.rudp.v0; CultMesh.create_client(endpoint="rudp://...") is the branded ergonomic helper for that path.
• Python's branded CultMesh facade now creates schema catalogs, built-in schema catalogs, and shard catalogs by delegating to the existing cultnet_py owners, matching the TypeScript/Kotlin/Rust entrypoint pattern without creating a second catalog authority. The facade now also parses rudp://host:port endpoints and creates RUDP client/server transports from endpoint or peer-card contact hints while leaving packet/session semantics in cultnet_py. Python peer catalogs also expose authorized-peer lookup, and the branded facade can create a RUDP client from the first peer authorized by the authority lease catalog for a Verse role. CultMeshLocalServer now also starts a RUDP listener beside the TCP-framed listener by default and advertises both transport profiles in cultnet.hello.v0; the RUDP listener keeps schema request handling in the same server authority while demultiplexing per-remote CultNetRudpSession state. The Python interop peer now also serves and dials schema-v0 over interop-rudp, advertises TCP-framed and RUDP in discovery and hello, and caps interop RUDP schema frames into 1024-byte fragments so catalog responses stay inside UDP datagram limits while remaining session-owned.
• Rust now has a poll-driven CultNetRudpReconnectLoop for substrate callers: service loops report closure, ask reconnect_if_due(now_ms) inside their own reactor, and the shared controller owns retry delay/exhaustion state while the caller-owned factory opens the next socket transport.
• Kotlin now has the same RUDP reconnect-loop shape for JVM/Android callers: the app-owned receive loop reports closure, CultNetRudpReconnectLoop schedules retry through CultNetReconnectController, and the caller-provided factory opens the next CultNetRudpSocketTransportConnection.
• Kotlin now mirrors the C#/TypeScript/Python local authority lease gate: peer cards may advertise authorityLeaseId, but CultMeshAuthorityLeaseCatalog owns role/shard/time authorization so discovery contact cannot impersonate trust.
• TypeScript CultMesh local catalogs now expose the same practical discovery ergonomics as the other runtimes: sorted local views, direct get(...) lookup, unsubscribe-able watch(...) callbacks for Verse and peer catalogs, watch callbacks for authority leases and stream declarations/frame cursors, plus lease listing and lookup beside the authority check. The branded CultMesh facade also creates schema catalogs, built-in schema catalogs, and shard catalogs by delegating to the existing cultnet-ts owners, so callers do not have to leave the CultMesh entrypoint for schema discovery or shard topology. The facade now also parses rudp://host:port endpoints and creates RUDP client/server transports from endpoint or peer-card contact hints while leaving packet/session semantics in cultnet-ts. TypeScript now also mirrors Kotlin's authorized-peer lookup and RUDP client helper, so peer cards remain contact hints until the authority lease catalog authorizes the requested Verse role. The facade can now also create a connected CultNetPeer from a direct RUDP endpoint, peer card, or authorized peer lookup, so schema and shard catalog request helpers ride the RUDP transport without callers hand-wrapping the socket transport. The TypeScript interop peer now also serves and dials the schema-v0 interop flow over interop-rudp while keeping TCP-framed as the compatibility lane; discovery and hello responses advertise both profiles.
• Kotlin now has the same full interop RUDP proof shape as the other targeted runtimes: the JVM CLI can serve schema-v0 hello/catalog/snapshot/mutation/fire over interop-rudp, and it can dial a TypeScript full peer over the same shared RUDP connection id and reliable ordered schema channel. TCP-framed remains a compatibility lane for the interop peer; WebSocket remains the JVM/Android-friendly client transport surface.
• TypeScript now also has a CultNetSchemaCatalog for remote schema descriptors plus CultNetPeer request/fetch/sync helpers for cultnet.schema_catalog_request.v0 / cultnet.schema_catalog_response.v0. CultNetSchemaRegistry remains the local definition owner; the catalog owns imported descriptors so callers do not treat raw response objects as state.
• TypeScript now has the matching CultNetShardCatalog and peer request/fetch/sync helpers for cultnet.shard_catalog_request.v0 / cultnet.shard_catalog_response.v0. Shard descriptors can be filtered by schema id and record key without requiring callers to inspect raw response maps. The built-in schema registry also advertises the shard catalog request/response wire-message schemas, so discovery matches the helper surface.
• Kotlin now mirrors the CultMesh stream catalog shape for Android-adjacent media, sensor, tensor, and byte streams: stream declaration, clock metadata, preferred body transports, consumer negotiation, copy-budget classification, max in-flight frame pressure, latest-frame cursors, and watch callbacks for stream declarations plus latest-frame publication.
• Kotlin now has a branded CultMesh facade matching the C#/TypeScript/Python entrypoint pattern for local nodes, schema catalogs, shard catalogs, Verse catalogs, peer catalogs, authority lease catalogs, stream catalogs, and RUDP client/server construction. Kotlin also parses advertised rudp://host:port endpoints and can build a RUDP client directly from a peer card contact hint or the first peer authorized by the authority lease catalog. The facade can now also return a connected RUDP client from a direct endpoint, peer card, or authorized peer lookup, so schema-message transport helpers can use RUDP without caller-side handshake ceremony. The facade delegates to the same owners as the top-level helpers instead of creating a second authority path.
• Kotlin WebSocket and RUDP transports now expose catalog fetch/sync helpers for schema and shard catalogs. The helpers send standard schema-v0 requests, require the matching response schema, and apply through the caller's catalog, giving JVM/Android callers the same client ergonomics Python already had without making the transport own catalog truth. Both adapters implement the shared CultNetSchemaMessageTransport shape so the helper logic has one owner across Kotlin stream and RUDP paths.
• Kotlin now also has a built-in schema catalog factory on the branded CultMesh surface. It advertises the Kotlin-supported CultNet/CultMesh request and response message descriptors, including schema catalog, shard catalog, shard log, Verse catalog, peer exchange, and the shared transport profile contract. The branded factory accepts the same schema-id, kind, and inline-schema filters as the catalog request path, while still returning ordinary CultNetSchemaCatalog state. Descriptors for contracts already present in the canonical schema set use those schema ids and content hashes; Kotlin-local descriptor bodies use schema-version ids until shared schema files exist. Transports do not own catalog truth.
• Kotlin authority lease catalogs now also expose watch callbacks, so JVM and Android clients can react to lease changes without treating peer-card contact hints as trust. Kotlin peer catalogs also expose authorized-peer lookup helpers, and the branded CultMesh facade can create a RUDP client from the first peer authorized for a Verse role while still delegating the trust check to the authority lease catalog.
• Rust now has a small CultMesh facade for its substrate role: peer cards, sorted peer catalogs, authority lease catalogs, schema registry factories, shard catalog factories, rudp://host:port endpoint parsing, and RUDP client/server construction from endpoint, peer-card contact hints, or the first peer authorized by the authority lease catalog for a Verse role. The facade delegates to the existing Rust schema registry, shard catalog, and RUDP socket transport owners; discovery contact remains separate from trust, which is still gated by the authority lease catalog. The facade can now also return a connected RUDP client from a direct endpoint, peer card, or authorized peer lookup. Rust RUDP transports now also send and receive typed cultnet.schema.v0 messages on the reliable ordered schema channel, so callers do not have to hand-encode MessagePack payloads or hand-roll the client handshake before using the shared RUDP pipe.
• Rust now also has substrate-shaped shard catalog helpers: CultNetShardDescriptor, CultNetShardCatalog, request filtering by schema id and record key, response creation, response application, and built-in schema registry entries for cultnet.shard_catalog_request.v0 / cultnet.shard_catalog_response.v0. This gives Rust the same topology vocabulary without claiming stream catalog or production game-session server ownership.
• The remaining adoption work beyond the current role-scoped parity claim is to finish production service-body migration behind the shared transport ports, then wire any remaining daemon/socket reconnect loops through the shared controller. C# built-in LiteNetLib service wrappers now register transport-aware CultNetServerPeer listeners instead of requiring each bridge to bounce through NetPeer, TypeScript exposes a transport-first TCP peer helper, C# schema-v0 service clients consume ICultNetSchemaClient, and the core schema-message RUDP matrix is live in the TypeScript interop gate; broader service adoption remains the unclaimed layer.

RUDP Packet Contract V0

cultnet.transport.rudp.v0 packets start with a fixed binary header, followed by a UTF-8 channel id and payload bytes. All integer fields are unsigned big-endian. The first deterministic fixture is live in TypeScript, C#, Rust, Python, and Kotlin; every future runtime must port it byte-for-byte before runtime-specific resend loops are allowed to claim parity.

Offset	Size	Field	Notes
0	4	magic	ASCII CNR0
4	1	version	0
5	1	packet type	1=connect, 2=accept, 3=data, 4=ack, 5=ping, 6=pong, 7=disconnect
6	1	flags	bit 0 reliable, bit 1 ordered, bit 2 sequenced, bit 3 fragmented
7	1	header bytes	fixed header plus channel id bytes
8	4	connection id	peer/session binding token
12	4	sequence	packet sequence number
16	4	ack	latest received sequence being acknowledged
20	4	ack mask	selective acknowledgement mask for prior packets
24	2	fragment id	0 when not fragmented
26	2	fragment index	zero-based fragment index
28	2	fragment count	total fragments, 0 when not fragmented
30	4	payload bytes	payload length
34	1	channel id bytes	UTF-8 byte count, max 255
35	1	reserved	0
36	n	channel id	UTF-8 channel id
36+n	m	payload	transport-neutral payload bytes

Canonical reliable ordered data fixture:

packetType=data
connectionId=0x01020304
sequence=0x0000002a
ack=0x00000029
ackMask=0x80000001
channelId=schema
flags=reliable|ordered|fragmented
fragmentId=7
fragmentIndex=1
fragmentCount=3
payload=hello
hex=434e523000030b2a010203040000002a0000002980000001000700010003000000050600736368656d6168656c6c6f

Reliable UDP Semantics To Lift From LiteNetLib

The portable RUDP contract must cover at least:

• connection handshake with application connection key support;
• peer id/session id binding;
• ping and timeout detection;
• reliable ordered channel delivery;
• unreliable channel delivery for realtime observations/input;
• sequenced delivery for latest-state streams;
• duplicate suppression;
• ack masks or equivalent selective acknowledgement;
• resend windows and retransmission timers;
• MTU-safe fragmentation and reassembly;
• disconnect reason propagation;
• bounded send queues and observable backpressure;
• deterministic wire fixtures for packet encode/decode in every runtime.

Until those are runtime-owned CultNet contracts, the runtimes do not truly "speak the same language"; they are only translating documents after somebody else already solved the pipe.