@qvac/ocr-ggml 0.0.1 → 0.1.1

package/test/integration/canvas-size.test.js

@@ -0,0 +1,75 @@
+'use strict'
+
+const { OcrGgml } = require('../..')
+const test = require('brittle')
+const { isMobile, getImagePath, ensureModelPath } = require('./utils')
+
+// 10 minutes: the dense page is heavy on slow CI runners.
+const TEST_TIMEOUT = 600 * 1000
+
+// Regression for QVAC-19340: dense high-resolution pages drove CRAFT detection
+// peak memory to ~13 GB (canvas capped at the 2560 default), OOM-killing the
+// host on memory-constrained Android devices. `canvasSize` caps the detection
+// canvas (EasyOCR's `canvas_size`) so callers can bound peak memory. A smaller
+// canvas must still configure, run, and return text on a dense page.
+// Desktop-only: this regression deliberately drives a dense page through the
+// detector to exercise the canvas cap. Even at canvasSize=1280 the CRAFT peak
+// (~3.6 GB) exceeds iOS/Android jetsam limits on Device Farm phones, so running
+// it there would re-trigger the very OOM it guards against. The cap behaviour
+// is deterministic and fully validated on desktop CI.
+test('canvasSize bounds the detection canvas and still recognizes a dense page', { timeout: TEST_TIMEOUT, skip: isMobile }, async function (t) {
+  const detectorPath = await ensureModelPath('detector_craft')
+  const recognizerPath = await ensureModelPath('recognizer_latin')
+
+  // lab_results.png is a dense 1414x2000 page (~100+ text regions): the fixture
+  // that triggered the original Android OOM.
+  const imagePath = getImagePath('/test/images/lab_results.png')
+
+  const ocrGgml = new OcrGgml({
+    params: {
+      pathDetector: detectorPath,
+      pathRecognizer: recognizerPath,
+      langList: ['en'],
+      canvasSize: 1280
+    },
+    opts: { stats: true }
+  })
+
+  await ocrGgml.load()
+  t.pass('Loaded with reduced canvasSize=1280')
+
+  try {
+    // Disable rotation retry: it triples recognition work on this dense page
+    // (each box re-run at 90/270) without adding value to the memory-cap
+    // assertion, and would otherwise blow the desktop test budget on slow CI.
+    const response = await ocrGgml.run({
+      path: imagePath,
+      options: { paragraph: false, rotationAngles: [] }
+    })
+
+    let texts = []
+    await response
+      .onUpdate(output => {
+        t.ok(Array.isArray(output), 'output should be an array')
+        t.ok(output.length > 0, 'dense page should still produce text regions with a smaller canvas')
+        texts = output.map(o => String(o[1]).toLowerCase())
+        t.comment('Detected ' + output.length + ' regions (canvasSize=1280)')
+      })
+      .onError(error => {
+        t.fail('unexpected error: ' + JSON.stringify(error))
+      })
+      .await()
+
+    // Recognition content varies slightly with canvas size; assert that at
+    // least one stable keyword from this lab report is still recognized.
+    const expected = ['medivista', 'hospital', 'clinical', 'biochemistry', 'patient']
+    const matched = expected.filter(w => texts.some(line => line.includes(w)))
+    t.comment('Matched keywords: ' + JSON.stringify(matched))
+    t.ok(matched.length > 0, 'should still recognize at least one expected keyword with a reduced canvas')
+
+    t.pass('canvasSize regression test completed successfully')
+  } finally {
+    await ocrGgml.unload()
+    await new Promise(resolve => setTimeout(resolve, 1000))
+  }
+})

package/test/integration/doctr-basic.test.js

@@ -0,0 +1,124 @@
+'use strict'
+
+const test = require('brittle')
+const { getImagePath, formatOCRPerformanceMetrics, ensureDoctrModels, runDoctrOCR } = require('./utils')
+
+const TEST_TIMEOUT = 300 * 1000
+
+// Words from english.bmp (WHO coronavirus infographic). At least 7 of 10 must be recognized
+// to catch OCR accuracy regressions without being overly strict.
+const ENGLISH_RECOGNITION_WORDS = [
+  'health', 'world', 'cook', 'soap', 'water', 'hands', 'reduce', 'risk', 'avoid', 'symptoms'
+]
+
+/**
+ * Assert at least minMatch of expectedWords appear in recognition results (substring match).
+ * Catches accuracy regressions while tolerating minor OCR variation.
+ */
+function assertRecognitionAccuracy (t, texts, expectedWords, minMatch, label) {
+  const lowerTexts = texts.map(w => w.toLowerCase())
+  const found = expectedWords.filter(word =>
+    lowerTexts.some(txt => txt.includes(word.toLowerCase()))
+  )
+  t.ok(
+    found.length >= minMatch,
+    `${label}: at least ${minMatch}/${expectedWords.length} words recognized (got ${found.length}: ${JSON.stringify(found)})`
+  )
+}
+
+let DB_MOBILENET
+let CRNN_MOBILENET
+
+test('DocTR basic - download models', { timeout: TEST_TIMEOUT }, async function (t) {
+  const models = await ensureDoctrModels()
+  DB_MOBILENET = models.db_mobilenet_v3_large
+  CRNN_MOBILENET = models.crnn_mobilenet_v3_small
+  t.ok(DB_MOBILENET, 'db_mobilenet model available')
+  t.ok(CRNN_MOBILENET, 'crnn_mobilenet model available')
+})
+
+test('DocTR basic - BMP image', { timeout: TEST_TIMEOUT }, async function (t) {
+  const imagePath = getImagePath('/test/images/basic_test.bmp')
+  t.comment('Detector: ' + DB_MOBILENET)
+  t.comment('Recognizer: ' + CRNN_MOBILENET)
+
+  const params = {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET
+  }
+
+  const { results, stats } = await runDoctrOCR(t, params, imagePath)
+
+  const outputTexts = results.map(r => r.text)
+  t.ok(results.length > 0, `BMP: should detect text regions, got ${results.length}`)
+  // DocTR on basic_test: only "normal" (horizontal) is reliably detected across CI (Linux, Windows, macOS);
+  // tilted/vertical vary by platform and DocTR lacks per-crop rotation handling (unlike EasyOCR).
+  t.ok(outputTexts.some(w => w.toLowerCase().includes('normal')), 'BMP should detect "normal"')
+  t.comment('BMP detected texts: ' + JSON.stringify(outputTexts))
+  t.comment(formatOCRPerformanceMetrics('[DocTR BMP]', stats, outputTexts, { skipReport: true }))
+})
+
+test('DocTR basic - JPEG image', { timeout: TEST_TIMEOUT }, async function (t) {
+  const imagePath = getImagePath('/test/images/basic_test.jpg')
+
+  const params = {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET
+  }
+
+  const { results, stats } = await runDoctrOCR(t, params, imagePath)
+
+  const outputTexts = results.map(r => r.text)
+  t.ok(results.length > 0, `JPEG: should detect text regions, got ${results.length}`)
+  t.ok(outputTexts.some(w => w.toLowerCase().includes('normal')), 'JPEG should detect "normal"')
+  t.comment('JPEG detected texts: ' + JSON.stringify(outputTexts))
+  t.comment(formatOCRPerformanceMetrics('[DocTR JPEG]', stats, outputTexts, { skipReport: true }))
+})
+
+test('DocTR basic - PNG image', { timeout: TEST_TIMEOUT }, async function (t) {
+  const imagePath = getImagePath('/test/images/basic_test.png')
+
+  const params = {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET
+  }
+
+  const { results, stats } = await runDoctrOCR(t, params, imagePath)
+
+  const outputTexts = results.map(r => r.text)
+  t.ok(results.length > 0, `PNG: should detect text regions, got ${results.length}`)
+  t.ok(outputTexts.some(w => w.toLowerCase().includes('normal')), 'PNG should detect "normal"')
+  t.comment('PNG detected texts: ' + JSON.stringify(outputTexts))
+  t.comment(formatOCRPerformanceMetrics('[DocTR PNG]', stats, outputTexts, { skipReport: true }))
+})
+
+test('DocTR basic - English image', { timeout: TEST_TIMEOUT }, async function (t) {
+  const imagePath = getImagePath('/test/images/english.bmp')
+
+  const params = {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET
+  }
+
+  const { results, stats } = await runDoctrOCR(t, params, imagePath)
+
+  const outputTexts = results.map(r => r.text)
+  t.ok(results.length > 0, `English: should detect text regions, got ${results.length}`)
+
+  // Recognition accuracy: at least 7 of 10 expected words to catch OCR regressions
+  assertRecognitionAccuracy(t, outputTexts, ENGLISH_RECOGNITION_WORDS, 7, 'English')
+
+  // english.bmp is 905x480 — verify coordinates are in original image space
+  let coordsInBounds = true
+  for (const r of results) {
+    for (const point of r.bbox) {
+      if (point[0] < 0 || point[0] > 905 || point[1] < 0 || point[1] > 480) {
+        coordsInBounds = false
+      }
+    }
+  }
+  t.ok(coordsInBounds, 'All bbox coordinates within image bounds (905x480)')
+
+  t.comment('English detected texts: ' + JSON.stringify(outputTexts))
+  t.comment(formatOCRPerformanceMetrics('[DocTR English]', stats, outputTexts, { skipReport: true }))
+})

package/test/integration/doctr-clinical-chemistry.test.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const test = require('brittle')
+const { getImagePath, formatOCRPerformanceMetrics, runDoctrOCR, ensureDoctrModels, PERF_RUNS } = require('./utils')
+
+const DOCTR_TEST_TIMEOUT = 180 * 1000
+
+let DB_MOBILENET
+let CRNN_MOBILENET
+let modelsAvailable = false
+
+test('DocTR clinical chemistry - download models', { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+  const models = await ensureDoctrModels()
+  if (!models) {
+    t.comment('DocTR models unavailable (download failed) — remaining tests will be skipped')
+    return
+  }
+  DB_MOBILENET = models.db_mobilenet_v3_large
+  CRNN_MOBILENET = models.crnn_mobilenet_v3_small
+  modelsAvailable = true
+  t.ok(DB_MOBILENET, 'db_mobilenet model available')
+  t.ok(CRNN_MOBILENET, 'crnn_mobilenet model available')
+})
+
+const EXPECTED_WORDS = [
+  'clinical', 'chemistry', 'alkaline', 'phosphatase',
+  'hemoglobin', 'creatinine', 'cholesterol', 'triglycerides',
+  'bilirubin', 'albumin', 'protein', 'lipid'
+]
+
+function runClinicalChemistryTest (device, run) {
+  const tag = device.toUpperCase()
+
+  test(`DocTR clinical chemistry [${tag}] run ${run} - db_mobilenet + crnn_mobilenet`, { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+    if (!modelsAvailable) { t.comment('Skipped — models unavailable'); return }
+    const imagePath = getImagePath('/test/images/clinical_chemistry.png')
+
+    t.comment(`Testing DocTR on clinical chemistry lab result image [${tag}] (run ${run}/${PERF_RUNS})`)
+    t.comment('Detector: db_mobilenet_v3_large, Recognizer: crnn_mobilenet_v3_small (CTC)')
+
+    const { results, stats } = await runDoctrOCR(t, {
+      pathDetector: DB_MOBILENET,
+      pathRecognizer: CRNN_MOBILENET
+    }, imagePath)
+
+    const texts = results.map(r => r.text)
+    t.comment('Detected texts: ' + JSON.stringify(texts))
+    t.comment(formatOCRPerformanceMetrics(`[DocTR clinical_chemistry] [${tag}]`, stats, texts, { imagePath }))
+
+    t.ok(results.length > 0, `should detect text regions, got ${results.length}`)
+
+    const lowerTexts = texts.map(w => w.toLowerCase())
+    for (const word of EXPECTED_WORDS) {
+      t.ok(
+        lowerTexts.some(w => w.includes(word)),
+        `should detect "${word}" in clinical chemistry report`
+      )
+    }
+
+    t.pass(`DocTR clinical chemistry [${tag}] run ${run} completed successfully`)
+  })
+}
+
+for (let i = 1; i <= PERF_RUNS; i++) runClinicalChemistryTest('cpu', i)

package/test/integration/doctr-ct-scan.test.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const test = require('brittle')
+const { getImagePath, formatOCRPerformanceMetrics, runDoctrOCR, ensureDoctrModels, PERF_RUNS } = require('./utils')
+
+const DOCTR_TEST_TIMEOUT = 180 * 1000
+
+let DB_MOBILENET
+let CRNN_MOBILENET
+let modelsAvailable = false
+
+test('DocTR CT scan - download models', { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+  const models = await ensureDoctrModels()
+  if (!models) {
+    t.comment('DocTR models unavailable (download failed) — remaining tests will be skipped')
+    return
+  }
+  DB_MOBILENET = models.db_mobilenet_v3_large
+  CRNN_MOBILENET = models.crnn_mobilenet_v3_small
+  modelsAvailable = true
+  t.ok(DB_MOBILENET, 'db_mobilenet model available')
+  t.ok(CRNN_MOBILENET, 'crnn_mobilenet model available')
+})
+
+const EXPECTED_WORDS = [
+  'diagnostic', 'imaging', 'computed', 'tomography',
+  'chest', 'abdomen', 'lung', 'liver', 'pancreas',
+  'gallbladder', 'spleen', 'radiologist', 'allied',
+  'medical', 'center', 'patient', 'heart', 'trachea',
+  'vascular', 'normal'
+]
+
+function runCtScanTest (device, run) {
+  const tag = device.toUpperCase()
+
+  test(`DocTR CT scan [${tag}] run ${run} - db_mobilenet + crnn_mobilenet`, { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+    if (!modelsAvailable) { t.comment('Skipped — models unavailable'); return }
+    const imagePath = getImagePath('/test/images/ct_scan_report.png')
+
+    t.comment(`Testing DocTR on CT scan diagnostic report image [${tag}] (run ${run}/${PERF_RUNS})`)
+    t.comment('Detector: db_mobilenet_v3_large, Recognizer: crnn_mobilenet_v3_small (CTC)')
+
+    const { results, stats } = await runDoctrOCR(t, {
+      pathDetector: DB_MOBILENET,
+      pathRecognizer: CRNN_MOBILENET
+    }, imagePath)
+
+    const texts = results.map(r => r.text)
+    t.comment('Detected texts: ' + JSON.stringify(texts))
+    t.comment(formatOCRPerformanceMetrics(`[DocTR ct_scan_report] [${tag}]`, stats, texts, { imagePath }))
+
+    t.ok(results.length > 0, `should detect text regions, got ${results.length}`)
+
+    const lowerTexts = texts.map(w => w.toLowerCase())
+    for (const word of EXPECTED_WORDS) {
+      t.ok(
+        lowerTexts.some(w => w.includes(word)),
+        `should detect "${word}" in CT scan report`
+      )
+    }
+
+    t.pass(`DocTR CT scan report [${tag}] run ${run} completed successfully`)
+  })
+}
+
+for (let i = 1; i <= PERF_RUNS; i++) runCtScanTest('cpu', i)

package/test/integration/doctr-lab-results.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const test = require('brittle')
+const { getImagePath, formatOCRPerformanceMetrics, runDoctrOCR, ensureDoctrModels, PERF_RUNS } = require('./utils')
+
+const DOCTR_TEST_TIMEOUT = 180 * 1000
+
+let DB_MOBILENET
+let CRNN_MOBILENET
+let modelsAvailable = false
+
+test('DocTR lab results - download models', { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+  const models = await ensureDoctrModels()
+  if (!models) {
+    t.comment('DocTR models unavailable (download failed) — remaining tests will be skipped')
+    return
+  }
+  DB_MOBILENET = models.db_mobilenet_v3_large
+  CRNN_MOBILENET = models.crnn_mobilenet_v3_small
+  modelsAvailable = true
+  t.ok(DB_MOBILENET, 'db_mobilenet model available')
+  t.ok(CRNN_MOBILENET, 'crnn_mobilenet model available')
+})
+
+const EXPECTED_WORDS = [
+  'parameter', 'results', 'calculated', 'direct', 'values',
+  'clinical', 'blood', 'patient', 'medivista', 'hospital',
+  'biochemistry', 'department', 'arterial', 'gases',
+  'oxygen', 'electrolyte', 'metabolite', 'oximetry'
+]
+
+function runLabResultsTest (device, run) {
+  const tag = device.toUpperCase()
+
+  test(`DocTR lab results [${tag}] run ${run} - db_mobilenet + crnn_mobilenet`, { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+    if (!modelsAvailable) { t.comment('Skipped — models unavailable'); return }
+    const imagePath = getImagePath('/test/images/lab_results.png')
+
+    t.comment(`Testing DocTR on medical lab results image [${tag}] (run ${run}/${PERF_RUNS})`)
+    t.comment('Detector: db_mobilenet_v3_large, Recognizer: crnn_mobilenet_v3_small (CTC)')
+
+    const { results, stats } = await runDoctrOCR(t, {
+      pathDetector: DB_MOBILENET,
+      pathRecognizer: CRNN_MOBILENET
+    }, imagePath)
+
+    const texts = results.map(r => r.text)
+    t.comment('Detected texts: ' + JSON.stringify(texts))
+    t.comment(formatOCRPerformanceMetrics(`[DocTR lab_results] [${tag}]`, stats, texts, { imagePath }))
+
+    t.ok(results.length > 0, `should detect text regions, got ${results.length}`)
+
+    const lowerTexts = texts.map(w => w.toLowerCase())
+    for (const word of EXPECTED_WORDS) {
+      t.ok(
+        lowerTexts.some(w => w.includes(word)),
+        `should detect "${word}" in lab results`
+      )
+    }
+
+    t.pass(`DocTR lab results [${tag}] run ${run} completed successfully`)
+  })
+}
+
+for (let i = 1; i <= PERF_RUNS; i++) runLabResultsTest('cpu', i)

package/test/integration/doctr-liver-function.test.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const test = require('brittle')
+const { getImagePath, formatOCRPerformanceMetrics, runDoctrOCR, ensureDoctrModels, PERF_RUNS } = require('./utils')
+
+const DOCTR_TEST_TIMEOUT = 180 * 1000
+
+let DB_MOBILENET
+let CRNN_MOBILENET
+let modelsAvailable = false
+
+test('DocTR liver function - download models', { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+  const models = await ensureDoctrModels()
+  if (!models) {
+    t.comment('DocTR models unavailable (download failed) — remaining tests will be skipped')
+    return
+  }
+  DB_MOBILENET = models.db_mobilenet_v3_large
+  CRNN_MOBILENET = models.crnn_mobilenet_v3_small
+  modelsAvailable = true
+  t.ok(DB_MOBILENET, 'db_mobilenet model available')
+  t.ok(CRNN_MOBILENET, 'crnn_mobilenet model available')
+})
+
+const EXPECTED_WORDS = [
+  'bilirubin', 'sgot', 'sgpt', 'alkaline', 'phosphatase',
+  'albumin', 'globulin', 'protein', 'serum', 'pathology',
+  'biochemistry', 'hospital', 'conjugated', 'unconjugated',
+  // TODO: crnn_mobilenet_v3_small misreads "INVESTIGATION" as "INVESTIGATIIN"/"investiaation"
+  // strengthen back to 'investigation' when model quality improves
+  'ratio', 'specimen', 'investig', 'total'
+]
+
+function runLiverFunctionTest (device, run) {
+  const tag = device.toUpperCase()
+
+  test(`DocTR liver function [${tag}] run ${run} - db_mobilenet + crnn_mobilenet`, { timeout: DOCTR_TEST_TIMEOUT }, async function (t) {
+    if (!modelsAvailable) { t.comment('Skipped — models unavailable'); return }
+    const imagePath = getImagePath('/test/images/liver_function_test.png')
+
+    t.comment(`Testing DocTR on liver function test (LFT) image [${tag}] (run ${run}/${PERF_RUNS})`)
+    t.comment('Detector: db_mobilenet_v3_large, Recognizer: crnn_mobilenet_v3_small (CTC)')
+
+    const { results, stats } = await runDoctrOCR(t, {
+      pathDetector: DB_MOBILENET,
+      pathRecognizer: CRNN_MOBILENET
+    }, imagePath)
+
+    const texts = results.map(r => r.text)
+    t.comment('Detected texts: ' + JSON.stringify(texts))
+    t.comment(formatOCRPerformanceMetrics(`[DocTR liver_function_test] [${tag}]`, stats, texts, { imagePath }))
+
+    t.ok(results.length > 0, `should detect text regions, got ${results.length}`)
+
+    const lowerTexts = texts.map(w => w.toLowerCase())
+    for (const word of EXPECTED_WORDS) {
+      t.ok(
+        lowerTexts.some(w => w.includes(word)),
+        `should detect "${word}" in liver function test report`
+      )
+    }
+
+    t.pass(`DocTR liver function test [${tag}] run ${run} completed successfully`)
+  })
+}
+
+for (let i = 1; i <= PERF_RUNS; i++) runLiverFunctionTest('cpu', i)

package/test/integration/doctr-models.test.js

@@ -0,0 +1,132 @@
+'use strict'
+
+const test = require('brittle')
+const fs = require('bare-fs')
+const { getImagePath, formatOCRPerformanceMetrics, runDoctrOCR, ensureDoctrModels } = require('./utils')
+
+const TEST_TIMEOUT = 180 * 1000
+
+// Words reliably detected by db_mobilenet_v3_large + crnn_mobilenet_v3_small on english.bmp (case-insensitive).
+// english.bmp is a WHO coronavirus infographic with known text.
+const ENGLISH_EXPECTED_WORDS = [
+  'health', 'world', 'animals', 'farm', 'unprotected', 'wild',
+  'eggs', 'meat', 'cook', 'symptoms', 'cold', 'anyone',
+  'avoid', 'sneezing', 'nose', 'coughing', 'mouth', 'cover',
+  'hand', 'rub', 'soap', 'water', 'hands', 'clean',
+  'your', 'reduce', 'risk'
+]
+
+// Model paths (set after download)
+let DB_MOBILENET
+let CRNN_MOBILENET
+
+/**
+ * Assert that all expected words appear in the detected texts (case-insensitive)
+ */
+function assertExpectedWords (t, texts, expectedWords, label) {
+  const lowerTexts = texts.map(w => w.toLowerCase())
+  for (const word of expectedWords) {
+    t.ok(
+      lowerTexts.includes(word.toLowerCase()),
+      `${label} should detect "${word}" (got: ${JSON.stringify(texts)})`
+    )
+  }
+}
+
+// -------------------------------------------------------------------
+// Download models before tests
+// -------------------------------------------------------------------
+test('DocTR models - download all models', { timeout: TEST_TIMEOUT }, async function (t) {
+  const models = await ensureDoctrModels()
+  DB_MOBILENET = models.db_mobilenet_v3_large
+  CRNN_MOBILENET = models.crnn_mobilenet_v3_small
+  t.ok(fs.existsSync(DB_MOBILENET), 'db_mobilenet_v3_large exists')
+  t.ok(fs.existsSync(CRNN_MOBILENET), 'crnn_mobilenet_v3_small exists')
+  t.pass('All models available')
+})
+
+// -------------------------------------------------------------------
+// 1. Default combo: db_mobilenet_v3_large + crnn_mobilenet_v3_small
+// -------------------------------------------------------------------
+test('DocTR CTC - db_mobilenet + crnn_mobilenet on english.bmp', { timeout: TEST_TIMEOUT }, async function (t) {
+  const imagePath = getImagePath('/test/images/english.bmp')
+  t.comment('Detector: db_mobilenet_v3_large, Recognizer: crnn_mobilenet_v3_small')
+
+  const { results, stats } = await runDoctrOCR(t, {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET
+  }, imagePath)
+
+  const texts = results.map(r => r.text)
+  t.comment('Detected: ' + JSON.stringify(texts))
+  t.comment(formatOCRPerformanceMetrics('[CTC mobilenet]', stats, texts, { skipReport: true }))
+
+  // Should detect many text regions from the infographic
+  t.ok(results.length >= 30, `should detect >= 30 text regions, got ${results.length}`)
+
+  // All confidences should be valid numbers in [0, 1]
+  for (const r of results) {
+    t.ok(r.confidence >= 0 && r.confidence <= 1, `confidence ${r.confidence.toFixed(3)} in [0,1]`)
+  }
+
+  // Verify expected words are detected
+  assertExpectedWords(t, texts, ENGLISH_EXPECTED_WORDS, '[CTC mobilenet]')
+})
+
+// -------------------------------------------------------------------
+// 2. repeated run — same image produces valid output
+// -------------------------------------------------------------------
+test('DocTR repeated run - should not crash and produce valid output', { timeout: TEST_TIMEOUT }, async function (t) {
+  const imagePath = getImagePath('/test/images/english.bmp')
+  t.comment('Testing repeated DocTR run on english.bmp')
+
+  const { results, stats } = await runDoctrOCR(t, {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET
+  }, imagePath)
+
+  const texts = results.map(r => r.text)
+  t.comment('Detected texts: ' + JSON.stringify(texts))
+  t.comment(formatOCRPerformanceMetrics('[DocTR repeated]', stats, texts, { skipReport: true }))
+
+  t.ok(results.length >= 30, `should detect >= 30 text regions, got ${results.length}`)
+  assertExpectedWords(t, texts, ENGLISH_EXPECTED_WORDS, '[DocTR repeated]')
+})
+
+// -------------------------------------------------------------------
+// 3. recognizerBatchSize — different batch sizes produce valid output
+// -------------------------------------------------------------------
+test('DocTR recognizerBatchSize - batch=1 vs batch=16 both produce valid output', { timeout: TEST_TIMEOUT * 2 }, async function (t) {
+  const imagePath = getImagePath('/test/images/english.bmp')
+  t.comment('Testing recognizerBatchSize=1 vs recognizerBatchSize=16')
+
+  const { results: resultsBatch1 } = await runDoctrOCR(t, {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET,
+    recognizerBatchSize: 1
+  }, imagePath)
+
+  const { results: resultsBatch16 } = await runDoctrOCR(t, {
+    pathDetector: DB_MOBILENET,
+    pathRecognizer: CRNN_MOBILENET,
+    recognizerBatchSize: 16
+  }, imagePath)
+
+  const textsBatch1 = resultsBatch1.map(r => r.text)
+  const textsBatch16 = resultsBatch16.map(r => r.text)
+  t.comment('Batch=1 texts (' + textsBatch1.length + '): ' + JSON.stringify(textsBatch1))
+  t.comment('Batch=16 texts (' + textsBatch16.length + '): ' + JSON.stringify(textsBatch16))
+
+  t.ok(resultsBatch1.length > 0, 'Batch=1 should detect text')
+  t.ok(resultsBatch16.length > 0, 'Batch=16 should detect text')
+  t.is(resultsBatch1.length, resultsBatch16.length, 'Both batch sizes should detect same number of regions')
+
+  // Texts should be identical regardless of batch size
+  for (let i = 0; i < Math.min(resultsBatch1.length, resultsBatch16.length); i++) {
+    t.is(resultsBatch1[i].text, resultsBatch16[i].text, 'Text at index ' + i + ' should match across batch sizes')
+  }
+
+  assertExpectedWords(t, textsBatch1, ENGLISH_EXPECTED_WORDS, '[batch=1]')
+  assertExpectedWords(t, textsBatch16, ENGLISH_EXPECTED_WORDS, '[batch=16]')
+  t.pass('recognizerBatchSize does not affect output accuracy')
+})