@dcl/sdk 7.29.1-35901015152.commit-d1b7b96 → 7.29.1-35917671376.commit-046b268

package/platform/index.js

@@ -1,8 +1,40 @@
 import { getExplorerInformation } from '~system/Runtime';
+import { subscribe } from '~system/EngineApi';
+import { Observable } from '../internal/Observable';
+import { localeChangedEvents } from '../internal/language-events';
 const VALID_PLATFORMS = new Set(['mobile', 'desktop', 'web']);
+const DEFAULT_LANGUAGE = 'en';
+const BCP47_TAG = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/;
 let platform = null;
+let language = DEFAULT_LANGUAGE;
+let languageSetByEvent = false;
+/**
+ * Triggered when the player switches the client language mid-session.
+ * Older clients never emit it.
+ * @public
+ */
+export const onPlayerLanguageChanged = new Observable();
+function normalizeLocale(locale) {
+    const tag = (locale ?? '').trim().replace(/_/g, '-');
+    return BCP47_TAG.test(tag) ? tag : DEFAULT_LANGUAGE;
+}
+function setLanguage(next) {
+    if (next === language)
+        return;
+    language = next;
+    onPlayerLanguageChanged.notifyObservers({ language });
+}
+localeChangedEvents.add((event) => {
+    languageSetByEvent = true;
+    setLanguage(normalizeLocale(event.locale));
+});
+subscribe({ eventId: 'localeChanged' }).catch(console.error);
 void getExplorerInformation({})
     .then((response) => {
+    // a mid-session change that arrived first is more recent than this response
+    if (!languageSetByEvent) {
+        setLanguage(normalizeLocale(response.configurations?.['locale']));
+    }
     const normalized = response.platform.toLowerCase();
     if (VALID_PLATFORMS.has(normalized)) {
         platform = normalized;
@@ -26,4 +58,13 @@ export function isDesktop() {
 export function isWeb() {
     return getPlatform() === 'web';
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Player's client language as a BCP-47 tag (e.g. `'es'`, `'pt-BR'`).
+ * Returns `'en'` until the explorer responds, and on clients that don't report a locale.
+ * Use `onPlayerLanguageChanged` to react to mid-session changes.
+ * @public
+ */
+export function getPlayerLanguage() {
+    return language;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/players/index.d.ts

@@ -11,7 +11,6 @@ type GetPlayerDataRes = {
     avatar?: PBAvatarBase;
     wearables: PBAvatarEquippedData['wearableUrns'];
     emotes: PBAvatarEquippedData['emoteUrns'];
-    forceRender: PBAvatarEquippedData['forceRender'];
     position: TransformType['position'] | undefined;
 };
 export declare function definePlayerHelper(engine: IEngine): {

package/players/index.js

@@ -64,9 +64,11 @@ export function definePlayerHelper(engine) {
                 isGuest: !!playerData?.isGuest,
                 userId: playerData?.address ?? '',
                 avatar: avatarData ?? undefined,
-                wearables: wearablesData?.wearableUrns ?? [],
-                emotes: wearablesData?.emoteUrns ?? [],
-                forceRender: wearablesData?.forceRender ?? [],
+                // Component reads come back deeply readonly, so these are copied rather than
+                // aliased: the public Player type promises plain mutable arrays, and handing
+                // out the component's own frozen array would throw on any caller that writes.
+                wearables: [...(wearablesData?.wearableUrns ?? [])],
+                emotes: [...(wearablesData?.emoteUrns ?? [])],
                 position: Transform.getOrNull(userEntity)?.position
             };
         }
@@ -76,4 +78,4 @@ const players = definePlayerHelper(engine);
 const { getPlayer, onEnterScene, onLeaveScene } = players;
 export { getPlayer, onEnterScene, onLeaveScene };
 export default players;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/players/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,MAAM,EAAE,MAAM,UAAU,CAAA;AACjE,OAAO,EACL,kBAAkB,IAAI,uBAAuB,EAC7C,UAAU,IAAI,gBAAgB,EAC9B,kBAAkB,IAAI,wBAAwB,EAG9C,SAAS,IAAI,eAAe,EAC7B,MAAM,0BAA0B,CAAA;AAiBjC,MAAM,UAAU,kBAAkB,CAAC,MAAe;IAChD,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,CAAC,CAAA;IACzC,MAAM,kBAAkB,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAA;IAC1D,MAAM,kBAAkB,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAA;IAC3D,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC3C,MAAM,cAAc,GAAG,IAAI,GAAG,EAAkB,CAAA;IAEhD,MAAM,cAAc,GAA2C,EAAE,CAAA;IACjE,MAAM,cAAc,GAAiC,EAAE,CAAA;IAEvD,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE;QACpB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,CAAA;QAClF,IAAI,OAAO,CAAC,MAAM,KAAK,cAAc,CAAC,IAAI;YAAE,OAAM;QAElD,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,OAAO,EAAE;YACxC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;gBAC/B,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;gBAE5C,wBAAwB;gBACxB,IAAI,cAAc,CAAC,MAAM,EAAE;oBACzB,cAAc,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAE,CAAC,CAAC,CAAA;iBAC7E;gBAED,qCAAqC;gBACrC,UAAU,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;oBACpC,IAAI,CAAC,KAAK,IAAI,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;wBACxC,cAAc,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAE,CAAC,CAAC,CAAA;wBAC/D,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;qBAC9B;gBACH,CAAC,CAAC,CAAA;aACH;SACF;IACH,CAAC,CAAC,CAAA;IAEF,OAAO;QACL,YAAY,CAAC,EAAsC;YACjD,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACzB,CAAC;QACD,YAAY,CAAC,EAA4B;YACvC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACzB,CAAC;QACD;;WAEG;QACH,SAAS,CAAC,IAAuB;YAC/B,SAAS,SAAS;gBAChB,IAAI,CAAC,IAAI,EAAE,MAAM;oBAAE,OAAO,MAAM,CAAC,YAAY,CAAA;gBAC7C,KAAK,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,eAAe,CAAC,kBAAkB,CAAC,EAAE;oBACvE,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,MAAM,EAAE;wBAChC,OAAO,MAAM,CAAA;qBACd;iBACF;gBACD,OAAO,SAAS,CAAA;YAClB,CAAC;YAED,MAAM,UAAU,GAAG,SAAS,EAAE,CAAA;YAC9B,IAAI,CAAC,UAAU;gBAAE,OAAO,IAAI,CAAA;YAE5B,MAAM,UAAU,GAAG,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;YAC3D,MAAM,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;YACnD,MAAM,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;YAE9D,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,IAAI,CAAC,aAAa;gBAAE,OAAO,IAAI,CAAA;YAE7D,OAAO;gBACL,MAAM,EAAE,UAAU;gBAClB,IAAI,EAAE,UAAU,EAAE,IAAI,IAAI,EAAE;gBAC5B,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,OAAO;gBAC9B,MAAM,EAAE,UAAU,EAAE,OAAO,IAAI,EAAE;gBACjC,MAAM,EAAE,UAAU,IAAI,SAAS;gBAC/B,SAAS,EAAE,aAAa,EAAE,YAAY,IAAI,EAAE;gBAC5C,MAAM,EAAE,aAAa,EAAE,SAAS,IAAI,EAAE;gBACtC,WAAW,EAAE,aAAa,EAAE,WAAW,IAAI,EAAE;gBAC7C,QAAQ,EAAE,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,QAAQ;aACpD,CAAA;QACH,CAAC;KACF,CAAA;AACH,CAAC;AAED,MAAM,OAAO,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAA;AAC1C,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,GAAG,OAAO,CAAA;AAEzD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,CAAA;AAChD,eAAe,OAAO,CAAA","sourcesContent":["import { Entity, IEngine, TransformType, engine } from '@dcl/ecs'\nimport {\n  PlayerIdentityData as definePlayerIdenityData,\n  AvatarBase as defineAvatarBase,\n  AvatarEquippedData as defineAvatarEquippedData,\n  PBAvatarBase,\n  PBAvatarEquippedData,\n  Transform as defineTransform\n} from '@dcl/ecs/dist/components'\n\ntype GetPlayerDataReq = {\n  userId: string\n}\ntype GetPlayerDataRes = {\n  entity: Entity\n  name: string\n  isGuest: boolean\n  userId: string\n  avatar?: PBAvatarBase\n  wearables: PBAvatarEquippedData['wearableUrns']\n  emotes: PBAvatarEquippedData['emoteUrns']\n  forceRender: PBAvatarEquippedData['forceRender']\n  position: TransformType['position'] | undefined\n}\n\nexport function definePlayerHelper(engine: IEngine) {\n  const Transform = defineTransform(engine)\n  const PlayerIdentityData = definePlayerIdenityData(engine)\n  const AvatarEquippedData = defineAvatarEquippedData(engine)\n  const AvatarBase = defineAvatarBase(engine)\n  const playerEntities = new Map<Entity, string>()\n\n  const onEnterSceneCb: ((player: GetPlayerDataRes) => void)[] = []\n  const onLeaveSceneCb: ((userId: string) => void)[] = []\n\n  engine.addSystem(() => {\n    const players = Array.from(engine.getEntitiesWith(PlayerIdentityData, AvatarBase))\n    if (players.length === playerEntities.size) return\n\n    for (const [entity, identity] of players) {\n      if (!playerEntities.has(entity)) {\n        playerEntities.set(entity, identity.address)\n\n        // Call onEnter callback\n        if (onEnterSceneCb.length) {\n          onEnterSceneCb.forEach((cb) => cb(getPlayer({ userId: identity.address })!))\n        }\n\n        // Check for changes/remove callbacks\n        AvatarBase.onChange(entity, (value) => {\n          if (!value && playerEntities.get(entity)) {\n            onLeaveSceneCb.forEach((cb) => cb(playerEntities.get(entity)!))\n            playerEntities.delete(entity)\n          }\n        })\n      }\n    }\n  })\n\n  return {\n    onEnterScene(cb: (player: GetPlayerDataRes) => void) {\n      onEnterSceneCb.push(cb)\n    },\n    onLeaveScene(cb: (userId: string) => void) {\n      onLeaveSceneCb.push(cb)\n    },\n    /**\n     * Returns the info of the player if it's in the scene.\n     */\n    getPlayer(user?: GetPlayerDataReq): GetPlayerDataRes | null {\n      function getEntity() {\n        if (!user?.userId) return engine.PlayerEntity\n        for (const [entity, data] of engine.getEntitiesWith(PlayerIdentityData)) {\n          if (data.address === user.userId) {\n            return entity\n          }\n        }\n        return undefined\n      }\n\n      const userEntity = getEntity()\n      if (!userEntity) return null\n\n      const playerData = PlayerIdentityData.getOrNull(userEntity)\n      const avatarData = AvatarBase.getOrNull(userEntity)\n      const wearablesData = AvatarEquippedData.getOrNull(userEntity)\n\n      if (!playerData && !avatarData && !wearablesData) return null\n\n      return {\n        entity: userEntity,\n        name: avatarData?.name ?? '',\n        isGuest: !!playerData?.isGuest,\n        userId: playerData?.address ?? '',\n        avatar: avatarData ?? undefined,\n        wearables: wearablesData?.wearableUrns ?? [],\n        emotes: wearablesData?.emoteUrns ?? [],\n        forceRender: wearablesData?.forceRender ?? [],\n        position: Transform.getOrNull(userEntity)?.position\n      }\n    }\n  }\n}\n\nconst players = definePlayerHelper(engine)\nconst { getPlayer, onEnterScene, onLeaveScene } = players\n\nexport { getPlayer, onEnterScene, onLeaveScene }\nexport default players\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/players/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Entity, IEngine, TransformType, engine } from '@dcl/ecs'\nimport {\n  PlayerIdentityData as definePlayerIdenityData,\n  AvatarBase as defineAvatarBase,\n  AvatarEquippedData as defineAvatarEquippedData,\n  PBAvatarBase,\n  PBAvatarEquippedData,\n  Transform as defineTransform\n} from '@dcl/ecs/dist/components'\n\ntype GetPlayerDataReq = {\n  userId: string\n}\ntype GetPlayerDataRes = {\n  entity: Entity\n  name: string\n  isGuest: boolean\n  userId: string\n  avatar?: PBAvatarBase\n  wearables: PBAvatarEquippedData['wearableUrns']\n  emotes: PBAvatarEquippedData['emoteUrns']\n  position: TransformType['position'] | undefined\n}\n\nexport function definePlayerHelper(engine: IEngine) {\n  const Transform = defineTransform(engine)\n  const PlayerIdentityData = definePlayerIdenityData(engine)\n  const AvatarEquippedData = defineAvatarEquippedData(engine)\n  const AvatarBase = defineAvatarBase(engine)\n  const playerEntities = new Map<Entity, string>()\n\n  const onEnterSceneCb: ((player: GetPlayerDataRes) => void)[] = []\n  const onLeaveSceneCb: ((userId: string) => void)[] = []\n\n  engine.addSystem(() => {\n    const players = Array.from(engine.getEntitiesWith(PlayerIdentityData, AvatarBase))\n    if (players.length === playerEntities.size) return\n\n    for (const [entity, identity] of players) {\n      if (!playerEntities.has(entity)) {\n        playerEntities.set(entity, identity.address)\n\n        // Call onEnter callback\n        if (onEnterSceneCb.length) {\n          onEnterSceneCb.forEach((cb) => cb(getPlayer({ userId: identity.address })!))\n        }\n\n        // Check for changes/remove callbacks\n        AvatarBase.onChange(entity, (value) => {\n          if (!value && playerEntities.get(entity)) {\n            onLeaveSceneCb.forEach((cb) => cb(playerEntities.get(entity)!))\n            playerEntities.delete(entity)\n          }\n        })\n      }\n    }\n  })\n\n  return {\n    onEnterScene(cb: (player: GetPlayerDataRes) => void) {\n      onEnterSceneCb.push(cb)\n    },\n    onLeaveScene(cb: (userId: string) => void) {\n      onLeaveSceneCb.push(cb)\n    },\n    /**\n     * Returns the info of the player if it's in the scene.\n     */\n    getPlayer(user?: GetPlayerDataReq): GetPlayerDataRes | null {\n      function getEntity() {\n        if (!user?.userId) return engine.PlayerEntity\n        for (const [entity, data] of engine.getEntitiesWith(PlayerIdentityData)) {\n          if (data.address === user.userId) {\n            return entity\n          }\n        }\n        return undefined\n      }\n\n      const userEntity = getEntity()\n      if (!userEntity) return null\n\n      const playerData = PlayerIdentityData.getOrNull(userEntity)\n      const avatarData = AvatarBase.getOrNull(userEntity)\n      const wearablesData = AvatarEquippedData.getOrNull(userEntity)\n\n      if (!playerData && !avatarData && !wearablesData) return null\n\n      return {\n        entity: userEntity,\n        name: avatarData?.name ?? '',\n        isGuest: !!playerData?.isGuest,\n        userId: playerData?.address ?? '',\n        avatar: avatarData ?? undefined,\n        // Component reads come back deeply readonly, so these are copied rather than\n        // aliased: the public Player type promises plain mutable arrays, and handing\n        // out the component's own frozen array would throw on any caller that writes.\n        wearables: [...(wearablesData?.wearableUrns ?? [])],\n        emotes: [...(wearablesData?.emoteUrns ?? [])],\n        position: Transform.getOrNull(userEntity)?.position\n      }\n    }\n  }\n}\n\nconst players = definePlayerHelper(engine)\nconst { getPlayer, onEnterScene, onLeaveScene } = players\n\nexport { getPlayer, onEnterScene, onLeaveScene }\nexport default players\n"]}

package/src/explorer-ui/index.ts

@@ -0,0 +1,398 @@
+import {
+  engine,
+  ExplorerItemPurchaseResult,
+  ExplorerUi,
+  ExplorerUiEventsResult,
+  GrowOnlyValueSetComponentDefinition,
+  IEngine,
+  PBExplorerItemPurchaseResult,
+  PBExplorerUiEventsResult
+} from '@dcl/ecs'
+import { openExplorerUi, OpenExplorerUiResult } from '~system/RestrictedActions'
+
+export { ExplorerUi, OpenExplorerUiResult }
+
+// What an explorer that does not echo request_id, or a user-initiated action, leaves on the wire.
+const UNCORRELATED = 0
+
+// Panels that can be on screen next to another panel. The `ui` field alone cannot attribute
+// their events, so an event on one of these panels must carry a request_id.
+const CONCURRENT_PANELS: readonly ExplorerUi[] = [ExplorerUi.EU_ITEM_PURCHASE]
+
+/** @public */
+export type CorrelatedEvent = {
+  timestamp: number
+  requestId: number
+}
+
+/**
+ * A named stream of events that this helper can collect and stop on.
+ * @public
+ */
+export type Channel<N extends string = string, T extends CorrelatedEvent = CorrelatedEvent> = {
+  readonly name: N
+  readonly component: GrowOnlyValueSetComponentDefinition<T>
+}
+
+/** @public */
+export type AnyChannel = Channel<string, any>
+
+/**
+ * Wraps a grow-only result component as a {@link Channel}. The name must be unique within a scene.
+ * @public
+ */
+export function channel<N extends string, T extends CorrelatedEvent>(
+  name: N,
+  component: GrowOnlyValueSetComponentDefinition<T>
+): Channel<N, T> {
+  return { name, component }
+}
+
+/** Panel lifecycle events: opened and closed. @public */
+export const ExplorerUiEvents: Channel<'explorerUi', PBExplorerUiEventsResult> = /* @__PURE__ */ channel(
+  'explorerUi',
+  ExplorerUiEventsResult
+)
+
+/** Outcome of an `EU_ITEM_PURCHASE` flow: purchased, dismissed or failed. @public */
+export const ItemPurchase: Channel<'itemPurchase', PBExplorerItemPurchaseResult> = /* @__PURE__ */ channel(
+  'itemPurchase',
+  ExplorerItemPurchaseResult
+)
+
+/**
+ * The `$case` names of a channel's event union.
+ * @public
+ */
+export type CaseOf<C extends AnyChannel> =
+  C extends Channel<any, infer T> ? Extract<T[keyof T], { $case: string }>['$case'] : never
+
+/** @public */
+export type Variant<C extends AnyChannel = AnyChannel, K extends string = string> = {
+  readonly channel: C
+  readonly $case: K
+}
+
+/** @public */
+export function variant<C extends AnyChannel, K extends CaseOf<C>>(ch: C, $case: K): Variant<C, K> {
+  return { channel: ch, $case }
+}
+
+/**
+ * What ends the wait before the panel closes: any event on a channel, or one `$case` of it.
+ * @public
+ */
+export type StopCondition = AnyChannel | Variant
+
+/** @public */
+export type Collected<C> = C extends Channel<infer N, infer T> ? { channel: N; event: T } : never
+
+/**
+ * How the wait ended.
+ * - `closed`: the panel this call opened was closed.
+ * - `matched`: `until` fired first, so the panel may still be on screen.
+ * - `notOpened`: this call did not open anything. `openResult` says why.
+ * - `timedOut`: `timeoutMs` elapsed first.
+ *
+ * `events` always holds everything collected, the event that stopped the wait included.
+ * @public
+ */
+export type WaitOutcome<C extends readonly AnyChannel[]> =
+  | { $case: 'closed'; events: readonly Collected<C[number]>[] }
+  | { $case: 'matched'; events: readonly Collected<C[number]>[] }
+  | { $case: 'notOpened'; openResult: OpenExplorerUiResult }
+  | { $case: 'timedOut'; events: readonly Collected<C[number]>[] }
+
+/** @public */
+export type WaitOptions<C extends readonly AnyChannel[]> = {
+  /** Channels whose events land in `events`. Defaults to none. */
+  collect?: C
+  /** Stops the wait early. The panel closing always stops it regardless. */
+  until?: StopCondition
+  /**
+   * Bounds the wait, in milliseconds. On expiry the promise resolves with `$case: 'timedOut'`.
+   * No default, because a panel can stay open for minutes. Without it, an explorer that opens
+   * a panel and then emits no `closed` leaves the promise pending for the scene's whole life.
+   */
+  timeoutMs?: number
+}
+
+/** @public */
+export type OpenExplorerUiRequest =
+  | { ui: Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>; itemPurchase?: undefined }
+  | { ui: ExplorerUi.EU_ITEM_PURCHASE; itemPurchase: { urn: string } }
+
+/**
+ * Signature of {@link openExplorerUiAndWait}. The second overload takes a bare `ui`, so a
+ * computed panel value needs no narrowing.
+ * @public
+ */
+export interface OpenExplorerUiAndWait {
+  <const C extends readonly AnyChannel[] = []>(
+    request: OpenExplorerUiRequest,
+    options?: WaitOptions<C>
+  ): Promise<WaitOutcome<C>>
+  (ui: Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>): Promise<WaitOutcome<[]>>
+}
+
+/** @internal exposed for tests */
+export const EXPLORER_UI_WAIT_TIMEOUT_SYSTEM = 'explorer-ui-wait-timeout'
+
+// Lowest priority sorts this system last, so when it removes itself mid-tick it splices the
+// last element of the array the engine is iterating and skips no other system.
+const TIMEOUT_SYSTEM_PRIORITY = Number.MIN_SAFE_INTEGER
+
+type OpenExplorerUiFn = (body: {
+  ui: ExplorerUi
+  requestId?: number
+  itemPurchase?: { urn: string }
+}) => Promise<{ openResult: OpenExplorerUiResult }>
+
+type CollectedEvent = { channel: string; event: CorrelatedEvent }
+
+type Session = {
+  requestId: number
+  ui: ExplorerUi
+  correlationRequired: boolean
+  collect: ReadonlySet<string>
+  watched: ReadonlySet<string>
+  until: { channel: string; $case: string | undefined } | undefined
+  events: CollectedEvent[]
+  timeoutMs: number | undefined
+  elapsedMs: number
+  settled: boolean
+  settle: (outcome: WaitOutcome<never[]>) => void
+  fail: (error: Error) => void
+}
+
+type Attribution = 'yes' | 'no' | 'ambiguous'
+
+// ts-proto renders a `oneof` as one wrapper property `{ $case, [$case]: value }`. Finding that
+// property by shape keeps the helper independent of the name each message gave it: `event` on
+// one message, `status` on another.
+function caseOf(event: CorrelatedEvent): string | undefined {
+  for (const key of Object.keys(event)) {
+    const value = (event as unknown as Record<string, unknown>)[key]
+    if (value && typeof value === 'object' && typeof (value as { $case?: unknown }).$case === 'string') {
+      return (value as { $case: string }).$case
+    }
+  }
+  return undefined
+}
+
+function normalizeStop(stop: StopCondition): { channel: AnyChannel; $case: string | undefined } {
+  return '$case' in stop ? { channel: stop.channel, $case: stop.$case } : { channel: stop, $case: undefined }
+}
+
+/** @internal test seam. The production instance is {@link openExplorerUiAndWait}. */
+export function create(deps: {
+  engine: IEngine
+  openExplorerUi: OpenExplorerUiFn
+  explorerUiEvents: Channel<'explorerUi', PBExplorerUiEventsResult>
+}) {
+  const { engine: engineInstance, openExplorerUi: openExplorerUiFn, explorerUiEvents } = deps
+  const root = engineInstance.RootEntity
+
+  const sessions = new Map<number, Session>()
+  // Keyed by name, so two wrappers around the same component arm one listener, not two.
+  const armed = new Map<string, GrowOnlyValueSetComponentDefinition<any>>()
+  // Starts at 1 so a minted id never collides with UNCORRELATED.
+  let nextRequestId = 1
+  let timeoutSystemAdded = false
+
+  function arm(ch: AnyChannel) {
+    const bound = armed.get(ch.name)
+    if (bound) {
+      if (bound !== ch.component) {
+        throw new Error(
+          `openExplorerUiAndWait: channel name '${ch.name}' is already bound to a different component. ` +
+            `Channel names identify a stream, so they have to be unique within a scene.`
+        )
+      }
+      return
+    }
+    armed.set(ch.name, ch.component)
+    const name = ch.name
+    // onChange has no unsubscribe, so one listener per channel lives for the engine's lifetime.
+    ch.component.onChange(root, (value: CorrelatedEvent | undefined) => {
+      // `undefined` arrives on DELETE_ENTITY. Otherwise `value` is one appended element,
+      // not the whole set.
+      if (value) deliver(name, value)
+    })
+  }
+
+  function attribute(session: Session, name: string, event: CorrelatedEvent): Attribution {
+    if (event.requestId === session.requestId) return 'yes'
+    if (event.requestId !== UNCORRELATED) return 'no'
+    // Only the lifecycle channel carries a second discriminator, `ui`, and it identifies a
+    // session only while panels cannot coexist. A second call for the same panel is answered
+    // WAS_ALREADY_OPEN, so at most one session per non-concurrent panel is ever live.
+    if (session.correlationRequired || name !== explorerUiEvents.name) return 'ambiguous'
+    return (event as PBExplorerUiEventsResult).ui === session.ui ? 'yes' : 'no'
+  }
+
+  function deliver(name: string, event: CorrelatedEvent) {
+    // Settling deletes from `sessions` mid-iteration, which a Map tolerates. Nothing adds.
+    for (const session of sessions.values()) {
+      if (!session.watched.has(name)) continue
+      const attribution = attribute(session, name, event)
+      if (attribution === 'no') continue
+      if (attribution === 'ambiguous') {
+        failSession(
+          session,
+          new Error(
+            `openExplorerUiAndWait: got a '${name}' event with no request_id, and nothing else identifies ` +
+              `the call it belongs to. This explorer does not echo OpenExplorerUiRequest.request_id.`
+          )
+        )
+        continue
+      }
+      accept(session, name, event)
+    }
+  }
+
+  function accept(session: Session, name: string, event: CorrelatedEvent) {
+    if (session.collect.has(name)) session.events.push({ channel: name, event })
+
+    // The close is terminal and wins over `until`, because `matched` would tell the caller
+    // that the panel is still on screen.
+    if (name === explorerUiEvents.name && caseOf(event) === 'closed') {
+      settleSession(session, { $case: 'closed', events: session.events as never[] })
+      return
+    }
+
+    const until = session.until
+    if (!until || until.channel !== name) return
+    if (until.$case === undefined || until.$case === caseOf(event)) {
+      settleSession(session, { $case: 'matched', events: session.events as never[] })
+    }
+  }
+
+  function settleSession(session: Session, outcome: WaitOutcome<never[]>) {
+    if (session.settled) return
+    session.settled = true
+    sessions.delete(session.requestId)
+    session.settle(outcome)
+    maybeRemoveTimeoutSystem()
+  }
+
+  function failSession(session: Session, error: Error) {
+    if (session.settled) return
+    session.settled = true
+    sessions.delete(session.requestId)
+    session.fail(error)
+    maybeRemoveTimeoutSystem()
+  }
+
+  function hasTimedSession(): boolean {
+    for (const session of sessions.values()) {
+      if (session.timeoutMs !== undefined) return true
+    }
+    return false
+  }
+
+  function maybeRemoveTimeoutSystem() {
+    if (!timeoutSystemAdded || hasTimedSession()) return
+    timeoutSystemAdded = false
+    engineInstance.removeSystem(EXPLORER_UI_WAIT_TIMEOUT_SYSTEM)
+  }
+
+  function ensureTimeoutSystem() {
+    if (timeoutSystemAdded) return
+    timeoutSystemAdded = true
+    // The scene runtime has no timers, so elapsed time is accumulated from the engine's dt.
+    engineInstance.addSystem(
+      (dt: number) => {
+        for (const session of sessions.values()) {
+          if (session.timeoutMs === undefined) continue
+          session.elapsedMs += dt * 1000
+          if (session.elapsedMs >= session.timeoutMs) {
+            settleSession(session, { $case: 'timedOut', events: session.events as never[] })
+          }
+        }
+        maybeRemoveTimeoutSystem()
+      },
+      TIMEOUT_SYSTEM_PRIORITY,
+      EXPLORER_UI_WAIT_TIMEOUT_SYSTEM
+    )
+  }
+
+  async function openExplorerUiAndWait(
+    request: OpenExplorerUiRequest | Exclude<ExplorerUi, ExplorerUi.EU_ITEM_PURCHASE>,
+    options?: WaitOptions<readonly AnyChannel[]>
+  ): Promise<WaitOutcome<never[]>> {
+    const { ui, itemPurchase } = typeof request === 'number' ? { ui: request, itemPurchase: undefined } : request
+    const requestId = nextRequestId++
+
+    const collect = options?.collect ?? []
+    const collectNames = new Set<string>()
+    for (const ch of collect) collectNames.add(ch.name)
+
+    const stop = options?.until ? normalizeStop(options.until) : undefined
+    const watched = new Set<string>(collectNames)
+    watched.add(explorerUiEvents.name)
+    if (stop) watched.add(stop.channel.name)
+
+    // Armed before the RPC, because events can land while the RPC is in flight. A listener
+    // that is already up is what makes replaying the accumulated set unnecessary.
+    arm(explorerUiEvents)
+    for (const ch of collect) arm(ch)
+    if (stop) arm(stop.channel)
+
+    let settle!: (outcome: WaitOutcome<never[]>) => void
+    let fail!: (error: Error) => void
+    const outcome = new Promise<WaitOutcome<never[]>>((resolve, reject) => {
+      settle = resolve
+      fail = reject
+    })
+
+    const session: Session = {
+      requestId,
+      ui,
+      correlationRequired: CONCURRENT_PANELS.includes(ui),
+      collect: collectNames,
+      watched,
+      until: stop ? { channel: stop.channel.name, $case: stop.$case } : undefined,
+      events: [],
+      timeoutMs: options?.timeoutMs,
+      elapsedMs: 0,
+      settled: false,
+      settle,
+      fail
+    }
+    sessions.set(requestId, session)
+    if (session.timeoutMs !== undefined) ensureTimeoutSystem()
+
+    try {
+      const { openResult } = await openExplorerUiFn({ ui, requestId, itemPurchase })
+      // This call opened nothing, so no event carrying this request id is coming.
+      if (openResult !== OpenExplorerUiResult.OPENED) {
+        settleSession(session, { $case: 'notOpened', openResult })
+      }
+    } catch (error) {
+      // Routed through the session rather than rethrown, so that `outcome` is never left
+      // pending and unobserved.
+      failSession(session, error as Error)
+    }
+
+    return outcome
+  }
+
+  // The implementation takes both argument forms and is blind to `collect`. The cast is what
+  // gives callers the two overloads that relate them.
+  return { openExplorerUiAndWait: openExplorerUiAndWait as OpenExplorerUiAndWait }
+}
+
+const helper = /* @__PURE__ */ create({ engine, openExplorerUi, explorerUiEvents: ExplorerUiEvents })
+
+/**
+ * Opens an explorer panel and waits for the session it started. The wait ends when the panel
+ * closes. See {@link WaitOptions} to collect events, to stop earlier or to bound the wait.
+ *
+ * Every lifecycle outcome resolves, see {@link WaitOutcome}. The promise rejects only when an
+ * event cannot be attributed to a call at all: an explorer too old to echo `request_id`
+ * paired with a panel that can coexist with another one.
+ *
+ * @public
+ */
+export const openExplorerUiAndWait: OpenExplorerUiAndWait = helper.openExplorerUiAndWait

package/src/internal/language-events.ts

@@ -0,0 +1,8 @@
+import { Observable } from './Observable'
+
+/**
+ * @internal
+ * Raw `localeChanged` events drained from the renderer by `pollEvents`.
+ * Kept side-effect free so `observables` doesn't load `platform` for every scene.
+ */
+export const localeChangedEvents = new Observable<{ locale: string }>()

package/src/observables.ts

@@ -12,6 +12,7 @@ import {
 } from '@dcl/ecs'
 import { ManyEntityAction, SendBatchResponse, subscribe } from '~system/EngineApi'
 import players from './players'
+import { localeChangedEvents } from './internal/language-events'
 
 /// --- EVENTS ---
 
@@ -49,6 +50,11 @@ export interface IEvents {
     message: string
   }
 
+  /** Triggered when the player switches the client language. `locale` is a BCP-47 tag */
+  localeChanged: {
+    locale: string
+  }
+
   /**
    * This is triggered once the scene should start.
    */
@@ -215,6 +221,10 @@ export async function pollEvents(sendBatch: (body: ManyEntityAction) => Promise<
           onCommsMessage.notifyObservers(data as IEvents['comms'])
           break
         }
+        case 'localeChanged': {
+          localeChangedEvents.notifyObservers(data as IEvents['localeChanged'])
+          break
+        }
       }
     }
   }

package/src/platform/index.ts

@@ -1,12 +1,49 @@
 import { getExplorerInformation } from '~system/Runtime'
+import { subscribe } from '~system/EngineApi'
+import { Observable } from '../internal/Observable'
+import { localeChangedEvents } from '../internal/language-events'
 
 export type Platform = 'mobile' | 'desktop' | 'web'
 
 const VALID_PLATFORMS: Set<string> = new Set<string>(['mobile', 'desktop', 'web'])
 
+const DEFAULT_LANGUAGE = 'en'
+const BCP47_TAG = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8})*$/
+
 let platform: Platform | null = null
+let language: string = DEFAULT_LANGUAGE
+let languageSetByEvent = false
+
+/**
+ * Triggered when the player switches the client language mid-session.
+ * Older clients never emit it.
+ * @public
+ */
+export const onPlayerLanguageChanged = new Observable<{ language: string }>()
+
+function normalizeLocale(locale: string | undefined): string {
+  const tag = (locale ?? '').trim().replace(/_/g, '-')
+  return BCP47_TAG.test(tag) ? tag : DEFAULT_LANGUAGE
+}
+
+function setLanguage(next: string) {
+  if (next === language) return
+  language = next
+  onPlayerLanguageChanged.notifyObservers({ language })
+}
+
+localeChangedEvents.add((event) => {
+  languageSetByEvent = true
+  setLanguage(normalizeLocale(event.locale))
+})
+subscribe({ eventId: 'localeChanged' }).catch(console.error)
+
 void getExplorerInformation({})
   .then((response) => {
+    // a mid-session change that arrived first is more recent than this response
+    if (!languageSetByEvent) {
+      setLanguage(normalizeLocale(response.configurations?.['locale']))
+    }
     const normalized = response.platform.toLowerCase()
     if (VALID_PLATFORMS.has(normalized)) {
       platform = normalized as Platform
@@ -33,3 +70,13 @@ export function isDesktop(): boolean {
 export function isWeb(): boolean {
   return getPlatform() === 'web'
 }
+
+/**
+ * Player's client language as a BCP-47 tag (e.g. `'es'`, `'pt-BR'`).
+ * Returns `'en'` until the explorer responds, and on clients that don't report a locale.
+ * Use `onPlayerLanguageChanged` to react to mid-session changes.
+ * @public
+ */
+export function getPlayerLanguage(): string {
+  return language
+}

package/src/players/index.ts

@@ -19,7 +19,6 @@ type GetPlayerDataRes = {
   avatar?: PBAvatarBase
   wearables: PBAvatarEquippedData['wearableUrns']
   emotes: PBAvatarEquippedData['emoteUrns']
-  forceRender: PBAvatarEquippedData['forceRender']
   position: TransformType['position'] | undefined
 }
 
@@ -93,9 +92,11 @@ export function definePlayerHelper(engine: IEngine) {
         isGuest: !!playerData?.isGuest,
         userId: playerData?.address ?? '',
         avatar: avatarData ?? undefined,
-        wearables: wearablesData?.wearableUrns ?? [],
-        emotes: wearablesData?.emoteUrns ?? [],
-        forceRender: wearablesData?.forceRender ?? [],
+        // Component reads come back deeply readonly, so these are copied rather than
+        // aliased: the public Player type promises plain mutable arrays, and handing
+        // out the component's own frozen array would throw on any caller that writes.
+        wearables: [...(wearablesData?.wearableUrns ?? [])],
+        emotes: [...(wearablesData?.emoteUrns ?? [])],
         position: Transform.getOrNull(userEntity)?.position
       }
     }