react-cheminfo 0.76.0 → 0.77.0

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"poolSize.js","sourceRoot":"","sources":["../../../src/osiris/core/poolSize.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAEnD,+CAA+C;AAC/C,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC;AAE/B;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,SAAkB;IACnD,MAAM,KAAK,GAAG,UAAU,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxD,MAAM,MAAM,GAAG,SAAS,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC"}

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

@@ -0,0 +1,140 @@
+/**
+ * What a page asks the prediction pool, and what it hears back.
+ *
+ * A prediction costs 210 to 380 ms of one thread, so a set of any size is
+ * answered a molecule at a time rather than all at once: a row appears as soon
+ * as it is read and fills in when its worker returns. Everything here is shaped
+ * around that — a per-result callback rather than a promise over the set, a
+ * progress figure, a cancel that works, and a way to say which rows the reader
+ * can actually see so those are computed first.
+ */
+import type { WorkerLike } from '../../worker/core/messages.ts';
+import type { PredictRequest, PredictResponse } from './predictProtocol.ts';
+import type { ResourceSource } from './predictors.ts';
+import type { OsirisProperties, RiskDetail, RiskType } from './types.ts';
+/** One molecule to predict. */
+export interface PredictionInput {
+    /**
+     * The caller's key for the row, echoed on the answer. It is the row's read
+     * position, never its idCode: a real list holds the same structure twice
+     * under two names, and both rows have to fill in.
+     */
+    key: string;
+    /** The idCode, with the editor's atom coordinates after a space or without. */
+    idCode: string;
+    /**
+     * The name the source carried.
+     * @default the canonical SMILES
+     */
+    label?: string;
+}
+/** What came back for one molecule. */
+export type PredictionOutcome = {
+    key: string;
+    ok: true;
+    properties: OsirisProperties;
+} | {
+    key: string;
+    ok: false;
+    message: string;
+};
+/** How far the pool has got. */
+export interface PredictionProgress {
+    /** Molecules answered, whether predicted or refused. */
+    done: number;
+    /** Molecules accepted since the run started. */
+    total: number;
+    /** Molecules still queued or still being worked on. */
+    pending: number;
+    /** Whether anything is still to come. */
+    running: boolean;
+}
+/** How a pool is built, and who it reports to. */
+export interface PredictionPoolOptions {
+    /**
+     * Where the workers register OpenChemLib's resources from — the absolute URL
+     * of the site's own `openchemlib-resources.json`, resolved on the main
+     * thread. See {@link ResourceSource}.
+     */
+    resources: ResourceSource;
+    /**
+     * How many workers to run. Clamped to 1 to 8.
+     * @default one fewer than the machine's cores, which measured 2.45x on two workers and 4.57x on four
+     */
+    size?: number;
+    /**
+     * Makes one worker, which serves `runPredictionJob` for the requests
+     * `isPredictRequest` accepts. Only called where the page has a `Worker` at
+     * all. The site writes it because a bundler resolves a worker's address
+     * against the module naming it: written in this package, the URL would point
+     * inside `node_modules` rather than at a chunk the site's build emitted.
+     */
+    createWorker: () => WorkerLike;
+    /**
+     * The same job on this thread, used where there is no `Worker` — Node, a
+     * unit test.
+     * @default `runPredictionJob`, the same function the worker serves
+     */
+    runInProcess?: (request: PredictRequest) => Promise<PredictResponse>;
+    /**
+     * Called once per molecule, as each one comes back.
+     * @default undefined
+     */
+    onResult?: (outcome: PredictionOutcome) => void;
+    /**
+     * Called whenever the count of answered molecules changes.
+     * @default undefined
+     */
+    onProgress?: (progress: PredictionProgress) => void;
+    /**
+     * Called once when the resource tables did not load. Every answer from every
+     * worker would be `unknown`, so the run stops and nothing more is dispatched.
+     * @default undefined
+     */
+    onUnavailable?: (message: string) => void;
+    /**
+     * Milliseconds one molecule may take before it is given up on.
+     * @default 60000
+     */
+    timeoutMs?: number;
+}
+/** A pool of workers answering one molecule at a time, each. */
+export interface PredictionPool {
+    /** How many workers it runs. */
+    readonly size: number;
+    /** How far it has got. */
+    readonly progress: PredictionProgress;
+    /**
+     * Add molecules to predict. One already queued or in flight is ignored, so a
+     * page may resubmit its whole set whenever the set changes.
+     * @param molecules - The molecules.
+     */
+    submit: (molecules: readonly PredictionInput[]) => void;
+    /**
+     * Say which rows to answer first — the ones the reader can see. Molecules
+     * already being worked on are left alone; only what is still queued moves.
+     * @param keys - The keys, most wanted first.
+     */
+    prioritize: (keys: readonly string[]) => void;
+    /**
+     * Why one risk came back as it did. Jumps the queue, because it is a click.
+     * A {@link PredictionPool.cancel} is about the set, not about the click, so
+     * an explanation it drops is asked for again.
+     * @param idCode - The molecule, coordinates included or not.
+     * @param risk - Which of the four risks to explain.
+     * @returns The findings, with the matched atoms and bonds of every fragment.
+     * @throws {Error} When even the second ask was dropped, with a sentence to show the reader.
+     */
+    riskDetail: (idCode: string, risk: RiskType) => Promise<RiskDetail>;
+    /**
+     * Drop everything queued and stop reporting. The molecule each worker is
+     * already on cannot be interrupted — the library call is synchronous — so it
+     * finishes and its answer is thrown away, within about 400 ms. A
+     * {@link PredictionPool.submit} made in the same turn is still dispatched, on
+     * the slots those abandoned answers free.
+     */
+    cancel: () => void;
+    /** Cancel, and end every worker. */
+    terminate: () => void;
+}
+//# sourceMappingURL=poolTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poolTypes.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/poolTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEzE,+BAA+B;AAC/B,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,uCAAuC;AACvC,MAAM,MAAM,iBAAiB,GACzB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,gBAAgB,CAAA;CAAE,GACvD;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhD,gCAAgC;AAChC,MAAM,WAAW,kBAAkB;IACjC,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,kDAAkD;AAClD,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,SAAS,EAAE,cAAc,CAAC;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,UAAU,CAAC;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACrE;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAChD;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACpD;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,gEAAgE;AAChE,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0BAA0B;IAC1B,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC;;;;OAIG;IACH,MAAM,EAAE,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,KAAK,IAAI,CAAC;IACxD;;;;OAIG;IACH,UAAU,EAAE,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,IAAI,CAAC;IAC9C;;;;;;;;OAQG;IACH,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACpE;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,oCAAoC;IACpC,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB"}

package/lib/osiris/core/poolTypes.js

@@ -0,0 +1,12 @@
+/**
+ * What a page asks the prediction pool, and what it hears back.
+ *
+ * A prediction costs 210 to 380 ms of one thread, so a set of any size is
+ * answered a molecule at a time rather than all at once: a row appears as soon
+ * as it is read and fills in when its worker returns. Everything here is shaped
+ * around that — a per-result callback rather than a promise over the set, a
+ * progress figure, a cancel that works, and a way to say which rows the reader
+ * can actually see so those are computed first.
+ */
+export {};
+//# sourceMappingURL=poolTypes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"poolTypes.js","sourceRoot":"","sources":["../../../src/osiris/core/poolTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

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

@@ -0,0 +1,39 @@
+/**
+ * Prediction from the only thing worth keeping per row.
+ *
+ * A row never holds an `OCL.Molecule` — ten thousand of them cost 198 MB — so
+ * what travels to a worker is the idCode, and the molecule is rebuilt there in
+ * a quarter of a millisecond against the 380 ms the prediction itself costs.
+ */
+import type { ComputePropertiesOptions } from './computeProperties.ts';
+import type { OsirisPredictors } from './predictors.ts';
+import type { OsirisProperties, RiskDetail, RiskType } from './types.ts';
+/**
+ * What is said when an idCode cannot be read.
+ *
+ * An idCode is written by a program, not typed by a chemist, so there is no
+ * position to point at and no parser reason worth repeating: OpenChemLib
+ * answers a malformed one with `Cannot set properties of undefined`, which
+ * names nothing anyone can act on. Worse, it does not always throw — `zzzz`
+ * reads as a 117-atom molecule — so this is the floor, not the whole guard.
+ */
+export declare const UNREADABLE_ID_CODE_MESSAGE = "This structure could not be read.";
+/**
+ * Predict everything the tool shows, from an idCode.
+ * @param value - The idCode, with the editor's atom coordinates after a space or without them.
+ * @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 idCode cannot be read, or describes no atoms.
+ */
+export declare function predictIdCode(value: string, predictors: OsirisPredictors, options?: ComputePropertiesOptions): OsirisProperties;
+/**
+ * Why one risk came back as it did, from an idCode.
+ * @param value - The idCode, coordinates included or not.
+ * @param risk - Which of the four risks to explain.
+ * @param predictors - OpenChemLib with its resources registered and checked.
+ * @returns The findings, with the matched atoms and bonds of every fragment.
+ * @throws {Error} When the idCode cannot be read.
+ */
+export declare function riskDetailOfIdCode(value: string, risk: RiskType, predictors: OsirisPredictors): RiskDetail;
+//# sourceMappingURL=predictIdCode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predictIdCode.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/predictIdCode.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAEvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,sCAAsC,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,gBAAgB,EAC5B,OAAO,GAAE,wBAA6B,GACrC,gBAAgB,CAElB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,gBAAgB,GAC3B,UAAU,CAEZ"}

package/lib/osiris/core/predictIdCode.js

@@ -0,0 +1,54 @@
+/**
+ * Prediction from the only thing worth keeping per row.
+ *
+ * A row never holds an `OCL.Molecule` — ten thousand of them cost 198 MB — so
+ * what travels to a worker is the idCode, and the molecule is rebuilt there in
+ * a quarter of a millisecond against the 380 ms the prediction itself costs.
+ */
+import { splitIdCode } from "../../structure/core/editorValue.js";
+import { computeProperties } from "./computeProperties.js";
+import { riskDetail } from "./riskDetail.js";
+/**
+ * What is said when an idCode cannot be read.
+ *
+ * An idCode is written by a program, not typed by a chemist, so there is no
+ * position to point at and no parser reason worth repeating: OpenChemLib
+ * answers a malformed one with `Cannot set properties of undefined`, which
+ * names nothing anyone can act on. Worse, it does not always throw — `zzzz`
+ * reads as a 117-atom molecule — so this is the floor, not the whole guard.
+ */
+export const UNREADABLE_ID_CODE_MESSAGE = 'This structure could not be read.';
+/**
+ * Predict everything the tool shows, from an idCode.
+ * @param value - The idCode, with the editor's atom coordinates after a space or without them.
+ * @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 idCode cannot be read, or describes no atoms.
+ */
+export function predictIdCode(value, predictors, options = {}) {
+    return computeProperties(read(value, predictors), predictors, options);
+}
+/**
+ * Why one risk came back as it did, from an idCode.
+ * @param value - The idCode, coordinates included or not.
+ * @param risk - Which of the four risks to explain.
+ * @param predictors - OpenChemLib with its resources registered and checked.
+ * @returns The findings, with the matched atoms and bonds of every fragment.
+ * @throws {Error} When the idCode cannot be read.
+ */
+export function riskDetailOfIdCode(value, risk, predictors) {
+    return riskDetail(read(value, predictors), risk, predictors);
+}
+function read(value, predictors) {
+    const { idCode, coordinates } = splitIdCode(value);
+    try {
+        return coordinates === undefined
+            ? predictors.Molecule.fromIDCode(idCode)
+            : predictors.Molecule.fromIDCode(idCode, coordinates);
+    }
+    catch (error) {
+        throw new Error(UNREADABLE_ID_CODE_MESSAGE, { cause: error });
+    }
+}
+//# sourceMappingURL=predictIdCode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predictIdCode.js","sourceRoot":"","sources":["../../../src/osiris/core/predictIdCode.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAGlE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,mCAAmC,CAAC;AAE9E;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAa,EACb,UAA4B,EAC5B,UAAoC,EAAE;IAEtC,OAAO,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAa,EACb,IAAc,EACd,UAA4B;IAE5B,OAAO,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,IAAI,CAAC,KAAa,EAAE,UAA4B;IACvD,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;IACnD,IAAI,CAAC;QACH,OAAO,WAAW,KAAK,SAAS;YAC9B,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC;YACxC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC1D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,0BAA0B,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;IAChE,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,67 @@
+/**
+ * What the page asks a prediction worker, and what it answers.
+ *
+ * One molecule per request. Two of the three answers are ordinary results; the
+ * third, `unavailable`, is how a worker says its resource tables did not load.
+ * That one travels as a *successful* answer on purpose: a rejection would be
+ * indistinguishable from the ordinary failure of one unreadable structure,
+ * whereas this one means every answer from every worker is worthless and the
+ * run must stop and say so.
+ */
+import type { ResourceSource } from './predictors.ts';
+import type { OsirisProperties, RiskDetail, RiskType } from './types.ts';
+/** What every request carries, whichever job it asks for. */
+interface BaseRequest {
+    /**
+     * Where the worker registers OpenChemLib's resources from. In a browser this
+     * is always the absolute URL of the site's own `openchemlib-resources.json`,
+     * resolved on the main thread: a worker has no `document`, so it cannot read
+     * the deployment's mount path itself. The parsed tables are accepted as well,
+     * for the in-process fallback where there is no worker to post them to.
+     */
+    resources: ResourceSource;
+}
+/** Predict everything the tool shows for one molecule. */
+export interface PropertiesRequest extends BaseRequest {
+    kind: 'properties';
+    /** The caller's key for the row, echoed back so answers can arrive in any order. */
+    key: string;
+    /** The idCode, with the editor's atom coordinates after a space or without. */
+    idCode: string;
+    /**
+     * The name the source carried.
+     * @default the canonical SMILES
+     */
+    label?: string;
+}
+/** Explain why one risk came back as it did. */
+export interface RiskDetailRequest extends BaseRequest {
+    kind: 'riskDetail';
+    /** The idCode, coordinates included or not. */
+    idCode: string;
+    /** Which of the four risks to explain. */
+    risk: RiskType;
+}
+/** One job for a prediction worker. */
+export type PredictRequest = PropertiesRequest | RiskDetailRequest;
+/** What a prediction worker answers. */
+export type PredictResponse = {
+    kind: 'properties';
+    key: string;
+    properties: OsirisProperties;
+} | {
+    kind: 'riskDetail';
+    detail: RiskDetail;
+} | {
+    kind: 'unavailable';
+    message: string;
+};
+/**
+ * Whether a message is a job this worker handles, so anything else is refused
+ * rather than read as one.
+ * @param value - Whatever was posted.
+ * @returns True when it is a well-formed request.
+ */
+export declare function isPredictRequest(value: unknown): value is PredictRequest;
+export {};
+//# sourceMappingURL=predictProtocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predictProtocol.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/predictProtocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEzE,6DAA6D;AAC7D,UAAU,WAAW;IACnB;;;;;;OAMG;IACH,SAAS,EAAE,cAAc,CAAC;CAC3B;AAED,0DAA0D;AAC1D,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,IAAI,EAAE,YAAY,CAAC;IACnB,oFAAoF;IACpF,GAAG,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,gDAAgD;AAChD,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,IAAI,EAAE,YAAY,CAAC;IACnB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,uCAAuC;AACvC,MAAM,MAAM,cAAc,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAEnE,wCAAwC;AACxC,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,gBAAgB,CAAA;CAAE,GACjE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAaxE"}

package/lib/osiris/core/predictProtocol.js

@@ -0,0 +1,29 @@
+/**
+ * What the page asks a prediction worker, and what it answers.
+ *
+ * One molecule per request. Two of the three answers are ordinary results; the
+ * third, `unavailable`, is how a worker says its resource tables did not load.
+ * That one travels as a *successful* answer on purpose: a rejection would be
+ * indistinguishable from the ordinary failure of one unreadable structure,
+ * whereas this one means every answer from every worker is worthless and the
+ * run must stop and say so.
+ */
+/**
+ * Whether a message is a job this worker handles, so anything else is refused
+ * rather than read as one.
+ * @param value - Whatever was posted.
+ * @returns True when it is a well-formed request.
+ */
+export function isPredictRequest(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const request = value;
+    if (typeof request.idCode !== 'string')
+        return false;
+    if (request.resources === undefined)
+        return false;
+    if (request.kind === 'properties')
+        return typeof request.key === 'string';
+    return request.kind === 'riskDetail' && typeof request.risk === 'string';
+}
+//# sourceMappingURL=predictProtocol.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predictProtocol.js","sourceRoot":"","sources":["../../../src/osiris/core/predictProtocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAiDH;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,OAAO,GAAG,KAMf,CAAC;IACF,IAAI,OAAO,OAAO,CAAC,MAAM,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACrD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IAClD,IAAI,OAAO,CAAC,IAAI,KAAK,YAAY;QAAE,OAAO,OAAO,OAAO,CAAC,GAAG,KAAK,QAAQ,CAAC;IAC1E,OAAO,OAAO,CAAC,IAAI,KAAK,YAAY,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC3E,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * A pool of prediction workers, answering one molecule at a time each.
+ *
+ * `createWorkerChannel` from `react-cheminfo/core` does the per-worker half —
+ * request identifiers so answers match callers whatever order they arrive in,
+ * timeouts, cancellation, and the in-process fallback where a page has no
+ * `Worker` at all. What it does not do is spread work over several workers, so
+ * that is what this adds: one channel per worker, a queue the pool owns, and at
+ * most one outstanding job per channel, which is what makes reordering possible
+ * at all. A channel asked for everything at once would post everything at once,
+ * and the row the reader is looking at would be answered forty-eighth.
+ */
+import type { PredictionPool, PredictionPoolOptions } from './poolTypes.ts';
+/**
+ * Start a pool of prediction workers.
+ *
+ * Workers are created lazily by the channels, on their first job, so a page
+ * that never predicts anything never loads OpenChemLib.
+ * @param options - See {@link PredictionPoolOptions}.
+ * @returns The pool.
+ */
+export declare function createPredictionPool(options: PredictionPoolOptions): PredictionPool;
+//# sourceMappingURL=predictionPool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predictionPool.d.ts","sourceRoot":"","sources":["../../../src/osiris/core/predictionPool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH,OAAO,KAAK,EAEV,cAAc,EACd,qBAAqB,EAEtB,MAAM,gBAAgB,CAAC;AAexB;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CA2LhB"}