react-cheminfo 0.64.1 → 0.65.0

package/src/server/answerAddresses.ts

@@ -0,0 +1,92 @@
+/**
+ * Where an answer of a site's tool server points: the static site people
+ * share, which an answer's `link` names, and this server, whose copy of the
+ * same pages a chat frames.
+ *
+ * The two are written however the deployment writes them — an origin, an
+ * origin and a mount, with or without a trailing slash — and a page is named
+ * from the site's own root, `/titration` and `titration` alike: every helper
+ * joins the two with exactly one slash, so `https://www.cheminfo.org/surge`
+ * and `https://www.cheminfo.org/surge/` both put `/generator` at
+ * `https://www.cheminfo.org/surge/generator`.
+ */
+
+import { trimTrailingSlash } from '../router/core/address.ts';
+import { joinBasePath } from '../router/core/basePath.ts';
+
+/** Where the pages of an answer are served, as a deployment writes them. */
+export interface AnswerAddressesInput {
+  /** The static site an answer links to, the address people share. */
+  siteUrl: string | URL;
+  /** This server, as a browser reaches it: the view frames its pages. */
+  publicUrl: string | URL;
+}
+
+/** Where the pages of an answer are served, checked and written alike. */
+export interface AnswerAddresses {
+  /** The static site, ending in `/`: `https://equilibrium.cheminfo.org/`. */
+  readonly siteUrl: string;
+  /** This server, ending in `/`: `https://equilibrium.c6h6.org/`. */
+  readonly publicUrl: string;
+}
+
+/**
+ * Check the two addresses of a tool server's answers, and write them alike:
+ * absolute, `http` or `https`, without a query or a fragment, ending in `/`.
+ * @param input - The site and this server, as the deployment gives them.
+ * @returns The two addresses.
+ * @throws {Error} When either is not an http or https address.
+ */
+export function answerAddresses(input: AnswerAddressesInput): AnswerAddresses {
+  return {
+    siteUrl: baseAddress(input.siteUrl, 'siteUrl'),
+    publicUrl: baseAddress(input.publicUrl, 'publicUrl'),
+  };
+}
+
+/**
+ * The origins a view may frame: this server's, which a chat frames, and the
+ * shared site's, which a link opens. A server that is the site gives one.
+ * @param addresses - The two addresses.
+ * @returns Each origin once, this server's first.
+ */
+export function viewOrigins(addresses: AnswerAddressesInput): string[] {
+  return [
+    ...new Set([
+      new URL(addresses.publicUrl).origin,
+      new URL(addresses.siteUrl).origin,
+    ]),
+  ];
+}
+
+/**
+ * A page under a base address, joined with exactly one slash.
+ * @param base - An origin, or an origin and a mount, with or without its
+ *   trailing slash.
+ * @param page - A page from the site's own root, with or without its leading
+ *   slash, and with its query: `/titration?ind=phenolphthalein`.
+ * @returns The page's absolute address.
+ */
+export function joinAddress(base: string | URL, page: string): string {
+  return `${trimTrailingSlash(String(base))}${joinBasePath('', page)}`;
+}
+
+/**
+ * One address of a deployment, checked.
+ * @param value - The address.
+ * @param name - What it is, for the error.
+ * @returns The address without its query or fragment, ending in `/`.
+ */
+function baseAddress(value: string | URL, name: string): string {
+  const text = String(value).trim();
+  if (!URL.canParse(text)) {
+    throw new Error(`${name} is not an address: ${text}`);
+  }
+  const url = new URL(text);
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new Error(`${name} is not an http or https address: ${text}`);
+  }
+  url.search = '';
+  url.hash = '';
+  return url.href.endsWith('/') ? url.href : `${url.href}/`;
+}

package/src/server/cardMeta.ts

@@ -0,0 +1,88 @@
+/**
+ * What a tool server's answer carries for a chat to show it: the link to the
+ * site's page people share, and the `meta` naming that page framed on this
+ * server — its card inline, the page itself over the full screen.
+ */
+
+import type { CardPageOptions } from '../card/core/cardPageUrl.ts';
+import { cardPageUrl, framedPageUrl } from '../card/core/cardPageUrl.ts';
+import { formatQueryString } from '../router/core/query.ts';
+
+import type { AnswerAddressesInput } from './answerAddresses.ts';
+import { joinAddress } from './answerAddresses.ts';
+import { mcpServer } from './mcpServer.ts';
+
+/** How {@link cardMeta} writes the card and the page. */
+export interface CardMetaOptions extends CardPageOptions {
+  /**
+   * The longest card address an answer carries. Browsers take far more, but a
+   * proxy reading the request line stops at 8 to 16 KB; past this length the
+   * answer carries no card, and the chat draws the answer itself.
+   * @default 8000
+   */
+  maxLength?: number;
+}
+
+/** The page an answer is shown on. */
+export interface PageAnswer {
+  /** The page on the static site people share: what `result.link` says. */
+  link: string;
+  /**
+   * The answer's `meta`: the card on this server, framed inline, and the same
+   * page whole for when the reader asks for more. Undefined when the card's
+   * address would be longer than `maxLength`.
+   */
+  meta: Record<string, unknown> | undefined;
+}
+
+/**
+ * What an answer carries for the view to show a page of this server: inline
+ * its card, drawing only the answer; over the full screen the page itself.
+ * Both are without the site's chrome, and without the parts `hide` names.
+ * @param addresses - Where the site and this server are; only this server's
+ *   is read.
+ * @param page - The page from the site's own root, with its own query and
+ *   without `embed`, `hide` or `card`: `/titration?ind=phenolphthalein`.
+ * @param options - The parts left out, what the card draws, and the longest
+ *   card address carried.
+ * @returns The answer's `meta`, or undefined when the card's address is too
+ *   long to carry.
+ */
+export function cardMeta(
+  addresses: AnswerAddressesInput,
+  page: string,
+  options: CardMetaOptions = {},
+): Record<string, unknown> | undefined {
+  const { maxLength = 8000, ...written } = options;
+  const framed = joinAddress(addresses.publicUrl, page);
+  const card = cardPageUrl(framed, written);
+  if (card.length > maxLength) return undefined;
+  return mcpServer().embedMeta(card, { page: framedPageUrl(framed, written) });
+}
+
+/**
+ * A page with its query: the link people share, on the static site, and the
+ * `meta` the view frames this server's copy of it with. The query is written
+ * by `formatQueryString`, so a `+` is escaped, a comma stays a comma, and a
+ * parameter left `undefined` or empty is not written: the page reads its own
+ * default.
+ * @param addresses - Where the site and this server are.
+ * @param path - The page, from the site's own root: `/titration`.
+ * @param params - Its query, in the order it is written.
+ * @param options - The parts left out, what the card draws, and the longest
+ *   card address carried.
+ * @returns The link and the meta.
+ */
+export function pageAnswer(
+  addresses: AnswerAddressesInput,
+  path: string,
+  params: Readonly<Record<string, string | undefined>> = {},
+  options: CardMetaOptions = {},
+): PageAnswer {
+  const query = formatQueryString(params);
+  const page = query === '' ? path : `${path}?${query}`;
+  return {
+    link: joinAddress(addresses.siteUrl, page),
+    meta: cardMeta(addresses, page, options),
+  };
+}

package/src/server/config.ts

@@ -0,0 +1,125 @@
+import { siteById } from '../ecosystem/core/lookup.ts';
+import type { SiteId } from '../ecosystem/core/sites.ts';
+import { siteUrl } from '../ecosystem/core/sites.ts';
+import { normalizeBasePath } from '../router/core/basePath.ts';
+
+import { readEnvNumber } from './envNumber.ts';
+import { parseTrustProxy } from './trustProxy.ts';
+
+/** An environment, as `process.env` holds it. */
+export type ServerEnvironment = Readonly<Record<string, string | undefined>>;
+
+/** What a site's server knows before it reads its environment. */
+export interface ServerConfigOptions {
+  /** The site, as `ECOSYSTEM_SITES` names it: its address is the default `SITE_URL`. */
+  siteId: SiteId;
+  /** The port derived from the site's creation date, the one compose publishes. */
+  port: number;
+  /**
+   * The build served when `SERVER_ROOT` names none, usually
+   * `join(import.meta.dirname, '../dist')`.
+   * @default 'dist' - resolved from the directory the process runs in
+   */
+  root?: string;
+}
+
+/** What a site's server is started with, every default filled in. */
+export interface ServerConfig {
+  /** Where it listens: `PORT`, or the site's own port. */
+  port: number;
+  /** The interface it listens on: `HOST`, or every interface, as a container needs. */
+  host: string;
+  /** `TRACKING_SCRIPT`, verbatim; `undefined` loads nothing. */
+  trackingScript: string | undefined;
+  /**
+   * `SITE_URL`: the static site people share, which every answer links to,
+   * ending in `/`.
+   */
+  siteUrl: string;
+  /**
+   * `PUBLIC_URL`: this server's own address, whose pages a chat frames, ending
+   * in `/`.
+   */
+  publicUrl: string;
+  /** `TRUST_PROXY`: the reverse proxies whose `X-Forwarded-For` is believed. */
+  trustProxy: boolean | string;
+  /** `SERVER_ROOT`: the build it serves. */
+  root: string;
+  /**
+   * `BASE_PATH`: where the deployment is mounted behind a proxy that takes the
+   * path off, `/osiris`, or `''` on a host of its own.
+   */
+  basePath: string;
+}
+
+/**
+ * Read a site's server configuration from its environment, once, at startup.
+ *
+ * A malformed value refuses to start rather than handing out links that lead
+ * nowhere. Both addresses keep their path — a site may be mounted under one,
+ * and its pages are written relative to it — and lose their query and their
+ * fragment; each ends in `/`.
+ *
+ *   const config = readServerConfig(process.env, { siteId: 'osiris', port: 10_620 });
+ * @param env - The environment, e.g. `process.env`.
+ * @param options - The site and its port.
+ * @returns The configuration.
+ * @throws {Error} When `PORT`, `SITE_URL` or `PUBLIC_URL` cannot be read, or
+ * `TRUST_PROXY` is a hop count.
+ */
+export function readServerConfig(
+  env: ServerEnvironment,
+  options: ServerConfigOptions,
+): ServerConfig {
+  const port = readEnvNumber(env, 'PORT', options.port, {
+    min: 1,
+    max: 65_535,
+    integer: true,
+  });
+  return {
+    port,
+    host: env.HOST?.trim() || '0.0.0.0',
+    trackingScript: env.TRACKING_SCRIPT?.trim() || undefined,
+    siteUrl: readHttpAddress(
+      env,
+      'SITE_URL',
+      siteUrl(siteById(options.siteId)),
+    ),
+    publicUrl: readHttpAddress(env, 'PUBLIC_URL', `http://localhost:${port}/`),
+    trustProxy: parseTrustProxy(env.TRUST_PROXY),
+    root: env.SERVER_ROOT?.trim() || options.root || 'dist',
+    basePath: normalizeBasePath(env.BASE_PATH ?? ''),
+  };
+}
+
+/**
+ * Read an http or https address from the environment, the way a link is built
+ * on it: its path kept and ended with `/`, its query and its fragment dropped.
+ * @param env - The environment, e.g. `process.env`.
+ * @param name - The variable, e.g. `SITE_URL`.
+ * @param fallback - The address when the variable is unset or blank.
+ * @returns The address, ending in `/`.
+ * @throws {Error} When the value, or the fallback, is not an http or https
+ * address.
+ */
+export function readHttpAddress(
+  env: ServerEnvironment,
+  name: string,
+  fallback: string,
+): string {
+  const text = env[name]?.trim() || fallback;
+  const message = `${name} must be an http(s) address, not "${text}".`;
+  let url: URL;
+  try {
+    url = new URL(text);
+  } catch (error) {
+    throw new Error(message, { cause: error });
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new Error(message);
+  }
+  url.search = '';
+  url.hash = '';
+  if (!url.pathname.endsWith('/')) url.pathname = `${url.pathname}/`;
+  return url.href;
+}

package/src/server/envNumber.ts

@@ -0,0 +1,65 @@
+/** The bounds a number read from the environment must keep. */
+export interface ReadEnvNumberOptions {
+  /**
+   * The smallest value accepted.
+   * @default undefined - no lower bound
+   */
+  min?: number;
+  /**
+   * The largest value accepted.
+   * @default undefined - no upper bound
+   */
+  max?: number;
+  /**
+   * Whether the value must be a whole number.
+   * @default false
+   */
+  integer?: boolean;
+}
+
+/**
+ * Read a number from the environment.
+ *
+ * The compose files forward every variable as `${NAME:-}`, so a deployment that
+ * sets nothing hands the process an empty string rather than no variable — and
+ * `Number('')` is 0, which turned an indexer's interval into a busy loop. Unset,
+ * empty and blank all mean the fallback here. A value that says something but is
+ * not an accepted number refuses to start rather than running on a guess.
+ * @param env - The environment, e.g. `process.env`.
+ * @param name - The variable, e.g. `INDEX_INTERVAL`.
+ * @param fallback - The value when the variable says nothing.
+ * @param options - The bounds the value must keep.
+ * @returns The number written, or the fallback.
+ * @throws {Error} When the value is not a finite number, or breaks a bound.
+ */
+export function readEnvNumber(
+  env: Readonly<Record<string, string | undefined>>,
+  name: string,
+  fallback: number,
+  options: ReadEnvNumberOptions = {},
+): number {
+  const text = env[name]?.trim();
+  if (!text) return fallback;
+  const value = Number(text);
+  const { min, max, integer = false } = options;
+  if (
+    !Number.isFinite(value) ||
+    (integer && !Number.isInteger(value)) ||
+    (min !== undefined && value < min) ||
+    (max !== undefined && value > max)
+  ) {
+    throw new Error(`${name} must be ${expected(options)}, not "${text}".`);
+  }
+  return value;
+}
+
+function expected(options: ReadEnvNumberOptions): string {
+  const { min, max, integer = false } = options;
+  const kind = integer ? 'an integer' : 'a number';
+  if (min !== undefined && max !== undefined) {
+    return `${kind} from ${min} to ${max}`;
+  }
+  if (min !== undefined) return `${kind} of at least ${min}`;
+  if (max !== undefined) return `${kind} of at most ${max}`;
+  return kind;
+}

package/src/server/healthRoute.ts

@@ -0,0 +1,42 @@
+import type { FastifyInstance } from 'fastify';
+
+import { ALLOW_ORIGIN, HIDDEN } from './routeOptions.ts';
+
+/** Options of {@link healthRoute}. */
+export interface HealthRouteOptions {
+  /**
+   * More fields for the answer, read locally and cheaply: a probe every 30 s
+   * must never wait on another service, or a dependency that is down rolls back
+   * a good release. `status` is always `ok`, whatever this returns.
+   * @default undefined - the answer is `{ status: 'ok' }`
+   */
+  extra?: () => Record<string, unknown> | Promise<Record<string, unknown>>;
+}
+
+/**
+ * Answer `GET /health`, what the container's health check and the server's
+ * deploy script probe before they keep a new container.
+ *
+ * It is at the root, never versioned, because it probes the process rather than
+ * the API contract. It logs nothing, or a probe every 30 s fills the log; it is
+ * kept out of the API's documentation; and it is open to any origin, like
+ * everything else a site serves.
+ *
+ *   await healthRoute(app);
+ * @param fastify - The server.
+ * @param options - Extra fields for the answer.
+ */
+export async function healthRoute(
+  fastify: FastifyInstance,
+  options: HealthRouteOptions = {},
+): Promise<void> {
+  const { extra } = options;
+  fastify.get(
+    '/health',
+    { logLevel: 'silent', schema: HIDDEN },
+    async (_request, reply) => {
+      const fields = extra === undefined ? {} : await extra();
+      return reply.header(ALLOW_ORIGIN, '*').send({ ...fields, status: 'ok' });
+    },
+  );
+}

package/src/server/listenSite.ts

@@ -0,0 +1,90 @@
+import type { FastifyInstance } from 'fastify';
+
+/** Options of {@link listenSite}. */
+export interface ListenSiteOptions {
+  /** The port to listen on. */
+  port: number;
+  /**
+   * The interface to listen on.
+   * @default '0.0.0.0' - every interface, as a container needs
+   */
+  host?: string;
+  /**
+   * Run once the server has closed on a signal: stop what the server does not
+   * own itself, such as a scheduler or a write queue started beside it.
+   * @default undefined - nothing more is stopped
+   */
+  onClose?: () => void | Promise<void>;
+  /**
+   * The signals that close the server.
+   * @default ['SIGTERM', 'SIGINT'] - what `docker stop` and a terminal send
+   */
+  signals?: readonly NodeJS.Signals[];
+}
+
+/**
+ * Listen, and close cleanly when the container is stopped.
+ *
+ * On the first signal the server closes — its `onClose` hooks stop the worker
+ * pools it owns — then `onClose` runs. A close that fails is logged and leaves
+ * `process.exitCode` at 1 rather than surfacing as an unhandled rejection, and
+ * the process ends on its own once nothing is left running. A server that
+ * cannot listen is logged, closed and reported the same way.
+ *
+ *   await listenSite(app, { port: config.port, host: config.host });
+ * @param app - The server, built and not yet listening.
+ * @param options - Where to listen, and what else to stop.
+ * @throws {Error} When the server cannot listen, after it has been closed.
+ */
+export async function listenSite(
+  app: FastifyInstance,
+  options: ListenSiteOptions,
+): Promise<void> {
+  const {
+    port,
+    host = '0.0.0.0',
+    onClose,
+    signals = ['SIGTERM', 'SIGINT'],
+  } = options;
+
+  const stop = () => {
+    for (const signal of signals) process.off(signal, stop);
+    void shutDown(app, onClose);
+  };
+  for (const signal of signals) process.once(signal, stop);
+
+  try {
+    await app.listen({ port, host });
+  } catch (error) {
+    for (const signal of signals) process.off(signal, stop);
+    app.log.error(error, `the server could not listen on ${host}:${port}`);
+    process.exitCode = 1;
+    await shutDown(app, onClose);
+    throw error;
+  }
+}
+
+/**
+ * Close the server, then run what else has to stop, reporting a failure of
+ * either through the log and the exit code.
+ * @param app - The server.
+ * @param onClose - What else to stop.
+ */
+async function shutDown(
+  app: FastifyInstance,
+  onClose: (() => void | Promise<void>) | undefined,
+): Promise<void> {
+  try {
+    await app.close();
+  } catch (error) {
+    app.log.error(error, 'the server did not close cleanly');
+    process.exitCode = 1;
+  }
+  if (onClose === undefined) return;
+  try {
+    await onClose();
+  } catch (error) {
+    app.log.error(error, 'what runs beside the server did not stop cleanly');
+    process.exitCode = 1;
+  }
+}

package/src/server/mcpServer.ts

@@ -0,0 +1,14 @@
+import { createRequire } from 'node:module';
+
+import type * as McpServer from 'cheminfo-mcp-server';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * `cheminfo-mcp-server`, an optional peer, loaded when a helper first needs
+ * it, so `react-cheminfo/server` imports on a site that serves no tools.
+ * @returns The module.
+ */
+export function mcpServer(): typeof McpServer {
+  return require('cheminfo-mcp-server') as typeof McpServer;
+}

package/src/server/repositoryVersion.ts

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { UNRELEASED_VERSION } from '../build/core/buildInfo.ts';
+import { findRepositoryRoot } from '../build/vite/buildInfo.ts';
+
+/**
+ * The release a server's repository is at, as release-please writes it.
+ *
+ * Read from the `package.json` at the repository root, found by the same
+ * climbing rule `cheminfoBuildInfo` follows: a `backend` or `server` directory
+ * keeps the `0.0.0` it was scaffolded with, or none at all, while the root is
+ * the manifest a release bumps. A manifest that cannot be read is not a reason
+ * to refuse to start, so it reads as unreleased instead.
+ *
+ *   const version = readRepositoryVersion(import.meta.dirname);
+ * @param fromDirectory - Where to start climbing, usually the server's own
+ * directory.
+ * @returns The version, or `'0.0.0'` when the root manifest carries none.
+ */
+export function readRepositoryVersion(fromDirectory: string): string {
+  const root = findRepositoryRoot(fromDirectory);
+  let manifest: unknown;
+  try {
+    manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+  } catch {
+    return UNRELEASED_VERSION;
+  }
+  const version = (manifest as { version?: unknown } | null)?.version;
+  return typeof version === 'string' && version !== ''
+    ? version
+    : UNRELEASED_VERSION;
+}

package/src/server/routeOptions.ts

@@ -0,0 +1,26 @@
+/**
+ * What every route the serving helpers register shares: how it is cached, who
+ * may read it, and that it stays out of the API's documentation.
+ */
+
+import type { FastifySchema } from 'fastify';
+
+/** A page is checked on every visit: it names the bundles of its own build. */
+export const PAGE_CACHE = 'no-cache';
+
+/** A bundle is named by its content, so it never changes under its name. */
+export const BUNDLE_CACHE = 'public, max-age=31536000, immutable';
+
+/**
+ * The header that opens an answer to every origin. Every file of a build is
+ * public, and a page framed by a sandboxed view runs under an opaque origin,
+ * where everything it fetches from its own site is cross-origin: the static
+ * hosts open every response, and so do these servers.
+ */
+export const ALLOW_ORIGIN = 'access-control-allow-origin';
+
+/** Kept out of the API's documentation (`@fastify/swagger` reads `hide`). */
+export const HIDDEN: FastifySchema & { hide: boolean } = { hide: true };
+
+/** The addresses an API and its documentation answer, never a page. */
+export const DEFAULT_RESERVED: readonly string[] = ['/v1/', '/docs'];

package/src/server/routeTable.ts

@@ -0,0 +1,35 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { ROUTE_TABLE_FILE, parseRouteTable } from '../seo/core/routeTable.ts';
+import type { RouteMeta } from '../seo/core/routes.ts';
+
+/**
+ * Every address the frontend routes itself, from the `routes.json` its build
+ * wrote beside the page (`cheminfoRouteTable` in `react-cheminfo/vite`).
+ *
+ * The pages that exist whatever the build wrote are the fallback, so a server
+ * started before the frontend was built, or against a build of an older shape,
+ * still titles them.
+ * @param root - The directory holding the built frontend.
+ * @param fallback - The routes when the build wrote no table this can read.
+ * @returns The routes, the home page first.
+ */
+export function readRouteTable(
+  root: string,
+  fallback: readonly RouteMeta[],
+): RouteMeta[] {
+  let text: string;
+  try {
+    text = readFileSync(join(root, ROUTE_TABLE_FILE), 'utf8');
+  } catch {
+    return [...fallback];
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return [...fallback];
+  }
+  return parseRouteTable(parsed) ?? [...fallback];
+}

package/src/server/siteView.ts

@@ -0,0 +1,42 @@
+import type { AppResource } from 'cheminfo-mcp-server';
+
+import type { AnswerAddressesInput } from './answerAddresses.ts';
+import { viewOrigins } from './answerAddresses.ts';
+import { mcpServer } from './mcpServer.ts';
+
+/** What {@link siteView} names, and where its pages come from. */
+export interface SiteViewOptions {
+  /** Its address, which the tools name in `ui.resourceUri`: `ui://lcao/page`. */
+  uri: string;
+  /** For people: the site's host, `lcao.cheminfo.org`. */
+  name: string;
+  /** For people: what the card shows inline, and the page over the screen. */
+  description: string;
+  /** Where the site and this server are: the view frames both, and no other. */
+  addresses: AnswerAddressesInput;
+  /**
+   * The height of the frame, in pixels, for a page that cannot report its
+   * own.
+   * @default undefined - the page reports its height, as `CardFrame` does
+   */
+  height?: number;
+}
+
+/**
+ * The MCP App showing an answer on the site's own page: inline the answer's
+ * card, the page itself over the full screen, framed from this server or from
+ * the static site. One per tool server, named by every tool whose answer
+ * carries a `meta` from `cardMeta` or `pageAnswer`.
+ * @param options - Its address, its name, and the two addresses it frames.
+ * @returns The resource, for `createToolRoutes({ resources })`.
+ */
+export function siteView(options: SiteViewOptions): AppResource {
+  const { uri, name, description, addresses, height } = options;
+  return mcpServer().embedView({
+    uri,
+    name,
+    description,
+    origins: viewOrigins(addresses),
+    height,
+  });
+}