dredless 0.2.0

package/src/protocol/outbound/commands.js

@@ -0,0 +1,149 @@
+import {COMMAND_DEFAULT_FORMATS, COMMAND_FIELDS, encoder} from "../../constants.js";
+import {concatBytes, toUint8Array} from "../codec/binary.js";
+import {cloneDragValue, encodeMapHeader, encodeStringBytes, encodeValue} from "../codec/msgpack.js";
+
+const SHA256_K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+
+function buildCommandDefaults(command = {}) {
+    const out = {};
+    for (const key of COMMAND_FIELDS) {
+        if (key === "drag") {
+            out[key] = cloneDragValue(command[key]);
+            continue;
+        }
+        if (command[key] !== undefined) out[key] = command[key];
+        else if (COMMAND_DEFAULT_FORMATS[key] === "nil") out[key] = null;
+        else if (COMMAND_DEFAULT_FORMATS[key] === "bool") out[key] = false;
+        else if (COMMAND_DEFAULT_FORMATS[key] === "float32") out[key] = 0;
+        else out[key] = 0;
+    }
+    out.type = command.type ?? 0;
+    out.n = command.n ?? null;
+    return out;
+}
+
+// Field names and the map header are identical for every command, so encode
+// them once instead of on each send.
+const COMMAND_MAP_HEADER = encodeMapHeader(COMMAND_FIELDS.length);
+const COMMAND_FIELD_KEY_BYTES = COMMAND_FIELDS.map((key) => encodeStringBytes(key));
+
+function buildCommandBody(command) {
+    const normalized = buildCommandDefaults(command);
+    const parts = [COMMAND_MAP_HEADER];
+    for (let i = 0; i < COMMAND_FIELDS.length; i++) {
+        parts.push(COMMAND_FIELD_KEY_BYTES[i]);
+        parts.push(encodeValue(COMMAND_FIELDS[i], normalized[COMMAND_FIELDS[i]], null));
+    }
+    return concatBytes(parts);
+}
+
+// The prefix depends only on the session id, which is fixed for a connection.
+let signaturePrefixSid = null;
+let signaturePrefixBytes = null;
+
+function buildSignaturePrefix(sessionId) {
+    const sid = Number(sessionId) >>> 0;
+    if (sid === signaturePrefixSid && signaturePrefixBytes) return signaturePrefixBytes;
+    const a = (sid ^ 52481) >>> 0;
+    const b = ((sid << 2) + 69) >>> 0;
+    const c = ((((sid >>> 1) * 5) >>> 0) + 420) >>> 0;
+    signaturePrefixBytes = encoder.encode(`MJAF${a}CANH${b}SCLJ${c}LODV`);
+    signaturePrefixSid = sid;
+    return signaturePrefixBytes;
+}
+
+function rightRotate(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+
+function sha256(bytes) {
+    const input = toUint8Array(bytes);
+    const bitLength = input.length * 8;
+    const paddingLength = ((56 - ((input.length + 1) % 64)) + 64) % 64;
+    const padded = new Uint8Array(input.length + 1 + paddingLength + 8);
+    padded.set(input, 0);
+    padded[input.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    const high = Math.floor(bitLength / 0x100000000);
+    const low = bitLength >>> 0;
+    view.setUint32(padded.length - 8, high, false);
+    view.setUint32(padded.length - 4, low, false);
+
+    const state = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    ]);
+    const schedule = new Uint32Array(64);
+
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let index = 0; index < 16; index++) schedule[index] = view.getUint32(offset + index * 4, false);
+        for (let index = 16; index < 64; index++) {
+            const s0 = rightRotate(schedule[index - 15], 7) ^ rightRotate(schedule[index - 15], 18) ^ (schedule[index - 15] >>> 3);
+            const s1 = rightRotate(schedule[index - 2], 17) ^ rightRotate(schedule[index - 2], 19) ^ (schedule[index - 2] >>> 10);
+            schedule[index] = (((schedule[index - 16] + s0) >>> 0) + ((schedule[index - 7] + s1) >>> 0)) >>> 0;
+        }
+
+        let a = state[0], b = state[1], c = state[2], d = state[3], e = state[4], f = state[5], g = state[6],
+            h = state[7];
+        for (let index = 0; index < 64; index++) {
+            const S1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = (((((h + S1) >>> 0) + ch) >>> 0) + ((SHA256_K[index] + schedule[index]) >>> 0)) >>> 0;
+            const S0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (S0 + maj) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) >>> 0;
+        }
+
+        state[0] = (state[0] + a) >>> 0;
+        state[1] = (state[1] + b) >>> 0;
+        state[2] = (state[2] + c) >>> 0;
+        state[3] = (state[3] + d) >>> 0;
+        state[4] = (state[4] + e) >>> 0;
+        state[5] = (state[5] + f) >>> 0;
+        state[6] = (state[6] + g) >>> 0;
+        state[7] = (state[7] + h) >>> 0;
+    }
+
+    const out = new Uint8Array(32);
+    const outView = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++) outView.setUint32(i * 4, state[i], false);
+    return out;
+}
+
+function signCommandBody(body, sessionId) {
+    return sha256(concatBytes([buildSignaturePrefix(sessionId), body, encoder.encode("YXTG")]));
+}
+
+function buildSignedCommandPacket(command, sessionId) {
+    const body = buildCommandBody(command);
+    const signature = signCommandBody(body, sessionId);
+    return concatBytes([body, signature]);
+}
+
+
+export {
+    buildCommandDefaults,
+    buildCommandBody,
+    buildSignaturePrefix,
+    rightRotate,
+    sha256,
+    signCommandBody,
+    buildSignedCommandPacket
+};

package/src/protocol/outbound/comms.d.ts

@@ -0,0 +1,28 @@
+export interface CommsMessage {
+    type: 3;
+    msg: string;
+}
+
+export interface NormalizedCommsMessage {
+    raw: unknown;
+    text: string;
+}
+
+export interface CommsEvent {
+    type: "comms";
+    filter?: number;
+    ent_id: number | null;
+    entity: number | null;
+    msgs_text: unknown[];
+    rawMessages: unknown[];
+    messages: NormalizedCommsMessage[];
+    update?: boolean;
+}
+
+export function buildCommsMessage(message?: string): CommsMessage;
+
+export function normalizeCommsEvent(event: unknown): CommsEvent;
+
+export function flattenRichText(value: unknown): string;
+
+export const COMMS_MESSAGE_TYPE: 3;

package/src/protocol/outbound/comms.js

@@ -0,0 +1,40 @@
+const COMMS_MESSAGE_TYPE = 3;
+
+function buildCommsMessage(message = "") {
+    return {
+        type: COMMS_MESSAGE_TYPE,
+        msg: String(message)
+    };
+}
+
+function normalizeCommsEvent(event) {
+    const rawMessages = Array.isArray(event?.msgs_text) ? event.msgs_text : [];
+    return {
+        ...event,
+        entity: event?.ent_id != null && Number.isFinite(Number(event.ent_id)) ? Number(event.ent_id) : null,
+        rawMessages,
+        messages: rawMessages.map((message) => ({
+            raw: message,
+            text: flattenRichText(message)
+        }))
+    };
+}
+
+function flattenRichText(value) {
+    if (value == null) return "";
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    if (Array.isArray(value)) return value.map(flattenRichText).join("");
+    if (typeof value === "object") {
+        if (Object.hasOwn(value, "c")) return flattenRichText(value.c);
+        if (Object.hasOwn(value, "text")) return flattenRichText(value.text);
+    }
+    return "";
+}
+
+export {
+    COMMS_MESSAGE_TYPE,
+    buildCommsMessage,
+    flattenRichText,
+    normalizeCommsEvent
+};

package/src/protocol/outbound/inventory.d.ts

@@ -0,0 +1,64 @@
+export const EquipmentSlot: {
+    readonly Head: "head";
+    readonly Face: "face";
+    readonly Body: "body";
+    readonly Back: "back";
+    readonly Hands: "hands";
+    readonly Feet: "feet";
+};
+export type EquipmentSlot = typeof EquipmentSlot[keyof typeof EquipmentSlot];
+
+export interface InventoryDragCommand {
+    drag: {
+        source: number;
+        target: number;
+        split: boolean;
+    };
+}
+
+export interface InventorySlotSnapshot {
+    index: number;
+    itemId: number | null;
+    itemName: string | null;
+    count: number;
+    kind: "hotbar" | "equipment";
+    equipmentSlot: "head" | "face" | "body" | "back" | "hands" | "feet" | null;
+    empty: boolean;
+}
+
+export interface InventoryState {
+    type: "inventory";
+    filter?: number;
+    hotbarSize: number;
+    slots: InventorySlotSnapshot[];
+    hotbar: InventorySlotSnapshot[];
+    equipment: {
+        head: InventorySlotSnapshot;
+        face: InventorySlotSnapshot;
+        body: InventorySlotSnapshot;
+        back: InventorySlotSnapshot;
+        hands: InventorySlotSnapshot;
+        feet: InventorySlotSnapshot;
+    };
+}
+
+export function normalizeEquipmentSlot(slot: EquipmentSlot): 16 | 17 | 18 | 19 | 20 | 21;
+
+export function equipmentSlotName(slot: number): "head" | "face" | "body" | "back" | "hands" | "feet" | null;
+
+export function buildInventoryDragCommand(source: number, target: number, split?: boolean): InventoryDragCommand;
+
+export function buildEquipItemCommand(source: number, slot: EquipmentSlot, split?: boolean): InventoryDragCommand;
+
+export function buildUnequipItemCommand(slot: EquipmentSlot, target?: number, split?: boolean): InventoryDragCommand;
+
+export function normalizeInventoryEvent(event: unknown): InventoryState;
+
+export const EQUIPMENT_SLOT_INDEXES: Readonly<{
+    head: 16;
+    face: 17;
+    body: 18;
+    back: 19;
+    hands: 20;
+    feet: 21;
+}>;

package/src/protocol/outbound/inventory.js

@@ -0,0 +1,147 @@
+import {itemNameFromId} from "../../state/items.js";
+
+export const EquipmentSlot = Object.freeze({
+    Head: "head",
+    Face: "face",
+    Body: "body",
+    Back: "back",
+    Hands: "hands",
+    Feet: "feet"
+});
+
+const EQUIPMENT_SLOT_INDEXES = Object.freeze({
+    [EquipmentSlot.Head]: 16,
+    [EquipmentSlot.Face]: 17,
+    [EquipmentSlot.Body]: 18,
+    [EquipmentSlot.Back]: 19,
+    [EquipmentSlot.Hands]: 20,
+    [EquipmentSlot.Feet]: 21
+});
+
+const EQUIPMENT_SLOT_NAMES = new Map([
+    [16, EquipmentSlot.Head],
+    [17, EquipmentSlot.Face],
+    [18, EquipmentSlot.Body],
+    [19, EquipmentSlot.Back],
+    [20, EquipmentSlot.Hands],
+    [21, EquipmentSlot.Feet]
+]);
+
+const EQUIPMENT_SLOT_VALUES = new Map([
+    [EquipmentSlot.Head, 16],
+    [EquipmentSlot.Face, 17],
+    [EquipmentSlot.Body, 18],
+    [EquipmentSlot.Back, 19],
+    [EquipmentSlot.Hands, 20],
+    [EquipmentSlot.Feet, 21]
+]);
+
+function normalizeEquipmentSlot(slot) {
+    const normalized = EQUIPMENT_SLOT_VALUES.get(slot);
+    if (!EQUIPMENT_SLOT_NAMES.has(normalized)) {
+        throw new RangeError(`equipment slot must be an EquipmentSlot value`);
+    }
+    return normalized;
+}
+
+function equipmentSlotName(slot) {
+    return EQUIPMENT_SLOT_NAMES.get(Number(slot)) ?? null;
+}
+
+function buildInventoryDragCommand(source, target, split = false) {
+    return {
+        drag: {
+            source: normalizeInventoryIndex(source, "source"),
+            target: normalizeInventoryIndex(target, "target"),
+            split: Boolean(split)
+        }
+    };
+}
+
+function buildEquipItemCommand(source, slot, split = false) {
+    return buildInventoryDragCommand(source, normalizeEquipmentSlot(slot), split);
+}
+
+function buildUnequipItemCommand(slot, target = 0, split = false) {
+    return buildInventoryDragCommand(normalizeEquipmentSlot(slot), target, split);
+}
+
+function normalizeInventoryEvent(event) {
+    const items = Array.isArray(event?.items) ? event.items : [];
+    const counts = Array.isArray(event?.item_counts) ? event.item_counts : [];
+    const rawHotbarSize = Number(event?.general_slots ?? 0);
+    const hotbarSize = Number.isFinite(rawHotbarSize) && rawHotbarSize > 0 ? Math.trunc(rawHotbarSize) : 0;
+
+    const slotSnapshot = (index, kind) => {
+        const count = normalizeCount(counts[index]);
+        const itemId = normalizeItemId(items[index], count);
+        return {
+            index,
+            itemId,
+            itemName: itemNameFromId(itemId),
+            count,
+            kind,
+            equipmentSlot: equipmentSlotName(index),
+            empty: itemId == null || count <= 0
+        };
+    };
+
+    const slotsByIndex = new Map();
+    for (let index = 0; index < hotbarSize; index++) {
+        slotsByIndex.set(index, slotSnapshot(index, "hotbar"));
+    }
+    slotsByIndex.set(EQUIPMENT_SLOT_INDEXES.head, slotSnapshot(EQUIPMENT_SLOT_INDEXES.head, "equipment"));
+    slotsByIndex.set(EQUIPMENT_SLOT_INDEXES.face, slotSnapshot(EQUIPMENT_SLOT_INDEXES.face, "equipment"));
+    slotsByIndex.set(EQUIPMENT_SLOT_INDEXES.body, slotSnapshot(EQUIPMENT_SLOT_INDEXES.body, "equipment"));
+    slotsByIndex.set(EQUIPMENT_SLOT_INDEXES.back, slotSnapshot(EQUIPMENT_SLOT_INDEXES.back, "equipment"));
+    slotsByIndex.set(EQUIPMENT_SLOT_INDEXES.hands, slotSnapshot(EQUIPMENT_SLOT_INDEXES.hands, "equipment"));
+    slotsByIndex.set(EQUIPMENT_SLOT_INDEXES.feet, slotSnapshot(EQUIPMENT_SLOT_INDEXES.feet, "equipment"));
+
+    const slots = [...slotsByIndex.values()].sort((a, b) => a.index - b.index);
+    const hotbar = slots.filter((slot) => slot.kind === "hotbar");
+    const equipment = {
+        head: slotsByIndex.get(EQUIPMENT_SLOT_INDEXES.head),
+        face: slotsByIndex.get(EQUIPMENT_SLOT_INDEXES.face),
+        body: slotsByIndex.get(EQUIPMENT_SLOT_INDEXES.body),
+        back: slotsByIndex.get(EQUIPMENT_SLOT_INDEXES.back),
+        hands: slotsByIndex.get(EQUIPMENT_SLOT_INDEXES.hands),
+        feet: slotsByIndex.get(EQUIPMENT_SLOT_INDEXES.feet)
+    };
+
+    return {
+        type: "inventory",
+        filter: event?.filter,
+        hotbarSize,
+        slots,
+        hotbar,
+        equipment
+    };
+}
+
+function normalizeInventoryIndex(value, name) {
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < 0) throw new RangeError(`${name} must be a non-negative integer inventory slot`);
+    return number;
+}
+
+function normalizeCount(value) {
+    const number = Number(value ?? 0);
+    return Number.isFinite(number) ? number : 0;
+}
+
+function normalizeItemId(value, count) {
+    if (value == null) return null;
+    const number = Number(value);
+    if (!Number.isFinite(number)) return null;
+    return number === 0 && count === 0 ? null : number;
+}
+
+export {
+    EQUIPMENT_SLOT_INDEXES,
+    buildEquipItemCommand,
+    buildInventoryDragCommand,
+    buildUnequipItemCommand,
+    equipmentSlotName,
+    normalizeEquipmentSlot,
+    normalizeInventoryEvent
+};

package/src/protocol/outbound/ship-management.d.ts

@@ -0,0 +1,84 @@
+export type ShipPrivacy = 0 | 1 | boolean | "public" | "private";
+export type ShipPlayerRank = 0 | 1 | 3 | "guest" | "crew" | "captain";
+
+export interface ShipManagementMessage {
+    type: 4;
+    act: string;
+    arg: unknown;
+    rank?: unknown;
+}
+
+export interface ShipConfig {
+    privacy: number | null;
+    privacyName: "public" | "private" | null;
+    inviteKey: string | null;
+    teamId: number | null;
+    patronPerks: unknown[];
+}
+
+export interface CaptainSubrank {
+    subrank: number | null;
+    enableCheats: boolean;
+}
+
+export interface PlayerListEntry {
+    refId: number | null;
+    discrim: string | null;
+    discrimColor: number | null;
+    teamRank: number | null;
+    captainRank: number | null;
+    isCaptain: boolean;
+    isShipOwner: boolean;
+    canBeManaged: boolean;
+    time: number | null;
+    items: unknown[];
+    aliasDiscrims: unknown[];
+    extraAliasCount: number;
+    onlineCount: number | null;
+}
+
+export interface ShipPlayerList {
+    ownerCaptainRank: number | null;
+    shipOwners: PlayerListEntry[];
+    players: PlayerListEntry[];
+    changes: PlayerListEntry[];
+    removedPlayers: number[];
+}
+
+export function buildShipManagementMessage(act: string, arg?: unknown, extra?: Record<string, unknown> | null): ShipManagementMessage;
+
+export function buildShipPrivacyMessage(privacy: ShipPrivacy): ShipManagementMessage;
+
+export function buildStarterRecoveryMessage(itemId: number): ShipManagementMessage;
+
+export function buildPlayerListMessage(): ShipManagementMessage;
+
+export function buildInviteResetMessage(): ShipManagementMessage;
+
+export function buildSetPlayerRankMessage(refId: number, rank: ShipPlayerRank): ShipManagementMessage;
+
+export function buildKickPlayerMessage(refId: number): ShipManagementMessage;
+
+export function buildBanPlayerMessage(refId: number): ShipManagementMessage;
+
+export function buildDemoteSelfMessage(): ShipManagementMessage;
+
+export function normalizePrivacy(privacy: ShipPrivacy): 0 | 1;
+
+export function normalizePlayerRank(rank: ShipPlayerRank): 0 | 1 | 3;
+
+export function normalizeShipConfig(event: unknown): ShipConfig;
+
+export function normalizeCaptainSubrank(event: unknown): CaptainSubrank;
+
+export function normalizeShipPlayerList(event: unknown, previous?: ShipPlayerList | null, currentCaptainSubrank?: CaptainSubrank | null): ShipPlayerList;
+
+export const BAN_ACTION: "ban";
+export const DEMOTE_SELF_ACTION: "demote_self";
+export const KICK_ACTION: "kick";
+export const PLAYER_LIST_ACTION: "player_list";
+export const INVITE_RESET_ACTION: "invite_reset";
+export const SET_PRIVACY_ACTION: "set_privacy";
+export const SET_RANK_ACTION: "set_rank";
+export const SHIP_MANAGEMENT_TYPE: 4;
+export const STARTER_RECOVERY_ACTION: "starter_recovery";