@tangle-network/agent-eval 0.126.7 → 0.127.0

package/dist/chunk-IG35YDN3.js

@@ -0,0 +1,614 @@
+// src/hosted/types.ts
+var HOSTED_WIRE_VERSION = "2026-07-24.v1";
+
+// src/hosted/schemas.ts
+import { z } from "zod";
+var finiteNumber = z.number().finite();
+var nonNegativeNumber = finiteNumber.nonnegative();
+var nonNegativeInteger = z.number().int().nonnegative();
+var nonEmptyString = z.string().min(1).refine((value) => value.trim().length > 0, "must not be blank");
+var attributeValue = z.union([z.string(), finiteNumber, z.boolean()]);
+var attributes = z.record(z.string(), attributeValue);
+var UINT64_MAX = 18446744073709551615n;
+var UnixNanoTimestampSchema = z.string().regex(/^(0|[1-9][0-9]*)$/, "expected an unsigned base-10 integer string").refine((value) => BigInt(value) <= UINT64_MAX, "must fit in an unsigned 64-bit integer");
+var GainDistributionBinSchema = z.object({
+  lo: finiteNumber,
+  hi: finiteNumber,
+  count: nonNegativeInteger
+}).strict();
+var ScalarDistributionSchema = z.object({
+  n: nonNegativeInteger,
+  mean: finiteNumber.nullable(),
+  p50: finiteNumber.nullable(),
+  p95: finiteNumber.nullable(),
+  stddev: nonNegativeNumber.nullable(),
+  min: finiteNumber.nullable(),
+  max: finiteNumber.nullable(),
+  histogram: z.array(GainDistributionBinSchema),
+  tailRuns: z.array(
+    z.object({
+      runId: nonEmptyString,
+      score: finiteNumber
+    }).strict()
+  ).optional()
+}).strict().superRefine((distribution, ctx) => {
+  const values = [
+    distribution.mean,
+    distribution.p50,
+    distribution.p95,
+    distribution.stddev,
+    distribution.min,
+    distribution.max
+  ];
+  if (distribution.n === 0 && values.some((value) => value !== null)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "distribution values must be null when n is 0"
+    });
+  }
+  if (distribution.n > 0 && values.some((value) => value === null)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "distribution values must be numbers when n is greater than 0"
+    });
+  }
+  if (distribution.min !== null && distribution.max !== null && distribution.min > distribution.max) {
+    ctx.addIssue({ code: "custom", path: ["min"], message: "min must not exceed max" });
+  }
+});
+var TokenUsageInsightSchema = z.object({
+  input: ScalarDistributionSchema,
+  output: ScalarDistributionSchema,
+  reasoning: ScalarDistributionSchema,
+  cached: ScalarDistributionSchema,
+  cacheWrite: ScalarDistributionSchema,
+  totals: z.object({
+    input: nonNegativeNumber,
+    output: nonNegativeNumber,
+    reasoning: nonNegativeNumber,
+    cached: nonNegativeNumber,
+    cacheWrite: nonNegativeNumber
+  }).strict()
+}).strict();
+var ExecutionErrorOutcomeCellSchema = z.object({
+  withErrors: nonNegativeInteger,
+  withoutErrors: nonNegativeInteger,
+  unreported: nonNegativeInteger
+}).strict();
+var ExecutionInsightSchema = z.object({
+  durationMs: ScalarDistributionSchema,
+  queueMs: ScalarDistributionSchema,
+  tokenUsage: TokenUsageInsightSchema,
+  aggregateUsage: z.object({
+    runs: nonNegativeInteger,
+    tokenUsage: TokenUsageInsightSchema,
+    costUsd: ScalarDistributionSchema,
+    totalCostUsd: nonNegativeNumber
+  }).strict(),
+  models: z.array(
+    z.object({
+      model: nonEmptyString,
+      runs: nonNegativeInteger
+    }).strict()
+  ),
+  modelCalls: z.object({
+    runs: nonNegativeInteger,
+    events: nonNegativeInteger,
+    reportingRuns: nonNegativeInteger
+  }).strict(),
+  executionErrors: z.object({
+    runs: nonNegativeInteger,
+    fraction: finiteNumber.min(0).max(1).nullable(),
+    events: nonNegativeInteger,
+    reportingRuns: nonNegativeInteger,
+    errorSpanEvents: nonNegativeInteger,
+    errorSpanReportingRuns: nonNegativeInteger,
+    byTerminalOutcome: z.object({
+      succeeded: ExecutionErrorOutcomeCellSchema,
+      failed: ExecutionErrorOutcomeCellSchema,
+      cancelled: ExecutionErrorOutcomeCellSchema,
+      incomplete: ExecutionErrorOutcomeCellSchema,
+      unknown: ExecutionErrorOutcomeCellSchema
+    }).strict()
+  }).strict(),
+  terminalOutcomes: z.object({
+    succeeded: nonNegativeInteger,
+    failed: nonNegativeInteger,
+    cancelled: nonNegativeInteger,
+    incomplete: nonNegativeInteger,
+    unknown: nonNegativeInteger
+  }).strict()
+}).strict();
+var CostProvenanceSummarySchema = z.object({
+  observed: z.object({
+    n: nonNegativeInteger,
+    totalUsd: nonNegativeNumber
+  }).strict(),
+  estimated: z.object({
+    n: nonNegativeInteger,
+    totalUsd: nonNegativeNumber
+  }).strict(),
+  uncaptured: z.object({ n: nonNegativeInteger }).strict(),
+  knownFraction: finiteNumber.min(0).max(1)
+}).strict();
+var ParetoFigureSpecSchema = z.object({
+  kind: z.literal("pareto-cost-quality"),
+  split: z.enum(["search", "holdout"]),
+  points: z.array(
+    z.object({
+      candidateId: nonEmptyString,
+      cost: nonNegativeNumber,
+      quality: finiteNumber,
+      n: nonNegativeInteger,
+      onFrontier: z.boolean(),
+      gate: z.enum(["promote", "reject"]).optional()
+    }).strict()
+  ),
+  axes: z.object({ x: z.literal("costUsd"), y: z.literal("score") }).strict()
+}).strict();
+var ContinuousAgreementSchema = z.object({
+  weightedKappa: finiteNumber,
+  icc: finiteNumber,
+  pearson: finiteNumber,
+  spearman: finiteNumber,
+  ci: z.object({
+    icc: z.tuple([finiteNumber, finiteNumber]),
+    weightedKappa: z.tuple([finiteNumber, finiteNumber])
+  }).strict(),
+  n: nonNegativeInteger,
+  raters: nonNegativeInteger
+}).strict();
+var JudgeInsightSchema = z.object({
+  n: nonNegativeInteger,
+  meanScore: finiteNumber,
+  calibration: ContinuousAgreementSchema.optional(),
+  positionalBias: finiteNumber.optional(),
+  selfPreference: finiteNumber.optional(),
+  verbosityBias: finiteNumber.optional()
+}).strict();
+var InterRaterInsightSchema = z.object({
+  raters: nonNegativeInteger,
+  jointlyRated: nonNegativeInteger,
+  kappa: finiteNumber,
+  icc: finiteNumber,
+  pearson: finiteNumber,
+  spearman: finiteNumber,
+  perPair: z.record(z.string(), finiteNumber),
+  disagreementCases: z.array(
+    z.object({
+      runId: nonEmptyString,
+      ratings: z.array(
+        z.object({
+          rater: nonEmptyString,
+          score: finiteNumber
+        }).strict()
+      ),
+      range: nonNegativeNumber
+    }).strict()
+  )
+}).strict();
+var LiftInsightSchema = z.object({
+  baselineMean: finiteNumber,
+  candidateMean: finiteNumber,
+  delta: finiteNumber,
+  ci95: z.tuple([finiteNumber, finiteNumber]),
+  pValue: finiteNumber.min(0).max(1),
+  n: nonNegativeInteger,
+  unpairedBaseline: nonNegativeInteger,
+  unpairedCandidate: nonNegativeInteger,
+  cohensD: finiteNumber.nullable(),
+  mde: nonNegativeNumber,
+  requiredN: nonNegativeInteger.nullable()
+}).strict();
+var FailureClusterInsightSchema = z.object({
+  clusters: z.array(
+    z.object({
+      id: nonEmptyString,
+      name: nonEmptyString,
+      share: finiteNumber.min(0).max(1),
+      exemplars: z.array(nonEmptyString).max(5),
+      suggestedFix: nonEmptyString.optional()
+    }).strict()
+  ),
+  totalFailures: nonNegativeInteger
+}).strict();
+var ContaminationInsightSchema = z.object({
+  leaks: nonNegativeInteger,
+  holdoutAuditPassed: z.boolean(),
+  details: z.array(
+    z.object({
+      runId: nonEmptyString,
+      canary: nonEmptyString,
+      matched: nonEmptyString
+    }).strict()
+  ).optional()
+}).strict();
+var OutcomeCorrelationInsightSchema = z.object({
+  metric: nonEmptyString,
+  n: nonNegativeInteger,
+  pearson: finiteNumber,
+  spearman: finiteNumber,
+  rewardModel: z.object({
+    intercept: finiteNumber,
+    slope: finiteNumber,
+    r2: finiteNumber
+  }).strict().optional()
+}).strict();
+var ReleaseSummarySchema = z.object({
+  status: z.enum(["pass", "warn", "fail"]),
+  axes: z.array(
+    z.object({
+      name: z.enum(["quality-lift", "contamination", "composite-distribution"]),
+      status: z.enum(["pass", "warn", "fail", "not_evaluated"]),
+      detail: nonEmptyString
+    }).strict()
+  ),
+  issues: z.array(z.string())
+}).strict();
+var MetricDeltaSchema = z.object({
+  current: finiteNumber,
+  baseline: finiteNumber,
+  delta: finiteNumber,
+  ci95: z.tuple([finiteNumber, finiteNumber]),
+  pValue: finiteNumber.min(0).max(1),
+  cohensD: finiteNumber,
+  baselineN: nonNegativeInteger,
+  currentN: nonNegativeInteger,
+  significant: z.boolean()
+}).strict();
+var PriorPeriodComparisonSchema = z.object({
+  baselineN: nonNegativeInteger,
+  currentN: nonNegativeInteger,
+  windowLabel: nonEmptyString.optional(),
+  metrics: z.record(z.string(), MetricDeltaSchema),
+  regressedMetrics: z.array(nonEmptyString),
+  improvedMetrics: z.array(nonEmptyString)
+}).strict();
+var RecommendationSchema = z.object({
+  priority: z.enum(["critical", "high", "medium", "low"]),
+  kind: z.enum(["ship", "hold", "investigate", "fix", "recalibrate", "expand-corpus"]),
+  title: nonEmptyString,
+  detail: nonEmptyString,
+  evidencePath: nonEmptyString.optional()
+}).strict();
+var InsightReportSchema = z.object({
+  n: nonNegativeInteger,
+  execution: ExecutionInsightSchema,
+  composite: ScalarDistributionSchema,
+  perDimension: z.record(z.string(), ScalarDistributionSchema),
+  costQuality: z.object({
+    cost: ScalarDistributionSchema,
+    pareto: ParetoFigureSpecSchema,
+    provenance: CostProvenanceSummarySchema.optional(),
+    degraded: z.object({
+      cost: nonEmptyString.optional(),
+      pareto: nonEmptyString.optional()
+    }).strict().optional()
+  }).strict(),
+  judges: z.record(z.string(), JudgeInsightSchema),
+  interRater: InterRaterInsightSchema.optional(),
+  lift: LiftInsightSchema.optional(),
+  failureClusters: FailureClusterInsightSchema.optional(),
+  contamination: ContaminationInsightSchema.optional(),
+  outcomeCorrelation: OutcomeCorrelationInsightSchema.optional(),
+  release: ReleaseSummarySchema,
+  priorPeriodComparison: PriorPeriodComparisonSchema.optional(),
+  failureModes: z.array(
+    z.object({
+      mode: nonEmptyString,
+      count: nonNegativeInteger,
+      share: finiteNumber.min(0).max(1)
+    }).strict()
+  ).optional(),
+  recommendations: z.array(RecommendationSchema)
+}).strict();
+var sha256Digest = z.custom(
+  (value) => typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value),
+  "expected sha256:<64 lowercase hex characters>"
+);
+var MutableSurfaceSchema = z.union([
+  z.string(),
+  z.object({
+    kind: z.literal("components"),
+    components: z.record(z.string(), z.string())
+  }).strict(),
+  z.object({
+    kind: z.literal("code"),
+    worktreeRef: nonEmptyString,
+    baseRef: nonEmptyString,
+    baseCommit: nonEmptyString,
+    baseTree: nonEmptyString,
+    candidateCommit: nonEmptyString,
+    candidateTree: nonEmptyString,
+    patch: z.object({
+      format: z.literal("git-diff-binary"),
+      sha256: sha256Digest,
+      byteLength: nonNegativeInteger
+    }).strict(),
+    summary: z.string().optional()
+  }).strict()
+]);
+var RunTerminalOutcomeSchema = z.enum([
+  "succeeded",
+  "failed",
+  "cancelled",
+  "incomplete",
+  "unknown"
+]);
+var EvalRunCellScoreSchema = z.object({
+  scenarioId: nonEmptyString,
+  rep: nonNegativeInteger,
+  compositeMean: finiteNumber.nullable(),
+  dimensions: z.record(z.string(), z.record(z.string(), finiteNumber)),
+  terminalOutcome: RunTerminalOutcomeSchema,
+  executionErrorCount: nonNegativeInteger.nullable(),
+  errorMessage: z.string().optional()
+}).strict();
+var EvalRunGenerationSnapshotSchema = z.object({
+  index: nonNegativeInteger,
+  surfaceHash: nonEmptyString,
+  surface: MutableSurfaceSchema.optional(),
+  cells: z.array(EvalRunCellScoreSchema),
+  compositeMean: finiteNumber.nullable(),
+  costUsd: nonNegativeNumber,
+  durationMs: nonNegativeNumber
+}).strict();
+var EvalRunStatusSchema = z.enum([
+  "started",
+  "baseline-complete",
+  "generation-complete",
+  "gate-decided",
+  "finished",
+  "errored"
+]);
+var GateDecisionSchema = z.enum([
+  "ship",
+  "hold",
+  "need_more_work",
+  "model_ceiling",
+  "arch_ceiling"
+]);
+var EvalRunEventSchema = z.object({
+  runId: nonEmptyString,
+  runDir: nonEmptyString,
+  timestamp: z.string().datetime({ offset: true }),
+  status: EvalRunStatusSchema,
+  labels: z.record(z.string(), z.string()),
+  baseline: EvalRunGenerationSnapshotSchema.optional(),
+  generations: z.array(EvalRunGenerationSnapshotSchema),
+  gateDecision: GateDecisionSchema.optional(),
+  holdoutLift: finiteNumber.optional(),
+  totalCostUsd: nonNegativeNumber,
+  totalDurationMs: nonNegativeNumber,
+  errorMessage: z.string().optional(),
+  insightReport: InsightReportSchema.optional()
+}).strict().superRefine((event, ctx) => {
+  if (event.baseline && event.baseline.index !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["baseline", "index"],
+      message: "baseline index must be 0"
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < event.generations.length; i++) {
+    const index = event.generations[i].index;
+    if (seen.has(index)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["generations", i, "index"],
+        message: `duplicate generation index ${index}`
+      });
+    }
+    seen.add(index);
+  }
+  if (event.status === "errored" && !event.errorMessage?.trim()) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["errorMessage"],
+      message: "errorMessage is required when status is errored"
+    });
+  }
+});
+var TraceSpanEventEntrySchema = z.object({
+  timeUnixNano: UnixNanoTimestampSchema,
+  name: nonEmptyString,
+  attributes: attributes.optional()
+}).strict();
+var TraceSpanEventSchema = z.object({
+  traceId: nonEmptyString,
+  spanId: nonEmptyString,
+  parentSpanId: nonEmptyString.optional(),
+  name: nonEmptyString,
+  startTimeUnixNano: UnixNanoTimestampSchema,
+  endTimeUnixNano: UnixNanoTimestampSchema,
+  attributes,
+  events: z.array(TraceSpanEventEntrySchema).optional(),
+  status: z.object({
+    code: z.enum(["OK", "ERROR", "UNSET"]),
+    message: z.string().optional()
+  }).strict().optional(),
+  "tangle.runId": nonEmptyString.optional(),
+  "tangle.generation": nonNegativeInteger.optional(),
+  "tangle.cellId": nonEmptyString.optional(),
+  "tangle.scenarioId": nonEmptyString.optional()
+}).strict().refine((span) => BigInt(span.endTimeUnixNano) >= BigInt(span.startTimeUnixNano), {
+  path: ["endTimeUnixNano"],
+  message: "endTimeUnixNano must be greater than or equal to startTimeUnixNano"
+});
+var IngestEvalRunsEnvelopeSchema = z.object({
+  wireVersion: z.literal(HOSTED_WIRE_VERSION),
+  events: z.array(z.unknown())
+}).strict();
+var IngestTracesEnvelopeSchema = z.object({
+  wireVersion: z.literal(HOSTED_WIRE_VERSION),
+  spans: z.array(z.unknown())
+}).strict();
+var IngestEvalRunsRequestSchema = z.object({
+  wireVersion: z.literal(HOSTED_WIRE_VERSION),
+  events: z.array(EvalRunEventSchema)
+}).strict();
+var IngestTracesRequestSchema = z.object({
+  wireVersion: z.literal(HOSTED_WIRE_VERSION),
+  spans: z.array(TraceSpanEventSchema)
+}).strict();
+var IngestResponseSchema = z.object({
+  accepted: nonNegativeInteger,
+  rejected: z.array(
+    z.object({
+      index: nonNegativeInteger,
+      reason: nonEmptyString
+    }).strict()
+  )
+}).strict();
+
+// src/hosted/client.ts
+var MAX_IDEMPOTENCY_KEY_LENGTH = 256;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeHostedBase(endpoint) {
+  return endpoint.trim().replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+function resolveIdempotencyKey(key) {
+  const resolved = key ?? globalThis.crypto.randomUUID();
+  if (resolved.trim().length === 0) throw new Error("idempotency key must not be blank");
+  if (resolved.length > MAX_IDEMPOTENCY_KEY_LENGTH) {
+    throw new Error(`idempotency key must be at most ${MAX_IDEMPOTENCY_KEY_LENGTH} characters`);
+  }
+  return resolved;
+}
+function responseValidationReason(error) {
+  return error.issues.map(
+    (issue) => `${issue.path.length > 0 ? issue.path.map(String).join(".") : "value"}: ${issue.message}`
+  ).join("; ");
+}
+async function post(tenant, path, body, opts = {}) {
+  const timeoutMs = tenant.timeoutMs ?? 3e4;
+  const maxRetries = tenant.retries ?? 2;
+  const f = tenant.fetchImpl ?? ((...args) => fetch(...args));
+  const base = normalizeHostedBase(tenant.endpoint);
+  const url = `${base}${path}`;
+  const idempotencyKey = resolveIdempotencyKey(opts.idempotencyKey);
+  const headers = {
+    "content-type": "application/json",
+    authorization: `Bearer ${tenant.apiKey}`,
+    "x-tangle-tenant-id": tenant.tenantId,
+    "x-tangle-wire-version": HOSTED_WIRE_VERSION,
+    "idempotency-key": idempotencyKey
+  };
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const ourTimeout = AbortSignal.timeout(timeoutMs);
+    const combinedSignal = opts.signal ? AbortSignal.any([opts.signal, ourTimeout]) : ourTimeout;
+    let res;
+    try {
+      res = await f(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: combinedSignal
+      });
+    } catch (err) {
+      if (opts.signal?.aborted) throw err;
+      lastError = err;
+      if (attempt === maxRetries) throw err;
+      await sleep(2 ** attempt * 200 + Math.random() * 200);
+      continue;
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      const error = new Error(`hosted ingest ${url} failed (${res.status}): ${text.slice(0, 500)}`);
+      const retryable = res.status >= 500 || res.status === 408 || res.status === 429;
+      if (!retryable || attempt === maxRetries) throw error;
+      lastError = error;
+      await sleep(2 ** attempt * 200 + Math.random() * 200);
+      continue;
+    }
+    let rawResponse;
+    try {
+      rawResponse = await res.json();
+    } catch (error) {
+      throw new Error(`hosted ingest ${url} returned invalid JSON`, { cause: error });
+    }
+    const parsed = IngestResponseSchema.safeParse(rawResponse);
+    if (!parsed.success) {
+      throw new Error(
+        `hosted ingest ${url} returned an invalid response: ${responseValidationReason(parsed.error)}`
+      );
+    }
+    return parsed.data;
+  }
+  throw lastError ?? new Error("hosted ingest exhausted retries");
+}
+function createHostedClient(tenant) {
+  if (normalizeHostedBase(tenant.endpoint).length === 0) throw new Error("endpoint is required");
+  if (tenant.apiKey.trim().length === 0) throw new Error("apiKey is required");
+  if (tenant.tenantId.trim().length === 0) throw new Error("tenantId is required");
+  if (tenant.timeoutMs !== void 0 && (!Number.isFinite(tenant.timeoutMs) || tenant.timeoutMs <= 0)) {
+    throw new Error("timeoutMs must be greater than 0");
+  }
+  if (tenant.retries !== void 0 && (!Number.isInteger(tenant.retries) || tenant.retries < 0)) {
+    throw new Error("retries must be a non-negative integer");
+  }
+  return {
+    tenant,
+    wireVersion: HOSTED_WIRE_VERSION,
+    async ingestEvalRun(event, idempotencyKey) {
+      return this.ingestEvalRuns([event], idempotencyKey);
+    },
+    async ingestEvalRuns(events, idempotencyKey) {
+      const body = IngestEvalRunsRequestSchema.parse({
+        wireVersion: HOSTED_WIRE_VERSION,
+        events
+      });
+      return post(tenant, "/v1/ingest/eval-runs", body, {
+        idempotencyKey
+      });
+    },
+    async ingestTraces(spans, idempotencyKey) {
+      const body = IngestTracesRequestSchema.parse({
+        wireVersion: HOSTED_WIRE_VERSION,
+        spans
+      });
+      return post(tenant, "/v1/ingest/traces", body, {
+        idempotencyKey
+      });
+    }
+  };
+}
+function hostedTenantFromEnv(overrides = {}) {
+  const env = overrides.env ?? process.env;
+  const endpoint = (overrides.endpoint ?? env.TANGLE_INGEST_URL ?? env.TANGLE_ORCHESTRATOR_URL)?.trim();
+  const apiKey = (overrides.apiKey ?? env.TANGLE_INGEST_API_KEY ?? env.TANGLE_API_KEY)?.trim();
+  const tenantId = (overrides.tenantId ?? env.TANGLE_TENANT_ID)?.trim();
+  if (!endpoint || !apiKey || !tenantId) return void 0;
+  const tenant = { endpoint: endpoint.replace(/\/+$/, ""), apiKey, tenantId };
+  if (overrides.fetchImpl) tenant.fetchImpl = overrides.fetchImpl;
+  if (overrides.timeoutMs !== void 0) tenant.timeoutMs = overrides.timeoutMs;
+  if (overrides.retries !== void 0) tenant.retries = overrides.retries;
+  return tenant;
+}
+function hostedClientFromEnv(overrides = {}) {
+  const tenant = hostedTenantFromEnv(overrides);
+  return tenant ? createHostedClient(tenant) : void 0;
+}
+
+export {
+  HOSTED_WIRE_VERSION,
+  UnixNanoTimestampSchema,
+  InsightReportSchema,
+  MutableSurfaceSchema,
+  RunTerminalOutcomeSchema,
+  EvalRunCellScoreSchema,
+  EvalRunGenerationSnapshotSchema,
+  EvalRunEventSchema,
+  TraceSpanEventSchema,
+  IngestEvalRunsRequestSchema,
+  IngestTracesRequestSchema,
+  IngestResponseSchema,
+  createHostedClient,
+  hostedTenantFromEnv,
+  hostedClientFromEnv
+};
+//# sourceMappingURL=chunk-IG35YDN3.js.map