@selvajs/solve 0.2.0-beta.1 → 0.2.0-beta.4

package/dist/server.d.ts

@@ -1,5 +1,7 @@
-import { GrasshopperClient, SolveScheduler, GrasshopperComputeResponse, SolveDefinition, DataTree, InputParam } from '@selvajs/compute';
+import { GrasshopperClient, SolveScheduler, GrasshopperComputeResponse, SolveDefinition, DataTree, InputParam, DefinitionRef } from '@selvajs/compute';
+export { DefinitionRef, SolveDefinition, isDefinitionRef } from '@selvajs/compute';
 import { SchemaInput } from '@selvajs/schemas';
+import { ILogger } from '@selvajs/platform';
 export { S as SolveInput } from './solve-input-CqYtetTA.js';
 
 /**
@@ -13,21 +15,20 @@ type ServerIdentity = string & {
 interface ResolvedServer {
     id: string;
     serverUrl: string;
-    /** Sent as `RhinoComputeKey`. */
+    /** Sent as the `RhinoComputeKey` header. */
     apiKey?: string;
 }
-/** Derive the opaque cache identity from a resolved server. Identity is the `id`. */
 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 `maxConcurrentSolves` 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.
+     * 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: {
@@ -39,7 +40,7 @@ interface CachedClient {
     };
     /**
      * Same snapshot-and-attribute pattern as `rhinoTiming`, for the scheduler's
-     * onSettle cache verdict. `seq` increments on every settle (success or
+     * `onSettle` cache verdict. `seq` increments on every settle (success or
      * error); `last` is written only on success.
      */
     solveMeta: {
@@ -50,48 +51,44 @@ interface CachedClient {
         seq: number;
     };
 }
+/**
+ * Debug verbosity: `false` is silent, `true` gives concise cache/timing logs
+ * (`onDebugLog`), `'verbose'` also enables full lib-level request/response
+ * 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.maxSolveDurationMs`). */
     maxSolveDurationMs: number;
-    /** Ask Rhino.Compute to cache solve results and return them on identical repeats. */
     cachesolve: boolean;
-    /** Also cache solves that reported GH errors (only meaningful with `cachesolve`). */
+    /** Only meaningful with `cachesolve`. */
     cacheerroredsolves: boolean;
-    /** Reference large definitions by server cache key (pointer) instead of re-uploading. */
+    /** Reference large definitions by server cache key instead of re-uploading. */
     reuseServerDefinitionCache: boolean;
     /**
-     * Max in-flight solves per compute server (scheduler `maxConcurrent`; excess
-     * FIFO-queues). Size to the server's `compute.geometry` child count
-     * (`ComputeLimits.computeMaxConcurrentSolves`).
-     */
-    maxConcurrentSolves: number;
-    /**
-     * Backpressure — max solves that may WAIT in the FIFO queue (excludes the
-     * in-flight `maxConcurrentSolves`). `0` = unbounded (`ComputeLimits.
-     * computeMaxQueueDepth`); a full queue sheds new solves with `QUEUE_FULL`.
+     * 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;
     /**
-     * Backpressure — max ms a solve may sit queued before executing; `0` = no
-     * deadline (`ComputeLimits.computeQueueWaitMs`). A too-long wait sheds with
+     * 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, evicted LRU alongside
-     * its entry-count cap. Applies per warm client — total worst-case heap is this
-     * × `maxCachedClients`. `0` disables the cache entirely
-     * (`ComputeLimits.computeSolveCacheBytes`, env `COMPUTE_SOLVE_CACHE_MB`).
+     * 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;
-    /** Concise cache/timing logs. When false, `onDebugLog` is never invoked. */
-    debug: boolean;
-    /** VERBOSE lib-level logging (full solve request/response incl. geometry). */
-    debugVerbose: boolean;
-    /** Max distinct warm clients before the LRU evicts the oldest. Default 16. */
-    maxCachedClients?: number;
-    /** Sink for the concise debug lines (the app wires `console.log`). */
+    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 {
@@ -106,11 +103,7 @@ interface ClientCache {
     }): 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. `warmClients` is
-     * reported alongside since each client owns its own cache. Counters die
-     * with the client that owns them, so totals can fall over time.
-     */
+    /** 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
@@ -123,7 +116,6 @@ interface ClientCache {
     /** Dispose every warm client. Test seam / shutdown hook. */
     disposeAll(): void;
 }
-/** Aggregate solve-cache counters across the warm clients (see `solveCacheStats`). */
 interface SolveCacheStats {
     warmClients: number;
     entries: number;
@@ -162,7 +154,6 @@ declare function createClientCache(config: ClientCacheConfig): ClientCache;
  */
 interface ByteRefOutcome {
     loaded: boolean;
-    /** When `loaded`, whether the bytes came from a warm cache entry. */
     fromCache: boolean;
 }
 /** A definition reference shaped for `@selvajs/compute`'s `DefinitionRef`. */
@@ -171,24 +162,16 @@ interface ByteCacheRef {
     load: () => Promise<Uint8Array>;
     outcome: ByteRefOutcome;
 }
-/** Hit/miss/eviction counters for observability (Server-Timing, admin debug). */
 interface ByteCacheStats {
     hits: number;
     misses: number;
-    /** Entries dropped by the byte-budget LRU. */
     evictions: number;
     entries: number;
     bytes: number;
 }
 interface DefinitionByteCache {
-    /**
-     * `DefinitionRef` whose `load()` serves `versionId`'s bytes from the cache
-     * when warm, otherwise calls `load` and caches the result. Cheap to build
-     * and moves no bytes until `load()` runs.
-     */
     getOrLoad(versionId: string, load: () => Promise<Uint8Array>): ByteCacheRef;
     stats(): ByteCacheStats;
-    /** Test seam / eviction on definition delete if ever needed. */
     clear(): void;
 }
 /**
@@ -200,10 +183,9 @@ declare function createDefinitionByteCache(maxBytes: number): DefinitionByteCach
 /**
  * Transport-agnostic solve pipeline: given an already-resolved solve context
  * (`.gh` bytes, input params + user values, a warm `SolveScheduler`), runs the
- * framework-free half of a solve and returns a discriminated {@link SolveOutcome}
- * instead of throwing for expected failures. Nothing here touches auth, the
- * database, share tokens, rate limits, or metric sinks — those stay app policy
- * in the route that calls this.
+ * 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.
  */
 
 /** Compute-response contract version. Bump (and document the change) whenever the envelope's shape changes in a way a consumer could observe. */
@@ -216,25 +198,20 @@ type PipelineInput = SchemaInput & {
 };
 interface SolvePipelineArgs {
     /**
-     * The definition to solve. Either raw `.gh` bytes, or a `DefinitionRef` (from
-     * the definition-byte cache) whose bytes the scheduler materializes ONLY when
-     * an upload is unavoidable — a pointer-known solve of a `DefinitionRef` moves
-     * zero bytes.
+     * 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;
-    /**
-     * When `definitionSource` is a byte-cache `DefinitionRef`, its mutable outcome
-     * so the pipeline can emit the `def_bytes` Server-Timing verdict. Omit for
-     * raw-bytes solves.
-     */
+    /** 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}. When present
-     * the pipeline skips its own build and solves this exact object.
+     * A tree the caller already built with {@link buildSolveInputTree}; skips the
+     * pipeline's own build and solves this object directly.
      *
-     * Needed whenever the caller coalesces concurrent solves: a single-flight key
+     * 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.
      */
@@ -243,28 +220,21 @@ interface SolvePipelineArgs {
     values: Record<string, unknown>;
     client: CachedClient;
     responseMaxBytes: number;
-    /** Used only to phrase the timeout message — the scheduler enforces the deadline itself. */
+    /** Only phrases the timeout message — the scheduler enforces the deadline itself. */
     maxSolveDurationMs: number;
     /** Client's `Accept-Encoding`; gzip is applied only when it advertises `gzip`. */
     acceptEncoding: string;
     /**
-     * Request abort signal, forwarded to the scheduler so a client disconnect
-     * cancels the upstream compute call. Its `aborted` flag also disambiguates a
-     * client disconnect from the scheduler's own deadline firing.
+     * 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()` captured at the top of the request)
-     * so the pipeline's `load`/`total` phase timings line up with the caller's
-     * pre-solve prep.
-     */
+    /** 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.
-     */
+    /** 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. */
@@ -288,12 +258,11 @@ interface SolveEnvelope {
     metrics: SolvePhaseMetrics;
 }
 /**
- * Discriminated result. `ok` carries the envelope; every other variant names an
- * expected failure the transport maps to a status code (the app route maps
- * timeout→504, client_abort→499, too_large→413, shed→503+Retry-After;
- * `compute_error` re-surfaces the original error for the generic 500/503 path).
- * `durationMs` on the 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 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.
  */
 type SolveOutcome = {
     kind: 'ok';
@@ -311,12 +280,7 @@ type SolveOutcome = {
 } | {
     kind: 'too_large';
 }
-/**
- * Scheduler backpressure shed the solve before it executed — the per-server
- * queue was full (`QUEUE_FULL`) or it sat queued past the wait deadline
- * (`QUEUE_TIMEOUT`). Retryable: the route maps this to 503 + `Retry-After`.
- * `retryAfterSeconds` is a suggested backoff hint for the client.
- */
+/** 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;
@@ -328,24 +292,19 @@ type SolveOutcome = {
     durationMs: number;
     error: unknown;
 };
-/**
- * Build the transformed input tree — the exact object handed to the scheduler.
- * `runSolvePipeline` calls this itself; a caller only needs it directly to see
- * the tree before the pipeline runs (see {@link SolvePipelineArgs.inputTree}).
- */
+/** 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[];
 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}. That
- * envelope's wire form is baked from the FIRST caller's `Accept-Encoding`, so a
- * later waiter with a different `Accept-Encoding` would otherwise get a body
- * labelled with the wrong encoding (`Vary` can't help — this is one object
- * shared across waiters, not a cache lookup). Encoding is deliberately not part
- * of the coalesce key, so mixed clients still coalesce; this adapts the shared
- * result to each waiter instead.
+ * 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
@@ -357,11 +316,8 @@ declare function adaptEnvelopeToEncoding(envelope: SolveEnvelope, acceptEncoding
 };
 
 /**
- * Adapt a persisted `SchemaInput` into `@selvajs/compute`'s raw `InputParamSchema`
- * and let its `processInput` produce the typed `InputParam`. `values`/`acceptedFormats`
- * are absent on `SchemaInput` (they live on the layout item's config), so
- * valueList/file inputs fall back to carrying the selected value with no option
- * list — the same value that reaches Grasshopper.
+ * `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;
@@ -372,44 +328,144 @@ declare function transformInputParameter(input: SchemaInput & {
 /**
  * In-process single-flight — dogpile protection for every solve.
  *
- * Deliberately NOT conditional on a result cache being configured: the dogpile is
- * worst precisely when nothing else is caching (N concurrent identical solves each
- * paying a full Rhino round trip — the scheduler has no in-flight coalescing of its
- * own, and Rhino's `cachesolve` still costs a round trip per repeat). Gating this on
- * cache configuration, as an earlier version did, turned it off in exactly the
- * deployments most exposed to a cold-key stampede (hot public definition + a deploy).
+ * 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.
  *
- * In-process only, sitting above `ISolveResultCache` (per app instance). A
- * cross-instance lease (Redis `SET NX`) is a later backend capability.
+ * Per app instance, above `ISolveResultCache`. No cross-instance lease (Redis
+ * `SET NX`) yet.
  *
- * Correctness note: the shared promise resolves to ONE value for all waiters, so
- * the wrapped work must return an immutable / independently-serializable result
- * (the solve pipeline's envelope is safe to share by reference here because the
- * app serializes it per response).
+ * 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 {
     /**
-     * Run `work` under `key`, coalescing concurrent identical calls: the first
-     * caller executes, overlapping callers for the same key await the same promise
-     * and result, and the key is freed as soon as it settles.
+     * 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 on the OWNER's call each time another caller joins its
-     * flight — ownership changes what the owner's abort signal means (a solo run
-     * may cancel on its own client's disconnect, a shared one may not, or it would
-     * 499 every waiter). Never fires for a joining caller, and never after `work`
-     * 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>;
-    /** Number of keys currently in flight (observability / tests). */
     inFlight(): number;
 }
 interface SolveCacheSingleFlightOptions {
-    /**
-     * Fired when a caller joins an already-in-flight key instead of running its
-     * own work — the coalescing win this module exists for, otherwise invisible.
-     */
     onJoin?: (key: string) => void;
 }
 declare function createSolveCacheSingleFlight(options?: SolveCacheSingleFlightOptions): SolveCacheSingleFlight;
 
-export { type ByteCacheRef, type ByteCacheStats, type ByteRefOutcome, COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER, type CachedClient, type ClientCache, type ClientCacheConfig, type DefinitionByteCache, type PipelineInput, type ResolvedServer, type ServerIdentity, type SolveCacheSingleFlight, type SolveCacheSingleFlightOptions, type SolveCacheStats, type SolveEnvelope, type SolveOutcome, type SolvePhaseMetrics, type SolvePipelineArgs, adaptEnvelopeToEncoding, buildSolveInputTree, createClientCache, createDefinitionByteCache, createSolveCacheSingleFlight, runSolvePipeline, serverIdentity, transformInputParameter };
+/**
+ * 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`.
+ */
+
+/**
+ * Subset of `ComputeLimits` (`@selvajs/server/compute`) the engine needs.
+ * Pass the resolved object through as-is — extra fields are ignored.
+ */
+interface SolveEngineLimits {
+    maxSolveDurationMs: 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;
+}
+/**
+ * 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.
+ */
+type SolveEngineDefinitionSource = Uint8Array | string | DefinitionRef | 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][];
+}
+interface FrameworkAgnosticResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string | Uint8Array;
+}
+interface SolveEngineStats {
+    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;
+}
+
+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 };

package/dist/server.js

@@ -1,2 +1,2 @@
-import{ErrorCodes as R,RhinoComputeError as I,TreeBuilder as O}from"@selvajs/compute";import{gzip as A,gunzipSync as _}from"zlib";import{promisify as L}from"util";import{processInput as z}from"@selvajs/compute";function T(e,r){let t={id:e.id,name:e.nickname,nickname:e.nickname||null,description:e.description||"",paramType:e.paramType==="dynamicValueList"?"valueList":e.paramType,treeAccess:e.inputStructure==="tree",minimum:e.minimum??null,maximum:e.maximum??null,atLeast:1,atMost:1,stepSize:e.stepSize,default:r??e.default},s=z(t),o=r??e.default;return s.default==null&&o!=null&&(Array.isArray(o)||s.paramType==="ValueList"&&typeof o!="object")&&(s.default=o),s}var $=L(A),P=1,E="X-Selva-Compute-Version";function B(e,r){return O.fromInputParams(e.filter(t=>t.paramType).map(t=>T(t,r[t.id])))}async function D(e){let{client:r,signal:t}=e,s=performance.now(),o=e.inputTree??B(e.inputs,e.values),u=performance.now()-s,i=r.solveMeta.seq,l=r.rhinoTiming.seq,n,a=performance.now();try{n=await r.scheduler.solve(e.definitionSource,o,{signal:t})}catch(v){let b=performance.now()-a;if(v instanceof Error&&v.name==="AbortError")return t.aborted?{kind:"client_abort",durationMs:b}:{kind:"timeout",durationMs:b,message:`Solve exceeded the ${Math.round(e.maxSolveDurationMs/1e3)}s deadline.`};if(v instanceof I){if(v.code===R.QUEUE_FULL)return{kind:"shed",durationMs:b,reason:"queue_full",retryAfterSeconds:1,message:"Compute server is at capacity. Retry shortly."};if(v.code===R.QUEUE_TIMEOUT)return{kind:"shed",durationMs:b,reason:"queue_timeout",retryAfterSeconds:1,message:"Compute request waited too long in the queue. Retry shortly."}}return{kind:"compute_error",durationMs:b,error:v}}let c=performance.now()-a,h=performance.now(),d;try{d=JSON.stringify(n)}catch(v){if(v instanceof RangeError)return{kind:"too_large"};throw v}if(d.length>e.responseMaxBytes)return{kind:"too_large"};let p=performance.now()-h,y=/\bgzip\b/i.test(e.acceptEncoding)&&d.length>1024,f=null,g=0;if(y){let v=performance.now();f=await $(Buffer.from(d)),g=performance.now()-v}let S=performance.now()-e.loadStartMs,M=r.solveMeta.seq===i+1?r.solveMeta.last:null,k=M&&!M.fromCache&&r.rhinoTiming.seq===l+1?r.rhinoTiming.last:null,C={"Content-Type":"application/json","Server-Timing":U({defLoadMs:e.defLoadMs,treeBuildMs:u,solveMs:c,serializeMs:p,gzipMs:g,serverTotalMs:S,rhino:k,settle:M,byteRefOutcome:e.byteRefOutcome,prepMarks:e.prepMarks??[]}),[E]:String(P),Vary:"Accept-Encoding"},w={treeBuildMs:u,solveMs:c,serializeMs:p,gzipMs:g,serverTotalMs:S,serializedBytes:d.length,compressedBytes:f?.byteLength??null},x;return f?(C["Content-Encoding"]="gzip",C["Content-Length"]=String(f.byteLength),x={body:new Uint8Array(f),encoding:"gzip",headers:C,result:n,metrics:w}):(C["Content-Length"]=String(Buffer.byteLength(d)),x={body:d,headers:C,result:n,metrics:w}),{kind:"ok",envelope:x,solveMs:c,errorCount:n.errors?.length??0,warningCount:n.warnings?.length??0}}function F(e,r){let t=/\bgzip\b/i.test(r);if(e.encoding==="gzip"&&!t){let s=_(e.body instanceof Uint8Array?e.body:Buffer.from(e.body)).toString("utf8"),o={...e.headers};return delete o["Content-Encoding"],o["Content-Length"]=String(Buffer.byteLength(s)),{body:s,headers:o}}return{body:e.body,headers:e.headers}}function U(e){let r=`load;dur=${e.defLoadMs.toFixed(1)}, tree;dur=${e.treeBuildMs.toFixed(1)}, solve;dur=${e.solveMs.toFixed(1)}, serialize;dur=${e.serializeMs.toFixed(1)}, gzip;dur=${e.gzipMs.toFixed(1)}, total;dur=${e.serverTotalMs.toFixed(1)}`,t=e.rhino;if(t){let u=t.decode+t.solve+t.encode,i=Math.max(0,e.solveMs-u);r+=`, rhino_decode;dur=${t.decode.toFixed(1)}, rhino_solve;dur=${t.solve.toFixed(1)}, rhino_encode;dur=${t.encode.toFixed(1)}, compute_link;dur=${i.toFixed(1)}`}for(let[u,i]of e.prepMarks)r+=`, p_${u};dur=${i.toFixed(1)}`;let s=e.settle;s&&(r+=`, selva_cache;dur=${s.fromCache?1:0}`,s.definitionReuploaded!==void 0&&(r+=`, def_reupload;dur=${s.definitionReuploaded?1:0}`));let o=e.byteRefOutcome;if(o){let u=o.loaded?o.fromCache?"hit":"miss":"skipped";r+=`, def_bytes;desc=${u}`}return r}import{GrasshopperClient as q,enableDebugLogging as G}from"@selvajs/compute";function V(e){return e.id}var N=16;function j(e){let r=e.maxCachedClients??N,t=new Map,s=new Map;e.debugVerbose&&G();let o=i=>{e.debug&&e.onDebugLog?.(i)};async function u(i,l){let n={last:null,seq:0},a={last:null,seq:0},c={serverUrl:i.serverUrl,apiKey:i.apiKey,debug:e.debugVerbose,cachesolve:e.cachesolve,cacheerroredsolves:e.cacheerroredsolves,onServerTiming:p=>{let m=p.decode??0,y=p.solve??0,f=p.encode??0;if(n.seq+=1,n.last={decode:m,solve:y,encode:f},!e.debug)return;let g=m<=1?"HIT (definition reused, no re-upload/parse)":"miss (full parse)",S=e.cachesolve&&y<=1?"HIT (cached result, solve skipped)":e.cachesolve?"miss (solved fresh)":"off";o(`[Compute/rhino-cache] decode=${m}ms solve=${y}ms encode=${f}ms | definition-cache: ${g} | solve-cache (cachesolve): ${S}`)}};l&&(c.headers={"X-Selva-Definition":l});let h=await q.create(c),d=h.createScheduler({mode:"queue",maxConcurrent:e.maxConcurrentSolves,maxQueueDepth:e.maxQueueDepth||void 0,queueWaitMs:e.queueWaitMs||void 0,timeoutMs:e.maxSolveDurationMs,cache:e.responseCacheMaxBytes>0?{maxBytes:e.responseCacheMaxBytes}:!1,reuseServerDefinitionCache:e.reuseServerDefinitionCache,onSettle:(p,m)=>{if(a.seq+=1,m.status==="success"&&(a.last={fromCache:m.fromCache===!0,definitionReuploaded:m.definitionReuploaded},!!e.debug&&(o(`[Compute/selva-cache] ${m.fromCache?"HIT  \u2014 served from cache (no compute call)":"miss \u2014 went to Rhino.Compute"} (${Math.round(m.durationMs)}ms)`),m.fromCache||o(m.definitionReuploaded===!0?"[Compute/def-cache] miss \u2014 definition RE-UPLOADED (pointer was cold/stale)":m.definitionReuploaded===!1?"[Compute/def-cache] HIT  \u2014 definition reused from server cache (no upload)":"[Compute/def-cache] n/a \u2014 reuse disabled or non-reusable definition"),!m.fromCache))){let y=m.response?.errors,f=Array.isArray(y)?y.length:0;if(f>0){let g=e.cacheerroredsolves?"cached (cacheerroredsolves on)":"not cached (cacheerroredsolves off) \u2014 re-run until fixed";o(`[Compute/rhino-cache] ${f} GH error(s); ${g}. First: ${JSON.stringify(y[0])}`)}}}});return{client:h,scheduler:d,rhinoTiming:n,solveMeta:a}}return{async getClient(i,l){let n=i.id,a=t.get(n);if(a)return t.delete(n),t.set(n,a),a;let c=s.get(n);if(c)return c;o(`[Compute/client-cache] miss \u2014 building warm client for server ${n}`);let h=(async()=>{let d=await u(i,l?.definitionGuid);if(t.size>=r){let p=t.keys().next().value;p!==void 0&&(o(`[Compute/client-cache] LRU evicted warm client for server ${p} (cap ${r})`),t.get(p)?.scheduler.dispose(),t.delete(p))}return t.set(n,d),d})().finally(()=>s.delete(n));return s.set(n,h),h},evict(i){let l=i,n=t.get(l);n&&(o(`[Compute/client-cache] evicted warm client for server ${l} (config change)`),n.scheduler.dispose(),t.delete(l))},solveCacheStats(){let i={warmClients:t.size,entries:0,bytes:0,hits:0,misses:0,evictions:0};for(let l of t.values()){let n=l.scheduler.cacheStats();i.entries+=n.entries,i.bytes+=n.bytes,i.hits+=n.hits,i.misses+=n.misses,i.evictions+=n.evictions}return i},clearSolveCaches(){o(`[Compute/client-cache] cleared solve caches on ${t.size} warm client(s)`);for(let i of t.values())i.scheduler.clearCache()},disposeAll(){o(`[Compute/client-cache] disposing all ${t.size} warm client(s)`);for(let i of t.values())i.scheduler.dispose();t.clear()}}}function H(e){let r=Math.max(0,Math.floor(e)),t=new Map,s=0,o={hits:0,misses:0,evictions:0};function u(n,a){t.delete(n),t.set(n,a)}function i(){for(;s>r&&t.size>0;){let n=t.keys().next().value,a=t.get(n);t.delete(n),s-=a.bytes.byteLength,o.evictions+=1}}function l(n,a){if(r===0||a.byteLength>r)return;let c=t.get(n);c&&(s-=c.bytes.byteLength),t.set(n,{bytes:a}),s+=a.byteLength,i()}return{getOrLoad(n,a){let c={loaded:!1,fromCache:!1};return{key:n,outcome:c,load:async()=>{let h=t.get(n);if(h)return u(n,h),o.hits+=1,c.loaded=!0,c.fromCache=!0,h.bytes;o.misses+=1,c.loaded=!0,c.fromCache=!1;let d=await a();return l(n,d),d}}},stats(){return{hits:o.hits,misses:o.misses,evictions:o.evictions,entries:t.size,bytes:s}},clear(){t.clear(),s=0}}}function W(e={}){let r=new Map;return{run(t,s,o){let u=r.get(t);if(u)return e.onJoin?.(t),u.notifyOwner?.(),u.promise;let i={notifyOwner:o,promise:void 0},l=(async()=>s())().finally(()=>{i.notifyOwner=void 0,r.get(t)===i&&r.delete(t)});return i.promise=l,r.set(t,i),l},inFlight(){return r.size}}}export{P as COMPUTE_CONTRACT_VERSION,E as COMPUTE_VERSION_HEADER,F as adaptEnvelopeToEncoding,B as buildSolveInputTree,j as createClientCache,H as createDefinitionByteCache,W as createSolveCacheSingleFlight,D as runSolvePipeline,V as serverIdentity,T as transformInputParameter};
+import{ErrorCodes as I,RhinoComputeError as U,TreeBuilder as q}from"@selvajs/compute";import{gzip as W,gunzipSync as G}from"zlib";import{promisify as N}from"util";import{processInput as $}from"@selvajs/compute";function A(e,n){let t={id:e.id,name:e.nickname,nickname:e.nickname||null,description:e.description||"",paramType:e.paramType==="dynamicValueList"?"valueList":e.paramType,treeAccess:e.inputStructure==="tree",minimum:e.minimum??null,maximum:e.maximum??null,atLeast:1,atMost:1,stepSize:e.stepSize,default:n??e.default},r=$(t),o=n??e.default;return r.default==null&&o!=null&&(Array.isArray(o)||r.paramType==="ValueList"&&typeof o!="object")&&(r.default=o),r}var j=N(W),F=1,_="X-Selva-Compute-Version";function E(e,n){return q.fromInputParams(e.filter(t=>t.paramType).map(t=>A(t,n[t.id])))}async function B(e){let{client:n,signal:t}=e,r=performance.now(),o=e.inputTree??E(e.inputs,e.values),c=performance.now()-r,s=n.solveMeta.seq,m=n.rhinoTiming.seq,i,l=performance.now();try{i=await n.scheduler.solve(e.definitionSource,o,{signal:t})}catch(v){let x=performance.now()-l;if(v instanceof Error&&v.name==="AbortError")return t.aborted?{kind:"client_abort",durationMs:x}:{kind:"timeout",durationMs:x,message:`Solve exceeded the ${Math.round(e.maxSolveDurationMs/1e3)}s deadline.`};if(v instanceof U){if(v.code===I.QUEUE_FULL)return{kind:"shed",durationMs:x,reason:"queue_full",retryAfterSeconds:1,message:"Compute server is at capacity. Retry shortly."};if(v.code===I.QUEUE_TIMEOUT)return{kind:"shed",durationMs:x,reason:"queue_timeout",retryAfterSeconds:1,message:"Compute request waited too long in the queue. Retry shortly."}}return{kind:"compute_error",durationMs:x,error:v}}let d=performance.now()-l,h=performance.now(),a;try{a=JSON.stringify(i)}catch(v){if(v instanceof RangeError)return{kind:"too_large"};throw v}if(a.length>e.responseMaxBytes)return{kind:"too_large"};let p=performance.now()-h,M=/\bgzip\b/i.test(e.acceptEncoding)&&a.length>1024,C=null,S=0;if(M){let v=performance.now();C=await j(Buffer.from(a)),S=performance.now()-v}let y=performance.now()-e.loadStartMs,u=n.solveMeta.seq===s+1?n.solveMeta.last:null,f=u&&!u.fromCache&&n.rhinoTiming.seq===m+1?n.rhinoTiming.last:null,g={"Content-Type":"application/json","Server-Timing":V({defLoadMs:e.defLoadMs,treeBuildMs:c,solveMs:d,serializeMs:p,gzipMs:S,serverTotalMs:y,rhino:f,settle:u,byteRefOutcome:e.byteRefOutcome,prepMarks:e.prepMarks??[]}),[_]:String(F),Vary:"Accept-Encoding"},R={treeBuildMs:c,solveMs:d,serializeMs:p,gzipMs:S,serverTotalMs:y,serializedBytes:a.length,compressedBytes:C?.byteLength??null},D;return C?(g["Content-Encoding"]="gzip",g["Content-Length"]=String(C.byteLength),D={body:new Uint8Array(C),encoding:"gzip",headers:g,result:i,metrics:R}):(g["Content-Length"]=String(Buffer.byteLength(a)),D={body:a,headers:g,result:i,metrics:R}),{kind:"ok",envelope:D,solveMs:d,errorCount:i.errors?.length??0,warningCount:i.warnings?.length??0}}function T(e,n){let t=/\bgzip\b/i.test(n);if(e.encoding==="gzip"&&!t){let r=G(e.body instanceof Uint8Array?e.body:Buffer.from(e.body)).toString("utf8"),o={...e.headers};return delete o["Content-Encoding"],o["Content-Length"]=String(Buffer.byteLength(r)),{body:r,headers:o}}return{body:e.body,headers:e.headers}}function V(e){let n=`load;dur=${e.defLoadMs.toFixed(1)}, tree;dur=${e.treeBuildMs.toFixed(1)}, solve;dur=${e.solveMs.toFixed(1)}, serialize;dur=${e.serializeMs.toFixed(1)}, gzip;dur=${e.gzipMs.toFixed(1)}, total;dur=${e.serverTotalMs.toFixed(1)}`,t=e.rhino;if(t){let c=t.decode+t.solve+t.encode,s=Math.max(0,e.solveMs-c);n+=`, rhino_decode;dur=${t.decode.toFixed(1)}, rhino_solve;dur=${t.solve.toFixed(1)}, rhino_encode;dur=${t.encode.toFixed(1)}, compute_link;dur=${s.toFixed(1)}`}for(let[c,s]of e.prepMarks)n+=`, p_${c};dur=${s.toFixed(1)}`;let r=e.settle;r&&(n+=`, selva_cache;dur=${r.fromCache?1:0}`,r.definitionReuploaded!==void 0&&(n+=`, def_reupload;dur=${r.definitionReuploaded?1:0}`));let o=e.byteRefOutcome;if(o){let c=o.loaded?o.fromCache?"hit":"miss":"skipped";n+=`, def_bytes;desc=${c}`}return n}import{GrasshopperClient as K,enableDebugLogging as Q}from"@selvajs/compute";function H(e){return e.id}var J=16,z=1,X=300*1e3;function k(e){let n=e.maxWarmComputeServers??J,t=new Map,r=new Map;e.debug==="verbose"&&Q();let o=s=>{e.debug&&e.onDebugLog?.(s)};async function c(s,m){let i={last:null,seq:0},l={last:null,seq:0},d=e.debug==="verbose",h={serverUrl:s.serverUrl,apiKey:s.apiKey,debug:d,cachesolve:e.cachesolve,cacheerroredsolves:e.cacheerroredsolves,onServerTiming:y=>{let u=y.decode??0,f=y.solve??0,b=y.encode??0;if(i.seq+=1,i.last={decode:u,solve:f,encode:b},!e.debug)return;let g=u<=1?"HIT (definition reused, no re-upload/parse)":"miss (full parse)",R=e.cachesolve&&f<=1?"HIT (cached result, solve skipped)":e.cachesolve?"miss (solved fresh)":"off";o(`[Compute/rhino-cache] decode=${u}ms solve=${f}ms encode=${b}ms | definition-cache: ${g} | solve-cache (cachesolve): ${R}`)}};m&&(h.headers={"X-Selva-Definition":m});let a=await K.create(h),p=z,w=0,M=!1;async function C(y){if(!M){M=!0;try{let u=await Promise.resolve(a.serverStats?.getActiveChildren({initialize:!1})).catch(()=>null);w=Date.now();let f=!u||u<=0?z:u;if(f===p)return;o(`[Compute/client-cache] concurrency ${p} \u2192 ${f} (server child count)`),p=f,y?.setMaxConcurrent(f)}finally{M=!1}}}await C();let S=a.createScheduler({mode:"queue",maxConcurrent:p,maxQueueDepth:e.maxQueueDepth||void 0,queueWaitMs:e.queueWaitMs||void 0,timeoutMs:e.maxSolveDurationMs,cache:e.responseCacheMaxBytes>0?{maxBytes:e.responseCacheMaxBytes}:!1,reuseServerDefinitionCache:e.reuseServerDefinitionCache,onSettle:(y,u)=>{if(l.seq+=1,u.status==="success"&&(u.fromCache!==!0&&Date.now()-w>=X&&C(S),l.last={fromCache:u.fromCache===!0,definitionReuploaded:u.definitionReuploaded},!!e.debug&&(o(`[Compute/selva-cache] ${u.fromCache?"HIT  \u2014 served from cache (no compute call)":"miss \u2014 went to Rhino.Compute"} (${Math.round(u.durationMs)}ms)`),u.fromCache||o(u.definitionReuploaded===!0?"[Compute/def-cache] miss \u2014 definition RE-UPLOADED (pointer was cold/stale)":u.definitionReuploaded===!1?"[Compute/def-cache] HIT  \u2014 definition reused from server cache (no upload)":"[Compute/def-cache] n/a \u2014 reuse disabled or non-reusable definition"),!u.fromCache))){let f=u.response?.errors,b=Array.isArray(f)?f.length:0;if(b>0){let g=e.cacheerroredsolves?"cached (cacheerroredsolves on)":"not cached (cacheerroredsolves off) \u2014 re-run until fixed";o(`[Compute/rhino-cache] ${b} GH error(s); ${g}. First: ${JSON.stringify(f[0])}`)}}}});return{client:a,scheduler:S,rhinoTiming:i,solveMeta:l}}return{async getClient(s,m){let i=s.id,l=t.get(i);if(l)return t.delete(i),t.set(i,l),l;let d=r.get(i);if(d)return d;o(`[Compute/client-cache] miss \u2014 building warm client for server ${i}`);let h=(async()=>{let a=await c(s,m?.definitionGuid);if(t.size>=n){let p=t.keys().next().value;p!==void 0&&(o(`[Compute/client-cache] LRU evicted warm client for server ${p} (cap ${n})`),t.get(p)?.scheduler.dispose(),t.delete(p))}return t.set(i,a),a})().finally(()=>r.delete(i));return r.set(i,h),h},evict(s){let m=s,i=t.get(m);i&&(o(`[Compute/client-cache] evicted warm client for server ${m} (config change)`),i.scheduler.dispose(),t.delete(m))},solveCacheStats(){let s={warmClients:t.size,entries:0,bytes:0,hits:0,misses:0,evictions:0};for(let m of t.values()){let i=m.scheduler.cacheStats();s.entries+=i.entries,s.bytes+=i.bytes,s.hits+=i.hits,s.misses+=i.misses,s.evictions+=i.evictions}return s},clearSolveCaches(){o(`[Compute/client-cache] cleared solve caches on ${t.size} warm client(s)`);for(let s of t.values())s.scheduler.clearCache()},disposeAll(){o(`[Compute/client-cache] disposing all ${t.size} warm client(s)`);for(let s of t.values())s.scheduler.dispose();t.clear()}}}function P(e){let n=Math.max(0,Math.floor(e)),t=new Map,r=0,o={hits:0,misses:0,evictions:0};function c(i,l){t.delete(i),t.set(i,l)}function s(){for(;r>n&&t.size>0;){let i=t.keys().next().value,l=t.get(i);t.delete(i),r-=l.bytes.byteLength,o.evictions+=1}}function m(i,l){if(n===0||l.byteLength>n)return;let d=t.get(i);d&&(r-=d.bytes.byteLength),t.set(i,{bytes:l}),r+=l.byteLength,s()}return{getOrLoad(i,l){let d={loaded:!1,fromCache:!1};return{key:i,outcome:d,load:async()=>{let h=t.get(i);if(h)return c(i,h),o.hits+=1,d.loaded=!0,d.fromCache=!0,h.bytes;o.misses+=1,d.loaded=!0,d.fromCache=!1;let a=await l();return m(i,a),a}}},stats(){return{hits:o.hits,misses:o.misses,evictions:o.evictions,entries:t.size,bytes:r}},clear(){t.clear(),r=0}}}function O(e={}){let n=new Map;return{run(t,r,o){let c=n.get(t);if(c)return e.onJoin?.(t),c.notifyOwner?.(),c.promise;let s={notifyOwner:o,promise:void 0},m=(async()=>r())().finally(()=>{s.notifyOwner=void 0,n.get(t)===s&&n.delete(t)});return s.promise=m,n.set(t,s),m},inFlight(){return n.size}}}import{isDefinitionRef as Y,stableStringify as Z}from"@selvajs/compute";import{NoopLogger as ee}from"@selvajs/platform";function te(e){return typeof e=="object"&&e!==null&&!(e instanceof Uint8Array)&&"outcome"in e}function ne(e){return typeof e=="object"&&e!==null&&!(e instanceof Uint8Array)&&!("outcome"in e)&&!("key"in e)&&"versionId"in e}var L=class{limits;clientCache;byteCache;singleFlight;constructor(n){this.limits=n.limits;let t=n.logger??new ee;this.clientCache=k({maxSolveDurationMs:this.limits.maxSolveDurationMs,cachesolve:this.limits.computeServerCachesolve,cacheerroredsolves:this.limits.computeCacheErroredSolves,reuseServerDefinitionCache:this.limits.computeReuseDefinitionCache,maxQueueDepth:this.limits.computeMaxQueueDepth,queueWaitMs:this.limits.computeQueueWaitMs,responseCacheMaxBytes:this.limits.computeSolveCacheBytes,debug:n.debug??!1,maxWarmComputeServers:n.maxWarmComputeServers,onDebugLog:n.onDebugLog??(r=>t.debug(r,{component:"Compute/client-cache"}))}),this.byteCache=P(this.limits.computeDefinitionCacheBytes),this.singleFlight=O({onJoin:n.onSolveCoalesced})}getClient(n,t){return this.clientCache.getClient(n,t)}definitionRef(n,t){return this.byteCache.getOrLoad(n,t)}evictServer(n){this.clientCache.evict(n)}clearSolveCaches(){this.clientCache.clearSolveCaches()}stats(){return{client:this.clientCache.solveCacheStats(),definitionBytes:this.byteCache.stats(),coalescing:{inFlight:this.singleFlight.inFlight()}}}async solve(n){let{definitionSource:t,byteRefOutcome:r,identity:o}=this.resolveDefinitionSource(n),c=await this.clientCache.getClient(n.server,{definitionGuid:n.definitionGuid}),s=E(n.inputs,n.values),m=`${o}:${n.server.id}:${Z(s)}`,i=new AbortController,l=!1,d=()=>{l||i.abort()};n.signal.addEventListener("abort",d,{once:!0});let h=n.acceptEncoding??"",a;try{a=await this.singleFlight.run(m,()=>B({definitionSource:t,byteRefOutcome:r,inputs:n.inputs,values:n.values,inputTree:s,client:c,responseMaxBytes:this.limits.computeResponseMaxBytes,maxSolveDurationMs:this.limits.maxSolveDurationMs,acceptEncoding:h,signal:i.signal,loadStartMs:n.loadStartMs??performance.now(),defLoadMs:n.defLoadMs??0,prepMarks:n.prepMarks}),()=>{l=!0})}finally{n.signal.removeEventListener("abort",d)}if(a.kind!=="ok")return a;let p=T(a.envelope,h);return{...a,envelope:{...a.envelope,body:p.body,headers:p.headers}}}toResponse(n,t){let r=(o,c)=>{t?.onError&&t.onError(o,c);let s={"Content-Type":"application/json"};return c.retryAfter!==void 0&&(s["Retry-After"]=String(c.retryAfter)),{status:o,headers:s,body:JSON.stringify(c)}};switch(n.kind){case"ok":return{status:200,headers:n.envelope.headers,body:n.envelope.body};case"timeout":return r(504,{message:n.message});case"client_abort":return r(499,{message:"Client closed request"});case"too_large":return r(413,{message:"Solve result is too large to return. This usually means a file output exceeds the supported size."});case"shed":return r(503,{message:n.message,retryAfter:n.retryAfterSeconds});case"compute_error":throw n.error}}toWebResponse(n){let t=this.toResponse(n);return new Response(typeof t.body=="string"?t.body:new Uint8Array(t.body),{status:t.status,headers:t.headers})}resolveDefinitionSource(n){let t=n.definitionSource;if(ne(t)){let r=this.byteCache.getOrLoad(t.versionId,t.load);return{definitionSource:r,byteRefOutcome:r.outcome,identity:r.key}}if(te(t))return{definitionSource:t,byteRefOutcome:t.outcome,identity:t.key};if(Y(t))return{definitionSource:t,identity:t.key};if(!n.definitionKey)throw new Error("SolveEngine.solve(): definitionKey is required when definitionSource is raw bytes or a string.");return{definitionSource:t,identity:n.definitionKey}}};import{isDefinitionRef as Te}from"@selvajs/compute";export{F as COMPUTE_CONTRACT_VERSION,_ as COMPUTE_VERSION_HEADER,L as SolveEngine,T as adaptEnvelopeToEncoding,E as buildSolveInputTree,k as createClientCache,P as createDefinitionByteCache,O as createSolveCacheSingleFlight,Te as isDefinitionRef,B as runSolvePipeline,H as serverIdentity,A as transformInputParameter};
 //# sourceMappingURL=server.js.map