yolkbot 1.4.8 → 1.5.0

package/dist/enums.d.ts

@@ -0,0 +1,154 @@
+// keep enums.js up to date
+
+export enum APIErrorEnum {
+    WebSocketConnectFail = 'websocket_connect_fail',
+    MissingParams = 'missing_params',
+    NetworkFail = 'firebase_network_failed',
+    ServicesClosedEarly = 'services_closed_early',
+    InternalError = 'unknown_error',
+    FirebaseRateLimited = 'firebase_rate_limited'
+}
+
+export interface APIError { ok: false, error: APIErrorEnum }
+
+export enum LoginErrorEnum {
+    AccountBanned = 'account_banned'
+}
+
+export type LoginError = APIError | { ok: false, error: LoginErrorEnum };
+
+export enum BuyItemErrorEnum {
+    SessionExpired = 'PLAYER_NOT_FOUND',
+    ItemNotFound = 'ITEM_NOT_FOUND',
+    ItemAlreadyOwned = 'ALREADY_OWNED',
+    CannotAfford = 'INSUFFICIENT_FUNDS',
+    InternalError = 'UNKNOWN_ERROR'
+}
+
+export type BuyItemError = { ok: false, error: BuyItemErrorEnum };
+
+export enum ChicknWinnerErrorEnum {
+    OnCooldown = 'on_cooldown',
+    HitDailyLimit = 'hit_daily_limit',
+    NotAtDailyLimit = 'not_at_limit',
+    NotEnoughResetEggs = 'not_enough_eggs',
+    SessionExpired = 'session_expired',
+    InternalError = 'unknown_error'
+}
+
+export type ChicknWinnerError = { ok: false, error: ChicknWinnerErrorEnum };
+
+export enum GameFindErrorEnum {
+    MissingParams = 'missing_params',
+    InvalidRegion = 'region_not_in_list',
+    InvalidMode = 'mode_not_in_list',
+    InvalidMap = 'map_not_in_list',
+    GameNotFound = 'game_not_found',
+    SessionExpired = 'session_expired',
+    InternalError = 'unknown_error'
+}
+
+export type GameFindError = { ok: false, error: GameFindErrorEnum };
+
+export enum GameJoinErrorEnum {
+    MissingParams = 'missing_params',
+    InvalidObject = 'invalid_game_object',
+    WebSocketConnectFail = 'websocket_connect_fail',
+    GameNotFound = 'game_not_found',
+    InternalError = 'unknown_error'
+}
+
+export type GameJoinError = { ok: false, error: GameJoinErrorEnum };
+
+export enum MatchmakerErrorEnum {
+    WebSocketConnectFail = 'websocket_connect_fail'
+}
+
+export type MatchmakerError = { ok: false, error: MatchmakerErrorEnum };
+
+export enum Intents {
+    CHALLENGES = 1,
+    BOT_STATS = 2,
+    PATHFINDING = 3,
+    PING = 5,
+    COSMETIC_DATA = 6,
+    PLAYER_HEALTH = 7,
+    PACKET_HOOK = 8,
+    LOG_PACKETS = 10,
+    SKIP_LOGIN = 11,
+    DEBUG_BUFFER = 12,
+    NO_AFK_KICK = 16,
+    LOAD_MAP = 17,
+    OBSERVE_GAME = 18,
+    RENEW_SESSION = 21,
+    VIP_HIDE_BADGE = 22,
+    SIMULATION = 23,
+    MANUAL_UPDATE = 24,
+    FASTER_RESPAWN = 25
+}
+
+export enum RedeemCodeErrorEnum {
+    SessionExpired = 'PLAYER_NOT_FOUND',
+    CurrentlyRedeemingElsewhere = 'CODE_DOUBLE_DOUBLE',
+    AlreadyRedeemed = 'CODE_PREV_REDEEMED',
+    InvalidCode = 'CODE_NOT_FOUND',
+    Ratelimited = 'RATE_LIMIT_REACHED',
+    InternalError = 'UNKNOWN_ERROR'
+}
+
+export type RedeemCodeError = { ok: false, error: RedeemCodeErrorEnum };
+
+export enum ClaimSocialErrorEnum {
+    SessionExpired = 'reward_expired_session',
+    InvalidReward = 'REWARD_NOT_FOUND',
+    AlreadyRedeemed = 'REWARD_PREV_GIVEN',
+    InternalError = 'unknown_error'
+}
+
+export type ClaimSocialError = { ok: false, error: ClaimSocialErrorEnum };
+
+export enum ClaimURLErrorEnum {
+    SessionExpired = 'urlRewardParams_expired_session',
+    InvalidReward = 'REWARD_NOT_FOUND',
+    AlreadyRedeemed = 'REWARD_PREV_GIVEN',
+    InternalError = 'unknown_error'
+}
+
+export type ClaimURLError = { ok: false, error: ClaimURLErrorEnum };
+
+export enum ChallengeRerollErrorEnum {
+    SessionExpired = 'challengeRerollSlot_expired_session',
+    ChallengeNotFound = 'challenge_not_found',
+    ChallengeNotAssigned = 'challenge_reroll_not_found',
+    NotEnoughEggs = 'insufficient_eggs',
+    InternalError = 'unknown_error'
+}
+
+export type ChallengeRerollError = { ok: false, error: ChallengeRerollErrorEnum };
+
+export enum ChallengeClaimErrorEnum {
+    SessionExpired = 'challengeClaimReward_expired_session',
+    ChallengeNotFound = 'challenge_claim_not_found',
+    ChallengeNotCompleted = 'challenge_not_completed',
+    InternalError = 'unknown_error'
+}
+
+export type ChallengeClaimError = { ok: false, error: ChallengeClaimErrorEnum };
+
+export enum PathfindError {
+    NoPathFound = 'no_path_found',
+    PathTooShort = 'path_too_short'
+}
+
+export enum ZoneLeaveReason {
+    Despawned = 'despawned',
+    Killed = 'killed',
+    WalkedOut = 'exited',
+    RoundEnded = 'round_ended'
+}
+
+export enum CleanupLevel {
+    None = 0,
+    Partial = 1,
+    Full = 2
+}

package/dist/enums.js

@@ -0,0 +1,114 @@
+export const APIError = {
+  WebSocketConnectFail: "websocket_connect_fail",
+  MissingParams: "missing_params",
+  NetworkFail: "firebase_network_failed",
+  ServicesClosedEarly: "services_closed_early",
+  InternalError: "unknown_error",
+  FirebaseRateLimited: "firebase_rate_limited"
+};
+export const LoginError = {
+  ...APIError,
+  AccountBanned: "account_banned"
+};
+export const BuyItemError = {
+  SessionExpired: "PLAYER_NOT_FOUND",
+  ItemNotFound: "ITEM_NOT_FOUND",
+  ItemAlreadyOwned: "ALREADY_OWNED",
+  CannotAfford: "INSUFFICIENT_FUNDS",
+  InternalError: "UNKNOWN_ERROR"
+};
+export const ChicknWinnerError = {
+  OnCooldown: "on_cooldown",
+  HitDailyLimit: "hit_daily_limit",
+  NotAtDailyLimit: "not_at_limit",
+  NotEnoughResetEggs: "not_enough_eggs",
+  SessionExpired: "session_expired",
+  InternalError: "unknown_error"
+};
+export const GameFindError = {
+  MissingParams: "missing_params",
+  InvalidRegion: "region_not_in_list",
+  InvalidMode: "mode_not_in_list",
+  InvalidMap: "map_not_in_list",
+  GameNotFound: "game_not_found",
+  SessionExpired: "session_expired",
+  InternalError: "unknown_error"
+};
+export const GameJoinError = {
+  MissingParams: "missing_params",
+  InvalidObject: "invalid_game_object",
+  WebSocketConnectFail: "websocket_connect_fail",
+  GameNotFound: "game_not_found",
+  InternalError: "unknown_error"
+};
+export const MatchmakerError = {
+  WebSocketConnectFail: "websocket_connect_fail"
+};
+export const Intents = {
+  CHALLENGES: 1,
+  BOT_STATS: 2,
+  PATHFINDING: 3,
+  PING: 5,
+  COSMETIC_DATA: 6,
+  PLAYER_HEALTH: 7,
+  PACKET_HOOK: 8,
+  LOG_PACKETS: 10,
+  SKIP_LOGIN: 11,
+  DEBUG_BUFFER: 12,
+  NO_AFK_KICK: 16,
+  LOAD_MAP: 17,
+  OBSERVE_GAME: 18,
+  RENEW_SESSION: 21,
+  VIP_HIDE_BADGE: 22,
+  SIMULATION: 23,
+  MANUAL_UPDATE: 24,
+  FASTER_RESPAWN: 25
+};
+export const RedeemCodeError = {
+  SessionExpired: "PLAYER_NOT_FOUND",
+  CurrentlyRedeemingElsewhere: "CODE_DOUBLE_DOUBLE",
+  AlreadyRedeemed: "CODE_PREV_REDEEMED",
+  InvalidCode: "CODE_NOT_FOUND",
+  Ratelimited: "RATE_LIMIT_REACHED",
+  InternalError: "UNKNOWN_ERROR"
+};
+export const ClaimSocialError = {
+  SessionExpired: "reward_expired_session",
+  InvalidReward: "REWARD_NOT_FOUND",
+  AlreadyRedeemed: "REWARD_PREV_GIVEN",
+  InternalError: "unknown_error"
+};
+export const ClaimURLError = {
+  SessionExpired: "urlRewardParams_expired_session",
+  InvalidReward: "REWARD_NOT_FOUND",
+  AlreadyRedeemed: "REWARD_PREV_GIVEN",
+  InternalError: "unknown_error"
+};
+export const ChallengeRerollError = {
+  SessionExpired: "challengeRerollSlot_expired_session",
+  ChallengeNotFound: "challenge_not_found",
+  ChallengeNotAssigned: "challenge_reroll_not_found",
+  NotEnoughEggs: "insufficient_eggs",
+  InternalError: "unknown_error"
+};
+export const ChallengeClaimError = {
+  SessionExpired: "challengeClaimReward_expired_session",
+  ChallengeNotFound: "challenge_claim_not_found",
+  ChallengeNotCompleted: "challenge_not_completed",
+  InternalError: "unknown_error"
+};
+export const PathfindError = {
+  NoPathFound: "no_path_found",
+  PathTooShort: "path_too_short"
+};
+export const ZoneLeaveReason = {
+  Despawned: "despawned",
+  Killed: "killed",
+  WalkedOut: "exited",
+  RoundEnded: "round_ended"
+};
+export const CleanupLevel = {
+  None: 0,
+  Partial: 1,
+  Full: 2
+};

package/dist/env/fetch.d.ts

@@ -0,0 +1,15 @@
+interface HttpResponse {
+    json(): any;
+    text(): string;
+}
+
+interface iFetchOptions {
+    method?: string;
+    proxy?: string;
+    headers?: Record<string, string>;
+    body?: string | null;
+    timeout?: number;
+}
+
+declare function iFetch(url: string, options?: iFetchOptions): Promise<HttpResponse>;
+export default iFetch;

package/dist/env/fetch.js

@@ -1,102 +1,136 @@
 import { socksConnect } from "wwws";
 import globals from "./globals.js";
-const sendHttpRequest = (socket, { method, pathname, hostname, port, headers, body }, resolve) => {
-  let reqHeaders = "";
-  for (const [k, v] of Object.entries(headers))
-    reqHeaders += `${k}: ${v}\r
-`;
+const parseChunkedBody = (body) => {
+  const chunks = [];
+  let i = 0;
+  const len = body.length;
+  while (i < len) {
+    const rnIdx = body.indexOf(`\r
+`, i);
+    if (rnIdx === -1)
+      break;
+    const sizeHex = body.slice(i, rnIdx).trim();
+    if (!sizeHex) {
+      i = rnIdx + 2;
+      continue;
+    }
+    const size = parseInt(sizeHex, 16);
+    if (Number.isNaN(size) || size === 0)
+      break;
+    i = rnIdx + 2;
+    chunks.push(body.slice(i, i + size));
+    i += size + 2;
+  }
+  return chunks.join("");
+};
+const sendHttpRequest = (socket, { method, pathname, hostname, port, headers, body }, time, resolve, reject) => {
+  const timeout = setTimeout(() => {
+    socket.destroy();
+    reject(new Error(`iFetch timed out: ${method} ${hostname}:${port}${pathname}`));
+  }, time);
+  let reqHeaders = Object.entries(headers).map(([k, v]) => `${k}: ${v}\r
+`).join("");
   if (body && !("Content-Length" in headers))
     reqHeaders += `Content-Length: ${Buffer.byteLength(body)}\r
 `;
-  let req = `${method} ${pathname} HTTP/1.1\r
+  socket.write(`${method} ${pathname} HTTP/1.1\r
 Host: ${hostname}:${port}\r
 ${reqHeaders}Connection: close\r
 \r
-`;
+`);
   if (body)
-    req += body;
-  socket.write(req);
+    socket.write(body);
   let response = "";
+  let headersParsed = false;
+  let contentLength = 0;
+  let bodyStart = 0;
   socket.on("data", (data) => {
     response += data.toString();
-    if (/transfer-encoding:\s*chunked/i.test(response)) {
-      if (response.includes(`\r
+    if (!headersParsed) {
+      bodyStart = response.indexOf(`\r
+\r
+`);
+      if (bodyStart !== -1) {
+        headersParsed = true;
+        bodyStart += 4;
+        const headersText = response.slice(0, bodyStart - 4);
+        const contentLengthMatch = headersText.match(/content-length:\s*(?<length>\d+)/i);
+        if (contentLengthMatch)
+          contentLength = parseInt(contentLengthMatch.groups.length, 10);
+      }
+    }
+    if (headersParsed) {
+      const isChunked = /transfer-encoding:\s*chunked/i.test(response);
+      if (isChunked) {
+        if (response.includes(`\r
 0\r
 \r
 `))
-        socket.end();
-    } else {
-      const contentLengthMatch = response.match(/content-length:\s*(?<len>\d+)/i);
-      if (contentLengthMatch) {
-        const contentLength = parseInt(contentLengthMatch.groups.len, 10);
-        const bodyStart = response.indexOf(`\r
-\r
-`) + 4;
-        const body3 = response.slice(bodyStart);
-        if (body3.length >= contentLength)
-          socket.end();
+          socket.destroy();
+      } else if (contentLength > 0) {
+        const bodyReceived = response.length - bodyStart;
+        if (bodyReceived >= contentLength)
+          socket.destroy();
       }
     }
   });
-  socket.on("end", () => {
-    const isChunked = /transfer-encoding:\s*chunked/i.test(response);
-    let parsedBody = response.split(`\r
+  socket.on("error", (err) => {
+    clearTimeout(timeout);
+    reject(err);
+  });
+  socket.on("close", () => {
+    clearTimeout(timeout);
+    const headerEnd = response.indexOf(`\r
 \r
-`)[1];
-    if (isChunked) {
-      const body2 = parsedBody;
-      const chunks = [];
-      let i = 0;
-      while (i < body2.length) {
-        const rnIdx = body2.indexOf(`\r
-`, i);
-        if (rnIdx === -1)
-          break;
-        const sizeHex = body2.slice(i, rnIdx).trim();
-        const size = parseInt(sizeHex, 16);
-        if (size === 0)
-          break;
-        i = rnIdx + 2;
-        chunks.push(body2.slice(i, i + size));
-        i += size + 2;
-      }
-      parsedBody = chunks.join("");
-    }
-    resolve({ json: () => JSON.parse(parsedBody), text: () => parsedBody });
+`);
+    if (headerEnd === -1)
+      return reject(new Error("Invalid HTTP response"));
+    let parsedBody = response.slice(headerEnd + 4);
+    if (/transfer-encoding:\s*chunked/i.test(response))
+      parsedBody = parseChunkedBody(parsedBody);
+    resolve({
+      json: () => JSON.parse(parsedBody),
+      text: () => parsedBody
+    });
   });
 };
-const iFetch = (url, { method = "GET", proxy, headers = {}, body = null } = {}) => new Promise((resolve) => {
-  if (typeof process === "undefined" || !process.getBuiltinModule)
-    return globals.fetch(url, { method, headers, body }).then(resolve);
-  const dns = process.getBuiltinModule("node:dns");
-  const net = process.getBuiltinModule("node:net");
-  const tls = process.getBuiltinModule("node:tls");
-  const { hostname, port: rawPort, pathname: path, protocol, search } = new URL(url);
-  const isHttps = protocol === "https:";
-  const pathname = path + search;
-  const port = rawPort ? parseInt(rawPort) : isHttps ? 443 : 80;
-  if (!proxy)
-    return dns.lookup(hostname, { family: 4 }, (err, host) => {
-      if (err)
-        throw err;
-      const socket = isHttps ? tls.connect({ port, host, servername: hostname }) : net.connect({ port, host });
-      socket.on("connect", () => sendHttpRequest(socket, { method, pathname, hostname, port, headers, body }, resolve));
-    });
-  const proxyInfo = new URL(proxy);
-  const scheme = proxyInfo.protocol.replace(":", "");
-  if (scheme !== "socks5" && scheme !== "socks5h")
-    throw new Error("iFetch only supports socks5 & socks5h proxies");
-  socksConnect({
-    proxy: {
-      hostname: proxyInfo.hostname,
-      port: Number(proxyInfo.port),
-      username: proxyInfo.username,
-      password: proxyInfo.password
-    },
-    destHost: hostname,
-    destPort: port,
-    useTLS: isHttps,
-    resolveDnsLocally: proxyInfo.protocol === "socks5"
-  }).then((socket) => sendHttpRequest(socket, { method, pathname, hostname, port, headers, body }, resolve));
+export const iFetch = (url, { method = "GET", proxy, headers = {}, body = null, timeout = 20000 } = {}) => new Promise((resolve, reject) => {
+  try {
+    if (typeof process === "undefined" || !process.getBuiltinModule)
+      return globals.fetch(url, { method, headers, body }).then(resolve).catch(reject);
+    const dns = process.getBuiltinModule("node:dns");
+    const net = process.getBuiltinModule("node:net");
+    const tls = process.getBuiltinModule("node:tls");
+    const { hostname, port: rawPort, pathname: path, protocol, search } = new URL(url);
+    const isHttps = protocol === "https:";
+    const pathname = path + search;
+    const port = rawPort ? parseInt(rawPort, 10) : isHttps ? 443 : 80;
+    if (!proxy) {
+      return dns.lookup(hostname, { family: 4 }, (err, host) => {
+        if (err)
+          return reject(err);
+        const socket = isHttps ? tls.connect({ port, host, servername: hostname }) : net.connect({ port, host });
+        socket.on("connect", () => sendHttpRequest(socket, { method, pathname, hostname, port, headers, body }, timeout, resolve, reject));
+      });
+    }
+    const proxyInfo = new URL(proxy);
+    const scheme = proxyInfo.protocol.replace(":", "");
+    if (scheme !== "socks5" && scheme !== "socks5h")
+      return reject(new Error("iFetch only supports socks5 & socks5h proxies"));
+    socksConnect({
+      proxy: {
+        hostname: proxyInfo.hostname,
+        port: Number(proxyInfo.port),
+        username: proxyInfo.username,
+        password: proxyInfo.password
+      },
+      destHost: hostname,
+      destPort: port,
+      useTLS: isHttps,
+      resolveDnsLocally: proxyInfo.protocol === "socks5"
+    }).then((socket) => sendHttpRequest(socket, { method, pathname, hostname, port, headers, body }, timeout, resolve, reject)).catch(reject);
+  } catch (err) {
+    reject(err);
+  }
 });
 export default iFetch;

package/dist/env/globals.d.ts

@@ -0,0 +1,9 @@
+import WWWebSocket from 'wwws';
+import iFetch from './fetch';
+
+export declare const globals: {
+    fetch: typeof globalThis.fetch | typeof iFetch,
+    WebSocket: typeof globalThis.WebSocket | typeof WWWebSocket
+};
+
+export default globals;

package/dist/env/globals.js

@@ -1,15 +1,17 @@
+import { WWWebSocket } from "wwws";
 import iFetch from "./fetch.js";
-const globals = {};
+export const globals = {};
 const isBrowser = typeof window !== "undefined" && typeof HTMLElement !== "undefined";
-const isWorker = typeof WebSocketPair !== "undefined" && typeof Cloudflare !== "undefined";
+const isWebWorker = typeof self !== "undefined" && typeof DedicatedWorkerGlobalScope !== "undefined" && self instanceof DedicatedWorkerGlobalScope;
+const isCloudflareWorker = typeof WebSocketPair !== "undefined" && typeof Cloudflare !== "undefined";
+const isUnsandboxedElectron = typeof process === "object" && process.versions?.electron && process.versions?.node && typeof window !== "undefined" && typeof window.require !== "undefined";
 const isNode = typeof process !== "undefined" && process.moduleLoadList?.length > 0;
 const isDeno = typeof Deno !== "undefined";
-const isBun = typeof process !== "undefined" && !!process.versions?.bun;
-if (!isBrowser && !isWorker && !isNode && !isDeno && !isBun)
+const isBun = typeof Bun !== "undefined";
+if (!isBrowser && !isCloudflareWorker && !isWebWorker && !isUnsandboxedElectron && !isNode && !isDeno && !isBun)
   throw new Error("yolkbot doesn't know how to run in this environment. Please open an issue on GitHub with information on where you run yolkbot.");
-globals.isBrowser = isBrowser;
-globals.isIsolated = !isNode && !isDeno && !isBun;
-import { WWWebSocket } from "wwws";
-globals.fetch = isBrowser || isWorker ? (...args) => globalThis.fetch(...args) : iFetch;
-globals.WebSocket = isBrowser || isWorker ? globalThis.WebSocket : WWWebSocket;
+globals.isBrowser = isBrowser || isWebWorker;
+globals.isIsolated = !isNode && !isDeno && !isBun && !isUnsandboxedElectron;
+globals.fetch = globals.isIsolated ? (...args) => globalThis.fetch(...args) : iFetch;
+globals.WebSocket = globals.isIsolated ? globalThis.WebSocket : WWWebSocket;
 export default globals;

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export declare type API = import('./api.js').API;
+export declare type Bot = import('./bot.js').Bot;
+export declare const Enums: typeof import('./enums.js');
+export declare const yolkws: typeof import('./socket.js').default;
+export declare const util: typeof import('./util.js');
+
+export declare type GamePlayer = import('./bot/GamePlayer.js').GamePlayer;
+
+export declare const Comm: {
+    CommIn: typeof import('./comm/CommIn.js').CommIn;
+    CommOut: typeof import('./comm/CommOut.js').CommOut;
+};
+
+export declare const Constants: typeof import('./constants/index.js');
+export declare const Challenges: typeof import('./constants/challenges.js').Challenges;
+export declare const CloseCode: typeof import('./constants/CloseCode.js').CloseCode;
+export declare const CommCode: typeof import('./constants/CommCode.js').CommCode;
+export declare const Guns: typeof import('./constants/guns.js');
+export declare const Items: typeof import('./constants/items.js').Items;
+export declare const Maps: typeof import('./constants/maps.js').Maps;
+export declare const Regions: typeof import('./constants/regions.js').Regions;
+
+export declare const Dispatches: typeof import('./dispatches/index.js').default;
+
+export declare const iFetch: typeof import('./env/fetch.js').default;
+export declare const globals: typeof import('./env/globals.js').globals;
+
+export declare const WASM: typeof import('./wasm/direct.js');
+
+declare const _default: typeof import('./bot.js').Bot;
+export default _default;

package/dist/index.js

@@ -1,14 +1,24 @@
-const red = "\x1B[31m";
-const green = "\x1B[32m";
-const reset = "\x1B[0m";
-console.error([
-  red,
-  "how NOT to import yolkbot:",
-  '> import yolkbot from "yolkbot";',
-  green,
-  "how to PROPERLY import yolkbot:",
-  '> import yolkbot from "yolkbot/bot";',
-  "please adjust your code.",
-  reset
-].join(`
-`));
+export { API } from "./api.js";
+export { Bot } from "./bot.js";
+export * as Enums from "./enums.js";
+export { yolkws } from "./socket.js";
+export * as util from "./util.js";
+export { GamePlayer } from "./bot/GamePlayer.js";
+import { CommIn } from "./comm/CommIn.js";
+import { CommOut } from "./comm/CommOut.js";
+export const Comm = { CommIn, CommOut };
+
+export * as Constants from "./constants/index.js";
+export { Challenges } from "./constants/challenges.js";
+export { CloseCode } from "./constants/CloseCode.js";
+export { CommCode } from "./constants/CommCode.js";
+export * as Guns from "./constants/guns.js";
+export { Items } from "./constants/items.js";
+export { Maps } from "./constants/maps.js";
+export { Regions } from "./constants/regions.js";
+export { default as Dispatches } from "./dispatches/index.js";
+export { iFetch } from "./env/fetch.js";
+export { globals } from "./env/globals.js";
+export * as WASM from "./wasm/direct.js";
+import Bot from "./bot.js";
+export default Bot;