@holoscript/structural-biology-plugin 0.0.1

package/dist/index.mjs

@@ -0,0 +1,629 @@
+// src/docking.ts
+function traitToConfig(trait) {
+  return {
+    backend: trait.backend,
+    receptor: trait.receptor,
+    ligand: trait.ligand,
+    centerX: trait.searchCenter.x,
+    centerY: trait.searchCenter.y,
+    centerZ: trait.searchCenter.z,
+    sizeX: trait.searchSize.x,
+    sizeY: trait.searchSize.y,
+    sizeZ: trait.searchSize.z,
+    numRuns: trait.numRuns,
+    scoringFunction: trait.scoringFunction
+  };
+}
+function dockingProvenance(result) {
+  const { fnv1a: fnv1a2 } = /* @__PURE__ */ (() => {
+    let h = 2166136261;
+    const fnv = (s) => {
+      h = 2166136261;
+      for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+      }
+      return (h >>> 0).toString(16).padStart(8, "0");
+    };
+    return { fnv1a: fnv };
+  })();
+  const head = `structural-biology@0.1.0|docking|${result.backend}`;
+  const receptorHash = fnv1a2(result.receptorId);
+  const ligandHash = fnv1a2(result.ligandId);
+  const affinityKey = `best:${result.bestAffinity?.toFixed(2) ?? "unknown"}`;
+  const poseKey = `poses:${result.poses.length}`;
+  return fnv1a2(`${head}|r:${receptorHash}|l:${ligandHash}|${affinityKey}|${poseKey}`);
+}
+function selectDockingBackend(questionType) {
+  const q = questionType.toLowerCase();
+  if (q.includes("screen") || q.includes("high-throughput") || q.includes("batch") || q.includes("many")) {
+    return "autodock-gpu";
+  }
+  if (q.includes("cnn") || q.includes("ml") || q.includes("gnina") || q.includes("neural") || q.includes("deep learning")) {
+    return "gnina";
+  }
+  return "autodock-vina";
+}
+function compileDocking(traits, opts = {}) {
+  const format = opts.format ?? "pdbqt";
+  switch (format) {
+    case "pdbqt":
+      return compileDockingToPdbqt(traits);
+    case "sdf":
+      return compileDockingToSdf(traits);
+    case "csv":
+      return compileDockingToCsv(traits);
+    case "holo":
+      return compileDockingToHolo(traits);
+    default:
+      throw new Error(`Unsupported docking format: ${format}`);
+  }
+}
+function compileDockingToPdbqt(traits) {
+  const lines = ["HEADER    HOLOSCRIPT DOCKING PLUGIN"];
+  for (const t of traits) {
+    if (t.trait === "auto_dock") {
+      lines.push(`REMARK 400 DOCKING backend=${t.backend}`);
+      lines.push(
+        `REMARK 400 SEARCH_CENTER ${t.searchCenter.x},${t.searchCenter.y},${t.searchCenter.z}`
+      );
+      lines.push(`REMARK 400 SEARCH_SIZE ${t.searchSize.x},${t.searchSize.y},${t.searchSize.z}`);
+      lines.push(`REMARK 400 SCORING ${t.scoringFunction ?? "vina"}`);
+      if (t.numRuns) lines.push(`REMARK 400 RUNS ${t.numRuns}`);
+    } else if (t.trait === "binding_affinity") {
+      lines.push(`REMARK 500 BINDING_AFFINITY best=${t.bestAffinity} kcal/mol`);
+      lines.push(`REMARK 500 POSES ${t.poseCount}`);
+      lines.push(
+        `REMARK 500 RMSD_RANGE ${t.bestRmsdRange[0].toFixed(3)}-${t.bestRmsdRange[1].toFixed(3)}`
+      );
+      lines.push(`REMARK 500 BACKEND ${t.backend}`);
+      if (t.ki_nm !== void 0) lines.push(`REMARK 500 KI ${t.ki_nm.toFixed(2)} nM`);
+      if (t.hitRate !== void 0)
+        lines.push(`REMARK 500 HIT_RATE ${(t.hitRate * 100).toFixed(1)}%`);
+    }
+  }
+  lines.push("END");
+  return lines.join("\n");
+}
+function compileDockingToSdf(traits) {
+  const lines = [];
+  for (const t of traits) {
+    if (t.trait === "binding_affinity") {
+      lines.push("ligand");
+      lines.push("  HoloScript");
+      lines.push("");
+      lines.push("  0  0  0  0  0  0  0  0  0  0  0 V2000");
+      lines.push("M  END");
+      lines.push(`>  <docking.backend> (${t.backend})`);
+      lines.push(`${t.backend}`);
+      lines.push("");
+      lines.push(`>  <docking.bestAffinity> (kcal/mol)`);
+      lines.push(`${t.bestAffinity}`);
+      lines.push("");
+      lines.push(`>  <docking.poseCount>`);
+      lines.push(`${t.poseCount}`);
+      lines.push("");
+      lines.push(`>  <docking.rmsdRange>`);
+      lines.push(`${t.bestRmsdRange[0].toFixed(3)},${t.bestRmsdRange[1].toFixed(3)}`);
+      lines.push("");
+      if (t.ki_nm !== void 0) {
+        lines.push(`>  <docking.ki_nm>`);
+        lines.push(`${t.ki_nm.toFixed(2)}`);
+        lines.push("");
+      }
+      lines.push("$$$$");
+    }
+  }
+  return lines.join("\n");
+}
+function compileDockingToCsv(traits) {
+  const rows = [
+    "trait,backend,bestAffinity_kcal_mol,poseCount,rmsdLb,rmsdUb,ki_nm,hitRate"
+  ];
+  for (const t of traits) {
+    if (t.trait === "binding_affinity") {
+      rows.push(
+        `binding_affinity,${t.backend},${t.bestAffinity},${t.poseCount},${t.bestRmsdRange[0]},${t.bestRmsdRange[1]},${t.ki_nm ?? ""},${t.hitRate ?? ""}`
+      );
+    } else if (t.trait === "auto_dock") {
+      rows.push(
+        `auto_dock,${t.backend},,,${t.searchCenter.x},${t.searchCenter.y},${t.searchCenter.z},`
+      );
+    }
+  }
+  return rows.join("\n");
+}
+function compileDockingToHolo(traits) {
+  const lines = ['composition "DockingScene" {'];
+  for (const t of traits) {
+    if (t.trait === "auto_dock") {
+      lines.push(`  object "DockingConfig" @auto_dock {`);
+      lines.push(`    backend: "${t.backend}"`);
+      lines.push(
+        `    center: { x: ${t.searchCenter.x}, y: ${t.searchCenter.y}, z: ${t.searchCenter.z} }`
+      );
+      lines.push(`    size: { x: ${t.searchSize.x}, y: ${t.searchSize.y}, z: ${t.searchSize.z} }`);
+      if (t.numRuns) lines.push(`    numRuns: ${t.numRuns}`);
+      if (t.scoringFunction) lines.push(`    scoringFunction: "${t.scoringFunction}"`);
+      lines.push("  }");
+    } else if (t.trait === "binding_affinity") {
+      lines.push(`  object "BindingAffinity" @binding_affinity {`);
+      lines.push(`    bestAffinity: ${t.bestAffinity}`);
+      lines.push(`    poseCount: ${t.poseCount}`);
+      lines.push(`    rmsdRange: [${t.bestRmsdRange[0]}, ${t.bestRmsdRange[1]}]`);
+      lines.push(`    backend: "${t.backend}"`);
+      if (t.ki_nm !== void 0) lines.push(`    ki_nm: ${t.ki_nm.toFixed(2)}`);
+      if (t.hitRate !== void 0) lines.push(`    hitRate: ${(t.hitRate * 100).toFixed(1)}%`);
+      lines.push("  }");
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/admet.ts
+var ADMET_PROPERTIES = [
+  // Absorption
+  "caco2_permeability",
+  // Caco-2 cell permeability (logPapp)
+  "hia",
+  // Human intestinal absorption (%)
+  "pgp_substrate",
+  // P-glycoprotein substrate (binary)
+  "pgp_inhibitor",
+  // P-glycoprotein inhibitor (binary)
+  "bbb_permeability",
+  // Blood-brain barrier penetration (binary)
+  "cns_permeability",
+  // CNS permeability (binary)
+  // Distribution
+  "vdss",
+  // Volume of distribution at steady state (L/kg)
+  "fraction_unbound",
+  // Fraction unbound in plasma (Fu)
+  "ppb",
+  // Plasma protein binding (%)
+  // Metabolism
+  "cyp2d6_substrate",
+  // CYP2D6 substrate (binary)
+  "cyp3a4_substrate",
+  // CYP3A4 substrate (binary)
+  "cyp1a2_inhibitor",
+  // CYP1A2 inhibitor (binary)
+  "cyp2c19_inhibitor",
+  // CYP2C19 inhibitor (binary)
+  "cyp2c9_inhibitor",
+  // CYP2C9 inhibitor (binary)
+  "cyp2d6_inhibitor",
+  // CYP2D6 inhibitor (binary)
+  "cyp3a4_inhibitor",
+  // CYP3A4 inhibitor (binary)
+  "cyp2d6_inhibitor_v2",
+  // CYP2D6 inhibitor v2 (binary, updated model)
+  // Excretion
+  "half_life",
+  // Elimination half-life (hours)
+  "clearance",
+  // Hepatic clearance (mL/min/kg)
+  // Toxicity
+  "hht",
+  // Human hepatotoxicity (binary)
+  "ames",
+  // Ames mutagenicity (binary)
+  "dili",
+  // Drug-induced liver injury (binary)
+  "skin_sensitization",
+  // Skin sensitization (binary)
+  "carcinogenesis",
+  // Carcinogenicity (binary)
+  "rat_oral_ld50"
+  // Rat oral LD50 (mol/kg)
+];
+function countLipinskiViolations(smiles) {
+  let violations = 0;
+  const heavyAtomCount = (smiles.match(/[A-Z]/g) ?? []).length;
+  const estimatedMW = heavyAtomCount * 13;
+  if (estimatedMW > 500) violations++;
+  const carbonCount = (smiles.match(/C/g) ?? []).length;
+  const polarAtomCount = (smiles.match(/[NO]/g) ?? []).length;
+  const estimatedLogP = carbonCount * 0.54 - polarAtomCount * 1;
+  if (estimatedLogP > 5) violations++;
+  const hbdCount = (smiles.match(/OH|NH/g) ?? []).length;
+  if (hbdCount > 5) violations++;
+  if (polarAtomCount > 10) violations++;
+  return violations;
+}
+function computeDrugLikeness(predictions, lipinskiViolations) {
+  let score = 1;
+  score -= lipinskiViolations * 0.2;
+  for (const p of predictions) {
+    if (p.property === "bbb_permeability" && p.value < 0.5) {
+      score -= 0.15;
+    }
+    if (p.property === "hia" && p.value < 80) {
+      score -= 0.1;
+    }
+    if ((p.property === "ames" || p.property === "hht" || p.property === "dili") && p.value > 0.5) {
+      score -= 0.25;
+    }
+    if (p.property === "half_life" && p.value >= 5 && p.value <= 24) {
+      score += 0.1;
+    }
+  }
+  return Math.max(0, Math.min(1, score));
+}
+function selectAdmetBackend(questionType) {
+  const q = questionType.toLowerCase();
+  if (q.includes("comprehensive") || q.includes("full") || q.includes("admetlab")) {
+    return "admetlab";
+  }
+  if (q.includes("offline") || q.includes("local") || q.includes("latency") || q.includes("edge")) {
+    return "local-ml";
+  }
+  return "rdkit";
+}
+function admetProvenance(result) {
+  let h = 2166136261;
+  const fnv = (s) => {
+    h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+      h ^= s.charCodeAt(i);
+      h = Math.imul(h, 16777619) >>> 0;
+    }
+    return (h >>> 0).toString(16).padStart(8, "0");
+  };
+  const head = `structural-biology@0.1.0|admet|${result.backend}`;
+  const smilesHash = fnv(result.smiles);
+  const predictionKey = `props:${result.predictions.length}`;
+  const scoreKey = `dl:${result.drugLikenessScore?.toFixed(2) ?? "na"}`;
+  const lipinskiKey = `lipinski:${result.lipinskiViolations ?? "na"}`;
+  return fnv(`${head}|smiles:${smilesHash}|${predictionKey}|${scoreKey}|${lipinskiKey}`);
+}
+function compileAdmet(traits, opts = {}) {
+  const format = opts.format ?? "csv";
+  switch (format) {
+    case "csv":
+      return compileAdmetToCsv(traits);
+    case "json":
+      return compileAdmetToJson(traits);
+    case "sdf":
+      return compileAdmetToSdf(traits);
+    case "holo":
+      return compileAdmetToHolo(traits);
+    default:
+      throw new Error(`Unsupported ADMET format: ${format}`);
+  }
+}
+function compileAdmetToCsv(traits) {
+  const rows = [
+    "trait,smiles,backend,properties,drugLikenessScore,lipinskiViolations,passes"
+  ];
+  for (const t of traits) {
+    if (t.trait === "admet_prediction") {
+      const props = t.properties?.join(";") ?? "all";
+      rows.push(`admet_prediction,${t.smiles},${t.backend ?? "rdkit"},${props},,`);
+    } else if (t.trait === "admet_result") {
+      rows.push(
+        `admet_result,${t.smiles},${t.backend},${t.propertyCount},${t.drugLikenessScore},${t.lipinskiViolations},${t.passes}`
+      );
+    }
+  }
+  return rows.join("\n");
+}
+function compileAdmetToJson(traits) {
+  return JSON.stringify(traits, null, 2);
+}
+function compileAdmetToSdf(traits) {
+  const lines = [];
+  for (const t of traits) {
+    lines.push("molecule");
+    lines.push("  HoloScript/ADMET");
+    lines.push("");
+    lines.push("  0  0  0  0  0  0  0  0  0  0  0 V2000");
+    lines.push("M  END");
+    if (t.trait === "admet_result") {
+      lines.push(`>  <admet.drugLikenessScore>`);
+      lines.push(`${t.drugLikenessScore}`);
+      lines.push("");
+      lines.push(`>  <admet.lipinskiViolations>`);
+      lines.push(`${t.lipinskiViolations}`);
+      lines.push("");
+      lines.push(`>  <admet.passes>`);
+      lines.push(`${t.passes}`);
+      lines.push("");
+    }
+    lines.push("$$$$");
+  }
+  return lines.join("\n");
+}
+function compileAdmetToHolo(traits) {
+  const lines = ['composition "AdmetScene" {'];
+  for (const t of traits) {
+    if (t.trait === "admet_prediction") {
+      lines.push(`  object "AdmetPrediction" @admet_prediction {`);
+      lines.push(`    smiles: "${t.smiles}"`);
+      if (t.backend) lines.push(`    backend: "${t.backend}"`);
+      if (t.properties && t.properties.length > 0) {
+        lines.push(`    properties: [${t.properties.map((p) => `"${p}"`).join(", ")}]`);
+      }
+      lines.push("  }");
+    } else if (t.trait === "admet_result") {
+      lines.push(`  object "AdmetResult" @admet_result {`);
+      lines.push(`    smiles: "${t.smiles}"`);
+      lines.push(`    drugLikenessScore: ${t.drugLikenessScore}`);
+      lines.push(`    lipinskiViolations: ${t.lipinskiViolations}`);
+      lines.push(`    propertyCount: ${t.propertyCount}`);
+      lines.push(`    backend: "${t.backend}"`);
+      lines.push(`    passes: ${t.passes}`);
+      lines.push("  }");
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/receipt.ts
+var PLUGIN_ID = "structural-biology@0.2.0";
+function createDockingReceipt(config, result) {
+  const provenanceHash = dockingProvenance(result);
+  const verified = result.status === "success";
+  return {
+    receiptId: `dock-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    issuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pluginId: PLUGIN_ID,
+    scale: "atomistic",
+    backend: result.backend,
+    config,
+    result,
+    provenanceHash,
+    executionTimeMs: result.executionTimeMs,
+    verified
+  };
+}
+function createAdmetReceipt(config, result) {
+  const provenanceHash = admetProvenance(result);
+  const verified = result.status === "success";
+  return {
+    receiptId: `admet-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    issuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pluginId: PLUGIN_ID,
+    scale: "empirical-surrogate",
+    backend: result.backend,
+    config,
+    result,
+    provenanceHash,
+    executionTimeMs: result.executionTimeMs,
+    verified
+  };
+}
+function createDrugDiscoveryReceipt(dockingReceipt, admetReceipt) {
+  const compositeInput = `${dockingReceipt.provenanceHash}|${admetReceipt.provenanceHash}`;
+  let h = 2166136261;
+  for (let i = 0; i < compositeInput.length; i++) {
+    h ^= compositeInput.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  const compositeProvenanceHash = (h >>> 0).toString(16).padStart(8, "0");
+  const bestAffinity = dockingReceipt.result.bestAffinity ?? 0;
+  const drugLikenessScore = admetReceipt.result.drugLikenessScore ?? 0;
+  const lipinskiViolations = admetReceipt.result.lipinskiViolations ?? 0;
+  const propertyCount = admetReceipt.result.predictions.length;
+  const passes = drugLikenessScore > 0.5 && lipinskiViolations <= 1;
+  const assessment = {
+    bestAffinity,
+    drugLikenessScore,
+    lipinskiViolations,
+    propertyCount,
+    passes,
+    ki_nm: dockingReceipt.result.poses[0] ? Math.exp(dockingReceipt.result.bestAffinity * 1e3 / (1989e-6 * 298.15)) : void 0,
+    hitRate: dockingReceipt.result.poses.length > 0 ? dockingReceipt.result.poses.filter((p) => p.affinity <= -7).length / dockingReceipt.result.poses.length : void 0,
+    summary: formatAssessmentSummary(bestAffinity, drugLikenessScore, lipinskiViolations, passes)
+  };
+  return {
+    receiptId: `drug-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    issuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pluginId: PLUGIN_ID,
+    docking: dockingReceipt,
+    admet: admetReceipt,
+    compositeProvenanceHash,
+    assessment
+  };
+}
+function formatAssessmentSummary(bestAffinity, drugLikenessScore, lipinskiViolations, passes) {
+  const affinityStr = bestAffinity < -7 ? `strong binding (${bestAffinity.toFixed(1)} kcal/mol)` : bestAffinity < -5 ? `moderate binding (${bestAffinity.toFixed(1)} kcal/mol)` : `weak binding (${bestAffinity.toFixed(1)} kcal/mol)`;
+  const drugStr = passes ? `drug-like (score=${drugLikenessScore.toFixed(2)}, ${lipinskiViolations} Lipinski violations)` : `not drug-like (score=${drugLikenessScore.toFixed(2)}, ${lipinskiViolations} Lipinski violations)`;
+  return `${affinityStr}, ${drugStr}`;
+}
+function runDrugDiscoveryPipeline(dockingConfig, dockingResult, admetConfig, admetResult) {
+  const dockingReceipt = createDockingReceipt(dockingConfig, dockingResult);
+  const admetReceipt = createAdmetReceipt(admetConfig, admetResult);
+  return createDrugDiscoveryReceipt(dockingReceipt, admetReceipt);
+}
+function compileDockingReceiptToHolo(receipt) {
+  const lines = [
+    'composition "DockingReceipt" {',
+    `  meta {`,
+    `    receiptId: "${receipt.receiptId}"`,
+    `    issuedAt: "${receipt.issuedAt}"`,
+    `    pluginId: "${receipt.pluginId}"`,
+    `    scale: "${receipt.scale}"`,
+    `    backend: "${receipt.backend}"`,
+    `    provenanceHash: "${receipt.provenanceHash}"`,
+    `    verified: ${receipt.verified}`,
+    `  }`,
+    `  config @auto_dock {`,
+    `    receptor: "${receipt.config.receptor}"`,
+    `    ligand: "${receipt.config.ligand}"`,
+    `    center: { x: ${receipt.config.centerX}, y: ${receipt.config.centerY}, z: ${receipt.config.centerZ} }`,
+    `    size: { x: ${receipt.config.sizeX}, y: ${receipt.config.sizeY}, z: ${receipt.config.sizeZ} }`,
+    `  }`,
+    `  result @binding_affinity {`,
+    `    bestAffinity: ${receipt.result.bestAffinity ?? "null"}`,
+    `    poseCount: ${receipt.result.poses.length}`,
+    `    status: "${receipt.result.status}"`,
+    `  }`,
+    `}`
+  ];
+  return lines.join("\n");
+}
+function compileAdmetReceiptToHolo(receipt) {
+  const lines = [
+    'composition "AdmetReceipt" {',
+    `  meta {`,
+    `    receiptId: "${receipt.receiptId}"`,
+    `    issuedAt: "${receipt.issuedAt}"`,
+    `    pluginId: "${receipt.pluginId}"`,
+    `    scale: "${receipt.scale}"`,
+    `    backend: "${receipt.backend}"`,
+    `    provenanceHash: "${receipt.provenanceHash}"`,
+    `    verified: ${receipt.verified}`,
+    `  }`,
+    `  config @admet_prediction {`,
+    `    smiles: "${receipt.config.smiles}"`,
+    `  }`,
+    `  result @admet_result {`,
+    `    drugLikenessScore: ${receipt.result.drugLikenessScore ?? "null"}`,
+    `    lipinskiViolations: ${receipt.result.lipinskiViolations ?? "null"}`,
+    `    propertyCount: ${receipt.result.predictions.length}`,
+    `    status: "${receipt.result.status}"`,
+    `  }`,
+    `}`
+  ];
+  return lines.join("\n");
+}
+function compileDrugDiscoveryReceiptToHolo(receipt) {
+  const lines = [
+    'composition "DrugDiscoveryReceipt" {',
+    `  meta {`,
+    `    receiptId: "${receipt.receiptId}"`,
+    `    issuedAt: "${receipt.issuedAt}"`,
+    `    pluginId: "${receipt.pluginId}"`,
+    `    compositeProvenanceHash: "${receipt.compositeProvenanceHash}"`,
+    `  }`,
+    `  docking {`,
+    `    receiptId: "${receipt.docking.receiptId}"`,
+    `    provenanceHash: "${receipt.docking.provenanceHash}"`,
+    `    backend: "${receipt.docking.backend}"`,
+    `    bestAffinity: ${receipt.assessment.bestAffinity}`,
+    `    poseCount: ${receipt.docking.result.poses.length}`,
+    `  }`,
+    `  admet {`,
+    `    receiptId: "${receipt.admet.receiptId}"`,
+    `    provenanceHash: "${receipt.admet.provenanceHash}"`,
+    `    backend: "${receipt.admet.backend}"`,
+    `    drugLikenessScore: ${receipt.assessment.drugLikenessScore}`,
+    `    lipinskiViolations: ${receipt.assessment.lipinskiViolations}`,
+    `    passes: ${receipt.assessment.passes}`,
+    `  }`,
+    `  assessment {`,
+    `    passes: ${receipt.assessment.passes}`,
+    `    drugLikenessScore: ${receipt.assessment.drugLikenessScore}`,
+    `    bestAffinity: ${receipt.assessment.bestAffinity}`,
+    `    summary: "${receipt.assessment.summary}"`,
+    `  }`,
+    `}`
+  ];
+  return lines.join("\n");
+}
+
+// src/index.ts
+var STRUCTURAL_BIOLOGY_OBJECT_TYPES = ["protein", "ligand", "chain"];
+var STRUCTURAL_BIOLOGY_TRAITS = [
+  "foldable",
+  // protein backbone supports folding state transitions
+  "helix",
+  // alpha-helix secondary-structure annotation
+  "sheet",
+  // beta-sheet secondary-structure annotation
+  "residue_anchor"
+  // per-residue provenance anchor (chain id + index)
+];
+var BRIDGE_TRAITS = [
+  "auto_dock",
+  // Automated molecular docking (core trait)
+  "binding_affinity",
+  // Binding affinity metrics (core trait)
+  "admet_prediction",
+  // ADMET property prediction (new)
+  "admet_result"
+  // ADMET prediction result (new)
+];
+var PLUGIN_DESCRIPTOR = {
+  id: "structural-biology",
+  version: "0.2.0",
+  objectTypes: STRUCTURAL_BIOLOGY_OBJECT_TYPES,
+  traits: STRUCTURAL_BIOLOGY_TRAITS,
+  bridgeTraits: BRIDGE_TRAITS
+};
+function register(host) {
+  for (const name of STRUCTURAL_BIOLOGY_OBJECT_TYPES) {
+    host.registerObjectType(name, { plugin: PLUGIN_DESCRIPTOR.id });
+  }
+  for (const name of STRUCTURAL_BIOLOGY_TRAITS) {
+    host.registerTrait(name, { plugin: PLUGIN_DESCRIPTOR.id });
+  }
+  for (const name of BRIDGE_TRAITS) {
+    host.registerTrait(name, { plugin: PLUGIN_DESCRIPTOR.id });
+  }
+  return PLUGIN_DESCRIPTOR;
+}
+function fnv1a(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function hashHex(s) {
+  return fnv1a(s).toString(16).padStart(8, "0");
+}
+function residueAnchor(residue) {
+  return hashHex(
+    `${PLUGIN_DESCRIPTOR.id}@${PLUGIN_DESCRIPTOR.version}|${residue.chain}:${residue.index}:${residue.resname}:${residue.secondary ?? "loop"}`
+  );
+}
+function chainHash(obj) {
+  const head = `${PLUGIN_DESCRIPTOR.id}@${PLUGIN_DESCRIPTOR.version}|${obj.type}|${obj.name}`;
+  if (obj.type === "protein") {
+    const tail = obj.residues.map(residueAnchor).join(":");
+    return hashHex(`${head}|${tail}|traits:${obj.traits.join(",")}`);
+  }
+  const traitsTail = `traits:${obj.traits.join(",")}`;
+  if (obj.type === "ligand") {
+    return hashHex(`${head}|smiles:${obj.smiles ?? ""}|${traitsTail}`);
+  }
+  return hashHex(`${head}|parent:${obj.parentProtein}|count:${obj.residueCount}|${traitsTail}`);
+}
+function verifyChain(obj, expected) {
+  return chainHash(obj) === expected;
+}
+var VERSION = "0.2.0";
+export {
+  ADMET_PROPERTIES,
+  BRIDGE_TRAITS,
+  PLUGIN_DESCRIPTOR,
+  STRUCTURAL_BIOLOGY_OBJECT_TYPES,
+  STRUCTURAL_BIOLOGY_TRAITS,
+  VERSION,
+  admetProvenance,
+  chainHash,
+  compileAdmet,
+  compileAdmetReceiptToHolo,
+  compileDocking,
+  compileDockingReceiptToHolo,
+  compileDrugDiscoveryReceiptToHolo,
+  computeDrugLikeness,
+  countLipinskiViolations,
+  createAdmetReceipt,
+  createDockingReceipt,
+  createDrugDiscoveryReceipt,
+  dockingProvenance,
+  register,
+  residueAnchor,
+  runDrugDiscoveryPipeline,
+  selectAdmetBackend,
+  selectDockingBackend,
+  traitToConfig,
+  verifyChain
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@holoscript/structural-biology-plugin",
+  "version": "0.0.1",
+  "description": "Structural-biology domain plugin: protein/ligand/chain + docking (AutoDock-GPU/Vina/GNINA) + ADMET prediction (RDKit/ADMETlab/local-ML). Bridge from AlphaFold structure to binding affinity and drug-likeness.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "holoscript",
+    "plugin",
+    "structural-biology",
+    "protein",
+    "alphafold",
+    "autodock",
+    "docking",
+    "binding-affinity",
+    "admet",
+    "drug-discovery",
+    "paper-12"
+  ],
+  "author": "brianonbased-dev",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}