dredless 0.2.0

package/src/network/servers.js

@@ -0,0 +1,133 @@
+import {DEFAULT_BASE_URL} from "../constants.js";
+import {hostName, normalizeBaseUrl} from "../runtime.js";
+import {HttpClient} from "./http.js";
+
+const cache = new Map();
+
+class ServerDirectory {
+    constructor(baseUrl = DEFAULT_BASE_URL) {
+        this.baseUrl = normalizeBaseUrl(baseUrl);
+        this.meta = null;
+    }
+
+    async load() {
+        if (cache.has(this.baseUrl)) {
+            this.meta = await cache.get(this.baseUrl);
+            return this;
+        }
+        const promise = this.#fetchMeta();
+        cache.set(this.baseUrl, promise);
+        this.meta = await promise;
+        return this;
+    }
+
+    async version() {
+        await this.load();
+        if (!this.meta.version) throw new Error("Unable to locate GAME_VERSION in drednot bundle");
+        return this.meta.version;
+    }
+
+    async list() {
+        return this.servers();
+    }
+
+    async servers() {
+        await this.load();
+        if (!this.meta.serverInfo) throw new Error("Unable to locate server list in drednot bundle");
+        return this.meta.serverInfo.servers;
+    }
+
+    async get(id = null) {
+        return this.pick(id);
+    }
+
+    async pick(id = null) {
+        const servers = await this.servers();
+        return servers.find((server) => server.index === Number(id)) || servers[0] || null;
+    }
+
+    async #fetchMeta() {
+        const response = await new HttpClient({baseUrl: this.baseUrl}).request("index.html");
+        if (!response.ok) throw new Error(`Failed to fetch bundle: ${response.status} ${response.statusText}`);
+        const text = await response.text();
+        return {text, version: parseGameVersion(text), serverInfo: parseServerInfo(text, this.baseUrl)};
+    }
+}
+
+export const fetchGameVersion = (baseUrl = DEFAULT_BASE_URL) => new ServerDirectory(baseUrl).version();
+export const fetchServers = (baseUrl = DEFAULT_BASE_URL) => new ServerDirectory(baseUrl).servers();
+
+export async function fetchNoticeVersion(baseUrl = DEFAULT_BASE_URL) {
+    const response = await new HttpClient({baseUrl}).request("index.html");
+    if (!response.ok) throw new Error(`Failed to fetch notice version: ${response.status} ${response.statusText}`);
+    const text = await response.text();
+    const version = parseNoticeVersion(text);
+    if (version == null) throw new Error("Unable to locate notice version in drednot page");
+    return version;
+}
+
+export async function resolveServer(server, baseUrl = DEFAULT_BASE_URL) {
+    if (server && typeof server === "object") return server;
+    const id = Number(server);
+    const servers = await fetchServers(baseUrl);
+    return servers.find((item) => item.index === id) || null;
+}
+
+export function serverId(server) {
+    if (server && typeof server === "object") return Number(server.index ?? server.id);
+    return Number(server);
+}
+
+function parseGameVersion(text) {
+    return text.match(/Object\.defineProperty\(exports,"GAME_VERSION",\{enumerable:true,get:\(\)=>e\}\);const e="([^"]+)"/)?.[1] || null;
+}
+
+function parseNoticeVersion(text) {
+    const moduleMatch = text.match(/Object\.defineProperty\(exports,"checkNotice"[\s\S]{0,8000}?setCookie\)\("notice_version",([A-Za-z_$][\w$]*)\)/);
+    if (moduleMatch) {
+        const constant = moduleMatch[1];
+        const prefix = text.slice(Math.max(0, moduleMatch.index - 1000), moduleMatch.index + moduleMatch[0].length);
+        const constantMatch = prefix.match(new RegExp(`const\\s+${constant}\\s*=\\s*(\\d+)\\s*;`));
+        if (constantMatch) return Number(constantMatch[1]);
+    }
+
+    const patterns = [
+        /notice_version["']?\s*[:=]\s*["']?(\d+)/i,
+        /noticeVersion["']?\s*[:=]\s*["']?(\d+)/i,
+        /NOTICE_VERSION["']?\s*[:=]\s*["']?(\d+)/,
+        /notice[^0-9]{0,40}version[^0-9]{0,20}(\d+)/i
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match) return Number(match[1]);
+    }
+    return null;
+}
+
+function parseServerInfo(text, baseUrl) {
+    const host = hostName(baseUrl);
+    const match = text.match(/const n=(true|false);const \$="([^"]+)";const o="([^"]+)";const T="([^"]+)";const t="([^"]+)";const S=\[([^\]]+)\];const c=\[([^\]]+)\];const A="([^"]+)";const I="([^"]+)"/s);
+    if (!match) return null;
+    const [localDomain, baseDomain, testDomain, testGameDomain] = match.slice(2, 6);
+    const domains = [...match[6].matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => m[1]);
+    const names = [...match[7].matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => m[1]);
+    const meta = {
+        localDomain,
+        baseDomain,
+        testDomain,
+        testGameDomain,
+        masterDomain: match[8],
+        testMasterDomain: match[9]
+    };
+    if (host === localDomain) return {mode: "local", servers: [server(0, localDomain, "Local Test 1")], meta};
+    if (host === testDomain) return {mode: "test", servers: [server(0, testGameDomain, "Public Test")], meta};
+    return {
+        mode: "production",
+        servers: domains.map((domain, index) => server(index, domain, names[index] || `Server ${index + 1}`)),
+        meta
+    };
+}
+
+function server(index, domain, description) {
+    return {index, domain, description, playerCount: 0, maxPlayerCount: 0, ping: null};
+}

package/src/network/session.d.ts

@@ -0,0 +1,7 @@
+export {
+    Session,
+    AnonSession,
+    createSession,
+    createAnonSession,
+    createAnonToken
+} from "../index.js";

package/src/network/session.js

@@ -0,0 +1,320 @@
+import {DEFAULT_BASE_URL, DEFAULT_NOTICE_VERSION, JOIN_USER_AGENT} from "../constants.js";
+import {asNumber, isNode, normalizeBaseUrl} from "../runtime.js";
+import {cookieName, cookiePrefix, readSetCookies, setCookieValues} from "./cookies.js";
+import {HttpClient} from "./http.js";
+import {fetchGameVersion, resolveServer, serverId} from "./servers.js";
+import {createInviteShipSpec, createShipSpec, fetchShipList, fetchShips, shipRef} from "./ships.js";
+import {Connection} from "./connection.js";
+import {DredlessClient} from "../client/index.js";
+
+export class Session {
+    constructor(gameSession = null, gameVersion = null, baseUrl = DEFAULT_BASE_URL) {
+        this.baseUrl = baseUrl;
+        this.cookies = setCookieValues(this.baseUrl, {});
+        this.gameVersion = gameVersion || null;
+        this._noticeVersion = null;
+        this.account = null;
+        this.geoServer = null;
+        this.upgraded = false;
+        this.isRegistered = false;
+        this.showAds = false;
+        this.forceTutorial = false;
+        this.ban = null;
+        if (gameSession) this.cookies.set(cookieName(this.baseUrl, "game_session"), String(gameSession));
+    }
+
+    get gameSession() {
+        return this.cookies.get(cookieName(this.baseUrl, "game_session")) || "";
+    }
+
+    get gameToken() {
+        return this.cookies.get(cookieName(this.baseUrl, "game_token")) || "";
+    }
+
+    get noticeVersion() {
+        return this._noticeVersion ?? this.cookies.get(cookieName(this.baseUrl, "notice_version")) ?? null;
+    }
+
+    set noticeVersion(value) {
+        this._noticeVersion = value == null ? null : Number(value);
+        const key = cookieName(this.baseUrl, "notice_version");
+        if (value == null) this.cookies.delete(key);
+        else this.cookies.set(key, String(value));
+    }
+
+    request(path, init = {}) {
+        return new HttpClient({baseUrl: this.baseUrl, session: this}).request(path, init);
+    }
+
+    async fetchAccountStatus() {
+        const response = await this.request("account/status", {
+            method: "GET",
+            mode: "cors",
+            credentials: "include",
+            referrer: `${this.baseUrl}/`,
+            headers: statusHeaders(this.baseUrl)
+        });
+        if (!response.ok) throw new Error(`account/status failed: ${response.status} ${response.statusText}`);
+        this.mergeSetCookies(response);
+        const raw = await response.json();
+        this.#readStatus(raw);
+        return raw;
+    }
+
+    async fetchShips(server) {
+        return fetchShips(this, server);
+    }
+
+    async fetchShipList(server) {
+        return fetchShipList(this, server);
+    }
+
+    async joinShipConnection(server, ship = null) {
+        return this.#startShipConnection(server, ship, true);
+    }
+
+    async startShipConnection(server, ship = null) {
+        return this.#startShipConnection(server, ship, false);
+    }
+
+    async startNewShipConnection(server, name = "", color = "") {
+        return this.#startShipConnection(server, createShipSpec(name, color), false);
+    }
+
+    async joinInviteConnection(server, code) {
+        return this.#startShipConnection(server, createInviteShipSpec(code), false);
+    }
+
+    async joinShip(server, ship = null) {
+        return readyClient(await this.joinShipConnection(server, ship));
+    }
+
+    async startShip(server, ship = null) {
+        return readyClient(await this.startShipConnection(server, ship));
+    }
+
+    async startNewShip(server, name = "", color = "") {
+        return readyClient(await this.startNewShipConnection(server, name, color));
+    }
+
+    async joinInvite(server, code) {
+        return readyClient(await this.joinInviteConnection(server, code));
+    }
+
+    toJSON() {
+        return {
+            baseUrl: this.baseUrl,
+            gameSession: this.gameSession,
+            gameToken: this.gameToken,
+            gameVersion: this.gameVersion,
+            noticeVersion: this.noticeVersion,
+            cookies: Object.fromEntries(this.cookies),
+            account: this.account,
+            geoServer: this.geoServer,
+            upgraded: this.upgraded,
+            isRegistered: this.isRegistered,
+            showAds: this.showAds,
+            forceTutorial: this.forceTutorial,
+            ban: this.ban,
+        };
+    }
+
+    async #startShipConnection(server, ship, neverLoad) {
+        if (server == null) throw new Error("A server id or server object is required");
+        const resolvedServer = await resolveServer(server, this.baseUrl);
+        if (!resolvedServer) throw new Error(`Unable to resolve server ${serverId(server)}`);
+        if (!this.gameVersion) this.gameVersion = await fetchGameVersion(this.baseUrl);
+        if (this.noticeVersion == null) this.noticeVersion = DEFAULT_NOTICE_VERSION;
+
+        const joinShip = ship == null ? createShipSpec("", "") : shipRef(ship);
+        const response = await this.request("join", {
+            method: "POST",
+            mode: "cors",
+            credentials: "include",
+            referrer: `${this.baseUrl}/`,
+            body: {
+                join_info: {
+                    game_version: this.gameVersion,
+                    hide_badges: false,
+                    never_load: Boolean(neverLoad),
+                    server_id: resolvedServer.index,
+                    ship: joinShip
+                }
+            },
+            headers: joinHeaders(this.baseUrl)
+        });
+        if (!response.ok) throw new Error(`Join request failed: ${await response.text()}`);
+        this.mergeSetCookies(response, ["game_session", "anon_key", "game_token"]);
+        const join = await response.json();
+        if (join.reject != null) {
+            const error = new Error(joinRejectMessage(join.reject, {
+                neverLoad,
+                ship: joinShip,
+                server: resolvedServer
+            }));
+            error.code = join.reject;
+            error.join = join;
+            throw error;
+        }
+        if (join.okay !== true) throw new Error("Bad join result");
+
+        const token = this.gameToken;
+        if (!token) throw new Error("Join did not return a game_token cookie");
+        return new Connection(this, token, join.net_port, Number.isInteger(join.server_id) ? join.server_id : resolvedServer.index, resolvedServer);
+    }
+
+    mergeSetCookies(response, names = ["game_session", "anon_key"]) {
+        const prefix = cookiePrefix(this.baseUrl);
+        for (const [name, value] of readSetCookies(response.headers, names, this.baseUrl)) {
+            const cookieName = name.startsWith(prefix) ? name : `${prefix}${name}`;
+            this.cookies.set(cookieName, value);
+        }
+    }
+
+    #readStatus(raw) {
+        const account = raw?.account && typeof raw.account === "object" ? raw.account : null;
+        this.account = account ? {
+            name: account.name || account.username || account.display_name || account.displayName || account.handle || "Unknown",
+            color: asNumber(account.color, 0),
+            game_rank: asNumber(account.game_rank, 0),
+            user_badges: Array.isArray(account.user_badges) ? account.user_badges.filter((item) => typeof item === "string") : [],
+            is_registered: Boolean(account.is_registered)
+        } : null;
+        this.geoServer = asNumber(raw?.geo_server ?? raw?.geoServer, null);
+        this.upgraded = Boolean(raw?.upgraded ?? account?.upgraded);
+        this.isRegistered = Boolean(account?.is_registered);
+        this.showAds = Boolean(raw?.show_ads ?? raw?.showAds);
+        this.forceTutorial = Boolean(raw?.force_tutorial ?? raw?.forceTutorial);
+        this.ban = raw?.ban || null;
+    }
+}
+
+export class AnonSession extends Session {
+    constructor(gameSession = null, anonKey = null, gameVersion = null, baseUrl = DEFAULT_BASE_URL) {
+        super(gameSession, gameVersion, baseUrl);
+        if (anonKey) this.cookies.set(cookieName(this.baseUrl, "anon_key"), String(anonKey));
+    }
+
+    get anonKey() {
+        return this.cookies.get(cookieName(this.baseUrl, "anon_key")) || "";
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            anonKey: this.anonKey
+        };
+    }
+}
+
+export async function createSession(noticeVersion = null, baseUrl = DEFAULT_BASE_URL) {
+    const resolvedBaseUrl = normalizeBaseUrl(arguments.length >= 2 ? arguments[1] : baseUrl);
+    const session = new Session(null, null, resolvedBaseUrl);
+    session.noticeVersion = await internalNoticeVersion(noticeVersion, resolvedBaseUrl);
+    await session.fetchAccountStatus();
+    return session;
+}
+
+export async function createAnonToken(noticeVersion = null, baseUrl = DEFAULT_BASE_URL) {
+    const resolvedBaseUrl = normalizeBaseUrl(arguments.length >= 2 ? arguments[1] : baseUrl);
+    const session = new AnonSession(null, null, null, resolvedBaseUrl);
+    session.noticeVersion = await internalNoticeVersion(noticeVersion, resolvedBaseUrl);
+    const response = await session.request("account/login/anon", {
+        method: "POST",
+        mode: "cors",
+        credentials: "include",
+        referrer: `${session.baseUrl}/`,
+        headers: anonHeaders(session.baseUrl)
+    });
+    if (response.status === 503) throw new Error("Anon token creation is rate limited by the server");
+    if (!response.ok) throw new Error(`account/login/anon failed: ${response.status} ${response.statusText}`);
+    session.mergeSetCookies(response, ["anon_key", "game_session"]);
+    if (!session.anonKey) throw new Error("Unable to obtain anon_key");
+    return session.anonKey;
+}
+
+export async function createAnonSession(anonKey = null, noticeVersion = null, baseUrl = DEFAULT_BASE_URL) {
+    if (typeof noticeVersion === "string" && noticeVersion.includes("://") && (baseUrl == null || baseUrl === DEFAULT_BASE_URL)) {
+        baseUrl = noticeVersion;
+        noticeVersion = null;
+    }
+    const resolvedBaseUrl = normalizeBaseUrl(arguments.length >= 3 ? arguments[2] : baseUrl);
+    const resolvedAnonKey = anonKey || await createAnonToken(noticeVersion, resolvedBaseUrl);
+    const session = new AnonSession(null, resolvedAnonKey, null, resolvedBaseUrl);
+    session.baseUrl = resolvedBaseUrl;
+    session.noticeVersion = await internalNoticeVersion(noticeVersion, resolvedBaseUrl);
+    await session.fetchAccountStatus();
+    return session;
+}
+
+async function readyClient(connection) {
+    const client = new DredlessClient(connection);
+    await client.whenReady();
+    return client;
+}
+
+async function internalNoticeVersion(value, baseUrl = DEFAULT_BASE_URL) {
+    if (value != null) return value;
+    try {
+        const {fetchNoticeVersion} = await import("./servers.js");
+        return await fetchNoticeVersion(baseUrl);
+    } catch (_) {
+        return DEFAULT_NOTICE_VERSION;
+    }
+}
+
+function statusHeaders(baseUrl) {
+    const headers = {accept: "*/*"};
+    if (isNode()) {
+        Object.assign(headers, {
+            "user-agent": JOIN_USER_AGENT,
+            "accept-language": "en-US,en;q=0.9",
+            referer: `${normalizeBaseUrl(baseUrl)}/`,
+            dnt: "1",
+            "sec-gpc": "1",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin"
+        });
+    }
+    return headers;
+}
+
+function anonHeaders(baseUrl) {
+    const origin = normalizeBaseUrl(baseUrl);
+    return {
+        accept: "*/*",
+        origin,
+        referer: `${origin}/`
+    };
+}
+
+function joinHeaders(baseUrl) {
+    const headers = {
+        accept: "*/*",
+        "accept-language": "en-US,en;q=0.9",
+        "content-type": "application/json",
+        origin: normalizeBaseUrl(baseUrl),
+        referer: `${normalizeBaseUrl(baseUrl)}/`,
+        pragma: "no-cache",
+        "cache-control": "no-cache",
+        dnt: "1",
+        "sec-gpc": "1",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        priority: "u=0"
+    };
+    if (isNode()) headers["user-agent"] = JOIN_USER_AGENT;
+    return headers;
+}
+
+function joinRejectMessage(code, {neverLoad, ship, server} = {}) {
+    if (code === 4007 && neverLoad) {
+        const name = ship?.name ? ` "${ship.name}"` : "";
+        const id = ship?.id != null ? ` (${ship.id})` : "";
+        const serverText = server?.description ? ` on ${server.description}` : "";
+        return `join rejected: 4007. ${name}${id}${serverText} could not be joined with never_load=true. Use session.startShip(server, ship) instead of session.joinShip(server, ship) when loading or starting a saved ship.`;
+    }
+    return `join rejected: ${code}`;
+}

package/src/network/ships.d.ts

@@ -0,0 +1,12 @@
+export {
+    fetchShips,
+    fetchShipList,
+    type Ship,
+    type ShipList,
+    type ShipRef,
+    type ShipSpec
+} from "../index.js";
+
+export function createShipSpec(name?: string, color?: string): ShipSpec;
+
+export function createInviteShipSpec(code: string): ShipSpec;

package/src/network/ships.js

@@ -0,0 +1,73 @@
+import {DEFAULT_BASE_URL} from "../constants.js";
+import {asNumber} from "../runtime.js";
+import {HttpClient} from "./http.js";
+
+export function createShipSpec(name = "", color = "") {
+    return {type: "new", name: String(name ?? ""), color: String(color ?? "")};
+}
+
+export function createInviteShipSpec(code) {
+    return {type: "invite", code: String(code ?? "")};
+}
+
+export function shipRef(ship) {
+    if (ship == null) return null;
+    if (typeof ship !== "object") return {type: "join_or_load", id: ship};
+    if (ship.type) return ship;
+    const id = ship.id ?? ship.hexCode ?? ship.hex_code;
+    if (id != null) return {type: "join_or_load", id};
+    return ship;
+}
+
+export const normalizeShipSpec = shipRef;
+
+export function normalizeShip(raw, key = null) {
+    if (!raw || typeof raw !== "object") return null;
+    const id = Number(raw.id ?? key);
+    return {
+        id: Number.isFinite(id) ? id : null,
+        hexCode: raw.hex_code || raw.hexCode || raw.id || key || null,
+        name: raw.team_name || "Unknown Ship",
+        iconUrl: raw.icon_path || null,
+        playerCount: asNumber(raw.player_count, 0),
+        owned: Boolean(raw.owned),
+        saved: Boolean(raw.saved),
+        color: raw.color || "",
+        time: asNumber(raw.time, null)
+    };
+}
+
+function extractShips(data) {
+    if (Array.isArray(data)) return data.map((ship, index) => [ship?.id || String(index), ship]);
+    if (Array.isArray(data?.ships)) return data.ships.map((ship, index) => [ship?.id || String(index), ship]);
+    if (data?.ships && typeof data.ships === "object") return Object.entries(data.ships);
+    return [];
+}
+
+export async function fetchShips(session, server, baseUrl = session?.baseUrl || DEFAULT_BASE_URL) {
+    const data = await fetchShipList(session, server, baseUrl);
+    return Array.isArray(data) ? data : Array.isArray(data?.ships) ? data.ships : [];
+}
+
+export async function fetchShipList(session, server, baseUrl = session?.baseUrl || DEFAULT_BASE_URL) {
+    if (!session) throw new Error("fetchShipList requires a session");
+    const serverId = Number(server && typeof server === "object" ? server.index ?? server.id : server ?? session.geoServer ?? 0);
+    const data = await new HttpClient({baseUrl, session}).json(`shiplist?server=${serverId}`, {
+        headers: {accept: "application/json"}
+    });
+    const ships = normalizeShipList(data);
+    if (Array.isArray(data)) return {ships};
+    if (data && typeof data === "object") {
+        return {
+            playerCount: asNumber(data.player_count, 0),
+            maxPlayerCount: asNumber(data.max_player_count, 0),
+            isMuted: Boolean(data.is_muted),
+            ships
+        };
+    }
+    return {ships};
+}
+
+function normalizeShipList(data) {
+    return extractShips(data).map(([key, raw]) => normalizeShip(raw, key)).filter(Boolean);
+}

package/src/node.d.ts

@@ -0,0 +1,2 @@
+export * from "./index.js";
+export {default} from "./index.js";

package/src/node.js

@@ -0,0 +1,8 @@
+import {enableNativeChaCha20} from "./crypto/chacha-native.js";
+
+// Node resolves the package root through this entry, so opting into the native
+// ChaCha20 backend here keeps `node:crypto` out of the browser build.
+enableNativeChaCha20();
+
+export * from "./index.js";
+export {default} from "./index.js";

package/src/protocol/codec/binary.d.ts

@@ -0,0 +1,3 @@
+export function toUint8Array(value: Uint8Array | ArrayBuffer | number[]): Uint8Array;
+export function concatBytes(...values: Array<Uint8Array | ArrayBuffer | number[]>): Uint8Array;
+export function valuesEqual(a: unknown, b: unknown): boolean;

package/src/protocol/codec/binary.js

@@ -0,0 +1,52 @@
+import {encoder} from "../../constants.js";
+
+function objectTag(value) {
+    return Object.prototype.toString.call(value);
+}
+
+function isArrayBufferLike(value) {
+    const tag = objectTag(value);
+    return tag === "[object ArrayBuffer]" || tag === "[object SharedArrayBuffer]";
+}
+
+function toUint8Array(value) {
+    if (value instanceof Uint8Array) return value;
+    if (isArrayBufferLike(value)) return new Uint8Array(value);
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    }
+    if (Array.isArray(value)) return Uint8Array.from(value);
+    if (typeof value === "string") return encoder.encode(value);
+    throw new Error(`Unsupported binary value: ${objectTag(value)}`);
+}
+
+function concatBytes(parts) {
+    const total = parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+
+function valuesEqual(a, b) {
+    if (a === b) return true;
+    if (a == null || b == null) return a == null && b == null;
+    if (typeof a !== "object" || typeof b !== "object") return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+        if (!valuesEqual(a[key], b[key])) return false;
+    }
+    return true;
+}
+
+
+export {
+    toUint8Array,
+    concatBytes,
+    valuesEqual
+};

package/src/protocol/codec/msgpack.d.ts

@@ -0,0 +1,3 @@
+export function decodeMsgpack(bytes: Uint8Array | ArrayBuffer | number[]): unknown;
+
+export function encodeMsgpack(value: unknown): Uint8Array;