@holoscript/structural-biology-plugin 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,657 @@
+/**
+ * @holoscript/structural-biology-plugin — AutoDock binding affinity bridge.
+ *
+ * Provides configuration, result, and trait interfaces for molecular docking
+ * via AutoDock-GPU / AutoDock Vina. Wires into core's existing `auto_dock`
+ * and `binding_affinity` scientific-computing traits.
+ *
+ * Architecture follows the qm-bridge pattern: each docking backend implements
+ * DockingSolver (which extends the SimSolver contract for steady-state
+ * molecular docking), and participates in the same SimulationContract / CAEL
+ * recording / Brittney dispatch pipeline.
+ *
+ * @module docking
+ */
+type DockingBackend = 'autodock-gpu' | 'autodock-vina' | 'gnina';
+interface DockingConfig {
+    /** Docking engine backend */
+    backend: DockingBackend;
+    /** Receptor protein (PDB data or PDBQT string) */
+    receptor: string;
+    /** Ligand (SMILES, PDBQT, or SDF) */
+    ligand: string;
+    /** Search space center x */
+    centerX: number;
+    /** Search space center y */
+    centerY: number;
+    /** Search space center z */
+    centerZ: number;
+    /** Search space size x (Angstroms) */
+    sizeX: number;
+    /** Search space size y (Angstroms) */
+    sizeY: number;
+    /** Search space size z (Angstroms) */
+    sizeZ: number;
+    /** Number of docking runs (exhaustiveness in Vina terms) */
+    numRuns?: number;
+    /** Energy range for Vina: max energy difference from best mode (kcal/mol) */
+    energyRange?: number;
+    /** Maximum number of binding modes to output */
+    maxModes?: number;
+    /** Flexible receptor residues (for induced-fit docking) */
+    flexibleResidues?: string[];
+    /** Scoring function variant */
+    scoringFunction?: 'vina' | 'ad4' | 'vinardo' | 'gnina_default';
+    /** GPU device index for AutoDock-GPU (-1 for CPU fallback) */
+    gpuDevice?: number;
+    /** Number of LGA runs for AutoDock-GPU */
+    lgaRuns?: number;
+    /** Population size for AutoDock-GPU LGA */
+    popSize?: number;
+}
+interface DockingPose {
+    /** Binding affinity in kcal/mol */
+    affinity: number;
+    /** Root-mean-square deviation from reference (lower bound) */
+    rmsdLb: number;
+    /** Root-mean-square deviation from reference (upper bound) */
+    rmsdUb: number;
+    /** Pose PDBQT data */
+    poseData: string;
+    /** Intermolecular energy (kcal/mol) */
+    intermolEnergy?: number;
+    /** Internal energy (kcal/mol) */
+    internalEnergy?: number;
+    /** Torsional energy (kcal/mol) */
+    torsionalEnergy?: number;
+}
+interface DockingResult {
+    status: 'success' | 'failed';
+    /** Best binding affinity (kcal/mol, most negative = strongest binding) */
+    bestAffinity?: number;
+    /** All poses from the docking run, sorted by affinity */
+    poses: DockingPose[];
+    /** Receptor identifier */
+    receptorId: string;
+    /** Ligand identifier (SMILES or name) */
+    ligandId: string;
+    /** Backend used */
+    backend: DockingBackend;
+    /** Execution time in milliseconds */
+    executionTimeMs?: number;
+    /** AutoDock-GPU specific: number of LGA runs completed */
+    lgaRunsCompleted?: number;
+    /** Error message if status is 'failed' */
+    error?: string;
+}
+/**
+ * @auto_dock trait — Automated molecular docking configuration.
+ * Wires to core's existing `auto_dock` scientific-computing trait.
+ */
+interface AutoDockTrait {
+    trait: 'auto_dock';
+    /** Docking backend */
+    backend: DockingBackend;
+    /** Receptor PDBQT or PDB data */
+    receptor: string;
+    /** Ligand SMILES, PDBQT, or SDF */
+    ligand: string;
+    /** Search box center {x, y, z} in Angstroms */
+    searchCenter: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Search box dimensions {x, y, z} in Angstroms */
+    searchSize: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Number of docking runs */
+    numRuns?: number;
+    /** Scoring function variant */
+    scoringFunction?: 'vina' | 'ad4' | 'vinardo' | 'gnina_default';
+}
+/**
+ * @binding_affinity trait — Binding affinity metrics result.
+ * Wires to core's existing `binding_affinity` scientific-computing trait.
+ */
+interface BindingAffinityTrait {
+    trait: 'binding_affinity';
+    /** Best binding affinity (kcal/mol) */
+    bestAffinity: number;
+    /** Number of poses */
+    poseCount: number;
+    /** RMSD range (lower, upper) for best pose */
+    bestRmsdRange: [number, number];
+    /** Backend used */
+    backend: DockingBackend;
+    /** Ki (inhibition constant) in nM, derived from affinity */
+    ki_nm?: number;
+    /** Percentage of poses below threshold affinity */
+    hitRate?: number;
+}
+/**
+ * DockingSolver — steady-state SimSolver for molecular docking.
+ *
+ * Extends the core SimSolver contract for docking workloads. `solve()`
+ * executes the docking run and returns the result. `step()` is a no-op
+ * (docking is steady-state, not transient). Output fields are accessible
+ * via `getField()` after `solve()` completes.
+ *
+ * Follows the qm-bridge factory pattern: `createDockingSolver(config)`
+ * returns a backend-specific instance.
+ */
+interface DockingSolver {
+    /** Docking is always steady-state */
+    readonly mode: 'steady-state';
+    /** Available output field names */
+    readonly fieldNames: readonly string[];
+    /** Backend identifier */
+    readonly backend: DockingBackend;
+    /** Execute the docking computation */
+    solve(): Promise<DockingResult>;
+    /** Retrieve a named output field after solve() */
+    getField(name: string): Float32Array | Float64Array | null;
+    /** Solver statistics (run count, timing, convergence) */
+    getStats(): Record<string, unknown>;
+    /** Release resources */
+    dispose(): void;
+}
+/**
+ * Convert an AutoDockTrait (domain-level) to a DockingConfig (solver-level).
+ * This bridges the plugin trait vocabulary to the solver configuration format.
+ */
+declare function traitToConfig(trait: AutoDockTrait): DockingConfig;
+/**
+ * Compute a provenance anchor for a docking result, linking it back to the
+ * structural-biology plugin identity and the specific receptor-ligand pair.
+ */
+declare function dockingProvenance(result: DockingResult): string;
+/**
+ * Select the appropriate docking backend based on a question or use case.
+ *
+ * - 'autodock-gpu': High-throughput screening, large grid searches, GPU-accelerated
+ * - 'autodock-vina': Standard docking, widely validated, good default
+ * - 'gnina': CNN scoring, pose prediction with ML re-scoring
+ */
+declare function selectDockingBackend(questionType: string): DockingBackend;
+type DockingCompileFormat = 'pdbqt' | 'sdf' | 'csv' | 'holo';
+interface DockingCompileOptions {
+    format?: DockingCompileFormat;
+}
+/**
+ * Compile AutoDock and BindingAffinity traits into a target representation.
+ *
+ * - `pdbqt`  — PDBQT with REMARK lines (default, AutoDock-native)
+ * - `sdf`    — MDL MOL/SDF with docking annotations
+ * - `csv`    — CSV table of pose affinities and RMSD values
+ * - `holo`   — HoloScript .holo composition
+ */
+declare function compileDocking(traits: Array<AutoDockTrait | BindingAffinityTrait>, opts?: DockingCompileOptions): string;
+
+/**
+ * @holoscript/structural-biology-plugin — ADMET prediction bridge.
+ *
+ * Absorption, Distribution, Metabolism, Excretion, and Toxicity (ADMET)
+ * prediction traits and interfaces. Extends the structural-biology plugin
+ * from structure (AlphaFold) to function (drug-likeness and safety).
+ *
+ * ADMET models predict whether a molecule is likely to be a viable drug
+ * candidate BEFORE expensive synthesis and testing. This bridge wires into
+ * the provenance chain so that ADMET predictions carry the same plugin-identity
+ * provenance as protein/ligand objects.
+ *
+ * Backend options:
+ *   - 'rdkit': Rule-based and ML models via RDKit (Python, fast, well-validated)
+ *   - 'admetlab': ADMETlab 3.0 web service (comprehensive, 47 endpoints)
+ *   - 'local-ml': On-device ONNX/Rust ML models (offline, latency-critical)
+ *
+ * @module admet
+ */
+declare const ADMET_PROPERTIES: readonly ["caco2_permeability", "hia", "pgp_substrate", "pgp_inhibitor", "bbb_permeability", "cns_permeability", "vdss", "fraction_unbound", "ppb", "cyp2d6_substrate", "cyp3a4_substrate", "cyp1a2_inhibitor", "cyp2c19_inhibitor", "cyp2c9_inhibitor", "cyp2d6_inhibitor", "cyp3a4_inhibitor", "cyp2d6_inhibitor_v2", "half_life", "clearance", "hht", "ames", "dili", "skin_sensitization", "carcinogenesis", "rat_oral_ld50"];
+type AdmetProperty = (typeof ADMET_PROPERTIES)[number];
+type AdmetBackend = 'rdkit' | 'admetlab' | 'local-ml';
+interface AdmetConfig {
+    /** Prediction backend */
+    backend: AdmetBackend;
+    /** Molecule in SMILES notation */
+    smiles: string;
+    /** Which ADMET properties to predict (empty = all) */
+    properties?: AdmetProperty[];
+    /** Confidence threshold for binary predictions (0.0-1.0) */
+    confidenceThreshold?: number;
+    /** Include uncertainty estimates */
+    includeUncertainty?: boolean;
+}
+interface AdmetPrediction {
+    /** ADMET property name */
+    property: AdmetProperty;
+    /** Predicted value (numeric) or probability (binary) */
+    value: number;
+    /** Unit of measurement (e.g., 'logPapp', '%', 'binary', 'L/kg') */
+    unit: string;
+    /** Prediction confidence (0.0-1.0) */
+    confidence: number;
+    /** Lower bound of 95% CI (if includeUncertainty) */
+    lower?: number;
+    /** Upper bound of 95% CI (if includeUncertainty) */
+    upper?: number;
+    /** Model version */
+    modelVersion: string;
+}
+interface AdmetResult {
+    status: 'success' | 'failed';
+    /** Input SMILES */
+    smiles: string;
+    /** Backend used */
+    backend: AdmetBackend;
+    /** Individual property predictions */
+    predictions: AdmetPrediction[];
+    /** Overall drug-likeness score (0.0-1.0, heuristic composite) */
+    drugLikenessScore?: number;
+    /** Lipinski Rule of 5 compliance */
+    lipinskiViolations?: number;
+    /** Execution time in milliseconds */
+    executionTimeMs?: number;
+    /** Error message if status is 'failed' */
+    error?: string;
+}
+/**
+ * @admet_prediction trait — Predict ADMET properties for a molecule.
+ *
+ * This trait connects to core's scientific-computing trait namespace and
+ * represents a request to compute absorption, distribution, metabolism,
+ * excretion, and toxicity properties from a molecular structure.
+ */
+interface AdmetPredictionTrait {
+    trait: 'admet_prediction';
+    /** Molecule in SMILES notation */
+    smiles: string;
+    /** Which properties to predict (empty = all) */
+    properties?: AdmetProperty[];
+    /** Backend to use */
+    backend?: AdmetBackend;
+    /** Confidence threshold for binary predictions */
+    confidenceThreshold?: number;
+}
+/**
+ * @admet_result trait — ADMET prediction result for provenance tracking.
+ *
+ * Carries the predicted ADMET properties alongside plugin identity so that
+ * downstream consumers can verify which plugin produced the prediction.
+ */
+interface AdmetResultTrait {
+    trait: 'admet_result';
+    /** Input SMILES */
+    smiles: string;
+    /** Drug-likeness composite score */
+    drugLikenessScore: number;
+    /** Number of Lipinski violations */
+    lipinskiViolations: number;
+    /** Number of properties predicted */
+    propertyCount: number;
+    /** Backend used */
+    backend: AdmetBackend;
+    /** Pass/fail summary — true if drug-likeness > 0.5 and lipinskiViolations <= 1 */
+    passes: boolean;
+}
+/**
+ * Compute Lipinski Rule of 5 violations for a SMILES string.
+ *
+ * This is a simplified heuristic count. A full implementation would use
+ * RDKit to compute exact molecular weight, logP, HBD, HBA from the SMILES.
+ * Here we count violations based on estimated properties.
+ *
+ * Lipinski rules:
+ *   1. MW <= 500 Da
+ *   2. logP <= 5
+ *   3. HBD <= 5
+ *   4. HBA <= 10
+ *
+ * Returns the number of rules violated (0-4).
+ */
+declare function countLipinskiViolations(smiles: string): number;
+/**
+ * Compute a heuristic drug-likeness score (0.0-1.0) from ADMET predictions.
+ *
+ * Weighted composite of:
+ *   - Lipinski compliance (0 violations → 1.0, each violation → -0.2)
+ *   - BBB permeability (if predicted, favorable → +0.15)
+ *   - HIA (if predicted, >80% → +0.1)
+ *   - Toxicity flags (any positive → -0.25 per flag)
+ *   - Half-life in therapeutic range (5-24h → +0.1)
+ */
+declare function computeDrugLikeness(predictions: AdmetPrediction[], lipinskiViolations: number): number;
+/**
+ * Select the appropriate ADMET backend based on question type.
+ *
+ * - 'rdkit': Fast, rule-based + ML, good for screening
+ * - 'admetlab': Comprehensive 47-endpoint prediction, web service
+ * - 'local-ml': On-device, offline, latency-critical
+ */
+declare function selectAdmetBackend(questionType: string): AdmetBackend;
+/**
+ * Compute a provenance anchor for an ADMET prediction, linking it back to the
+ * structural-biology plugin identity and the input SMILES.
+ */
+declare function admetProvenance(result: AdmetResult): string;
+type AdmetCompileFormat = 'csv' | 'json' | 'sdf' | 'holo';
+interface AdmetCompileOptions {
+    format?: AdmetCompileFormat;
+}
+/**
+ * Compile ADMET traits into a target representation.
+ *
+ * - `csv`  — CSV table of property predictions (default)
+ * - `json` — JSON payload for API consumption
+ * - `sdf`  — MDL SDF with ADMET annotations
+ * - `holo` — HoloScript .holo composition
+ */
+declare function compileAdmet(traits: Array<AdmetPredictionTrait | AdmetResultTrait>, opts?: AdmetCompileOptions): string;
+
+/**
+ * @holoscript/structural-biology-plugin — SimulationContract receipt bridge.
+ *
+ * Connects docking and ADMET results to the HoloScript SimulationContract system.
+ * Each docking run and ADMET prediction produces a verifiable receipt that ties
+ * the result back to the structural-biology plugin identity and the input
+ * parameters, enabling provenance tracking across the drug-discovery pipeline.
+ *
+ * ## Architecture
+ *
+ * The docking/ADMET pipeline is steady-state (solve once, not per-frame), so
+ * the receipt pattern follows the ContractedSimulation Route 2d convention:
+ * a single terminal state digest after solve() completes, rather than per-step
+ * digests. The receipt carries:
+ *
+ *   - Plugin identity (structural-biology@version)
+ *   - Input parameters (receptor, ligand, search box, backend)
+ *   - Result summary (best affinity, pose count, drug-likeness)
+ *   - Provenance hash chain (docking provenance + ADMET provenance)
+ *   - Simulation scale tag ('atomistic' for docking, 'empirical-surrogate' for ADMET)
+ *
+ * ## Drug-discovery pipeline
+ *
+ *   AlphaFold (structure) → Docking (affinity) → ADMET (safety) → Receipt (provenance)
+ *
+ * The receipt is the 6th component of the SimContract pattern (per W.058):
+ *   Config → Solver → Solve → Result → Provenance → Receipt
+ *
+ * @module receipt
+ */
+
+/**
+ * Simulation scale tags for drug-discovery pipeline stages.
+ *
+ * - 'atomistic': Molecular docking operates at the atomic scale
+ *   (inter-atomic potentials, protein-ligand geometry)
+ * - 'empirical-surrogate': ADMET prediction uses ML/rule-based models
+ *   trained on experimental data — empirical surrogates by definition
+ */
+type DrugDiscoveryScale = 'atomistic' | 'empirical-surrogate';
+/**
+ * Receipt for a molecular docking simulation run.
+ *
+ * Follows the SimulationContract pattern: config → solver → solve → result →
+ * provenance → receipt. The receipt ties the docking result to the input
+ * parameters and plugin identity, enabling reproducible provenance tracking.
+ *
+ * Scale: 'atomistic' — docking operates at inter-atomic potential scale.
+ */
+interface DockingReceipt {
+    /** Unique receipt ID for this docking run */
+    receiptId: string;
+    /** ISO-8601 timestamp when this receipt was generated */
+    issuedAt: string;
+    /** Plugin identity (structural-biology@version) */
+    pluginId: string;
+    /** Simulation scale — always 'atomistic' for docking */
+    scale: 'atomistic';
+    /** Docking backend used */
+    backend: DockingBackend;
+    /** Input configuration (receptor, ligand, search box) */
+    config: DockingConfig;
+    /** Docking result (best affinity, poses) */
+    result: DockingResult;
+    /** Provenance hash from dockingProvenance() */
+    provenanceHash: string;
+    /** Execution time in milliseconds (if available) */
+    executionTimeMs?: number;
+    /** Whether the docking run succeeded */
+    verified: boolean;
+}
+/**
+ * Receipt for an ADMET prediction run.
+ *
+ * Scale: 'empirical-surrogate' — ADMET predictions use ML/rule-based models.
+ */
+interface AdmetReceipt {
+    /** Unique receipt ID for this ADMET prediction run */
+    receiptId: string;
+    /** ISO-8601 timestamp when this receipt was generated */
+    issuedAt: string;
+    /** Plugin identity (structural-biology@version) */
+    pluginId: string;
+    /** Simulation scale — always 'empirical-surrogate' for ADMET */
+    scale: 'empirical-surrogate';
+    /** ADMET backend used */
+    backend: AdmetBackend;
+    /** Input configuration (SMILES, properties) */
+    config: AdmetConfig;
+    /** ADMET result (predictions, drug-likeness) */
+    result: AdmetResult;
+    /** Provenance hash from admetProvenance() */
+    provenanceHash: string;
+    /** Execution time in milliseconds (if available) */
+    executionTimeMs?: number;
+    /** Whether the ADMET prediction succeeded */
+    verified: boolean;
+}
+/**
+ * Combined receipt for the full drug-discovery pipeline:
+ * AlphaFold structure → Docking → ADMET → Drug-likeness assessment.
+ *
+ * This is the top-level receipt that chains the three stages together
+ * with a composite provenance hash, enabling end-to-end verification
+ * from protein structure prediction through drug-likeness assessment.
+ */
+interface DrugDiscoveryReceipt {
+    /** Unique receipt ID for this pipeline run */
+    receiptId: string;
+    /** ISO-8601 timestamp when this receipt was generated */
+    issuedAt: string;
+    /** Plugin identity (structural-biology@version) */
+    pluginId: string;
+    /** Docking receipt (affinity stage) */
+    docking: DockingReceipt;
+    /** ADMET receipt (safety stage) */
+    admet: AdmetReceipt;
+    /** Composite provenance hash (docking + ADMET) */
+    compositeProvenanceHash: string;
+    /**
+     * Overall drug-likeness assessment combining docking affinity
+     * and ADMET safety profile.
+     */
+    assessment: DrugLikenessAssessment;
+}
+/**
+ * Drug-likeness assessment combining docking affinity and ADMET safety.
+ *
+ * This is the "so what" of the pipeline: does the molecule bind well
+ * AND pass safety screening? A strong binder that fails ADMET is not
+ * a viable drug candidate.
+ */
+interface DrugLikenessAssessment {
+    /** Best binding affinity (kcal/mol) — more negative = stronger binding */
+    bestAffinity: number;
+    /** Drug-likeness score (0.0-1.0) from computeDrugLikeness() */
+    drugLikenessScore: number;
+    /** Number of Lipinski Rule of 5 violations */
+    lipinskiViolations: number;
+    /** Number of ADMET properties predicted */
+    propertyCount: number;
+    /** Whether the molecule passes drug-likeness threshold (>0.5 score, <=1 Lipinski violation) */
+    passes: boolean;
+    /** Ki (inhibition constant) in nM, derived from best affinity */
+    ki_nm?: number;
+    /** Percentage of docking poses below threshold affinity */
+    hitRate?: number;
+    /** Human-readable summary */
+    summary: string;
+}
+/**
+ * Create a receipt for a docking simulation run.
+ *
+ * This is the primary receipt-emission point for the docking stage.
+ * Each docking run produces exactly one receipt that ties the result
+ * to the input configuration and plugin identity.
+ */
+declare function createDockingReceipt(config: DockingConfig, result: DockingResult): DockingReceipt;
+/**
+ * Create a receipt for an ADMET prediction run.
+ *
+ * Each ADMET prediction produces exactly one receipt that ties the result
+ * to the input SMILES and plugin identity.
+ */
+declare function createAdmetReceipt(config: AdmetConfig, result: AdmetResult): AdmetReceipt;
+/**
+ * Create a composite receipt for the full drug-discovery pipeline.
+ *
+ * Chains docking receipt + ADMET receipt into a single provenance chain.
+ * The composite hash ties both stages together so the pipeline is
+ * end-to-end verifiable.
+ */
+declare function createDrugDiscoveryReceipt(dockingReceipt: DockingReceipt, admetReceipt: AdmetReceipt): DrugDiscoveryReceipt;
+/**
+ * Run the full drug-discovery pipeline: docking → ADMET → receipt.
+ *
+ * This is the top-level entry point that chains all three stages together.
+ * Each stage produces its own receipt, and the composite receipt ties them
+ * together for end-to-end provenance.
+ *
+ * @param dockingConfig - Docking configuration (receptor, ligand, search box)
+ * @param dockingResult - Docking result from a DockingSolver
+ * @param admetConfig - ADMET configuration (SMILES, properties)
+ * @param admetResult - ADMET prediction result
+ * @returns Combined drug-discovery receipt
+ */
+declare function runDrugDiscoveryPipeline(dockingConfig: DockingConfig, dockingResult: DockingResult, admetConfig: AdmetConfig, admetResult: AdmetResult): DrugDiscoveryReceipt;
+/**
+ * Compile a DockingReceipt to HoloScript .holo format.
+ */
+declare function compileDockingReceiptToHolo(receipt: DockingReceipt): string;
+/**
+ * Compile an AdmetReceipt to HoloScript .holo format.
+ */
+declare function compileAdmetReceiptToHolo(receipt: AdmetReceipt): string;
+/**
+ * Compile a DrugDiscoveryReceipt to HoloScript .holo format.
+ *
+ * This is the canonical output format for the drug-discovery pipeline:
+ * a .holo composition that chains docking + ADMET + assessment into a
+ * single verifiable artifact.
+ */
+declare function compileDrugDiscoveryReceiptToHolo(receipt: DrugDiscoveryReceipt): string;
+
+/**
+ * @holoscript/structural-biology-plugin — protein/ligand/chain + docking + ADMET.
+ *
+ * Implements the canonical structural-biology vocabulary referenced by
+ * paper-12 (HoloLand I3D) §"Comparison with OpenUSD Schema Plugins": three
+ * domain object types (`protein`, `ligand`, `chain`) plus annotation traits
+ * (`foldable`, `helix`, `sheet`, `residue_anchor`) that compose with the
+ * 28 scientific-computing traits in @holoscript/core.
+ *
+ * v0.2.0 extends the bridge from AlphaFold structure prediction toward
+ * binding affinity (AutoDock-GPU / Vina / GNINA) and ADMET prediction
+ * (RDKit / ADMETlab / local-ML). This connects "structure" to "function" —
+ * the founder direction for quarter-horizon expansion.
+ *
+ * ## New in v0.2.0 (AlphaFold → Binding/ADMET bridge)
+ *
+ * - Docking configuration and result types (AutoDock-GPU, Vina, GNINA)
+ * - ADMET property prediction types (25 endpoints across A/D/M/E/T)
+ * - `auto_dock`, `binding_affinity`, `admet_prediction`, `admet_result` traits
+ *   wired to core's existing scientific-computing trait namespace
+ * - Provenance chain integration for docking and ADMET results
+ * - Compile targets: PDBQT, SDF, CSV, JSON, HoloScript .holo
+ * - Drug-likeness heuristics (Lipinski Rule of 5, composite score)
+ * - Backend selection functions for docking and ADMET
+ *
+ * @module @holoscript/structural-biology-plugin
+ */
+declare const STRUCTURAL_BIOLOGY_OBJECT_TYPES: readonly ["protein", "ligand", "chain"];
+type StructuralBiologyObjectType = (typeof STRUCTURAL_BIOLOGY_OBJECT_TYPES)[number];
+declare const STRUCTURAL_BIOLOGY_TRAITS: readonly ["foldable", "helix", "sheet", "residue_anchor"];
+type StructuralBiologyTraitName = (typeof STRUCTURAL_BIOLOGY_TRAITS)[number];
+/**
+ * Bridge traits this plugin contributes that wire into core's existing
+ * scientific-computing trait namespace. These are NOT redeclared — they
+ * reference `auto_dock`, `binding_affinity` from core's
+ * `SCIENTIFIC_COMPUTING_TRAITS` and add `admet_prediction`, `admet_result`
+ * as new domain traits.
+ */
+declare const BRIDGE_TRAITS: readonly ["auto_dock", "binding_affinity", "admet_prediction", "admet_result"];
+type BridgeTraitName = (typeof BRIDGE_TRAITS)[number];
+interface StructuralBiologyPluginDescriptor {
+    /** Stable plugin identity used in the provenance hash chain. */
+    id: 'structural-biology';
+    version: string;
+    objectTypes: readonly StructuralBiologyObjectType[];
+    traits: readonly StructuralBiologyTraitName[];
+    bridgeTraits: readonly BridgeTraitName[];
+}
+declare const PLUGIN_DESCRIPTOR: StructuralBiologyPluginDescriptor;
+interface PluginHostRegistry {
+    registerObjectType(name: string, descriptor: {
+        plugin: string;
+    }): void;
+    registerTrait(name: string, descriptor: {
+        plugin: string;
+    }): void;
+}
+/**
+ * Single registration entry point. Paper-12 §"Comparison with OpenUSD Schema
+ * Plugins" claims `register()` is the entire effort on the HoloScript side
+ * — this function IS that claim, evaluated for LOC by the comparison harness.
+ *
+ * v0.2.0: Also registers the 4 bridge traits (auto_dock, binding_affinity,
+ * admet_prediction, admet_result) alongside the original annotation traits.
+ */
+declare function register(host: PluginHostRegistry): StructuralBiologyPluginDescriptor;
+interface Residue {
+    chain: string;
+    index: number;
+    resname: string;
+    secondary?: 'helix' | 'sheet' | 'loop';
+}
+interface ProteinObject {
+    type: 'protein';
+    name: string;
+    uniprot?: string;
+    residues: Residue[];
+    traits: StructuralBiologyTraitName[];
+}
+interface LigandObject {
+    type: 'ligand';
+    name: string;
+    smiles?: string;
+    traits: StructuralBiologyTraitName[];
+}
+interface ChainObject {
+    type: 'chain';
+    name: string;
+    parentProtein: string;
+    residueCount: number;
+    traits: StructuralBiologyTraitName[];
+}
+type StructuralBiologyObject = ProteinObject | LigandObject | ChainObject;
+declare function residueAnchor(residue: Residue): string;
+declare function chainHash(obj: StructuralBiologyObject): string;
+declare function verifyChain(obj: StructuralBiologyObject, expected: string): boolean;
+
+declare const VERSION = "0.2.0";
+
+export { ADMET_PROPERTIES, type AdmetBackend, type AdmetCompileFormat, type AdmetCompileOptions, type AdmetConfig, type AdmetPrediction, type AdmetPredictionTrait, type AdmetProperty, type AdmetReceipt, type AdmetResult, type AdmetResultTrait, type AutoDockTrait, BRIDGE_TRAITS, type BindingAffinityTrait, type BridgeTraitName, type ChainObject, type DockingBackend, type DockingCompileFormat, type DockingCompileOptions, type DockingConfig, type DockingPose, type DockingReceipt, type DockingResult, type DockingSolver, type DrugDiscoveryReceipt, type DrugDiscoveryScale, type DrugLikenessAssessment, type LigandObject, PLUGIN_DESCRIPTOR, type PluginHostRegistry, type ProteinObject, type Residue, STRUCTURAL_BIOLOGY_OBJECT_TYPES, STRUCTURAL_BIOLOGY_TRAITS, type StructuralBiologyObject, type StructuralBiologyObjectType, type StructuralBiologyPluginDescriptor, type StructuralBiologyTraitName, VERSION, admetProvenance, chainHash, compileAdmet, compileAdmetReceiptToHolo, compileDocking, compileDockingReceiptToHolo, compileDrugDiscoveryReceiptToHolo, computeDrugLikeness, countLipinskiViolations, createAdmetReceipt, createDockingReceipt, createDrugDiscoveryReceipt, dockingProvenance, register, residueAnchor, runDrugDiscoveryPipeline, selectAdmetBackend, selectDockingBackend, traitToConfig, verifyChain };