@dcl/sdk 7.29.1-36591934525.commit-48aa9b5 → 7.29.1-36625469671.commit-2d5ffac

package/src/server/storage/serialize.ts

@@ -0,0 +1,132 @@
+const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/
+const UNSTORABLE_TEXT = /\u0000/
+const MAX_KEY_LENGTH = 255
+
+/**
+ * JSON.stringify always writes NUL as `\u0000` and an unpaired surrogate as a `\udXXX` escape (ES2019),
+ * while paired surrogates stay raw; an escaped backslash in front means the text is literal.
+ */
+const ESCAPED_UNSTORABLE_TEXT = /(?<!\\)(?:\\\\)*\\u(?:0000|d[89a-f][0-9a-f]{2})/i
+
+/** Raised from inside the replacer, so it is not mistaken for an engine error. */
+class UnstorableValueError extends TypeError {}
+
+type Reason = (holder: Record<string, unknown>, property: string, item: unknown) => string | undefined
+
+/**
+ * The `{ value }` PUT body. Rejects, at any depth, what JSON would drop or change: functions,
+ * symbols, non-finite numbers, `undefined` array elements and holes, built-ins with no JSON form
+ * (Map, Set, typed arrays, RegExp, Error, ...), and text the service cannot store. An `undefined`
+ * object property is dropped, as it reads back the same.
+ * @internal
+ */
+export function serializeStorageValue(value: unknown, callSite: string): string {
+  const body = stringify(value, callSite, fastReason)
+  // Text is checked once on the output; only a rejection pays for locating the offending item.
+  if (ESCAPED_UNSTORABLE_TEXT.test(body)) {
+    stringify(value, callSite, unstorable)
+    throw new TypeError(`${callSite}: value must not contain an unpaired surrogate or a NUL character.`)
+  }
+  if (body === '{}') {
+    throw new TypeError(`${callSite}: value must be JSON-serializable. Use delete() to remove a key.`)
+  }
+  return body
+}
+
+function stringify(value: unknown, callSite: string, reason: Reason): string {
+  const envelope = { value }
+  try {
+    return JSON.stringify(envelope, function (this: Record<string, unknown>, property, item) {
+      const why = reason(this, property, item)
+      if (why) {
+        const where = this === envelope ? 'the value' : `"${property}"`
+        throw new UnstorableValueError(
+          `${callSite}: value must be JSON-serializable, but ${where} ${why}. Use delete() to remove a key.`
+        )
+      }
+      return item
+    })
+  } catch (error) {
+    if (error instanceof UnstorableValueError) throw error
+    const cause = error instanceof Error ? error.message.split('\n')[0] : String(error)
+    throw new TypeError(`${callSite}: value must be JSON-serializable (${cause}). Use delete() to remove a key.`)
+  }
+}
+
+/** Everything but the text checks, with plain objects and arrays skipping the built-in check. */
+function fastReason(holder: Record<string, unknown>, property: string, item: unknown): string | undefined {
+  switch (typeof item) {
+    case 'function':
+    case 'symbol':
+      return `is a ${typeof item}`
+    case 'number':
+      return Number.isFinite(item) ? undefined : `is the non-finite number ${item}`
+    case 'undefined':
+      if (Array.isArray(holder)) return 'is undefined or a hole in an array'
+      return holder[property] !== undefined ? 'has a toJSON() that returns undefined' : undefined
+    case 'object': {
+      if (item === null || Array.isArray(item)) return undefined
+      const prototype = Object.getPrototypeOf(item)
+      return prototype === Object.prototype || prototype === null ? undefined : builtInReason(item)
+    }
+    default:
+      return undefined
+  }
+}
+
+/** Every check, per item: used to name the item a text rejection comes from. */
+function unstorable(holder: Record<string, unknown>, property: string, item: unknown): string | undefined {
+  const fast = fastReason(holder, property, item)
+  if (fast) return fast
+  if (typeof item === 'string' && (LONE_SURROGATE.test(item) || UNSTORABLE_TEXT.test(item))) {
+    return 'contains an unpaired surrogate or a NUL character'
+  }
+  if (!Array.isArray(holder) && (LONE_SURROGATE.test(property) || UNSTORABLE_TEXT.test(property))) {
+    return 'is a key with an unpaired surrogate or a NUL character'
+  }
+  return undefined
+}
+
+function builtInReason(item: unknown): string | undefined {
+  const builtIn = builtInName(item)
+  return builtIn ? `is ${/^[AEIO]/.test(builtIn) ? 'an' : 'a'} ${builtIn}, which has no JSON form` : undefined
+}
+
+function builtInName(item: unknown): string | undefined {
+  if (item === null || typeof item !== 'object') return undefined
+  if (item instanceof Map) return 'Map'
+  if (item instanceof Set) return 'Set'
+  if (item instanceof WeakMap) return 'WeakMap'
+  if (item instanceof WeakSet) return 'WeakSet'
+  if (item instanceof RegExp) return 'RegExp'
+  if (item instanceof Error) return 'Error'
+  if (item instanceof Promise) return 'Promise'
+  if (item instanceof ArrayBuffer) return 'ArrayBuffer'
+  if (ArrayBuffer.isView(item)) return item.constructor?.name ?? 'typed array'
+  return undefined
+}
+
+/**
+ * Keys and player addresses go into the request path, where `.`, `..` and an empty segment are
+ * resolved away by URL parsing, so they would address a different resource.
+ * @internal
+ */
+export function assertStorageKey(key: unknown, callSite: string): void {
+  if (typeof key !== 'string' || key === '' || key === '.' || key === '..') {
+    throw new TypeError(`${callSite}: key must be a non-empty string other than "." and "..".`)
+  }
+  if (LONE_SURROGATE.test(key) || UNSTORABLE_TEXT.test(key)) {
+    throw new TypeError(`${callSite}: key must not contain an unpaired surrogate or a NUL character.`)
+  }
+  // Counted in characters, as the service counts them.
+  if ([...key].length > MAX_KEY_LENGTH) {
+    throw new TypeError(`${callSite}: key must be at most ${MAX_KEY_LENGTH} characters.`)
+  }
+}
+
+/** @internal */
+export function assertPlayerAddress(address: unknown, callSite: string): void {
+  if (typeof address !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(address)) {
+    throw new TypeError(`${callSite}: address must be a 0x-prefixed 20-byte hex address.`)
+  }
+}

package/src/server/storage/value-cache.ts

@@ -0,0 +1,119 @@
+import { DEFAULT_STORAGE_CONFIG, StorageConfigState } from './constants'
+
+/**
+ * A cached fact about a key's server-side state.
+ * @internal
+ */
+export interface CacheEntry {
+  /**
+   * Serialized `{ value }` body; absent for negative entries. Parsed per read
+   * hit so callers never share object references, and compared verbatim for
+   * write dedup (exact equality — no hash-collision risk).
+   */
+  body?: string
+  /** True when the server confirmed the key does not exist (GET 404 or successful DELETE). */
+  absent?: boolean
+}
+
+/**
+ * Bounded, lazily-expiring cache of key states, backing both write dedup
+ * (skip storage writes whose value is already known to be stored) and read
+ * caching (serve get() without a network request within the TTL).
+ * @internal
+ */
+export interface ValueCache {
+  /** Returns the entry if present and fresh; lazily evicts expired entries. */
+  get(key: string): CacheEntry | undefined
+  /** Stores or refreshes a known value (serialized body); overwrites negative entries. */
+  set(key: string, entry: { body: string }): void
+  /** Stores a confirmed-absent (negative) entry, replacing any value entry. */
+  setAbsent(key: string): void
+  delete(key: string): void
+  /** Starts recording mutated keys, so a read issued earlier can tell its snapshot went stale. */
+  watch(): CacheWatcher
+}
+
+/**
+ * Keys mutated since the watch started. Always stop() it, or it keeps collecting.
+ * @internal
+ */
+export interface CacheWatcher {
+  mutated(key: string): boolean
+  stop(): void
+}
+
+/**
+ * Creates the bounded value cache shared by a storage scope.
+ * @internal
+ */
+export function createValueCache(config: StorageConfigState): ValueCache {
+  const entries = new Map<string, CacheEntry & { storedAt: number }>()
+  const watchers = new Set<Set<string>>()
+
+  function noteMutation(key: string): void {
+    for (const seen of watchers) seen.add(key)
+  }
+
+  function insert(key: string, entry: CacheEntry): void {
+    noteMutation(key)
+    // Delete + re-insert moves refreshed keys to the end of the Map's
+    // insertion order, so eviction below drops the least-recently-written.
+    entries.delete(key)
+    entries.set(key, { ...entry, storedAt: Date.now() })
+
+    // Guard against misconfiguration: a negative bound would loop forever on
+    // an empty map, and a NaN bound would silently disable eviction.
+    const maxEntries = !Number.isNaN(config.cacheMaxEntries)
+      ? Math.max(0, config.cacheMaxEntries)
+      : DEFAULT_STORAGE_CONFIG.cacheMaxEntries
+
+    while (entries.size > maxEntries) {
+      entries.delete(entries.keys().next().value!)
+    }
+  }
+
+  return {
+    get(key: string): CacheEntry | undefined {
+      const entry = entries.get(key)
+      if (!entry) return undefined
+
+      // Guard against misconfiguration, mirroring cacheMaxEntries: a NaN
+      // bound would silently disable expiry (NaN comparisons are false).
+      // Negative values need no guard — they just expire everything.
+      const maxAgeMs = !Number.isNaN(config.cacheMaxAgeMs) ? config.cacheMaxAgeMs : DEFAULT_STORAGE_CONFIG.cacheMaxAgeMs
+
+      // Lazy max-age expiry: storedAt is never refreshed on hits, so the age
+      // bounds the time since the last actual network confirmation.
+      if (Date.now() - entry.storedAt > maxAgeMs) {
+        entries.delete(key)
+        return undefined
+      }
+
+      return entry
+    },
+
+    set(key: string, entry: { body: string }): void {
+      insert(key, entry)
+    },
+
+    setAbsent(key: string): void {
+      insert(key, { absent: true })
+    },
+
+    delete(key: string): void {
+      noteMutation(key)
+      entries.delete(key)
+    },
+
+    watch(): CacheWatcher {
+      const seen = new Set<string>()
+      watchers.add(seen)
+      return {
+        mutated: (key: string) => seen.has(key),
+        stop: () => {
+          watchers.delete(seen)
+        }
+      }
+    }
+  }
+}

package/src/server/storage/write-queue.ts

@@ -0,0 +1,174 @@
+/**
+ * Rejection of a superseded delete when the write that replaced it did not apply.
+ * @internal
+ */
+export class SupersedingWriteFailed extends Error {
+  constructor() {
+    super('a write that replaced it did not apply')
+    this.name = 'SupersedingWriteFailed'
+  }
+}
+
+/**
+ * A pending write operation. `body` is the serialized PUT payload, or null
+ * for a DELETE. Callers that join the op share its promise.
+ */
+interface PendingOp {
+  body: string | null
+  execute: (body: string | null) => Promise<boolean>
+  promise: Promise<boolean>
+  resolve: (result: boolean) => void
+  reject: (error: unknown) => void
+}
+
+interface KeyState {
+  /** The op currently on the network. */
+  active: PendingOp
+  /** At most one queued op; a later write replaces it (latest wins). */
+  queued?: PendingOp
+}
+
+/**
+ * Serializes writes per key so the service commits them in issue order.
+ * Overlapping PUTs from the single scene server would otherwise race: the
+ * server keeps whichever request it processes last, while the local cache
+ * keeps whichever response arrives last — either can disagree with the last
+ * set() issued. With at most one in-flight op per key and a single queued
+ * "latest value" slot, the server's final state always matches the last
+ * write issued, and N rapid writes collapse into at most 2 network calls.
+ * @internal
+ */
+export interface WriteQueue {
+  /**
+   * Body of the latest issued write for the key (the queued op if present,
+   * else the in-flight one): a string for a PUT, null for a DELETE,
+   * undefined when no write is pending.
+   */
+  pending(key: string): string | null | undefined
+  /** True while any write for the key is in flight or queued. */
+  isPending(key: string): boolean
+  /**
+   * Resolves once the in-flight op settles and, if one was queued at call time,
+   * the op that runs next. At most two, so writes cannot starve a waiter. Never rejects.
+   */
+  settled(key: string): Promise<void>
+  /**
+   * Issues a write, queued behind any in-flight one and replacing any queued one
+   * (see settleSuperseded). An identical queued op is joined; `joinActive` also
+   * joins an identical in-flight op, which only dedup-tolerant callers may do.
+   * Rejects with the executor's error; see settleSuperseded for replaced ops.
+   */
+  enqueue(
+    key: string,
+    body: string | null,
+    execute: (body: string | null) => Promise<boolean>,
+    joinActive: boolean
+  ): Promise<boolean>
+}
+
+/**
+ * Creates the per-key write serializer shared by a storage scope.
+ * @internal
+ */
+export function createWriteQueue(): WriteQueue {
+  const keys = new Map<string, KeyState>()
+
+  function makeOp(body: string | null, execute: PendingOp['execute']): PendingOp {
+    let resolve!: (result: boolean) => void
+    let reject!: (error: unknown) => void
+    const promise = new Promise<boolean>((res, rej) => {
+      resolve = res
+      reject = rej
+    })
+    return { body, execute, promise, resolve, reject }
+  }
+
+  /**
+   * A replaced op resolves true when its replacement lands. On failure a set
+   * resolves false and a delete rejects, in its own terms.
+   */
+  function settleSuperseded(superseded: PendingOp, by: PendingOp): void {
+    by.promise.then(
+      (result) => {
+        const applied = by.body === null || result
+        if (superseded.body !== null) superseded.resolve(applied)
+        else if (applied) superseded.resolve(true)
+        else superseded.reject(new SupersedingWriteFailed())
+      },
+      (error) => {
+        if (superseded.body === null) superseded.reject(error)
+        else superseded.resolve(false)
+      }
+    )
+  }
+
+  async function drain(key: string, state: KeyState): Promise<void> {
+    for (;;) {
+      const op = state.active
+      try {
+        op.resolve(await op.execute(op.body))
+      } catch (error) {
+        op.reject(error)
+      }
+
+      if (state.queued) {
+        state.active = state.queued
+        state.queued = undefined
+      } else {
+        keys.delete(key)
+        return
+      }
+    }
+  }
+
+  return {
+    pending(key: string): string | null | undefined {
+      const state = keys.get(key)
+      if (!state) return undefined
+      return (state.queued ?? state.active).body
+    },
+
+    isPending(key: string): boolean {
+      return keys.has(key)
+    },
+
+    async settled(key: string): Promise<void> {
+      const state = keys.get(key)
+      if (!state) return
+      const hadQueued = state.queued !== undefined
+      await state.active.promise.catch(() => undefined)
+      // drain() promotes the queued op (or its replacement) in place before this resumes.
+      if (hadQueued) await state.active.promise.catch(() => undefined)
+    },
+
+    enqueue(key: string, body: string | null, execute: PendingOp['execute'], joinActive: boolean): Promise<boolean> {
+      const state = keys.get(key)
+
+      if (!state) {
+        const op = makeOp(body, execute)
+        const newState: KeyState = { active: op }
+        keys.set(key, newState)
+        void drain(key, newState)
+        return op.promise
+      }
+
+      if (state.queued) {
+        // A queued op has not started, so it is issued "after" this caller
+        // either way: join it when identical, supersede it otherwise.
+        if (state.queued.body === body) return state.queued.promise
+        const op = makeOp(body, execute)
+        settleSuperseded(state.queued, op)
+        state.queued = op
+        return op.promise
+      }
+
+      if (joinActive && state.active.body === body) {
+        return state.active.promise
+      }
+
+      const op = makeOp(body, execute)
+      state.queued = op
+      return op.promise
+    }
+  }
+}

package/src/server/storage-url.ts

@@ -0,0 +1,49 @@
+import { getRealm } from '~system/Runtime'
+
+const STORAGE_SERVER_ORG = 'https://storage.decentraland.org'
+const STORAGE_SERVER_ZONE = 'https://storage.decentraland.zone'
+
+async function resolveStorageServerUrl(): Promise<string> {
+  const { realmInfo } = await getRealm({})
+
+  if (!realmInfo) {
+    throw new Error('Unable to retrieve realm information')
+  }
+
+  // Local development / preview mode
+  if (realmInfo.isPreview) {
+    return realmInfo.baseUrl
+  }
+
+  // Staging / testing environment
+  if (realmInfo.baseUrl.includes('.zone')) {
+    return STORAGE_SERVER_ZONE
+  }
+
+  // Production environment
+  return STORAGE_SERVER_ORG
+}
+
+let memoizedUrl: Promise<string> | null = null
+
+/**
+ * Determines the correct storage server URL based on the current realm.
+ *
+ * - If `isPreview` is true, uses the realm's baseUrl (localhost)
+ * - If the realm's baseUrl contains `.zone`, uses storage.decentraland.zone
+ * - Otherwise, uses storage.decentraland.org (production)
+ *
+ * The realm never changes mid-session, so the result is memoized; a failed
+ * resolution is not memoized so transient getRealm errors can be retried.
+ *
+ * @returns The storage server base URL
+ */
+export function getStorageServerUrl(): Promise<string> {
+  if (!memoizedUrl) {
+    memoizedUrl = resolveStorageServerUrl()
+    memoizedUrl.catch(() => {
+      memoizedUrl = null
+    })
+  }
+  return memoizedUrl
+}

package/src/server/utils.ts

@@ -0,0 +1,83 @@
+import { signedFetch, SignedFetchRequest } from '~system/SignedFetch'
+import { isServer } from '../network'
+import { errorMessage } from './storage/error-message'
+
+/**
+ * Validates that the code is running on a server-side scene.
+ * Throws an error if called from a client-side context.
+ *
+ * @param moduleName - The name of the module for the error message
+ * @throws Error if not running on a server-side scene
+ */
+export function assertIsServer(moduleName: string): void {
+  if (!isServer()) {
+    throw new Error(`${moduleName} is only available on server-side scenes`)
+  }
+}
+
+/**
+ * Result type for operations that can fail.
+ * Returns a tuple of [error, null] on failure or [null, data] on success.
+ */
+export type Result<T, E = string> = [E, null] | [null, T]
+
+/**
+ * Extended result type that includes HTTP status code information.
+ */
+export type FetchResult<T> = [string, null, number?] | [null, T, number]
+
+/**
+ * Wraps a promise to catch errors and return a Result tuple.
+ * This allows for cleaner error handling without try-catch blocks.
+ *
+ * @param promise - The promise to wrap
+ * @returns A tuple of [error, null] on failure or [null, data] on success
+ */
+export async function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>> {
+  try {
+    const data = await promise
+    return [null, data]
+  } catch (error) {
+    return [error as E, null]
+  }
+}
+
+/**
+ * Wraps signedFetch with automatic error handling and JSON parsing. Never rejects.
+ * Returns a FetchResult tuple with parsed JSON data or error message and status code.
+ *
+ * @param signedFetchBody - The signedFetch request configuration
+ * @returns A tuple of [error, null, statusCode?] on failure or [null, data, statusCode] on success
+ */
+export async function wrapSignedFetch<T = unknown>(signedFetchBody: SignedFetchRequest): Promise<FetchResult<T>> {
+  let response: Awaited<ReturnType<typeof signedFetch>> | undefined
+  try {
+    response = await signedFetch(signedFetchBody)
+  } catch (error) {
+    console.error(`Error in ${signedFetchBody.url} endpoint`, { error })
+    return [errorMessage(error, 'signedFetch failed'), null, undefined]
+  }
+
+  if (!response) {
+    console.error(`Error in ${signedFetchBody.url} endpoint: no response`)
+    return ['signedFetch returned no response', null, undefined]
+  }
+
+  if (!response.ok) {
+    const errorMessage = `${response.status} ${response.statusText}`
+    console.error(`Error in ${signedFetchBody.url} endpoint`, { response })
+    return [errorMessage, null, response.status]
+  }
+
+  let body: T
+  try {
+    // JSON.parse throws synchronously, so it can't be wrapped with tryCatch (the
+    // throw would happen while evaluating the argument, rejecting this promise).
+    body = JSON.parse(response.body || '{}')
+  } catch {
+    console.error(`Failed to parse response from ${signedFetchBody.url}`)
+    return ['Failed to parse response', null, response.status]
+  }
+
+  return [null, (body ?? {}) as T, response.status]
+}

package/explorer-ui/index.d.ts

@@ -1,118 +0,0 @@
-/// <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;