@dcl/protocol 1.0.0-27226386025.commit-c056d32 → 1.0.0-27358757907.commit-3c70e8a

package/README.md

@@ -67,3 +67,201 @@ In this case, there is no problem with when each PR is merged. It's recommendabl
 ## Comms
 
 TODO
+
+---
+
+# Bitwise Serialization Plugin (`protoc-gen-bitwise`)
+
+A custom protoc plugin that generates C# partial classes with typed float
+accessors for quantized `uint32` fields in high-frequency MMO networking
+messages (position deltas, player input, etc.).  It runs alongside
+`--csharp_out` in the same protoc invocation; the two output files coexist
+via C# `partial class`.
+
+## How it works
+
+Protobuf encodes `uint32` values as varints, which are already compact for
+small values: a value up to 2¹⁴−1 costs 2 bytes, up to 2²¹−1 costs 3 bytes.
+Rather than a separate binary packing layer, the plugin leverages this:
+
+1. Declare quantized fields as `uint32` in the `.proto` schema and annotate
+   them with `[(decentraland.common.quantized)]` to specify the float range
+   and bit resolution.
+2. `--csharp_out` generates the standard protobuf class with the raw `uint32`
+   property (e.g. `PositionX`).
+3. `--bitwise_out` (this plugin) generates a `partial class` extension with a
+   cached float accessor (e.g. `PositionXQuantized`) that encodes/decodes
+   transparently via `Quantize.Encode` / `Quantize.Decode`.
+
+The wire representation is a standard protobuf message — any protobuf-capable
+client can read it without knowledge of the plugin.
+
+## Prerequisites
+
+| Requirement | Version |
+|---|---|
+| Python | 3.10+ |
+| `protobuf` Python package | 4.x or 3.20+ |
+| `protoc` | 3.19+ |
+
+```bash
+pip install protobuf
+```
+
+## Step 1 — Annotate your `.proto` file
+
+Declare quantized fields as `uint32` and import `options.proto`:
+
+```protobuf
+syntax = "proto3";
+
+import "decentraland/common/options.proto";
+
+package decentraland.kernel.comms.v3;
+
+message PositionDelta {
+  // Float range [-100, 100] quantized to 16 bits ≈ 0.003-unit precision.
+  // Stored as uint32 on the wire; protobuf encodes it as a 3-byte varint.
+  uint32 dx        = 1 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 dy        = 2 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 dz        = 3 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+
+  // Unannotated uint32: protobuf varint encodes small values compactly by default.
+  uint32 entity_id = 4 [(decentraland.common.bit_packed) = { bits: 20 }];
+}
+```
+
+### Annotation reference
+
+| Annotation | Target type | Parameters | Effect |
+|---|---|---|---|
+| `[(decentraland.common.quantized)]` | `uint32` | `min`, `max`, `bits` | Plugin emits a cached `float {Name}Quantized` accessor |
+| `[(decentraland.common.bit_packed)]` | `uint32` | `bits` | Documents the value range; protobuf handles varint compaction automatically |
+
+### Wire cost at worst-case (all bits set)
+
+| Quantization bits | Max value | Varint bytes | Tag (field ≤ 15) | Total per field |
+|---|---|---|---|---|
+| 8 | 255 | 2 | 1 | 3 B |
+| 12 | 4 095 | 2 | 1 | 3 B |
+| 14 | 16 383 | 2 | 1 | 3 B |
+| 16 | 65 535 | 3 | 1 | 4 B |
+| 20 | 1 048 575 | 3 | 1 | 4 B |
+
+Proto3 omits fields equal to their default value (0), so average cost is lower.
+
+## Step 2 — Run protoc
+
+```bash
+protoc \
+  --proto_path=proto \
+  --proto_path=/path/to/google/protobuf/include \
+  --csharp_out=generated/cs \
+  --plugin=protoc-gen-bitwise=protoc-gen-bitwise/plugin.py \
+  --bitwise_out=generated/cs \
+  proto/decentraland/kernel/comms/v3/comms.proto
+```
+
+The plugin emits one `*.Bitwise.cs` file (PascalCase, flat in the output
+directory) for each `.proto` file that contains at least one `[(quantized)]`
+field.
+
+## Step 3 — Copy the runtime
+
+Copy `Quantize.cs` into your project:
+
+```
+Assets/
+└── Scripts/
+    └── Networking/
+        └── Bitwise/
+            └── Quantize.cs   ← protoc-gen-bitwise/runtime/cs/Quantize.cs
+```
+
+`Quantize.cs` lives in the `Decentraland.Networking.Bitwise` namespace and
+provides two static methods used by the generated accessors:
+
+```csharp
+public static class Quantize
+{
+    public static uint  Encode(float value, float min, float max, int bits);
+    public static float Decode(uint encoded, float min, float max, int bits);
+}
+```
+
+## Step 4 — Use the generated code
+
+The plugin emits a `partial class` that adds float accessors on top of the
+standard protobuf-generated `uint32` properties:
+
+```csharp
+using Decentraland.Kernel.Comms.V3;
+
+// --- Build and send ---
+var delta = new PositionDelta();
+delta.DxQuantized = 3.14f;   // encodes to uint32, stored in delta.Dx
+delta.DyQuantized = 0f;
+delta.DzQuantized = -7.5f;
+delta.EntityId    = 42u;
+
+byte[] bytes = delta.ToByteArray();   // standard protobuf serialization
+SendOnChannel1(bytes);
+
+// --- Receive and read ---
+var received = PositionDelta.Parser.ParseFrom(receivedBytes);
+float x = received.DxQuantized;   // decoded on first access, cached thereafter
+float y = received.DyQuantized;
+float z = received.DzQuantized;
+
+// If raw uint32 fields are mutated directly after construction, invalidate the cache:
+received.ResetDecodedCache();
+```
+
+## Generated file example
+
+For the `PositionDelta` message above the plugin emits `PositionDelta.Bitwise.cs`:
+
+```csharp
+// <auto-generated>
+//   Generated by protoc-gen-bitwise. DO NOT EDIT.
+//   Source: decentraland/kernel/comms/v3/comms.proto
+// </auto-generated>
+
+using Decentraland.Networking.Bitwise;
+
+namespace Decentraland.Kernel.Comms.V3
+{
+    public partial class PositionDelta
+    {
+        private float? _dx;
+        public float DxQuantized
+        {
+            get => _dx ??= Quantize.Decode(Dx, -100.0f, 100.0f, 16);
+            set { _dx = value; Dx = Quantize.Encode(value, -100.0f, 100.0f, 16); }
+        }
+
+        private float? _dy;
+        public float DyQuantized
+        {
+            get => _dy ??= Quantize.Decode(Dy, -100.0f, 100.0f, 16);
+            set { _dy = value; Dy = Quantize.Encode(value, -100.0f, 100.0f, 16); }
+        }
+
+        private float? _dz;
+        public float DzQuantized
+        {
+            get => _dz ??= Quantize.Decode(Dz, -100.0f, 100.0f, 16);
+            set { _dz = value; Dz = Quantize.Encode(value, -100.0f, 100.0f, 16); }
+        }
+
+        /// <summary>Clears all cached decoded values. Call after mutating raw uint32 fields directly.</summary>
+        public void ResetDecodedCache()
+        {
+            _dx = null;
+            _dy = null;
+            _dz = null;
+        }
+    }
+
+} // namespace Decentraland.Kernel.Comms.V3
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-27226386025.commit-c056d32",
+  "version": "1.0.0-27358757907.commit-3c70e8a",
   "description": "",
   "repository": {
     "type": "git",
@@ -28,10 +28,11 @@
     "protobufjs": "7.2.4"
   },
   "files": [
-    "proto",
+    "proto/decentraland",
     "out-ts",
     "out-js",
-    "public"
+    "public",
+    "protoc-gen-bitwise"
   ],
-  "commit": "c056d32602c680fe758e8d6e3eedcd30b11aaaba"
+  "commit": "3c70e8a31967c1171f5470426006675976fcad11"
 }

package/proto/decentraland/common/options.proto

@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package decentraland.common;
+
+import "google/protobuf/descriptor.proto";
+
+// Options for quantizing a float value stored as a uint32 field.
+// The float is clamped to [min, max] and uniformly quantized to N bits;
+// protobuf encodes the resulting uint32 as a varint on the wire.
+// The generator emits a float {Name}Quantized accessor in the partial class.
+message QuantizedFloatOptions {
+  float  min  = 1;
+  float  max  = 2;
+  uint32 bits = 3;
+}
+
+// Options for bit-packing an integer field into fewer than 32 bits.
+message BitPackedOptions {
+  uint32 bits = 1;
+}
+
+extend google.protobuf.FieldOptions {
+  // Apply to uint32 fields to enable quantized float encoding.
+  // Example: uint32 dx = 1 [(decentraland.common.quantized) = { min: -100.0, max: 100.0, bits: 16 }];
+  QuantizedFloatOptions quantized  = 50001;
+
+  // Apply to uint32 fields to pack into fewer bits.
+  // Example: uint32 entity_id = 4 [(decentraland.common.bit_packed) = { bits: 20 }];
+  BitPackedOptions      bit_packed = 50002;
+}

package/proto/decentraland/common/quantization_example.proto

@@ -0,0 +1,132 @@
+syntax = "proto3";
+
+package decentraland.common;
+
+import "decentraland/common/options.proto";
+
+// High-frequency player state messages sent on Channel 1 (unreliable sequenced).
+//
+// Every message below uses the protoc-gen-bitwise annotations to minimise
+// wire size.  Wire costs are listed per-message so the trade-offs are clear.
+//
+// Annotation cheat-sheet:
+//   [(decentraland.common.quantized)  = { min: F, max: F, bits: N }]
+//       → stores a float as a uint32 quantized to N bits over [min, max].
+//       → protobuf encodes the uint32 as a varint: values ≤ 2^14-1 cost 2 bytes,
+//         values ≤ 2^21-1 cost 3 bytes; the generated partial class adds a
+//         float {Name}Quantized accessor that encodes/decodes transparently.
+//   [(decentraland.common.bit_packed) = { bits: N }]
+//       → documents that this uint32 uses at most N bits; protobuf encodes it
+//         as a varint (same savings, no generated accessor needed).
+//   (no annotation)
+//       → standard protobuf encoding (bool/double/etc. at natural width).
+//
+// Varint byte costs at worst-case (all bits set):
+//   ≤ 7 bits  → 1 byte   (max 127)
+//   ≤ 14 bits → 2 bytes  (max 16 383)
+//   ≤ 21 bits → 3 bytes  (max 2 097 151)
+// Proto3 omits fields equal to their default value (0), so average cost is lower.
+
+// ---------------------------------------------------------------------------
+// PositionDelta — Δ position relative to last acknowledged full snapshot.
+//
+// Sent every client tick (~10 Hz) on Channel 1.
+//
+//  Field       | Type   | Range          | Q bits | Wire worst-case
+//  ------------|--------|----------------|--------|-----------------------
+//  dx          | uint32 | [-100, 100]    |   16   | tag 1B + varint 3B = 4B
+//  dy          | uint32 | [-100, 100]    |   16   | tag 1B + varint 3B = 4B
+//  dz          | uint32 | [-100, 100]    |   16   | tag 1B + varint 3B = 4B
+//  entity_id   | uint32 | [0, 1 048 575] |   20   | tag 1B + varint 3B = 4B
+//  sequence    | uint32 | [0,     4 095] |   12   | tag 1B + varint 2B = 3B
+//  ---------------------------------------------------------------------------
+//  Worst-case: 19 B  (vs. 20 B raw: 3×float + 2×uint32)
+//  Step: dx/dy/dz ≈ 0.003 units
+// ---------------------------------------------------------------------------
+message PositionDelta {
+  uint32 dx        = 1 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 dy        = 2 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 dz        = 3 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 entity_id = 4 [(decentraland.common.bit_packed) = { bits: 20 }];
+  uint32 sequence  = 5 [(decentraland.common.bit_packed) = { bits: 12 }];
+}
+
+// ---------------------------------------------------------------------------
+// PlayerInput — client input snapshot for server-side reconciliation.
+//
+// Sent every client frame (~30 Hz) on Channel 1.
+//
+//  Field       | Type   | Range          | Q bits | Wire worst-case
+//  ------------|--------|----------------|--------|-----------------------
+//  move_x      | uint32 | [-1, 1]        |    8   | tag 1B + varint 2B = 3B
+//  move_z      | uint32 | [-1, 1]        |    8   | tag 1B + varint 2B = 3B
+//  yaw         | uint32 | [-180, 180]    |   12   | tag 1B + varint 2B = 3B
+//  buttons     | uint32 | bitmask        |    8   | tag 1B + varint 2B = 3B
+//  sequence    | uint32 | [0, 4 095]     |   12   | tag 1B + varint 2B = 3B
+//  ---------------------------------------------------------------------------
+//  Worst-case: 15 B  (vs. 20 B raw: 3×float + 2×uint32)
+//  Step: move_x/move_z ≈ 0.008; yaw ≈ 0.088°
+// ---------------------------------------------------------------------------
+message PlayerInput {
+  // Normalised joystick axes in [-1, 1].
+  uint32 move_x   = 1 [(decentraland.common.quantized)  = { min: -1.0,   max: 1.0,   bits:  8 }];
+  uint32 move_z   = 2 [(decentraland.common.quantized)  = { min: -1.0,   max: 1.0,   bits:  8 }];
+
+  // Horizontal look direction in degrees.
+  uint32 yaw      = 3 [(decentraland.common.quantized)  = { min: -180.0, max: 180.0, bits: 12 }];
+
+  // Bitmask of active buttons (see ButtonFlags below).
+  uint32 buttons  = 4 [(decentraland.common.bit_packed) = { bits:  8 }];
+
+  // Rolling input sequence number used by the server for reconciliation.
+  uint32 sequence = 5 [(decentraland.common.bit_packed) = { bits: 12 }];
+}
+
+// Bitmask values for PlayerInput.buttons.
+enum ButtonFlags {
+  BF_NONE      = 0;
+  BF_JUMP      = 1;   // bit 0
+  BF_SPRINT    = 2;   // bit 1
+  BF_INTERACT  = 4;   // bit 2
+  BF_EMOTE     = 8;   // bit 3
+  BF_CROUCH    = 16;  // bit 4
+  // bits 5-7 reserved
+}
+
+// ---------------------------------------------------------------------------
+// AvatarStateSnapshot — full authoritative state, sent on Channel 0 (reliable)
+// or on resync requests.  Demonstrates wider ranges and mixed encodings.
+//
+//  Field            | Type   | Range            | Q bits | Wire worst-case
+//  -----------------|--------|------------------|--------|-----------------------
+//  x                | uint32 | [-4096, 4096]    |   16   | tag 1B + varint 3B = 4B
+//  y                | uint32 | [-256,   256]    |   14   | tag 1B + varint 2B = 3B
+//  z                | uint32 | [-4096, 4096]    |   16   | tag 1B + varint 3B = 4B
+//  pitch            | uint32 | [-90,    90]     |   10   | tag 1B + varint 2B = 3B
+//  yaw              | uint32 | [-180,  180]     |   12   | tag 1B + varint 2B = 3B
+//  entity_id        | uint32 | [0, 1 048 575]   |   20   | tag 1B + varint 3B = 4B
+//  animation_state  | uint32 | [0,       63]    |    6   | tag 1B + varint 1B = 2B
+//  is_grounded      | bool   | —                |   —    | tag 1B + varint 1B = 2B
+//  timestamp        | double | —                |   —    | tag 1B + fixed64  8B = 9B
+//  ---------------------------------------------------------------------------
+//  Worst-case: 34 B  (vs. 45 B raw: 5×float + 2×uint32 + bool + double)
+//  Step: x/z ≈ 0.125 units; y ≈ 0.031 units; pitch ≈ 0.176°; yaw ≈ 0.088°
+// ---------------------------------------------------------------------------
+message AvatarStateSnapshot {
+  // World-space position.
+  uint32 x               = 1 [(decentraland.common.quantized)  = { min: -4096.0, max: 4096.0, bits: 16 }];
+  uint32 y               = 2 [(decentraland.common.quantized)  = { min:  -256.0, max:  256.0, bits: 14 }];
+  uint32 z               = 3 [(decentraland.common.quantized)  = { min: -4096.0, max: 4096.0, bits: 16 }];
+
+  // View angles.
+  uint32 pitch           = 4 [(decentraland.common.quantized)  = { min:  -90.0,  max:   90.0, bits: 10 }];
+  uint32 yaw             = 5 [(decentraland.common.quantized)  = { min: -180.0,  max:  180.0, bits: 12 }];
+
+  // Identity and animation state.
+  uint32 entity_id       = 6 [(decentraland.common.bit_packed) = { bits: 20 }];
+  uint32 animation_state = 7 [(decentraland.common.bit_packed) = { bits:  6 }];
+
+  // Un-annotated fields — encoded at their natural width.
+  bool   is_grounded     = 8;
+  double timestamp       = 9;   // server epoch milliseconds
+}

package/proto/decentraland/pulse/pulse_client.proto

@@ -0,0 +1,77 @@
+syntax = "proto3";
+
+package decentraland.pulse;
+
+import "decentraland/common/vectors.proto";
+import "decentraland/pulse/pulse_shared.proto";
+
+message HandshakeRequest {
+	bytes auth_chain = 1;
+  int32 profile_version = 2;
+  optional PlayerInitialState initial_state = 3;
+}
+
+// Describes the initial state of the player if (re-)connected in the middle of the session
+message PlayerInitialState {
+  PlayerState state = 1;
+  optional string emote_id = 2;
+  optional uint32 emote_duration_ms = 3;
+  // Indicates how many milliseconds ago the emote was started
+  optional uint32 emote_start_offset_ms = 4;
+  // Non-empty realm identifier. Rejected if empty.
+  string realm = 5;
+  optional int32 emote_mask = 6;
+}
+
+// Similarly to the LiveKit pipeline, a peer announces the version of its profile but
+// it only does it when it's changed as it's sent reliably and stored on the server for other peers
+message ProfileVersionAnnouncement {
+  int32 version = 1;
+}
+
+// Since the server doesn't simulate the scenes state, it trusts the values from the client
+message PlayerStateInput {
+  PlayerState state = 1;
+}
+
+// Client sends resync request if it has a gap in the known sequences and, thus, can't apply a delta.
+// It's sent reliably to prevent further desynchronization
+message ResyncRequest {
+  uint32 subject_id = 1;
+  // highest seq the client actually has for this subject
+  uint32 known_seq = 2;
+}
+
+// Client → Server. Client requests to start an emote.
+message EmoteStart {
+  string emote_id = 1;
+  optional uint32 duration_ms = 2;
+  PlayerState player_state = 3;
+  optional int32 mask = 4;
+}
+
+// Client → Server. Client requests to stop a looping emote.
+// One-shot emotes are terminated by the server timer.
+message EmoteStop {
+}
+
+// Client → Server. Also announces the peer's realm; peers in different realms never see each
+// other. Must be the first gameplay message after handshake. Same-realm re-teleports are valid.
+message TeleportRequest {
+  int32 parcel_index = 1;
+  decentraland.common.Vector3 position = 2;
+  // Non-empty realm identifier. Rejected if empty.
+  string realm = 3;
+}
+
+message ClientMessage {
+  oneof message {
+    HandshakeRequest handshake = 1;
+    PlayerStateInput input = 2;
+    ResyncRequest resync = 3;
+    ProfileVersionAnnouncement profile_announcement = 4;
+    EmoteStart emote_start = 5;
+    EmoteStop emote_stop = 6;
+    TeleportRequest teleport = 7;
+  }
+}

package/proto/decentraland/pulse/pulse_server.proto

@@ -0,0 +1,138 @@
+syntax = "proto3";
+
+package decentraland.pulse;
+
+import "decentraland/common/options.proto";
+import "decentraland/pulse/pulse_shared.proto";
+
+message HandshakeResponse {
+  bool success = 1;
+  optional string error = 2;
+}
+
+message PlayerProfileVersionsAnnounced {
+  uint32 subject_id = 1;
+  int32 version = 2;
+}
+
+message PlayerStateDeltaTier0 {
+  uint32 subject_id = 1;
+
+  // Between two consecutive server simulation ticks, the subject may have sent multiple inputs, each incrementing Seq by 1. So
+  // the delta's NewSeq will naturally jump by more than 1 compared to the previous delta — even with zero packet loss.
+  // Without the "BaselineSeq" the client has no way to detect the package loss
+  uint32 baseline_seq = 2;
+  uint32 new_seq = 3;
+  uint32 server_tick = 4;
+
+  // While the player doesn't cross the parcel, this field is omitted from diff
+  optional int32 parcel_index = 5;
+
+  // X position inside the parcel
+  optional uint32 position_x = 6 [(decentraland.common.quantized) = { min:  0,  max:   16, bits: 8 }];
+
+  // Y position
+  optional uint32 position_y = 7 [(decentraland.common.quantized) = { min:  0,  max:   200, bits: 13 }];
+
+  // Z position inside the parcel
+  optional uint32 position_z = 8 [(decentraland.common.quantized) = { min:  0,  max:   16, bits: 8 }];
+
+  optional uint32 velocity_x = 9 [(decentraland.common.quantized) = { min:  -50,  max:   50, bits: 8 }];
+  optional uint32 velocity_y = 10 [(decentraland.common.quantized) = { min:  -50,  max:   50, bits: 8 }];
+  optional uint32 velocity_z = 11 [(decentraland.common.quantized) = { min:  -50,  max:   50, bits: 8 }];
+
+  optional uint32 rotation_y = 12 [(decentraland.common.quantized) = { min:  0,  max:   360.0, bits: 7 }];
+  optional uint32 movement_blend = 13 [(decentraland.common.quantized) = { min:  0,  max:   3, bits: 5 }];
+  optional uint32 slide_blend = 14 [(decentraland.common.quantized) = { min:  0,  max:   1, bits: 4 }];
+  optional uint32 head_yaw = 15 [(decentraland.common.quantized) = { min:  0,  max:   360.0, bits: 7 }];
+  optional uint32 head_pitch = 16 [(decentraland.common.quantized) = { min:  0,  max:   360.0, bits: 7 }];
+
+  optional uint32 state_flags = 17;
+  optional GlideState glide_state = 18;
+
+  optional int32 jump_count = 19;
+
+  // Absolute world hit position the player is pointing at.
+  // Only meaningful when POINTING_AT is set in `state_flags`.
+  //
+  // X/Z use 17 bits over the world span (~±3000m, covers GenesisCity + border +
+  // raycast cutoff) which yields ~0.046m steps — at least as fine as the player's
+  // own parcel_index + position_x/z combined precision (0.0625m), so no separate
+  // parcel index is needed for point-at.
+  //
+  // Y uses 7 bits over the player altitude range (matches position_y), step ~1.6m.
+  // Point At is not supposed to change frequently so the wire overhead should be minimal
+  optional uint32 point_at_x = 20 [(decentraland.common.quantized) = { min: -3000.0, max: 3000.0, bits: 17 }];
+  optional uint32 point_at_y = 21 [(decentraland.common.quantized) = { min:     0.0, max:  200.0, bits:  7 }];
+  optional uint32 point_at_z = 22 [(decentraland.common.quantized) = { min: -3000.0, max: 3000.0, bits: 17 }];
+}
+
+// Full State is sent to the client when it is out of sync, and can't recover with a diff only
+message PlayerStateFull {
+  uint32 subject_id = 1;
+  uint32 sequence = 2;
+  uint32 server_tick = 3;
+  PlayerState state = 4;
+}
+
+// Notification to the client, that a peer has joined, it can mean connection or entering the area of interest, it's up to the server to decide
+message PlayerJoined {
+  string user_id = 1;
+  int32 profile_version = 2;
+  PlayerStateFull state = 3;
+}
+
+// Notification to the client, that a peer has left, it can mean disconnection or leaving the area of interest
+message PlayerLeft {
+  uint32 subject_id = 1;
+}
+
+enum EmoteStopReason {
+  COMPLETED = 0;  // one-shot timer expired on the server
+  CANCELLED = 1;  // client sent EmoteStop (looping emotes)
+}
+
+// Server → All Observers
+// Full player state is piggybacked to ensure the emote is played in the right place.
+// Observers use server_tick to scrub animation forward by transit latency.
+message EmoteStarted {
+  uint32 subject_id = 1;
+  uint32 sequence = 2;
+  uint32 server_tick = 3;
+  string emote_id = 4;
+  PlayerState player_state = 5;
+  optional int32 mask = 6;
+}
+
+// Server → All Observers
+// Client resumes MovementInput only after receiving this.
+// Carries full PlayerState so the client can snap to the correct position on resume.
+message EmoteStopped {
+  uint32 subject_id = 1;
+  uint32 server_tick = 2;
+  EmoteStopReason reason = 3;
+  uint32 sequence = 4;
+  PlayerState player_state = 5;
+}
+
+// Server → All Observers
+message TeleportPerformed {
+  uint32 subject_id = 1;
+  uint32 sequence = 2;
+  uint32 server_tick = 3;
+  PlayerState state = 4;
+}
+
+message ServerMessage {
+  oneof message {
+      HandshakeResponse handshake = 1;
+      PlayerStateFull player_state_full = 2;
+      PlayerStateDeltaTier0 player_state_delta = 3;
+      PlayerJoined player_joined = 4;
+      PlayerLeft player_left = 5;
+      PlayerProfileVersionsAnnounced player_profile_version_announced = 6;
+      EmoteStarted emote_started = 7;
+      EmoteStopped emote_stopped = 8;
+      TeleportPerformed teleported = 9;
+  }
+}

package/proto/decentraland/pulse/pulse_shared.proto

@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package decentraland.pulse;
+
+import "decentraland/common/vectors.proto";
+
+enum PlayerAnimationFlags {
+  NONE = 0;
+  GROUNDED = 1;
+  LONG_JUMP = 2;
+  LONG_FALL = 4;
+  FALLING = 8;
+  STUNNED = 16;
+  HEAD_YAW = 32;
+  HEAD_PITCH = 64;
+  POINTING_AT = 128;
+}
+
+enum GlideState {
+  PROP_CLOSED = 0;
+  OPENING_PROP = 1;
+  GLIDING = 2;
+  CLOSING_PROP = 3;
+}
+
+message PlayerState {
+  int32 parcel_index = 1;
+
+  decentraland.common.Vector3 position = 2;
+  decentraland.common.Vector3 velocity = 3;
+
+  float rotation_y = 4;
+
+  float movement_blend = 5;
+  float slide_blend = 6;
+
+  optional float head_yaw = 7;
+  optional float head_pitch = 8;
+
+  uint32 state_flags = 9;
+  GlideState glide_state = 10;
+
+  int32 jump_count = 11;
+
+  // Absolute world hit position the player is pointing at.
+  // Only meaningful when POINTING_AT is set in `state_flags`.
+  optional decentraland.common.Vector3 point_at = 12;
+}