react-cheminfo 0.76.0 → 0.78.0

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

@@ -0,0 +1,42 @@
+/**
+ * Where a property's bar starts, how far it runs, and where its labelled mark
+ * goes.
+ *
+ * Three numbers come out of the domain and are merely arranged here. The
+ * **position** is how far along the scale the value sits and gives the bar its
+ * length; the **fitness** is DataWarrior's own `getValuation`, a continuous
+ * 0-to-1 score that the stylesheet reads as the green-to-red ramp; the
+ * **threshold** is the published rule of thumb — cLogP ≤ 5, logS > −4,
+ * molweight < 450, drug-likeness > 0 — drawn as a mark on the track.
+ *
+ * Nothing here invents a cut-off. A bar whose colour disagreed with the panel's
+ * own scale record would be a second opinion nobody could trace.
+ */
+import type { PropertyKey } from './propertyKeys.ts';
+/** Where a bar's fill and its mark go, all as fractions of the track. */
+export interface BarGeometry {
+    /** Where the fill starts, 0 at the left end of the track and 1 at the right. */
+    start: number;
+    /** How much of the track the fill covers, 0 to 1. */
+    length: number;
+    /** How good the value is: 0 as bad as the ramp goes, 1 inside the preferred band. */
+    fitness: number;
+    /**
+     * Where the fill grows from: the left end of the track, or its middle for a
+     * quantity that runs either side of zero. Drawn as a tick, because a fill
+     * that starts at a quarter of the way along says nothing without it.
+     */
+    origin: number;
+    /** Where the published threshold is marked, or `null` where the property has none. */
+    mark: number | null;
+    /** How that threshold reads, e.g. `≤ 5`, or `null`. */
+    markLabel: string | null;
+}
+/**
+ * Lay out one property's bar.
+ * @param key - Which of the ten properties.
+ * @param value - The predicted number, or `null` when the predictor could not answer.
+ * @returns The geometry, or `null` when there is no bar to draw.
+ */
+export declare function barGeometry(key: PropertyKey, value: number | null): BarGeometry | null;
+//# sourceMappingURL=barGeometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"barGeometry.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/barGeometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,qFAAqF;IACrF,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,sFAAsF;IACtF,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,uDAAuD;IACvD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAQD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,WAAW,GAAG,IAAI,CAmBpB"}

package/lib/osiris/core/barGeometry.js

@@ -0,0 +1,46 @@
+/**
+ * Where a property's bar starts, how far it runs, and where its labelled mark
+ * goes.
+ *
+ * Three numbers come out of the domain and are merely arranged here. The
+ * **position** is how far along the scale the value sits and gives the bar its
+ * length; the **fitness** is DataWarrior's own `getValuation`, a continuous
+ * 0-to-1 score that the stylesheet reads as the green-to-red ramp; the
+ * **threshold** is the published rule of thumb — cLogP ≤ 5, logS > −4,
+ * molweight < 450, drug-likeness > 0 — drawn as a mark on the track.
+ *
+ * Nothing here invents a cut-off. A bar whose colour disagreed with the panel's
+ * own scale record would be a second opinion nobody could trace.
+ */
+import { propertyFitness, propertyPosition } from "./fitness.js";
+import { propertyScale } from "./scales.js";
+/**
+ * Where a diverging bar grows from: the middle of its own range, which is
+ * drug-likeness 0 and drug score 0.
+ */
+const DIVERGING_ORIGIN = 0.5;
+/**
+ * Lay out one property's bar.
+ * @param key - Which of the ten properties.
+ * @param value - The predicted number, or `null` when the predictor could not answer.
+ * @returns The geometry, or `null` when there is no bar to draw.
+ */
+export function barGeometry(key, value) {
+    const position = propertyPosition(key, value);
+    if (position === null)
+        return null;
+    const scale = propertyScale(key);
+    const origin = scale.diverging ? DIVERGING_ORIGIN : 0;
+    const mark = scale.threshold === null
+        ? null
+        : propertyPosition(key, scale.threshold.value);
+    return {
+        start: Math.min(origin, position),
+        length: Math.abs(position - origin),
+        fitness: propertyFitness(key, value) ?? 0,
+        origin,
+        mark,
+        markLabel: scale.threshold?.label ?? null,
+    };
+}
+//# sourceMappingURL=barGeometry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"barGeometry.js","sourceRoot":"","sources":["../../../src/osiris/core/barGeometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEjE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAsB5C;;;GAGG;AACH,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,GAAgB,EAChB,KAAoB;IAEpB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC9C,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAEnC,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,MAAM,IAAI,GACR,KAAK,CAAC,SAAS,KAAK,IAAI;QACtB,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAEnD,OAAO;QACL,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC;QACjC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,MAAM,CAAC;QACnC,OAAO,EAAE,eAAe,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC;QACzC,MAAM;QACN,IAAI;QACJ,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,IAAI,IAAI;KAC1C,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,42 @@
+/**
+ * Everything the tool predicts about one molecule, in one pass.
+ *
+ * The order of the reads is not arbitrary. `MoleculeProperties`' constructor
+ * normalises ambiguous bonds on the molecule it is handed, so the work is done
+ * on a copy and the caller's molecule — the one the editor is still drawing —
+ * is never touched. Its fields are prototype getters that rerun the whole
+ * predictor on every read, at 13 µs each, and the object cannot be spread or
+ * serialised at all, so each field is read exactly once into a plain object,
+ * and that plain object is what crosses the worker boundary.
+ *
+ * Nothing here trusts OpenChemLib to fail loudly. An empty molecule answers a
+ * full set of innocent numbers and a drug score of 0.63; a failed predictor
+ * answers -999, -1 or 0, never `NaN`; and `DrugScoreCalculator` consumes every
+ * one of those and returns something plausible. So the empty molecule is
+ * refused first, every sentinel becomes `null`, and a drug score is computed
+ * only when all of its inputs are real.
+ */
+import type * as OCL from 'openchemlib';
+import type { OsirisPredictors } from './predictors.ts';
+import type { OsirisProperties } from './types.ts';
+/** What a caller knows about the molecule that the molecule does not. */
+export interface ComputePropertiesOptions {
+    /**
+     * The name the source carried. The canonical SMILES is used when there is
+     * none, so a row always has something to be called.
+     * @default the canonical SMILES
+     */
+    label?: string;
+}
+/** A structure with no atoms, which has nothing to predict. */
+export declare const EMPTY_MOLECULE_MESSAGE = "This structure has no atoms, so there is nothing to predict.";
+/**
+ * Predict everything the tool shows for one molecule.
+ * @param molecule - The molecule. It is copied before anything touches it, so the caller keeps it exactly as it was.
+ * @param predictors - OpenChemLib with its resources registered and checked.
+ * @param options - See {@link ComputePropertiesOptions}.
+ * @returns The ten numbers, the four risks, and what to call the molecule.
+ * @throws {Error} When the molecule has no atoms.
+ */
+export declare function computeProperties(molecule: OCL.Molecule, predictors: OsirisPredictors, options?: ComputePropertiesOptions): OsirisProperties;
+//# sourceMappingURL=computeProperties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"computeProperties.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/computeProperties.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,KAAK,GAAG,MAAM,aAAa,CAAC;AAUxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAuB,MAAM,YAAY,CAAC;AAGxE,yEAAyE;AACzE,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB,iEAC6B,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,GAAG,CAAC,QAAQ,EACtB,UAAU,EAAE,gBAAgB,EAC5B,OAAO,GAAE,wBAA6B,GACrC,gBAAgB,CAmDlB"}

package/lib/osiris/core/computeProperties.js

@@ -0,0 +1,115 @@
+/**
+ * Everything the tool predicts about one molecule, in one pass.
+ *
+ * The order of the reads is not arbitrary. `MoleculeProperties`' constructor
+ * normalises ambiguous bonds on the molecule it is handed, so the work is done
+ * on a copy and the caller's molecule — the one the editor is still drawing —
+ * is never touched. Its fields are prototype getters that rerun the whole
+ * predictor on every read, at 13 µs each, and the object cannot be spread or
+ * serialised at all, so each field is read exactly once into a plain object,
+ * and that plain object is what crosses the worker boundary.
+ *
+ * Nothing here trusts OpenChemLib to fail loudly. An empty molecule answers a
+ * full set of innocent numbers and a drug score of 0.63; a failed predictor
+ * answers -999, -1 or 0, never `NaN`; and `DrugScoreCalculator` consumes every
+ * one of those and returns something plausible. So the empty molecule is
+ * refused first, every sentinel becomes `null`, and a drug score is computed
+ * only when all of its inputs are real.
+ */
+import { NO_FRAGMENT_MATCHED, RISK_TYPE_CODES, UNKNOWN_NUMBER, UNKNOWN_SURFACE_AREA, riskCodeOf, riskLevelOf, } from "./constants.js";
+import { RISK_TYPES } from "./types.js";
+/** A structure with no atoms, which has nothing to predict. */
+export const EMPTY_MOLECULE_MESSAGE = 'This structure has no atoms, so there is nothing to predict.';
+/**
+ * Predict everything the tool shows for one molecule.
+ * @param molecule - The molecule. It is copied before anything touches it, so the caller keeps it exactly as it was.
+ * @param predictors - OpenChemLib with its resources registered and checked.
+ * @param options - See {@link ComputePropertiesOptions}.
+ * @returns The ten numbers, the four risks, and what to call the molecule.
+ * @throws {Error} When the molecule has no atoms.
+ */
+export function computeProperties(molecule, predictors, options = {}) {
+    if (molecule.getAllAtoms() === 0)
+        throw new Error(EMPTY_MOLECULE_MESSAGE);
+    const working = molecule.getCompactCopy();
+    const idCode = working.getIDCode();
+    const smiles = working.toIsomericSmiles();
+    const { formula, relativeWeight } = working.getMolecularFormula();
+    const properties = new predictors.MoleculeProperties(working);
+    const logP = real(properties.logP, UNKNOWN_NUMBER);
+    const logS = real(properties.logS, UNKNOWN_NUMBER);
+    const polarSurfaceArea = real(properties.polarSurfaceArea, UNKNOWN_SURFACE_AREA);
+    const acceptorCount = properties.acceptorCount;
+    const donorCount = properties.donorCount;
+    const stereoCenterCount = properties.stereoCenterCount;
+    const rotatableBondCount = properties.rotatableBondCount;
+    const assessed = predictors.druglikeness.assessDruglikeness(working);
+    const druglikeness = assessed === UNKNOWN_NUMBER || assessed === NO_FRAGMENT_MATCHED
+        ? null
+        : assessed;
+    const risks = assessRisks(working, predictors);
+    return {
+        idCode,
+        smiles,
+        label: options.label ?? smiles,
+        molecularFormula: formula,
+        molecularWeight: relativeWeight,
+        logP,
+        logS,
+        polarSurfaceArea,
+        druglikeness,
+        drugScore: drugScore(predictors, {
+            logP,
+            logS,
+            relativeWeight,
+            druglikeness,
+            risks,
+        }),
+        acceptorCount,
+        donorCount,
+        stereoCenterCount,
+        rotatableBondCount,
+        risks,
+    };
+}
+function assessRisks(molecule, predictors) {
+    const risks = {};
+    for (const risk of RISK_TYPES) {
+        risks[risk] = riskLevelOf(predictors.toxicity.assessRisk(molecule, RISK_TYPE_CODES[risk]));
+    }
+    return risks;
+}
+/**
+ * The drug score, or `null` when any of its five inputs was unknown.
+ *
+ * `calculate` never refuses: a drug-likeness of -999 simply makes that factor
+ * exactly 0.5 and the score comes back looking ordinary, and an unassessed risk
+ * applies no penalty where a high one would have applied 0.6. Both read as good
+ * news, which is why they are refused here instead.
+ *
+ * The second argument is the **solubility**. The legacy explorer passed the
+ * polar surface area, which is a different number in a different unit; see the
+ * test that pins both.
+ * @param predictors - OpenChemLib with its resources registered and checked.
+ * @param inputs - The four predicted numbers and the four risks.
+ * @returns The score, or `null` when it cannot be trusted.
+ */
+function drugScore(predictors, inputs) {
+    const { logP, logS, relativeWeight, druglikeness, risks } = inputs;
+    if (logP === null || logS === null || druglikeness === null)
+        return null;
+    const codes = [];
+    for (const risk of RISK_TYPES) {
+        const level = risks[risk];
+        if (level === 'unknown')
+            return null;
+        codes.push(riskCodeOf(level));
+    }
+    return predictors.DrugScoreCalculator.calculate(logP, logS, relativeWeight, druglikeness, codes);
+}
+function real(value, sentinel) {
+    if (value === sentinel || !Number.isFinite(value))
+        return null;
+    return value;
+}
+//# sourceMappingURL=computeProperties.js.map

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

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

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

@@ -0,0 +1,70 @@
+/**
+ * The numbers OpenChemLib speaks, and the words this site says instead.
+ *
+ * Two translations live here and nowhere else. The first is the library's risk
+ * numbering, which is easy to get backwards: `ToxicityPredictor.RISK_NAMES` is
+ * indexed by risk *type*, not by risk *level*, and the library exports no level
+ * names at all — so reading a level out of `RISK_NAMES` gives a confident,
+ * wrong answer. The second is the set of sentinels every predictor returns
+ * instead of failing: none of them is `NaN`, and `DrugScoreCalculator` consumes
+ * every one of them and hands back a plausible number.
+ */
+import type { RiskLevel, RiskType } from './types.ts';
+/**
+ * Where each risk sits in the library's numbering — `TYPE_MUTAGENIC` 0 through
+ * `TYPE_REPRODUCTIVE_EFFECTIVE` 3. It is also the order `DrugScoreCalculator`
+ * expects its `toxRisks` array in.
+ */
+export declare const RISK_TYPE_CODES: Record<RiskType, number>;
+/**
+ * What `assessRisk` returns, read as a word: `RISK_UNKNOWN` 0, `RISK_NO` 1,
+ * `RISK_LOW` 2, `RISK_HIGH` 3.
+ */
+export declare const RISK_LEVELS: readonly RiskLevel[];
+/**
+ * What the library calls each risk, matching `ToxicityPredictor.RISK_NAMES`.
+ * Written out here so reading a label costs no import of a megabyte of
+ * OpenChemLib on a page that only draws a table.
+ */
+export declare const RISK_LABELS: Record<RiskType, string>;
+/**
+ * How each level reads on screen. OSIRIS's own three words, plus one for the
+ * state where the tables did not load — which is not "no risk" and must never
+ * be shown as one.
+ */
+export declare const RISK_LEVEL_LABELS: Record<RiskLevel, string>;
+/**
+ * What each level multiplies the drug score by, decoded from
+ * `DrugScoreCalculator.calculate`. `unknown` applies no factor at all, which is
+ * why a score is refused rather than shown when a risk came back unassessed.
+ */
+export declare const DRUG_SCORE_RISK_FACTORS: Record<RiskLevel, number>;
+/**
+ * What cLogP, solubility and drug-likeness answer when the predictor failed
+ * outright. `CLogPPredictor` returns it on an internal exception, and both
+ * `SolubilityPredictor.cSolubilityUnknown` and
+ * `DruglikenessPredictor.DRUGLIKENESS_UNKNOWN` are this value.
+ */
+export declare const UNKNOWN_NUMBER = -999;
+/** What the polar surface area answers when it is unknown — not `-999`. */
+export declare const UNKNOWN_SURFACE_AREA = -1;
+/**
+ * What `assessDruglikeness` answers when the molecule matched none of the 5294
+ * fragments. It is a real return value, not a failure, and it is
+ * indistinguishable from a drug-likeness that happens to be exactly -1.
+ */
+export declare const NO_FRAGMENT_MATCHED = -1;
+/**
+ * The word for a risk the library answered with a number.
+ * @param code - What `assessRisk` returned, 0 to 3.
+ * @returns The level, `unknown` for anything outside the four the library defines.
+ */
+export declare function riskLevelOf(code: number): RiskLevel;
+/**
+ * The number the library uses for a level, for the `toxRisks` argument of
+ * `DrugScoreCalculator.calculate`.
+ * @param level - The level.
+ * @returns 0 to 3.
+ */
+export declare function riskCodeOf(level: RiskLevel): number;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAKpD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAK3C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAKhD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAKvD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAK7D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAEnD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAGnD"}

package/lib/osiris/core/constants.js

@@ -0,0 +1,99 @@
+/**
+ * The numbers OpenChemLib speaks, and the words this site says instead.
+ *
+ * Two translations live here and nowhere else. The first is the library's risk
+ * numbering, which is easy to get backwards: `ToxicityPredictor.RISK_NAMES` is
+ * indexed by risk *type*, not by risk *level*, and the library exports no level
+ * names at all — so reading a level out of `RISK_NAMES` gives a confident,
+ * wrong answer. The second is the set of sentinels every predictor returns
+ * instead of failing: none of them is `NaN`, and `DrugScoreCalculator` consumes
+ * every one of them and hands back a plausible number.
+ */
+/**
+ * Where each risk sits in the library's numbering — `TYPE_MUTAGENIC` 0 through
+ * `TYPE_REPRODUCTIVE_EFFECTIVE` 3. It is also the order `DrugScoreCalculator`
+ * expects its `toxRisks` array in.
+ */
+export const RISK_TYPE_CODES = {
+    mutagenic: 0,
+    tumorigenic: 1,
+    irritant: 2,
+    reproductive: 3,
+};
+/**
+ * What `assessRisk` returns, read as a word: `RISK_UNKNOWN` 0, `RISK_NO` 1,
+ * `RISK_LOW` 2, `RISK_HIGH` 3.
+ */
+export const RISK_LEVELS = [
+    'unknown',
+    'none',
+    'low',
+    'high',
+];
+/**
+ * What the library calls each risk, matching `ToxicityPredictor.RISK_NAMES`.
+ * Written out here so reading a label costs no import of a megabyte of
+ * OpenChemLib on a page that only draws a table.
+ */
+export const RISK_LABELS = {
+    mutagenic: 'Mutagenicity',
+    tumorigenic: 'Tumorigenicity',
+    irritant: 'Irritating effects',
+    reproductive: 'Reproductive effects',
+};
+/**
+ * How each level reads on screen. OSIRIS's own three words, plus one for the
+ * state where the tables did not load — which is not "no risk" and must never
+ * be shown as one.
+ */
+export const RISK_LEVEL_LABELS = {
+    unknown: 'Not assessed',
+    none: 'No risk',
+    low: 'Medium risk',
+    high: 'High risk',
+};
+/**
+ * What each level multiplies the drug score by, decoded from
+ * `DrugScoreCalculator.calculate`. `unknown` applies no factor at all, which is
+ * why a score is refused rather than shown when a risk came back unassessed.
+ */
+export const DRUG_SCORE_RISK_FACTORS = {
+    unknown: 1,
+    none: 1,
+    low: 0.8,
+    high: 0.6,
+};
+/**
+ * What cLogP, solubility and drug-likeness answer when the predictor failed
+ * outright. `CLogPPredictor` returns it on an internal exception, and both
+ * `SolubilityPredictor.cSolubilityUnknown` and
+ * `DruglikenessPredictor.DRUGLIKENESS_UNKNOWN` are this value.
+ */
+export const UNKNOWN_NUMBER = -999;
+/** What the polar surface area answers when it is unknown — not `-999`. */
+export const UNKNOWN_SURFACE_AREA = -1;
+/**
+ * What `assessDruglikeness` answers when the molecule matched none of the 5294
+ * fragments. It is a real return value, not a failure, and it is
+ * indistinguishable from a drug-likeness that happens to be exactly -1.
+ */
+export const NO_FRAGMENT_MATCHED = -1;
+/**
+ * The word for a risk the library answered with a number.
+ * @param code - What `assessRisk` returned, 0 to 3.
+ * @returns The level, `unknown` for anything outside the four the library defines.
+ */
+export function riskLevelOf(code) {
+    return RISK_LEVELS[code] ?? 'unknown';
+}
+/**
+ * The number the library uses for a level, for the `toxRisks` argument of
+ * `DrugScoreCalculator.calculate`.
+ * @param level - The level.
+ * @returns 0 to 3.
+ */
+export function riskCodeOf(level) {
+    const code = RISK_LEVELS.indexOf(level);
+    return code === -1 ? 0 : code;
+}
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/osiris/core/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAA6B;IACvD,SAAS,EAAE,CAAC;IACZ,WAAW,EAAE,CAAC;IACd,QAAQ,EAAE,CAAC;IACX,YAAY,EAAE,CAAC;CAChB,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAyB;IAC/C,SAAS;IACT,MAAM;IACN,KAAK;IACL,MAAM;CACP,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAA6B;IACnD,SAAS,EAAE,cAAc;IACzB,WAAW,EAAE,gBAAgB;IAC7B,QAAQ,EAAE,oBAAoB;IAC9B,YAAY,EAAE,sBAAsB;CACrC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA8B;IAC1D,OAAO,EAAE,cAAc;IACvB,IAAI,EAAE,SAAS;IACf,GAAG,EAAE,aAAa;IAClB,IAAI,EAAE,WAAW;CAClB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAA8B;IAChE,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,GAAG;IACR,IAAI,EAAE,GAAG;CACV,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,GAAG,CAAC;AAEnC,2EAA2E;AAC3E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,CAAC;AAEvC;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,CAAC;AAEtC;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,WAAW,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC;AACxC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,KAAgB;IACzC,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACxC,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAChC,CAAC"}

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

@@ -0,0 +1,32 @@
+/**
+ * How good one predicted number is, from 0 to 1, and where it sits on its bar.
+ *
+ * The fitness is what the green-to-red ramp reads; the position is what the
+ * bar's length reads. They are deliberately two numbers: a molecular weight of
+ * 780 is nearly the full width of its bar and nearly the worst fitness, while
+ * a drug-likeness of 0 is halfway along its bar and exactly half fit.
+ */
+import type { PropertyKey } from './propertyKeys.ts';
+/**
+ * How well a value sits in its property's preferred band, from 0 (as bad as
+ * the ramp goes) to 1 (inside the band).
+ *
+ * The drug score is already that fitness — it is the product of the four
+ * valuations `DrugScoreCalculator` computes — so it is returned as it stands
+ * rather than valued a second time.
+ * @param key - Which of the ten properties.
+ * @param value - The predicted number, or `null` when the predictor could not answer.
+ * @returns The fitness, or `null` for an unknown value.
+ */
+export declare function propertyFitness(key: PropertyKey, value: number | null): number | null;
+/**
+ * Where a value sits along its bar, from 0 at the left end to 1 at the right.
+ *
+ * Clamped, because a range is a typical spread rather than a bound: cholesterol
+ * runs past the solubility axis and still has to draw.
+ * @param key - Which of the ten properties.
+ * @param value - The predicted number, or `null`.
+ * @returns The position, or `null` for an unknown value.
+ */
+export declare function propertyPosition(key: PropertyKey, value: number | null): number | null;
+//# sourceMappingURL=fitness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fitness.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/fitness.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,MAAM,GAAG,IAAI,CAUf;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,MAAM,GAAG,IAAI,CAKf"}

package/lib/osiris/core/fitness.js

@@ -0,0 +1,48 @@
+/**
+ * How good one predicted number is, from 0 to 1, and where it sits on its bar.
+ *
+ * The fitness is what the green-to-red ramp reads; the position is what the
+ * bar's length reads. They are deliberately two numbers: a molecular weight of
+ * 780 is nearly the full width of its bar and nearly the worst fitness, while
+ * a drug-likeness of 0 is halfway along its bar and exactly half fit.
+ */
+import { clamp } from "../../format/core/clamp.js";
+import { propertyScale } from "./scales.js";
+import { getValuation } from "./valuation.js";
+/**
+ * How well a value sits in its property's preferred band, from 0 (as bad as
+ * the ramp goes) to 1 (inside the band).
+ *
+ * The drug score is already that fitness — it is the product of the four
+ * valuations `DrugScoreCalculator` computes — so it is returned as it stands
+ * rather than valued a second time.
+ * @param key - Which of the ten properties.
+ * @param value - The predicted number, or `null` when the predictor could not answer.
+ * @returns The fitness, or `null` for an unknown value.
+ */
+export function propertyFitness(key, value) {
+    if (value === null || !Number.isFinite(value))
+        return null;
+    const scale = propertyScale(key);
+    if (scale.halfWidth === null)
+        return clamp(value, 0, 1);
+    return getValuation(value, scale.preferredMin, scale.preferredMax, scale.halfWidth);
+}
+/**
+ * Where a value sits along its bar, from 0 at the left end to 1 at the right.
+ *
+ * Clamped, because a range is a typical spread rather than a bound: cholesterol
+ * runs past the solubility axis and still has to draw.
+ * @param key - Which of the ten properties.
+ * @param value - The predicted number, or `null`.
+ * @returns The position, or `null` for an unknown value.
+ */
+export function propertyPosition(key, value) {
+    if (value === null || !Number.isFinite(value))
+        return null;
+    const { rangeMin, rangeMax } = propertyScale(key);
+    if (rangeMax === rangeMin)
+        return 0;
+    return clamp((value - rangeMin) / (rangeMax - rangeMin), 0, 1);
+}
+//# sourceMappingURL=fitness.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fitness.js","sourceRoot":"","sources":["../../../src/osiris/core/fitness.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAGnD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAgB,EAChB,KAAoB;IAEpB,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3D,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,KAAK,CAAC,SAAS,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACxD,OAAO,YAAY,CACjB,KAAK,EACL,KAAK,CAAC,YAAY,EAClB,KAAK,CAAC,YAAY,EAClB,KAAK,CAAC,SAAS,CAChB,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC9B,GAAgB,EAChB,KAAoB;IAEpB,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3D,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAClD,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC;IACpC,OAAO,KAAK,CAAC,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AACjE,CAAC"}

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

@@ -0,0 +1,29 @@
+export type { BarGeometry } from './barGeometry.ts';
+export { barGeometry } from './barGeometry.ts';
+export type { ComputePropertiesOptions } from './computeProperties.ts';
+export { EMPTY_MOLECULE_MESSAGE, computeProperties, } from './computeProperties.ts';
+export { DRUG_SCORE_RISK_FACTORS, NO_FRAGMENT_MATCHED, RISK_LABELS, RISK_LEVELS, RISK_LEVEL_LABELS, RISK_TYPE_CODES, UNKNOWN_NUMBER, UNKNOWN_SURFACE_AREA, riskCodeOf, riskLevelOf, } from './constants.ts';
+export { propertyFitness, propertyPosition } from './fitness.ts';
+export { MAX_POOL_SIZE, predictionPoolSize } from './poolSize.ts';
+export type { PredictionInput, PredictionOutcome, PredictionPool, PredictionPoolOptions, PredictionProgress, } from './poolTypes.ts';
+export { UNREADABLE_ID_CODE_MESSAGE, predictIdCode, riskDetailOfIdCode, } from './predictIdCode.ts';
+export type { PredictRequest, PredictResponse, PropertiesRequest, RiskDetailRequest, } from './predictProtocol.ts';
+export { isPredictRequest } from './predictProtocol.ts';
+export { createPredictionPool } from './predictionPool.ts';
+export type { PredictionQueue } from './predictionQueue.ts';
+export { createPredictionQueue } from './predictionQueue.ts';
+export type { OsirisPredictors, ResourceSource } from './predictors.ts';
+export { PredictorsUnavailableError, loadPredictors, resetPredictors, } from './predictors.ts';
+export type { PropertyKey } from './propertyKeys.ts';
+export { PROPERTY_KEYS, isPropertyKey, propertyValue } from './propertyKeys.ts';
+export type { RiskAppearance, RiskTone } from './riskAppearance.ts';
+export { KNOWN_MOLECULE_NOTE, PENDING_RISK_LABEL, RISK_CAVEAT, riskAppearance, } from './riskAppearance.ts';
+export { riskDetail } from './riskDetail.ts';
+export { parseRiskFindings } from './riskFindings.ts';
+export { runPredictionJob } from './runPredictionJob.ts';
+export type { PropertyScale, PropertyThreshold, ScaleSource, } from './scales.ts';
+export { PROPERTY_SCALES, propertyScale } from './scales.ts';
+export type { DetailEntry, OsirisProperties, RiskDetail, RiskFinding, RiskFindingKind, RiskLevel, RiskType, } from './types.ts';
+export { RISK_TYPES } from './types.ts';
+export { getValuation } from './valuation.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EACL,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,UAAU,EACV,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAClE,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,0BAA0B,EAC1B,cAAc,EACd,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAChF,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,cAAc,GACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7D,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,eAAe,EACf,SAAS,EACT,QAAQ,GACT,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/lib/osiris/core/index.js

@@ -0,0 +1,19 @@
+export { barGeometry } from "./barGeometry.js";
+export { EMPTY_MOLECULE_MESSAGE, computeProperties, } from "./computeProperties.js";
+export { DRUG_SCORE_RISK_FACTORS, NO_FRAGMENT_MATCHED, RISK_LABELS, RISK_LEVELS, RISK_LEVEL_LABELS, RISK_TYPE_CODES, UNKNOWN_NUMBER, UNKNOWN_SURFACE_AREA, riskCodeOf, riskLevelOf, } from "./constants.js";
+export { propertyFitness, propertyPosition } from "./fitness.js";
+export { MAX_POOL_SIZE, predictionPoolSize } from "./poolSize.js";
+export { UNREADABLE_ID_CODE_MESSAGE, predictIdCode, riskDetailOfIdCode, } from "./predictIdCode.js";
+export { isPredictRequest } from "./predictProtocol.js";
+export { createPredictionPool } from "./predictionPool.js";
+export { createPredictionQueue } from "./predictionQueue.js";
+export { PredictorsUnavailableError, loadPredictors, resetPredictors, } from "./predictors.js";
+export { PROPERTY_KEYS, isPropertyKey, propertyValue } from "./propertyKeys.js";
+export { KNOWN_MOLECULE_NOTE, PENDING_RISK_LABEL, RISK_CAVEAT, riskAppearance, } from "./riskAppearance.js";
+export { riskDetail } from "./riskDetail.js";
+export { parseRiskFindings } from "./riskFindings.js";
+export { runPredictionJob } from "./runPredictionJob.js";
+export { PROPERTY_SCALES, propertyScale } from "./scales.js";
+export { RISK_TYPES } from "./types.js";
+export { getValuation } from "./valuation.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/osiris/core/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EACL,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,UAAU,EACV,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAQlE,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EACL,0BAA0B,EAC1B,cAAc,EACd,eAAe,GAChB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEhF,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,cAAc,GACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAMzD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAU7D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,17 @@
+/**
+ * How many workers to run.
+ *
+ * One fewer than the machine's cores, so the thread that draws the table keeps
+ * one to itself, and never more than eight: measured scaling is 2.45x on two
+ * workers and 4.57x on four, and each worker costs its own copy of OpenChemLib
+ * and of the 398 kB resource tables.
+ */
+/** The most workers the pool will ever run. */
+export declare const MAX_POOL_SIZE = 8;
+/**
+ * How many workers a pool should run here.
+ * @param requested - What the caller asked for, or `undefined` to read the machine.
+ * @returns A count between 1 and {@link MAX_POOL_SIZE}.
+ */
+export declare function predictionPoolSize(requested?: number): number;
+//# sourceMappingURL=poolSize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poolSize.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/poolSize.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,+CAA+C;AAC/C,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAI7D"}

package/lib/osiris/core/poolSize.js

@@ -0,0 +1,22 @@
+/**
+ * How many workers to run.
+ *
+ * One fewer than the machine's cores, so the thread that draws the table keeps
+ * one to itself, and never more than eight: measured scaling is 2.45x on two
+ * workers and 4.57x on four, and each worker costs its own copy of OpenChemLib
+ * and of the 398 kB resource tables.
+ */
+import { clamp } from "../../format/core/clamp.js";
+/** The most workers the pool will ever run. */
+export const MAX_POOL_SIZE = 8;
+/**
+ * How many workers a pool should run here.
+ * @param requested - What the caller asked for, or `undefined` to read the machine.
+ * @returns A count between 1 and {@link MAX_POOL_SIZE}.
+ */
+export function predictionPoolSize(requested) {
+    const cores = globalThis.navigator?.hardwareConcurrency;
+    const wanted = requested ?? (typeof cores === 'number' ? cores - 1 : 1);
+    return Math.trunc(clamp(wanted, 1, MAX_POOL_SIZE, 1));
+}
+//# sourceMappingURL=poolSize.js.map