feat: add diagnostic debug loader for Wine troubleshooting

test_wine_colab.ipynb

@@ -28,11 +28,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 1. Install Wine + MinGW\n",
-    "!dpkg --add-architecture i386\n",
-    "!apt-get update -qq\n",
-    "!apt-get install -y -qq wine64 mingw-w64 > /dev/null 2>&1\n",
-    "!wine64 --version"
+    "# 1. Install Wine + MinGW (use WineHQ repo for latest stable)\n",
+    "import subprocess, os\n",
+    "\n",
+    "# Add WineHQ repo for latest stable Wine (Ubuntu's stock is old)\n",
+    "cmds = [\n",
+    "    'dpkg --add-architecture i386',\n",
+    "    'mkdir -pm755 /etc/apt/keyrings',\n",
+    "    'wget -qO /etc/apt/keyrings/winehq-archive.key https://dl.winehq.org/wine-builds/winehq.key 2>/dev/null || true',\n",
+    "    'apt-get update -qq',\n",
+    "    'apt-get install -y -qq wine64 mingw-w64 > /dev/null 2>&1',\n",
+    "]\n",
+    "for cmd in cmds:\n",
+    "    subprocess.run(cmd, shell=True, capture_output=True)\n",
+    "\n",
+    "# Show Wine version\n",
+    "!wine64 --version\n",
+    "!x86_64-w64-mingw32-gcc --version | head -1"
    ]
   },
   {
@@ -42,13 +54,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 2. Initialize Wine prefix (suppress noise)\n",
+    "# 2. Initialize Wine prefix (64-bit, suppress noise)\n",
     "import os\n",
     "os.environ['WINEDEBUG'] = '-all'\n",
     "os.environ['WINEPREFIX'] = '/root/.wine'\n",
     "os.environ['WINEARCH'] = 'win64'\n",
-    "!wineboot --init 2>/dev/nulla\n",
-    "print('Wine prefix initialized')"
+    "!wineboot --init 2>/dev/null\n",
+    "!echo \"Wine prefix initialized\"\n",
+    "# Verify Wine can run basic exe\n",
+    "!echo 'int main(){return 0;}' > /tmp/test.c && x86_64-w64-mingw32-gcc -o /tmp/test.exe /tmp/test.c && wine64 /tmp/test.exe && echo \"Wine runs MinGW executables OK\""
    ]
   },
   {
@@ -58,10 +72,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 3. Clone repo from HuggingFace (code only — DLLs not in repo)\n",
+    "# 3. Clone repo from HuggingFace\n",
+    "!pip install -q huggingface_hub 2>/dev/null\n",
     "!git lfs install\n",
-    "!git clone https://huggingface.co/MattyMroz/oneocr /content/oneocr 2>/dev/null || echo \"Already cloned\"\n",
+    "!git clone https://huggingface.co/MattyMroz/oneocr /content/oneocr 2>/dev/null || (cd /content/oneocr && git pull)\n",
     "!mkdir -p /content/oneocr/ocr_data\n",
+    "!ls -la /content/oneocr/tools/\n",
+    "print(\"\\n--- ocr_data/ contents ---\")\n",
     "!ls -la /content/oneocr/ocr_data/ 2>/dev/null || echo \"ocr_data/ is empty — upload DLLs in next cell\""
    ]
   },
@@ -87,27 +104,55 @@
     "from pathlib import Path\n",
     "\n",
     "ocr_data = Path('/content/oneocr/ocr_data')\n",
-    "needed = ['oneocr.dll', 'oneocr.onemodel', 'onnxruntime.dll']\n",
+    "needed = {\n",
+    "    'oneocr.dll': 40_000_000,       # ~40 MB\n",
+    "    'oneocr.onemodel': 50_000_000,  # ~56 MB  \n",
+    "    'onnxruntime.dll': 10_000_000,  # ~13 MB\n",
+    "}\n",
+    "\n",
+    "# Search multiple possible locations\n",
+    "search_dirs = [Path('/content'), Path('/root'), Path('/tmp')]\n",
     "\n",
-    "# Przenieś z /content/ (domyślny upload) do ocr_data/\n",
-    "for f in needed:\n",
-    "    src = Path(f'/content/{f}')\n",
+    "for f, min_size in needed.items():\n",
     "    dst = ocr_data / f\n",
-    "    if src.exists() and not dst.exists():\n",
-    "        shutil.move(str(src), str(dst))\n",
-    "        print(f'  ✅ Przeniesiono: {f}')\n",
-    "    elif dst.exists():\n",
+    "    if dst.exists() and dst.stat().st_size > min_size:\n",
     "        print(f'  ✅ Już jest: {f} ({dst.stat().st_size / 1e6:.1f} MB)')\n",
-    "    else:\n",
-    "        print(f'  ❌ BRAK: {f} — wrzuć plik!')\n",
-    "\n",
-    "# Sprawdź\n",
-    "missing = [f for f in needed if not (ocr_data / f).exists()]\n",
-    "if missing:\n",
-    "    print(f'\\n⚠️ Brakuje: {missing}')\n",
-    "    print('Wrzuć pliki przez panel \"Files\" po lewej stronie, potem uruchom tę komórkę ponownie.')\n",
+    "        continue\n",
+    "    \n",
+    "    # Find the file\n",
+    "    found = False\n",
+    "    for d in search_dirs:\n",
+    "        src = d / f\n",
+    "        if src.exists() and src.stat().st_size > min_size:\n",
+    "            shutil.copy2(str(src), str(dst))\n",
+    "            print(f'  ✅ Skopiowano: {f} ({dst.stat().st_size / 1e6:.1f} MB)')\n",
+    "            found = True\n",
+    "            break\n",
+    "    \n",
+    "    if not found:\n",
+    "        if dst.exists():\n",
+    "            size = dst.stat().st_size\n",
+    "            if size < 1000:\n",
+    "                # Likely git LFS pointer\n",
+    "                print(f'  ❌ {f} — to git LFS pointer ({size} B)! Wrzuć prawdziwy plik.')\n",
+    "                with open(dst) as fh:\n",
+    "                    print(f'     Zawartość: {fh.read(100)[:80]}...')\n",
+    "            else:\n",
+    "                print(f'  ⚠️ {f} istnieje ale mały ({size / 1e6:.1f} MB) — sprawdź!')\n",
+    "        else:\n",
+    "            print(f'  ❌ BRAK: {f} — wrzuć plik!')\n",
+    "\n",
+    "# Final check\n",
+    "print()\n",
+    "all_ok = True\n",
+    "for f, min_size in needed.items():\n",
+    "    dst = ocr_data / f\n",
+    "    if not dst.exists() or dst.stat().st_size < min_size:\n",
+    "        all_ok = False\n",
+    "if all_ok:\n",
+    "    print('🎉 Wszystkie pliki na miejscu!')\n",
     "else:\n",
-    "    print(f'\\n🎉 Wszystkie pliki na miejscu! Lecimy dalej.')"
+    "    print('⚠️ Brakuje plików — wrzuć je i uruchom tę komórkę ponownie.')"
    ]
   },
   {
@@ -128,10 +173,60 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 6. Compile C loader with MinGW cross-compiler\n",
+    "# 6. Compile BOTH loaders: debug + normal\n",
+    "!x86_64-w64-mingw32-gcc -O2 -o /content/oneocr/tools/oneocr_debug.exe /content/oneocr/tools/oneocr_debug.c\n",
     "!x86_64-w64-mingw32-gcc -O2 -o /content/oneocr/tools/oneocr_loader.exe /content/oneocr/tools/oneocr_loader.c\n",
-    "!ls -la /content/oneocr/tools/oneocr_loader.exe\n",
-    "print('✅ C loader compiled OK')"
+    "!ls -la /content/oneocr/tools/*.exe\n",
+    "print('✅ Both loaders compiled')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b76a011",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 7. 🔍 DIAGNOSTYKA — Run debug loader to find exact failure point\n",
+    "import subprocess, os\n",
+    "\n",
+    "os.environ['WINEDEBUG'] = '-all'\n",
+    "\n",
+    "# Convert path for Wine\n",
+    "dll_dir_wine = 'Z:\\\\content\\\\oneocr\\\\ocr_data'\n",
+    "\n",
+    "print(\"=\" * 60)\n",
+    "print(\"DIAGNOSTYKA: Testowanie komponentów pod Wine\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "# Run debug loader\n",
+    "result = subprocess.run(\n",
+    "    ['wine64', '/content/oneocr/tools/oneocr_debug.exe', dll_dir_wine],\n",
+    "    capture_output=True, text=True, timeout=120,\n",
+    "    env={**os.environ, 'WINEDEBUG': '-all'}\n",
+    ")\n",
+    "\n",
+    "print(result.stdout)\n",
+    "if result.stderr:\n",
+    "    print(\"--- STDERR ---\")\n",
+    "    print(result.stderr[:1000])\n",
+    "\n",
+    "# Also run with Wine debug channels for bcrypt/ntdll\n",
+    "print(\"\\n\" + \"=\" * 60)\n",
+    "print(\"EXTRA: Wine debug trace (bcrypt + module loading)\")\n",
+    "print(\"=\" * 60)\n",
+    "result2 = subprocess.run(\n",
+    "    ['wine64', '/content/oneocr/tools/oneocr_debug.exe', dll_dir_wine],\n",
+    "    capture_output=True, text=True, timeout=120,\n",
+    "    env={**os.environ, 'WINEDEBUG': '+bcrypt,+loaddll'}\n",
+    ")\n",
+    "# Only show relevant debug lines (not all the noise)\n",
+    "for line in result2.stderr.split('\\n'):\n",
+    "    if any(kw in line.lower() for kw in ['bcrypt', 'cfb', 'fail', 'err:', 'fixme:', 'oneocr', 'onnxruntime', 'not implemented', 'not supported']):\n",
+    "        print(line)\n",
+    "if result2.stdout != result.stdout:\n",
+    "    print(\"\\nDiagnostic output:\")\n",
+    "    print(result2.stdout[-500:])"
    ]
   },
   {
@@ -141,7 +236,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 7. 🧪 TEST: Run C loader via Wine on a single image\n",
+    "# 8. 🧪 TEST: Run C loader via Wine on a single image\n",
     "import subprocess, json, os\n",
     "from PIL import Image\n",
     "from pathlib import Path\n",
@@ -192,7 +287,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 8. 🧪 FULL TEST: Run on ALL 19 test images\n",
+    "# 9. 🧪 FULL TEST: Run on ALL 19 test images\n",
     "import time\n",
     "\n",
     "test_dir = Path('/content/oneocr/working_space/input')\n",
@@ -234,7 +329,7 @@
     "if fail == 0:\n",
     "    print('🎉 Wine bridge on Linux: WORKS! 100% accuracy identical to Windows DLL.')\n",
     "else:\n",
-    "    print(f'⚠️ {fail} failures — check Wine/DLL setup')"
+    "    print(f'⚠️ {fail} failures — check diagnostic output (cell 7) for details')"
    ]
   },
   {
@@ -244,7 +339,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 9. 🧪 TEST: Unified engine (auto-selects Wine backend on Linux)\n",
+    "# 10. 🧪 TEST: Unified engine (auto-selects Wine backend on Linux)\n",
     "import sys\n",
     "sys.path.insert(0, '/content/oneocr')\n",
     "\n",

tools/oneocr_debug.c

@@ -0,0 +1,331 @@
+/* oneocr_debug.c -- Diagnostic loader for Wine troubleshooting
+ * Compile: x86_64-w64-mingw32-gcc -O2 -o oneocr_debug.exe oneocr_debug.c
+ * Usage:   wine64 oneocr_debug.exe <dll_dir>
+ *
+ * Tests each component separately:
+ *   1. File access (can we read oneocr.onemodel?)
+ *   2. DLL loading (oneocr.dll, onnxruntime.dll)
+ *   3. bcrypt AES-256-CFB128 (model decryption)
+ *   4. CreateOcrPipeline (full init)
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <windows.h>
+
+/* bcrypt types */
+typedef void* BCRYPT_ALG_HANDLE;
+typedef void* BCRYPT_KEY_HANDLE;
+typedef long NTSTATUS;
+
+typedef NTSTATUS (*fn_BCryptOpenAlgorithmProvider)(BCRYPT_ALG_HANDLE*, const wchar_t*, const wchar_t*, unsigned long);
+typedef NTSTATUS (*fn_BCryptSetProperty)(BCRYPT_ALG_HANDLE, const wchar_t*, unsigned char*, unsigned long, unsigned long);
+typedef NTSTATUS (*fn_BCryptGenerateSymmetricKey)(BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE*, unsigned char*, unsigned long, unsigned char*, unsigned long, unsigned long);
+typedef NTSTATUS (*fn_BCryptEncrypt)(BCRYPT_KEY_HANDLE, unsigned char*, unsigned long, void*, unsigned char*, unsigned long, unsigned char*, unsigned long, unsigned long*, unsigned long);
+typedef NTSTATUS (*fn_BCryptDecrypt)(BCRYPT_KEY_HANDLE, unsigned char*, unsigned long, void*, unsigned char*, unsigned long, unsigned char*, unsigned long, unsigned long*, unsigned long);
+typedef NTSTATUS (*fn_BCryptCloseAlgorithmProvider)(BCRYPT_ALG_HANDLE, unsigned long);
+typedef NTSTATUS (*fn_BCryptDestroyKey)(BCRYPT_KEY_HANDLE);
+
+/* DLL function types */
+typedef long long (*fn_CreateOcrInitOptions)(long long*);
+typedef long long (*fn_OcrInitOptionsSetUseModelDelayLoad)(long long, char);
+typedef long long (*fn_CreateOcrPipeline)(const char*, const char*, long long, long long*);
+typedef void (*fn_ReleaseOcrInitOptions)(long long);
+typedef void (*fn_ReleaseOcrPipeline)(long long);
+
+static void test_file_access(const char* dll_dir) {
+    printf("\n=== TEST 1: File Access ===\n");
+
+    char model_path[MAX_PATH];
+    snprintf(model_path, sizeof(model_path), "%s\\oneocr.onemodel", dll_dir);
+
+    /* Test CreateFileA */
+    HANDLE hFile = CreateFileA(model_path, GENERIC_READ, FILE_SHARE_READ, NULL,
+                                OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (hFile == INVALID_HANDLE_VALUE) {
+        printf("  FAIL: Cannot open model file: %s (error %lu)\n", model_path, GetLastError());
+
+        /* Try alternate paths */
+        printf("  Trying alternate paths...\n");
+        char alt1[MAX_PATH];
+        snprintf(alt1, sizeof(alt1), "%s/oneocr.onemodel", dll_dir);
+        hFile = CreateFileA(alt1, GENERIC_READ, FILE_SHARE_READ, NULL,
+                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+        if (hFile != INVALID_HANDLE_VALUE) {
+            printf("  OK with forward slashes: %s\n", alt1);
+        } else {
+            printf("  FAIL with forward slashes too (error %lu)\n", GetLastError());
+        }
+    }
+
+    if (hFile != INVALID_HANDLE_VALUE) {
+        LARGE_INTEGER size;
+        GetFileSizeEx(hFile, &size);
+        printf("  OK: Model file opened. Size: %lld bytes (%.1f MB)\n",
+               size.QuadPart, size.QuadPart / 1e6);
+
+        if (size.QuadPart < 1000000) {
+            /* Read first 100 bytes to check if it's a git lfs pointer */
+            char buf[200] = {0};
+            DWORD read = 0;
+            ReadFile(hFile, buf, 100, &read, NULL);
+            if (strstr(buf, "version https://git-lfs") != NULL) {
+                printf("  *** WARNING: File is a Git LFS POINTER, not actual data! ***\n");
+                printf("  Content: %s\n", buf);
+                printf("  Run: git lfs pull\n");
+            } else {
+                printf("  WARNING: File seems too small for a model!\n");
+            }
+        }
+
+        /* Read first 16 bytes (header) */
+        SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
+        unsigned char header[16];
+        DWORD bytesRead = 0;
+        ReadFile(hFile, header, 16, &bytesRead, NULL);
+        printf("  Header (first 16 bytes): ");
+        for (int i = 0; i < 16; i++) printf("%02x ", header[i]);
+        printf("\n");
+
+        CloseHandle(hFile);
+    }
+
+    /* Check DLL files */
+    char dll_path[MAX_PATH], ort_path[MAX_PATH];
+    snprintf(dll_path, sizeof(dll_path), "%s\\oneocr.dll", dll_dir);
+    snprintf(ort_path, sizeof(ort_path), "%s\\onnxruntime.dll", dll_dir);
+
+    HANDLE h1 = CreateFileA(dll_path, GENERIC_READ, FILE_SHARE_READ, NULL,
+                             OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (h1 != INVALID_HANDLE_VALUE) {
+        LARGE_INTEGER s; GetFileSizeEx(h1, &s);
+        printf("  OK: oneocr.dll exists (%.1f MB)\n", s.QuadPart/1e6);
+        CloseHandle(h1);
+    } else {
+        printf("  FAIL: oneocr.dll not found at %s (error %lu)\n", dll_path, GetLastError());
+    }
+
+    HANDLE h2 = CreateFileA(ort_path, GENERIC_READ, FILE_SHARE_READ, NULL,
+                             OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (h2 != INVALID_HANDLE_VALUE) {
+        LARGE_INTEGER s; GetFileSizeEx(h2, &s);
+        printf("  OK: onnxruntime.dll exists (%.1f MB)\n", s.QuadPart/1e6);
+        CloseHandle(h2);
+    } else {
+        printf("  FAIL: onnxruntime.dll not found at %s (error %lu)\n", ort_path, GetLastError());
+    }
+}
+
+static void test_dll_loading(const char* dll_dir) {
+    printf("\n=== TEST 2: DLL Loading ===\n");
+
+    SetDllDirectoryA(dll_dir);
+
+    /* Try onnxruntime first */
+    char ort_path[MAX_PATH];
+    snprintf(ort_path, sizeof(ort_path), "%s\\onnxruntime.dll", dll_dir);
+    HMODULE hort = LoadLibraryA(ort_path);
+    if (hort) {
+        printf("  OK: onnxruntime.dll loaded\n");
+        FreeLibrary(hort);
+    } else {
+        printf("  FAIL: onnxruntime.dll LoadLibrary error %lu\n", GetLastError());
+    }
+
+    /* Try oneocr */
+    char dll_path[MAX_PATH];
+    snprintf(dll_path, sizeof(dll_path), "%s\\oneocr.dll", dll_dir);
+    HMODULE hmod = LoadLibraryA(dll_path);
+    if (hmod) {
+        printf("  OK: oneocr.dll loaded\n");
+
+        /* Check exports */
+        const char* exports[] = {
+            "CreateOcrInitOptions", "CreateOcrPipeline", "RunOcrPipeline",
+            "ReleaseOcrResult", "ReleaseOcrPipeline", NULL
+        };
+        for (int i = 0; exports[i]; i++) {
+            void* fn = GetProcAddress(hmod, exports[i]);
+            printf("  %s %s\n", fn ? "  OK:" : "  FAIL:", exports[i]);
+        }
+        FreeLibrary(hmod);
+    } else {
+        printf("  FAIL: oneocr.dll LoadLibrary error %lu\n", GetLastError());
+    }
+}
+
+static void test_bcrypt_cfb(void) {
+    printf("\n=== TEST 3: bcrypt AES-256-CFB128 ===\n");
+
+    HMODULE hbcrypt = LoadLibraryA("bcrypt.dll");
+    if (!hbcrypt) {
+        printf("  FAIL: Cannot load bcrypt.dll (error %lu)\n", GetLastError());
+        return;
+    }
+    printf("  OK: bcrypt.dll loaded\n");
+
+    fn_BCryptOpenAlgorithmProvider pOpen = (fn_BCryptOpenAlgorithmProvider)GetProcAddress(hbcrypt, "BCryptOpenAlgorithmProvider");
+    fn_BCryptSetProperty pSetProp = (fn_BCryptSetProperty)GetProcAddress(hbcrypt, "BCryptSetProperty");
+    fn_BCryptGenerateSymmetricKey pGenKey = (fn_BCryptGenerateSymmetricKey)GetProcAddress(hbcrypt, "BCryptGenerateSymmetricKey");
+    fn_BCryptDecrypt pDecrypt = (fn_BCryptDecrypt)GetProcAddress(hbcrypt, "BCryptDecrypt");
+    fn_BCryptCloseAlgorithmProvider pClose = (fn_BCryptCloseAlgorithmProvider)GetProcAddress(hbcrypt, "BCryptCloseAlgorithmProvider");
+    fn_BCryptDestroyKey pDestroy = (fn_BCryptDestroyKey)GetProcAddress(hbcrypt, "BCryptDestroyKey");
+
+    if (!pOpen || !pSetProp || !pGenKey || !pDecrypt) {
+        printf("  FAIL: Missing bcrypt functions\n");
+        return;
+    }
+
+    /* Test 1: Open AES provider */
+    BCRYPT_ALG_HANDLE hAlg = NULL;
+    NTSTATUS status = pOpen(&hAlg, L"AES", NULL, 0);
+    printf("  BCryptOpenAlgorithmProvider(AES): 0x%08lx %s\n", status, status == 0 ? "OK" : "FAIL");
+    if (status != 0) return;
+
+    /* Test 2: Set CFB chaining mode */
+    wchar_t cfb[] = L"ChainingModeCFB";
+    status = pSetProp(hAlg, L"ChainingMode", (unsigned char*)cfb, sizeof(cfb), 0);
+    printf("  BCryptSetProperty(ChainingModeCFB): 0x%08lx %s\n", status, status == 0 ? "OK" : "FAIL");
+
+    if (status != 0) {
+        printf("  *** CFB MODE NOT SUPPORTED IN THIS WINE VERSION! ***\n");
+        printf("  This is likely the root cause of error 6.\n");
+        printf("  Trying CBC mode instead...\n");
+        wchar_t cbc[] = L"ChainingModeCBC";
+        status = pSetProp(hAlg, L"ChainingMode", (unsigned char*)cbc, sizeof(cbc), 0);
+        printf("  BCryptSetProperty(ChainingModeCBC): 0x%08lx %s\n", status, status == 0 ? "OK" : "FAIL");
+
+        printf("  Trying ECB mode...\n");
+        wchar_t ecb[] = L"ChainingModeECB";
+        status = pSetProp(hAlg, L"ChainingMode", (unsigned char*)ecb, sizeof(ecb), 0);
+        printf("  BCryptSetProperty(ChainingModeECB): 0x%08lx %s\n", status, status == 0 ? "OK" : "FAIL");
+
+        printf("  Trying GCM mode...\n");
+        wchar_t gcm[] = L"ChainingModeGCM";
+        status = pSetProp(hAlg, L"ChainingMode", (unsigned char*)gcm, sizeof(gcm), 0);
+        printf("  BCryptSetProperty(ChainingModeGCM): 0x%08lx %s\n", status, status == 0 ? "OK" : "FAIL");
+    }
+
+    if (status == 0) {
+        /* Test 3: Generate key with test data */
+        unsigned char test_key[32] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
+                                       0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,
+                                       0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
+                                       0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20};
+        BCRYPT_KEY_HANDLE hKey = NULL;
+        status = pGenKey(hAlg, &hKey, NULL, 0, test_key, 32, 0);
+        printf("  BCryptGenerateSymmetricKey: 0x%08lx %s\n", status, status == 0 ? "OK" : "FAIL");
+
+        if (status == 0 && hKey) {
+            /* Test 4: Try decrypt */
+            unsigned char iv[16] = {0};
+            unsigned char ciphertext[16] = {0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,
+                                             0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50};
+            unsigned char plaintext[16] = {0};
+            unsigned long cbResult = 0;
+            status = pDecrypt(hKey, ciphertext, 16, NULL, iv, 16, plaintext, 16, &cbResult, 0);
+            printf("  BCryptDecrypt: 0x%08lx %s (decrypted %lu bytes)\n",
+                   status, status == 0 ? "OK" : "FAIL", cbResult);
+            if (hKey) pDestroy(hKey);
+        }
+    }
+
+    pClose(hAlg, 0);
+    FreeLibrary(hbcrypt);
+}
+
+static void test_pipeline(const char* dll_dir, const char* key_hex) {
+    printf("\n=== TEST 4: CreateOcrPipeline ===\n");
+
+    SetDllDirectoryA(dll_dir);
+
+    char dll_path[MAX_PATH];
+    snprintf(dll_path, sizeof(dll_path), "%s\\oneocr.dll", dll_dir);
+
+    HMODULE hmod = LoadLibraryA(dll_path);
+    if (!hmod) {
+        printf("  FAIL: LoadLibrary failed: %lu\n", GetLastError());
+        return;
+    }
+
+    fn_CreateOcrInitOptions pCreateInit = (fn_CreateOcrInitOptions)GetProcAddress(hmod, "CreateOcrInitOptions");
+    fn_OcrInitOptionsSetUseModelDelayLoad pSetDelay = (fn_OcrInitOptionsSetUseModelDelayLoad)GetProcAddress(hmod, "OcrInitOptionsSetUseModelDelayLoad");
+    fn_CreateOcrPipeline pCreatePipeline = (fn_CreateOcrPipeline)GetProcAddress(hmod, "CreateOcrPipeline");
+    fn_ReleaseOcrInitOptions pRelInit = (fn_ReleaseOcrInitOptions)GetProcAddress(hmod, "ReleaseOcrInitOptions");
+    fn_ReleaseOcrPipeline pRelPipeline = (fn_ReleaseOcrPipeline)GetProcAddress(hmod, "ReleaseOcrPipeline");
+
+    if (!pCreateInit || !pCreatePipeline) {
+        printf("  FAIL: Missing functions\n");
+        return;
+    }
+
+    /* Init options */
+    long long init_opts = 0;
+    long long res = pCreateInit(&init_opts);
+    printf("  CreateOcrInitOptions: %lld %s\n", res, res == 0 ? "OK" : "FAIL");
+
+    if (pSetDelay) {
+        /* Try with delay load = 1 (defer ONNX model loading) */
+        res = pSetDelay(init_opts, 1);
+        printf("  OcrInitOptionsSetUseModelDelayLoad(1): %lld %s\n", res, res == 0 ? "OK" : "FAIL");
+    }
+
+    /* Model path and key */
+    char model_path[MAX_PATH];
+    snprintf(model_path, sizeof(model_path), "%s\\oneocr.onemodel", dll_dir);
+    printf("  Model path: %s\n", model_path);
+
+    int key_len = strlen(key_hex) / 2;
+    char key[64] = {0};
+    for (int i = 0; i < key_len && i < 63; i++) {
+        sscanf(key_hex + i*2, "%2hhx", &key[i]);
+    }
+    printf("  Key length: %d bytes\n", key_len);
+    printf("  Key (first 8): ");
+    for (int i = 0; i < 8 && i < key_len; i++) printf("%02x", (unsigned char)key[i]);
+    printf("...\n");
+
+    /* Try pipeline creation */
+    long long pipeline = 0;
+    printf("  Calling CreateOcrPipeline...\n");
+    fflush(stdout);
+    res = pCreatePipeline(model_path, key, init_opts, &pipeline);
+    printf("  CreateOcrPipeline result: %lld %s\n", res, res == 0 ? "OK" : "FAIL");
+
+    if (res != 0) {
+        printf("\n  === DIAGNOSIS ===\n");
+        printf("  Error code %lld from CreateOcrPipeline.\n", res);
+        printf("  Most likely causes:\n");
+        printf("  - bcrypt AES-256-CFB128 not supported in Wine (check TEST 3 above)\n");
+        printf("  - onnxruntime.dll initialization failed\n");
+        printf("  - Model file corrupted or git-lfs pointer\n");
+    } else {
+        printf("  SUCCESS! Pipeline created.\n");
+        pRelPipeline(pipeline);
+    }
+
+    pRelInit(init_opts);
+    FreeLibrary(hmod);
+}
+
+int main(int argc, char** argv) {
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s <dll_dir> [model_key_hex]\n", argv[0]);
+        return 1;
+    }
+
+    const char* dll_dir = argv[1];
+    const char* key_hex = argc > 2 ? argv[2] :
+        "6b6a29544774724b3e665d625b50696f772e67552b6e43407322222222222234";
+
+    printf("OneOCR Wine Debug Tool\n");
+    printf("DLL dir: %s\n", dll_dir);
+
+    test_file_access(dll_dir);
+    test_dll_loading(dll_dir);
+    test_bcrypt_cfb();
+    test_pipeline(dll_dir, key_hex);
+
+    printf("\n=== DONE ===\n");
+    return 0;
+}