Add Lian Li SL-INF wireless tools and SignalRGB plugin

Proof-of-concept tools for the UNI FAN SL-INF Wireless kit (SLV3 TX/RX
dongles 0416:8040/8041): a Python scan/colour script, tinyuz helpers, a
JavaScript tinyuz encoder, the SignalRGB plugin and tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

build-src/tuz_wrapper.cpp

@@ -0,0 +1,86 @@
+// C wrapper around tinyuz compression for Rust FFI.
+// Provides a simple memory-to-memory compression API.
+//
+// MIT License — wraps tinyuz (https://github.com/sisong/tinyuz)
+
+#include "tinyuz/compress/tuz_enc.h"
+#include <cstring>
+#include <cstdlib>
+
+
+struct MemStreamInput {
+    const unsigned char* data;
+    size_t size;
+};
+
+struct MemStreamOutput {
+    unsigned char* buf;
+    size_t capacity;
+    size_t written;
+};
+
+static hpatch_BOOL mem_read(const hpatch_TStreamInput* stream,
+                            hpatch_StreamPos_t readFromPos,
+                            unsigned char* out_data,
+                            unsigned char* out_data_end) {
+    auto* ms = (const MemStreamInput*)stream->streamImport;
+    size_t len = (size_t)(out_data_end - out_data);
+    if (readFromPos + len > ms->size) return hpatch_FALSE;
+    memcpy(out_data, ms->data + readFromPos, len);
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL mem_write(const hpatch_TStreamOutput* stream,
+                             hpatch_StreamPos_t writeToPos,
+                             const unsigned char* data,
+                             const unsigned char* data_end) {
+    auto* ms = (MemStreamOutput*)stream->streamImport;
+    size_t len = (size_t)(data_end - data);
+    if (writeToPos + len > ms->capacity) return hpatch_FALSE;
+    memcpy(ms->buf + writeToPos, data, len);
+    size_t end = (size_t)writeToPos + len;
+    if (end > ms->written) ms->written = end;
+    return hpatch_TRUE;
+}
+
+
+extern "C" {
+
+/// Compress `input` using tinyuz with the given dictionary size.
+///
+/// Returns the compressed size on success, or 0 on failure.
+/// `output` must be at least `tuz_maxCompressedSize(input_len)` bytes.
+size_t tuz_compress_mem(const unsigned char* input, size_t input_len,
+                        unsigned char* output, size_t output_capacity,
+                        size_t dict_size) {
+    MemStreamInput  in_mem  = { input, input_len };
+    MemStreamOutput out_mem = { output, output_capacity, 0 };
+
+    hpatch_TStreamInput in_stream;
+    memset(&in_stream, 0, sizeof(in_stream));
+    in_stream.streamImport = (void*)&in_mem;
+    in_stream.streamSize   = input_len;
+    in_stream.read         = mem_read;
+
+    hpatch_TStreamOutput out_stream;
+    memset(&out_stream, 0, sizeof(out_stream));
+    out_stream.streamImport    = (void*)&out_mem;
+    out_stream.streamSize      = output_capacity;
+    out_stream.read_writed     = nullptr;
+    out_stream.write           = mem_write;
+
+    tuz_TCompressProps props = tuz_kDefaultCompressProps;
+    props.dictSize   = dict_size;
+    props.threadNum  = 1;
+
+    hpatch_StreamPos_t result = tuz_compress(&out_stream, &in_stream, &props);
+    if (result == 0 || result > output_capacity) return 0;
+    return (size_t)result;
+}
+
+/// Returns the maximum compressed output size for a given input length.
+size_t tuz_max_compressed_size(size_t input_len) {
+    return (size_t)tuz_maxCompressedSize(input_len);
+}
+
+} // extern "C"