@yigitahmetsahin/captcha-solver 2.0.1 → 3.1.0

package/dist/index.js

@@ -1,51 +1,522 @@
-// src/solver.ts
-import { generateText } from "ai";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/preprocess.ts
 import fs from "fs";
 import path from "path";
 import sharp from "sharp";
-async function preprocessCaptcha(input) {
-  const buf = await preprocessCaptchaToBuffer(input);
+async function preprocessCaptcha(input, options) {
+  const buf = await preprocessCaptchaToBuffer(input, options);
   return buf.toString("base64");
 }
-async function preprocessCaptchaToBuffer(input) {
-  const source = typeof input === "string" ? path.resolve(input) : input;
+async function preprocessCaptchaToBuffer(input, options) {
+  const {
+    preCropHeight = 1,
+    median = 0,
+    blur = 1.5,
+    greyscale = true,
+    scale = 4,
+    upscaleKernel = "lanczos3",
+    postBlur = 0,
+    normalise = false,
+    contrast = 3,
+    sharpen = true,
+    threshold = false,
+    negate = false,
+    crop = "auto",
+    padding = true
+  } = options ?? {};
+  let source = typeof input === "string" ? path.resolve(input) : input;
   const metadata = await sharp(source).metadata();
   const origW = metadata.width;
-  const origH = metadata.height;
-  const smoothed = await sharp(source).blur(1.5).greyscale().toBuffer();
-  const upscaled = await sharp(smoothed).resize(origW * 4, origH * 4, { kernel: "lanczos3" }).toBuffer();
-  const stats = await sharp(upscaled).stats();
-  const mean = stats.channels[0].mean;
-  const enhanced = await sharp(upscaled).linear(3, mean * (1 - 3)).sharpen({ sigma: 1, m1: 2, m2: 1 }).toBuffer();
-  const scaledW = origW * 4;
-  const scaledH = origH * 4;
-  const cropLeft = Math.floor(scaledW * 0.1);
-  const cropTop = Math.floor(scaledH * 0.02);
-  const cropRight = Math.floor(scaledW * 0.9);
-  const cropBottom = Math.floor(scaledH * 0.6);
-  const cropW = cropRight - cropLeft;
-  const cropH = cropBottom - cropTop;
-  return sharp(enhanced).extract({ left: cropLeft, top: cropTop, width: cropW, height: cropH }).extend({
-    top: 20,
-    bottom: 20,
-    left: 30,
-    right: 30,
+  let origH = metadata.height;
+  if (preCropHeight < 1 && preCropHeight > 0) {
+    const keepH = Math.floor(origH * preCropHeight);
+    source = await sharp(source).extract({ left: 0, top: 0, width: origW, height: keepH }).toBuffer();
+    origH = keepH;
+  }
+  let pipeline = sharp(source);
+  if (median > 0) pipeline = pipeline.median(median);
+  if (blur > 0) pipeline = pipeline.blur(blur);
+  if (greyscale) pipeline = pipeline.greyscale();
+  const smoothed = await pipeline.toBuffer();
+  const upscaled = await sharp(smoothed).resize(origW * scale, origH * scale, { kernel: upscaleKernel }).toBuffer();
+  let postProcessed = upscaled;
+  if (postBlur > 0) {
+    postProcessed = await sharp(upscaled).blur(postBlur).toBuffer();
+  }
+  if (normalise) {
+    postProcessed = await sharp(postProcessed).normalise().toBuffer();
+  }
+  let enhanced;
+  if (contrast !== 1) {
+    const stats = await sharp(postProcessed).stats();
+    const mean = stats.channels[0].mean;
+    let pipe = sharp(postProcessed).linear(contrast, mean * (1 - contrast));
+    if (sharpen) pipe = pipe.sharpen({ sigma: 1, m1: 2, m2: 1 });
+    enhanced = await pipe.toBuffer();
+  } else {
+    enhanced = sharpen ? await sharp(postProcessed).sharpen({ sigma: 1, m1: 2, m2: 1 }).toBuffer() : postProcessed;
+  }
+  if (threshold !== false && typeof threshold === "number") {
+    enhanced = await sharp(enhanced).threshold(threshold).toBuffer();
+  }
+  const targetWidth = options?.targetWidth;
+  if (targetWidth && targetWidth > 0) {
+    enhanced = await sharp(enhanced).resize(targetWidth, null, { kernel: "lanczos3" }).toBuffer();
+  }
+  let cropped;
+  if (crop === "none") {
+    cropped = enhanced;
+  } else if (crop === "auto") {
+    cropped = await autoCrop(enhanced);
+  } else {
+    const fractions = crop === "legacy" ? LEGACY_CROP : crop;
+    const scaledW = origW * scale;
+    const scaledH = origH * scale;
+    const cropLeft = Math.floor(scaledW * fractions.left);
+    const cropTop = Math.floor(scaledH * fractions.top);
+    const cropRight = Math.floor(scaledW * fractions.right);
+    const cropBottom = Math.floor(scaledH * fractions.bottom);
+    const cropW = cropRight - cropLeft;
+    const cropH = cropBottom - cropTop;
+    cropped = await sharp(enhanced).extract({ left: cropLeft, top: cropTop, width: cropW, height: cropH }).toBuffer();
+  }
+  const final = negate ? await sharp(cropped).negate().toBuffer() : cropped;
+  if (padding === false) {
+    return sharp(final).png().toBuffer();
+  }
+  const pad = typeof padding === "number" ? padding : void 0;
+  const vPad = pad ?? 20;
+  const hPad = pad ?? 30;
+  return sharp(final).extend({
+    top: vPad,
+    bottom: vPad,
+    left: hPad,
+    right: hPad,
     background: { r: 255, g: 255, b: 255 }
   }).png().toBuffer();
 }
+async function autoCrop(enhanced) {
+  try {
+    const trimmed = sharp(enhanced).trim({ threshold: 30 });
+    const trimmedBuf = await trimmed.toBuffer({ resolveWithObject: true });
+    const { width, height } = trimmedBuf.info;
+    if (width > 2 && height > 2) {
+      return trimmedBuf.data;
+    }
+  } catch {
+  }
+  return enhanced;
+}
 function imageToBase64(imagePath) {
   const buffer = fs.readFileSync(imagePath);
   return buffer.toString("base64");
 }
+var LEGACY_CROP;
+var init_preprocess = __esm({
+  "src/preprocess.ts"() {
+    "use strict";
+    LEGACY_CROP = { left: 0.1, top: 0.02, right: 0.9, bottom: 0.6 };
+  }
+});
+
+// src/tesseract.ts
+var tesseract_exports = {};
+__export(tesseract_exports, {
+  TESSERACT_VARIANTS: () => TESSERACT_VARIANTS,
+  createTesseractReader: () => createTesseractReader
+});
+async function createTesseractReader() {
+  let createWorker;
+  try {
+    const tess = await import("tesseract.js");
+    createWorker = tess.createWorker;
+  } catch {
+    return null;
+  }
+  const worker = await createWorker("eng");
+  await worker.setParameters({
+    tessedit_char_whitelist: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
+    tessedit_pageseg_mode: "7"
+    // PSM.SINGLE_LINE
+  });
+  return {
+    async recognize(image) {
+      const { data } = await worker.recognize(image);
+      return data.text.trim().replace(/[^A-Z0-9]/g, "");
+    },
+    async recognizeMulti(input, variants) {
+      const results = [];
+      for (const opts of variants) {
+        try {
+          const buf = await preprocessCaptchaToBuffer(input, opts);
+          const { data } = await worker.recognize(buf);
+          const clean = data.text.trim().replace(/[^A-Z0-9]/g, "");
+          if (clean.length >= 2 && clean.length <= 8) {
+            results.push(clean);
+          }
+        } catch {
+        }
+      }
+      return results;
+    },
+    async dispose() {
+      await worker.terminate();
+    }
+  };
+}
+var TESSERACT_VARIANTS;
+var init_tesseract = __esm({
+  "src/tesseract.ts"() {
+    "use strict";
+    init_preprocess();
+    TESSERACT_VARIANTS = [
+      // Variant 1: standard enhanced
+      {
+        blur: 1.5,
+        greyscale: true,
+        scale: 4,
+        contrast: 3,
+        sharpen: true,
+        crop: "auto",
+        padding: true
+      },
+      // Variant 2: enhanced + negated
+      {
+        blur: 1.5,
+        greyscale: true,
+        scale: 4,
+        contrast: 3,
+        sharpen: true,
+        negate: true,
+        crop: "auto",
+        padding: true
+      }
+    ];
+  }
+});
 
 // src/solver.ts
-var PROMPT = `You are an assistant helping a visually impaired person read distorted text from an image.
-The text contains uppercase letters A-Z and/or digits 0-9.
-A thin vertical stroke is the digit 1. Never read it as the letter I or L.
-A round closed shape is the letter O, not the letter D.
-Output ONLY the exact characters you read, nothing else.`;
+init_preprocess();
+import { generateText } from "ai";
+
+// src/disambiguate.ts
+import sharp2 from "sharp";
+async function disambiguateResult(result, rankedByPos, binaryImage) {
+  const ambiguousPositions = [];
+  for (let pos = 0; pos < result.length; pos++) {
+    if (result[pos] !== "2" && result[pos] !== "Z") continue;
+    const ranked = rankedByPos[pos];
+    const hasAlt = (ranked.get("6") ?? 0) >= 1 || (ranked.get("L") ?? 0) >= 1 || (ranked.get("1") ?? 0) >= 1;
+    if (hasAlt) {
+      ambiguousPositions.push(pos);
+      continue;
+    }
+    const twoZCount = result.filter((c) => c === "2" || c === "Z").length;
+    if (twoZCount >= 3) {
+      ambiguousPositions.push(pos);
+    }
+  }
+  if (ambiguousPositions.length === 0) return;
+  const meta = await sharp2(binaryImage).metadata();
+  const fullW = meta.width;
+  const fullH = meta.height;
+  const cropTop = Math.floor(fullH * 0.12);
+  const cropH = Math.floor(fullH * 0.76);
+  const { data, info } = await sharp2(binaryImage).extract({ left: 0, top: cropTop, width: fullW, height: cropH }).greyscale().negate().raw().toBuffer({ resolveWithObject: true });
+  const w = info.width;
+  const h = info.height;
+  const pixels = new Uint8Array(data);
+  const regions = segmentCharacters(pixels, w, h, result.length);
+  if (!regions || regions.length !== result.length) return;
+  for (const pos of ambiguousPositions) {
+    const region = regions[pos];
+    const features = analyseCharacter(pixels, w, h, region);
+    const newChar = classifyFromFeatures(features, result[pos]);
+    if (newChar) {
+      result[pos] = newChar;
+    }
+  }
+}
+function segmentCharacters(pixels, w, h, expectedCount) {
+  const colDensity = new Float64Array(w);
+  for (let x = 0; x < w; x++) {
+    let count = 0;
+    for (let y = 0; y < h; y++) {
+      if (pixels[y * w + x] >= 128) count++;
+    }
+    colDensity[x] = count / h;
+  }
+  let contentLeft = 0;
+  let contentRight = w;
+  for (let x = 0; x < w; x++) {
+    if (colDensity[x] > 0.05) {
+      contentLeft = x;
+      break;
+    }
+  }
+  for (let x = w - 1; x >= 0; x--) {
+    if (colDensity[x] > 0.05) {
+      contentRight = x + 1;
+      break;
+    }
+  }
+  const smoothW = 15;
+  const smoothed = new Float64Array(w);
+  for (let x = contentLeft; x < contentRight; x++) {
+    let sum = 0;
+    let count = 0;
+    for (let dx = -smoothW; dx <= smoothW; dx++) {
+      const nx = x + dx;
+      if (nx >= contentLeft && nx < contentRight) {
+        sum += colDensity[nx];
+        count++;
+      }
+    }
+    smoothed[x] = sum / count;
+  }
+  const charWidth = (contentRight - contentLeft) / expectedCount;
+  const margin = Math.floor(charWidth * 0.6);
+  const searchLeft = contentLeft + margin;
+  const searchRight = contentRight - margin;
+  const valleys = [];
+  for (let x = searchLeft + 1; x < searchRight - 1; x++) {
+    if (smoothed[x] <= smoothed[x - 1] && smoothed[x] <= smoothed[x + 1]) {
+      const leftMax = Math.max(...Array.from(smoothed.slice(Math.max(searchLeft, x - 40), x)));
+      const rightMax = Math.max(
+        ...Array.from(smoothed.slice(x + 1, Math.min(searchRight, x + 41)))
+      );
+      const depth = Math.min(leftMax, rightMax) - smoothed[x];
+      if (depth > 0.01) {
+        valleys.push({ x, depth });
+      }
+    }
+  }
+  valleys.sort((a, b) => b.depth - a.depth);
+  const splits = [];
+  const minDist = charWidth * 0.6;
+  for (const v of valleys) {
+    if (splits.length >= expectedCount - 1) break;
+    if (splits.every((s) => Math.abs(s - v.x) > minDist)) {
+      splits.push(v.x);
+    }
+  }
+  if (splits.length < expectedCount - 1) {
+    const step = (contentRight - contentLeft) / expectedCount;
+    splits.length = 0;
+    for (let i = 1; i < expectedCount; i++) {
+      splits.push(Math.floor(contentLeft + step * i));
+    }
+  }
+  splits.sort((a, b) => a - b);
+  const boundaries = [contentLeft, ...splits, contentRight];
+  return boundaries.slice(0, expectedCount).map((start, idx) => {
+    const end = boundaries[idx + 1];
+    let top = h;
+    let bottom = 0;
+    for (let y = 0; y < h; y++) {
+      for (let x = start; x < end; x++) {
+        if (pixels[y * w + x] >= 128) {
+          if (y < top) top = y;
+          if (y > bottom) bottom = y;
+        }
+      }
+    }
+    return { left: start, right: end, top: Math.max(0, top), bottom: Math.min(h, bottom + 1) };
+  });
+}
+function detectHoles(pixels, imgW, region) {
+  const rw = region.right - region.left;
+  const rh = region.bottom - region.top;
+  if (rw < 3 || rh < 3) return { count: 0, hasBottom: false, hasTop: false };
+  const grid = new Uint8Array(rw * rh);
+  for (let ly = 0; ly < rh; ly++) {
+    for (let lx = 0; lx < rw; lx++) {
+      const px = pixels[(region.top + ly) * imgW + (region.left + lx)];
+      grid[ly * rw + lx] = px >= 128 ? 1 : 0;
+    }
+  }
+  const visited = new Uint8Array(rw * rh);
+  const queue = [];
+  for (let lx = 0; lx < rw; lx++) {
+    if (grid[lx] === 0 && !visited[lx]) {
+      visited[lx] = 1;
+      queue.push(lx);
+    }
+    const bottom = (rh - 1) * rw + lx;
+    if (grid[bottom] === 0 && !visited[bottom]) {
+      visited[bottom] = 1;
+      queue.push(bottom);
+    }
+  }
+  for (let ly = 0; ly < rh; ly++) {
+    const left = ly * rw;
+    if (grid[left] === 0 && !visited[left]) {
+      visited[left] = 1;
+      queue.push(left);
+    }
+    const right = ly * rw + rw - 1;
+    if (grid[right] === 0 && !visited[right]) {
+      visited[right] = 1;
+      queue.push(right);
+    }
+  }
+  let qi = 0;
+  while (qi < queue.length) {
+    const idx = queue[qi++];
+    const lx = idx % rw;
+    const ly = Math.floor(idx / rw);
+    for (const [dx, dy] of [
+      [0, 1],
+      [0, -1],
+      [1, 0],
+      [-1, 0]
+    ]) {
+      const nx = lx + dx;
+      const ny = ly + dy;
+      if (nx < 0 || nx >= rw || ny < 0 || ny >= rh) continue;
+      const ni = ny * rw + nx;
+      if (!visited[ni] && grid[ni] === 0) {
+        visited[ni] = 1;
+        queue.push(ni);
+      }
+    }
+  }
+  let holeCount = 0;
+  let hasBottom = false;
+  let hasTop = false;
+  const midY = rh / 2;
+  for (let ly = 0; ly < rh; ly++) {
+    for (let lx = 0; lx < rw; lx++) {
+      const idx = ly * rw + lx;
+      if (grid[idx] === 0 && !visited[idx]) {
+        const holeQueue = [idx];
+        visited[idx] = 1;
+        let hi = 0;
+        let area = 0;
+        let sumY = 0;
+        while (hi < holeQueue.length) {
+          const hidx = holeQueue[hi++];
+          area++;
+          sumY += Math.floor(hidx / rw);
+          const hx = hidx % rw;
+          const hy = Math.floor(hidx / rw);
+          for (const [dx, dy] of [
+            [0, 1],
+            [0, -1],
+            [1, 0],
+            [-1, 0]
+          ]) {
+            const hnx = hx + dx;
+            const hny = hy + dy;
+            if (hnx < 0 || hnx >= rw || hny < 0 || hny >= rh) continue;
+            const hni = hny * rw + hnx;
+            if (!visited[hni] && grid[hni] === 0) {
+              visited[hni] = 1;
+              holeQueue.push(hni);
+            }
+          }
+        }
+        const charArea = rw * rh;
+        if (area > charArea * 5e-3) {
+          holeCount++;
+          const avgY = sumY / area;
+          if (avgY >= midY) hasBottom = true;
+          else hasTop = true;
+        }
+      }
+    }
+  }
+  return { count: holeCount, hasBottom, hasTop };
+}
+function analyseCharacter(pixels, imgW, _imgH, region) {
+  const rw = region.right - region.left;
+  const rh = region.bottom - region.top;
+  const holes = detectHoles(pixels, imgW, region);
+  const aspectRatio = rh / Math.max(rw, 1);
+  const quarterH = Math.max(3, Math.floor(rh * 0.25));
+  let topMinX = rw, topMaxX = 0, botMinX = rw, botMaxX = 0;
+  for (let lx = 0; lx < rw; lx++) {
+    for (let ly = 0; ly < quarterH; ly++) {
+      if (pixels[(region.top + ly) * imgW + (region.left + lx)] >= 128) {
+        if (lx < topMinX) topMinX = lx;
+        if (lx > topMaxX) topMaxX = lx;
+      }
+    }
+    for (let ly = rh - quarterH; ly < rh; ly++) {
+      if (pixels[(region.top + ly) * imgW + (region.left + lx)] >= 128) {
+        if (lx < botMinX) botMinX = lx;
+        if (lx > botMaxX) botMaxX = lx;
+      }
+    }
+  }
+  const topWidth = topMaxX > topMinX ? (topMaxX - topMinX) / rw : 0;
+  const bottomWidth = botMaxX > botMinX ? (botMaxX - botMinX) / rw : 0;
+  const bottomHorizontalExtent = bottomWidth;
+  const topHorizontalExtent = topWidth;
+  const topQuarterH = Math.max(3, Math.floor(rh * 0.25));
+  const rightHalf = Math.floor(rw / 2);
+  let topRightDark = 0;
+  let topRightTotal = 0;
+  for (let ly = 0; ly < topQuarterH; ly++) {
+    for (let lx = rightHalf; lx < rw; lx++) {
+      topRightTotal++;
+      if (pixels[(region.top + ly) * imgW + (region.left + lx)] >= 128) {
+        topRightDark++;
+      }
+    }
+  }
+  const topCurvature = topRightTotal > 0 && topRightDark / topRightTotal > 0.15;
+  return {
+    hasHoleBottom: holes.hasBottom,
+    hasHoleTop: holes.hasTop,
+    holeCount: holes.count,
+    aspectRatio,
+    bottomHorizontalExtent,
+    topHorizontalExtent,
+    topCurvature
+  };
+}
+function classifyFromFeatures(features, _votedChar) {
+  if (features.hasHoleBottom && !features.hasHoleTop) {
+    return "6";
+  }
+  if (features.holeCount >= 2) {
+    return "8";
+  }
+  if (features.hasHoleTop && !features.hasHoleBottom) {
+    return null;
+  }
+  if (features.holeCount === 0 && features.aspectRatio > 1.8 && !features.topCurvature) {
+    return "1";
+  }
+  if (features.holeCount === 0 && features.bottomHorizontalExtent > 0.5 && features.bottomHorizontalExtent > features.topHorizontalExtent * 1.15 && features.aspectRatio > 0.8) {
+    return "L";
+  }
+  return null;
+}
+
+// src/solver.ts
+var PROMPT = `Read the 4 distorted characters in these images. Two processed versions shown.
+The text uses UPPERCASE A-Z and digits 0-9 only. No lowercase.
+
+WARNING: The dithered rendering makes many characters appear as "2". Before writing "2", check:
+- Could it be "6"? (has closed loop at bottom)
+- Could it be "L"? (has vertical stem + horizontal foot, 90\xB0 corner)
+- Could it be "1"? (thin vertical stroke, no curve)
+- Could it be "Z"? (all straight lines, sharp angles)
+
+Also watch for: O/0 have curved sides (not D which has flat left); B has two bumps (not D with one curve); X is two crossing diagonals (not K with vertical bar); G has horizontal bar inside (not C).
+
+Output ONLY the 4 characters.`;
 var DEFAULT_MODELS = {
   openai: "gpt-4o",
   anthropic: "claude-sonnet-4-20250514",
@@ -71,7 +542,7 @@ async function resolveModel(apiKey, provider, modelId) {
       );
   }
 }
-var CONFUSION_GROUPS = {
+var LEGACY_CONFUSION_GROUPS = {
   "1": "1",
   I: "1",
   L: "1",
@@ -83,7 +554,23 @@ var CONFUSION_GROUPS = {
   Z: "Z",
   "2": "Z"
 };
-function majorityVote(attempts, expectedLength) {
+var DITHER_CONFUSION_GROUPS = {
+  D: "O",
+  O: "O",
+  I: "1",
+  "1": "1",
+  K: "X",
+  X: "X",
+  A: "X",
+  C: "G",
+  G: "G",
+  "9": "8",
+  "8": "8",
+  Y: "X",
+  E: "5",
+  "5": "5"
+};
+function majorityVote(attempts, expectedLength, groups) {
   let filtered = expectedLength ? attempts.filter((a) => a.length === expectedLength) : attempts;
   if (filtered.length === 0) {
     filtered = attempts;
@@ -103,30 +590,127 @@ function majorityVote(attempts, expectedLength) {
   }
   const sameLenAttempts = filtered.filter((a) => a.length === bestLen);
   if (sameLenAttempts.length === 0) return filtered[0];
+  const useGroups = groups && typeof groups === "object" ? groups : void 0;
   const result = [];
+  const rankedByPos = [];
   for (let pos = 0; pos < bestLen; pos++) {
     const charCounts = /* @__PURE__ */ new Map();
     for (const a of sameLenAttempts) {
       const ch = a[pos];
       charCounts.set(ch, (charCounts.get(ch) ?? 0) + 1);
     }
-    const groupCounts = /* @__PURE__ */ new Map();
-    for (const [ch, count] of charCounts) {
-      const canonical = CONFUSION_GROUPS[ch] ?? ch;
-      groupCounts.set(canonical, (groupCounts.get(canonical) ?? 0) + count);
-    }
-    let bestGroup = "";
-    let bestGroupCount = 0;
-    for (const [canonical, count] of groupCounts) {
-      if (count > bestGroupCount) {
-        bestGroup = canonical;
-        bestGroupCount = count;
+    if (useGroups) {
+      const groupCounts = /* @__PURE__ */ new Map();
+      for (const [ch, count] of charCounts) {
+        const canonical = useGroups[ch] ?? ch;
+        groupCounts.set(canonical, (groupCounts.get(canonical) ?? 0) + count);
+      }
+      rankedByPos.push(groupCounts);
+      let bestGroup = "";
+      let bestGroupCount = 0;
+      for (const [canonical, count] of groupCounts) {
+        if (count > bestGroupCount) {
+          bestGroup = canonical;
+          bestGroupCount = count;
+        }
+      }
+      result.push(bestGroup);
+    } else {
+      rankedByPos.push(charCounts);
+      let bestChar = "";
+      let bestCharCount = 0;
+      for (const [ch, count] of charCounts) {
+        if (count > bestCharCount) {
+          bestChar = ch;
+          bestCharCount = count;
+        }
+      }
+      result.push(bestChar);
+    }
+  }
+  if (bestLen >= 4) {
+    const charFreq = /* @__PURE__ */ new Map();
+    for (const ch of result) {
+      charFreq.set(ch, (charFreq.get(ch) ?? 0) + 1);
+    }
+    for (const [ch, freq] of charFreq) {
+      if (freq < 3) continue;
+      let strongestPos = -1;
+      let strongestCount = 0;
+      for (let pos = 0; pos < bestLen; pos++) {
+        if (result[pos] !== ch) continue;
+        const count = rankedByPos[pos].get(ch) ?? 0;
+        if (count > strongestCount) {
+          strongestCount = count;
+          strongestPos = pos;
+        }
+      }
+      for (let pos = 0; pos < bestLen; pos++) {
+        if (result[pos] !== ch || pos === strongestPos) continue;
+        const ranked = rankedByPos[pos];
+        const usedChars = new Set(result);
+        let bestUnique = "";
+        let bestUniqueCount = 0;
+        let bestAny = "";
+        let bestAnyCount = 0;
+        for (const [c, count] of ranked) {
+          if (c === ch) continue;
+          if (count > bestAnyCount) {
+            bestAny = c;
+            bestAnyCount = count;
+          }
+          if (!usedChars.has(c) && count > bestUniqueCount) {
+            bestUnique = c;
+            bestUniqueCount = count;
+          }
+        }
+        const sub = bestUniqueCount >= 2 ? bestUnique : bestAnyCount >= 2 ? bestAny : "";
+        if (sub) {
+          result[pos] = sub;
+        }
       }
     }
-    result.push(bestGroup);
   }
   return result.join("");
 }
+function majorityVoteDetailed(attempts, expectedLength, groups) {
+  let filtered = expectedLength ? attempts.filter((a) => a.length === expectedLength) : attempts;
+  if (filtered.length === 0) filtered = attempts;
+  if (filtered.length === 0) return { result: [], rankedByPos: [] };
+  const lenCounts = /* @__PURE__ */ new Map();
+  for (const a of filtered) lenCounts.set(a.length, (lenCounts.get(a.length) ?? 0) + 1);
+  let bestLen = 0;
+  let bestCount = 0;
+  for (const [len, count] of lenCounts) {
+    if (count > bestCount) {
+      bestLen = len;
+      bestCount = count;
+    }
+  }
+  const sameLenAttempts = filtered.filter((a) => a.length === bestLen);
+  if (sameLenAttempts.length === 0) return { result: [...filtered[0]], rankedByPos: [] };
+  const useGroups = groups && typeof groups === "object" ? groups : void 0;
+  const result = [];
+  const rankedByPos = [];
+  for (let pos = 0; pos < bestLen; pos++) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const a of sameLenAttempts) {
+      const ch = useGroups ? useGroups[a[pos]] ?? a[pos] : a[pos];
+      counts.set(ch, (counts.get(ch) ?? 0) + 1);
+    }
+    rankedByPos.push(counts);
+    let bestChar = "";
+    let bestCharCount = 0;
+    for (const [ch, count] of counts) {
+      if (count > bestCharCount) {
+        bestChar = ch;
+        bestCharCount = count;
+      }
+    }
+    result.push(bestChar);
+  }
+  return { result, rankedByPos };
+}
 function sumOptional(a, b) {
   if (a === void 0 && b === void 0) return void 0;
   return (a ?? 0) + (b ?? 0);
@@ -219,30 +803,212 @@ var Solver = class {
    * @returns Solved text, per-attempt answers, and token usage
    */
   async solve(input, options = {}) {
-    const { numAttempts = 5, expectedLength, maxRetries = 2, verbose = true } = options;
+    const {
+      numAttempts = 9,
+      expectedLength,
+      maxRetries = 2,
+      verbose = true,
+      confusionGroups = false,
+      preprocess,
+      useTesseract = true,
+      useDisambiguation = true
+    } = options;
     const model = await this.getModel();
-    const imageBuffer = await preprocessCaptchaToBuffer(input);
-    const results = await Promise.all(
-      Array.from({ length: numAttempts }, () => this.singleAttempt(model, imageBuffer, maxRetries))
-    );
-    const valid = results.filter((r) => r !== null);
+    const [enhancedBuffer, heavyCleanBuffer, mediumCleanBuffer] = await Promise.all([
+      preprocessCaptchaToBuffer(input, preprocess),
+      preprocessCaptchaToBuffer(input, {
+        blur: 0,
+        greyscale: true,
+        scale: 8,
+        upscaleKernel: "nearest",
+        postBlur: 15,
+        normalise: true,
+        contrast: 1,
+        sharpen: false,
+        threshold: 140,
+        negate: true,
+        crop: "none",
+        targetWidth: 800,
+        padding: 20
+      }),
+      preprocessCaptchaToBuffer(input, {
+        blur: 0,
+        greyscale: true,
+        scale: 8,
+        upscaleKernel: "nearest",
+        postBlur: 8,
+        normalise: true,
+        contrast: 1,
+        sharpen: false,
+        threshold: 120,
+        negate: true,
+        crop: "none",
+        targetWidth: 800,
+        padding: 20
+      })
+    ]);
+    const halfN = Math.ceil(numAttempts / 2);
+    const visionResults = await Promise.all([
+      ...Array.from(
+        { length: halfN },
+        () => this.singleAttempt(model, enhancedBuffer, heavyCleanBuffer, maxRetries)
+      ),
+      ...Array.from(
+        { length: numAttempts - halfN },
+        () => this.singleAttempt(model, enhancedBuffer, mediumCleanBuffer, maxRetries)
+      )
+    ]);
+    const valid = visionResults.filter((r) => r !== null);
     if (verbose) {
       valid.forEach((r, i) => console.log(`  Attempt ${i + 1}: ${r.text}`));
     }
     const attempts = valid.map((r) => r.text);
     const attemptUsages = valid.map((r) => r.usage);
+    if (useTesseract) {
+      try {
+        const reader = await this.getTesseractReader();
+        if (reader) {
+          const { TESSERACT_VARIANTS: TESSERACT_VARIANTS2 } = await Promise.resolve().then(() => (init_tesseract(), tesseract_exports));
+          const tessReads = await reader.recognizeMulti(input, TESSERACT_VARIANTS2);
+          for (const read of tessReads) {
+            attempts.push(read);
+            if (verbose) console.log(`  Tesseract: ${read}`);
+          }
+        }
+      } catch {
+      }
+    }
+    const correctionAttempts = Math.min(3, Math.floor(numAttempts / 3));
+    if (correctionAttempts > 0 && attempts.length > 0) {
+      const initialVote = majorityVote(attempts, expectedLength, confusionGroups);
+      const suspiciousCount = [...initialVote].filter((c) => c === "2" || c === "Z").length;
+      if (suspiciousCount >= 2 && initialVote.length === (expectedLength ?? initialVote.length)) {
+        const corrPrompt = this.buildCorrectionPrompt(initialVote);
+        if (corrPrompt) {
+          const corrections = await Promise.all(
+            Array.from(
+              { length: correctionAttempts },
+              () => this.selfCorrect(model, enhancedBuffer, heavyCleanBuffer, initialVote, corrPrompt)
+            )
+          );
+          for (const c of corrections) {
+            if (c) {
+              for (let w = 0; w < 5; w++) attempts.push(c.text);
+              if (verbose) console.log(`  Corrected: ${c.text}`);
+            }
+          }
+        }
+      }
+    }
     const usage = aggregateUsage(attemptUsages);
     if (attempts.length === 0) {
       if (verbose) console.log("  All attempts failed!");
       return { text: "", attempts, usage, attemptUsages };
     }
-    return { text: majorityVote(attempts, expectedLength), attempts, usage, attemptUsages };
+    const { result, rankedByPos } = majorityVoteDetailed(attempts, expectedLength, confusionGroups);
+    if (useDisambiguation && result.length > 0 && rankedByPos.length > 0) {
+      try {
+        await disambiguateResult(result, rankedByPos, heavyCleanBuffer);
+        const lightCleanBuffer = await preprocessCaptchaToBuffer(input, {
+          median: 3,
+          blur: 0,
+          greyscale: true,
+          scale: 4,
+          postBlur: 3,
+          normalise: true,
+          contrast: 1,
+          sharpen: false,
+          threshold: 128,
+          crop: "none",
+          padding: 20
+        });
+        await disambiguateResult(result, rankedByPos, lightCleanBuffer);
+      } catch {
+      }
+    }
+    const finalText = majorityVote(
+      [...attempts, result.join("")],
+      // include disambiguated result as an extra "vote"
+      expectedLength,
+      confusionGroups
+    );
+    return {
+      text: finalText,
+      attempts,
+      usage,
+      attemptUsages
+    };
+  }
+  _tesseractReader = void 0;
+  async getTesseractReader() {
+    if (this._tesseractReader !== void 0) return this._tesseractReader;
+    try {
+      const { createTesseractReader: createTesseractReader2 } = await Promise.resolve().then(() => (init_tesseract(), tesseract_exports));
+      this._tesseractReader = await createTesseractReader2();
+    } catch {
+      this._tesseractReader = null;
+    }
+    return this._tesseractReader;
+  }
+  /** Clean up resources (Tesseract worker). */
+  async dispose() {
+    if (this._tesseractReader) {
+      await this._tesseractReader.dispose();
+      this._tesseractReader = null;
+    }
+  }
+  buildCorrectionPrompt(initial) {
+    const checks = [...initial].map((c, pos) => {
+      if (c !== "2" && c !== "Z") return null;
+      if (pos === 0)
+        return `Pos ${pos + 1} ("${c}"): thin stroke \u2192 "1"? closed loop at bottom \u2192 "6"? vertical+foot \u2192 "L"?`;
+      if (pos < initial.length - 1)
+        return `Pos ${pos + 1} ("${c}"): vertical + horizontal foot \u2192 "L"? thin stroke \u2192 "1"? loop \u2192 "6"?`;
+      return `Pos ${pos + 1} ("${c}"): curved top \u2192 keep "2"; straight angles \u2192 "Z"`;
+    }).filter(Boolean);
+    if (!checks.length) return null;
+    const prefix = [...initial].filter((c) => c === "2" || c === "Z").length >= 3 ? `"${initial}" has many similar chars \u2014 unusual for a captcha.
+` : "";
+    return `${prefix}Recheck:
+${checks.join("\n")}
+Only change with clear evidence. Output ONLY the corrected 4 characters.`;
+  }
+  async selfCorrect(model, primaryBuffer, secondaryBuffer, initial, correctionPrompt) {
+    try {
+      const { text } = await generateText({
+        model,
+        messages: [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: PROMPT },
+              { type: "image", image: primaryBuffer },
+              { type: "image", image: secondaryBuffer }
+            ]
+          },
+          { role: "assistant", content: initial },
+          {
+            role: "user",
+            content: [
+              { type: "text", text: correctionPrompt },
+              { type: "image", image: primaryBuffer }
+            ]
+          }
+        ],
+        temperature: 0.3,
+        maxOutputTokens: 32
+      });
+      const cleaned = text.trim().replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+      return cleaned.length >= 2 && cleaned.length <= 8 ? { text: cleaned } : null;
+    } catch {
+      return null;
+    }
   }
   /**
    * Make a single API call to read the captcha.
    * Retries up to `maxRetries` times on failure.
    */
-  async singleAttempt(model, imageBuffer, maxRetries) {
+  async singleAttempt(model, primaryBuffer, secondaryBuffer, maxRetries) {
     for (let retry = 0; retry <= maxRetries; retry++) {
       try {
         const { text, usage } = await generateText({
@@ -252,7 +1018,8 @@ var Solver = class {
               role: "user",
               content: [
                 { type: "text", text: PROMPT },
-                { type: "image", image: imageBuffer }
+                { type: "image", image: primaryBuffer },
+                { type: "image", image: secondaryBuffer }
               ]
             }
           ],
@@ -261,11 +1028,29 @@ var Solver = class {
         });
         const raw = text.trim();
         const lower = raw.toLowerCase();
-        if (lower.includes("sorry") || lower.includes("can't help") || lower.includes("cannot help") || lower.includes("unable to") || lower.includes("i can't") || raw.length > 20) {
+        if (lower.includes("sorry") || lower.includes("can't help") || lower.includes("cannot help") || lower.includes("unable to") || lower.includes("i can't")) {
           return null;
         }
-        const cleaned = raw.toUpperCase().replace(/[^A-Z0-9]/g, "");
-        return cleaned ? { text: cleaned, usage } : null;
+        let answer = "";
+        const allAlpha = raw.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+        if (allAlpha.length <= 10) {
+          answer = allAlpha;
+        } else {
+          const lines = raw.split(/\n/).reverse();
+          for (const line of lines) {
+            const tokens = line.trim().split(/\s+/);
+            for (let ti = tokens.length - 1; ti >= 0; ti--) {
+              const clean = tokens[ti].replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+              if (clean.length >= 2 && clean.length <= 8) {
+                answer = clean;
+                break;
+              }
+            }
+            if (answer) break;
+          }
+          if (!answer) answer = allAlpha.slice(-8);
+        }
+        return answer ? { text: answer, usage } : null;
       } catch (_err) {
         if (retry < maxRetries) {
           await new Promise((r) => setTimeout(r, 1e3 * (retry + 1)));
@@ -277,9 +1062,20 @@ var Solver = class {
     return null;
   }
 };
+
+// src/index.ts
+init_preprocess();
+init_tesseract();
 export {
+  DITHER_CONFUSION_GROUPS,
+  LEGACY_CONFUSION_GROUPS,
   Solver,
+  TESSERACT_VARIANTS,
+  createTesseractReader,
+  disambiguateResult,
   imageToBase64,
+  majorityVote,
+  majorityVoteDetailed,
   preprocessCaptcha,
   preprocessCaptchaToBuffer
 };