@cyanheads/sanctions-screening-mcp-server 0.1.0

package/dist/services/screening/sanctions-ingest.js

@@ -0,0 +1,688 @@
+/**
+ * @fileoverview Sanctions ingesters — one per source (OFAC SDN, OFAC
+ * Consolidated, EU FSF, UK Sanctions List, UN SC Consolidated). Each fetches the
+ * source file, parses the XML, and maps records onto the common
+ * {@link NormalizedDesignation} schema. The {@link createSanctionsSync} factory
+ * wires them into the MirrorService `sync` generator: each refresh re-harvests
+ * all sources in full (the combined corpus is tens of thousands of rows — no
+ * delta logic needed), yielding one page per source.
+ *
+ * The XML shapes differ wildly across sources; each parser is defensive about
+ * sparsity and arrays-of-one (fast-xml-parser collapses single children to
+ * objects), and preserves absence rather than fabricating fields.
+ * @module services/screening/sanctions-ingest
+ */
+import { serviceUnavailable } from '@cyanheads/mcp-ts-core/errors';
+import { fetchWithTimeout, requestContextService, withRetry } from '@cyanheads/mcp-ts-core/utils';
+import { getServerConfig } from '../../config/server-config.js';
+import { fold } from '../../services/screening/text-matching.js';
+import { parseXml } from '../../services/screening/xml.js';
+/** Browser-style UA — the UN SC domain returns 404 to bare requests. */
+const BROWSER_UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36';
+const FETCH_TIMEOUT_MS = 120_000;
+/** Coerce fast-xml-parser's "single child → object, many → array" into an array. */
+function asArray(value) {
+    if (value == null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+/** Coerce a scalar XML node (string/number/object-with-#text) to a trimmed string. */
+function asText(value) {
+    if (value == null)
+        return;
+    if (typeof value === 'string')
+        return value.trim() || undefined;
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'object' && '#text' in value) {
+        return asText(value['#text']);
+    }
+    return;
+}
+/**
+ * Conditional-spread fragment: `{ [key]: value }` when `value` is defined and
+ * non-empty, else `{}`. Keeps the normalized objects honest under
+ * `exactOptionalPropertyTypes` (absent rather than `undefined`) without a
+ * double `asText` call or a non-null assertion.
+ */
+function opt(key, value) {
+    return value ? { [key]: value } : {};
+}
+/** Fetch text with a browser UA, retry, and HTML-error-page detection. */
+function fetchXml(url, signal, source) {
+    const reqCtx = requestContextService.createRequestContext({ operation: `harvest:${source}` });
+    return withRetry(async () => {
+        const response = await fetchWithTimeout(url, FETCH_TIMEOUT_MS, reqCtx, {
+            signal,
+            headers: { 'User-Agent': BROWSER_UA, Accept: 'application/xml, text/xml, */*' },
+            redirect: 'follow',
+        });
+        const text = await response.text();
+        if (/^\s*<(!DOCTYPE\s+html|html[\s>])/i.test(text)) {
+            throw serviceUnavailable(`${source} returned HTML instead of XML — likely rate-limited.`);
+        }
+        return text;
+    }, { operation: `harvest:${source}`, baseDelayMs: 2000, signal });
+}
+// ─── OFAC (SDN + Consolidated, advanced UN 1267/1988 schema) ────────────────────
+/**
+ * Parse one OFAC advanced-schema `<distinctParty>` (or the standard fallback
+ * `<sdnEntry>`) shape. The advanced schema is the richest; we read the common
+ * fields and keep the rest in `payload`. Robust to the two shapes via duck typing.
+ */
+function buildOfacIngester(source, urlGetter) {
+    return {
+        source,
+        url: urlGetter,
+        async harvest(signal) {
+            const xml = await fetchXml(urlGetter(), signal, source);
+            const doc = parseXml(xml);
+            return parseOfac(doc, source);
+        },
+    };
+}
+export function parseOfac(doc, source) {
+    // Standard schema: <sdnList><sdnEntry>. Advanced: <Sanctions><DistinctParties>.
+    const sdnList = (doc.sdnList ?? doc.SDNList);
+    if (sdnList) {
+        return asArray(sdnList.sdnEntry).map((e) => parseOfacStandard(e, source));
+    }
+    // Advanced schema (the configured default — SDN_ADVANCED.XML / CONS_ADVANCED.XML).
+    const sanctions = (doc.Sanctions ?? doc.sanctions);
+    if (!sanctions)
+        return [];
+    const refs = buildOfacReferenceSets(sanctions);
+    const programsByProfile = buildOfacProgramIndex(sanctions);
+    const parties = sanctions.DistinctParties;
+    return asArray(parties?.DistinctParty)
+        .map((p) => parseOfacAdvanced(p, source, refs, programsByProfile))
+        .filter(Boolean);
+}
+function buildOfacReferenceSets(sanctions) {
+    const sets = (sanctions.ReferenceValueSets ?? {});
+    const aliasType = new Map();
+    for (const a of asArray(sets.AliasTypeValues?.AliasType)) {
+        const id = asText(a['@_ID']);
+        const label = asText(a['#text'] ?? a);
+        if (id && label)
+            aliasType.set(id, label);
+    }
+    const featureType = new Map();
+    for (const f of asArray(sets.FeatureTypeValues?.FeatureType)) {
+        const id = asText(f['@_ID']);
+        const label = asText(f['#text'] ?? f);
+        if (id && label)
+            featureType.set(id, label);
+    }
+    const subTypeToPartyType = new Map();
+    const subTypeLabel = new Map();
+    for (const s of asArray(sets.PartySubTypeValues?.PartySubType)) {
+        const sub = s;
+        const id = asText(sub['@_ID']);
+        if (!id)
+            continue;
+        const partyTypeId = asText(sub['@_PartyTypeID']);
+        if (partyTypeId)
+            subTypeToPartyType.set(id, partyTypeId);
+        const label = asText(sub['#text'] ?? sub);
+        if (label)
+            subTypeLabel.set(id, label);
+    }
+    return { aliasType, featureType, subTypeToPartyType, subTypeLabel };
+}
+/**
+ * Build a `profileId → { program, designationDate }` index from the advanced
+ * schema's `<SanctionsEntries>`. The programme name is published as a
+ * `<SanctionsMeasure><Comment>` and the designation date as the `<EntryEvent>`
+ * `<Date>` (Year/Month/Day elements). Keyed by `ProfileID` (== the DistinctParty
+ * `FixedRef`).
+ */
+function buildOfacProgramIndex(sanctions) {
+    const out = new Map();
+    const entries = (sanctions.SanctionsEntries ?? {});
+    for (const raw of asArray(entries.SanctionsEntry)) {
+        const e = raw;
+        const profileId = asText(e['@_ProfileID']);
+        if (!profileId)
+            continue;
+        const programs = asArray(e.SanctionsMeasure)
+            .map((m) => asText(m.Comment))
+            .filter((x) => Boolean(x));
+        const event = (e.EntryEvent ?? {});
+        const designationDate = composeOfacDate(event.Date);
+        const existing = out.get(profileId) ?? {};
+        out.set(profileId, {
+            ...existing,
+            ...(programs.length ? { program: programs.join(', ') } : {}),
+            ...(designationDate ? { designationDate } : {}),
+        });
+    }
+    return out;
+}
+/** Compose an OFAC `<Date><Year>/<Month>/<Day></Date>` node into an ISO-ish string. */
+function composeOfacDate(date) {
+    if (!date)
+        return;
+    const y = asText(date.Year);
+    if (!y)
+        return;
+    const m = asText(date.Month);
+    const d = asText(date.Day);
+    if (m && d)
+        return `${y}-${m.padStart(2, '0')}-${d.padStart(2, '0')}`;
+    if (m)
+        return `${y}-${m.padStart(2, '0')}`;
+    return y;
+}
+function parseOfacStandard(e, source) {
+    const uid = asText(e.uid) ?? crypto.randomUUID();
+    const first = asText(e.firstName);
+    const last = asText(e.lastName);
+    const sdnType = asText(e.sdnType)?.toLowerCase();
+    const primaryName = [first, last].filter(Boolean).join(' ').trim() || last || first || 'Unknown';
+    const aliases = asArray(e.akaList?.aka)
+        .map((aka) => {
+        const a = aka;
+        const an = [asText(a.firstName), asText(a.lastName)].filter(Boolean).join(' ').trim();
+        const category = asText(a.category)?.toLowerCase();
+        return {
+            name: an || asText(a.lastName) || '',
+            nameType: category === 'weak' ? 'low-quality-aka' : 'aka',
+        };
+    })
+        .filter((a) => a.name);
+    const identifiers = asArray(e.idList?.id)
+        .map((id) => {
+        const i = id;
+        return {
+            type: asText(i.idType) ?? 'ID',
+            value: asText(i.idNumber) ?? '',
+            ...opt('country', asText(i.idCountry)),
+        };
+    })
+        .filter((i) => i.value);
+    const addresses = asArray(e.addressList?.address)
+        .map((addr) => {
+        const a = addr;
+        const parts = [
+            asText(a.address1),
+            asText(a.address2),
+            asText(a.city),
+            asText(a.stateOrProvince),
+            asText(a.postalCode),
+            asText(a.country),
+        ].filter(Boolean);
+        return {
+            full: parts.join(', '),
+            ...opt('country', asText(a.country)),
+        };
+    })
+        .filter((a) => a.full);
+    const dobs = asArray(e.dateOfBirthList?.dateOfBirthItem)
+        .map((d) => {
+        const dd = d;
+        return opt('date', asText(dd.dateOfBirth));
+    })
+        .filter((d) => d.date);
+    const nationalities = asArray(e.nationalityList?.nationality)
+        .map((n) => asText(n.country))
+        .filter((x) => Boolean(x));
+    const remarks = asText(e.remarks);
+    const designationDate = remarks ? extractDateFromRemarks(remarks) : undefined;
+    return {
+        id: `${source}:${uid}`,
+        source,
+        sourceEntryId: uid,
+        entityType: mapOfacType(sdnType),
+        primaryName,
+        ...opt('program', asText(e.program)),
+        ...(designationDate ? { designationDate } : {}),
+        payload: {
+            aliases,
+            identifiers,
+            addresses,
+            datesOfBirth: dobs,
+            nationalities,
+            ...opt('remarks', remarks),
+        },
+    };
+}
+/**
+ * Parse one advanced-schema `<DistinctParty>`. With attributes available this
+ * reads the stable `FixedRef` entry id, the entity type (via `PartySubTypeID` →
+ * `PartyType`), the primary name and typed aliases (via `AliasTypeID` /
+ * `LowQuality`), and dates/places of birth (via `Feature` type ids). The
+ * programme + designation date come from the `<SanctionsEntries>` index, keyed by
+ * profile id. Resilient to the deep nesting and to sparse records.
+ */
+function parseOfacAdvanced(p, source, refs, programsByProfile) {
+    const profile = (p.Profile ?? p.profile);
+    const id = asText(p['@_FixedRef']) ?? asText(p['@_ID']) ?? crypto.randomUUID();
+    const collected = [];
+    for (const ident of asArray((profile?.Identity ?? profile?.identity))) {
+        for (const aliasRaw of asArray(ident.Alias)) {
+            const alias = aliasRaw;
+            const aliasLabel = refs.aliasType.get(asText(alias['@_AliasTypeID']) ?? '');
+            const lowQuality = asText(alias['@_LowQuality']) === 'true';
+            const aliasPrimary = asText(alias['@_Primary']) === 'true';
+            for (const dn of asArray(alias.DocumentedName)) {
+                const parts = asArray(dn.DocumentedNamePart)
+                    .map((np) => asText(np.NamePartValue?.['#text'] ?? np.NamePartValue))
+                    .filter(Boolean);
+                const name = parts.join(' ').trim();
+                if (!name)
+                    continue;
+                collected.push({
+                    name,
+                    isPrimary: aliasPrimary,
+                    nameType: ofacAliasNameType(aliasLabel, lowQuality, aliasPrimary),
+                });
+            }
+        }
+    }
+    const firstName = collected[0];
+    if (!firstName)
+        return null;
+    // Primary = the alias flagged Primary (AliasTypeID 1403 "Name"); fall back to first.
+    const primaryEntry = collected.find((n) => n.isPrimary) ?? firstName;
+    const aliases = collected
+        .filter((n) => n !== primaryEntry)
+        .map((n) => ({ name: n.name, nameType: n.nameType }));
+    const { datesOfBirth, placesOfBirth } = extractOfacFeatures(profile, refs);
+    const program = programsByProfile.get(id);
+    return {
+        id: `${source}:${id}`,
+        source,
+        sourceEntryId: id,
+        entityType: mapOfacPartySubType(asText(profile?.['@_PartySubTypeID']), refs),
+        primaryName: primaryEntry.name,
+        ...(program?.program ? { program: program.program } : {}),
+        ...(program?.designationDate ? { designationDate: program.designationDate } : {}),
+        payload: {
+            aliases,
+            identifiers: [],
+            addresses: [],
+            datesOfBirth: datesOfBirth.length || placesOfBirth.length ? mergeDobPob(datesOfBirth, placesOfBirth) : [],
+            nationalities: [],
+        },
+    };
+}
+/** Map an advanced-schema alias to a normalized name type. */
+function ofacAliasNameType(aliasLabel, lowQuality, isPrimary) {
+    if (isPrimary)
+        return 'primary';
+    if (lowQuality)
+        return 'low-quality-aka';
+    const label = aliasLabel?.toUpperCase().replace(/\./g, '');
+    if (label === 'FKA')
+        return 'fka';
+    return 'aka';
+}
+/**
+ * Map an advanced-schema `PartySubTypeID` to a coarse entity type. Vessel and
+ * Aircraft are explicit sub-types; otherwise the parent `PartyType` distinguishes
+ * Individual (person) from Entity (organization).
+ */
+function mapOfacPartySubType(subTypeId, refs) {
+    if (!subTypeId)
+        return 'unknown';
+    const subLabel = refs.subTypeLabel.get(subTypeId)?.toLowerCase();
+    if (subLabel === 'vessel')
+        return 'vessel';
+    if (subLabel === 'aircraft')
+        return 'aircraft';
+    const partyType = refs.subTypeToPartyType.get(subTypeId);
+    if (partyType === '1')
+        return 'person';
+    if (partyType === '2' || partyType === '5')
+        return 'organization';
+    if (partyType === '4')
+        return 'vessel'; // Transport without a specific sub-type
+    return 'unknown';
+}
+/** Birthdate / place-of-birth feature values pulled from a profile's `<Feature>`s. */
+function extractOfacFeatures(profile, refs) {
+    const datesOfBirth = [];
+    const placesOfBirth = [];
+    for (const featRaw of asArray(profile?.Feature)) {
+        const feat = featRaw;
+        const label = refs.featureType.get(asText(feat['@_FeatureTypeID']) ?? '')?.toLowerCase();
+        if (label === 'birthdate') {
+            const date = ofacFeatureDate(feat);
+            if (date)
+                datesOfBirth.push(date);
+        }
+        else if (label === 'place of birth') {
+            const place = asText(feat.FeatureVersion?.VersionLocation);
+            // Place often lives as free text in the VersionDetail; capture what's there.
+            const detail = asText(feat.FeatureVersion?.VersionDetail?.['#text'] ?? feat.FeatureVersion?.VersionDetail);
+            const pob = detail ?? place;
+            if (pob)
+                placesOfBirth.push(pob);
+        }
+    }
+    return { datesOfBirth, placesOfBirth };
+}
+/** Pull an ISO-ish birthdate out of a `<Feature>`'s nested `DatePeriod`. */
+function ofacFeatureDate(feat) {
+    const version = (feat.FeatureVersion ?? {});
+    const period = (version.DatePeriod ?? {});
+    const start = (period.Start ?? {});
+    const from = (start.From ?? {});
+    return composeOfacDate(from);
+}
+/** Zip parallel DOB and POB lists into DobRecords (best-effort pairing by index). */
+function mergeDobPob(dates, places) {
+    const len = Math.max(dates.length, places.length);
+    const out = [];
+    for (let i = 0; i < len; i++) {
+        out.push({ ...opt('date', dates[i]), ...opt('place', places[i]) });
+    }
+    return out.filter((d) => d.date || d.place);
+}
+function mapOfacType(t) {
+    switch (t) {
+        case 'individual':
+            return 'person';
+        case 'entity':
+            return 'organization';
+        case 'vessel':
+            return 'vessel';
+        case 'aircraft':
+            return 'aircraft';
+        default:
+            return 'unknown';
+    }
+}
+/** OFAC remarks embed the designation date; pull an ISO-ish date if present. */
+function extractDateFromRemarks(remarks) {
+    const m = remarks.match(/(\d{1,2}\s+\w+\s+\d{4})|(\d{4}-\d{2}-\d{2})/);
+    return m ? m[0] : undefined;
+}
+// ─── EU (xmlFullSanctionsList_1_1) ──────────────────────────────────────────────
+function buildEuIngester() {
+    return {
+        source: 'eu',
+        url: () => getServerConfig().euFsfUrl,
+        async harvest(signal) {
+            const xml = await fetchXml(getServerConfig().euFsfUrl, signal, 'eu');
+            const doc = parseXml(xml);
+            return parseEu(doc);
+        },
+    };
+}
+export function parseEu(doc) {
+    const root = (doc.export ?? doc);
+    const entities = asArray((root.sanctionEntity ?? root.SanctionEntity));
+    return entities
+        .map((raw) => {
+        const e = raw;
+        const id = asText(e['@_logicalId']) ?? asText(e['@_euReferenceNumber']) ?? crypto.randomUUID();
+        const subjectType = e.subjectType?.['@_code'];
+        const nameAliases = asArray(e.nameAlias)
+            .map((n) => {
+            const na = n;
+            const whole = asText(na['@_wholeName']);
+            const strong = asText(na['@_strong']);
+            return {
+                name: whole ??
+                    [asText(na['@_firstName']), asText(na['@_lastName'])].filter(Boolean).join(' '),
+                strong: strong !== 'false',
+            };
+        })
+            .filter((n) => n.name);
+        const primary = nameAliases[0]?.name;
+        if (!primary)
+            return null;
+        const birthdates = asArray(e.birthdate)
+            .map((b) => asText(b['@_birthdate']))
+            .filter((x) => Boolean(x));
+        const citizenships = asArray(e.citizenship)
+            .map((c) => asText(c['@_countryDescription']))
+            .filter((x) => Boolean(x));
+        return {
+            id: `eu:${id}`,
+            source: 'eu',
+            sourceEntryId: id,
+            entityType: mapEuType(asText(subjectType)),
+            primaryName: primary,
+            ...opt('program', asText(e.regulation?.['@_programme'])),
+            ...opt('designationDate', asText(e.regulation?.['@_publicationDate'])),
+            payload: {
+                aliases: nameAliases.slice(1).map((n) => ({
+                    name: n.name,
+                    nameType: (n.strong ? 'aka' : 'low-quality-aka'),
+                })),
+                identifiers: [],
+                addresses: [],
+                datesOfBirth: birthdates.map((d) => ({ date: d })),
+                nationalities: citizenships,
+            },
+        };
+    })
+        .filter(Boolean);
+}
+function mapEuType(code) {
+    if (code === 'P' || code?.toLowerCase() === 'person')
+        return 'person';
+    if (code === 'E' || code?.toLowerCase() === 'enterprise')
+        return 'organization';
+    return 'unknown';
+}
+// ─── UK Sanctions List (UKSL, FCDO) ─────────────────────────────────────────────
+function buildUkIngester() {
+    return {
+        source: 'uk',
+        url: () => getServerConfig().ukSanctionsUrl,
+        async harvest(signal) {
+            const xml = await fetchXml(getServerConfig().ukSanctionsUrl, signal, 'uk');
+            const doc = parseXml(xml);
+            return parseUk(doc);
+        },
+    };
+}
+export function parseUk(doc) {
+    // UKSL XML root is <Sanctions...><Designations><Designation>. Famously messy;
+    // be defensive about every field.
+    const root = (doc.Designations ?? doc.UKSanctionsList ?? doc);
+    const designations = asArray((root.Designation ?? root.designation));
+    const list = designations.length
+        ? designations
+        : asArray(doc.Designations
+            ?.Designation);
+    return list
+        .map((raw) => {
+        const d = raw;
+        const id = asText(d.UniqueID) ??
+            asText(d.OFSIGroupID) ??
+            asText(d['@_UniqueID']) ??
+            crypto.randomUUID();
+        const names = asArray(d.Names?.Name)
+            .map((n) => {
+            const nm = n;
+            const parts = [
+                asText(nm.Name1),
+                asText(nm.Name2),
+                asText(nm.Name3),
+                asText(nm.Name4),
+                asText(nm.Name5),
+                asText(nm.Name6),
+            ].filter(Boolean);
+            const whole = asText(nm.NameType) && parts.length
+                ? parts.join(' ')
+                : (asText(nm.WholeName) ?? parts.join(' '));
+            return { name: whole, type: asText(nm.NameType) };
+        })
+            .filter((n) => Boolean(n.name));
+        const fallbackName = asText(d.Name) ?? asText(d.Names?.WholeName);
+        const allNames = names.length
+            ? names
+            : fallbackName
+                ? [{ name: fallbackName, type: 'Primary name' }]
+                : [];
+        const primary = allNames[0]?.name;
+        if (!primary)
+            return null;
+        return {
+            id: `uk:${id}`,
+            source: 'uk',
+            sourceEntryId: id,
+            entityType: mapUkType(asText(d.IndividualEntityShip ?? d.GroupType)),
+            primaryName: primary,
+            ...opt('program', asText(d.RegimeName)),
+            ...opt('designationDate', asText(d.DateDesignated ?? d.LastUpdated)),
+            payload: {
+                aliases: allNames.slice(1).map((n) => ({
+                    name: n.name,
+                    nameType: 'aka',
+                })),
+                identifiers: [],
+                addresses: [],
+                datesOfBirth: [],
+                nationalities: asArray(d.Nationalities?.Nationality)
+                    .map((x) => asText(x))
+                    .filter((x) => Boolean(x)),
+                ...opt('remarks', asText(d.OtherInformation)),
+            },
+        };
+    })
+        .filter(Boolean);
+}
+function mapUkType(t) {
+    const v = t?.toLowerCase();
+    if (v === 'individual' || v === 'person')
+        return 'person';
+    if (v === 'entity' || v === 'organisation' || v === 'organization')
+        return 'organization';
+    if (v === 'ship' || v === 'vessel')
+        return 'vessel';
+    return 'unknown';
+}
+// ─── UN Security Council Consolidated List ───────────────────────────────────────
+function buildUnIngester() {
+    return {
+        source: 'un',
+        url: () => getServerConfig().unScUrl,
+        async harvest(signal) {
+            const xml = await fetchXml(getServerConfig().unScUrl, signal, 'un');
+            const doc = parseXml(xml);
+            return parseUn(doc);
+        },
+    };
+}
+export function parseUn(doc) {
+    const root = (doc.CONSOLIDATED_LIST ?? doc);
+    const individuals = asArray(root.INDIVIDUALS?.INDIVIDUAL).map((i) => parseUnEntry(i, 'person'));
+    const entities = asArray(root.ENTITIES?.ENTITY).map((e) => parseUnEntry(e, 'organization'));
+    return [...individuals, ...entities].filter(Boolean);
+}
+function parseUnEntry(e, entityType) {
+    const id = asText(e.DATAID) ?? asText(e.REFERENCE_NUMBER) ?? crypto.randomUUID();
+    const nameParts = [
+        asText(e.FIRST_NAME),
+        asText(e.SECOND_NAME),
+        asText(e.THIRD_NAME),
+        asText(e.FOURTH_NAME),
+    ].filter(Boolean);
+    const primary = entityType === 'organization'
+        ? (asText(e.FIRST_NAME) ?? nameParts.join(' '))
+        : nameParts.join(' ');
+    if (!primary)
+        return null;
+    const aliases = asArray(e.INDIVIDUAL_ALIAS ?? e.ENTITY_ALIAS)
+        .map((a) => {
+        const al = a;
+        const quality = asText(al.QUALITY)?.toLowerCase();
+        return {
+            name: asText(al.ALIAS_NAME) ?? '',
+            nameType: (quality === 'low' ? 'low-quality-aka' : 'aka'),
+        };
+    })
+        .filter((a) => a.name);
+    const dobs = asArray(e.INDIVIDUAL_DATE_OF_BIRTH)
+        .map((d) => {
+        const dd = d;
+        return opt('date', asText(dd.DATE) ?? asText(dd.YEAR));
+    })
+        .filter((d) => d.date);
+    const nationalities = asArray(e.NATIONALITY?.VALUE)
+        .map((v) => asText(v))
+        .filter((x) => Boolean(x));
+    return {
+        id: `un:${id}`,
+        source: 'un',
+        sourceEntryId: id,
+        entityType,
+        primaryName: primary,
+        ...opt('program', asText(e.UN_LIST_TYPE)),
+        ...opt('designationDate', asText(e.LISTED_ON)),
+        payload: {
+            aliases,
+            identifiers: asArray(e.INDIVIDUAL_DOCUMENT)
+                .map((d) => {
+                const dd = d;
+                return {
+                    type: asText(dd.TYPE_OF_DOCUMENT) ?? 'Document',
+                    value: asText(dd.NUMBER) ?? '',
+                    ...opt('country', asText(dd.ISSUING_COUNTRY)),
+                };
+            })
+                .filter((x) => x.value),
+            addresses: [],
+            datesOfBirth: dobs,
+            nationalities,
+            ...opt('remarks', asText(e.COMMENTS1)),
+        },
+    };
+}
+// ─── Registry + sync factory ─────────────────────────────────────────────────
+/** All five sanctions ingesters, configured from the current server config. */
+export function buildSanctionsIngesters() {
+    const cfg = getServerConfig();
+    return [
+        buildOfacIngester('ofac_sdn', () => cfg.ofacSdnUrl),
+        buildOfacIngester('ofac_consolidated', () => cfg.ofacConsolidatedUrl),
+        buildEuIngester(),
+        buildUkIngester(),
+        buildUnIngester(),
+    ];
+}
+/**
+ * The MirrorService `sync` generator for the sanctions designation mirror. Each
+ * run harvests every source in full and yields one page per source. The mirror
+ * upserts the `designation` rows; the per-alias `name` index is rebuilt from
+ * `designation.payload` after the sync by the service's `rebuildNameIndex()`
+ * (the lifecycle scripts and the refresh cron call it). `init` and `refresh`
+ * behave identically — these are small, fully re-harvested corpora.
+ */
+export function createSanctionsSync() {
+    return async function* sync(ctx) {
+        const ingesters = buildSanctionsIngesters();
+        const stamp = new Date().toISOString();
+        for (const ingester of ingesters) {
+            if (ctx.signal.aborted)
+                return;
+            const designations = await ingester.harvest(ctx.signal);
+            yield {
+                records: designations.map(toDesignationRow),
+                checkpoint: stamp,
+            };
+        }
+    };
+}
+/** Map a normalized designation to its primary-table row (no aux fields). */
+export function toDesignationRow(d) {
+    return {
+        id: d.id,
+        source: d.source,
+        source_entry_id: d.sourceEntryId,
+        entity_type: d.entityType,
+        primary_name: d.primaryName,
+        normalized_name: fold(d.primaryName),
+        program: d.program ?? null,
+        legal_basis: d.legalBasis ?? null,
+        designation_date: d.designationDate ?? null,
+        payload: JSON.stringify(d.payload),
+    };
+}
+//# sourceMappingURL=sanctions-ingest.js.map