@selvajs/selva 4.6.20 → 4.6.21-beta.1

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

@@ -0,0 +1,612 @@
+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