@inflexa-ai/harness 0.35.8 → 0.36.0

package/dist/workflows/target-assessment/lib/clinical-evidence-attribution.js

@@ -1,152 +0,0 @@
-function normalize(text) {
-    return text
-        .toUpperCase()
-        .replace(/[^A-Z0-9]+/g, " ")
-        .trim();
-}
-function tokenMatch(haystack, needle) {
-    const h = ` ${normalize(haystack)} `;
-    const n = normalize(needle);
-    if (!n)
-        return false;
-    return h.includes(` ${n} `);
-}
-function trialText(trial) {
-    return [
-        trial.title,
-        trial.officialTitle,
-        ...(trial.conditions ?? []),
-        ...(trial.interventions ?? []),
-        ...(trial.interventionDetails ?? []).flatMap((i) => [i.name, i.description, ...(i.otherNames ?? [])]),
-        trial.briefSummary,
-        trial.detailedDescription,
-    ]
-        .filter((v) => typeof v === "string" && v.length > 0)
-        .join(" ");
-}
-function interventionDetails(trial) {
-    if (trial.interventionDetails && trial.interventionDetails.length > 0) {
-        return trial.interventionDetails;
-    }
-    return (trial.interventions ?? []).map((name) => ({
-        name,
-        type: null,
-        description: null,
-        otherNames: [],
-    }));
-}
-function toResolvedIntervention(intervention, source, extras = {}) {
-    return {
-        name: intervention.name,
-        intervention_type: intervention.type ?? null,
-        target_uniprots: extras.target_uniprots ?? [],
-        resolver_source: source,
-        ...extras,
-    };
-}
-function isDiagnosticOrBiomarkerOnly(trial) {
-    const details = interventionDetails(trial);
-    const hasOnlyDiagnostic = details.length > 0 && details.every((i) => ["DIAGNOSTIC_TEST", "OTHER", "PROCEDURE"].includes(String(i.type ?? "").toUpperCase()));
-    const design = `${trial.studyType ?? ""} ${trial.primaryPurpose ?? ""}`.toUpperCase();
-    return hasOnlyDiagnostic || /\bOBSERVATIONAL\b|\bBASIC_SCIENCE\b/.test(design);
-}
-function targetBiomarkerMention(trial, symbol) {
-    const text = normalize(trialText(trial));
-    const sym = normalize(symbol);
-    if (!sym)
-        return false;
-    const wrapped = ` ${text} `;
-    return wrapped.includes(` ${sym} `) || wrapped.includes(`S ${sym} `) || wrapped.includes(` ${sym} LEVEL`) || wrapped.includes(` ${sym} CONCENTRATION`);
-}
-function excluded(relationship, reason, basisKind, source, resolved_interventions) {
-    return {
-        eligible_for_toxicology_aggregation: false,
-        attribution: {
-            relationship,
-            evidence_role: relationship === "target_biomarker" || relationship === "pathway_biomarker" ? "contextual" : "excluded",
-            basis: [{ kind: basisKind, source }],
-            resolved_interventions,
-            exclusion_reason: reason,
-        },
-    };
-}
-export function classifyClinicalEvidenceTrial(trial, ctx) {
-    const details = interventionDetails(trial);
-    for (const program of ctx.therapeuticPrograms) {
-        const matchesProgram = (program.nctIds ?? []).includes(trial.nctId) ||
-            details.some((i) => tokenMatch(i.name, program.name) || (i.otherNames ?? []).some((alias) => tokenMatch(alias, program.name))) ||
-            tokenMatch(trial.title, program.name);
-        const hitsTarget = normalize(program.targetSymbol) === normalize(ctx.assessmentSymbol) || program.targetUniprot === ctx.assessmentUniprot;
-        if (matchesProgram && hitsTarget) {
-            const matched = details.find((i) => tokenMatch(i.name, program.name)) ??
-                details[0] ?? {
-                name: program.name,
-                type: null,
-                description: null,
-                otherNames: [],
-            };
-            return {
-                eligible_for_toxicology_aggregation: true,
-                attribution: {
-                    relationship: "direct_modulator",
-                    evidence_role: "supports_target",
-                    basis: [
-                        {
-                            kind: "therapeutic_program_match",
-                            source: "therapeutic_programs",
-                            excerpt: `${program.name} targets ${program.targetSymbol}`,
-                        },
-                    ],
-                    resolved_interventions: [
-                        toResolvedIntervention(matched, "therapeutic_programs", {
-                            therapeutic_program_id: program.programId,
-                            target_uniprots: program.targetUniprot ? [program.targetUniprot] : [],
-                        }),
-                    ],
-                },
-            };
-        }
-    }
-    for (const intervention of details) {
-        const candidates = [intervention.name, ...(intervention.otherNames ?? [])];
-        const matchedDrug = ctx.knownClassDrugs.find((drug) => candidates.some((candidate) => tokenMatch(candidate, drug.name)));
-        if (!matchedDrug)
-            continue;
-        const targetUniprots = matchedDrug.targetUniprots ?? [];
-        if (targetUniprots.includes(ctx.assessmentUniprot)) {
-            return {
-                eligible_for_toxicology_aggregation: true,
-                attribution: {
-                    relationship: "class_modulator",
-                    evidence_role: "supports_target",
-                    basis: [{ kind: "known_class_drug", source: "chembl" }],
-                    resolved_interventions: [
-                        toResolvedIntervention(intervention, "chembl", {
-                            chembl_id: matchedDrug.moleculeChemblId ?? null,
-                            target_uniprots: targetUniprots,
-                        }),
-                    ],
-                },
-            };
-        }
-        if (targetUniprots.some((u) => ctx.familyUniprots.includes(u))) {
-            return excluded("related_family_target", "Intervention targets a related family receptor, not the assessed target.", "related_family_target", "chembl", [
-                toResolvedIntervention(intervention, "chembl", {
-                    chembl_id: matchedDrug.moleculeChemblId ?? null,
-                    target_uniprots: targetUniprots,
-                }),
-            ]);
-        }
-    }
-    if (targetBiomarkerMention(trial, ctx.assessmentSymbol)) {
-        const resolved = details.map((i) => toResolvedIntervention(i, "ctgov"));
-        return excluded("target_biomarker", isDiagnosticOrBiomarkerOnly(trial)
-            ? "Target is used as a biomarker or diagnostic endpoint, not as a therapeutic intervention."
-            : "Target is mentioned in biomarker/outcome context without target-modulating intervention evidence.", "biomarker_endpoint", "ctgov", resolved);
-    }
-    const conditionOnly = (trial.conditions ?? []).some((c) => tokenMatch(c, ctx.assessmentSymbol));
-    if (conditionOnly) {
-        return excluded("condition_only", "Trial matched only by condition text and has no target-modulating intervention evidence.", "condition_only", "ctgov", details.map((i) => toResolvedIntervention(i, "ctgov")));
-    }
-    return excluded("unrelated", "No intervention or mechanism evidence links this trial to the assessed target.", "text_match", "ctgov", details.map((i) => toResolvedIntervention(i, "ctgov")));
-}

package/dist/workflows/target-assessment/lib/compute-derived.d.ts

@@ -1,20 +0,0 @@
-import type { Derived } from "@inflexa-ai/harness/contracts/target-dossier.js";
-import { type OrganSystem } from "../../../contracts/organ-system.js";
-/**
- * Derive the set of organs that should appear in the organ rollup based on
- * available safety signals (FAERS top signals, serious trial AEs, and
- * off-target panel entries).
- *
- * Exported so the Phase-4 assembler can call the same logic when building
- * organ_rollup rows — ensuring the set of "expected" organs is identical at
- * assembly time and at derived-validation time.
- */
-export declare function expectedOrgansFromBody(bodyInput: unknown): OrganSystem[];
-/**
- * Build the derived sub-tree from a raw dossier body.
- *
- * Pure function: no I/O, no LLM calls, no side effects. Defensive against
- * missing/partial bodies — always returns a best-effort result and never throws.
- * Schema validation happens at the persist boundary, not here.
- */
-export declare function computeDerivedFields(bodyInput: unknown): Derived;

package/dist/workflows/target-assessment/lib/compute-derived.js

@@ -1,261 +0,0 @@
-import { ORGAN_SYSTEMS } from "../../../contracts/organ-system.js";
-import { classifyOrgan, classifyTrialAe } from "./meddra-organ-map.js";
-import { HIGH_EXPRESSION_TPM_THRESHOLD } from "./expression-constants.js";
-const FAERS_TOP_SIGNAL_THRESHOLD = 1000;
-const ORGAN_SYSTEM_SET = new Set(ORGAN_SYSTEMS);
-/**
- * The body arrives here unvalidated, so an organ token is checked against the
- * vocabulary before it is carried into the derived sub-tree.
- */
-function isOrganSystem(value) {
-    return typeof value === "string" && ORGAN_SYSTEM_SET.has(value);
-}
-/**
- * Derive the set of organs that should appear in the organ rollup based on
- * available safety signals (FAERS top signals, serious trial AEs, and
- * off-target panel entries).
- *
- * Exported so the Phase-4 assembler can call the same logic when building
- * organ_rollup rows — ensuring the set of "expected" organs is identical at
- * assembly time and at derived-validation time.
- */
-export function expectedOrgansFromBody(bodyInput) {
-    const body = bodyInput;
-    const expected = new Set();
-    const top = body?.safety_profile?.faers?.data?.top_signals ?? [];
-    for (const sig of top) {
-        if (sig.report_count >= FAERS_TOP_SIGNAL_THRESHOLD) {
-            const organ = classifyOrgan(sig.meddra_term);
-            if (organ)
-                expected.add(organ);
-        }
-    }
-    const serious = body?.safety_profile?.trial_aes?.data?.serious ?? [];
-    for (const ae of serious) {
-        const organ = classifyTrialAe(ae);
-        if (organ)
-            expected.add(organ);
-    }
-    const offTargets = body?.safety_profile?.off_target_panel?.data?.rows ?? [];
-    for (const r of offTargets) {
-        if (r.organ_system && isOrganSystem(r.organ_system))
-            expected.add(r.organ_system);
-    }
-    return [...expected].sort();
-}
-function presentOrgans(body) {
-    const rows = body?.safety_profile?.organ_rollup?.data?.rows ?? [];
-    return rows
-        .map((r) => r.organ)
-        .filter(isOrganSystem)
-        .sort();
-}
-function countDistinctPapers(body) {
-    const set = new Set();
-    const keyPapers = body?.reference_biology?.key_papers?.data?.rows ?? [];
-    for (const p of keyPapers)
-        if (p.pmid)
-            set.add(String(p.pmid));
-    return set.size;
-}
-function countDistinctTrials(body) {
-    const set = new Set();
-    // Ineligible trials are partitioned into `excluded_rows`, so the distinct
-    // count must union both buckets for trials, failed_trials, and
-    // discovery_trials. Outcomes preserves every row in `rows` and has no
-    // `excluded_rows` bucket.
-    const partitioned = [body?.clinical_development?.trials?.data, body?.clinical_development?.failed_trials?.data, body?.analytics?.discovery_trials?.data];
-    for (const data of partitioned) {
-        for (const bucket of ["rows", "excluded_rows"]) {
-            for (const r of data?.[bucket] ?? []) {
-                if (r.nct_id)
-                    set.add(String(r.nct_id));
-            }
-        }
-    }
-    for (const r of body?.clinical_development?.outcomes?.data?.rows ?? []) {
-        if (r.nct_id)
-            set.add(String(r.nct_id));
-    }
-    return set.size;
-}
-// Walk the entire body tree counting all `evidence` array entries to produce
-// a total evidence item count. This is intentionally recursive and treats every
-// nested `evidence` array as contributing to the total.
-function countTotalEvidenceItems(body) {
-    let total = 0;
-    const walk = (v) => {
-        if (Array.isArray(v)) {
-            for (const item of v)
-                walk(item);
-        }
-        else if (v && typeof v === "object") {
-            const node = v;
-            if (Array.isArray(node.evidence))
-                total += node.evidence.length;
-            for (const k of Object.keys(v))
-                walk(node[k]);
-        }
-    };
-    walk(body);
-    return total;
-}
-function hasHumanEvidence(body) {
-    let found = false;
-    const walk = (v) => {
-        if (found)
-            return;
-        if (Array.isArray(v)) {
-            for (const item of v)
-                walk(item);
-        }
-        else if (v && typeof v === "object") {
-            const node = v;
-            if (node.has_human_evidence === true || node.is_human === true) {
-                found = true;
-                return;
-            }
-            for (const k of Object.keys(v))
-                walk(node[k]);
-        }
-    };
-    walk(body);
-    return found;
-}
-function hasClinicalEvidence(body) {
-    let found = false;
-    const walk = (v) => {
-        if (found)
-            return;
-        if (Array.isArray(v)) {
-            for (const item of v)
-                walk(item);
-        }
-        else if (v && typeof v === "object") {
-            const node = v;
-            if (node.has_clinical_evidence === true || node.is_clinical === true) {
-                found = true;
-                return;
-            }
-            for (const k of Object.keys(v))
-                walk(node[k]);
-        }
-    };
-    walk(body);
-    return found;
-}
-function highestRiskOrgan(body) {
-    const rows = body?.safety_profile?.organ_rollup?.data?.rows ?? [];
-    const high = rows.find((r) => r.risk_level === "high");
-    if (high)
-        return high.organ;
-    const med = rows.find((r) => r.risk_level === "medium");
-    if (med)
-        return med.organ;
-    return null;
-}
-function topIndicationSummary(body) {
-    const rows = body?.indications?.coverage === "available" ? (body.indications?.data?.rows ?? []) : [];
-    if (rows.length === 0) {
-        return { highest_score: null, strongest_strength_label: null, highest_score_is_conflicted: false };
-    }
-    let top = null;
-    for (const r of rows) {
-        if (typeof r.composite_score !== "number")
-            continue;
-        if (!top || r.composite_score > top.composite_score)
-            top = r;
-    }
-    if (!top) {
-        return { highest_score: null, strongest_strength_label: null, highest_score_is_conflicted: false };
-    }
-    const conflicted = Array.isArray(top.evidence) ? top.evidence.some((e) => e?.predicate === "direction_mismatch") : false;
-    return {
-        highest_score: top.composite_score ?? null,
-        strongest_strength_label: top.disease_name ?? null,
-        highest_score_is_conflicted: conflicted,
-    };
-}
-// Count distinct high-expression tissues across the human protein atlas consensus
-// (normal_tissue_expression, keyed as "human") and the cross-species expression
-// heatmap. Deduplication uses `${tissue}::${species}` pairs so the same tissue
-// in different species counts as separate entries.
-function countHighExpressionTissues(body) {
-    const set = new Set();
-    const consensusRows = body?.reference_biology?.normal_tissue_expression?.data?.rows ?? [];
-    for (const r of consensusRows) {
-        if ((r.value ?? 0) >= HIGH_EXPRESSION_TPM_THRESHOLD && r.tissue) {
-            set.add(`${r.tissue}::human`);
-        }
-    }
-    const heatmapCells = body?.reference_biology?.preclinical?.expression_heatmap?.data?.cells ?? [];
-    for (const c of heatmapCells) {
-        if (c.rank === "high" && c.tissue) {
-            const species = c.species ?? "unknown";
-            set.add(`${c.tissue}::${species}`);
-        }
-    }
-    return set.size;
-}
-/**
- * Build the derived sub-tree from a raw dossier body.
- *
- * Pure function: no I/O, no LLM calls, no side effects. Defensive against
- * missing/partial bodies — always returns a best-effort result and never throws.
- * Schema validation happens at the persist boundary, not here.
- */
-export function computeDerivedFields(bodyInput) {
-    const body = bodyInput;
-    const classLiabilityRows = body?.safety_profile?.class_precedent?.coverage === "available"
-        ? (body.safety_profile?.class_precedent?.data?.per_organ ?? []).filter((o) => o.is_class_liability)
-        : [];
-    const classLiabilityCount = classLiabilityRows.length;
-    const sameClassDrugCount = body?.safety_profile?.class_precedent?.coverage === "available" ? (body.safety_profile?.class_precedent?.data?.drugs_in_class ?? []).length : 0;
-    const offTargetRows = body?.safety_profile?.off_target_panel?.data?.rows ?? [];
-    const safetyHits = offTargetRows.filter((r) => r.is_safety_panel_target === true).length;
-    const offTissueRows = body?.off_tissue_risk?.data?.rows ?? [];
-    const offTissueOrganCount = new Set(offTissueRows.map((r) => r.organ).filter(Boolean)).size;
-    const expected = expectedOrgansFromBody(body);
-    const present = presentOrgans(body);
-    const missing = expected.filter((o) => !present.includes(o));
-    const seriousness = body?.safety_profile?.faers?.data?.seriousness;
-    const fatalBullet = (body?.liability_summary?.liability_bullets ?? []).some((b) => b?.category === "fatal_post_market");
-    const anyFatal = seriousness?.coverage === "available" ? (seriousness.by_seriousness?.death ?? 0) > 0 || fatalBullet : fatalBullet ? true : "unknown";
-    const tissueRows = body?.reference_biology?.normal_tissue_expression?.data?.rows ?? [];
-    const highTissues = countHighExpressionTissues(body);
-    const safetySources = ["organ_rollup", "faers", "trial_aes", "off_target_panel", "failed_trials_safety_lens", "class_precedent"].filter((k) => body?.safety_profile?.[k]?.coverage === "available").length;
-    return {
-        summary: {
-            has_human_evidence: hasHumanEvidence(body),
-            has_clinical_evidence: hasClinicalEvidence(body),
-            total_evidence_items: countTotalEvidenceItems(body),
-            total_distinct_papers: countDistinctPapers(body),
-            total_distinct_clinical_trials: countDistinctTrials(body),
-            ...topIndicationSummary(body),
-        },
-        risk_summary: {
-            any_fatal_signal: anyFatal,
-            highest_risk_organ: highestRiskOrgan(body),
-            off_target_safety_target_hits: safetyHits,
-            class_liability_count: classLiabilityCount,
-        },
-        liability_summary: {
-            counts: {
-                class_liability_count: classLiabilityCount,
-                safety_target_off_target_count: safetyHits,
-                off_tissue_risk_organ_count: offTissueOrganCount,
-            },
-            expression_breadth: {
-                total_assessed_tissues: tissueRows.length,
-                high_expression_tissue_count: highTissues,
-            },
-            same_class_drug_count: sameClassDrugCount,
-            safety_data_sources_checked: safetySources,
-        },
-        organ_rollup_completeness: {
-            expected_organs: expected,
-            present_organs: present,
-            missing_organs: missing,
-        },
-    };
-}

package/dist/workflows/target-assessment/lib/compute-selectivity.d.ts

@@ -1,15 +0,0 @@
-export declare function computeSelectivity(input: {
-    primary_pchembl: number | null;
-    off_target_pchembl: number | null;
-    primary_source?: "chembl_target_drug_indication" | "literature_curated";
-}): {
-    vs_primary_potency: {
-        primary_pchembl_used: number;
-        primary_source: "chembl_target_drug_indication" | "literature_curated";
-        fold: number;
-        log_units: number;
-    };
-} | {
-    selectivity_unknown: true;
-    reason: string;
-};

package/dist/workflows/target-assessment/lib/compute-selectivity.js

@@ -1,18 +0,0 @@
-export function computeSelectivity(input) {
-    if (input.primary_pchembl == null) {
-        return { selectivity_unknown: true, reason: "no primary pChEMBL available for this modulator in ChEMBL target-drug-indication table" };
-    }
-    if (input.off_target_pchembl == null) {
-        return { selectivity_unknown: true, reason: "no off-target pChEMBL recorded" };
-    }
-    const logUnits = input.primary_pchembl - input.off_target_pchembl;
-    const fold = Math.pow(10, logUnits);
-    return {
-        vs_primary_potency: {
-            primary_pchembl_used: input.primary_pchembl,
-            primary_source: input.primary_source ?? "chembl_target_drug_indication",
-            fold,
-            log_units: logUnits,
-        },
-    };
-}

package/dist/workflows/target-assessment/lib/dedup-modulators.d.ts

@@ -1,37 +0,0 @@
-import { type ChemblModulator } from "../../../tools/lib/chembl-client.js";
-export type DroppedSynonym = {
-    chemblId: string;
-    reason: "same_active_substance" | "ambiguous_name_synonym";
-    keptId: string | null;
-};
-export type DedupResult<T extends Pick<ChemblModulator, "moleculeChemblId" | "parentChemblId" | "maxPhase" | "firstApproval">> = {
-    kept: T[];
-    dropped: DroppedSynonym[];
-};
-/**
- * Group modulators by parent_molecule_chembl_id (or moleculeChemblId when
- * the parent is absent — singleton groups). Within each group keep the
- * "most informative" entry: prefer firstApproval populated, then highest
- * maxPhase, then earliest moleculeChemblId for deterministic tie-break.
- *
- * Reason: ChEMBL exposes the same active substance under multiple
- * molecule_chembl_ids (e.g., CALCITONIN SALMON vs generic CALCITONIN),
- * which causes downstream FAERS queries to double-count the same reports.
- *
- * A second pass handles name-prefix synonyms where ChEMBL does not populate
- * molecule_hierarchy (e.g., CALCITONIN → CALCITONIN HUMAN). Entries with a
- * null firstApproval whose preferredName (uppercased) is a strict
- * word-boundary prefix of another entry's name within the same moleculeType
- * are dropped as same_active_substance (one match) or ambiguous_name_synonym
- * (multiple matches).
- */
-export declare function dedupModulatorsByParent<T extends Pick<ChemblModulator, "moleculeChemblId" | "parentChemblId" | "maxPhase" | "firstApproval" | "preferredName" | "moleculeType">>(modulators: T[]): DedupResult<T>;
-/**
- * For each modulator whose ChEMBL `moleculeType` is empty or "Unknown",
- * fetch the molecule's standard InChI key from ChEMBL, look it up in
- * PubChem, and apply the heuristic classifier (MW + amide-bond count).
- * Returns a new array of modulators with `moleculeType` replaced when a
- * confident classification emerges; otherwise the original ChEMBL value is
- * preserved. Network failures are isolated per modulator.
- */
-export declare function resolveModulatorMoleculeType<T extends Pick<ChemblModulator, "moleculeChemblId" | "moleculeType">>(modulators: T[]): Promise<T[]>;

package/dist/workflows/target-assessment/lib/dedup-modulators.js

@@ -1,157 +0,0 @@
-import { getMoleculeInChIKey } from "../../../tools/lib/chembl-client.js";
-import { classifyMoleculeType, getCompoundPropertiesByInChIKey } from "../../../tools/lib/pubchem-client.js";
-import { withHost } from "../../../lib/host-concurrency.js";
-/**
- * Group modulators by parent_molecule_chembl_id (or moleculeChemblId when
- * the parent is absent — singleton groups). Within each group keep the
- * "most informative" entry: prefer firstApproval populated, then highest
- * maxPhase, then earliest moleculeChemblId for deterministic tie-break.
- *
- * Reason: ChEMBL exposes the same active substance under multiple
- * molecule_chembl_ids (e.g., CALCITONIN SALMON vs generic CALCITONIN),
- * which causes downstream FAERS queries to double-count the same reports.
- *
- * A second pass handles name-prefix synonyms where ChEMBL does not populate
- * molecule_hierarchy (e.g., CALCITONIN → CALCITONIN HUMAN). Entries with a
- * null firstApproval whose preferredName (uppercased) is a strict
- * word-boundary prefix of another entry's name within the same moleculeType
- * are dropped as same_active_substance (one match) or ambiguous_name_synonym
- * (multiple matches).
- */
-export function dedupModulatorsByParent(modulators) {
-    const groups = new Map();
-    for (const m of modulators) {
-        const key = m.parentChemblId ?? m.moleculeChemblId;
-        const arr = groups.get(key) ?? [];
-        arr.push(m);
-        groups.set(key, arr);
-    }
-    const kept = [];
-    const dropped = [];
-    for (const group of groups.values()) {
-        if (group.length === 1) {
-            kept.push(group[0]);
-            continue;
-        }
-        const ranked = [...group].sort((a, b) => {
-            const aHasApp = a.firstApproval != null ? 1 : 0;
-            const bHasApp = b.firstApproval != null ? 1 : 0;
-            if (aHasApp !== bHasApp)
-                return bHasApp - aHasApp;
-            const aPhase = a.maxPhase ?? -1;
-            const bPhase = b.maxPhase ?? -1;
-            if (aPhase !== bPhase)
-                return bPhase - aPhase;
-            return a.moleculeChemblId.localeCompare(b.moleculeChemblId);
-        });
-        const winner = ranked[0];
-        kept.push(winner);
-        for (const loser of ranked.slice(1)) {
-            dropped.push({
-                chemblId: loser.moleculeChemblId,
-                reason: "same_active_substance",
-                keptId: winner.moleculeChemblId,
-            });
-        }
-    }
-    // Second pass: name-prefix synonym detection within the same moleculeType.
-    // Handles cases where ChEMBL does not populate molecule_hierarchy for
-    // unqualified generic names (e.g., "CALCITONIN" as a prefix of
-    // "CALCITONIN HUMAN" and "CALCITONIN SALMON"). Only drops entries with
-    // null firstApproval — an approved generic name should never be silently
-    // dropped.
-    const byType = new Map();
-    for (const m of kept) {
-        const k = (m.moleculeType ?? "").toUpperCase();
-        const arr = byType.get(k) ?? [];
-        arr.push(m);
-        byType.set(k, arr);
-    }
-    const dropIds = new Set();
-    for (const group of byType.values()) {
-        for (const shortEntry of group) {
-            if (shortEntry.firstApproval != null)
-                continue;
-            const shortName = (shortEntry.preferredName ?? "").trim().toUpperCase();
-            if (!shortName)
-                continue;
-            const longerMatches = group.filter((other) => {
-                if (other === shortEntry)
-                    return false;
-                const longName = (other.preferredName ?? "").trim().toUpperCase();
-                if (longName.length <= shortName.length)
-                    return false;
-                if (!longName.startsWith(shortName))
-                    return false;
-                // Require a word-boundary character (whitespace or hyphen) immediately
-                // after the prefix — prevents "CALC" from matching "CALCITONIN".
-                const boundary = longName.charAt(shortName.length);
-                return /[\s-]/.test(boundary);
-            });
-            if (longerMatches.length === 1) {
-                dropIds.add(shortEntry.moleculeChemblId);
-                dropped.push({
-                    chemblId: shortEntry.moleculeChemblId,
-                    reason: "same_active_substance",
-                    keptId: longerMatches[0].moleculeChemblId,
-                });
-            }
-            else if (longerMatches.length > 1) {
-                dropIds.add(shortEntry.moleculeChemblId);
-                dropped.push({
-                    chemblId: shortEntry.moleculeChemblId,
-                    reason: "ambiguous_name_synonym",
-                    keptId: null,
-                });
-            }
-        }
-    }
-    const finalKept = kept.filter((m) => !dropIds.has(m.moleculeChemblId));
-    return { kept: finalKept, dropped };
-}
-// ── PubChem-backed molecule_type backfill ─────────────────────────────────────
-function looksUnknown(value) {
-    if (!value)
-        return true;
-    const lowered = value.trim().toLowerCase();
-    return lowered === "" || lowered === "unknown";
-}
-/**
- * For each modulator whose ChEMBL `moleculeType` is empty or "Unknown",
- * fetch the molecule's standard InChI key from ChEMBL, look it up in
- * PubChem, and apply the heuristic classifier (MW + amide-bond count).
- * Returns a new array of modulators with `moleculeType` replaced when a
- * confident classification emerges; otherwise the original ChEMBL value is
- * preserved. Network failures are isolated per modulator.
- */
-export async function resolveModulatorMoleculeType(modulators) {
-    const candidates = modulators.filter((m) => looksUnknown(m.moleculeType));
-    if (candidates.length === 0)
-        return modulators;
-    const refined = new Map();
-    await Promise.all(candidates.map(async (m) => {
-        try {
-            const inchiKey = await withHost("chembl", () => getMoleculeInChIKey(m.moleculeChemblId));
-            if (!inchiKey)
-                return;
-            const props = await withHost("pubchem", () => getCompoundPropertiesByInChIKey(inchiKey));
-            if (!props)
-                return;
-            const classified = classifyMoleculeType(props);
-            if (classified !== "Unknown")
-                refined.set(m.moleculeChemblId, classified);
-        }
-        catch {
-            // Per-modulator failures must not blank out the others — keep the
-            // original ChEMBL annotation.
-        }
-    }));
-    if (refined.size === 0)
-        return modulators;
-    return modulators.map((m) => {
-        const next = refined.get(m.moleculeChemblId);
-        if (!next)
-            return m;
-        return { ...m, moleculeType: next };
-    });
-}

package/dist/workflows/target-assessment/lib/evidence-conflict-detector.d.ts

@@ -1,17 +0,0 @@
-/**
- * Deterministic structural conflict detector.
- *
- * Each rule is a pure function over the dossier body. A row is emitted
- * when the body internally contradicts itself in a way that should be
- * impossible post-pipeline-fix. The post-fix pipeline should produce an
- * empty array for any well-formed body; the rules exist to catch
- * regressions and to surface upstream pipeline bugs.
- */
-export type StructuralEvidenceConflict = {
-    evidence_item_id: string;
-    predicate: string;
-    contradicting_predicates: string[];
-    surfaced_in_section: string;
-    evidence: never[];
-};
-export declare function detectStructuralEvidenceConflicts(bodyInput: unknown): StructuralEvidenceConflict[];