@selvajs/compute 5.0.0-beta.7 → 5.0.0-beta.9

package/dist/grasshopper.d.cts

@@ -1,1355 +0,0 @@
-import { D as ComputeAuth, M as ComputeError, O as ComputeConfig, _ as SolveDefinition, j as ServerTiming, k as RetryPolicy, s as FileBaseInfo } from "./index-DDmprCht.cjs";
-interface ServerVersion {
-  rhino: string;
-  compute: string;
-  git_sha: string | null;
-}
-interface ServerStats {
-  isOnline: boolean;
-  version?: ServerVersion;
-  activeChildren?: number;
-}
-/**
- * ComputeServerStats provides methods to query Rhino Compute server statistics.
- *
- * @public Use this for server health monitoring and statistics.
- *
- * @example
- * ```typescript
- * const stats = new ComputeServerStats('http://localhost:6500', 'your-api-key');
- *
- * try {
- *   const isOnline = await stats.isServerOnline();
- *   const children = await stats.getActiveChildren();
- *   const version = await stats.getVersion();
- *
- *   // Or get everything at once
- *   const allStats = await stats.getServerStats();
- * } finally {
- *   await stats.dispose(); // Clean up resources
- * }
- * ```
- */
-declare class ComputeServerStats {
-  private readonly serverUrl;
-  private readonly headers;
-  private disposed;
-  private activeMonitors;
-  /** Timeout (ms) for the fast read/monitoring endpoints. */
-  private static readonly DEFAULT_TIMEOUT_MS;
-  /** Timeout (ms) for child-lifecycle POSTs — a cold Windows child can take ~30s to spawn. */
-  private static readonly LIFECYCLE_TIMEOUT_MS;
-  /** Floor for `monitor()`'s `intervalMs` — anything lower hot-loops the server. */
-  private static readonly MIN_MONITOR_INTERVAL_MS;
-  /** Every control-plane answer is a count, a version or a short map. */
-  private static readonly MAX_BODY_BYTES;
-  /**
-   * @param serverUrl - Base URL of the Rhino Compute server with http:// or https:// scheme (e.g., 'http://localhost:6500')
-   * @param auth - An API key, or the same auth fields a solve's `ComputeConfig` carries
-   *   (`apiKey`, `apiKeyHeader`, `authToken`, `headers`).
-   */
-  constructor(serverUrl: string, auth?: string | ComputeAuth);
-  /**
-   * Aborts after `timeoutMs` so a hung connection can't stall a probe or `monitor()`; `0` disables
-   * it. Redirects are not followed: fetch would carry the API key header to the target.
-   */
-  private fetchWithTimeout;
-  /**
-   * The response body of `path`, or `null` (logged) on a non-2xx or a network
-   * failure. Throws only when disposed.
-   */
-  private getText;
-  /**
-   * Check if the server is online.
-   *
-   * This is a single-sample probe: it returns `true` only on a 2xx or a redirect
-   * from the proxy liveness root `/`, and `false` for every other outcome (4xx/5xx,
-   * network error, or timeout). A cold or briefly-busy-but-up server can therefore
-   * read as offline — callers that gate on this (e.g. client construction)
-   * should retry rather than treat a single `false` as authoritative.
-   *
-   * @param timeoutMs - Abort the probe after this many ms (default: 5000).
-   *   Pass `0` to disable the timeout. Prevents a hung connection from
-   *   stalling the caller indefinitely.
-   */
-  isServerOnline(timeoutMs?: number): Promise<boolean>;
-  /**
-   * Detailed liveness probe backing {@link isServerOnline}.
-   *
-   * Reports what the probe actually saw so callers can distinguish "connection
-   * failed" (`error` set) from "server answered non-2xx" (`status` set) — e.g.
-   * a 401 from a proxy that requires an API key is a misconfiguration, not an
-   * offline server. Same single-sample caveat as {@link isServerOnline}.
-   *
-   * @param timeoutMs - Abort the probe after this many ms (default: 5000).
-   *   Pass `0` to disable the timeout.
-   * @returns `online` plus either the HTTP `status` the server answered with,
-   *   or the `error` the connection attempt failed with.
-   */
-  probeServer(timeoutMs?: number): Promise<{
-    online: boolean;
-    status?: number;
-    error?: string;
-  }>;
-  /**
-   * Get the number of active child processes on the server.
-   *
-   * By default the proxy's `/activechildren` endpoint will *spawn* children up
-   * to the configured count if none are running, then report the count — which
-   * wakes (and bills) an idle server. Pass `{ initialize: false }` for a passive
-   * read that reports the current count without spawning; use this for
-   * monitoring or before a purge/probe where you must not wake the server.
-   *
-   * @param options.initialize - When `false`, append `?initialize=false` so the
-   *   server reports without spawning. Defaults to `true` (the server's default).
-   * @returns Number of active children, or null if unavailable
-   */
-  getActiveChildren(options?: {
-    initialize?: boolean;
-  }): Promise<number | null>;
-  /**
-   * Get the server version information.
-   *
-   * @returns Version object with rhino, compute, and git_sha, or null if unavailable
-   */
-  getVersion(): Promise<ServerVersion | null>;
-  /**
-   * Get the plugins installed on the server.
-   *
-   * Returns a `name → version` map of non-core plugins the server has loaded,
-   * or `null` if the request failed. Pass `kind` to choose which inventory:
-   * `'gh'` (default) lists Grasshopper add-on assemblies via
-   * `/plugins/gh/installed`; `'rhino'` lists Rhino plugins via
-   * `/plugins/rhino/installed`. Plugins that ship with Rhino / are core
-   * libraries are excluded by the server.
-   *
-   * @param kind - `'gh'` for Grasshopper add-ons (default) or `'rhino'` for Rhino plugins.
-   * @returns Map of plugin name to version, or `null` on failure.
-   *
-   * @example
-   * ```ts
-   * const gh = await stats.getInstalledPlugins();        // Grasshopper add-ons
-   * const selvaVersion = gh?.['Selva'] ?? null;
-   * ```
-   */
-  getInstalledPlugins(kind?: 'gh' | 'rhino'): Promise<Record<string, string> | null>;
-  /**
-   * Get comprehensive server statistics.
-   * Fetches all available server information in parallel.
-   *
-   * @returns Object containing server status and available stats
-   */
-  getServerStats(): Promise<ServerStats>;
-  /**
-   * Purge the server's solve-results / URL-data cache.
-   *
-   * POSTs to `cache/purge` and returns the number of entries removed, or `null`
-   * if the request failed. This clears cached solve responses and fetched
-   * definition-URL data; it does NOT evict the definition cache (active
-   * `pointer` references stay valid).
-   *
-   * **Caveat:** `cache/purge` is forwarded by the rhino.compute proxy to a
-   * single round-robin-selected child, so in a multi-child deployment one call
-   * purges one child's cache. Call repeatedly (or size the pool to 1) if you
-   * need a fleet-wide purge.
-   *
-   * @returns Number of entries removed, or `null` on failure.
-   *
-   * @example
-   * ```ts
-   * const removed = await stats.purgeCache();
-   * if (removed !== null) console.log(`Purged ${removed} cached solves`);
-   * ```
-   */
-  purgeCache(): Promise<number | null>;
-  /**
-   * Best-effort fleet-wide cache purge across a multi-child deployment.
-   *
-   * A single {@link purgeCache} POST is forwarded by the rhino.compute proxy to
-   * just ONE round-robin-selected child, so the other children keep serving
-   * stale cached solves. There is no proxy endpoint that addresses children
-   * individually, so this method reads the active child count (passively, never
-   * spawning) and fires `2 × count` sequential purges, relying on the proxy's
-   * round-robin to spread the hits across the pool.
-   *
-   * **This is best-effort, not a guarantee.** Round-robin can revisit one child
-   * and skip another; under concurrent traffic the rotation drifts. The result's
-   * `confident` flag is `true` only when the server reports a single child (where
-   * one purge is exact) — surface it so callers don't over-promise. For a hard
-   * fleet-wide guarantee, run the deployment at `--childcount 1` or add a
-   * server-side fan-out endpoint.
-   *
-   * @returns `{ totalPurged, calls, children, confident }`, or `null` if the
-   *   child count couldn't be read (server unreachable). `totalPurged` sums the
-   *   per-call counts; `calls` is how many purges were issued; `children` is the
-   *   reported pool size; `confident` is `true` only at a single-child pool.
-   *
-   * @example
-   * ```ts
-   * const r = await stats.purgeAllChildren();
-   * if (r && !r.confident) {
-   *   console.warn(`Purged ~${r.totalPurged} across ${r.children} children (best-effort)`);
-   * }
-   * ```
-   */
-  purgeAllChildren(): Promise<{
-    totalPurged: number;
-    calls: number;
-    children: number;
-    confident: boolean;
-  } | null>;
-  /**
-   * Get the server's current UTC clock.
-   *
-   * GETs `/servertime`, which the server emits as a JSON-encoded ISO-8601
-   * timestamp (e.g. `"2026-06-18T08:30:00Z"`). Useful for detecting clock skew
-   * between caller and server. Returns `null` if the request failed or the body
-   * isn't a parseable date.
-   *
-   * @returns A `Date` for the server's UTC time, or `null` on failure.
-   */
-  getServerTime(): Promise<Date | null>;
-  /**
-   * Get how long the rhino.compute proxy has been idle.
-   *
-   * GETs `/idlespan` on the proxy, which returns the seconds elapsed since the
-   * last request was forwarded to a compute child. This is a proxy-level metric
-   * (not proxied to a child) used by autoscalers to decide when a node can be
-   * drained. Returns `null` if unavailable.
-   *
-   * @returns Idle time in seconds, or `null` on failure.
-   */
-  getIdleSpan(): Promise<number | null>;
-  /**
-   * Fill the compute child pool up to the server's configured baseline.
-   *
-   * POSTs `/launch-children`. No-op when the pool is already at or above the
-   * configured `--childcount`. Returns `{ spawned, active }` — how many children
-   * were started and the resulting child count — or `null` on failure.
-   *
-   * To raise capacity above the baseline use {@link launchChild}; the baseline
-   * itself can only be changed by restarting rhino.compute.
-   *
-   * @returns `{ spawned, active }`, or `null` on failure.
-   */
-  launchChildren(): Promise<{
-    spawned: number[];
-    active: number;
-  } | null>;
-  /**
-   * Add a single compute child to the pool, optionally on a specific port.
-   *
-   * POSTs `/launch-child` (with `?port=N` when `port` is given). Unlike
-   * {@link launchChildren}, this can push the pool above the baseline, up to the
-   * server's `MaxChildren` cap. Returns `{ spawned: [port] }` on success, or
-   * `null` on failure (server replies 400 for a bad port, 409 if the port is in
-   * use, 503 at the max-children cap).
-   *
-   * @param port - Optional specific port to launch on; otherwise the next free one.
-   * @returns `{ spawned }` listing the launched port, or `null` on failure.
-   */
-  launchChild(port?: number): Promise<{
-    spawned: number[];
-  } | null>;
-  /**
-   * Gracefully shut down compute children without respawning them.
-   *
-   * POSTs `/shutdown-children`. With no `port` it shuts down every child; with
-   * `port` it targets just that one. Children do not respawn, but the next
-   * `/grasshopper` request auto-spawns the pool back to the baseline. Returns
-   * `{ shutdown, active }` — how many were stopped and the remaining count — or
-   * `null` on failure.
-   *
-   * @param port - Optional port to target; omit to shut down all children.
-   * @returns `{ shutdown, active }`, or `null` on failure.
-   */
-  shutdownChildren(port?: number): Promise<{
-    shutdown: number;
-    active: number;
-  } | null>;
-  /**
-   * Shut down compute children and respawn replacements (rolling restart).
-   *
-   * POSTs `/recycle-children`. With no `port` it recycles every child; with
-   * `port` it recycles just that one. The server recycles sequentially (each
-   * replacement is serving before the next child is stopped) so the pool never
-   * drops to zero mid-recycle. Returns `{ shutdown, spawned, active }`, or
-   * `null` on failure.
-   *
-   * @param port - Optional port to target; omit to recycle all children.
-   * @returns `{ shutdown, spawned, active }`, or `null` on failure.
-   */
-  recycleChildren(port?: number): Promise<{
-    shutdown: number;
-    spawned: number[];
-    active: number;
-  } | null>;
-  /** A child-lifecycle POST: a spawn or recycle can take ~30 s. */
-  private postJson;
-  /**
-   * Continuously monitor server stats at specified interval.
-   *
-   * @param callback - Function called with stats on each interval
-   * @param intervalMs - Milliseconds between checks (default: 5000). Must be a
-   *   finite number of at least 100 ms — lower values would hot-loop the server.
-   * @returns Function to stop monitoring
-   * @throws {ComputeError} `INVALID_CONFIG` if `intervalMs` is not a finite number >= 100.
-   *
-   * @example
-   * ```typescript
-   * const stopMonitoring = stats.monitor((data) => {
-   *   console.log('Server stats:', data);
-   * }, 3000);
-   *
-   * // Later...
-   * stopMonitoring();
-   * ```
-   */
-  monitor(callback: (stats: ServerStats) => void, intervalMs?: number): () => void;
-  /**
-   * Disposes of all resources and stops all active monitors.
-   * Call this when you're done using the stats instance.
-   */
-  dispose(): Promise<void>;
-  private ensureNotDisposed;
-}
-type DataTreePath = `{${string}}`;
-interface DataItem {
-  type: string;
-  data: string;
-  id: string;
-}
-type DataTreeDefault<T = any> = { [K in DataTreePath]?: T[]; };
-type InnerTreeData = { [path in DataTreePath]: DataItem[]; };
-/**
- * Tree with parameter metadata (used in compute requests and responses).
- *
- * This client sends PascalCase (`TreeBuilder.toComputeFormat()`), so those
- * fields are required; a response's casing varies by server branch, so read
- * one with `readField` rather than by property.
- */
-interface DataTree {
-  /** PascalCase — stock mcneel servers, and the request shape this client sends. */
-  InnerTree: InnerTreeData;
-  /** PascalCase — stock mcneel servers, and the request shape this client sends. */
-  ParamName: string;
-  /** camelCase — sent instead of `InnerTree` by camelCase server forks. */
-  innerTree?: InnerTreeData;
-  /** camelCase — sent instead of `ParamName` by camelCase server forks. */
-  paramName?: string;
-}
-/**
- * Union type for all possible default value types
- */
-type DefaultValue<T> = T | T[] | DataTreeDefault<T> | undefined | null;
-/**
- * Base properties common to all processed input types.
- * Note: `groupName` and `id` require the custom Rhino Compute branch.
- */
-interface BaseInputType {
-  description: string;
-  name: string;
-  nickname: string | null;
-  treeAccess: boolean;
-  /**
-   * Name of the group this parameter belongs to.
-   * @requires Custom branch of compute.rhino3d
-   */
-  groupName?: string;
-  /**
-   * Unique identifier for the parameter.
-   * @requires Custom branch of compute.rhino3d
-   */
-  id?: string;
-}
-/**
- * Numeric input type (Number or Integer)
- */
-interface NumericInputType extends BaseInputType {
-  paramType: 'Number' | 'Integer';
-  minimum?: number | null;
-  maximum?: number | null;
-  atLeast?: number | null;
-  atMost?: number | null;
-  stepSize?: number | null;
-  default: DefaultValue<number>;
-}
-/**
- * Text input type
- */
-interface TextInputType extends BaseInputType {
-  paramType: 'Text';
-  default: DefaultValue<string>;
-}
-/**
- * Boolean input type
- */
-interface BooleanInputType extends BaseInputType {
-  paramType: 'Boolean';
-  default: DefaultValue<boolean>;
-}
-/**
- * Geometry input type (generic geometry)
- */
-interface GeometryInputType extends BaseInputType {
-  paramType: 'Geometry';
-  default: DefaultValue<object | string>;
-}
-/**
- * ValueList input type (dropdown/select)
- */
-interface ValueListInputType extends BaseInputType {
-  paramType: 'ValueList';
-  values: Record<string, string>;
-  default?: string;
-}
-/**
- * File input type
- */
-interface FileInputType extends BaseInputType {
-  paramType: 'File';
-  acceptedFormats?: string[];
-  default: DefaultValue<object | string>;
-}
-/**
- * Color input type. Values are `"R, G, B"` strings (`"255, 0, 0"`), not hex.
- */
-interface ColorInputType extends BaseInputType {
-  paramType: 'Color';
-  default: DefaultValue<string>;
-}
-/**
- * Discriminated union of all input parameter types
- */
-type InputParam = NumericInputType | BooleanInputType | TextInputType | ValueListInputType | GeometryInputType | FileInputType | ColorInputType;
-type RhinoModelUnit = 'None' | 'Microns' | 'Millimeters' | 'Centimeters' | 'Decimeters' | 'Meters' | 'Kilometers' | 'Mils' | 'Inches' | 'Feet' | 'Yards' | 'Miles' | 'CustomUnits' | 'Unset';
-/**
- * Base Grasshopper schema properties shared by config, args, and response
- */
-interface GrasshopperBaseSchema {
-  /** Absolute tolerance used in computation */
-  absolutetolerance?: number | null;
-  /** Angular tolerance used in computation */
-  angletolerance?: number | null;
-  /** Model units used */
-  modelunits?: RhinoModelUnit | null;
-  /** Data version (7 or 8) */
-  dataversion?: 7 | 8 | null;
-  /** Whether to use cached solution */
-  cachesolve?: boolean | null;
-  /**
-   * Opt-in: cache a solve even when the definition reported GH errors. Default
-   * (false/unset) means errored solves are never cached server-side. Some
-   * definitions throw GH errors by design (a guarded Python component, a
-   * filtered branch) while still producing correct geometry — set this so those
-   * still benefit from the server's solve cache. Only meaningful with
-   * `cachesolve`. Requires a server that honors it (VektorNode fork).
-   */
-  cacheerroredsolves?: boolean | null;
-}
-/**
- * Where a Selva-family plugin running inside the solve may POST live events, and
- * the bearer it presents. The VektorNode fork hands these to the document as
- * constants; a stock server ignores the block. Never echoed in the response.
- */
-interface SelvaEventTarget {
-  url: string;
-  solveId: string;
-  token: string;
-}
-/**
- * Definition source (used in args and response)
- */
-interface GrasshopperDefinitionSource {
-  /** Base64 encoded algorithm (if embedded) */
-  algo?: string | null;
-  /** URL pointer to definition file */
-  pointer?: string | null;
-  /** Filename of the definition */
-  filename?: string | null;
-}
-/**
- * Server config plus the Grasshopper solve settings. The definition is not part
- * of it: pass that to `solve()` and friends.
- */
-interface GrasshopperComputeConfig extends ComputeConfig, GrasshopperBaseSchema {
-  /** Per-solve live-event callback; see {@link SelvaEventTarget}. */
-  selvaevents?: SelvaEventTarget | null;
-}
-/**
- * Response from Grasshopper compute server.
- *
- * No `pointer`: the solve returns the server's echoed pointer as its `cacheKey`
- * instead. The echoed settings (`cachesolve`, `dataversion`) stay optional:
- * nothing client-side enforces them.
- */
-interface GrasshopperComputeResponse extends GrasshopperBaseSchema, Omit<GrasshopperDefinitionSource, 'pointer'> {
-  /**
-   * Model units the definition was solved in. Every conforming server response
-   * carries this (it drives downstream scaling, e.g. the webdisplay parser),
-   * but note it is not validated client-side — a non-conforming server or
-   * hand-built mock may omit it at runtime.
-   */
-  modelunits: RhinoModelUnit;
-  /** Always `undefined` on a client-returned response: the solve strips it. */
-  algo?: string | null;
-  /** Filename of the definition (always present in response) */
-  filename: string | null;
-  /** Recursion level used */
-  recursionlevel?: number;
-  /** Output values organized by parameter */
-  values: DataTree[];
-  /** Computation errors */
-  errors?: string[];
-  /** Computation warnings */
-  warnings?: string[];
-  /** Set by the VektorNode fork when a Selva plugin judged the solve; see {@link SelvaResponseBlock}. */
-  selva?: SelvaResponseBlock | null;
-}
-/**
- * The Selva plugin's verdict on a solve, which the VektorNode fork copies verbatim into the
- * response. `outcome` is `SolveOutcome` from `@selvajs/schemas`, typed loosely here because
- * this package does not depend on it. A blocked or aborted outcome comes with empty `values`.
- * Absent from a stock server, an older plugin, or a definition without a Selva component.
- */
-interface SelvaResponseBlock {
-  outcome?: unknown;
-}
-/**
- * Output parameter
- */
-interface OutputParamSchema {
-  name: string;
-  nickname: string | null;
-  paramType: string;
-  /**
-   * Grasshopper parameter instance GUID
-   */
-  id: string;
-}
-/**
- * Input parameter
- */
-interface InputParamSchema {
-  /**
-   * Grasshopper parameter instance GUID
-   */
-  id: string;
-  name: string;
-  nickname: string | null;
-  description: string;
-  paramType: string;
-  treeAccess: boolean;
-  minimum: number | null;
-  maximum: number | null;
-  atLeast: number;
-  atMost: number;
-  stepSize?: number;
-  default: any;
-  /**
-   * Key-value pairs for dropdown options
-   */
-  values?: Record<string, string>;
-  /**
-   * Accepted file formats for File input
-   */
-  acceptedFormats?: string[];
-  groupName?: string | null;
-}
-/** Input/output schemas as the `/io` endpoint reports them, keys canonicalized. */
-interface GrasshopperParsedIORaw {
-  inputs: InputParamSchema[];
-  outputs: OutputParamSchema[];
-  /**
-   * Warnings the server raised loading the definition (e.g. an obsolete
-   * component). Distinct from `parseErrors`, the client failing to type an input.
-   */
-  loadWarnings?: string[];
-  /**
-   * Errors the server raised loading the definition (e.g. a missing plugin).
-   * When present, `inputs`/`outputs` may be incomplete.
-   */
-  loadErrors?: string[];
-}
-/**
- * Per-input parse failure. The corresponding entry in `inputs` was filled
- * with a safe default so the rest of the pipeline can keep going — but the
- * caller should surface this so the user knows their definition has a
- * misconfigured parameter.
- */
-interface InputParseError {
-  /** The input's `name` (or `'unknown'` if the schema didn't have one). */
-  inputName: string;
-  /** The declared paramType from the raw schema. */
-  paramType: string;
-  /** Human-readable reason from the underlying ComputeError. */
-  message: string;
-  /** Error code from the underlying ComputeError, if available. */
-  code?: string;
-}
-/** {@link GrasshopperParsedIORaw} with each input parsed into its typed {@link InputParam}. */
-interface GrasshopperParsedIO extends Omit<GrasshopperParsedIORaw, 'inputs'> {
-  inputs: InputParam[];
-  /**
-   * Inputs that failed validation and got a safe default. The result is still
-   * usable, but surface these so the user can fix their definition.
-   */
-  parseErrors?: InputParseError[];
-}
-/**
- * How concurrent `solve()` calls interact.
- *
- * - `latest-wins`: one in flight at a time. A new call supersedes the pending
- *   one and aborts the one in flight. For slider scrubs and live UIs.
- * - `queue`: FIFO, every call runs to completion, up to `maxConcurrent` at
- *   once (default 1). For "submit job" flows where every request matters.
- */
-type SchedulerMode = 'latest-wins' | 'queue';
-interface CacheOptions {
-  /**
-   * Total byte budget for retained responses, evicted LRU. The only size bound
-   * there is: responses range KB→100s of MB, so memory is the constraint that
-   * matters and an entry count would only obscure it.
-   *
-   * Sizing uses the response's wire size (JSON text length, recorded at the
-   * fetch boundary — no re-serialization); a response without that hint
-   * (custom executor) is sized by a one-off `JSON.stringify`. A single
-   * response larger than the whole budget is served but never retained.
-   * Parsed, a response of many small items holds more heap than its wire size,
-   * so leave headroom.
-   *
-   * Required and must be > 0 — to disable caching, pass `cache: false`.
-   */
-  maxBytes: number;
-  /**
-   * Time-to-live in ms. Set to `0` for no expiry (default, and the right
-   * choice for a solve keyed by immutable definition+inputs — expiry there
-   * only buys a paid re-solve of an identical answer). Meaningful only when a
-   * definition reaches outside its inputs (external data source, clock), where
-   * a stale result is genuinely wrong rather than merely old.
-   *
-   * Expiry is evaluated lazily on read: an expired entry keeps its bytes
-   * counted against `maxBytes` until that exact key is next consulted.
-   */
-  ttlMs?: number;
-  /**
-   * Cache responses that carry Grasshopper `errors`. Default `true`: an
-   * errored solve is a valid, deterministic result — definitions raise GH
-   * errors by design (guarded components, validation branches), so replaying
-   * one from cache is correct. Set `false` for parity with Rhino's opt-in
-   * `cacheerroredsolves` server flag, e.g. when a definition's errors are
-   * transient (external data sources) rather than functions of the inputs.
-   */
-  cacheErroredSolves?: boolean;
-}
-interface SolveSchedulerOptions {
-  mode?: SchedulerMode;
-  maxConcurrent?: number;
-  /**
-   * Backpressure — cap on how many calls may wait in the FIFO queue (i.e.
-   * excluding the ones already in flight). When the queue is full, a new
-   * `solve()` is rejected immediately with `code: QUEUE_FULL` (retryable, meant to
-   * map to HTTP 503 + Retry-After) instead of piling up unbounded. Bounds the
-   * miss path under load. Only applies to `queue` mode —
-   * `latest-wins` has an intrinsic depth of 1. Default: unbounded.
-   */
-  maxQueueDepth?: number;
-  /**
-   * Backpressure — max time (ms) a call may sit queued before it starts
-   * executing. If it's still waiting after this long it's rejected with
-   * `code: QUEUE_TIMEOUT` rather than burning compute on a stale request.
-   * Bounds tail latency. Only applies to `queue` mode. Default: no deadline.
-   */
-  queueWaitMs?: number;
-  timeoutMs?: number;
-  retry?: RetryPolicy;
-  /**
-   * Response caching keyed by hash of (definition, dataTree). Omit or pass
-   * `false` to disable; otherwise a byte budget is required, so an unbounded
-   * cache can't be enabled by accident.
-   */
-  cache?: false | CacheOptions;
-  /**
-   * Upload a definition once, then solve it by the server's cache key (`pointer`)
-   * instead of re-sending the bytes; a `DefinitionRef` also skips its `load()`.
-   * When the server has evicted the key, the solve falls back to a full upload,
-   * so this is safe to leave on. No effect for URL definitions, which are
-   * already a reference. Default `true`.
-   */
-  reuseServerDefinitionCache?: boolean;
-  /** Lifecycle hooks — fired in order. Errors thrown by hooks are logged, not rethrown. */
-  onStart?: (ctx: SolveContext) => void;
-  onSettle?: (ctx: SolveContext, result: SolveResult) => void;
-  onSuperseded?: (ctx: SolveContext) => void;
-}
-interface SolveContext {
-  /** Stable hash of (definition, dataTree). */
-  key: string;
-  /** Timestamp when scheduler.solve() was called. */
-  enqueuedAt: number;
-  /** Timestamp when execution actually started (after queueing). */
-  startedAt: number | null;
-}
-type SolveResult = {
-  status: 'success';
-  response: GrasshopperComputeResponse;
-  durationMs: number;
-  fromCache: boolean;
-  /**
-   * Whether this solve uploaded the full definition: `true` on its first
-   * solve or after the server evicted the cache key, `false` when the server
-   * reused its cached copy via the pointer. `undefined` for a `fromCache`
-   * hit, or when reuse is off or the definition is a URL.
-   */
-  definitionReuploaded?: boolean;
-} | {
-  status: 'error';
-  error: ComputeError;
-  durationMs: number;
-} | {
-  status: 'superseded';
-};
-/**
- * Solves by `cacheKey` when given one, otherwise uploads. Reports the server's
- * (possibly new) key and whether the full definition was uploaded (`missed`).
- * The scheduler passes `null` whenever server-definition reuse is off.
- */
-type SolveExecutor = (definition: SolveDefinition, dataTree: DataTree[], cacheKey: string | null, config: GrasshopperComputeConfig) => Promise<{
-  response: GrasshopperComputeResponse;
-  cacheKey: string | null;
-  missed: boolean;
-}>;
-interface SchedulerSolveOptions {
-  signal?: AbortSignal;
-  /** Per-solve live-event callback. Not part of the cache key: it names where events go, not what is solved. */
-  selvaevents?: SelvaEventTarget;
-  /**
-   * This call's `Server-Timing` breakdown, after the client config's own `onServerTiming`.
-   * Never fires for a `fromCache` hit, which sends no request.
-   */
-  onServerTiming?: (timing: ServerTiming, requestId: string) => void;
-}
-/** What `solveDetailed()` resolves with: the response plus how this call got it. */
-interface SolveDetail {
-  response: GrasshopperComputeResponse;
-  /** Served from the scheduler's response cache without a request. */
-  fromCache: boolean;
-  /** Same meaning as on {@link SolveResult}. */
-  definitionReuploaded?: boolean;
-  /** Executor wall time; `0` for a `fromCache` hit. */
-  durationMs: number;
-}
-/**
- * Adds to a plain solve call:
- * - Scheduling (latest-wins for sliders, queue for jobs)
- * - Backpressure (bounded queue depth + queue-wait deadline)
- * - Cancellation (per-call signal + cancelAll)
- * - Optional response caching for repeated inputs
- * - Lifecycle hooks (start / settle / superseded) and state via subscribe()
- *
- * @example
- * ```ts
- * const scheduler = client.createScheduler({ mode: 'latest-wins', timeoutMs: 30_000 });
- *
- * // From a slider handler:
- * scheduler.solve(definition, tree).then((result) => {
- *   updateMeshes(result);
- * }).catch((err) => {
- *   if (err.code !== 'SUPERSEDED') showError(err);
- * });
- *
- * // From a UI binding:
- * scheduler.subscribe(() => {
- *   showSpinner = scheduler.isSolving;
- * });
- * ```
- */
-export declare class SolveScheduler {
-  private readonly executor;
-  private readonly baseConfig;
-  private readonly mode;
-  private maxConcurrent;
-  private readonly maxQueueDepth;
-  private readonly queueWaitMs;
-  private readonly timeoutMs;
-  private readonly retry;
-  private readonly cacheEnabled;
-  private readonly cacheMaxBytes;
-  private readonly cacheTtl;
-  private readonly cacheErroredSolves;
-  private readonly cache;
-  private cacheBytes;
-  private cacheHits;
-  private cacheMisses;
-  private cacheEvictions;
-  private readonly reuseServerDefinitionCache;
-  /** Definition hash → the server's cache key (`pointer`) for it. */
-  private readonly serverCacheKeys;
-  /** A string definition re-sent unchanged is compared with this, far cheaper than hashing it. */
-  private lastStringDefinition;
-  private readonly onStart?;
-  private readonly onSettle?;
-  private readonly onSuperseded?;
-  private readonly subscribers;
-  private readonly inFlight;
-  private pendingForLatestWins;
-  private readonly fifo;
-  private _lastResult;
-  private _lastError;
-  private _lastDurationMs;
-  private solveSeq;
-  /** seq of the solve that last wrote `_lastResult`/`_lastError`. */
-  private lastStateSeq;
-  private disposed;
-  constructor(executor: SolveExecutor, baseConfig: GrasshopperComputeConfig, options?: SolveSchedulerOptions);
-  get isSolving(): boolean;
-  get hasPending(): boolean;
-  get inFlightCount(): number;
-  get queueDepth(): number;
-  get lastResult(): GrasshopperComputeResponse | null;
-  get lastError(): ComputeError | null;
-  get lastDurationMs(): number | null;
-  /**
-   * Adjust how many solves may run at once, for when the compute server's worker
-   * pool changes size after this scheduler was built.
-   *
-   * Raising it drains queued work immediately. Lowering it never interrupts work
-   * already in flight — those finish above the new limit, and the cap applies from
-   * the next dispatch. Values below 1 are clamped, since 0 would wedge the queue.
-   */
-  setMaxConcurrent(value: number): void;
-  /** Current concurrency cap — reflects any {@link setMaxConcurrent} adjustment. */
-  getMaxConcurrent(): number;
-  /** Subscribe to state changes. */
-  subscribe(listener: () => void): () => void;
-  private notify;
-  /**
-   * Schedule a solve. Returns a promise that:
-   * - Resolves with the compute response on success.
-   * - Rejects with `ComputeError` on failure.
-   * - Rejects with `code: ErrorCodes.SUPERSEDED` when the call was canceled because
-   *   newer values arrived (latest-wins mode).
-   * - Rejects with `code: ErrorCodes.ABORTED` when the call was canceled via
-   *   its own `signal` (queued or running) or `cancelAll()`.
-   * - Rejects with `code: ErrorCodes.QUEUE_FULL` when `maxQueueDepth` is set and
-   *   the queue was already full (backpressure; `statusCode: 503`).
-   * - Rejects with `code: ErrorCodes.QUEUE_TIMEOUT` when `queueWaitMs` is set and
-   *   the call sat queued longer than that before starting (`statusCode: 503`).
-   *
-   * Don't mutate a `Uint8Array` definition after solving it. Responses served
-   * from the cache (and via `lastResult`) are shared objects, not copies —
-   * treat them as immutable. Mutating one poisons every later cache hit for
-   * that key.
-   *
-   * Partial-success contract: unlike `GrasshopperClient.solve()`, which throws
-   * `COMPUTATION_ERROR` when the response carries solver errors, this RESOLVES
-   * with the response as-is — check `response.errors` yourself if a partial
-   * success must not be treated as a result (see `cacheErroredSolves` for the
-   * caching side of the same distinction).
-   */
-  solve(definition: SolveDefinition, dataTree: DataTree[], options?: SchedulerSolveOptions): Promise<GrasshopperComputeResponse>;
-  /** {@link solve}, also resolving with whether this call hit the cache and how long it took. */
-  solveDetailed(definition: SolveDefinition, dataTree: DataTree[], options?: SchedulerSolveOptions): Promise<SolveDetail>;
-  /** A slow solve settling late must not overwrite state a newer solve or cache hit published. */
-  private writeLastState;
-  /** latest-wins: supersede the pending item and abort everything in flight. */
-  private supersedeCurrent;
-  private dequeue;
-  private abortQueuedItem;
-  /** The structured context lets an HTTP layer map QUEUE_FULL to 503 + Retry-After. */
-  private shedAsQueueFull;
-  private armQueueWaitTimer;
-  private clearQueueWaitTimer;
-  private enqueue;
-  private execute;
-  private runExecutor;
-  private hashDefinitionMemo;
-  private drainNext;
-  private supersede;
-  private makeAbortError;
-  /**
-   * The executor, `supersede`, `cancelAll`, abort and the queue limits can all race to settle one
-   * item, and a promise ignores a second settle silently. The first settle wins; the return value
-   * says whether this call won, so only the winner fires its hook. Every settle path goes through
-   * here or {@link settleSuccess}.
-   */
-  private settleError;
-  /**
-   * Fires `onSettle` for queued items too, so a consumer counting solves in progress doesn't
-   * leak one. A supersede settles through {@link settleError} and fires `onSuperseded` instead.
-   */
-  private fail;
-  private settleSuccess;
-  private removeQueuedAbortHandler;
-  private normalizeExecutionError;
-  /** Cancel everything — in-flight and pending. */
-  cancelAll(): void;
-  private readCache;
-  private writeCache;
-  private dropCacheEntry;
-  clearCache(): void;
-  /**
-   * Observability snapshot of the solve cache: current size plus lifetime
-   * hit/miss/eviction counters.
-   *
-   * `hits`/`misses` count cache CONSULTATIONS, so `hits / (hits + misses)` is the
-   * hit rate. A TTL-expired entry counts as a miss (the solve runs either way).
-   * `evictions` counts only entries dropped under size/byte pressure — not
-   * replace-in-place writes or TTL expiry, which are not capacity signals.
-   * Counters are cumulative and survive `clearCache()`.
-   */
-  cacheStats(): {
-    entries: number;
-    bytes: number;
-    hits: number;
-    misses: number;
-    evictions: number;
-  };
-  dispose(): void;
-  private runHook;
-}
-/**
- * Per-call options that override the client's default ComputeConfig values.
- *
- * Use these for per-request control without mutating the client config:
- * - `signal` — cancel a specific solve (e.g. when a slider value is superseded)
- * - `timeoutMs` — extend timeout for a long-running solve, or pass `0` to disable
- * - `retry` — override retry policy for this call only
- */
-interface SolveOptions {
-  signal?: AbortSignal;
-  timeoutMs?: number;
-  retry?: RetryPolicy;
-  /** Per-solve live-event callback, forwarded onto the request body. */
-  selvaevents?: SelvaEventTarget;
-}
-/** Options for {@link GrasshopperClient.create} that shape construction, not the solves. */
-interface CreateClientOptions {
-  /**
-   * Retry ladder for the liveness probe: `attempts` retries after the first probe (default 2),
-   * with exponential backoff from `baseDelayMs` (default 250) capped at `maxDelayMs` (default 1000).
-   * Independent of `config.retry`, which governs solves only.
-   */
-  probe?: {
-    attempts?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-  };
-}
-/**
- * GrasshopperClient provides a simple API for interacting with a Rhino Compute server and grasshopper.
- *
- * @public This is the recommended high-level API for Rhino Compute operations.
- *
- * **Security Warning:**
- * Using this client in a browser environment exposes your server URL and API key to users.
- * For production, use this library server-side or proxy requests through your own backend.
- *
- * @example
- * ```typescript
- * const client = await GrasshopperClient.create({
- *   serverUrl: 'http://localhost:6500',
- *   apiKey: 'your-api-key'
- * });
- *
- * try {
- *   const io = await client.getIO(definitionUrl);
- *   const result = await client.solve(definitionUrl, TreeBuilder.fromInputParams(io.inputs));
- * } finally {
- *   await client.dispose(); // Clean up resources
- * }
- * ```
- */
-declare class GrasshopperClient {
-  private readonly config;
-  readonly serverStats: ComputeServerStats;
-  private disposed;
-  /**
-   * Per-probe timeout for the `create()` liveness gate. A healthy `GET /` on the
-   * proxy answers in milliseconds; this bound only ever applies to a server that
-   * is not answering, where every extra second is multiplied by the retry count
-   * and paid by whoever is waiting on the solve.
-   */
-  private static readonly CREATE_PROBE_TIMEOUT_MS;
-  private constructor();
-  /**
-   * Creates and initializes a GrasshopperClient with server validation.
-   *
-   * The pre-flight liveness probe (a GET on the proxy root `/`) is a
-   * single-sample boolean gate that reads a cold or briefly-busy-but-up server
-   * as offline. To avoid failing construction on that transient class, the probe
-   * is retried with a short exponential backoff before giving up.
-   *
-   * Retries stop early when {@link classifyProbeFailure} says waiting cannot
-   * change the answer — connection refused, or a 401/403. This runs in front of
-   * a user who clicked Solve, so the retry ladder must not spend its whole
-   * budget confirming that a machine is switched off.
-   *
-   * @throws {ComputeError} with code NETWORK_ERROR if the server stays
-   *   unreachable across all attempts. `context.probeVerdict` carries the
-   *   {@link ProbeVerdict} so callers can render a specific cause.
-   * @throws {ComputeError} with code INVALID_CONFIG if configuration is invalid
-   */
-  static create(config: GrasshopperComputeConfig, options?: CreateClientOptions): Promise<GrasshopperClient>;
-  /**
-   * Gets the client's configuration.
-   * Useful for passing to lower-level functions.
-   */
-  getConfig(): GrasshopperComputeConfig;
-  /**
-   * Get input/output parameters of a Grasshopper definition.
-   */
-  getIO(definition: string | Uint8Array): Promise<GrasshopperParsedIO>;
-  getRawIO(definition: string | Uint8Array): Promise<GrasshopperParsedIORaw>;
-  /**
-   * Run a compute job with a Grasshopper definition.
-   *
-   * @throws {ComputeError} with code INVALID_INPUT if definition is empty
-   * @throws {ComputeError} with code NETWORK_ERROR if server is offline
-   * @throws {ComputeError} with code COMPUTATION_ERROR if computation fails.
-   *   On a partial-success response (some outputs computed, some errored) the
-   *   error's `context.values` carries the outputs that did compute — pass
-   *   `{ values } as GrasshopperComputeResponse` to the response processors to
-   *   render them. `context.inputSummary` describes the inputs (param names,
-   *   item counts, byte sizes) without pinning the full data tree.
-   */
-  solve(definition: SolveDefinition, dataTree: DataTree[], options?: SolveOptions): Promise<GrasshopperComputeResponse>;
-  /**
-   * Create a scheduler bound to this client. Use a scheduler for any UI surface
-   * that fires solves frequently (sliders, live editors) or that needs cancel
-   * semantics, response caching, or state observability.
-   *
-   * Multiple schedulers can be created from a single client — typically one per
-   * UI surface so their queues stay independent.
-   *
-   * @example
-   * ```ts
-   * const sliderScheduler = client.createScheduler({ mode: 'latest-wins' });
-   * const submitScheduler = client.createScheduler({ mode: 'queue', timeoutMs: 0, retry: { attempts: 1 } });
-   * ```
-   */
-  createScheduler(options?: SolveSchedulerOptions): SolveScheduler;
-  /**
-   * Disposes of client resources.
-   * Call this when you're done using the client.
-   */
-  dispose(): Promise<void>;
-  private ensureNotDisposed;
-}
-interface ParsedContext {
-  [key: string]: any;
-}
-interface GetValuesOptions {
-  parseValues?: boolean;
-  rhino?: any;
-  /**
-   * If true, only include values of type System.String in the result.
-   * Non-string types are filtered out.
-   */
-  stringOnly?: boolean;
-}
-interface GetValuesResult<T = ParsedContext> {
-  values: T;
-  /**
-   * Free every rhino3dm WASM object decoded into `values`. When a `rhino`
-   * instance was passed, decoded geometry lives on the WASM heap and is never
-   * garbage-collected — call this once the values are consumed, or the heap
-   * grows monotonically across solves. Idempotent; a no-op when nothing was
-   * decoded. `values` must not be used after disposal.
-   */
-  dispose: () => void;
-}
-/** Reads parsed values and produced files out of one compute response. */
-declare class GrasshopperResponseProcessor {
-  /** Hand it to a mesh parser such as `@selvajs/visualization/parse`. */
-  readonly response: GrasshopperComputeResponse;
-  constructor(
-  /** Hand it to a mesh parser such as `@selvajs/visualization/parse`. */
-  response: GrasshopperComputeResponse);
-  /**
-   * Extract all values in the response.
-   *
-   * @typeParam T - Expected structure of the return value. Defaults to a simple key/value map. (later cast as needed)
-   * @param byId - Key by parameter ID instead of name. Requires the VektorNode rhino.compute branch.
-   * @param options - Controls parsing behavior such as Rhino geometry decoding.
-   * @returns Parsed Grasshopper output values.
-   *
-   * @example
-   * ```ts
-   * const processor = new GrasshopperResponseProcessor(response);
-   * const { values } = processor.getValues();
-   * ```
-   *
-   */
-  getValues<T = ParsedContext>(byId?: boolean, options?: GetValuesOptions): GetValuesResult<T>;
-  /**
-   * Retrieve a specific value by parameter name or ID.
-   *
-   * @param selector - `{ byName }` for the human-readable name, `{ byId }` for the parameter GUID.
-   * @param options - Parsing configuration (e.g. disable parsing or enable Rhino).
-   * @returns Single parsed value, array of values, or undefined if the parameter is absent.
-   *
-   * `byId` requires the VektorNode rhino.compute branch.
-   *
-   * @example
-   * ```ts
-   * const schema = processor.getValue({ byName: 'Schema' });
-   * const output = processor.getValue({ byId: 'a4be1c1e-23f9-4c27-b942-7f3bb2c45c6f' });
-   * ```
-   */
-  getValue(selector: {
-    byName: string;
-  } | {
-    byId: string;
-  }, options?: GetValuesOptions): any;
-  /**
-   * Download all files generated by Grasshopper, optionally including
-   * additional user-provided files.
-   *
-   * Files are grouped under the specified folder name when downloaded.
-   *
-   * @param folderName - Name for the download directory.
-   * @param additionalFiles - Extra files to package (single file, array, or null).
-   *
-   * @example
-   * ```ts
-   * await processor.getAndDownloadFiles('gh-output');
-   * ```
-   *
-   * @example
-   * ```ts
-   * const extra = { name: 'notes.txt', data: 'Example' };
-   * await processor.getAndDownloadFiles('project', extra);
-   * ```
-   */
-  getAndDownloadFiles(folderName: string, additionalFiles?: FileBaseInfo[] | FileBaseInfo | null): Promise<void>;
-}
-/**
- * Deterministic stringify with sorted keys. {a:1,b:2} and {b:2,a:1} produce
- * the same string. Safely handles circular references and non-finite numbers.
- *
- * The output is a cache key, so the invariant that matters is: two payloads
- * that serialize differently on the wire must stringify differently here
- * (false misses are harmless; false hits serve the wrong cached solve).
- * Non-JSON values get unquoted markers (`{u8:…}`, `[Circular]`) that no JSON
- * value stringifies to, so a plain object can't pose as one.
- */
-export declare function stableStringify(value: unknown): string;
-/** The scheduler's solve-cache key for a definition and its input tree. */
-export declare function hashSolveInput(definition: SolveDefinition, dataTree: unknown): string;
-/**
- * A definition's identity, without its inputs. Strings and bytes are hashed over their full
- * content; a `DefinitionRef` uses its `key`.
- */
-export declare function hashDefinition(definition: SolveDefinition): string;
-/**
- * Run one solve. `GrasshopperClient.solve()` adds input validation and throws on solver errors.
- *
- * @param definition - A URL (sent as a pointer), base64 `.gh` content, raw `.gh` bytes, or a
- *   `DefinitionRef` (loaded for the upload). Any other string is encoded as the definition text.
- * @returns The compute response, without the server's `pointer` and echoed `algo`.
- *
- * @example
- * await solveGrasshopperDefinition(trees, 'https://example.com/definition.gh', config);
- * await solveGrasshopperDefinition(trees, new Uint8Array(await readFile('model.gh')), config);
- */
-export declare function solveGrasshopperDefinition(dataTree: DataTree[], definition: SolveDefinition, config: GrasshopperComputeConfig): Promise<GrasshopperComputeResponse>;
-/**
- * Fetches a definition's input/output schemas without per-type parsing.
- *
- * Field KEYS are canonicalized to camelCase and missing required fields get a
- * fallback ({@link normalizeInputSchema}); a missing or non-array `inputs` /
- * `outputs` becomes `[]`. Field VALUES, notably `default` and the `values`
- * label map, pass through verbatim.
- *
- * @throws {ComputeError} If fetch fails or response is invalid
- *
- * @public Use `fetchParsedDefinitionIO()` for processed, type-safe inputs
- */
-export declare function fetchDefinitionIO(definition: string | Uint8Array, config: ComputeConfig): Promise<GrasshopperParsedIORaw>;
-/**
- * Fetches a definition's input/output schemas and parses each input into its
- * typed `InputParam`. An input that fails to parse gets a safe default
- * and an entry in `parseErrors`.
- *
- * @throws {ComputeError} If fetch fails or response is invalid
- *
- * @example
- * ```typescript
- * const { inputs, outputs } = await fetchParsedDefinitionIO(
- *   'https://example.com/definition.gh',
- *   { serverUrl: 'http://localhost:6500', apiKey: 'YOUR_KEY' }
- * );
- *
- * // Inputs are now strongly typed
- * inputs.forEach(input => {
- *   if (input.paramType === 'Number') {
- *     console.log(input.minimum, input.maximum); // TypeScript knows these exist
- *   }
- * });
- * ```
- */
-export declare function fetchParsedDefinitionIO(definition: string | Uint8Array, config: ComputeConfig): Promise<GrasshopperParsedIO>;
-/** One entry of the schema endpoint's response, after wrapper-key normalization. */
-interface SchemaEndpointResult<TSchema = unknown> {
-  /** Schemas embedded in that file. Absent when the file yielded none. */
-  schemas?: TSchema[];
-  /** Per-file diagnosis. Compute reports this and still answers 200. */
-  error?: string;
-}
-/**
- * Read compute's `/grasshopper/schema` body: `[{ FileName, Schemas }]` per
- * uploaded file, or a bare object for a single file.
- *
- * Use this rather than unwrapping the body by hand: the wrapper keys' casing
- * varies by server branch, and a fixed-key read yields "no schemas" with a 200.
- * Only the two wrapper keys are read; schema contents pass through untouched.
- *
- * @typeParam TSchema - Your schema type (e.g. `UISchema`). Not inspected.
- */
-export declare function readSchemaResults<TSchema = unknown>(raw: unknown): SchemaEndpointResult<TSchema>[];
-/**
- * Canonicalize a `/grasshopper/schema` body's key casing.
- *
- * Compute serializes the plugin's `UISchema`, whose camelCase wire names live in
- * Newtonsoft `[JsonProperty]` attributes. `Selva.gha` ILRepack-merges Newtonsoft,
- * so those attributes are `Selva!Newtonsoft.Json.JsonPropertyAttribute`. When
- * compute's OWN Newtonsoft serializes, it doesn't recognize them, reads no
- * attributes, and emits raw CLR names (`Inputs`, `SchemaVersion`). Nothing throws:
- * `schema.inputs` reads `undefined`, and so does the `schemaVersion` gate.
- *
- * A casing rule, not a key allowlist: the wire names are the CLR names run
- * through Newtonsoft's camelCase strategy, so reproducing it covers every key
- * without drifting each time `UISchema` gains a field.
- */
-/**
- * Returns a schema whose structural keys are camelCase, whichever Newtonsoft
- * serialized it. Always a fresh object the caller may mutate; non-objects are
- * returned as-is.
- */
-export declare function normalizeUISchemaCasing<T>(raw: T): T;
-/**
- * Parse one raw Grasshopper input schema into a typed {@link InputParam}.
- * A validation failure is swallowed and replaced with a safe default.
- */
-export declare function processInput(rawInput: InputParamSchema): InputParam;
-/**
- * Sentinel a Rhino geometry decode returns when a decode was attempted
- * and failed hard (a registered decoder or `CommonObject.decode` threw). Carries
- * the original payload so callers can log or retry. Use
- * {@link isRhinoDecodeError} to detect it.
- */
-interface RhinoDecodeError {
-  __decodeError: true;
-  /** The Rhino type name the failed decode was attempted for. */
-  type: string;
-  /** The original (undecoded) payload. */
-  raw: unknown;
-}
-/** Type guard for the {@link RhinoDecodeError} sentinel. */
-export declare function isRhinoDecodeError(value: unknown): value is RhinoDecodeError;
-/**
- * Free every rhino3dm WASM object reachable from `value`.
- *
- * rhino3dm objects are emscripten bindings — JS GC never reclaims their WASM
- * heap allocation, so everything decoded from a solve response (`getValues`,
- * `getValue`) must be deleted explicitly or the heap
- * grows monotonically across solves (e.g. a UI decoding per slider tick).
- *
- * Walks arrays and plain objects recursively; anything exposing a `delete()`
- * method is treated as a WASM binding and freed (skipped if already deleted).
- * Safe to call more than once and on values containing no WASM objects.
- */
-export declare function disposeRhinoObjects(value: unknown): void;
-type DataTreeValue = string | number | boolean | object | null;
-/** One input's value for {@link TreeBuilder.fromValues}. */
-interface TreeValueEntry {
-  paramName: string;
-  /** Matched case-insensitively. */
-  paramType: string;
-  /** A scalar, an array (branch `{0}`), or a branch-path map like `{ '{0;1}': [1, 2] }`. */
-  value: unknown;
-  minimum?: number | null;
-  maximum?: number | null;
-}
-/**
- * Builds the Grasshopper data trees a solve takes as input.
- *
- * @example
- * ```ts
- * const tree = new TreeBuilder('MyParam')
- *   .append([0], [1, 2, 3])
- *   .append([1], [4, 5])
- *   .toComputeFormat();
- * ```
- */
-export declare class TreeBuilder {
-  private innerTree;
-  private paramName;
-  constructor(paramName: string);
-  /** Append values to the branch at `path` (`[0, 1]` is `{0;1}`). */
-  append(path: number[], items: DataTreeValue[]): this;
-  /** Replace the tree with a branch-path map like `{ '{0;1}': [1, 2] }`. */
-  fromDataTreeDefault(treeData: DataTreeDefault): this;
-  /** Append a value, or each value of an array, to branch `{0}`. */
-  appendFlat(values: DataTreeValue | DataTreeValue[]): this;
-  /** Every value across all branches. */
-  flatten(): DataTreeValue[];
-  /** The tree in the shape a solve request sends. */
-  toComputeFormat(): DataTree;
-  getParamName(): string;
-  /**
-   * One tree per input that has a default, keyed by its nickname. Defaults are coerced and
-   * clamped by the same rules as {@link TreeBuilder.fromValues}.
-   */
-  static fromInputParams(inputs: InputParam[]): DataTree[];
-  /**
-   * One tree per entry, coercing UI values the way Grasshopper reads them. Number and Integer
-   * items go through the numeric coercion (Integer rounds) and are clamped to
-   * `minimum`/`maximum`; Boolean items also accept `'true'`/`'false'`; every other type passes
-   * through. An item that fails coercion is dropped with a warning. An entry left with no items
-   * is omitted, so Grasshopper uses its own value; `''` is an item, not an empty value.
-   */
-  static fromValues(entries: TreeValueEntry[]): DataTree[];
-  private static branchesOf;
-  /** `null` means the item was rejected. */
-  private static itemCoercer;
-  /**
-   * Set or add `paramName`'s tree to `newValue`: a scalar, an array (branch `{0}`), or a
-   * branch-path map. Copy-on-write: returns a new array and leaves the caller's untouched, so
-   * assign the result.
-   */
-  static replaceTreeValue(trees: DataTree[], paramName: string, newValue: DataTreeValue): DataTree[];
-  private static buildFromValue;
-  /**
-   * `paramName`'s whole tree from a solve result's `values`, keyed by branch path (`'{0;1}'`).
-   * `null` when no tree has that param, an empty `Map` when it has no branches. An item without
-   * `data` reads as `null` in place, so indices don't shift.
-   */
-  static getTree(trees: DataTree[], paramName: string): Map<DataTreePath, DataTreeValue[]> | null;
-  /**
-   * `paramName`'s value when its tree has a single branch: one item unwrapped (`5`, not `[5]`),
-   * several as an array. `null` for a missing param or an empty tree.
-   *
-   * @throws {ComputeError} `INVALID_INPUT` when the tree has more than one branch; read those
-   *   with {@link TreeBuilder.getTree}.
-   */
-  static getTreeValue(trees: DataTree[], paramName: string): DataTreeValue | null;
-  private static paramNameOf;
-  /**
-   * Parse a branch path like `"{0;1;2}"` into `[0, 1, 2]`.
-   *
-   * @throws {ComputeError} `INVALID_INPUT` for a malformed path, rather than
-   *   collapsing it to a default branch where two bad keys would merge.
-   */
-  static parsePathString(pathStr: string): number[];
-  /** `[0, 1, 2]` → `"{0;1;2}"`. */
-  static formatPathString(path: number[]): DataTreePath;
-  /** Booleans and numbers stay primitives: Grasshopper reads them typed. */
-  private static serializeValue;
-  private static deserializeValue;
-  private static hasValidValue;
-  private static clampValue;
-}
-export { type BooleanInputType, type CacheOptions, type ColorInputType, ComputeServerStats, type CreateClientOptions, type DataItem, type DataTree, type DataTreeDefault, type DataTreePath, type DataTreeValue, type DefaultValue, type FileInputType, type GeometryInputType, type GetValuesOptions, type GetValuesResult, GrasshopperClient, type GrasshopperComputeConfig, type GrasshopperComputeResponse, type GrasshopperParsedIO, type GrasshopperParsedIORaw, GrasshopperResponseProcessor, type InnerTreeData, type InputParam, type InputParamSchema, type InputParseError, type NumericInputType, type OutputParamSchema, type ParsedContext, type RhinoDecodeError, type RhinoModelUnit, type SchedulerMode, type SchedulerSolveOptions, type SchemaEndpointResult, type SelvaEventTarget, type SelvaResponseBlock, type ServerStats, type ServerVersion, type SolveContext, type SolveDetail, type SolveExecutor, type SolveOptions, type SolveResult, type SolveSchedulerOptions, type TextInputType, type TreeValueEntry, type ValueListInputType };
-//# sourceMappingURL=grasshopper.d.cts.map