@discretion/core 0.1.0

package/src/detect/detectors/natid/mx.ts

@@ -0,0 +1,83 @@
+/**
+ * Mexico: CURP and RFC.
+ *
+ * CURP — eighteen characters with a REAL check digit: the first seventeen
+ * are valued through the RENAPO alphabet (0–9 then A–Z with Ñ between N
+ * and O), weighted 18 down to 2, and the check is (10 − sum mod 10) mod 10.
+ * The state field must be one of the 32 states or NE (born abroad).
+ *
+ * RFC — the persona-física 4-letter + date + 3-char homoclave form. The
+ * homoclave's final character is derived from an SAT table with unpublished
+ * collision-resolution quirks, so RFC validates structurally (date gate) at
+ * MEDIUM and says so.
+ */
+
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+const CURP_ALPHABET = '0123456789ABCDEFGHIJKLMNÑOPQRSTUVWXYZ';
+
+const MX_STATES = new Set([
+  'AS', 'BC', 'BS', 'CC', 'CL', 'CM', 'CS', 'CH', 'DF', 'DG', 'GT', 'GR',
+  'HG', 'JC', 'MC', 'MN', 'MS', 'NT', 'NL', 'OC', 'PL', 'QT', 'QR', 'SP',
+  'SL', 'SR', 'TC', 'TS', 'TL', 'VZ', 'YN', 'ZS', 'NE',
+]);
+
+/** The RENAPO check digit over the first seventeen characters. */
+export function curpCheckDigit(seventeen: string): number | null {
+  let sum = 0;
+  for (let i = 0; i < 17; i++) {
+    const value = CURP_ALPHABET.indexOf(seventeen[i]!);
+    if (value < 0) return null;
+    sum += value * (18 - i);
+  }
+  return (10 - (sum % 10)) % 10;
+}
+
+registerDetector({
+  id: 'national-id-mx-curp',
+  entityType: 'NATIONAL_ID',
+  regions: ['MX'],
+  pattern: /\b([A-ZÑ]{4})(\d{2})(\d{2})(\d{2})([HM])([A-Z]{2})([A-ZÑ]{3})([0-9A-Z])(\d)\b/gu,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Mexican CURP: state code, date, sex and the RENAPO check digit.',
+  validate(ctx): ValidationResult {
+    const month = Number(ctx.match[3]);
+    if (month < 1 || month > 12) return invalid('month out of range');
+    const day = Number(ctx.match[4]);
+    if (day < 1 || day > 31) return invalid('day out of range');
+    if (!MX_STATES.has(ctx.match[6]!)) return invalid('not a state code');
+
+    const value = ctx.match[0];
+    const expected = curpCheckDigit(value.slice(0, 17));
+    if (expected === null || expected !== Number(value[17])) {
+      return invalid('RENAPO check digit failed');
+    }
+    return valid({
+      canonical: value,
+      metadata: { scheme: 'curp', country: 'MX', state: ctx.match[6] },
+      validator: 'curp-mod10',
+    });
+  },
+});
+
+registerDetector({
+  id: 'national-id-mx-rfc',
+  entityType: 'TAX_ID',
+  regions: ['MX'],
+  pattern: /\b([A-ZÑ&]{4})(\d{2})(\d{2})(\d{2})([A-Z0-9]{3})\b/gu,
+  baseConfidence: CONFIDENCE.MEDIUM,
+  description: 'Mexican RFC (persona física): date-gated structure; the SAT homoclave table is unpublished.',
+  validate(ctx): ValidationResult {
+    const month = Number(ctx.match[3]);
+    if (month < 1 || month > 12) return invalid('month out of range');
+    const day = Number(ctx.match[4]);
+    if (day < 1 || day > 31) return invalid('day out of range');
+    return valid({
+      canonical: ctx.match[0],
+      metadata: { scheme: 'rfc', country: 'MX' },
+      validator: 'rfc-structure',
+    });
+  },
+});

package/src/detect/detectors/natid/nl.ts

@@ -0,0 +1,38 @@
+/**
+ * Netherlands: BSN — nine digits under the "11-proef":
+ * (9·d₁ + 8·d₂ + … + 2·d₈ − d₉) mod 11 must be 0. The MINUS on the last
+ * digit is what separates the BSN test from the plain divisibility tests —
+ * transcribing it as +1 accepts a different (wrong) fifth of all numbers.
+ */
+
+import { toDigits } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+registerDetector({
+  id: 'national-id-nl-bsn',
+  entityType: 'NATIONAL_ID',
+  regions: ['NL'],
+  pattern: /\b\d{9}\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Dutch BSNs under the 11-proef (negative final weight).',
+  validate(ctx): ValidationResult {
+    const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+    if (/[\d.-]/.test(before ?? '')) return invalid('fragment of a longer number');
+    const after = ctx.text.slice(ctx.end, ctx.end + 2);
+    if (/^\d/.test(after) || /^[.-]\d/.test(after)) return invalid('fragment of a longer number');
+
+    const digits = toDigits(ctx.match[0])!;
+    let sum = 0;
+    for (let i = 0; i < 8; i++) sum += digits[i]! * (9 - i);
+    sum -= digits[8]!;
+    if (sum % 11 !== 0) return invalid('11-proef failed');
+    if (digits.every((d) => d === 0)) return invalid('all zeros');
+    return valid({
+      canonical: ctx.match[0],
+      metadata: { scheme: 'bsn', country: 'NL' },
+      validator: '11-proef',
+    });
+  },
+});

package/src/detect/detectors/natid/no.ts

@@ -0,0 +1,50 @@
+/**
+ * Norway: Fødselsnummer — eleven digits with TWO chained mod-11 checks
+ * (SPEC.md: "dual mod 11"). k1 closes the first nine digits, k2 closes the
+ * first ten including k1; a remainder of 1 in either makes the number
+ * unissuable. D-numbers (day+40, for temporary residents) are accepted and
+ * flagged.
+ */
+
+import { toDigits, weightedMod } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+const K1_WEIGHTS = [3, 7, 6, 1, 8, 9, 4, 5, 2];
+const K2_WEIGHTS = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+
+registerDetector({
+  id: 'national-id-no-fodselsnummer',
+  entityType: 'NATIONAL_ID',
+  regions: ['NO'],
+  pattern: /\b(\d{2})(\d{2})(\d{2})[ ]?(\d{5})\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Norwegian fødselsnummer: dual mod-11 check digits, D-numbers included.',
+  validate(ctx): ValidationResult {
+    const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+    if (/[\d-]/.test(before ?? '')) return invalid('fragment of a longer number');
+    const after = ctx.text.slice(ctx.end, ctx.end + 2);
+    if (/^\d/.test(after) || /^-\d/.test(after)) return invalid('fragment of a longer number');
+
+    const day = Number(ctx.match[1]);
+    const dNumber = day >= 41 && day <= 71;
+    if (!(day >= 1 && day <= 31) && !dNumber) return invalid('day out of range');
+    const month = Number(ctx.match[2]);
+    if (month < 1 || month > 12) return invalid('month out of range');
+
+    const digits = toDigits(`${ctx.match[1]}${ctx.match[2]}${ctx.match[3]}${ctx.match[4]}`)!;
+    let k1 = 11 - weightedMod(digits.slice(0, 9), K1_WEIGHTS, 11)!;
+    if (k1 === 11) k1 = 0;
+    if (k1 === 10 || k1 !== digits[9]) return invalid('first mod-11 check failed');
+    let k2 = 11 - weightedMod(digits.slice(0, 10), K2_WEIGHTS, 11)!;
+    if (k2 === 11) k2 = 0;
+    if (k2 === 10 || k2 !== digits[10]) return invalid('second mod-11 check failed');
+
+    return valid({
+      canonical: digits.join(''),
+      metadata: { scheme: 'fodselsnummer', country: 'NO', dNumber },
+      validator: 'dual-mod11',
+    });
+  },
+});

package/src/detect/detectors/natid/nz.ts

@@ -0,0 +1,53 @@
+/**
+ * New Zealand: IRD number — eight or nine digits in the issued range
+ * (10,000,000–150,000,000), with the IRD's two-phase mod-11: primary
+ * weights 3,2,7,6,5,4,3,2 over the zero-padded first eight; check =
+ * 11 − remainder (0 stays 0); a result of 10 triggers the secondary
+ * weights 7,4,3,2,5,2,7,6, and a second 10 is unissuable.
+ */
+
+import { toDigits, weightedMod } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+const PRIMARY = [3, 2, 7, 6, 5, 4, 3, 2];
+const SECONDARY = [7, 4, 3, 2, 5, 2, 7, 6];
+
+function irdCheck(payload: readonly number[], weights: readonly number[]): number {
+  const remainder = weightedMod(payload, weights, 11)!;
+  return remainder === 0 ? 0 : 11 - remainder;
+}
+
+registerDetector({
+  id: 'national-id-nz-ird',
+  entityType: 'TAX_ID',
+  regions: ['NZ'],
+  pattern: /\b(\d{2,3})-(\d{3})-(\d{3})\b|\b(\d{8,9})\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'New Zealand IRD numbers: issued range plus the two-phase mod-11.',
+  validate(ctx): ValidationResult {
+    const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+    if (/[\d-]/.test(before ?? '')) return invalid('fragment of a longer number');
+    const after = ctx.text.slice(ctx.end, ctx.end + 2);
+    if (/^\d/.test(after) || /^-\d/.test(after)) return invalid('fragment of a longer number');
+
+    const digitsStr = ctx.match[0].replace(/-/g, '');
+    const value = Number(digitsStr);
+    if (value < 10_000_000 || value > 150_000_000) return invalid('outside the issued range');
+
+    const padded = digitsStr.padStart(9, '0');
+    const digits = toDigits(padded)!;
+    let check = irdCheck(digits.slice(0, 8), PRIMARY);
+    if (check === 10) {
+      check = irdCheck(digits.slice(0, 8), SECONDARY);
+      if (check === 10) return invalid('unissuable (double remainder 10)');
+    }
+    if (check !== digits[8]) return invalid('IRD check digit failed');
+    return valid({
+      canonical: digitsStr,
+      metadata: { scheme: 'ird', country: 'NZ' },
+      validator: 'ird-two-phase-mod11',
+    });
+  },
+});

package/src/detect/detectors/natid/pe.ts

@@ -0,0 +1,28 @@
+/**
+ * Peru: DNI — eight digits with no public checksum; only the labeled
+ * writing ("DNI 12345678", "DNI: 12345678", "DNI N° 12345678") is claimed,
+ * span narrowed to the number, MEDIUM.
+ */
+
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+registerDetector({
+  id: 'national-id-pe-dni',
+  entityType: 'NATIONAL_ID',
+  regions: ['PE'],
+  pattern: /\bDNI(?:\s*(?:N[°º.]?|No\.?))?:?\s*(\d{8})\b/g,
+  baseConfidence: CONFIDENCE.MEDIUM,
+  description: 'Peruvian DNI in labeled notation (no public checksum).',
+  validate(ctx): ValidationResult {
+    const numberPart = ctx.match[1]!;
+    const start = ctx.start + ctx.match[0].lastIndexOf(numberPart);
+    return valid({
+      canonical: numberPart,
+      metadata: { scheme: 'dni', country: 'PE' },
+      validator: 'dni-labeled',
+      span: { start, end: start + numberPart.length },
+    });
+  },
+});

package/src/detect/detectors/natid/pl.ts

@@ -0,0 +1,100 @@
+/**
+ * Poland: PESEL, NIP, REGON — all genuinely checksummed.
+ *
+ * PESEL: weights 1,3,7,9 cycling over ten digits, check = (10 − sum) mod 10;
+ * the month field encodes the century (+20 → 2000s, +40 → 2100s, +60 →
+ * 2200s, +80 → 1800s) and is validated as such. NIP: weights
+ * 6,5,7,2,3,4,5,6,7 mod 11, remainder 10 never issued. REGON (9-digit):
+ * weights 8,9,2,3,4,5,6,7 mod 11 with 10→0.
+ */
+
+import { toDigits, cyclicWeightedMod, weightedMod } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationContext, ValidationResult } from '../../types.js';
+
+function digitFragmentGuard(ctx: ValidationContext): string | null {
+  const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+  if (/[\d-]/.test(before ?? '')) return 'fragment of a longer number';
+  const after = ctx.text.slice(ctx.end, ctx.end + 2);
+  if (/^\d/.test(after) || /^-\d/.test(after)) return 'fragment of a longer number';
+  return null;
+}
+
+registerDetector({
+  id: 'national-id-pl-pesel',
+  entityType: 'NATIONAL_ID',
+  regions: ['PL'],
+  pattern: /\b\d{11}\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Polish PESEL: century-encoded date plus the 1-3-7-9 checksum.',
+  validate(ctx): ValidationResult {
+    const guard = digitFragmentGuard(ctx);
+    if (guard !== null) return invalid(guard);
+    const digits = toDigits(ctx.match[0])!;
+    const month = Number(ctx.match[0].slice(2, 4));
+    const monthValid =
+      (month >= 1 && month <= 12) || (month >= 21 && month <= 32) || (month >= 41 && month <= 52) ||
+      (month >= 61 && month <= 72) || (month >= 81 && month <= 92);
+    if (!monthValid) return invalid('month field outside all century bands');
+    const day = Number(ctx.match[0].slice(4, 6));
+    if (day < 1 || day > 31) return invalid('day field out of range');
+    const sum = cyclicWeightedMod(digits.slice(0, 10), [1, 3, 7, 9], 10)!;
+    if ((10 - sum) % 10 !== digits[10]) return invalid('PESEL checksum failed');
+    return valid({
+      canonical: ctx.match[0],
+      metadata: { scheme: 'pesel', country: 'PL' },
+      validator: 'pesel-mod10',
+    });
+  },
+});
+
+const NIP_WEIGHTS = [6, 5, 7, 2, 3, 4, 5, 6, 7];
+
+registerDetector({
+  id: 'national-id-pl-nip',
+  entityType: 'TAX_ID',
+  regions: ['PL'],
+  pattern: /\b\d{3}[- ]?\d{3}[- ]?\d{2}[- ]?\d{2}\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Polish NIP tax ids: mod-11 checksum, remainder 10 never issued.',
+  validate(ctx): ValidationResult {
+    const guard = digitFragmentGuard(ctx);
+    if (guard !== null) return invalid(guard);
+    const digitsStr = ctx.match[0].replace(/[- ]/g, '');
+    if (digitsStr.length !== 10) return invalid('not ten digits');
+    const digits = toDigits(digitsStr)!;
+    const remainder = weightedMod(digits.slice(0, 9), NIP_WEIGHTS, 11)!;
+    if (remainder === 10) return invalid('remainder 10 never issued');
+    if (remainder !== digits[9]) return invalid('NIP checksum failed');
+    return valid({
+      canonical: digitsStr,
+      metadata: { scheme: 'nip', country: 'PL' },
+      validator: 'nip-mod11',
+    });
+  },
+});
+
+const REGON_WEIGHTS = [8, 9, 2, 3, 4, 5, 6, 7];
+
+registerDetector({
+  id: 'national-id-pl-regon',
+  entityType: 'TAX_ID',
+  regions: ['PL'],
+  pattern: /\b\d{9}\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Polish REGON business registry numbers (9-digit form), mod-11 checked.',
+  validate(ctx): ValidationResult {
+    const guard = digitFragmentGuard(ctx);
+    if (guard !== null) return invalid(guard);
+    const digits = toDigits(ctx.match[0])!;
+    let check = weightedMod(digits.slice(0, 8), REGON_WEIGHTS, 11)!;
+    if (check === 10) check = 0;
+    if (check !== digits[8]) return invalid('REGON checksum failed');
+    return valid({
+      canonical: ctx.match[0],
+      metadata: { scheme: 'regon', country: 'PL' },
+      validator: 'regon-mod11',
+    });
+  },
+});

package/src/detect/detectors/natid/pt.ts

@@ -0,0 +1,36 @@
+/**
+ * Portugal: NIF — nine digits, weights 9..2 over the first eight, check =
+ * 0 when the remainder is below 2, else 11 − remainder.
+ */
+
+import { toDigits, weightedMod } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+const NIF_WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2];
+
+registerDetector({
+  id: 'national-id-pt-nif',
+  entityType: 'TAX_ID',
+  regions: ['PT'],
+  pattern: /\b[1-9]\d{8}\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Portuguese NIF with its mod-11 check digit.',
+  validate(ctx): ValidationResult {
+    const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+    if (/[\d-]/.test(before ?? '')) return invalid('fragment of a longer number');
+    const after = ctx.text.slice(ctx.end, ctx.end + 2);
+    if (/^\d/.test(after) || /^-\d/.test(after)) return invalid('fragment of a longer number');
+
+    const digits = toDigits(ctx.match[0])!;
+    const remainder = weightedMod(digits.slice(0, 8), NIF_WEIGHTS, 11)!;
+    const check = remainder < 2 ? 0 : 11 - remainder;
+    if (check !== digits[8]) return invalid('NIF checksum failed');
+    return valid({
+      canonical: ctx.match[0],
+      metadata: { scheme: 'nif', country: 'PT' },
+      validator: 'nif-mod11',
+    });
+  },
+});

package/src/detect/detectors/natid/ro.ts

@@ -0,0 +1,47 @@
+/**
+ * Romania: CNP — thirteen digits: S YYMMDD JJ NNN C, where S encodes
+ * sex+century (1–9, never 0), JJ is a county code 01–52 (or 70/80-series
+ * special allocations — 01–52 plus 70..80 accepted), and C closes with the
+ * constant weight vector 2,7,9,1,4,6,3,5,8,2,7,9 mod 11 with 10 → 1.
+ */
+
+import { toDigits, weightedMod } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+const CNP_WEIGHTS = [2, 7, 9, 1, 4, 6, 3, 5, 8, 2, 7, 9];
+
+registerDetector({
+  id: 'national-id-ro-cnp',
+  entityType: 'NATIONAL_ID',
+  regions: ['RO'],
+  pattern: /\b([1-9])(\d{2})(\d{2})(\d{2})(\d{2})(\d{3})(\d)\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Romanian CNP with its constant-weight mod-11 check (10 folds to 1).',
+  validate(ctx): ValidationResult {
+    const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+    if (/[\d-]/.test(before ?? '')) return invalid('fragment of a longer number');
+    const after = ctx.text.slice(ctx.end, ctx.end + 2);
+    if (/^\d/.test(after) || /^-\d/.test(after)) return invalid('fragment of a longer number');
+
+    const month = Number(ctx.match[3]);
+    if (month < 1 || month > 12) return invalid('month out of range');
+    const day = Number(ctx.match[4]);
+    if (day < 1 || day > 31) return invalid('day out of range');
+    const county = Number(ctx.match[5]);
+    if (!((county >= 1 && county <= 52) || (county >= 70 && county <= 80))) {
+      return invalid('county code out of range');
+    }
+
+    const digits = toDigits(ctx.match[0])!;
+    let check = weightedMod(digits.slice(0, 12), CNP_WEIGHTS, 11)!;
+    if (check === 10) check = 1;
+    if (check !== digits[12]) return invalid('CNP checksum failed');
+    return valid({
+      canonical: ctx.match[0],
+      metadata: { scheme: 'cnp', country: 'RO' },
+      validator: 'cnp-mod11',
+    });
+  },
+});

package/src/detect/detectors/natid/ru.ts

@@ -0,0 +1,82 @@
+/**
+ * Russia: INN (both widths) and SNILS.
+ *
+ * INN-10 (organizations): weights 2,4,10,3,5,9,4,6,8 → (sum mod 11) mod 10
+ * closes digit 10. INN-12 (individuals): two chained checks with the
+ * 11- and 12-position weight vectors. SNILS: nine payload digits weighted
+ * 9..1, the two check digits are (sum mod 101) with 100 folding to 0 —
+ * SPEC.md names the mod-101 explicitly.
+ */
+
+import { toDigits, weightedMod } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationContext, ValidationResult } from '../../types.js';
+
+const INN10_WEIGHTS = [2, 4, 10, 3, 5, 9, 4, 6, 8];
+const INN12_W11 = [7, 2, 4, 10, 3, 5, 9, 4, 6, 8];
+const INN12_W12 = [3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8];
+
+function guard(ctx: ValidationContext): string | null {
+  const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+  if (/[\d-]/.test(before ?? '')) return 'fragment of a longer number';
+  const after = ctx.text.slice(ctx.end, ctx.end + 2);
+  if (/^\d/.test(after) || /^-\d/.test(after)) return 'fragment of a longer number';
+  return null;
+}
+
+registerDetector({
+  id: 'national-id-ru-inn',
+  entityType: 'TAX_ID',
+  regions: ['RU'],
+  pattern: /\b\d{10}\b|\b\d{12}\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Russian INN, 10-digit organizational and 12-digit personal forms.',
+  validate(ctx): ValidationResult {
+    const g = guard(ctx);
+    if (g !== null) return invalid(g);
+    const value = ctx.match[0];
+    const d = toDigits(value)!;
+    if (value.length === 10) {
+      const check = weightedMod(d.slice(0, 9), INN10_WEIGHTS, 11)! % 10;
+      if (check !== d[9]) return invalid('INN-10 check failed');
+      return valid({
+        canonical: value,
+        metadata: { scheme: 'inn', country: 'RU', kind: 'organization' },
+        validator: 'inn-mod11',
+      });
+    }
+    const c11 = weightedMod(d.slice(0, 10), INN12_W11, 11)! % 10;
+    if (c11 !== d[10]) return invalid('INN-12 first check failed');
+    const c12 = weightedMod(d.slice(0, 11), INN12_W12, 11)! % 10;
+    if (c12 !== d[11]) return invalid('INN-12 second check failed');
+    return valid({
+      canonical: value,
+      metadata: { scheme: 'inn', country: 'RU', kind: 'personal' },
+      validator: 'inn-dual-mod11',
+    });
+  },
+});
+
+registerDetector({
+  id: 'national-id-ru-snils',
+  entityType: 'NATIONAL_ID',
+  regions: ['RU'],
+  pattern: /\b(\d{3})-(\d{3})-(\d{3})[- ](\d{2})\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Russian SNILS with the mod-101 check (SPEC.md names it).',
+  validate(ctx): ValidationResult {
+    const nine = `${ctx.match[1]}${ctx.match[2]}${ctx.match[3]}`;
+    const d = toDigits(nine)!;
+    let sum = 0;
+    for (let i = 0; i < 9; i++) sum += d[i]! * (9 - i);
+    let check = sum % 101;
+    if (check === 100) check = 0;
+    if (check !== Number(ctx.match[4])) return invalid('mod-101 check failed');
+    return valid({
+      canonical: `${nine}${ctx.match[4]}`,
+      metadata: { scheme: 'snils', country: 'RU' },
+      validator: 'snils-mod101',
+    });
+  },
+});

package/src/detect/detectors/natid/se.ts

@@ -0,0 +1,42 @@
+/**
+ * Sweden: Personnummer — YYMMDD±NNNC, Luhn over the ten digits (shared
+ * library). '+' as the separator means the person is over 100. The 12-digit
+ * century-prefixed writing is also accepted; Luhn always runs on the final
+ * ten. Date plausibility gates first (day 61–91 is the samordningsnummer
+ * coordination range, day+60, and is accepted as such).
+ */
+
+import { luhnValid } from '../../../checksums/index.js';
+import { registerDetector } from '../../registry.js';
+import { CONFIDENCE, invalid, valid } from '../../types.js';
+import type { ValidationResult } from '../../types.js';
+
+registerDetector({
+  id: 'national-id-se-personnummer',
+  entityType: 'NATIONAL_ID',
+  regions: ['SE'],
+  pattern: /\b(?:\d{2})?(\d{2})(\d{2})(\d{2})([-+]?)(\d{4})\b/g,
+  baseConfidence: CONFIDENCE.HIGH,
+  description: 'Swedish personnummer: Luhn over the final ten digits, coordination numbers included.',
+  validate(ctx): ValidationResult {
+    const before = ctx.start > 0 ? ctx.text[ctx.start - 1] : '';
+    if (/[\d-]/.test(before ?? '')) return invalid('fragment of a longer number');
+    const after = ctx.text.slice(ctx.end, ctx.end + 2);
+    if (/^\d/.test(after) || /^-\d/.test(after)) return invalid('fragment of a longer number');
+
+    const month = Number(ctx.match[2]);
+    if (month < 1 || month > 12) return invalid('month out of range');
+    const day = Number(ctx.match[3]);
+    const ordinaryDay = day >= 1 && day <= 31;
+    const coordinationDay = day >= 61 && day <= 91;
+    if (!ordinaryDay && !coordinationDay) return invalid('day out of range');
+
+    const ten = `${ctx.match[1]}${ctx.match[2]}${ctx.match[3]}${ctx.match[5]}`;
+    if (!luhnValid(ten)) return invalid('Luhn checksum failed');
+    return valid({
+      canonical: ten,
+      metadata: { scheme: 'personnummer', country: 'SE', coordination: coordinationDay },
+      validator: 'luhn',
+    });
+  },
+});