@dcl/protocol 1.0.0-30361475985.commit-df8a4ff → 1.0.0-30376440685.commit-2726089

package/out-ts/decentraland/kernel/apis/restricted_actions.gen.ts

@@ -5,6 +5,135 @@ import { AvatarMask, avatarMaskFromJSON, avatarMaskToJSON } from "../../sdk/comp
 
 export const protobufPackage = "decentraland.kernel.apis";
 
+/**
+ * Identifies which fullscreen explorer panel OpenExplorerUi targets.
+ * EU_SETTINGS holds 0 so an unset `ui` field defaults to the least-intrusive panel.
+ */
+export enum ExplorerUi {
+  EU_SETTINGS = 0,
+  EU_MAP = 1,
+  EU_BACKPACK = 2,
+  EU_CAMERA_REEL = 3,
+  EU_COMMUNITIES = 4,
+  EU_PLACES = 5,
+  EU_EVENTS = 6,
+  UNRECOGNIZED = -1,
+}
+
+export function explorerUiFromJSON(object: any): ExplorerUi {
+  switch (object) {
+    case 0:
+    case "EU_SETTINGS":
+      return ExplorerUi.EU_SETTINGS;
+    case 1:
+    case "EU_MAP":
+      return ExplorerUi.EU_MAP;
+    case 2:
+    case "EU_BACKPACK":
+      return ExplorerUi.EU_BACKPACK;
+    case 3:
+    case "EU_CAMERA_REEL":
+      return ExplorerUi.EU_CAMERA_REEL;
+    case 4:
+    case "EU_COMMUNITIES":
+      return ExplorerUi.EU_COMMUNITIES;
+    case 5:
+    case "EU_PLACES":
+      return ExplorerUi.EU_PLACES;
+    case 6:
+    case "EU_EVENTS":
+      return ExplorerUi.EU_EVENTS;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ExplorerUi.UNRECOGNIZED;
+  }
+}
+
+export function explorerUiToJSON(object: ExplorerUi): string {
+  switch (object) {
+    case ExplorerUi.EU_SETTINGS:
+      return "EU_SETTINGS";
+    case ExplorerUi.EU_MAP:
+      return "EU_MAP";
+    case ExplorerUi.EU_BACKPACK:
+      return "EU_BACKPACK";
+    case ExplorerUi.EU_CAMERA_REEL:
+      return "EU_CAMERA_REEL";
+    case ExplorerUi.EU_COMMUNITIES:
+      return "EU_COMMUNITIES";
+    case ExplorerUi.EU_PLACES:
+      return "EU_PLACES";
+    case ExplorerUi.EU_EVENTS:
+      return "EU_EVENTS";
+    case ExplorerUi.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** Verdict of an OpenExplorerUi request (enum rather than a bool so new outcomes stay expressible). */
+export enum OpenExplorerUiResult {
+  UNSPECIFIED = 0,
+  OPENED = 1,
+  /** WAS_ALREADY_OPEN - a fullscreen panel is already open */
+  WAS_ALREADY_OPEN = 2,
+  /** REJECTED_NOT_CURRENT_SCENE - the standard restricted-actions current-scene gate rejected the call */
+  REJECTED_NOT_CURRENT_SCENE = 3,
+  /** REJECTED_FEATURE_DISABLED - the requested section is hidden by feature flags or client doesn't have that feature */
+  REJECTED_FEATURE_DISABLED = 4,
+  /** REJECTED_NO_USER_GESTURE - rejected: the call did not originate from a user gesture */
+  REJECTED_NO_USER_GESTURE = 5,
+  UNRECOGNIZED = -1,
+}
+
+export function openExplorerUiResultFromJSON(object: any): OpenExplorerUiResult {
+  switch (object) {
+    case 0:
+    case "UNSPECIFIED":
+      return OpenExplorerUiResult.UNSPECIFIED;
+    case 1:
+    case "OPENED":
+      return OpenExplorerUiResult.OPENED;
+    case 2:
+    case "WAS_ALREADY_OPEN":
+      return OpenExplorerUiResult.WAS_ALREADY_OPEN;
+    case 3:
+    case "REJECTED_NOT_CURRENT_SCENE":
+      return OpenExplorerUiResult.REJECTED_NOT_CURRENT_SCENE;
+    case 4:
+    case "REJECTED_FEATURE_DISABLED":
+      return OpenExplorerUiResult.REJECTED_FEATURE_DISABLED;
+    case 5:
+    case "REJECTED_NO_USER_GESTURE":
+      return OpenExplorerUiResult.REJECTED_NO_USER_GESTURE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return OpenExplorerUiResult.UNRECOGNIZED;
+  }
+}
+
+export function openExplorerUiResultToJSON(object: OpenExplorerUiResult): string {
+  switch (object) {
+    case OpenExplorerUiResult.UNSPECIFIED:
+      return "UNSPECIFIED";
+    case OpenExplorerUiResult.OPENED:
+      return "OPENED";
+    case OpenExplorerUiResult.WAS_ALREADY_OPEN:
+      return "WAS_ALREADY_OPEN";
+    case OpenExplorerUiResult.REJECTED_NOT_CURRENT_SCENE:
+      return "REJECTED_NOT_CURRENT_SCENE";
+    case OpenExplorerUiResult.REJECTED_FEATURE_DISABLED:
+      return "REJECTED_FEATURE_DISABLED";
+    case OpenExplorerUiResult.REJECTED_NO_USER_GESTURE:
+      return "REJECTED_NO_USER_GESTURE";
+    case OpenExplorerUiResult.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export interface MovePlayerToRequest {
   newRelativePosition: Vector3 | undefined;
   cameraTarget?: Vector3 | undefined;
@@ -74,6 +203,15 @@ export interface EmptyResponse {
 export interface StopEmoteRequest {
 }
 
+export interface OpenExplorerUiRequest {
+  ui: ExplorerUi;
+}
+
+export interface OpenExplorerUiResponse {
+  /** Carries only the verdict of the open action. */
+  openResult: OpenExplorerUiResult;
+}
+
 function createBaseMovePlayerToRequest(): MovePlayerToRequest {
   return { newRelativePosition: undefined, cameraTarget: undefined, avatarTarget: undefined, duration: undefined };
 }
@@ -1029,6 +1167,122 @@ export namespace StopEmoteRequest {
   }
 }
 
+function createBaseOpenExplorerUiRequest(): OpenExplorerUiRequest {
+  return { ui: 0 };
+}
+
+export namespace OpenExplorerUiRequest {
+  export function encode(message: OpenExplorerUiRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.ui !== 0) {
+      writer.uint32(8).int32(message.ui);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): OpenExplorerUiRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOpenExplorerUiRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.ui = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): OpenExplorerUiRequest {
+    return { ui: isSet(object.ui) ? explorerUiFromJSON(object.ui) : 0 };
+  }
+
+  export function toJSON(message: OpenExplorerUiRequest): unknown {
+    const obj: any = {};
+    message.ui !== undefined && (obj.ui = explorerUiToJSON(message.ui));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<OpenExplorerUiRequest>, I>>(base?: I): OpenExplorerUiRequest {
+    return OpenExplorerUiRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<OpenExplorerUiRequest>, I>>(
+    object: I,
+  ): OpenExplorerUiRequest {
+    const message = createBaseOpenExplorerUiRequest();
+    message.ui = object.ui ?? 0;
+    return message;
+  }
+}
+
+function createBaseOpenExplorerUiResponse(): OpenExplorerUiResponse {
+  return { openResult: 0 };
+}
+
+export namespace OpenExplorerUiResponse {
+  export function encode(message: OpenExplorerUiResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.openResult !== 0) {
+      writer.uint32(8).int32(message.openResult);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): OpenExplorerUiResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOpenExplorerUiResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.openResult = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): OpenExplorerUiResponse {
+    return { openResult: isSet(object.openResult) ? openExplorerUiResultFromJSON(object.openResult) : 0 };
+  }
+
+  export function toJSON(message: OpenExplorerUiResponse): unknown {
+    const obj: any = {};
+    message.openResult !== undefined && (obj.openResult = openExplorerUiResultToJSON(message.openResult));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<OpenExplorerUiResponse>, I>>(base?: I): OpenExplorerUiResponse {
+    return OpenExplorerUiResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<OpenExplorerUiResponse>, I>>(
+    object: I,
+  ): OpenExplorerUiResponse {
+    const message = createBaseOpenExplorerUiResponse();
+    message.openResult = object.openResult ?? 0;
+    return message;
+  }
+}
+
 export type RestrictedActionsServiceDefinition = typeof RestrictedActionsServiceDefinition;
 export const RestrictedActionsServiceDefinition = {
   name: "RestrictedActionsService",
@@ -1131,6 +1385,15 @@ export const RestrictedActionsServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /** OpenExplorerUi opens a specific fullscreen explorer panel and returns the open verdict. */
+    openExplorerUi: {
+      name: "OpenExplorerUi",
+      requestType: OpenExplorerUiRequest,
+      requestStream: false,
+      responseType: OpenExplorerUiResponse,
+      responseStream: false,
+      options: {},
+    },
   },
 } as const;
 

package/out-ts/decentraland/kernel/comms/rfc4/comms.gen.ts

@@ -137,6 +137,36 @@ export interface PlayerEmote {
   incrementalId: number;
   urn: string;
   timestamp: number;
+  /** true means the emote has been stopped in the sender's client */
+  isStopping?:
+    | boolean
+    | undefined;
+  /** true when it is not the first time the looping animation plays */
+  isRepeating?:
+    | boolean
+    | undefined;
+  /** identifies an interaction univocaly, established when the start animation is triggered */
+  interactionId?:
+    | number
+    | undefined;
+  /** -1 means it does not use an outcome animation */
+  socialEmoteOutcome?:
+    | number
+    | undefined;
+  /** to a social emote started by other user */
+  isReacting?:
+    | boolean
+    | undefined;
+  /** wallet address of the user that initiated social emote */
+  socialEmoteInitiator?:
+    | string
+    | undefined;
+  /** wallet address of the user whose avatar is the target of a directed emote */
+  targetAvatar?:
+    | string
+    | undefined;
+  /** mask for which bones an animation applies to. */
+  mask?: number | undefined;
 }
 
 export interface SceneEmote {
@@ -161,6 +191,11 @@ export interface ProfileResponse {
 export interface Chat {
   message: string;
   timestamp: number;
+  /**
+   * Extension: optional forwarded_from to identify the original sender when
+   * messages are forwarded through an SFU
+   */
+  forwardedFrom?: string | undefined;
 }
 
 export interface Scene {
@@ -1287,7 +1322,19 @@ export namespace MovementCompressed {
 }
 
 function createBasePlayerEmote(): PlayerEmote {
-  return { incrementalId: 0, urn: "", timestamp: 0 };
+  return {
+    incrementalId: 0,
+    urn: "",
+    timestamp: 0,
+    isStopping: undefined,
+    isRepeating: undefined,
+    interactionId: undefined,
+    socialEmoteOutcome: undefined,
+    isReacting: undefined,
+    socialEmoteInitiator: undefined,
+    targetAvatar: undefined,
+    mask: undefined,
+  };
 }
 
 export namespace PlayerEmote {
@@ -1301,6 +1348,30 @@ export namespace PlayerEmote {
     if (message.timestamp !== 0) {
       writer.uint32(29).float(message.timestamp);
     }
+    if (message.isStopping !== undefined) {
+      writer.uint32(32).bool(message.isStopping);
+    }
+    if (message.isRepeating !== undefined) {
+      writer.uint32(40).bool(message.isRepeating);
+    }
+    if (message.interactionId !== undefined) {
+      writer.uint32(48).int32(message.interactionId);
+    }
+    if (message.socialEmoteOutcome !== undefined) {
+      writer.uint32(56).int32(message.socialEmoteOutcome);
+    }
+    if (message.isReacting !== undefined) {
+      writer.uint32(64).bool(message.isReacting);
+    }
+    if (message.socialEmoteInitiator !== undefined) {
+      writer.uint32(74).string(message.socialEmoteInitiator);
+    }
+    if (message.targetAvatar !== undefined) {
+      writer.uint32(82).string(message.targetAvatar);
+    }
+    if (message.mask !== undefined) {
+      writer.uint32(88).uint32(message.mask);
+    }
     return writer;
   }
 
@@ -1332,6 +1403,62 @@ export namespace PlayerEmote {
 
           message.timestamp = reader.float();
           continue;
+        case 4:
+          if (tag !== 32) {
+            break;
+          }
+
+          message.isStopping = reader.bool();
+          continue;
+        case 5:
+          if (tag !== 40) {
+            break;
+          }
+
+          message.isRepeating = reader.bool();
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.interactionId = reader.int32();
+          continue;
+        case 7:
+          if (tag !== 56) {
+            break;
+          }
+
+          message.socialEmoteOutcome = reader.int32();
+          continue;
+        case 8:
+          if (tag !== 64) {
+            break;
+          }
+
+          message.isReacting = reader.bool();
+          continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+
+          message.socialEmoteInitiator = reader.string();
+          continue;
+        case 10:
+          if (tag !== 82) {
+            break;
+          }
+
+          message.targetAvatar = reader.string();
+          continue;
+        case 11:
+          if (tag !== 88) {
+            break;
+          }
+
+          message.mask = reader.uint32();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -1346,6 +1473,14 @@ export namespace PlayerEmote {
       incrementalId: isSet(object.incrementalId) ? Number(object.incrementalId) : 0,
       urn: isSet(object.urn) ? String(object.urn) : "",
       timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+      isStopping: isSet(object.isStopping) ? Boolean(object.isStopping) : undefined,
+      isRepeating: isSet(object.isRepeating) ? Boolean(object.isRepeating) : undefined,
+      interactionId: isSet(object.interactionId) ? Number(object.interactionId) : undefined,
+      socialEmoteOutcome: isSet(object.socialEmoteOutcome) ? Number(object.socialEmoteOutcome) : undefined,
+      isReacting: isSet(object.isReacting) ? Boolean(object.isReacting) : undefined,
+      socialEmoteInitiator: isSet(object.socialEmoteInitiator) ? String(object.socialEmoteInitiator) : undefined,
+      targetAvatar: isSet(object.targetAvatar) ? String(object.targetAvatar) : undefined,
+      mask: isSet(object.mask) ? Number(object.mask) : undefined,
     };
   }
 
@@ -1354,6 +1489,14 @@ export namespace PlayerEmote {
     message.incrementalId !== undefined && (obj.incrementalId = Math.round(message.incrementalId));
     message.urn !== undefined && (obj.urn = message.urn);
     message.timestamp !== undefined && (obj.timestamp = message.timestamp);
+    message.isStopping !== undefined && (obj.isStopping = message.isStopping);
+    message.isRepeating !== undefined && (obj.isRepeating = message.isRepeating);
+    message.interactionId !== undefined && (obj.interactionId = Math.round(message.interactionId));
+    message.socialEmoteOutcome !== undefined && (obj.socialEmoteOutcome = Math.round(message.socialEmoteOutcome));
+    message.isReacting !== undefined && (obj.isReacting = message.isReacting);
+    message.socialEmoteInitiator !== undefined && (obj.socialEmoteInitiator = message.socialEmoteInitiator);
+    message.targetAvatar !== undefined && (obj.targetAvatar = message.targetAvatar);
+    message.mask !== undefined && (obj.mask = Math.round(message.mask));
     return obj;
   }
 
@@ -1366,6 +1509,14 @@ export namespace PlayerEmote {
     message.incrementalId = object.incrementalId ?? 0;
     message.urn = object.urn ?? "";
     message.timestamp = object.timestamp ?? 0;
+    message.isStopping = object.isStopping ?? undefined;
+    message.isRepeating = object.isRepeating ?? undefined;
+    message.interactionId = object.interactionId ?? undefined;
+    message.socialEmoteOutcome = object.socialEmoteOutcome ?? undefined;
+    message.isReacting = object.isReacting ?? undefined;
+    message.socialEmoteInitiator = object.socialEmoteInitiator ?? undefined;
+    message.targetAvatar = object.targetAvatar ?? undefined;
+    message.mask = object.mask ?? undefined;
     return message;
   }
 }
@@ -1642,7 +1793,7 @@ export namespace ProfileResponse {
 }
 
 function createBaseChat(): Chat {
-  return { message: "", timestamp: 0 };
+  return { message: "", timestamp: 0, forwardedFrom: undefined };
 }
 
 export namespace Chat {
@@ -1653,6 +1804,9 @@ export namespace Chat {
     if (message.timestamp !== 0) {
       writer.uint32(17).double(message.timestamp);
     }
+    if (message.forwardedFrom !== undefined) {
+      writer.uint32(26).string(message.forwardedFrom);
+    }
     return writer;
   }
 
@@ -1677,6 +1831,13 @@ export namespace Chat {
 
           message.timestamp = reader.double();
           continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.forwardedFrom = reader.string();
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -1690,6 +1851,7 @@ export namespace Chat {
     return {
       message: isSet(object.message) ? String(object.message) : "",
       timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
+      forwardedFrom: isSet(object.forwardedFrom) ? String(object.forwardedFrom) : undefined,
     };
   }
 
@@ -1697,6 +1859,7 @@ export namespace Chat {
     const obj: any = {};
     message.message !== undefined && (obj.message = message.message);
     message.timestamp !== undefined && (obj.timestamp = message.timestamp);
+    message.forwardedFrom !== undefined && (obj.forwardedFrom = message.forwardedFrom);
     return obj;
   }
 
@@ -1708,6 +1871,7 @@ export namespace Chat {
     const message = createBaseChat();
     message.message = object.message ?? "";
     message.timestamp = object.timestamp ?? 0;
+    message.forwardedFrom = object.forwardedFrom ?? undefined;
     return message;
   }
 }

package/out-ts/decentraland/sdk/components/avatar_shape.gen.ts

@@ -5,6 +5,40 @@ import { Color3 } from "../../common/colors.gen";
 
 export const protobufPackage = "decentraland.sdk.components";
 
+/** Mask for which bones an animation applies to. */
+export enum AvatarEmoteMask {
+  AEM_FULL_BODY = 0,
+  AEM_UPPER_BODY = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function avatarEmoteMaskFromJSON(object: any): AvatarEmoteMask {
+  switch (object) {
+    case 0:
+    case "AEM_FULL_BODY":
+      return AvatarEmoteMask.AEM_FULL_BODY;
+    case 1:
+    case "AEM_UPPER_BODY":
+      return AvatarEmoteMask.AEM_UPPER_BODY;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return AvatarEmoteMask.UNRECOGNIZED;
+  }
+}
+
+export function avatarEmoteMaskToJSON(object: AvatarEmoteMask): string {
+  switch (object) {
+    case AvatarEmoteMask.AEM_FULL_BODY:
+      return "AEM_FULL_BODY";
+    case AvatarEmoteMask.AEM_UPPER_BODY:
+      return "AEM_UPPER_BODY";
+    case AvatarEmoteMask.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 /**
  * The AvatarShape component contains the information required to draw and animate avatar, acting as
  * a simplified GLTF container for this specific case.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-30361475985.commit-df8a4ff",
+  "version": "1.0.0-30376440685.commit-2726089",
   "description": "",
   "repository": {
     "type": "git",
@@ -13,10 +13,11 @@
   "license": "Apache-2.0",
   "main": "index.js",
   "scripts": {
-    "test": "./scripts/check-proto-compabitility.sh"
+    "test": "./scripts/check-proto-compabitility.sh",
+    "gen:test": "node protoc-gen-bitwise/test/generator.test.js"
   },
   "devDependencies": {
-    "@protobuf-ts/protoc": "^2.8.1",
+    "@protobuf-ts/protoc": "^2.11.0",
     "proto-compatibility-tool": "^1.1.2-20220925163655.commit-25bd040",
     "typescript": "^5.0.4"
   },
@@ -28,10 +29,12 @@
     "protobufjs": "7.2.4"
   },
   "files": [
-    "proto",
+    "proto/decentraland",
     "out-ts",
     "out-js",
-    "public"
+    "public",
+    "protoc-gen-bitwise/*.js",
+    "protoc-gen-bitwise/runtime"
   ],
-  "commit": "df8a4ff26e8aa1944c07f23516aab1e2759be681"
+  "commit": "2726089f694644e752fbbb15fa152a83eeeeecd6"
 }

package/proto/decentraland/common/options.proto

@@ -0,0 +1,51 @@
+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 quantizing a signed float with a power-law curve, stored as a uint32 field.
+// The value is split into an (bits-1)-bit linear unorm magnitude `u in [0, 1]` plus a sign,
+// and reconstructed as `value = sign * max * u^pow`. Because `u = 0` maps to exactly `0`, zero is
+// representable (unlike the linear quantizer, whose codes straddle zero), and `pow > 1` concentrates
+// resolution near zero — useful for fields like velocity that need fine detail at low magnitudes and
+// only coarse detail near the extremes. The range is symmetric ([-max, max]); there is no `min`.
+// The encoded layout puts the magnitude in the high bits and the sign in the LSB
+// (`(magnitude << 1) | sign`), so the varint cost tracks magnitude, not direction: a small `|value|`
+// of either sign stays in one varint byte. Zero canonicalizes to `0`, so proto3 omits a stopped field.
+// The generator emits a float {Name}Quantized accessor, same as the linear option.
+message QuantizedPowerFloatOptions {
+  float  max  = 1;
+  float  pow  = 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;
+
+  // Apply to uint32 fields to enable power-law quantized float encoding (sign + magnitude curve).
+  // A field carries either `quantized` or `quantized_power`, not both.
+  // Example: uint32 velocity_x = 9 [(decentraland.common.quantized_power) = { max: 50.0, pow: 2.0, bits: 8 }];
+  QuantizedPowerFloatOptions quantized_power = 50003;
+}