[feat.ligand.rho.D7+] two panels were computing halves of one question; they are now joined

Ivan showed me the Ligand Physics panel and asked whether that was the thing. It is
half of it, and it is the half I did not have.

Another session built ligand-physics while I built the halogen audit. Its header says
a clean-context medicinal chemist ranked its two numbers 9/10 — the only ones in the
repo that would change a synthesis queue tomorrow — and it computes exactly the
quantity my panel was reporting as UNMEASURED: V_S,max on the 0.001 a.u. isodensity
surface, with the C–X···max angle that decides whether a positive cap is a σ-hole at
all. My panel computes the other half: whether that hole is AIMED at anything, what it
is aimed at, and what a purely geometric profiler would have claimed instead.

Rather than issue a second SCF for numbers already on screen — wasteful, and a way for
two panels to disagree about one molecule — ligand-physics now publishes its completed
run through a six-line additive hook, and the audit subscribes. Pressing Compute there
resolves the UNMEASURED rows here with no second click. The publisher clears the result
on ligand change, because a number belongs to the molecule it was computed on.

The mapping is keyed by ELEMENT and the code says why that is a stopgap: MEP extrema
are indexed against the isolated ligand RDKit parsed, the pocket walk against the mol*
loci, and quietly assuming those two indexings agree is how a confident wrong answer is
made. One halogen per element — lapatinib's case — is unambiguous. Two chlorines is
not, and then the deeper hole is applied to both, which overstates the weaker one.
Stated in the panel's own source rather than discovered later.

[coord] Six added lines in another session's live facet, purely additive: a module-level
last-result, a getter, a subscribe, and one call at the point the result already lands.
No existing behaviour touched. tsc clean, prd build clean.

Author: ivanicu

src/app.frontend.facets.molstar-rdkit.editable/facets/halogen-audit/index.ts

@@ -21,6 +21,7 @@ import { StructureSelectionQueries } from '../../../mol-plugin-state/helpers/str
 import { auditHalogen, HalogenAudit, PocketAtom, ELECTRONIC } from '../../../chemistry.backend.perception.rdkit-wasm.editable/halogen-audit';
 import { extractLigandAtomData, lociFromFocusOptions } from '../../../chemistry.backend.perception.rdkit-wasm.editable/ligand-pipeline';
 import type { LigandFocusOptions } from '../../../chemistry.backend.perception.rdkit-wasm.editable/semantic-focus';
+import { onSurfaceResult, getLastSurfaceResult } from '../ligand-physics';
 
 const HALOGENS = new Set(['F', 'CL', 'BR', 'I']);
 
@@ -134,14 +135,56 @@ export function renderHalogenPanel(rows: HalogenRow[]) {
     </div>`).join('');
 }
 
+/**
+ * V_S,max comes from the Ligand Physics panel's own SCF rather than a second one.
+ *
+ * That panel answers "is there a σ-hole and how deep"; this one answers "is anything on
+ * the axis". Two halves of one question that have lived in two different products for
+ * years — and issuing our own /surface/mep for numbers already on screen would be both
+ * wasteful and a way for the two panels to disagree about the same molecule.
+ *
+ * Keyed by element, and that is a stopgap the code says out loud: the MEP extrema are
+ * indexed against the isolated ligand RDKit parsed, while the pocket walk is indexed
+ * against the mol* loci, and quietly assuming those agree is how a confident wrong answer
+ * gets made. With one halogen of each element — the common case, and true of lapatinib —
+ * the mapping is unambiguous. With two chlorines it is not, and then the deeper hole is
+ * used for both, which overstates the weaker one.
+ */
+function qmFromSurface(): Map<string, { vsMax: number, anisotropy: number | null, basis?: string, method?: string }> {
+    const out = new Map<string, { vsMax: number, anisotropy: number | null, basis?: string, method?: string }>();
+    const last = getLastSurfaceResult();
+    if (!last) return out;
+    for (const e of last.extrema) {
+        if (e.kind !== 'maximum' || !e.sigma_hole) continue;
+        const el = (e.element || '').toUpperCase();
+        if (!HALOGENS.has(el)) continue;
+        const prev = out.get(el);
+        if (prev && prev.vsMax >= e.value_kcal_per_mol) continue;
+        out.set(el, {
+            vsMax: e.value_kcal_per_mol,
+            anisotropy: e.sigma_hole.anisotropy_kcal_per_mol ?? null,
+            basis: last.meta.basis,
+            method: last.meta.method,
+        });
+    }
+    return out;
+}
+
+let current: { structure: Structure, options: LigandFocusOptions } | null = null;
+let subscribed = false;
+
 /** Called from the same lifecycle point that refreshes the other ligand facets. */
-export function updateHalogenAudit(
-    structure: Structure | null, options: LigandFocusOptions,
-    qmBySymbol?: Map<string, { vsMax: number, anisotropy: number | null, basis?: string, method?: string }>,
-) {
-    if (!structure) { renderHalogenPanel([]); return; }
+export function updateHalogenAudit(structure: Structure | null, options: LigandFocusOptions) {
+    if (!subscribed) {
+        subscribed = true;
+        // Re-render the moment the physics panel finishes, so pressing Compute over there
+        // resolves the UNMEASURED rows here without a second click.
+        onSurfaceResult(() => { if (current) updateHalogenAudit(current.structure, current.options); });
+    }
+    if (!structure) { current = null; renderHalogenPanel([]); return; }
+    current = { structure, options };
     try {
-        renderHalogenPanel(auditLigandHalogens(structure, options, qmBySymbol));
+        renderHalogenPanel(auditLigandHalogens(structure, options, qmFromSurface()));
     } catch (error) {
         console.error('halogen audit failed', error);
         renderHalogenPanel([]);

src/app.frontend.facets.molstar-rdkit.editable/facets/ligand-physics/index.ts

@@ -191,6 +191,20 @@ function extremaTable(extrema: Extremum[], pct: number): string {
         <tbody>${rows}</tbody></table>`;
 }
 
+/** The last completed surface run, for consumers that need the numbers rather than the table. */
+let lastSurface: { extrema: Extremum[], meta: SurfaceMeta } | null = null;
+const surfaceListeners = new Set<(r: { extrema: Extremum[], meta: SurfaceMeta }) => void>();
+
+export function getLastSurfaceResult() { return lastSurface; }
+export function onSurfaceResult(cb: (r: { extrema: Extremum[], meta: SurfaceMeta }) => void) {
+    surfaceListeners.add(cb);
+    return () => surfaceListeners.delete(cb);
+}
+function publishSurfaceResult(extrema: Extremum[], meta: SurfaceMeta) {
+    lastSurface = { extrema, meta };
+    for (const cb of surfaceListeners) { try { cb(lastSurface); } catch (e) { console.error(e); } }
+}
+
 function surfacePanel(extrema: Extremum[], meta: SurfaceMeta): string {
     const pct = meta.absolute_uncertainty_pct ?? 25;
     const holes = meta.sigma_holes_found;
@@ -295,6 +309,11 @@ async function runSurface() {
         }
         const host = byId('phys-surface-body');
         if (host) host.innerHTML = surfacePanel(out.extrema, out.meta);
+        // Publish, so the halogen audit can ask what the σ-hole POINTS AT without issuing a
+        // second SCF for numbers that already exist. This panel answers "is there a hole and
+        // how deep"; that one answers "is anything on the axis" — two halves of one question
+        // that have historically lived in two different products.
+        publishSurfaceResult(out.extrema, out.meta);
         setStatus('phys-surface-status',
             `Surface electrostatics for ${ligandLabel ?? 'ligand'}.`, 'ok');
         try { await markExtrema(out.extrema); } catch { /* table still stands */ }
@@ -376,6 +395,9 @@ export function initLigandPhysicsPanel(p: PluginContext) {
 /** Same contract as the other facets: the lab hands over the focused ligand's
  * molfile, already in scene coordinates. */
 export function updateLigandPhysics(nextMolfile: string | null, label: string | null) {
+    // A result belongs to the molecule it was computed on; carrying it across a ligand
+    // switch is how a number ends up describing something it never saw.
+    lastSurface = null;
     const changed = nextMolfile !== molfile;
     molfile = nextMolfile;
     ligandLabel = label;