@discretion/core 0.1.0

package/src/generate/crypto.ts

@@ -0,0 +1,91 @@
+/**
+ * Valid-value generators for the crypto wallet family.
+ *
+ * Built from the SAME primitives the validators verify with — the
+ * primitives are pinned to published vectors in crypto-primitives.test.ts,
+ * so this is synthesis, not circularity. Chains with real checksums (BTC,
+ * ETH mixed-case, LTC, TRX, XMR) get the mutation half of the property
+ * standard; SOL and DOT are structural formats and skip it (stated in the
+ * tests).
+ */
+
+import { keccak256 } from '../crypto/keccak256.js';
+import { base58CheckEncode, base58Encode } from '../encoding/base58.js';
+import { bech32Encode, convertBits } from '../encoding/bech32.js';
+import { moneroBase58Encode } from '../encoding/base58monero.js';
+import { toEip55 } from '../detect/detectors/crypto/eth.js';
+import { mulberry32 } from './prng.js';
+
+function randomBytes(rng: () => number, count: number): Uint8Array {
+  const out = new Uint8Array(count);
+  for (let i = 0; i < count; i++) out[i] = Math.floor(rng() * 256);
+  return out;
+}
+
+/** A checksummed Bitcoin address: P2PKH, P2SH, segwit v0, or taproot. */
+export function generateValidBtc(seed: number): string {
+  const rng = mulberry32(seed);
+  const kind = Math.floor(rng() * 4);
+  if (kind === 0) return base58CheckEncode(0x00, randomBytes(rng, 20));
+  if (kind === 1) return base58CheckEncode(0x05, randomBytes(rng, 20));
+  if (kind === 2) {
+    const program = randomBytes(rng, rng() < 0.5 ? 20 : 32);
+    return bech32Encode('bc', [0, ...convertBits([...program], 8, 5, true)!], 'bech32');
+  }
+  const program = randomBytes(rng, 32);
+  return bech32Encode('bc', [1, ...convertBits([...program], 8, 5, true)!], 'bech32m');
+}
+
+/** An EIP-55 checksummed Ethereum address. */
+export function generateValidEth(seed: number): string {
+  const rng = mulberry32(seed);
+  const hexLower = [...randomBytes(rng, 20)].map((b) => b.toString(16).padStart(2, '0')).join('');
+  return `0x${toEip55(hexLower)}`;
+}
+
+/** A checksummed Litecoin address (L/M base58check or ltc1 segwit v0). */
+export function generateValidLtc(seed: number): string {
+  const rng = mulberry32(seed);
+  const kind = Math.floor(rng() * 3);
+  if (kind === 0) return base58CheckEncode(0x30, randomBytes(rng, 20));
+  if (kind === 1) return base58CheckEncode(0x32, randomBytes(rng, 20));
+  const program = randomBytes(rng, rng() < 0.5 ? 20 : 32);
+  return bech32Encode('ltc', [0, ...convertBits([...program], 8, 5, true)!], 'bech32');
+}
+
+/** A checksummed Tron address. */
+export function generateValidTrx(seed: number): string {
+  const rng = mulberry32(seed);
+  return base58CheckEncode(0x41, randomBytes(rng, 20));
+}
+
+/** A checksummed Monero address (standard or subaddress). */
+export function generateValidXmr(seed: number): string {
+  const rng = mulberry32(seed);
+  const network = rng() < 0.5 ? 0x12 : 0x2a;
+  const body = Uint8Array.from([network, ...randomBytes(rng, 64)]);
+  const checksum = keccak256(body).slice(0, 4);
+  return moneroBase58Encode(Uint8Array.from([...body, ...checksum]));
+}
+
+/** A structurally valid Solana address (32-byte key; no checksum exists). */
+export function generateValidSol(seed: number): string {
+  const rng = mulberry32(seed);
+  const bytes = randomBytes(rng, 32);
+  if (bytes.every((b) => b === 0)) bytes[0] = 1; // avoid the system program
+  return base58Encode(bytes);
+}
+
+/** A checksummed Cardano Shelley address. */
+export function generateValidAda(seed: number): string {
+  const rng = mulberry32(seed);
+  // 57 payload bytes ≈ a real Shelley base address envelope.
+  const data = convertBits([...randomBytes(rng, 57)], 8, 5, true)!;
+  return bech32Encode('addr', data, 'bech32');
+}
+
+/** A structurally valid Polkadot SS58 envelope (checksum bytes arbitrary). */
+export function generateValidDot(seed: number): string {
+  const rng = mulberry32(seed);
+  return base58Encode(Uint8Array.from([0x00, ...randomBytes(rng, 34)]));
+}

package/src/generate/documents.ts

@@ -0,0 +1,142 @@
+/**
+ * Valid-value generators for the documents & health family.
+ *
+ * The MRZ generator is the important one: it assembles a TD3 (or TD1) zone
+ * and computes every ICAO check digit with the shared library, exactly the
+ * way M3's corpus generator will synthesize labeled passports. MRZ, VIN,
+ * NPI and SNOMED carry real checksums → full mutation properties. UK DVLA
+ * and lab results are structural.
+ */
+
+import { mrzCheckDigit } from '../checksums/index.js';
+import { luhnCheckDigit, verhoeffCheckDigit } from '../checksums/index.js';
+import { vinCheckChar } from '../detect/detectors/documents/vin.js';
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+function int(rng: () => number, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1));
+}
+
+const AZ = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const DIGITS = '0123456789';
+
+function chars(rng: () => number, alphabet: string, n: number): string {
+  let out = '';
+  for (let i = 0; i < n; i++) out += alphabet[Math.floor(rng() * alphabet.length)]!;
+  return out;
+}
+
+const STATES = ['UTO', 'DEU', 'FRA', 'TUR', 'JPN', 'BRA', 'IND', 'USA', 'GBR', 'NLD'];
+const SURNAMES = ['ERIKSSON', 'YILMAZ', 'TANAKA', 'SILVA', 'MUELLER', 'GARCIA', 'KOWALSKI'];
+const GIVEN = ['ANNA', 'MEHMET', 'YUKI', 'LUCIA', 'HANS', 'PRIYA', 'JAN'];
+
+function mrzDate(rng: () => number, startYear: number, endYear: number): string {
+  const y = int(rng, startYear, endYear) % 100;
+  const m = int(rng, 1, 12);
+  const d = int(rng, 1, 28);
+  return `${String(y).padStart(2, '0')}${String(m).padStart(2, '0')}${String(d).padStart(2, '0')}`;
+}
+
+const pad = (s: string, n: number): string => (s + '<'.repeat(n)).slice(0, n);
+
+/** A TD3 passport MRZ (two 44-char lines) with every check digit correct. */
+export function generateValidTd3(seed: number): string {
+  const rng = mulberry32(seed);
+  const state = pick(rng, STATES);
+  const name = pad(`${pick(rng, SURNAMES)}<<${pick(rng, GIVEN)}`, 39);
+  const line1 = `P<${state}${name}`;
+
+  const docNumber = pad(chars(rng, AZ, 2) + chars(rng, DIGITS, 7), 9);
+  const docCheck = mrzCheckDigit(docNumber)!;
+  const nationality = state;
+  const birth = mrzDate(rng, 1950, 2005);
+  const birthCheck = mrzCheckDigit(birth)!;
+  const sex = pick(rng, ['M', 'F', '<']);
+  const expiry = mrzDate(rng, 2025, 2035);
+  const expiryCheck = mrzCheckDigit(expiry)!;
+  const optional = pad('', 14);
+  const optionalCheck = mrzCheckDigit(optional)!;
+  const composite = `${docNumber}${docCheck}${birth}${birthCheck}${expiry}${expiryCheck}${optional}${optionalCheck}`;
+  const compositeCheck = mrzCheckDigit(composite)!;
+
+  const line2 = `${docNumber}${docCheck}${nationality}${birth}${birthCheck}${sex}${expiry}${expiryCheck}${optional}${optionalCheck}${compositeCheck}`;
+  return `${line1}\n${line2}`;
+}
+
+/** A TD1 identity-card MRZ (three 30-char lines), all check digits correct. */
+export function generateValidTd1(seed: number): string {
+  const rng = mulberry32(seed);
+  const state = pick(rng, STATES);
+
+  const docNumber = pad(chars(rng, AZ, 1) + chars(rng, DIGITS, 8), 9);
+  const docCheck = mrzCheckDigit(docNumber)!;
+  const optional1 = pad('', 15);
+  const line1 = `I<${state}${docNumber}${docCheck}${optional1}`;
+
+  const birth = mrzDate(rng, 1950, 2005);
+  const birthCheck = mrzCheckDigit(birth)!;
+  const sex = pick(rng, ['M', 'F']);
+  const expiry = mrzDate(rng, 2025, 2035);
+  const expiryCheck = mrzCheckDigit(expiry)!;
+  const nationality = state;
+  const optional2 = pad('', 11);
+  const composite = `${docNumber}${docCheck}${optional1}${birth}${birthCheck}${expiry}${expiryCheck}${optional2}`;
+  const compositeCheck = mrzCheckDigit(composite)!;
+  const line2 = `${birth}${birthCheck}${sex}${expiry}${expiryCheck}${nationality}${optional2}${compositeCheck}`;
+
+  const name = pad(`${pick(rng, SURNAMES)}<<${pick(rng, GIVEN)}`, 30);
+  return `${line1}\n${line2}\n${name}`;
+}
+
+/** A VIN whose ISO 3779 check digit is correct. */
+export function generateValidVin(seed: number): string {
+  const rng = mulberry32(seed);
+  const alphabet = 'ABCDEFGHJKLMNPRSTUVWXYZ0123456789';
+  let vin = chars(rng, alphabet, 8) + '0' + chars(rng, alphabet, 8);
+  const check = vinCheckChar(vin)!;
+  vin = vin.slice(0, 8) + check + vin.slice(9);
+  return vin;
+}
+
+/** An NPI with the 80840-prefixed Luhn check digit correct. */
+export function generateValidNpi(seed: number): string {
+  const rng = mulberry32(seed);
+  const payload = pick(rng, ['1', '2']) + chars(rng, DIGITS, 8);
+  const check = luhnCheckDigit(`80840${payload}`)!;
+  return `${payload}${check}`;
+}
+
+/** A UK DVLA licence number obeying the date rules. */
+export function generateValidDvla(seed: number): string {
+  const rng = mulberry32(seed);
+  const surname = pad(pick(rng, SURNAMES).slice(0, 5), 5).replace(/</g, '9');
+  const decade = String(int(rng, 5, 9));
+  const month = int(rng, 1, 12) + (rng() < 0.5 ? 50 : 0);
+  const day = int(rng, 1, 28);
+  const year = String(int(rng, 0, 9));
+  const initials = chars(rng, AZ, 2);
+  return `${surname}${decade}${String(month).padStart(2, '0')}${String(day).padStart(2, '0')}${year}${initials}${int(rng, 0, 9)}${chars(rng, AZ, 2)}`;
+}
+
+/** A SNOMED SCTID: defined partition pair, closed with Verhoeff. */
+export function generateValidSctid(seed: number): string {
+  const rng = mulberry32(seed);
+  const body = chars(rng, DIGITS, int(rng, 5, 12));
+  const partition = pick(rng, ['00', '01', '10']);
+  const payload = `${body}${partition}`;
+  return `${payload}${verhoeffCheckDigit(payload)!}`;
+}
+
+/** A lab-result phrase: value, unit, bracketed reference range. */
+export function generateValidLabResult(seed: number): string {
+  const rng = mulberry32(seed);
+  const units = ['mg/dL', 'mmol/L', 'g/dL', 'IU/L', 'ng/mL', '%'];
+  const value = (int(rng, 40, 400) / (rng() < 0.5 ? 1 : 10)).toFixed(1);
+  const lo = int(rng, 1, 80);
+  const hi = lo + int(rng, 5, 120);
+  return `${value} ${pick(rng, units)} [${lo}-${hi}]`;
+}

package/src/generate/financial.ts

@@ -0,0 +1,149 @@
+/**
+ * Valid-value generators for the financial core family.
+ *
+ * These synthesize values with the SAME checksum library the validators
+ * verify with (`luhnCheckDigit`, `ibanCheckDigits`) — which is not circular:
+ * the library is tested independently against published vectors, and this is
+ * exactly how M3's corpus generator and M4's surrogate substitution will
+ * create valid identifiers.
+ *
+ * IBAN and credit cards carry real checksums, so their property tests run
+ * the full standard including the single-character-mutation half. BIC has no
+ * checksum; its property omits mutation (see the BIC section).
+ */
+
+import { ibanCheckDigits, luhnCheckDigit } from '../checksums/index.js';
+import { IBAN_REGISTRY } from '../detect/detectors/financial/ibanRegistry.js';
+import { ISO_COUNTRY_CODES } from '../detect/isoCountries.js';
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+const DIGITS = '0123456789';
+const LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const ALNUM = DIGITS + LETTERS;
+
+function chars(rng: () => number, alphabet: string, count: number): string {
+  let out = '';
+  for (let i = 0; i < count; i++) out += alphabet[Math.floor(rng() * alphabet.length)]!;
+  return out;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// IBAN
+// ─────────────────────────────────────────────────────────────────────────────
+
+const IBAN_COUNTRIES = [...IBAN_REGISTRY.keys()];
+
+/** A structurally valid, mod-97-closed IBAN for a random registry country. */
+export function generateValidIban(seed: number): string {
+  const rng = mulberry32(seed);
+  const country = pick(rng, IBAN_COUNTRIES);
+  const spec = IBAN_REGISTRY.get(country)!;
+  let bban = '';
+  for (const seg of spec.segments) {
+    const alphabet = seg.type === 'n' ? DIGITS : seg.type === 'a' ? LETTERS : ALNUM;
+    bban += chars(rng, alphabet, seg.length);
+  }
+  const check = ibanCheckDigits(country, bban)!;
+  return `${country}${check}${bban}`;
+}
+
+/** A valid IBAN for a SPECIFIC country (SPEC.md: substitute same-country). */
+export function generateValidIbanForCountry(country: string, seed: number): string {
+  const spec = IBAN_REGISTRY.get(country);
+  if (spec === undefined) return generateValidIban(seed);
+  const rng = mulberry32(seed);
+  let bban = '';
+  for (const seg of spec.segments) {
+    const alphabet = seg.type === 'n' ? DIGITS : seg.type === 'a' ? LETTERS : ALNUM;
+    bban += chars(rng, alphabet, seg.length);
+  }
+  const check = ibanCheckDigits(country, bban)!;
+  return `${country}${check}${bban}`;
+}
+
+/** The same IBAN in conventional four-character display groups. */
+export function groupIban(iban: string): string {
+  return iban.replace(/(.{4})/g, '$1 ').trim();
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Credit cards
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Issuer prefix + PAN length pairs; every entry resolves to that issuer. */
+const CARD_SHAPES: readonly (readonly [string, number])[] = [
+  ['4539', 16], // visa (avoids the 4xxxxx Elo overlaps)
+  ['4716', 13], // visa short form
+  ['5274', 16], // mastercard
+  ['2223', 16], // mastercard 2-series
+  ['371', 15], // amex
+  ['6011', 16], // discover
+  ['3540', 16], // jcb
+  ['36', 14], // diners
+  ['9792', 16], // troy
+  ['2201', 16], // mir
+  ['6250', 16], // unionpay
+  ['6521', 16], // rupay
+  ['509001', 16], // elo
+  ['506110', 16], // verve
+  ['6759', 12], // maestro
+];
+
+/** A Luhn-closed PAN with a recognized issuer prefix. */
+export function generateValidCard(seed: number): string {
+  const rng = mulberry32(seed);
+  const [prefix, length] = pick(rng, CARD_SHAPES);
+  const payload = prefix + chars(rng, DIGITS, length - prefix.length - 1);
+  return `${payload}${luhnCheckDigit(payload)!}`;
+}
+
+/** Prefix + length per issuer, for same-issuer credit-card surrogates. */
+const ISSUER_SHAPES: Readonly<Record<string, readonly [string, number]>> = {
+  visa: ['4539', 16],
+  mastercard: ['5274', 16],
+  amex: ['371', 15],
+  discover: ['6011', 16],
+  jcb: ['3540', 16],
+  diners: ['36', 14],
+  unionpay: ['6250', 16],
+  maestro: ['6759', 16],
+  troy: ['9792', 16],
+  mir: ['2201', 16],
+  rupay: ['6521', 16],
+  elo: ['509001', 16],
+  verve: ['506110', 16],
+};
+
+/** A Luhn-valid PAN for a SPECIFIC issuer (SPEC.md: substitute same issuer). */
+export function generateValidCardForIssuer(issuer: string, seed: number): string {
+  const shape = ISSUER_SHAPES[issuer];
+  if (shape === undefined) return generateValidCard(seed);
+  const rng = mulberry32(seed);
+  const [prefix, length] = shape;
+  const payload = prefix + chars(rng, DIGITS, length - prefix.length - 1);
+  return `${payload}${luhnCheckDigit(payload)!}`;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SWIFT BIC
+// ─────────────────────────────────────────────────────────────────────────────
+
+const BIC_COUNTRIES = [...ISO_COUNTRY_CODES].filter((c) => c !== 'EU');
+/** Location alphabet obeying ISO 9362: first char never 0/1, second never 0
+ *  (0 designates a test BIC, generated separately). */
+const LOC_FIRST = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+const LOC_SECOND = 'ABCDEFGHJKLMNPQRSTUVWXYZ123456789';
+
+/** A structurally valid production (non-test) BIC. */
+export function generateValidBic(seed: number): string {
+  const rng = mulberry32(seed);
+  const bank = chars(rng, LETTERS, 4);
+  const country = pick(rng, BIC_COUNTRIES);
+  const location = chars(rng, LOC_FIRST, 1) + chars(rng, LOC_SECOND, 1);
+  const branch = rng() < 0.5 ? chars(rng, ALNUM, 3) : '';
+  return `${bank}${country}${location}${branch}`;
+}

package/src/generate/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Deterministic valid-value generators — one per Stage 1 detector scheme.
+ *
+ * Public API: the eval package builds its labeled corpus from these, and
+ * M4's format-preserving substitution synthesizes checksum-valid surrogates
+ * with them. Each generator is seeded (mulberry32) and never calls the
+ * validator it feeds.
+ */
+export { mulberry32 } from './prng.js';
+export * from './bankcodes.js';
+export * from './contact.js';
+export * from './crypto.js';
+export * from './documents.js';
+export * from './financial.js';
+export * from './location.js';
+export * from './natidAmOc.js';
+export * from './natidAsia.js';
+export * from './natidCee.js';
+export * from './natidMeCis.js';
+export * from './natidWest.js';
+export * from './secrets.js';
+export * from './vat.js';

package/src/generate/location.ts

@@ -0,0 +1,80 @@
+/**
+ * Valid-value generators for the location family. All three formats are
+ * structural (no checksums), so the properties assert validation without
+ * the mutation half — stated in the tests.
+ */
+
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+function int(rng: () => number, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1));
+}
+
+function digits(rng: () => number, n: number): string {
+  let out = '';
+  for (let i = 0; i < n; i++) out += String(int(rng, 0, 9));
+  return out;
+}
+
+/** A postal code satisfying at least one country's format. */
+export function generateValidPostal(seed: number): string {
+  const rng = mulberry32(seed);
+  const CA_FIRST = 'ABCEGHJKLMNPRSTVXY';
+  const CA_REST = 'ABCEGHJKLMNPRSTVWXYZ';
+  const shapes: readonly (() => string)[] = [
+    () => `${digits(rng, 5)}`, // DE/FR/US/TR…
+    () => `${digits(rng, 5)}-${digits(rng, 4)}`, // US ZIP+4
+    () => `${digits(rng, 2)}-${digits(rng, 3)}`, // PL
+    () => `${digits(rng, 4)}-${digits(rng, 3)}`, // PT
+    () => `${digits(rng, 5)}-${digits(rng, 3)}`, // BR
+    () => `${digits(rng, 3)}-${digits(rng, 4)}`, // JP
+    () => `${digits(rng, 4)} ${pick(rng, ['AB', 'CD', 'XZ', 'JK'])}`, // NL
+    () => `SW1A 1AA`, // GB, fixed shape
+    () => `${pick(rng, [...CA_FIRST])}${int(rng, 0, 9)}${pick(rng, [...CA_REST])} ${int(rng, 0, 9)}${pick(rng, [...CA_REST])}${int(rng, 0, 9)}`, // CA
+    () => `${digits(rng, 6)}`, // CN/IN/SG/RU
+  ];
+  const value = pick(rng, shapes)();
+  // The 4-digit shape can collide with the year guard; regenerate as 5-digit.
+  if (/^\d{4}$/.test(value)) return `${value}0`;
+  return value;
+}
+
+const WESTERN = ['Baker Street', 'Pennsylvania Avenue', 'Abbey Road', 'Elm Drive'];
+const GERMANIC = ['Hauptstraße', 'Bahnhofstraße', 'Prinsengracht', 'Ringallee'];
+const ROMANCE_T = ['rue', 'avenida', 'via', 'calle'];
+const ROMANCE_N = ['de la Paix', 'Mayor', 'Roma', 'del Sol'];
+const TURKISH_N = ['Atatürk', 'Cumhuriyet', 'İstiklal'];
+const TURKISH_T = ['Caddesi', 'Sokak', 'Bulvarı'];
+
+/** A street address in one of the six conventions. */
+export function generateValidStreet(seed: number): string {
+  const rng = mulberry32(seed);
+  const shapes: readonly (() => string)[] = [
+    () => `${int(rng, 1, 9999)} ${pick(rng, WESTERN)}`,
+    () => `${int(rng, 1, 999)} ${pick(rng, ROMANCE_T)} ${pick(rng, ROMANCE_N)}`,
+    () => `${pick(rng, GERMANIC)} ${int(rng, 1, 200)}`,
+    () => `${pick(rng, TURKISH_N)} ${pick(rng, TURKISH_T)} No: ${int(rng, 1, 200)}`,
+    () => `中山路${int(rng, 1, 999)}号`,
+    () => `銀座${int(rng, 1, 9)}丁目${int(rng, 1, 20)}番${int(rng, 1, 20)}号`,
+    () => `세종대로 ${int(rng, 1, 500)}`,
+    () => `شارع الملك فهد ${int(rng, 1, 200)}`,
+  ];
+  return pick(rng, shapes)();
+}
+
+/** An in-range coordinate pair, decimal or DMS. */
+export function generateValidCoordinates(seed: number): string {
+  const rng = mulberry32(seed);
+  const lat = (rng() * 178 - 89).toFixed(int(rng, 3, 6));
+  const lon = (rng() * 358 - 179).toFixed(int(rng, 3, 6));
+  if (rng() < 0.6) {
+    return `${lat}, ${lon}`;
+  }
+  const latD = int(rng, 0, 89);
+  const lonD = int(rng, 0, 179);
+  return `${latD}°${int(rng, 0, 59)}′${int(rng, 0, 59)}″${pick(rng, ['N', 'S'])} ${lonD}°${int(rng, 0, 59)}′${int(rng, 0, 59)}″${pick(rng, ['E', 'W'])}`;
+}

package/src/generate/natidAmOc.ts

@@ -0,0 +1,198 @@
+/**
+ * Valid-value generators for W2e national identifiers (Oceania, Americas,
+ * Africa).
+ */
+
+import { luhnCheckDigit, toDigits, weightedSum, weightedMod, weightedModBy } from '../checksums/index.js';
+import { curpCheckDigit } from '../detect/detectors/natid/mx.js';
+import { rutCheckChar } from '../detect/detectors/natid/cl.js';
+import { nitCheckDigit } from '../detect/detectors/natid/co.js';
+import { mulberry32 } from './prng.js';
+
+function pick<T>(rng: () => number, items: readonly T[]): T {
+  return items[Math.floor(rng() * items.length)]!;
+}
+
+function int(rng: () => number, min: number, max: number): number {
+  return min + Math.floor(rng() * (max - min + 1));
+}
+
+function digits(rng: () => number, n: number): string {
+  let out = '';
+  for (let i = 0; i < n; i++) out += String(int(rng, 0, 9));
+  return out;
+}
+
+const pad2 = (n: number): string => String(n).padStart(2, '0');
+
+export function generateValidTfn(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    // Solve the last digit so the weighted sum is divisible by 11.
+    const eight = digits(rng, 8);
+    const partial = weightedSum(toDigits(eight)!, [1, 4, 3, 7, 5, 8, 6, 9])!;
+    // Last weight is 10: need (partial + 10·d) ≡ 0 (mod 11) → d ≡ partial·(10⁻¹≡10)… iterate.
+    for (let d = 0; d <= 9; d++) {
+      if ((partial + 10 * d) % 11 === 0) return `${eight}${d}`;
+    }
+    // No digit closes it (happens when partial ≡ 1 mod 11 needs d=10): redraw.
+  }
+}
+
+export function generateValidMedicare(seed: number): string {
+  const rng = mulberry32(seed);
+  const eight = String(int(rng, 2, 6)) + digits(rng, 7);
+  const check = weightedMod(toDigits(eight)!, [1, 3, 7, 9, 1, 3, 7, 9], 10)!;
+  return `${eight}${check}${int(rng, 1, 9)}`;
+}
+
+export function generateValidAbn(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const body = String(int(rng, 1, 9)) + digits(rng, 9);
+    const adjusted = [Number(body[0]) - 1, ...toDigits(body.slice(1))!];
+    const partial = weightedSum(adjusted, [10, 1, 3, 5, 7, 9, 11, 13, 15, 17])!;
+    for (let d = 0; d <= 9; d++) {
+      if ((partial + 19 * d) % 89 === 0) return `${body}${d}`;
+    }
+  }
+}
+
+export function generateValidIrd(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const value = int(rng, 10_000_000, 150_000_000);
+    const padded = String(value).padStart(9, '0');
+    const payload = toDigits(padded.slice(0, 8))!;
+    const r = weightedMod(payload, [3, 2, 7, 6, 5, 4, 3, 2], 11)!;
+    let check = r === 0 ? 0 : 11 - r;
+    if (check === 10) {
+      const r2 = weightedMod(payload, [7, 4, 3, 2, 5, 2, 7, 6], 11)!;
+      check = r2 === 0 ? 0 : 11 - r2;
+      if (check === 10) continue;
+    }
+    if (check !== Number(padded[8])) continue; // draw a value whose real check matches
+    return String(value);
+  }
+}
+
+function brCheck(ds: readonly number[], start: number): number {
+  const remainder = weightedModBy(ds, (i) => start - i, 11)!;
+  return remainder < 2 ? 0 : 11 - remainder;
+}
+
+export function generateValidCpf(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const nine = digits(rng, 9);
+    if (/^(.)\1+$/.test(nine)) continue;
+    const d = toDigits(nine)!;
+    const c1 = brCheck(d, 10);
+    const c2 = brCheck([...d, c1], 11);
+    return `${nine}${c1}${c2}`;
+  }
+}
+
+export function generateValidCnpj(seed: number): string {
+  const rng = mulberry32(seed);
+  const twelve = digits(rng, 8) + '0001'; // conventional head-office suffix
+  const d = toDigits(twelve)!;
+  const w1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+  const w2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+  const sum1 = d.reduce((acc, digit, i) => acc + digit * w1[i]!, 0);
+  const c1 = sum1 % 11 < 2 ? 0 : 11 - (sum1 % 11);
+  const with13 = [...d, c1];
+  const sum2 = with13.reduce((acc, digit, i) => acc + digit * w2[i]!, 0);
+  const c2 = sum2 % 11 < 2 ? 0 : 11 - (sum2 % 11);
+  return `${twelve}${c1}${c2}`;
+}
+
+const CURP_CONSONANTS = 'BCDFGHJKLMNPQRSTVWXYZ';
+const MX_STATE_POOL = ['DF', 'JC', 'NL', 'MC', 'VZ', 'GT', 'PL', 'SR', 'NE'];
+
+export function generateValidCurp(seed: number): string {
+  const rng = mulberry32(seed);
+  const vowels = 'AEIOU';
+  const seventeen =
+    pick(rng, [...CURP_CONSONANTS]) + pick(rng, [...vowels]) + pick(rng, [...CURP_CONSONANTS]) + pick(rng, [...CURP_CONSONANTS]) +
+    pad2(int(rng, 0, 99)) + pad2(int(rng, 1, 12)) + pad2(int(rng, 1, 28)) +
+    pick(rng, ['H', 'M']) + pick(rng, MX_STATE_POOL) +
+    pick(rng, [...CURP_CONSONANTS]) + pick(rng, [...CURP_CONSONANTS]) + pick(rng, [...CURP_CONSONANTS]) +
+    pick(rng, [...'0123456789A']);
+  return `${seventeen}${curpCheckDigit(seventeen)!}`;
+}
+
+export function generateValidRfc(seed: number): string {
+  const rng = mulberry32(seed);
+  const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let s = '';
+  for (let i = 0; i < 4; i++) s += letters[int(rng, 0, 25)];
+  s += pad2(int(rng, 0, 99)) + pad2(int(rng, 1, 12)) + pad2(int(rng, 1, 28));
+  for (let i = 0; i < 3; i++) s += pick(rng, [...'ABCDEFGHIJKLMNPQRSTUVWXYZ123456789']);
+  return s;
+}
+
+const CUIT_PREFIX_POOL = ['20', '23', '24', '27', '30', '33'];
+
+export function generateValidCuit(seed: number): string {
+  const rng = mulberry32(seed);
+  for (;;) {
+    const ten = pick(rng, CUIT_PREFIX_POOL) + digits(rng, 8);
+    const remainder = weightedMod(toDigits(ten)!, [5, 4, 3, 2, 7, 6, 5, 4, 3, 2], 11)!;
+    let check = 11 - remainder;
+    if (check === 11) check = 0;
+    if (check === 10) continue;
+    return `${ten.slice(0, 2)}-${ten.slice(2)}-${check}`;
+  }
+}
+
+export function generateValidRut(seed: number): string {
+  const rng = mulberry32(seed);
+  const body = String(int(rng, 1_000_000, 25_999_999));
+  const check = rutCheckChar(body)!;
+  const dotted = body.replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+  return `${dotted}-${check}`;
+}
+
+export function generateValidNit(seed: number): string {
+  const rng = mulberry32(seed);
+  const body = String(int(rng, 10_000_000, 999_999_999));
+  return `${body}-${nitCheckDigit(body)!}`;
+}
+
+export function generateValidPeDni(seed: number): string {
+  const rng = mulberry32(seed);
+  return `DNI ${digits(rng, 8)}`;
+}
+
+export function generateValidZaId(seed: number): string {
+  const rng = mulberry32(seed);
+  const payload =
+    pad2(int(rng, 0, 99)) + pad2(int(rng, 1, 12)) + pad2(int(rng, 1, 28)) +
+    String(int(rng, 0, 9999)).padStart(4, '0') + String(int(rng, 0, 2)) + String(int(rng, 0, 9));
+  return `${payload}${luhnCheckDigit(payload)!}`;
+}
+
+export function generateValidNin(seed: number): string {
+  const rng = mulberry32(seed);
+  return `NIN: ${digits(rng, 11)}`;
+}
+
+export function generateValidKeId(seed: number): string {
+  const rng = mulberry32(seed);
+  return `ID No. ${digits(rng, 8)}`;
+}
+
+const EG_GOV_POOL = ['01', '02', '12', '21', '31', '88'];
+
+export function generateValidEgId(seed: number): string {
+  const rng = mulberry32(seed);
+  return `${pick(rng, ['2', '3'])}${pad2(int(rng, 0, 99))}${pad2(int(rng, 1, 12))}${pad2(int(rng, 1, 28))}${pick(rng, EG_GOV_POOL)}${digits(rng, 4)}${int(rng, 0, 9)}`;
+}
+
+export function generateValidCnie(seed: number): string {
+  const rng = mulberry32(seed);
+  const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  const prefix = rng() < 0.5 ? letters[int(rng, 0, 25)]! : letters[int(rng, 0, 25)]! + letters[int(rng, 0, 25)]!;
+  return `CNIE: ${prefix}${digits(rng, 6)}`;
+}