@selvajs/selva 4.6.21-beta.0 → 4.7.0-beta.2

package/build/server/chunks/entries/endpoints/api/compute/{_server.ts.js-DkyT3FO6.js → _server.ts.js-D9qvgnX7.js}

@@ -1,49 +1,217 @@
-import { a as apiError, A as ApiErrorCode, r as resolveServerForOrg, f as fetchSchemaFromCompute, C as ComputeServerUnconfiguredError } from '../../../../chunks/api-errors.js-yRMzxqNi.js';
+import { a as apiError, A as ApiErrorCode, r as resolveServerForOrg, f as fetchSchemaFromCompute, C as ComputeServerUnconfiguredError } from '../../../../chunks/api-errors.js-DlfcfPJs.js';
 import { isHttpError } from '@sveltejs/kit';
-import { g as getClient, C as COMPUTE_DEBUG } from '../../../../chunks/clientCache.server.js-nl8vnalG.js';
+import { g as getClient, C as COMPUTE_DEBUG } from '../../../../chunks/clientCache.server.js-BS8-NdiI.js';
+import { r as runSolvePipeline } from '../../../../chunks/solve-cache-key.js-BIwJfBG9.js';
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
-import { f as MAX_SOLVE_DURATION_MS, C as COMPUTE_RESPONSE_MAX_BYTES, D as DEFINITION_CACHE_TTL_MS, R as REMOTE_DEFINITION_FETCH_TIMEOUT_MS, a as REMOTE_DEFINITION_MAX_BYTES, d as RATE_LIMIT_MAX_REQUESTS, e as RATE_LIMIT_WINDOW_MS, b as COMPUTE_REQUEST_MAX_BYTES } from '../../../../chunks/computeLimits.js-C5c7HPGJ.js';
-import { TreeBuilder, processInput } from '@selvajs/compute';
-import { gzipSync } from 'node:zlib';
-import { h as requireMaxBodySize } from '../../../../chunks/admin-auth.server.js-hCWF6Pqg.js';
-import { s as getStorageProvider, v as getSolveMetricSink, p as providers } from '../../../../chunks/providers.server.js-D0hpk-aq.js';
-import { i as requireCanEditDefinition, j as requireCanSolve } from '../../../../chunks/access.server.js-D99g5hZd.js';
-import { t as tryResolveShareToken } from '../../../../chunks/resolve.server.js-CtUK_9yC.js';
-import '../../../../chunks/context.js-D8E0GFTw.js';
+import { f as MAX_SOLVE_DURATION_MS, C as COMPUTE_RESPONSE_MAX_BYTES, S as SOLVE_CACHE_DEFAULT_MAX_ENTRIES, m as SOLVE_CACHE_PROVIDER, D as DEFINITION_CACHE_TTL_MS, R as REMOTE_DEFINITION_FETCH_TIMEOUT_MS, a as REMOTE_DEFINITION_MAX_BYTES, n as COMPUTE_DEFINITION_BYTE_CACHE_BYTES, o as SOLVE_CACHE_MAX_TOTAL_BYTES, d as RATE_LIMIT_MAX_REQUESTS, e as RATE_LIMIT_WINDOW_MS, b as COMPUTE_REQUEST_MAX_BYTES } from '../../../../chunks/computeLimits.js-CQh4jXlX.js';
+import '../../../../chunks/context.js-DsQGiS2x.js';
+import { stableStringify } from '@selvajs/compute';
+import { f as requireMaxBodySize, h as createComputeRateLimiter } from '../../../../chunks/admin-auth.server.js-CitjWnKM.js';
+import { t as getStorageProvider, x as getSolveMetricSink, p as providers } from '../../../../chunks/providers.server.js-CIHOepKv.js';
+import { i as requireCanEditDefinition, j as requireCanSolve } from '../../../../chunks/access.server.js-_nJWuQcN.js';
+import { t as tryResolveShareToken } from '../../../../chunks/resolve.server.js-Dg1o2vnd.js';
 import '@selvajs/compute/core';
 import '../../../../chunks/schema.js-j3D3emog.js';
-import '../../../../chunks/utils4.js-BRotGwxx.js';
+import '../../../../chunks/utils4.js-8SHxuGTr.js';
 import '../../../../chunks/shared-server.js-DaWdgxVh.js';
+import 'node:crypto';
+import 'node:zlib';
+import 'node:util';
+import 'zod';
 import 'node:url';
 import 'node:path';
 import 'node:fs';
-import 'node:crypto';
 import 'node:fs/promises';
 import '@supabase/supabase-js';
-import 'zod';
-import '../../../../chunks/token2.server.js-Cqw1dJj-.js';
+import '../../../../chunks/token2.server.js-Cjb4XaWC.js';
+import '../../../../chunks/token-codec.js-1RPNe2RW.js';
 
-function createComputeRateLimiter(config) {
-  const { windowMs, maxPerWindow } = config;
-  const buckets = /* @__PURE__ */ new Map();
+class NoopSolveResultCache {
+  async get(_ctx, _key) {
+    return null;
+  }
+  async set(_ctx, _key, _bytes, _opts) {
+  }
+}
+function createDefinitionByteCache(maxBytes) {
+  const budget = Math.max(0, Math.floor(maxBytes));
+  const cache2 = /* @__PURE__ */ new Map();
+  let retainedBytes = 0;
+  const stats = { hits: 0, misses: 0, evictions: 0 };
+  function touch(key, entry) {
+    cache2.delete(key);
+    cache2.set(key, entry);
+  }
+  function evictToFit() {
+    while (retainedBytes > budget && cache2.size > 0) {
+      const oldestKey = cache2.keys().next().value;
+      const oldest = cache2.get(oldestKey);
+      cache2.delete(oldestKey);
+      retainedBytes -= oldest.bytes.byteLength;
+      stats.evictions += 1;
+    }
+  }
+  function store(key, bytes) {
+    if (budget === 0) return;
+    if (bytes.byteLength > budget) return;
+    const existing = cache2.get(key);
+    if (existing) retainedBytes -= existing.bytes.byteLength;
+    cache2.set(key, { bytes });
+    retainedBytes += bytes.byteLength;
+    evictToFit();
+  }
   return {
-    config,
-    check(key) {
-      const now = Date.now();
-      const entry = buckets.get(key);
-      if (!entry || now > entry.resetAt) {
-        buckets.set(key, { count: 1, resetAt: now + windowMs });
-        return { allowed: true };
-      }
-      if (entry.count >= maxPerWindow) {
-        return { allowed: false, retryAfter: Math.ceil((entry.resetAt - now) / 1e3) };
+    getOrLoad(versionId, load) {
+      const outcome = { loaded: false, fromCache: false };
+      return {
+        key: versionId,
+        outcome,
+        load: async () => {
+          const hit = cache2.get(versionId);
+          if (hit) {
+            touch(versionId, hit);
+            stats.hits += 1;
+            outcome.loaded = true;
+            outcome.fromCache = true;
+            return hit.bytes;
+          }
+          stats.misses += 1;
+          outcome.loaded = true;
+          outcome.fromCache = false;
+          const bytes = await load();
+          store(versionId, bytes);
+          return bytes;
+        }
+      };
+    },
+    stats() {
+      return {
+        hits: stats.hits,
+        misses: stats.misses,
+        evictions: stats.evictions,
+        entries: cache2.size,
+        bytes: retainedBytes
+      };
+    },
+    clear() {
+      cache2.clear();
+      retainedBytes = 0;
+    }
+  };
+}
+function createMemorySolveResultCache(maxTotalBytes) {
+  const byteBudget = Math.max(0, Math.floor(maxTotalBytes));
+  const cache2 = /* @__PURE__ */ new Map();
+  const byDefinition = /* @__PURE__ */ new Map();
+  let retainedBytes = 0;
+  const stats = { hits: 0, misses: 0, writes: 0, quotaEvictions: 0, byteEvictions: 0 };
+  function storageKey(key) {
+    return `${key.orgId}\0${key.definitionId}\0${key.versionId}\0${key.inputKey}`;
+  }
+  function defList(definitionId) {
+    let list = byDefinition.get(definitionId);
+    if (!list) {
+      list = [];
+      byDefinition.set(definitionId, list);
+    }
+    return list;
+  }
+  function removeFromDefList(definitionId, k) {
+    const list = byDefinition.get(definitionId);
+    if (!list) return;
+    const i = list.indexOf(k);
+    if (i !== -1) list.splice(i, 1);
+    if (list.length === 0) byDefinition.delete(definitionId);
+  }
+  function drop(k) {
+    const entry = cache2.get(k);
+    if (!entry) return;
+    cache2.delete(k);
+    retainedBytes -= entry.bytes.byteLength;
+    removeFromDefList(entry.definitionId, k);
+  }
+  function touch(k, entry) {
+    cache2.delete(k);
+    cache2.set(k, entry);
+    const list = defList(entry.definitionId);
+    const i = list.indexOf(k);
+    if (i !== -1) list.splice(i, 1);
+    list.push(k);
+  }
+  function evictQuota(definitionId, maxEntries) {
+    const list = defList(definitionId);
+    while (list.length > maxEntries) {
+      const oldest = list[0];
+      drop(oldest);
+      stats.quotaEvictions += 1;
+    }
+  }
+  function evictByteBackstop() {
+    if (byteBudget === 0) return;
+    while (retainedBytes > byteBudget && cache2.size > 0) {
+      const oldestKey = cache2.keys().next().value;
+      drop(oldestKey);
+      stats.byteEvictions += 1;
+    }
+  }
+  return {
+    async get(_ctx, key) {
+      const k = storageKey(key);
+      const entry = cache2.get(k);
+      if (!entry) {
+        stats.misses += 1;
+        return null;
       }
-      entry.count += 1;
-      return { allowed: true };
+      touch(k, entry);
+      stats.hits += 1;
+      return entry.bytes;
+    },
+    async set(_ctx, key, bytes, opts) {
+      const maxEntries = Math.max(0, Math.floor(opts.maxEntriesForDefinition));
+      if (maxEntries === 0) return;
+      const k = storageKey(key);
+      drop(k);
+      const entry = { bytes, definitionId: key.definitionId };
+      cache2.set(k, entry);
+      defList(key.definitionId).push(k);
+      retainedBytes += bytes.byteLength;
+      stats.writes += 1;
+      evictQuota(key.definitionId, maxEntries);
+      evictByteBackstop();
     },
-    reset() {
-      buckets.clear();
+    stats() {
+      return {
+        hits: stats.hits,
+        misses: stats.misses,
+        writes: stats.writes,
+        quotaEvictions: stats.quotaEvictions,
+        byteEvictions: stats.byteEvictions,
+        entries: cache2.size,
+        bytes: retainedBytes
+      };
+    },
+    clear() {
+      cache2.clear();
+      byDefinition.clear();
+      retainedBytes = 0;
+    }
+  };
+}
+function createSolveCacheSingleFlight() {
+  const inflight = /* @__PURE__ */ new Map();
+  return {
+    run(key, work) {
+      const existing = inflight.get(key);
+      if (existing) return existing;
+      const p = (async () => work())().finally(() => {
+        if (inflight.get(key) === p) inflight.delete(key);
+      });
+      inflight.set(key, p);
+      return p;
+    },
+    inFlight() {
+      return inflight.size;
     }
   };
 }
@@ -151,35 +319,6 @@ async function assertSafeRemoteDefinitionUrl(raw) {
   }
   return raw;
 }
-function transformInputParameter(input, value) {
-  const raw = {
-    id: input.id,
-    name: input.nickname,
-    nickname: input.nickname || null,
-    description: input.description || "",
-    // Dynamic value lists ride the ValueList contract on the wire — the plugin's
-    // GetDynamicValueListParameter deliberately reuses TypeName "ValueList" so the
-    // compute fork's existing ValueList input case assigns it. processInput has no
-    // dynamicValueList handler; without this mapping it falls back to Geometry with
-    // a null default and TreeBuilder DROPS the input, so the user's selection never
-    // reaches the definition (the param then solves on its own stale fallback).
-    paramType: input.paramType === "dynamicValueList" ? "valueList" : input.paramType,
-    treeAccess: input.inputStructure === "tree",
-    minimum: input.minimum ?? null,
-    maximum: input.maximum ?? null,
-    atLeast: 1,
-    atMost: 1,
-    stepSize: input.stepSize,
-    // The user's selection wins; otherwise the schema default.
-    default: value ?? input.default
-  };
-  const processed = processInput(raw);
-  const effective = value ?? input.default;
-  if (Array.isArray(effective) && processed.default == null) {
-    processed.default = effective;
-  }
-  return processed;
-}
 const CACHE_MAX_ENTRIES = 50;
 const CACHE_EVICT_BATCH = 10;
 async function readBodyWithCap(response, maxBytes, controller) {
@@ -210,12 +349,12 @@ async function readBodyWithCap(response, maxBytes, controller) {
   return out;
 }
 function createRemoteDefinitionFetcher(config) {
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
   return {
     async load(url) {
       await assertSafeRemoteDefinitionUrl(url);
       const now = config.now();
-      const cached = cache.get(url);
+      const cached = cache2.get(url);
       if (cached && now - cached.fetchedAt < config.cacheTtlMs) {
         return cached.data;
       }
@@ -238,128 +377,18 @@ function createRemoteDefinitionFetcher(config) {
       } finally {
         clearTimeout(timeout);
       }
-      cache.set(url, { data, fetchedAt: now });
-      if (cache.size > CACHE_MAX_ENTRIES) {
-        const entries = Array.from(cache.entries());
+      cache2.set(url, { data, fetchedAt: now });
+      if (cache2.size > CACHE_MAX_ENTRIES) {
+        const entries = Array.from(cache2.entries());
         entries.sort((a, b) => a[1].fetchedAt - b[1].fetchedAt);
         for (let i = 0; i < CACHE_EVICT_BATCH; i++) {
-          cache.delete(entries[i][0]);
+          cache2.delete(entries[i][0]);
         }
       }
       return data;
     }
   };
 }
-const COMPUTE_CONTRACT_VERSION = 1;
-const COMPUTE_VERSION_HEADER = "X-Selva-Compute-Version";
-async function runSolvePipeline(args) {
-  const { client, signal } = args;
-  const treeBuildStart = performance.now();
-  const inputTree = TreeBuilder.fromInputParams(
-    args.inputs.filter((input) => input.paramType).map((input) => transformInputParameter(input, args.values[input.id]))
-  );
-  const treeBuildMs = performance.now() - treeBuildStart;
-  client.rhinoTiming.last = null;
-  client.solveMeta.last = null;
-  let result;
-  const solveStart = performance.now();
-  try {
-    result = await client.scheduler.solve(args.definitionSource, inputTree, { signal });
-  } catch (err) {
-    const durationMs = performance.now() - solveStart;
-    const isAbort = err instanceof Error && err.name === "AbortError";
-    if (isAbort) {
-      if (signal.aborted) return { kind: "client_abort", durationMs };
-      return {
-        kind: "timeout",
-        durationMs,
-        message: `Solve exceeded the ${Math.round(args.maxSolveDurationMs / 1e3)}s deadline.`
-      };
-    }
-    return { kind: "compute_error", durationMs, error: err };
-  }
-  const solveMs = performance.now() - solveStart;
-  const serializeStart = performance.now();
-  let serialized;
-  try {
-    serialized = JSON.stringify(result);
-  } catch (err) {
-    if (err instanceof RangeError) return { kind: "too_large" };
-    throw err;
-  }
-  if (serialized.length > args.responseMaxBytes) return { kind: "too_large" };
-  const serializeMs = performance.now() - serializeStart;
-  let compressed = null;
-  let gzipMs = 0;
-  if (/\bgzip\b/i.test(args.acceptEncoding) && serialized.length > 1024) {
-    const gzipStart = performance.now();
-    compressed = gzipSync(Buffer.from(serialized));
-    gzipMs = performance.now() - gzipStart;
-  }
-  const serverTotalMs = performance.now() - args.loadStartMs;
-  const serverTiming = buildServerTiming({
-    defLoadMs: args.defLoadMs,
-    treeBuildMs,
-    solveMs,
-    serializeMs,
-    gzipMs,
-    serverTotalMs,
-    rhino: client.rhinoTiming.last,
-    settle: client.solveMeta.last,
-    prepMarks: args.prepMarks ?? []
-  });
-  const headers = {
-    "Content-Type": "application/json",
-    "Server-Timing": serverTiming,
-    [COMPUTE_VERSION_HEADER]: String(COMPUTE_CONTRACT_VERSION),
-    Vary: "Accept-Encoding"
-  };
-  const metrics = {
-    treeBuildMs,
-    solveMs,
-    serializeMs,
-    gzipMs,
-    serverTotalMs,
-    serializedBytes: serialized.length,
-    compressedBytes: compressed?.byteLength ?? null
-  };
-  let envelope;
-  if (compressed) {
-    headers["Content-Encoding"] = "gzip";
-    headers["Content-Length"] = String(compressed.byteLength);
-    envelope = { body: new Uint8Array(compressed), encoding: "gzip", headers, result, metrics };
-  } else {
-    headers["Content-Length"] = String(Buffer.byteLength(serialized));
-    envelope = { body: serialized, headers, result, metrics };
-  }
-  return {
-    kind: "ok",
-    envelope,
-    solveMs,
-    errorCount: result.errors?.length ?? 0,
-    warningCount: result.warnings?.length ?? 0
-  };
-}
-function buildServerTiming(parts) {
-  let header = `load;dur=${parts.defLoadMs.toFixed(1)}, tree;dur=${parts.treeBuildMs.toFixed(1)}, solve;dur=${parts.solveMs.toFixed(1)}, serialize;dur=${parts.serializeMs.toFixed(1)}, gzip;dur=${parts.gzipMs.toFixed(1)}, total;dur=${parts.serverTotalMs.toFixed(1)}`;
-  const rhino = parts.rhino;
-  if (rhino) {
-    const onRhinoMs = rhino.decode + rhino.solve + rhino.encode;
-    const computeLinkMs = Math.max(0, parts.solveMs - onRhinoMs);
-    header += `, rhino_decode;dur=${rhino.decode.toFixed(1)}, rhino_solve;dur=${rhino.solve.toFixed(1)}, rhino_encode;dur=${rhino.encode.toFixed(1)}, compute_link;dur=${computeLinkMs.toFixed(1)}`;
-  }
-  for (const [label, ms] of parts.prepMarks) {
-    header += `, p_${label};dur=${ms.toFixed(1)}`;
-  }
-  const settle = parts.settle;
-  if (settle) {
-    header += `, selva_cache;dur=${settle.fromCache ? 1 : 0}`;
-    if (settle.definitionReuploaded !== void 0) {
-      header += `, def_reupload;dur=${settle.definitionReuploaded ? 1 : 0}`;
-    }
-  }
-  return header;
-}
 const fetcher = createRemoteDefinitionFetcher({
   maxBytes: REMOTE_DEFINITION_MAX_BYTES,
   fetchTimeoutMs: REMOTE_DEFINITION_FETCH_TIMEOUT_MS,
@@ -369,6 +398,32 @@ const fetcher = createRemoteDefinitionFetcher({
 function loadRemoteDefinition(url) {
   return fetcher.load(url);
 }
+const cache$1 = createDefinitionByteCache(COMPUTE_DEFINITION_BYTE_CACHE_BYTES);
+function definitionRef(versionId, load) {
+  return cache$1.getOrLoad(versionId, load);
+}
+const memoryCache = SOLVE_CACHE_PROVIDER === "memory" ? createMemorySolveResultCache(SOLVE_CACHE_MAX_TOTAL_BYTES) : null;
+const cache = memoryCache ?? new NoopSolveResultCache();
+const solveCacheSingleFlight = createSolveCacheSingleFlight();
+const solveCacheEnabled = memoryCache !== null;
+function resolveSolveCacheQuota(solveCacheLimit) {
+  if (solveCacheLimit === void 0) return SOLVE_CACHE_DEFAULT_MAX_ENTRIES;
+  return Math.max(0, Math.floor(solveCacheLimit));
+}
+function buildSolveCacheHook(params) {
+  if (!solveCacheEnabled || params.quota <= 0 || !params.orgId) return null;
+  const { ctx, orgId, definitionId, versionId, quota, configSubset } = params;
+  return {
+    configSubset,
+    lookup: (inputKey) => cache.get(ctx, { orgId, definitionId, versionId, inputKey }),
+    store: (inputKey, entry) => {
+      void cache.set(ctx, { orgId, definitionId, versionId, inputKey }, entry, {
+        maxEntriesForDefinition: quota
+      }).catch(() => {
+      });
+    }
+  };
+}
 const limiter = createComputeRateLimiter({
   windowMs: RATE_LIMIT_WINDOW_MS,
   maxPerWindow: RATE_LIMIT_MAX_REQUESTS
@@ -413,11 +468,13 @@ const POST = async ({ request, locals, url }) => {
       );
     }
     let definitionSource;
+    let localDefinitionRef = null;
     let localVersionForBackfill = null;
     let solveOrgId = null;
     let definitionPin = null;
     let metricDefinitionId = null;
     let metricVersionId = null;
+    let solveCacheQuota = 0;
     const isLocal = definitionUrl.startsWith("local:");
     const guid = isLocal ? definitionUrl.substring(6) : null;
     const sharedAccess = isLocal && guid && !explicitVersionId ? await tryResolveShareToken(request, url, guid, channel, { requireSolve: true }) : null;
@@ -472,6 +529,7 @@ const POST = async ({ request, locals, url }) => {
       const project = await providers.data.projects.getProject(solveCtx, record.projectId);
       solveOrgId = project?.orgId ?? null;
       definitionPin = record.computeServerId ?? null;
+      solveCacheQuota = resolveSolveCacheQuota(record.solveCacheLimit);
       mark("project");
       if (!sharedAccess) {
         if (channel === "draft" || explicitVersionId) {
@@ -496,14 +554,12 @@ const POST = async ({ request, locals, url }) => {
       metricDefinitionId = guid;
       metricVersionId = version.id;
       mark("version");
-      try {
+      localDefinitionRef = definitionRef(version.id, async () => {
         const bytes = await storage.get(version.fileKey);
         if (!bytes) throw new Error(`Version blob missing: ${version.fileKey}`);
-        definitionSource = bytes;
-      } catch (err) {
-        console.error(`Failed to load local definition blob: ${guid}`, err);
-        apiError(404, ApiErrorCode.NOT_FOUND, `Definition '${guid}' not found`);
-      }
+        return bytes;
+      });
+      definitionSource = localDefinitionRef;
       mark("blob");
     } else {
       try {
@@ -532,10 +588,11 @@ const POST = async ({ request, locals, url }) => {
     }
     const serverConfig = await resolveServerForOrg(solveCtx, solveOrgId, { definitionPin });
     mark("resolveServer");
-    if (localVersionForBackfill && !localVersionForBackfill.hasSchema) {
+    if (localVersionForBackfill && !localVersionForBackfill.hasSchema && localDefinitionRef) {
       const versionId = localVersionForBackfill.id;
       try {
-        const schema = await fetchSchemaFromCompute(definitionSource, serverConfig);
+        const bytes = await localDefinitionRef.load();
+        const schema = await fetchSchemaFromCompute(bytes, serverConfig);
         await providers.data.definitions.setVersionSchema(solveCtx, versionId, schema);
       } catch (err) {
         console.warn(`[API/Compute] Schema backfill failed for version ${versionId}:`, err);
@@ -544,19 +601,38 @@ const POST = async ({ request, locals, url }) => {
     }
     const client = await getClient(serverConfig, { definitionGuid: guid ?? void 0 });
     mark("client");
-    const outcome = await runSolvePipeline({
-      definitionSource,
-      inputs,
-      values,
-      client,
-      responseMaxBytes: COMPUTE_RESPONSE_MAX_BYTES,
-      maxSolveDurationMs: MAX_SOLVE_DURATION_MS,
-      acceptEncoding: request.headers.get("accept-encoding") ?? "",
-      signal: request.signal,
-      loadStartMs: loadStart,
-      defLoadMs,
-      prepMarks
-    });
+    const cacheable = channel === "live" && !explicitVersionId && metricVersionId !== null;
+    const solveCache = cacheable ? buildSolveCacheHook({
+      ctx: solveCtx,
+      orgId: solveOrgId,
+      definitionId: metricDefinitionId,
+      versionId: metricVersionId,
+      quota: solveCacheQuota,
+      // Fold the compute server identity into the key (R8): two servers can
+      // run different Rhino/plugin versions yielding different geometry.
+      configSubset: { computeServerId: serverConfig.id }
+    }) : null;
+    const coalesced = solveCache != null && metricVersionId != null;
+    const coalesceKey = coalesced ? `${solveOrgId}:${metricVersionId}:${stableStringify({ inputs, values })}` : `nocoalesce:${metricVersionId ?? definitionUrl}:${performance.now()}:${Math.round(Math.random() * 1e9)}`;
+    const solveSignal = coalesced ? new AbortController().signal : request.signal;
+    const outcome = await solveCacheSingleFlight.run(
+      coalesceKey,
+      () => runSolvePipeline({
+        definitionSource,
+        byteRefOutcome: localDefinitionRef?.outcome,
+        inputs,
+        values,
+        client,
+        responseMaxBytes: COMPUTE_RESPONSE_MAX_BYTES,
+        maxSolveDurationMs: MAX_SOLVE_DURATION_MS,
+        acceptEncoding: request.headers.get("accept-encoding") ?? "",
+        signal: solveSignal,
+        loadStartMs: loadStart,
+        defLoadMs,
+        prepMarks,
+        solveCache: solveCache ?? void 0
+      })
+    );
     if (outcome.kind === "timeout") {
       recordMetric("timeout", { durationMs: outcome.durationMs });
       apiError(504, ApiErrorCode.INTERNAL, outcome.message);
@@ -573,6 +649,19 @@ const POST = async ({ request, locals, url }) => {
         "Solve result is too large to return. This usually means a file output exceeds the supported size."
       );
     }
+    if (outcome.kind === "shed") {
+      recordMetric("shed", { durationMs: outcome.durationMs });
+      return new Response(
+        JSON.stringify({ message: outcome.message, retryAfter: outcome.retryAfterSeconds }),
+        {
+          status: 503,
+          headers: {
+            "Content-Type": "application/json",
+            "Retry-After": String(outcome.retryAfterSeconds)
+          }
+        }
+      );
+    }
     if (outcome.kind === "compute_error") {
       throw outcome.error;
     }
@@ -625,4 +714,4 @@ const POST = async ({ request, locals, url }) => {
 };
 
 export { POST };
-//# sourceMappingURL=_server.ts.js-DkyT3FO6.js.map
+//# sourceMappingURL=_server.ts.js-D9qvgnX7.js.map