@taphubhq/sdk-core 0.13.0

package/dist/index.js

@@ -0,0 +1,2448 @@
+// src/errors/index.ts
+var TaphubError = class _TaphubError extends Error {
+  code;
+  details;
+  constructor(message, options) {
+    super(message);
+    this.name = "TaphubError";
+    this.code = options.code;
+    this.details = options.details;
+    Object.setPrototypeOf(this, _TaphubError.prototype);
+  }
+};
+var TaphubAuthError = class _TaphubAuthError extends TaphubError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TaphubAuthError";
+    Object.setPrototypeOf(this, _TaphubAuthError.prototype);
+  }
+};
+var TaphubNetworkError = class _TaphubNetworkError extends TaphubError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TaphubNetworkError";
+    Object.setPrototypeOf(this, _TaphubNetworkError.prototype);
+  }
+};
+var TaphubValidationError = class _TaphubValidationError extends TaphubError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TaphubValidationError";
+    Object.setPrototypeOf(this, _TaphubValidationError.prototype);
+  }
+};
+var TaphubServerError = class _TaphubServerError extends TaphubError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TaphubServerError";
+    Object.setPrototypeOf(this, _TaphubServerError.prototype);
+  }
+};
+var TaphubSlippageError = class _TaphubSlippageError extends TaphubValidationError {
+  clientCoef;
+  serverCoef;
+  slippage;
+  constructor(message, options) {
+    super(message, { code: options.code, details: options.details });
+    this.name = "TaphubSlippageError";
+    this.clientCoef = options.clientCoef;
+    this.serverCoef = options.serverCoef;
+    this.slippage = options.slippage;
+    Object.setPrototypeOf(this, _TaphubSlippageError.prototype);
+  }
+};
+
+// src/events/bus.ts
+var TaphubEventBus = class {
+  target = new EventTarget();
+  on(event, handler) {
+    this.target.addEventListener(event, handler);
+  }
+  off(event, handler) {
+    this.target.removeEventListener(event, handler);
+  }
+  emit(event, payload) {
+    this.target.dispatchEvent(new CustomEvent(event, { detail: payload }));
+  }
+};
+
+// src/modules/auth/normalise.ts
+function normaliseGoogleResponse(body) {
+  return {
+    accessToken: body.access_token,
+    user: {
+      id: body.user.id,
+      displayName: body.user.name ?? "",
+      agencyUid: body.user.agency_uid ?? null,
+      currency: body.user.currency ?? "",
+      wallet: {
+        id: body.user.default_wallet?.id ?? null,
+        balance: body.user.default_wallet?.amount ?? "0",
+        currency: body.user.default_wallet?.currency ?? "",
+        isEnabled: body.user.default_wallet?.is_enable ?? false
+      }
+    },
+    isDemo: false
+  };
+}
+function normaliseDemoResponse(body) {
+  return {
+    accessToken: body.access_token,
+    user: {
+      id: body.user.id,
+      displayName: body.user.username ?? "",
+      agencyUid: null,
+      currency: body.user.currency ?? "",
+      wallet: {
+        id: null,
+        balance: body.user.balance ?? "0",
+        currency: body.user.currency ?? "",
+        isEnabled: true
+      }
+    },
+    isDemo: body.demo ?? true
+  };
+}
+function normaliseCreateDemoUserResponse(body) {
+  const node = body.createDemoUser;
+  if (!node || typeof node.token !== "string" || node.token === "") {
+    throw new TaphubServerError("Invalid response from server", { code: "InvalidResponse" });
+  }
+  if (!node.user || typeof node.user.id !== "string" || node.user.id === "") {
+    throw new TaphubServerError("Invalid response from server", { code: "InvalidResponse" });
+  }
+  return {
+    accessToken: node.token,
+    user: {
+      id: node.user.id,
+      displayName: node.user.username ?? "",
+      agencyUid: null,
+      currency: "",
+      wallet: {
+        id: null,
+        balance: node.user.balance ?? "0",
+        currency: "",
+        isEnabled: true
+      }
+    },
+    isDemo: node.user.is_demo
+  };
+}
+function normaliseUserLoginResponse(body) {
+  const node = body.userLogin;
+  if (!node || typeof node.accessToken !== "string" || node.accessToken === "") {
+    throw new TaphubServerError("Invalid response from server", { code: "InvalidResponse" });
+  }
+  if (!node.user || typeof node.user.id !== "string" || node.user.id === "") {
+    throw new TaphubServerError("Invalid response from server", { code: "InvalidResponse" });
+  }
+  const wallet = node.user.defaultWallet;
+  return {
+    accessToken: node.accessToken,
+    user: {
+      id: node.user.id,
+      displayName: node.user.name,
+      agencyUid: node.user.agencyUid,
+      currency: node.user.currency,
+      wallet: {
+        id: wallet.id,
+        balance: String(wallet.amount),
+        currency: wallet.currency,
+        isEnabled: wallet.isEnable
+      }
+    },
+    isDemo: false
+  };
+}
+function validateLoginBody(body) {
+  if (typeof body.access_token !== "string" || body.access_token === "") {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  if (!body.user || typeof body.user.id !== "string") {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+}
+
+// src/modules/auth/queries.ts
+var CREATE_DEMO_USER_MUTATION = `
+  mutation CreateDemoUser($username: String) {
+    createDemoUser(username: $username) {
+      token
+      user {
+        id
+        username
+        wallet_address
+        balance
+        is_demo
+      }
+    }
+  }
+`;
+var USER_LOGIN_MUTATION = `
+  mutation UserLogin($input: LoginInput!) {
+    userLogin(input: $input) {
+      accessToken
+      user {
+        id
+        agencyUid
+        name
+        currency
+        defaultWallet {
+          id
+          amount
+          currency
+          isEnable
+        }
+      }
+    }
+  }
+`;
+
+// src/modules/auth/index.ts
+var AuthModule = class {
+  #rest;
+  #graphql;
+  #graphqlUser;
+  #setToken;
+  #agencyId;
+  #onLoginSuccess;
+  #onLogout;
+  constructor(deps) {
+    this.#rest = deps.rest;
+    this.#graphql = deps.graphql;
+    this.#graphqlUser = deps.graphqlUser;
+    this.#setToken = deps.setToken;
+    this.#agencyId = deps.agencyId;
+    this.#onLoginSuccess = deps.onLoginSuccess;
+    this.#onLogout = deps.onLogout;
+  }
+  /** @deprecated REST auth endpoints are being retired; use `loginWithSession` instead. */
+  async loginWithGoogle(idToken) {
+    const body = {
+      id_token: idToken,
+      aid: this.#agencyId
+    };
+    const response = await this.#rest.post("/auth/google", body);
+    validateLoginBody(response);
+    const result = normaliseGoogleResponse(response);
+    this.#setToken(result.accessToken, { isDemo: false });
+    if (this.#onLoginSuccess) {
+      try {
+        await this.#onLoginSuccess();
+      } catch {
+      }
+    }
+    return result;
+  }
+  /** @deprecated REST auth endpoints are being retired; use `loginWithSession` or `createDemoUser` instead. */
+  async demoLogin(username) {
+    const body = username !== void 0 ? { aid: this.#agencyId, username } : { aid: this.#agencyId };
+    const response = await this.#rest.post("/demo-login", body);
+    validateLoginBody(response);
+    const result = normaliseDemoResponse(response);
+    this.#setToken(result.accessToken, { isDemo: true });
+    if (this.#onLoginSuccess) {
+      try {
+        await this.#onLoginSuccess();
+      } catch {
+      }
+    }
+    return result;
+  }
+  async createDemoUser(username, opts) {
+    const variables = username !== void 0 ? { username } : {};
+    const body = await this.#graphql.request(
+      CREATE_DEMO_USER_MUTATION,
+      variables,
+      opts
+    );
+    const result = normaliseCreateDemoUserResponse(body);
+    this.#setToken(result.accessToken, { isDemo: true });
+    if (this.#onLoginSuccess) {
+      try {
+        await this.#onLoginSuccess();
+      } catch {
+      }
+    }
+    return result;
+  }
+  async loginWithSession(sessionToken, opts) {
+    const variables = { input: { sessionToken, agencyId: this.#agencyId } };
+    const body = await this.#graphqlUser.request(
+      USER_LOGIN_MUTATION,
+      variables,
+      opts
+    );
+    const result = normaliseUserLoginResponse(body);
+    this.#setToken(result.accessToken, { isDemo: false });
+    if (this.#onLoginSuccess) {
+      try {
+        await this.#onLoginSuccess();
+      } catch {
+      }
+    }
+    return result;
+  }
+  async logout() {
+    this.#setToken(null);
+    if (this.#onLogout) {
+      try {
+        await this.#onLogout();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/modules/bid/normalise.ts
+var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "win", "lose", "cancelled"]);
+var PAST_TENSE_MAP = {
+  won: "win",
+  lost: "lose"
+};
+function coerceStatus(raw) {
+  if (VALID_STATUSES.has(raw)) return raw;
+  const mapped = PAST_TENSE_MAP[raw];
+  if (mapped) return mapped;
+  console.warn(`Unknown bid status "${raw}", defaulting to "pending"`);
+  return "pending";
+}
+function normaliseBid(node) {
+  if (typeof node.id !== "string" || node.id === "" || typeof node.user_id !== "string" || node.user_id === "" || typeof node.game_id !== "string" || node.game_id === "" || typeof node.status !== "string" || node.status === "") {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return {
+    id: node.id,
+    userId: node.user_id,
+    gameId: node.game_id,
+    currency: node.currency,
+    amount: node.amount,
+    coefficient: node.coefficient,
+    time1: node.time1,
+    time2: node.time2,
+    price1: node.price1,
+    price2: node.price2,
+    status: coerceStatus(node.status),
+    payout: node.payout || null,
+    slippage: node.slippage,
+    createdAt: node.created_at || null
+  };
+}
+function normaliseBids(list) {
+  if (!Array.isArray(list)) {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return list.map(normaliseBid);
+}
+
+// src/modules/bid/queries.ts
+var PLACE_BID_MUTATION = `mutation PlaceBid($input: PlaceBidInput!) {
+  placeBid(input: $input) {
+    id user_id game_id currency amount coefficient time1 time2 price1 price2 status payout slippage created_at
+  }
+}`;
+var MY_BIDS_QUERY = `query MyBids($status: String, $limit: Int, $offset: Int, $gameId: ID) {
+  myBids(status: $status, limit: $limit, offset: $offset, gameId: $gameId) {
+    id user_id game_id currency amount coefficient time1 time2 price1 price2 status payout slippage created_at
+  }
+}`;
+var CANCEL_BID_MUTATION = `mutation CancelBid($input: CancelBidInput!) {
+  cancelBid(input: $input) {
+    bid { id user_id game_id currency amount coefficient time1 time2 price1 price2 status cancelled payout slippage created_at }
+    refund_amount
+    new_balance
+  }
+}`;
+
+// src/modules/bid/classifiers.ts
+var isPending = (bid) => bid.status === "pending";
+var isTerminal = (bid) => bid.status !== "pending";
+var isWin = (bid) => bid.status === "win";
+var isLoss = (bid) => bid.status === "lose";
+var isCancelled = (bid) => bid.status === "cancelled";
+
+// src/modules/bid/index.ts
+var BidModule = class {
+  #graphql;
+  constructor(deps) {
+    this.#graphql = deps.graphql;
+  }
+  async placeBid(input, opts) {
+    const variables = {
+      input: {
+        game_id: input.gameId,
+        // wallet_id is forwarded as-is — grid-api enforces ownership +
+        // currency validation. See openspec/bid-260518-wallet-id D1/D8.
+        wallet_id: input.walletId,
+        time1: input.time1,
+        time2: input.time2,
+        price1: input.price1,
+        price2: input.price2,
+        coefficient: input.coefficient,
+        amount: input.amount,
+        slippage: input.slippage
+      }
+    };
+    try {
+      const body = await this.#graphql.request(
+        PLACE_BID_MUTATION,
+        variables,
+        opts
+      );
+      return normaliseBid(body.placeBid);
+    } catch (err) {
+      if (err instanceof TaphubValidationError && err.code === "NotExist") {
+        throw new TaphubValidationError("Game not found", {
+          code: "GameNotFound",
+          details: { gameId: input.gameId }
+        });
+      }
+      throw err;
+    }
+  }
+  async cancelBid(bidId, opts) {
+    const body = await this.#graphql.request(
+      CANCEL_BID_MUTATION,
+      { input: { bid_id: bidId } },
+      opts
+    );
+    const { bid, refund_amount, new_balance } = body.cancelBid;
+    return {
+      bid: normaliseBid(bid),
+      refundAmount: refund_amount,
+      newBalance: new_balance
+    };
+  }
+  async listBids(opts) {
+    const variables = {};
+    if (opts?.status !== void 0) {
+      variables.status = opts.status;
+    }
+    if (opts?.limit !== void 0) {
+      variables.limit = opts.limit;
+    }
+    if (opts?.offset !== void 0) {
+      variables.offset = opts.offset;
+    }
+    if (opts?.gameId !== void 0) {
+      variables.gameId = opts.gameId;
+    }
+    const body = await this.#graphql.request(
+      MY_BIDS_QUERY,
+      variables,
+      opts?.signal ? { signal: opts.signal } : void 0
+    );
+    return normaliseBids(body.myBids);
+  }
+};
+
+// src/modules/game/normalise.ts
+function normaliseGame(node) {
+  if (typeof node.id !== "string" || node.id === "" || typeof node.pair !== "string" || node.pair === "" || typeof node.status !== "string" || node.status === "" || !node.config) {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return {
+    id: node.id,
+    pair: node.pair,
+    status: node.status,
+    config: normaliseGameConfig(node.config),
+    createdAt: node.created_at || null
+  };
+}
+function normaliseGameConfig(node) {
+  return {
+    gridConfig: normaliseGridConfig(node.gridConfig),
+    constraints: normaliseConstraints(node.constraints),
+    acceptableBids: node.acceptableBids,
+    minBidAmount: node.minBidAmount,
+    maxBidAmount: node.maxBidAmount
+  };
+}
+function normaliseGridConfig(node) {
+  return {
+    cellSizeTime: node.cellSizeTime,
+    cellSizeValue: node.cellSizeValue,
+    candleSize: node.candleSize,
+    baseline: node.baseline,
+    baselineTime: node.baselineTime
+  };
+}
+function normaliseConstraints(node) {
+  return {
+    minBetTime: node.minBetTime,
+    maxBetTime: node.maxBetTime,
+    slippage: node.slippage,
+    priceMinRange: node.priceMinRange,
+    priceMaxRange: node.priceMaxRange,
+    coefMults: node.coefMults,
+    maxCoef: node.maxCoef
+  };
+}
+function normaliseCandles(list) {
+  if (!Array.isArray(list)) {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return list.map((c) => ({
+    time: c.time,
+    o: c.o,
+    h: c.h,
+    l: c.l,
+    c: c.c,
+    volatility: c.volatility,
+    coefMults: c.coefMults
+  }));
+}
+function normaliseGamePairInfo(node) {
+  if (typeof node.id !== "string" || node.id === "" || typeof node.pair !== "string" || node.pair === "") {
+    throw new TaphubServerError("Invalid response from server", { code: "InvalidResponse" });
+  }
+  return {
+    id: node.id,
+    pair: node.pair,
+    gameplayId: node.gameplayId,
+    gameplayName: node.gameplayName,
+    source: node.source,
+    gameId: node.gameId ?? null
+  };
+}
+
+// src/modules/game/queries.ts
+var GAME_QUERY = `query Game($pair: String!, $gameplaySlug: String) {
+  game(pair: $pair, gameplaySlug: $gameplaySlug) {
+    id pair status created_at
+    config {
+      gridConfig { cellSizeTime cellSizeValue candleSize baseline baselineTime }
+      constraints { minBetTime maxBetTime slippage priceMinRange priceMaxRange coefMults maxCoef }
+      acceptableBids minBidAmount maxBidAmount
+    }
+  }
+}`;
+var CHART_HISTORY_QUERY = `query ChartHistory($gameId: ID!, $limit: Int) {
+  chartHistory(gameId: $gameId, limit: $limit) {
+    time o h l c volatility coefMults
+  }
+}`;
+var BUILDER_AVAILABLE_GAME_PAIRS_QUERY = `query BuilderAvailableGamePairs($gameplayId: ID) {
+  builderAvailableGamePairs(gameplayId: $gameplayId) {
+    id
+    pair
+    gameplayId
+    gameplayName
+    source
+    gameId
+  }
+}`;
+
+// src/modules/game/index.ts
+var GameModule = class {
+  #graphql;
+  constructor(deps) {
+    this.#graphql = deps.graphql;
+  }
+  async get(pair, opts) {
+    const variables = { pair };
+    if (opts?.gameplaySlug) variables.gameplaySlug = opts.gameplaySlug;
+    let body;
+    try {
+      body = await this.#graphql.request(GAME_QUERY, variables, opts);
+    } catch (err) {
+      if (err instanceof TaphubValidationError && err.code === "NotExist") {
+        throw new TaphubValidationError("Game not found for pair", {
+          code: "GameNotFound",
+          details: { pair }
+        });
+      }
+      throw err;
+    }
+    if (body.game === null) {
+      throw new TaphubValidationError("Game not found for pair", {
+        code: "GameNotFound",
+        details: { pair }
+      });
+    }
+    return normaliseGame(body.game);
+  }
+  /**
+   * Returns available game pairs, optionally filtered by gameplay.
+   *
+   * When called with a valid JWT (authenticated builder), each entry includes
+   * `gameId` — use it directly as the MQTT topic `game/{gameId}/candle`.
+   *
+   * @example
+   * const pairs = await client.game.availableGamePairs({ gameplayId: 'taptrading' });
+   * const game  = await client.game.get(pairs[0].pair, { gameplaySlug: pairs[0].gameplayId });
+   * const ch    = client.realtime?.subscribe(pairs[0].gameId ?? game.id, userId);
+   */
+  async availableGamePairs(opts) {
+    const variables = {};
+    if (opts?.gameplayId) variables.gameplayId = opts.gameplayId;
+    const body = await this.#graphql.request(
+      BUILDER_AVAILABLE_GAME_PAIRS_QUERY,
+      variables,
+      opts
+    );
+    return body.builderAvailableGamePairs.map(normaliseGamePairInfo);
+  }
+  async chartHistory(gameId, limit, opts) {
+    const variables = { gameId };
+    if (limit !== void 0) {
+      variables.limit = limit;
+    }
+    const body = await this.#graphql.request(
+      CHART_HISTORY_QUERY,
+      variables,
+      opts
+    );
+    return normaliseCandles(body.chartHistory);
+  }
+};
+
+// src/modules/leaderboard/normalise.ts
+function normaliseLeaderboard(rows) {
+  if (!Array.isArray(rows)) {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return rows.map((row) => ({
+    userId: row.user_id,
+    username: row.username,
+    rank: row.rank,
+    totalBids: row.total_bids,
+    totalWins: row.total_wins,
+    totalWagered: row.total_wagered,
+    totalPayout: row.total_payout,
+    gain: row.gain
+  }));
+}
+
+// src/modules/leaderboard/queries.ts
+var LEADERBOARD_QUERY = `query Leaderboard($period: String!, $sort_by: String!) {
+  leaderboard(period: $period, sort_by: $sort_by) {
+    user_id username rank total_bids total_wins total_wagered total_payout gain
+  }
+}`;
+
+// src/modules/leaderboard/index.ts
+var LeaderboardModule = class {
+  #graphql;
+  constructor(deps) {
+    this.#graphql = deps.graphql;
+  }
+  async list(args) {
+    const body = await this.#graphql.request(
+      LEADERBOARD_QUERY,
+      { period: args.period, sort_by: args.sortBy },
+      args.signal ? { signal: args.signal } : void 0
+    );
+    return normaliseLeaderboard(body.leaderboard);
+  }
+};
+
+// src/modules/locale/normalise.ts
+function normaliseLocaleResponse(node) {
+  let translations = null;
+  if (node.translations !== null) {
+    try {
+      translations = JSON.parse(node.translations);
+    } catch (err) {
+      throw new TaphubValidationError("Malformed translations JSON string from backend", {
+        code: "InvalidLocaleResponse",
+        details: {
+          lang: node.lang,
+          version: node.version,
+          parseError: err instanceof Error ? err.message : String(err)
+        }
+      });
+    }
+  }
+  return {
+    lang: node.lang,
+    version: node.version,
+    notModified: node.notModified,
+    translations
+  };
+}
+function normaliseRefreshLocalesPayload(node) {
+  let versions;
+  try {
+    versions = JSON.parse(node.versions);
+  } catch (err) {
+    throw new TaphubValidationError("Malformed versions JSON string from backend", {
+      code: "InvalidRefreshLocalesPayload",
+      details: {
+        parseError: err instanceof Error ? err.message : String(err)
+      }
+    });
+  }
+  return {
+    refreshed: node.refreshed,
+    versions
+  };
+}
+
+// src/modules/locale/queries.ts
+var LOCALES_QUERY = `query Locales($input: LocalesInput!) {
+  locales(input: $input) {
+    lang
+    version
+    notModified
+    translations
+  }
+}`;
+var REFRESH_LOCALES_MUTATION = `mutation RefreshLocales {
+  refreshLocales {
+    refreshed
+    versions
+  }
+}`;
+
+// src/modules/locale/index.ts
+var LocaleModule = class {
+  #graphql;
+  constructor(deps) {
+    this.#graphql = deps.graphql;
+  }
+  /**
+   * Fetch translations for a single language.
+   *
+   * Pass the last-seen `version` as `knownVersion` to opt into not-modified
+   * short-circuit semantics: backend returns `{notModified: true, translations: null}`
+   * when the cached body still matches, and the caller keeps prior state.
+   *
+   * Errors surface as TaphubError subclasses with `extensions.code` codes from
+   * the backend (e.g. `LangNotSupported`, `InsufficientUpstream`, `FeatureDisabled`).
+   * Caller decides the fallback strategy.
+   */
+  async get(lang, knownVersion, opts) {
+    const input = { lang };
+    if (knownVersion !== void 0 && knownVersion !== "") {
+      input.knownVersion = knownVersion;
+    }
+    const body = await this.#graphql.request(LOCALES_QUERY, { input }, opts);
+    return normaliseLocaleResponse(body.locales);
+  }
+  /**
+   * Trigger an admin refresh — backend re-pulls the source Sheet, invalidates
+   * its cache, and writes fresh entries for every supported language.
+   *
+   * Requires `X-API-Key` header equal to backend `InternalApiKey`. The transport
+   * layer is responsible for attaching the header; this method does not handle
+   * auth concerns directly.
+   */
+  async refresh(opts) {
+    const body = await this.#graphql.request(
+      REFRESH_LOCALES_MUTATION,
+      {},
+      opts
+    );
+    return normaliseRefreshLocalesPayload(body.refreshLocales);
+  }
+};
+
+// src/transport/mqtt/index.ts
+import mqtt from "mqtt";
+var GAME_SCOPED_SUFFIXES = ["candle", "config", "ideal_config"];
+var USER_SCOPED_SUFFIXES = ["bid_result", "balance_update"];
+var TOPIC_PREFIX = "game";
+function topicFor(gameId, suffix, userId) {
+  if (USER_SCOPED_SUFFIXES.includes(suffix)) {
+    return `${TOPIC_PREFIX}/${gameId}/user/${userId}/${suffix}`;
+  }
+  return `${TOPIC_PREFIX}/${gameId}/${suffix}`;
+}
+function normaliseUserId(userId) {
+  return userId && userId !== "" ? userId : null;
+}
+function userScopedTopicsFor(gameId, userId) {
+  return USER_SCOPED_SUFFIXES.map((s) => topicFor(gameId, s, userId));
+}
+function subKey(gameId, userId) {
+  return `${gameId}::${userId ?? ""}`;
+}
+function createMqttTransport(endpoint, opts = {}) {
+  let client = null;
+  const subscriptions = /* @__PURE__ */ new Map();
+  const { onLifecycle } = opts;
+  let connectStartedAt = 0;
+  function fireLifecycle(event) {
+    if (!onLifecycle) return;
+    try {
+      onLifecycle(event);
+    } catch {
+    }
+  }
+  function ensureConnected() {
+    if (client) return client;
+    connectStartedAt = Date.now();
+    client = mqtt.connect(endpoint, {
+      clean: true,
+      reconnectPeriod: 2e3,
+      connectTimeout: 1e4,
+      keepalive: 6
+    });
+    let lastPingreqAt = 0;
+    client.on("packetsend", (packet) => {
+      if (packet.cmd === "pingreq") {
+        lastPingreqAt = Date.now();
+      }
+    });
+    client.on("packetreceive", (packet) => {
+      if (packet.cmd === "pingresp" && lastPingreqAt > 0) {
+        const rttMs = Date.now() - lastPingreqAt;
+        lastPingreqAt = 0;
+        fireLifecycle({ kind: "ping", rttMs });
+      }
+    });
+    client.on("connect", () => {
+      fireLifecycle({ kind: "connect", rttMs: Date.now() - connectStartedAt });
+    });
+    client.on("reconnect", () => {
+      const rttMs = Date.now() - connectStartedAt;
+      connectStartedAt = Date.now();
+      fireLifecycle({ kind: "reconnect", rttMs });
+    });
+    client.on("close", () => {
+      fireLifecycle({ kind: "disconnect" });
+    });
+    client.on("error", (err) => {
+      fireLifecycle({ kind: "error", err });
+    });
+    client.on("message", (receivedTopic, message) => {
+      let matched;
+      for (const sub of subscriptions.values()) {
+        if (sub.topics.includes(receivedTopic)) {
+          matched = sub;
+          break;
+        }
+      }
+      if (!matched) return;
+      let payload;
+      try {
+        payload = JSON.parse(message.toString());
+      } catch {
+        matched.onError(new Error(`Invalid JSON on topic ${receivedTopic}`));
+        return;
+      }
+      matched.onMessage(matched.gameId, receivedTopic, payload);
+    });
+    return client;
+  }
+  function entriesForGame(gameId) {
+    const out = [];
+    for (const sub of subscriptions.values()) {
+      if (sub.gameId === gameId) out.push(sub);
+    }
+    return out;
+  }
+  return {
+    subscribe(gameId, userId, onMessage, onError) {
+      const cleanUserId = normaliseUserId(userId);
+      const key = subKey(gameId, cleanUserId);
+      if (subscriptions.has(key)) return;
+      const mqttClient = ensureConnected();
+      const fullTopics = [
+        ...GAME_SCOPED_SUFFIXES.map((s) => topicFor(gameId, s)),
+        ...cleanUserId ? userScopedTopicsFor(gameId, cleanUserId) : []
+      ];
+      subscriptions.set(key, {
+        gameId,
+        topics: fullTopics,
+        userId: cleanUserId,
+        onMessage,
+        onError
+      });
+      for (const t of fullTopics) {
+        mqttClient.subscribe(t, { qos: t.endsWith("candle") ? 0 : 1 });
+      }
+    },
+    unsubscribeAll(gameId, userId) {
+      const matches = entriesForGame(gameId);
+      if (matches.length === 0) return;
+      let target;
+      if (userId !== void 0) {
+        const cleanUserId = normaliseUserId(userId);
+        target = matches.find((m) => m.userId === cleanUserId);
+        if (!target) return;
+      } else if (matches.length === 1) {
+        target = matches[0];
+      } else {
+        const activeUserIds = matches.map((m) => m.userId ?? "<anonymous>");
+        throw new TaphubError(
+          `Ambiguous unsubscribe for gameId='${gameId}': multiple active userIds (${activeUserIds.join(", ")}). Pass userId explicitly to disambiguate.`,
+          { code: "AmbiguousUnsubscribe", details: { gameId, activeUserIds } }
+        );
+      }
+      if (client) {
+        for (const t of target.topics) {
+          client.unsubscribe(t);
+        }
+      }
+      subscriptions.delete(subKey(target.gameId, target.userId));
+    },
+    close() {
+      if (client) {
+        for (const sub of subscriptions.values()) {
+          for (const t of sub.topics) {
+            client.unsubscribe(t);
+          }
+        }
+      }
+      subscriptions.clear();
+      if (client) {
+        client.end(true);
+        client = null;
+      }
+    }
+  };
+}
+
+// src/modules/realtime/index.ts
+import EventEmitter2 from "eventemitter3";
+
+// src/modules/realtime/GameChannel.ts
+import EventEmitter from "eventemitter3";
+var GameChannel = class extends EventEmitter {
+  gameId;
+  constructor(gameId) {
+    super();
+    this.gameId = gameId;
+  }
+};
+
+// src/modules/realtime/index.ts
+var TOPIC_SUFFIX_CANDLE = "candle";
+var TOPIC_SUFFIX_BID_RESULT = "bid_result";
+var TOPIC_SUFFIX_BALANCE_UPDATE = "balance_update";
+var TOPIC_SUFFIX_CONFIG = "config";
+var TOPIC_SUFFIX_IDEAL_CONFIG = "ideal_config";
+function mapWireCandle(raw) {
+  const p = raw;
+  const c = p.candle ?? p;
+  const result = {
+    type: p.type,
+    time: c.time,
+    o: c.o,
+    h: c.h,
+    l: c.l,
+    c: c.c
+  };
+  if (c.volatility !== void 0) result.volatility = c.volatility;
+  if (c.coef_mults !== void 0) result.coefMults = c.coef_mults;
+  if (c.coefMults !== void 0) result.coefMults = c.coefMults;
+  return result;
+}
+function mapWireBidResult(raw) {
+  const p = raw;
+  switch (p.type) {
+    case "accepted": {
+      const data = {
+        bid: p.bid
+      };
+      if (typeof p.balance === "string") data.balance = p.balance;
+      return { event: "bidAccepted", data };
+    }
+    case "won": {
+      const data = {
+        bidId: p.bidId,
+        payout: p.payout,
+        userId: p.user_id
+      };
+      if (typeof p.balance === "string") data.balance = p.balance;
+      return { event: "bidWon", data };
+    }
+    case "lost": {
+      return {
+        event: "bidLost",
+        data: { bidId: p.bidId }
+      };
+    }
+    default:
+      console.warn(`Unknown bid_result type "${String(p.type)}"`);
+      return null;
+  }
+}
+function mapWireBalanceUpdate(raw) {
+  const p = raw;
+  return {
+    userId: p.userId,
+    balance: p.balance
+  };
+}
+function mapWireConfig(raw) {
+  const p = raw;
+  return {
+    minBidAmount: p.min_bid_amount,
+    maxBidAmount: p.max_bid_amount,
+    acceptableBids: p.acceptable_bids
+  };
+}
+function mapWireIdealConfig(raw) {
+  const p = raw;
+  return {
+    cellSizeValue: p.cellSizeValue,
+    currentPrice: p.currentPrice,
+    reason: p.reason ?? "volatility_shift"
+  };
+}
+function mapWireToEvent(topic, payload) {
+  if (topic.endsWith(`/${TOPIC_SUFFIX_CANDLE}`)) {
+    return { event: "candle", data: mapWireCandle(payload) };
+  }
+  if (topic.endsWith(`/${TOPIC_SUFFIX_BID_RESULT}`)) {
+    return mapWireBidResult(payload);
+  }
+  if (topic.endsWith(`/${TOPIC_SUFFIX_BALANCE_UPDATE}`)) {
+    return { event: "balanceUpdate", data: mapWireBalanceUpdate(payload) };
+  }
+  if (topic.endsWith(`/${TOPIC_SUFFIX_IDEAL_CONFIG}`)) {
+    return { event: "idealConfigUpdate", data: mapWireIdealConfig(payload) };
+  }
+  if (topic.endsWith(`/${TOPIC_SUFFIX_CONFIG}`)) {
+    return { event: "configUpdate", data: mapWireConfig(payload) };
+  }
+  return null;
+}
+function normaliseUserId2(userId) {
+  return userId && userId !== "" ? userId : null;
+}
+function subKey2(gameId, userId) {
+  return `${gameId}::${userId ?? ""}`;
+}
+var RealtimeModule = class extends EventEmitter2 {
+  #transport;
+  #entries = /* @__PURE__ */ new Map();
+  constructor(mqttEndpointOrOptions) {
+    super();
+    if (typeof mqttEndpointOrOptions === "string") {
+      this.#transport = createMqttTransport(mqttEndpointOrOptions);
+    } else {
+      this.#transport = mqttEndpointOrOptions.transport ?? createMqttTransport(mqttEndpointOrOptions.mqttEndpoint, {
+        onLifecycle: mqttEndpointOrOptions.onMqttLifecycle
+      });
+    }
+  }
+  /** @internal Access transport for testing */
+  get _transport() {
+    return this.#transport;
+  }
+  subscribe(gameId, userId) {
+    const cleanUserId = normaliseUserId2(userId);
+    const key = subKey2(gameId, cleanUserId);
+    const existing = this.#entries.get(key);
+    if (existing) {
+      existing.refcount += 1;
+      return existing.channel;
+    }
+    const channel = new GameChannel(gameId);
+    const onMessage = (_gid, topic, payload) => {
+      const mapped = mapWireToEvent(topic, payload);
+      if (mapped) {
+        if (mapped.event === "candle") channel.emit("candle", mapped.data);
+        else if (mapped.event === "bidAccepted") channel.emit("bidAccepted", mapped.data);
+        else if (mapped.event === "bidWon") channel.emit("bidWon", mapped.data);
+        else if (mapped.event === "bidLost") channel.emit("bidLost", mapped.data);
+        else if (mapped.event === "balanceUpdate") channel.emit("balanceUpdate", mapped.data);
+        else if (mapped.event === "configUpdate") channel.emit("configUpdate", mapped.data);
+        else if (mapped.event === "idealConfigUpdate")
+          channel.emit("idealConfigUpdate", mapped.data);
+      }
+    };
+    const onError = (err) => {
+      channel.emit("error", err);
+    };
+    this.#entries.set(key, {
+      gameId,
+      userId: cleanUserId,
+      channel,
+      refcount: 1,
+      onMessage,
+      onError
+    });
+    this.#transport.subscribe(gameId, cleanUserId, onMessage, onError);
+    return channel;
+  }
+  unsubscribe(gameId, userId) {
+    const matches = [];
+    for (const entry of this.#entries.values()) {
+      if (entry.gameId === gameId) matches.push(entry);
+    }
+    if (matches.length === 0) return;
+    let target;
+    if (userId !== void 0) {
+      const cleanUserId = normaliseUserId2(userId);
+      target = matches.find((m) => m.userId === cleanUserId);
+      if (!target) return;
+    } else if (matches.length === 1) {
+      target = matches[0];
+    } else {
+      const activeUserIds = matches.map((m) => m.userId ?? "<anonymous>");
+      throw new TaphubError(
+        `Ambiguous unsubscribe for gameId='${gameId}': multiple active userIds (${activeUserIds.join(", ")}). Pass userId explicitly to disambiguate.`,
+        { code: "AmbiguousUnsubscribe", details: { gameId, activeUserIds } }
+      );
+    }
+    target.refcount -= 1;
+    if (target.refcount > 0) return;
+    const key = subKey2(target.gameId, target.userId);
+    this.#entries.delete(key);
+    target.channel.removeAllListeners();
+    this.#transport.unsubscribeAll(gameId, target.userId);
+  }
+  disconnect() {
+    for (const entry of this.#entries.values()) {
+      entry.channel.removeAllListeners();
+    }
+    this.#entries.clear();
+    this.#transport.close();
+  }
+};
+
+// src/modules/user/normalise.ts
+function normaliseMeResponse(body) {
+  const me = body.me;
+  if (typeof me.id !== "string" || me.id === "" || typeof me.username !== "string" || me.username === "" || typeof me.balance !== "string" || me.balance === "" || typeof me.is_demo !== "boolean") {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  const walletAddress = me.wallet_address || null;
+  return {
+    id: me.id,
+    username: me.username,
+    walletAddress,
+    balance: me.balance,
+    isDemo: me.is_demo
+  };
+}
+function normaliseCurrencies(body) {
+  if (!Array.isArray(body)) {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return body.map((entry) => ({
+    code: entry.code,
+    unit: entry.unit,
+    unitSymbol: entry.unit_symbol
+  }));
+}
+function normaliseWalletNode(node) {
+  if (node === null || typeof node !== "object") {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  const w = node;
+  if (typeof w.id !== "string" || w.id === "" || typeof w.amount !== "string" || w.amount === "" || typeof w.currency !== "string" || w.currency === "" || typeof w.isEnable !== "boolean") {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return {
+    id: w.id,
+    amount: w.amount,
+    currency: w.currency,
+    isEnable: w.isEnable
+  };
+}
+function normaliseMyWalletsResponse(body) {
+  if (!body || !Array.isArray(body.myWallets)) {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return body.myWallets.map(normaliseWalletNode);
+}
+function normaliseMyWalletByCurrencyResponse(body) {
+  if (!body) {
+    throw new TaphubServerError("Invalid response from server", {
+      code: "InvalidResponse"
+    });
+  }
+  return normaliseWalletNode(body.myWalletByCurrency);
+}
+
+// src/modules/user/queries.ts
+var ME_QUERY = "query Me { me { id username wallet_address balance is_demo } }";
+var MY_WALLETS_QUERY = "query MyWallets { myWallets { id amount currency isEnable } }";
+var MY_WALLET_BY_CURRENCY_QUERY = "query MyWalletByCurrency($currency: String!) { myWalletByCurrency(currency: $currency) { id amount currency isEnable } }";
+
+// src/modules/user/index.ts
+var UserModule = class {
+  #rest;
+  #graphql;
+  #graphqlUser;
+  #currencies = null;
+  constructor(deps) {
+    this.#rest = deps.rest;
+    this.#graphql = deps.graphql;
+    this.#graphqlUser = deps.graphqlUser;
+  }
+  async me() {
+    const body = await this.#graphql.request(ME_QUERY);
+    return normaliseMeResponse(body);
+  }
+  async wallets(opts) {
+    const body = await this.#graphqlUser.request(
+      MY_WALLETS_QUERY,
+      void 0,
+      opts
+    );
+    return normaliseMyWalletsResponse(body);
+  }
+  async walletByCurrency(currency, opts) {
+    const body = await this.#graphqlUser.request(
+      MY_WALLET_BY_CURRENCY_QUERY,
+      { currency },
+      opts
+    );
+    return normaliseMyWalletByCurrencyResponse(body);
+  }
+  get currencies() {
+    return this.#currencies;
+  }
+  async refreshCurrencies() {
+    const body = await this.#rest.post("/currency/list-enable");
+    const currencies = normaliseCurrencies(body);
+    this.#currencies = currencies;
+    return currencies;
+  }
+  clearCurrencies() {
+    this.#currencies = null;
+  }
+};
+
+// src/network/classify.ts
+var TIMEOUT_MS = 15e3;
+function isAbortError(err) {
+  if (err === null || err === void 0) return false;
+  if (typeof err !== "object") return false;
+  const name = err.name;
+  return name === "AbortError";
+}
+var EMPTY_GQL_ERRORS = (errors) => !errors || Array.isArray(errors) && errors.length === 0;
+function classifyHttpOutcome(outcome, ctx) {
+  if (outcome.onlineHint === false) {
+    return {
+      ts: ctx.now,
+      rtt: Number.POSITIVE_INFINITY,
+      source: ctx.source,
+      reason: "offline"
+    };
+  }
+  if (outcome.rtt > TIMEOUT_MS) {
+    return {
+      ts: ctx.now,
+      rtt: TIMEOUT_MS,
+      source: ctx.source,
+      reason: "timeout"
+    };
+  }
+  const status = outcome.httpStatus;
+  if (status !== null && status !== void 0) {
+    if (status >= 500) {
+      return { ts: ctx.now, rtt: outcome.rtt, source: ctx.source, reason: "backend5xx" };
+    }
+    if (status >= 400) {
+      return { ts: ctx.now, rtt: outcome.rtt, source: ctx.source, reason: "backend4xx" };
+    }
+    if (!EMPTY_GQL_ERRORS(outcome.gqlErrors)) {
+      return { ts: ctx.now, rtt: outcome.rtt, source: ctx.source, reason: "gqlError" };
+    }
+    return { ts: ctx.now, rtt: outcome.rtt, source: ctx.source, reason: "ok" };
+  }
+  if (outcome.threw) {
+    return {
+      ts: ctx.now,
+      rtt: outcome.rtt,
+      source: ctx.source,
+      reason: "network"
+    };
+  }
+  return { ts: ctx.now, rtt: outcome.rtt, source: ctx.source, reason: "ok" };
+}
+function classifyBackendHealth(samples) {
+  const httpSamples = samples.filter((s) => s.source === "graphql" || s.source === "rest");
+  if (httpSamples.length === 0) return "ok";
+  const total = httpSamples.length;
+  const fiveXxCount = httpSamples.filter((s) => s.reason === "backend5xx").length;
+  const fiveXxRate = fiveXxCount / total;
+  if (fiveXxRate >= 0.5) return "down";
+  if (fiveXxRate >= 0.2) return "degraded";
+  const gqlSamples = httpSamples.filter((s) => s.source === "graphql");
+  if (gqlSamples.length > 0) {
+    const gqlErrorRate = gqlSamples.filter((s) => s.reason === "gqlError").length / gqlSamples.length;
+    if (gqlErrorRate >= 0.3) return "degraded";
+  }
+  return "ok";
+}
+var isPoor = (m) => m.rtt > 450 || m.jitter > 150 || m.lossRate > 0.05;
+var canLeavePoor = (m) => m.rtt < 350 && m.jitter < 120 && m.lossRate < 0.03;
+var isFairUpper = (rtt) => rtt > 180;
+var canReachGood = (rtt) => rtt < 120;
+function classifyNetworkLevel(metrics, current) {
+  if (current === "offline") {
+    return isPoor(metrics) ? "poor" : "fair";
+  }
+  if (current === "good") {
+    if (isPoor(metrics)) return "fair";
+    if (isFairUpper(metrics.rtt)) return "fair";
+    return "good";
+  }
+  if (current === "fair") {
+    if (isPoor(metrics)) return "poor";
+    if (canReachGood(metrics.rtt)) return "good";
+    return "fair";
+  }
+  if (canLeavePoor(metrics)) return "fair";
+  return "poor";
+}
+
+// src/network/RttSmoother.ts
+var EMA_ALPHA = 0.25;
+var OUTLIER_MULTIPLIER = 3;
+var DEBOUNCE_DEGRADE = 2;
+var DEBOUNCE_IMPROVE = 5;
+var LEVEL_RANK = {
+  good: 0,
+  fair: 1,
+  poor: 2,
+  offline: 3
+};
+var RttSmoother = class {
+  ema = 0;
+  level = "good";
+  committed = "good";
+  candidate = "good";
+  candidateCount = 0;
+  overrideOffline = false;
+  consecutiveOutliers = 0;
+  add(rtt, metrics) {
+    if (this.ema > 0 && rtt > OUTLIER_MULTIPLIER * this.ema) {
+      this.consecutiveOutliers += 1;
+      if (this.consecutiveOutliers < 2) return;
+    } else {
+      this.consecutiveOutliers = 0;
+    }
+    this.ema = this.ema === 0 ? rtt : EMA_ALPHA * rtt + (1 - EMA_ALPHA) * this.ema;
+    const next = classifyNetworkLevel(
+      { rtt, jitter: metrics.jitter, lossRate: metrics.lossRate },
+      this.committed
+    );
+    if (next === this.candidate) {
+      this.candidateCount += 1;
+    } else {
+      this.candidate = next;
+      this.candidateCount = 1;
+    }
+    const required = this.requiredSamplesFor(next);
+    if (this.candidateCount >= required) {
+      this.committed = next;
+    }
+    this.level = this.overrideOffline ? "offline" : this.committed;
+  }
+  forceOffline() {
+    this.overrideOffline = true;
+    this.level = "offline";
+  }
+  releaseOffline() {
+    this.overrideOffline = false;
+    this.level = this.committed;
+  }
+  reset() {
+    this.ema = 0;
+    this.committed = "good";
+    this.candidate = "good";
+    this.candidateCount = 0;
+    this.consecutiveOutliers = 0;
+    this.overrideOffline = false;
+    this.level = "good";
+  }
+  requiredSamplesFor(next) {
+    return LEVEL_RANK[next] > LEVEL_RANK[this.committed] ? DEBOUNCE_DEGRADE : DEBOUNCE_IMPROVE;
+  }
+};
+
+// src/network/NetworkQualityMonitor.ts
+var WINDOW_MS = 6e4;
+var WINDOW_MAX_SAMPLES_PER_SOURCE = 30;
+var OFFLINE_HOLD_MS = 1e4;
+var TICK_INTERVAL_MS = 5e3;
+var COLD_START_REAL_SAMPLE_THRESHOLD = 3;
+var EFFECTIVE_TYPE_TO_RTT = {
+  "4g": 80,
+  "3g": 250,
+  "2g": 700,
+  "slow-2g": 1500
+};
+function emptyBuckets() {
+  return { graphql: [], rest: [], mqtt: [], browser: [], connection: [] };
+}
+function isHttpSource(s) {
+  return s === "graphql" || s === "rest";
+}
+var NetworkQualityMonitor = class {
+  bus;
+  buckets = emptyBuckets();
+  smoother = new RttSmoother();
+  mqttConnected = false;
+  mqttDisconnectedAt = null;
+  lastSuccessfulHttpAt = null;
+  committedNetwork = "good";
+  committedBackend = "ok";
+  tickHandle = null;
+  onlineListener = null;
+  offlineListener = null;
+  disposed = false;
+  constructor(opts) {
+    this.bus = opts.bus;
+    this.attachBrowserListeners();
+    this.startTick();
+  }
+  addSample(sample, prevMqttConnectedOverride) {
+    if (this.disposed) return;
+    const bucket = this.buckets[sample.source];
+    bucket.push(sample);
+    if (bucket.length > WINDOW_MAX_SAMPLES_PER_SOURCE) {
+      bucket.shift();
+    }
+    if (sample.source !== "connection" && sample.source !== "browser") {
+      if (sample.reason === "ok") {
+        this.lastSuccessfulHttpAt = sample.ts;
+        this.smoother.add(sample.rtt, this.deriveMetrics());
+      } else if (sample.reason === "network" || sample.reason === "timeout") {
+        this.smoother.add(sample.rtt, this.deriveMetrics());
+      }
+    }
+    this.recompute(prevMqttConnectedOverride);
+  }
+  seedFromConnection(seed) {
+    const rtt = this.resolveSeedRtt(seed);
+    if (rtt === null) return;
+    this.addSample({
+      ts: this.now(),
+      rtt,
+      source: "connection",
+      reason: "ok"
+    });
+  }
+  notifyMqttConnect(rttMs) {
+    const prevMqttConnected = this.mqttConnected;
+    this.mqttConnected = true;
+    this.mqttDisconnectedAt = null;
+    this.addSample(
+      {
+        ts: this.now(),
+        rtt: rttMs,
+        source: "mqtt",
+        reason: "ok"
+      },
+      prevMqttConnected
+    );
+  }
+  notifyMqttDisconnect() {
+    const prevMqttConnected = this.mqttConnected;
+    this.mqttConnected = false;
+    this.mqttDisconnectedAt = this.now();
+    this.recompute(prevMqttConnected);
+  }
+  notifyMqttPing(rttMs) {
+    this.addSample({
+      ts: this.now(),
+      rtt: rttMs,
+      source: "mqtt",
+      reason: "ok"
+    });
+  }
+  subscribe(listener) {
+    const wrapped = ((evt) => {
+      const detail = evt.detail;
+      if (detail) listener(detail);
+    });
+    this.bus.on("network:change", wrapped);
+    return () => this.bus.off("network:change", wrapped);
+  }
+  getCurrent() {
+    this.pruneWindow();
+    return this.snapshot();
+  }
+  reset() {
+    const prev = this.snapshot();
+    for (const key of Object.keys(this.buckets)) {
+      this.buckets[key] = [];
+    }
+    this.smoother.reset();
+    this.mqttConnected = false;
+    this.mqttDisconnectedAt = null;
+    this.lastSuccessfulHttpAt = null;
+    this.committedNetwork = "good";
+    this.committedBackend = "ok";
+    const current = this.snapshot();
+    if (prev.network !== current.network || prev.backend !== current.backend) {
+      this.bus.emit("network:change", { previous: prev, current });
+    }
+  }
+  tick() {
+    this.pruneWindow();
+    this.recompute();
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (this.tickHandle !== null) {
+      clearInterval(this.tickHandle);
+      this.tickHandle = null;
+    }
+    this.detachBrowserListeners();
+  }
+  resolveSeedRtt(seed) {
+    if (typeof seed.rtt === "number" && seed.rtt > 0) return seed.rtt;
+    if (seed.effectiveType && seed.effectiveType in EFFECTIVE_TYPE_TO_RTT) {
+      return EFFECTIVE_TYPE_TO_RTT[seed.effectiveType] ?? null;
+    }
+    return null;
+  }
+  startTick() {
+    if (typeof setInterval === "undefined") return;
+    this.tickHandle = setInterval(() => this.tick(), TICK_INTERVAL_MS);
+  }
+  attachBrowserListeners() {
+    if (typeof globalThis === "undefined") return;
+    const w = globalThis;
+    if (typeof w.addEventListener !== "function") return;
+    this.onlineListener = () => this.tick();
+    this.offlineListener = () => this.tick();
+    try {
+      w.addEventListener("online", this.onlineListener);
+      w.addEventListener("offline", this.offlineListener);
+    } catch {
+      this.onlineListener = null;
+      this.offlineListener = null;
+    }
+  }
+  detachBrowserListeners() {
+    const w = globalThis;
+    if (typeof w.removeEventListener !== "function") return;
+    try {
+      if (this.onlineListener) w.removeEventListener("online", this.onlineListener);
+      if (this.offlineListener) w.removeEventListener("offline", this.offlineListener);
+    } catch {
+    }
+  }
+  pruneWindow() {
+    const cutoff = this.now() - WINDOW_MS;
+    for (const key of Object.keys(this.buckets)) {
+      this.buckets[key] = this.buckets[key].filter((s) => s.ts >= cutoff);
+    }
+  }
+  recompute(prevMqttConnectedOverride) {
+    this.pruneWindow();
+    const prev = this.snapshot();
+    const allSamples = this.allHttpAndMqttSamples();
+    const realSamples = allSamples.filter((s) => s.source !== "connection");
+    const useConnection = realSamples.length < COLD_START_REAL_SAMPLE_THRESHOLD;
+    const effectiveSamples = useConnection ? allSamples : realSamples;
+    const httpSamples = effectiveSamples.filter((s) => isHttpSource(s.source));
+    const backend = classifyBackendHealth(httpSamples);
+    const metrics = this.deriveMetricsFrom(effectiveSamples);
+    const candidate = classifyNetworkLevel(
+      { rtt: metrics.emaForLevel, jitter: metrics.jitter, lossRate: metrics.lossRate },
+      this.committedNetwork
+    );
+    let nextNetwork = this.smoother.level;
+    if (effectiveSamples.length === 0) {
+      nextNetwork = this.committedNetwork;
+    } else if (this.smoother.ema > 0) {
+      nextNetwork = this.smoother.level;
+    } else {
+      nextNetwork = candidate;
+    }
+    if (this.isHardOffline()) {
+      this.smoother.forceOffline();
+      nextNetwork = "offline";
+    } else if (this.smoother.level === "offline") {
+      this.smoother.releaseOffline();
+      nextNetwork = this.smoother.level;
+    }
+    const prevMqttConnected = prevMqttConnectedOverride ?? prev.mqttConnected;
+    const changed = nextNetwork !== this.committedNetwork || backend !== this.committedBackend || this.mqttConnected !== prevMqttConnected;
+    this.committedNetwork = nextNetwork;
+    this.committedBackend = backend;
+    if (changed) {
+      const current = this.snapshot();
+      this.bus.emit("network:change", { previous: prev, current });
+    }
+  }
+  deriveMetrics() {
+    return this.deriveMetricsFrom(this.allHttpAndMqttSamples());
+  }
+  deriveMetricsFrom(samples) {
+    const httpSamples = samples.filter((s) => isHttpSource(s.source));
+    const total = httpSamples.length;
+    const lossCount = httpSamples.filter(
+      (s) => s.reason === "network" || s.reason === "timeout" || s.reason === "offline"
+    ).length;
+    const lossRate = total > 0 ? lossCount / total : 0;
+    const okRtts = httpSamples.filter(
+      (s) => s.reason === "ok" || s.reason === "backend5xx" || s.reason === "backend4xx" || s.reason === "gqlError"
+    ).map((s) => s.rtt).filter((r) => Number.isFinite(r));
+    let jitter = 0;
+    if (okRtts.length > 1) {
+      const mean = okRtts.reduce((a, b) => a + b, 0) / okRtts.length;
+      const variance = okRtts.reduce((a, b) => a + (b - mean) ** 2, 0) / okRtts.length;
+      jitter = Math.sqrt(variance);
+    }
+    const connectionFallback = samples.filter((s) => s.source === "connection" && Number.isFinite(s.rtt)).slice(-1)[0]?.rtt;
+    const emaForLevel = this.smoother.ema > 0 ? this.smoother.ema : okRtts.length > 0 ? okRtts[okRtts.length - 1] ?? 0 : connectionFallback ?? 0;
+    return { jitter, lossRate, emaForLevel };
+  }
+  isHardOffline() {
+    if (typeof navigator !== "undefined" && navigator && navigator.onLine === false) {
+      return true;
+    }
+    const now = this.now();
+    const recent = this.allHttpAndMqttSamples().filter(
+      (s) => s.ts >= now - OFFLINE_HOLD_MS && (s.source === "graphql" || s.source === "rest")
+    );
+    if (recent.length >= 3 && recent.every(
+      (s) => s.reason === "network" || s.reason === "timeout" || s.reason === "offline"
+    )) {
+      return true;
+    }
+    if (this.mqttDisconnectedAt !== null && now - this.mqttDisconnectedAt > OFFLINE_HOLD_MS && (this.lastSuccessfulHttpAt === null || now - this.lastSuccessfulHttpAt > OFFLINE_HOLD_MS)) {
+      return true;
+    }
+    return false;
+  }
+  allHttpAndMqttSamples() {
+    return [
+      ...this.buckets.graphql,
+      ...this.buckets.rest,
+      ...this.buckets.mqtt,
+      ...this.buckets.connection
+    ];
+  }
+  snapshot() {
+    const samples = this.allHttpAndMqttSamples();
+    const metrics = this.deriveMetricsFrom(samples);
+    return {
+      network: this.committedNetwork,
+      backend: this.committedBackend,
+      rtt: Math.round(metrics.emaForLevel),
+      jitter: Math.round(metrics.jitter),
+      lossRate: metrics.lossRate,
+      mqttConnected: this.mqttConnected,
+      samplesInWindow: samples.filter((s) => s.source !== "connection").length,
+      lastUpdated: this.now()
+    };
+  }
+  now() {
+    return Date.now();
+  }
+};
+
+// src/network/probes/connectionProbe.ts
+function attachConnectionProbe(monitor) {
+  const nav = typeof navigator !== "undefined" ? navigator : void 0;
+  const connection = nav?.connection;
+  if (!connection) {
+    return { dispose: () => void 0 };
+  }
+  const emit = () => {
+    const seed = {
+      rtt: connection.rtt,
+      effectiveType: connection.effectiveType
+    };
+    monitor.seedFromConnection(seed);
+  };
+  emit();
+  const listener = () => emit();
+  connection.addEventListener?.("change", listener);
+  return {
+    dispose() {
+      connection.removeEventListener?.("change", listener);
+    }
+  };
+}
+
+// src/network/probes/graphqlProbe.ts
+function createGraphqlProbe(monitor) {
+  return (event) => {
+    if (isAbortError(event.threw)) return;
+    const sample = classifyHttpOutcome(
+      {
+        rtt: event.endedAt - event.startedAt,
+        httpStatus: event.httpStatus,
+        gqlErrors: event.gqlErrors ?? null,
+        threw: event.threw
+      },
+      { now: event.endedAt, source: "graphql" }
+    );
+    monitor.addSample(sample);
+  };
+}
+
+// src/network/probes/mqttProbe.ts
+function createMqttProbe(monitor) {
+  return (event) => {
+    switch (event.kind) {
+      case "connect":
+      case "reconnect":
+        monitor.notifyMqttConnect(event.rttMs);
+        return;
+      case "disconnect":
+        monitor.notifyMqttDisconnect();
+        return;
+      case "ping":
+        monitor.notifyMqttPing(event.rttMs);
+        return;
+      case "error":
+        return;
+    }
+  };
+}
+
+// src/network/probes/restProbe.ts
+function createRestProbe(monitor) {
+  return (event) => {
+    if (isAbortError(event.threw)) return;
+    const sample = classifyHttpOutcome(
+      {
+        rtt: event.endedAt - event.startedAt,
+        httpStatus: event.httpStatus,
+        threw: event.threw
+      },
+      { now: event.endedAt, source: "rest" }
+    );
+    monitor.addSample(sample);
+  };
+}
+
+// src/storage/index.ts
+var MemoryAdapter = class {
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.store.get(key) ?? null;
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  remove(key) {
+    this.store.delete(key);
+  }
+};
+var BrowserStorageAdapter = class {
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  get(key) {
+    return this.storage.getItem(key);
+  }
+  set(key, value) {
+    this.storage.setItem(key, value);
+  }
+  remove(key) {
+    this.storage.removeItem(key);
+  }
+};
+function autoDetectStorage() {
+  if (typeof localStorage !== "undefined") {
+    return TaphubStorage.localStorage();
+  }
+  return TaphubStorage.memory();
+}
+var TaphubStorage = {
+  memory() {
+    return new MemoryAdapter();
+  },
+  localStorage() {
+    if (typeof localStorage === "undefined") {
+      throw new TaphubError("localStorage is not available in this environment", {
+        code: "StorageUnavailable"
+      });
+    }
+    return new BrowserStorageAdapter(localStorage);
+  },
+  sessionStorage() {
+    if (typeof sessionStorage === "undefined") {
+      throw new TaphubError("sessionStorage is not available in this environment", {
+        code: "StorageUnavailable"
+      });
+    }
+    return new BrowserStorageAdapter(sessionStorage);
+  }
+};
+
+// src/transport/shared/errors.ts
+function mapNetworkErrorToTaphubError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") {
+    throw new TaphubNetworkError("Request aborted", { code: "Aborted" });
+  }
+  if (err instanceof Error && (err.name === "AbortError" || err.message.includes("aborted"))) {
+    throw new TaphubNetworkError("Request aborted", { code: "Aborted" });
+  }
+  throw new TaphubNetworkError(err instanceof Error ? err.message : "Network error", {
+    code: "NetworkUnreachable"
+  });
+}
+
+// src/transport/shared/headers.ts
+function buildHeaders(opts) {
+  const headers = new Headers();
+  if (opts.token !== null) {
+    headers.set("Authorization", `Bearer ${opts.token}`);
+  }
+  if (opts.hasBody) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (opts.agencyId) {
+    headers.set("x-builder-code", opts.agencyId);
+  }
+  return headers;
+}
+
+// src/transport/graphql/errors.ts
+var AUTH_ERROR_CODES = [
+  "Unauthorized",
+  "TokenExpired",
+  "NotAuthenticated",
+  "ErrAccessTokenInvalid",
+  "ErrSessionInvalid"
+];
+var SLIPPAGE_CODE = "Bid_CoefficientMismatch";
+function extractSlippageMeta(entry) {
+  const meta = entry?.extensions?.meta;
+  if (!meta) return null;
+  const clientCoef = meta.clientCoef;
+  const serverCoef = meta.serverCoef;
+  const slippage = meta.slippage;
+  if (typeof clientCoef !== "number" || typeof serverCoef !== "number" || typeof slippage !== "number" || !Number.isFinite(clientCoef) || !Number.isFinite(serverCoef) || !Number.isFinite(slippage)) {
+    return null;
+  }
+  return { clientCoef, serverCoef, slippage };
+}
+function isAuthCode(code) {
+  return AUTH_ERROR_CODES.includes(code);
+}
+function firstErrorCode(body) {
+  const code = body.errors?.[0]?.extensions?.code;
+  if (typeof code === "string") return code;
+  return "Unknown";
+}
+function firstErrorMessage(body) {
+  return body.errors?.[0]?.message ?? "GraphQL error";
+}
+function buildDetails(body) {
+  const details = {};
+  if (body.errors && body.errors.length > 0) {
+    details.errors = body.errors;
+  }
+  if (body.data !== void 0 && body.data !== null) {
+    details.partialData = body.data;
+  }
+  return details;
+}
+function mapGraphQLHttpError(status, body) {
+  const parsed = typeof body === "object" && body !== null ? body : null;
+  if (status === 401) {
+    const code = parsed?.errors?.[0]?.extensions?.code ?? "Unauthorized";
+    const message = parsed?.errors?.[0]?.message ?? "Unauthorized";
+    throw new TaphubAuthError(message, {
+      code,
+      details: parsed ? buildDetails(parsed) : body
+    });
+  }
+  if (status >= 400 && status < 500) {
+    const code = parsed?.errors?.[0]?.extensions?.code ?? "BadRequest";
+    const message = parsed?.errors?.[0]?.message ?? "Bad Request";
+    throw new TaphubValidationError(message, {
+      code,
+      details: parsed ? buildDetails(parsed) : body
+    });
+  }
+  if (status >= 500) {
+    if (!parsed) {
+      throw new TaphubServerError("Invalid response from server", {
+        code: "InvalidResponse",
+        details: body ?? void 0
+      });
+    }
+    const code = parsed.errors?.[0]?.extensions?.code ?? "ServerError";
+    const message = parsed.errors?.[0]?.message ?? "Internal Server Error";
+    throw new TaphubServerError(message, {
+      code,
+      details: buildDetails(parsed)
+    });
+  }
+  throw new TaphubServerError("Unexpected status", {
+    code: "ServerError",
+    details: body ?? void 0
+  });
+}
+function mapGraphQLLevelError(body) {
+  const code = firstErrorCode(body);
+  const message = firstErrorMessage(body);
+  if (isAuthCode(code)) {
+    throw new TaphubAuthError(message, {
+      code,
+      details: buildDetails(body)
+    });
+  }
+  if (code === SLIPPAGE_CODE) {
+    const meta = extractSlippageMeta(body.errors?.[0]);
+    if (meta) {
+      throw new TaphubSlippageError(message, {
+        code,
+        clientCoef: meta.clientCoef,
+        serverCoef: meta.serverCoef,
+        slippage: meta.slippage,
+        details: buildDetails(body)
+      });
+    }
+  }
+  throw new TaphubValidationError(message, {
+    code,
+    details: buildDetails(body)
+  });
+}
+
+// src/transport/graphql/index.ts
+function extractOp(query) {
+  const named = query.match(/(?:query|mutation|subscription)\s+([A-Za-z]\w*)/);
+  if (named) return named[1];
+  return query.match(/{\s*([A-Za-z]\w*)/)?.[1] ?? "unknown";
+}
+function createGraphQLTransport(deps) {
+  const { baseUrl, getToken, agencyId, onRequest } = deps;
+  function resolveFetch() {
+    const fetchImpl = deps.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+      throw new TaphubError(
+        "fetch is not available. Provide a custom fetch or ensure globalThis.fetch exists.",
+        {
+          code: "FetchUnavailable"
+        }
+      );
+    }
+    return fetchImpl;
+  }
+  return {
+    async request(query, variables, opts) {
+      const fetchImpl = resolveFetch();
+      const base = baseUrl.replace(/\/+$/, "");
+      const op = extractOp(query);
+      const url = `${base}?${op}`;
+      const token = getToken();
+      const headers = buildHeaders({ token, hasBody: true, agencyId });
+      const body = { query };
+      if (variables !== void 0) {
+        body.variables = variables;
+      }
+      const startedAt = Date.now();
+      let httpStatus = null;
+      let gqlErrors = null;
+      let threw = null;
+      const fireProbe = () => {
+        if (!onRequest) return;
+        try {
+          onRequest({
+            startedAt,
+            endedAt: Date.now(),
+            httpStatus,
+            gqlErrors,
+            threw
+          });
+        } catch {
+        }
+      };
+      try {
+        let response;
+        try {
+          response = await fetchImpl.call(void 0, url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: opts?.signal
+          });
+        } catch (err) {
+          threw = err;
+          mapNetworkErrorToTaphubError(err);
+        }
+        httpStatus = response.status;
+        let responseBody;
+        try {
+          responseBody = await response.json();
+        } catch {
+          throw new TaphubServerError("Invalid response from server", {
+            code: "InvalidResponse"
+          });
+        }
+        if (!response.ok) {
+          mapGraphQLHttpError(response.status, responseBody);
+        }
+        const graphqlBody = responseBody;
+        if (graphqlBody.errors && graphqlBody.errors.length > 0) {
+          gqlErrors = graphqlBody.errors;
+          mapGraphQLLevelError(graphqlBody);
+        }
+        if (graphqlBody.data === void 0 || graphqlBody.data === null) {
+          throw new TaphubServerError("Invalid response from server", {
+            code: "InvalidResponse"
+          });
+        }
+        return graphqlBody.data;
+      } catch (err) {
+        if (threw === null) threw = err;
+        throw err;
+      } finally {
+        fireProbe();
+      }
+    }
+  };
+}
+
+// src/transport/rest/errors.ts
+function tryParseBody(body) {
+  if (typeof body === "object" && body !== null && "code" in body) {
+    return body;
+  }
+  return null;
+}
+function mapHttpToTaphubError(status, body) {
+  const parsed = tryParseBody(body);
+  const code = parsed?.code ?? "";
+  const details = body ?? void 0;
+  if (status === 401) {
+    throw new TaphubAuthError(parsed?.message ?? "Unauthorized", {
+      code: code || "Unauthorized",
+      details
+    });
+  }
+  if (status >= 400 && status < 500) {
+    throw new TaphubValidationError(parsed?.message ?? "Bad Request", {
+      code: code || "BadRequest",
+      details
+    });
+  }
+  if (status >= 500) {
+    if (!parsed) {
+      throw new TaphubServerError("Invalid response from server", {
+        code: "InvalidResponse",
+        details
+      });
+    }
+    throw new TaphubServerError(parsed.message ?? "Internal Server Error", {
+      code: code || "ServerError",
+      details
+    });
+  }
+  throw new TaphubServerError("Unexpected status", {
+    code: "ServerError",
+    details
+  });
+}
+
+// src/transport/rest/url.ts
+var API_PREFIX = "/api/user/v1";
+function buildUrl(baseUrl, path) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const cleanPath = path.replace(/^\/+/, "");
+  return `${base}${API_PREFIX}/${cleanPath}`;
+}
+
+// src/transport/rest/index.ts
+function createRestTransport(deps) {
+  const { baseUrl, getToken, onRequest } = deps;
+  function resolveFetch() {
+    const fetchImpl = deps.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+      throw new TaphubError(
+        "fetch is not available. Provide a custom fetch or ensure globalThis.fetch exists.",
+        {
+          code: "FetchUnavailable"
+        }
+      );
+    }
+    return fetchImpl;
+  }
+  async function request(method, path, body, opts) {
+    const fetchImpl = resolveFetch();
+    const url = buildUrl(baseUrl, path);
+    const token = getToken();
+    const hasBody = body !== void 0;
+    const headers = buildHeaders({ token, hasBody });
+    const startedAt = Date.now();
+    let httpStatus = null;
+    let threw = null;
+    const fireProbe = () => {
+      if (!onRequest) return;
+      try {
+        onRequest({ startedAt, endedAt: Date.now(), httpStatus, threw });
+      } catch {
+      }
+    };
+    try {
+      let response;
+      try {
+        response = await fetchImpl.call(void 0, url, {
+          method,
+          headers,
+          body: hasBody ? JSON.stringify(body) : void 0,
+          signal: opts?.signal
+        });
+      } catch (err) {
+        threw = err;
+        mapNetworkErrorToTaphubError(err);
+      }
+      httpStatus = response.status;
+      let responseBody;
+      try {
+        responseBody = await response.json();
+      } catch {
+        throw new TaphubServerError("Invalid response from server", {
+          code: "InvalidResponse"
+        });
+      }
+      if (!response.ok) {
+        mapHttpToTaphubError(response.status, responseBody);
+      }
+      const envelope = responseBody;
+      if (envelope.code !== "Success" || !("data" in envelope)) {
+        throw new TaphubServerError("Invalid response from server", {
+          code: "InvalidResponse"
+        });
+      }
+      return envelope.data;
+    } catch (err) {
+      if (threw === null) threw = err;
+      throw err;
+    } finally {
+      fireProbe();
+    }
+  }
+  return {
+    get(path, opts) {
+      return request("GET", path, void 0, opts);
+    },
+    post(path, body, opts) {
+      return request("POST", path, body, opts);
+    }
+  };
+}
+
+// src/client.ts
+function tokenStorageKey(agencyId) {
+  return `taphub:${agencyId}:token`;
+}
+function isDemoStorageKey(agencyId) {
+  return `taphub:${agencyId}:isDemo`;
+}
+var TaphubClient = class {
+  agencyId;
+  endpoint;
+  storage;
+  /** @readonly User module — reassignment has no effect at runtime. */
+  user;
+  /** @readonly Auth module — reassignment has no effect at runtime. */
+  auth;
+  /** @readonly Game module — reassignment has no effect at runtime. */
+  game;
+  /** @readonly Bid module — reassignment has no effect at runtime. */
+  bid;
+  /** @readonly Leaderboard module — reassignment has no effect at runtime. */
+  leaderboard;
+  /** @readonly Locale module — reassignment has no effect at runtime. */
+  locale;
+  /** @readonly Realtime module — undefined when mqttEndpoint not configured. */
+  realtime;
+  /** @readonly Network quality monitor — always present (operates passively). */
+  network;
+  bus;
+  #token;
+  #isDemo;
+  #tokenKey;
+  #isDemoKey;
+  #rest;
+  #graphql;
+  #graphqlUser;
+  constructor(config) {
+    if (!config.agencyId) {
+      throw new TaphubValidationError("agencyId is required", {
+        code: "InvalidConfig",
+        details: { field: "agencyId" }
+      });
+    }
+    try {
+      new URL(config.endpoint);
+    } catch {
+      throw new TaphubValidationError("endpoint must be a valid absolute URL", {
+        code: "InvalidConfig",
+        details: { field: "endpoint" }
+      });
+    }
+    this.agencyId = config.agencyId;
+    this.endpoint = config.endpoint;
+    this.storage = config.storage ?? autoDetectStorage();
+    this.bus = new TaphubEventBus();
+    this.network = new NetworkQualityMonitor({ bus: this.bus });
+    const graphqlProbe = createGraphqlProbe(this.network);
+    const restProbe = createRestProbe(this.network);
+    this.#tokenKey = tokenStorageKey(this.agencyId);
+    this.#isDemoKey = isDemoStorageKey(this.agencyId);
+    this.#token = this.storage.get(this.#tokenKey);
+    this.#isDemo = this.storage.get(this.#isDemoKey) === "1";
+    this.#rest = createRestTransport({
+      baseUrl: this.endpoint,
+      getToken: () => this.getToken(),
+      fetch: config.fetch,
+      onRequest: restProbe
+    });
+    const baseApi = this.endpoint.replace(/\/+$/, "");
+    this.#graphql = createGraphQLTransport({
+      baseUrl: `${baseApi}/grid-api/grid-gql`,
+      getToken: () => this.getToken(),
+      agencyId: this.agencyId,
+      fetch: config.fetch,
+      onRequest: graphqlProbe
+    });
+    this.#graphqlUser = createGraphQLTransport({
+      baseUrl: `${baseApi}/taphub-user-service/th-user-gql`,
+      getToken: () => this.getToken(),
+      agencyId: this.agencyId,
+      fetch: config.fetch,
+      onRequest: graphqlProbe
+    });
+    this.user = new UserModule({
+      rest: this.#rest,
+      graphql: this.#graphql,
+      graphqlUser: this.#graphqlUser
+    });
+    this.auth = new AuthModule({
+      rest: this.#rest,
+      graphql: this.#graphql,
+      graphqlUser: this.#graphqlUser,
+      setToken: (t, opts) => this.setToken(t, opts),
+      agencyId: this.agencyId,
+      onLoginSuccess: () => this.user.refreshCurrencies().then(() => void 0).catch(() => void 0),
+      onLogout: () => {
+        this.user.clearCurrencies();
+      }
+    });
+    this.game = new GameModule({ graphql: this.#graphql });
+    this.bid = new BidModule({ graphql: this.#graphql });
+    this.leaderboard = new LeaderboardModule({ graphql: this.#graphql });
+    this.locale = new LocaleModule({ graphql: this.#graphql });
+    this.realtime = config.mqttEndpoint ? new RealtimeModule({
+      mqttEndpoint: config.mqttEndpoint,
+      onMqttLifecycle: createMqttProbe(this.network)
+    }) : void 0;
+    attachConnectionProbe(this.network);
+    Object.defineProperty(this, "user", {
+      value: this.user,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    Object.defineProperty(this, "auth", {
+      value: this.auth,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    Object.defineProperty(this, "game", {
+      value: this.game,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    Object.defineProperty(this, "bid", {
+      value: this.bid,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    Object.defineProperty(this, "leaderboard", {
+      value: this.leaderboard,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+    if (this.realtime) {
+      Object.defineProperty(this, "realtime", {
+        value: this.realtime,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      });
+    }
+    Object.defineProperty(this, "network", {
+      value: this.network,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    });
+  }
+  getToken() {
+    return this.#token;
+  }
+  setToken(token, opts) {
+    this.#token = token;
+    if (token === null) {
+      this.#isDemo = false;
+      this.storage.remove(this.#tokenKey);
+      this.storage.remove(this.#isDemoKey);
+      return;
+    }
+    const isDemo = opts?.isDemo ?? false;
+    this.#isDemo = isDemo;
+    this.storage.set(this.#tokenKey, token);
+    this.storage.set(this.#isDemoKey, isDemo ? "1" : "0");
+  }
+  isDemo() {
+    return this.#isDemo;
+  }
+  /** @internal Used by module integrations to access the REST transport. Not part of the public API. */
+  get _rest() {
+    return this.#rest;
+  }
+  /** @internal Used by module integrations to access the GraphQL transport. Not part of the public API. */
+  get _graphql() {
+    return this.#graphql;
+  }
+  on(event, handler) {
+    this.bus.on(event, handler);
+  }
+  off(event, handler) {
+    this.bus.off(event, handler);
+  }
+};
+
+// src/utils/coefficient.ts
+function errorFunction(x) {
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const sign = x >= 0 ? 1 : -1;
+  const absX = Math.abs(x);
+  const t = 1 / (1 + p * absX);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
+  return sign * y;
+}
+function normalCDF(x) {
+  return 0.5 * (1 + errorFunction(x / Math.SQRT2));
+}
+function normalPDF(x) {
+  return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+}
+function adaptiveSimpson(f, a, b, tolerance = 1e-6, maxDepth = 50) {
+  function simpson(a2, b2, fa2, fm2, fb2) {
+    return (b2 - a2) / 6 * (fa2 + 4 * fm2 + fb2);
+  }
+  function recurse(a2, b2, fa2, fm2, fb2, whole2, depth) {
+    const m = (a2 + b2) / 2;
+    const m1 = (a2 + m) / 2;
+    const m2 = (m + b2) / 2;
+    const fm1 = f(m1);
+    const fm22 = f(m2);
+    const left = simpson(a2, m, fa2, fm1, fm2);
+    const right = simpson(m, b2, fm2, fm22, fb2);
+    const combined = left + right;
+    if (depth >= maxDepth || Math.abs(combined - whole2) <= 15 * tolerance) {
+      return combined + (combined - whole2) / 15;
+    }
+    return recurse(a2, m, fa2, fm1, fm2, left, depth + 1) + recurse(m, b2, fm2, fm22, fb2, right, depth + 1);
+  }
+  const fa = f(a);
+  const fm = f((a + b) / 2);
+  const fb = f(b);
+  const whole = simpson(a, b, fa, fm, fb);
+  return recurse(a, b, fa, fm, fb, whole, 0);
+}
+function calculateProbWin(time1, time2, _price1, price2, creationTime, currentPrice, volatility) {
+  if (volatility <= 0 || time2 <= time1) {
+    return 0;
+  }
+  const _elapsed = time1 - creationTime;
+  const remaining = time2 - time1;
+  const totalDuration = time2 - creationTime;
+  if (totalDuration <= 0) {
+    return 0;
+  }
+  const targetMove = price2 - currentPrice;
+  const timeFraction = remaining / totalDuration;
+  const scaledVolatility = volatility * Math.sqrt(timeFraction);
+  if (scaledVolatility === 0) {
+    return currentPrice >= price2 ? 1 : 0;
+  }
+  const z = targetMove / scaledVolatility;
+  const prob = 1 - normalCDF(z);
+  return Math.max(0, Math.min(1, prob));
+}
+function calculateProbWin_v2(time1, time2, _price1, price2, creationTime, currentPrice, volatility) {
+  if (volatility <= 0 || time2 <= time1) {
+    return 0;
+  }
+  const elapsed = time1 - creationTime;
+  if (elapsed <= 0) {
+    return 0;
+  }
+  const remaining = time2 - time1;
+  const totalDuration = time2 - creationTime;
+  const timeFraction = remaining / totalDuration;
+  const scaledVolatility = volatility * Math.sqrt(timeFraction);
+  if (scaledVolatility === 0) {
+    return currentPrice >= price2 ? 1 : 0;
+  }
+  const targetMove = price2 - currentPrice;
+  const z = targetMove / scaledVolatility;
+  const prob = 1 - normalCDF(z);
+  return Math.max(0, Math.min(1, prob));
+}
+export {
+  AuthModule,
+  BidModule,
+  GameModule,
+  LeaderboardModule,
+  LocaleModule,
+  NetworkQualityMonitor,
+  RealtimeModule,
+  TaphubAuthError,
+  TaphubClient,
+  TaphubError,
+  TaphubEventBus,
+  TaphubNetworkError,
+  TaphubServerError,
+  TaphubSlippageError,
+  TaphubStorage,
+  TaphubValidationError,
+  UserModule,
+  adaptiveSimpson,
+  autoDetectStorage,
+  calculateProbWin,
+  calculateProbWin_v2,
+  errorFunction,
+  isCancelled,
+  isLoss,
+  isPending,
+  isTerminal,
+  isWin,
+  normalCDF,
+  normalPDF
+};