@selvajs/solve 1.0.0-beta.8 → 1.0.0

package/dist/server.d.cts

@@ -1,56 +1,55 @@
-import { SolveDefinition } from '@selvajs/compute/core';
-export { DefinitionRef, SolveDefinition, isDefinitionRef } from '@selvajs/compute/core';
-import { GrasshopperClient, SolveScheduler, GrasshopperComputeResponse, DataTree, InputParam, DefinitionRef } from '@selvajs/compute/grasshopper';
-import { SchemaInput } from '@selvajs/schemas';
-import { ILogger } from '@selvajs/platform';
-export { S as SolveInput } from './solve-input-CqYtetTA.cjs';
-
+import { t as SolveInput } from "./solve-input-BDv_JdvS.cjs";
+import { SchemaInput } from "@selvajs/schemas";
+import { DataTree, DefinitionRef as DefinitionRef$1, GrasshopperClient, GrasshopperComputeResponse, InputParam, SolveScheduler } from "@selvajs/compute/grasshopper";
+import { DefinitionRef, SolveDefinition, SolveDefinition as SolveDefinition$1, isDefinitionRef } from "@selvajs/compute/core";
+import { ILogger } from "@selvajs/platform";
+//#region src/server/client-cache.d.ts
 /**
  * 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.
  */
 type ServerIdentity = string & {
-    readonly __brand: 'ServerIdentity';
+  readonly __brand: 'ServerIdentity';
 };
 /** Minimal resolved-server shape the cache needs (a subset of the app's `ComputeServerConfig`). */
 interface ResolvedServer {
-    id: string;
-    serverUrl: string;
-    /** Sent as the `RhinoComputeKey` header. */
-    apiKey?: string;
+  id: string;
+  serverUrl: string;
+  /** Sent as the `RhinoComputeKey` header. */
+  apiKey?: string;
 }
 declare function serverIdentity(server: Pick<ResolvedServer, 'id'>): ServerIdentity;
 interface CachedClient {
-    client: GrasshopperClient;
-    scheduler: SolveScheduler;
-    /**
-     * Last Server-Timing decode/solve/encode, written by `onServerTiming`. The
-     * scheduler runs up to `maxConcurrent` solves at once, so `last` alone can't
-     * be trusted per-request: callers snapshot `seq` before their solve and only
-     * attribute `last` to themselves if exactly one write happened since (see
-     * the guard in `runSolvePipeline`), dropping it otherwise rather than risk
-     * misattributing another request's timing.
-     */
-    rhinoTiming: {
-        last: {
-            decode: number;
-            solve: number;
-            encode: number;
-        } | null;
-        seq: number;
-    };
-    /**
-     * Same snapshot-and-attribute pattern as `rhinoTiming`, for the scheduler's
-     * `onSettle` cache verdict. `seq` increments on every settle (success or
-     * error); `last` is written only on success.
-     */
-    solveMeta: {
-        last: {
-            fromCache: boolean;
-            definitionReuploaded?: boolean;
-        } | null;
-        seq: number;
-    };
+  client: GrasshopperClient;
+  scheduler: SolveScheduler;
+  /**
+   * Last Server-Timing decode/solve/encode, written by `onServerTiming`. The
+   * scheduler runs up to `maxConcurrent` solves at once, so `last` alone can't
+   * be trusted per-request: callers snapshot `seq` before their solve and only
+   * attribute `last` to themselves if exactly one write happened since (see
+   * the guard in `runSolvePipeline`), dropping it otherwise rather than risk
+   * misattributing another request's timing.
+   */
+  rhinoTiming: {
+    last: {
+      decode: number;
+      solve: number;
+      encode: number;
+    } | null;
+    seq: number;
+  };
+  /**
+   * Same snapshot-and-attribute pattern as `rhinoTiming`, for the scheduler's
+   * `onSettle` cache verdict. `seq` increments on every settle (success or
+   * error); `last` is written only on success.
+   */
+  solveMeta: {
+    last: {
+      fromCache: boolean;
+      definitionReuploaded?: boolean;
+    } | null;
+    seq: number;
+  };
 }
 /**
  * Debug verbosity: `false` is silent, `true` gives concise cache/timing logs
@@ -60,74 +59,75 @@ interface CachedClient {
 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;
-    /** Only meaningful with `cachesolve`. */
-    cacheerroredsolves: 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;
-    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;
+  /** Per-solve timeout forwarded to the scheduler (`ComputeLimits.solveDeadlineMs`). */
+  solveDeadlineMs: number;
+  cachesolve: boolean;
+  /** Only meaningful with `cachesolve`. */
+  cacheerroredsolves: 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;
+  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;
+  /**
+   * 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;
-    bytes: number;
-    hits: number;
-    misses: number;
-    /** Entries dropped under size/byte pressure (not replacement or manual clears). */
-    evictions: number;
+  warmClients: number;
+  entries: number;
+  bytes: number;
+  hits: number;
+  misses: number;
+  /** Entries dropped under size/byte pressure (not replacement or manual clears). */
+  evictions: number;
 }
 declare function createClientCache(config: ClientCacheConfig): ClientCache;
-
+//#endregion
+//#region src/server/definition-byte-cache.d.ts
 /**
  * In-process cache of `.gh` definition bytes, keyed by immutable **version id**.
  *
@@ -154,109 +154,102 @@ declare function createClientCache(config: ClientCacheConfig): ClientCache;
  * verdict (`skipped` / `hit` / `miss`).
  */
 interface ByteRefOutcome {
-    loaded: boolean;
-    fromCache: boolean;
+  loaded: boolean;
+  fromCache: boolean;
 }
 /** A definition reference shaped for `@selvajs/compute`'s `DefinitionRef`. */
 interface ByteCacheRef {
-    key: string;
-    load: () => Promise<Uint8Array>;
-    outcome: ByteRefOutcome;
+  key: string;
+  load: () => Promise<Uint8Array>;
+  outcome: ByteRefOutcome;
 }
 interface ByteCacheStats {
-    hits: number;
-    misses: number;
-    evictions: number;
-    entries: number;
-    bytes: number;
+  hits: number;
+  misses: number;
+  evictions: number;
+  entries: number;
+  bytes: number;
 }
 interface DefinitionByteCache {
-    getOrLoad(versionId: string, load: () => Promise<Uint8Array>): ByteCacheRef;
-    stats(): ByteCacheStats;
-    clear(): void;
+  getOrLoad(versionId: string, load: () => Promise<Uint8Array>): ByteCacheRef;
+  stats(): ByteCacheStats;
+  clear(): void;
 }
 /**
  * @param maxBytes total retained-byte budget; `0` (or negative) disables caching
  *   entirely — every `load()` calls the loader and nothing is retained.
  */
 declare function createDefinitionByteCache(maxBytes: number): DefinitionByteCache;
-
-/**
- * Transport-agnostic solve pipeline: given an already-resolved solve context
- * (`.gh` bytes, input params + user values, a warm `SolveScheduler`), runs the
- * solve and returns a discriminated {@link SolveOutcome} instead of throwing
- * for expected failures. Auth, the database, share tokens, rate limits, and
- * metric sinks are the calling route's job, not this file's.
- */
-
+//#endregion
+//#region src/server/solve-pipeline.d.ts
 /** Compute-response contract version. Bump (and document the change) whenever the envelope's shape changes in a way a consumer could observe. */
 declare const COMPUTE_CONTRACT_VERSION: 1;
 declare const COMPUTE_VERSION_HEADER = "X-Selva-Compute-Version";
 type PipelineInput = SchemaInput & {
-    minimum?: number;
-    maximum?: number;
-    stepSize?: number;
+  minimum?: number;
+  maximum?: number;
+  stepSize?: number;
 };
 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;
-    /** 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;
-    /**
-     * 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][];
+  /**
+   * 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;
+  /**
+   * 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. */
 interface SolvePhaseMetrics {
-    treeBuildMs: number;
-    solveMs: number;
-    serializeMs: number;
-    gzipMs: number;
-    serverTotalMs: number;
-    serializedBytes: number;
-    /** Null when compression was skipped. */
-    compressedBytes: number | null;
+  treeBuildMs: number;
+  solveMs: number;
+  serializeMs: number;
+  gzipMs: number;
+  serverTotalMs: number;
+  serializedBytes: number;
+  /** Null when compression was skipped. */
+  compressedBytes: number | null;
 }
 /** A ready-to-send response: body + headers + the solve result + phase metrics. */
 interface SolveEnvelope {
-    /** A gzip `Uint8Array` when `encoding === 'gzip'`, else the JSON string. */
-    body: string | Uint8Array;
-    encoding?: 'gzip';
-    headers: Record<string, string>;
-    result: GrasshopperComputeResponse;
-    metrics: SolvePhaseMetrics;
+  /** A gzip `Uint8Array` when `encoding === 'gzip'`, else the JSON string. */
+  body: string | Uint8Array;
+  encoding?: 'gzip';
+  headers: Record<string, string>;
+  result: GrasshopperComputeResponse;
+  metrics: SolvePhaseMetrics;
 }
 /**
  * `ok` carries the envelope; every other variant names an expected failure the
@@ -266,32 +259,32 @@ interface SolveEnvelope {
  * the metric record.
  */
 type SolveOutcome = {
-    kind: 'ok';
-    envelope: SolveEnvelope;
-    solveMs: number;
-    errorCount: number;
-    warningCount: number;
+  kind: 'ok';
+  envelope: SolveEnvelope;
+  solveMs: number;
+  errorCount: number;
+  warningCount: number;
 } | {
-    kind: 'timeout';
-    durationMs: number;
-    message: string;
+  kind: 'timeout';
+  durationMs: number;
+  message: string;
 } | {
-    kind: 'client_abort';
-    durationMs: number;
+  kind: 'client_abort';
+  durationMs: number;
 } | {
-    kind: 'too_large';
-}
+  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. */
- | {
-    kind: 'shed';
-    durationMs: number;
-    reason: 'queue_full' | 'queue_timeout';
-    retryAfterSeconds: number;
-    message: string;
+{
+  kind: 'shed';
+  durationMs: number;
+  reason: 'queue_full' | 'queue_timeout';
+  retryAfterSeconds: number;
+  message: string;
 } | {
-    kind: 'compute_error';
-    durationMs: number;
-    error: unknown;
+  kind: 'compute_error';
+  durationMs: number;
+  error: unknown;
 };
 /** The transformed input tree exactly as handed to the scheduler; `runSolvePipeline` calls this itself unless the caller supplies {@link SolvePipelineArgs.inputTree}. */
 declare function buildSolveInputTree(inputs: PipelineInput[], values: Record<string, unknown>): DataTree[];
@@ -312,20 +305,22 @@ declare function runSolvePipeline(args: SolvePipelineArgs): Promise<SolveOutcome
  * gzip-capable waiter) is left uncompressed — correct, just not maximally small.
  */
 declare function adaptEnvelopeToEncoding(envelope: SolveEnvelope, acceptEncoding: string): {
-    body: string | Uint8Array;
-    headers: Record<string, string>;
+  body: string | Uint8Array;
+  headers: Record<string, string>;
 };
-
+//#endregion
+//#region src/server/transform-input.d.ts
 /**
  * `SchemaInput` has no `values`/`acceptedFormats` (those live on the layout item's config), so
  * valueList/file inputs here carry just the selected value with no option list.
  */
 declare function transformInputParameter(input: SchemaInput & {
-    minimum?: number;
-    maximum?: number;
-    stepSize?: number;
+  minimum?: number;
+  maximum?: number;
+  stepSize?: number;
 }, value: unknown): InputParam;
-
+//#endregion
+//#region src/server/solve-cache-single-flight.d.ts
 /**
  * In-process single-flight — dogpile protection for every solve.
  *
@@ -344,63 +339,50 @@ declare function transformInputParameter(input: SchemaInput & {
  * 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;
+  /**
+   * 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;
+  onJoin?: (key: string) => void;
 }
 declare function createSolveCacheSingleFlight(options?: SolveCacheSingleFlightOptions): SolveCacheSingleFlight;
-
-/**
- * Facade over the warm-client cache, definition-byte cache, single-flight
- * coalescing, and the solve pipeline — the primitives an app route would
- * otherwise wire up by hand.
- *
- * Doesn't read env itself: `@selvajs/server` owns `resolveComputeLimits` and
- * depends on `@selvajs/solve`, so calling it from here would be a circular
- * import. Callers resolve their own limits and pass in the fields below.
- *
- * Stays out of auth, DB reads, share tokens, rate limiting, metrics, and
- * compute-server selection — all app policy, supplied per-call via
- * `SolveEngineSolveArgs.server`.
- */
-
+//#endregion
+//#region src/server/solve-engine.d.ts
 /**
  * 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;
-    computeCacheErroredSolves: boolean;
-    computeMaxQueueDepth: number;
-    computeQueueWaitMs: number;
-    computeDefinitionCacheBytes: number;
-    computeSolveCacheBytes: number;
+  solveDeadlineMs: number;
+  computeResponseMaxBytes: number;
+  computeReuseDefinitionCache: boolean;
+  computeServerCachesolve: boolean;
+  computeCacheErroredSolves: boolean;
+  computeMaxQueueDepth: number;
+  computeQueueWaitMs: number;
+  computeDefinitionCacheBytes: number;
+  computeSolveCacheBytes: number;
 }
 interface SolveEngineOptions {
-    limits: SolveEngineLimits;
-    logger?: ILogger;
-    /** Max distinct warm compute servers before the LRU evicts the oldest. Default 16. */
-    maxWarmComputeServers?: number;
-    /** Concise cache/timing logs when truthy; `'verbose'` also dumps full lib-level requests/responses. Default off. */
-    debug?: ClientCacheDebug;
-    onDebugLog?: (message: string) => void;
-    /** Fired when a caller joins an already-in-flight solve instead of running its own. */
-    onSolveCoalesced?: (key: string) => void;
+  limits: SolveEngineLimits;
+  logger?: ILogger;
+  /** Max distinct warm compute servers before the LRU evicts the oldest. Default 16. */
+  maxWarmComputeServers?: number;
+  /** Concise cache/timing logs when truthy; `'verbose'` also dumps full lib-level requests/responses. Default off. */
+  debug?: ClientCacheDebug;
+  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
@@ -409,64 +391,65 @@ interface SolveEngineOptions {
  * schema extraction before solving) is passed through as-is — detected by its
  * `outcome` field, which a plain `DefinitionRef` never has.
  */
-type SolveEngineDefinitionSource = Uint8Array | string | DefinitionRef | ByteCacheRef | {
-    versionId: string;
-    load: () => Promise<Uint8Array>;
+type SolveEngineDefinitionSource = Uint8Array | string | DefinitionRef$1 | ByteCacheRef | {
+  versionId: string;
+  load: () => Promise<Uint8Array>;
 };
 interface SolveEngineSolveArgs {
-    server: ResolvedServer;
-    definitionSource: SolveEngineDefinitionSource;
-    /**
-     * Coalesce-key identity for a raw `Uint8Array`/`string` source, which has
-     * no natural identity the way a `DefinitionRef`'s `.key` does. Required in
-     * that case — `solve()` throws rather than silently hashing the bytes.
-     * Ignored for the other source forms.
-     */
-    definitionKey?: string;
-    inputs: PipelineInput[];
-    values: Record<string, unknown>;
-    signal: AbortSignal;
-    acceptEncoding?: string;
-    /** Stamped as `X-Selva-Definition` on this solve's client. */
-    definitionGuid?: string;
-    loadStartMs?: number;
-    defLoadMs?: number;
-    prepMarks?: [string, number][];
+  server: ResolvedServer;
+  definitionSource: SolveEngineDefinitionSource;
+  /**
+   * Coalesce-key identity for a raw `Uint8Array`/`string` source, which has
+   * no natural identity the way a `DefinitionRef`'s `.key` does. Required in
+   * that case — `solve()` throws rather than silently hashing the bytes.
+   * Ignored for the other source forms.
+   */
+  definitionKey?: string;
+  inputs: PipelineInput[];
+  values: Record<string, unknown>;
+  signal: AbortSignal;
+  acceptEncoding?: string;
+  /** Stamped as `X-Selva-Definition` on this solve's client. */
+  definitionGuid?: string;
+  loadStartMs?: number;
+  defLoadMs?: number;
+  prepMarks?: [string, number][];
 }
 interface FrameworkAgnosticResponse {
-    status: number;
-    headers: Record<string, string>;
-    body: string | Uint8Array;
+  status: number;
+  headers: Record<string, string>;
+  body: string | Uint8Array;
 }
 interface SolveEngineStats {
-    client: SolveCacheStats;
-    definitionBytes: ByteCacheStats;
-    coalescing: {
-        inFlight: number;
-    };
+  client: SolveCacheStats;
+  definitionBytes: ByteCacheStats;
+  coalescing: {
+    inFlight: number;
+  };
 }
 declare class SolveEngine {
-    private readonly limits;
-    private readonly clientCache;
-    private readonly byteCache;
-    private readonly singleFlight;
-    constructor(options: SolveEngineOptions);
-    getClient(server: ResolvedServer, opts?: {
-        definitionGuid?: string;
-    }): Promise<CachedClient>;
-    definitionRef(versionId: string, load: () => Promise<Uint8Array>): ByteCacheRef;
-    evictServer(id: string): void;
-    clearSolveCaches(): 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;
-    private resolveDefinitionSource;
+  private readonly limits;
+  private readonly clientCache;
+  private readonly byteCache;
+  private readonly singleFlight;
+  constructor(options: SolveEngineOptions);
+  getClient(server: ResolvedServer, opts?: {
+    definitionGuid?: string;
+  }): Promise<CachedClient>;
+  definitionRef(versionId: string, load: () => Promise<Uint8Array>): ByteCacheRef;
+  evictServer(id: string): void;
+  clearSolveCaches(): 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;
+  private resolveDefinitionSource;
 }
-
-export { type ByteCacheRef, type ByteCacheStats, type ByteRefOutcome, COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER, type CachedClient, type ClientCache, type ClientCacheConfig, type DefinitionByteCache, type FrameworkAgnosticResponse, type PipelineInput, type ResolvedServer, type ServerIdentity, type SolveCacheSingleFlight, type SolveCacheSingleFlightOptions, type SolveCacheStats, SolveEngine, type SolveEngineDefinitionSource, type SolveEngineLimits, type SolveEngineOptions, type SolveEngineSolveArgs, type SolveEngineStats, type SolveEnvelope, type SolveOutcome, type SolvePhaseMetrics, type SolvePipelineArgs, adaptEnvelopeToEncoding, buildSolveInputTree, createClientCache, createDefinitionByteCache, createSolveCacheSingleFlight, runSolvePipeline, serverIdentity, transformInputParameter };
+//#endregion
+export { type ByteCacheRef, type ByteCacheStats, type ByteRefOutcome, COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER, 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, SolveEngine, type SolveEngineDefinitionSource, type SolveEngineLimits, type SolveEngineOptions, type SolveEngineSolveArgs, type SolveEngineStats, type SolveEnvelope, type SolveInput, type SolveOutcome, type SolvePhaseMetrics, type SolvePipelineArgs, adaptEnvelopeToEncoding, buildSolveInputTree, createClientCache, createDefinitionByteCache, createSolveCacheSingleFlight, isDefinitionRef, runSolvePipeline, serverIdentity, transformInputParameter };
+//# sourceMappingURL=server.d.cts.map