@dcl/sdk 7.29.1-36041177279.commit-502e633 → 7.29.1-36591934525.commit-48aa9b5

package/explorer-ui/index.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="@dcl/js-runtime" />
+import { ExplorerUi, GrowOnlyValueSetComponentDefinition, PBExplorerItemPurchaseResult, PBExplorerUiEventsResult } from '@dcl/ecs';
+import { OpenExplorerUiResult } from '~system/RestrictedActions';
+export { ExplorerUi, OpenExplorerUiResult };
+/** @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 declare function channel<N extends string, T extends CorrelatedEvent>(name: N, component: GrowOnlyValueSetComponentDefinition<T>): Channel<N, T>;
+/** Panel lifecycle events: opened and closed. @public */
+export declare const ExplorerUiEvents: Channel<'explorerUi', PBExplorerUiEventsResult>;
+/** Outcome of an `EU_ITEM_PURCHASE` flow: purchased, dismissed or failed. @public */
+export declare const ItemPurchase: Channel<'itemPurchase', PBExplorerItemPurchaseResult>;
+/**
+ * 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 declare function variant<C extends AnyChannel, K extends CaseOf<C>>(ch: C, $case: K): Variant<C, K>;
+/**
+ * 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<[]>>;
+}
+/**
+ * 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 declare const openExplorerUiAndWait: OpenExplorerUiAndWait;

package/explorer-ui/index.js

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

package/internal/transports/rendererTransport.js

@@ -33,11 +33,8 @@ export function createRendererTransport(engineApi) {
             }
             return !!message;
         },
-        type: 'renderer',
-        // The renderer/host is the authority for reserved-range entities (avatars,
-        // root/player/camera): it is the only transport allowed to mutate or delete them.
-        allowReservedEntities: true
+        type: 'renderer'
     };
     return rendererTransport;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/network/binary-message-bus.d.ts

@@ -1,10 +1,7 @@
 export declare enum CommsMessage {
-    CRDT = 7,
-    REQ_CRDT_STATE = 8,
-    RES_CRDT_STATE = 9,
-    CRDT_SERVER = 4,
-    CRDT_AUTHORITATIVE = 5,
-    CUSTOM_EVENT = 6
+    CRDT = 1,
+    REQ_CRDT_STATE = 2,
+    RES_CRDT_STATE = 3
 }
 export declare function BinaryMessageBus<T extends CommsMessage>(send: (message: Uint8Array, toPeerAddress?: string[]) => void): {
     on: <K extends T>(message: K, callback: (value: Uint8Array, sender: string) => void) => void;

package/network/binary-message-bus.js

@@ -1,12 +1,9 @@
 import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
 export var CommsMessage;
 (function (CommsMessage) {
-    CommsMessage[CommsMessage["CRDT"] = 7] = "CRDT";
-    CommsMessage[CommsMessage["REQ_CRDT_STATE"] = 8] = "REQ_CRDT_STATE";
-    CommsMessage[CommsMessage["RES_CRDT_STATE"] = 9] = "RES_CRDT_STATE";
-    CommsMessage[CommsMessage["CRDT_SERVER"] = 4] = "CRDT_SERVER";
-    CommsMessage[CommsMessage["CRDT_AUTHORITATIVE"] = 5] = "CRDT_AUTHORITATIVE";
-    CommsMessage[CommsMessage["CUSTOM_EVENT"] = 6] = "CUSTOM_EVENT";
+    CommsMessage[CommsMessage["CRDT"] = 1] = "CRDT";
+    CommsMessage[CommsMessage["REQ_CRDT_STATE"] = 2] = "REQ_CRDT_STATE";
+    CommsMessage[CommsMessage["RES_CRDT_STATE"] = 3] = "RES_CRDT_STATE";
 })(CommsMessage || (CommsMessage = {}));
 export function BinaryMessageBus(send) {
     const mapping = new Map();
@@ -20,9 +17,8 @@ export function BinaryMessageBus(send) {
         __processMessages: (messages) => {
             for (const message of messages) {
                 const commsMsg = decodeCommsMessage(message);
-                if (!commsMsg) {
+                if (!commsMsg)
                     continue;
-                }
                 const { sender, messageType, data } = commsMsg;
                 const fn = mapping.get(messageType);
                 if (fn)
@@ -69,4 +65,4 @@ export function encodeString(s) {
     buffer.writeUtf8String(s);
     return buffer.readBuffer();
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/network/index.d.ts

@@ -1,8 +1,2 @@
-export declare function isServer(): boolean;
-declare const getChildren: (parent: import("@dcl/ecs").Entity) => Iterable<import("@dcl/ecs").Entity>, syncEntity: (entityId: import("@dcl/ecs").Entity, componentIds: number[], entityEnumId?: number | undefined) => void, parentEntity: (entity: import("@dcl/ecs").Entity, parent: import("@dcl/ecs").Entity) => void, getParent: (child: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity | undefined, myProfile: import("./message-bus-sync").IProfile, removeParent: (entity: import("@dcl/ecs").Entity) => void, getFirstChild: (entity: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity, isStateSyncronized: () => boolean, binaryMessageBus: {
-    on: <K extends import("./binary-message-bus").CommsMessage>(message: K, callback: (value: Uint8Array, sender: string) => void) => void;
-    emit: <K_1 extends import("./binary-message-bus").CommsMessage>(message: K_1, value: Uint8Array, toPeerAddress?: string[] | undefined) => void;
-    __processMessages: (messages: Uint8Array[]) => void;
-}, eventBus: import("./events/implementation").Room<import("./events").EventSchemaRegistry>;
-export { registerMessages, getRoom } from './events';
-export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized, binaryMessageBus, eventBus };
+declare const getChildren: (parent: import("@dcl/ecs").Entity) => Iterable<import("@dcl/ecs").Entity>, syncEntity: (entityId: import("@dcl/ecs").Entity, componentIds: number[], entityEnumId?: number | undefined) => void, parentEntity: (entity: import("@dcl/ecs").Entity, parent: import("@dcl/ecs").Entity) => void, getParent: (child: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity | undefined, myProfile: import("./message-bus-sync").IProfile, removeParent: (entity: import("@dcl/ecs").Entity) => void, getFirstChild: (entity: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity, isStateSyncronized: () => boolean;
+export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized };

package/network/index.js

@@ -2,20 +2,7 @@ import { sendBinary } from '~system/CommunicationsController';
 import { engine } from '@dcl/ecs';
 import { addSyncTransport } from './message-bus-sync';
 import { getUserData } from '~system/UserIdentity';
-import { isServer as isServerApi } from '~system/EngineApi';
-import { Atom } from '../atom';
-// Create isServer atom for consistent state
-const isServerAtom = Atom(false);
-void isServerApi({}).then((response) => {
-    isServerAtom.swap(!!response.isServer);
-});
-// Helper function to check if running on server
-export function isServer() {
-    return isServerAtom.getOrNull() ?? false;
-}
 // initialize sync transport for sdk engine
-const { getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, getFirstChild, isStateSyncronized, binaryMessageBus, eventBus } = addSyncTransport(engine, sendBinary, getUserData, isServerApi, 'network');
-// Re-export the room messaging system
-export { registerMessages, getRoom } from './events';
-export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized, binaryMessageBus, eventBus };
-//# sourceMappingURL=data:application/json;base64,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
+const { getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, getFirstChild, isStateSyncronized } = addSyncTransport(engine, sendBinary, getUserData);
+export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbmV0d29yay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0NBQWtDLENBQUE7QUFDN0QsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUNqQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUNyRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFFbEQsMkNBQTJDO0FBQzNDLE1BQU0sRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsa0JBQWtCLEVBQUUsR0FDcEgsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLFVBQVUsRUFBRSxXQUFXLENBQUMsQ0FBQTtBQUVuRCxPQUFPLEVBQUUsYUFBYSxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLGtCQUFrQixFQUFFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzZW5kQmluYXJ5IH0gZnJvbSAnfnN5c3RlbS9Db21tdW5pY2F0aW9uc0NvbnRyb2xsZXInXG5pbXBvcnQgeyBlbmdpbmUgfSBmcm9tICdAZGNsL2VjcydcbmltcG9ydCB7IGFkZFN5bmNUcmFuc3BvcnQgfSBmcm9tICcuL21lc3NhZ2UtYnVzLXN5bmMnXG5pbXBvcnQgeyBnZXRVc2VyRGF0YSB9IGZyb20gJ35zeXN0ZW0vVXNlcklkZW50aXR5J1xuXG4vLyBpbml0aWFsaXplIHN5bmMgdHJhbnNwb3J0IGZvciBzZGsgZW5naW5lXG5jb25zdCB7IGdldENoaWxkcmVuLCBzeW5jRW50aXR5LCBwYXJlbnRFbnRpdHksIGdldFBhcmVudCwgbXlQcm9maWxlLCByZW1vdmVQYXJlbnQsIGdldEZpcnN0Q2hpbGQsIGlzU3RhdGVTeW5jcm9uaXplZCB9ID1cbiAgYWRkU3luY1RyYW5zcG9ydChlbmdpbmUsIHNlbmRCaW5hcnksIGdldFVzZXJEYXRhKVxuXG5leHBvcnQgeyBnZXRGaXJzdENoaWxkLCBnZXRDaGlsZHJlbiwgc3luY0VudGl0eSwgcGFyZW50RW50aXR5LCBnZXRQYXJlbnQsIG15UHJvZmlsZSwgcmVtb3ZlUGFyZW50LCBpc1N0YXRlU3luY3Jvbml6ZWQgfVxuIl19

package/network/message-bus-sync.d.ts

@@ -1,27 +1,14 @@
 /// <reference types="@dcl/js-runtime" />
 import { IEngine } from '@dcl/ecs';
-import type { SendBinaryRequest, SendBinaryResponse } from '~system/CommunicationsController';
-import { CommsMessage } from './binary-message-bus';
-import type { GetUserDataRequest, GetUserDataResponse } from '~system/UserIdentity';
-import { IsServerRequest, IsServerResponse } from '~system/EngineApi';
-import { Atom } from '../atom';
-import { Room } from './events/implementation';
+import { type SendBinaryRequest, type SendBinaryResponse } from '~system/CommunicationsController';
+import { GetUserDataRequest, GetUserDataResponse } from '~system/UserIdentity';
 export type IProfile = {
     networkId: number;
     userId: string;
 };
-export declare const AUTH_SERVER_PEER_ID = "authoritative-server";
-export declare const DEBUG_NETWORK_MESSAGES: () => any;
-export declare function addSyncTransport(engine: IEngine, sendBinary: (msg: SendBinaryRequest) => Promise<SendBinaryResponse>, getUserData: (value: GetUserDataRequest) => Promise<GetUserDataResponse>, isServerFn: (request: IsServerRequest) => Promise<IsServerResponse>, name: string): {
+export declare function addSyncTransport(engine: IEngine, sendBinary: (msg: SendBinaryRequest) => Promise<SendBinaryResponse>, getUserData: (value: GetUserDataRequest) => Promise<GetUserDataResponse>): {
     myProfile: IProfile;
     isStateSyncronized: () => boolean;
-    binaryMessageBus: {
-        on: <K extends CommsMessage>(message: K, callback: (value: Uint8Array, sender: string) => void) => void;
-        emit: <K_1 extends CommsMessage>(message: K_1, value: Uint8Array, toPeerAddress?: string[] | undefined) => void;
-        __processMessages: (messages: Uint8Array[]) => void;
-    };
-    eventBus: Room<import("./events").EventSchemaRegistry>;
-    isRoomReadyAtom: Atom<boolean>;
     syncEntity: (entityId: import("@dcl/ecs").Entity, componentIds: number[], entityEnumId?: number | undefined) => void;
     getChildren: (parent: import("@dcl/ecs").Entity) => Iterable<import("@dcl/ecs").Entity>;
     getParent: (child: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity | undefined;