Fix Windows CI test failures + apply PR #12 bug fixes

Windows CI fixes:
- tq_ops.c: pthread_cond_wait must use SleepConditionVariableSRW (not CS)
  since pthread_mutex_t is mapped to SRWLOCK. CS variant on SRW = deadlock
  in test_ops thread pool.
- test_tqm.cpp, test_gguf_moe.cpp: replace hardcoded /tmp paths with
  CWD-relative names on Windows.
- CMakeLists.txt: bump TIMEOUT to 600s on MSVC for slow tests
  (test_multihash_dim64, test_ops, test_unbiased, test_cumulative_error).
  MSVC release lacks auto-vectorization the GCC/Clang build relies on.

Apply functional fixes from PR #12 (cherry-picked without reformatting):
- tq_qjl.c: dim > 0 guard before src[dim-1] NaN check.
- tq_uniform.c: heap-allocate Q8 query buffer (was 512B stack array).
- tq_transformer.c: NULL-check key_cache and value_cache calloc results.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: unamedkr

.gitignore

@@ -61,3 +61,4 @@ tq_run.dSYM/
 .claude/worktrees/
 .claude/worktrees/
 docs/assets/hero_backup.png
+build_nomt/

CMakeLists.txt

@@ -229,6 +229,11 @@ if(TQ_BUILD_TESTS)
         target_link_libraries(${test_name} turboquant GTest::gtest_main)
         add_test(NAME ${test_name} COMMAND ${test_name})
 
+        # Slow tests on MSVC (no auto-vectorization, weaker codegen) need more time
+        if(MSVC AND ${test_name} MATCHES "test_(multihash_dim64|ops|unbiased|cumulative_error)")
+            set_tests_properties(${test_name} PROPERTIES TIMEOUT 600)
+        endif()
+
         # Pass Metal availability to test targets
         if(TQ_BUILD_METAL AND APPLE)
             target_compile_definitions(${test_name} PRIVATE TQ_HAS_METAL=1)

src/core/tq_qjl.c

@@ -54,7 +54,7 @@ void tq_qjl_quantize_ref(const float* src, void* dst, int n) {
     if (dim > TQ_BK_QJL) dim = TQ_BK_QJL;
 
     /* Quick NaN check on first and last element */
-    if (src[0] != src[0] || src[dim-1] != src[dim-1]) {
+    if (dim > 0 && (src[0] != src[0] || src[dim-1] != src[dim-1])) {
         memset(block, 0, sizeof(*block));
         return;
     }

src/core/tq_uniform.c

@@ -9,6 +9,7 @@
 
 #include "turboquant/turboquant.h"
 #include <math.h>
+#include <stdlib.h>
 #include <string.h>
 #include <float.h>
 
@@ -191,8 +192,10 @@ void tq_quantize_query_q8(const float* query, int8_t* q8_out,
  */
 void tq_uniform_4b_attention_int_ref(const float* query, const void* kv,
                                       float* scores, int seq_len, int head_dim) {
-    /* Step 1: Quantize query to Q8 (once, amortized over seq_len) */
-    int8_t q8[512]; /* max head_dim supported */
+    /* Step 1: Quantize query to Q8 (once, amortized over seq_len).
+     * Heap-allocate to avoid stack overflow on large head_dim. */
+    int8_t* q8 = (int8_t*)malloc((size_t)head_dim * sizeof(int8_t));
+    if (!q8) { for (int s = 0; s < seq_len; s++) scores[s] = 0.0f; return; }
     float q_scale, q_sum;
     tq_quantize_query_q8(query, q8, &q_scale, &q_sum, head_dim);
 
@@ -225,6 +228,7 @@ void tq_uniform_4b_attention_int_ref(const float* query, const void* kv,
         }
         scores[s] = score;
     }
+    free(q8);
 }
 
 /* ---------- Uniform 4-bit attention (dequantize + dot product) ---------- */

src/engine/tq_ops.c

@@ -23,7 +23,8 @@ typedef CONDITION_VARIABLE pthread_cond_t;
 #define pthread_mutex_unlock(m)  LeaveCriticalSection(m)
 #define pthread_mutex_destroy(m) DeleteCriticalSection(m)
 #define pthread_cond_init(c, a)  InitializeConditionVariable(c)
-#define pthread_cond_wait(c, m)  SleepConditionVariableCS(c, m, INFINITE)
+/* Note: cond_wait uses SRW variant because mutex is SRWLOCK (see below) */
+#define pthread_cond_wait(c, m)  SleepConditionVariableSRW(c, m, INFINITE, 0)
 #define pthread_cond_broadcast(c) WakeAllConditionVariable(c)
 #define pthread_cond_destroy(c)  ((void)0)
 /* __thread → __declspec(thread) */

src/engine/tq_transformer.c

@@ -216,6 +216,7 @@ tq_state_t* tq_create_state_ex(const tq_model_config_t* config, tq_type kv_type,
 #else
     s->key_cache   = (float*)calloc(1, kv_total_bytes);
 #endif
+    if (!s->key_cache) { free(s); return NULL; }
 
     /* Value cache quantization: Q4 or Q2 for aggressive V compression.
      * When value_quant_bits > 0, V is stored quantized instead of FP16/FP32.
@@ -265,6 +266,7 @@ tq_state_t* tq_create_state_ex(const tq_model_config_t* config, tq_type kv_type,
 #else
         s->value_cache = (float*)calloc((size_t)n_layers * kv_layer_size, sizeof(float));
 #endif
+        if (!s->value_cache) { free(s->key_cache); free(s); return NULL; }
         s->value_cache_qs = NULL;
         s->value_cache_scales = NULL;
         s->kv_cache_size = (size_t)n_layers * kv_layer_size * sizeof(float);

tests/test_gguf_moe.cpp

@@ -420,7 +420,11 @@ TEST(ModelConfig, MoEFields) {
 
 TEST(GGUF, MagicDetection) {
     /* Write a tiny file with GGUF magic but invalid content */
+#ifdef _WIN32
+    const char* tmppath = "test_gguf_magic.gguf";
+#else
     const char* tmppath = "/tmp/test_gguf_magic.gguf";
+#endif
     FILE* f = fopen(tmppath, "wb");
     ASSERT_NE(f, nullptr);
     uint32_t magic = 0x46554747; /* "GGUF" as LE uint32 */

tests/test_tqm.cpp

@@ -175,7 +175,11 @@ TEST(TQM, SaveLoadRoundtrip) {
     ASSERT_EQ(model.use_q4_weights, 1);
 
     /* Save to temp file */
+#ifdef _WIN32
+    const char* tmp_path = "test_tqm_roundtrip.tqm";
+#else
     const char* tmp_path = "/tmp/test_tqm_roundtrip.tqm";
+#endif
     int ret = tq_save_tqm(&model, NULL, tmp_path);
     ASSERT_EQ(ret, 0);
 
@@ -259,7 +263,11 @@ TEST(TQM, SaveLoadRoundtrip) {
  * ============================================================ */
 TEST(TQM, AutoDetect) {
     /* Write a minimal TQM header to a temp file */
+#ifdef _WIN32
+    const char* tmp_path = "test_tqm_autodetect.tqm";
+#else
     const char* tmp_path = "/tmp/test_tqm_autodetect.tqm";
+#endif
     FILE* f = fopen(tmp_path, "wb");
     ASSERT_NE(f, nullptr);