dredless 0.2.0 → 0.2.1

package/src/client/index.d.ts

@@ -1,2 +1,2 @@
-export {DredlessClient, WrenchMode, TurretMode} from "../index.js";
-export type {DredlessClientOptions, ClientSnapshot} from "../index.js";
+export {DredlessClient, WrenchMode, TurretMode} from "../index.js";
+export type {DredlessClientOptions, ClientSnapshot} from "../index.js";

package/src/client/index.js

@@ -1 +1 @@
-export {DredlessClient, WrenchMode, TurretMode} from "./core.js";
+export {DredlessClient, WrenchMode, TurretMode} from "./core.js";

package/src/compression/lz4.d.ts

@@ -1 +1 @@
-export function decompressLz4Frame(bytes: Uint8Array | ArrayBuffer | number[]): Uint8Array;
+export function decompressLz4Frame(bytes: Uint8Array | ArrayBuffer | number[]): Uint8Array;

package/src/compression/lz4.js

@@ -1,112 +1,112 @@
-import {toUint8Array} from "../protocol/codec/binary.js";
-
-// Growable typed-array sink. LZ4 block headers carry the compressed size, not
-// the decompressed size, so the output buffer starts at a generous multiple and
-// doubles on demand rather than pushing into a plain array one byte at a time.
-function ensureCapacity(buffer, needed) {
-    if (needed <= buffer.length) return buffer;
-    let size = buffer.length || 64;
-    while (size < needed) size *= 2;
-    const grown = new Uint8Array(size);
-    grown.set(buffer);
-    return grown;
-}
-
-function decompressLz4Block(block) {
-    let out = new Uint8Array(Math.max(64, block.length * 4));
-    let len = 0;
-    let pos = 0;
-
-    while (pos < block.length) {
-        const token = block[pos++];
-
-        let literalLen = token >>> 4;
-        if (literalLen === 15) {
-            let b;
-            do {
-                if (pos >= block.length) throw new Error("truncated lz4 literal length");
-                b = block[pos++];
-                literalLen += b;
-            } while (b === 255);
-        }
-
-        if (pos + literalLen > block.length) throw new Error("truncated lz4 literals");
-        if (literalLen > 0) {
-            out = ensureCapacity(out, len + literalLen);
-            out.set(block.subarray(pos, pos + literalLen), len);
-            len += literalLen;
-            pos += literalLen;
-        }
-
-        if (pos >= block.length) break;
-        if (pos + 2 > block.length) throw new Error("truncated lz4 offset");
-        const offset = block[pos] | (block[pos + 1] << 8);
-        pos += 2;
-        if (offset === 0 || offset > len) throw new Error(`invalid lz4 offset ${offset}`);
-
-        let matchLen = token & 0x0f;
-        if (matchLen === 15) {
-            let b;
-            do {
-                if (pos >= block.length) throw new Error("truncated lz4 match length");
-                b = block[pos++];
-                matchLen += b;
-            } while (b === 255);
-        }
-        matchLen += 4;
-
-        out = ensureCapacity(out, len + matchLen);
-        // Matches may overlap the region being written, so copy byte by byte rather
-        // than with copyWithin, which would read the pre-copy bytes.
-        let from = len - offset;
-        for (let i = 0; i < matchLen; i++) out[len++] = out[from++];
-    }
-
-    // Return a compact standalone array, matching the previous contract: callers
-    // must not see a view over a larger backing buffer.
-    return out.length === len ? out : out.slice(0, len);
-}
-
-function decompressLz4Frame(bytes) {
-    const buf = toUint8Array(bytes);
-    if (buf.length < 7) return buf;
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    if (view.getUint32(0, true) !== 0x184d2204) return buf;
-    const flg = buf[4];
-    let pos = 6;
-    if (flg & 0x08) pos += 8;
-    if (flg & 0x01) pos += 4;
-    pos += 1;
-    const chunks = [];
-    let total = 0;
-    while (pos + 4 <= buf.length) {
-        const rawSize = view.getUint32(pos, true);
-        pos += 4;
-        if (rawSize === 0) break;
-        const uncompressed = (rawSize & 0x80000000) !== 0;
-        const size = rawSize & 0x7fffffff;
-        if (pos + size > buf.length) throw new Error("truncated lz4 block");
-        const block = buf.subarray(pos, pos + size);
-        const chunk = uncompressed ? block.slice() : decompressLz4Block(block);
-        chunks.push(chunk);
-        total += chunk.length;
-        pos += size;
-        if (flg & 0x10) pos += 4;
-    }
-    // Single-chunk frames are the common case and need no concatenation pass.
-    if (chunks.length === 1) return chunks[0];
-    if (chunks.length === 0) return new Uint8Array(0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return out;
-}
-
-
-export {
-    decompressLz4Block,
-    decompressLz4Frame
-};
+import {toUint8Array} from "../protocol/codec/binary.js";
+
+// Growable typed-array sink. LZ4 block headers carry the compressed size, not
+// the decompressed size, so the output buffer starts at a generous multiple and
+// doubles on demand rather than pushing into a plain array one byte at a time.
+function ensureCapacity(buffer, needed) {
+    if (needed <= buffer.length) return buffer;
+    let size = buffer.length || 64;
+    while (size < needed) size *= 2;
+    const grown = new Uint8Array(size);
+    grown.set(buffer);
+    return grown;
+}
+
+function decompressLz4Block(block) {
+    let out = new Uint8Array(Math.max(64, block.length * 4));
+    let len = 0;
+    let pos = 0;
+
+    while (pos < block.length) {
+        const token = block[pos++];
+
+        let literalLen = token >>> 4;
+        if (literalLen === 15) {
+            let b;
+            do {
+                if (pos >= block.length) throw new Error("truncated lz4 literal length");
+                b = block[pos++];
+                literalLen += b;
+            } while (b === 255);
+        }
+
+        if (pos + literalLen > block.length) throw new Error("truncated lz4 literals");
+        if (literalLen > 0) {
+            out = ensureCapacity(out, len + literalLen);
+            out.set(block.subarray(pos, pos + literalLen), len);
+            len += literalLen;
+            pos += literalLen;
+        }
+
+        if (pos >= block.length) break;
+        if (pos + 2 > block.length) throw new Error("truncated lz4 offset");
+        const offset = block[pos] | (block[pos + 1] << 8);
+        pos += 2;
+        if (offset === 0 || offset > len) throw new Error(`invalid lz4 offset ${offset}`);
+
+        let matchLen = token & 0x0f;
+        if (matchLen === 15) {
+            let b;
+            do {
+                if (pos >= block.length) throw new Error("truncated lz4 match length");
+                b = block[pos++];
+                matchLen += b;
+            } while (b === 255);
+        }
+        matchLen += 4;
+
+        out = ensureCapacity(out, len + matchLen);
+        // Matches may overlap the region being written, so copy byte by byte rather
+        // than with copyWithin, which would read the pre-copy bytes.
+        let from = len - offset;
+        for (let i = 0; i < matchLen; i++) out[len++] = out[from++];
+    }
+
+    // Return a compact standalone array, matching the previous contract: callers
+    // must not see a view over a larger backing buffer.
+    return out.length === len ? out : out.slice(0, len);
+}
+
+function decompressLz4Frame(bytes) {
+    const buf = toUint8Array(bytes);
+    if (buf.length < 7) return buf;
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    if (view.getUint32(0, true) !== 0x184d2204) return buf;
+    const flg = buf[4];
+    let pos = 6;
+    if (flg & 0x08) pos += 8;
+    if (flg & 0x01) pos += 4;
+    pos += 1;
+    const chunks = [];
+    let total = 0;
+    while (pos + 4 <= buf.length) {
+        const rawSize = view.getUint32(pos, true);
+        pos += 4;
+        if (rawSize === 0) break;
+        const uncompressed = (rawSize & 0x80000000) !== 0;
+        const size = rawSize & 0x7fffffff;
+        if (pos + size > buf.length) throw new Error("truncated lz4 block");
+        const block = buf.subarray(pos, pos + size);
+        const chunk = uncompressed ? block.slice() : decompressLz4Block(block);
+        chunks.push(chunk);
+        total += chunk.length;
+        pos += size;
+        if (flg & 0x10) pos += 4;
+    }
+    // Single-chunk frames are the common case and need no concatenation pass.
+    if (chunks.length === 1) return chunks[0];
+    if (chunks.length === 0) return new Uint8Array(0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+
+
+export {
+    decompressLz4Block,
+    decompressLz4Frame
+};

package/src/constants.js

@@ -1,74 +1,74 @@
-export const DEFAULT_BASE_URL = "https://drednot.io";
-export const DEFAULT_GAME_VERSION = null;
-export const DEFAULT_NOTICE_VERSION = 17;
-
-export const encoder = new TextEncoder();
-export const decoder = new TextDecoder("utf-8");
-
-export const SHARED_CHACHA_MATERIAL = Uint8Array.from([
-    0x15, 0x85, 0x59, 0xc6, 0x26, 0xc4, 0x31, 0x32,
-    0xb8, 0xed, 0xb2, 0xfe, 0x5b, 0x87, 0x5e, 0x5e,
-    0x3d, 0xd9, 0xe3, 0xcc, 0xa3, 0x9b, 0xd6, 0x58,
-    0xe2, 0xdc, 0x0e, 0x8b, 0x96, 0xb7, 0x05, 0x88,
-    0x78, 0xd1, 0xd4, 0xa4, 0x19, 0x3c, 0xb9, 0x1e,
-    0xbe, 0x78, 0x18, 0x12
-]);
-
-export const JOIN_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
-export const KEEPALIVE_INTERVAL_MS = 15_000;
-export const INITIAL_OUTFIT_MESSAGE = {
-    type: 7,
-    outfit: {
-        color_body: 4695355,
-        color_legs: 1393785,
-        color_skin: 13212550,
-        color_feet: 6242065,
-        color_hair: 1118481,
-        style_hair: 0,
-        color_hat: 16716049,
-        style_hat: 0,
-        color_face_1: 8421504,
-        style_face_1: 0,
-        color_face_2: 8421504,
-        style_face_2: 0
-    }
-};
-export const KEEPALIVE_MESSAGE = {type: 2, msg: "/"};
-
-export const COMMAND_FIELDS = [
-    "type", "n", "x", "y", "mx", "my", "vx", "vy",
-    "jump", "jump_held", "drop", "act1", "act1_held", "exit", "act2", "act_alt", "act_alt_held",
-    "wrench_mode", "turret_mode", "scr_w", "scr_h", "motion",
-    "focus_ent", "config_ent", "tip_select", "inv_slot", "blur", "drag"
-];
-
-export const COMMAND_DEFAULT_FORMATS = {
-    type: "positive-fixint",
-    n: "uint16",
-    x: "float32",
-    y: "float32",
-    mx: "float32",
-    my: "float32",
-    vx: "float32",
-    vy: "float32",
-    jump: "bool",
-    jump_held: "bool",
-    drop: "bool",
-    act1: "bool",
-    act1_held: "bool",
-    exit: "bool",
-    act2: "bool",
-    act_alt: "bool",
-    act_alt_held: "bool",
-    wrench_mode: "positive-fixint",
-    turret_mode: "positive-fixint",
-    scr_w: "uint16",
-    scr_h: "uint16",
-    motion: "float32",
-    focus_ent: "nil",
-    config_ent: "nil",
-    tip_select: "nil",
-    inv_slot: "positive-fixint",
-    blur: "bool",
-    drag: "nil"
-};
+export const DEFAULT_BASE_URL = "https://drednot.io";
+export const DEFAULT_GAME_VERSION = null;
+export const DEFAULT_NOTICE_VERSION = 17;
+
+export const encoder = new TextEncoder();
+export const decoder = new TextDecoder("utf-8");
+
+export const SHARED_CHACHA_MATERIAL = Uint8Array.from([
+    0x15, 0x85, 0x59, 0xc6, 0x26, 0xc4, 0x31, 0x32,
+    0xb8, 0xed, 0xb2, 0xfe, 0x5b, 0x87, 0x5e, 0x5e,
+    0x3d, 0xd9, 0xe3, 0xcc, 0xa3, 0x9b, 0xd6, 0x58,
+    0xe2, 0xdc, 0x0e, 0x8b, 0x96, 0xb7, 0x05, 0x88,
+    0x78, 0xd1, 0xd4, 0xa4, 0x19, 0x3c, 0xb9, 0x1e,
+    0xbe, 0x78, 0x18, 0x12
+]);
+
+export const JOIN_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+export const KEEPALIVE_INTERVAL_MS = 15_000;
+export const INITIAL_OUTFIT_MESSAGE = {
+    type: 7,
+    outfit: {
+        color_body: 4695355,
+        color_legs: 1393785,
+        color_skin: 13212550,
+        color_feet: 6242065,
+        color_hair: 1118481,
+        style_hair: 0,
+        color_hat: 16716049,
+        style_hat: 0,
+        color_face_1: 8421504,
+        style_face_1: 0,
+        color_face_2: 8421504,
+        style_face_2: 0
+    }
+};
+export const KEEPALIVE_MESSAGE = {type: 2, msg: "/"};
+
+export const COMMAND_FIELDS = [
+    "type", "n", "x", "y", "mx", "my", "vx", "vy",
+    "jump", "jump_held", "drop", "act1", "act1_held", "exit", "act2", "act_alt", "act_alt_held",
+    "wrench_mode", "turret_mode", "scr_w", "scr_h", "motion",
+    "focus_ent", "config_ent", "tip_select", "inv_slot", "blur", "drag"
+];
+
+export const COMMAND_DEFAULT_FORMATS = {
+    type: "positive-fixint",
+    n: "uint16",
+    x: "float32",
+    y: "float32",
+    mx: "float32",
+    my: "float32",
+    vx: "float32",
+    vy: "float32",
+    jump: "bool",
+    jump_held: "bool",
+    drop: "bool",
+    act1: "bool",
+    act1_held: "bool",
+    exit: "bool",
+    act2: "bool",
+    act_alt: "bool",
+    act_alt_held: "bool",
+    wrench_mode: "positive-fixint",
+    turret_mode: "positive-fixint",
+    scr_w: "uint16",
+    scr_h: "uint16",
+    motion: "float32",
+    focus_ent: "nil",
+    config_ent: "nil",
+    tip_select: "nil",
+    inv_slot: "positive-fixint",
+    blur: "bool",
+    drag: "nil"
+};

package/src/crypto/chacha-native.d.ts

@@ -1,9 +1,9 @@
-import type {ChaCha20Backend} from "./chacha.js";
-
-/**
- * Node-only. Installs OpenSSL's `chacha20` as the ChaCha20 backend when it is
- * available. Returns false when the cipher is not present in this build.
- */
-export function enableNativeChaCha20(): boolean;
-
-export const nativeChaCha20: ChaCha20Backend;
+import type {ChaCha20Backend} from "./chacha.js";
+
+/**
+ * Node-only. Installs OpenSSL's `chacha20` as the ChaCha20 backend when it is
+ * available. Returns false when the cipher is not present in this build.
+ */
+export function enableNativeChaCha20(): boolean;
+
+export const nativeChaCha20: ChaCha20Backend;

package/src/crypto/chacha-native.js

@@ -1,48 +1,48 @@
-// Node-only ChaCha20 backend.
-//
-// OpenSSL exposes a raw `chacha20` stream cipher whose keystream matches
-// src/crypto/chacha.js exactly, and it is roughly 27x faster on 64 KB payloads.
-// This module is imported only from src/node.js so that browser bundles never
-// encounter a `node:crypto` specifier.
-import {createCipheriv, getCiphers} from "node:crypto";
-
-import {installNativeChaCha20} from "./chacha.js";
-
-// OpenSSL takes a 16-byte IV: a 32-bit little-endian block counter followed by
-// the 12-byte nonce. The JS implementation starts its counter at zero.
-function buildIv(nonce) {
-    const iv = new Uint8Array(16);
-    iv.set(nonce, 4);
-    return iv;
-}
-
-function nativeChaCha20(key, nonce, out, source) {
-    try {
-        const cipher = createCipheriv("chacha20", key, buildIv(nonce));
-        const input = source ?? new Uint8Array(out.length);
-        const head = cipher.update(input);
-        const tail = cipher.final();
-        if (head.length) out.set(head, 0);
-        if (tail.length) out.set(tail, head.length);
-        return out;
-    } catch (_) {
-        // Fall back to the portable implementation.
-        return null;
-    }
-}
-
-function enableNativeChaCha20() {
-    try {
-        if (!getCiphers().includes("chacha20")) return false;
-    } catch (_) {
-        return false;
-    }
-    installNativeChaCha20(nativeChaCha20);
-    return true;
-}
-
-
-export {
-    enableNativeChaCha20,
-    nativeChaCha20
-};
+// Node-only ChaCha20 backend.
+//
+// OpenSSL exposes a raw `chacha20` stream cipher whose keystream matches
+// src/crypto/chacha.js exactly, and it is roughly 27x faster on 64 KB payloads.
+// This module is imported only from src/node.js so that browser bundles never
+// encounter a `node:crypto` specifier.
+import {createCipheriv, getCiphers} from "node:crypto";
+
+import {installNativeChaCha20} from "./chacha.js";
+
+// OpenSSL takes a 16-byte IV: a 32-bit little-endian block counter followed by
+// the 12-byte nonce. The JS implementation starts its counter at zero.
+function buildIv(nonce) {
+    const iv = new Uint8Array(16);
+    iv.set(nonce, 4);
+    return iv;
+}
+
+function nativeChaCha20(key, nonce, out, source) {
+    try {
+        const cipher = createCipheriv("chacha20", key, buildIv(nonce));
+        const input = source ?? new Uint8Array(out.length);
+        const head = cipher.update(input);
+        const tail = cipher.final();
+        if (head.length) out.set(head, 0);
+        if (tail.length) out.set(tail, head.length);
+        return out;
+    } catch (_) {
+        // Fall back to the portable implementation.
+        return null;
+    }
+}
+
+function enableNativeChaCha20() {
+    try {
+        if (!getCiphers().includes("chacha20")) return false;
+    } catch (_) {
+        return false;
+    }
+    installNativeChaCha20(nativeChaCha20);
+    return true;
+}
+
+
+export {
+    enableNativeChaCha20,
+    nativeChaCha20
+};

package/src/crypto/chacha.d.ts

@@ -1,25 +1,25 @@
-export function decryptPayload(wireBytes: Uint8Array | ArrayBuffer | number[], worldId: number, seed: number): Uint8Array;
-
-export function chacha20(key: Uint8Array, nonce: Uint8Array, length: number): Uint8Array;
-
-/** Generates the keystream and XORs it with `data` in a single pass. */
-export function chacha20Xor(key: Uint8Array, nonce: Uint8Array, data: Uint8Array): Uint8Array;
-
-export function rotl32(x: number, n: number): number;
-
-export function rotr32(x: number, n: number): number;
-
-export function quarterRound(state: Uint32Array, a: number, b: number, c: number, d: number): void;
-
-export type ChaCha20Backend = (
-    key: Uint8Array,
-    nonce: Uint8Array,
-    out: Uint8Array,
-    source?: Uint8Array
-) => Uint8Array | null;
-
-/**
- * Installs a faster backend for large payloads. Node's entry point wires this to
- * OpenSSL's `chacha20`; pass null to restore the portable implementation.
- */
-export function installNativeChaCha20(cipherFactory: ChaCha20Backend | null): void;
+export function decryptPayload(wireBytes: Uint8Array | ArrayBuffer | number[], worldId: number, seed: number): Uint8Array;
+
+export function chacha20(key: Uint8Array, nonce: Uint8Array, length: number): Uint8Array;
+
+/** Generates the keystream and XORs it with `data` in a single pass. */
+export function chacha20Xor(key: Uint8Array, nonce: Uint8Array, data: Uint8Array): Uint8Array;
+
+export function rotl32(x: number, n: number): number;
+
+export function rotr32(x: number, n: number): number;
+
+export function quarterRound(state: Uint32Array, a: number, b: number, c: number, d: number): void;
+
+export type ChaCha20Backend = (
+    key: Uint8Array,
+    nonce: Uint8Array,
+    out: Uint8Array,
+    source?: Uint8Array
+) => Uint8Array | null;
+
+/**
+ * Installs a faster backend for large payloads. Node's entry point wires this to
+ * OpenSSL's `chacha20`; pass null to restore the portable implementation.
+ */
+export function installNativeChaCha20(cipherFactory: ChaCha20Backend | null): void;