edge_det 0.1.0

package/.github/workflows/build.yml

@@ -0,0 +1,36 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+    push:
+        tags:
+            - "*"
+
+permissions:
+    id-token: write # Required for OIDC
+    contents: read
+
+jobs:
+    publish-npm:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+            - name: Install Rust
+              uses: actions-rs/toolchain@v1
+              with:
+                  toolchain: stable
+                  profile: minimal
+                  override: true
+            - run: |
+                  rustup target add wasm32-unknown-unknown
+                  cargo install wasm-pack
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 24
+                  registry-url: https://registry.npmjs.org/
+            - run: |
+                  npm i
+                  npm run build
+            - run: npm publish

package/Cargo.lock

@@ -0,0 +1,114 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "edge_det"
+version = "0.1.0"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"
+dependencies = [
+ "unicode-ident",
+]

package/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "edge_det"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+wasm-bindgen = "0.2"
+
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = false
+
+[profile.release]
+opt-level = "s"
+lto = true
+codegen-units = 1
+strip = true

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "edge_det",
+    "version": "0.1.0",
+    "type": "module",
+    "scripts": {
+        "build:wasm": "node scripts/build-wasm.mjs",
+        "build": "npm run build:wasm && tsc",
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "devDependencies": {
+        "pureimage": "^0.4.18",
+        "typescript": "^5.7.0",
+        "vite": "^6.0.0",
+        "vitest": "^3.0.0"
+    }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

package/scripts/build-wasm.mjs

@@ -0,0 +1,19 @@
+import { execSync } from 'child_process'
+import { readFileSync, writeFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const root = join(__dirname, '..')
+
+console.log('Building WASM...')
+execSync('wasm-pack build --target web --release', { cwd: root, stdio: 'inherit' })
+
+const wasmPath = join(root, 'pkg', 'edge_det_bg.wasm')
+const wasmBytes = readFileSync(wasmPath)
+console.log(`WASM size: ${wasmBytes.length} bytes`)
+
+const bytesStr = JSON.stringify(Array.from(wasmBytes))
+const outPath = join(root, 'src_ts', 'wasm_bytes.ts')
+writeFileSync(outPath, `export const WASM_BYTES = new Uint8Array(${bytesStr});\n`)
+console.log(`Inlined WASM bytes to ${outPath}`)

package/src/lib.rs

@@ -0,0 +1,327 @@
+use wasm_bindgen::prelude::*;
+
+const GAUSS: [f32; 5] = [1.0, 4.0, 6.0, 4.0, 1.0];
+const GAUSS_SUM: f32 = 16.0;
+
+fn grayscale(data: &[u8], w: usize, h: usize) -> Vec<f32> {
+    let n = w * h;
+    let mut g = vec![0.0f32; n];
+    for i in 0..n {
+        let o = i * 4;
+        g[i] = 0.299 * data[o] as f32 + 0.587 * data[o + 1] as f32 + 0.114 * data[o + 2] as f32;
+    }
+    g
+}
+
+fn blur(img: &[f32], w: usize, h: usize) -> Vec<f32> {
+    let mut tmp = vec![0.0f32; w * h];
+    let mut out = vec![0.0f32; w * h];
+    for y in 0..h {
+        for x in 0..w {
+            let mut s = 0.0f32;
+            for k in 0usize..5 {
+                let xx = ((x as i32) + k as i32 - 2).max(0).min(w as i32 - 1) as usize;
+                s += img[y * w + xx] * GAUSS[k];
+            }
+            tmp[y * w + x] = s / GAUSS_SUM;
+        }
+    }
+    for y in 0..h {
+        for x in 0..w {
+            let mut s = 0.0f32;
+            for k in 0usize..5 {
+                let yy = ((y as i32) + k as i32 - 2).max(0).min(h as i32 - 1) as usize;
+                s += tmp[yy * w + x] * GAUSS[k];
+            }
+            out[y * w + x] = s / GAUSS_SUM;
+        }
+    }
+    out
+}
+
+struct SobelResult {
+    mag: Vec<f32>,
+    dx: Vec<f32>,
+    dy: Vec<f32>,
+}
+
+fn sobel(img: &[f32], w: usize, h: usize) -> SobelResult {
+    let n = w * h;
+    let mut mag = vec![0.0f32; n];
+    let mut dx = vec![0.0f32; n];
+    let mut dy = vec![0.0f32; n];
+    for y in 1..h - 1 {
+        for x in 1..w - 1 {
+            let i = y * w + x;
+            let sx = -img[i - w - 1] - 2.0 * img[i - 1] - img[i + w - 1]
+                + img[i - w + 1] + 2.0 * img[i + 1] + img[i + w + 1];
+            let sy = -img[i - w - 1] - 2.0 * img[i - w] - img[i - w + 1]
+                + img[i + w - 1] + 2.0 * img[i + w] + img[i + w + 1];
+            dx[i] = sx;
+            dy[i] = sy;
+            mag[i] = (sx * sx + sy * sy).sqrt();
+        }
+    }
+    SobelResult { mag, dx, dy }
+}
+
+fn nms(result: &SobelResult, w: usize, h: usize) -> Vec<f32> {
+    let mut out = vec![0.0f32; w * h];
+    for y in 1..h - 1 {
+        for x in 1..w - 1 {
+            let i = y * w + x;
+            let m = result.mag[i];
+            if m < 0.5 {
+                continue;
+            }
+            let gx = result.dx[i];
+            let gy = result.dy[i];
+            let abs_gx = gx.abs();
+            let abs_gy = gy.abs();
+
+            let (mut mag1, mut mag2) = (0.0f32, 0.0f32);
+            if abs_gx > abs_gy {
+                let t = abs_gy / abs_gx;
+                if gx * gy > 0.0 {
+                    mag1 = result.mag[i - w - 1] * (1.0 - t) + result.mag[i - w] * t;
+                    mag2 = result.mag[i + w + 1] * (1.0 - t) + result.mag[i + w] * t;
+                } else {
+                    mag1 = result.mag[i - w + 1] * (1.0 - t) + result.mag[i - w] * t;
+                    mag2 = result.mag[i + w - 1] * (1.0 - t) + result.mag[i + w] * t;
+                }
+            } else if abs_gy > 0.0 {
+                let t = abs_gx / abs_gy;
+                if gx * gy > 0.0 {
+                    mag1 = result.mag[i - w - 1] * (1.0 - t) + result.mag[i - 1] * t;
+                    mag2 = result.mag[i + w + 1] * (1.0 - t) + result.mag[i + 1] * t;
+                } else {
+                    mag1 = result.mag[i - w + 1] * (1.0 - t) + result.mag[i + 1] * t;
+                    mag2 = result.mag[i + w - 1] * (1.0 - t) + result.mag[i - 1] * t;
+                }
+            }
+            out[i] = if m >= mag1 && m >= mag2 { m } else { 0.0 };
+        }
+    }
+    out
+}
+
+fn hysteresis(edges: &mut [u8], w: usize, h: usize) {
+    let mut stack: Vec<(i32, i32)> = Vec::new();
+    for y in 0..h {
+        for x in 0..w {
+            if edges[y * w + x] == 2 {
+                stack.push((x as i32, y as i32));
+            }
+        }
+    }
+    while let Some((x, y)) = stack.pop() {
+        for dy in -1..=1 {
+            for dx in -1..=1 {
+                let nx = x + dx;
+                let ny = y + dy;
+                if nx >= 0 && nx < w as i32 && ny >= 0 && ny < h as i32 {
+                    let ni = (ny * w as i32 + nx) as usize;
+                    if edges[ni] == 1 {
+                        edges[ni] = 2;
+                        stack.push((nx, ny));
+                    }
+                }
+            }
+        }
+    }
+    for e in edges.iter_mut() {
+        if *e == 1 {
+            *e = 0;
+        }
+    }
+}
+
+struct UF {
+    p: Vec<usize>,
+    r: Vec<u8>,
+}
+
+impl UF {
+    fn new(n: usize) -> Self {
+        Self {
+            p: (0..n).collect(),
+            r: vec![0; n],
+        }
+    }
+    fn find(&mut self, x: usize) -> usize {
+        if self.p[x] != x {
+            self.p[x] = self.find(self.p[x]);
+        }
+        self.p[x]
+    }
+    fn union(&mut self, a: usize, b: usize) {
+        let ra = self.find(a);
+        let rb = self.find(b);
+        if ra == rb {
+            return;
+        }
+        if self.r[ra] < self.r[rb] {
+            self.p[ra] = rb;
+        } else if self.r[ra] > self.r[rb] {
+            self.p[rb] = ra;
+        } else {
+            self.p[rb] = ra;
+            self.r[ra] += 1;
+        }
+    }
+}
+
+fn bounding_boxes(edges: &[u8], w: usize, h: usize, min_area: usize) -> Vec<[i32; 4]> {
+    let n = w * h;
+    let mut uf = UF::new(n);
+    for y in 0..h {
+        for x in 0..w {
+            let i = y * w + x;
+            if edges[i] == 0 {
+                continue;
+            }
+            if x + 1 < w && edges[i + 1] != 0 {
+                uf.union(i, i + 1);
+            }
+            if y + 1 < h && edges[i + w] != 0 {
+                uf.union(i, i + w);
+            }
+            if x + 1 < w && y + 1 < h && edges[i + w + 1] != 0 {
+                uf.union(i, i + w + 1);
+            }
+            if x > 0 && y + 1 < h && edges[i + w - 1] != 0 {
+                uf.union(i, i + w - 1);
+            }
+        }
+    }
+    let mut x0 = vec![w as i32; n];
+    let mut y0 = vec![h as i32; n];
+    let mut x1 = vec![0i32; n];
+    let mut y1 = vec![0i32; n];
+    let mut cnt = vec![0usize; n];
+    for y in 0..h {
+        for x in 0..w {
+            let i = y * w + x;
+            if edges[i] == 0 {
+                continue;
+            }
+            let r = uf.find(i);
+            x0[r] = x0[r].min(x as i32);
+            y0[r] = y0[r].min(y as i32);
+            x1[r] = x1[r].max(x as i32);
+            y1[r] = y1[r].max(y as i32);
+            cnt[r] += 1;
+        }
+    }
+    let mut boxes: Vec<[i32; 4]> = Vec::new();
+    for i in 0..n {
+        if cnt[i] >= min_area {
+            boxes.push([x0[i], y0[i], x1[i] - x0[i] + 1, y1[i] - y0[i] + 1]);
+        }
+    }
+    boxes.sort_by(|a, b| (b[2] * b[3]).cmp(&(a[2] * a[3])));
+    boxes
+}
+
+fn color_gradient(data: &[u8], w: usize, h: usize) -> SobelResult {
+    let n = w * h;
+    let mut r_ch = vec![0.0f32; n];
+    let mut g_ch = vec![0.0f32; n];
+    let mut b_ch = vec![0.0f32; n];
+    for i in 0..n {
+        let o = i * 4;
+        r_ch[i] = data[o] as f32;
+        g_ch[i] = data[o + 1] as f32;
+        b_ch[i] = data[o + 2] as f32;
+    }
+    let rb = blur(&r_ch, w, h);
+    let gb = blur(&g_ch, w, h);
+    let bb = blur(&b_ch, w, h);
+
+    let mut mag = vec![0.0f32; n];
+    let mut dx = vec![0.0f32; n];
+    let mut dy = vec![0.0f32; n];
+    for y in 1..h - 1 {
+        for x in 1..w - 1 {
+            let i = y * w + x;
+            let dr_x = rb[i + 1] - rb[i - 1];
+            let dg_x = gb[i + 1] - gb[i - 1];
+            let db_x = bb[i + 1] - bb[i - 1];
+            let dr_y = rb[i + w] - rb[i - w];
+            let dg_y = gb[i + w] - gb[i - w];
+            let db_y = bb[i + w] - bb[i - w];
+            let sx = (dr_x * dr_x + dg_x * dg_x + db_x * db_x).sqrt();
+            let sy = (dr_y * dr_y + dg_y * dg_y + db_y * db_y).sqrt();
+            let sign_x = if dr_x + dg_x + db_x >= 0.0 { 1.0 } else { -1.0 };
+            let sign_y = if dr_y + dg_y + db_y >= 0.0 { 1.0 } else { -1.0 };
+            dx[i] = sx * sign_x;
+            dy[i] = sy * sign_y;
+            mag[i] = (sx * sx + sy * sy).sqrt();
+        }
+    }
+    SobelResult { mag, dx, dy }
+}
+
+fn merge_and_threshold(
+    gray_sup: &[f32],
+    color_sup: &[f32],
+    w: usize,
+    h: usize,
+    lo: f32,
+    hi: f32,
+) -> Vec<u8> {
+    let n = w * h;
+    let mut out = vec![0u8; n];
+    for i in 0..n {
+        let v = gray_sup[i].max(color_sup[i]);
+        if v >= hi {
+            out[i] = 2;
+        } else if v >= lo {
+            out[i] = 1;
+        }
+    }
+    out
+}
+
+#[wasm_bindgen]
+pub fn detect_borders(
+    data: &[u8],
+    width: usize,
+    height: usize,
+    low_threshold: f32,
+    high_threshold: f32,
+    min_area: usize,
+) -> Vec<f32> {
+    let gray = grayscale(data, width, height);
+    let blurred = blur(&gray, width, height);
+    let gray_sobel = sobel(&blurred, width, height);
+    let gray_sup = nms(&gray_sobel, width, height);
+
+    let color_sobel = color_gradient(data, width, height);
+    let color_sup = nms(&color_sobel, width, height);
+
+    let mut edges = merge_and_threshold(
+        &gray_sup,
+        &color_sup,
+        width,
+        height,
+        low_threshold,
+        high_threshold,
+    );
+    hysteresis(&mut edges, width, height);
+
+    let boxes = bounding_boxes(&edges, width, height, min_area);
+    let mut out = Vec::with_capacity(boxes.len() * 4);
+    for b in &boxes {
+        out.push(b[0] as f32);
+        out.push(b[1] as f32);
+        out.push(b[2] as f32);
+        out.push(b[3] as f32);
+    }
+    out
+}
+
+#[wasm_bindgen]
+pub fn detect_borders_default(data: &[u8], width: usize, height: usize) -> Vec<f32> {
+    detect_borders(data, width, height, 20.0, 60.0, 100)
+}

package/src_ts/index.ts

@@ -0,0 +1,68 @@
+import {
+  initSync,
+  detect_borders,
+  detect_borders_default,
+} from '../pkg/edge_det.js'
+import { WASM_BYTES } from './wasm_bytes'
+
+export interface Border {
+  x: number
+  y: number
+  w: number
+  h: number
+}
+
+let _initialized = false
+
+function ensureInit() {
+  if (!_initialized) {
+    initSync({ module: WASM_BYTES })
+    _initialized = true
+  }
+}
+
+export function detectBorders(
+  data: Uint8Array,
+  width: number,
+  height: number,
+  options?: { lowThreshold?: number; highThreshold?: number; minArea?: number }
+): Border[] {
+  ensureInit()
+  const result = detect_borders(
+    data,
+    width,
+    height,
+    options?.lowThreshold ?? 20,
+    options?.highThreshold ?? 60,
+    options?.minArea ?? 100
+  )
+  const borders: Border[] = []
+  for (let i = 0; i < result.length; i += 4) {
+    borders.push({
+      x: result[i],
+      y: result[i + 1],
+      w: result[i + 2],
+      h: result[i + 3],
+    })
+  }
+  return borders
+}
+
+export function detectBordersDefault(
+  data: Uint8Array,
+  width: number,
+  height: number
+): Border[] {
+  ensureInit()
+  const result = detect_borders_default(data, width, height)
+  const borders: Border[] = []
+  for (let i = 0; i < result.length; i += 4) {
+    borders.push({
+      x: result[i],
+      y: result[i + 1],
+      w: result[i + 2],
+      h: result[i + 3],
+    })
+  }
+  return borders
+}

package/tests/detection.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect } from 'vitest'
+import * as PImage from 'pureimage'
+import { detectBorders, detectBordersDefault, Border } from '../src_ts/index'
+
+function createImage(
+  w: number,
+  h: number,
+  draw: (ctx: PImage.Context) => void
+): Uint8Array {
+  const img = PImage.make(w, h, {})
+  const ctx = img.getContext('2d')
+  ctx.fillStyle = '#ffffff'
+  ctx.fillRect(0, 0, w, h)
+  draw(ctx)
+  const buf = img.data
+  const rgba = new Uint8Array(w * h * 4)
+  for (let i = 0; i < w * h; i++) {
+    rgba[i * 4] = buf[i * 4]
+    rgba[i * 4 + 1] = buf[i * 4 + 1]
+    rgba[i * 4 + 2] = buf[i * 4 + 2]
+    rgba[i * 4 + 3] = buf[i * 4 + 3]
+  }
+  return rgba
+}
+
+function drawRect(
+  ctx: PImage.Context,
+  x: number,
+  y: number,
+  w: number,
+  h: number,
+  color: string,
+  lineWidth?: number
+) {
+  ctx.strokeStyle = color
+  ctx.lineWidth = lineWidth ?? 1
+  ctx.strokeRect(x, y, w, h)
+}
+
+function fillRect(
+  ctx: PImage.Context,
+  x: number,
+  y: number,
+  w: number,
+  h: number,
+  color: string
+) {
+  ctx.fillStyle = color
+  ctx.fillRect(x, y, w, h)
+}
+
+function mergeBounds(borders: Border[]) {
+  const m = { x: Infinity, y: Infinity, x2: -Infinity, y2: -Infinity }
+  for (const b of borders) {
+    m.x = Math.min(m.x, b.x)
+    m.y = Math.min(m.y, b.y)
+    m.x2 = Math.max(m.x2, b.x + b.w)
+    m.y2 = Math.max(m.y2, b.y + b.h)
+  }
+  return m
+}
+
+function areaOf(b: Border) {
+  return b.w * b.h
+}
+
+function coverage(borders: Border[], expected: { x: number; y: number; w: number; h: number }) {
+  const merged = mergeBounds(borders)
+  const ex = expected.x
+  const ey = expected.y
+  const ex2 = expected.x + expected.w
+  const ey2 = expected.y + expected.h
+  const iw = Math.max(0, Math.min(merged.x2, ex2) - Math.max(merged.x, ex))
+  const ih = Math.max(0, Math.min(merged.y2, ey2) - Math.max(merged.y, ey))
+  const inter = iw * ih
+  const unionArea = (merged.x2 - merged.x) * (merged.y2 - merged.y) + expected.w * expected.h - inter
+  return inter / unionArea
+}
+
+const TOL = 6
+
+describe('detectBorders', () => {
+  it('solid color → no borders', () => {
+    const w = 80, h = 80
+    const data = createImage(w, h, () => {})
+    const borders = detectBorders(data, w, h)
+    expect(borders.length).toBe(0)
+  })
+
+  it('white bg + gray filled rect (low contrast)', () => {
+    const w = 200, h = 200
+    const rect = { x: 30, y: 40, w: 80, h: 60 }
+    const data = createImage(w, h, (ctx) => {
+      fillRect(ctx, rect.x, rect.y, rect.w, rect.h, '#cccccc')
+    })
+    const borders = detectBorders(data, w, h, {
+      lowThreshold: 8,
+      highThreshold: 25,
+      minArea: 20,
+    })
+    expect(borders.length).toBeGreaterThanOrEqual(1)
+    const merged = mergeBounds(borders)
+    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
+    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
+    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
+    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
+  })
+
+  it('white bg + thin black 1px line rect', () => {
+    const w = 200, h = 200
+    const rect = { x: 20, y: 20, w: 100, h: 80 }
+    const data = createImage(w, h, (ctx) => {
+      drawRect(ctx, rect.x, rect.y, rect.w, rect.h, '#000000', 1)
+    })
+    const borders = detectBorders(data, w, h, {
+      lowThreshold: 15,
+      highThreshold: 45,
+      minArea: 10,
+    })
+    expect(borders.length).toBeGreaterThanOrEqual(1)
+    const merged = mergeBounds(borders)
+    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
+    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
+    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
+    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
+  })
+
+  it('white bg + thin black 2px line rect', () => {
+    const w = 200, h = 200
+    const rect = { x: 50, y: 30, w: 100, h: 120 }
+    const data = createImage(w, h, (ctx) => {
+      drawRect(ctx, rect.x, rect.y, rect.w, rect.h, '#000000', 2)
+    })
+    const borders = detectBorders(data, w, h, {
+      lowThreshold: 15,
+      highThreshold: 45,
+      minArea: 10,
+    })
+    expect(borders.length).toBeGreaterThanOrEqual(1)
+    const merged = mergeBounds(borders)
+    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
+    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
+    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
+    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
+  })
+
+  it('white bg + gray thin line rect (low contrast + thin)', () => {
+    const w = 200, h = 200
+    const rect = { x: 25, y: 25, w: 100, h: 100 }
+    const data = createImage(w, h, (ctx) => {
+      drawRect(ctx, rect.x, rect.y, rect.w, rect.h, '#999999', 1)
+    })
+    const borders = detectBorders(data, w, h, {
+      lowThreshold: 5,
+      highThreshold: 18,
+      minArea: 10,
+    })
+    expect(borders.length).toBeGreaterThanOrEqual(1)
+    const merged = mergeBounds(borders)
+    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
+    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
+    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
+    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
+  })
+
+  it('blue rect on gray bg (color)', () => {
+    const w = 200, h = 200
+    const rect = { x: 40, y: 30, w: 80, h: 60 }
+    const data = createImage(w, h, (ctx) => {
+      fillRect(ctx, 0, 0, w, h, '#555555')
+      fillRect(ctx, rect.x, rect.y, rect.w, rect.h, '#0088ff')
+    })
+    const borders = detectBorders(data, w, h, {
+      lowThreshold: 12,
+      highThreshold: 35,
+      minArea: 20,
+    })
+    expect(borders.length).toBeGreaterThanOrEqual(1)
+    const merged = mergeBounds(borders)
+    expect(merged.x).toBeLessThanOrEqual(rect.x + TOL)
+    expect(merged.y).toBeLessThanOrEqual(rect.y + TOL)
+    expect(merged.x2).toBeGreaterThanOrEqual(rect.x + rect.w - TOL)
+    expect(merged.y2).toBeGreaterThanOrEqual(rect.y + rect.h - TOL)
+  })
+
+  it('two rects — count and area', () => {
+    const w = 300, h = 300
+    const r1 = { x: 20, y: 20, w: 60, h: 60 }
+    const r2 = { x: 150, y: 120, w: 100, h: 80 }
+    const data = createImage(w, h, (ctx) => {
+      fillRect(ctx, r1.x, r1.y, r1.w, r1.h, '#cccccc')
+      fillRect(ctx, r2.x, r2.y, r2.w, r2.h, '#cccccc')
+    })
+    const borders = detectBorders(data, w, h, {
+      lowThreshold: 8,
+      highThreshold: 25,
+      minArea: 20,
+    })
+    expect(borders.length).toBe(2)
+    const areas = borders.map(areaOf).sort((a, b) => a - b)
+    const expectedAreas = [r1.w * r1.h, r2.w * r2.h].sort((a, b) => a - b)
+    for (let i = 0; i < 2; i++) {
+      expect(areas[i]).toBeGreaterThan(expectedAreas[i] * 0.5)
+      expect(areas[i]).toBeLessThan(expectedAreas[i] * 2.5)
+    }
+  })
+
+  it('two thin-line rects — count and area', () => {
+    const w = 300, h = 300
+    const r1 = { x: 20, y: 20, w: 80, h: 60 }
+    const r2 = { x: 160, y: 100, w: 100, h: 80 }
+    const data = createImage(w, h, (ctx) => {
+      drawRect(ctx, r1.x, r1.y, r1.w, r1.h, '#000000', 2)
+      drawRect(ctx, r2.x, r2.y, r2.w, r2.h, '#000000', 2)
+    })
+    const borders = detectBorders(data, w, h, {
+      lowThreshold: 15,
+      highThreshold: 45,
+      minArea: 10,
+    })
+    expect(borders.length).toBeGreaterThanOrEqual(2)
+    const sorted = [...borders].sort((a, b) => areaOf(a) - areaOf(b))
+    const r1Area = r1.w * r1.h
+    const r2Area = r2.w * r2.h
+    expect(areaOf(sorted[sorted.length - 1])).toBeGreaterThan(r2Area * 0.3)
+    expect(areaOf(sorted[sorted.length - 1])).toBeLessThan(r2Area * 3)
+  })
+
+  it('detectBordersDefault works', () => {
+    const w = 200, h = 200
+    const rect = { x: 30, y: 30, w: 100, h: 100 }
+    const data = createImage(w, h, (ctx) => {
+      fillRect(ctx, rect.x, rect.y, rect.w, rect.h, '#cccccc')
+    })
+    const borders = detectBordersDefault(data, w, h)
+    expect(borders.length).toBeGreaterThanOrEqual(1)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src_ts"],
+  "exclude": ["tests", "node_modules"]
+}

package/vite.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: 'src_ts/index.ts',
+      formats: ['es'],
+    },
+  },
+})

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+})