@selvajs/selva 4.7.0-beta.2 → 4.7.0-beta.3

package/build/server/chunks/entries/endpoints/api/compute/_server.ts.js-D9qvgnX7.js

@@ -1,717 +0,0 @@
-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-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, 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-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:fs/promises';
-import '@supabase/supabase-js';
-import '../../../../chunks/token2.server.js-Cjb4XaWC.js';
-import '../../../../chunks/token-codec.js-1RPNe2RW.js';
-
-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 {
-    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;
-      }
-      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();
-    },
-    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;
-    }
-  };
-}
-function isBlockedIp(ip) {
-  let addr = ip.toLowerCase();
-  const mappedDotted = /^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(addr);
-  if (mappedDotted) {
-    addr = mappedDotted[1];
-  } else {
-    const mappedHex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(addr);
-    if (mappedHex) {
-      const hi = parseInt(mappedHex[1], 16);
-      const lo = parseInt(mappedHex[2], 16);
-      addr = [hi >> 8 & 255, hi & 255, lo >> 8 & 255, lo & 255].join(".");
-    }
-  }
-  if (isIP(addr) === 4) {
-    const octets = addr.split(".").map(Number);
-    if (octets.length !== 4 || octets.some((o) => o > 255)) return true;
-    const [a, b] = octets;
-    if (a === 0) return true;
-    if (a === 127) return true;
-    if (a === 10) return true;
-    if (a === 192 && b === 168) return true;
-    if (a === 172 && b >= 16 && b <= 31) return true;
-    if (a === 169 && b === 254) return true;
-    return false;
-  }
-  if (addr === "::1" || addr === "::") return true;
-  if (/^(fc|fd)[0-9a-f]{0,2}:/.test(addr)) return true;
-  if (/^fe[89ab][0-9a-f]:/.test(addr)) return true;
-  return false;
-}
-function canonicalizeNumericIpv4(host) {
-  if (isIP(host) === 4) return host;
-  const rawParts = host.split(".");
-  if (rawParts.length === 0 || rawParts.length > 4) return null;
-  const parseUInt = (s) => {
-    if (s === "") return null;
-    let n;
-    if (/^0x[0-9a-f]+$/i.test(s)) n = parseInt(s, 16);
-    else if (/^0[0-7]+$/.test(s)) n = parseInt(s, 8);
-    else if (/^[0-9]+$/.test(s)) n = parseInt(s, 10);
-    else return null;
-    return Number.isFinite(n) ? n : null;
-  };
-  const nums = rawParts.map(parseUInt);
-  if (nums.some((n) => n === null)) return null;
-  const parts = nums;
-  let value;
-  switch (parts.length) {
-    case 1:
-      value = parts[0];
-      break;
-    case 2:
-      if (parts[0] > 255 || parts[1] > 16777215) return null;
-      value = parts[0] << 24 | parts[1];
-      break;
-    case 3:
-      if (parts[0] > 255 || parts[1] > 255 || parts[2] > 65535) return null;
-      value = parts[0] << 24 | parts[1] << 16 | parts[2];
-      break;
-    default:
-      if (parts.some((p) => p > 255)) return null;
-      value = parts[0] << 24 | parts[1] << 16 | parts[2] << 8 | parts[3];
-  }
-  value = value >>> 0;
-  if (value > 4294967295) return null;
-  return [value >>> 24 & 255, value >>> 16 & 255, value >>> 8 & 255, value & 255].join(
-    "."
-  );
-}
-function isSafeRemoteDefinitionUrl(raw) {
-  let parsed;
-  try {
-    parsed = new URL(raw);
-  } catch {
-    return false;
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
-  let host = parsed.hostname.toLowerCase();
-  if (!host) return false;
-  if (host === "localhost" || host.endsWith(".localhost")) return false;
-  const isBracketed = host.startsWith("[") && host.endsWith("]");
-  if (isBracketed) host = host.slice(1, -1);
-  if (isIP(host) === 6) return !isBlockedIp(host);
-  const canonical = canonicalizeNumericIpv4(host);
-  if (canonical) return !isBlockedIp(canonical);
-  return true;
-}
-async function assertSafeRemoteDefinitionUrl(raw) {
-  if (!isSafeRemoteDefinitionUrl(raw)) {
-    throw new Error("Remote definition URL is not allowed");
-  }
-  const host = new URL(raw).hostname.toLowerCase().replace(/^\[|\]$/g, "");
-  if (isIP(host) !== 0 || canonicalizeNumericIpv4(host)) return raw;
-  let resolved;
-  try {
-    resolved = await lookup(host, { all: true });
-  } catch {
-    throw new Error("Remote definition URL is not allowed");
-  }
-  if (resolved.length === 0 || resolved.some((r) => isBlockedIp(r.address))) {
-    throw new Error("Remote definition URL is not allowed");
-  }
-  return raw;
-}
-const CACHE_MAX_ENTRIES = 50;
-const CACHE_EVICT_BATCH = 10;
-async function readBodyWithCap(response, maxBytes, controller) {
-  if (!response.body) {
-    const buffer = await response.arrayBuffer();
-    if (buffer.byteLength > maxBytes) throw new Error("Remote definition exceeds size limit");
-    return new Uint8Array(buffer);
-  }
-  const reader = response.body.getReader();
-  const chunks = [];
-  let total = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    total += value.byteLength;
-    if (total > maxBytes) {
-      controller.abort();
-      throw new Error("Remote definition exceeds size limit");
-    }
-    chunks.push(value);
-  }
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return out;
-}
-function createRemoteDefinitionFetcher(config) {
-  const cache2 = /* @__PURE__ */ new Map();
-  return {
-    async load(url) {
-      await assertSafeRemoteDefinitionUrl(url);
-      const now = config.now();
-      const cached = cache2.get(url);
-      if (cached && now - cached.fetchedAt < config.cacheTtlMs) {
-        return cached.data;
-      }
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), config.fetchTimeoutMs);
-      let data;
-      try {
-        const response = await fetch(url, {
-          signal: controller.signal,
-          redirect: "error"
-        });
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const declared = Number(response.headers.get("content-length"));
-        if (Number.isFinite(declared) && declared > config.maxBytes) {
-          throw new Error("Remote definition exceeds size limit");
-        }
-        data = await readBodyWithCap(response, config.maxBytes, controller);
-      } finally {
-        clearTimeout(timeout);
-      }
-      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++) {
-          cache2.delete(entries[i][0]);
-        }
-      }
-      return data;
-    }
-  };
-}
-const fetcher = createRemoteDefinitionFetcher({
-  maxBytes: REMOTE_DEFINITION_MAX_BYTES,
-  fetchTimeoutMs: REMOTE_DEFINITION_FETCH_TIMEOUT_MS,
-  cacheTtlMs: DEFINITION_CACHE_TTL_MS,
-  now: () => Date.now()
-});
-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
-});
-function checkComputeRateLimit(key) {
-  return limiter.check(key);
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-const POST = async ({ request, locals, url }) => {
-  const storage = getStorageProvider();
-  requireMaxBodySize(request, COMPUTE_REQUEST_MAX_BYTES);
-  const loadStart = performance.now();
-  const prepMarks = [];
-  let prevMark = performance.now();
-  const mark = (label) => {
-    prepMarks.push([label, performance.now() - prevMark]);
-    prevMark = performance.now();
-  };
-  try {
-    const body = await request.json();
-    mark("body");
-    const { inputs, values } = body;
-    const definitionUrl = body.definitionUrl;
-    const channel = body.channel ?? "live";
-    const explicitVersionId = body.versionId ?? null;
-    if (!inputs || !values || !definitionUrl) {
-      apiError(
-        400,
-        ApiErrorCode.VALIDATION_FAILED,
-        "Missing required fields: inputs, values, or definitionUrl"
-      );
-    }
-    if (channel !== "live" && channel !== "draft") {
-      apiError(
-        400,
-        ApiErrorCode.VALIDATION_FAILED,
-        `Invalid channel: ${channel}. Must be 'live' or 'draft'.`
-      );
-    }
-    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;
-    mark("shareToken");
-    if (!sharedAccess && (!locals.ctx || !locals.user)) {
-      apiError(401, ApiErrorCode.UNAUTHORIZED, "Unauthorized");
-    }
-    const solveCtx = sharedAccess?.ctx ?? locals.ctx;
-    const recordMetric = (failureKind, extra = {}) => {
-      void getSolveMetricSink().record(solveCtx, {
-        definitionUrl,
-        definitionId: metricDefinitionId,
-        versionId: metricVersionId,
-        channel,
-        orgId: solveOrgId,
-        durationMs: extra.durationMs ?? 0,
-        ok: failureKind === "ok",
-        failureKind,
-        errorCount: extra.errorCount ?? 0,
-        warningCount: extra.warningCount ?? 0
-      });
-    };
-    const rateLimitKey = sharedAccess ? `share:${sharedAccess.link.id}` : `user:${locals.user.id}`;
-    const rateLimit = checkComputeRateLimit(rateLimitKey);
-    if (!rateLimit.allowed) {
-      recordMetric("rate_limited");
-      const retryAfter = rateLimit.retryAfter ?? 1;
-      return new Response(
-        JSON.stringify({
-          message: `Too many compute requests. Retry in ${retryAfter}s.`,
-          retryAfter
-        }),
-        {
-          status: 429,
-          headers: {
-            "Content-Type": "application/json",
-            "Retry-After": String(retryAfter)
-          }
-        }
-      );
-    }
-    if (isLocal && guid) {
-      let record;
-      try {
-        record = await providers.data.definitions.get(solveCtx, guid);
-      } catch (err) {
-        console.error(`Failed to load local definition: ${guid}`, err);
-        apiError(404, ApiErrorCode.NOT_FOUND, `Definition '${guid}' not found`);
-      }
-      if (!record) apiError(404, ApiErrorCode.NOT_FOUND, `Definition '${guid}' not found`);
-      mark("defRecord");
-      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) {
-          await requireCanEditDefinition(locals, record.projectId, guid, {
-            project,
-            definition: record
-          });
-        } else {
-          await requireCanSolve(locals, record.projectId, project ?? void 0);
-        }
-      }
-      mark("access");
-      const versionId = explicitVersionId ?? (channel === "live" ? record.liveVersionId : record.draftVersionId);
-      if (!versionId) {
-        apiError(404, ApiErrorCode.NOT_FOUND, `Definition '${guid}' has no ${channel} version yet`);
-      }
-      const version = await providers.data.definitions.getVersion(solveCtx, versionId);
-      if (!version || version.definitionId !== guid) {
-        apiError(404, ApiErrorCode.NOT_FOUND, `Definition '${guid}' version is missing`);
-      }
-      localVersionForBackfill = { id: version.id, hasSchema: version.schema !== void 0 };
-      metricDefinitionId = guid;
-      metricVersionId = version.id;
-      mark("version");
-      localDefinitionRef = definitionRef(version.id, async () => {
-        const bytes = await storage.get(version.fileKey);
-        if (!bytes) throw new Error(`Version blob missing: ${version.fileKey}`);
-        return bytes;
-      });
-      definitionSource = localDefinitionRef;
-      mark("blob");
-    } else {
-      try {
-        definitionSource = await loadRemoteDefinition(definitionUrl);
-      } catch (err) {
-        console.error(`Failed to fetch definition from ${definitionUrl}:`, err);
-        apiError(
-          400,
-          ApiErrorCode.VALIDATION_FAILED,
-          `Failed to load definition: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-      mark("remoteDef");
-    }
-    const defLoadMs = performance.now() - loadStart;
-    if (sharedAccess) {
-      const next = await providers.data.shareLinks.tryIncrementSolveCount(
-        solveCtx,
-        sharedAccess.link.id
-      );
-      if (next === null) {
-        recordMetric("share_cap");
-        apiError(429, ApiErrorCode.INTERNAL, "Share link solve cap reached.");
-      }
-      mark("shareCap");
-    }
-    const serverConfig = await resolveServerForOrg(solveCtx, solveOrgId, { definitionPin });
-    mark("resolveServer");
-    if (localVersionForBackfill && !localVersionForBackfill.hasSchema && localDefinitionRef) {
-      const versionId = localVersionForBackfill.id;
-      try {
-        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);
-      }
-      mark("schemaBackfill");
-    }
-    const client = await getClient(serverConfig, { definitionGuid: guid ?? void 0 });
-    mark("client");
-    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);
-    }
-    if (outcome.kind === "client_abort") {
-      recordMetric("client_abort", { durationMs: outcome.durationMs });
-      apiError(499, ApiErrorCode.INTERNAL, "Client closed request");
-    }
-    if (outcome.kind === "too_large") {
-      recordMetric("too_large");
-      apiError(
-        413,
-        ApiErrorCode.INTERNAL,
-        "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;
-    }
-    recordMetric("ok", {
-      durationMs: outcome.solveMs,
-      errorCount: outcome.errorCount,
-      warningCount: outcome.warningCount
-    });
-    if (metricDefinitionId) {
-      providers.data.definitions.incrementSolveCount(solveCtx, metricDefinitionId).catch(
-        (err) => console.warn(`[API/Compute] solveCount increment failed for ${metricDefinitionId}:`, err)
-      );
-    }
-    const { envelope } = outcome;
-    const { metrics } = envelope;
-    if (COMPUTE_DEBUG) {
-      console.info(
-        `[Compute/server] load=${defLoadMs.toFixed(0)}ms tree=${metrics.treeBuildMs.toFixed(0)}ms solve=${metrics.solveMs.toFixed(0)}ms serialize=${metrics.serializeMs.toFixed(0)}ms gzip=${metrics.gzipMs.toFixed(0)}ms total=${metrics.serverTotalMs.toFixed(0)}ms | result=${formatBytes(metrics.serializedBytes)}`
-      );
-      if (metrics.compressedBytes !== null) {
-        console.info(
-          `[Compute/server] gzip ${formatBytes(metrics.serializedBytes)} → ${formatBytes(metrics.compressedBytes)} (${(metrics.serializedBytes / metrics.compressedBytes).toFixed(1)}×)`
-        );
-      } else {
-        const acceptEncoding = request.headers.get("accept-encoding") ?? "";
-        console.info(
-          `[Compute/server] compression skipped — Accept-Encoding: "${acceptEncoding || "(absent)"}"`
-        );
-      }
-      console.info(
-        `[Compute/server] prep breakdown: ` + prepMarks.map(([label, ms]) => `${label}=${ms.toFixed(0)}ms`).join(" ")
-      );
-    }
-    return new Response(
-      typeof envelope.body === "string" ? envelope.body : new Uint8Array(envelope.body),
-      { headers: envelope.headers }
-    );
-  } catch (err) {
-    if (isHttpError(err)) throw err;
-    if (err instanceof ComputeServerUnconfiguredError) {
-      apiError(503, ApiErrorCode.COMPUTE_UNAVAILABLE, err.message);
-    }
-    const message = err instanceof Error ? err.message : "Unknown error";
-    console.error("[API/Compute] Error:", message);
-    if (err instanceof TypeError && message === "fetch failed") {
-      apiError(503, ApiErrorCode.COMPUTE_UNAVAILABLE, "Compute server is unreachable");
-    }
-    apiError(500, ApiErrorCode.INTERNAL, message);
-  }
-};
-
-export { POST };
-//# sourceMappingURL=_server.ts.js-D9qvgnX7.js.map