@inflexa-ai/harness 0.1.1

package/dist/workflows/target-assessment/schemas.js

@@ -0,0 +1,293 @@
+/**
+ * Shared schemas for target-assessment workflow inter-step contracts.
+ *
+ * The workflow input/output schemas, the resolved-target shape used by
+ * every Phase-1 collector, and the keyed Phase-1/2/3 bundle shapes.
+ */
+import { z } from "zod";
+import { EvidenceItemSchema } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import { withCoverage } from "./coverage.js";
+export const TargetAssessmentInputSchema = z.object({
+    /** UUID of the target_assessments row already inserted by the trigger route. */
+    assessmentId: z.string().uuid(),
+    /** Free-form target identifier (gene symbol, alias, UniProt accession, ENSG, CHEMBL\d+). */
+    target: z.string().min(1),
+    /** Optional reviewer goal (carried into the dossier header). */
+    goal: z.string().nullable().optional(),
+    /** Organization id — used for scoping & billing. */
+    organizationId: z.string(),
+    /** Requesting user id (identity sub claim). */
+    requestedBy: z.string(),
+});
+export const ResolvedTargetSchema = z.object({
+    assessmentId: z.string().uuid(),
+    goal: z.string().nullable(),
+    canonicalId: z.string(),
+    canonicalOntology: z.enum(["hgnc", "ensembl"]),
+    geneSymbol: z.string(),
+    approvedName: z.string(),
+    ids: z.object({
+        hgnc: z.string().nullable(),
+        ensembl: z.string().nullable(),
+        uniprot: z.string().nullable(),
+        chembl: z.string().nullable(),
+        entrez: z.string().nullable(),
+    }),
+    synonyms: z.array(z.string()),
+    proteinSynonyms: z.array(z.string()),
+    proteinFamily: z.string().nullable(),
+    resolutionCoverage: z.object({
+        hgnc: z.boolean(),
+        uniprot: z.boolean(),
+        ensembl: z.boolean(),
+        chembl: z.boolean(),
+    }),
+});
+// ── Phase-1 collector output schemas ─────────────────────────────────
+const AssociationSchema = z.object({
+    diseaseId: z.string(),
+    diseaseName: z.string(),
+    score: z.number(),
+    geneticAssociationScore: z.number().nullable(),
+    knownDrugScore: z.number().nullable(),
+    literatureScore: z.number().nullable(),
+    animalModelScore: z.number().nullable().default(null),
+    somaticMutationScore: z.number().nullable().default(null),
+    literaturePmids: z.array(z.string()).default([]),
+});
+export const OpenTargetsBundleSchema = z.object({
+    ensemblId: z.string(),
+    approvedSymbol: z.string(),
+    approvedName: z.string(),
+    tractability: z
+        .object({
+        smallMolecule: z.boolean().nullable(),
+        antibody: z.boolean().nullable(),
+        otherModalities: z.boolean().nullable(),
+    })
+        .nullable(),
+    associations: z.array(AssociationSchema),
+    safetyLiabilities: z.array(z.object({
+        event: z.string(),
+        biosamples: z.array(z.string()),
+        effects: z.string().nullable(),
+        source: z.string(),
+    })),
+    baselineExpression: z.array(z.object({
+        tissueId: z.string(),
+        tissueLabel: z.string(),
+        organSystem: z.string().nullable(),
+        rna: z.object({ value: z.number(), unit: z.string() }).nullable(),
+        protein: z.object({ level: z.number().nullable() }).nullable(),
+    })),
+});
+export const ChemblModulatorsBundleSchema = z.object({
+    targetChemblId: z.string().nullable(),
+    modulators: z.array(z.object({
+        moleculeChemblId: z.string(),
+        parentChemblId: z.string().nullable(),
+        preferredName: z.string().nullable(),
+        maxPhase: z.number().nullable(),
+        moleculeType: z.string().nullable(),
+        firstApproval: z.number().nullable(),
+        /** Present only for entries discovered via the activity-table secondary path. */
+        evidence_source: z.literal("chembl_activity").optional(),
+    })),
+});
+export const CtgovInterventionSchema = z.object({
+    name: z.string(),
+    type: z.string().nullable(),
+    description: z.string().nullable(),
+    otherNames: z.array(z.string()),
+});
+export const CtgovTrialSchema = z.object({
+    nctId: z.string(),
+    title: z.string(),
+    officialTitle: z.string().nullable(),
+    status: z.string(),
+    phase: z.string().nullable(),
+    studyType: z.string().nullable(),
+    primaryPurpose: z.string().nullable(),
+    conditions: z.array(z.string()),
+    interventions: z.array(z.string()),
+    interventionDetails: z.array(CtgovInterventionSchema),
+    enrollmentCount: z.number().nullable(),
+    startDate: z.string().nullable(),
+    primaryCompletionDate: z.string().nullable(),
+    whyStopped: z.string().nullable(),
+    briefSummary: z.string().nullable(),
+    detailedDescription: z.string().nullable(),
+    sponsor: z.string().nullable(),
+    collection_query: z.string().optional(),
+    collection_channel: z.enum(["target_symbol", "class_modulator", "therapeutic_program", "biomarker_context", "failed_intervention"]).optional(),
+});
+export const CtgovBundleSchema = z.object({
+    active: z.array(CtgovTrialSchema),
+    failed: z.array(CtgovTrialSchema),
+});
+export const FaersByTargetBundleSchema = z.object({
+    drugProbed: z.string(),
+    totalReports: z.number().nullable(),
+    topReactions: z.array(z.object({ reaction: z.string(), count: z.number() })),
+    seriousness: z
+        .object({
+        totalReports: z.number(),
+        fatalCount: z.number(),
+        hospitalizationCount: z.number(),
+        lifeThreateningCount: z.number(),
+        disablingCount: z.number(),
+        congenitalAnomalyCount: z.number().default(0),
+        otherSeriousCount: z.number().default(0),
+    })
+        .nullable(),
+});
+export const ExpressionHumanBundleSchema = z.object({
+    source: z.enum(["gtex", "hpa_consensus", "hpa_rna_tissue"]),
+    unit: z.enum(["tpm", "ntpm", "consensus_normalized"]),
+    normalization_notes: z.string().min(1),
+    tissues: z.array(z.object({
+        tissueLabel: z.string(),
+        organSystem: z.string().nullable(),
+        value: z.number().nullable(),
+        protein: z.number().nullable(),
+    })),
+});
+export const ExpressionMultiSpeciesBundleSchema = z.object({
+    geneSymbol: z.string(),
+    humanEnsemblId: z.string().nullable(),
+    bySpecies: z.array(z.object({
+        species: z.string(),
+        taxonId: z.number(),
+        ensemblId: z.string(),
+        source: z.string(),
+        unit: z.string(),
+        normalization_notes: z.string(),
+        tissues: z.array(z.object({
+            tissue: z.string(),
+            rank: z.enum(["absent", "low", "medium", "high"]),
+            expressionScore: z.number().nullable(),
+        })),
+    })),
+    notFound: z.array(z.string()),
+});
+export const ClinvarBundleSchema = z.object({
+    totalFound: z.number(),
+    variants: z.array(z.object({
+        variationId: z.string(),
+        title: z.string(),
+        clinicalSignificance: z.string(),
+        reviewStatus: z.string(),
+        conditions: z.array(z.string()),
+        molecularConsequence: z.string(),
+        accession: z.string(),
+    })),
+});
+export const CbioportalBundleSchema = z.object({
+    entrezGeneId: z.number().nullable(),
+    rows: z.array(z.object({
+        cancerTypeId: z.string(),
+        cancerTypeName: z.string(),
+        totalSamples: z.number(),
+        mutatedSamples: z.number(),
+        frequency: z.number(),
+        studies: z.array(z.string()),
+    })),
+});
+export const ImpcBundleSchema = z.object({
+    mouseMarkerSymbol: z.string().nullable(),
+    mgiAccessionId: z.string().nullable(),
+    viability: z.enum(["lethal_pre_weaning", "subviable", "viable"]).nullable(),
+    viabilityCalls: z.array(z.object({
+        zygosity: z.string(),
+        parameterStableId: z.string(),
+        mpTerm: z.object({ id: z.string(), name: z.string() }).nullable(),
+    })),
+    mpTerms: z.array(z.object({ id: z.string(), term: z.string(), bestPValue: z.number().nullable() })),
+    organSystems: z.array(z.string()),
+    sexDimorphic: z.boolean(),
+    phenotypeCount: z.number(),
+});
+export const PubmedIndexBundleSchema = z.object({
+    totalFound: z.number(),
+    topPmids: z.array(z.string()),
+    results: z.array(z.object({
+        pmid: z.string(),
+        title: z.string(),
+        journal: z.string(),
+        year: z.string(),
+        authors: z.string(),
+    })),
+});
+export const PathwaysBundleSchema = z.object({
+    pathways: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        source: z.enum(["kegg", "reactome"]),
+        url: z.string().optional(),
+        entity_uniprots: z.array(z.string()).optional(),
+        metadata: z.object({ species_present: z.array(z.string()).optional() }).optional(),
+    })),
+});
+export const StringPpiBundleSchema = z.object({
+    partners: z.array(z.object({
+        proteinA: z.string(),
+        proteinB: z.string(),
+        score: z.number(),
+        experimentalScore: z.number().optional(),
+        databaseScore: z.number().optional(),
+        textminingScore: z.number().optional(),
+    })),
+});
+/**
+ * Heterodimer / receptor-accessory complex inventory for the assessment
+ * target, sourced from IUPHAR Guide to Pharmacology. Drives runtime
+ * heterodimer-name detection (no hardcoded RAMP/MRAP/RGS regex) and the
+ * obligate-cofactor supplement in the off-target panel.
+ */
+export const FamilyComplexesBundleSchema = z.object({
+    primaryTargetGene: z.string(),
+    primaryTargetUniprot: z.string().nullable(),
+    accessoryProteinNames: z.array(z.string()),
+    complexes: z.array(z.object({
+        complexName: z.string(),
+        complexId: z.number().nullable(),
+        accessoryNames: z.array(z.string()),
+        subunitNames: z.array(z.string()),
+    })),
+});
+export const TherapeuticProgramsBundleSchema = z.object({
+    programs: z.array(z.object({
+        programId: z.string(),
+        name: z.string(),
+        targetSymbol: z.string(),
+        targetUniprot: z.string().nullable(),
+        modality: z.string(),
+        sponsor: z.string().nullable(),
+        mechanism: z.string(),
+        status: z.string(),
+        nctIds: z.array(z.string()),
+        pmids: z.array(z.string()),
+        evidence: z.array(EvidenceItemSchema),
+        confidence: z.enum(["high", "medium", "low"]),
+    })),
+});
+// ── Phase-1 keyed bundle (output of phase1Aggregate) ─────────────────
+export const Phase1BundleSchema = z.object({
+    resolved: ResolvedTargetSchema,
+    collectors: z.object({
+        opentargets: withCoverage(OpenTargetsBundleSchema),
+        chemblModulators: withCoverage(ChemblModulatorsBundleSchema),
+        ctgov: withCoverage(CtgovBundleSchema),
+        faersByTarget: withCoverage(FaersByTargetBundleSchema),
+        expressionHuman: withCoverage(ExpressionHumanBundleSchema),
+        expressionMultiSpecies: withCoverage(ExpressionMultiSpeciesBundleSchema),
+        clinvar: withCoverage(ClinvarBundleSchema),
+        cbioportal: withCoverage(CbioportalBundleSchema),
+        impc: withCoverage(ImpcBundleSchema),
+        pubmedIndex: withCoverage(PubmedIndexBundleSchema),
+        pathways: withCoverage(PathwaysBundleSchema),
+        stringPpi: withCoverage(StringPpiBundleSchema),
+        familyComplexes: withCoverage(FamilyComplexesBundleSchema),
+        therapeuticPrograms: withCoverage(TherapeuticProgramsBundleSchema).optional(),
+    }),
+});

package/dist/workflows/target-assessment/steps/collectors/pathways.d.ts

@@ -0,0 +1,15 @@
+export type PathwayRow = {
+    id: string;
+    name: string;
+    source: "reactome" | "kegg";
+    url: string;
+    entity_uniprots?: string[];
+    metadata?: {
+        species_present?: string[];
+    };
+};
+export declare function stripHtml(s: string): string;
+export declare function dedupPathwaysAcrossSpecies(rows: PathwayRow[], opts?: {
+    geneSymbolEchoFilter?: string;
+    assessmentUniprot?: string;
+}): PathwayRow[];

package/dist/workflows/target-assessment/steps/collectors/pathways.js

@@ -0,0 +1,58 @@
+import { stripHtmlAndCollapseWs } from "../../../../tools/lib/pathway-client.js";
+const REACTOME_ID_RE = /^R-([A-Z]+)-(\d+)/;
+export function stripHtml(s) {
+    return stripHtmlAndCollapseWs(s);
+}
+export function dedupPathwaysAcrossSpecies(rows, opts = {}) {
+    // Group Reactome rows by stable suffix; KEGG/other sources pass through.
+    const reactomeGroups = new Map();
+    const others = [];
+    for (const r of rows) {
+        if (r.source !== "reactome") {
+            others.push(r);
+            continue;
+        }
+        const m = REACTOME_ID_RE.exec(r.id);
+        if (!m) {
+            others.push(r);
+            continue;
+        }
+        const suffix = m[2];
+        const arr = reactomeGroups.get(suffix) ?? [];
+        arr.push(r);
+        reactomeGroups.set(suffix, arr);
+    }
+    const collapsed = [];
+    for (const group of reactomeGroups.values()) {
+        const withSpecies = group.map((r) => ({
+            r,
+            species: REACTOME_ID_RE.exec(r.id)[1],
+        }));
+        const human = withSpecies.find((x) => x.species === "HSA");
+        const winner = (human ?? withSpecies[0]).r;
+        const species_present = withSpecies.map((x) => x.species);
+        collapsed.push({
+            ...winner,
+            metadata: { ...(winner.metadata ?? {}), species_present },
+        });
+    }
+    const merged = [...collapsed, ...others];
+    let filtered = merged;
+    if (opts.assessmentUniprot) {
+        filtered = filtered.filter((r) => {
+            if (r.source !== "reactome")
+                return true; // only Reactome carries entity_uniprots
+            if (!r.entity_uniprots || r.entity_uniprots.length === 0)
+                return true; // graceful fallback when fetch failed
+            return r.entity_uniprots.includes(opts.assessmentUniprot);
+        });
+    }
+    if (opts.geneSymbolEchoFilter) {
+        const echo = opts.geneSymbolEchoFilter.toLowerCase();
+        filtered = filtered.filter((r) => r.name.toLowerCase() !== echo);
+    }
+    return filtered;
+}
+// `stripHtmlAndCollapseWs` is the underlying helper — kept in scope so the
+// `stripHtml` re-export above stays callable.
+void stripHtmlAndCollapseWs;

package/dist/workflows/target-assessment/steps/fanout/aes-for-one-class-drug-step.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Per-class-drug AE — fan-out item schemas.
+ *
+ * The DBOS-driven implementation lives in `target-assessment/fanout/index.ts`
+ * (`aesForOneClassDrug`); this module is retained for its input/output
+ * schemas and inferred item types.
+ */
+import { z } from "zod";
+export declare const ClassDrugItemSchema: z.ZodObject<{
+    moleculeChemblId: z.ZodString;
+    preferredName: z.ZodString;
+    maxPhase: z.ZodNullable<z.ZodNumber>;
+    firstApproval: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ClassDrugItem = z.infer<typeof ClassDrugItemSchema>;
+export declare const PerClassDrugAEsItemSchema: z.ZodObject<{
+    moleculeChemblId: z.ZodString;
+    preferredName: z.ZodString;
+    totalReports: z.ZodNullable<z.ZodNumber>;
+    topReactions: z.ZodArray<z.ZodObject<{
+        reaction: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    seriousness: z.ZodNullable<z.ZodObject<{
+        totalReports: z.ZodNumber;
+        fatalCount: z.ZodNumber;
+        hospitalizationCount: z.ZodNumber;
+        lifeThreateningCount: z.ZodNumber;
+        disablingCount: z.ZodNumber;
+        congenitalAnomalyCount: z.ZodDefault<z.ZodNumber>;
+        otherSeriousCount: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PerClassDrugAEsItem = z.infer<typeof PerClassDrugAEsItemSchema>;

package/dist/workflows/target-assessment/steps/fanout/aes-for-one-class-drug-step.js

@@ -0,0 +1,31 @@
+/**
+ * Per-class-drug AE — fan-out item schemas.
+ *
+ * The DBOS-driven implementation lives in `target-assessment/fanout/index.ts`
+ * (`aesForOneClassDrug`); this module is retained for its input/output
+ * schemas and inferred item types.
+ */
+import { z } from "zod";
+export const ClassDrugItemSchema = z.object({
+    moleculeChemblId: z.string(),
+    preferredName: z.string(),
+    maxPhase: z.number().nullable(),
+    firstApproval: z.number().nullable(),
+});
+export const PerClassDrugAEsItemSchema = z.object({
+    moleculeChemblId: z.string(),
+    preferredName: z.string(),
+    totalReports: z.number().nullable(),
+    topReactions: z.array(z.object({ reaction: z.string(), count: z.number() })),
+    seriousness: z
+        .object({
+        totalReports: z.number(),
+        fatalCount: z.number(),
+        hospitalizationCount: z.number(),
+        lifeThreateningCount: z.number(),
+        disablingCount: z.number(),
+        congenitalAnomalyCount: z.number().default(0),
+        otherSeriousCount: z.number().default(0),
+    })
+        .nullable(),
+});

package/dist/workflows/target-assessment/steps/fanout/aes-for-one-trial-step.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Per-trial AE — fan-out item schemas.
+ *
+ * The DBOS-driven implementation lives in `target-assessment/fanout/index.ts`
+ * (`aesForOneTrial`); this module is retained for its input/output schemas
+ * and inferred item types.
+ */
+import { z } from "zod";
+export declare const TrialItemSchema: z.ZodObject<{
+    nctId: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strip>;
+export type TrialItem = z.infer<typeof TrialItemSchema>;
+export declare const PerTrialAEsItemSchema: z.ZodObject<{
+    nctId: z.ZodString;
+    title: z.ZodString;
+    whyStopped: z.ZodNullable<z.ZodString>;
+    outcomes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            other: "other";
+            primary: "primary";
+            secondary: "secondary";
+        }>;
+        measure: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        timeFrame: z.ZodNullable<z.ZodString>;
+        effect: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"quantitative">;
+            value: z.ZodNumber;
+            units: z.ZodString;
+            ci_low: z.ZodOptional<z.ZodNumber>;
+            ci_high: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"not_extracted">;
+            reason: z.ZodEnum<{
+                ctgov_no_numeric_result: "ctgov_no_numeric_result";
+                ctgov_no_result_groups: "ctgov_no_result_groups";
+            }>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>>>;
+    groups: z.ZodArray<z.ZodObject<{
+        groupId: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    events: z.ZodArray<z.ZodObject<{
+        serious: z.ZodBoolean;
+        term: z.ZodString;
+        organSystem: z.ZodNullable<z.ZodString>;
+        counts: z.ZodArray<z.ZodObject<{
+            groupId: z.ZodString;
+            numAffected: z.ZodNullable<z.ZodNumber>;
+            numAtRisk: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PerTrialAEsItem = z.infer<typeof PerTrialAEsItemSchema>;

package/dist/workflows/target-assessment/steps/fanout/aes-for-one-trial-step.js

@@ -0,0 +1,54 @@
+/**
+ * Per-trial AE — fan-out item schemas.
+ *
+ * The DBOS-driven implementation lives in `target-assessment/fanout/index.ts`
+ * (`aesForOneTrial`); this module is retained for its input/output schemas
+ * and inferred item types.
+ */
+import { z } from "zod";
+export const TrialItemSchema = z.object({
+    nctId: z.string(),
+    title: z.string(),
+});
+const OutcomeEffectSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("quantitative"),
+        value: z.number(),
+        units: z.string(),
+        ci_low: z.number().optional(),
+        ci_high: z.number().optional(),
+    }),
+    z.object({
+        kind: z.literal("not_extracted"),
+        reason: z.enum(["ctgov_no_numeric_result", "ctgov_no_result_groups"]),
+    }),
+]);
+export const PerTrialAEsItemSchema = z.object({
+    nctId: z.string(),
+    title: z.string(),
+    whyStopped: z.string().nullable(),
+    outcomes: z
+        .array(z.object({
+        type: z.enum(["primary", "secondary", "other"]),
+        measure: z.string(),
+        description: z.string().nullable(),
+        timeFrame: z.string().nullable(),
+        effect: OutcomeEffectSchema,
+    }))
+        .default([]),
+    groups: z.array(z.object({
+        groupId: z.string(),
+        title: z.string(),
+        description: z.string().nullable(),
+    })),
+    events: z.array(z.object({
+        serious: z.boolean(),
+        term: z.string(),
+        organSystem: z.string().nullable(),
+        counts: z.array(z.object({
+            groupId: z.string(),
+            numAffected: z.number().nullable(),
+            numAtRisk: z.number().nullable(),
+        })),
+    })),
+});

package/dist/workflows/target-assessment/steps/fanout/faers-for-one-modulator-step.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Per-modulator FAERS — fan-out item schemas.
+ *
+ * The DBOS-driven implementation lives in `target-assessment/fanout/index.ts`
+ * (`faersForOneModulator`); this module is retained for its input/output
+ * schemas and inferred item types.
+ */
+import { z } from "zod";
+export declare const ModulatorItemSchema: z.ZodObject<{
+    moleculeChemblId: z.ZodString;
+    preferredName: z.ZodString;
+    maxPhase: z.ZodNullable<z.ZodNumber>;
+    firstApproval: z.ZodNullable<z.ZodNumber>;
+    rationale: z.ZodString;
+}, z.core.$strip>;
+export type ModulatorItem = z.infer<typeof ModulatorItemSchema>;
+export declare const PerModulatorFaersItemSchema: z.ZodObject<{
+    moleculeChemblId: z.ZodString;
+    preferredName: z.ZodString;
+    totalReports: z.ZodNullable<z.ZodNumber>;
+    topReactions: z.ZodArray<z.ZodObject<{
+        reaction: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strip>>;
+    seriousness: z.ZodNullable<z.ZodObject<{
+        totalReports: z.ZodNumber;
+        fatalCount: z.ZodNumber;
+        hospitalizationCount: z.ZodNumber;
+        lifeThreateningCount: z.ZodNumber;
+        disablingCount: z.ZodNumber;
+        congenitalAnomalyCount: z.ZodDefault<z.ZodNumber>;
+        otherSeriousCount: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PerModulatorFaersItem = z.infer<typeof PerModulatorFaersItemSchema>;

package/dist/workflows/target-assessment/steps/fanout/faers-for-one-modulator-step.js

@@ -0,0 +1,32 @@
+/**
+ * Per-modulator FAERS — fan-out item schemas.
+ *
+ * The DBOS-driven implementation lives in `target-assessment/fanout/index.ts`
+ * (`faersForOneModulator`); this module is retained for its input/output
+ * schemas and inferred item types.
+ */
+import { z } from "zod";
+export const ModulatorItemSchema = z.object({
+    moleculeChemblId: z.string(),
+    preferredName: z.string(),
+    maxPhase: z.number().nullable(),
+    firstApproval: z.number().nullable(),
+    rationale: z.string(),
+});
+export const PerModulatorFaersItemSchema = z.object({
+    moleculeChemblId: z.string(),
+    preferredName: z.string(),
+    totalReports: z.number().nullable(),
+    topReactions: z.array(z.object({ reaction: z.string(), count: z.number() })),
+    seriousness: z
+        .object({
+        totalReports: z.number(),
+        fatalCount: z.number(),
+        hospitalizationCount: z.number(),
+        lifeThreateningCount: z.number(),
+        disablingCount: z.number(),
+        congenitalAnomalyCount: z.number().default(0),
+        otherSeriousCount: z.number().default(0),
+    })
+        .nullable(),
+});

package/dist/workflows/target-assessment/steps/fanout/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Phase-3 fan-out item schemas. Each schema describes one work item (one
+ * modulator, one trial, one class drug) and its coverage-tagged payload.
+ * The harness DBOS implementation lives in
+ * `../../fanout/index.ts` — these schemas are the shared type contract.
+ */
+export { ModulatorItemSchema, PerModulatorFaersItemSchema } from "./faers-for-one-modulator-step.js";
+export type { ModulatorItem, PerModulatorFaersItem } from "./faers-for-one-modulator-step.js";
+export { TrialItemSchema, PerTrialAEsItemSchema } from "./aes-for-one-trial-step.js";
+export type { TrialItem, PerTrialAEsItem } from "./aes-for-one-trial-step.js";
+export { PolypharmInputItemSchema, PerModulatorPolypharmItemSchema } from "./polypharm-for-one-modulator-step.js";
+export type { PolypharmInputItem, PerModulatorPolypharmItem } from "./polypharm-for-one-modulator-step.js";
+export { ClassDrugItemSchema, PerClassDrugAEsItemSchema } from "./aes-for-one-class-drug-step.js";
+export type { ClassDrugItem, PerClassDrugAEsItem } from "./aes-for-one-class-drug-step.js";

package/dist/workflows/target-assessment/steps/fanout/index.js

@@ -0,0 +1,10 @@
+/**
+ * Phase-3 fan-out item schemas. Each schema describes one work item (one
+ * modulator, one trial, one class drug) and its coverage-tagged payload.
+ * The harness DBOS implementation lives in
+ * `../../fanout/index.ts` — these schemas are the shared type contract.
+ */
+export { ModulatorItemSchema, PerModulatorFaersItemSchema } from "./faers-for-one-modulator-step.js";
+export { TrialItemSchema, PerTrialAEsItemSchema } from "./aes-for-one-trial-step.js";
+export { PolypharmInputItemSchema, PerModulatorPolypharmItemSchema } from "./polypharm-for-one-modulator-step.js";
+export { ClassDrugItemSchema, PerClassDrugAEsItemSchema } from "./aes-for-one-class-drug-step.js";

package/dist/workflows/target-assessment/steps/fanout/polypharm-for-one-modulator-step.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per-modulator polypharmacology — fan-out item schemas.
+ *
+ * The DBOS-driven implementation lives in `target-assessment/fanout/index.ts`
+ * (`polypharmForOneModulator`); this module is retained for its input/output
+ * schemas and inferred item types.
+ */
+import { z } from "zod";
+export declare const PolypharmInputItemSchema: z.ZodObject<{
+    moleculeChemblId: z.ZodString;
+    preferredName: z.ZodString;
+    primaryTargetChemblId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PolypharmInputItem = z.infer<typeof PolypharmInputItemSchema>;
+export declare const PerModulatorPolypharmItemSchema: z.ZodObject<{
+    moleculeChemblId: z.ZodString;
+    preferredName: z.ZodString;
+    primaryPchembl: z.ZodNullable<z.ZodNumber>;
+    hits: z.ZodArray<z.ZodObject<{
+        targetChemblId: z.ZodString;
+        targetName: z.ZodNullable<z.ZodString>;
+        pchemblValue: z.ZodNullable<z.ZodNumber>;
+        standardType: z.ZodNullable<z.ZodString>;
+        standardValue: z.ZodNullable<z.ZodNumber>;
+        standardUnits: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PerModulatorPolypharmItem = z.infer<typeof PerModulatorPolypharmItemSchema>;