react-cheminfo 0.70.0 → 0.71.0

package/src/host/core/irKinds.ts

@@ -0,0 +1,92 @@
+/**
+ * The kinds a measured infrared spectrum travels as: the JCAMP-DX a notebook
+ * keeps with the bands picked on it, and those bands alone, which is what a
+ * tool hands back.
+ *
+ * Shaped on what SciPeaks keeps for a sample's infrared spectrum — a JCAMP-DX
+ * attachment and a `peak` list beside it — with the text of the attachment in
+ * place of its address, since a tool framed from another origin cannot fetch
+ * what the notebook serves its own pages. A band is written the way SciPeaks
+ * and `ir-spectrum` write one, so what a tool hands back can be stored as it
+ * arrives.
+ *
+ * Named after pipeline's `spectra.nmr.1d.jdx`. Pipeline's own `spectra.ir` is
+ * a computed spectrum — normal modes, not a measurement — and is not one of the
+ * kinds read here.
+ */
+
+/** One band of an infrared spectrum, as SciPeaks and `ir-spectrum` write it. */
+export interface IrPeakValue {
+  /** Where it sits, in cm⁻¹. */
+  wavenumber: number;
+  /**
+   * Its absorbance.
+   * @default read off the spectrum
+   */
+  absorbance?: number;
+  /**
+   * Its transmittance, as a fraction between 0 and 1 — not a percentage.
+   * @default read off the spectrum
+   */
+  transmittance?: number;
+  /**
+   * How strong it is: `w` weak, `m` medium, `S` strong. Any other letter is
+   * worked out again from the spectrum.
+   * @default worked out from the spectrum
+   */
+  kind?: string;
+}
+
+/** `spectra.ir.jdx`: a measured infrared spectrum and the bands picked on it. */
+export interface IrJdxValue {
+  /** The JCAMP-DX, as text. */
+  jdx: string;
+  /**
+   * The name the notebook keeps it under, e.g. `spectra/ir/sample.jdx`.
+   * @default undefined
+   */
+  filename?: string;
+  /**
+   * The bands picked on it. Absent or empty, the tool picks them itself.
+   * @default undefined
+   */
+  peaks?: IrPeakValue[];
+}
+
+/** `spectra.ir.peaks`: the bands picked on an infrared spectrum, alone. */
+export interface IrPeaksValue {
+  /** The bands, ascending by wavenumber. */
+  peaks: IrPeakValue[];
+}
+
+const IR_PEAK_SCHEMA = {
+  type: 'object',
+  properties: {
+    wavenumber: { type: 'number' },
+    absorbance: { type: 'number' },
+    transmittance: { type: 'number' },
+    kind: { type: 'string' },
+  },
+  required: ['wavenumber'],
+  additionalProperties: false,
+} as const;
+
+/** The schema of `spectra.ir.jdx`. */
+export const IR_JDX_SCHEMA = {
+  type: 'object',
+  properties: {
+    jdx: { type: 'string' },
+    filename: { type: 'string' },
+    peaks: { type: 'array', items: IR_PEAK_SCHEMA },
+  },
+  required: ['jdx'],
+  additionalProperties: false,
+} as const;
+
+/** The schema of `spectra.ir.peaks`. */
+export const IR_PEAKS_SCHEMA = {
+  type: 'object',
+  properties: { peaks: { type: 'array', items: IR_PEAK_SCHEMA } },
+  required: ['peaks'],
+  additionalProperties: false,
+} as const;

package/src/host/core/kinds.ts

@@ -4,16 +4,20 @@
  * name, a JSON Schema, and ajv.
  *
  * The names are pipeline's (`chem.molfile.2d`, `chem.ocl.id`…), plus
- * `chem.smiles`, which pipeline lists among its future schemas. A name with
- * children is a category whose schema every child satisfies, so `chem.molfile`
- * reads `chem.molfile.2d` and `chem.molfile.3d.h.energy` alike; the fields a
- * tool does not read are stripped rather than refused, so a host sending more
- * than it needs to is never turned away.
+ * `chem.smiles`, which pipeline lists among its future schemas, and the two
+ * infrared kinds of `./irKinds.ts`. A name with children is a category whose
+ * schema every child satisfies, so `chem.molfile` reads `chem.molfile.2d` and
+ * `chem.molfile.3d.h.energy` alike; the fields a tool does not read are
+ * stripped rather than refused, so a host sending more than it needs to is
+ * never turned away.
  */
 
 import type { JSONSchemaType, ValidateFunction } from 'ajv';
 import { Ajv } from 'ajv';
 
+import type { IrJdxValue, IrPeaksValue } from './irKinds.ts';
+import { IR_JDX_SCHEMA, IR_PEAKS_SCHEMA } from './irKinds.ts';
+
 /** A molfile, V2000 or V3000. */
 export interface MolfileValue {
   molfile: string;
@@ -34,7 +38,9 @@ export interface SmilesValue {
 export type CheckedValue =
   | { kind: 'chem.molfile'; value: MolfileValue }
   | { kind: 'chem.ocl.id'; value: OclIdValue }
-  | { kind: 'chem.smiles'; value: SmilesValue };
+  | { kind: 'chem.smiles'; value: SmilesValue }
+  | { kind: 'spectra.ir.jdx'; value: IrJdxValue }
+  | { kind: 'spectra.ir.peaks'; value: IrPeaksValue };
 
 /** The name of a kind a tool can read. */
 export type KnownKind = CheckedValue['kind'];
@@ -125,4 +131,8 @@ const VALIDATORS: { [K in KnownKind]: ValidateFunction<ValueOf<K>> } = {
   'chem.molfile': ajv.compile(MOLFILE_SCHEMA),
   'chem.ocl.id': ajv.compile(OCL_ID_SCHEMA),
   'chem.smiles': ajv.compile(SMILES_SCHEMA),
+  // Written as plain schemas rather than `JSONSchemaType`, which would demand
+  // `nullable` on every optional field and so let a `null` band through.
+  'spectra.ir.jdx': ajv.compile<IrJdxValue>(IR_JDX_SCHEMA),
+  'spectra.ir.peaks': ajv.compile<IrPeaksValue>(IR_PEAKS_SCHEMA),
 };

package/src/host/core/protocol.ts

@@ -4,9 +4,10 @@
  *
  * Two messages travel between the windows — `hello`, from the tool, and
  * `connect`, the host's answer carrying a private `MessagePort` — and everything
- * else goes through that port: the host's requests (`load`, `get`) and the
- * tool's `result` for each. This module only spells the messages, and reads
- * what arrives as the untrusted input it is.
+ * else goes through that port: the host's requests (`load`, `get`), the tool's
+ * `result` for each, and the `output` the tool sends when a value the host
+ * takes back changes. This module only spells the messages, and reads what
+ * arrives as the untrusted input it is.
  */
 
 /** The version a tool speaks; a `connect` naming another is ignored. */
@@ -52,9 +53,24 @@ export interface ToolInput {
   key: string;
   /** Kinds in order of preference; a category accepts every kind under it. */
   kinds: readonly string[];
+  /**
+   * Whether it takes every item of its kinds, in the host's order, rather than
+   * the one it prefers — every spectrum of a sample.
+   * @default false
+   */
+  many?: boolean;
+  /**
+   * Whether a request may leave it without an item. A request is still
+   * refused when no input at all gets one.
+   * @default false
+   */
+  optional?: boolean;
 }
 
-/** One value the tool can hand back. */
+/**
+ * One value the tool can hand back: answered to `get`, and sent as `output`
+ * whenever it changes, when the host accepted it.
+ */
 export interface ToolOutput {
   key: string;
   kind: string;
@@ -86,6 +102,13 @@ export interface LoadRequest {
   /** What the data belongs to; the same document twice is applied once. */
   document: string;
   items: HostItem[];
+  /**
+   * The outputs the host takes back for this document, by key or by kind — a
+   * kind taking every kind under it: the tool sends an `output` whenever one
+   * of their values changes.
+   * @default undefined — nothing is sent unasked
+   */
+  accept?: string[];
 }
 
 /** `get`: the current value of some outputs. */
@@ -119,18 +142,35 @@ export interface UsedItem {
   kind: string;
 }
 
-/** The answer to one request, carrying its `id`. */
+/**
+ * The answer to one request, carrying its `id`: which items a `load` used, or
+ * the values a `get` asked for.
+ */
 export type ResultMessage =
   | { type: 'result'; id: string; ok: true; used: UsedItem[] }
+  | { type: 'result'; id: string; ok: true; items: HostItem[] }
   | { type: 'result'; id: string; ok: false; error: HostError };
 
+/**
+ * Sent by the tool, unasked, when values the host accepted have changed — the
+ * user picked a band. It carries only the items that changed: one missing is
+ * unchanged, never deleted.
+ */
+export interface OutputMessage {
+  type: 'output';
+  /** The document the values belong to, as the host's `load` named it. */
+  document: string;
+  /** Each with its `key`, and the `id` of the item it was made from. */
+  items: HostItem[];
+}
+
 /**
  * Read a message that arrived through the port.
  *
  * Anything that is not a well-formed `load` or `get` is `null`, and goes
  * unanswered: an unknown request is a newer host talking, not an error. An item
- * without a string `kind` is dropped, and a label is cut to
- * {@link MAX_LABEL_LENGTH}.
+ * without a string `kind` is dropped, a label is cut to
+ * {@link MAX_LABEL_LENGTH}, and a `load` without `accept` takes nothing back.
  * @param data - What the port delivered.
  * @returns The request, or `null`.
  */
@@ -140,12 +180,14 @@ export function parseRequest(data: unknown): HostRequest | null {
     if (typeof data.document !== 'string' || !Array.isArray(data.items)) {
       return null;
     }
-    return {
+    const load: LoadRequest = {
       type: 'load',
       id: data.id,
       document: data.document,
       items: readItems(data.items),
     };
+    if (Array.isArray(data.accept)) load.accept = readStrings(data.accept);
+    return load;
   }
   if (data.type === 'get') {
     return { type: 'get', id: data.id, keys: readStrings(data.keys) };

package/src/host/core/selectInputs.ts

@@ -0,0 +1,145 @@
+/**
+ * Which items of a request each input of a tool takes, and the sentence a
+ * host is answered with when the request loads nothing.
+ */
+
+import type { CheckedValue, KnownKind } from './kinds.ts';
+import { checkValue, isKnownKind, kindAccepts } from './kinds.ts';
+import type {
+  HostError,
+  HostItem,
+  ToolInput,
+  ToolInterface,
+} from './protocol.ts';
+
+/** The item an input took, and its value as the input's kind reads it. */
+export interface LoadedInput {
+  key: string;
+  item: HostItem;
+  checked: CheckedValue;
+}
+
+/** What choosing the items of a request gave. */
+export type InputSelection =
+  { ok: true; inputs: LoadedInput[] } | { ok: false; error: HostError };
+
+/**
+ * Give each input of the tool the items of a request it takes.
+ *
+ * Each input tries its kinds in its own order of preference, and takes the
+ * first item that falls under one and passes that kind's schema: the tool
+ * knows which notation serves it best, whatever order the host listed them in.
+ * An input taking `many` takes every such item instead, in the host's order.
+ * An item naming another input's `key` is left to that input.
+ *
+ * A required input left without an item refuses the request. An optional one
+ * is passed over, unless no input got an item at all.
+ * @param tool - What the tool takes.
+ * @param items - What the host sent.
+ * @returns The items the inputs took, or why the request loads nothing.
+ */
+export function selectInputs(
+  tool: ToolInterface,
+  items: readonly HostItem[],
+): InputSelection {
+  const inputs: LoadedInput[] = [];
+  const passedOver: string[] = [];
+  for (const input of tool.inputs) {
+    const errors: string[] = [];
+    const taken = input.many
+      ? selectEvery(input, items, errors)
+      : selectFirst(input, items, errors);
+    if (taken.length > 0) {
+      inputs.push(...taken);
+    } else if (input.optional) {
+      passedOver.push(...errors);
+    } else {
+      return { ok: false, error: refusal(tool, [input], errors) };
+    }
+  }
+  if (inputs.length > 0 || tool.inputs.length === 0) {
+    return { ok: true, inputs };
+  }
+  return { ok: false, error: refusal(tool, tool.inputs, passedOver) };
+}
+
+function selectFirst(
+  input: ToolInput,
+  items: readonly HostItem[],
+  errors: string[],
+): LoadedInput[] {
+  for (const accepted of input.kinds) {
+    if (!isKnownKind(accepted)) continue;
+    for (const item of items) {
+      if (!isFor(input, accepted, item)) continue;
+      const loaded = checkItem(input.key, accepted, item, errors);
+      if (loaded !== null) return [loaded];
+    }
+  }
+  return [];
+}
+
+function selectEvery(
+  input: ToolInput,
+  items: readonly HostItem[],
+  errors: string[],
+): LoadedInput[] {
+  const taken: LoadedInput[] = [];
+  for (const item of items) {
+    for (const accepted of input.kinds) {
+      if (!isKnownKind(accepted) || !isFor(input, accepted, item)) continue;
+      const loaded = checkItem(input.key, accepted, item, errors);
+      if (loaded === null) continue;
+      taken.push(loaded);
+      break;
+    }
+  }
+  return taken;
+}
+
+function isFor(input: ToolInput, accepted: KnownKind, item: HostItem): boolean {
+  if (item.key !== undefined && item.key !== input.key) return false;
+  return kindAccepts(accepted, item.kind);
+}
+
+function checkItem(
+  key: string,
+  accepted: KnownKind,
+  item: HostItem,
+  errors: string[],
+): LoadedInput | null {
+  const outcome = checkValue(accepted, item.value);
+  if (outcome.valid) return { key, item, checked: outcome.checked };
+  for (const error of outcome.errors) errors.push(`${item.kind} ${error}`);
+  return null;
+}
+
+/**
+ * Why a request loads nothing: some item had the wrong shape, or no item was
+ * of a kind the inputs take.
+ * @param tool - What the tool takes.
+ * @param inputs - The inputs left without an item.
+ * @param errors - What the schemas found.
+ * @returns The error the host is answered with.
+ */
+function refusal(
+  tool: ToolInterface,
+  inputs: readonly ToolInput[],
+  errors: string[],
+): HostError {
+  if (errors.length > 0) {
+    const keys = inputs.map((input) => input.key);
+    return {
+      code: 'invalid',
+      message: `No item for ${LIST.format(keys)} has the shape its kind requires, so ${tool.name} loaded nothing.`,
+      errors,
+    };
+  }
+  const kinds = inputs.flatMap((input) => input.kinds);
+  return {
+    code: 'no-input',
+    message: `No item is a ${LIST.format(kinds)}, so ${tool.name} loaded nothing.`,
+  };
+}
+
+const LIST = new Intl.ListFormat('en', { type: 'disjunction' });

package/src/host/testing/sciPeaks.ts

@@ -8,6 +8,10 @@
  * The sample is a real one, and so are its quirks: its molfile is V2000 with
  * every atom at the origin, its title is blank so the label is its first name,
  * and its formula travels as a kind no structure input reads.
+ *
+ * Its infrared spectrum is pinned here before the tool tab sends it: the bands
+ * are the sample's own, and the message is the one visualizer-helper's `ir`
+ * reader has to write.
  */
 
 import type { LoadRequest } from '../core/protocol.ts';
@@ -64,3 +68,139 @@ export const SCIPEAKS_ETHYLBENZENE_LOAD: LoadRequest & { accept: string[] } = {
   ],
   accept: [],
 };
+
+/** Where SciPeaks keeps that sample's infrared spectrum: its attachment. */
+export const SCIPEAKS_ETHYLBENZENE_IR_FILENAME =
+  'spectra/ir/spectra_ir_100-41-4-IR.jdx';
+
+/**
+ * The bands SciPeaks keeps for that spectrum, as stored: out of wavenumber
+ * order, a transmittance that is a fraction, and the visualizer's `_highlight`.
+ */
+export const SCIPEAKS_ETHYLBENZENE_IR_PEAKS = [
+  peak(
+    1613.8583376884494,
+    0.473660722610156,
+    0.33599999999999997,
+    'm',
+    0.5620600551849647,
+  ),
+  peak(
+    1952.5275809045322,
+    0.13123804178794973,
+    0.7392,
+    'w',
+    0.5211472441361716,
+  ),
+  peak(
+    2872.4947788943773,
+    0.4610494379856386,
+    0.3459,
+    'm',
+    0.30496127508514037,
+  ),
+  peak(2887.659073366737, 0.7066374452885544, 0.1965, 'S', 0.6306151483877337),
+  peak(2907.878132663217, 0.4962093169428189, 0.319, 'S', 0.7220300834282813),
+  peak(2944.9464080400967, 1.0867160982395816, 0.0819, 'S', 0.8391486100817713),
+  peak(2978.6448402008964, 1.7958800173440752, 0.016, 'S', 0.6098050482700554),
+  peak(3014.028193969736, 0.32975414692587596, 0.468, 'm', 0.39091552830124354),
+  peak(3039.302018090336, 1.0969100130080565, 0.08, 'S', 0.502385910408338),
+  peak(
+    3076.3702934672156,
+    0.5831931281770556,
+    0.2611,
+    'S',
+    0.06293920935800923,
+  ),
+  peak(
+    3098.2742743717354,
+    0.38658105496542694,
+    0.4106,
+    'm',
+    0.4934643842659038,
+  ),
+  peak(
+    3118.493333668215,
+    0.16557929631846746,
+    0.6829999999999999,
+    'w',
+    0.05290000144269602,
+  ),
+  peak(
+    1875.0211869346824,
+    0.11935787359571505,
+    0.7597,
+    'w',
+    0.9972320630781272,
+  ),
+  peak(
+    1812.6790874371945,
+    0.11125903931710739,
+    0.774,
+    'w',
+    0.07102323198933491,
+  ),
+  peak(
+    1753.706831155787,
+    0.0834934128848443,
+    0.8251000000000001,
+    'w',
+    0.0750629173499594,
+  ),
+];
+
+/**
+ * The `load` the tool tab is to send that sample to a site that reads
+ * infrared spectra and hands their bands back, once its `ir` reader and its
+ * `save` exist: the structure as it is sent today, one `spectra.ir.jdx` item
+ * per spectrum — the attachment's text, its name and its bands, under the
+ * attachment's name as `id` — and `accept` naming the kind saved back, as
+ * the tool tab's `save` names it.
+ * @param jdx - The attachment's text, which SciPeaks serves at its `dUrl`.
+ * @returns The request, its bands copied so that reading them cannot strip
+ * this module's own.
+ */
+export function sciPeaksEthylbenzeneIrLoad(
+  jdx: string,
+): LoadRequest & { accept: string[] } {
+  return {
+    type: 'load',
+    id: 'load-1',
+    document: SCIPEAKS_ETHYLBENZENE_LOAD.document,
+    items: [
+      ...SCIPEAKS_ETHYLBENZENE_LOAD.items,
+      {
+        kind: 'spectra.ir.jdx',
+        id: SCIPEAKS_ETHYLBENZENE_IR_FILENAME,
+        label: 'spectra_ir_100-41-4-IR.jdx',
+        value: {
+          jdx,
+          filename: SCIPEAKS_ETHYLBENZENE_IR_FILENAME,
+          peaks: SCIPEAKS_ETHYLBENZENE_IR_PEAKS.map((stored) => ({
+            ...stored,
+          })),
+        },
+      },
+    ],
+    accept: ['spectra.ir.peaks'],
+  };
+}
+
+/**
+ * One stored band.
+ * @param wavenumber - Where it sits, in cm⁻¹.
+ * @param absorbance - Its absorbance.
+ * @param transmittance - Its transmittance, a fraction.
+ * @param kind - Its strength letter.
+ * @param highlight - The visualizer's own `_highlight`, stored with it.
+ * @returns The band as SciPeaks stores it.
+ */
+function peak(
+  wavenumber: number,
+  absorbance: number,
+  transmittance: number,
+  kind: string,
+  highlight: number,
+) {
+  return { wavenumber, absorbance, transmittance, kind, _highlight: highlight };
+}

package/src/host/testing/standInHost.ts

@@ -37,7 +37,7 @@ export interface StandInHost {
 export interface StandInHostLog {
   /** The tool's `hello`, or `null` before it came. */
   hello: HelloMessage | null;
-  /** Every message the tool sent on the port, in order. */
+  /** Every message the tool sent on the port, in order: results and outputs. */
   results: unknown[];
 }
 
@@ -46,10 +46,15 @@ export interface StandInHostLog {
  * @returns The host; close it when the tests are done.
  */
 export async function startStandInHost(): Promise<StandInHost> {
-  const server: Server = createServer((_request, response) => {
-    response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
-    response.end(HOST_PAGE);
-  });
+  // A setup carrying a spectrum is tens of kilobytes of address, past the
+  // 16 KiB Node allows a request's head by default.
+  const server: Server = createServer(
+    { maxHeaderSize: MAX_SETUP_BYTES },
+    (_request, response) => {
+      response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+      response.end(HOST_PAGE);
+    },
+  );
   await new Promise<void>((resolve) => {
     server.listen(0, '127.0.0.1', resolve);
   });
@@ -81,6 +86,24 @@ export function readStandInHostLog(): StandInHostLog {
   return (globalThis as unknown as { hostLog: StandInHostLog }).hostLog;
 }
 
+/**
+ * Send one more request on the port, once the tool has connected — a `get`
+ * after the user has worked. Runs in the page, as
+ * `page.evaluate(sendStandInHostRequest, request)`.
+ * @param request - What to send.
+ * @returns Whether there was a port to send it on.
+ */
+export function sendStandInHostRequest(request: unknown): boolean {
+  const { hostPort } = globalThis as unknown as {
+    hostPort: MessagePort | null;
+  };
+  hostPort?.postMessage(request);
+  return hostPort !== null;
+}
+
+/** How long the page's address may be, in bytes: Chrome's own limit is 2 MB. */
+const MAX_SETUP_BYTES = 2 * 1024 * 1024;
+
 /**
  * The page. Its setup is its own `?setup=`, so one page serves every test, and
  * it listens before it frames, so the tool's `hello` cannot be missed.
@@ -95,11 +118,13 @@ const { toolUrl, requests } = JSON.parse(new URLSearchParams(location.search).ge
 const toolOrigin = new URL(toolUrl).origin;
 const frame = document.querySelector('#tool');
 globalThis.hostLog = { hello: null, results: [] };
+globalThis.hostPort = null;
 globalThis.addEventListener('message', (event) => {
   if (event.source !== frame.contentWindow || event.origin !== toolOrigin) return;
   if (event.data?.type !== 'cheminfo:hello') return;
   globalThis.hostLog.hello = event.data;
   const channel = new MessageChannel();
+  globalThis.hostPort = channel.port1;
   channel.port1.onmessage = (answer) => {
     globalThis.hostLog.results.push(answer.data);
   };

package/src/host/ui/useHostConnection.ts

@@ -7,17 +7,25 @@
 
 import { useEffect, useRef } from 'react';
 
-import type { LoadedInput } from '../core/connectHost.ts';
+import type { HostOutputs } from '../core/hostOutputs.ts';
 import type { ToolInterface } from '../core/protocol.ts';
+import type { LoadedInput } from '../core/selectInputs.ts';
 
 /** What a tool does with what its host sends, and what it says about itself. */
 export interface HostHandlers {
   /**
-   * Show the inputs of a new document. Throwing means they could not be read:
-   * the error's message goes back to the host, and nothing should have changed
-   * on screen.
+   * Show the inputs of a new document. Throwing, or rejecting, means they
+   * could not be read: the error's message goes back to the host, and nothing
+   * should have changed on screen.
    */
-  load: (inputs: readonly LoadedInput[]) => void;
+  load: (inputs: readonly LoadedInput[]) => void | Promise<void>;
+  /**
+   * Where the values of the tool's outputs are read, and their changes heard.
+   * Read once, when the host connects, so it lives as long as the page — a
+   * store of signals rather than a value of one render.
+   * @default undefined — nothing goes back
+   */
+  outputs?: HostOutputs;
   /**
    * The build that is running — `BUILD_INFO` from `react-cheminfo/build-info`
    * — so a host can record which version produced what it stores.
@@ -67,9 +75,10 @@ export function useHostConnection(
           tool,
           origin: globalThis.location.origin,
           build: latest.current.build ?? null,
-          load: (inputs) => {
-            latest.current.load(inputs);
-          },
+          load: (inputs) => latest.current.load(inputs),
+          ...(latest.current.outputs === undefined
+            ? {}
+            : { outputs: latest.current.outputs }),
         });
       })
       .catch(() => {

package/src/host-testing.ts

@@ -9,10 +9,14 @@ export type {
 } from './host/testing/standInHost.ts';
 export {
   readStandInHostLog,
+  sendStandInHostRequest,
   startStandInHost,
 } from './host/testing/standInHost.ts';
 export {
+  SCIPEAKS_ETHYLBENZENE_IR_FILENAME,
+  SCIPEAKS_ETHYLBENZENE_IR_PEAKS,
   SCIPEAKS_ETHYLBENZENE_LOAD,
   SCIPEAKS_ETHYLBENZENE_MOLFILE,
   SCIPEAKS_HOST_NAME,
+  sciPeaksEthylbenzeneIrLoad,
 } from './host/testing/sciPeaks.ts';