@selvajs/selva 4.6.21-beta.1 → 4.7.0-beta.3

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

@@ -1,612 +0,0 @@
-import { a as apiError, A as ApiErrorCode, r as resolveServerForOrg, f as fetchSchemaFromCompute, C as ComputeServerUnconfiguredError } from '../../../../chunks/api-errors.js-CwTBBHWD.js';
-import { isHttpError } from '@sveltejs/kit';
-import { g as getClient, C as COMPUTE_DEBUG } from '../../../../chunks/clientCache.server.js-CDbNbNdZ.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-DmiFfoef.js';
-import { TreeBuilder, processInput } from '@selvajs/compute';
-import { gzipSync } from 'node:zlib';
-import { f as requireMaxBodySize, h as createComputeRateLimiter } from '../../../../chunks/admin-auth.server.js-BAXmH56n.js';
-import { t as getStorageProvider, x as getSolveMetricSink, p as providers } from '../../../../chunks/providers.server.js-BKhwGvoh.js';
-import { i as requireCanEditDefinition, j as requireCanSolve } from '../../../../chunks/access.server.js-DmuVt13u.js';
-import { t as tryResolveShareToken } from '../../../../chunks/resolve.server.js-BQY6Vw9q.js';
-import '../../../../chunks/context.js-D8E0GFTw.js';
-import '@selvajs/compute/core';
-import '../../../../chunks/schema.js-j3D3emog.js';
-import '../../../../chunks/utils4.js-C-poIiFQ.js';
-import '../../../../chunks/shared-server.js-DaWdgxVh.js';
-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-Cjb4XaWC.js';
-import '../../../../chunks/token-codec.js-1RPNe2RW.js';
-
-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;
-}
-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 (processed.default == null && effective != null) {
-    if (Array.isArray(effective)) {
-      processed.default = effective;
-    } else if (processed.paramType === "ValueList" && typeof effective !== "object") {
-      processed.default = effective;
-    }
-  }
-  return processed;
-}
-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 cache = /* @__PURE__ */ new Map();
-  return {
-    async load(url) {
-      await assertSafeRemoteDefinitionUrl(url);
-      const now = config.now();
-      const cached = cache.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);
-      }
-      cache.set(url, { data, fetchedAt: now });
-      if (cache.size > CACHE_MAX_ENTRIES) {
-        const entries = Array.from(cache.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]);
-        }
-      }
-      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;
-  const settleSeqBefore = client.solveMeta.seq;
-  const rhinoSeqBefore = client.rhinoTiming.seq;
-  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 settle = client.solveMeta.seq === settleSeqBefore + 1 ? client.solveMeta.last : null;
-  const rhino = settle && !settle.fromCache && client.rhinoTiming.seq === rhinoSeqBefore + 1 ? client.rhinoTiming.last : null;
-  const serverTiming = buildServerTiming({
-    defLoadMs: args.defLoadMs,
-    treeBuildMs,
-    solveMs,
-    serializeMs,
-    gzipMs,
-    serverTotalMs,
-    rhino,
-    settle,
-    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,
-  cacheTtlMs: DEFINITION_CACHE_TTL_MS,
-  now: () => Date.now()
-});
-function loadRemoteDefinition(url) {
-  return fetcher.load(url);
-}
-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 localVersionForBackfill = null;
-    let solveOrgId = null;
-    let definitionPin = null;
-    let metricDefinitionId = null;
-    let metricVersionId = null;
-    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;
-      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");
-      try {
-        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`);
-      }
-      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) {
-      const versionId = localVersionForBackfill.id;
-      try {
-        const schema = await fetchSchemaFromCompute(definitionSource, 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 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
-    });
-    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 === "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-D4bNHN4G.js.map