react-cheminfo 0.76.0 → 0.78.0

package/lib/osiris/core/predictionQueue.js

@@ -0,0 +1,57 @@
+/**
+ * What is still to be predicted, in the order it will be.
+ *
+ * Arrival order by default, because that is the order the reader read the file
+ * in. On top of it sits a short list of keys to answer first — the rows
+ * actually on screen — which is re-laid every time the reader scrolls or
+ * focuses a row. A key named as wanted that has since been answered or removed
+ * is skipped rather than looked up again.
+ */
+/**
+ * A queue of molecules to predict.
+ * @returns The queue, empty.
+ */
+export function createPredictionQueue() {
+    const waiting = new Map();
+    let wanted = [];
+    let cursor = 0;
+    return {
+        get size() {
+            return waiting.size;
+        },
+        has: (key) => waiting.has(key),
+        add(input) {
+            if (waiting.has(input.key))
+                return false;
+            waiting.set(input.key, input);
+            return true;
+        },
+        take() {
+            while (cursor < wanted.length) {
+                const key = wanted[cursor];
+                cursor += 1;
+                const next = waiting.get(key);
+                if (next !== undefined) {
+                    waiting.delete(key);
+                    return next;
+                }
+            }
+            const first = waiting.keys().next();
+            if (first.done === true)
+                return undefined;
+            const next = waiting.get(first.value);
+            waiting.delete(first.value);
+            return next;
+        },
+        prioritize(keys) {
+            wanted = [...keys];
+            cursor = 0;
+        },
+        clear() {
+            waiting.clear();
+            wanted = [];
+            cursor = 0;
+        },
+    };
+}
+//# sourceMappingURL=predictionQueue.js.map

package/lib/osiris/core/predictionQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictionQueue.js","sourceRoot":"","sources":["../../../src/osiris/core/predictionQueue.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAmCH;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,MAAM,OAAO,GAAG,IAAI,GAAG,EAA2B,CAAC;IACnD,IAAI,MAAM,GAAsB,EAAE,CAAC;IACnC,IAAI,MAAM,GAAG,CAAC,CAAC;IAEf,OAAO;QACL,IAAI,IAAI;YACN,OAAO,OAAO,CAAC,IAAI,CAAC;QACtB,CAAC;QACD,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;QAC9B,GAAG,CAAC,KAAK;YACP,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;gBAAE,OAAO,KAAK,CAAC;YACzC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI;YACF,OAAO,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;gBAC9B,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAW,CAAC;gBACrC,MAAM,IAAI,CAAC,CAAC;gBACZ,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;oBACvB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oBACpB,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;YACD,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;YACpC,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI;gBAAE,OAAO,SAAS,CAAC;YAC1C,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAoB,CAAC;YACzD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC5B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,UAAU,CAAC,IAAI;YACb,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;YACnB,MAAM,GAAG,CAAC,CAAC;QACb,CAAC;QACD,KAAK;YACH,OAAO,CAAC,KAAK,EAAE,CAAC;YAChB,MAAM,GAAG,EAAE,CAAC;YACZ,MAAM,GAAG,CAAC,CAAC;QACb,CAAC;KACF,CAAC;AACJ,CAAC"}

package/lib/osiris/core/predictors.d.ts

@@ -0,0 +1,62 @@
+/**
+ * OpenChemLib, loaded once and proved to be working before anything is
+ * predicted with it.
+ *
+ * Both predictors throw `static resources must be registered first` until
+ * `Resources.register*` has run — but only when *nothing* was registered. If
+ * something else was, `new ToxicityPredictor()` constructs happily, prints to
+ * the console, and answers every `assessRisk` with `RISK_UNKNOWN`, on which
+ * `DrugScoreCalculator` applies no penalty at all. The failure therefore reads
+ * on screen as four clean molecules and a healthy score. So the tables are
+ * proved here, at start-up, against a molecule whose answer is known: a
+ * fragment match that must come back high, and a drug-likeness that must be a
+ * real number. Between them the two families of resource file are both covered.
+ *
+ * The check costs about 160 ms once per worker, most of which is warm-up the
+ * first real molecule would have paid anyway — measured, a first prediction is
+ * 320 ms cold against 191 ms warm.
+ */
+import type * as OCL from 'openchemlib';
+/**
+ * Where the resource tables come from: the URL of the site's own
+ * `openchemlib-resources.json`, or the parsed file itself.
+ *
+ * A URL must be absolute. `registerFromUrl` resolves a relative one against
+ * `import.meta.url`, which after a build is a hashed chunk under `assets/`, so
+ * it answers 404 and every prediction quietly becomes unknown.
+ */
+export type ResourceSource = string | Readonly<Record<string, string>>;
+/** OpenChemLib, registered, checked and ready to predict with. */
+export interface OsirisPredictors {
+    /** Reads an idCode or a SMILES into a molecule. */
+    Molecule: typeof OCL.Molecule;
+    /** cLogP, solubility, TPSA and the four counts. */
+    MoleculeProperties: typeof OCL.MoleculeProperties;
+    /** Finds a toxicophore on a molecule, in the predictor's own match mode. */
+    SSSearcher: typeof OCL.SSSearcher;
+    /** The four spline terms and the four risk factors. */
+    DrugScoreCalculator: typeof OCL.DrugScoreCalculator;
+    /** The four risk assessments and their explanations. */
+    toxicity: OCL.ToxicityPredictor;
+    /** The 5294-fragment drug-likeness table. */
+    druglikeness: OCL.DruglikenessPredictor;
+}
+/** The tables did not load, so nothing may be predicted. */
+export declare class PredictorsUnavailableError extends Error {
+    name: string;
+}
+/**
+ * OpenChemLib with its resources registered and checked.
+ *
+ * Loaded lazily — the library is 340 kB gzipped and does not tree-shake — and
+ * kept, because `Resources.register` replaces the whole map rather than merging
+ * into it, so registering twice with different keys silently unregisters the
+ * first set.
+ * @param source - The resources URL, or the parsed resources themselves.
+ * @returns The predictors, proved to answer.
+ * @throws {PredictorsUnavailableError} When the resources did not load, or loaded and answer nothing.
+ */
+export declare function loadPredictors(source: ResourceSource): Promise<OsirisPredictors>;
+/** Forget the loaded predictors, so the next call registers again. */
+export declare function resetPredictors(): void;
+//# sourceMappingURL=predictors.d.ts.map

package/lib/osiris/core/predictors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictors.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/predictors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,KAAK,GAAG,MAAM,aAAa,CAAC;AAQxC;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAEvE,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,QAAQ,EAAE,OAAO,GAAG,CAAC,QAAQ,CAAC;IAC9B,mDAAmD;IACnD,kBAAkB,EAAE,OAAO,GAAG,CAAC,kBAAkB,CAAC;IAClD,4EAA4E;IAC5E,UAAU,EAAE,OAAO,GAAG,CAAC,UAAU,CAAC;IAClC,uDAAuD;IACvD,mBAAmB,EAAE,OAAO,GAAG,CAAC,mBAAmB,CAAC;IACpD,wDAAwD;IACxD,QAAQ,EAAE,GAAG,CAAC,iBAAiB,CAAC;IAChC,6CAA6C;IAC7C,YAAY,EAAE,GAAG,CAAC,qBAAqB,CAAC;CACzC;AAED,4DAA4D;AAC5D,qBAAa,0BAA2B,SAAQ,KAAK;IAC1C,IAAI,SAAgC;CAC9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAG3B;AAED,sEAAsE;AACtE,wBAAgB,eAAe,IAAI,IAAI,CAEtC"}

package/lib/osiris/core/predictors.js

@@ -0,0 +1,100 @@
+/**
+ * OpenChemLib, loaded once and proved to be working before anything is
+ * predicted with it.
+ *
+ * Both predictors throw `static resources must be registered first` until
+ * `Resources.register*` has run — but only when *nothing* was registered. If
+ * something else was, `new ToxicityPredictor()` constructs happily, prints to
+ * the console, and answers every `assessRisk` with `RISK_UNKNOWN`, on which
+ * `DrugScoreCalculator` applies no penalty at all. The failure therefore reads
+ * on screen as four clean molecules and a healthy score. So the tables are
+ * proved here, at start-up, against a molecule whose answer is known: a
+ * fragment match that must come back high, and a drug-likeness that must be a
+ * real number. Between them the two families of resource file are both covered.
+ *
+ * The check costs about 160 ms once per worker, most of which is warm-up the
+ * first real molecule would have paid anyway — measured, a first prediction is
+ * 320 ms cold against 191 ms warm.
+ */
+import { NO_FRAGMENT_MATCHED, RISK_TYPE_CODES, UNKNOWN_NUMBER, } from "./constants.js";
+/** The tables did not load, so nothing may be predicted. */
+export class PredictorsUnavailableError extends Error {
+    name = 'PredictorsUnavailableError';
+}
+/**
+ * OpenChemLib with its resources registered and checked.
+ *
+ * Loaded lazily — the library is 340 kB gzipped and does not tree-shake — and
+ * kept, because `Resources.register` replaces the whole map rather than merging
+ * into it, so registering twice with different keys silently unregisters the
+ * first set.
+ * @param source - The resources URL, or the parsed resources themselves.
+ * @returns The predictors, proved to answer.
+ * @throws {PredictorsUnavailableError} When the resources did not load, or loaded and answer nothing.
+ */
+export function loadPredictors(source) {
+    if (loaded === null)
+        loaded = start(source);
+    return loaded;
+}
+/** Forget the loaded predictors, so the next call registers again. */
+export function resetPredictors() {
+    loaded = null;
+}
+let loaded = null;
+/**
+ * A failed load is not kept: a fetch that failed once may well answer on the
+ * next try, and a cached rejection would turn one lost packet into a page that
+ * stays broken until it is reloaded.
+ * @param source - The resources URL, or the parsed resources themselves.
+ * @returns The predictors, proved to answer.
+ */
+function start(source) {
+    const pending = build(source);
+    void pending.catch(() => {
+        if (loaded === pending)
+            loaded = null;
+    });
+    return pending;
+}
+/** Benzidine — its mutagenicity comes from a fragment match, not from a list. */
+const PROBE_ID_CODE = 'dg}@@@mIe]e^ftx@H@H@@';
+const UNAVAILABLE = 'The prediction tables did not load, so no risk or drug-likeness can be computed. Reload the page.';
+async function build(source) {
+    const ocl = await import('openchemlib');
+    try {
+        if (typeof source === 'string')
+            await ocl.Resources.registerFromUrl(source);
+        else
+            ocl.Resources.register({ ...source });
+    }
+    catch {
+        throw new PredictorsUnavailableError(UNAVAILABLE);
+    }
+    let toxicity;
+    let druglikeness;
+    try {
+        toxicity = new ocl.ToxicityPredictor();
+        druglikeness = new ocl.DruglikenessPredictor();
+    }
+    catch {
+        throw new PredictorsUnavailableError(UNAVAILABLE);
+    }
+    const probe = ocl.Molecule.fromIDCode(PROBE_ID_CODE);
+    const risk = toxicity.assessRisk(probe, RISK_TYPE_CODES.mutagenic);
+    const likeness = druglikeness.assessDruglikeness(probe);
+    if (risk !== 3 ||
+        likeness === UNKNOWN_NUMBER ||
+        likeness === NO_FRAGMENT_MATCHED) {
+        throw new PredictorsUnavailableError(UNAVAILABLE);
+    }
+    return {
+        Molecule: ocl.Molecule,
+        MoleculeProperties: ocl.MoleculeProperties,
+        SSSearcher: ocl.SSSearcher,
+        DrugScoreCalculator: ocl.DrugScoreCalculator,
+        toxicity,
+        druglikeness,
+    };
+}
+//# sourceMappingURL=predictors.js.map

package/lib/osiris/core/predictors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictors.js","sourceRoot":"","sources":["../../../src/osiris/core/predictors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,cAAc,GACf,MAAM,gBAAgB,CAAC;AA4BxB,4DAA4D;AAC5D,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IAC1C,IAAI,GAAG,4BAA4B,CAAC;CAC9C;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAsB;IAEtB,IAAI,MAAM,KAAK,IAAI;QAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IAC5C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,eAAe;IAC7B,MAAM,GAAG,IAAI,CAAC;AAChB,CAAC;AAED,IAAI,MAAM,GAAqC,IAAI,CAAC;AAEpD;;;;;;GAMG;AACH,SAAS,KAAK,CAAC,MAAsB;IACnC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IAC9B,KAAK,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;QACtB,IAAI,MAAM,KAAK,OAAO;YAAE,MAAM,GAAG,IAAI,CAAC;IACxC,CAAC,CAAC,CAAC;IACH,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,iFAAiF;AACjF,MAAM,aAAa,GAAG,uBAAuB,CAAC;AAE9C,MAAM,WAAW,GACf,mGAAmG,CAAC;AAEtG,KAAK,UAAU,KAAK,CAAC,MAAsB;IACzC,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;IACxC,IAAI,CAAC;QACH,IAAI,OAAO,MAAM,KAAK,QAAQ;YAAE,MAAM,GAAG,CAAC,SAAS,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;;YACvE,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;IAC7C,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,0BAA0B,CAAC,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,IAAI,QAA+B,CAAC;IACpC,IAAI,YAAuC,CAAC;IAC5C,IAAI,CAAC;QACH,QAAQ,GAAG,IAAI,GAAG,CAAC,iBAAiB,EAAE,CAAC;QACvC,YAAY,GAAG,IAAI,GAAG,CAAC,qBAAqB,EAAE,CAAC;IACjD,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,0BAA0B,CAAC,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IACrD,MAAM,IAAI,GAAG,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC;IACnE,MAAM,QAAQ,GAAG,YAAY,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACxD,IACE,IAAI,KAAK,CAAC;QACV,QAAQ,KAAK,cAAc;QAC3B,QAAQ,KAAK,mBAAmB,EAChC,CAAC;QACD,MAAM,IAAI,0BAA0B,CAAC,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,kBAAkB,EAAE,GAAG,CAAC,kBAAkB;QAC1C,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,mBAAmB,EAAE,GAAG,CAAC,mBAAmB;QAC5C,QAAQ;QACR,YAAY;KACb,CAAC;AACJ,CAAC"}

package/lib/osiris/core/propertyKeys.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Which of a molecule's predicted numbers the tool shows, and in which order.
+ *
+ * The order is the legacy panel's, top to bottom, and it is the same order the
+ * comparison table's columns and the plot's default axes take: a reader who
+ * learned the panel reads the table without relearning it. The keys are the
+ * field names of {@link OsirisProperties}, so an address carrying
+ * `axes=logP,logS` names the same things the panel does.
+ */
+import type { OsirisProperties } from './types.ts';
+/** The ten numbers the tool shows, in the order it shows them. */
+export declare const PROPERTY_KEYS: readonly ["logP", "logS", "molecularWeight", "polarSurfaceArea", "druglikeness", "acceptorCount", "donorCount", "stereoCenterCount", "rotatableBondCount", "drugScore"];
+/** One of the ten displayed properties. */
+export type PropertyKey = (typeof PROPERTY_KEYS)[number];
+/**
+ * Whether a string names a displayed property, so an address that carries
+ * something else is ignored rather than plotted as a blank axis.
+ * @param value - Whatever the address or the reader supplied.
+ * @returns True when it is one of the ten.
+ */
+export declare function isPropertyKey(value: string): value is PropertyKey;
+/**
+ * One property of one molecule.
+ *
+ * `null` means the predictor could not answer — never zero, and never the
+ * library's own sentinel, both of which plot and sort as real values.
+ * @param properties - What was predicted for the molecule.
+ * @param key - Which of the ten to read.
+ * @returns The number, or `null` when it is unknown.
+ */
+export declare function propertyValue(properties: OsirisProperties, key: PropertyKey): number | null;
+//# sourceMappingURL=propertyKeys.d.ts.map

package/lib/osiris/core/propertyKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyKeys.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/propertyKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,kEAAkE;AAClE,eAAO,MAAM,aAAa,yKAWhB,CAAC;AAEX,2CAA2C;AAC3C,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,WAAW,CAEjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,WAAW,GACf,MAAM,GAAG,IAAI,CAEf"}

package/lib/osiris/core/propertyKeys.js

@@ -0,0 +1,44 @@
+/**
+ * Which of a molecule's predicted numbers the tool shows, and in which order.
+ *
+ * The order is the legacy panel's, top to bottom, and it is the same order the
+ * comparison table's columns and the plot's default axes take: a reader who
+ * learned the panel reads the table without relearning it. The keys are the
+ * field names of {@link OsirisProperties}, so an address carrying
+ * `axes=logP,logS` names the same things the panel does.
+ */
+/** The ten numbers the tool shows, in the order it shows them. */
+export const PROPERTY_KEYS = [
+    'logP',
+    'logS',
+    'molecularWeight',
+    'polarSurfaceArea',
+    'druglikeness',
+    'acceptorCount',
+    'donorCount',
+    'stereoCenterCount',
+    'rotatableBondCount',
+    'drugScore',
+];
+/**
+ * Whether a string names a displayed property, so an address that carries
+ * something else is ignored rather than plotted as a blank axis.
+ * @param value - Whatever the address or the reader supplied.
+ * @returns True when it is one of the ten.
+ */
+export function isPropertyKey(value) {
+    return PROPERTY_KEYS.includes(value);
+}
+/**
+ * One property of one molecule.
+ *
+ * `null` means the predictor could not answer — never zero, and never the
+ * library's own sentinel, both of which plot and sort as real values.
+ * @param properties - What was predicted for the molecule.
+ * @param key - Which of the ten to read.
+ * @returns The number, or `null` when it is unknown.
+ */
+export function propertyValue(properties, key) {
+    return properties[key];
+}
+//# sourceMappingURL=propertyKeys.js.map

package/lib/osiris/core/propertyKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"propertyKeys.js","sourceRoot":"","sources":["../../../src/osiris/core/propertyKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,kEAAkE;AAClE,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,MAAM;IACN,MAAM;IACN,iBAAiB;IACjB,kBAAkB;IAClB,cAAc;IACd,eAAe;IACf,YAAY;IACZ,mBAAmB;IACnB,oBAAoB;IACpB,WAAW;CACH,CAAC;AAKX;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAQ,aAAmC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAC3B,UAA4B,EAC5B,GAAgB;IAEhB,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC"}

package/lib/osiris/core/riskAppearance.d.ts

@@ -0,0 +1,60 @@
+/**
+ * How one risk reads on screen: the word for it, and the tone its square takes.
+ *
+ * Three levels, and they are exactly the three `DrugScoreCalculator` multiplies
+ * by — no risk ×1, medium ×0.8, high ×0.6 — so the colours say what the score
+ * already counted. A fourth tone exists for the state the library calls
+ * `RISK_UNKNOWN`, which means its tables did not load: it is grey, never green,
+ * because "nothing was assessed" and "nothing was found" are different answers
+ * and showing them alike is the one mistake that makes the panel dishonest.
+ *
+ * A fifth, `pending`, is ours: the prediction costs a fifth of a second and the
+ * square is on screen before it comes back.
+ */
+import type { RiskLevel } from './types.ts';
+/** What a square is painted with, before the stylesheet turns it into a colour. */
+export type RiskTone = 'pending' | 'unknown' | 'none' | 'low' | 'high';
+/** How one risk is shown. */
+export interface RiskAppearance {
+    /** The stylesheet's `data-level`, which picks the square's colour. */
+    tone: RiskTone;
+    /** What the square says next to the risk's name, e.g. `High risk`. */
+    label: string;
+    /**
+     * Whether the level is worth opening: an explanation exists for an assessed
+     * risk and for nothing else.
+     */
+    explainable: boolean;
+}
+/** What a square says while its molecule is still being predicted. */
+export declare const PENDING_RISK_LABEL = "Predicting\u2026";
+/**
+ * What a square says when there is no molecule to predict.
+ *
+ * The comparison page draws the panel before a row is picked, and a square that
+ * said `Predicting…` there would claim work nobody asked for — under a heading
+ * inviting the reader to pick a row, which is a plain contradiction.
+ */
+export declare const IDLE_RISK_LABEL = "Not predicted yet";
+/**
+ * What the predictor's own page says about its alerts, word for word.
+ *
+ * Quoted rather than paraphrased: it is the sentence that stops a red square
+ * being read as a verdict, and rewriting it would put our words over his.
+ */
+export declare const RISK_CAVEAT = "Toxicity risk alerts are by no means meant to be a fully reliable toxicity prediction. Nor should be concluded from the absence of risk alerts that a particular substance is completely free of any toxic effect.";
+/**
+ * What is said in place of a highlight when the compound's own idCode is on one
+ * of the RTECS-derived lists. There is no fragment to point at, and painting the
+ * whole molecule would call the compound its own toxicophore.
+ */
+export declare const KNOWN_MOLECULE_NOTE = "This exact compound is on the list, so there is no fragment to point at.";
+/**
+ * The tone and the word for one risk.
+ * @param level - How the risk came back, or `undefined` when there is none yet.
+ * @param pending - Whether a prediction is actually running for this molecule.
+ * @default false
+ * @returns See {@link RiskAppearance}.
+ */
+export declare function riskAppearance(level: RiskLevel | undefined, pending?: boolean): RiskAppearance;
+//# sourceMappingURL=riskAppearance.d.ts.map

package/lib/osiris/core/riskAppearance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskAppearance.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/riskAppearance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,mFAAmF;AACnF,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvE,6BAA6B;AAC7B,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,IAAI,EAAE,QAAQ,CAAC;IACf,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,qBAAgB,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,sBAAsB,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,uNAC8L,CAAC;AAEvN;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,6EAC4C,CAAC;AAE7E;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,OAAO,UAAQ,GACd,cAAc,CAahB"}

package/lib/osiris/core/riskAppearance.js

@@ -0,0 +1,59 @@
+/**
+ * How one risk reads on screen: the word for it, and the tone its square takes.
+ *
+ * Three levels, and they are exactly the three `DrugScoreCalculator` multiplies
+ * by — no risk ×1, medium ×0.8, high ×0.6 — so the colours say what the score
+ * already counted. A fourth tone exists for the state the library calls
+ * `RISK_UNKNOWN`, which means its tables did not load: it is grey, never green,
+ * because "nothing was assessed" and "nothing was found" are different answers
+ * and showing them alike is the one mistake that makes the panel dishonest.
+ *
+ * A fifth, `pending`, is ours: the prediction costs a fifth of a second and the
+ * square is on screen before it comes back.
+ */
+import { RISK_LEVEL_LABELS } from "./constants.js";
+/** What a square says while its molecule is still being predicted. */
+export const PENDING_RISK_LABEL = 'Predicting…';
+/**
+ * What a square says when there is no molecule to predict.
+ *
+ * The comparison page draws the panel before a row is picked, and a square that
+ * said `Predicting…` there would claim work nobody asked for — under a heading
+ * inviting the reader to pick a row, which is a plain contradiction.
+ */
+export const IDLE_RISK_LABEL = 'Not predicted yet';
+/**
+ * What the predictor's own page says about its alerts, word for word.
+ *
+ * Quoted rather than paraphrased: it is the sentence that stops a red square
+ * being read as a verdict, and rewriting it would put our words over his.
+ */
+export const RISK_CAVEAT = 'Toxicity risk alerts are by no means meant to be a fully reliable toxicity prediction. Nor should be concluded from the absence of risk alerts that a particular substance is completely free of any toxic effect.';
+/**
+ * What is said in place of a highlight when the compound's own idCode is on one
+ * of the RTECS-derived lists. There is no fragment to point at, and painting the
+ * whole molecule would call the compound its own toxicophore.
+ */
+export const KNOWN_MOLECULE_NOTE = 'This exact compound is on the list, so there is no fragment to point at.';
+/**
+ * The tone and the word for one risk.
+ * @param level - How the risk came back, or `undefined` when there is none yet.
+ * @param pending - Whether a prediction is actually running for this molecule.
+ * @default false
+ * @returns See {@link RiskAppearance}.
+ */
+export function riskAppearance(level, pending = false) {
+    if (level === undefined) {
+        return {
+            tone: 'pending',
+            label: pending ? PENDING_RISK_LABEL : IDLE_RISK_LABEL,
+            explainable: false,
+        };
+    }
+    return {
+        tone: level,
+        label: RISK_LEVEL_LABELS[level],
+        explainable: level !== 'unknown',
+    };
+}
+//# sourceMappingURL=riskAppearance.js.map

package/lib/osiris/core/riskAppearance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskAppearance.js","sourceRoot":"","sources":["../../../src/osiris/core/riskAppearance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAmBnD,sEAAsE;AACtE,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GACtB,oNAAoN,CAAC;AAEvN;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC9B,0EAA0E,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAC5B,KAA4B,EAC5B,OAAO,GAAG,KAAK;IAEf,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,eAAe;YACrD,WAAW,EAAE,KAAK;SACnB,CAAC;IACJ,CAAC;IACD,OAAO;QACL,IAAI,EAAE,KAAK;QACX,KAAK,EAAE,iBAAiB,CAAC,KAAK,CAAC;QAC/B,WAAW,EAAE,KAAK,KAAK,SAAS;KACjC,CAAC;AACJ,CAAC"}

package/lib/osiris/core/riskDetail.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Why one risk came back as it did, with the offending substructure located on
+ * the molecule.
+ *
+ * The match runs in the predictor's own mode —
+ * `new SSSearcher({ matchAtomCharge: true, matchAromDBondToDelocalized: false })`,
+ * which is OpenChemLib's mode 1. The JavaScript default is mode 8, and it can
+ * disagree with what `assessRisk` actually found, which would leave a risk
+ * reported with nothing highlighted and no way to tell why.
+ */
+import type * as OCL from 'openchemlib';
+import type { OsirisPredictors } from './predictors.ts';
+import type { RiskDetail, RiskType } from './types.ts';
+/**
+ * What the predictor found, and where on the molecule it found it.
+ * @param molecule - The molecule the risk was assessed on. It is copied before being searched.
+ * @param risk - Which of the four risks to explain.
+ * @param predictors - OpenChemLib with its resources registered and checked.
+ * @returns One finding per sentence the predictor printed, and one per matched fragment.
+ */
+export declare function riskDetail(molecule: OCL.Molecule, risk: RiskType, predictors: OsirisPredictors): RiskDetail;
+//# sourceMappingURL=riskDetail.d.ts.map

package/lib/osiris/core/riskDetail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskDetail.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/riskDetail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,KAAK,GAAG,MAAM,aAAa,CAAC;AAGxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,KAAK,EAEV,UAAU,EAEV,QAAQ,EACT,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,GAAG,CAAC,QAAQ,EACtB,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,gBAAgB,GAC3B,UAAU,CAgBZ"}

package/lib/osiris/core/riskDetail.js

@@ -0,0 +1,86 @@
+/**
+ * Why one risk came back as it did, with the offending substructure located on
+ * the molecule.
+ *
+ * The match runs in the predictor's own mode —
+ * `new SSSearcher({ matchAtomCharge: true, matchAromDBondToDelocalized: false })`,
+ * which is OpenChemLib's mode 1. The JavaScript default is mode 8, and it can
+ * disagree with what `assessRisk` actually found, which would leave a risk
+ * reported with nothing highlighted and no way to tell why.
+ */
+import { RISK_TYPE_CODES } from "./constants.js";
+import { parseRiskFindings } from "./riskFindings.js";
+/**
+ * What the predictor found, and where on the molecule it found it.
+ * @param molecule - The molecule the risk was assessed on. It is copied before being searched.
+ * @param risk - Which of the four risks to explain.
+ * @param predictors - OpenChemLib with its resources registered and checked.
+ * @returns One finding per sentence the predictor printed, and one per matched fragment.
+ */
+export function riskDetail(molecule, risk, predictors) {
+    const working = molecule.getCompactCopy();
+    const entries = predictors.toxicity.getDetail(working, RISK_TYPE_CODES[risk]);
+    const findings = [];
+    for (const finding of parseRiskFindings(entries)) {
+        findings.push(finding.idCode === null
+            ? finding
+            : { ...finding, ...locate(working, finding.idCode, predictors) });
+    }
+    return { risk, findings };
+}
+function locate(molecule, fragmentIdCode, predictors) {
+    let fragment;
+    try {
+        fragment = predictors.Molecule.fromIDCode(fragmentIdCode);
+    }
+    catch {
+        return { atoms: [], bonds: [] };
+    }
+    const searcher = new predictors.SSSearcher({
+        matchAtomCharge: true,
+        matchAromDBondToDelocalized: false,
+    });
+    searcher.setMol(fragment, molecule);
+    if (!searcher.isFragmentInMolecule())
+        return { atoms: [], bonds: [] };
+    searcher.findFragmentInMolecule({ countMode: 'overlapping' });
+    const atoms = new Set();
+    const bonds = new Set();
+    for (const match of searcher.getMatchList()) {
+        collect(molecule, fragment, match, atoms, bonds);
+    }
+    return { atoms: sorted(atoms), bonds: sorted(bonds) };
+}
+/**
+ * Add one match's atoms and bonds to the running sets.
+ *
+ * A fragment atom the query marked as an exclude group maps to -1, and a bond
+ * between two matched atoms may not exist in the molecule when the fragment
+ * matched through a bridge, so both are checked rather than assumed.
+ * @param molecule - The molecule searched.
+ * @param fragment - The fragment that matched.
+ * @param map - The molecule's atom for each of the fragment's, -1 for none.
+ * @param atoms - The matched atoms so far, added to.
+ * @param bonds - The matched bonds so far, added to.
+ */
+function collect(molecule, fragment, map, atoms, bonds) {
+    for (const atom of map) {
+        if (atom >= 0)
+            atoms.add(atom);
+    }
+    for (let bond = 0; bond < fragment.getAllBonds(); bond++) {
+        const first = map[fragment.getBondAtom(0, bond)];
+        const second = map[fragment.getBondAtom(1, bond)];
+        if (first === undefined || second === undefined)
+            continue;
+        if (first < 0 || second < 0)
+            continue;
+        const found = molecule.getBond(first, second);
+        if (found !== -1)
+            bonds.add(found);
+    }
+}
+function sorted(values) {
+    return Array.from(values).toSorted((a, b) => a - b);
+}
+//# sourceMappingURL=riskDetail.js.map

package/lib/osiris/core/riskDetail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskDetail.js","sourceRoot":"","sources":["../../../src/osiris/core/riskDetail.ts"],"names":[],"mappings":"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"}

package/lib/osiris/core/riskDetailRequest.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Asking a worker why one risk came back as it did, and asking again when the
+ * set's cancel took the question with it.
+ *
+ * An explanation travels on a properties channel, and `cancel` drops every
+ * request on every channel — the reader's click included, which then reads as
+ * the channel's own words in place of the findings. It is not part of the set
+ * being abandoned, so it is simply asked for again.
+ *
+ * A channel of its own would be the other way, and is worse here: a channel
+ * makes its worker on the first request, so the first click would wait for
+ * OpenChemLib and the 398 kB of resource tables to load in a cold worker,
+ * where the shared one is already warm. The retry costs one more message on a
+ * worker that is running anyway.
+ */
+import type { WorkerChannel } from '../../worker/core/workerChannelTypes.ts';
+import type { PredictRequest, PredictResponse, RiskDetailRequest } from './predictProtocol.ts';
+type Channel = WorkerChannel<PredictRequest, PredictResponse>;
+/** What the reader is told when the second ask was dropped as well. */
+export declare const RISK_DETAIL_DROPPED = "That explanation was dropped when the run stopped. Close the risk square and open it again.";
+/**
+ * Ask a worker to explain one risk, once more if a cancel dropped the ask.
+ * @param channelOf - Picks the channel to ask on, called again for the retry so it lands on whichever worker is least busy by then.
+ * @param request - The explanation to ask for.
+ * @param mayRetry - Whether asking again can still be answered: false once the pool is terminated, or once its resources are known not to have loaded.
+ * @returns Whatever the worker answered, including its `unavailable`.
+ * @throws {Error} When the ask was dropped and cannot be made again.
+ */
+export declare function requestRiskDetail(channelOf: () => Channel, request: RiskDetailRequest, mayRetry: () => boolean): Promise<PredictResponse>;
+export {};
+//# sourceMappingURL=riskDetailRequest.d.ts.map

package/lib/osiris/core/riskDetailRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riskDetailRequest.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/riskDetailRequest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAE7E,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAE9B,KAAK,OAAO,GAAG,aAAa,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;AAE9D,uEAAuE;AACvE,eAAO,MAAM,mBAAmB,gGAC+D,CAAC;AAEhG;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,OAAO,EACxB,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,MAAM,OAAO,GACtB,OAAO,CAAC,eAAe,CAAC,CAQ1B"}