@selvajs/solve 2.0.0-beta.11 → 2.0.0-beta.13

package/dist/outcome-DNrffAXp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-DNrffAXp.js","names":[],"sources":["../src/shared/solve-fn.ts","../src/shared/compute-diagnostics.ts","../src/shared/outcome.ts"],"sourcesContent":["import type { SolveDiagnostic } from '@selvajs/schemas';\n\n/**\n * The solve contract — what a solve returns and what a caller supplies to run one.\n *\n * Lives in `shared/` because both halves of the package speak it: `client/` calls a `SolveFn` and\n * stores its `SolveResult`; `server/` produces the payload one is built from.\n */\n\n/**\n * Marker the Grasshopper Message component prepends to a blocking error.\n *\n * Rhino.Compute flattens runtime messages to plain strings with no component attribution, so\n * this is the only way that path can tell a deliberate block from any other solve error. The\n * local WebSocket path carries `isGate` structurally and does not need it — but the component\n * writes the marker unconditionally, because the same definition runs on both.\n *\n * Changing this string breaks blocking on deployed Selva for every already-published\n * definition, since the text is baked into the .gh file's solve output, not the plugin.\n */\nexport const SOLVE_BLOCKED_MARKER = '[Selva:blocked]';\n\n/**\n * Marker the Message component prepends to a remark or warning — the non-blocking levels.\n *\n * Same reason as `SOLVE_BLOCKED_MARKER`: on Rhino.Compute nothing structural survives, and the\n * UI has to tell a message the author chose to write from an incidental Grasshopper warning.\n * Definitions saved before this existed lack it, so the reader falls back to the component name.\n */\nexport const SOLVE_AUTHORED_MARKER = '[Selva:msg]';\n\n/**\n * Marker for an authored message whose author chose Notify = Log.\n *\n * Still theirs — it keeps its attribution and its place in the message list — but it does not\n * interrupt. Errors never carry it: their result is withheld, so they always interrupt.\n */\nexport const SOLVE_LOG_ONLY_MARKER = '[Selva:log]';\n\n/**\n * One message a solve raised, with who raised it and whether it was deliberate (`isGate`).\n * Generated from `wire-schema.json`; both transports decode into it (see `outcome.ts`).\n */\nexport type { SolveDiagnostic };\n\n/**\n * `TMesh` is deliberately opaque and defaults to `unknown`: this package never inspects meshes, and\n * typing them would drag a renderer dependency into a package whose whole point is not having one.\n * The app that owns assembly (parse → `THREE.Object3D[]`) is the only place that knows the concrete\n * type, and it narrows by writing `SolveResult<THREE.Object3D>` at its own seam.\n */\nexport interface SolveResult<TMesh = unknown, TSource = unknown> {\n\toutputs: Record<string, unknown>;\n\tmeshes?: TMesh[];\n\terrors?: string[];\n\twarnings?: string[];\n\t/** Structured form of `errors`/`warnings`, including remarks. Absent from transports that report neither. */\n\tdiagnostics?: SolveDiagnostic[];\n\t/**\n\t * The definition refused this solve — a guard in the definition raised an error and its\n\t * outputs were withheld deliberately. Distinct from an errored solve that still returned\n\t * values, and from a transport failure: the solve ran and its answer is \"no\". Consumers\n\t * should show `errors` instead of treating the empty outputs as a result.\n\t */\n\tblocked?: boolean;\n\t/**\n\t * The solve was stopped before it finished. Always also `blocked`: what computed before\n\t * the stop is not a result. Absent from a transport that cannot tell.\n\t */\n\taborted?: boolean;\n\t/**\n\t * The unparsed payload this result was built from, passed through verbatim. Opaque here for the\n\t * same reason as `TMesh`: a consumer that must persist or re-submit exactly what it showed the\n\t * user narrows it at its own seam. Travels with the result through the driver's memo, so a\n\t * cached hit carries the source that produced it. Unlike `meshes` it needs no ownership policy —\n\t * it is inert data, not a GPU-backed handle.\n\t *\n\t * Supplied by the `SolveFn`, so it is present only when the one in use sets it\n\t * (`createComputeFetchSolveFn` does). A transport with no raw payload to hand back leaves it\n\t * absent — see `values` on telling absent from unsupported.\n\t */\n\tsource?: TSource;\n\t/**\n\t * The input set that produced this result, stamped by the driver rather than the `SolveFn` — a\n\t * memo hit never calls the `SolveFn`, so a consumer reading values captured inside it would pair\n\t * the on-screen result with whatever solved last. Keeping the pair atomic is the point: a commit\n\t * path holding a `SolveResult` cannot mismatch artifact and inputs.\n\t *\n\t * Present only from a driver that owns a request/response pair (`createRequestResponseDriver`).\n\t * A push driver cannot attribute an incoming frame to a request and must leave this absent\n\t * rather than guess — so `undefined` means \"this transport does not supply it\", not \"no solve\n\t * yet\", and a consumer that needs the pair requires a request/response driver. See `SolveDriver`.\n\t */\n\tvalues?: Record<string, unknown>;\n}\n\n/** Implementations should listen to `signal` and abort/clean up when it fires. */\nexport type SolveFn<TMesh = unknown, TSource = unknown> = (\n\tvalues: Record<string, unknown>,\n\tsignal: AbortSignal\n) => Promise<SolveResult<TMesh, TSource>>;\n","// Rhino.Compute reports runtime messages as flat strings, so everything the UI needs to tell a\n// deliberate message from incidental noise has to be recovered from the text. This is the one\n// place that parsing happens.\n//\n// Two decorations are applied by the server, in this order:\n//   \"<author's text>: component \\\"<Name>\\\" (<guid>)\"   — LogRuntimeMessages, every message\n//   \"<n>. Solution exception:<marker> ...\"              — the numbered-error wrapper\n// The local WebSocket path carries the same facts structurally and never comes through here.\n\nimport {\n\tSOLVE_AUTHORED_MARKER,\n\tSOLVE_BLOCKED_MARKER,\n\tSOLVE_LOG_ONLY_MARKER,\n\ttype SolveDiagnostic\n} from './solve-fn.js';\n\n/**\n * Compute's per-message attribution suffix. Anchored to the end and requiring the parenthesised\n * GUID, so an author who writes `component \"x\"` mid-sentence keeps their text intact.\n */\nconst ATTRIBUTION = /:\\s*component\\s+\"([^\"]*)\"\\s*\\(([0-9a-fA-F-]{36}|\\.\\.\\.)\\)\\s*$/;\n\n/** The Selva Message component's own name, as `LogRuntimeMessages` reports it. */\nconst MESSAGE_COMPONENT_NAME = 'Message';\n\nexport interface ParsedComputeMessage {\n\t/** The author's text, with the attribution suffix and any marker removed. */\n\tmessage: string;\n\t/** Component name from the attribution suffix, when present. */\n\tsource?: string;\n\t/** Carried the block marker: a Message component refused the solve. */\n\tblocked: boolean;\n\t/** Carried any marker: a Message component wrote this. */\n\tauthored: boolean;\n\t/** The author chose Notify = Log: list it, but do not interrupt. */\n\tlogOnly: boolean;\n}\n\n/**\n * Splits one Compute message string into the author's text and its attribution.\n *\n * Leaves the text alone when the suffix is absent — an exception thrown by a script component\n * has no attribution and must not be truncated on a guess.\n */\nexport function parseComputeMessage(raw: string): ParsedComputeMessage {\n\tconst blocked = raw.includes(SOLVE_BLOCKED_MARKER);\n\tconst logOnly = !blocked && raw.includes(SOLVE_LOG_ONLY_MARKER);\n\tconst authored = blocked || logOnly || raw.includes(SOLVE_AUTHORED_MARKER);\n\tlet message = raw;\n\n\tlet source: string | undefined;\n\tconst attribution = ATTRIBUTION.exec(message);\n\tif (attribution) {\n\t\tsource = attribution[1] || undefined;\n\t\tmessage = message.slice(0, attribution.index);\n\t}\n\n\tif (authored) {\n\t\tmessage = message\n\t\t\t.replace(SOLVE_BLOCKED_MARKER, '')\n\t\t\t.replace(SOLVE_AUTHORED_MARKER, '')\n\t\t\t.replace(SOLVE_LOG_ONLY_MARKER, '')\n\t\t\t// The numbered wrapper reads as noise next to the author's own sentence. Dropped only\n\t\t\t// when a marker proves the text is one of ours.\n\t\t\t.replace(/^\\s*\\d+\\.\\s*Solution exception:\\s*/, '');\n\t}\n\n\treturn { message: message.replace(/\\s{2,}/g, ' ').trim(), source, blocked, authored, logOnly };\n}\n\n/**\n * Rebuilds structured diagnostics from Compute's `errors`/`warnings` arrays.\n *\n * `isGate` comes from the marker the component writes. The component-name fallback is for\n * definitions saved before the non-blocking marker existed; `obj.Name` is the component's type\n * name, not its nickname, so renaming one on the canvas cannot change how it behaves.\n */\nexport function parseComputeDiagnostics(\n\terrors: readonly string[],\n\twarnings: readonly string[]\n): SolveDiagnostic[] {\n\tconst build = (raw: string, level: 'error' | 'warning'): SolveDiagnostic => {\n\t\tconst { message, source, authored, logOnly } = parseComputeMessage(raw);\n\t\tconst isGate = (authored || source === MESSAGE_COMPONENT_NAME) && !logOnly;\n\t\treturn { level, message, ...(source ? { source } : {}), ...(isGate ? { isGate } : {}) };\n\t};\n\treturn [\n\t\t...errors.map((raw) => build(raw, 'error')),\n\t\t...warnings.map((raw) => build(raw, 'warning'))\n\t];\n}\n","// The one place a solve's verdict becomes a `SolveResult`. The plugin decides the verdict\n// (`SolveOutcome`: diagnostics, blocked, aborted) once, and both transports carry it: the local\n// `outputs` envelope and the VektorNode fork's `selva` block. Each driver decodes it here, so a\n// rule about what a verdict means is written once rather than once per transport.\n//\n// A Compute response without a `selva` block (stock server, older plugin) falls back to\n// `outcomeFromComputeMessages`, which recovers what it can from the flattened strings. It cannot\n// see remarks or an abort.\n\nimport type { SolveOutcome } from '@selvajs/schemas';\nimport { parseComputeDiagnostics } from './compute-diagnostics.js';\nimport { SOLVE_BLOCKED_MARKER, type SolveDiagnostic, type SolveResult } from './solve-fn.js';\n\nexport type { SolveOutcome };\n\nfunction isLevel(value: unknown): value is SolveDiagnostic['level'] {\n\treturn value === 'error' || value === 'warning' || value === 'remark';\n}\n\n/**\n * One wire diagnostic, normalized: an unknown level reads as a remark, text is trimmed, and\n * `source`/`isGate` are omitted rather than null or false. Null when it carries no message.\n */\nexport function decodeDiagnostic(entry: unknown): SolveDiagnostic | null {\n\tif (!entry || typeof entry !== 'object') return null;\n\tconst d = entry as Record<string, unknown>;\n\tconst message = typeof d.message === 'string' ? d.message.trim() : '';\n\tif (!message) return null;\n\tconst source = typeof d.source === 'string' && d.source ? d.source : undefined;\n\treturn {\n\t\tlevel: isLevel(d.level) ? d.level : 'remark',\n\t\tmessage,\n\t\t...(source ? { source } : {}),\n\t\t...(d.isGate === true ? { isGate: true } : {})\n\t};\n}\n\nfunction normalizeOutcome(\n\tentries: readonly unknown[],\n\tblocked: boolean,\n\taborted: boolean\n): SolveOutcome {\n\tconst seen = new Set<string>();\n\tconst diagnostics: SolveDiagnostic[] = [];\n\tfor (const entry of entries) {\n\t\tconst d = decodeDiagnostic(entry);\n\t\tif (!d) continue;\n\t\tconst key = `${d.level}\\u0000${d.message}\\u0000${d.source ?? ''}\\u0000${d.isGate === true}`;\n\t\tif (seen.has(key)) continue;\n\t\tseen.add(key);\n\t\tdiagnostics.push(d);\n\t}\n\treturn { diagnostics, blocked: blocked || aborted, aborted };\n}\n\n/**\n * Normalizes a wire outcome with `decodeDiagnostic`, dropping exact repeats, so the same verdict\n * decodes to the same object from either transport. Null when `wire` is not an outcome at all;\n * the caller then falls back. A verdict without a diagnostic list still counts: reading a refusal\n * as \"no outcome\" would let the solve through.\n */\nexport function decodeOutcome(wire: unknown): SolveOutcome | null {\n\tif (!wire || typeof wire !== 'object') return null;\n\tconst { diagnostics, blocked, aborted } = wire as Record<string, unknown>;\n\tconst hasList = Array.isArray(diagnostics);\n\tif (!hasList && blocked === undefined && aborted === undefined) return null;\n\t// `'true'` too: a flag that arrives stringified must fail closed, not let a refusal through.\n\tconst isTrue = (flag: unknown) => flag === true || flag === 'true';\n\treturn normalizeOutcome(hasList ? diagnostics : [], isTrue(blocked), isTrue(aborted));\n}\n\n/** The legacy verdict, read from Compute's flattened `errors`/`warnings` and their markers. */\nexport function outcomeFromComputeMessages(\n\terrors: readonly unknown[],\n\twarnings: readonly unknown[]\n): SolveOutcome {\n\tconst strings = (list: readonly unknown[]) => list.filter((m) => typeof m === 'string');\n\tconst errorText = strings(errors);\n\treturn normalizeOutcome(\n\t\tparseComputeDiagnostics(errorText, strings(warnings)),\n\t\t// Substring, not prefix: the server numbers each entry (\"1. Solution exception: ...\").\n\t\terrorText.some((e) => e.includes(SOLVE_BLOCKED_MARKER)),\n\t\tfalse\n\t);\n}\n\n/**\n * Builds the result a driver reports. A blocked or aborted outcome is \"no result\" whatever the\n * transport sent along: no outputs, no `source` (it holds the withheld outputs), and an empty mesh\n * list so the viewer clears. `errors` and `warnings` are derived from the diagnostics for hosts\n * that only want text.\n */\nexport function finalizeResult<TMesh, TSource>(\n\tpartial: { outputs: Record<string, unknown>; meshes?: TMesh[]; source?: TSource },\n\toutcome: SolveOutcome\n): SolveResult<TMesh, TSource> {\n\tconst rejected = outcome.blocked || outcome.aborted;\n\tconst meshes = rejected ? [] : partial.meshes;\n\treturn {\n\t\toutputs: rejected ? {} : partial.outputs,\n\t\t...(meshes !== undefined ? { meshes } : {}),\n\t\terrors: outcome.diagnostics.filter((d) => d.level === 'error').map((d) => d.message),\n\t\twarnings: outcome.diagnostics.filter((d) => d.level === 'warning').map((d) => d.message),\n\t\tdiagnostics: outcome.diagnostics,\n\t\tblocked: outcome.blocked,\n\t\taborted: outcome.aborted,\n\t\t...(partial.source !== undefined && !rejected ? { source: partial.source } : {})\n\t};\n}\n"],"mappings":"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"}

package/dist/server.d.ts

@@ -1,14 +1,25 @@
 import { t as SolveInput } from "./solve-input-CUjVGYPC.js";
-import { DataTree, GrasshopperClient, GrasshopperComputeResponse, SelvaEventTarget, SolveScheduler } from "@selvajs/compute/grasshopper";
-import { DefinitionRef, DefinitionRef as DefinitionRef$1, SolveDefinition, SolveDefinition as SolveDefinition$1, isDefinitionRef } from "@selvajs/compute/core";
-import { ILogger } from "@selvajs/platform";
+import { UISchema } from "@selvajs/schemas";
+import { GrasshopperClient, GrasshopperComputeResponse, SelvaEventTarget, SolveScheduler } from "@selvajs/compute/grasshopper";
+import { DefinitionRef, DefinitionRef as DefinitionRef$1, ServerTiming, SolveDefinition } from "@selvajs/compute/core";
+/** Rhino.Compute's own default `--timeout`, for a server that can't report its own. */
+export declare const DEFAULT_SOLVE_DEADLINE_MS = 100000;
 /**
- * Opaque identity of a compute server — construct only via `serverIdentity()`.
- * Kept opaque so "a server is now a pool of URLs behind one id" stays additive.
+ * Ceiling on any solve deadline, whatever the server reports. Bounds how long a request, its
+ * live-event token and a delegated session stay open; past an hour a solve belongs in a job.
  */
-type ServerIdentity = string & {
-  readonly __brand: 'ServerIdentity';
-};
+export declare const MAX_SOLVE_DEADLINE_MS: number;
+/** What Selva holds a solve to on one compute server. */
+interface SolveLimits {
+  solveDeadlineMs: number;
+  /** `null` when the server didn't say: its own 413 is then the only check. */
+  maxRequestBytes: number | null;
+  /**
+   * Send a pointer to the server's cached definition instead of the `.gh`. Only on a server that
+   * answers a stale pointer with `definition_not_cached`: one that doesn't returns empty geometry.
+   */
+  reuseDefinitionCache: boolean;
+}
 /** Minimal resolved-server shape the cache needs (a subset of the app's `ComputeServerConfig`). */
 interface ResolvedServer {
   id: string;
@@ -16,10 +27,11 @@ interface ResolvedServer {
   /** Sent as the `RhinoComputeKey` header. */
   apiKey?: string;
 }
-export declare function serverIdentity(server: Pick<ResolvedServer, 'id'>): ServerIdentity;
 interface CachedClient {
   client: GrasshopperClient;
   scheduler: SolveScheduler;
+  /** Read from the server when the client was built; a changed server rebuilds the client. */
+  limits: SolveLimits;
 }
 /**
  * Debug verbosity: `false` is silent, `true` gives concise cache/timing logs
@@ -27,68 +39,6 @@ interface CachedClient {
  * dumps (incl. geometry) — a superset of `true`, not an independent setting.
  */
 type ClientCacheDebug = boolean | 'verbose';
-/** Config injected by the consuming app, so this module stays env-agnostic and testable. */
-interface ClientCacheConfig {
-  /** Per-solve timeout forwarded to the scheduler (`ComputeLimits.solveDeadlineMs`). */
-  solveDeadlineMs: number;
-  cachesolve: boolean;
-  /** Reference large definitions by server cache key instead of re-uploading. */
-  reuseServerDefinitionCache: boolean;
-  /**
-   * Max solves that may wait in the FIFO queue, excluding in-flight solves
-   * (capped at `maxConcurrent`, itself driven by the server's probed child
-   * count). `0` = unbounded (`ComputeLimits.computeMaxQueueDepth`); a full
-   * queue rejects new solves with `QUEUE_FULL`.
-   */
-  maxQueueDepth: number;
-  /**
-   * Max ms a solve may sit queued before executing; `0` = no deadline
-   * (`ComputeLimits.computeQueueWaitMs`). Too long a wait rejects with
-   * `QUEUE_TIMEOUT`.
-   */
-  queueWaitMs: number;
-  /**
-   * Byte budget for this client's in-process solve cache. Applies per warm
-   * client — worst-case heap is this × `maxWarmComputeServers`. `0` disables
-   * the cache (`ComputeLimits.computeSolveCacheBytes`, env `COMPUTE_SOLVE_CACHE_MB`).
-   */
-  responseCacheMaxBytes: number;
-  /**
-   * Largest compute response body read; past it the download is cancelled (`too_large`).
-   * Default: no limit.
-   */
-  maxResponseBytes?: number;
-  debug: ClientCacheDebug;
-  /** Max distinct warm compute servers before the LRU evicts the oldest. Default 16. */
-  maxWarmComputeServers?: number;
-  /** Sink for the debug lines. `onDebugLog` only fires when `debug` is not `false`. */
-  onDebugLog?: (message: string) => void;
-}
-interface ClientCache {
-  /**
-   * Get (or create) the warm client + scheduler for a resolved compute server,
-   * keyed by its `id`. `definitionGuid`, when present, is stamped as the
-   * `X-Selva-Definition` header on this client's outbound solve/IO requests —
-   * inert routing/telemetry metadata until a pool router exists.
-   */
-  getClient(server: ResolvedServer, opts?: {
-    definitionGuid?: string;
-  }): Promise<CachedClient>;
-  /** Dispose and drop the warm client for `id`, so the next request rebuilds against fresh connection details. */
-  evict(id: string | ServerIdentity): void;
-  /** Solve-cache counters summed across every warm client. Counters die with the client that owns them, so totals can fall over time. */
-  solveCacheStats(): SolveCacheStats;
-  /**
-   * Drop every retained solve result, keeping the warm clients (and their
-   * connections and server-side definition pointers) intact. Nothing expires
-   * these on its own — the byte budget is the only other pressure — so this is
-   * the operator's release valve when a definition's inputs no longer describe
-   * its output, e.g. it reads an external source that has since changed.
-   */
-  clearSolveCaches(): void;
-  /** Dispose every warm client. Test seam / shutdown hook. */
-  disposeAll(): void;
-}
 interface SolveCacheStats {
   warmClients: number;
   entries: number;
@@ -98,7 +48,6 @@ interface SolveCacheStats {
   /** Entries dropped under size/byte pressure (not replacement or manual clears). */
   evictions: number;
 }
-export declare function createClientCache(config: ClientCacheConfig): ClientCache;
 /**
  * In-process cache of `.gh` definition bytes, keyed by immutable **version id**.
  *
@@ -131,7 +80,7 @@ interface ByteRefOutcome {
 /** A definition reference shaped for `@selvajs/compute`'s `DefinitionRef`. */
 interface ByteCacheRef {
   key: string;
-  load: () => Promise<Uint8Array>;
+  load: (signal?: AbortSignal) => Promise<Uint8Array>;
   outcome: ByteRefOutcome;
 }
 interface ByteCacheStats {
@@ -141,65 +90,23 @@ interface ByteCacheStats {
   entries: number;
   bytes: number;
 }
-interface DefinitionByteCache {
-  getOrLoad(versionId: string, load: () => Promise<Uint8Array>): ByteCacheRef;
-  stats(): ByteCacheStats;
-  clear(): void;
+/** A pre-solve prep sub-phase: `[label, ms]`, surfaced as a `p_*` Server-Timing entry. */
+type PrepMark = [string, number];
+interface CacheVerdict {
+  fromCache: boolean;
+  definitionReuploaded?: boolean;
 }
 /**
- * @param maxBytes total retained-byte budget; `0` (or negative) disables caching
- *   entirely — every `load()` calls the loader and nothing is retained.
+ * skipped = scheduler never materialized bytes (pointer-known solve, the whole point of this
+ * path); hit = warm byte cache; miss = fell through to storage.
  */
-export declare function createDefinitionByteCache(maxBytes: number): DefinitionByteCache;
+type DefBytesVerdict = 'skipped' | 'hit' | 'miss';
 /** Compute-response contract version. Bump (and document the change) whenever the envelope's shape changes in a way a consumer could observe. */
 export declare const COMPUTE_CONTRACT_VERSION: 1;
 export declare const COMPUTE_VERSION_HEADER = "X-Selva-Compute-Version";
-type PipelineInput = SolveInput;
-interface SolvePipelineArgs {
-  /**
-   * Raw `.gh` bytes, or a byte-cache `DefinitionRef` whose bytes the scheduler
-   * materializes only when an upload is unavoidable — a pointer-known solve
-   * moves zero bytes.
-   */
-  definitionSource: SolveDefinition$1;
-  /** Mutable load outcome for a `DefinitionRef` source, so the `def_bytes` Server-Timing verdict can be emitted. Omit for raw-bytes solves. */
-  byteRefOutcome?: ByteRefOutcome;
-  /** Persisted input params; only those with a `paramType` are sent to the solve. */
-  inputs: PipelineInput[];
-  /**
-   * A tree the caller already built with {@link buildSolveInputTree}; skips the
-   * pipeline's own build and solves this object directly.
-   *
-   * A caller coalescing concurrent solves needs this: a single-flight key
-   * derived from raw `{inputs, values}` would split two requests that transform
-   * to the same tree, which is the identity the scheduler actually caches on.
-   */
-  inputTree?: DataTree[];
-  /** User-chosen values keyed by input id; missing keys fall back to the schema default. */
-  values: Record<string, unknown>;
-  client: CachedClient;
-  responseMaxBytes: number;
-  /** Only phrases the timeout message — the scheduler enforces the deadline itself. */
-  solveDeadlineMs: number;
-  /** Client's `Accept-Encoding`; gzip is applied only when it advertises `gzip`. */
-  acceptEncoding: string;
-  /** Per-solve live-event callback the compute server hands to the definition; absent when the caller opened no stream. */
-  selvaEvents?: SelvaEventTarget;
-  /**
-   * Forwarded to the scheduler so a client disconnect cancels the upstream
-   * compute call. Its `aborted` flag also distinguishes a client disconnect
-   * from the scheduler's own deadline firing.
-   */
-  signal: AbortSignal;
-  /** Wall-clock origin (`performance.now()` at the top of the request) so `load`/`total` phase timings line up with the caller's pre-solve prep. */
-  loadStartMs: number;
-  /** Pre-solve "load" phase duration the caller already measured (auth + DB + fetch). */
-  defLoadMs: number;
-  /** Pre-solve prep sub-phase marks (`[label, ms]`), surfaced verbatim as `p_*` Server-Timing entries. */
-  prepMarks?: [string, number][];
-}
-/** Phase timings the pipeline measured; the caller uses them for debug logging. */
+/** What the `Server-Timing` header carries for one caller, as data: read this, don't parse that. */
 interface SolvePhaseMetrics {
+  defLoadMs: number;
   treeBuildMs: number;
   solveMs: number;
   serializeMs: number;
@@ -208,6 +115,11 @@ interface SolvePhaseMetrics {
   serializedBytes: number;
   /** Null when compression was skipped. */
   compressedBytes: number | null;
+  /** The compute server's own timing; null when it reports none. */
+  rhino: ServerTiming | null;
+  settle: CacheVerdict;
+  /** Absent for raw-bytes solves. */
+  defBytes?: DefBytesVerdict;
 }
 /** A ready-to-send response: body + headers + the solve result + phase metrics. */
 interface SolveEnvelope {
@@ -218,20 +130,21 @@ interface SolveEnvelope {
   result: GrasshopperComputeResponse;
   metrics: SolvePhaseMetrics;
 }
+/** Whether an `Accept-Encoding` header takes gzip. `gzip;q=0` is a client refusing it. */
+export declare function acceptsGzip(acceptEncoding: string): boolean;
 /**
- * `ok` carries the envelope; every other variant names an expected failure the
- * calling route maps to a status code (timeout→504, client_abort→499,
- * too_large→413, shed→503+Retry-After, compute_error→generic 500/503).
- * `durationMs` on error variants is the solve wall time up to the failure, for
- * the metric record.
+ * `ok` carries the envelope; every other variant names an expected failure:
+ * `SolveEngine.toWebResponse` maps each to a status. `durationMs` on error variants is the solve
+ * wall time up to the failure, for the metric record.
  */
-type SolveOutcome = {
+type SolveEngineOutcome = {
   kind: 'ok';
   envelope: SolveEnvelope;
   solveMs: number;
   errorCount: number;
   warningCount: number;
-} | {
+} | SolveFailure;
+type SolveFailure = {
   kind: 'timeout';
   durationMs: number;
   message: string;
@@ -241,11 +154,21 @@ type SolveOutcome = {
 } | {
   kind: 'too_large';
 } |
-/** Scheduler backpressure rejected the solve before it ran: queue was full (`queue_full`) or the wait exceeded the deadline (`queue_timeout`). Retryable — `retryAfterSeconds` is a backoff hint. */
+/** The compute server refused the request body (its `RHINO_COMPUTE_MAX_REQUEST_SIZE`). */
+{
+  kind: 'request_too_large';
+  durationMs: number;
+  message: string;
+} |
+/**
+ * Retryable: no result, through no fault of the request, and `retryAfterSeconds` is a backoff
+ * hint. Scheduler backpressure rejected the solve before it ran (`queue_full`,
+ * `queue_timeout`), or its client was shut down under it (`interrupted`).
+ */
 {
   kind: 'shed';
   durationMs: number;
-  reason: 'queue_full' | 'queue_timeout';
+  reason: 'queue_full' | 'queue_timeout' | 'interrupted';
   retryAfterSeconds: number;
   message: string;
 } | {
@@ -253,71 +176,12 @@ type SolveOutcome = {
   durationMs: number;
   error: unknown;
 };
-export declare function runSolvePipeline(args: SolvePipelineArgs): Promise<SolveOutcome>;
-/**
- * Re-key a coalesced envelope to a single waiter's `Accept-Encoding`.
- *
- * The single-flight coalescer runs ONE pipeline execution for N identical
- * concurrent solves and hands every waiter the same {@link SolveEnvelope},
- * baked from the FIRST caller's `Accept-Encoding`. A later waiter with a
- * different `Accept-Encoding` would otherwise get a body labelled with the
- * wrong encoding — `Vary` can't help here, since it's one shared object, not a
- * cache lookup. Encoding is deliberately left out of the coalesce key so mixed
- * clients still coalesce; this adapts the shared result to each waiter instead.
- *
- * Only the correctness-critical direction is adapted: a gzip envelope served to
- * a non-gzip waiter is gunzipped back to JSON. The reverse (plain JSON to a
- * gzip-capable waiter) is left uncompressed — correct, just not maximally small.
- */
-export declare function adaptEnvelopeToEncoding(envelope: SolveEnvelope, acceptEncoding: string): {
-  body: string | Uint8Array;
-  headers: Record<string, string>;
-};
-/** The input tree a solve sends: each input's value, or its schema default when it has none. */
-export declare function buildSolveInputTree(inputs: SolveInput[], values: Record<string, unknown>): DataTree[];
-/**
- * In-process single-flight — dogpile protection for every solve.
- *
- * Always on, not gated behind a result cache being configured: the dogpile is worst
- * when nothing else is caching, since N concurrent identical solves each pay a full
- * Rhino round trip (the scheduler doesn't coalesce in-flight requests itself, and
- * Rhino's `cachesolve` still costs a round trip per repeat). An earlier version
- * gated this on cache config and so disabled it in exactly the deployments most
- * exposed to a cold-key stampede — hot public definition plus a deploy.
- *
- * Per app instance, above `ISolveResultCache`. No cross-instance lease (Redis
- * `SET NX`) yet.
- *
- * The shared promise resolves to one value for every waiter, so `work` must return
- * something safe to share by reference — the solve pipeline's envelope qualifies
- * because the app serializes it per response.
- */
-interface SolveCacheSingleFlight {
-  /**
-   * Coalesces concurrent calls under the same key: the first caller runs `work`,
-   * later callers for that key await the same promise, and the key frees as soon
-   * as it settles.
-   *
-   * `onWaiterJoined` fires only on the owner's call, only while `work` is still
-   * running, each time another caller joins. Ownership changes what the owner's
-   * abort signal should mean: a solo run can cancel on its own client's
-   * disconnect, but a shared run can't without 499-ing every waiter.
-   */
-  run<T>(key: string, work: () => Promise<T>, onWaiterJoined?: () => void): Promise<T>;
-  inFlight(): number;
-}
-interface SolveCacheSingleFlightOptions {
-  onJoin?: (key: string) => void;
-}
-export declare function createSolveCacheSingleFlight(options?: SolveCacheSingleFlightOptions): SolveCacheSingleFlight;
 /**
  * Subset of `ComputeLimits` (`@selvajs/server/compute`) the engine needs.
  * Pass the resolved object through as-is — extra fields are ignored.
  */
 interface SolveEngineLimits {
-  solveDeadlineMs: number;
   computeResponseMaxBytes: number;
-  computeReuseDefinitionCache: boolean;
   computeServerCachesolve: boolean;
   computeMaxQueueDepth: number;
   computeQueueWaitMs: number;
@@ -326,26 +190,20 @@ interface SolveEngineLimits {
 }
 interface SolveEngineOptions {
   limits: SolveEngineLimits;
-  logger?: ILogger;
-  /** Max distinct warm compute servers before the LRU evicts the oldest. Default 16. */
+  /** Max distinct warm compute servers before the LRU evicts the oldest. */
   maxWarmComputeServers?: number;
   /** Concise cache/timing logs when truthy; `'verbose'` also dumps full lib-level requests/responses. Default off. */
   debug?: ClientCacheDebug;
+  /** Sink for the debug lines. Without it they go nowhere. */
   onDebugLog?: (message: string) => void;
   /** Fired when a caller joins an already-in-flight solve instead of running its own. */
   onSolveCoalesced?: (key: string) => void;
 }
 /**
- * Accepts every form `runSolvePipeline` does, plus `{versionId, load}` sugar
- * that builds (and caches) a `ByteCacheRef` internally. A `ByteCacheRef`
- * obtained ahead of time from `engine.definitionRef()` (e.g. to read bytes for
- * schema extraction before solving) is passed through as-is — detected by its
- * `outcome` field, which a plain `DefinitionRef` never has.
+ * A `ByteCacheRef` obtained ahead of time from `engine.definitionRef()` (e.g. to
+ * read bytes for schema extraction before solving) is passed through as-is.
  */
-type SolveEngineDefinitionSource = Uint8Array | string | DefinitionRef$1 | ByteCacheRef | {
-  versionId: string;
-  load: () => Promise<Uint8Array>;
-};
+type SolveEngineDefinitionSource = Uint8Array | string | DefinitionRef$1 | ByteCacheRef;
 interface SolveEngineSolveArgs {
   server: ResolvedServer;
   definitionSource: SolveEngineDefinitionSource;
@@ -356,15 +214,23 @@ interface SolveEngineSolveArgs {
    * Ignored for the other source forms.
    */
   definitionKey?: string;
-  inputs: PipelineInput[];
+  /**
+   * The definition's inputs, from the schema you stored, never from the request: `id`, `nickname`,
+   * `paramType` and the bounds decide what reaches the definition, so a body that supplies them
+   * can drop a limit or fill a slot your host reserved.
+   */
+  inputs: SolveInput[];
   values: Record<string, unknown>;
   signal: AbortSignal;
   acceptEncoding?: string;
-  /** Stamped as `X-Selva-Definition` on this solve's client. */
+  /**
+   * Stamped as `X-Selva-Definition` when this solve builds the server's warm client. The header
+   * is fixed per client, so later solves on that server carry the first definition's guid.
+   */
   definitionGuid?: string;
   loadStartMs?: number;
   defLoadMs?: number;
-  prepMarks?: [string, number][];
+  prepMarks?: PrepMark[];
   /**
    * Per-solve live-event callback. A coalesced waiter shares the first caller's
    * compute call, so only that caller's target reaches the definition; the
@@ -372,11 +238,6 @@ interface SolveEngineSolveArgs {
    */
   selvaEvents?: SelvaEventTarget;
 }
-interface FrameworkAgnosticResponse {
-  status: number;
-  headers: Record<string, string>;
-  body: string | Uint8Array;
-}
 interface SolveEngineStats {
   client: SolveCacheStats;
   definitionBytes: ByteCacheStats;
@@ -389,11 +250,17 @@ export declare class SolveEngine {
   private readonly clientCache;
   private readonly byteCache;
   private readonly singleFlight;
+  private readonly clientGenerations;
+  private lastClientGeneration;
   constructor(options: SolveEngineOptions);
   getClient(server: ResolvedServer, opts?: {
     definitionGuid?: string;
   }): Promise<CachedClient>;
-  definitionRef(versionId: string, load: () => Promise<Uint8Array>): ByteCacheRef;
+  definitionRef(versionId: string, load: (signal: AbortSignal) => Promise<Uint8Array>): ByteCacheRef;
+  /**
+   * Drops the warm client for `id`; call it when the server's URL or key changes. Solves already
+   * running finish on the old connection details first, so a revoked key stays in use until then.
+   */
   evictServer(id: string): void;
   clearSolveCaches(): void;
   /**
@@ -402,15 +269,23 @@ export declare class SolveEngine {
    */
   clearDefinitionCache(): void;
   stats(): SolveEngineStats;
-  solve(args: SolveEngineSolveArgs): Promise<SolveOutcome>;
-  toResponse(outcome: SolveOutcome, opts?: {
-    onError?: (status: number, body: {
-      message: string;
-      retryAfter?: number;
-    }) => never;
-  }): FrameworkAgnosticResponse;
-  toWebResponse(outcome: SolveOutcome): Response;
+  solve(args: SolveEngineSolveArgs): Promise<SolveEngineOutcome>;
+  /**
+   * The response for an outcome; the mapping from outcome to status lives here. Throws
+   * `compute_error`'s error: what it means for the caller is the host's to decide.
+   */
+  toWebResponse(outcome: SolveEngineOutcome): Response;
+  /**
+   * Part of the coalesce key: after an eviction the id stays and the client changes, and a new
+   * caller joining a draining flight would get an answer from the old URL or key.
+   */
+  private clientGeneration;
   private resolveDefinitionSource;
 }
-export { type ByteCacheRef, type ByteCacheStats, type ByteRefOutcome, type CachedClient, type ClientCache, type ClientCacheConfig, type DefinitionByteCache, type DefinitionRef, type FrameworkAgnosticResponse, type PipelineInput, type ResolvedServer, type ServerIdentity, type SolveCacheSingleFlight, type SolveCacheSingleFlightOptions, type SolveCacheStats, type SolveDefinition, type SolveEngineDefinitionSource, type SolveEngineLimits, type SolveEngineOptions, type SolveEngineSolveArgs, type SolveEngineStats, type SolveEnvelope, type SolveInput, type SolveOutcome, type SolvePhaseMetrics, type SolvePipelineArgs, isDefinitionRef };
+/**
+ * What `SolveEngine.solve` takes as `inputs`, from a schema the host stored. The bounds live on
+ * the number widgets in the layout, not on `schema.inputs`, so without them nothing clamps.
+ */
+export declare function solveInputsFromSchema(schema: UISchema): SolveInput[];
+export type { ByteCacheRef, ByteCacheStats, ByteRefOutcome, CachedClient, DefinitionRef, ResolvedServer, SolveCacheStats, SolveDefinition, SolveEngineDefinitionSource, SolveEngineLimits, SolveEngineOptions, SolveEngineOutcome, SolveEngineSolveArgs, SolveEngineStats, SolveEnvelope, SolveInput, SolveLimits, SolvePhaseMetrics };
 //# sourceMappingURL=server.d.ts.map