goldenmatch 0.1.0

package/dist/node/backends/score-worker.cjs

@@ -0,0 +1,934 @@
+'use strict';
+
+// src/core/types.ts
+function makeScoredPair(a, b, score) {
+  const lo = a < b ? a : b;
+  const hi = a < b ? b : a;
+  return { idA: lo, idB: hi, score };
+}
+
+// src/core/cluster.ts
+function pairKey(a, b) {
+  const lo = a < b ? a : b;
+  const hi = a < b ? b : a;
+  return `${lo}:${hi}`;
+}
+
+// src/core/transforms.ts
+function applyTransform(value, transform) {
+  if (value === null) return null;
+  if (transform.startsWith("substring:")) return applySubstring(value, transform);
+  if (transform.startsWith("qgram:")) return applyQgram(value, transform);
+  if (transform.startsWith("bloom_filter")) return applyBloomFilter(value, transform);
+  switch (transform) {
+    case "lowercase":
+      return value.toLowerCase();
+    case "uppercase":
+      return value.toUpperCase();
+    case "strip":
+      return value.trim();
+    case "strip_all":
+      return value.replace(/\s+/g, "");
+    case "digits_only":
+      return value.replace(/\D/g, "");
+    case "alpha_only":
+      return value.replace(/[^a-zA-Z]/g, "");
+    case "normalize_whitespace":
+      return value.trim().replace(/\s+/g, " ");
+    case "token_sort":
+      return value.trim().split(/\s+/).sort().join(" ");
+    case "first_token":
+      return value.trim().split(/\s+/)[0] ?? "";
+    case "last_token": {
+      const tokens = value.trim().split(/\s+/);
+      return tokens[tokens.length - 1] ?? "";
+    }
+    case "soundex":
+      return soundex(value);
+    case "metaphone":
+      return metaphone(value);
+    default:
+      return value;
+  }
+}
+function applyTransforms(value, transforms) {
+  let result = value;
+  for (const t of transforms) {
+    result = applyTransform(result, t);
+    if (result === null) return null;
+  }
+  return result;
+}
+function applySubstring(value, transform) {
+  const parts = transform.split(":");
+  const start = parseInt(parts[1] ?? "0", 10);
+  const end = parts[2] !== void 0 ? parseInt(parts[2], 10) : void 0;
+  return value.slice(start, end);
+}
+function applyQgram(value, transform) {
+  const parts = transform.split(":");
+  const n = parseInt(parts[1] ?? "2", 10);
+  if (n <= 0 || value.length < n) return value;
+  const grams = [];
+  for (let i = 0; i <= value.length - n; i++) {
+    grams.push(value.slice(i, i + n));
+  }
+  return grams.sort().join(" ");
+}
+var SOUNDEX_MAP = {
+  B: "1",
+  F: "1",
+  P: "1",
+  V: "1",
+  C: "2",
+  G: "2",
+  J: "2",
+  K: "2",
+  Q: "2",
+  S: "2",
+  X: "2",
+  Z: "2",
+  D: "3",
+  T: "3",
+  L: "4",
+  M: "5",
+  N: "5",
+  R: "6"
+};
+function soundex(value) {
+  const clean = value.toUpperCase().replace(/[^A-Z]/g, "");
+  if (clean.length === 0) return "0000";
+  const firstLetter = clean[0];
+  let code = firstLetter;
+  let lastDigit = SOUNDEX_MAP[firstLetter] ?? "0";
+  for (let i = 1; i < clean.length && code.length < 4; i++) {
+    const ch = clean[i];
+    const digit = SOUNDEX_MAP[ch];
+    if (digit && digit !== lastDigit) {
+      code += digit;
+      lastDigit = digit;
+    } else if (!digit) {
+      if (ch !== "H" && ch !== "W") {
+        lastDigit = "0";
+      }
+    }
+  }
+  return (code + "0000").slice(0, 4);
+}
+function metaphone(value) {
+  let word = value.toUpperCase().replace(/[^A-Z]/g, "");
+  if (word.length === 0) return "";
+  const dropPrefixes = ["AE", "GN", "KN", "PN", "WR"];
+  for (const prefix of dropPrefixes) {
+    if (word.startsWith(prefix)) {
+      word = word.slice(1);
+      break;
+    }
+  }
+  if (word.endsWith("MB")) {
+    word = word.slice(0, -1);
+  }
+  let code = "";
+  let i = 0;
+  while (i < word.length && code.length < 4) {
+    const ch = word[i];
+    const next = word[i + 1] ?? "";
+    const prev = i > 0 ? word[i - 1] : "";
+    if (ch === prev && ch !== "C") {
+      i++;
+      continue;
+    }
+    switch (ch) {
+      case "A":
+      case "E":
+      case "I":
+      case "O":
+      case "U":
+        if (i === 0) code += ch;
+        break;
+      case "B":
+        code += "B";
+        break;
+      case "C":
+        if (next === "I" || next === "E" || next === "Y") {
+          code += "S";
+        } else {
+          code += "K";
+        }
+        break;
+      case "D":
+        if (next === "G" && "IEY".includes(word[i + 2] ?? "")) {
+          code += "J";
+        } else {
+          code += "T";
+        }
+        break;
+      case "F":
+        code += "F";
+        break;
+      case "G":
+        if (next === "H" && i + 2 < word.length && !"AEIOU".includes(word[i + 2] ?? "")) {
+          i += 2;
+          continue;
+        } else if (i > 0 && (next === "N" || next === "N" && word[i + 2] === "E" && i + 2 === word.length - 1)) ; else if (prev === "G") ; else if (next === "I" || next === "E" || next === "Y") {
+          code += "J";
+        } else {
+          code += "K";
+        }
+        break;
+      case "H":
+        if ("AEIOU".includes(next) && !"AEIOU".includes(prev)) {
+          code += "H";
+        }
+        break;
+      case "J":
+        code += "J";
+        break;
+      case "K":
+        if (prev !== "C") code += "K";
+        break;
+      case "L":
+        code += "L";
+        break;
+      case "M":
+        code += "M";
+        break;
+      case "N":
+        code += "N";
+        break;
+      case "P":
+        if (next === "H") {
+          code += "F";
+          i++;
+        } else {
+          code += "P";
+        }
+        break;
+      case "Q":
+        code += "K";
+        break;
+      case "R":
+        code += "R";
+        break;
+      case "S":
+        if (next === "H" || next === "I" && (word[i + 2] === "O" || word[i + 2] === "A")) {
+          code += "X";
+          i++;
+        } else if (next === "C" && word[i + 2] === "H") {
+          code += "SK";
+          i += 2;
+        } else {
+          code += "S";
+        }
+        break;
+      case "T":
+        if (next === "H") {
+          code += "0";
+          i++;
+        } else if (next === "I" && (word[i + 2] === "O" || word[i + 2] === "A")) {
+          code += "X";
+        } else {
+          code += "T";
+        }
+        break;
+      case "V":
+        code += "F";
+        break;
+      case "W":
+      case "Y":
+        if ("AEIOU".includes(next)) {
+          code += ch;
+        }
+        break;
+      case "X":
+        code += "KS";
+        break;
+      case "Z":
+        code += "S";
+        break;
+    }
+    i++;
+  }
+  return code.slice(0, 4);
+}
+var BLOOM_PRESETS = {
+  standard: { size: 512, k: 20, ngram: 2, hmac: false, balanced: false },
+  high: { size: 1024, k: 30, ngram: 2, hmac: true, balanced: false },
+  paranoid: { size: 2048, k: 40, ngram: 3, hmac: true, balanced: true }
+};
+var BLOOM_DEFAULTS = { size: 1024, k: 20, ngram: 2 };
+var BLOOM_DEFAULT_HMAC_KEY = "default_field_key";
+function applyBloomFilter(value, transform) {
+  let ngramSize = BLOOM_DEFAULTS.ngram;
+  let numHashes = BLOOM_DEFAULTS.k;
+  let filterSize = BLOOM_DEFAULTS.size;
+  let hmacKey = null;
+  let balanced = false;
+  if (transform === "bloom_filter") ; else {
+    const parts = transform.split(":");
+    const maybeLevel = parts[1];
+    if (maybeLevel && maybeLevel in BLOOM_PRESETS) {
+      const preset = BLOOM_PRESETS[maybeLevel];
+      ngramSize = preset.ngram;
+      numHashes = preset.k;
+      filterSize = preset.size;
+      balanced = preset.balanced;
+      if (preset.hmac) {
+        hmacKey = parts[2] && parts[2].length > 0 ? parts[2] : BLOOM_DEFAULT_HMAC_KEY;
+      }
+    } else {
+      ngramSize = parseInt(parts[1] ?? String(BLOOM_DEFAULTS.ngram), 10);
+      numHashes = parseInt(parts[2] ?? String(BLOOM_DEFAULTS.k), 10);
+      filterSize = parseInt(parts[3] ?? String(BLOOM_DEFAULTS.size), 10);
+      if (parts.length > 4 && parts[4].length > 0) {
+        hmacKey = parts[4];
+      }
+    }
+  }
+  const filterBytes = Math.floor(filterSize / 8);
+  const bits = new Uint8Array(filterBytes);
+  let padded = value.toLowerCase().trim();
+  if (padded.length < ngramSize) {
+    padded = padded.padEnd(ngramSize, "_");
+  }
+  if (balanced && padded.length < 8) {
+    const salt = sha256Hex(padded).slice(0, 8);
+    padded = padded + salt;
+  }
+  const ngrams = [];
+  for (let i = 0; i <= padded.length - ngramSize; i++) {
+    ngrams.push(padded.slice(i, i + ngramSize));
+  }
+  for (const ngram of ngrams) {
+    for (let k = 0; k < numHashes; k++) {
+      const hex = hmacKey ? hmacSha256Hex(`${hmacKey}:${k}`, ngram) : sha256Hex(`${k}:${ngram}`);
+      const bitPos = Number(modHexBigInt(hex, filterSize));
+      bits[bitPos >> 3] |= 1 << (bitPos & 7);
+    }
+  }
+  return hexEncode(bits);
+}
+function modHexBigInt(hex, modulus) {
+  const big = BigInt("0x" + hex);
+  const mod = BigInt(modulus);
+  const rem = big % mod;
+  return Number(rem);
+}
+function hexEncode(bytes) {
+  const hex = [];
+  for (let i = 0; i < bytes.length; i++) {
+    hex.push(bytes[i].toString(16).padStart(2, "0"));
+  }
+  return hex.join("");
+}
+var K256 = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotr32(x, n) {
+  return (x >>> n | x << 32 - n) >>> 0;
+}
+function utf8Encode(input) {
+  return new TextEncoder().encode(input);
+}
+function sha256Bytes(msg) {
+  const H = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const msgLen = msg.length;
+  const bitLen = msgLen * 8;
+  const withPadLen = msgLen + 9 + 63 >> 6 << 6;
+  const padded = new Uint8Array(withPadLen);
+  padded.set(msg);
+  padded[msgLen] = 128;
+  const hi = Math.floor(bitLen / 4294967296);
+  const lo = bitLen >>> 0;
+  const dv = new DataView(padded.buffer);
+  dv.setUint32(withPadLen - 8, hi, false);
+  dv.setUint32(withPadLen - 4, lo, false);
+  const W = new Uint32Array(64);
+  for (let offset = 0; offset < withPadLen; offset += 64) {
+    for (let t = 0; t < 16; t++) {
+      W[t] = dv.getUint32(offset + t * 4, false);
+    }
+    for (let t = 16; t < 64; t++) {
+      const w15 = W[t - 15];
+      const w2 = W[t - 2];
+      const s0 = rotr32(w15, 7) ^ rotr32(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr32(w2, 17) ^ rotr32(w2, 19) ^ w2 >>> 10;
+      W[t] = W[t - 16] + s0 + W[t - 7] + s1 >>> 0;
+    }
+    let a = H[0], b = H[1], c = H[2], d = H[3];
+    let e = H[4], f = H[5], g = H[6], h = H[7];
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
+      const ch = e & f ^ ~e & g;
+      const T1 = h + S1 + ch + K256[t] + W[t] >>> 0;
+      const S0 = rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22);
+      const mj = a & b ^ a & c ^ b & c;
+      const T2 = S0 + mj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + T1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = T1 + T2 >>> 0;
+    }
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+    H[5] = H[5] + f >>> 0;
+    H[6] = H[6] + g >>> 0;
+    H[7] = H[7] + h >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const outDv = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) outDv.setUint32(i * 4, H[i], false);
+  return out;
+}
+function sha256Hex(input) {
+  return hexEncode(sha256Bytes(utf8Encode(input)));
+}
+function hmacSha256Hex(key, msg) {
+  const blockSize = 64;
+  let keyBytes = utf8Encode(key);
+  if (keyBytes.length > blockSize) {
+    keyBytes = sha256Bytes(keyBytes);
+  }
+  const kPad = new Uint8Array(blockSize);
+  kPad.set(keyBytes);
+  const oKeyPad = new Uint8Array(blockSize);
+  const iKeyPad = new Uint8Array(blockSize);
+  for (let i = 0; i < blockSize; i++) {
+    oKeyPad[i] = kPad[i] ^ 92;
+    iKeyPad[i] = kPad[i] ^ 54;
+  }
+  const msgBytes = utf8Encode(msg);
+  const inner = new Uint8Array(blockSize + msgBytes.length);
+  inner.set(iKeyPad);
+  inner.set(msgBytes, blockSize);
+  const innerHash = sha256Bytes(inner);
+  const outer = new Uint8Array(blockSize + innerHash.length);
+  outer.set(oKeyPad);
+  outer.set(innerHash, blockSize);
+  return hexEncode(sha256Bytes(outer));
+}
+
+// src/core/scorer.ts
+function asString(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "string") return v;
+  return String(v);
+}
+function jaro(a, b) {
+  if (a === b) return 1;
+  const lenA = a.length;
+  const lenB = b.length;
+  if (lenA === 0 || lenB === 0) return 0;
+  const matchWindow = Math.max(Math.floor(Math.max(lenA, lenB) / 2) - 1, 0);
+  const aMatched = new Uint8Array(lenA);
+  const bMatched = new Uint8Array(lenB);
+  let matches = 0;
+  for (let i = 0; i < lenA; i++) {
+    const lo = Math.max(0, i - matchWindow);
+    const hi = Math.min(lenB - 1, i + matchWindow);
+    for (let j = lo; j <= hi; j++) {
+      if (bMatched[j] !== 0 || a[i] !== b[j]) continue;
+      aMatched[i] = 1;
+      bMatched[j] = 1;
+      matches++;
+      break;
+    }
+  }
+  if (matches === 0) return 0;
+  let transpositions = 0;
+  let k = 0;
+  for (let i = 0; i < lenA; i++) {
+    if (aMatched[i] === 0) continue;
+    while (bMatched[k] === 0) k++;
+    if (a[i] !== b[k]) transpositions++;
+    k++;
+  }
+  return (matches / lenA + matches / lenB + (matches - transpositions / 2) / matches) / 3;
+}
+function jaroWinkler(a, b) {
+  const jaroSim = jaro(a, b);
+  if (jaroSim === 0) return 0;
+  const maxPrefix = Math.min(4, Math.min(a.length, b.length));
+  let prefix = 0;
+  for (let i = 0; i < maxPrefix; i++) {
+    if (a[i] === b[i]) prefix++;
+    else break;
+  }
+  return jaroSim + prefix * 0.1 * (1 - jaroSim);
+}
+function levenshteinDistance(a, b) {
+  const lenA = a.length;
+  const lenB = b.length;
+  if (lenA === 0) return lenB;
+  if (lenB === 0) return lenA;
+  let prev = new Uint32Array(lenB + 1);
+  let curr = new Uint32Array(lenB + 1);
+  for (let j = 0; j <= lenB; j++) prev[j] = j;
+  for (let i = 1; i <= lenA; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= lenB; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(
+        prev[j] + 1,
+        // deletion
+        curr[j - 1] + 1,
+        // insertion
+        prev[j - 1] + cost
+        // substitution
+      );
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[lenB];
+}
+function levenshteinSimilarity(a, b) {
+  if (a === b) return 1;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshteinDistance(a, b) / maxLen;
+}
+function indelDistance(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const m = a.length;
+  const n = b.length;
+  let prev = new Uint32Array(n + 1);
+  let curr = new Uint32Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      if (a.charCodeAt(i - 1) === b.charCodeAt(j - 1)) {
+        curr[j] = prev[j - 1];
+      } else {
+        curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1);
+      }
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function indelSimilarity(a, b) {
+  const total = a.length + b.length;
+  if (total === 0) return 1;
+  return 1 - indelDistance(a, b) / total;
+}
+function tokenSortRatio(a, b) {
+  const normalize = (s) => s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").trim().split(/\s+/).filter(Boolean).sort().join(" ");
+  return indelSimilarity(normalize(a), normalize(b));
+}
+function soundexMatch(a, b) {
+  return soundex(a) === soundex(b) ? 1 : 0;
+}
+function hexToBytes(hex) {
+  const len = hex.length >>> 1;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function popcount(bytes) {
+  let count = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    let b = bytes[i];
+    while (b !== 0) {
+      b &= b - 1;
+      count++;
+    }
+  }
+  return count;
+}
+function popcountAnd(a, b) {
+  const len = Math.min(a.length, b.length);
+  let count = 0;
+  for (let i = 0; i < len; i++) {
+    let v = a[i] & b[i];
+    while (v !== 0) {
+      v &= v - 1;
+      count++;
+    }
+  }
+  return count;
+}
+function popcountOr(a, b) {
+  const maxLen = Math.max(a.length, b.length);
+  let count = 0;
+  for (let i = 0; i < maxLen; i++) {
+    let v = (a[i] ?? 0) | (b[i] ?? 0);
+    while (v !== 0) {
+      v &= v - 1;
+      count++;
+    }
+  }
+  return count;
+}
+function diceCoefficient(a, b) {
+  const bytesA = hexToBytes(a);
+  const bytesB = hexToBytes(b);
+  const pcA = popcount(bytesA);
+  const pcB = popcount(bytesB);
+  const total = pcA + pcB;
+  if (total === 0) return 0;
+  const intersection = popcountAnd(bytesA, bytesB);
+  return 2 * intersection / total;
+}
+function jaccardSimilarity(a, b) {
+  const bytesA = hexToBytes(a);
+  const bytesB = hexToBytes(b);
+  const intersection = popcountAnd(bytesA, bytesB);
+  const union = popcountOr(bytesA, bytesB);
+  if (union === 0) return 0;
+  return intersection / union;
+}
+function ensembleScore(a, b) {
+  const jw = jaroWinkler(a, b);
+  const ts = tokenSortRatio(a, b);
+  const sx = soundexMatch(a, b) * 0.8;
+  return Math.max(jw, ts, sx);
+}
+function scoreField(valA, valB, scorer) {
+  if (valA === null || valB === null) return null;
+  switch (scorer) {
+    case "exact":
+      return valA === valB ? 1 : 0;
+    case "jaro_winkler":
+      return jaroWinkler(valA, valB);
+    case "levenshtein":
+      return levenshteinSimilarity(valA, valB);
+    case "token_sort":
+      return tokenSortRatio(valA, valB);
+    case "soundex_match":
+      return soundexMatch(valA, valB);
+    case "dice":
+      return diceCoefficient(valA, valB);
+    case "jaccard":
+      return jaccardSimilarity(valA, valB);
+    case "ensemble":
+      return ensembleScore(valA, valB);
+    default:
+      throw new Error(`Unknown scorer: ${JSON.stringify(scorer)}`);
+  }
+}
+function scoreMatrix(values, scorerName) {
+  const n = values.length;
+  const matrix = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const s = scoreField(values[i], values[j], scorerName) ?? 0;
+      matrix[i][j] = s;
+      matrix[j][i] = s;
+    }
+  }
+  return matrix;
+}
+function exactScoreMatrix(values) {
+  const n = values.length;
+  const matrix = Array.from({ length: n }, () => new Array(n).fill(0));
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const v = values[i];
+    if (v != null) {
+      const existing = groups.get(v);
+      if (existing !== void 0) {
+        existing.push(i);
+      } else {
+        groups.set(v, [i]);
+      }
+    }
+  }
+  groups.forEach((indices) => {
+    if (indices.length > 1) {
+      for (let a = 0; a < indices.length; a++) {
+        for (let b = a + 1; b < indices.length; b++) {
+          matrix[indices[a]][indices[b]] = 1;
+          matrix[indices[b]][indices[a]] = 1;
+        }
+      }
+    }
+  });
+  return matrix;
+}
+function soundexScoreMatrix(values) {
+  const codes = values.map((v) => v !== null ? soundex(v) : null);
+  return exactScoreMatrix(codes);
+}
+function ensembleScoreMatrix(values) {
+  const n = values.length;
+  const clean = values.map((v) => v ?? "");
+  const jw = Array.from({ length: n }, () => new Array(n).fill(0));
+  const ts = Array.from({ length: n }, () => new Array(n).fill(0));
+  const sx = soundexScoreMatrix(values);
+  const result = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (values[i] === null || values[j] === null) continue;
+      jw[i][j] = jaroWinkler(clean[i], clean[j]);
+      jw[j][i] = jw[i][j];
+      ts[i][j] = tokenSortRatio(clean[i], clean[j]);
+      ts[j][i] = ts[i][j];
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const val = Math.max(jw[i][j], ts[i][j], sx[i][j] * 0.8);
+      result[i][j] = val;
+      result[j][i] = val;
+    }
+  }
+  return result;
+}
+function buildNullMask(values) {
+  const n = values.length;
+  const mask = Array.from({ length: n }, () => new Array(n).fill(false));
+  for (let i = 0; i < n; i++) {
+    if (values[i] === null) {
+      for (let j = 0; j < n; j++) {
+        mask[i][j] = true;
+        mask[j][i] = true;
+      }
+    }
+  }
+  return mask;
+}
+function buildScoreMatrix(values, scorerName) {
+  switch (scorerName) {
+    case "exact":
+      return exactScoreMatrix(values);
+    case "soundex_match":
+      return soundexScoreMatrix(values);
+    case "ensemble":
+      return ensembleScoreMatrix(values);
+    default:
+      return scoreMatrix(values, scorerName);
+  }
+}
+function getTransformedValues(rows, field) {
+  return rows.map((row) => {
+    const raw = asString(row[field.field]);
+    return applyTransforms(raw, field.transforms);
+  });
+}
+function findFuzzyMatches(rows, mk, excludePairs, preScoredPairs) {
+  const threshold = mk.type === "exact" ? 1 : mk.threshold ?? 0.85;
+  if (preScoredPairs !== void 0) {
+    const results2 = [];
+    for (const p of preScoredPairs) {
+      if (p.score < threshold) continue;
+      const idA = Math.min(p.idA, p.idB);
+      const idB = Math.max(p.idA, p.idB);
+      const key = pairKey(idA, idB);
+      if (excludePairs !== void 0 && excludePairs.has(key)) continue;
+      results2.push(makeScoredPair(idA, idB, p.score));
+    }
+    return results2;
+  }
+  const n = rows.length;
+  if (n < 2) return [];
+  const rowIds = rows.map((r) => r["__row_id__"]);
+  const cheapFields = mk.fields.filter(
+    (f) => f.scorer === "exact" || f.scorer === "soundex_match"
+  );
+  const fuzzyFields = mk.fields.filter(
+    (f) => f.scorer !== "exact" && f.scorer !== "soundex_match" && f.scorer !== "record_embedding"
+  );
+  const totalWeight = mk.fields.reduce((sum, f) => sum + f.weight, 0);
+  if (totalWeight === 0) return [];
+  const cheapNumerator = Array.from({ length: n }, () => new Array(n).fill(0));
+  const cheapDenominator = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (const f of cheapFields) {
+    const values = getTransformedValues(rows, f);
+    const nullMask = buildNullMask(values);
+    const scores = f.scorer === "exact" ? exactScoreMatrix(values) : soundexScoreMatrix(values);
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        if (!nullMask[i][j]) {
+          cheapNumerator[i][j] += scores[i][j] * f.weight;
+          cheapNumerator[j][i] = cheapNumerator[i][j];
+          cheapDenominator[i][j] += f.weight;
+          cheapDenominator[j][i] = cheapDenominator[i][j];
+        }
+      }
+    }
+  }
+  const fuzzyTotalWeight = fuzzyFields.reduce((sum, f) => sum + f.weight, 0);
+  const impossible = Array.from({ length: n }, () => new Array(n).fill(false));
+  let combined;
+  if (fuzzyFields.length === 0) {
+    combined = Array.from({ length: n }, () => new Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        combined[i][j] = cheapDenominator[i][j] > 0 ? cheapNumerator[i][j] / cheapDenominator[i][j] : 0;
+        combined[j][i] = combined[i][j];
+      }
+    }
+  } else {
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        const maxNum = cheapNumerator[i][j] + fuzzyTotalWeight;
+        const maxDen = cheapDenominator[i][j] + fuzzyTotalWeight;
+        const maxPossible = maxDen > 0 ? maxNum / maxDen : 0;
+        if (maxPossible < threshold) {
+          impossible[i][j] = true;
+          impossible[j][i] = true;
+        }
+      }
+    }
+    const fuzzyNumerator = Array.from({ length: n }, () => new Array(n).fill(0));
+    const fuzzyDenominator = Array.from({ length: n }, () => new Array(n).fill(0));
+    for (let fIdx = 0; fIdx < fuzzyFields.length; fIdx++) {
+      const f = fuzzyFields[fIdx];
+      const values = getTransformedValues(rows, f);
+      const nullMask = buildNullMask(values);
+      const scores = buildScoreMatrix(values, f.scorer);
+      for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+          if (!nullMask[i][j]) {
+            fuzzyNumerator[i][j] += scores[i][j] * f.weight;
+            fuzzyNumerator[j][i] = fuzzyNumerator[i][j];
+            fuzzyDenominator[i][j] += f.weight;
+            fuzzyDenominator[j][i] = fuzzyDenominator[i][j];
+          }
+        }
+      }
+      const remainingWeight = fuzzyFields.slice(fIdx + 1).reduce((sum, ff) => sum + ff.weight, 0);
+      if (remainingWeight > 0) {
+        let anyCanReach = false;
+        for (let i = 0; i < n && !anyCanReach; i++) {
+          for (let j = i + 1; j < n && !anyCanReach; j++) {
+            if (impossible[i][j]) continue;
+            const totalNum = cheapNumerator[i][j] + fuzzyNumerator[i][j] + remainingWeight;
+            const totalDen = cheapDenominator[i][j] + fuzzyDenominator[i][j] + remainingWeight;
+            const bestPossible = totalDen > 0 ? totalNum / totalDen : 0;
+            if (bestPossible >= threshold) {
+              anyCanReach = true;
+            }
+          }
+        }
+        if (!anyCanReach) break;
+      }
+    }
+    combined = Array.from({ length: n }, () => new Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        if (impossible[i][j]) {
+          combined[i][j] = 0;
+        } else {
+          const totalNum = cheapNumerator[i][j] + fuzzyNumerator[i][j];
+          const totalDen = cheapDenominator[i][j] + fuzzyDenominator[i][j];
+          combined[i][j] = totalDen > 0 ? totalNum / totalDen : 0;
+        }
+        combined[j][i] = combined[i][j];
+      }
+    }
+  }
+  const results = [];
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const score = combined[i][j];
+      if (score < threshold) continue;
+      const idA = Math.min(rowIds[i], rowIds[j]);
+      const idB = Math.max(rowIds[i], rowIds[j]);
+      const key = pairKey(idA, idB);
+      if (excludePairs !== void 0 && excludePairs.has(key)) continue;
+      results.push(makeScoredPair(idA, idB, score));
+    }
+  }
+  return results;
+}
+
+// src/node/backends/score-worker.ts
+function scoreWorker(input) {
+  const excludeSet = new Set(input.matchedPairs);
+  const pairs = findFuzzyMatches(
+    input.block.rows,
+    input.mk,
+    excludeSet,
+    input.block.preScoredPairs
+  );
+  return { pairs };
+}
+
+module.exports = scoreWorker;
+//# sourceMappingURL=score-worker.cjs.map
+//# sourceMappingURL=score-worker.cjs.map